chore: merge upstream main into history revision branch

src/modules/AbstractModule.ts

@@ -1,9 +1,9 @@
 import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
-import type { AnyEntry, FilePathWithPrefix } from "@lib/common/types";
+import type { AnyEntry, FilePathWithPrefix } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import type { IMinimumLiveSyncCommands, LiveSyncBaseCore } from "@/LiveSyncBaseCore";
-import { stripAllPrefixes } from "@lib/string_and_binary/path";
-import { createInstanceLogFunction } from "@lib/services/lib/logUtils";
-import type { ServiceContext } from "@lib/services/base/ServiceBase";
+import { stripAllPrefixes } from "@vrtmrz/livesync-commonlib/compat/string_and_binary/path";
+import { createInstanceLogFunction } from "@vrtmrz/livesync-commonlib/compat/services/lib/logUtils";
+import type { ServiceContext } from "@vrtmrz/livesync-commonlib/context";
 
 export abstract class AbstractModule<
     T extends LiveSyncBaseCore<ServiceContext, IMinimumLiveSyncCommands> = LiveSyncBaseCore<
@@ -48,7 +48,9 @@ export abstract class AbstractModule<
     constructor(public core: T) {
         Logger(`[${this.constructor.name}] Loaded`, LOG_LEVEL_VERBOSE);
     }
-    saveSettings = this.core.services.setting.saveSettingData.bind(this.core.services.setting);
+    saveSettings(): Promise<void> {
+        return this.core.services.setting.saveSettingData();
+    }
 
     addTestResult(key: string, value: boolean, summary?: string, message?: string) {
         this.services.test.addTestResult(`${this.constructor.name}`, key, value, summary, message);

src/modules/core/ModuleReplicator.ts

@@ -3,21 +3,25 @@ import { fireAndForget } from "octagonal-wheels/promises";
 import { AbstractModule } from "@/modules/AbstractModule";
 import { Logger, LOG_LEVEL_NOTICE, LOG_LEVEL_INFO } from "octagonal-wheels/common/logger";
 import { skipIfDuplicated } from "octagonal-wheels/concurrency/lock";
-import { balanceChunkPurgedDBs } from "@lib/pouchdb/chunks";
-import { purgeUnreferencedChunks } from "@lib/pouchdb/chunks";
-import { LiveSyncCouchDBReplicator } from "@lib/replication/couchdb/LiveSyncReplicator";
-import { type EntryDoc, type RemoteType } from "@lib/common/types";
+import { balanceChunkPurgedDBs } from "@vrtmrz/livesync-commonlib/compat/pouchdb/chunks";
+import { purgeUnreferencedChunks } from "@vrtmrz/livesync-commonlib/compat/pouchdb/chunks";
+import { LiveSyncCouchDBReplicator } from "@vrtmrz/livesync-commonlib/compat/replication/couchdb/LiveSyncReplicator";
+import {
+    type EntryDoc,
+    type ObsidianLiveSyncSettings,
+    type RemoteType,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
 
 import { scheduleTask } from "octagonal-wheels/concurrency/task";
 import { EVENT_FILE_SAVED, EVENT_SETTING_SAVED, eventHub } from "@/common/events";
 
-import { $msg } from "@lib/common/i18n";
+import { $msg } from "@/common/translation";
 import type { LiveSyncCore } from "@/main";
 import { ReplicateResultProcessor } from "./ReplicateResultProcessor";
-import { UnresolvedErrorManager } from "@lib/services/base/UnresolvedErrorManager";
-import { clearHandlers } from "@lib/replication/SyncParamsHandler";
-import type { NecessaryServices } from "@lib/interfaces/ServiceModule";
-import { MARK_LOG_NETWORK_ERROR } from "@lib/services/lib/logUtils";
+import { UnresolvedErrorManager } from "@vrtmrz/livesync-commonlib/compat/services/base/UnresolvedErrorManager";
+import { clearHandlers } from "@vrtmrz/livesync-commonlib/compat/replication/SyncParamsHandler";
+import type { NecessaryServices } from "@vrtmrz/livesync-commonlib/compat/interfaces/ServiceModule";
+import { MARK_LOG_NETWORK_ERROR } from "@vrtmrz/livesync-commonlib/compat/services/lib/logUtils";
 
 function isOnlineAndCanReplicate(
     errorManager: UnresolvedErrorManager,
@@ -49,7 +53,8 @@ async function canReplicateWithPBKDF2(
     // Showing message is false: that because be shown here. (And it is a fatal error, no way to hide it).
     // tagged as network error at beginning for error filtering with NetworkWarningStyles
     const ensureMessage = `${MARK_LOG_NETWORK_ERROR}Failed to initialise the encryption key, preventing replication.`;
-    const ensureResult = await replicator.ensurePBKDF2Salt(currentSettings, showMessage, true);
+    // A remote database rebuild replaces the Security Seed while this process may still hold the previous one.
+    const ensureResult = await replicator.ensurePBKDF2Salt(currentSettings, showMessage, false);
     if (!ensureResult) {
         errorManager.showError(ensureMessage, showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO);
         return false;
@@ -63,25 +68,60 @@ export class ModuleReplicator extends AbstractModule {
 
     processor: ReplicateResultProcessor = new ReplicateResultProcessor(this);
     private _unresolvedErrorManager: UnresolvedErrorManager = new UnresolvedErrorManager(
-        this.core.services.appLifecycle
+        this.core.services.appLifecycle,
+        this.core.services.context.events
     );
 
     clearErrors() {
         this._unresolvedErrorManager.clearErrors();
     }
 
+    private _normalFileReflectionFilterSignature: string | undefined;
+
+    private getNormalFileReflectionFilterSignature(
+        settings: Pick<
+            ObsidianLiveSyncSettings,
+            | "handleFilenameCaseSensitive"
+            | "ignoreFiles"
+            | "maxMTimeForReflectEvents"
+            | "syncIgnoreRegEx"
+            | "syncInternalFiles"
+            | "syncMaxSizeInMB"
+            | "syncOnlyRegEx"
+            | "useIgnoreFiles"
+        >
+    ): string {
+        return JSON.stringify({
+            handleFilenameCaseSensitive: settings.handleFilenameCaseSensitive ?? false,
+            ignoreFiles: settings.ignoreFiles ?? "",
+            maxMTimeForReflectEvents: settings.maxMTimeForReflectEvents ?? 0,
+            syncIgnoreRegEx: settings.syncIgnoreRegEx ?? "",
+            syncInternalFiles: settings.syncInternalFiles ?? false,
+            syncMaxSizeInMB: settings.syncMaxSizeInMB ?? 0,
+            syncOnlyRegEx: settings.syncOnlyRegEx ?? "",
+            useIgnoreFiles: settings.useIgnoreFiles ?? false,
+        });
+    }
+
     private _everyOnloadAfterLoadSettings(): Promise<boolean> {
+        this._normalFileReflectionFilterSignature = this.getNormalFileReflectionFilterSignature(this.settings);
         eventHub.onEvent(EVENT_FILE_SAVED, () => {
             if (this.settings.syncOnSave && !this.core.services.appLifecycle.isSuspended()) {
                 scheduleTask("perform-replicate-after-save", 250, () => this.services.replication.replicateByEvent());
             }
         });
         eventHub.onEvent(EVENT_SETTING_SAVED, (setting) => {
+            const previousReflectionFilter = this._normalFileReflectionFilterSignature;
+            const nextReflectionFilter = this.getNormalFileReflectionFilterSignature(setting);
+            this._normalFileReflectionFilterSignature = nextReflectionFilter;
             if (this.core.settings.suspendParseReplicationResult) {
                 this.processor.suspend();
             } else {
                 this.processor.resume();
             }
+            if (previousReflectionFilter !== undefined && previousReflectionFilter !== nextReflectionFilter) {
+                fireAndForget(() => this.processor.reprocessStoredDocuments());
+            }
         });
 
         return Promise.resolve(true);
@@ -105,7 +145,8 @@ export class ModuleReplicator extends AbstractModule {
     }
 
     /**
-     * obsolete method. No longer maintained and will be removed in the future.
+     * Reconciles local chunks when an older IndexedDB client reports that the remote database was cleaned.
+     * This compatibility path remains reachable while those clients can still set `remoteCleaned`.
      * @deprecated v0.24.17
      * @param showMessage If true, show message to the user.
      */
@@ -132,33 +173,45 @@ Even if you choose to clean up, you will see this option again if you exit Obsid
                 await this.core.rebuilder.$performRebuildDB("localOnly");
             }
             if (ret == CHOICE_CLEAN) {
-                const replicator = this.services.replicator.getActiveReplicator();
-                if (!(replicator instanceof LiveSyncCouchDBReplicator)) return;
-                const remoteDB = await replicator.connectRemoteCouchDBWithSetting(
-                    this.settings,
-                    this.services.API.isMobile(),
-                    true
-                );
-                if (typeof remoteDB == "string") {
-                    Logger(remoteDB, LOG_LEVEL_NOTICE);
-                    return false;
-                }
+                await this.services.replicator.runBoundedRemoteActivity(
+                    async () => {
+                        const replicator = this.services.replicator.getActiveReplicator();
+                        if (!(replicator instanceof LiveSyncCouchDBReplicator)) return;
+                        const remoteDB = await replicator.connectRemoteCouchDBWithSetting(
+                            this.settings,
+                            this.services.API.isMobile(),
+                            true
+                        );
+                        if (typeof remoteDB == "string") {
+                            Logger(remoteDB, LOG_LEVEL_NOTICE);
+                            return false;
+                        }
 
-                await purgeUnreferencedChunks(this.localDatabase.localDatabase, false);
-                this.localDatabase.clearCaches();
-                // Perform the synchronisation once.
-                if (await this.core.replicator.openReplication(this.settings, false, showMessage, true)) {
-                    await balanceChunkPurgedDBs(this.localDatabase.localDatabase, remoteDB.db);
-                    await purgeUnreferencedChunks(this.localDatabase.localDatabase, false);
-                    this.localDatabase.clearCaches();
-                    await this.services.replicator.getActiveReplicator()?.markRemoteResolved(this.settings);
-                    Logger("The local database has been cleaned up.", showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO);
-                } else {
-                    Logger(
-                        "Replication has been cancelled. Please try it again.",
-                        showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
-                    );
-                }
+                        await purgeUnreferencedChunks(this.localDatabase.localDatabase, false);
+                        this.localDatabase.clearCaches();
+                        // Perform the synchronisation once.
+                        const replicated = await this.services.replicator.runFiniteReplicationActivity(
+                            () => this.core.replicator.openReplication(this.settings, false, showMessage, true),
+                            { label: "replication" }
+                        );
+                        if (replicated) {
+                            await balanceChunkPurgedDBs(this.localDatabase.localDatabase, remoteDB.db);
+                            await purgeUnreferencedChunks(this.localDatabase.localDatabase, false);
+                            this.localDatabase.clearCaches();
+                            await this.services.replicator.getActiveReplicator()?.markRemoteResolved(this.settings);
+                            Logger(
+                                "The local database has been cleaned up.",
+                                showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+                            );
+                        } else {
+                            Logger(
+                                "Replication has been cancelled. Please try it again.",
+                                showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+                            );
+                        }
+                    },
+                    { label: "database-cleanup" }
+                );
             }
         });
     }
@@ -271,12 +324,14 @@ Even if you choose to clean up, you will see this option again if you exit Obsid
         // --> These handlers can be separated.
         const isOnlineAndCanReplicateWithHost = isOnlineAndCanReplicate.bind(null, this._unresolvedErrorManager, {
             services: {
+                context: services.context,
                 API: services.API,
             },
             serviceModules: {},
         });
         const canReplicateWithPBKDF2WithHost = canReplicateWithPBKDF2.bind(null, this._unresolvedErrorManager, {
             services: {
+                context: services.context,
                 replicator: services.replicator,
                 setting: services.setting,
             },

src/modules/core/ModuleReplicator.unit.spec.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it, vi } from "vitest";
+import { createServiceContext } from "@vrtmrz/livesync-commonlib/context";
+import { EVENT_SETTING_SAVED, eventHub } from "@/common/events";
+import type { ObsidianLiveSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
+
+const chunkMocks = vi.hoisted(() => ({
+    purgeUnreferencedChunks: vi.fn(async (_db: unknown, countOnly: boolean) => (countOnly ? 2 : 0)),
+    balanceChunkPurgedDBs: vi.fn(async () => undefined),
+}));
+
+vi.mock("@vrtmrz/livesync-commonlib/compat/pouchdb/chunks", () => chunkMocks);
+vi.mock("@vrtmrz/livesync-commonlib/compat/replication/couchdb/LiveSyncReplicator", () => ({
+    LiveSyncCouchDBReplicator: class {},
+}));
+
+import { LiveSyncCouchDBReplicator } from "@vrtmrz/livesync-commonlib/compat/replication/couchdb/LiveSyncReplicator";
+import { ModuleReplicator } from "./ModuleReplicator";
+
+describe("ModuleReplicator", () => {
+    it("refreshes the remote Security Seed before replication", async () => {
+        const ensurePBKDF2Salt = vi.fn(async () => true);
+        let beforeReplicate: ((showMessage: boolean) => Promise<boolean>) | undefined;
+        const addHandler = vi.fn((handler: (showMessage: boolean) => Promise<boolean>, priority?: number) => {
+            if (priority === 20) {
+                beforeReplicate = handler;
+            }
+        });
+        const services = {
+            API: { isOnline: true },
+            replicator: {
+                onReplicatorInitialised: { addHandler: vi.fn() },
+                getActiveReplicator: () => ({ ensurePBKDF2Salt }),
+            },
+            setting: { currentSettings: () => ({}) },
+            databaseEvents: { onDatabaseInitialised: { addHandler: vi.fn() } },
+            appLifecycle: { onSettingLoaded: { addHandler: vi.fn() } },
+            replication: {
+                parseSynchroniseResult: { addHandler: vi.fn() },
+                onBeforeReplicate: { addHandler },
+                onReplicationFailed: { addHandler: vi.fn() },
+            },
+        };
+        const module = {
+            _unresolvedErrorManager: {
+                showError: vi.fn(),
+                clearError: vi.fn(),
+            },
+            _onReplicatorInitialised: vi.fn(),
+            _everyOnDatabaseInitialized: vi.fn(),
+            _everyOnloadAfterLoadSettings: vi.fn(),
+            _parseReplicationResult: vi.fn(),
+            _everyBeforeReplicate: vi.fn(),
+            onReplicationFailed: vi.fn(),
+        };
+
+        ModuleReplicator.prototype.onBindFunction.call(module, {} as never, services as never);
+        expect(beforeReplicate).toBeDefined();
+
+        await beforeReplicate!(false);
+
+        expect(ensurePBKDF2Salt).toHaveBeenCalledWith({}, false, false);
+    });
+
+    it("reprocesses stored documents when the normal-file target filters change", async () => {
+        eventHub.offAll();
+        const settings = {
+            handleFilenameCaseSensitive: false,
+            ignoreFiles: ".gitignore",
+            maxMTimeForReflectEvents: 0,
+            syncOnlyRegEx: "^E2E/allowed/.*",
+            syncIgnoreRegEx: "",
+            syncInternalFiles: false,
+            syncMaxSizeInMB: 0,
+            suspendParseReplicationResult: false,
+            useIgnoreFiles: false,
+        } as ObsidianLiveSyncSettings;
+        const services = {
+            context: createServiceContext(),
+            API: {
+                addLog: vi.fn(),
+                addCommand: vi.fn(),
+                registerWindow: vi.fn(),
+                addRibbonIcon: vi.fn(),
+                registerProtocolHandler: vi.fn(),
+            },
+            appLifecycle: {
+                getUnresolvedMessages: { addHandler: vi.fn() },
+                isSuspended: vi.fn(() => false),
+            },
+        };
+        const core = {
+            _services: services,
+            services,
+            settings,
+        } as any;
+        const module = new ModuleReplicator(core);
+        const reprocessStoredDocuments = vi.fn(async () => 1);
+        Object.assign(module.processor, { reprocessStoredDocuments });
+
+        try {
+            await (module as any)._everyOnloadAfterLoadSettings();
+            eventHub.emitEvent(EVENT_SETTING_SAVED, { ...settings });
+            await Promise.resolve();
+            expect(reprocessStoredDocuments).not.toHaveBeenCalled();
+
+            Object.assign(settings, { syncOnlyRegEx: "" });
+            eventHub.emitEvent(EVENT_SETTING_SAVED, { ...settings });
+            await vi.waitFor(() => expect(reprocessStoredDocuments).toHaveBeenCalledOnce());
+
+            settings.syncMaxSizeInMB = 10;
+            eventHub.emitEvent(EVENT_SETTING_SAVED, { ...settings });
+            await vi.waitFor(() => expect(reprocessStoredDocuments).toHaveBeenCalledTimes(2));
+        } finally {
+            eventHub.offAll();
+        }
+    });
+});
+
+describe("compatibility: cleaned-remote reconciliation for IndexedDB clients", () => {
+    it("keeps its finite replication and balancing work inside the shared activity boundary", async () => {
+        const activityFinished = vi.fn();
+        const runBoundedRemoteActivity = vi.fn(async (task: () => unknown) => {
+            try {
+                return await task();
+            } finally {
+                activityFinished();
+            }
+        });
+        const runFiniteReplicationActivity = vi.fn(async (task: () => unknown) => await task());
+        const openReplication = vi.fn(async () => true);
+        const activeReplicator = Object.assign(new LiveSyncCouchDBReplicator({} as any), {
+            connectRemoteCouchDBWithSetting: vi.fn(async () => ({ db: {} })),
+            markRemoteResolved: vi.fn(async () => undefined),
+        });
+        const services = {
+            context: createServiceContext(),
+            API: {
+                addLog: vi.fn(),
+                addCommand: vi.fn(),
+                registerWindow: vi.fn(),
+                addRibbonIcon: vi.fn(),
+                registerProtocolHandler: vi.fn(),
+                isMobile: vi.fn(() => false),
+            },
+            setting: { saveSettingData: vi.fn(async () => undefined) },
+            appLifecycle: {
+                getUnresolvedMessages: { addHandler: vi.fn() },
+            },
+            replicator: {
+                getActiveReplicator: vi.fn(() => activeReplicator),
+                runBoundedRemoteActivity,
+                runFiniteReplicationActivity,
+            },
+        };
+        const localDatabase = {
+            localDatabase: {},
+            clearCaches: vi.fn(),
+        };
+        const core = {
+            _services: services,
+            services,
+            settings: {},
+            localDatabase,
+            confirm: { confirmWithMessage: vi.fn(async () => "Cleanup") },
+            replicator: { openReplication },
+        } as any;
+        const module = new ModuleReplicator(core);
+
+        await module.cleaned(true);
+
+        expect(runBoundedRemoteActivity).toHaveBeenCalledWith(expect.any(Function), {
+            label: "database-cleanup",
+        });
+        expect(runFiniteReplicationActivity).toHaveBeenCalledWith(expect.any(Function), {
+            label: "replication",
+        });
+        expect(openReplication).toHaveBeenCalledOnce();
+        expect(openReplication.mock.invocationCallOrder[0]).toBeLessThan(activityFinished.mock.invocationCallOrder[0]);
+        expect(chunkMocks.balanceChunkPurgedDBs).toHaveBeenCalledOnce();
+    });
+});

src/modules/core/ModuleReplicatorCouchDB.ts

@@ -1,7 +1,7 @@
 import { fireAndForget } from "octagonal-wheels/promises";
-import { REMOTE_MINIO, REMOTE_P2P, type RemoteDBSettings } from "@lib/common/types";
-import { LiveSyncCouchDBReplicator } from "@lib/replication/couchdb/LiveSyncReplicator";
-import type { LiveSyncAbstractReplicator } from "@lib/replication/LiveSyncAbstractReplicator";
+import { REMOTE_MINIO, REMOTE_P2P, type RemoteDBSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { LiveSyncCouchDBReplicator } from "@vrtmrz/livesync-commonlib/compat/replication/couchdb/LiveSyncReplicator";
+import type { LiveSyncAbstractReplicator } from "@vrtmrz/livesync-commonlib/compat/replication/LiveSyncAbstractReplicator";
 import { AbstractModule } from "@/modules/AbstractModule";
 import type { LiveSyncCore } from "@/main";
 
@@ -28,7 +28,15 @@ export class ModuleReplicatorCouchDB extends AbstractModule {
                 fireAndForget(async () => {
                     const canReplicate = await this.services.replication.isReplicationReady(false);
                     if (!canReplicate) return;
-                    void this.core.replicator.openReplication(this.settings, continuous, false, false);
+                    const openReplication = () =>
+                        this.core.replicator.openReplication(this.settings, continuous, false, false);
+                    if (continuous) {
+                        void openReplication();
+                    } else {
+                        await this.services.replicator.runFiniteReplicationActivity(openReplication, {
+                            label: "replication",
+                        });
+                    }
                 });
             }
         }

src/modules/core/ModuleReplicatorCouchDB.unit.spec.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it, vi } from "vitest";
+import { ModuleReplicatorCouchDB } from "./ModuleReplicatorCouchDB.ts";
+
+function createModule(settings: { liveSync: boolean; syncOnStart: boolean }, isReplicationReady = true) {
+    const openReplication = vi.fn(async () => true);
+    const runFiniteReplicationActivity = vi.fn(async (task: () => unknown) => await task());
+    const services = {
+        API: {
+            addLog: vi.fn(),
+            addCommand: vi.fn(),
+            registerWindow: vi.fn(),
+            addRibbonIcon: vi.fn(),
+            registerProtocolHandler: vi.fn(),
+        },
+        appLifecycle: {
+            isSuspended: vi.fn(() => false),
+            isReady: vi.fn(() => true),
+        },
+        replication: {
+            isReplicationReady: vi.fn(async () => isReplicationReady),
+        },
+        replicator: {
+            runFiniteReplicationActivity,
+        },
+        setting: {
+            saveSettingData: vi.fn(async () => undefined),
+        },
+    };
+    const core = {
+        _services: services,
+        services,
+        settings: {
+            remoteType: "",
+            ...settings,
+        },
+        replicator: { openReplication },
+    } as any;
+    return {
+        module: new ModuleReplicatorCouchDB(core),
+        openReplication,
+        runFiniteReplicationActivity,
+    };
+}
+
+describe("ModuleReplicatorCouchDB resume replication activity", () => {
+    it("exposes start-up one-shot replication as finite replication activity", async () => {
+        const { module, openReplication, runFiniteReplicationActivity } = createModule({
+            liveSync: false,
+            syncOnStart: true,
+        });
+
+        await module._everyAfterResumeProcess();
+
+        await vi.waitFor(() => expect(openReplication).toHaveBeenCalledOnce());
+        expect(runFiniteReplicationActivity).toHaveBeenCalledWith(expect.any(Function), {
+            label: "replication",
+        });
+        expect(openReplication).toHaveBeenCalledWith(expect.any(Object), false, false, false);
+    });
+
+    it("does not wrap the unbounded continuous channel in another finite activity", async () => {
+        const { module, openReplication, runFiniteReplicationActivity } = createModule({
+            liveSync: true,
+            syncOnStart: false,
+        });
+
+        await module._everyAfterResumeProcess();
+
+        await vi.waitFor(() => expect(openReplication).toHaveBeenCalledOnce());
+        expect(runFiniteReplicationActivity).not.toHaveBeenCalled();
+        expect(openReplication).toHaveBeenCalledWith(expect.any(Object), true, false, false);
+    });
+
+    it("does not start a one-shot activity when start-up readiness fails", async () => {
+        const { module, openReplication, runFiniteReplicationActivity } = createModule(
+            {
+                liveSync: false,
+                syncOnStart: true,
+            },
+            false
+        );
+
+        await module._everyAfterResumeProcess();
+        await new Promise((resolve) => setTimeout(resolve, 0));
+
+        expect(runFiniteReplicationActivity).not.toHaveBeenCalled();
+        expect(openReplication).not.toHaveBeenCalled();
+    });
+});

src/modules/core/ModuleReplicatorMinIO.ts

@@ -1,6 +1,6 @@
-import { REMOTE_MINIO, type RemoteDBSettings } from "@lib/common/types";
-import { LiveSyncJournalReplicator } from "@lib/replication/journal/LiveSyncJournalReplicator";
-import type { LiveSyncAbstractReplicator } from "@lib/replication/LiveSyncAbstractReplicator";
+import { REMOTE_MINIO, type RemoteDBSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { LiveSyncJournalReplicator } from "@vrtmrz/livesync-commonlib/compat/replication/journal/LiveSyncJournalReplicator";
+import type { LiveSyncAbstractReplicator } from "@vrtmrz/livesync-commonlib/compat/replication/LiveSyncAbstractReplicator";
 import type { LiveSyncCore } from "@/main";
 import { AbstractModule } from "@/modules/AbstractModule";
 

src/modules/core/ReplicateResultProcessor.ts

@@ -6,9 +6,9 @@ import {
     type EntryLeaf,
     type LoadedEntry,
     type MetaEntry,
-} from "@lib/common/types";
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
 import type { ModuleReplicator } from "./ModuleReplicator";
-import { isChunk } from "@lib/common/typeUtils";
+import { isChunk } from "@vrtmrz/livesync-commonlib/compat/common/typeUtils";
 import {
     LOG_LEVEL_DEBUG,
     LOG_LEVEL_INFO,
@@ -16,15 +16,17 @@ import {
     LOG_LEVEL_VERBOSE,
     Logger,
     type LOG_LEVEL,
-} from "@lib/common/logger";
-import { fireAndForget, isAnyNote, throttle } from "@lib/common/utils";
+} from "@vrtmrz/livesync-commonlib/compat/common/logger";
+import { fireAndForget, isAnyNote, throttle } from "@vrtmrz/livesync-commonlib/compat/common/utils";
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore_v2";
 import { serialized } from "octagonal-wheels/concurrency/lock";
 import type { ReactiveSource } from "octagonal-wheels/dataobject/reactive_v2";
 import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore";
-import { isNotFoundError } from "@lib/common/utils.doc";
+import { isNotFoundError } from "@vrtmrz/livesync-commonlib/compat/common/utils.doc";
+import type PouchDB from "pouchdb-core";
 
 const KV_KEY_REPLICATION_RESULT_PROCESSOR_SNAPSHOT = "replicationResultProcessorSnapshot";
+const REPROCESS_BATCH_SIZE = 100;
 type ReplicateResultProcessorState = {
     queued: PouchDB.Core.ExistingDocument<EntryDoc>[];
     processing: PouchDB.Core.ExistingDocument<EntryDoc>[];
@@ -181,6 +183,26 @@ export class ReplicateResultProcessor {
             }
         }
     }
+
+    /**
+     * Requeues stored normal-file metadata after its reflection filters change.
+     * Replication checkpoints may already cover documents which were skipped
+     * by the previous filter, so a later ordinary sync cannot emit them again.
+     */
+    public async reprocessStoredDocuments(): Promise<number> {
+        let count = 0;
+        let batch: PouchDB.Core.ExistingDocument<EntryDoc>[] = [];
+        for await (const document of this.localDatabase.findAllNormalDocs()) {
+            batch.push(document);
+            count++;
+            if (batch.length < REPROCESS_BATCH_SIZE) continue;
+            this.enqueueAll(batch);
+            batch = [];
+        }
+        if (batch.length > 0) this.enqueueAll(batch);
+        this.log(`Requeued ${count} stored document(s) after the reflection filters changed`, LOG_LEVEL_INFO);
+        return count;
+    }
     /**
      * Process the change if it is not a document change.
      * @param change Change to process

src/modules/core/ReplicateResultProcessor.unit.spec.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it, vi } from "vitest";
+import type { EntryDoc } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { ReplicateResultProcessor } from "./ReplicateResultProcessor";
+
+describe("ReplicateResultProcessor target-filter reprocessing", () => {
+    it("scans normal-file metadata without loading chunk documents and requeues it", async () => {
+        const documents = [
+            { _id: "first", _rev: "1-a", type: "plain", path: "first.md" },
+            { _id: "second", _rev: "1-b", type: "plain", path: "second.md" },
+        ] as unknown as PouchDB.Core.ExistingDocument<EntryDoc>[];
+        const findAllNormalDocs = vi.fn(async function* () {
+            yield* documents;
+        });
+        const processor = new ReplicateResultProcessor({
+            core: { localDatabase: { findAllNormalDocs } },
+        } as never);
+        const enqueueAll = vi.spyOn(processor, "enqueueAll").mockImplementation(() => undefined);
+
+        await expect(processor.reprocessStoredDocuments()).resolves.toBe(2);
+
+        expect(findAllNormalDocs).toHaveBeenCalledOnce();
+        expect(enqueueAll).toHaveBeenCalledOnce();
+        expect(enqueueAll).toHaveBeenCalledWith(documents);
+    });
+});

src/modules/coreFeatures/ModuleConflictChecker.ts

@@ -1,8 +1,8 @@
 import { AbstractModule } from "@/modules/AbstractModule.ts";
-import { LOG_LEVEL_NOTICE, type FilePathWithPrefix } from "@lib/common/types";
+import { LOG_LEVEL_NOTICE, type FilePathWithPrefix } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { QueueProcessor } from "octagonal-wheels/concurrency/processor";
 import { sendValue } from "octagonal-wheels/messagepassing/signal";
-import type { InjectableServiceHub } from "@lib/services/InjectableServices.ts";
+import type { InjectableServiceHub } from "@vrtmrz/livesync-commonlib/compat/services/implements/injectable/InjectableServiceHub";
 import type { LiveSyncCore } from "@/main.ts";
 
 export class ModuleConflictChecker extends AbstractModule {

src/modules/coreFeatures/ModuleConflictResolver.ts

@@ -10,27 +10,22 @@ import {
     NOT_CONFLICTED,
     type diff_check_result,
     type FilePathWithPrefix,
-} from "@lib/common/types";
-import { isCustomisationSyncMetadata, isPluginMetadata } from "@lib/common/typeUtils.ts";
-import { TARGET_IS_NEW } from "@lib/common/models/shared.const.symbols.ts";
-import { compareMTime, displayRev } from "@lib/common/utils.ts";
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { isCustomisationSyncMetadata, isPluginMetadata } from "@vrtmrz/livesync-commonlib/compat/common/typeUtils";
+import { TARGET_IS_NEW } from "@vrtmrz/livesync-commonlib/compat/common/models/shared.const.symbols";
+import { compareMTime, displayRev } from "@vrtmrz/livesync-commonlib/compat/common/utils";
 import diff_match_patch from "diff-match-patch";
-import { stripAllPrefixes, isPlainText } from "@lib/string_and_binary/path";
-import { eventHub } from "@/common/events.ts";
-import type { InjectableServiceHub } from "@lib/services/InjectableServices.ts";
+import { stripAllPrefixes, isPlainText } from "@vrtmrz/livesync-commonlib/compat/string_and_binary/path";
+import { EVENT_CONFLICT_CANCELLED, eventHub } from "@/common/events.ts";
+import type { InjectableServiceHub } from "@vrtmrz/livesync-commonlib/compat/services/implements/injectable/InjectableServiceHub";
 import type { LiveSyncCore } from "@/main.ts";
 
-declare global {
-    interface LSEvents {
-        "conflict-cancelled": FilePathWithPrefix;
-    }
-}
-
 export class ModuleConflictResolver extends AbstractModule {
     private async _resolveConflictByDeletingRev(
         path: FilePathWithPrefix,
         deleteRevision: string,
-        subTitle = ""
+        subTitle = "",
+        showNotice = true
     ): Promise<typeof MISSING_OR_ERROR | typeof AUTO_MERGED> {
         const title = `Resolving ${subTitle ? `[${subTitle}]` : ""}:`;
         if (!(await this.core.fileHandler.deleteRevisionFromDB(path, deleteRevision))) {
@@ -40,7 +35,7 @@ export class ModuleConflictResolver extends AbstractModule {
             );
             return MISSING_OR_ERROR;
         }
-        eventHub.emitEvent("conflict-cancelled", path);
+        eventHub.emitEvent(EVENT_CONFLICT_CANCELLED, path);
         this._log(
             `${title} Conflicted revision has been deleted ${displayRev(deleteRevision)} ${path}`,
             LOG_LEVEL_INFO
@@ -58,7 +53,7 @@ export class ModuleConflictResolver extends AbstractModule {
             this._log(`Could not write the resolved content to the storage: ${path}`, LOG_LEVEL_NOTICE);
             return MISSING_OR_ERROR;
         }
-        const level = subTitle.indexOf("same") !== -1 ? LOG_LEVEL_INFO : LOG_LEVEL_NOTICE;
+        const level = subTitle.indexOf("same") !== -1 || !showNotice ? LOG_LEVEL_INFO : LOG_LEVEL_NOTICE;
         this._log(`${path} has been merged automatically`, level);
         return AUTO_MERGED;
     }
@@ -91,8 +86,11 @@ export class ModuleConflictResolver extends AbstractModule {
             return MISSING_OR_ERROR;
         }
         if (rightLeaf == false) {
-            // Conflicted item could not load, delete this.
-            return await this.services.conflict.resolveByDeletingRevision(path, rightRev, "MISSING OLD REV");
+            // A locally unreadable conflict leaf may still be recoverable from another
+            // replica or backup. Keep it visible for explicit repair instead of treating
+            // missing chunks as evidence that the branch is obsolete.
+            this._log(`could not read conflicted revision ${rightRev}:${path}`, LOG_LEVEL_NOTICE);
+            return MISSING_OR_ERROR;
         }
 
         const isSame = leftLeaf.data == rightLeaf.data && leftLeaf.deleted == rightLeaf.deleted;
@@ -130,11 +128,12 @@ export class ModuleConflictResolver extends AbstractModule {
         // const filename = filenames[0];
         return await serialized(`conflict-resolve:${filename}`, async () => {
             const conflictCheckResult = await this.checkConflictAndPerformAutoMerge(filename);
-            if (
-                conflictCheckResult === MISSING_OR_ERROR ||
-                conflictCheckResult === NOT_CONFLICTED ||
-                conflictCheckResult === CANCELLED
-            ) {
+            if (conflictCheckResult === NOT_CONFLICTED) {
+                eventHub.emitEvent(EVENT_CONFLICT_CANCELLED, filename);
+                this._log(`[conflict] Not conflicted or cancelled: ${filename}`, LOG_LEVEL_VERBOSE);
+                return;
+            }
+            if (conflictCheckResult === MISSING_OR_ERROR || conflictCheckResult === CANCELLED) {
                 // nothing to do.
                 this._log(`[conflict] Not conflicted or cancelled: ${filename}`, LOG_LEVEL_VERBOSE);
                 return;
@@ -160,12 +159,12 @@ export class ModuleConflictResolver extends AbstractModule {
                 }
             }
             this._log("[conflict] Manual merge required!");
-            eventHub.emitEvent("conflict-cancelled", filename);
+            eventHub.emitEvent(EVENT_CONFLICT_CANCELLED, filename);
             await this.services.conflict.resolveByUserInteraction(filename, conflictCheckResult);
         });
     }
 
-    private async _anyResolveConflictByNewest(filename: FilePathWithPrefix): Promise<boolean> {
+    private async _anyResolveConflictByNewest(filename: FilePathWithPrefix, showNotice = true): Promise<boolean> {
         const currentRev = await this.core.databaseFileAccess.fetchEntryMeta(filename, undefined, true);
         if (currentRev == false) {
             this._log(`Could not get current revision of ${filename}`);
@@ -203,7 +202,7 @@ export class ModuleConflictResolver extends AbstractModule {
             this._log(
                 `conflict: Deleting the older revision ${mTimeAndRev[i][1]} (${new Date(mTimeAndRev[i][0]).toLocaleString()}) of ${filename}`
             );
-            await this.services.conflict.resolveByDeletingRevision(filename, mTimeAndRev[i][1], "NEWEST");
+            await this._resolveConflictByDeletingRev(filename, mTimeAndRev[i][1], "NEWEST", showNotice);
         }
         return true;
     }
@@ -214,13 +213,14 @@ export class ModuleConflictResolver extends AbstractModule {
 
         let i = 0;
         for (const file of files) {
-            if (i++ % 10)
+            i++;
+            if (i % 10 === 0)
                 this._log(
                     `Check and Processing ${i} / ${files.length}`,
                     LOG_LEVEL_NOTICE,
                     "resolveAllConflictedFilesByNewerOnes"
                 );
-            await this.services.conflict.resolveByNewest(file);
+            await this._anyResolveConflictByNewest(file, false);
         }
         this._log(`Done!`, LOG_LEVEL_NOTICE, "resolveAllConflictedFilesByNewerOnes");
     }

src/modules/coreFeatures/ModuleConflictResolver.unit.spec.ts

@@ -0,0 +1,268 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+    AUTO_MERGED,
+    DEFAULT_SETTINGS,
+    LOG_LEVEL_INFO,
+    LOG_LEVEL_NOTICE,
+    MISSING_OR_ERROR,
+    type FilePathWithPrefix,
+    type MetaEntry,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { ModuleConflictResolver } from "./ModuleConflictResolver";
+
+function createModule(files: FilePathWithPrefix[] = []) {
+    const resolveByDeletingRevision = vi.fn(async () => AUTO_MERGED);
+    const tryAutoMerge = vi.fn();
+    const queueCheckFor = vi.fn(async () => undefined);
+    const resolveByUserInteraction = vi.fn(async () => false);
+    const core = {
+        _services: {
+            API: {
+                addLog: vi.fn(),
+                addCommand: vi.fn(),
+                registerWindow: vi.fn(),
+                addRibbonIcon: vi.fn(),
+                registerProtocolHandler: vi.fn(),
+            },
+            setting: {
+                saveSettingData: vi.fn(async () => undefined),
+            },
+            conflict: {
+                resolveByNewest: vi.fn(async () => true),
+                resolveByDeletingRevision,
+                resolveByUserInteraction,
+                queueCheckFor,
+            },
+            appLifecycle: {
+                isSuspended: vi.fn(() => false),
+            },
+            replication: {
+                replicateByEvent: vi.fn(async () => true),
+            },
+            vault: {
+                getActiveFilePath: vi.fn(() => undefined),
+            },
+        },
+        settings: DEFAULT_SETTINGS,
+        fileHandler: {
+            deleteRevisionFromDB: vi.fn(async () => true),
+            dbToStorage: vi.fn(async () => true),
+        },
+        databaseFileAccess: {
+            getConflictedRevs: vi.fn(async () => []),
+            storeContent: vi.fn(async () => true),
+        },
+        localDatabase: {
+            tryAutoMerge,
+        },
+        storageAccess: {
+            getFileNames: vi.fn(async () => files),
+        },
+    } as any;
+    Object.defineProperty(core, "services", { get: () => core._services });
+
+    const module = new ModuleConflictResolver(core);
+    module._log = vi.fn();
+    return { module, queueCheckFor, resolveByDeletingRevision, resolveByUserInteraction, tryAutoMerge };
+}
+
+describe("ModuleConflictResolver bulk newest resolution", () => {
+    it("retains the success notice for a non-bulk newest resolution", async () => {
+        const { module } = createModule();
+        const path = "example.md" as FilePathWithPrefix;
+        module.core.databaseFileAccess.fetchEntryMeta = vi.fn(
+            async (_path: unknown, rev?: string): Promise<MetaEntry> =>
+                ({
+                    _id: "doc-id",
+                    _rev: rev ?? "2-current",
+                    path,
+                    ctime: 1,
+                    mtime: rev ? 1 : 2,
+                    size: 0,
+                    children: [],
+                    type: "plain",
+                    eden: {},
+                }) as unknown as MetaEntry
+        );
+        module.core.databaseFileAccess.getConflictedRevs = vi
+            .fn()
+            .mockResolvedValueOnce(["1-old"])
+            .mockResolvedValue([]);
+
+        await (module as any)._anyResolveConflictByNewest(path);
+
+        expect(module._log).toHaveBeenLastCalledWith(`${path} has been merged automatically`, LOG_LEVEL_NOTICE);
+    });
+
+    it("logs a successful bulk newest resolution without displaying a notice", async () => {
+        const { module } = createModule();
+        const path = "example.md" as FilePathWithPrefix;
+        module.core.databaseFileAccess.fetchEntryMeta = vi.fn(
+            async (_path: unknown, rev?: string): Promise<MetaEntry> =>
+                ({
+                    _id: "doc-id",
+                    _rev: rev ?? "2-current",
+                    path,
+                    ctime: 1,
+                    mtime: rev ? 1 : 2,
+                    size: 0,
+                    children: [],
+                    type: "plain",
+                    eden: {},
+                }) as unknown as MetaEntry
+        );
+        module.core.databaseFileAccess.getConflictedRevs = vi
+            .fn()
+            .mockResolvedValueOnce(["1-old"])
+            .mockResolvedValue([]);
+
+        await (module as any)._anyResolveConflictByNewest(path, false);
+
+        expect(module._log).toHaveBeenLastCalledWith(`${path} has been merged automatically`, LOG_LEVEL_INFO);
+    });
+
+    it("updates notice-level progress once every ten checked files", async () => {
+        const files = Array.from({ length: 11 }, (_, index) => `note-${index}.md` as FilePathWithPrefix);
+        const { module } = createModule(files);
+        const resolveByNewest = vi.spyOn(module as any, "_anyResolveConflictByNewest").mockResolvedValue(true);
+
+        await (module as any)._resolveAllConflictedFilesByNewerOnes();
+
+        expect(resolveByNewest).toHaveBeenCalledTimes(11);
+        expect(resolveByNewest).toHaveBeenCalledWith(files[0], false);
+        expect(module._log).toHaveBeenCalledWith(
+            "Check and Processing 10 / 11",
+            LOG_LEVEL_NOTICE,
+            "resolveAllConflictedFilesByNewerOnes"
+        );
+        expect(module._log).toHaveBeenCalledTimes(3);
+    });
+});
+
+describe("ModuleConflictResolver independent same-path creation", () => {
+    const path = "independently-created.md" as FilePathWithPrefix;
+
+    function leaf(rev: string, data: string, mtime: number) {
+        return {
+            rev,
+            data,
+            mtime,
+            ctime: mtime,
+            deleted: false,
+        } as any;
+    }
+
+    it("collapses one duplicate revision when independently created files have identical content", async () => {
+        const { module, resolveByDeletingRevision, tryAutoMerge } = createModule();
+        const leftLeaf = leaf("1-left", "Same content\n", 1000);
+        const rightLeaf = leaf("1-right", "Same content\n", 2000);
+        tryAutoMerge.mockResolvedValue({
+            leftRev: leftLeaf.rev,
+            rightRev: rightLeaf.rev,
+            leftLeaf,
+            rightLeaf,
+        });
+
+        const result = await module.checkConflictAndPerformAutoMerge(path);
+
+        expect(result).toBe(AUTO_MERGED);
+        expect(resolveByDeletingRevision).toHaveBeenCalledOnce();
+        expect(resolveByDeletingRevision).toHaveBeenCalledWith(path, "1-left", "same");
+    });
+
+    it("returns a manual diff when independently created files have different content", async () => {
+        const { module, resolveByDeletingRevision, tryAutoMerge } = createModule();
+        const leftLeaf = leaf("1-left", "Left content\n", 1000);
+        const rightLeaf = leaf("1-right", "Right content\n", 2000);
+        tryAutoMerge.mockResolvedValue({
+            leftRev: leftLeaf.rev,
+            rightRev: rightLeaf.rev,
+            leftLeaf,
+            rightLeaf,
+        });
+
+        const result = await module.checkConflictAndPerformAutoMerge(path);
+
+        expect(result).toMatchObject({ left: leftLeaf, right: rightLeaf });
+        expect(result).toHaveProperty("diff");
+        expect(resolveByDeletingRevision).not.toHaveBeenCalled();
+    });
+});
+
+describe("ModuleConflictResolver sensible merge hand-off", () => {
+    it("keeps an unreadable non-winner revision unresolved", async () => {
+        const path = "missing-conflict-body.md" as FilePathWithPrefix;
+        const { module, resolveByDeletingRevision, tryAutoMerge } = createModule();
+        tryAutoMerge.mockResolvedValue({
+            leftRev: "3-current",
+            rightRev: "2-unreadable",
+            leftLeaf: {
+                rev: "3-current",
+                data: "Readable current body\n",
+                ctime: 1,
+                mtime: 3,
+                deleted: false,
+            },
+            rightLeaf: false,
+        });
+
+        const result = await module.checkConflictAndPerformAutoMerge(path);
+
+        expect(result).toBe(MISSING_OR_ERROR);
+        expect(resolveByDeletingRevision).not.toHaveBeenCalled();
+    });
+
+    it("stores the merged body and removes the resolved conflict leaf", async () => {
+        const path = "sensible.md" as FilePathWithPrefix;
+        const { module, resolveByDeletingRevision, tryAutoMerge } = createModule();
+        tryAutoMerge.mockResolvedValue({
+            result: "Title\nLeft changed\nRight changed\n",
+            conflictedRev: "2-right",
+        });
+
+        const result = await module.checkConflictAndPerformAutoMerge(path);
+
+        expect(result).toBe(AUTO_MERGED);
+        expect(module.core.databaseFileAccess.storeContent).toHaveBeenCalledWith(
+            path,
+            "Title\nLeft changed\nRight changed\n"
+        );
+        expect(resolveByDeletingRevision).toHaveBeenCalledWith(path, "2-right", "Sensible");
+    });
+
+    it("commits a sensible pair before rechecking the remaining manual pair", async () => {
+        const path = "three-versions.md" as FilePathWithPrefix;
+        const { module, queueCheckFor, resolveByDeletingRevision, resolveByUserInteraction, tryAutoMerge } =
+            createModule();
+        const remainingManualPair = {
+            leftRev: "3-merged",
+            rightRev: "2-third",
+            leftLeaf: { rev: "3-merged", data: "Merged\n", ctime: 1, mtime: 3 },
+            rightLeaf: { rev: "2-third", data: "Overlapping\n", ctime: 1, mtime: 2 },
+        };
+        tryAutoMerge
+            .mockResolvedValueOnce({
+                result: "Merged\n",
+                conflictedRev: "2-second",
+            })
+            .mockResolvedValueOnce(remainingManualPair);
+
+        await (module as any)._resolveConflict(path);
+
+        expect(module.core.databaseFileAccess.storeContent).toHaveBeenCalledWith(path, "Merged\n");
+        expect(resolveByDeletingRevision).toHaveBeenCalledWith(path, "2-second", "Sensible");
+        expect(queueCheckFor).toHaveBeenCalledWith(path);
+        expect(resolveByUserInteraction).not.toHaveBeenCalled();
+
+        await (module as any)._resolveConflict(path);
+
+        expect(tryAutoMerge).toHaveBeenCalledTimes(2);
+        expect(resolveByUserInteraction).toHaveBeenCalledWith(
+            path,
+            expect.objectContaining({
+                left: remainingManualPair.leftLeaf,
+                right: remainingManualPair.rightLeaf,
+            })
+        );
+    });
+});

src/modules/coreFeatures/ModuleResolveMismatchedTweaks.ts

@@ -10,13 +10,13 @@ import {
     type RemoteDBSettings,
     IncompatibleChangesInSpecificPattern,
     CompatibleButLossyChanges,
-} from "@lib/common/types.ts";
-import { escapeMarkdownValue } from "@lib/common/utils.ts";
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { escapeMarkdownValue } from "@vrtmrz/livesync-commonlib/compat/common/utils";
 import { AbstractModule } from "@/modules/AbstractModule.ts";
-import { $msg } from "@lib/common/i18n.ts";
-import type { InjectableServiceHub } from "@lib/services/InjectableServices.ts";
+import { $msg } from "@/common/translation";
+import type { InjectableServiceHub } from "@vrtmrz/livesync-commonlib/compat/services/implements/injectable/InjectableServiceHub";
 import type { LiveSyncCore } from "@/main.ts";
-import { REMOTE_P2P } from "@lib/common/models/setting.const.ts";
+import { REMOTE_P2P } from "@vrtmrz/livesync-commonlib/compat/common/models/setting.const";
 
 function valueToString(value: string | number | boolean | object | undefined): string {
     if (typeof value === "boolean") {
@@ -29,8 +29,6 @@ function valueToString(value: string | number | boolean | object | undefined): s
 }
 
 export class ModuleResolvingMismatchedTweaks extends AbstractModule {
-    private _hasNotifiedAutoAcceptCompatibleUndefined = false;
-
     private _collectMismatchedTweakKeys(current: TweakValues, preferred: Partial<TweakValues>) {
         const items = Object.keys(
             TweakValuesShouldMatchedTemplate
@@ -64,33 +62,17 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
         );
         if (!hasOnlyCompatibleLossyMismatches) return undefined;
 
+        let autoAcceptCompatibleTweak = this.settings.autoAcceptCompatibleTweak;
         if (this.settings.autoAcceptCompatibleTweak === undefined) {
-            if (this._hasNotifiedAutoAcceptCompatibleUndefined) {
-                return undefined;
-            }
-            this._hasNotifiedAutoAcceptCompatibleUndefined = true;
-            const CHOICE_ENABLE = $msg("TweakMismatchResolve.Action.EnableAutoAcceptCompatible");
-            const CHOICE_DISABLE = $msg("TweakMismatchResolve.Action.DisableAutoAcceptCompatible");
-            const CHOICES = [CHOICE_ENABLE, CHOICE_DISABLE] as const;
-            const message = $msg("TweakMismatchResolve.Message.AutoAcceptCompatibleUndefined");
-            const ret = await this.core.confirm.askSelectStringDialogue(message, CHOICES, {
-                title: $msg("TweakMismatchResolve.Title.AutoAcceptCompatible"),
-                timeout: 0,
-                defaultAction: CHOICE_ENABLE,
-            });
-            if (ret !== CHOICE_ENABLE) {
-                return undefined;
-            }
-            await this.services.setting.applyPartial(
-                {
-                    autoAcceptCompatibleTweak: true,
-                },
-                true
-            );
-            Logger("Auto-accept for compatible tweak mismatch has been enabled.");
+            // Keep the settings object stable: settings panes and an in-flight replication retry can
+            // retain this reference while the default is persisted.
+            this.settings.autoAcceptCompatibleTweak = true;
+            await this.services.setting.saveSettingData();
+            autoAcceptCompatibleTweak = true;
+            Logger("Automatic alignment of compatible chunk settings has been enabled.");
         }
 
-        if (this.settings.autoAcceptCompatibleTweak !== true) return undefined;
+        if (autoAcceptCompatibleTweak !== true) return undefined;
         return this._selectNewerTweakSide(current, preferred);
     }
 
@@ -215,7 +197,7 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
         } else if (rebuildRecommended) {
             CHOICE_AND_VALUES.push([CHOICE_USE_REMOTE, [preferred, false]]);
             CHOICE_AND_VALUES.push([CHOICE_USE_MINE, [true, false]]);
-            CHOICE_AND_VALUES.push([CHOICE_USE_REMOTE_WITH_REBUILD, [true, true]]);
+            CHOICE_AND_VALUES.push([CHOICE_USE_REMOTE_WITH_REBUILD, [preferred, true]]);
             CHOICE_AND_VALUES.push([CHOICE_USE_MINE_WITH_REBUILD, [true, true]]);
         } else {
             CHOICE_AND_VALUES.push([CHOICE_USE_REMOTE, [preferred, false]]);
@@ -255,9 +237,16 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
             return "CHECKAGAIN";
         }
         if (conf) {
-            this.settings = { ...this.settings, ...conf };
-            await this.core.replicator.setPreferredRemoteTweakSettings(this.settings);
+            // ReplicationService retains the current settings object while it performs the immediate
+            // CHECKAGAIN retry. Update that object in place so the retry observes the accepted values.
+            Object.assign(this.settings, extractObject(TweakValuesTemplate, conf));
             await this.services.setting.saveSettingData();
+            if (!rebuildRequired) {
+                // The failed replication has settled before mismatch resolution runs. Reinitialise the
+                // chunk-generation managers now so hash and splitter changes take effect before retrying.
+                await this.localDatabase.managers.reinitialise();
+            }
+            await this.core.replicator.setPreferredRemoteTweakSettings(this.settings);
             if (rebuildRequired) {
                 await this.core.rebuilder.$fetchLocal();
             }

src/modules/coreFeatures/ModuleResolveMismatchedTweaks.unit.spec.ts

@@ -1,9 +1,16 @@
 import { describe, expect, it, vi } from "vitest";
-import { DEFAULT_SETTINGS, REMOTE_COUCHDB, type RemoteDBSettings, type TweakValues } from "@lib/common/types";
+import {
+    DEFAULT_SETTINGS,
+    REMOTE_COUCHDB,
+    type RemoteDBSettings,
+    type TweakValues,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { ModuleResolvingMismatchedTweaks } from "./ModuleResolveMismatchedTweaks";
 
 function createModule(settingsOverride: Partial<typeof DEFAULT_SETTINGS> = {}) {
-    const askSelectStringDialogue = vi.fn(async () => undefined);
+    const askSelectStringDialogue = vi.fn(async (..._args: unknown[]): Promise<string | undefined> => undefined);
+    const applyPartial = vi.fn(async (_partial: Record<string, unknown>): Promise<void> => undefined);
+    const reinitialise = vi.fn(async () => undefined);
     const core = {
         _services: {
             API: {
@@ -15,6 +22,12 @@ function createModule(settingsOverride: Partial<typeof DEFAULT_SETTINGS> = {}) {
             },
             setting: {
                 saveSettingData: vi.fn(async () => undefined),
+                applyPartial,
+            },
+        },
+        localDatabase: {
+            managers: {
+                reinitialise,
             },
         },
         settings: {
@@ -26,6 +39,9 @@ function createModule(settingsOverride: Partial<typeof DEFAULT_SETTINGS> = {}) {
             askSelectStringDialogue,
         },
     } as any;
+    applyPartial.mockImplementation(async (partial: Record<string, unknown>) => {
+        core.settings = { ...core.settings, ...partial };
+    });
 
     Object.defineProperty(core, "services", {
         get() {
@@ -34,10 +50,35 @@ function createModule(settingsOverride: Partial<typeof DEFAULT_SETTINGS> = {}) {
     });
 
     const module = new ModuleResolvingMismatchedTweaks(core);
-    return { module, core, askSelectStringDialogue };
+    return { module, core, askSelectStringDialogue, applyPartial, reinitialise };
 }
 
 describe("ModuleResolvingMismatchedTweaks", () => {
+    it("should enable and auto-accept compatible mismatches when the preference is undefined", async () => {
+        const { module, core, askSelectStringDialogue, applyPartial } = createModule({
+            autoAcceptCompatibleTweak: undefined,
+            hashAlg: "xxhash64",
+            tweakModified: 100,
+        });
+        const initialSettings = core.settings;
+
+        const preferred = {
+            ...(DEFAULT_SETTINGS as unknown as TweakValues),
+            hashAlg: "xxhash32",
+            tweakModified: 200,
+        } as Partial<TweakValues>;
+
+        const [conf, rebuild] = await module._checkAndAskResolvingMismatchedTweaks(preferred);
+
+        expect(conf).toEqual(preferred);
+        expect(rebuild).toBe(false);
+        expect(core.settings).toBe(initialSettings);
+        expect(core.settings.autoAcceptCompatibleTweak).toBe(true);
+        expect(core._services.setting.saveSettingData).toHaveBeenCalledTimes(1);
+        expect(applyPartial).not.toHaveBeenCalled();
+        expect(askSelectStringDialogue).not.toHaveBeenCalled();
+    });
+
     it("should auto-accept compatible mismatches on connect check using newer remote tweakModified", async () => {
         const { module, askSelectStringDialogue } = createModule({
             autoAcceptCompatibleTweak: true,
@@ -58,6 +99,28 @@ describe("ModuleResolvingMismatchedTweaks", () => {
         expect(askSelectStringDialogue).not.toHaveBeenCalled();
     });
 
+    it.each([
+        { label: "neither side has a recorded time", currentModified: 0, preferredModified: 0 },
+        { label: "the recorded times are equal", currentModified: 200, preferredModified: 200 },
+    ])("should use the remote compatible value when $label", async ({ currentModified, preferredModified }) => {
+        const { module, askSelectStringDialogue } = createModule({
+            autoAcceptCompatibleTweak: true,
+            hashAlg: "xxhash64",
+            tweakModified: currentModified,
+        });
+        const preferred = {
+            ...(DEFAULT_SETTINGS as unknown as TweakValues),
+            hashAlg: "xxhash32",
+            tweakModified: preferredModified,
+        } as Partial<TweakValues>;
+
+        const [conf, rebuild] = await module._checkAndAskResolvingMismatchedTweaks(preferred);
+
+        expect(conf).toEqual(preferred);
+        expect(rebuild).toBe(false);
+        expect(askSelectStringDialogue).not.toHaveBeenCalled();
+    });
+
     it("should fallback to manual confirmation when mismatches are mixed on connect check", async () => {
         const { module, askSelectStringDialogue } = createModule({
             autoAcceptCompatibleTweak: true,
@@ -80,6 +143,24 @@ describe("ModuleResolvingMismatchedTweaks", () => {
         expect(askSelectStringDialogue).toHaveBeenCalledTimes(1);
     });
 
+    it("should fetch after applying a compatible remote setting when the user selects the rebuild option", async () => {
+        const { module, askSelectStringDialogue } = createModule({
+            autoAcceptCompatibleTweak: false,
+            hashAlg: "xxhash64",
+        });
+        askSelectStringDialogue.mockResolvedValueOnce("Apply settings to this device, and fetch again");
+
+        const preferred = {
+            ...(DEFAULT_SETTINGS as unknown as TweakValues),
+            hashAlg: "xxhash32",
+        } as TweakValues;
+
+        const [conf, rebuild] = await module._checkAndAskResolvingMismatchedTweaks(preferred);
+
+        expect(conf).toEqual(preferred);
+        expect(rebuild).toBe(true);
+    });
+
     it("should auto-accept compatible mismatches on remote-config check using newer local tweakModified", async () => {
         const { module, askSelectStringDialogue } = createModule({
             autoAcceptCompatibleTweak: true,
@@ -105,4 +186,42 @@ describe("ModuleResolvingMismatchedTweaks", () => {
         expect(result).toEqual({ result: false, requireFetch: false });
         expect(askSelectStringDialogue).not.toHaveBeenCalled();
     });
+
+    it("should apply remote compatible settings in place and reinitialise managers before retrying", async () => {
+        const { module, core, reinitialise } = createModule({
+            autoAcceptCompatibleTweak: true,
+            hashAlg: "xxhash64",
+            tweakModified: 100,
+        });
+        const initialSettings = core.settings;
+        const preferred = {
+            ...(DEFAULT_SETTINGS as unknown as TweakValues),
+            hashAlg: "xxhash32",
+            tweakModified: 200,
+        } as TweakValues;
+        const calls: string[] = [];
+        core._services.tweakValue = {
+            checkAndAskResolvingMismatched: vi.fn(async () => [preferred, false]),
+        };
+        core._services.setting.saveSettingData = vi.fn(async () => {
+            calls.push("save");
+        });
+        core.replicator = {
+            tweakSettingsMismatched: true,
+            preferredTweakValue: preferred,
+            setPreferredRemoteTweakSettings: vi.fn(async () => {
+                calls.push("set-preferred");
+            }),
+        };
+        reinitialise.mockImplementation(async () => {
+            calls.push("reinitialise");
+        });
+
+        const result = await module._askResolvingMismatchedTweaks();
+
+        expect(result).toBe("CHECKAGAIN");
+        expect(core.settings).toBe(initialSettings);
+        expect(core.settings.hashAlg).toBe("xxhash32");
+        expect(calls).toEqual(["save", "reinitialise", "set-preferred"]);
+    });
 });

src/modules/coreObsidian/UILib/dialogs.ts

@@ -1,23 +1,19 @@
 import { ButtonComponent } from "@/deps.ts";
 import { App, FuzzySuggestModal, MarkdownRenderer, Modal, Plugin, Setting, Component } from "@/deps.ts";
 import { EVENT_PLUGIN_UNLOADED, eventHub } from "@/common/events.ts";
-import { compatGlobal, type CompatIntervalHandle } from "@lib/common/coreEnvFunctions.ts";
+import { compatGlobal, type CompatIntervalHandle } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
 
 class AutoClosableModal extends Modal {
-    _closeByUnload() {
-        // eslint-disable-next-line @typescript-eslint/unbound-method
+    _closeByUnload = () => {
         eventHub.off(EVENT_PLUGIN_UNLOADED, this._closeByUnload);
         this.close();
-    }
+    };
 
     constructor(app: App) {
         super(app);
-        this._closeByUnload = this._closeByUnload.bind(this);
-        // eslint-disable-next-line @typescript-eslint/unbound-method
         eventHub.once(EVENT_PLUGIN_UNLOADED, this._closeByUnload);
     }
     override onClose() {
-        // eslint-disable-next-line @typescript-eslint/unbound-method
         eventHub.off(EVENT_PLUGIN_UNLOADED, this._closeByUnload);
     }
 }
@@ -192,6 +188,7 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
     override onOpen() {
         this.component.load();
         const { contentEl } = this;
+        contentEl.closest(".modal-container")?.classList.add("livesync-message-box-container");
         this.titleEl.setText(this.title);
         const div = contentEl.createDiv();
         div.setCssStyles({

src/modules/coreObsidian/storageLib/utilObsidian.ts

@@ -2,9 +2,9 @@
 
 import { TFile, type TAbstractFile, type TFolder } from "@/deps.ts";
 import { ICHeader } from "@/common/types.ts";
-import { addPrefix, isPlainText } from "@lib/string_and_binary/path.ts";
+import { addPrefix, isPlainText } from "@vrtmrz/livesync-commonlib/compat/string_and_binary/path";
 import { LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
-import { createBlob } from "@lib/common/utils.ts";
+import { createBlob } from "@vrtmrz/livesync-commonlib/compat/common/utils";
 import type {
     FilePath,
     FilePathWithPrefix,
@@ -12,10 +12,22 @@ import type {
     UXFileInfoStub,
     UXFolderInfo,
     UXInternalFileInfoStub,
-} from "@lib/common/types.ts";
+    UXStat,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
 import type { LiveSyncCore } from "@/main.ts";
 import type { FileAccessObsidian } from "@/serviceModules/FileAccessObsidian.ts";
 
+function isUXStat(value: unknown): value is UXStat {
+    if (typeof value !== "object" || value === null) return false;
+    const stat = value as Partial<UXStat>;
+    return (
+        typeof stat.size === "number" &&
+        typeof stat.ctime === "number" &&
+        typeof stat.mtime === "number" &&
+        (stat.type === "file" || stat.type === "folder")
+    );
+}
+
 export async function TFileToUXFileInfo(
     core: LiveSyncCore,
     file: TFile,
@@ -55,8 +67,8 @@ export async function InternalFileToUXFileInfo(
     prefix: string = ICHeader
 ): Promise<UXFileInfo> {
     const name = fullPath.split("/").pop() as string;
-    const stat = await vaultAccess.tryAdapterStat(fullPath);
-    if (stat == null) throw new Error(`File not found: ${fullPath}`);
+    const stat: unknown = await vaultAccess.tryAdapterStat(fullPath);
+    if (!isUXStat(stat)) throw new Error(`File not found: ${fullPath}`);
     if (stat.type == "folder") throw new Error(`File not found: ${fullPath}`);
     const file = await vaultAccess.adapterReadAuto(fullPath);
 

src/modules/essential/ModuleBasicMenu.ts

@@ -2,24 +2,29 @@ import type { LiveSyncCore } from "@/main";
 import { LOG_LEVEL_NOTICE } from "octagonal-wheels/common/logger";
 import { fireAndForget } from "octagonal-wheels/promises";
 import { AbstractModule } from "@/modules/AbstractModule";
+import { $msg } from "@/common/translation";
+import { copyFileDatabaseInfo } from "@/serviceFeatures/fileDatabaseInfo";
 // Separated Module for basic menu commands, which are not related to obsidian specific features. It is expected to be used in other platforms with minimal changes.
 // However, it is odd that it has here at all; it really ought to be in each respective feature. It will likely be moved eventually. Until now, addCommand pointed to Obsidian's version.
 export class ModuleBasicMenu extends AbstractModule {
     _everyOnloadStart(): Promise<boolean> {
         this.addCommand({
             id: "livesync-replicate",
-            name: "Replicate now",
+            name: $msg("Sync now"),
             callback: async () => {
                 await this.services.replication.replicate();
             },
         });
         this.addCommand({
             id: "livesync-dump",
-            name: "Dump information of this doc ",
-            callback: () => {
+            name: $msg("Copy database information for the active file"),
+            checkCallback: (checking) => {
                 const file = this.services.vault.getActiveFilePath();
-                if (!file) return;
-                fireAndForget(() => this.localDatabase.getDBEntry(file, {}, true, false));
+                if (!file) return false;
+                if (!checking) {
+                    fireAndForget(() => copyFileDatabaseInfo(this.core, file));
+                }
+                return true;
             },
         });
         this.addCommand({
@@ -56,14 +61,18 @@ export class ModuleBasicMenu extends AbstractModule {
         this.addCommand({
             id: "livesync-scan-files",
             name: "Scan storage and database again",
-            callback: async () => {
-                await this.services.vault.scanVault(true);
+            checkCallback: (checking) => {
+                if (!this.settings.useAdvancedMode) return false;
+                if (!checking) {
+                    fireAndForget(() => this.services.vault.scanVault(true));
+                }
+                return true;
             },
         });
 
         this.addCommand({
             id: "livesync-runbatch",
-            name: "Run pended batch processes",
+            name: $msg("Apply pending changes now"),
             callback: async () => {
                 await this.services.fileProcessing.commitPendingFileEvents();
             },
@@ -73,8 +82,12 @@ export class ModuleBasicMenu extends AbstractModule {
         this.addCommand({
             id: "livesync-abortsync",
             name: "Abort synchronization immediately",
-            callback: () => {
-                this.core.replicator.terminateSync();
+            checkCallback: (checking) => {
+                if (!this.settings.useAdvancedMode) return false;
+                if (!checking) {
+                    this.core.replicator.terminateSync();
+                }
+                return true;
             },
         });
         return Promise.resolve(true);

src/modules/essential/ModuleBasicMenu.unit.spec.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it, vi } from "vitest";
+import type { Command } from "@/deps";
+import { ModuleBasicMenu } from "./ModuleBasicMenu";
+
+type RegisteredCommand = Command & {
+    checkCallback?: (checking: boolean) => boolean | void;
+};
+
+function createFixture() {
+    const commands: RegisteredCommand[] = [];
+    const settings = {
+        liveSync: false,
+        useAdvancedMode: false,
+        enableDebugTools: false,
+    };
+    const services = {
+        API: {
+            addLog: vi.fn(),
+            addCommand: vi.fn((command: RegisteredCommand) => {
+                commands.push(command);
+                return command;
+            }),
+            registerWindow: vi.fn(),
+            addRibbonIcon: vi.fn(),
+            registerProtocolHandler: vi.fn(),
+        },
+        replication: {
+            replicate: vi.fn(async () => undefined),
+        },
+        vault: {
+            getActiveFilePath: vi.fn((): string | null => "note.md"),
+            scanVault: vi.fn(async () => undefined),
+        },
+        control: {
+            applySettings: vi.fn(async () => undefined),
+        },
+        setting: {
+            saveSettingData: vi.fn(async () => undefined),
+        },
+        appLifecycle: {
+            isSuspended: vi.fn(() => false),
+            setSuspended: vi.fn(),
+        },
+        fileProcessing: {
+            commitPendingFileEvents: vi.fn(async () => true),
+        },
+        UI: {
+            promptCopyToClipboard: vi.fn(async (_title: string, _value: string) => true),
+        },
+        path: {
+            path2id: vi.fn(async () => "f:note"),
+        },
+    };
+    const core = {
+        settings,
+        _services: services,
+        services,
+        localDatabase: {
+            getDBEntry: vi.fn(async () => false),
+            localDatabase: {
+                get: vi.fn(async () => ({
+                    _id: "f:note",
+                    _rev: "2-current",
+                    _conflicts: [],
+                    path: "note.md",
+                    ctime: 100,
+                    mtime: 200,
+                    size: 12,
+                    type: "plain",
+                    children: ["h:private-chunk-id"],
+                    eden: {},
+                })),
+            },
+            getDBEntryMeta: vi.fn(async () => ({
+                _id: "f:note",
+                _rev: "2-current",
+                _conflicts: [],
+                path: "note.md",
+                ctime: 100,
+                mtime: 200,
+                size: 12,
+                type: "plain",
+                datatype: "plain",
+                data: "",
+                children: ["h:private-chunk-id"],
+                eden: {},
+            })),
+            allDocsRaw: vi.fn(async () => ({
+                rows: [{ id: "h:private-chunk-id", key: "h:private-chunk-id", value: { rev: "1-chunk" } }],
+            })),
+        },
+        storageAccess: {
+            isExistsIncludeHidden: vi.fn(async () => true),
+            statHidden: vi.fn(async () => ({ ctime: 100, mtime: 200, size: 12, type: "file" })),
+        },
+        replicator: {
+            terminateSync: vi.fn(),
+        },
+    };
+    const module = new ModuleBasicMenu(core as never);
+
+    return {
+        commands,
+        core,
+        module,
+        services,
+        settings,
+        getCommand(id: string) {
+            const command = commands.find((candidate) => candidate.id === id);
+            expect(command, `command ${id}`).toBeDefined();
+            return command!;
+        },
+    };
+}
+
+describe("ModuleBasicMenu command palette", () => {
+    it("uses clear user-facing names without changing the established command IDs", async () => {
+        const fixture = createFixture();
+
+        await fixture.module._everyOnloadStart();
+
+        expect(fixture.getCommand("livesync-replicate").name).toBe("Sync now");
+        expect(fixture.getCommand("livesync-runbatch").name).toBe("Apply pending changes now");
+    });
+
+    it("keeps maintenance commands out of the normal palette", async () => {
+        const fixture = createFixture();
+
+        await fixture.module._everyOnloadStart();
+
+        expect(fixture.getCommand("livesync-scan-files").checkCallback?.(true)).toBe(false);
+        expect(fixture.getCommand("livesync-abortsync").checkCallback?.(true)).toBe(false);
+
+        fixture.settings.useAdvancedMode = true;
+        expect(fixture.getCommand("livesync-scan-files").checkCallback?.(true)).toBe(true);
+        expect(fixture.getCommand("livesync-abortsync").checkCallback?.(true)).toBe(true);
+    });
+
+    it("keeps active-file database information available and opens it in a copy dialogue", async () => {
+        const fixture = createFixture();
+
+        await fixture.module._everyOnloadStart();
+
+        const command = fixture.getCommand("livesync-dump");
+        expect(command.name).toBe("Copy database information for the active file");
+        expect(command.checkCallback?.(true)).toBe(true);
+
+        command.checkCallback?.(false);
+
+        await vi.waitFor(() => {
+            expect(fixture.services.UI.promptCopyToClipboard).toHaveBeenCalledOnce();
+        });
+        const [title, report] = fixture.services.UI.promptCopyToClipboard.mock.calls[0];
+        expect(title).toBe("Database information for note.md");
+        expect(report).toContain("note.md");
+        expect(report).toContain("2-current");
+        expect(report).toContain("h:private-chunk-id");
+        expect(report).toContain("1-chunk");
+        expect(fixture.core.localDatabase.getDBEntry).not.toHaveBeenCalled();
+    });
+
+    it("hides the active-file database report when no file is active", async () => {
+        const fixture = createFixture();
+        fixture.services.vault.getActiveFilePath.mockReturnValue(null);
+
+        await fixture.module._everyOnloadStart();
+
+        expect(fixture.getCommand("livesync-dump").checkCallback?.(true)).toBe(false);
+    });
+});

src/modules/essential/ModuleMigration.ts

@@ -1,4 +1,9 @@
-import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, Logger } from "@lib/common/logger.ts";
+import {
+    LOG_LEVEL_INFO,
+    LOG_LEVEL_NOTICE,
+    LOG_LEVEL_VERBOSE,
+    Logger,
+} from "@vrtmrz/livesync-commonlib/compat/common/logger";
 import {
     EVENT_REQUEST_OPEN_P2P,
     EVENT_REQUEST_OPEN_SETTING_WIZARD,
@@ -8,14 +13,24 @@ import {
     eventHub,
 } from "@/common/events.ts";
 import { AbstractModule } from "@/modules/AbstractModule.ts";
-import { $msg } from "@lib/common/i18n.ts";
-import { performDoctorConsultation, RebuildOptions } from "@lib/common/configForDoc.ts";
+import { $msg } from "@/common/translation";
+import { performDoctorConsultation, RebuildOptions } from "@vrtmrz/livesync-commonlib/compat/common/configForDoc";
 import { isValidPath } from "@/common/utils.ts";
-import { isMetaEntry } from "@lib/common/types.ts";
-import { isDeletedEntry, isDocContentSame, isLoadedEntry, readAsBlob } from "@lib/common/utils.ts";
-import { countCompromisedChunks } from "@lib/pouchdb/negotiation.ts";
+import { isMetaEntry } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import {
+    isDeletedEntry,
+    isDocContentSame,
+    isLoadedEntry,
+    readAsBlob,
+} from "@vrtmrz/livesync-commonlib/compat/common/utils";
+import { countCompromisedChunks } from "@vrtmrz/livesync-commonlib/compat/pouchdb/negotiation";
 import type { LiveSyncCore } from "@/main.ts";
 import { SetupManager } from "@/modules/features/SetupManager.ts";
+import { showOnboardingInvitation } from "@/serviceFeatures/setupObsidian/setupManagerHandlers.ts";
+import {
+    runConfiguredStartupLifecycle,
+    runStartupEntryLifecycle,
+} from "@/serviceFeatures/configuredStartupLifecycle.ts";
 
 type ErrorInfo = {
     path: string;
@@ -26,10 +41,22 @@ type ErrorInfo = {
     isConflicted?: boolean;
 };
 
-export class ModuleMigration extends AbstractModule {
+const INCOMPLETE_DOCUMENT_NOTICE_GROUP = "startup-integrity-check";
+
+export class ModuleMigration extends AbstractModule<LiveSyncCore> {
+    constructor(
+        core: LiveSyncCore,
+        private readonly waitForCompatibilityReview: () => Promise<void> = () => Promise.resolve()
+    ) {
+        super(core);
+    }
+
     async migrateUsingDoctor(skipRebuild: boolean = false, activateReason = "updated", forceRescan = false) {
         const { shouldRebuild, shouldRebuildLocal, isModified, settings } = await performDoctorConsultation(
-            this.core,
+            {
+                confirm: this.core.confirm,
+                translate: this.services.context.translate,
+            },
             this.settings,
             {
                 localRebuild: skipRebuild ? RebuildOptions.SkipEvenIfRequired : RebuildOptions.AutomaticAcceptable,
@@ -65,9 +92,9 @@ export class ModuleMigration extends AbstractModule {
         }
     }
 
-    async initialMessage() {
+    initialMessage() {
         const manager = this.core.getModule(SetupManager);
-        return await manager.startOnBoarding();
+        showOnboardingInvitation(this.core, manager);
         /*
         const message = $msg("moduleMigration.msgInitialSetup", {
             URI_DOC: $msg("moduleMigration.docUri"),
@@ -124,133 +151,152 @@ export class ModuleMigration extends AbstractModule {
             return Promise.resolve(true);
         }
 
-        this._log("Checking for incomplete documents...", LOG_LEVEL_NOTICE, "check-incomplete");
-
-        const errorFiles = [] as ErrorInfo[];
-        for await (const metaDoc of this.localDatabase.findAllNormalDocs({ conflicts: true })) {
-            const path = this.getPath(metaDoc);
-
-            if (!isValidPath(path)) {
-                continue;
-            }
-            if (!(await this.services.vault.isTargetFile(path))) {
-                continue;
-            }
-            if (!isMetaEntry(metaDoc)) {
-                continue;
-            }
-
-            const doc = await this.localDatabase.getDBEntryFromMeta(metaDoc);
-            if (!doc || !isLoadedEntry(doc)) {
-                continue;
-            }
-            if (isDeletedEntry(doc)) {
-                continue;
-            }
-            const isConflicted = metaDoc?._conflicts && metaDoc._conflicts.length > 0;
-
-            let storageFileContent;
-            try {
-                storageFileContent = await this.core.storageAccess.readHiddenFileBinary(path);
-            } catch (e) {
-                Logger(`Failed to read file ${path}: Possibly unprocessed or missing`);
-                Logger(e, LOG_LEVEL_VERBOSE);
-                continue;
-            }
-            // const storageFileBlob = createBlob(storageFileContent);
-            const sizeOnStorage = storageFileContent.byteLength;
-            const recordedSize = doc.size;
-            const docBlob = readAsBlob(doc);
-            const actualSize = docBlob.size;
-            if (
-                recordedSize !== actualSize ||
-                sizeOnStorage !== actualSize ||
-                sizeOnStorage !== recordedSize ||
-                isConflicted
-            ) {
-                const contentMatched = await isDocContentSame(doc.data, storageFileContent);
-                errorFiles.push({
-                    path,
-                    recordedSize,
-                    actualSize,
-                    storageSize: sizeOnStorage,
-                    contentMatched,
-                    isConflicted,
-                });
-                Logger(
-                    `Size mismatch for ${path}: ${recordedSize} (DB Recorded) , ${actualSize} (DB Stored) , ${sizeOnStorage} (Storage Stored), ${contentMatched ? "Content Matched" : "Content Mismatched"} ${isConflicted ? "Conflicted" : "Not Conflicted"}`
-                );
-            }
-        }
-        if (errorFiles.length == 0) {
-            Logger("No size mismatches found", LOG_LEVEL_NOTICE);
-            await this.core.kvDB.set("checkIncompleteDocs", true);
-            return Promise.resolve(true);
-        }
-        Logger(`Found ${errorFiles.length} size mismatches`, LOG_LEVEL_NOTICE);
-        // We have to repair them following rules and situations:
-        // A. DB Recorded != DB Stored
-        //   A.1. DB Recorded == Storage Stored
-        //        Possibly recoverable from storage. Just overwrite the DB content with storage content.
-        //   A.2. Neither
-        //        Probably it cannot be resolved on this device. Even if the storage content is larger than DB Recorded, it possibly corrupted.
-        //        We do not fix it automatically. Leave it as is. Possibly other device can do this.
-        // B. DB Recorded == DB Stored ,  < Storage Stored
-        //   Very fragile, if DB Recorded size is less than Storage Stored size, we possibly repair the content (The issue was `unexpectedly shortened file`).
-        //   We do not fix it automatically, but it will be automatically overwritten in other process.
-        // C. DB Recorded == DB Stored ,  > Storage Stored
-        //   Probably restored by the user by resolving A or B on other device, We should overwrite the storage
-        //   Also do not fix it automatically. It should be overwritten by replication.
-        const recoverable = errorFiles.filter((e) => {
-            return e.recordedSize === e.storageSize && !e.isConflicted;
+        const noticeGroups = this.core.services.context.noticeGroups;
+        noticeGroups.setItem(INCOMPLETE_DOCUMENT_NOTICE_GROUP, "checking", {
+            message: "Checking for incomplete documents...",
         });
-        const unrecoverable = errorFiles.filter((e) => {
-            return e.recordedSize !== e.storageSize || e.isConflicted;
-        });
-        const fileInfo = (e: (typeof errorFiles)[0]) => {
-            return `${e.path} (M: ${e.recordedSize}, A: ${e.actualSize}, S: ${e.storageSize}) ${e.isConflicted ? "(Conflicted)" : ""}`;
-        };
-        const messageUnrecoverable =
-            unrecoverable.length > 0
-                ? $msg("moduleMigration.fix0256.messageUnrecoverable", {
-                      filesNotRecoverable: unrecoverable.map((e) => `- ${fileInfo(e)}`).join("\n"),
-                  })
-                : "";
+        this._log("Checking for incomplete documents...", LOG_LEVEL_VERBOSE);
 
-        const message = $msg("moduleMigration.fix0256.message", {
-            files: recoverable.map((e) => `- ${fileInfo(e)}`).join("\n"),
-            messageUnrecoverable,
-        });
-        const CHECK_IT_LATER = $msg("moduleMigration.fix0256.buttons.checkItLater");
-        const FIX = $msg("moduleMigration.fix0256.buttons.fix");
-        const DISMISS = $msg("moduleMigration.fix0256.buttons.DismissForever");
-        const ret = await this.core.confirm.askSelectStringDialogue(message, [CHECK_IT_LATER, FIX, DISMISS], {
-            title: $msg("moduleMigration.fix0256.title"),
-            defaultAction: CHECK_IT_LATER,
-        });
-        if (ret == FIX) {
-            for (const file of recoverable) {
-                // Overwrite the database with the files on the storage
-                const stubFile = await this.core.storageAccess.getFileStub(file.path);
-                if (stubFile == null) {
-                    Logger(`Could not find stub file for ${file.path}`, LOG_LEVEL_NOTICE);
+        try {
+            const errorFiles = [] as ErrorInfo[];
+            for await (const metaDoc of this.localDatabase.findAllNormalDocs({ conflicts: true })) {
+                const path = this.getPath(metaDoc);
+
+                if (!isValidPath(path)) {
+                    continue;
+                }
+                if (!(await this.services.vault.isTargetFile(path))) {
+                    continue;
+                }
+                if (!isMetaEntry(metaDoc)) {
                     continue;
                 }
 
-                stubFile.stat.mtime = Date.now();
-                const result = await this.core.fileHandler.storeFileToDB(stubFile, true, false);
-                if (result) {
-                    Logger(`Successfully restored ${file.path} from storage`);
-                } else {
-                    Logger(`Failed to restore ${file.path} from storage`, LOG_LEVEL_NOTICE);
+                const doc = await this.localDatabase.getDBEntryFromMeta(metaDoc);
+                if (!doc || !isLoadedEntry(doc)) {
+                    continue;
+                }
+                if (isDeletedEntry(doc)) {
+                    continue;
+                }
+                const isConflicted = metaDoc?._conflicts && metaDoc._conflicts.length > 0;
+
+                let storageFileContent;
+                try {
+                    storageFileContent = await this.core.storageAccess.readHiddenFileBinary(path);
+                } catch (e) {
+                    Logger(`Failed to read file ${path}: Possibly unprocessed or missing`);
+                    Logger(e, LOG_LEVEL_VERBOSE);
+                    continue;
+                }
+                // const storageFileBlob = createBlob(storageFileContent);
+                const sizeOnStorage = storageFileContent.byteLength;
+                const recordedSize = doc.size;
+                const docBlob = readAsBlob(doc);
+                const actualSize = docBlob.size;
+                if (
+                    recordedSize !== actualSize ||
+                    sizeOnStorage !== actualSize ||
+                    sizeOnStorage !== recordedSize ||
+                    isConflicted
+                ) {
+                    const contentMatched = await isDocContentSame(doc.data, storageFileContent);
+                    errorFiles.push({
+                        path,
+                        recordedSize,
+                        actualSize,
+                        storageSize: sizeOnStorage,
+                        contentMatched,
+                        isConflicted,
+                    });
+                    Logger(
+                        `Size mismatch for ${path}: ${recordedSize} (DB Recorded) , ${actualSize} (DB Stored) , ${sizeOnStorage} (Storage Stored), ${contentMatched ? "Content Matched" : "Content Mismatched"} ${isConflicted ? "Conflicted" : "Not Conflicted"}`
+                    );
                 }
             }
-        } else if (ret === DISMISS) {
-            // User chose to dismiss the issue
-            await this.core.kvDB.set("checkIncompleteDocs", true);
-        }
+            if (errorFiles.length == 0) {
+                Logger("No size mismatches found", LOG_LEVEL_INFO);
+                noticeGroups.setItem(INCOMPLETE_DOCUMENT_NOTICE_GROUP, "result", {
+                    message: "No size mismatches found",
+                });
+                await this.core.kvDB.set("checkIncompleteDocs", true);
+                return Promise.resolve(true);
+            }
+            Logger(`Found ${errorFiles.length} size mismatches`, LOG_LEVEL_INFO);
+            noticeGroups.setItem(INCOMPLETE_DOCUMENT_NOTICE_GROUP, "result", {
+                message: `Found ${errorFiles.length} size mismatches`,
+            });
+            // We have to repair them following rules and situations:
+            // A. DB Recorded != DB Stored
+            //   A.1. DB Recorded == Storage Stored
+            //        Possibly recoverable from storage. Just overwrite the DB content with storage content.
+            //   A.2. Neither
+            //        Probably it cannot be resolved on this device. Even if the storage content is larger than DB Recorded, it possibly corrupted.
+            //        We do not fix it automatically. Leave it as is. Possibly other device can do this.
+            // B. DB Recorded == DB Stored ,  < Storage Stored
+            //   Very fragile, if DB Recorded size is less than Storage Stored size, we possibly repair the content (The issue was `unexpectedly shortened file`).
+            //   We do not fix it automatically, but it will be automatically overwritten in other process.
+            // C. DB Recorded == DB Stored ,  > Storage Stored
+            //   Probably restored by the user by resolving A or B on other device, We should overwrite the storage
+            //   Also do not fix it automatically. It should be overwritten by replication.
+            const recoverable = errorFiles.filter((e) => {
+                return e.recordedSize === e.storageSize && !e.isConflicted;
+            });
+            const unrecoverable = errorFiles.filter((e) => {
+                return e.recordedSize !== e.storageSize || e.isConflicted;
+            });
+            const fileInfo = (e: (typeof errorFiles)[0]) => {
+                return `${e.path} (M: ${e.recordedSize}, A: ${e.actualSize}, S: ${e.storageSize}) ${e.isConflicted ? "(Conflicted)" : ""}`;
+            };
+            const messageUnrecoverable =
+                unrecoverable.length > 0
+                    ? $msg("moduleMigration.fix0256.messageUnrecoverable", {
+                          filesNotRecoverable: unrecoverable.map((e) => `- ${fileInfo(e)}`).join("\n"),
+                      })
+                    : "";
 
-        return Promise.resolve(true);
+            const message = $msg("moduleMigration.fix0256.message", {
+                files: recoverable.map((e) => `- ${fileInfo(e)}`).join("\n"),
+                messageUnrecoverable,
+            });
+            const CHECK_IT_LATER = $msg("moduleMigration.fix0256.buttons.checkItLater");
+            const FIX = $msg("moduleMigration.fix0256.buttons.fix");
+            const DISMISS = $msg("moduleMigration.fix0256.buttons.DismissForever");
+            const ret = await this.core.confirm.askSelectStringDialogue(message, [CHECK_IT_LATER, FIX, DISMISS], {
+                title: $msg("moduleMigration.fix0256.title"),
+                defaultAction: CHECK_IT_LATER,
+            });
+            if (ret == FIX) {
+                for (const file of recoverable) {
+                    // Overwrite the database with the files on the storage
+                    const stubFile = await this.core.storageAccess.getFileStub(file.path);
+                    if (stubFile == null) {
+                        Logger(`Could not find stub file for ${file.path}`, LOG_LEVEL_NOTICE);
+                        continue;
+                    }
+
+                    stubFile.stat.mtime = Date.now();
+                    const result = await this.core.fileHandler.storeFileToDB(stubFile, true, false);
+                    if (result) {
+                        Logger(`Successfully restored ${file.path} from storage`);
+                    } else {
+                        Logger(`Failed to restore ${file.path} from storage`, LOG_LEVEL_NOTICE);
+                    }
+                }
+            } else if (ret === DISMISS) {
+                // User chose to dismiss the issue
+                await this.core.kvDB.set("checkIncompleteDocs", true);
+            }
+
+            return Promise.resolve(true);
+        } catch (error) {
+            noticeGroups.setItem(INCOMPLETE_DOCUMENT_NOTICE_GROUP, "result", {
+                message: "The incomplete document check could not be completed.",
+            });
+            throw error;
+        } finally {
+            noticeGroups.finish(INCOMPLETE_DOCUMENT_NOTICE_GROUP);
+        }
     }
 
     async hasCompromisedChunks(): Promise<boolean> {
@@ -310,39 +356,22 @@ export class ModuleMigration extends AbstractModule {
     }
 
     async _everyOnFirstInitialize(): Promise<boolean> {
-        if (!this.localDatabase.isReady) {
-            this._log($msg("moduleMigration.logLocalDatabaseNotReady"), LOG_LEVEL_NOTICE);
-            return false;
-        }
-        if (this.settings.isConfigured) {
-            if (!(await this.hasCompromisedChunks())) {
-                return false;
-            }
-            if (!(await this.hasIncompleteDocs())) {
-                return false;
-            }
-            if (!(await this.migrateUsingDoctor(false))) {
-                return false;
-            }
-            // await this.migrationCheck();
-            await this.migrateDisableBulkSend();
-        }
-        if (!this.settings.isConfigured) {
-            // if (!(await this.initialMessage()) || !(await this.askAgainForSetupURI())) {
-            //     this._log($msg("moduleMigration.logSetupCancelled"), LOG_LEVEL_NOTICE);
-            //     return false;
-            // }
-            if (!(await this.initialMessage())) {
-                this._log($msg("moduleMigration.logSetupCancelled"), LOG_LEVEL_NOTICE);
-                return false;
-            }
-            if (!(await this.migrateUsingDoctor(true))) {
-                return false;
-            }
-        }
-        return true;
+        return await runConfiguredStartupLifecycle({
+            databaseReady: this.localDatabase.isReady,
+            reportDatabaseNotReady: () => this._log($msg("moduleMigration.logLocalDatabaseNotReady"), LOG_LEVEL_NOTICE),
+            hasCompromisedChunks: () => this.hasCompromisedChunks(),
+            hasIncompleteDocuments: () => this.hasIncompleteDocs(),
+            waitForCompatibilityReview: () => this.waitForCompatibilityReview(),
+            runDoctor: () => this.migrateUsingDoctor(false),
+            migrateBulkSend: () => this.migrateDisableBulkSend(),
+        });
     }
     _everyOnLayoutReady(): Promise<boolean> {
+        const shouldInitialiseDatabase = runStartupEntryLifecycle({
+            configured: this.settings.isConfigured === true,
+            inviteToOnboarding: () => this.initialMessage(),
+        });
+        if (!shouldInitialiseDatabase) return Promise.resolve(false);
         eventHub.onEvent(EVENT_REQUEST_RUN_DOCTOR, async (reason) => {
             await this.migrateUsingDoctor(false, reason, true);
         });

src/modules/essential/ModuleMigration.unit.spec.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@/modules/features/SetupManager.ts", () => ({
+    SetupManager: class SetupManager {},
+}));
+vi.mock("@/deps.ts", () => ({}));
+vi.mock("@/common/utils.ts", () => ({
+    isValidPath: () => true,
+}));
+
+import { ModuleMigration } from "./ModuleMigration.ts";
+
+async function* noDocuments() {
+    return;
+}
+
+async function* failedDocumentScan() {
+    throw new Error("scan failed");
+}
+
+function createMigration(findAllNormalDocs: typeof noDocuments | typeof failedDocumentScan = noDocuments) {
+    const noticeGroups = {
+        setItem: vi.fn(),
+        finish: vi.fn(() => true),
+    };
+    const services = {
+        API: {
+            addLog: vi.fn(),
+            addCommand: vi.fn(),
+            registerWindow: vi.fn(),
+            addRibbonIcon: vi.fn(),
+            registerProtocolHandler: vi.fn(),
+        },
+        context: { noticeGroups },
+        vault: { isTargetFile: vi.fn(async () => true) },
+        path: { getPath: vi.fn() },
+    };
+    const core = {
+        _services: services,
+        services,
+        kvDB: {
+            get: vi.fn(async () => false),
+            set: vi.fn(async () => undefined),
+        },
+        localDatabase: { findAllNormalDocs },
+        storageAccess: {},
+    };
+    return {
+        migration: new ModuleMigration(core as never),
+        noticeGroups,
+    };
+}
+
+describe("ModuleMigration incomplete-document notice", () => {
+    it("keeps the check and its result in one persistent named group", async () => {
+        const { migration, noticeGroups } = createMigration();
+
+        await expect(migration.hasIncompleteDocs()).resolves.toBe(true);
+
+        expect(noticeGroups.setItem).toHaveBeenNthCalledWith(1, "startup-integrity-check", "checking", {
+            message: "Checking for incomplete documents...",
+        });
+        expect(noticeGroups.setItem).toHaveBeenNthCalledWith(2, "startup-integrity-check", "result", {
+            message: "No size mismatches found",
+        });
+        expect(noticeGroups.finish).toHaveBeenCalledWith("startup-integrity-check");
+    });
+
+    it("finishes the group with a failure result when the scan throws", async () => {
+        const { migration, noticeGroups } = createMigration(failedDocumentScan);
+
+        await expect(migration.hasIncompleteDocs()).rejects.toThrow("scan failed");
+
+        expect(noticeGroups.setItem).toHaveBeenLastCalledWith("startup-integrity-check", "result", {
+            message: "The incomplete document check could not be completed.",
+        });
+        expect(noticeGroups.finish).toHaveBeenCalledWith("startup-integrity-check");
+    });
+});

src/modules/essentialObsidian/APILib/ObsHttpHandler.ts

@@ -7,7 +7,7 @@ import { FetchHttpHandler, type FetchHttpHandlerOptions } from "@smithy/fetch-ht
 import { HttpRequest, HttpResponse, type HttpHandlerOptions } from "@smithy/protocol-http";
 import { buildQueryString } from "@smithy/querystring-builder";
 import { requestUrl, type RequestUrlParam } from "@/deps.ts";
-import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
+import { compatGlobal } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
 
 ////////////////////////////////////////////////////////////////////////////////
 // special handler using Obsidian requestUrl
@@ -25,6 +25,19 @@ function requestTimeout(timeoutInMs: number = 0): Promise<never> {
     });
 }
 
+function normaliseRequestBody(body: unknown): string | ArrayBuffer | undefined {
+    if (body === undefined) return undefined;
+    if (typeof body === "string" || body instanceof ArrayBuffer) return body;
+    if (ArrayBuffer.isView(body)) {
+        if (body.buffer instanceof ArrayBuffer && body.byteOffset === 0 && body.byteLength === body.buffer.byteLength) {
+            return body.buffer;
+        }
+        return new Uint8Array(body.buffer, body.byteOffset, body.byteLength).slice().buffer;
+    }
+    const bodyType = Object.prototype.toString.call(body).slice(8, -1);
+    throw new TypeError(`Obsidian requestUrl does not support the request body type ${bodyType}`);
+}
+
 /**
  * This is close to origin implementation of FetchHttpHandler
  * https://github.com/aws/aws-sdk-js-v3/blob/main/packages/fetch-http-handler/src/fetch-http-handler.ts
@@ -64,7 +77,7 @@ export class ObsHttpHandler extends FetchHttpHandler {
             urlObj.host = this.reverseProxyNoSignUrl;
             url = urlObj.href;
         }
-        const body = method === "GET" || method === "HEAD" ? undefined : request.body;
+        const body: unknown = method === "GET" || method === "HEAD" ? undefined : request.body;
 
         const transformedHeaders: Record<string, string> = {};
         for (const key of Object.keys(request.headers)) {
@@ -80,10 +93,7 @@ export class ObsHttpHandler extends FetchHttpHandler {
             contentType = transformedHeaders["content-type"];
         }
 
-        let transformedBody = body;
-        if (ArrayBuffer.isView(body)) {
-            transformedBody = new Uint8Array(body.buffer).buffer;
-        }
+        const transformedBody = normaliseRequestBody(body);
 
         const param: RequestUrlParam = {
             body: transformedBody,

src/modules/essentialObsidian/APILib/ObsHttpHandler.unit.spec.ts

@@ -0,0 +1,60 @@
+import { HttpRequest } from "@smithy/protocol-http";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const requestUrlMock = vi.hoisted(() =>
+    vi.fn<
+        (param: { body?: string | ArrayBuffer }) => Promise<{
+            headers: Record<string, string>;
+            status: number;
+            arrayBuffer: ArrayBuffer;
+        }>
+    >()
+);
+
+vi.mock("@/deps.ts", () => ({
+    requestUrl: requestUrlMock,
+}));
+
+import { ObsHttpHandler } from "./ObsHttpHandler.ts";
+
+function requestWithBody(body: unknown) {
+    return new HttpRequest({
+        protocol: "https:",
+        hostname: "objects.example.com",
+        method: "PUT",
+        path: "/bucket/object",
+        headers: {},
+        body,
+    });
+}
+
+describe("ObsHttpHandler request bodies", () => {
+    beforeEach(() => {
+        requestUrlMock.mockReset();
+        requestUrlMock.mockResolvedValue({
+            headers: {},
+            status: 200,
+            arrayBuffer: new ArrayBuffer(0),
+        });
+    });
+
+    it("sends only the bytes addressed by an ArrayBuffer view", async () => {
+        const body = new Uint8Array([0, 1, 2, 3]).subarray(1, 3);
+
+        await new ObsHttpHandler().handle(requestWithBody(body));
+
+        expect(requestUrlMock).toHaveBeenCalledOnce();
+        const transmittedBody = requestUrlMock.mock.calls[0][0].body;
+        expect(transmittedBody).toBeInstanceOf(ArrayBuffer);
+        expect([...new Uint8Array(transmittedBody as ArrayBuffer)]).toEqual([1, 2]);
+    });
+
+    it("rejects an unsupported body instead of dispatching an empty request", async () => {
+        const body = new ReadableStream<Uint8Array>();
+
+        await expect(new ObsHttpHandler().handle(requestWithBody(body))).rejects.toThrow(
+            "Obsidian requestUrl does not support the request body type ReadableStream"
+        );
+        expect(requestUrlMock).not.toHaveBeenCalled();
+    });
+});

src/modules/essentialObsidian/ModuleObsidianEvents.ts

@@ -4,16 +4,33 @@ import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/log
 import { scheduleTask } from "octagonal-wheels/concurrency/task";
 import type { TFile } from "@/deps.ts";
 import { fireAndForget } from "octagonal-wheels/promises";
-import { type FilePathWithPrefix } from "@lib/common/types.ts";
+import { type FilePathWithPrefix } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { reactive, reactiveSource, type ReactiveSource } from "octagonal-wheels/dataobject/reactive";
 import {
     collectingChunks,
     pluginScanningCount,
     hiddenFilesEventCount,
     hiddenFilesProcessingCount,
-} from "@lib/mock_and_interop/stores.ts";
+} from "@vrtmrz/livesync-commonlib/compat/mock_and_interop/stores";
 import type { LiveSyncCore } from "@/main.ts";
-import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
+import { compatGlobal } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
+
+type MutableCommandDefinition = {
+    callback?: () => void;
+};
+
+type InternalCommandRegistry = {
+    commands?: Record<string, MutableCommandDefinition | undefined>;
+    executeCommandById(commandId: string): unknown;
+};
+
+type AppWithInternalCommands = {
+    commands?: InternalCommandRegistry;
+};
+
+type CodeMirrorAdapter = {
+    commands: { save: () => void };
+};
 
 export class ModuleObsidianEvents extends AbstractObsidianModule {
     _everyOnloadStart(): Promise<boolean> {
@@ -40,10 +57,10 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
 
     swapSaveCommand() {
         this._log("Modifying callback of the save command", LOG_LEVEL_VERBOSE);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Editor Tweaking
-        const saveCommandDefinition = (this.app as any).commands?.commands?.["editor:save-file"];
+        const commandRegistry = (this.app as unknown as AppWithInternalCommands).commands;
+        const saveCommandDefinition = commandRegistry?.commands?.["editor:save-file"];
         const save = saveCommandDefinition?.callback;
-        if (typeof save === "function") {
+        if (saveCommandDefinition && typeof save === "function") {
             this.initialCallback = save;
             saveCommandDefinition.callback = () => {
                 scheduleTask("syncOnEditorSave", 250, () => {
@@ -61,17 +78,14 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
                 save();
             };
         }
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const _this = this;
-        //@ts-ignore
-        if (!compatGlobal.CodeMirrorAdapter) {
+        const codeMirrorAdapter = (compatGlobal as typeof compatGlobal & { CodeMirrorAdapter?: CodeMirrorAdapter })
+            .CodeMirrorAdapter;
+        if (!codeMirrorAdapter) {
             this._log("CodeMirrorAdapter is not available");
             return;
         }
-        //@ts-ignore
-        compatGlobal.CodeMirrorAdapter.commands.save = () => {
-            //@ts-ignore
-            void _this.app.commands.executeCommandById("editor:save-file");
+        codeMirrorAdapter.commands.save = () => {
+            void commandRegistry?.executeCommandById("editor:save-file");
             // _this.app.performCommand('editor:save-file');
         };
     }
@@ -82,23 +96,71 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
         this.watchWorkspaceOpen = this.watchWorkspaceOpen.bind(this);
         this.watchOnline = this.watchOnline.bind(this);
         // Already bound
-        // eslint-disable-next-line @typescript-eslint/unbound-method
+        // eslint-disable-next-line @typescript-eslint/unbound-method -- The handler is bound above before registration.
         this.plugin.registerEvent(this.app.workspace.on("file-open", this.watchWorkspaceOpen));
         // Already bound
-        // eslint-disable-next-line @typescript-eslint/unbound-method
+        // eslint-disable-next-line @typescript-eslint/unbound-method -- The handler is bound above before registration.
         this.plugin.registerDomEvent(activeDocument, "visibilitychange", this.watchWindowVisibility);
         this.plugin.registerDomEvent(compatGlobal, "focus", () => this.setHasFocus(true));
         this.plugin.registerDomEvent(compatGlobal, "blur", () => this.setHasFocus(false));
         // Already bound
-        // eslint-disable-next-line @typescript-eslint/unbound-method
+        // eslint-disable-next-line @typescript-eslint/unbound-method -- The handler is bound above before registration.
         this.plugin.registerDomEvent(compatGlobal, "online", this.watchOnline);
         // Already bound
-        // eslint-disable-next-line @typescript-eslint/unbound-method
+        // eslint-disable-next-line @typescript-eslint/unbound-method -- The handler is bound above before registration.
         this.plugin.registerDomEvent(compatGlobal, "offline", this.watchOnline);
     }
 
     hasFocus = true;
     isLastHidden = false;
+    private boundedRemoteActivityEndHandler?: (value: { readonly value: number }) => unknown;
+    private deferredBoundedLifecycle?: "suspend-if-hidden" | "restart-continuous-if-visible";
+
+    private keepReplicationActiveInBackground() {
+        return (
+            this.settings.keepReplicationActiveInBackground &&
+            (this.settings.liveSync || this.settings.periodicReplication) &&
+            !this.services.API.isMobile()
+        );
+    }
+
+    private async applyDeferredBoundedActivityLifecycle() {
+        const count = this.services.replicator.boundedRemoteActivityCount;
+        if (count.value !== 0) {
+            this.deferLifecycleUntilBoundedRemoteActivityEnds();
+            return;
+        }
+        const deferredLifecycle = this.deferredBoundedLifecycle;
+        this.deferredBoundedLifecycle = undefined;
+        const keepActiveInBackground = this.keepReplicationActiveInBackground();
+        if (deferredLifecycle === "suspend-if-hidden" && activeWindow.document.hidden) {
+            if (!keepActiveInBackground) await this.services.appLifecycle.onSuspending();
+            return;
+        }
+        if (
+            deferredLifecycle === "restart-continuous-if-visible" &&
+            !activeWindow.document.hidden &&
+            keepActiveInBackground &&
+            this.settings.liveSync
+        ) {
+            await this.services.appLifecycle.onSuspending();
+            await this.services.appLifecycle.onResuming();
+            await this.services.appLifecycle.onResumed();
+        }
+    }
+
+    private deferLifecycleUntilBoundedRemoteActivityEnds() {
+        if (this.boundedRemoteActivityEndHandler) return;
+        const count = this.services.replicator.boundedRemoteActivityCount;
+        const handler = (value: { readonly value: number }) => {
+            if (value.value !== 0) return;
+            count.offChanged(handler);
+            this.boundedRemoteActivityEndHandler = undefined;
+            fireAndForget(() => this.applyDeferredBoundedActivityLifecycle());
+        };
+        this.boundedRemoteActivityEndHandler = handler;
+        count.onChanged(handler);
+    }
 
     setHasFocus(hasFocus: boolean) {
         this.hasFocus = hasFocus;
@@ -122,7 +184,19 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
     }
 
     async watchWindowVisibilityAsync() {
-        if (this.settings.suspendFileWatching) return;
+        if (this.settings.suspendFileWatching) {
+            if (
+                this.settings.isConfigured &&
+                this.services.appLifecycle.isReady() &&
+                this.services.replicator.boundedRemoteActivityCount.value > 0
+            ) {
+                const isHidden = activeWindow.document.hidden;
+                this.isLastHidden = isHidden;
+                this.deferredBoundedLifecycle = isHidden ? "suspend-if-hidden" : undefined;
+                this.deferLifecycleUntilBoundedRemoteActivityEnds();
+            }
+            return;
+        }
         if (!this.settings.isConfigured) return;
         if (!this.services.appLifecycle.isReady()) return;
 
@@ -135,6 +209,13 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
         if (this.isLastHidden === isHidden) {
             return;
         }
+
+        const boundedRemoteActivityInProgress = this.services.replicator.boundedRemoteActivityCount.value > 0;
+        if (!isHidden && boundedRemoteActivityInProgress && this.deferredBoundedLifecycle === "suspend-if-hidden") {
+            this.isLastHidden = false;
+            this.deferredBoundedLifecycle = undefined;
+            return;
+        }
         this.isLastHidden = isHidden;
 
         await this.services.fileProcessing.commitPendingFileEvents();
@@ -144,16 +225,23 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
         // modes (LiveSync's continuous replication and Periodic's timer both stall otherwise);
         // becoming visible reopens normally, and for LiveSync additionally forces a teardown first
         // (see the resume branch) so a stalled continuous channel is always replaced.
-        const keepActiveInBackground =
-            this.settings.keepReplicationActiveInBackground &&
-            (this.settings.liveSync || this.settings.periodicReplication) &&
-            !this.services.API.isMobile();
+        const keepActiveInBackground = this.keepReplicationActiveInBackground();
 
         if (isHidden) {
-            if (!keepActiveInBackground) await this.services.appLifecycle.onSuspending();
+            if (boundedRemoteActivityInProgress && !keepActiveInBackground) {
+                this.deferredBoundedLifecycle = "suspend-if-hidden";
+                this.deferLifecycleUntilBoundedRemoteActivityEnds();
+            } else if (!keepActiveInBackground) {
+                await this.services.appLifecycle.onSuspending();
+            }
         } else {
             // suspend all temporary.
             if (this.services.appLifecycle.isSuspended()) return;
+            if (boundedRemoteActivityInProgress && keepActiveInBackground && this.settings.liveSync) {
+                this.deferredBoundedLifecycle = "restart-continuous-if-visible";
+                this.deferLifecycleUntilBoundedRemoteActivityEnds();
+                return;
+            }
             // Only the continuous (LiveSync) channel can go stalled-but-not-terminated: PouchDB
             // emits paused/retry while the replicator keeps its AbortController set, so the reopen
             // below would no-op on exactly the channel that needs replacing. Force a teardown first
@@ -243,7 +331,7 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
                 // const proc = this.core.processingFileEventCount.value;
                 const e = 0;
                 const proc = 0;
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Reading the tick establishes the reactive polling dependency.
                 const __ = __tick.value;
                 return (
                     dbCount +

src/modules/essentialObsidian/ModuleObsidianEvents.unit.spec.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi, afterEach } from "vitest";
 
 import { ModuleObsidianEvents } from "./ModuleObsidianEvents";
-import { DEFAULT_SETTINGS, REMOTE_COUCHDB } from "@lib/common/types";
+import { DEFAULT_SETTINGS, REMOTE_COUCHDB } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { reactiveSource } from "octagonal-wheels/dataobject/reactive";
 
 type SetupOptions = {
     settings?: Partial<typeof DEFAULT_SETTINGS>;
@@ -22,6 +23,7 @@ function setup(opts: SetupOptions) {
         onResumed: vi.fn(async () => true),
     };
     const fileProcessing = { commitPendingFileEvents: vi.fn(async () => true) };
+    const boundedRemoteActivityCount = reactiveSource(0);
 
     const core = {
         _services: {
@@ -36,6 +38,7 @@ function setup(opts: SetupOptions) {
             setting: { saveSettingData: vi.fn(async () => undefined) },
             appLifecycle,
             fileProcessing,
+            replicator: { boundedRemoteActivityCount },
         },
         settings: {
             ...DEFAULT_SETTINGS,
@@ -53,7 +56,7 @@ function setup(opts: SetupOptions) {
     // The handler reads `activeWindow.document.hidden`.
     (globalThis as any).activeWindow = { document: { hidden: opts.hidden } };
 
-    return { module, appLifecycle, fileProcessing };
+    return { module, appLifecycle, fileProcessing, boundedRemoteActivityCount };
 }
 
 describe("watchWindowVisibilityAsync — keepReplicationActiveInBackground", () => {
@@ -81,6 +84,106 @@ describe("watchWindowVisibilityAsync — keepReplicationActiveInBackground", ()
         expect(appLifecycle.onSuspending).toHaveBeenCalledTimes(1);
     });
 
+    it("defers desktop suspension while bounded remote activity is running", async () => {
+        const { module, appLifecycle, boundedRemoteActivityCount } = setup({
+            settings: { keepReplicationActiveInBackground: false, liveSync: false },
+            hidden: true,
+        });
+        boundedRemoteActivityCount.value = 1;
+
+        await module.watchWindowVisibilityAsync();
+
+        expect(appLifecycle.onSuspending).not.toHaveBeenCalled();
+    });
+
+    it("suspends a hidden desktop window after the final bounded remote activity ends", async () => {
+        const { module, appLifecycle, boundedRemoteActivityCount } = setup({
+            settings: { keepReplicationActiveInBackground: false, liveSync: false },
+            hidden: true,
+        });
+        boundedRemoteActivityCount.value = 1;
+        await module.watchWindowVisibilityAsync();
+
+        boundedRemoteActivityCount.value = 0;
+
+        await vi.waitFor(() => expect(appLifecycle.onSuspending).toHaveBeenCalledTimes(1));
+    });
+
+    it("defers mobile suspension while bounded remote activity is running", async () => {
+        const { module, appLifecycle, boundedRemoteActivityCount } = setup({
+            settings: { keepReplicationActiveInBackground: false, liveSync: false },
+            hidden: true,
+            isMobile: true,
+        });
+        boundedRemoteActivityCount.value = 1;
+
+        await module.watchWindowVisibilityAsync();
+
+        expect(appLifecycle.onSuspending).not.toHaveBeenCalled();
+
+        boundedRemoteActivityCount.value = 0;
+
+        await vi.waitFor(() => expect(appLifecycle.onSuspending).toHaveBeenCalledTimes(1));
+    });
+
+    it("records deferred suspension while rebuild file watching is suspended", async () => {
+        const { module, appLifecycle, boundedRemoteActivityCount, fileProcessing } = setup({
+            settings: { suspendFileWatching: true },
+            hidden: true,
+        });
+        boundedRemoteActivityCount.value = 1;
+
+        await module.watchWindowVisibilityAsync();
+
+        expect(appLifecycle.onSuspending).not.toHaveBeenCalled();
+        expect(fileProcessing.commitPendingFileEvents).not.toHaveBeenCalled();
+
+        boundedRemoteActivityCount.value = 0;
+
+        await vi.waitFor(() => expect(appLifecycle.onSuspending).toHaveBeenCalledTimes(1));
+    });
+
+    it("resumes after a hidden rebuild finishes and the window becomes visible", async () => {
+        const { module, appLifecycle, boundedRemoteActivityCount } = setup({
+            settings: { suspendFileWatching: true },
+            hidden: true,
+        });
+        boundedRemoteActivityCount.value = 1;
+
+        await module.watchWindowVisibilityAsync();
+        boundedRemoteActivityCount.value = 0;
+        await vi.waitFor(() => expect(appLifecycle.onSuspending).toHaveBeenCalledTimes(1));
+
+        (module.settings as typeof DEFAULT_SETTINGS).suspendFileWatching = false;
+        (globalThis as any).activeWindow.document.hidden = false;
+        await module.watchWindowVisibilityAsync();
+
+        expect(appLifecycle.onResuming).toHaveBeenCalledTimes(1);
+        expect(appLifecycle.onResumed).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not resume when the window becomes visible before deferred suspension runs", async () => {
+        const { module, appLifecycle, boundedRemoteActivityCount } = setup({
+            settings: { keepReplicationActiveInBackground: false, liveSync: false },
+            hidden: true,
+        });
+        boundedRemoteActivityCount.value = 1;
+        await module.watchWindowVisibilityAsync();
+
+        (globalThis as any).activeWindow.document.hidden = false;
+        await module.watchWindowVisibilityAsync();
+
+        expect(appLifecycle.onSuspending).not.toHaveBeenCalled();
+        expect(appLifecycle.onResuming).not.toHaveBeenCalled();
+        expect(appLifecycle.onResumed).not.toHaveBeenCalled();
+
+        boundedRemoteActivityCount.value = 0;
+        await Promise.resolve();
+        expect(appLifecycle.onSuspending).not.toHaveBeenCalled();
+        expect(appLifecycle.onResuming).not.toHaveBeenCalled();
+        expect(appLifecycle.onResumed).not.toHaveBeenCalled();
+    });
+
     it("forces onSuspending before the resume on becoming visible when enabled (LiveSync teardown)", async () => {
         const { module, appLifecycle } = setup({
             settings: { keepReplicationActiveInBackground: true, liveSync: true },
@@ -99,6 +202,30 @@ describe("watchWindowVisibilityAsync — keepReplicationActiveInBackground", ()
         );
     });
 
+    it("defers the LiveSync teardown on becoming visible until bounded remote activity ends", async () => {
+        const { module, appLifecycle, boundedRemoteActivityCount } = setup({
+            settings: { keepReplicationActiveInBackground: true, liveSync: true },
+            hidden: false,
+            isLastHidden: true,
+        });
+        boundedRemoteActivityCount.value = 1;
+
+        await module.watchWindowVisibilityAsync();
+
+        expect(appLifecycle.onSuspending).not.toHaveBeenCalled();
+        expect(appLifecycle.onResuming).not.toHaveBeenCalled();
+        expect(appLifecycle.onResumed).not.toHaveBeenCalled();
+
+        boundedRemoteActivityCount.value = 0;
+
+        await vi.waitFor(() => expect(appLifecycle.onResumed).toHaveBeenCalledTimes(1));
+        expect(appLifecycle.onSuspending).toHaveBeenCalledTimes(1);
+        expect(appLifecycle.onResuming).toHaveBeenCalledTimes(1);
+        expect(appLifecycle.onSuspending.mock.invocationCallOrder[0]).toBeLessThan(
+            appLifecycle.onResuming.mock.invocationCallOrder[0]
+        );
+    });
+
     it("does not force a teardown on becoming visible by default (setting off)", async () => {
         const { module, appLifecycle } = setup({
             settings: { keepReplicationActiveInBackground: false, liveSync: true },

src/modules/essentialObsidian/ModuleObsidianMenu.ts

@@ -1,7 +1,5 @@
-import { type Editor, type MarkdownFileInfo, type MarkdownView } from "@/deps.ts";
 import { addIcon } from "@/deps.ts";
-import { type FilePathWithPrefix } from "@lib/common/types.ts";
-import { $msg } from "@lib/common/i18n.ts";
+import { $msg } from "@/common/translation";
 import type { LiveSyncCore } from "@/main.ts";
 import { AbstractModule } from "@/modules/AbstractModule.ts";
 // Obsidian specific menu commands.
@@ -22,16 +20,6 @@ export class ModuleObsidianMenu extends AbstractModule {
             await this.services.replication.replicate(true);
         }).addClass("livesync-ribbon-replicate");
 
-        this.addCommand({
-            id: "livesync-checkdoc-conflicted",
-            name: "Resolve if conflicted.",
-            editorCallback: (editor: Editor, view: MarkdownView | MarkdownFileInfo) => {
-                const file = view.file;
-                if (!file) return;
-                void this.services.conflict.queueCheckForIfOpen(file.path as FilePathWithPrefix);
-            },
-        });
-
         return Promise.resolve(true);
     }
 

src/modules/extras/ModuleDev.ts

@@ -1,11 +1,11 @@
 import { delay } from "octagonal-wheels/promises";
-import { __onMissingTranslation } from "@lib/common/i18n";
+import { __onMissingTranslation } from "@/common/translation";
 import { AbstractObsidianModule } from "@/modules/AbstractObsidianModule.ts";
 import { LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
 // import { enableTestFunction } from "./devUtil/testUtils.ts";
 import { TestPaneView, VIEW_TYPE_TEST } from "./devUtil/TestPaneView.ts";
 import { writable } from "svelte/store";
-import type { FilePathWithPrefix } from "@lib/common/types.ts";
+import type { FilePathWithPrefix } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import type { LiveSyncCore } from "@/main.ts";
 import type { WorkspaceLeaf } from "@/deps.ts";
 export class ModuleDev extends AbstractObsidianModule {
@@ -74,12 +74,13 @@ export class ModuleDev extends AbstractObsidianModule {
                 if (w) {
                     const id = await this.services.path.path2id(filename as FilePathWithPrefix);
                     const f = await this.core.localDatabase.getRaw(id);
-                    console.log(f);
-                    console.log(f._rev);
+                    this._log(f, LOG_LEVEL_VERBOSE);
+                    this._log(f._rev, LOG_LEVEL_VERBOSE);
                     const revConflict = f._rev.split("-")[0] + "-" + (parseInt(f._rev.split("-")[1]) + 1).toString();
-                    console.log(await this.core.localDatabase.bulkDocsRaw([f], { new_edits: false }));
-                    console.log(
-                        await this.core.localDatabase.bulkDocsRaw([{ ...f, _rev: revConflict }], { new_edits: false })
+                    this._log(await this.core.localDatabase.bulkDocsRaw([f], { new_edits: false }), LOG_LEVEL_VERBOSE);
+                    this._log(
+                        await this.core.localDatabase.bulkDocsRaw([{ ...f, _rev: revConflict }], { new_edits: false }),
+                        LOG_LEVEL_VERBOSE
                     );
                 }
             },

src/modules/extras/devUtil/tests.ts

@@ -34,8 +34,7 @@ async function measure(
     return [name, measures.get(name) as MeasureResult];
 }
 
-// eslint-disable-next-line require-await, @typescript-eslint/require-await
-async function formatPerfResults(items: NamedMeasureResult[]) {
+function formatPerfResults(items: NamedMeasureResult[]) {
     return (
         `| Name | Runs | Each | Total |\n| --- | --- | --- | --- | \n` +
         items

src/modules/features/DocumentHistory/DocumentHistoryModal.ts

@@ -1,6 +1,6 @@
 import { TFile, Modal, App, DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, diff_match_patch } from "@/deps.ts";
 import { getPathFromTFile, isValidPath } from "@/common/utils.ts";
-import { decodeBinary, readString } from "@lib/string_and_binary/convert.ts";
+import { decodeBinary, readString } from "@vrtmrz/livesync-commonlib/compat/string_and_binary/convert";
 import ObsidianLiveSyncPlugin from "@/main.ts";
 import {
     type DocumentID,
@@ -9,14 +9,20 @@ import {
     LOG_LEVEL_INFO,
     LOG_LEVEL_NOTICE,
     LOG_LEVEL_VERBOSE,
-} from "@lib/common/types.ts";
-import { Logger } from "@lib/common/logger.ts";
-import { isErrorOfMissingDoc } from "@lib/pouchdb/utils_couchdb.ts";
-import { fireAndForget, getDocData, readContent } from "@lib/common/utils.ts";
-import { isPlainText, stripPrefix } from "@lib/string_and_binary/path.ts";
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { Logger } from "@vrtmrz/livesync-commonlib/compat/common/logger";
+import { isErrorOfMissingDoc } from "@vrtmrz/livesync-commonlib/compat/pouchdb/utils_couchdb";
+import { fireAndForget, getDocData, readContent } from "@vrtmrz/livesync-commonlib/compat/common/utils";
+import { isPlainText, stripPrefix } from "@vrtmrz/livesync-commonlib/compat/string_and_binary/path";
 import { scheduleOnceIfDuplicated } from "octagonal-wheels/concurrency/lock";
 import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore.ts";
-import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
+import { compatGlobal } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
+import {
+    DOCUMENT_HISTORY_PREFERENCE_KEYS,
+    loadDocumentHistoryPreference,
+    saveDocumentHistoryPreference,
+} from "./documentHistoryPreferences.ts";
+import type PouchDB from "pouchdb-core";
 
 function isImage(path: string) {
     const ext = path.split(".").splice(-1)[0].toLowerCase();
@@ -106,12 +112,10 @@ export class DocumentHistoryModal extends Modal {
         if (!file && id) {
             this.file = this.services.path.id2path(id);
         }
-        // eslint-disable-next-line obsidianmd/no-unsupported-api -- loadLocalStorage is supported in Obsidian 1.7.2+
-        if (this.app.loadLocalStorage("ols-history-highlightdiff") == "1") {
+        if (loadDocumentHistoryPreference(this.app, DOCUMENT_HISTORY_PREFERENCE_KEYS.highlightDiff)) {
             this.showDiff = true;
         }
-        // eslint-disable-next-line obsidianmd/no-unsupported-api -- loadLocalStorage is supported in Obsidian 1.7.2+
-        if (this.app.loadLocalStorage("ols-history-diffonly") == "1") {
+        if (loadDocumentHistoryPreference(this.app, DOCUMENT_HISTORY_PREFERENCE_KEYS.diffOnly)) {
             this.diffOnly = true;
         }
     }
@@ -567,10 +571,10 @@ export class DocumentHistoryModal extends Modal {
             e.addEventListener("click", () => this.navigateSearch("next"));
         });
 
-        this.searchResultIndicator = searchRow.createEl("span", { text: "" });
+        this.searchResultIndicator = searchRow.createSpan({ text: "" });
         this.searchResultIndicator.addClass("history-search-result-indicator");
 
-        this.searchProgressIndicator = searchRow.createEl("span", { text: "" });
+        this.searchProgressIndicator = searchRow.createSpan({ text: "" });
         this.searchProgressIndicator.addClass("history-search-progress-indicator");
 
         const revNavRow = contentEl.createDiv({ cls: "history-rev-nav-row" });
@@ -620,8 +624,11 @@ export class DocumentHistoryModal extends Modal {
                 }
                 checkbox.addEventListener("input", (evt: Event) => {
                     this.showDiff = checkbox.checked;
-                    // eslint-disable-next-line obsidianmd/no-unsupported-api -- saveLocalStorage is supported in Obsidian 1.7.2+
-                    this.app.saveLocalStorage("ols-history-highlightdiff", this.showDiff == true ? "1" : null);
+                    saveDocumentHistoryPreference(
+                        this.app,
+                        DOCUMENT_HISTORY_PREFERENCE_KEYS.highlightDiff,
+                        this.showDiff
+                    );
                     this.updateDiffNavVisibility();
                     void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
                 });
@@ -636,8 +643,7 @@ export class DocumentHistoryModal extends Modal {
             }
             checkbox.addEventListener("input", (evt: Event) => {
                 this.diffOnly = checkbox.checked;
-                // eslint-disable-next-line obsidianmd/no-unsupported-api -- saveLocalStorage is supported in Obsidian 1.7.2+
-                this.app.saveLocalStorage("ols-history-diffonly", this.diffOnly == true ? "1" : null);
+                saveDocumentHistoryPreference(this.app, DOCUMENT_HISTORY_PREFERENCE_KEYS.diffOnly, this.diffOnly);
                 void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
             });
         });
@@ -663,7 +669,7 @@ export class DocumentHistoryModal extends Modal {
                 this.navigateDiff("next");
             });
         });
-        this.diffNavIndicator = this.diffNavContainer.createEl("span", { text: "\u2014" });
+        this.diffNavIndicator = this.diffNavContainer.createSpan({ text: "\u2014" });
         this.diffNavIndicator.addClass("diff-nav-indicator");
 
         this.info = contentEl.createDiv("");
@@ -718,7 +724,6 @@ export class DocumentHistoryModal extends Modal {
         const { contentEl } = this;
         contentEl.empty();
         this.BlobURLs.forEach((value) => {
-            console.log(value);
             if (value) URL.revokeObjectURL(value);
         });
     }

src/modules/features/DocumentHistory/documentHistoryPreferences.ts

@@ -0,0 +1,22 @@
+import { requireApiVersion, type App } from "@/deps.ts";
+
+export const DOCUMENT_HISTORY_PREFERENCE_KEYS = {
+    diffOnly: "ols-history-diffonly",
+    highlightDiff: "ols-history-highlightdiff",
+} as const;
+
+export type DocumentHistoryPreferenceKey =
+    (typeof DOCUMENT_HISTORY_PREFERENCE_KEYS)[keyof typeof DOCUMENT_HISTORY_PREFERENCE_KEYS];
+
+export function loadDocumentHistoryPreference(app: App, key: DocumentHistoryPreferenceKey): boolean {
+    if (requireApiVersion("1.8.7")) {
+        return app.loadLocalStorage(key) === "1";
+    }
+    return false;
+}
+
+export function saveDocumentHistoryPreference(app: App, key: DocumentHistoryPreferenceKey, enabled: boolean): void {
+    if (requireApiVersion("1.8.7")) {
+        app.saveLocalStorage(key, enabled ? "1" : null);
+    }
+}

src/modules/features/DocumentHistory/documentHistoryPreferences.unit.spec.ts

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const requireApiVersionMock = vi.hoisted(() => vi.fn<(version: string) => boolean>());
+
+vi.mock("@/deps.ts", () => ({
+    requireApiVersion: requireApiVersionMock,
+}));
+
+import {
+    DOCUMENT_HISTORY_PREFERENCE_KEYS,
+    loadDocumentHistoryPreference,
+    saveDocumentHistoryPreference,
+} from "./documentHistoryPreferences.ts";
+
+function createAppStorage() {
+    return {
+        loadLocalStorage: vi.fn<(key: string) => unknown>(),
+        saveLocalStorage: vi.fn<(key: string, value: unknown | null) => void>(),
+    };
+}
+
+describe("document history preferences", () => {
+    beforeEach(() => {
+        requireApiVersionMock.mockReset();
+    });
+
+    it("falls back without accessing Vault local storage on older Obsidian versions", () => {
+        requireApiVersionMock.mockReturnValue(false);
+        const app = createAppStorage();
+
+        expect(loadDocumentHistoryPreference(app as never, DOCUMENT_HISTORY_PREFERENCE_KEYS.highlightDiff)).toBe(false);
+        saveDocumentHistoryPreference(app as never, DOCUMENT_HISTORY_PREFERENCE_KEYS.diffOnly, true);
+
+        expect(requireApiVersionMock).toHaveBeenCalledWith("1.8.7");
+        expect(app.loadLocalStorage).not.toHaveBeenCalled();
+        expect(app.saveLocalStorage).not.toHaveBeenCalled();
+    });
+
+    it("loads and saves Vault-scoped preferences when the API is available", () => {
+        requireApiVersionMock.mockReturnValue(true);
+        const app = createAppStorage();
+        app.loadLocalStorage.mockReturnValue("1");
+
+        expect(loadDocumentHistoryPreference(app as never, DOCUMENT_HISTORY_PREFERENCE_KEYS.diffOnly)).toBe(true);
+        saveDocumentHistoryPreference(app as never, DOCUMENT_HISTORY_PREFERENCE_KEYS.highlightDiff, true);
+        saveDocumentHistoryPreference(app as never, DOCUMENT_HISTORY_PREFERENCE_KEYS.highlightDiff, false);
+
+        expect(app.loadLocalStorage).toHaveBeenCalledWith("ols-history-diffonly");
+        expect(app.saveLocalStorage).toHaveBeenNthCalledWith(1, "ols-history-highlightdiff", "1");
+        expect(app.saveLocalStorage).toHaveBeenNthCalledWith(2, "ols-history-highlightdiff", null);
+    });
+});

src/modules/features/GlobalHistory/GlobalHistory.svelte

@@ -1,11 +1,11 @@
 <script lang="ts">
     import ObsidianLiveSyncPlugin from "@/main.ts";
     import { onDestroy, onMount } from "svelte";
-    import type { AnyEntry, FilePathWithPrefix } from "@lib/common/types.ts";
-    import { getDocData, isAnyNote, isDocContentSame, readAsBlob } from "@lib/common/utils.ts";
+    import type { AnyEntry, FilePathWithPrefix } from "@vrtmrz/livesync-commonlib/compat/common/types";
+    import { getDocData, isAnyNote, isDocContentSame, readAsBlob } from "@vrtmrz/livesync-commonlib/compat/common/utils";
     import { diff_match_patch } from "@/deps.ts";
     import { DocumentHistoryModal } from "@/modules/features/DocumentHistory/DocumentHistoryModal.ts";
-    import { isPlainText, stripAllPrefixes } from "@lib/string_and_binary/path.ts";
+    import { isPlainText, stripAllPrefixes } from "@vrtmrz/livesync-commonlib/compat/string_and_binary/path";
     import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore.ts";
     export let plugin: ObsidianLiveSyncPlugin;
     export let core: LiveSyncBaseCore;

src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts

@@ -1,29 +1,38 @@
 import { App, Modal } from "@/deps.ts";
 import { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT } from "diff-match-patch";
-import { CANCELLED, LEAVE_TO_SUBSEQUENT, type diff_result } from "@lib/common/types.ts";
-import { delay } from "@lib/common/utils.ts";
-import { eventHub } from "@/common/events.ts";
-import { globalSlipBoard } from "@lib/bureau/bureau.ts";
+import {
+    CANCELLED,
+    LEAVE_TO_SUBSEQUENT,
+    type diff_result,
+    type FilePathWithPrefix,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { EVENT_CONFLICT_CANCELLED, eventHub } from "@/common/events.ts";
+import { promiseWithResolvers } from "octagonal-wheels/promises";
 
-export type MergeDialogResult = typeof CANCELLED | typeof LEAVE_TO_SUBSEQUENT | string;
+export const POSTPONED = Symbol("postponed");
 
-declare global {
-    interface Slips extends LSSlips {
-        "conflict-resolved": typeof CANCELLED | MergeDialogResult;
-    }
-}
+export type MergeDialogResult = typeof CANCELLED | typeof POSTPONED | typeof LEAVE_TO_SUBSEQUENT | string;
+
+export type ConflictResolveModalOptions = {
+    readOnly?: boolean;
+    title?: string;
+    localName?: string;
+    remoteName?: string;
+};
 
 export class ConflictResolveModal extends Modal {
     result: diff_result;
-    filename: string;
+    filename: FilePathWithPrefix;
 
     response: MergeDialogResult = CANCELLED;
     isClosed = false;
     consumed = false;
+    private readonly resultPromise = promiseWithResolvers<MergeDialogResult>();
 
     title: string = "Conflicting changes";
 
     pluginPickMode: boolean = false;
+    readOnly: boolean = false;
     localName: string = "Base";
     remoteName: string = "Conflicted";
     offEvent?: ReturnType<typeof eventHub.onEvent>;
@@ -31,19 +40,28 @@ export class ConflictResolveModal extends Modal {
     diffView!: HTMLDivElement;
     diffNavIndicator!: HTMLSpanElement;
 
-    constructor(app: App, filename: string, diff: diff_result, pluginPickMode?: boolean, remoteName?: string) {
+    constructor(
+        app: App,
+        filename: FilePathWithPrefix,
+        diff: diff_result,
+        pluginPickMode?: boolean,
+        remoteName?: string,
+        options?: ConflictResolveModalOptions
+    ) {
         super(app);
         this.result = diff;
         this.filename = filename;
         this.pluginPickMode = pluginPickMode || false;
+        this.readOnly = options?.readOnly ?? false;
         if (this.pluginPickMode) {
             this.title = "Pick a version";
             this.remoteName = `${remoteName || "Remote"}`;
             this.localName = "Local";
+        } else if (this.readOnly) {
+            this.title = options?.title ?? "Vault and database revision";
+            this.localName = options?.localName ?? "Vault file";
+            this.remoteName = options?.remoteName ?? "Database revision";
         }
-        // Send cancel signal for the previous merge dialogue
-        // if not there, simply be ignored.
-        // sendValue("close-resolve-conflict:" + this.filename, false);
     }
 
     appendDiffFragment(container: HTMLDivElement, text: string, cls: string) {
@@ -94,23 +112,26 @@ export class ConflictResolveModal extends Modal {
 
     override onOpen() {
         const { contentEl } = this;
-        // Send cancel signal for the previous merge dialogue
-        // if not there, simply be ignored.
-        globalSlipBoard.submit("conflict-resolved", this.filename, CANCELLED);
         if (this.offEvent) {
             this.offEvent();
         }
-        this.offEvent = eventHub.onEvent("conflict-cancelled", (path) => {
-            if (path === this.filename) {
-                this.sendResponse(CANCELLED);
-            }
-        });
-        // sendValue("close-resolve-conflict:" + this.filename, false);
+        if (!this.readOnly) {
+            // Cancel an older dialogue for this path before subscribing this
+            // instance. Emitting after subscription would close the replacement
+            // itself; the instance-owned result promise then completes the older
+            // caller even when it only begins waiting after this event.
+            eventHub.emitEvent(EVENT_CONFLICT_CANCELLED, this.filename);
+            this.offEvent = eventHub.onEvent(EVENT_CONFLICT_CANCELLED, (path) => {
+                if (path === this.filename) {
+                    this.sendResponse(CANCELLED);
+                }
+            });
+        }
         this.titleEl.setText(this.title);
         contentEl.empty();
         const diffOptionsRow = contentEl.createDiv("");
         diffOptionsRow.addClass("diff-options-row");
-        diffOptionsRow.createEl("span", { text: this.filename });
+        diffOptionsRow.createSpan({ text: this.filename });
 
         const diffNavContainer = diffOptionsRow.createDiv("");
         diffNavContainer.addClass("diff-nav");
@@ -122,7 +143,7 @@ export class ConflictResolveModal extends Modal {
             e.addClass("diff-nav-btn");
             e.addEventListener("click", () => this.navigateDiff("next"));
         });
-        this.diffNavIndicator = diffNavContainer.createEl("span", { text: "\u2014" });
+        this.diffNavIndicator = diffNavContainer.createSpan({ text: "\u2014" });
         this.diffNavIndicator.addClass("diff-nav-indicator");
 
         this.diffView = contentEl.createDiv("");
@@ -153,24 +174,32 @@ export class ConflictResolveModal extends Modal {
             new Date(this.result.right.mtime).toLocaleString() + (this.result.right.deleted ? " (Deleted)" : "");
         this.appendVersionInfo(div2, "deleted", this.localName, date1);
         this.appendVersionInfo(div2, "added", this.remoteName, date2);
-        contentEl.createEl("button", { text: `Use ${this.localName}` }, (e) => {
-            e.addClass("conflict-action-button");
-            e.addEventListener("click", () => this.sendResponse(this.result.right.rev));
-        });
-        contentEl.createEl("button", { text: `Use ${this.remoteName}` }, (e) => {
-            e.addClass("conflict-action-button");
-            e.addEventListener("click", () => this.sendResponse(this.result.left.rev));
-        });
-        if (!this.pluginPickMode) {
-            contentEl.createEl("button", { text: "Concat both" }, (e) => {
+        const actionContainer = contentEl.createDiv("conflict-action-container");
+        if (this.readOnly) {
+            actionContainer.createEl("button", { text: "Close" }, (e) => {
                 e.addClass("conflict-action-button");
-                e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT));
+                e.addEventListener("click", () => this.sendResponse(CANCELLED));
+            });
+        } else {
+            actionContainer.createEl("button", { text: `Use ${this.localName}` }, (e) => {
+                e.addClass("conflict-action-button");
+                e.addEventListener("click", () => this.sendResponse(this.result.right.rev));
+            });
+            actionContainer.createEl("button", { text: `Use ${this.remoteName}` }, (e) => {
+                e.addClass("conflict-action-button");
+                e.addEventListener("click", () => this.sendResponse(this.result.left.rev));
+            });
+            if (!this.pluginPickMode) {
+                actionContainer.createEl("button", { text: "Concat both" }, (e) => {
+                    e.addClass("conflict-action-button");
+                    e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT));
+                });
+            }
+            actionContainer.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) => {
+                e.addClass("conflict-action-button");
+                e.addEventListener("click", () => this.sendResponse(this.pluginPickMode ? CANCELLED : POSTPONED));
             });
         }
-        contentEl.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) => {
-            e.addClass("conflict-action-button");
-            e.addEventListener("click", () => this.sendResponse(CANCELLED));
-        });
         if (diffLength > 100 * 1024) {
             this.diffView.empty();
             this.diffView.setText("(Too large diff to display)");
@@ -194,12 +223,10 @@ export class ConflictResolveModal extends Modal {
             return;
         }
         this.consumed = true;
-        globalSlipBoard.submit("conflict-resolved", this.filename, this.response);
+        this.resultPromise.resolve(this.response);
     }
 
     async waitForResult(): Promise<MergeDialogResult> {
-        await delay(100);
-        const r = await globalSlipBoard.awaitNext("conflict-resolved", this.filename);
-        return r;
+        return await this.resultPromise.promise;
     }
 }

src/modules/features/InteractiveConflictResolving/ConflictResolveModal.unit.spec.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it, vi } from "vitest";
+import { POSTPONED, ConflictResolveModal } from "./ConflictResolveModal.ts";
+import { CANCELLED, type diff_result, type FilePathWithPrefix } from "@vrtmrz/livesync-commonlib/compat/common/types";
+
+vi.mock("@/deps.ts", () => ({
+    App: class App {},
+    Modal: class Modal {
+        createdButtons: string[] = [];
+
+        private createElement(): Record<string, unknown> {
+            const element: Record<string, unknown> = {
+                addClass: vi.fn(),
+                addEventListener: vi.fn(),
+                appendText: vi.fn(),
+                classList: {
+                    add: vi.fn(),
+                    remove: vi.fn(),
+                },
+                empty: vi.fn(),
+                querySelector: vi.fn(() => null),
+                querySelectorAll: vi.fn(() => []),
+                scrollIntoView: vi.fn(),
+                setText: vi.fn(),
+            };
+            element.createDiv = vi.fn(() => this.createElement());
+            element.createEl = vi.fn((_tag: string, _options?: unknown, callback?: (child: unknown) => void) => {
+                if (
+                    _tag === "button" &&
+                    typeof _options === "object" &&
+                    _options !== null &&
+                    "text" in _options
+                ) {
+                    this.createdButtons.push(String((_options as { text: unknown }).text));
+                }
+                const child = this.createElement();
+                callback?.(child);
+                return child;
+            });
+            element.createSpan = vi.fn(() => this.createElement());
+            return element;
+        }
+
+        contentEl = this.createElement();
+        titleEl = {
+            setText: vi.fn(),
+        };
+
+        close() {
+            (this as { onClose?: () => void }).onClose?.();
+        }
+    },
+}));
+
+const conflict: diff_result = {
+    left: { rev: "2-left", data: "left", ctime: 1, mtime: 2 },
+    right: { rev: "2-right", data: "right", ctime: 1, mtime: 2 },
+    diff: [],
+};
+
+describe("ConflictResolveModal result lifecycle", () => {
+    it("returns a response which closes the dialogue before the caller begins waiting", async () => {
+        const modal = new ConflictResolveModal({} as never, "early-response.md" as FilePathWithPrefix, conflict);
+
+        modal.sendResponse(POSTPONED);
+        const result = await Promise.race([
+            modal.waitForResult(),
+            new Promise<"timed-out">((resolve) => setTimeout(() => resolve("timed-out"), 250)),
+        ]);
+
+        expect(result).toBe(POSTPONED);
+    });
+
+    it("cancels the previous same-path dialogue without cancelling the replacement", async () => {
+        const filename = "same-path.md" as FilePathWithPrefix;
+        const previous = new ConflictResolveModal({} as never, filename, conflict);
+        const replacement = new ConflictResolveModal({} as never, filename, conflict);
+        previous.onOpen();
+
+        replacement.onOpen();
+        const previousResult = await Promise.race([
+            previous.waitForResult(),
+            new Promise<"timed-out">((resolve) => setTimeout(() => resolve("timed-out"), 250)),
+        ]);
+        const replacementState = await Promise.race([
+            replacement.waitForResult(),
+            new Promise<"still-open">((resolve) => setTimeout(() => resolve("still-open"), 25)),
+        ]);
+
+        previous.sendResponse(CANCELLED);
+        replacement.sendResponse(CANCELLED);
+
+        expect(previousResult).toBe(CANCELLED);
+        expect(replacementState).toBe("still-open");
+    });
+
+    it("renders a read-only comparison with no resolution actions", () => {
+        const ReadOnlyModal = ConflictResolveModal as unknown as new (
+            ...args: unknown[]
+        ) => ConflictResolveModal & { createdButtons: string[] };
+        const modal = new ReadOnlyModal(
+            {},
+            "repair-preview.md",
+            conflict,
+            false,
+            undefined,
+            {
+                readOnly: true,
+                title: "Vault and database revision",
+                localName: "Vault file",
+                remoteName: "Database revision",
+            }
+        );
+
+        modal.onOpen();
+
+        expect(modal.createdButtons).toContain("Close");
+        expect(modal.createdButtons).not.toContain("Use Vault file");
+        expect(modal.createdButtons).not.toContain("Use Database revision");
+        expect(modal.createdButtons).not.toContain("Concat both");
+        expect(modal.createdButtons).not.toContain("Not now");
+        modal.close();
+    });
+
+    it("does not cancel an active conflict dialogue when a read-only comparison opens for the same file", async () => {
+        const filename = "repair-alongside-conflict.md" as FilePathWithPrefix;
+        const previous = new ConflictResolveModal({} as never, filename, conflict);
+        const ReadOnlyModal = ConflictResolveModal as unknown as new (
+            ...args: unknown[]
+        ) => ConflictResolveModal;
+        const comparison = new ReadOnlyModal({}, filename, conflict, false, undefined, {
+            readOnly: true,
+        });
+        previous.onOpen();
+
+        comparison.onOpen();
+        const previousState = await Promise.race([
+            previous.waitForResult(),
+            new Promise<"still-open">((resolve) => setTimeout(() => resolve("still-open"), 25)),
+        ]);
+
+        previous.sendResponse(CANCELLED);
+        comparison.close();
+
+        expect(previousState).toBe("still-open");
+    });
+});

src/modules/features/Log/LogPane.svelte

@@ -1,10 +1,10 @@
 <script lang="ts">
     import { onDestroy, onMount } from "svelte";
-    import { logMessages } from "@lib/mock_and_interop/stores";
+    import { logMessages } from "@vrtmrz/livesync-commonlib/compat/mock_and_interop/stores";
     import { reactive, type ReactiveInstance } from "octagonal-wheels/dataobject/reactive";
-    import { Logger } from "@lib/common/logger";
-    import { $msg as msg, currentLang as lang } from "@lib/common/i18n.ts";
-    import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
+    import { Logger } from "@vrtmrz/livesync-commonlib/compat/common/logger";
+    import { $msg as msg, currentLang as lang } from "@/common/translation";
+    import { compatGlobal } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
 
     let unsubscribe: () => void;
     let messages = $state([] as string[]);

src/modules/features/Log/LogPaneView.ts

@@ -2,7 +2,7 @@ import { WorkspaceLeaf } from "@/deps.ts";
 import LogPaneComponent from "./LogPane.svelte";
 import type ObsidianLiveSyncPlugin from "@/main.ts";
 import { SvelteItemView } from "@/common/SvelteItemView.ts";
-import { $msg } from "@lib/common/i18n.ts";
+import { $msg } from "@/common/translation";
 import { mount } from "svelte";
 export const VIEW_TYPE_LOG = "log-log";
 //Log view

src/modules/features/ModuleInteractiveConflictResolver.ts

@@ -8,16 +8,76 @@ import {
     type DocumentID,
     type FilePathWithPrefix,
     type diff_result,
-} from "@lib/common/types.ts";
-import { ConflictResolveModal } from "./InteractiveConflictResolving/ConflictResolveModal.ts";
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { ConflictResolveModal, POSTPONED } from "./InteractiveConflictResolving/ConflictResolveModal.ts";
 import { AbstractObsidianModule } from "@/modules/AbstractObsidianModule.ts";
 import { displayRev } from "@/common/utils.ts";
 import { fireAndForget } from "octagonal-wheels/promises";
 import { serialized } from "octagonal-wheels/concurrency/lock";
 import type { LiveSyncCore } from "@/main.ts";
+import { EVENT_CONFLICT_CANCELLED, EVENT_ON_UNRESOLVED_ERROR, eventHub } from "@/common/events.ts";
+import { $msg } from "@/common/translation.ts";
+import type { Editor, MarkdownFileInfo, MarkdownView } from "@/deps.ts";
 
 export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
+    private postponedConflictEpisodes = new Set<FilePathWithPrefix>();
+
+    private async getConflictVersionCount(filename: FilePathWithPrefix): Promise<number | undefined> {
+        try {
+            const conflictCount = (await this.core.databaseFileAccess.getConflictedRevs(filename)).length;
+            return conflictCount === 0 ? 0 : conflictCount + 1;
+        } catch (error) {
+            this._log(`Could not inspect the conflict state of ${filename}`, LOG_LEVEL_VERBOSE);
+            this._log(error, LOG_LEVEL_VERBOSE);
+            return undefined;
+        }
+    }
+
+    private async getActiveConflictMessages(): Promise<string[]> {
+        const filename = this.services.vault.getActiveFilePath();
+        if (!filename) return [];
+        const versionCount = await this.getConflictVersionCount(filename);
+        if (versionCount === 0) {
+            this.postponedConflictEpisodes.delete(filename);
+            return [];
+        }
+        if (versionCount !== undefined && versionCount >= 3) {
+            return [
+                $msg("This file has ${COUNT} unresolved versions. They will be reviewed one pair at a time.", {
+                    COUNT: `${versionCount}`,
+                }),
+            ];
+        }
+        if (versionCount === 2 || this.postponedConflictEpisodes.has(filename)) {
+            return [$msg("This file has unresolved conflicts.")];
+        }
+        return [];
+    }
+
+    private async refreshConflictState(filename: FilePathWithPrefix): Promise<void> {
+        if ((await this.getConflictVersionCount(filename)) === 0) {
+            this.postponedConflictEpisodes.delete(filename);
+        }
+        eventHub.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+    }
+
+    private async requestConflictResolution(filename: FilePathWithPrefix): Promise<void> {
+        this.postponedConflictEpisodes.delete(filename);
+        eventHub.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+        await this.services.conflict.queueCheckFor(filename);
+        await this.services.conflict.ensureAllProcessed();
+    }
+
     _everyOnloadStart(): Promise<boolean> {
+        this.addCommand({
+            id: "livesync-checkdoc-conflicted",
+            name: "Resolve if conflicted.",
+            editorCallback: (editor: Editor, view: MarkdownView | MarkdownFileInfo) => {
+                const file = view.file;
+                if (!file) return;
+                void this.requestConflictResolution(file.path as FilePathWithPrefix);
+            },
+        });
         this.addCommand({
             id: "livesync-conflictcheck",
             name: "Pick a file to resolve conflict",
@@ -38,10 +98,21 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
     async _anyResolveConflictByUI(filename: FilePathWithPrefix, conflictCheckResult: diff_result): Promise<boolean> {
         // UI for resolving conflicts should one-by-one.
         return await serialized(`conflict-resolve-ui`, async () => {
+            if (this.postponedConflictEpisodes.has(filename)) {
+                this._log(`Merge: Postponed ${filename}`, LOG_LEVEL_VERBOSE);
+                eventHub.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+                return false;
+            }
             this._log("Merge:open conflict dialog", LOG_LEVEL_VERBOSE);
             const dialog = new ConflictResolveModal(this.app, filename, conflictCheckResult);
             dialog.open();
             const selected = await dialog.waitForResult();
+            if (selected === POSTPONED) {
+                this.postponedConflictEpisodes.add(filename);
+                eventHub.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+                this._log(`Merge: Postponed ${filename}`, LOG_LEVEL_INFO);
+                return false;
+            }
             if (selected === CANCELLED) {
                 // Cancelled by UI, or another conflict.
                 this._log(`Merge: Cancelled ${filename}`, LOG_LEVEL_INFO);
@@ -52,8 +123,21 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
                 this._log(`Merge: Could not read ${filename} from the local database`, LOG_LEVEL_VERBOSE);
                 return false;
             }
-            if (!testDoc._conflicts) {
+            if (!testDoc._conflicts || testDoc._conflicts.length === 0) {
                 this._log(`Merge: Nothing to do ${filename}`, LOG_LEVEL_VERBOSE);
+                await this.refreshConflictState(filename);
+                return false;
+            }
+            if (
+                testDoc._rev !== conflictCheckResult.left.rev ||
+                !testDoc._conflicts.includes(conflictCheckResult.right.rev)
+            ) {
+                this._log(
+                    `Merge: The compared revisions changed while the dialogue was open: ${filename}`,
+                    LOG_LEVEL_INFO
+                );
+                await this.refreshConflictState(filename);
+                await this.services.conflict.queueCheckFor(filename);
                 return false;
             }
             const toDelete = selected;
@@ -62,7 +146,7 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
                 // Concatenate both conflicted revisions.
                 // Create a new file by concatenating both conflicted revisions.
                 const p = conflictCheckResult.diff.map((e) => e[1]).join("");
-                const delRev = testDoc._conflicts[0];
+                const delRev = conflictCheckResult.right.rev;
                 if (!(await this.core.databaseFileAccess.storeContent(filename, p))) {
                     this._log(`Concatenated content cannot be stored:${filename}`, LOG_LEVEL_NOTICE);
                     return false;
@@ -78,7 +162,10 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
                     );
                     return false;
                 }
-            } else if (typeof toDelete === "string") {
+            } else if (
+                typeof toDelete === "string" &&
+                (toDelete === conflictCheckResult.left.rev || toDelete === conflictCheckResult.right.rev)
+            ) {
                 // Select one of the conflicted revision to delete.
                 if (
                     (await this.services.conflict.resolveByDeletingRevision(filename, toDelete, "UI Selected")) ==
@@ -88,7 +175,7 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
                     return false;
                 }
             } else {
-                this._log(`Merge: Something went wrong: ${filename}, (${toDelete as string})`, LOG_LEVEL_NOTICE);
+                this._log(`Merge: Something went wrong: ${filename}, (${String(toDelete)})`, LOG_LEVEL_NOTICE);
                 return false;
             }
             // In here, some merge has been processed.
@@ -103,10 +190,13 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
         });
     }
     async allConflictCheck() {
-        while (await this.pickFileForResolve());
+        let notifyIfEmpty = true;
+        while (await this.pickFileForResolve(notifyIfEmpty)) {
+            notifyIfEmpty = false;
+        }
     }
 
-    async pickFileForResolve() {
+    async pickFileForResolve(notifyIfEmpty = true) {
         const notes: { id: DocumentID; path: FilePathWithPrefix; dispPath: string; mtime: number }[] = [];
         for await (const doc of this.localDatabase.findAllDocs({ conflicts: true })) {
             if (!("_conflicts" in doc)) continue;
@@ -120,14 +210,15 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
         notes.sort((a, b) => b.mtime - a.mtime);
         const notesList = notes.map((e) => e.dispPath);
         if (notesList.length == 0) {
-            this._log("There are no conflicted documents", LOG_LEVEL_NOTICE);
+            if (notifyIfEmpty) {
+                this._log("There are no conflicted documents", LOG_LEVEL_NOTICE);
+            }
             return false;
         }
         const target = await this.core.confirm.askSelectString("File to resolve conflict", notesList);
         if (target) {
             const targetItem = notes.find((e) => e.dispPath == target)!;
-            await this.services.conflict.queueCheckFor(targetItem.path);
-            await this.services.conflict.ensureAllProcessed();
+            await this.requestConflictResolution(targetItem.path);
             return true;
         }
         return false;
@@ -172,6 +263,10 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
     override onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
         services.appLifecycle.onScanningStartupIssues.addHandler(this._allScanStat.bind(this));
         services.appLifecycle.onInitialise.addHandler(this._everyOnloadStart.bind(this));
+        services.appLifecycle.getUnresolvedMessages.addHandler(this.getActiveConflictMessages.bind(this));
         services.conflict.resolveByUserInteraction.addHandler(this._anyResolveConflictByUI.bind(this));
+        eventHub.onEvent(EVENT_CONFLICT_CANCELLED, (filename) => {
+            fireAndForget(() => this.refreshConflictState(filename));
+        });
     }
 }

src/modules/features/ModuleInteractiveConflictResolver.unit.spec.ts

@@ -0,0 +1,281 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+    AUTO_MERGED,
+    CANCELLED,
+    DEFAULT_SETTINGS,
+    LEAVE_TO_SUBSEQUENT,
+    LOG_LEVEL_NOTICE,
+    type FilePathWithPrefix,
+    type diff_result,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+
+const modalState = vi.hoisted(() => ({
+    constructed: 0,
+    result: undefined as unknown,
+    postponed: Symbol("postponed"),
+}));
+
+vi.mock("@/common/utils.ts", () => ({
+    displayRev: (revision: string) => revision,
+}));
+
+vi.mock("./InteractiveConflictResolving/ConflictResolveModal.ts", () => ({
+    POSTPONED: modalState.postponed,
+    ConflictResolveModal: class ConflictResolveModal {
+        constructor() {
+            modalState.constructed++;
+        }
+
+        open() {}
+
+        async waitForResult() {
+            return modalState.result;
+        }
+    },
+}));
+
+import { ModuleInteractiveConflictResolver } from "./ModuleInteractiveConflictResolver.ts";
+
+const path = "note.md" as FilePathWithPrefix;
+const conflict: diff_result = {
+    left: { rev: "2-left", data: "left", ctime: 1, mtime: 2 },
+    right: { rev: "2-right", data: "right", ctime: 1, mtime: 2 },
+    diff: [],
+};
+
+async function* documents(items: unknown[]) {
+    for (const item of items) {
+        yield item;
+    }
+}
+
+function createModule(conflictedRevisions: string[] = ["2-right"]) {
+    const handlers = {
+        unresolvedMessages: undefined as undefined | (() => Promise<string[]>),
+    };
+    const services = {
+        API: {
+            addLog: vi.fn(),
+            addCommand: vi.fn(),
+            registerWindow: vi.fn(),
+            addRibbonIcon: vi.fn(),
+            registerProtocolHandler: vi.fn(),
+        },
+        appLifecycle: {
+            getUnresolvedMessages: {
+                addHandler: vi.fn((handler: () => Promise<string[]>) => {
+                    handlers.unresolvedMessages = handler;
+                }),
+            },
+            onScanningStartupIssues: { addHandler: vi.fn() },
+            onInitialise: { addHandler: vi.fn() },
+            isSuspended: vi.fn(() => false),
+        },
+        conflict: {
+            resolveByUserInteraction: { addHandler: vi.fn() },
+            resolveByDeletingRevision: vi.fn(async () => AUTO_MERGED),
+            queueCheckFor: vi.fn(async () => undefined),
+            ensureAllProcessed: vi.fn(async () => true),
+        },
+        replication: { replicateByEvent: vi.fn(async () => true) },
+        vault: { getActiveFilePath: vi.fn(() => path) },
+        path: { getPath: vi.fn((entry: { path: FilePathWithPrefix }) => entry.path) },
+    };
+    const core = {
+        _services: services,
+        services,
+        settings: { ...DEFAULT_SETTINGS, syncAfterMerge: false },
+        localDatabase: {
+            getDBEntry: vi.fn(async (): Promise<false | { _rev: string; _conflicts?: string[] }> => false),
+            findAllDocs: vi.fn(() => documents([])),
+        },
+        databaseFileAccess: {
+            getConflictedRevs: vi.fn(async () => conflictedRevisions),
+            storeContent: vi.fn(async () => true),
+        },
+        confirm: {
+            askSelectString: vi.fn(async (): Promise<string | undefined> => undefined),
+        },
+    };
+    const plugin = { app: {} };
+    const module = new ModuleInteractiveConflictResolver(plugin as never, core as never);
+    module._log = vi.fn();
+    return { core, handlers, module, services };
+}
+
+describe("ModuleInteractiveConflictResolver postponement", () => {
+    beforeEach(() => {
+        modalState.constructed = 0;
+        modalState.result = modalState.postponed;
+    });
+
+    it("does not reopen an unchanged conflict after the user chooses Not now", async () => {
+        const { module } = createModule();
+
+        await module._anyResolveConflictByUI(path, conflict);
+        await module._anyResolveConflictByUI(path, conflict);
+
+        expect(modalState.constructed).toBe(1);
+    });
+
+    it("does not treat cancellation by another conflict dialogue as Not now", async () => {
+        const { module } = createModule();
+        modalState.result = CANCELLED;
+
+        await module._anyResolveConflictByUI(path, conflict);
+        await module._anyResolveConflictByUI(path, conflict);
+
+        expect(modalState.constructed).toBe(2);
+    });
+
+    it("allows an explicit resolution request to reopen a postponed conflict", async () => {
+        const { module, services } = createModule();
+
+        await module._anyResolveConflictByUI(path, conflict);
+        await (module as any).requestConflictResolution(path);
+        await module._anyResolveConflictByUI(path, conflict);
+
+        expect(services.conflict.queueCheckFor).toHaveBeenCalledWith(path);
+        expect(services.conflict.ensureAllProcessed).toHaveBeenCalledOnce();
+        expect(modalState.constructed).toBe(2);
+    });
+
+    it("opens a later conflict after the postponed conflict episode has resolved", async () => {
+        const conflictedRevisions = ["2-right"];
+        const { module } = createModule(conflictedRevisions);
+
+        await module._anyResolveConflictByUI(path, conflict);
+        conflictedRevisions.splice(0);
+        await (module as any).refreshConflictState(path);
+        conflictedRevisions.push("4-later");
+        await module._anyResolveConflictByUI(path, conflict);
+
+        expect(modalState.constructed).toBe(2);
+    });
+
+    it("contributes the active conflict to the existing unresolved-message display", async () => {
+        const { core, handlers, module, services } = createModule();
+
+        module.onBindFunction(core as never, services as never);
+
+        expect(services.appLifecycle.getUnresolvedMessages.addHandler).toHaveBeenCalledOnce();
+        await expect(handlers.unresolvedMessages?.()).resolves.toEqual(["This file has unresolved conflicts."]);
+    });
+
+    it("removes the active warning once the conflict has resolved", async () => {
+        const conflictedRevisions = ["2-right"];
+        const { core, handlers, module, services } = createModule(conflictedRevisions);
+        module.onBindFunction(core as never, services as never);
+
+        await expect(handlers.unresolvedMessages?.()).resolves.toEqual(["This file has unresolved conflicts."]);
+        conflictedRevisions.splice(0);
+        await expect(handlers.unresolvedMessages?.()).resolves.toEqual([]);
+    });
+
+    it("reports the number of live versions and reduces it after each resolved pair", async () => {
+        const conflictedRevisions = ["2-second", "2-third"];
+        const { core, handlers, module, services } = createModule(conflictedRevisions);
+        module.onBindFunction(core as never, services as never);
+
+        await expect(handlers.unresolvedMessages?.()).resolves.toEqual([
+            "This file has 3 unresolved versions. They will be reviewed one pair at a time.",
+        ]);
+
+        conflictedRevisions.shift();
+        await (module as any).refreshConflictState(path);
+        await expect(handlers.unresolvedMessages?.()).resolves.toEqual(["This file has unresolved conflicts."]);
+
+        conflictedRevisions.shift();
+        await (module as any).refreshConflictState(path);
+        await expect(handlers.unresolvedMessages?.()).resolves.toEqual([]);
+    });
+
+    it("reconstructs the remaining pair after a postponed session is restarted", async () => {
+        const conflictedRevisions = ["2-second", "2-third"];
+        const firstSession = createModule(conflictedRevisions);
+
+        await firstSession.module._anyResolveConflictByUI(path, conflict);
+        conflictedRevisions.shift();
+
+        const restartedSession = createModule(conflictedRevisions);
+        restartedSession.module.onBindFunction(restartedSession.core as never, restartedSession.services as never);
+        await expect(restartedSession.handlers.unresolvedMessages?.()).resolves.toEqual([
+            "This file has unresolved conflicts.",
+        ]);
+
+        await restartedSession.module._anyResolveConflictByUI(path, {
+            left: { rev: "3-merged", data: "merged", ctime: 1, mtime: 3 },
+            right: { rev: "2-third", data: "third", ctime: 1, mtime: 2 },
+            diff: [],
+        });
+
+        expect(modalState.constructed).toBe(2);
+    });
+
+    it("deletes the compared right leaf when concatenating a deterministically selected pair", async () => {
+        const { core, module, services } = createModule(["2-unrelated", "2-right"]);
+        modalState.result = LEAVE_TO_SUBSEQUENT;
+        core.localDatabase.getDBEntry.mockResolvedValue({
+            _rev: "2-left",
+            _conflicts: ["2-unrelated", "2-right"],
+        });
+
+        await module._anyResolveConflictByUI(path, conflict);
+
+        expect(core.databaseFileAccess.storeContent).toHaveBeenCalledWith(path, "");
+        expect(services.conflict.resolveByDeletingRevision).toHaveBeenCalledWith(path, "2-right", "UI Concatenated");
+    });
+
+    it("rechecks the live leaves instead of applying a stale dialogue selection", async () => {
+        const { core, module, services } = createModule(["2-other"]);
+        modalState.result = "2-right";
+        core.localDatabase.getDBEntry.mockResolvedValue({
+            _rev: "3-new-winner",
+            _conflicts: ["2-other"],
+        });
+
+        await module._anyResolveConflictByUI(path, conflict);
+
+        expect(services.conflict.resolveByDeletingRevision).not.toHaveBeenCalled();
+        expect(services.conflict.queueCheckFor).toHaveBeenCalledWith(path);
+    });
+});
+
+describe("ModuleInteractiveConflictResolver file selection", () => {
+    beforeEach(() => {
+        modalState.constructed = 0;
+        modalState.result = modalState.postponed;
+    });
+
+    it("does not show a no-conflicts notice when an automatic repeat reaches its normal end", async () => {
+        const { core, module } = createModule();
+        core.localDatabase.findAllDocs
+            .mockImplementationOnce(() =>
+                documents([
+                    {
+                        _id: "note-id",
+                        _rev: "2-left",
+                        _conflicts: ["2-right"],
+                        path,
+                        mtime: 2,
+                    },
+                ])
+            )
+            .mockImplementationOnce(() => documents([]));
+        core.confirm.askSelectString.mockResolvedValue(path);
+
+        await module.allConflictCheck();
+
+        expect(core.confirm.askSelectString).toHaveBeenCalledOnce();
+        expect(module._log).not.toHaveBeenCalledWith("There are no conflicted documents", LOG_LEVEL_NOTICE);
+    });
+
+    it("shows one no-conflicts notice for an explicit selection request which starts empty", async () => {
+        const { module } = createModule();
+
+        await module.pickFileForResolve();
+
+        expect(module._log).toHaveBeenCalledTimes(1);
+        expect(module._log).toHaveBeenCalledWith("There are no conflicted documents", LOG_LEVEL_NOTICE);
+    });
+});

src/modules/features/ModuleLog.ts

@@ -6,9 +6,9 @@ import {
     PREFIXMD_LOGFILE,
     type DatabaseConnectingStatus,
     type LOG_LEVEL,
-} from "@lib/common/types.ts";
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { cancelTask, scheduleTask } from "octagonal-wheels/concurrency/task";
-import { fireAndForget, isDirty, throttle } from "@lib/common/utils.ts";
+import { fireAndForget, isDirty, throttle } from "@vrtmrz/livesync-commonlib/compat/common/utils";
 import {
     collectingChunks,
     pluginScanningCount,
@@ -16,32 +16,38 @@ import {
     hiddenFilesProcessingCount,
     type LogEntry,
     logMessages,
-} from "@lib/mock_and_interop/stores.ts";
-import { eventHub } from "@lib/hub/hub.ts";
+} from "@vrtmrz/livesync-commonlib/compat/mock_and_interop/stores";
 import {
     EVENT_FILE_RENAMED,
     EVENT_LAYOUT_READY,
     EVENT_LEAF_ACTIVE_CHANGED,
     EVENT_ON_UNRESOLVED_ERROR,
+    eventHub,
 } from "@/common/events.ts";
 import { AbstractObsidianModule } from "@/modules/AbstractObsidianModule.ts";
 import { addIcon, debounce, normalizePath, Notice, stringifyYaml, type WorkspaceLeaf } from "@/deps.ts";
 import { LOG_LEVEL_NOTICE, setGlobalLogFunction } from "octagonal-wheels/common/logger";
 import { LogPaneView, VIEW_TYPE_LOG } from "./Log/LogPaneView.ts";
 import { serialized } from "octagonal-wheels/concurrency/lock";
-import { $msg } from "@lib/common/i18n.ts";
-import { P2PLogCollector } from "@lib/replication/trystero/P2PLogCollector.ts";
+import { $msg } from "@/common/translation";
+import { P2PLogCollector } from "@vrtmrz/livesync-commonlib/compat/replication/trystero/P2PLogCollector";
+import {
+    REMOTE_REQUEST_ACTIVITY_MINIMUM_VISIBLE_MS,
+    formatRemoteActivityStatusLabel,
+    getTrackedRequestCount,
+} from "./RemoteActivityStatus.ts";
+import { createMinimumVisibleActivityCount, createPaddedCounterLabel } from "./StatusBarDisplay.ts";
 import type { LiveSyncCore } from "@/main.ts";
-import { LiveSyncError } from "@lib/common/LSError.ts";
+import { LiveSyncError } from "@vrtmrz/livesync-commonlib/compat/common/LSError";
 import { isValidPath } from "@/common/utils.ts";
 import {
     isValidFilenameInAndroid,
     isValidFilenameInDarwin,
     isValidFilenameInWidows,
-} from "@lib/string_and_binary/path.ts";
-import { MARK_LOG_NETWORK_ERROR, MARK_LOG_SEPARATOR } from "@lib/services/lib/logUtils.ts";
-import { NetworkWarningStyles } from "@lib/common/models/setting.const.ts";
-import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
+} from "@vrtmrz/livesync-commonlib/compat/string_and_binary/path";
+import { MARK_LOG_NETWORK_ERROR, MARK_LOG_SEPARATOR } from "@vrtmrz/livesync-commonlib/compat/services/lib/logUtils";
+import { NetworkWarningStyles } from "@vrtmrz/livesync-commonlib/compat/common/models/setting.const";
+import { compatGlobal } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
 import { generateReport } from "@/common/reportTool.ts";
 
 // This module cannot be a core module because it depends on the Obsidian UI.
@@ -114,46 +120,46 @@ export class ModuleLog extends AbstractObsidianModule {
     statusLog = reactiveSource("");
     activeFileStatus = reactiveSource("");
     notifies: { [key: string]: { notice: Notice; count: number } } = {};
-    p2pLogCollector = new P2PLogCollector();
+    p2pLogCollector = new P2PLogCollector(this.services.context.events);
 
     observeForLogs() {
-        const padSpaces = `\u{2007}`.repeat(10);
-        // const emptyMark = `\u{2003}`;
-        function padLeftSpComputed(numI: ReactiveValue<number>, mark: string) {
-            const formatted = reactiveSource("");
-            let timer: number | undefined = undefined;
-            let maxLen = 1;
-            numI.onChanged((numX) => {
-                const num = numX.value;
-                const numLen = `${Math.abs(num)}`.length + 1;
-                maxLen = maxLen < numLen ? numLen : maxLen;
-                if (timer) compatGlobal.clearTimeout(timer);
-                if (num == 0) {
-                    timer = compatGlobal.setTimeout(() => {
-                        formatted.value = "";
-                        maxLen = 1;
-                    }, 3000);
-                }
-                formatted.value = ` ${mark}${`${padSpaces}${num}`.slice(-maxLen)}`;
-            });
-            return computed(() => formatted.value);
-        }
-        const labelReplication = padLeftSpComputed(this.services.replication.replicationResultCount, `📥`);
-        const labelDBCount = padLeftSpComputed(this.services.replication.databaseQueueCount, `📄`);
-        const labelStorageCount = padLeftSpComputed(this.services.replication.storageApplyingCount, `💾`);
-        const labelChunkCount = padLeftSpComputed(collectingChunks, `🧩`);
-        const labelPluginScanCount = padLeftSpComputed(pluginScanningCount, `🔌`);
-        const labelConflictProcessCount = padLeftSpComputed(this.services.conflict.conflictProcessQueueCount, `🔩`);
+        const registerDisplay = <T extends { dispose(): void }>(display: T): T => {
+            this.plugin.register(() => display.dispose());
+            return display;
+        };
+        const labelReplication = registerDisplay(
+            createPaddedCounterLabel(this.services.replication.replicationResultCount, `📥`)
+        );
+        const labelDBCount = registerDisplay(
+            createPaddedCounterLabel(this.services.replication.databaseQueueCount, `📄`)
+        );
+        const labelStorageCount = registerDisplay(
+            createPaddedCounterLabel(this.services.replication.storageApplyingCount, `💾`)
+        );
+        const labelChunkCount = registerDisplay(createPaddedCounterLabel(collectingChunks, `🧩`));
+        const labelPluginScanCount = registerDisplay(createPaddedCounterLabel(pluginScanningCount, `🔌`));
+        const labelConflictProcessCount = registerDisplay(
+            createPaddedCounterLabel(this.services.conflict.conflictProcessQueueCount, `🔩`)
+        );
         const hiddenFilesCount = reactive(() => hiddenFilesEventCount.value - hiddenFilesProcessingCount.value);
-        const labelHiddenFilesCount = padLeftSpComputed(hiddenFilesCount, `⚙️`);
+        const labelHiddenFilesCount = registerDisplay(createPaddedCounterLabel(hiddenFilesCount, `⚙️`));
         const queueCountLabelX = reactive(() => {
-            return `${labelReplication()}${labelDBCount()}${labelStorageCount()}${labelChunkCount()}${labelPluginScanCount()}${labelHiddenFilesCount()}${labelConflictProcessCount()}`;
+            return `${labelReplication.value}${labelDBCount.value}${labelStorageCount.value}${labelChunkCount.value}${labelPluginScanCount.value}${labelHiddenFilesCount.value}${labelConflictProcessCount.value}`;
         });
         const queueCountLabel = () => queueCountLabelX.value;
 
+        const trackedRequestCount = reactive(() => {
+            return getTrackedRequestCount(this.services.API.requestCount.value, this.services.API.responseCount.value);
+        });
+        const displayedTrackedRequestCount = registerDisplay(
+            createMinimumVisibleActivityCount(trackedRequestCount, REMOTE_REQUEST_ACTIVITY_MINIMUM_VISIBLE_MS)
+        );
+
         const requestingStatLabel = computed(() => {
-            const diff = this.services.API.requestCount.value - this.services.API.responseCount.value;
-            return diff != 0 ? "📲 " : "";
+            return formatRemoteActivityStatusLabel({
+                remoteOperationCount: Math.max(0, this.services.replicator.boundedRemoteActivityCount.value),
+                trackedRequestCount: displayedTrackedRequestCount.value,
+            });
         });
 
         const replicationStatLabel = computed(() => {
@@ -209,11 +215,11 @@ export class ModuleLog extends AbstractObsidianModule {
             }
             return { w, sent, pushLast, arrived, pullLast };
         });
-        const labelProc = padLeftSpComputed(this.services.fileProcessing.processing, `⏳`);
-        const labelPend = padLeftSpComputed(this.services.fileProcessing.totalQueued, `🛫`);
-        const labelInBatchDelay = padLeftSpComputed(this.services.fileProcessing.batched, `📬`);
+        const labelProc = registerDisplay(createPaddedCounterLabel(this.services.fileProcessing.processing, `⏳`));
+        const labelPend = registerDisplay(createPaddedCounterLabel(this.services.fileProcessing.totalQueued, `🛫`));
+        const labelInBatchDelay = registerDisplay(createPaddedCounterLabel(this.services.fileProcessing.batched, `📬`));
         const waitingLabel = computed(() => {
-            return `${labelProc()}${labelPend()}${labelInBatchDelay()}`;
+            return `${labelProc.value}${labelPend.value}${labelInBatchDelay.value}`;
         });
         const statusLineLabel = computed(() => {
             const { w, sent, pushLast, arrived, pullLast } = replicationStatLabel();
@@ -545,13 +551,6 @@ ${stringifyYaml(info)}
             return;
         }
         addDisplayLog(newMessage);
-        if (message instanceof Error) {
-            console.error(vaultName + ":" + newMessage);
-        } else if (level >= LOG_LEVEL_INFO) {
-            console.log(vaultName + ":" + newMessage);
-        } else {
-            console.debug(vaultName + ":" + newMessage);
-        }
         if (!this.settings?.showOnlyIconsOnEditor) {
             this.statusLog.value = messageContent;
         }

src/modules/features/ModuleObsidianDocumentHistory.ts

@@ -1,7 +1,7 @@
 import { type TFile } from "@/deps.ts";
 import { eventHub } from "@/common/events.ts";
 import { EVENT_REQUEST_SHOW_HISTORY } from "@/common/obsidianEvents.ts";
-import type { FilePathWithPrefix, LoadedEntry, DocumentID } from "@lib/common/types.ts";
+import type { FilePathWithPrefix, LoadedEntry, DocumentID } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { AbstractObsidianModule } from "@/modules/AbstractObsidianModule.ts";
 import { DocumentHistoryModal } from "./DocumentHistory/DocumentHistoryModal.ts";
 import { fireAndForget } from "octagonal-wheels/promises";

src/modules/features/ModuleObsidianSettingAsMarkdown.ts

@@ -2,12 +2,16 @@
 import { isObjectDifferent } from "octagonal-wheels/object";
 import { EVENT_SETTING_SAVED, eventHub } from "@/common/events";
 import { fireAndForget } from "octagonal-wheels/promises";
-import { DEFAULT_SETTINGS, type FilePathWithPrefix, type ObsidianLiveSyncSettings } from "@lib/common/types";
-import { parseYaml, stringifyYaml } from "@/deps";
+import {
+    DEFAULT_SETTINGS,
+    type FilePathWithPrefix,
+    type ObsidianLiveSyncSettings,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { parseYaml, stringifyYaml, type Editor, type MarkdownView } from "@/deps";
 import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
 import { AbstractModule } from "@/modules/AbstractModule.ts";
-import type { ServiceContext } from "@lib/services/base/ServiceBase.ts";
-import type { InjectableServiceHub } from "@lib/services/InjectableServices.ts";
+import type { ServiceContext } from "@vrtmrz/livesync-commonlib/context";
+import type { InjectableServiceHub } from "@vrtmrz/livesync-commonlib/compat/services/implements/injectable/InjectableServiceHub";
 import type { LiveSyncCore } from "@/main.ts";
 const SETTING_HEADER = "````yaml:livesync-setting\n";
 const SETTING_FOOTER = "\n````";
@@ -28,7 +32,7 @@ export class ModuleObsidianSettingsAsMarkdown extends AbstractModule {
         this.addCommand({
             id: "livesync-import-config",
             name: "Parse setting file",
-            editorCheckCallback: (checking, editor, ctx) => {
+            editorCheckCallback: (checking: boolean, editor: Editor, ctx: MarkdownView) => {
                 if (checking) {
                     const doc = editor.getValue();
                     const ret = this.extractSettingFromWholeText(doc);
@@ -104,7 +108,11 @@ export class ModuleObsidianSettingsAsMarkdown extends AbstractModule {
         const { body } = await this.parseSettingFromMarkdown(filename);
         let newSetting = {} as Partial<ObsidianLiveSyncSettings>;
         try {
-            newSetting = parseYaml(body);
+            const parsed: unknown = parseYaml(body);
+            if (typeof parsed !== "object" || parsed === null) {
+                throw new TypeError("The YAML settings must contain an object");
+            }
+            newSetting = parsed;
         } catch (ex) {
             this._log("Could not parse YAML", LOG_LEVEL_NOTICE);
             this._log(ex, LOG_LEVEL_VERBOSE);

src/modules/features/ModuleObsidianSettingTab.ts

@@ -3,6 +3,7 @@ import { AbstractObsidianModule } from "@/modules/AbstractObsidianModule.ts";
 // import { PouchDB } from "../../lib/src/pouchdb/pouchdb-browser";
 import { EVENT_REQUEST_OPEN_SETTING_WIZARD, EVENT_REQUEST_OPEN_SETTINGS, eventHub } from "@/common/events.ts";
 import type { LiveSyncCore } from "@/main.ts";
+import { openObsidianSettings } from "@/common/obsidianSettings.ts";
 
 export class ModuleObsidianSettingDialogue extends AbstractObsidianModule {
     settingTab!: ObsidianLiveSyncSettingTab;
@@ -20,11 +21,7 @@ export class ModuleObsidianSettingDialogue extends AbstractObsidianModule {
     }
 
     openSetting() {
-        // Undocumented API
-        //@ts-ignore
-        this.app.setting.open();
-        //@ts-ignore
-        this.app.setting.openTabById("obsidian-livesync");
+        openObsidianSettings(this.app, "obsidian-livesync");
     }
 
     get appId() {

src/modules/features/RemoteActivityStatus.ts

@@ -0,0 +1,27 @@
+/** Status icon for a finite remote operation whose lifetime is known. */
+export const REMOTE_OPERATION_ACTIVITY_ICON = "📲";
+
+/** Status icon for approximate physical remote-request activity. */
+export const REMOTE_REQUEST_ACTIVITY_ICON = "🌐";
+
+/** Avoids hiding very short remote requests before the status bar can render them. */
+export const REMOTE_REQUEST_ACTIVITY_MINIMUM_VISIBLE_MS = 150;
+
+export type RemoteActivityStatus = {
+    remoteOperationCount: number;
+    trackedRequestCount: number;
+};
+
+/** Returns the non-negative difference between tracked request starts and completions. */
+export function getTrackedRequestCount(requestCount: number, responseCount: number): number {
+    return Math.max(0, requestCount - responseCount);
+}
+
+/** Formats the compact prefix shown before the replication status. */
+export function formatRemoteActivityStatusLabel(status: RemoteActivityStatus): string {
+    const labels = [
+        status.remoteOperationCount > 0 ? REMOTE_OPERATION_ACTIVITY_ICON : "",
+        status.trackedRequestCount > 0 ? `${REMOTE_REQUEST_ACTIVITY_ICON}${status.trackedRequestCount}` : "",
+    ].filter((label) => label !== "");
+    return labels.length > 0 ? `${labels.join(" ")} ` : "";
+}

src/modules/features/RemoteActivityStatus.unit.spec.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+
+import {
+    REMOTE_OPERATION_ACTIVITY_ICON,
+    REMOTE_REQUEST_ACTIVITY_ICON,
+    formatRemoteActivityStatusLabel,
+    getTrackedRequestCount,
+} from "./RemoteActivityStatus.ts";
+
+describe("getTrackedRequestCount", () => {
+    it("reports the non-negative difference between starts and completions", () => {
+        expect(getTrackedRequestCount(3, 2)).toBe(1);
+        expect(getTrackedRequestCount(2, 2)).toBe(0);
+        expect(getTrackedRequestCount(2, 3)).toBe(0);
+    });
+});
+
+describe("formatRemoteActivityStatusLabel", () => {
+    it("separates a finite remote operation from tracked physical requests", () => {
+        expect(formatRemoteActivityStatusLabel({ remoteOperationCount: 1, trackedRequestCount: 0 })).toBe(
+            `${REMOTE_OPERATION_ACTIVITY_ICON} `
+        );
+        expect(formatRemoteActivityStatusLabel({ remoteOperationCount: 0, trackedRequestCount: 1 })).toBe(
+            `${REMOTE_REQUEST_ACTIVITY_ICON}1 `
+        );
+        expect(formatRemoteActivityStatusLabel({ remoteOperationCount: 1, trackedRequestCount: 2 })).toBe(
+            `${REMOTE_OPERATION_ACTIVITY_ICON} ${REMOTE_REQUEST_ACTIVITY_ICON}2 `
+        );
+    });
+
+    it("omits inactive and invalid negative activity counts", () => {
+        expect(formatRemoteActivityStatusLabel({ remoteOperationCount: 0, trackedRequestCount: 0 })).toBe("");
+        expect(formatRemoteActivityStatusLabel({ remoteOperationCount: -1, trackedRequestCount: -1 })).toBe("");
+    });
+});

src/modules/features/SettingDialogue/InfoPanel.svelte

@@ -4,7 +4,7 @@
      * Mostly used in the Setting Dialogue
      */
     import { type SveltePanelProps } from "./SveltePanel";
-    import InfoTable from "@lib/UI/components/InfoTable.svelte";
+    import InfoTable from "@/modules/services/LiveSyncUI/components/InfoTable.svelte";
     type Props = SveltePanelProps<{
         info: Record<string, any>;
     }>;

src/modules/features/SettingDialogue/LiveSyncSetting.ts

@@ -8,7 +8,7 @@ import {
     type ValueComponent,
 } from "@/deps.ts";
 import { unique } from "octagonal-wheels/collection";
-import { LEVEL_ADVANCED, LEVEL_POWER_USER, statusDisplay, type ConfigurationItem } from "@lib/common/types.ts";
+import { LEVEL_ADVANCED, LEVEL_POWER_USER, statusDisplay, type ConfigurationItem } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { type ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import {
     type AllSettingItemKey,
@@ -18,7 +18,7 @@ import {
     type AllNumericItemKey,
     type AllBooleanItemKey,
 } from "./settingConstants.ts";
-import { $msg } from "@lib/common/i18n.ts";
+import { $msg } from "@/common/translation";
 import { wrapMemo, type AutoWireOption, type OnUpdateResult } from "./SettingPane.ts";
 
 export class LiveSyncSetting extends Setting {
@@ -206,7 +206,8 @@ export class LiveSyncSetting extends Setting {
             const setValue = wrapMemo((value: boolean) => {
                 toggle.setValue(opt?.invert ? !value : value);
             });
-            this.invalidateValue = () => setValue(LiveSyncSetting.env.editingSettings[key] ?? false);
+            this.invalidateValue = () =>
+                setValue(LiveSyncSetting.env.editingSettings[key] ?? opt?.defaultToggleValue ?? false);
             this.invalidateValue();
 
             toggle.onChange(async (value) => {

src/modules/features/SettingDialogue/MultipleRegExpControl.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
-    import type { CustomRegExpSource } from "@lib/common/types";
-    import { isInvertedRegExp, isValidRegExp } from "@lib/common/utils";
+    import type { CustomRegExpSource } from "@vrtmrz/livesync-commonlib/compat/common/types";
+    import { isInvertedRegExp, isValidRegExp } from "@vrtmrz/livesync-commonlib/compat/common/utils";
 
     export let patterns = [] as CustomRegExpSource[];
     export let originals = [] as CustomRegExpSource[];

src/modules/features/SettingDialogue/ObsidianLiveSyncSettingTab.ts

@@ -12,15 +12,14 @@ import {
     LEVEL_ADVANCED,
     LEVEL_EDGE_CASE,
     REMOTE_P2P,
-} from "@lib/common/types.ts";
-import { delay, isObjectDifferent, sizeToHumanReadable } from "@lib/common/utils.ts";
-import { versionNumberString2Number } from "@lib/string_and_binary/convert.ts";
-import { Logger } from "@lib/common/logger.ts";
-import { checkSyncInfo } from "@lib/pouchdb/negotiation.ts";
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { delay, isObjectDifferent, sizeToHumanReadable } from "@vrtmrz/livesync-commonlib/compat/common/utils";
+import { Logger } from "@vrtmrz/livesync-commonlib/compat/common/logger";
+import { checkSyncInfo } from "@vrtmrz/livesync-commonlib/compat/pouchdb/negotiation";
 import { testCrypt } from "octagonal-wheels/encryption/encryption";
 import ObsidianLiveSyncPlugin from "@/main.ts";
 import { scheduleTask } from "@/common/utils.ts";
-import { LiveSyncCouchDBReplicator } from "@lib/replication/couchdb/LiveSyncReplicator.ts";
+import { LiveSyncCouchDBReplicator } from "@vrtmrz/livesync-commonlib/compat/replication/couchdb/LiveSyncReplicator";
 import {
     type AllSettingItemKey,
     type AllStringItemKey,
@@ -31,10 +30,9 @@ import {
     type OnDialogSettings,
     getConfName,
 } from "./settingConstants.ts";
-import { $msg } from "@lib/common/i18n.ts";
+import { $msg } from "@/common/translation";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import { fireAndForget, yieldNextAnimationFrame } from "octagonal-wheels/promises";
-import { confirmWithMessage } from "@/modules/coreObsidian/UILib/dialogs.ts";
 import { EVENT_REQUEST_RELOAD_SETTING_TAB, eventHub } from "@/common/events.ts";
 import { paneChangeLog } from "./PaneChangeLog.ts";
 import {
@@ -62,9 +60,10 @@ import { paneAdvanced } from "./PaneAdvanced.ts";
 import { panePowerUsers } from "./PanePowerUsers.ts";
 import { panePatches } from "./PanePatches.ts";
 import { paneMaintenance } from "./PaneMaintenance.ts";
-import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
-import { JournalSyncCore } from "@lib/replication/journal/JournalSyncCore.js";
-import { MinioStorageAdapter } from "@lib/replication/journal/objectstore/MinioStorageAdapter.js";
+import { compatGlobal } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
+import { JournalSyncCore } from "@vrtmrz/livesync-commonlib/compat/replication/journal/JournalSyncCore";
+import { MinioStorageAdapter } from "@vrtmrz/livesync-commonlib/compat/replication/journal/objectstore/MinioStorageAdapter";
+import { closeObsidianSettings } from "@/common/obsidianSettings.ts";
 
 // For creating a document
 // const toc = new Set<string>();
@@ -101,6 +100,14 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
     // Buffered Settings for comparing.
     initialSettings?: typeof this.editingSettings;
 
+    private copySettingValue(target: object | undefined, source: object, key: AllSettingItemKey): void {
+        if (!target) {
+            throw new Error("Initial settings have not been loaded");
+        }
+        const value: unknown = Reflect.get(source, key);
+        Reflect.set(target, key, value);
+    }
+
     /**
      * Apply editing setting to the plug-in.
      * @param keys setting keys for applying
@@ -113,10 +120,8 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                 // this.initialSettings[k] = this.editingSettings[k];
                 continue;
             }
-            //@ts-ignore
-            this.core.settings[k] = this.editingSettings[k];
-            //@ts-ignore
-            this.initialSettings[k] = this.core.settings[k];
+            this.copySettingValue(this.core.settings, this.editingSettings, k);
+            this.copySettingValue(this.initialSettings, this.core.settings, k);
         }
         keys.forEach((e) => this.refreshSetting(e));
     }
@@ -151,14 +156,11 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             appliedKeys.push(k);
             if (k in OnDialogSettingsDefault) {
                 await this.saveLocalSetting(k as keyof OnDialogSettings);
-                //@ts-ignore
-                this.initialSettings[k] = this.editingSettings[k];
+                this.copySettingValue(this.initialSettings, this.editingSettings, k);
                 continue;
             }
-            //@ts-ignore
-            this.core.settings[k] = this.editingSettings[k];
-            //@ts-ignore
-            this.initialSettings[k] = this.core.settings[k];
+            this.copySettingValue(this.core.settings, this.editingSettings, k);
+            this.copySettingValue(this.initialSettings, this.core.settings, k);
             hasChanged = true;
         }
 
@@ -236,15 +238,11 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
         const localSetting = this.reloadAllLocalSettings();
         if (key in this.core.settings) {
             if (key in localSetting) {
-                //@ts-ignore
-                this.initialSettings[key] = localSetting[key];
-                //@ts-ignore
-                this.editingSettings[key] = localSetting[key];
+                this.copySettingValue(this.initialSettings, localSetting, key);
+                this.copySettingValue(this.editingSettings, localSetting, key);
             } else {
-                //@ts-ignore
-                this.initialSettings[key] = this.core.settings[key];
-                //@ts-ignore
-                this.editingSettings[key] = this.initialSettings[key];
+                this.copySettingValue(this.initialSettings, this.core.settings, key);
+                this.copySettingValue(this.editingSettings, this.initialSettings ?? {}, key);
             }
         }
         this.editingSettings = { ...this.editingSettings, ...this.computeAllLocalSettings() };
@@ -310,8 +308,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
     }
 
     closeSetting() {
-        //@ts-ignore :
-        this.plugin.app.setting.close();
+        closeObsidianSettings(this.plugin.app);
     }
 
     handleElement(element: HTMLElement, func: OnUpdateFunc) {
@@ -417,11 +414,6 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
         }
     }
 
-    //@ts-ignore
-    manifestVersion: string = MANIFEST_VERSION || "-";
-
-    lastVersion = ~~(versionNumberString2Number(this.manifestVersion) / 1000);
-
     screenElements: { [key: string]: HTMLElement[] } = {};
     changeDisplay(screen: string) {
         for (const k in this.screenElements) {
@@ -480,7 +472,6 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
     isNeedRebuildLocal() {
         return this.isSomeDirty([
             "useIndexedDBAdapter",
-            "doNotUseFixedRevisionForChunks",
             "handleFilenameCaseSensitive",
             "passphrase",
             "useDynamicIterationCount",
@@ -491,7 +482,6 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
     }
     isNeedRebuildRemote() {
         return this.isSomeDirty([
-            "doNotUseFixedRevisionForChunks",
             "handleFilenameCaseSensitive",
             "passphrase",
             "useDynamicIterationCount",
@@ -623,7 +613,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             OPTION_ONLY_SETTING,
             OPTION_CANCEL,
         ];
-        const result = await confirmWithMessage(this.plugin, title, note, buttons, OPTION_CANCEL, 0);
+        const result = await this.core.confirm.confirmWithMessage(title, note, buttons, OPTION_CANCEL);
         if (result == OPTION_CANCEL) return;
         if (result == OPTION_FETCH) {
             if (!(await this.checkWorkingPassphrase())) {
@@ -736,7 +726,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                             value: `${order}`,
                             cls: "sls-setting-tab",
                         } as DomElementInfo);
-                        el.createEl("div", {
+                        el.createDiv({
                             cls: "sls-setting-menu-btn",
                             text: icon,
                             title: title,
@@ -829,18 +819,10 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
 
         void yieldNextAnimationFrame().then(() => {
             if (this.selectedScreen == "") {
-                if (this.lastVersion != this.editingSettings.lastReadUpdates) {
-                    if (this.editingSettings.isConfigured) {
-                        changeDisplay("100");
-                    } else {
-                        changeDisplay("110");
-                    }
+                if (this.isAnySyncEnabled()) {
+                    changeDisplay("20");
                 } else {
-                    if (this.isAnySyncEnabled()) {
-                        changeDisplay("20");
-                    } else {
-                        changeDisplay("110");
-                    }
+                    changeDisplay("110");
                 }
             } else {
                 changeDisplay(this.selectedScreen);

src/modules/features/SettingDialogue/PaneAdvanced.ts

@@ -1,4 +1,4 @@
-import { ChunkAlgorithmNames } from "@lib/common/types.ts";
+import { ChunkAlgorithmNames } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import type { PageFunctions } from "./SettingPane.ts";
@@ -35,7 +35,9 @@ export function paneAdvanced(this: ObsidianLiveSyncSettingTab, paneEl: HTMLEleme
             clampMin: 10,
             onUpdate: this.onlyOnCouchDB,
         });
-        new Setting(paneEl).setClass("wizardHidden").autoWireToggle("autoAcceptCompatibleTweak");
+        new Setting(paneEl)
+            .setClass("wizardHidden")
+            .autoWireToggle("autoAcceptCompatibleTweak", { defaultToggleValue: true });
         // new Setting(paneEl)
         //     .setClass("wizardHidden")
         //     .autoWireToggle("sendChunksBulk", { onUpdate: onlyOnCouchDB })
@@ -45,4 +47,7 @@ export function paneAdvanced(this: ObsidianLiveSyncSettingTab, paneEl: HTMLEleme
         //         clampMax: 100, clampMin: 1, onUpdate: onlyOnCouchDB
         //     })
     });
+    void addPanel(paneEl, "Remote Database Tweak").then((paneEl) => {
+        new Setting(paneEl).setClass("wizardHidden").autoWireToggle("enableCompression");
+    });
 }

src/modules/features/SettingDialogue/PaneChangeLog.ts

@@ -1,61 +1,11 @@
 import { MarkdownRenderer } from "@/deps.ts";
-import { versionNumberString2Number } from "@lib/string_and_binary/convert.ts";
-import { $msg } from "@lib/common/i18n.ts";
 import { fireAndForget } from "octagonal-wheels/promises";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
-import { visibleOnly } from "./SettingPane.ts";
-//@ts-ignore
-const manifestVersion: string = MANIFEST_VERSION || "-";
-//@ts-ignore
+declare const UPDATE_INFO: string;
 const updateInformation: string = UPDATE_INFO || "";
 
-const lastVersion = ~~(versionNumberString2Number(manifestVersion) / 1000);
 export function paneChangeLog(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElement): void {
-    const cx = this.createEl(
-        paneEl,
-        "div",
-        {
-            cls: "op-warn-info",
-        },
-        undefined,
-        visibleOnly(() => !this.isConfiguredAs("versionUpFlash", ""))
-    );
-    this.createEl(
-        cx,
-        "div",
-        {
-            text: this.editingSettings.versionUpFlash,
-        },
-        undefined
-    );
-    this.createEl(cx, "button", { text: $msg("obsidianLiveSyncSettingTab.btnGotItAndUpdated") }, (e) => {
-        e.addClass("mod-cta");
-        e.addEventListener("click", () => {
-            fireAndForget(async () => {
-                this.editingSettings.versionUpFlash = "";
-                await this.saveAllDirtySettings();
-            });
-        });
-    });
     const informationDivEl = this.createEl(paneEl, "div", { text: "" });
-    const tmpDiv = createDiv();
-    // tmpDiv.addClass("sls-header-button");
-    tmpDiv.addClass("op-warn-info");
-
-    tmpDiv.createEl("p", { text: $msg("obsidianLiveSyncSettingTab.msgNewVersionNote") });
-    const readEverythingButton = tmpDiv.createEl("button", {
-        text: $msg("obsidianLiveSyncSettingTab.optionOkReadEverything"),
-    });
-    if (lastVersion > (this.editingSettings?.lastReadUpdates || 0)) {
-        const informationButtonDiv = informationDivEl.appendChild(tmpDiv);
-        readEverythingButton.addEventListener("click", () => {
-            fireAndForget(async () => {
-                this.editingSettings.lastReadUpdates = lastVersion;
-                await this.saveAllDirtySettings();
-                informationButtonDiv.remove();
-            });
-        });
-    }
     fireAndForget(() =>
         MarkdownRenderer.render(this.plugin.app, updateInformation, informationDivEl, "/", this.lifetimeComponent)
     );

src/modules/features/SettingDialogue/PaneGeneral.ts

@@ -1,11 +1,11 @@
-import { $msg, $t } from "@lib/common/i18n.ts";
-import { SUPPORTED_I18N_LANGS, type I18N_LANGS } from "@lib/common/rosetta.ts";
+import { $msg, $t } from "@/common/translation";
+import { SUPPORTED_I18N_LANGS, type I18N_LANGS } from "@/common/rosetta";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import type { PageFunctions } from "./SettingPane.ts";
 import { visibleOnly } from "./SettingPane.ts";
 import { EVENT_ON_UNRESOLVED_ERROR, eventHub } from "@/common/events.ts";
-import { NetworkWarningStyles } from "@lib/common/models/setting.const.ts";
+import { NetworkWarningStyles } from "@vrtmrz/livesync-commonlib/compat/common/models/setting.const";
 export function paneGeneral(
     this: ObsidianLiveSyncSettingTab,
     paneEl: HTMLElement,

src/modules/features/SettingDialogue/PaneMaintenance.ts

@@ -1,8 +1,8 @@
 import { EVENT_REQUEST_PERFORM_GC_V3, eventHub } from "@/common/events.ts";
-import { LOG_LEVEL_NOTICE, Logger } from "@lib/common/logger.ts";
-import { FlagFilesHumanReadable, FLAGMD_REDFLAG } from "@lib/common/types.ts";
-import { fireAndForget } from "@lib/common/utils.ts";
-import { LiveSyncCouchDBReplicator } from "@lib/replication/couchdb/LiveSyncReplicator.ts";
+import { LOG_LEVEL_NOTICE, Logger } from "@vrtmrz/livesync-commonlib/compat/common/logger";
+import { FlagFilesHumanReadable, FLAGMD_REDFLAG } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { fireAndForget } from "@vrtmrz/livesync-commonlib/compat/common/utils";
+import { LiveSyncCouchDBReplicator } from "@vrtmrz/livesync-commonlib/compat/replication/couchdb/LiveSyncReplicator";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab";
 import { visibleOnly, type PageFunctions } from "./SettingPane";
@@ -187,7 +187,7 @@ export function paneMaintenance(
             )
             .addOnUpdate(this.onlyOnMinIO);
     });
-    void addPanel(paneEl, "Garbage Collection V3 (Beta)", (e) => e, this.onlyOnP2POrCouchDB).then((paneEl) => {
+    void addPanel(paneEl, "Garbage Collection V3 (Beta)", (e) => e, this.onlyOnCouchDB).then((paneEl) => {
         new Setting(paneEl)
             .setName("Perform Garbage Collection")
             .setDesc("Perform Garbage Collection to remove unused chunks and reduce database size.")

src/modules/features/SettingDialogue/PanePatches.ts

@@ -4,14 +4,14 @@ import {
     type HashAlgorithm,
     LOG_LEVEL_NOTICE,
     SuffixDatabaseName,
-} from "@lib/common/types.ts";
-import { Logger } from "@lib/common/logger.ts";
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { Logger } from "@vrtmrz/livesync-commonlib/compat/common/logger";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import type { PageFunctions } from "./SettingPane.ts";
 import { visibleOnly } from "./SettingPane.ts";
-import { PouchDB } from "@lib/pouchdb/pouchdb-browser";
-import { ExtraSuffixIndexedDB } from "@lib/common/types.ts";
+import { PouchDB } from "@vrtmrz/livesync-commonlib/compat/pouchdb/pouchdb-browser";
+import { ExtraSuffixIndexedDB } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { migrateDatabases } from "./settingUtils.ts";
 
 export function panePatches(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElement, { addPanel }: PageFunctions): void {
@@ -188,7 +188,7 @@ export function panePatches(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElemen
                     }
                     this.requestUpdate();
                 };
-                text.inputEl.before((dateEl = activeDocument.createElement("span")));
+                text.inputEl.before((dateEl = activeDocument.createSpan()));
                 text.inputEl.type = "datetime-local";
                 if (this.editingSettings.maxMTimeForReflectEvents > 0) {
                     const date = new Date(this.editingSettings.maxMTimeForReflectEvents);
@@ -231,15 +231,4 @@ export function panePatches(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElemen
             }
         });
     });
-    void addPanel(paneEl, "Remote Database Tweak (In sunset)").then((paneEl) => {
-        // new Setting(paneEl).autoWireToggle("useEden").setClass("wizardHidden");
-        // const onlyUsingEden = visibleOnly(() => this.isConfiguredAs("useEden", true));
-        // new Setting(paneEl).autoWireNumeric("maxChunksInEden", { onUpdate: onlyUsingEden }).setClass("wizardHidden");
-        // new Setting(paneEl)
-        //     .autoWireNumeric("maxTotalLengthInEden", { onUpdate: onlyUsingEden })
-        //     .setClass("wizardHidden");
-        // new Setting(paneEl).autoWireNumeric("maxAgeInEden", { onUpdate: onlyUsingEden }).setClass("wizardHidden");
-
-        new Setting(paneEl).autoWireToggle("enableCompression").setClass("wizardHidden");
-    });
 }

src/modules/features/SettingDialogue/PanePowerUsers.ts

@@ -1,4 +1,4 @@
-import { type ConfigPassphraseStore } from "@lib/common/types.ts";
+import { type ConfigPassphraseStore } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import type { PageFunctions } from "./SettingPane.ts";

src/modules/features/SettingDialogue/PaneRemoteConfig.ts

@@ -6,9 +6,9 @@ import {
     LOG_LEVEL_NOTICE,
     type ObsidianLiveSyncSettings,
     LOG_LEVEL_VERBOSE,
-} from "@lib/common/types.ts";
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { Menu, type ButtonComponent } from "@/deps.ts";
-import { $msg } from "@lib/common/i18n.ts";
+import { $msg } from "@/common/translation";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import type { PageFunctions } from "./SettingPane.ts";
@@ -16,23 +16,23 @@ import type { PageFunctions } from "./SettingPane.ts";
 import InfoPanel from "./InfoPanel.svelte";
 import { writable } from "svelte/store";
 import { SveltePanel } from "./SveltePanel.ts";
-import {
-    getBucketConfigSummary,
-    getP2PConfigSummary,
-    getCouchDBConfigSummary,
-    getE2EEConfigSummary,
-} from "./settingUtils.ts";
-import { SETTING_KEY_P2P_DEVICE_NAME } from "@lib/common/types.ts";
+import { getE2EEConfigSummary } from "./settingUtils.ts";
 import { SetupManager, UserMode } from "@/modules/features/SetupManager.ts";
 import { OnDialogSettingsDefault, type AllSettings } from "./settingConstants.ts";
-import { activateRemoteConfiguration } from "@lib/serviceFeatures/remoteConfig.ts";
-import { ConnectionStringParser } from "@lib/common/ConnectionString.ts";
-import type { RemoteConfigurationResult } from "@lib/common/ConnectionString.ts";
-import type { RemoteConfiguration } from "@lib/common/models/setting.type.ts";
+import {
+    activateRemoteConfiguration,
+    type RemoteConfiguration,
+} from "@vrtmrz/livesync-commonlib/remote-configurations";
+import { ConnectionStringParser } from "@vrtmrz/livesync-commonlib/compat/common/ConnectionString";
+import type { RemoteConfigurationResult } from "@vrtmrz/livesync-commonlib/compat/common/ConnectionString";
 import SetupRemote from "@/modules/features/SetupWizard/dialogs/SetupRemote.svelte";
 import SetupRemoteCouchDB from "@/modules/features/SetupWizard/dialogs/SetupRemoteCouchDB.svelte";
 import SetupRemoteBucket from "@/modules/features/SetupWizard/dialogs/SetupRemoteBucket.svelte";
 import SetupRemoteP2P from "@/modules/features/SetupWizard/dialogs/SetupRemoteP2P.svelte";
+import type {
+    SetupRemoteCouchDBInitialData,
+    SetupRemoteCouchDBResultType,
+} from "@/modules/features/SetupWizard/dialogs/setupDialogTypes.ts";
 import { syncActivatedRemoteSettings } from "./remoteConfigBuffer.ts";
 
 function getSettingsFromEditingSettings(editingSettings: AllSettings): ObsidianLiveSyncSettings {
@@ -43,15 +43,6 @@ function getSettingsFromEditingSettings(editingSettings: AllSettings): ObsidianL
     }
     return workObj;
 }
-const toggleActiveSyncClass = (el: HTMLElement, isActive: () => boolean) => {
-    if (isActive()) {
-        el.addClass("active-pane");
-    } else {
-        el.removeClass("active-pane");
-    }
-    return {};
-};
-
 function createRemoteConfigurationId(): string {
     return `remote-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -142,8 +133,8 @@ export function paneRemoteConfig(
     }
     {
         // TODO: very WIP. need to refactor the UI.
-        void addPanel(paneEl, $msg("obsidianLiveSyncSettingTab.titleRemoteServer"), () => {}).then((paneEl) => {
-            const actions = new Setting(paneEl).setName("Remote Databases");
+        void addPanel(paneEl, $msg("Connection settings"), () => {}).then((paneEl) => {
+            const actions = new Setting(paneEl).setName($msg("Saved connections"));
             // actions.addButton((button) =>
             //     button
             //         .setButtonText("Change Remote and Setup")
@@ -229,7 +220,13 @@ export function paneRemoteConfig(
                     return { ...baseSettings, ...p2pConf, remoteType: REMOTE_P2P };
                 }
 
-                const couchConf = await dialogManager.openWithExplicitCancel(SetupRemoteCouchDB, baseSettings);
+                const couchConf = await dialogManager.openWithExplicitCancel<
+                    SetupRemoteCouchDBResultType,
+                    SetupRemoteCouchDBInitialData
+                >(SetupRemoteCouchDB, {
+                    settings: baseSettings,
+                    mode: "settings",
+                });
                 if (couchConf === "cancelled" || typeof couchConf !== "object") {
                     return false;
                 }
@@ -517,123 +514,6 @@ export function paneRemoteConfig(
             refreshList();
         });
     }
-    // eslint-disable-next-line no-constant-condition
-    if (false) {
-        const initialProps = {
-            info: getCouchDBConfigSummary(this.editingSettings),
-        };
-        const summaryWritable = writable(initialProps);
-        const updateSummary = () => {
-            summaryWritable.set({
-                info: getCouchDBConfigSummary(this.editingSettings),
-            });
-        };
-        void addPanel(paneEl, $msg("obsidianLiveSyncSettingTab.titleCouchDB"), () => {}).then((paneEl) => {
-            new SveltePanel(InfoPanel, paneEl, summaryWritable);
-            const setupButton = new Setting(paneEl).setName("Configure Remote");
-            setupButton
-                .addButton((button) =>
-                    button
-                        .setButtonText("Configure")
-                        .setCta()
-                        .onClick(async () => {
-                            const setupManager = this.core.getModule(SetupManager);
-                            const originalSettings = getSettingsFromEditingSettings(this.editingSettings);
-                            await setupManager.onCouchDBManualSetup(
-                                UserMode.Update,
-                                originalSettings,
-                                this.editingSettings.remoteType === REMOTE_COUCHDB
-                            );
-
-                            updateSummary();
-                        })
-                )
-                .addOnUpdate(() =>
-                    toggleActiveSyncClass(paneEl, () => this.editingSettings.remoteType === REMOTE_COUCHDB)
-                );
-        });
-    }
-    // eslint-disable-next-line no-constant-condition
-    if (false) {
-        const initialProps = {
-            info: getBucketConfigSummary(this.editingSettings),
-        };
-        const summaryWritable = writable(initialProps);
-        const updateSummary = () => {
-            summaryWritable.set({
-                info: getBucketConfigSummary(this.editingSettings),
-            });
-        };
-        void addPanel(paneEl, $msg("obsidianLiveSyncSettingTab.titleMinioS3R2"), () => {}).then((paneEl) => {
-            new SveltePanel(InfoPanel, paneEl, summaryWritable);
-            const setupButton = new Setting(paneEl).setName("Configure Remote");
-            setupButton
-                .addButton((button) =>
-                    button
-                        .setButtonText("Configure")
-                        .setCta()
-                        .onClick(async () => {
-                            const setupManager = this.core.getModule(SetupManager);
-                            const originalSettings = getSettingsFromEditingSettings(this.editingSettings);
-                            await setupManager.onBucketManualSetup(
-                                UserMode.Update,
-                                originalSettings,
-                                this.editingSettings.remoteType === REMOTE_MINIO
-                            );
-                            //TODO
-                            updateSummary();
-                        })
-                )
-                .addOnUpdate(() =>
-                    toggleActiveSyncClass(paneEl, () => this.editingSettings.remoteType === REMOTE_MINIO)
-                );
-        });
-    }
-    // eslint-disable-next-line no-constant-condition
-    if (false) {
-        const getDevicePeerId = () => this.services.config.getSmallConfig(SETTING_KEY_P2P_DEVICE_NAME) || "";
-        const initialProps = {
-            info: getP2PConfigSummary(this.editingSettings, {
-                "Device Peer ID": getDevicePeerId(),
-            }),
-        };
-        const summaryWritable = writable(initialProps);
-        const updateSummary = () => {
-            summaryWritable.set({
-                info: getP2PConfigSummary(this.editingSettings, {
-                    "Device Peer ID": getDevicePeerId(),
-                }),
-            });
-        };
-        void addPanel(paneEl, "Peer-to-Peer Synchronisation", () => {}).then((paneEl) => {
-            new SveltePanel(InfoPanel, paneEl, summaryWritable);
-            const setupButton = new Setting(paneEl).setName("Configure Remote");
-            setupButton
-                .addButton((button) =>
-                    button
-                        .setButtonText("Configure")
-                        .setCta()
-                        .onClick(async () => {
-                            const setupManager = this.core.getModule(SetupManager);
-                            const originalSettings = getSettingsFromEditingSettings(this.editingSettings);
-                            await setupManager.onP2PManualSetup(
-                                UserMode.Update,
-                                originalSettings,
-                                this.editingSettings.remoteType === REMOTE_P2P
-                            );
-                            //TODO
-                            updateSummary();
-                        })
-                )
-                .addOnUpdate(() =>
-                    toggleActiveSyncClass(
-                        paneEl,
-                        () => this.editingSettings.remoteType === REMOTE_P2P || this.editingSettings.P2P_Enabled
-                    )
-                );
-        });
-    }
-
     // new Setting(paneEl)
     //     .setDesc("Generate ES256 Keypair for testing")
     //     .addButton((button) =>

src/modules/features/SettingDialogue/PaneSelector.ts

@@ -1,5 +1,5 @@
-import { LEVEL_ADVANCED, type CustomRegExpSource } from "@lib/common/types.ts";
-import { constructCustomRegExpList, splitCustomRegExpList } from "@lib/common/utils.ts";
+import { LEVEL_ADVANCED, type CustomRegExpSource } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { constructCustomRegExpList, splitCustomRegExpList } from "@vrtmrz/livesync-commonlib/compat/common/utils";
 import MultipleRegExpControl from "./MultipleRegExpControl.svelte";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import { mount } from "svelte";

src/modules/features/SettingDialogue/PaneSetup.ts

@@ -1,5 +1,5 @@
 import { MarkdownRenderer } from "@/deps.ts";
-import { $msg } from "@lib/common/i18n.ts";
+import { $msg } from "@/common/translation";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import { fireAndForget } from "octagonal-wheels/promises";
 import {
@@ -11,10 +11,13 @@ import {
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import type { PageFunctions } from "./SettingPane.ts";
 import { visibleOnly } from "./SettingPane.ts";
-import { DEFAULT_SETTINGS } from "@lib/common/types.ts";
 import { request } from "@/deps.ts";
-import { SetupManager, UserMode } from "@/modules/features/SetupManager.ts";
-import { LiveSyncError } from "@lib/common/LSError.ts";
+import { SetupManager } from "@/modules/features/SetupManager.ts";
+import { LiveSyncError } from "@vrtmrz/livesync-commonlib/compat/common/LSError";
+import {
+    createCoreSettingsAfterFullReset,
+    createEditingSettingsAfterFullReset,
+} from "@/serviceFeatures/setupObsidian/settingsReset.ts";
 export function paneSetup(
     this: ObsidianLiveSyncSettingTab,
     paneEl: HTMLElement,
@@ -37,8 +40,7 @@ export function paneSetup(
             .addButton((text) => {
                 text.setButtonText($msg("Rerun Wizard")).onClick(async () => {
                     const setupManager = this.core.getModule(SetupManager);
-                    await setupManager.onOnboard(UserMode.ExistingUser);
-                    // await this.plugin.moduleSetupObsidian.onBoardingWizard(true);
+                    await setupManager.startOnBoarding();
                 });
             });
 
@@ -92,9 +94,9 @@ export function paneSetup(
                                 { defaultOption: "No" }
                             )) == "yes"
                         ) {
-                            this.editingSettings = { ...this.editingSettings, ...DEFAULT_SETTINGS };
+                            this.editingSettings = createEditingSettingsAfterFullReset(this.editingSettings);
                             await this.saveAllDirtySettings();
-                            this.core.settings = { ...DEFAULT_SETTINGS };
+                            this.core.settings = createCoreSettingsAfterFullReset();
                             await this.services.setting.saveSettingData();
                             await this.services.database.resetDatabase();
                             // await this.plugin.initializeDatabase();

src/modules/features/SettingDialogue/PaneSyncSettings.ts

@@ -1,6 +1,6 @@
-import { type ObsidianLiveSyncSettings, LOG_LEVEL_NOTICE, REMOTE_COUCHDB, LEVEL_ADVANCED } from "@lib/common/types.ts";
-import { Logger } from "@lib/common/logger.ts";
-import { $msg } from "@lib/common/i18n.ts";
+import { type ObsidianLiveSyncSettings, LOG_LEVEL_NOTICE, REMOTE_COUCHDB, LEVEL_ADVANCED } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { Logger } from "@vrtmrz/livesync-commonlib/compat/common/logger";
+import { $msg } from "@/common/translation";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import { EVENT_REQUEST_COPY_SETUP_URI, eventHub } from "@/common/events.ts";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
@@ -222,8 +222,6 @@ export function paneSyncSettings(
         LEVEL_ADVANCED
     ).then((paneEl) => {
         paneEl.addClass("wizardHidden");
-        new Setting(paneEl).setClass("wizardHidden").autoWireToggle("trashInsteadDelete");
-
         new Setting(paneEl).setClass("wizardHidden").autoWireToggle("doNotDeleteFolder");
     });
     void addPanel(

src/modules/features/SettingDialogue/SettingPane.ts

@@ -1,5 +1,5 @@
-import { $msg } from "@lib/common/i18n";
-import { LEVEL_ADVANCED, LEVEL_EDGE_CASE, LEVEL_POWER_USER, type ConfigLevel } from "@lib/common/types";
+import { $msg } from "@/common/translation";
+import { LEVEL_ADVANCED, LEVEL_EDGE_CASE, LEVEL_POWER_USER, type ConfigLevel } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import type { AllSettingItemKey, AllSettings } from "./settingConstants";
 
 export const combineOnUpdate = (func1: OnUpdateFunc, func2: OnUpdateFunc): OnUpdateFunc => {
@@ -75,6 +75,7 @@ export type AutoWireOption = {
     holdValue?: boolean;
     isPassword?: boolean;
     invert?: boolean;
+    defaultToggleValue?: boolean;
     onUpdate?: OnUpdateFunc;
     obsolete?: boolean;
 };

src/modules/features/SettingDialogue/remoteConfigBuffer.ts

@@ -1,5 +1,5 @@
-import { pickBucketSyncSettings, pickCouchDBSyncSettings, pickP2PSyncSettings } from "@lib/common/utils.ts";
-import type { ObsidianLiveSyncSettings } from "@lib/common/types.ts";
+import { pickBucketSyncSettings, pickCouchDBSyncSettings, pickP2PSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/utils";
+import type { ObsidianLiveSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
 
 // Keep the setting dialogue buffer aligned with the current core settings before persisting other dirty keys.
 // This also clears stale dirty values left from editing a different remote type before switching active remotes.

src/modules/features/SettingDialogue/remoteConfigBuffer.unit.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { DEFAULT_SETTINGS, REMOTE_COUCHDB, REMOTE_MINIO } from "@lib/common/types";
+import { DEFAULT_SETTINGS, REMOTE_COUCHDB, REMOTE_MINIO } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { syncActivatedRemoteSettings } from "./remoteConfigBuffer";
 
 describe("syncActivatedRemoteSettings", () => {

src/modules/features/SettingDialogue/settingConstants.ts

@@ -1 +1 @@
-export * from "@lib/common/settingConstants.ts";
+export * from "@vrtmrz/livesync-commonlib/compat/common/settingConstants";

src/modules/features/SettingDialogue/settingUtils.ts

@@ -1,14 +1,16 @@
 import { escapeStringToHTML } from "octagonal-wheels/string";
-import { E2EEAlgorithmNames, MILESTONE_DOCID, NODEINFO_DOCID, type ObsidianLiveSyncSettings } from "@lib/common/types";
+import { E2EEAlgorithmNames, MILESTONE_DOCID, NODEINFO_DOCID, type ObsidianLiveSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import {
     pickCouchDBSyncSettings,
     pickBucketSyncSettings,
     pickP2PSyncSettings,
     pickEncryptionSettings,
-} from "@lib/common/utils";
+} from "@vrtmrz/livesync-commonlib/compat/common/utils";
 import { getConfig, type AllSettingItemKey } from "./settingConstants";
 import { LOG_LEVEL_NOTICE, Logger } from "octagonal-wheels/common/logger";
-import { isNotFoundError } from "@lib/common/utils.doc";
+import { isNotFoundError } from "@vrtmrz/livesync-commonlib/compat/common/utils.doc";
+import type PouchDB from "pouchdb-core";
+import type {} from "pouchdb-replication";
 
 /**
  * Generates a summary of P2P configuration settings
@@ -119,8 +121,7 @@ export async function migrateDatabases(operationName: string, from: PouchDB.Data
     Logger(`Destroyed existing destination database for migration: ${operationName}.`, LOG_LEVEL_NOTICE, "migration");
 
     const dbTo2 = await openTo();
-    const info2 = await dbTo2.info(); // ensure created
-    console.log(info2);
+    await dbTo2.info(); // ensure created
     Logger(`Re-created destination database for migration: ${operationName}.`, LOG_LEVEL_NOTICE, "migration");
 
     const info = await from.info();

src/modules/features/SettingDialogue/utilFixCouchDBSetting.ts

@@ -1,12 +1,18 @@
 import { requestToCouchDBWithCredentials } from "@/common/utils";
-import { $msg } from "@lib/common/i18n";
-import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, Logger } from "@lib/common/logger";
-import type { ObsidianLiveSyncSettings } from "@lib/common/types";
-import { fireAndForget, parseHeaderValues } from "@lib/common/utils";
-import { isCloudantURI } from "@lib/pouchdb/utils_couchdb";
-import { generateCredentialObject } from "@lib/replication/httplib";
-import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
-import { isUnauthorizedError } from "@lib/common/utils.doc";
+import { $msg } from "@/common/translation";
+import {
+    LOG_LEVEL_INFO,
+    LOG_LEVEL_NOTICE,
+    LOG_LEVEL_VERBOSE,
+    Logger,
+} from "@vrtmrz/livesync-commonlib/compat/common/logger";
+import type { ObsidianLiveSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { fireAndForget, parseHeaderValues } from "@vrtmrz/livesync-commonlib/compat/common/utils";
+import { isCloudantURI } from "@vrtmrz/livesync-commonlib/compat/pouchdb/utils_couchdb";
+import { generateCredentialObject } from "@vrtmrz/livesync-commonlib/compat/replication/httplib";
+import { compatGlobal } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
+import { isUnauthorizedError } from "@vrtmrz/livesync-commonlib/compat/common/utils.doc";
+import { normaliseCouchDBConfiguration } from "@/common/couchdbConfiguration";
 
 export const checkConfig = async (
     checkResultDiv: HTMLDivElement | undefined,
@@ -43,7 +49,7 @@ export const checkConfig = async (
             undefined,
             customHeaders
         );
-        const responseConfig = r.json;
+        const responseConfig = normaliseCouchDBConfiguration(r.json as unknown);
 
         const addConfigFixButton = (title: string, key: string, value: string) => {
             if (!checkResultDiv) return;

src/modules/features/SetupManager.ts

@@ -1,17 +1,16 @@
 import {
     type BucketSyncSetting,
-    type CouchDBConnection,
     type EncryptionSettings,
     type ObsidianLiveSyncSettings,
     type P2PSyncSetting,
-    DEFAULT_SETTINGS,
     LOG_LEVEL_NOTICE,
     LOG_LEVEL_VERBOSE,
     REMOTE_COUCHDB,
     REMOTE_MINIO,
-    REMOTE_P2P,
-} from "@lib/common/types.ts";
-import { isObjectDifferent } from "@lib/common/utils.ts";
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { createNewVaultSettings } from "@vrtmrz/livesync-commonlib/settings";
+import { upsertRemoteConfigurationInPlace } from "@vrtmrz/livesync-commonlib/remote-configurations";
+import { isObjectDifferent } from "@vrtmrz/livesync-commonlib/compat/common/utils";
 import Intro from "./SetupWizard/dialogs/Intro.svelte";
 import SelectMethodNewUser from "./SetupWizard/dialogs/SelectMethodNewUser.svelte";
 import SelectMethodExisting from "./SetupWizard/dialogs/SelectMethodExisting.svelte";
@@ -25,9 +24,8 @@ import SetupRemoteCouchDB from "./SetupWizard/dialogs/SetupRemoteCouchDB.svelte"
 import SetupRemoteBucket from "./SetupWizard/dialogs/SetupRemoteBucket.svelte";
 import SetupRemoteP2P from "./SetupWizard/dialogs/SetupRemoteP2P.svelte";
 import SetupRemoteE2EE from "./SetupWizard/dialogs/SetupRemoteE2EE.svelte";
-import { decodeSettingsFromQRCodeData } from "@lib/API/processSetting.ts";
+import { decodeSettingsFromQRCodeData } from "@vrtmrz/livesync-commonlib/compat/API/processSetting";
 import { AbstractModule } from "@/modules/AbstractModule.ts";
-import { ConnectionStringParser } from "@lib/common/ConnectionString.ts";
 import type {
     OutroAskUserModeResultType,
     OutroExistingUserResultType,
@@ -35,11 +33,24 @@ import type {
     ScanQRCodeResultType,
     SetupRemoteBucketResultType,
     SetupRemoteCouchDBResultType,
+    SetupRemoteCouchDBInitialData,
     SetupRemoteE2EEResultType,
     SetupRemoteP2PResultType,
     SetupRemoteResultType,
     UseSetupURIResultType,
 } from "./SetupWizard/dialogs/setupDialogTypes.ts";
+import {
+    applySettingsAndFetchOnActivation,
+    applySettingsWithScheduledInitialisation,
+} from "@/serviceFeatures/setupObsidian/setupActivationLifecycle.ts";
+import { isP2PMainRemote } from "@/common/remoteConfiguration.ts";
+
+function copySettingsForRemoteProfileUpdate(settings: ObsidianLiveSyncSettings): ObsidianLiveSyncSettings {
+    return {
+        ...settings,
+        remoteConfigurations: { ...(settings.remoteConfigurations ?? {}) },
+    };
+}
 
 /**
  * User modes for onboarding and setup
@@ -60,7 +71,7 @@ export const enum UserMode {
     /**
      * Update User Mode - for users who are updating configuration. May be `existing-user` as well, but possibly they want to treat it differently.
      */
-    // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+    // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values -- Update is a semantic alias for the unknown setup mode.
     Update = "unknown", // Alias for Unknown for better readability
 }
 
@@ -99,7 +110,7 @@ export class SetupManager extends AbstractModule {
      * @returns Promise that resolves to true if onboarding completed successfully, false otherwise
      */
     async onOnboard(userMode: UserMode): Promise<boolean> {
-        const originalSetting = userMode === UserMode.NewUser ? DEFAULT_SETTINGS : this.core.settings;
+        const originalSetting = userMode === UserMode.NewUser ? createNewVaultSettings() : this.core.settings;
         if (userMode === UserMode.NewUser) {
             //Ask how to apply initial setup
             const method = await this.dialogManager.openWithExplicitCancel(SelectMethodNewUser);
@@ -158,20 +169,30 @@ export class SetupManager extends AbstractModule {
         currentSetting: ObsidianLiveSyncSettings,
         activate = true
     ): Promise<boolean> {
-        const originalSetting = JSON.parse(JSON.stringify(currentSetting)) as ObsidianLiveSyncSettings;
-        const baseSetting = JSON.parse(JSON.stringify(originalSetting)) as ObsidianLiveSyncSettings;
         const couchConf = await this.dialogManager.openWithExplicitCancel<
             SetupRemoteCouchDBResultType,
-            CouchDBConnection
-        >(SetupRemoteCouchDB, originalSetting);
+            SetupRemoteCouchDBInitialData
+        >(SetupRemoteCouchDB, {
+            settings: currentSetting,
+            mode:
+                userMode === UserMode.NewUser
+                    ? "create-or-connect"
+                    : userMode === UserMode.ExistingUser
+                      ? "connect-existing"
+                      : "settings",
+        });
         if (couchConf === "cancelled") {
             this._log("Manual configuration cancelled.", LOG_LEVEL_NOTICE);
             return await this.onOnboard(userMode);
         }
-        const newSetting = { ...baseSetting, ...couchConf } as ObsidianLiveSyncSettings;
+        const newSetting = {
+            ...copySettingsForRemoteProfileUpdate(currentSetting),
+            ...couchConf,
+        } as ObsidianLiveSyncSettings;
         if (activate) {
             newSetting.remoteType = REMOTE_COUCHDB;
         }
+        upsertRemoteConfigurationInPlace(newSetting, "couchdb", { activate });
         return await this.onConfirmApplySettingsFromWizard(newSetting, userMode, activate);
     }
 
@@ -195,10 +216,14 @@ export class SetupManager extends AbstractModule {
             this._log("Manual configuration cancelled.", LOG_LEVEL_NOTICE);
             return await this.onOnboard(userMode);
         }
-        const newSetting = { ...currentSetting, ...bucketConf } as ObsidianLiveSyncSettings;
+        const newSetting = {
+            ...copySettingsForRemoteProfileUpdate(currentSetting),
+            ...bucketConf,
+        } as ObsidianLiveSyncSettings;
         if (activate) {
             newSetting.remoteType = REMOTE_MINIO;
         }
+        upsertRemoteConfigurationInPlace(newSetting, "s3", { activate });
         return await this.onConfirmApplySettingsFromWizard(newSetting, userMode, activate);
     }
 
@@ -222,26 +247,15 @@ export class SetupManager extends AbstractModule {
             this._log("Manual configuration cancelled.", LOG_LEVEL_NOTICE);
             return await this.onOnboard(userMode);
         }
-        const newSetting = { ...currentSetting, ...p2pConf } as ObsidianLiveSyncSettings;
-        // Apply remoteConfigurations
-        if (newSetting.P2P_ActiveRemoteConfigurationId) {
-            const id = newSetting.P2P_ActiveRemoteConfigurationId;
-            const merged = {
-                ...newSetting,
-                ...p2pConf,
-            } as ObsidianLiveSyncSettings;
-            const uri = ConnectionStringParser.serialize({ type: "p2p", settings: merged });
-            newSetting.remoteConfigurations[id] = {
-                ...newSetting.remoteConfigurations[id],
-                uri,
-                isEncrypted: false,
-            };
-            newSetting.P2P_ActiveRemoteConfigurationId = id;
-        }
-        if (activate) {
-            newSetting.remoteType = REMOTE_P2P;
-            newSetting.activeConfigurationId = newSetting.P2P_ActiveRemoteConfigurationId;
-        }
+        const newSetting = {
+            ...copySettingsForRemoteProfileUpdate(currentSetting),
+            ...p2pConf,
+        } as ObsidianLiveSyncSettings;
+        upsertRemoteConfigurationInPlace(newSetting, "p2p", {
+            id: newSetting.P2P_ActiveRemoteConfigurationId || undefined,
+            activate,
+            activateForP2P: true,
+        });
         return await this.onConfirmApplySettingsFromWizard(newSetting, userMode, activate);
     }
 
@@ -341,9 +355,9 @@ export class SetupManager extends AbstractModule {
             // console.dir(patch);
             if (!activate) {
                 extra();
-                await this.applySetting(newConf, UserMode.ExistingUser);
-                this._log("Setting Applied", LOG_LEVEL_NOTICE);
-                return true;
+                const applied = await this.applySettingAndScheduleFetchOnActivation(newConf, UserMode.ExistingUser);
+                if (applied) this._log("Setting Applied", LOG_LEVEL_NOTICE);
+                return applied;
             }
             // Check virtual changes
             const original = { ...this.settings, P2P_DevicePeerName: "" } as ObsidianLiveSyncSettings;
@@ -351,9 +365,9 @@ export class SetupManager extends AbstractModule {
             const isOnlyVirtualChange = isObjectDifferent(original, modified, true) === false;
             if (isOnlyVirtualChange) {
                 extra();
-                await this.applySetting(newConf, UserMode.ExistingUser);
-                this._log("Settings from wizard applied.", LOG_LEVEL_NOTICE);
-                return true;
+                const applied = await this.applySettingAndScheduleFetchOnActivation(newConf, UserMode.ExistingUser);
+                if (applied) this._log("Settings from wizard applied.", LOG_LEVEL_NOTICE);
+                return applied;
             } else {
                 const userModeResult =
                     await this.dialogManager.openWithExplicitCancel<OutroAskUserModeResultType>(OutroAskUserMode);
@@ -363,9 +377,9 @@ export class SetupManager extends AbstractModule {
                     userMode = UserMode.ExistingUser;
                 } else if (userModeResult === "compatible-existing-user") {
                     extra();
-                    await this.applySetting(newConf, UserMode.ExistingUser);
-                    this._log("Settings from wizard applied.", LOG_LEVEL_NOTICE);
-                    return true;
+                    const applied = await this.applySettingAndScheduleFetchOnActivation(newConf, UserMode.ExistingUser);
+                    if (applied) this._log("Settings from wizard applied.", LOG_LEVEL_NOTICE);
+                    return applied;
                 } else if (userModeResult === "cancelled") {
                     this._log("User cancelled applying settings from wizard.", LOG_LEVEL_NOTICE);
                     return false;
@@ -374,21 +388,26 @@ export class SetupManager extends AbstractModule {
         }
         const component = userMode === UserMode.NewUser ? OutroNewUser : OutroExistingUser;
         const confirm = await this.dialogManager.openWithExplicitCancel<
-            OutroNewUserResultType | OutroExistingUserResultType
-        >(component);
+            OutroNewUserResultType | OutroExistingUserResultType,
+            { isP2P: boolean }
+        >(component, { isP2P: isP2PMainRemote(newConf) });
         if (confirm === "cancelled") {
             this._log("User cancelled applying settings from wizard..", LOG_LEVEL_NOTICE);
             return false;
         }
         if (confirm) {
             extra();
-            await this.applySetting(newConf, userMode);
             if (userMode === UserMode.NewUser) {
-                // For new users, schedule a rebuild everything.
-                await this.core.rebuilder.scheduleRebuild();
+                // Reserve Rebuild before enabling the imported settings, so
+                // the current runtime cannot begin ordinary processing first.
+                await applySettingsWithScheduledInitialisation(this.core.rebuilder, "rebuild", async () => {
+                    await this.applySetting(newConf, userMode);
+                });
             } else {
-                // For existing users, schedule a fetch.
-                await this.core.rebuilder.scheduleFetch();
+                // Existing data must be fetched before the ordinary startup scan.
+                await applySettingsWithScheduledInitialisation(this.core.rebuilder, "fetch", async () => {
+                    await this.applySetting(newConf, userMode);
+                });
             }
         }
         // Settings applied, but may require rebuild to take effect.
@@ -430,4 +449,19 @@ export class SetupManager extends AbstractModule {
         await this.services.setting.applyExternalSettings(newConf, true);
         return true;
     }
+
+    private async applySettingAndScheduleFetchOnActivation(
+        newConf: ObsidianLiveSyncSettings,
+        userMode: UserMode
+    ): Promise<boolean> {
+        const wasConfigured = this.settings.isConfigured;
+        return await applySettingsAndFetchOnActivation(
+            this.core.rebuilder,
+            wasConfigured,
+            newConf.isConfigured,
+            async () => {
+                await this.applySetting(newConf, userMode);
+            }
+        );
+    }
 }

src/modules/features/SetupManager.unit.spec.ts

@@ -1,7 +1,13 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { DEFAULT_SETTINGS, REMOTE_COUCHDB, type ObsidianLiveSyncSettings } from "@lib/common/types";
-import { SettingService } from "@lib/services/base/SettingService";
-import { ServiceContext } from "@lib/services/base/ServiceBase";
+import {
+    DEFAULT_SETTINGS,
+    REMOTE_COUCHDB,
+    REMOTE_P2P,
+    type ObsidianLiveSyncSettings,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { SettingService } from "@vrtmrz/livesync-commonlib/compat/services/base/SettingService";
+import { ServiceContext } from "@vrtmrz/livesync-commonlib/context";
+import { createNewVaultSettings } from "@vrtmrz/livesync-commonlib/settings";
 
 vi.mock("./SetupWizard/dialogs/Intro.svelte", () => ({ default: {} }));
 vi.mock("./SetupWizard/dialogs/SelectMethodNewUser.svelte", () => ({ default: {} }));
@@ -17,11 +23,11 @@ vi.mock("./SetupWizard/dialogs/SetupRemoteBucket.svelte", () => ({ default: {} }
 vi.mock("./SetupWizard/dialogs/SetupRemoteP2P.svelte", () => ({ default: {} }));
 vi.mock("./SetupWizard/dialogs/SetupRemoteE2EE.svelte", () => ({ default: {} }));
 
-vi.mock("../../lib/src/API/processSetting.ts", () => ({
+vi.mock("@vrtmrz/livesync-commonlib/compat/API/processSetting", () => ({
     decodeSettingsFromQRCodeData: vi.fn(),
 }));
 
-import { decodeSettingsFromQRCodeData } from "@lib/API/processSetting.ts";
+import { decodeSettingsFromQRCodeData } from "@vrtmrz/livesync-commonlib/compat/API/processSetting";
 import { SetupManager, UserMode } from "./SetupManager";
 
 class TestSettingService extends SettingService<ServiceContext> {
@@ -93,8 +99,14 @@ function createSetupManager() {
     const core: any = {
         _services: services,
         rebuilder: {
-            scheduleRebuild: vi.fn(() => Promise.resolve()),
-            scheduleFetch: vi.fn(() => Promise.resolve()),
+            scheduleRebuild: vi.fn(async (prepareBeforeRestart?: () => Promise<void>) => {
+                await prepareBeforeRestart?.();
+                return true;
+            }),
+            scheduleFetch: vi.fn(async (prepareBeforeRestart?: () => Promise<void>) => {
+                await prepareBeforeRestart?.();
+                return true;
+            }),
         },
     };
     Object.defineProperty(core, "services", {
@@ -125,7 +137,17 @@ describe("SetupManager", () => {
         vi.restoreAllMocks();
     });
 
-    it("onUseSetupURI should normalise imported legacy remote settings before applying", async () => {
+    it("starts manual new-user setup from the recommended new-Vault settings", async () => {
+        const { manager, dialogManager } = createSetupManager();
+        dialogManager.openWithExplicitCancel.mockResolvedValueOnce("configure-manually");
+        const configureManually = vi.spyOn(manager, "onConfigureManually").mockResolvedValue(true);
+
+        await manager.onOnboard(UserMode.NewUser);
+
+        expect(configureManually).toHaveBeenCalledWith(createNewVaultSettings(), UserMode.NewUser);
+    });
+
+    it("compatibility: normalises imported flat remote settings from a Setup URI before applying", async () => {
         const { manager, setting, dialogManager } = createSetupManager();
         dialogManager.openWithExplicitCancel
             .mockResolvedValueOnce(createLegacyRemoteSetting())
@@ -140,7 +162,7 @@ describe("SetupManager", () => {
         expect(setting.currentSettings().activeConfigurationId).toBe("legacy-couchdb");
     });
 
-    it("decodeQR should normalise imported legacy remote settings before applying", async () => {
+    it("compatibility: normalises imported flat remote settings from QR data before applying", async () => {
         const { manager, setting, dialogManager } = createSetupManager();
         vi.mocked(decodeSettingsFromQRCodeData).mockReturnValue(createLegacyRemoteSetting());
         dialogManager.openWithExplicitCancel.mockResolvedValueOnce("compatible-existing-user");
@@ -154,4 +176,397 @@ describe("SetupManager", () => {
         );
         expect(setting.currentSettings().activeConfigurationId).toBe("legacy-couchdb");
     });
+
+    it("reserves Rebuild before saving a new-user configuration", async () => {
+        const { manager, setting, dialogManager, core } = createSetupManager();
+        setting.settings = { ...setting.currentSettings(), isConfigured: false };
+        const applyExternalSettings = vi.spyOn(setting, "applyExternalSettings");
+        dialogManager.openWithExplicitCancel.mockResolvedValueOnce(true);
+
+        await manager.onConfirmApplySettingsFromWizard(
+            { ...createLegacyRemoteSetting(), isConfigured: true },
+            UserMode.NewUser
+        );
+
+        expect(core.rebuilder.scheduleRebuild).toHaveBeenCalledWith(expect.any(Function));
+        expect(core.rebuilder.scheduleRebuild.mock.invocationCallOrder[0]).toBeLessThan(
+            applyExternalSettings.mock.invocationCallOrder[0]
+        );
+        expect(setting.currentSettings().isConfigured).toBe(true);
+    });
+
+    it("identifies P2P when opening the new-user initialisation confirmation", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        setting.settings = { ...setting.currentSettings(), isConfigured: false };
+        dialogManager.openWithExplicitCancel.mockResolvedValueOnce(true);
+        const p2pProfileId = "p2p-profile";
+
+        await manager.onConfirmApplySettingsFromWizard(
+            {
+                ...setting.currentSettings(),
+                isConfigured: true,
+                // Imported profile settings can still carry the previous compatibility field
+                // until the selected profile is projected by the setting lifecycle.
+                remoteType: REMOTE_COUCHDB,
+                activeConfigurationId: p2pProfileId,
+                remoteConfigurations: {
+                    [p2pProfileId]: {
+                        id: p2pProfileId,
+                        name: "P2P room",
+                        uri: "sls+p2p://:secret@team-room?relays=wss%3A%2F%2Frelay.example",
+                        isEncrypted: false,
+                    },
+                },
+            },
+            UserMode.NewUser
+        );
+
+        expect(dialogManager.openWithExplicitCancel).toHaveBeenCalledWith(expect.anything(), {
+            isP2P: true,
+        });
+    });
+
+    it("reserves Fetch when compatible imported settings activate an unconfigured device", async () => {
+        const { manager, setting, dialogManager, core } = createSetupManager();
+        setting.settings = { ...setting.currentSettings(), isConfigured: false };
+        const applyExternalSettings = vi.spyOn(setting, "applyExternalSettings");
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce({ ...createLegacyRemoteSetting(), isConfigured: true })
+            .mockResolvedValueOnce("compatible-existing-user");
+
+        await manager.onUseSetupURI(UserMode.Unknown, "mock-config://settings");
+
+        expect(core.rebuilder.scheduleFetch).toHaveBeenCalledWith(expect.any(Function));
+        expect(core.rebuilder.scheduleFetch.mock.invocationCallOrder[0]).toBeLessThan(
+            applyExternalSettings.mock.invocationCallOrder[0]
+        );
+        expect(setting.currentSettings().isConfigured).toBe(true);
+    });
+
+    it("applies compatible settings to an already configured device without scheduling Fetch", async () => {
+        const { manager, setting, dialogManager, core } = createSetupManager();
+        setting.settings = { ...setting.currentSettings(), isConfigured: true };
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce({ ...createLegacyRemoteSetting(), isConfigured: true })
+            .mockResolvedValueOnce("compatible-existing-user");
+
+        await manager.onUseSetupURI(UserMode.Unknown, "mock-config://settings");
+
+        expect(core.rebuilder.scheduleFetch).not.toHaveBeenCalled();
+        expect(setting.currentSettings().isConfigured).toBe(true);
+    });
+
+    it("does not enable imported settings when the initialisation flag cannot be reserved", async () => {
+        const { manager, setting, dialogManager, core } = createSetupManager();
+        setting.settings = { ...setting.currentSettings(), isConfigured: false };
+        const applyExternalSettings = vi.spyOn(setting, "applyExternalSettings");
+        core.rebuilder.scheduleRebuild.mockResolvedValueOnce(false);
+        dialogManager.openWithExplicitCancel.mockResolvedValueOnce(true);
+
+        await manager.onConfirmApplySettingsFromWizard(
+            { ...createLegacyRemoteSetting(), isConfigured: true },
+            UserMode.NewUser
+        );
+
+        expect(core.rebuilder.scheduleRebuild).toHaveBeenCalledWith(expect.any(Function));
+        expect(applyExternalSettings).not.toHaveBeenCalled();
+        expect(setting.currentSettings().isConfigured).toBe(false);
+    });
+
+    it("preserves modern profiles, display names, and the active selection from a Setup URI", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        const imported = {
+            ...DEFAULT_SETTINGS,
+            remoteConfigurations: {
+                couch: {
+                    id: "couch",
+                    name: "Office CouchDB",
+                    uri: "sls+https://alice:secret@couch.example/?db=notes",
+                    isEncrypted: false,
+                },
+                archive: {
+                    id: "archive",
+                    name: "Archive bucket",
+                    uri: "sls+s3://key:secret@storage.example/?endpoint=https%3A%2F%2Fstorage.example&bucket=archive&region=auto",
+                    isEncrypted: false,
+                },
+            },
+            activeConfigurationId: "archive",
+        } as ObsidianLiveSyncSettings;
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce(imported)
+            .mockResolvedValueOnce("compatible-existing-user");
+
+        await manager.onUseSetupURI(UserMode.Unknown, "mock-config://modern-settings");
+
+        const current = setting.currentSettings();
+        expect(current.remoteConfigurations).toEqual(imported.remoteConfigurations);
+        expect(current.activeConfigurationId).toBe("archive");
+        expect(Object.keys(current.remoteConfigurations).some((id) => id.startsWith("legacy-"))).toBe(false);
+    });
+
+    it("adds and activates a manually configured CouchDB without replacing existing profiles", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        setting.settings = {
+            ...setting.currentSettings(),
+            isConfigured: true,
+            remoteConfigurations: {
+                existing: {
+                    id: "existing",
+                    name: "Existing remote",
+                    uri: "sls+http://old:secret@old.example/?db=old",
+                    isEncrypted: false,
+                },
+            },
+            activeConfigurationId: "existing",
+        };
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce({
+                couchDB_URI: "https://couch.example",
+                couchDB_USER: "alice",
+                couchDB_PASSWORD: "secret",
+                couchDB_DBNAME: "notes",
+                couchDB_CustomHeaders: "",
+                useJWT: false,
+                jwtAlgorithm: "",
+                jwtKey: "",
+                jwtKid: "",
+                jwtSub: "",
+                jwtExpDuration: 5,
+                useRequestAPI: false,
+            })
+            .mockResolvedValueOnce(true);
+
+        await manager.onCouchDBManualSetup(UserMode.ExistingUser, setting.currentSettings());
+
+        const current = setting.currentSettings();
+        expect(current.remoteConfigurations.existing).toBeDefined();
+        expect(Object.keys(current.remoteConfigurations)).toHaveLength(2);
+        expect(current.activeConfigurationId).not.toBe("existing");
+        const activeProfile = current.remoteConfigurations[current.activeConfigurationId];
+        expect(activeProfile?.name).toBe("CouchDB couch.example");
+        expect(activeProfile?.uri).toContain("sls+https://alice:secret@couch.example");
+    });
+
+    it.each([
+        [UserMode.NewUser, "create-or-connect"],
+        [UserMode.ExistingUser, "connect-existing"],
+        [UserMode.Update, "settings"],
+    ] as const)(
+        "passes the %s CouchDB database policy to the manual setup dialogue",
+        async (userMode, expectedMode) => {
+            const { manager, setting, dialogManager } = createSetupManager();
+            const couchConf = {
+                couchDB_URI: "https://couch.example",
+                couchDB_USER: "alice",
+                couchDB_PASSWORD: "secret",
+                couchDB_DBNAME: "notes",
+                couchDB_CustomHeaders: "",
+                useJWT: false,
+                jwtAlgorithm: "",
+                jwtKey: "",
+                jwtKid: "",
+                jwtSub: "",
+                jwtExpDuration: 5,
+                useRequestAPI: false,
+            };
+            dialogManager.openWithExplicitCancel.mockResolvedValueOnce(couchConf).mockResolvedValueOnce("cancelled");
+
+            await manager.onCouchDBManualSetup(userMode, setting.currentSettings());
+
+            expect(dialogManager.openWithExplicitCancel).toHaveBeenNthCalledWith(1, expect.anything(), {
+                settings: setting.currentSettings(),
+                mode: expectedMode,
+            });
+        }
+    );
+
+    it("adds and activates a manually configured Object Storage profile without replacing existing profiles", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        setting.settings = {
+            ...setting.currentSettings(),
+            isConfigured: true,
+            remoteConfigurations: {
+                existing: {
+                    id: "existing",
+                    name: "Existing remote",
+                    uri: "sls+http://old:secret@old.example/?db=old",
+                    isEncrypted: false,
+                },
+            },
+            activeConfigurationId: "existing",
+        };
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce({
+                endpoint: "https://storage.example",
+                accessKey: "key",
+                secretKey: "secret",
+                bucket: "notes",
+                region: "auto",
+                bucketPrefix: "",
+                useCustomRequestHandler: false,
+                bucketCustomHeaders: "",
+                forcePathStyle: true,
+            })
+            .mockResolvedValueOnce(true);
+
+        await manager.onBucketManualSetup(UserMode.ExistingUser, setting.currentSettings());
+
+        const current = setting.currentSettings();
+        expect(current.remoteConfigurations.existing).toBeDefined();
+        expect(Object.keys(current.remoteConfigurations)).toHaveLength(2);
+        expect(current.activeConfigurationId).not.toBe("existing");
+        const activeProfile = current.remoteConfigurations[current.activeConfigurationId];
+        expect(activeProfile?.name).toBe("S3 notes");
+        expect(activeProfile?.uri).toContain("sls+s3://key:secret@storage.example");
+    });
+
+    it("creates and selects a P2P profile during fresh manual onboarding", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        setting.settings = {
+            ...setting.currentSettings(),
+            isConfigured: false,
+            remoteConfigurations: {},
+            activeConfigurationId: "",
+            P2P_ActiveRemoteConfigurationId: "",
+        };
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce({
+                P2P_Enabled: true,
+                P2P_roomID: "team-room",
+                P2P_passphrase: "secret",
+                P2P_relays: "wss://relay.example",
+                P2P_AppID: "self-hosted-livesync",
+                P2P_AutoStart: true,
+                P2P_AutoBroadcast: false,
+                P2P_turnServers: "",
+                P2P_turnUsername: "",
+                P2P_turnCredential: "",
+            })
+            .mockResolvedValueOnce(true);
+
+        await manager.onP2PManualSetup(UserMode.NewUser, setting.currentSettings());
+
+        const current = setting.currentSettings();
+        expect(Object.keys(current.remoteConfigurations)).toHaveLength(1);
+        expect(current.activeConfigurationId).not.toBe("");
+        expect(current.P2P_ActiveRemoteConfigurationId).toBe(current.activeConfigurationId);
+        const activeProfile = current.remoteConfigurations[current.activeConfigurationId];
+        expect(activeProfile?.name).toBe("P2P team-room");
+        expect(activeProfile?.uri).toContain("sls+p2p://");
+    });
+
+    it("selects a configured P2P profile without replacing the active main remote", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        setting.settings = {
+            ...setting.currentSettings(),
+            isConfigured: true,
+            remoteConfigurations: {
+                main: {
+                    id: "main",
+                    name: "Main CouchDB",
+                    uri: "sls+http://old:secret@old.example/?db=old",
+                    isEncrypted: false,
+                },
+            },
+            activeConfigurationId: "main",
+            P2P_ActiveRemoteConfigurationId: "",
+        };
+        dialogManager.openWithExplicitCancel.mockResolvedValueOnce({
+            P2P_Enabled: true,
+            P2P_roomID: "team-room",
+            P2P_passphrase: "secret",
+            P2P_relays: "wss://relay.example",
+            P2P_AppID: "self-hosted-livesync",
+            P2P_AutoStart: true,
+            P2P_AutoBroadcast: false,
+            P2P_turnServers: "",
+            P2P_turnUsername: "",
+            P2P_turnCredential: "",
+        });
+
+        await manager.onP2PManualSetup(UserMode.Unknown, setting.currentSettings(), false);
+
+        const current = setting.currentSettings();
+        expect(Object.keys(current.remoteConfigurations)).toHaveLength(2);
+        expect(current.activeConfigurationId).toBe("main");
+        expect(current.P2P_ActiveRemoteConfigurationId).not.toBe("");
+        expect(current.P2P_ActiveRemoteConfigurationId).not.toBe("main");
+        expect(current.remoteConfigurations[current.P2P_ActiveRemoteConfigurationId]?.name).toBe("P2P team-room");
+    });
+
+    it("does not register Object Storage when final confirmation is cancelled", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        setting.settings = {
+            ...setting.currentSettings(),
+            isConfigured: true,
+            remoteConfigurations: {
+                existing: {
+                    id: "existing",
+                    name: "Existing remote",
+                    uri: "sls+http://old:secret@old.example/?db=old",
+                    isEncrypted: false,
+                },
+            },
+            activeConfigurationId: "existing",
+        };
+        const before = structuredClone(setting.currentSettings().remoteConfigurations);
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce({
+                endpoint: "https://storage.example",
+                accessKey: "key",
+                secretKey: "secret",
+                bucket: "notes",
+                region: "auto",
+                bucketPrefix: "",
+                useCustomRequestHandler: false,
+                bucketCustomHeaders: "",
+                forcePathStyle: true,
+            })
+            .mockResolvedValueOnce("cancelled");
+
+        await manager.onBucketManualSetup(UserMode.ExistingUser, setting.currentSettings());
+
+        expect(setting.currentSettings().remoteConfigurations).toEqual(before);
+        expect(setting.currentSettings().activeConfigurationId).toBe("existing");
+    });
+
+    it("does not mutate an existing P2P profile when final confirmation is cancelled", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        setting.settings = {
+            ...setting.currentSettings(),
+            isConfigured: true,
+            remoteConfigurations: {
+                existing: {
+                    id: "existing",
+                    name: "Existing P2P remote",
+                    uri: "sls+p2p://old-room?passphrase=old-secret",
+                    isEncrypted: false,
+                },
+            },
+            activeConfigurationId: "existing",
+            P2P_ActiveRemoteConfigurationId: "existing",
+        };
+        const before = structuredClone(setting.currentSettings().remoteConfigurations);
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce({
+                P2P_Enabled: true,
+                P2P_roomID: "new-room",
+                P2P_passphrase: "new-secret",
+                P2P_relays: "wss://relay.example",
+                P2P_AppID: "self-hosted-livesync",
+                P2P_AutoStart: true,
+                P2P_AutoBroadcast: false,
+                P2P_turnServers: "",
+                P2P_turnUsername: "",
+                P2P_turnCredential: "",
+            })
+            .mockResolvedValueOnce("cancelled");
+
+        await manager.onP2PManualSetup(UserMode.ExistingUser, setting.currentSettings());
+
+        expect(setting.currentSettings().remoteConfigurations).toEqual(before);
+        expect(setting.currentSettings().activeConfigurationId).toBe("existing");
+        expect(setting.currentSettings().P2P_ActiveRemoteConfigurationId).toBe("existing");
+    });
 });

src/modules/features/SetupWizard/dialogs/FetchEverything.svelte

@@ -1,15 +1,15 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import Question from "@lib/UI/components/Question.svelte";
-    import Option from "@lib/UI/components/Option.svelte";
-    import Options from "@lib/UI/components/Options.svelte";
-    import Instruction from "@lib/UI/components/Instruction.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
-    import InfoNote from "@lib/UI/components/InfoNote.svelte";
-    import ExtraItems from "@lib/UI/components/ExtraItems.svelte";
-    import Check from "@lib/UI/components/Check.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import Question from "@/modules/services/LiveSyncUI/components/Question.svelte";
+    import Option from "@/modules/services/LiveSyncUI/components/Option.svelte";
+    import Options from "@/modules/services/LiveSyncUI/components/Options.svelte";
+    import Instruction from "@/modules/services/LiveSyncUI/components/Instruction.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import InfoNote from "@/modules/services/LiveSyncUI/components/InfoNote.svelte";
+    import ExtraItems from "@/modules/services/LiveSyncUI/components/ExtraItems.svelte";
+    import Check from "@/modules/services/LiveSyncUI/components/Check.svelte";
     import {
         TYPE_BACKUP_DONE,
         TYPE_BACKUP_SKIPPED,

src/modules/features/SetupWizard/dialogs/Intro.svelte

@@ -1,13 +1,15 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import Question from "@lib/UI/components/Question.svelte";
-    import Option from "@lib/UI/components/Option.svelte";
-    import Options from "@lib/UI/components/Options.svelte";
-    import Instruction from "@lib/UI/components/Instruction.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import InfoNote from "@/modules/services/LiveSyncUI/components/InfoNote.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import Question from "@/modules/services/LiveSyncUI/components/Question.svelte";
+    import Option from "@/modules/services/LiveSyncUI/components/Option.svelte";
+    import Options from "@/modules/services/LiveSyncUI/components/Options.svelte";
+    import Instruction from "@/modules/services/LiveSyncUI/components/Instruction.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
     import { TYPE_NEW_USER, TYPE_EXISTING_USER, TYPE_CANCELLED, type IntroResultType } from "./setupDialogTypes";
+    import { $msg as translateMessage } from "@/common/translation";
 
     type Props = {
         setResult: (result: IntroResultType) => void;
@@ -30,6 +32,11 @@
 
 <DialogHeader title="Welcome to Self-hosted LiveSync" />
 <Guidance>We will now guide you through a few questions to simplify the synchronisation setup.</Guidance>
+<InfoNote>
+    {translateMessage(
+        "This first setup has several short steps because it confirms encryption, the connection method, and which device provides the initial data. Once it is complete, additional devices can reuse a Setup URI."
+    )}
+</InfoNote>
 <Instruction>
     <Question>First, please select the option that best describes your current situation.</Question>
     <Options>

src/modules/features/SetupWizard/dialogs/OutroAskUserMode.svelte

@@ -1,12 +1,12 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import Question from "@lib/UI/components/Question.svelte";
-    import Option from "@lib/UI/components/Option.svelte";
-    import Instruction from "@lib/UI/components/Instruction.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
-    import InfoNote from "@lib/UI/components/InfoNote.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import Question from "@/modules/services/LiveSyncUI/components/Question.svelte";
+    import Option from "@/modules/services/LiveSyncUI/components/Option.svelte";
+    import Instruction from "@/modules/services/LiveSyncUI/components/Instruction.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import InfoNote from "@/modules/services/LiveSyncUI/components/InfoNote.svelte";
     import {
         type OutroAskUserModeResultType,
         TYPE_CANCELLED,

src/modules/features/SetupWizard/dialogs/OutroExistingUser.svelte

@@ -1,36 +1,70 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import Question from "@lib/UI/components/Question.svelte";
-    import Instruction from "@lib/UI/components/Instruction.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import Question from "@/modules/services/LiveSyncUI/components/Question.svelte";
+    import Instruction from "@/modules/services/LiveSyncUI/components/Instruction.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import { $msg as translateMessage } from "@/common/translation";
 
     import { TYPE_CANCELLED, TYPE_APPLY, type OutroExistingUserResultType } from "./setupDialogTypes";
     type Props = {
         setResult: (result: OutroExistingUserResultType) => void;
+        getInitialData?: () => { isP2P?: boolean } | undefined;
     };
-    const { setResult }: Props = $props();
+    const { setResult, getInitialData }: Props = $props();
+    const isP2P = $derived(getInitialData?.()?.isP2P === true);
 </script>
 
-<DialogHeader title="Setup Complete: Preparing to Fetch Synchronisation Data" />
-<Guidance>
-    <p>
-        The connection to the server has been configured successfully. As the next step, <strong
-            >the latest synchronisation data will be downloaded from the server to this device.</strong
-        >
-    </p>
-    <p>
-        <strong>PLEASE NOTE</strong>
-        <br />
-        After restarting, the database on this device will be rebuilt using data from the server. If there are any unsynchronised
-        files in this vault, conflicts may occur with the server data.
-    </p>
-</Guidance>
-<Instruction>
-    <Question>Please select the button below to restart and proceed to the data fetching confirmation.</Question>
-</Instruction>
-<UserDecisions>
-    <Decision title="Restart and Fetch Data" important={true} commit={() => setResult(TYPE_APPLY)} />
-    <Decision title="No, please take me back" commit={() => setResult(TYPE_CANCELLED)} />
-</UserDecisions>
+{#if isP2P}
+    <DialogHeader title={translateMessage("Setup Complete: Preparing to Fetch from Another Device")} />
+    <Guidance>
+        <p>
+            {translateMessage(
+                "The P2P connection has been configured successfully. The initial synchronisation data must now be fetched from an online source device."
+            )}
+        </p>
+        <p>
+            <strong>PLEASE NOTE</strong>
+            <br />
+            {translateMessage(
+                "After restarting, select an online source device for the initial Fetch. The local LiveSync database on this device will be rebuilt from that source. Unsynchronised files in this Vault may conflict with the fetched data."
+            )}
+        </p>
+    </Guidance>
+    <Instruction>
+        <Question>
+            {translateMessage("Restart this device, then choose the source device when P2P Rebuild opens.")}
+        </Question>
+    </Instruction>
+    <UserDecisions>
+        <Decision
+            title={translateMessage("Restart and Select Source Device")}
+            important={true}
+            commit={() => setResult(TYPE_APPLY)}
+        />
+        <Decision title="No, please take me back" commit={() => setResult(TYPE_CANCELLED)} />
+    </UserDecisions>
+{:else}
+    <DialogHeader title="Setup Complete: Preparing to Fetch Synchronisation Data" />
+    <Guidance>
+        <p>
+            The connection to the server has been configured successfully. As the next step, <strong
+                >the latest synchronisation data will be downloaded from the server to this device.</strong
+            >
+        </p>
+        <p>
+            <strong>PLEASE NOTE</strong>
+            <br />
+            After restarting, the database on this device will be rebuilt using data from the server. If there are any unsynchronised
+            files in this vault, conflicts may occur with the server data.
+        </p>
+    </Guidance>
+    <Instruction>
+        <Question>Please select the button below to restart and proceed to the data fetching confirmation.</Question>
+    </Instruction>
+    <UserDecisions>
+        <Decision title="Restart and Fetch Data" important={true} commit={() => setResult(TYPE_APPLY)} />
+        <Decision title="No, please take me back" commit={() => setResult(TYPE_CANCELLED)} />
+    </UserDecisions>
+{/if}

src/modules/features/SetupWizard/dialogs/OutroNewUser.svelte

@@ -1,37 +1,63 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import Question from "@lib/UI/components/Question.svelte";
-    import Instruction from "@lib/UI/components/Instruction.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import Question from "@/modules/services/LiveSyncUI/components/Question.svelte";
+    import Instruction from "@/modules/services/LiveSyncUI/components/Instruction.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import { $msg as msg } from "@/common/translation";
     import { TYPE_APPLY, TYPE_CANCELLED, type OutroNewUserResultType } from "./setupDialogTypes";
 
     type Props = {
         setResult: (result: OutroNewUserResultType) => void;
+        getInitialData?: () => { isP2P?: boolean } | undefined;
     };
-    const { setResult }: Props = $props();
+    const { setResult, getInitialData }: Props = $props();
+    const isP2P = $derived(getInitialData?.()?.isP2P === true);
     // let userType = $state<OutroNewUserResultType>(TYPE_CANCELLED);
 </script>
 
-<DialogHeader title="Setup Complete: Preparing to Initialise Server" />
-<Guidance>
-    <p>
-        The connection to the server has been configured successfully. As the next step, <strong
-            >the synchronisation data on the server will be built based on the current data on this device.</strong
-        >
-    </p>
-    <p>
-        <strong>IMPORTANT</strong>
-        <br />
-        After restarting, the data on this device will be uploaded to the server as the 'master copy'. Please be aware that
-        any unintended data currently on the server will be completely overwritten.
-    </p>
-</Guidance>
-<Instruction>
-    <Question>Please select the button below to restart and proceed to the final confirmation.</Question>
-</Instruction>
-<UserDecisions>
-    <Decision title="Restart and Initialise Server" important={true} commit={() => setResult(TYPE_APPLY)} />
-    <Decision title="No, please take me back" commit={() => setResult(TYPE_CANCELLED)} />
-</UserDecisions>
+{#if isP2P}
+    <DialogHeader title={msg("Ui.SetupWizard.OutroNewP2PUser.Title")} />
+    <Guidance>
+        <p>{msg("Ui.SetupWizard.OutroNewP2PUser.GuidancePrimary")}</p>
+        <p>
+            <strong>{msg("Ui.SetupWizard.OutroNewP2PUser.Important")}</strong>
+            <br />
+            {msg("Ui.SetupWizard.OutroNewP2PUser.GuidanceNotice")}
+        </p>
+    </Guidance>
+    <Instruction>
+        <Question>{msg("Ui.SetupWizard.OutroNewP2PUser.Question")}</Question>
+    </Instruction>
+    <UserDecisions>
+        <Decision
+            title={msg("Ui.SetupWizard.OutroNewP2PUser.Proceed")}
+            important={true}
+            commit={() => setResult(TYPE_APPLY)}
+        />
+        <Decision title="No, please take me back" commit={() => setResult(TYPE_CANCELLED)} />
+    </UserDecisions>
+{:else}
+    <DialogHeader title="Setup Complete: Preparing to Initialise Server" />
+    <Guidance>
+        <p>
+            The connection to the server has been configured successfully. As the next step, <strong
+                >the synchronisation data on the server will be built based on the current data on this device.</strong
+            >
+        </p>
+        <p>
+            <strong>IMPORTANT</strong>
+            <br />
+            After restarting, the data on this device will be uploaded to the server as the 'master copy'. Please be aware
+            that any unintended data currently on the server will be completely overwritten.
+        </p>
+    </Guidance>
+    <Instruction>
+        <Question>Please select the button below to restart and proceed to the final confirmation.</Question>
+    </Instruction>
+    <UserDecisions>
+        <Decision title="Restart and Initialise Server" important={true} commit={() => setResult(TYPE_APPLY)} />
+        <Decision title="No, please take me back" commit={() => setResult(TYPE_CANCELLED)} />
+    </UserDecisions>
+{/if}

src/modules/features/SetupWizard/dialogs/PanelCouchDBCheck.svelte

@@ -2,23 +2,27 @@
     /**
      * Panel to check and fix CouchDB configuration issues
      */
-    import type { ObsidianLiveSyncSettings } from "@lib/common/types";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
+    import type { ObsidianLiveSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
     import { checkConfig, type ConfigCheckResult, type ResultError, type ResultErrorMessage } from "./utilCheckCouchDB";
+    import { LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
+    import { $msg as translateMessage } from "@/common/translation";
+    import { getDialogContext } from "@/modules/services/LiveSyncUI/svelteDialog";
+    import { getCouchDBServerFixConfirmation } from "./couchDBServerFixConfirmation";
     type Props = {
         trialRemoteSetting: ObsidianLiveSyncSettings;
     };
     const { trialRemoteSetting }: Props = $props();
+    const context = getDialogContext();
     let detectedIssues = $state<ConfigCheckResult[]>([]);
     async function testAndFixSettings() {
         detectedIssues = [];
         try {
             const fixResults = await checkConfig(trialRemoteSetting);
-            console.dir(fixResults);
             detectedIssues = fixResults;
         } catch (e) {
-            console.error("Error during testAndFixSettings:", e);
+            Logger(e, LOG_LEVEL_VERBOSE, "setup-couchdb-check");
             detectedIssues.push({ message: `Error during testAndFixSettings: ${e}`, result: "error", classes: [] });
         }
     }
@@ -33,14 +37,23 @@
     }
     let processing = $state(false);
     async function fixIssue(issue: ResultError<unknown>) {
+        const confirmation = getCouchDBServerFixConfirmation(issue.settingKey, issue.expectedValue);
+        const confirmed = await context.services.confirm.askYesNoDialog(confirmation.message, {
+            title: confirmation.title,
+            defaultOption: "No",
+        });
+        if (confirmed !== "yes") {
+            return;
+        }
         try {
             processing = true;
             await issue.fix();
         } catch (e) {
-            console.error("Error during fixIssue:", e);
+            Logger(e, LOG_LEVEL_VERBOSE, "setup-couchdb-fix");
+        } finally {
+            await testAndFixSettings();
+            processing = false;
         }
-        await testAndFixSettings();
-        processing = false;
     }
     const errorIssueCount = $derived.by(() => {
         return detectedIssues.filter((issue) => isErrorResult(issue)).length;
@@ -64,7 +77,7 @@
     </div>
 {/snippet}
 <UserDecisions>
-    <Decision title="Detect and Fix CouchDB Issues" important={true} commit={testAndFixSettings} />
+    <Decision title={translateMessage("Check server requirements")} important={true} commit={testAndFixSettings} />
 </UserDecisions>
 <div class="check-results">
     <details open={!isAllSuccess}>

src/modules/features/SetupWizard/dialogs/RebuildEverything.svelte

@@ -1,15 +1,16 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import Question from "@lib/UI/components/Question.svelte";
-    import Option from "@lib/UI/components/Option.svelte";
-    import Options from "@lib/UI/components/Options.svelte";
-    import Instruction from "@lib/UI/components/Instruction.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
-    import InfoNote from "@lib/UI/components/InfoNote.svelte";
-    import ExtraItems from "@lib/UI/components/ExtraItems.svelte";
-    import Check from "@lib/UI/components/Check.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import Question from "@/modules/services/LiveSyncUI/components/Question.svelte";
+    import Option from "@/modules/services/LiveSyncUI/components/Option.svelte";
+    import Options from "@/modules/services/LiveSyncUI/components/Options.svelte";
+    import Instruction from "@/modules/services/LiveSyncUI/components/Instruction.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import InfoNote from "@/modules/services/LiveSyncUI/components/InfoNote.svelte";
+    import ExtraItems from "@/modules/services/LiveSyncUI/components/ExtraItems.svelte";
+    import Check from "@/modules/services/LiveSyncUI/components/Check.svelte";
+    import { $msg as msg } from "@/common/translation";
     import {
         TYPE_CANCEL,
         TYPE_BACKUP_DONE,
@@ -21,20 +22,19 @@
 
     type Props = {
         setResult: (result: RebuildEverythingResult) => void;
+        getInitialData?: () => { isP2P?: boolean } | undefined;
     };
-    const { setResult }: Props = $props();
+    const { setResult, getInitialData }: Props = $props();
+    const isP2P = $derived(getInitialData?.()?.isP2P === true);
 
     let backupType = $state<ResultTypeBackup>(TYPE_CANCEL);
     let confirmationCheck1 = $state(false);
     let confirmationCheck2 = $state(false);
     let confirmationCheck3 = $state(false);
     const canProceed = $derived.by(() => {
-        return (
-            (backupType === TYPE_BACKUP_DONE || backupType === TYPE_BACKUP_SKIPPED) &&
-            confirmationCheck1 &&
-            confirmationCheck2 &&
-            confirmationCheck3
-        );
+        const backupConfirmed = backupType === TYPE_BACKUP_DONE || backupType === TYPE_BACKUP_SKIPPED;
+        if (isP2P) return backupConfirmed && confirmationCheck1;
+        return backupConfirmed && confirmationCheck1 && confirmationCheck2 && confirmationCheck3;
     });
     let preventFetchingConfig = $state(false);
 
@@ -48,33 +48,44 @@
     }
 </script>
 
-<DialogHeader title="Final Confirmation: Overwrite Server Data with This Device's Files" />
-<Guidance
-    >This procedure will first delete all existing synchronisation data from the server. Following this, the server data
-    will be completely rebuilt, using the current state of your Vault on this device (including its local database) as
-    <strong>the single, authoritative master copy</strong>.</Guidance
->
-<InfoNote>
-    You should perform this operation only in exceptional circumstances, such as when the server data is completely
-    corrupted, when changes on all other devices are no longer needed, or when the database size has become unusually
-    large in comparison to the Vault size.
-</InfoNote>
-<Guidance important title="⚠️ Please Confirm the Following">
-    <Check
-        title="I understand that all changes made on other smartphones or computers possibly could be lost."
-        bind:value={confirmationCheck1}
+{#if isP2P}
+    <DialogHeader title={msg("Ui.SetupWizard.RebuildEverythingP2P.Title")} />
+    <Guidance>{msg("Ui.SetupWizard.RebuildEverythingP2P.Guidance")}</Guidance>
+    <InfoNote>{msg("Ui.SetupWizard.RebuildEverythingP2P.Note")}</InfoNote>
+    <Guidance important title={msg("Ui.SetupWizard.RebuildEverythingP2P.ConfirmTitle")}>
+        <Check title={msg("Ui.SetupWizard.RebuildEverythingP2P.ConfirmLocalReset")} bind:value={confirmationCheck1}>
+            <InfoNote>{msg("Ui.SetupWizard.RebuildEverythingP2P.ConfirmLocalResetNote")}</InfoNote>
+        </Check>
+    </Guidance>
+{:else}
+    <DialogHeader title="Final Confirmation: Overwrite Server Data with This Device's Files" />
+    <Guidance
+        >This procedure will first delete all existing synchronisation data from the server. Following this, the server
+        data will be completely rebuilt, using the current state of your Vault on this device (including its local
+        database) as <strong>the single, authoritative master copy</strong>.</Guidance
     >
-        <InfoNote>There is a way to resolve this on other devices.</InfoNote>
-        <InfoNote>Of course, we can back up the data before proceeding.</InfoNote>
-    </Check>
-    <Check
-        title="I understand that other devices will no longer be able to synchronise, and will need to be reset the synchronisation information."
-        bind:value={confirmationCheck2}
-    >
-        <InfoNote>by resetting the remote, you will be informed on other devices.</InfoNote>
-    </Check>
-    <Check title="I understand that this action is irreversible once performed." bind:value={confirmationCheck3} />
-</Guidance>
+    <InfoNote>
+        You should perform this operation only in exceptional circumstances, such as when the server data is completely
+        corrupted, when changes on all other devices are no longer needed, or when the database size has become unusually
+        large in comparison to the Vault size.
+    </InfoNote>
+    <Guidance important title="⚠️ Please Confirm the Following">
+        <Check
+            title="I understand that all changes made on other smartphones or computers possibly could be lost."
+            bind:value={confirmationCheck1}
+        >
+            <InfoNote>There is a way to resolve this on other devices.</InfoNote>
+            <InfoNote>Of course, we can back up the data before proceeding.</InfoNote>
+        </Check>
+        <Check
+            title="I understand that other devices will no longer be able to synchronise, and will need to be reset the synchronisation information."
+            bind:value={confirmationCheck2}
+        >
+            <InfoNote>by resetting the remote, you will be informed on other devices.</InfoNote>
+        </Check>
+        <Check title="I understand that this action is irreversible once performed." bind:value={confirmationCheck3} />
+    </Guidance>
+{/if}
 <hr />
 <Instruction>
     <Question>Have you created a backup before proceeding?</Question>
@@ -103,12 +114,19 @@
         </Option>
     </Options>
 </Instruction>
-<Instruction>
-    <ExtraItems title="Advanced">
-        <Check title="Prevent fetching configuration from server" bind:value={preventFetchingConfig} />
-    </ExtraItems>
-</Instruction>
+{#if !isP2P}
+    <Instruction>
+        <ExtraItems title="Advanced">
+            <Check title="Prevent fetching configuration from server" bind:value={preventFetchingConfig} />
+        </ExtraItems>
+    </Instruction>
+{/if}
 <UserDecisions>
-    <Decision title="I Understand, Overwrite Server" important disabled={!canProceed} commit={() => commit()} />
+    <Decision
+        title={isP2P ? msg("Ui.SetupWizard.RebuildEverythingP2P.Proceed") : "I Understand, Overwrite Server"}
+        important
+        disabled={!canProceed}
+        commit={() => commit()}
+    />
     <Decision title="Cancel" commit={() => setResult(TYPE_CANCEL)} />
 </UserDecisions>

src/modules/features/SetupWizard/dialogs/ScanQRCode.svelte

@@ -1,9 +1,9 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import Instruction from "@lib/UI/components/Instruction.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import Instruction from "@/modules/services/LiveSyncUI/components/Instruction.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
     import { TYPE_CLOSE, type ScanQRCodeResultType } from "./setupDialogTypes";
 
     type Props = {

src/modules/features/SetupWizard/dialogs/SelectMethodExisting.svelte

@@ -1,12 +1,13 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import Question from "@lib/UI/components/Question.svelte";
-    import Option from "@lib/UI/components/Option.svelte";
-    import Options from "@lib/UI/components/Options.svelte";
-    import Instruction from "@lib/UI/components/Instruction.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import Question from "@/modules/services/LiveSyncUI/components/Question.svelte";
+    import Option from "@/modules/services/LiveSyncUI/components/Option.svelte";
+    import Options from "@/modules/services/LiveSyncUI/components/Options.svelte";
+    import Instruction from "@/modules/services/LiveSyncUI/components/Instruction.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import { $msg as translateMessage } from "@/common/translation";
     import {
         TYPE_USE_SETUP_URI,
         TYPE_SCAN_QR_CODE,
@@ -24,7 +25,7 @@
         if (userType === TYPE_USE_SETUP_URI) {
             return "Proceed with Setup URI";
         } else if (userType === TYPE_CONFIGURE_MANUALLY) {
-            return "I know my server details, let me enter them";
+            return translateMessage("Ui.SetupWizard.SelectExisting.ProceedManual");
         } else if (userType === TYPE_SCAN_QR_CODE) {
             return "Scan the QR code displayed on an active device using this device's camera.";
         } else {
@@ -49,10 +50,10 @@
         </Option>
         <Option
             selectedValue={TYPE_CONFIGURE_MANUALLY}
-            title="Enter the server information manually"
+            title={translateMessage("Ui.SetupWizard.SelectExisting.ManualOption")}
             bind:value={userType}
         >
-            Configure the same server information as your other devices again, manually, very advanced users only.
+            {translateMessage("Ui.SetupWizard.SelectExisting.ManualOptionDesc")}
         </Option>
     </Options>
 </Instruction>

src/modules/features/SetupWizard/dialogs/SelectMethodNewUser.svelte

@@ -1,12 +1,13 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import Question from "@lib/UI/components/Question.svelte";
-    import Option from "@lib/UI/components/Option.svelte";
-    import Options from "@lib/UI/components/Options.svelte";
-    import Instruction from "@lib/UI/components/Instruction.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import Question from "@/modules/services/LiveSyncUI/components/Question.svelte";
+    import Option from "@/modules/services/LiveSyncUI/components/Option.svelte";
+    import Options from "@/modules/services/LiveSyncUI/components/Options.svelte";
+    import Instruction from "@/modules/services/LiveSyncUI/components/Instruction.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import { $msg as translateMessage } from "@/common/translation";
     import {
         TYPE_USE_SETUP_URI,
         TYPE_CONFIGURE_MANUALLY,
@@ -23,7 +24,7 @@
         if (userType === TYPE_USE_SETUP_URI) {
             return "Proceed with Setup URI";
         } else if (userType === TYPE_CONFIGURE_MANUALLY) {
-            return "I know my server details, let me enter them";
+            return translateMessage("Ui.SetupWizard.SelectNew.ProceedManual");
         } else {
             return "Please select an option to proceed";
         }
@@ -34,22 +35,22 @@
 </script>
 
 <DialogHeader title="Connection Method" />
-<Guidance>We will now proceed with the server configuration.</Guidance>
+<Guidance>{translateMessage("Ui.SetupWizard.SelectNew.Guidance")}</Guidance>
 <Instruction>
-    <Question>How would you like to configure the connection to your server?</Question>
+    <Question>{translateMessage("Ui.SetupWizard.SelectNew.Question")}</Question>
     <Options>
         <Option selectedValue={TYPE_USE_SETUP_URI} title="Use a Setup URI (Recommended)" bind:value={userType}>
-            A Setup URI is a single string of text containing your server address and authentication details. Using a
-            URI, if one was generated by your server installation script, provides a simple and secure configuration.
+            {translateMessage("Ui.SetupWizard.SelectNew.SetupUriOptionDesc")}
         </Option>
         <Option
             selectedValue={TYPE_CONFIGURE_MANUALLY}
-            title="Enter the server information manually"
+            title={translateMessage("Ui.SetupWizard.SelectNew.ManualOption")}
             bind:value={userType}
         >
-            This is an advanced option for users who do not have a URI or who wish to configure detailed settings.
-            You can also select this option if you intend to use <strong>P2P (Peer-to-Peer) synchronisation</strong>
-            instead of a CouchDB/S3 server — P2P requires no server setup at all.
+            {translateMessage("Ui.SetupWizard.SelectNew.ManualOptionDesc")}
+            {translateMessage(
+                "P2P requires no central data-storage server, but it still uses a signalling relay for peer discovery."
+            )}
         </Option>
     </Options>
 </Instruction>

src/modules/features/SetupWizard/dialogs/SetupRemote.svelte

@@ -1,11 +1,12 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import Question from "@lib/UI/components/Question.svelte";
-    import Option from "@lib/UI/components/Option.svelte";
-    import Options from "@lib/UI/components/Options.svelte";
-    import Instruction from "@lib/UI/components/Instruction.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import Question from "@/modules/services/LiveSyncUI/components/Question.svelte";
+    import Option from "@/modules/services/LiveSyncUI/components/Option.svelte";
+    import Options from "@/modules/services/LiveSyncUI/components/Options.svelte";
+    import Instruction from "@/modules/services/LiveSyncUI/components/Instruction.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import { $msg as translateMessage } from "@/common/translation";
     import {
         TYPE_COUCHDB,
         TYPE_BUCKET,
@@ -23,9 +24,9 @@
         if (userType === TYPE_COUCHDB) {
             return "Continue to CouchDB setup";
         } else if (userType === TYPE_BUCKET) {
-            return "Continue to S3/MinIO/R2 setup";
+            return translateMessage("Ui.SetupWizard.SetupRemote.ProceedBucket");
         } else if (userType === TYPE_P2P) {
-            return "Continue to Peer-to-Peer only setup";
+            return translateMessage("Ui.SetupWizard.SetupRemote.ProceedP2P");
         } else {
             return "Please select an option to proceed";
         }
@@ -35,21 +36,29 @@
     });
 </script>
 
-<DialogHeader title="Enter Server Information" />
+<DialogHeader title={translateMessage("Ui.SetupWizard.SetupRemote.Title")} />
 <Instruction>
-    <Question>Please select the type of server to which you are connecting.</Question>
+    <Question>{translateMessage("Ui.SetupWizard.SetupRemote.Guidance")}</Question>
     <Options>
         <Option selectedValue={TYPE_COUCHDB} title="CouchDB" bind:value={userType}>
             This is the most suitable synchronisation method for the design. All functions are available. You must have
             set up a CouchDB instance.
         </Option>
-        <Option selectedValue={TYPE_BUCKET} title="S3/MinIO/R2 Object Storage" bind:value={userType}>
-            Synchronisation utilising journal files. You must have set up an S3/MinIO/R2 compatible object storage.
+        <Option
+            selectedValue={TYPE_BUCKET}
+            title={translateMessage("Ui.SetupWizard.SetupRemote.BucketOption")}
+            bind:value={userType}
+        >
+            {translateMessage("Ui.SetupWizard.SetupRemote.BucketOptionDesc")}
         </Option>
-        <Option selectedValue={TYPE_P2P} title="Peer-to-Peer only" bind:value={userType}>
-            This feature enables direct synchronisation between devices. No server is required, but both devices must be
-            online at the same time for synchronisation to occur, and some features may be limited. Internet connection
-            is only required to signalling (detecting peers) and not for data transfer.
+        <Option
+            selectedValue={TYPE_P2P}
+            title={translateMessage("Ui.SetupWizard.SetupRemote.P2POption")}
+            bind:value={userType}
+        >
+            {translateMessage(
+                "No central data-storage server is required, but a signalling relay is required for peer discovery. Both devices must be online at the same time. Vault data travels through the encrypted P2P connection, not through the signalling relay. Some features may be limited."
+            )}
         </Option>
     </Options>
 </Instruction>

src/modules/features/SetupWizard/dialogs/SetupRemoteBucket.svelte

@@ -1,23 +1,23 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
-    import InfoNote from "@lib/UI/components/InfoNote.svelte";
-    import ExtraItems from "@lib/UI/components/ExtraItems.svelte";
-    import InputRow from "@lib/UI/components/InputRow.svelte";
-    import Password from "@lib/UI/components/Password.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import InfoNote from "@/modules/services/LiveSyncUI/components/InfoNote.svelte";
+    import ExtraItems from "@/modules/services/LiveSyncUI/components/ExtraItems.svelte";
+    import InputRow from "@/modules/services/LiveSyncUI/components/InputRow.svelte";
+    import Password from "@/modules/services/LiveSyncUI/components/Password.svelte";
     import {
         type BucketSyncSetting,
         type ObsidianLiveSyncSettings,
         DEFAULT_SETTINGS,
         PREFERRED_JOURNAL_SYNC,
         RemoteTypes,
-    } from "@lib/common/types";
+    } from "@vrtmrz/livesync-commonlib/compat/common/types";
 
     import { onMount } from "svelte";
-    import { getDialogContext, type GuestDialogProps } from "@lib/UI/svelteDialog";
-    import { copyTo, pickBucketSyncSettings } from "@lib/common/utils";
+    import { getDialogContext, type GuestDialogProps } from "@/modules/services/LiveSyncUI/svelteDialog";
+    import { copyTo, pickBucketSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/utils";
     import { TYPE_CANCELLED, type SetupRemoteBucketResultType } from "./setupDialogTypes";
 
     const default_setting = pickBucketSyncSettings(DEFAULT_SETTINGS);

src/modules/features/SetupWizard/dialogs/SetupRemoteCouchDB.svelte

@@ -1,12 +1,12 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
-    import InfoNote from "@lib/UI/components/InfoNote.svelte";
-    import ExtraItems from "@lib/UI/components/ExtraItems.svelte";
-    import InputRow from "@lib/UI/components/InputRow.svelte";
-    import Password from "@lib/UI/components/Password.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import InfoNote from "@/modules/services/LiveSyncUI/components/InfoNote.svelte";
+    import ExtraItems from "@/modules/services/LiveSyncUI/components/ExtraItems.svelte";
+    import InputRow from "@/modules/services/LiveSyncUI/components/InputRow.svelte";
+    import Password from "@/modules/services/LiveSyncUI/components/Password.svelte";
     import {
         DEFAULT_SETTINGS,
         PREFERRED_SETTING_CLOUDANT,
@@ -14,25 +14,34 @@
         RemoteTypes,
         type CouchDBConnection,
         type ObsidianLiveSyncSettings,
-    } from "@lib/common/types";
-    import { isCloudantURI } from "@lib/pouchdb/utils_couchdb";
+    } from "@vrtmrz/livesync-commonlib/compat/common/types";
+    import { isCloudantURI } from "@vrtmrz/livesync-commonlib/compat/pouchdb/utils_couchdb";
 
     import { onMount } from "svelte";
-    import { getDialogContext, type GuestDialogProps } from "@lib/UI/svelteDialog";
-    import { copyTo, pickCouchDBSyncSettings } from "@lib/common/utils";
+    import { getDialogContext, type GuestDialogProps } from "@/modules/services/LiveSyncUI/svelteDialog";
+    import { copyTo, pickCouchDBSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/utils";
     import PanelCouchDBCheck from "./PanelCouchDBCheck.svelte";
-    import { TYPE_CANCELLED, type SetupRemoteCouchDBResultType } from "./setupDialogTypes";
+    import {
+        TYPE_CANCELLED,
+        type CouchDBSetupMode,
+        type SetupRemoteCouchDBInitialData,
+        type SetupRemoteCouchDBResultType,
+    } from "./setupDialogTypes";
+    import { isValidCouchDBServerURL, probeCouchDBConnection } from "./couchDBConnectionProbe";
+    import { $msg as translateMessage } from "@/common/translation";
 
     const default_setting = pickCouchDBSyncSettings(DEFAULT_SETTINGS);
 
     let syncSetting = $state<CouchDBConnection>({ ...default_setting });
-    type Props = GuestDialogProps<SetupRemoteCouchDBResultType, CouchDBConnection>;
+    let setupMode = $state<CouchDBSetupMode>("settings");
+    type Props = GuestDialogProps<SetupRemoteCouchDBResultType, SetupRemoteCouchDBInitialData>;
     const { setResult, getInitialData }: Props = $props();
     onMount(() => {
         if (getInitialData) {
             const initialData = getInitialData();
             if (initialData) {
-                copyTo(initialData, syncSetting);
+                setupMode = initialData.mode;
+                copyTo(initialData.settings, syncSetting);
             }
         }
     });
@@ -69,11 +78,15 @@
                 return "Failed to create replicator instance.";
             }
             try {
-                const result = await replicator.tryConnectRemote(trialRemoteSetting, false);
-                if (result) {
+                const result = await probeCouchDBConnection(
+                    replicator,
+                    trialRemoteSetting,
+                    setupMode === "create-or-connect"
+                );
+                if (result.ok) {
                     return "";
                 } else {
-                    return "Failed to connect to the server. Please check your settings.";
+                    return `Failed to connect to the server: ${result.reason}`;
                 }
             } catch (e) {
                 return `Failed to connect to the server: ${e}`;
@@ -122,7 +135,7 @@
     });
     const canProceed = $derived.by(() => {
         return (
-            syncSetting.couchDB_URI.trim().length > 0 &&
+            isValidCouchDBServerURL(syncSetting.couchDB_URI.trim()) &&
             syncSetting.couchDB_USER.trim().length > 0 &&
             syncSetting.couchDB_PASSWORD.trim().length > 0 &&
             syncSetting.couchDB_DBNAME.trim().length > 0 &&
@@ -132,6 +145,18 @@
     const testSettings = $derived.by(() => {
         return generateSetting();
     });
+    const isURLInvalid = $derived.by(
+        () => syncSetting.couchDB_URI.trim() !== "" && !isValidCouchDBServerURL(syncSetting.couchDB_URI.trim())
+    );
+    const primaryActionTitle = $derived.by(() => {
+        if (setupMode === "create-or-connect") {
+            return translateMessage("Create or connect to database and continue");
+        }
+        if (setupMode === "connect-existing") {
+            return translateMessage("Connect to existing database and continue");
+        }
+        return translateMessage("Test connection and save");
+    });
 </script>
 
 <DialogHeader title="CouchDB Configuration" />
@@ -150,6 +175,7 @@
     />
 </InputRow>
 <InfoNote warning visible={isURIInsecure}>We can use only Secure (HTTPS) connections on Obsidian Mobile.</InfoNote>
+<InfoNote warning visible={isURLInvalid}>{translateMessage("Enter a complete HTTP or HTTPS URL.")}</InfoNote>
 <InputRow label="Username">
     <input
         type="text"
@@ -180,13 +206,11 @@
         autocapitalize="off"
         spellcheck="false"
         required
-        pattern="^[a-z][a-z0-9_$()+/-]*$"
         bind:value={syncSetting.couchDB_DBNAME}
     />
 </InputRow>
 <InfoNote>
-    You cannot use capital letters, spaces, or special characters in the database name. And not allowed to start with an
-    underscore (_).
+    {translateMessage("CouchDB validates the database name when you connect. The name must not be empty.")}
 </InfoNote>
 <InputRow label="Use Internal API">
     <input type="checkbox" name="couchdb-use-internal-api" bind:checked={syncSetting.useRequestAPI} />
@@ -270,6 +294,11 @@
     </InfoNote>
 </ExtraItems>
 
+<InfoNote warning>
+    {translateMessage(
+        "This optional check uses Obsidian's internal request API and sends the credentials above to the CouchDB server. Use it only with a server you trust; administrator access may be required."
+    )}
+</InfoNote>
 <PanelCouchDBCheck trialRemoteSetting={testSettings}></PanelCouchDBCheck>
 <hr />
 
@@ -281,8 +310,19 @@
     Checking connection... Please wait.
 {:else}
     <UserDecisions>
-        <Decision title="Test Settings and Continue" important disabled={!canProceed} commit={() => checkAndCommit()} />
-        <Decision title="Continue anyway" commit={() => commit()} />
+        <Decision title={primaryActionTitle} important disabled={!canProceed} commit={() => checkAndCommit()} />
+        {#if setupMode === "settings"}
+            <InfoNote warning>
+                {translateMessage(
+                    "Saving without a successful connection test keeps this profile, but automatic synchronisation may fail until the connection is corrected."
+                )}
+            </InfoNote>
+            <Decision
+                title={translateMessage("Save without connecting")}
+                disabled={!canProceed}
+                commit={() => commit()}
+            />
+        {/if}
         <Decision title="Cancel" commit={() => cancel()} />
     </UserDecisions>
 {/if}

src/modules/features/SetupWizard/dialogs/SetupRemoteE2EE.svelte

@@ -1,21 +1,21 @@
 <script lang="ts">
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
-    import InfoNote from "@lib/UI/components/InfoNote.svelte";
-    import ExtraItems from "@lib/UI/components/ExtraItems.svelte";
-    import InputRow from "@lib/UI/components/InputRow.svelte";
-    import Password from "@lib/UI/components/Password.svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import InfoNote from "@/modules/services/LiveSyncUI/components/InfoNote.svelte";
+    import ExtraItems from "@/modules/services/LiveSyncUI/components/ExtraItems.svelte";
+    import InputRow from "@/modules/services/LiveSyncUI/components/InputRow.svelte";
+    import Password from "@/modules/services/LiveSyncUI/components/Password.svelte";
     import {
         DEFAULT_SETTINGS,
         E2EEAlgorithmNames,
         E2EEAlgorithms,
         type EncryptionSettings,
-    } from "@lib/common/types";
+    } from "@vrtmrz/livesync-commonlib/compat/common/types";
     import { onMount } from "svelte";
-    import type { GuestDialogProps } from "@lib/UI/svelteDialog";
-    import { copyTo, pickEncryptionSettings } from "@lib/common/utils";
+    import type { GuestDialogProps } from "@/modules/services/LiveSyncUI/svelteDialog";
+    import { copyTo, pickEncryptionSettings } from "@vrtmrz/livesync-commonlib/compat/common/utils";
     import { TYPE_CANCELLED, type SetupRemoteE2EEResultType } from "./setupDialogTypes";
 
     type Props = GuestDialogProps<SetupRemoteE2EEResultType, EncryptionSettings>;

src/modules/features/SetupWizard/dialogs/SetupRemoteP2P.svelte

@@ -1,13 +1,13 @@
 <script lang="ts">
     // import { delay } from "octagonal-wheels/promises";
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
-    import InfoNote from "@lib/UI/components/InfoNote.svelte";
-    import InputRow from "@lib/UI/components/InputRow.svelte";
-    import Password from "@lib/UI/components/Password.svelte";
-    import { PouchDB } from "@lib/pouchdb/pouchdb-browser";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import InfoNote from "@/modules/services/LiveSyncUI/components/InfoNote.svelte";
+    import InputRow from "@/modules/services/LiveSyncUI/components/InputRow.svelte";
+    import Password from "@/modules/services/LiveSyncUI/components/Password.svelte";
+    import { PouchDB } from "@vrtmrz/livesync-commonlib/compat/pouchdb/pouchdb-browser";
     import {
         DEFAULT_SETTINGS,
         P2P_DEFAULT_SETTINGS,
@@ -17,16 +17,24 @@
         type ObsidianLiveSyncSettings,
         type P2PConnectionInfo,
         type P2PSyncSetting,
-    } from "@lib/common/types";
+    } from "@vrtmrz/livesync-commonlib/compat/common/types";
 
-    import { TrysteroReplicator } from "@lib/replication/trystero/TrysteroReplicator";
-    import type { ReplicatorHostEnv } from "@lib/replication/trystero/types";
-    import { copyTo, pickP2PSyncSettings, type SimpleStore } from "@lib/common/utils";
+    import { TrysteroReplicator } from "@vrtmrz/livesync-commonlib/compat/replication/trystero/TrysteroReplicator";
+    import type { ReplicatorHostEnv } from "@vrtmrz/livesync-commonlib/compat/replication/trystero/types";
+    import {
+        copyTo,
+        generateP2PRoomId,
+        pickP2PSyncSettings,
+        type SimpleStore,
+    } from "@vrtmrz/livesync-commonlib/compat/common/utils";
     import { onMount } from "svelte";
-    import { getDialogContext, type GuestDialogProps } from "@lib/UI/svelteDialog";
-    import { SETTING_KEY_P2P_DEVICE_NAME } from "@lib/common/types";
-    import ExtraItems from "@lib/UI/components/ExtraItems.svelte";
+    import { getDialogContext, type GuestDialogProps } from "@/modules/services/LiveSyncUI/svelteDialog";
+    import { SETTING_KEY_P2P_DEVICE_NAME } from "@vrtmrz/livesync-commonlib/compat/common/types";
+    import ExtraItems from "@/modules/services/LiveSyncUI/components/ExtraItems.svelte";
     import { TYPE_CANCELLED, type SetupRemoteP2PResultType } from "./setupDialogTypes";
+    import { LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
+    import { $msg as translateMessage } from "@/common/translation";
+    import { probeP2PSetupConnection } from "./p2pSetupConnectionProbe";
 
     const default_setting = pickP2PSyncSettings(DEFAULT_SETTINGS);
     let syncSetting = $state<P2PConnectionInfo>({ ...default_setting });
@@ -99,6 +107,8 @@
 
             const dummyPouch = new PouchDB<EntryDoc>("dummy");
             const env: ReplicatorHostEnv = {
+                events: context.context.events,
+                translate: context.context.translate,
                 settings: trialRemoteSetting,
                 processReplicatedDocs: async (_docs: any[]) => {
                     return;
@@ -111,31 +121,17 @@
             };
             const replicator = new TrysteroReplicator(env);
             try {
-                await replicator.setOnSetup();
-                await replicator.allowReconnection();
-                await replicator.open();
-                for (let i = 0; i < 10; i++) {
-                    // await delay(1000);
-                    await new Promise((resolve) => window.setTimeout(resolve, 1000));
-                    // Logger(`Checking known advertisements... (${i})`, LOG_LEVEL_INFO);
-                    if (replicator.knownAdvertisements.length > 0) {
-                        break;
-                    }
-                }
-                // context.holdingSettings = trialRemoteSetting;
-
-                if (replicator.knownAdvertisements.length === 0) {
-                    return "Your settings seem correct, but no other peers were found.";
+                const result = await probeP2PSetupConnection(replicator);
+                if (!result.ok) {
+                    return `Failed to connect to the signalling relay: ${result.reason}`;
                 }
                 return "";
-            } catch (e) {
-                return `Failed to connect to other peers: ${e}`;
             } finally {
                 try {
-                    replicator.close();
-                    dummyPouch.destroy();
+                    await replicator.close();
+                    await dummyPouch.destroy();
                 } catch (e) {
-                    console.error(e);
+                    Logger(e, LOG_LEVEL_VERBOSE, "setup-p2p-cleanup");
                 }
             }
         } finally {
@@ -148,17 +144,7 @@
 
     let processing = $state(false);
     function generateDefaultGroupId() {
-        const randomValues = new Uint16Array(4);
-        crypto.getRandomValues(randomValues);
-        const MAX_UINT16 = 65536;
-        const a = Math.floor((randomValues[0] / MAX_UINT16) * 1000);
-        const b = Math.floor((randomValues[1] / MAX_UINT16) * 1000);
-        const c = Math.floor((randomValues[2] / MAX_UINT16) * 1000);
-        const d_range = 36 * 36 * 36;
-        const d = Math.floor((randomValues[3] / MAX_UINT16) * d_range);
-        syncSetting.P2P_roomID = `${a.toString().padStart(3, "0")}-${b
-            .toString()
-            .padStart(3, "0")}-${c.toString().padStart(3, "0")}-${d.toString(36).padStart(3, "0")}`;
+        syncSetting.P2P_roomID = generateP2PRoomId();
     }
 
     async function checkAndCommit() {
@@ -197,18 +183,31 @@
 <InputRow label="Enabled">
     <input type="checkbox" name="p2p-enabled" bind:checked={syncSetting.P2P_Enabled} />
 </InputRow>
-<InputRow label="Relay URL">
+<InputRow label={translateMessage("Signalling relay URLs")}>
     <input
         type="text"
         name="p2p-relay-url"
-        placeholder="Enter the Relay URL)"
+        placeholder="wss://relay.example.com"
         autocorrect="off"
         autocapitalize="off"
         spellcheck="false"
         bind:value={syncSetting.P2P_relays}
     />
-    <button class="button" onclick={() => setDefaultRelay()}>Use vrtmrz's relay</button>
+    <button class="button" onclick={() => setDefaultRelay()}>
+        {translateMessage("Use the project's public signalling relay")}
+    </button>
 </InputRow>
+<InfoNote>
+    {translateMessage("Peer discovery uses Nostr-compatible signalling relays.")}
+    {translateMessage(
+        "The project's public signalling relay is a best-effort convenience operated by the project author. It does not store Vault contents, but signalling metadata may be visible to the relay. Availability and log retention are not guaranteed. You can replace it with your own Nostr-compatible relay."
+    )}
+    <a
+        href="https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/p2p.md"
+        target="_blank"
+        rel="noopener noreferrer">{translateMessage("Learn more about P2P connections")}</a
+    >.
+</InfoNote>
 <InputRow label="Group ID">
     <input
         type="text"
@@ -247,12 +246,13 @@
     If "Auto Start P2P Connection" is enabled, the P2P connection will be started automatically when the plug-in
     launches.
 </InfoNote>
-<InputRow label="Auto Broadcast Changes">
+<InputRow label={translateMessage("Announce changes automatically after connecting")}>
     <input type="checkbox" name="p2p-auto-broadcast" bind:checked={syncSetting.P2P_AutoBroadcast} />
 </InputRow>
 <InfoNote>
-    If "Auto Broadcast Changes" is enabled, changes will be automatically broadcasted to connected peers without
-    requiring manual intervention. This requests peers to fetch this device's changes.
+    {translateMessage(
+        "When enabled, this device notifies connected peers after a local change. The notification contains no Vault data; a peer which follows this device then fetches the change through the encrypted P2P connection."
+    )}
 </InfoNote>
 <ExtraItems title="Advanced Settings">
     <InfoNote>
@@ -260,10 +260,14 @@
         connections. In most cases, you can leave these fields blank.
     </InfoNote>
     <InfoNote warning>
-        Using public TURN servers may have privacy implications, as your data will be relayed through third-party
-        servers. Even if your data are encrypted, your existence may be known to them. Please ensure you trust the TURN
-        server provider before using their services. Also your `network administrator` too. You should consider setting
-        up your own TURN server for your FQDN, if possible.
+        {translateMessage(
+            "TURN relays the encrypted WebRTC connection only when a direct path cannot be established. A TURN provider cannot read encrypted Vault contents, but it can observe connection metadata and traffic volume. Use a provider you trust."
+        )}
+        <a
+            href="https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/p2p.md#signalling-relay-and-turn-server"
+            target="_blank"
+            rel="noopener noreferrer">{translateMessage("Learn more about signalling and TURN")}</a
+        >.
     </InfoNote>
     <InputRow label="TURN Server URLs (comma-separated)">
         <textarea

src/modules/features/SetupWizard/dialogs/UseSetupURI.svelte

@@ -1,17 +1,17 @@
 <script lang="ts">
     import { configURIBase } from "@/common/types";
-    import type { ObsidianLiveSyncSettings } from "@lib/common/types";
-    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
-    import Guidance from "@lib/UI/components/Guidance.svelte";
-    import Decision from "@lib/UI/components/Decision.svelte";
-    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
-    import InfoNote from "@lib/UI/components/InfoNote.svelte";
-    import InputRow from "@lib/UI/components/InputRow.svelte";
-    import Password from "@lib/UI/components/Password.svelte";
+    import type { ObsidianLiveSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import InfoNote from "@/modules/services/LiveSyncUI/components/InfoNote.svelte";
+    import InputRow from "@/modules/services/LiveSyncUI/components/InputRow.svelte";
+    import Password from "@/modules/services/LiveSyncUI/components/Password.svelte";
 
     import { onMount } from "svelte";
-    import { decryptString } from "@lib/encryption/stringEncryption.ts";
-    import type { GuestDialogProps } from "@lib/UI/svelteDialog.ts";
+    import { decryptString } from "@vrtmrz/livesync-commonlib/compat/encryption/stringEncryption";
+    import type { GuestDialogProps } from "@/modules/services/LiveSyncUI/svelteDialog";
     import { TYPE_CANCELLED, type UseSetupURIResultType } from "./setupDialogTypes";
 
     type Props = GuestDialogProps<UseSetupURIResultType, string>;

src/modules/features/SetupWizard/dialogs/couchDBConnectionProbe.ts

@@ -0,0 +1,63 @@
+import type {
+    ObsidianLiveSyncSettings,
+    RemoteDBSettings,
+} from "@vrtmrz/livesync-commonlib/compat/common/models/setting.type";
+
+export type CouchDBConnectionProbeResult = { ok: true } | { ok: false; reason: string };
+
+type CouchDBConnectionResult =
+    | string
+    | {
+          db: unknown;
+          info: unknown;
+      };
+
+export interface CouchDBConnectionProbe {
+    isMobile(): boolean;
+    connectRemoteCouchDBWithSetting(
+        settings: RemoteDBSettings,
+        isMobile: boolean,
+        performSetup: boolean,
+        skipInfo: boolean
+    ): CouchDBConnectionResult | Promise<CouchDBConnectionResult>;
+}
+
+export function isCouchDBConnectionProbe(value: unknown): value is CouchDBConnectionProbe {
+    return (
+        typeof value === "object" &&
+        value !== null &&
+        "isMobile" in value &&
+        typeof value.isMobile === "function" &&
+        "connectRemoteCouchDBWithSetting" in value &&
+        typeof value.connectRemoteCouchDBWithSetting === "function"
+    );
+}
+
+export async function probeCouchDBConnection(
+    replicator: unknown,
+    settings: ObsidianLiveSyncSettings,
+    createIfMissing: boolean
+): Promise<CouchDBConnectionProbeResult> {
+    if (!isCouchDBConnectionProbe(replicator)) {
+        return { ok: false, reason: "The CouchDB connection probe is unavailable." };
+    }
+    const result = await replicator.connectRemoteCouchDBWithSetting(
+        settings,
+        replicator.isMobile(),
+        createIfMissing,
+        false
+    );
+    if (typeof result === "string") {
+        return { ok: false, reason: result };
+    }
+    return { ok: true };
+}
+
+export function isValidCouchDBServerURL(value: string): boolean {
+    try {
+        const url = new URL(value);
+        return (url.protocol === "http:" || url.protocol === "https:") && url.hostname !== "";
+    } catch {
+        return false;
+    }
+}

src/modules/features/SetupWizard/dialogs/couchDBConnectionProbe.unit.spec.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it, vi } from "vitest";
+import type { ObsidianLiveSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/models/setting.type";
+import { isValidCouchDBServerURL, probeCouchDBConnection } from "./couchDBConnectionProbe";
+
+const settings = {
+    couchDB_URI: "https://couch.example",
+    couchDB_DBNAME: "notes",
+} as ObsidianLiveSyncSettings;
+
+describe("CouchDB setup connection policy", () => {
+    it.each([
+        [false, "connect to an existing database"],
+        [true, "create or connect to a database"],
+    ] as const)(
+        "%s can %s without changing the Commonlib connection contract",
+        async (createIfMissing, _description) => {
+            const connectRemoteCouchDBWithSetting = vi.fn(async () => ({
+                db: {},
+                info: { db_name: "notes" },
+            }));
+            const replicator = {
+                isMobile: vi.fn(() => false),
+                connectRemoteCouchDBWithSetting,
+                tryConnectRemote: vi.fn(),
+            };
+
+            await expect(probeCouchDBConnection(replicator, settings, createIfMissing)).resolves.toEqual({ ok: true });
+            expect(connectRemoteCouchDBWithSetting).toHaveBeenCalledWith(settings, false, createIfMissing, false);
+            expect(replicator.tryConnectRemote).not.toHaveBeenCalled();
+        }
+    );
+
+    it("returns the connection error without saving or creating through another path", async () => {
+        const replicator = {
+            isMobile: vi.fn(() => true),
+            connectRemoteCouchDBWithSetting: vi.fn(() => "database does not exist"),
+        };
+
+        await expect(probeCouchDBConnection(replicator, settings, false)).resolves.toEqual({
+            ok: false,
+            reason: "database does not exist",
+        });
+    });
+
+    it.each([
+        ["https://couch.example", true],
+        ["http://127.0.0.1:5984", true],
+        ["ftp://couch.example", false],
+        ["couch.example", false],
+        ["https://", false],
+    ])("validates the saved server URL %s", (value, expected) => {
+        expect(isValidCouchDBServerURL(value)).toBe(expected);
+    });
+});

src/modules/features/SetupWizard/dialogs/couchDBServerFixConfirmation.ts

@@ -0,0 +1,11 @@
+import { $msg } from "@/common/translation";
+
+export function getCouchDBServerFixConfirmation(settingKey: string, expectedValue: string) {
+    return {
+        title: $msg("Change CouchDB server setting"),
+        message: $msg("Change CouchDB server setting '${SETTING}' to '${VALUE}'?", {
+            SETTING: settingKey,
+            VALUE: expectedValue,
+        }),
+    };
+}

src/modules/features/SetupWizard/dialogs/couchDBServerFixConfirmation.unit.spec.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { getCouchDBServerFixConfirmation } from "./couchDBServerFixConfirmation";
+
+describe("CouchDB server requirement fixes", () => {
+    it("identifies the exact server setting and value before a fix is applied", () => {
+        expect(getCouchDBServerFixConfirmation("chttpd/require_valid_user", "true")).toEqual({
+            title: "Change CouchDB server setting",
+            message: "Change CouchDB server setting 'chttpd/require_valid_user' to 'true'?",
+        });
+    });
+});

src/modules/features/SetupWizard/dialogs/p2pSetupConnectionProbe.ts

@@ -0,0 +1,23 @@
+export type P2PSetupConnectionProbeResult = { ok: true } | { ok: false; reason: string };
+
+export interface P2PSetupConnectionProbe {
+    setOnSetup(): void | Promise<void>;
+    allowReconnection(): void | Promise<void>;
+    open(): Promise<void>;
+}
+
+export async function probeP2PSetupConnection(
+    replicator: P2PSetupConnectionProbe
+): Promise<P2PSetupConnectionProbeResult> {
+    try {
+        await replicator.setOnSetup();
+        await replicator.allowReconnection();
+        await replicator.open();
+        return { ok: true };
+    } catch (error) {
+        return {
+            ok: false,
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

src/modules/features/SetupWizard/dialogs/p2pSetupConnectionProbe.unit.spec.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from "vitest";
+import { probeP2PSetupConnection } from "./p2pSetupConnectionProbe";
+
+describe("P2P setup connection probe", () => {
+    it("accepts an empty room after the signalling connection opens", async () => {
+        const replicator = {
+            knownAdvertisements: [],
+            setOnSetup: vi.fn(),
+            allowReconnection: vi.fn(),
+            open: vi.fn(async () => undefined),
+        };
+
+        await expect(probeP2PSetupConnection(replicator)).resolves.toEqual({ ok: true });
+        expect(replicator.setOnSetup).toHaveBeenCalledOnce();
+        expect(replicator.allowReconnection).toHaveBeenCalledOnce();
+        expect(replicator.open).toHaveBeenCalledOnce();
+    });
+
+    it("reports a signalling connection failure", async () => {
+        const replicator = {
+            knownAdvertisements: [],
+            setOnSetup: vi.fn(),
+            allowReconnection: vi.fn(),
+            open: vi.fn(async () => {
+                throw new Error("relay unavailable");
+            }),
+        };
+
+        await expect(probeP2PSetupConnection(replicator)).resolves.toEqual({
+            ok: false,
+            reason: "relay unavailable",
+        });
+    });
+});

src/modules/features/SetupWizard/dialogs/setupDialogTypes.ts

@@ -4,7 +4,7 @@ import type {
     EncryptionSettings,
     ObsidianLiveSyncSettings,
     P2PConnectionInfo,
-} from "@lib/common/models/setting.type";
+} from "@vrtmrz/livesync-commonlib/compat/common/models/setting.type";
 
 export const TYPE_IDENTICAL = "identical";
 export const TYPE_INDEPENDENT = "independent";
@@ -102,6 +102,11 @@ export type SetupRemoteE2EEResultType = typeof TYPE_CANCELLED | EncryptionSettin
 export type SetupRemoteBucketResultType = typeof TYPE_CANCELLED | BucketSyncSetting;
 
 export type SetupRemoteCouchDBResultType = typeof TYPE_CANCELLED | CouchDBConnection;
+export type CouchDBSetupMode = "create-or-connect" | "connect-existing" | "settings";
+export type SetupRemoteCouchDBInitialData = {
+    settings: CouchDBConnection;
+    mode: CouchDBSetupMode;
+};
 
 export type SetupRemoteP2PResultType = typeof TYPE_CANCELLED | P2PConnectionInfo;
 

src/modules/features/SetupWizard/dialogs/utilCheckCouchDB.ts

@@ -1,17 +1,26 @@
 import { requestToCouchDBWithCredentials } from "@/common/utils";
-import { $msg } from "@lib/common/i18n";
-import { Logger } from "@lib/common/logger";
-import type { ObsidianLiveSyncSettings } from "@lib/common/types";
-import { parseHeaderValues } from "@lib/common/utils";
-import { isCloudantURI } from "@lib/pouchdb/utils_couchdb";
-import { generateCredentialObject } from "@lib/replication/httplib";
-import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
-import { isUnauthorizedError } from "@lib/common/utils.doc";
+import { $msg } from "@/common/translation";
+import { Logger } from "@vrtmrz/livesync-commonlib/compat/common/logger";
+import type { ObsidianLiveSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { parseHeaderValues } from "@vrtmrz/livesync-commonlib/compat/common/utils";
+import { isCloudantURI } from "@vrtmrz/livesync-commonlib/compat/pouchdb/utils_couchdb";
+import { generateCredentialObject } from "@vrtmrz/livesync-commonlib/compat/replication/httplib";
+import { compatGlobal } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
+import { isUnauthorizedError } from "@vrtmrz/livesync-commonlib/compat/common/utils.doc";
+import { normaliseCouchDBConfiguration } from "@/common/couchdbConfiguration";
 
 export type ResultMessage = { message: string; classes: string[] };
 export type ResultErrorMessage = { message: string; result: "error"; classes: string[] };
 export type ResultOk<T> = { message: string; result: "ok"; value?: T };
-export type ResultError<T> = { message: string; result: "error"; value: T; fixMessage: string; fix(): Promise<void> };
+export type ResultError<T> = {
+    message: string;
+    result: "error";
+    value: T;
+    fixMessage: string;
+    settingKey: string;
+    expectedValue: string;
+    fix(): Promise<void>;
+};
 export type ConfigCheckResult<T = unknown, U = unknown> =
     | ResultOk<T>
     | ResultError<U>
@@ -78,8 +87,15 @@ export const checkConfig = async (editingSettings: ObsidianLiveSyncSettings) =>
     const addSuccess = <T>(msg: string, value?: T) => {
         result.push({ message: msg, result: "ok", value });
     };
-    const _addError = <T>(message: string, fixMessage: string, fix: () => Promise<void>, value?: T) => {
-        result.push({ message, result: "error", fixMessage, fix, value });
+    const _addError = <T>(
+        message: string,
+        fixMessage: string,
+        settingKey: string,
+        expectedValue: string,
+        fix: () => Promise<void>,
+        value?: T
+    ) => {
+        result.push({ message, result: "error", fixMessage, settingKey, expectedValue, fix, value });
     };
     const addErrorMessage = (msg: string, classes: string[] = []) => {
         result.push({ message: msg, result: "error", classes });
@@ -89,6 +105,8 @@ export const checkConfig = async (editingSettings: ObsidianLiveSyncSettings) =>
         _addError(
             message,
             fixMessage,
+            key,
+            expected,
             async () => {
                 await updateRemoteSetting(editingSettings, key, expected);
             },
@@ -115,7 +133,7 @@ export const checkConfig = async (editingSettings: ObsidianLiveSyncSettings) =>
             undefined,
             customHeaders
         );
-        const responseConfig = r.json;
+        const responseConfig = normaliseCouchDBConfiguration(r.json as unknown);
         addMessage($msg("obsidianLiveSyncSettingTab.msgNotice"), ["ob-btn-config-head"]);
         addMessage($msg("obsidianLiveSyncSettingTab.msgIfConfigNotPersistent"), ["ob-btn-config-info"]);
         addMessage($msg("obsidianLiveSyncSettingTab.msgConfigCheck"), ["ob-btn-config-head"]);

src/modules/features/StatusBarDisplay.ts

@@ -0,0 +1,133 @@
+import { reactiveSource, type ReactiveSource, type ReactiveValue } from "octagonal-wheels/dataobject/reactive";
+
+import { compatGlobal } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
+
+const STATUS_COUNTER_PADDING = "\u2007".repeat(10);
+
+export const STATUS_COUNTER_INACTIVE_LINGER_MS = 3_000;
+
+export type DisposableReactiveValue<T> = ReactiveValue<T> & {
+    dispose(): void;
+};
+
+function asDisposableReactiveValue<T>(value: ReactiveSource<T>, dispose: () => void): DisposableReactiveValue<T> {
+    return {
+        get value() {
+            return value.value;
+        },
+        onChanged(handler) {
+            value.onChanged(handler);
+        },
+        offChanged(handler) {
+            value.offChanged(handler);
+        },
+        dispose,
+    };
+}
+
+/**
+ * Mirrors an activity count while keeping each visible period on screen for a
+ * minimum total lifetime. The delay applies only when the source becomes zero.
+ */
+export function createMinimumVisibleActivityCount(
+    source: ReactiveValue<number>,
+    minimumVisibleMs: number
+): DisposableReactiveValue<number> {
+    const minimumLifetime = Math.max(0, minimumVisibleMs);
+    const displayed = reactiveSource(Math.max(0, source.value));
+    let visibleSince = displayed.value > 0 ? Date.now() : undefined;
+    let hideTimer: number | undefined;
+    let disposed = false;
+
+    const cancelHide = () => {
+        if (hideTimer === undefined) return;
+        compatGlobal.clearTimeout(hideTimer);
+        hideTimer = undefined;
+    };
+    const hideIfIdle = () => {
+        hideTimer = undefined;
+        if (disposed || Math.max(0, source.value) > 0) return;
+        displayed.value = 0;
+        visibleSince = undefined;
+    };
+    const update = () => {
+        if (disposed) return;
+        const nextCount = Math.max(0, source.value);
+        cancelHide();
+        if (nextCount > 0) {
+            if (displayed.value === 0) {
+                visibleSince = Date.now();
+            }
+            displayed.value = nextCount;
+            return;
+        }
+        if (displayed.value === 0) {
+            visibleSince = undefined;
+            return;
+        }
+
+        const elapsed = Date.now() - (visibleSince ?? Date.now());
+        const remaining = Math.max(0, minimumLifetime - elapsed);
+        if (remaining === 0) {
+            hideIfIdle();
+        } else {
+            hideTimer = compatGlobal.setTimeout(hideIfIdle, remaining);
+        }
+    };
+
+    source.onChanged(update);
+    return asDisposableReactiveValue(displayed, () => {
+        if (disposed) return;
+        disposed = true;
+        cancelHide();
+        source.offChanged(update);
+    });
+}
+
+/**
+ * Formats a counter with a stable width and briefly retains its zero value so
+ * that the completion of queued work remains visible.
+ */
+export function createPaddedCounterLabel(
+    source: ReactiveValue<number>,
+    mark: string,
+    inactiveLingerMs = STATUS_COUNTER_INACTIVE_LINGER_MS
+): DisposableReactiveValue<string> {
+    const linger = Math.max(0, inactiveLingerMs);
+    const formatted = reactiveSource("");
+    let maximumLength = 1;
+    let clearTimer: number | undefined;
+    let disposed = false;
+
+    const cancelClear = () => {
+        if (clearTimer === undefined) return;
+        compatGlobal.clearTimeout(clearTimer);
+        clearTimer = undefined;
+    };
+    const format = (count: number) => {
+        const requiredLength = `${Math.abs(count)}`.length + 1;
+        maximumLength = Math.max(maximumLength, requiredLength);
+        return ` ${mark}${`${STATUS_COUNTER_PADDING}${count}`.slice(-maximumLength)}`;
+    };
+    const update = () => {
+        if (disposed) return;
+        cancelClear();
+        const count = source.value;
+        formatted.value = format(count);
+        if (count !== 0) return;
+        clearTimer = compatGlobal.setTimeout(() => {
+            clearTimer = undefined;
+            if (disposed) return;
+            formatted.value = "";
+            maximumLength = 1;
+        }, linger);
+    };
+
+    source.onChanged(update);
+    return asDisposableReactiveValue(formatted, () => {
+        if (disposed) return;
+        disposed = true;
+        cancelClear();
+        source.offChanged(update);
+    });
+}

src/modules/features/StatusBarDisplay.unit.spec.ts

@@ -0,0 +1,139 @@
+import { reactive, reactiveSource } from "octagonal-wheels/dataobject/reactive";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+    STATUS_COUNTER_INACTIVE_LINGER_MS,
+    createMinimumVisibleActivityCount,
+    createPaddedCounterLabel,
+} from "./StatusBarDisplay.ts";
+
+describe("createMinimumVisibleActivityCount", () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date("2026-07-16T00:00:00Z"));
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it("keeps a short activity visible for the configured minimum lifetime", () => {
+        const source = reactiveSource(0);
+        const display = createMinimumVisibleActivityCount(source, 150);
+        const rendered = reactive(() => `active:${display.value}`);
+
+        expect(rendered.value).toBe("active:0");
+        source.value = 1;
+        expect(rendered.value).toBe("active:1");
+        vi.advanceTimersByTime(50);
+        source.value = 0;
+
+        expect(display.value).toBe(1);
+        vi.advanceTimersByTime(99);
+        expect(display.value).toBe(1);
+        vi.advanceTimersByTime(1);
+        expect(display.value).toBe(0);
+        expect(rendered.value).toBe("active:0");
+
+        display.dispose();
+    });
+
+    it("updates overlapping activity and starts a new minimum lifetime after becoming idle", () => {
+        const source = reactiveSource(0);
+        const display = createMinimumVisibleActivityCount(source, 150);
+
+        source.value = 1;
+        vi.advanceTimersByTime(25);
+        source.value = 2;
+        expect(display.value).toBe(2);
+        source.value = 0;
+
+        vi.advanceTimersByTime(50);
+        source.value = 1;
+        expect(display.value).toBe(1);
+
+        vi.advanceTimersByTime(75);
+        source.value = 0;
+        expect(display.value).toBe(0);
+
+        source.value = 3;
+        source.value = 0;
+        expect(display.value).toBe(3);
+        vi.advanceTimersByTime(150);
+        expect(display.value).toBe(0);
+
+        display.dispose();
+    });
+
+    it("cancels pending work and stops observing its source when disposed", () => {
+        const source = reactiveSource(0);
+        const display = createMinimumVisibleActivityCount(source, 150);
+
+        source.value = 1;
+        source.value = 0;
+        display.dispose();
+        vi.advanceTimersByTime(150);
+        source.value = 2;
+
+        expect(display.value).toBe(1);
+    });
+});
+
+describe("createPaddedCounterLabel", () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it("keeps the widest counter label until its inactive linger period ends", () => {
+        const source = reactiveSource(0);
+        const display = createPaddedCounterLabel(source, "📥");
+
+        expect(display.value).toBe("");
+        source.value = 9;
+        expect(display.value).toBe(" 📥\u20079");
+        source.value = 123;
+        expect(display.value).toBe(" 📥\u2007123");
+        source.value = 0;
+        expect(display.value).toBe(" 📥\u2007\u2007\u20070");
+
+        vi.advanceTimersByTime(STATUS_COUNTER_INACTIVE_LINGER_MS - 1);
+        expect(display.value).toBe(" 📥\u2007\u2007\u20070");
+        vi.advanceTimersByTime(1);
+        expect(display.value).toBe("");
+
+        source.value = 7;
+        expect(display.value).toBe(" 📥\u20077");
+        display.dispose();
+    });
+
+    it("cancels the pending clear when counter activity resumes", () => {
+        const source = reactiveSource(0);
+        const display = createPaddedCounterLabel(source, "📄");
+
+        source.value = 1;
+        source.value = 0;
+        vi.advanceTimersByTime(1_000);
+        source.value = 2;
+        vi.advanceTimersByTime(STATUS_COUNTER_INACTIVE_LINGER_MS);
+
+        expect(display.value).toBe(" 📄\u20072");
+        display.dispose();
+    });
+
+    it("cancels its inactive timer and source subscription when disposed", () => {
+        const source = reactiveSource(0);
+        const display = createPaddedCounterLabel(source, "📄");
+
+        source.value = 4;
+        source.value = 0;
+        display.dispose();
+        vi.advanceTimersByTime(STATUS_COUNTER_INACTIVE_LINGER_MS);
+        source.value = 5;
+
+        expect(display.value).toBe(" 📄\u20070");
+    });
+});

src/modules/main/ModuleLiveSyncMain.ts

@@ -1,5 +1,9 @@
 import { fireAndForget } from "octagonal-wheels/promises";
-import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, VER, type ObsidianLiveSyncSettings } from "@lib/common/types.ts";
+import {
+    LOG_LEVEL_NOTICE,
+    LOG_LEVEL_VERBOSE,
+    type ObsidianLiveSyncSettings,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
 import {
     EVENT_LAYOUT_READY,
     EVENT_PLUGIN_LOADED,
@@ -7,14 +11,12 @@ import {
     EVENT_SETTING_SAVED,
     eventHub,
 } from "@/common/events.ts";
-import { $msg, setLang } from "@lib/common/i18n.ts";
-import { versionNumberString2Number } from "@lib/string_and_binary/convert.ts";
+import { $msg, setLang } from "@/common/translation";
 import { AbstractModule } from "@/modules/AbstractModule.ts";
-import type { InjectableServiceHub } from "@lib/services/implements/injectable/InjectableServiceHub.ts";
+import type { InjectableServiceHub } from "@vrtmrz/livesync-commonlib/compat/services/implements/injectable/InjectableServiceHub";
 import type { LiveSyncCore } from "@/main.ts";
-import { initialiseWorkerModule } from "@lib/worker/bgWorker.ts";
-import { manifestVersion, packageVersion } from "@lib/common/coreEnvVars.ts";
-import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
+import { initialiseWorkerModule } from "@vrtmrz/livesync-commonlib/compat/worker/bgWorker";
+import { manifestVersion, packageVersion } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvVars";
 
 export class ModuleLiveSyncMain extends AbstractModule {
     async _onLiveSyncReady() {
@@ -81,7 +83,7 @@ export class ModuleLiveSyncMain extends AbstractModule {
     }
 
     async _onLiveSyncLoad(): Promise<boolean> {
-        initialiseWorkerModule();
+        initialiseWorkerModule(this.services.context.events);
         await this.services.appLifecycle.onWireUpEvents();
         // debugger;
         eventHub.emitEvent(EVENT_PLUGIN_LOADED);
@@ -97,30 +99,6 @@ export class ModuleLiveSyncMain extends AbstractModule {
             this._log($msg("moduleLiveSyncMain.logPluginInitCancelled"), LOG_LEVEL_NOTICE);
             return false;
         }
-        const lsKey = "obsidian-live-sync-ver" + this.services.vault.getVaultName();
-        const last_version = compatGlobal.localStorage.getItem(lsKey);
-
-        const lastVersion = ~~(versionNumberString2Number(manifestVersion) / 1000);
-        if (lastVersion > this.settings.lastReadUpdates && this.settings.isConfigured) {
-            this._log($msg("moduleLiveSyncMain.logReadChangelog"), LOG_LEVEL_NOTICE);
-        }
-
-        // //@ts-ignore
-        // if (this.isMobile) {
-        //     this.settings.disableRequestURI = true;
-        // }
-        if (last_version && Number(last_version) < VER) {
-            this.settings.liveSync = false;
-            this.settings.syncOnSave = false;
-            this.settings.syncOnEditorSave = false;
-            this.settings.syncOnStart = false;
-            this.settings.syncOnFileOpen = false;
-            this.settings.syncAfterMerge = false;
-            this.settings.periodicReplication = false;
-            this.settings.versionUpFlash = $msg("moduleLiveSyncMain.logVersionUpdate");
-            await this.saveSettings();
-        }
-        compatGlobal.localStorage.setItem(lsKey, `${VER}`);
         await this.services.database.openDatabase({
             databaseEvents: this.services.databaseEvents,
             replicator: this.services.replicator,

src/modules/services/LiveSyncUI/DialogHost.svelte

@@ -0,0 +1,184 @@
+<script lang="ts">
+    import type { DialogHostProps } from "@vrtmrz/livesync-commonlib/compat/services/implements/base/SvelteDialog";
+    import { type DialogSvelteComponentBaseProps } from "./svelteDialog";
+    // type Props = DialogSvelteComponentBaseProps & {
+    //     /**
+    //      * The Svelte component to mount inside the dialog host
+    //      */
+    //     mountComponent: ComponentHasResult<any>;
+    //     /**
+    //      * Callback function to setup the dialog context
+    //      * @param props
+    //      */
+    //     onSetupContext?(props: DialogSvelteComponentBaseProps): void;
+    // };
+    const props: DialogHostProps = $props();
+    const contextProps = {
+        setTitle: (title: string) => props.setTitle(title),
+        closeDialog: () => props.closeDialog(),
+        setResult: (result: any) => props.setResult(result),
+        getInitialData: () => props.getInitialData?.(),
+    } satisfies DialogSvelteComponentBaseProps<any, any>;
+
+    // Context must be established during component initialisation. The callbacks retain live access to the host props.
+    const setupContext = () => props.onSetupContext?.(contextProps);
+    setupContext();
+
+    /**
+     * Wrapper around setResult to also close the dialog
+     * @param result
+     */
+    const setResultWrapper = (result: any) => {
+        props.setResult(result);
+        props.closeDialog();
+    };
+
+    const Component = $derived(props.mountComponent);
+    let thisElement: HTMLElement;
+</script>
+
+<div class="dialog-host" bind:this={thisElement}>
+    <Component setResult={setResultWrapper} getInitialData={props.getInitialData}></Component>
+</div>
+
+<style>
+    :global(body.is-mobile .livesync-svelte-dialog-container) {
+        box-sizing: border-box;
+        padding-top: var(--safe-area-inset-top, env(safe-area-inset-top, 0px));
+        padding-right: var(--safe-area-inset-right, env(safe-area-inset-right, 0px));
+        padding-bottom: var(--safe-area-inset-bottom, env(safe-area-inset-bottom, 0px));
+        padding-left: var(--safe-area-inset-left, env(safe-area-inset-left, 0px));
+    }
+
+    :global(body.is-mobile .livesync-svelte-dialog-container .modal) {
+        max-height: 100%;
+    }
+
+    :global(body.is-mobile .livesync-svelte-dialog-container .dialog-host > .button-group) {
+        background: var(--modal-background, var(--background-primary));
+        bottom: 0;
+        padding-bottom: 1px;
+        position: sticky;
+        z-index: 1;
+    }
+
+    .dialog-host {
+        padding: 20px;
+        gap: 0.5em;
+        display: flex;
+        flex-direction: column;
+        padding-bottom: var(--keyboard-height, 0px);
+        user-select: text;
+        -webkit-user-select: text;
+    }
+
+    .dialog-host :global(button) {
+        margin-left: 10px;
+    }
+
+    .dialog-host :global(.button-group) {
+        display: flex;
+        flex-direction: column;
+        gap: 10px;
+        margin-top: 20px;
+    }
+
+    .dialog-host :global(.row) {
+        display: flex;
+        flex-direction: row;
+        justify-items: center;
+        align-items: center;
+        flex-wrap: wrap;
+    }
+
+    .dialog-host :global(.row > input[type="text"]),
+    .dialog-host :global(.row > input[type="password"]),
+    .dialog-host :global(.row > textarea),
+    .dialog-host :global(.row > select) {
+        flex: 1;
+        margin-left: 10px;
+        min-width: 10em;
+    }
+    .dialog-host :global(.row > input[type="password"]) {
+        -webkit-text-security: disc;
+    }
+
+    .dialog-host :global(.row > input[type="checkbox"]) {
+        margin-left: 10px;
+        margin-right: 10px;
+    }
+
+    .dialog-host :global(label > span) {
+        display: block;
+        width: 8em;
+    }
+
+    .dialog-host :global(.note),
+    .dialog-host :global(.note-important),
+    .dialog-host :global(.note-error) {
+        padding: 10px;
+        margin-top: 4px;
+        margin-bottom: 0.5lh;
+        border-left: 4px solid;
+    }
+
+    .dialog-host :global(.note) {
+        background-color: var(--interactive-hover);
+        border-left-color: var(--interactive-accent);
+    }
+    .dialog-host :global(.note-important) {
+        background-color: var(--interactive-hover);
+        border-left-color: var(--text-warning);
+    }
+    .dialog-host :global(.note-error) {
+        background-color: var(--interactive-hover);
+        border-left-color: var(--text-error);
+    }
+    .dialog-host :global(hr) {
+        margin: 0.7lh 0;
+    }
+    .dialog-host :global(details) {
+        gap: 0.5em;
+        padding-left: 0.5em;
+        border-left: 2px solid var(--interactive-accent);
+    }
+    .dialog-host :global(summary::marker) {
+        display: none;
+        content: "";
+    }
+
+    .dialog-host :global(summary) {
+        border-left: 4px solid var(--interactive-accent);
+        padding-left: 0.5em;
+        cursor: pointer;
+        outline: none;
+    }
+    .dialog-host :global(details > summary::after) {
+        content: "⏷";
+        float: right;
+        margin-right: 0.5em;
+    }
+    .dialog-host :global(details[open] > summary::after) {
+        content: "⏶";
+        float: right;
+        margin-right: 0.5em;
+    }
+
+    .dialog-host :global(input:invalid),
+    .dialog-host :global(textarea:invalid) {
+        border-color: var(--background-modifier-error);
+    }
+    .dialog-host :global(.sub-section) {
+        margin-left: 1em;
+        display: flex;
+        flex-direction: column;
+        gap: 0.5em;
+    }
+
+    .dialog-host :global(.row > input[type="text"]:disabled),
+    .dialog-host :global(.row > input[type="password"]:disabled),
+    .dialog-host :global(.row > textarea:disabled),
+    .dialog-host :global(.row > select:disabled) {
+        background-color: var(--background-secondary);
+    }
+</style>

src/modules/services/LiveSyncUI/components/Check.svelte

@@ -0,0 +1,53 @@
+<script lang="ts">
+    import { translateIfAvailable as translate } from "@/common/translation";
+
+    type Props = {
+        title: string;
+        value: boolean;
+        noteOnSelected?: () => any;
+        noteOnUnselected?: () => any;
+        children?: () => any;
+    };
+
+    let { title, value = $bindable(), noteOnSelected, noteOnUnselected, children }: Props = $props();
+    const translatedTitle = $derived.by(() => translate(title));
+</script>
+
+<label class="choice-row">
+    <input type="checkbox" bind:checked={value} />
+    <span class="choice-title">{translatedTitle}</span>
+</label>
+<div class="choice-notes">
+    <!-- TODO Highlight selected option -->
+    {#if value && noteOnSelected}
+        {@render noteOnSelected()}
+    {:else if !value && noteOnUnselected}
+        {@render noteOnUnselected()}
+    {/if}
+    {@render children?.()}
+</div>
+
+<style>
+    .choice-row {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        margin-top: 1rem;
+        cursor: pointer;
+    }
+    .choice-row span.choice-title {
+        width: auto;
+    }
+    .choice-row input[type="checkbox"] {
+        /* width: 1.2rem;
+        height: 1.2rem; */
+        cursor: pointer;
+    }
+
+    .choice-notes {
+        margin-left: 2rem;
+        margin-top: 0.25rem;
+        color: var(--text-muted);
+        font-size: 0.9rem;
+    }
+</style>

src/modules/services/LiveSyncUI/components/Decision.svelte

@@ -0,0 +1,24 @@
+<script lang="ts">
+    import { translateIfAvailable as translate } from "@/common/translation";
+    import { fireAndForget } from "octagonal-wheels/promises";
+
+    type Props = {
+        title: string;
+        commit: () => Promise<void> | void;
+        important?: boolean;
+        destructive?: boolean;
+        additionalClasses?: string;
+        disabled?: boolean;
+    };
+    let { title, commit, additionalClasses, important, disabled = $bindable(), destructive }: Props = $props();
+    const translatedTitle = $derived.by(() => translate(title));
+    function onclick() {
+        fireAndForget(async () => commit());
+    }
+</script>
+
+<button
+    class="button {additionalClasses} {important ? 'mod-cta' : ''} {destructive ? 'mod-destructive' : ''}"
+    {onclick}
+    {disabled}>{translatedTitle}</button
+>

src/modules/services/LiveSyncUI/components/DialogHeader.svelte

@@ -0,0 +1,41 @@
+<script lang="ts">
+    import { onMount, tick } from "svelte";
+    import { translateIfAvailable as translate } from "@/common/translation";
+    import { getDialogContext } from "@/modules/services/LiveSyncUI/svelteDialog";
+    import { _activeDocument } from "@vrtmrz/livesync-commonlib/compat/common/coreEnvFunctions";
+
+    type Props = {
+        title: string;
+        subtitle?: string;
+        children?: () => unknown;
+    };
+    let { title = $bindable(), subtitle }: Props = $props();
+    const context = getDialogContext();
+    const translatedTitle = $derived.by(() => translate(title));
+    const translatedSubtitle = $derived.by(() => (subtitle ? translate(subtitle) : ""));
+    const modalTitle = $derived.by(() => `${translatedTitle}${translatedSubtitle ? ` - ${translatedSubtitle}` : ""}`);
+
+    $effect(() => {
+        if (translatedTitle) {
+            context.setTitle(modalTitle);
+        }
+    });
+    onMount(async () => {
+        context.setTitle(modalTitle);
+        await tick();
+        _activeDocument.querySelector(".modal")?.scrollTo(0, 0);
+    });
+</script>
+
+<div class="dialog-header">
+    <h2>{translatedTitle}</h2>
+    {#if translatedSubtitle}
+        <h4>{translatedSubtitle}</h4>
+    {/if}
+</div>
+
+<style>
+    .dialog-header {
+        display: none;
+    }
+</style>

src/modules/services/LiveSyncUI/components/ExtraItems.svelte

@@ -0,0 +1,17 @@
+<script lang="ts">
+    import { translateIfAvailable as translate } from "@/common/translation";
+
+    type Props = {
+        title?: string;
+        children?: () => any;
+    };
+    const { children, title }: Props = $props();
+    const translatedTitle = $derived.by(() => (title ? translate(title) : ""));
+</script>
+
+<details>
+    <summary>{translatedTitle}</summary>
+    <div class="sub-section">
+        {@render children?.()}
+    </div>
+</details>

src/modules/services/LiveSyncUI/components/Guidance.svelte

@@ -0,0 +1,21 @@
+<script lang="ts">
+    import { translateIfAvailable as translate } from "@/common/translation";
+
+    type Props = {
+        children?: () => any;
+        important?: boolean;
+        title?: string;
+    };
+    const { children, important, title }: Props = $props();
+    const cssClass = $derived.by(() => {
+        return important ? "guidance important" : "guidance";
+    });
+    const translatedTitle = $derived.by(() => (title ? translate(title) : ""));
+</script>
+
+<div class={cssClass}>
+    {#if translatedTitle}
+        <h3>{translatedTitle}</h3>
+    {/if}
+    {@render children?.()}
+</div>

src/modules/services/LiveSyncUI/components/InfoNote.svelte

@@ -0,0 +1,87 @@
+<script lang="ts">
+    import { translateIfAvailable as translate } from "@/common/translation";
+
+    type SignalWord = "danger" | "warning" | "caution" | "notice";
+
+    type Props = {
+        title?: string;
+        message?: string;
+        children?: () => any;
+        cssClass?: string;
+        warning?: boolean;
+        caution?: boolean;
+        error?: boolean;
+        notice?: boolean;
+        info?: boolean;
+        signalWord?: string | false;
+        visible?: boolean;
+    };
+    const {
+        title,
+        message,
+        children,
+        cssClass,
+        warning: isWarning,
+        caution: isCaution,
+        error: isError,
+        notice: isNotice,
+        info: isInfo = true,
+        signalWord,
+        visible,
+    }: Props = $props();
+    const derivedCssClass = $derived.by(() => {
+        if (isError) {
+            return "note-error sls-info-note sls-info-note-danger";
+        } else if (isWarning) {
+            return "note-important sls-info-note sls-info-note-warning";
+        } else if (isCaution) {
+            return "note-important sls-info-note sls-info-note-caution";
+        } else if (isNotice) {
+            return "note sls-info-note sls-info-note-notice";
+        } else if (isInfo) {
+            return "note sls-info-note";
+        } else {
+            return "sls-info-note";
+        }
+    });
+
+    const signalWordKind = $derived.by((): SignalWord | undefined => {
+        if (isError) return "danger";
+        if (isWarning) return "warning";
+        if (isCaution) return "caution";
+        if (isNotice) return "notice";
+        return undefined;
+    });
+    const defaultSignalWord = $derived.by(() => {
+        switch (signalWordKind) {
+            case "danger":
+                return "Ui.Common.Signal.Danger";
+            case "warning":
+                return "Ui.Common.Signal.Warning";
+            case "caution":
+                return "Ui.Common.Signal.Caution";
+            case "notice":
+                return "Ui.Common.Signal.Notice";
+            default:
+                return "";
+        }
+    });
+    const signalWordText = $derived.by(() => {
+        if (signalWord === false) return "";
+        return signalWord ? translate(signalWord) : defaultSignalWord ? translate(defaultSignalWord) : "";
+    });
+    const signalWordCssKind = $derived.by(() => signalWordKind ?? "custom");
+    const translatedTitle = $derived.by(() => (title ? translate(title) : ""));
+    const translatedMessage = $derived.by(() => (message ? translate(message) : ""));
+</script>
+
+{#if visible === undefined || visible === true}
+    <div class={(cssClass ?? "") + " " + derivedCssClass}>
+        {#if signalWordText}
+            <div class="sls-signal-word sls-signal-word-{signalWordCssKind}">{signalWordText}</div>
+        {/if}
+        {#if translatedTitle}<h3>{translatedTitle}</h3>{/if}
+        {#if translatedMessage}<p>{translatedMessage}</p>{/if}
+        {@render children?.()}
+    </div>
+{/if}

src/modules/services/LiveSyncUI/components/InfoTable.svelte

@@ -0,0 +1,74 @@
+<script lang="ts">
+    type Props = {
+        info: Record<string, any>;
+    };
+    const { info }: Props = $props();
+    const infoEntries = $derived.by(() => Object.entries(info ?? {}));
+</script>
+
+<div class="info-panel">
+    <div class="info-grid" role="list">
+        {#each infoEntries as [key, value]}
+            <div class="info-entry info-key" role="listitem" aria-label={key}>
+                <div class="key">{key}</div>
+            </div>
+            <div class="info-entry info-item" role="listitem" aria-label={key}>
+                <div class="value">{value}</div>
+            </div>
+        {/each}
+    </div>
+</div>
+
+<style>
+    .info-panel {
+        padding: 0.6rem;
+        flex-grow: 1;
+    }
+
+    /* Main Grid (Info Items) 120px to 1fr, repeat */
+    .info-grid {
+        display: grid;
+        grid-template-columns:  minmax(120px, 1fr) 1fr;
+        column-count: 2;
+        gap: 0.6rem;
+        margin-top: 0.5rem;
+        grid-area: "info-key" "info-value";
+    }
+    .info-entry {
+        display: grid;
+        gap: 0.5rem;
+        border-radius: 6px;
+        box-sizing: border-box;
+        min-height: 1.2em;
+    }
+
+    .info-key {
+        font-weight: 600;
+        align-items: center;
+        border-top: 1px solid var(--background-modifier-hover);
+        border-bottom: 1px solid var(--background-modifier-hover);
+        grid-area: "info-key";
+    }
+    .info-item {
+        align-items: start;
+        padding: 0.5rem;
+        background: var(--background-modifier-hover, rgba(0, 0, 0, 0.03));
+        grid-area: "info-value";
+    }
+
+    .value {
+        white-space: pre-wrap;
+        word-break: break-word;
+        color: var(--text-normal, #e6e6e6);
+        min-height: 1em;
+    }
+
+    @container (max-width: 340px) {
+        .info-grid {
+            grid-template-columns: 1fr;
+        }
+        .info-item {
+            grid-template-columns: 1fr;
+        }
+    }
+</style>