11th March, 2026

Now, Self-hosted LiveSync has finally begun to be split into the Self-hosted LiveSync plugin for Obsidian, and a properly abstracted version of it.
This may not offer much benefit to Obsidian plugin users, or might even cause a slight inconvenience, but I believe it will certainly help improve testability and make the ecosystem better.
However, I do not see the point in putting something with little benefit into beta, so I am handling this on the alpha branch. I would actually preferred to create an R&D branch, but I was not keen on the ampersand, and I feel it will eventually become a proper beta anyway.

### Refactored

- Separated `ObsidianLiveSyncPlugin` into `ObsidianLiveSyncPlugin` and `LiveSyncBaseCore`.
- Now `LiveSyncCore` indicates the type specified version of `LiveSyncBaseCore`.
- Referencing `plugin.xxx` has been rewritten to referencing the corresponding service or `core.xxx`.

### Internal API changes

- Storage Access APIs are now yielding Promises. This is to allow more limited storage platforms to be supported.

### R&D

- Browser-version of Self-hosted LiveSync is now in development. This is not intended for public use now, but I will eventually make it available for testing.
- We can see the code in `src/apps/webapp` for the browser version.

src/common/PeriodicProcessor.ts

@@ -0,0 +1,45 @@
+import { Logger } from "octagonal-wheels/common/logger";
+import { fireAndForget } from "octagonal-wheels/promises";
+import { eventHub, EVENT_PLUGIN_UNLOADED } from "./events";
+import type { NecessaryServices } from "@lib/interfaces/ServiceModule";
+type PeriodicProcessorHost = NecessaryServices<"API" | "control", never>;
+export class PeriodicProcessor {
+    _process: () => Promise<any>;
+    _timer?: number = undefined;
+    _core: PeriodicProcessorHost;
+    constructor(core: PeriodicProcessorHost, process: () => Promise<any>) {
+        // this._plugin = plugin;
+        this._core = core;
+        this._process = process;
+        eventHub.onceEvent(EVENT_PLUGIN_UNLOADED, () => {
+            this.disable();
+        });
+    }
+    async process() {
+        try {
+            await this._process();
+        } catch (ex) {
+            Logger(ex);
+        }
+    }
+    enable(interval: number) {
+        this.disable();
+        if (interval == 0) return;
+        this._timer = this._core.services.API.setInterval(
+            () =>
+                fireAndForget(async () => {
+                    await this.process();
+                    if (this._core.services?.control?.hasUnloaded()) {
+                        this.disable();
+                    }
+                }),
+            interval
+        );
+    }
+    disable() {
+        if (this._timer !== undefined) {
+            this._core.services.API.clearInterval(this._timer);
+            this._timer = undefined;
+        }
+    }
+}