bump

-  No longer the status element breaks other plugins' interaction (#930).

.github/workflows/cli-deno-tests.yml

@@ -32,13 +32,13 @@ jobs:
 
           case "$SELECTED_TASK" in
             test)
-              TASK_MATRIX='["test:setup-put-cat","test:mirror","test:push-pull","test:sync-two-local","test:sync-locked-remote","test:p2p-host","test:p2p-peers","test:p2p-sync","test:p2p-three-nodes","test:p2p-upload-download","test:e2e-matrix:couchdb-enc0","test:e2e-matrix:couchdb-enc1","test:e2e-matrix:minio-enc0","test:e2e-matrix:minio-enc1"]'
+              TASK_MATRIX='["test:setup-put-cat","test:mirror","test:push-pull","test:sync-two-local","test:sync-locked-remote","test:p2p-host","test:p2p-peers","test:p2p-sync","test:p2p-three-nodes","test:p2p-upload-download","test:e2e-couchdb","test:e2e-matrix"]'
               ;;
             test:local)
               TASK_MATRIX='["test:setup-put-cat","test:mirror"]'
               ;;
             test:e2e-matrix)
-              TASK_MATRIX='["test:e2e-matrix:couchdb-enc0","test:e2e-matrix:couchdb-enc1","test:e2e-matrix:minio-enc0","test:e2e-matrix:minio-enc1"]'
+              TASK_MATRIX='["test:e2e-matrix"]'
               ;;
             test:p2p-sync)
               TASK_MATRIX='["test:p2p-sync"]'
@@ -55,8 +55,6 @@ jobs:
     needs: prepare
     runs-on: ubuntu-latest
     timeout-minutes: 60
-    env:
-      DENO_DIR: ~/.cache/deno
     strategy:
       fail-fast: false
       matrix:
@@ -72,21 +70,12 @@ jobs:
         with:
           node-version: '24.x'
           cache: 'npm'
-          cache-dependency-path: package-lock.json
 
       - name: Setup Deno
         uses: denoland/setup-deno@v2
         with:
           deno-version: v2.x
 
-      - name: Cache Deno dependencies
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/deno
-          key: ${{ runner.os }}-deno-${{ hashFiles('src/apps/cli/testdeno/deno.lock', 'src/apps/cli/testdeno/deno.json') }}
-          restore-keys: |
-            ${{ runner.os }}-deno-
-
       - name: Install dependencies
         run: npm ci
 

.gitignore

@@ -30,4 +30,5 @@ cov_profile/**
 coverage
 src/apps/cli/dist/*
 _testdata/**
-utils/bench/splitResults.csv
+utils/bench/splitResults.csv
+.eslintcache

devs.md

@@ -17,7 +17,7 @@ The plugin uses a dynamic module system to reduce coupling and improve maintaina
     - `coreObsidian/` - Obsidian-specific core (e.g., `ModuleFileAccessObsidian`)
     - `essential/` - Required modules (e.g., `ModuleMigration`, `ModuleKeyValueDB`)
     - `features/` - Optional features (e.g., `ModuleLog`, `ModuleObsidianSettings`)
-    - `extras/` - Development/testing tools (e.g., `ModuleDev`, `ModuleIntegratedTest`)
+    - `extras/` - Development/testing tools (e.g., `ModuleDev`, ~~`ModuleIntegratedTest`~~)
 - **Services**: Core services (e.g., `database`, `replicator`, `storageAccess`) are registered in `ServiceHub` and accessed by modules. They provide an extension point for add new behaviour without modifying existing code.
     - For example, checks before the replication can be added to the `replication.onBeforeReplicate` handler, and the handlers can be return `false` to prevent replication-starting. `vault.isTargetFile` also can be used to prevent processing specific files.
 - **ServiceModule**: A new type of module that directly depends on services.

eslint.config.mjs

@@ -3,81 +3,132 @@ import obsidianmd from "eslint-plugin-obsidianmd";
 import globals from "globals";
 import { defineConfig, globalIgnores } from "eslint/config";
 import * as sveltePlugin from "eslint-plugin-svelte";
-
+import svelteParser from "svelte-eslint-parser";
+const warnWhileDev = "off"; // Change to "warn" to enable warnings for rules that are currently disabled.
 export default defineConfig([
     globalIgnores([
-        "**/node_modules/*",
-        "**/jest.config.js",
+        // Build outputs and legacy files
+        "**/build",
+        "coverage",
+        "**/main.js",
+        "main_org.js",
+        "pouchdb-browser.js",
+        "version-bump.mjs",
+        "package.json",
+        "**/*.json",
+        "**/.eslintrc.js.bak",
+        // Files from linked dependencies (those files should not exist for most people).
+        "modules/octagonal-wheels/dist/**/*",
+
+        // Sub-projects (Exclude from root linting as they have different environments)
+        "src/apps/**/*",
+        "utils/**/*",
+
+        // Specific exclusions from common library (src/lib)
         "src/lib/coverage",
         "src/lib/browsertest",
-        "**/test.ts",
-        "**/tests.ts",
-        "**/**test.ts",
-        "**/**.test.ts",
-        "**/*.unit.spec.ts",
-        "**/esbuild.*.mjs",
-        "**/terser.*.mjs",
-        "**/node_modules",
-        "**/build",
-        "**/.eslintrc.js.bak",
-        "src/lib/src/patches/pouchdb-utils",
-        "**/esbuild.config.mjs",
-        "**/rollup.config.js",
-        "modules/octagonal-wheels/rollup.config.js",
-        "modules/octagonal-wheels/dist/**/*",
         "src/lib/test",
         "src/lib/_tools",
+        "src/lib/src/patches/pouchdb-utils",
         "src/lib/src/cli",
-        "**/main.js",
-        "src/apps/**/*",
-        ".prettierrc.*.mjs",
-        ".prettierrc.mjs",
-        "*.config.mjs",
-        "src/apps/**/*",
         "src/lib/src/services/implements/browser/**",
         "src/lib/src/services/implements/headless/**",
         "src/lib/src/API",
+
+        // Config files and build scripts
+        "**/jest.config.js",
+        "**/rollup.config.js",
+        "**/esbuild.config.mjs",
+        "**/terser.*.mjs",
+        ".prettierrc.*.mjs",
+        ".prettierrc.mjs",
+        "*.config.mjs",
+        "vite.*",
+        "vitest.*",
+        // Testing files (Simplified patterns)
+        "test/**",
+        "**/*.test.ts",
+        "**/*.unit.spec.ts",
+        "**/test.ts",
+        "**/tests.ts",
     ]),
     ...sveltePlugin.configs["flat/base"],
     ...obsidianmd.configs.recommended,
     {
         files: ["**/*.ts"],
+        // ignores:["src/lib/**/*.ts"], // Exclude library files from root linting (they have different environments and rules).
         languageOptions: {
-            globals: { ...globals.browser },
+            globals: { ...globals.browser, PouchDB: "readonly" },
             parser: tsParser,
             parserOptions: {
                 project: "./tsconfig.json",
             },
         },
+        linterOptions:{
+            reportUnusedDisableDirectives: false,
+        },
         rules: {
+            // -- Base rules (turned off in favour of TS specific versions or explicitly disabled).
             "no-unused-vars": "off",
-            "@typescript-eslint/no-unused-vars": ["error", { args: "none" }],
             "no-unused-labels": "off",
-            "@typescript-eslint/ban-ts-comment": "off",
             "no-prototype-builtins": "off",
-            "@typescript-eslint/no-empty-function": "off",
-            "require-await": "error",
-            "obsidianmd/rule-custom-message": "off", // Temporary
-            "obsidianmd/ui/sentence-case": "off", // Temporary
-            "@typescript-eslint/require-await": "warn",
-            "@typescript-eslint/no-misused-promises": "warn",
-            "@typescript-eslint/no-floating-promises": "warn",
-            "no-async-promise-executor": "warn",
+            "require-await": "off",
+            // -- TypeScript specific rules
+            //  @typescript-eslint/no-unsafe-* rules and @typescript-eslint/no-explicit-any:
+            //  This project contains a lot of library-sh code where the use of `any` is often necessary and justified.
+            //  Rules is now set to 'off' for a while.
             "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-unsafe-argument": "off",
+            "@typescript-eslint/no-unsafe-call": "off",
+            "@typescript-eslint/no-unsafe-member-access": "off",
+            "@typescript-eslint/no-unsafe-return": "off",
+            "@typescript-eslint/no-unsafe-assignment": "off",
+            // -- Reasonable rules.
+            "@typescript-eslint/no-deprecated": warnWhileDev,
+            "@typescript-eslint/no-unused-vars": ["error", { args: "none" }],
+            "@typescript-eslint/ban-ts-comment": "off",
+            "@typescript-eslint/no-empty-function": "off",
+            "@typescript-eslint/require-await": "error",
+            "@typescript-eslint/no-misused-promises": "error",
+            "@typescript-eslint/no-floating-promises": "error",
             "@typescript-eslint/no-unnecessary-type-assertion": "error",
+
+            // -- Obsidian rules
+            // obsidianmd/no-unsupported-api: usually this project checks for API support at runtime, so this rule is not critical but can be helpful to catch potential issues.
+            "obsidianmd/no-unsupported-api": warnWhileDev,
+
+            // -- General rules
+            "no-async-promise-executor": warnWhileDev,
             "no-constant-condition": ["error", { checkLoops: false }],
+            // -- Disabled rules
+            // no-undef: This option breaks the global declarations for the library files and is not worth the effort to fix at this time.
+            "no-undef": "off",
+
+            // -- Plugin specific overrides
+            "obsidianmd/rule-custom-message": "off",
+            "obsidianmd/ui/sentence-case": "off",
+            "obsidianmd/no-plugin-as-component": "off",
+
+            // -- Temporary overrides for migration
+            "obsidianmd/no-static-styles-assignment": "off",
         },
     },
     {
         files: ["**/*.svelte"],
         languageOptions: {
+            parser: svelteParser,
             parserOptions: {
                 parser: tsParser,
+                extraFileExtensions: [".svelte"],
             },
         },
         rules: {
-            "no-unused-vars": ["error", { argsIgnorePattern: "^_", varsIgnorePattern: "^_" }],
-            "obsidianmd/no-plugin-as-component": "off", // Temporary
+            // no-unused-vars:
+            // Svelte template's declarations have a lot of false positives and the rule is not worth the effort to fix at this time.
+            // it may improve in the future with some options as like   ["error", { argsIgnorePattern: "^_", varsIgnorePattern: "^_" }],]
+            "no-unused-vars": "off",
+            "obsidianmd/no-plugin-as-component": "off",
+            "obsidianmd/ui/sentence-case": "off",
         },
     },
 ]);

manifest.json

@@ -1,10 +1,10 @@
 {
     "id": "obsidian-livesync",
     "name": "Self-hosted LiveSync",
-    "version": "0.25.68",
+    "version": "0.25.70-patch2",
     "minAppVersion": "1.7.2",
     "description": "Community implementation of self-hosted livesync. Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "author": "vorotamoroz",
     "authorUrl": "https://github.com/vrtmrz",
     "isDesktopOnly": false
-}
+}

package-lock.json

@@ -1,12 +1,12 @@
 {
     "name": "obsidian-livesync",
-    "version": "0.25.68",
+    "version": "0.25.70-patch2",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "obsidian-livesync",
-            "version": "0.25.68",
+            "version": "0.25.70-patch2",
             "license": "MIT",
             "dependencies": {
                 "@aws-sdk/client-s3": "^3.808.0",
@@ -15,6 +15,7 @@
                 "@smithy/middleware-apply-body-checksum": "^4.3.9",
                 "@smithy/protocol-http": "^5.3.9",
                 "@smithy/querystring-builder": "^4.2.9",
+                "@smithy/util-retry": "^4.4.5",
                 "@trystero-p2p/nostr": "^0.24.0",
                 "chokidar": "^4.0.0",
                 "commander": "^14.0.3",
@@ -25,7 +26,7 @@
                 "micromatch": "^4.0.0",
                 "minimatch": "^10.2.2",
                 "obsidian": "^1.12.3",
-                "octagonal-wheels": "^0.1.45",
+                "octagonal-wheels": "^0.1.46",
                 "pouchdb-adapter-leveldb": "^9.0.0",
                 "qrcode-generator": "^1.4.4",
                 "werift": "^0.23.0",
@@ -3546,9 +3547,9 @@
             }
         },
         "node_modules/@smithy/core": {
-            "version": "3.24.3",
-            "resolved": "https://registry.npmjs.org/@smithy/core/-/core-3.24.3.tgz",
-            "integrity": "sha512-Ep/7tPamGY8mgESE3LyLKtxJyy6U52WWAqr/3wial47Sj4u3PiIF73AOGI27UyLy9duTkhZbgzodOfLV4TduZg==",
+            "version": "3.24.5",
+            "resolved": "https://registry.npmjs.org/@smithy/core/-/core-3.24.5.tgz",
+            "integrity": "sha512-Kt8phUg45M15EjhYAbZ+fFikYneijLu9Liugz8ZsYz2i8j0hzGv27LWKpEHYRfvj+LyCOSijpcR/2i8RouV+cA==",
             "license": "Apache-2.0",
             "dependencies": {
                 "@aws-crypto/crc32": "5.2.0",
@@ -4149,13 +4150,12 @@
             }
         },
         "node_modules/@smithy/util-retry": {
-            "version": "4.2.12",
-            "resolved": "https://registry.npmjs.org/@smithy/util-retry/-/util-retry-4.2.12.tgz",
-            "integrity": "sha512-1zopLDUEOwumjcHdJ1mwBHddubYF8GMQvstVCLC54Y46rqoHwlIU+8ZzUeaBcD+WCJHyDGSeZ2ml9YSe9aqcoQ==",
+            "version": "4.4.5",
+            "resolved": "https://registry.npmjs.org/@smithy/util-retry/-/util-retry-4.4.5.tgz",
+            "integrity": "sha512-W9Ovy9i02yGqtLlpqZNQuXNxXc5OPfXujnembxN/FxyBtGjJd8vKY0PQYEJ8FNybTOcXG+ZxsSsX23HOb3zQzg==",
             "license": "Apache-2.0",
             "dependencies": {
-                "@smithy/service-error-classification": "^4.2.12",
-                "@smithy/types": "^4.13.1",
+                "@smithy/core": "^3.24.5",
                 "tslib": "^2.6.2"
             },
             "engines": {
@@ -11491,9 +11491,9 @@
             "license": "MIT"
         },
         "node_modules/octagonal-wheels": {
-            "version": "0.1.45",
-            "resolved": "https://registry.npmjs.org/octagonal-wheels/-/octagonal-wheels-0.1.45.tgz",
-            "integrity": "sha512-gXoCrwoUIXhmu57YN4BxAtBe+JaYNJNaXaZuVjqjopwYKpH5p2mn1om6KjA22rgGPiIJFXkse2U28FFXoT3/0Q==",
+            "version": "0.1.46",
+            "resolved": "https://registry.npmjs.org/octagonal-wheels/-/octagonal-wheels-0.1.46.tgz",
+            "integrity": "sha512-19eB7b/WNNrZ4Xghu93f+NVJsbRiaZaIIzU1rn5shxb6SzwVBoOVkNPJdCAsONl6C1MwjaGDrPUS8CBXvPHjPg==",
             "license": "MIT",
             "dependencies": {
                 "idb": "^8.0.3"

package.json

@@ -1,6 +1,6 @@
 {
     "name": "obsidian-livesync",
-    "version": "0.25.68",
+    "version": "0.25.70-patch2",
     "description": "Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "main": "main.js",
     "type": "module",
@@ -19,13 +19,13 @@
         "buildVite": "npx dotenv-cli -e .env  -- vite build --mode production",
         "buildViteOriginal": "npx dotenv-cli -e .env  -- vite build --mode original",
         "buildDev": "node esbuild.config.mjs dev",
-        "lint": "eslint src",
+        "lint": "eslint --cache --concurrency auto src",
         "svelte-check": "svelte-check --tsconfig ./tsconfig.json",
         "tsc-check": "tsc --noEmit",
         "pretty": "npm run prettyNoWrite -- --write --log-level error",
         "prettyCheck": "npm run prettyNoWrite -- --check",
         "prettyNoWrite": "prettier --config ./.prettierrc.mjs \"**/*.js\" \"**/*.ts\" \"**/*.json\" ",
-        "check": "npm run lint && npm run svelte-check",
+        "check": "npm run tsc-check && npm run lint && npm run svelte-check",
         "unittest": "deno test -A --no-check --coverage=cov_profile  --v8-flags=--expose-gc  --trace-leaks  ./src/",
         "test": "vitest run",
         "test:unit": "vitest run --config vitest.config.unit.ts",
@@ -130,17 +130,18 @@
         "@smithy/middleware-apply-body-checksum": "^4.3.9",
         "@smithy/protocol-http": "^5.3.9",
         "@smithy/querystring-builder": "^4.2.9",
+        "@smithy/util-retry": "^4.4.5",
         "@trystero-p2p/nostr": "^0.24.0",
         "chokidar": "^4.0.0",
         "commander": "^14.0.3",
-        "obsidian": "^1.12.3",
         "diff-match-patch": "^1.0.5",
         "fflate": "^0.8.2",
         "idb": "^8.0.3",
         "markdown-it": "^14.1.1",
         "micromatch": "^4.0.0",
         "minimatch": "^10.2.2",
-        "octagonal-wheels": "^0.1.45",
+        "obsidian": "^1.12.3",
+        "octagonal-wheels": "^0.1.46",
         "pouchdb-adapter-leveldb": "^9.0.0",
         "qrcode-generator": "^1.4.4",
         "werift": "^0.23.0",

src/apps/cli/.gitignore

@@ -5,5 +5,4 @@ test/test-init.local.sh
 node_modules
 .*.json
 *.env
-!.test.env
-bench-results
+!.test.env

src/apps/cli/testdeno/bench-couchdb.ts

@@ -1,312 +0,0 @@
-import { TempDir } from "./helpers/temp.ts";
-import { applyRemoteSyncSettings, initSettingsFile } from "./helpers/settings.ts";
-import { assertFilesEqual, runCliOrFail } from "./helpers/cli.ts";
-import { startCouchdb, stopCouchdb } from "./helpers/docker.ts";
-import { createDeterministicDataset, type DatasetEntry } from "./helpers/dataset.ts";
-
-type BenchmarkConfig = {
-    couchdbBackendUri: string;
-    couchdbProxyUri: string;
-    couchdbUser: string;
-    couchdbPassword: string;
-    couchdbDbname: string;
-    datasetDirName: string;
-    datasetSeed: string;
-    mdFileCount: number;
-    mdMinSizeBytes: number;
-    mdMaxSizeBytes: number;
-    binFileCount: number;
-    binSizeBytes: number;
-    syncTimeoutSeconds: number;
-    requestedRttMs: number;
-    passphrase: string;
-    encrypt: boolean;
-};
-
-function readEnvString(name: string, fallback: string): string {
-    const value = Deno.env.get(name)?.trim();
-    return value && value.length > 0 ? value : fallback;
-}
-
-function readEnvNumber(name: string, fallback: number): number {
-    const raw = Deno.env.get(name);
-    if (raw === undefined || raw.trim() === "") {
-        return fallback;
-    }
-
-    const parsed = Number(raw);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw new Error(`${name} must be a positive number, got '${raw}'`);
-    }
-    return parsed;
-}
-
-function readEnvBool(name: string, fallback: boolean): boolean {
-    const raw = Deno.env.get(name);
-    if (raw === undefined || raw.trim() === "") {
-        return fallback;
-    }
-    return /^(1|true|yes|on)$/i.test(raw.trim());
-}
-
-function nowMs(): number {
-    return performance.now();
-}
-
-function formatMs(value: number): string {
-    return `${value.toFixed(1)} ms`;
-}
-
-function formatBytes(value: number): string {
-    if (value < 1024) {
-        return `${value} B`;
-    }
-    const kib = value / 1024;
-    if (kib < 1024) {
-        return `${kib.toFixed(1)} KiB`;
-    }
-    return `${(kib / 1024).toFixed(1)} MiB`;
-}
-
-function buildConfig(): BenchmarkConfig {
-    return {
-        couchdbBackendUri: readEnvString("BENCH_COUCHDB_BACKEND_URI", "http://127.0.0.1:5989"),
-        couchdbProxyUri: readEnvString("BENCH_COUCHDB_URI", "http://127.0.0.1:15989"),
-        couchdbUser: readEnvString("BENCH_COUCHDB_USER", readEnvString("username", "admin")),
-        couchdbPassword: readEnvString("BENCH_COUCHDB_PASSWORD", readEnvString("password", "password")),
-        couchdbDbname: readEnvString("BENCH_COUCHDB_DBNAME", `bench-couchdb-${Date.now()}`),
-        datasetDirName: readEnvString("BENCH_DATASET_DIR", "bench-dataset"),
-        datasetSeed: readEnvString("BENCH_SEED", "livesync-benchmark-seed"),
-        mdFileCount: Math.floor(readEnvNumber("BENCH_MD_FILE_COUNT", 1500)),
-        mdMinSizeBytes: Math.floor(readEnvNumber("BENCH_MD_MIN_SIZE_BYTES", 1024)),
-        mdMaxSizeBytes: Math.floor(readEnvNumber("BENCH_MD_MAX_SIZE_BYTES", 20 * 1024)),
-        binFileCount: Math.floor(readEnvNumber("BENCH_BIN_FILE_COUNT", 500)),
-        binSizeBytes: Math.floor(readEnvNumber("BENCH_BIN_SIZE_BYTES", 100 * 1024)),
-        syncTimeoutSeconds: readEnvNumber("BENCH_SYNC_TIMEOUT", 240),
-        requestedRttMs: Math.floor(readEnvNumber("BENCH_COUCHDB_RTT_MS", 50)),
-        passphrase: readEnvString("BENCH_PASSPHRASE", `bench-${Date.now()}`),
-        encrypt: readEnvBool("BENCH_ENCRYPT", true),
-    };
-}
-
-function readOptionalResultPath(): string | undefined {
-    const raw = Deno.env.get("BENCH_RESULT_JSON")?.trim();
-    if (!raw) {
-        return undefined;
-    }
-    return raw;
-}
-
-function pickSampleFiles(entries: DatasetEntry[]): DatasetEntry[] {
-    if (entries.length === 0) {
-        return [];
-    }
-    const md = entries.find((e) => e.kind === "md");
-    const bin = entries.find((e) => e.kind === "bin");
-    const middle = entries[Math.floor(entries.length / 2)];
-    const last = entries[entries.length - 1];
-    const unique = new Map<string, DatasetEntry>();
-    for (const entry of [md, bin, middle, last]) {
-        if (entry) {
-            unique.set(entry.relativePath, entry);
-        }
-    }
-    return [...unique.values()];
-}
-
-type ProxyHandle = {
-    stop: () => Promise<void>;
-    applied: boolean;
-    note: string;
-};
-
-function startCouchdbProxy(options: { backendUri: string; proxyUri: string; requestedRttMs: number }): ProxyHandle {
-    const backend = new URL(options.backendUri);
-    const proxy = new URL(options.proxyUri);
-    const halfDelayMs = Math.max(1, Math.floor(options.requestedRttMs / 2));
-    const controller = new AbortController();
-
-    const listener = Deno.serve(
-        {
-            hostname: proxy.hostname,
-            port: Number(proxy.port),
-            signal: controller.signal,
-            onError(error) {
-                console.error(`[Proxy] ${String(error)}`);
-                return new Response("proxy error", { status: 502 });
-            },
-        },
-        async (request) => {
-            await new Promise((resolve) => setTimeout(resolve, halfDelayMs));
-
-            const targetUrl = new URL(request.url);
-            targetUrl.protocol = backend.protocol;
-            targetUrl.host = backend.host;
-
-            const headers = new Headers(request.headers);
-            headers.delete("host");
-            headers.delete("content-length");
-
-            let requestBody: ArrayBuffer | undefined;
-            if (request.method !== "GET" && request.method !== "HEAD") {
-                try {
-                    requestBody = await request.arrayBuffer();
-                } catch {
-                    requestBody = undefined;
-                }
-            }
-
-            const upstream = await fetch(targetUrl, {
-                method: request.method,
-                headers,
-                body: requestBody,
-                redirect: "manual",
-            });
-
-            const responseHeaders = new Headers(upstream.headers);
-            responseHeaders.delete("content-length");
-            const responseBody = await upstream.arrayBuffer();
-
-            return new Response(responseBody, {
-                status: upstream.status,
-                statusText: upstream.statusText,
-                headers: responseHeaders,
-            });
-        }
-    );
-
-    return {
-        applied: true,
-        note: `local reverse proxy on ${proxy.origin} with ${halfDelayMs}ms pre-forward delay`,
-        stop: async () => {
-            controller.abort();
-            await listener.finished.catch(() => {});
-        },
-    };
-}
-
-async function main(): Promise<void> {
-    const config = buildConfig();
-    const resultPath = readOptionalResultPath();
-
-    await using workDir = await TempDir.create("livesync-cli-couchdb-bench");
-    const vaultA = workDir.join("vault-a");
-    const vaultB = workDir.join("vault-b");
-    const settingsA = workDir.join("settings-a.json");
-    const settingsB = workDir.join("settings-b.json");
-    await Deno.mkdir(vaultA, { recursive: true });
-    await Deno.mkdir(vaultB, { recursive: true });
-
-    await initSettingsFile(settingsA);
-    await initSettingsFile(settingsB);
-
-    await startCouchdb(config.couchdbBackendUri, config.couchdbUser, config.couchdbPassword, config.couchdbDbname);
-
-    const proxy = startCouchdbProxy({
-        backendUri: config.couchdbBackendUri,
-        proxyUri: config.couchdbProxyUri,
-        requestedRttMs: config.requestedRttMs,
-    });
-
-    try {
-        await Promise.all([
-            applyRemoteSyncSettings(settingsA, {
-                remoteType: "COUCHDB",
-                couchdbUri: config.couchdbProxyUri,
-                couchdbUser: config.couchdbUser,
-                couchdbPassword: config.couchdbPassword,
-                couchdbDbname: config.couchdbDbname,
-                encrypt: config.encrypt,
-                passphrase: config.passphrase,
-            }),
-            applyRemoteSyncSettings(settingsB, {
-                remoteType: "COUCHDB",
-                couchdbUri: config.couchdbProxyUri,
-                couchdbUser: config.couchdbUser,
-                couchdbPassword: config.couchdbPassword,
-                couchdbDbname: config.couchdbDbname,
-                encrypt: config.encrypt,
-                passphrase: config.passphrase,
-            }),
-        ]);
-
-        const seedFiles = await createDeterministicDataset({
-            rootDir: vaultA,
-            datasetDirName: config.datasetDirName,
-            seed: config.datasetSeed,
-            mdCount: config.mdFileCount,
-            mdMinSizeBytes: config.mdMinSizeBytes,
-            mdMaxSizeBytes: config.mdMaxSizeBytes,
-            binCount: config.binFileCount,
-            binSizeBytes: config.binSizeBytes,
-        });
-
-        const mirrorStart = nowMs();
-        await runCliOrFail(vaultA, "--settings", settingsA, "mirror");
-        const mirrorElapsed = nowMs() - mirrorStart;
-
-        const syncAStart = nowMs();
-        await runCliOrFail(vaultA, "--settings", settingsA, "sync");
-        const syncAElapsed = nowMs() - syncAStart;
-
-        const syncBStart = nowMs();
-        await runCliOrFail(vaultB, "--settings", settingsB, "sync");
-        const syncBElapsed = nowMs() - syncBStart;
-
-        const sampleFiles = pickSampleFiles(seedFiles.entries);
-        for (const sample of sampleFiles) {
-            const pulledPath = workDir.join(`pulled-${sample.relativePath.split("/").join("_")}`);
-            await runCliOrFail(vaultB, "--settings", settingsB, "pull", sample.relativePath, pulledPath);
-            await assertFilesEqual(
-                sample.absolutePath,
-                pulledPath,
-                `sample file mismatch after CouchDB sync: ${sample.relativePath}`
-            );
-        }
-
-        const result = {
-            mode: "couchdb-cli-benchmark",
-            couchdbBackendUri: config.couchdbBackendUri,
-            couchdbProxyUri: config.couchdbProxyUri,
-            couchdbDbname: config.couchdbDbname,
-            rttRequestedMs: config.requestedRttMs,
-            proxyApplied: proxy.applied,
-            proxyNote: proxy.note,
-            datasetSeed: config.datasetSeed,
-            datasetDirName: config.datasetDirName,
-            totalFiles: seedFiles.totalFiles,
-            totalBytes: seedFiles.totalBytes,
-            mdFileCount: seedFiles.mdCount,
-            binFileCount: seedFiles.binCount,
-            mirrorElapsedMs: Number(mirrorElapsed.toFixed(1)),
-            syncAElapsedMs: Number(syncAElapsed.toFixed(1)),
-            syncBElapsedMs: Number(syncBElapsed.toFixed(1)),
-            totalSyncElapsedMs: Number((syncAElapsed + syncBElapsed).toFixed(1)),
-            throughputBytesPerSec: Number((seedFiles.totalBytes / ((syncAElapsed + syncBElapsed) / 1000)).toFixed(2)),
-            throughputMiBPerSec: Number(
-                (seedFiles.totalBytes / ((syncAElapsed + syncBElapsed) / 1000) / 1024 / 1024).toFixed(4)
-            ),
-        };
-
-        if (resultPath) {
-            await Deno.writeTextFile(resultPath, JSON.stringify(result, null, 2));
-        }
-
-        console.log(JSON.stringify(result, null, 2));
-        console.error(
-            `[Benchmark] couchdb mirrored ${seedFiles.totalFiles} files (${formatBytes(seedFiles.totalBytes)}) in ${formatMs(
-                mirrorElapsed
-            )}, synced in ${formatMs(syncAElapsed + syncBElapsed)} (${result.throughputBytesPerSec} B/s, ${result.throughputMiBPerSec} MiB/s)`
-        );
-    } finally {
-        await proxy.stop();
-        await stopCouchdb().catch(() => {});
-    }
-}
-
-if (import.meta.main) {
-    main().catch((error) => {
-        console.error(`[Fatal Error]`, error);
-        Deno.exit(1);
-    });
-}

src/apps/cli/testdeno/bench-p2p.ts

@@ -1,223 +0,0 @@
-import { TempDir } from "./helpers/temp.ts";
-import { applyP2pSettings, applyP2pTestTweaks, initSettingsFile } from "./helpers/settings.ts";
-import { startCliInBackground } from "./helpers/backgroundCli.ts";
-import { discoverPeer, maybeStartLocalRelay, stopLocalRelayIfStarted } from "./helpers/p2p.ts";
-import { assertFilesEqual, runCliOrFail } from "./helpers/cli.ts";
-import { createDeterministicDataset, type DatasetEntry } from "./helpers/dataset.ts";
-
-type BenchmarkConfig = {
-    relay: string;
-    appId: string;
-    roomId: string;
-    passphrase: string;
-    datasetDirName: string;
-    datasetSeed: string;
-    mdFileCount: number;
-    mdMinSizeBytes: number;
-    mdMaxSizeBytes: number;
-    binFileCount: number;
-    binSizeBytes: number;
-    peersTimeoutSeconds: number;
-    syncTimeoutSeconds: number;
-};
-
-function readEnvString(name: string, fallback: string): string {
-    const value = Deno.env.get(name)?.trim();
-    return value && value.length > 0 ? value : fallback;
-}
-
-function readEnvNumber(name: string, fallback: number): number {
-    const raw = Deno.env.get(name);
-    if (raw === undefined || raw.trim() === "") {
-        return fallback;
-    }
-
-    const parsed = Number(raw);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw new Error(`${name} must be a positive number, got '${raw}'`);
-    }
-    return parsed;
-}
-
-function nowMs(): number {
-    return performance.now();
-}
-
-function formatMs(value: number): string {
-    return `${value.toFixed(1)} ms`;
-}
-
-function formatBytes(value: number): string {
-    if (value < 1024) {
-        return `${value} B`;
-    }
-    const kib = value / 1024;
-    if (kib < 1024) {
-        return `${kib.toFixed(1)} KiB`;
-    }
-    const mib = kib / 1024;
-    return `${mib.toFixed(1)} MiB`;
-}
-
-function buildConfig(): BenchmarkConfig {
-    return {
-        relay: readEnvString("BENCH_RELAY", "ws://localhost:4000/"),
-        appId: readEnvString("BENCH_APP_ID", "self-hosted-livesync-cli-benchmark"),
-        roomId: readEnvString("BENCH_ROOM_ID", `bench-room-${Date.now()}`),
-        passphrase: readEnvString("BENCH_PASSPHRASE", `bench-${Date.now()}`),
-        datasetDirName: readEnvString("BENCH_DATASET_DIR", "bench-dataset"),
-        datasetSeed: readEnvString("BENCH_SEED", "livesync-benchmark-seed"),
-        mdFileCount: Math.floor(readEnvNumber("BENCH_MD_FILE_COUNT", 1500)),
-        mdMinSizeBytes: Math.floor(readEnvNumber("BENCH_MD_MIN_SIZE_BYTES", 1024)),
-        mdMaxSizeBytes: Math.floor(readEnvNumber("BENCH_MD_MAX_SIZE_BYTES", 20 * 1024)),
-        binFileCount: Math.floor(readEnvNumber("BENCH_BIN_FILE_COUNT", 500)),
-        binSizeBytes: Math.floor(readEnvNumber("BENCH_BIN_SIZE_BYTES", 100 * 1024)),
-        peersTimeoutSeconds: readEnvNumber("BENCH_PEERS_TIMEOUT", 20),
-        syncTimeoutSeconds: readEnvNumber("BENCH_SYNC_TIMEOUT", 240),
-    };
-}
-
-function readOptionalResultPath(): string | undefined {
-    const raw = Deno.env.get("BENCH_RESULT_JSON")?.trim();
-    if (!raw) {
-        return undefined;
-    }
-    return raw;
-}
-
-function pickSampleFiles(entries: DatasetEntry[]): DatasetEntry[] {
-    if (entries.length === 0) {
-        return [];
-    }
-    const md = entries.find((e) => e.kind === "md");
-    const bin = entries.find((e) => e.kind === "bin");
-    const middle = entries[Math.floor(entries.length / 2)];
-    const last = entries[entries.length - 1];
-    const unique = new Map<string, DatasetEntry>();
-    for (const entry of [md, bin, middle, last]) {
-        if (entry) {
-            unique.set(entry.relativePath, entry);
-        }
-    }
-    return [...unique.values()];
-}
-
-async function main(): Promise<void> {
-    const config = buildConfig();
-    const resultPath = readOptionalResultPath();
-
-    const relayStarted = await maybeStartLocalRelay(config.relay);
-    await using workDir = await TempDir.create("livesync-cli-p2p-bench");
-
-    const hostVault = workDir.join("vault-host");
-    const clientVault = workDir.join("vault-client");
-    const hostSettings = workDir.join("settings-host.json");
-    const clientSettings = workDir.join("settings-client.json");
-
-    await Promise.all([
-        Deno.mkdir(hostVault, { recursive: true }),
-        Deno.mkdir(clientVault, { recursive: true }),
-        initSettingsFile(hostSettings),
-        initSettingsFile(clientSettings),
-    ]);
-
-    await Promise.all([
-        applyP2pSettings(hostSettings, config.roomId, config.passphrase, config.appId, config.relay, "~.*"),
-        applyP2pSettings(clientSettings, config.roomId, config.passphrase, config.appId, config.relay, "~.*"),
-    ]);
-
-    await Promise.all([
-        applyP2pTestTweaks(hostSettings, "p2p-bench-host", config.passphrase),
-        applyP2pTestTweaks(clientSettings, "p2p-bench-client", config.passphrase),
-    ]);
-
-    const seedFiles = await createDeterministicDataset({
-        rootDir: hostVault,
-        datasetDirName: config.datasetDirName,
-        seed: config.datasetSeed,
-        mdCount: config.mdFileCount,
-        mdMinSizeBytes: config.mdMinSizeBytes,
-        mdMaxSizeBytes: config.mdMaxSizeBytes,
-        binCount: config.binFileCount,
-        binSizeBytes: config.binSizeBytes,
-    });
-
-    const mirrorStart = nowMs();
-    await runCliOrFail(hostVault, "--settings", hostSettings, "mirror");
-    const mirrorElapsed = nowMs() - mirrorStart;
-
-    const host = startCliInBackground(hostVault, "--settings", hostSettings, "p2p-host");
-    try {
-        const hostReadyStart = nowMs();
-        await host.waitUntilContains("P2P host is running", 20000);
-        const hostReadyElapsed = nowMs() - hostReadyStart;
-
-        const peerDiscoveryStart = nowMs();
-        const peer = await discoverPeer(clientVault, clientSettings, config.peersTimeoutSeconds);
-        const peerDiscoveryElapsed = nowMs() - peerDiscoveryStart;
-
-        const syncStart = nowMs();
-        await runCliOrFail(
-            clientVault,
-            "--settings",
-            clientSettings,
-            "p2p-sync",
-            peer.id,
-            String(config.syncTimeoutSeconds)
-        );
-        const syncElapsed = nowMs() - syncStart;
-
-        const sampleFiles = pickSampleFiles(seedFiles.entries);
-        for (const sample of sampleFiles) {
-            const pulledPath = workDir.join(`pulled-${sample.relativePath.replaceAll("/", "_")}`);
-            await runCliOrFail(clientVault, "--settings", clientSettings, "pull", sample.relativePath, pulledPath);
-            await assertFilesEqual(
-                sample.absolutePath,
-                pulledPath,
-                `sample file mismatch after sync: ${sample.relativePath}`
-            );
-        }
-
-        const result = {
-            mode: "p2p-cli-benchmark",
-            relay: config.relay,
-            appId: config.appId,
-            roomId: config.roomId,
-            datasetSeed: config.datasetSeed,
-            datasetDirName: config.datasetDirName,
-            peerId: peer.id,
-            peerName: peer.name,
-            totalFiles: seedFiles.totalFiles,
-            totalBytes: seedFiles.totalBytes,
-            mdFileCount: seedFiles.mdCount,
-            binFileCount: seedFiles.binCount,
-            mirrorElapsedMs: Number(mirrorElapsed.toFixed(1)),
-            hostReadyElapsedMs: Number(hostReadyElapsed.toFixed(1)),
-            peerDiscoveryElapsedMs: Number(peerDiscoveryElapsed.toFixed(1)),
-            syncElapsedMs: Number(syncElapsed.toFixed(1)),
-            throughputBytesPerSec: Number((seedFiles.totalBytes / (syncElapsed / 1000)).toFixed(2)),
-            throughputMiBPerSec: Number((seedFiles.totalBytes / (syncElapsed / 1000) / 1024 / 1024).toFixed(4)),
-        };
-
-        if (resultPath) {
-            await Deno.writeTextFile(resultPath, JSON.stringify(result, null, 2));
-        }
-
-        console.log(JSON.stringify(result, null, 2));
-        console.error(
-            `[Benchmark] mirrored ${seedFiles.totalFiles} files (${formatBytes(seedFiles.totalBytes)}) in ${formatMs(mirrorElapsed)}, ` +
-                `synced in ${formatMs(syncElapsed)} ` +
-                `(${result.throughputBytesPerSec} B/s, ${result.throughputMiBPerSec} MiB/s)`
-        );
-    } finally {
-        await host.stop();
-        await stopLocalRelayIfStarted(relayStarted);
-    }
-}
-
-if (import.meta.main) {
-    main().catch((error) => {
-        console.error(`[Fatal Error]`, error);
-        Deno.exit(1);
-    });
-}

src/apps/cli/testdeno/bench-run-item1.sh

@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-RESULTS_ROOT="${SCRIPT_DIR}/bench-results"
-TIMESTAMP="$(date +%Y%m%d-%H%M%S)"
-OUT_DIR="${RESULTS_ROOT}/${TIMESTAMP}"
-
-mkdir -p "${OUT_DIR}"
-
-echo "[bench-wrapper] output directory: ${OUT_DIR}"
-
-echo "[bench-wrapper] running p2p benchmark"
-(
-  cd "${SCRIPT_DIR}"
-  BENCH_RESULT_JSON="${OUT_DIR}/p2p.json" deno task bench:p2p
-)
-
-echo "[bench-wrapper] running couchdb benchmark with RTT ${BENCH_COUCHDB_RTT_MS:-default} ms (emulating HTTP network latency)"
-(
-  cd "${SCRIPT_DIR}"
-  BENCH_RESULT_JSON="${OUT_DIR}/couchdb.json" deno task bench:couchdb
-)
-
-cat > "${OUT_DIR}/README.txt" <<EOF
-Bench wrapper result set
-
-Generated at: ${TIMESTAMP}
-Directory: ${OUT_DIR}
-
-Files:
-- p2p.json
-- couchdb.json
-EOF
-
-echo "[bench-wrapper] verify outputs by cat"
-echo "========== ${OUT_DIR}/README.txt =========="
-cat "${OUT_DIR}/README.txt"
-echo "========== ${OUT_DIR}/p2p.json =========="
-cat "${OUT_DIR}/p2p.json"
-echo "========== ${OUT_DIR}/couchdb.json =========="
-cat "${OUT_DIR}/couchdb.json"
-
-echo "[bench-wrapper] done"
-echo "[bench-wrapper] result directory: ${OUT_DIR}"

src/apps/cli/testdeno/deno.json

@@ -12,16 +12,8 @@
         "test:p2p-sync": "deno test --env-file=.test.env -A --no-check test-p2p-sync.ts",
         "test:p2p-three-nodes": "deno test --env-file=.test.env -A --no-check test-p2p-three-nodes-conflict.ts",
         "test:p2p-upload-download": "deno test --env-file=.test.env -A --no-check test-p2p-upload-download-repro.ts",
-        "bench:p2p": "deno run --env-file=.test.env -A --no-check bench-p2p.ts",
-        "bench:couchdb": "deno run --env-file=.test.env -A --no-check bench-couchdb.ts",
-        "bench:item1": "bash ./bench-run-item1.sh",
-        "bench:item1:full": "BENCH_MD_FILE_COUNT=1500 BENCH_MD_MIN_SIZE_BYTES=1024 BENCH_MD_MAX_SIZE_BYTES=20480 BENCH_BIN_FILE_COUNT=500 BENCH_BIN_SIZE_BYTES=102400 BENCH_COUCHDB_RTT_MS=50 bash ./bench-run-item1.sh",
         "test:e2e-couchdb": "deno test --env-file=.test.env -A --no-check test-e2e-two-vaults-couchdb.ts",
-        "test:e2e-matrix": "deno test --env-file=.test.env -A --no-check test-e2e-two-vaults-matrix.ts",
-        "test:e2e-matrix:couchdb-enc0": "deno test --env-file=.test.env -A --no-check --filter='e2e matrix: COUCHDB-enc0' test-e2e-two-vaults-matrix.ts",
-        "test:e2e-matrix:couchdb-enc1": "deno test --env-file=.test.env -A --no-check --filter='e2e matrix: COUCHDB-enc1' test-e2e-two-vaults-matrix.ts",
-        "test:e2e-matrix:minio-enc0": "deno test --env-file=.test.env -A --no-check --filter='e2e matrix: MINIO-enc0' test-e2e-two-vaults-matrix.ts",
-        "test:e2e-matrix:minio-enc1": "deno test --env-file=.test.env -A --no-check --filter='e2e matrix: MINIO-enc1' test-e2e-two-vaults-matrix.ts"
+        "test:e2e-matrix": "deno test --env-file=.test.env -A --no-check test-e2e-two-vaults-matrix.ts"
     },
     "imports": {
         "@std/assert": "jsr:@std/assert@^1.0.13",

src/apps/cli/testdeno/helpers/cli.ts

@@ -39,73 +39,27 @@ function concatChunks(chunks: Uint8Array[]): Uint8Array {
     return out;
 }
 
-function formatTeeCommand(args: string[]): string {
-    return ["node", CLI_DIST, ...args].map((part) => JSON.stringify(part)).join(" ");
-}
-
-function createLineTeeWriter(
-    pid: number,
-    streamName: "stdout" | "stderr",
-    writer: (chunk: Uint8Array) => void
-): { write: (chunk: Uint8Array) => void; close: () => void } {
-    const enc = new TextEncoder();
-    const dec = new TextDecoder();
-    let pending = "";
-    let headerWritten = false;
-    const emitLine = (line: string) => {
-        if (!headerWritten) {
-            writer(enc.encode(`[CLI tee pid=${pid}:${streamName}]\n`));
-            headerWritten = true;
-        }
-        writer(enc.encode(`[CLI tee pid=${pid}:${streamName}] ${line}\n`));
-    };
-
-    const flush = (final = false) => {
-        let index = pending.indexOf("\n");
-        while (index >= 0) {
-            const line = pending.slice(0, index).replace(/\r$/, "");
-            pending = pending.slice(index + 1);
-            emitLine(line);
-            index = pending.indexOf("\n");
-        }
-        if (final && pending.length > 0) {
-            emitLine(pending.replace(/\r$/, ""));
-            pending = "";
-        }
-    };
-
-    return {
-        write(chunk: Uint8Array) {
-            pending += dec.decode(chunk, { stream: true });
-            flush(false);
-        },
-        close() {
-            pending += dec.decode();
-            flush(true);
-        },
-    };
-}
-
 async function collectStream(
     stream: ReadableStream<Uint8Array>,
-    teeTarget: { write: (chunk: Uint8Array) => void; close: () => void } | null
+    teeTarget: WritableStream<Uint8Array> | null
 ): Promise<Uint8Array> {
     const reader = stream.getReader();
     const chunks: Uint8Array[] = [];
+    const writer = teeTarget?.getWriter();
     try {
         while (true) {
             const { done, value } = await reader.read();
             if (done) break;
             if (value) {
                 chunks.push(value);
-                if (teeTarget) {
-                    teeTarget.write(value);
+                if (writer) {
+                    await writer.write(value);
                 }
             }
         }
     } finally {
-        if (teeTarget) {
-            teeTarget.close();
+        if (writer) {
+            writer.releaseLock();
         }
         reader.releaseLock();
     }
@@ -122,20 +76,8 @@ async function runNodeCommand(args: string[], stdinData?: Uint8Array): Promise<C
         stderr: "piped",
     }).spawn();
 
-    if (TEE_ENABLED) {
-        Deno.stdout.writeSync(
-            new TextEncoder().encode(`[CLI tee pid=${child.pid}] process: ${formatTeeCommand(cliArgs)}\n`)
-        );
-    }
-
-    const stdoutPromise = collectStream(
-        child.stdout,
-        TEE_ENABLED ? createLineTeeWriter(child.pid, "stdout", (chunk) => Deno.stdout.writeSync(chunk)) : null
-    );
-    const stderrPromise = collectStream(
-        child.stderr,
-        TEE_ENABLED ? createLineTeeWriter(child.pid, "stderr", (chunk) => Deno.stderr.writeSync(chunk)) : null
-    );
+    const stdoutPromise = collectStream(child.stdout, TEE_ENABLED ? Deno.stdout.writable : null);
+    const stderrPromise = collectStream(child.stderr, TEE_ENABLED ? Deno.stderr.writable : null);
 
     if (stdinData) {
         const w = child.stdin.getWriter();

src/apps/cli/testdeno/helpers/dataset.ts

@@ -1,123 +0,0 @@
-export type DeterministicDatasetConfig = {
-    rootDir: string;
-    datasetDirName: string;
-    seed: string;
-    mdCount: number;
-    mdMinSizeBytes: number;
-    mdMaxSizeBytes: number;
-    binCount: number;
-    binSizeBytes: number;
-};
-
-export type DatasetEntry = {
-    kind: "md" | "bin";
-    relativePath: string;
-    absolutePath: string;
-    size: number;
-};
-
-export type DeterministicDataset = {
-    rootDir: string;
-    datasetDirName: string;
-    seed: string;
-    entries: DatasetEntry[];
-    totalFiles: number;
-    totalBytes: number;
-    mdCount: number;
-    binCount: number;
-};
-
-function fnv1a32(input: string): number {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < input.length; i++) {
-        hash ^= input.charCodeAt(i) & 0xff;
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return hash >>> 0;
-}
-
-function createXorshift32(seed: number): () => number {
-    let state = seed >>> 0;
-    if (state === 0) {
-        state = 0x9e3779b9;
-    }
-    return () => {
-        state ^= state << 13;
-        state ^= state >>> 17;
-        state ^= state << 5;
-        return state >>> 0;
-    };
-}
-
-function createTextBytes(size: number, fileIndex: number, seed: string): Uint8Array {
-    const template =
-        `# Bench file ${fileIndex}\n` +
-        `seed: ${seed}\n` +
-        "lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n";
-
-    const templateBytes = new TextEncoder().encode(template);
-    const out = new Uint8Array(size);
-    for (let i = 0; i < size; i++) {
-        out[i] = templateBytes[i % templateBytes.length];
-    }
-    return out;
-}
-
-function toPath(rootDir: string, relativePath: string): string {
-    return `${rootDir}/${relativePath}`;
-}
-
-export async function createDeterministicDataset(config: DeterministicDatasetConfig): Promise<DeterministicDataset> {
-    if (config.mdCount < 0 || config.binCount < 0) {
-        throw new Error("mdCount and binCount must be non-negative");
-    }
-    if (config.mdMinSizeBytes <= 0 || config.mdMaxSizeBytes <= 0 || config.binSizeBytes <= 0) {
-        throw new Error("all size values must be positive");
-    }
-    if (config.mdMinSizeBytes > config.mdMaxSizeBytes) {
-        throw new Error("mdMinSizeBytes must be <= mdMaxSizeBytes");
-    }
-
-    const datasetRoot = toPath(config.rootDir, config.datasetDirName);
-    const mdDir = `${datasetRoot}/md`;
-    const binDir = `${datasetRoot}/bin`;
-    await Deno.mkdir(mdDir, { recursive: true });
-    await Deno.mkdir(binDir, { recursive: true });
-
-    const nextRandom = createXorshift32(fnv1a32(config.seed));
-    const mdRange = config.mdMaxSizeBytes - config.mdMinSizeBytes + 1;
-    const entries: DatasetEntry[] = [];
-
-    for (let index = 0; index < config.mdCount; index++) {
-        const size = config.mdMinSizeBytes + (nextRandom() % mdRange);
-        const relativePath = `${config.datasetDirName}/md/file-${String(index).padStart(4, "0")}.md`;
-        const absolutePath = toPath(config.rootDir, relativePath);
-        const body = createTextBytes(size, index, config.seed);
-        await Deno.writeFile(absolutePath, body);
-        entries.push({ kind: "md", relativePath, absolutePath, size });
-    }
-
-    for (let index = 0; index < config.binCount; index++) {
-        const size = config.binSizeBytes;
-        const relativePath = `${config.datasetDirName}/bin/file-${String(index).padStart(4, "0")}.bin`;
-        const absolutePath = toPath(config.rootDir, relativePath);
-        const body = new Uint8Array(size);
-        for (let i = 0; i < size; i++) {
-            body[i] = nextRandom() & 0xff;
-        }
-        await Deno.writeFile(absolutePath, body);
-        entries.push({ kind: "bin", relativePath, absolutePath, size });
-    }
-
-    const totalBytes = entries.reduce((sum, e) => sum + e.size, 0);
-    return {
-        rootDir: config.rootDir,
-        datasetDirName: config.datasetDirName,
-        seed: config.seed,
-        entries,
-        totalFiles: entries.length,
-        totalBytes,
-        mdCount: config.mdCount,
-        binCount: config.binCount,
-    };
-}

src/apps/cli/testdeno/helpers/docker.ts

@@ -14,11 +14,6 @@ type DockerInvoker = {
 
 let dockerInvokerPromise: Promise<DockerInvoker> | null = null;
 const DOCKER_TEE = Deno.env.get("LIVESYNC_DOCKER_TEE") === "1" || Deno.env.get("LIVESYNC_TEST_TEE") === "1";
-const trackedContainers = new Set<string>();
-const CLEANUP_SIGNALS: Deno.Signal[] = ["SIGINT", "SIGTERM"];
-let signalCleanupHandlersInstalled = false;
-let signalCleanupInProgress = false;
-const signalCleanupHandlers = new Map<Deno.Signal, () => void>();
 
 // ---------------------------------------------------------------------------
 // Low-level docker wrapper
@@ -32,53 +27,29 @@ function parseCommand(command: string): { bin: string; prefix: string[] } {
     return { bin: parts[0], prefix: parts.slice(1) };
 }
 
-async function collectStream(
-    stream: ReadableStream<Uint8Array>,
-    teeTarget: ((chunk: Uint8Array) => void) | null
-): Promise<Uint8Array> {
-    const reader = stream.getReader();
-    const chunks: Uint8Array[] = [];
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            if (!value) continue;
-            chunks.push(value);
-            if (teeTarget) {
-                teeTarget(value);
-            }
-        }
-    } finally {
-        reader.releaseLock();
-    }
-
-    const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return out;
-}
-
 async function runCommand(bin: string, args: string[]): Promise<{ code: number; stdout: string; stderr: string }> {
+    const cmd = new Deno.Command(bin, {
+        args,
+        stdin: "null",
+        stdout: "piped",
+        stderr: "piped",
+    });
     try {
-        const child = new Deno.Command(bin, {
-            args,
-            stdin: "null",
-            stdout: "piped",
-            stderr: "piped",
-        }).spawn();
-        const stdoutPromise = collectStream(child.stdout, DOCKER_TEE ? (chunk) => Deno.stdout.writeSync(chunk) : null);
-        const stderrPromise = collectStream(child.stderr, DOCKER_TEE ? (chunk) => Deno.stderr.writeSync(chunk) : null);
-        const [status, stdout, stderr] = await Promise.all([child.status, stdoutPromise, stderrPromise]);
+        const { code, stdout, stderr } = await cmd.output();
         const dec = new TextDecoder();
         const result = {
-            code: status.code,
+            code,
             stdout: dec.decode(stdout),
             stderr: dec.decode(stderr),
         };
+        if (DOCKER_TEE) {
+            if (result.stdout.trim().length > 0) {
+                console.log(`[docker:${bin}] ${result.stdout.trimEnd()}`);
+            }
+            if (result.stderr.trim().length > 0) {
+                console.error(`[docker:${bin}] ${result.stderr.trimEnd()}`);
+            }
+        }
         return result;
     } catch (err) {
         if (err instanceof Deno.errors.NotFound) {
@@ -188,73 +159,6 @@ async function dockerOrFail(...args: string[]): Promise<string> {
     return r.stdout;
 }
 
-async function stopAndRemoveContainer(container: string): Promise<void> {
-    await docker("stop", container).catch(() => {});
-    await docker("rm", container).catch(() => {});
-}
-
-async function cleanupTrackedContainers(reason: string): Promise<void> {
-    const names = [...trackedContainers];
-    if (names.length === 0) return;
-
-    console.warn(`[WARN] cleaning up tracked containers on ${reason}: ${names.join(", ")}`);
-    for (const container of names.reverse()) {
-        await stopAndRemoveContainer(container);
-        trackedContainers.delete(container);
-    }
-}
-
-async function handleSignalCleanup(signal: Deno.Signal): Promise<void> {
-    if (signalCleanupInProgress) return;
-    signalCleanupInProgress = true;
-    try {
-        await cleanupTrackedContainers(`signal ${signal}`);
-    } finally {
-        Deno.exit(signal === "SIGINT" ? 130 : 143);
-    }
-}
-
-function ensureSignalCleanupHandlers(): void {
-    if (signalCleanupHandlersInstalled) return;
-    signalCleanupHandlersInstalled = true;
-    for (const signal of CLEANUP_SIGNALS) {
-        const listener = () => {
-            void handleSignalCleanup(signal);
-        };
-        try {
-            Deno.addSignalListener(signal, listener);
-            signalCleanupHandlers.set(signal, listener);
-        } catch {
-            // Unsupported signal on this platform.
-        }
-    }
-}
-
-function removeSignalCleanupHandlers(): void {
-    if (!signalCleanupHandlersInstalled) return;
-    for (const [signal, listener] of signalCleanupHandlers) {
-        try {
-            Deno.removeSignalListener(signal, listener);
-        } catch {
-            // Ignore if already removed or unsupported.
-        }
-    }
-    signalCleanupHandlers.clear();
-    signalCleanupHandlersInstalled = false;
-}
-
-function trackContainer(container: string): void {
-    ensureSignalCleanupHandlers();
-    trackedContainers.add(container);
-}
-
-function untrackContainer(container: string): void {
-    trackedContainers.delete(container);
-    if (trackedContainers.size === 0) {
-        removeSignalCleanupHandlers();
-    }
-}
-
 function sleep(ms: number): Promise<void> {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -331,8 +235,8 @@ const MINIO_IMAGE = "minio/minio";
 const MINIO_MC_IMAGE = "minio/mc";
 
 export async function stopCouchdb(): Promise<void> {
-    await stopAndRemoveContainer(COUCHDB_CONTAINER);
-    untrackContainer(COUCHDB_CONTAINER);
+    await docker("stop", COUCHDB_CONTAINER);
+    await docker("rm", COUCHDB_CONTAINER);
 }
 
 /**
@@ -361,7 +265,6 @@ export async function startCouchdb(couchdbUri: string, user: string, password: s
         "COUCHDB_SINGLE_NODE=y",
         COUCHDB_IMAGE
     );
-    trackContainer(COUCHDB_CONTAINER);
 
     console.log("[INFO] initialising CouchDB");
     await initCouchdb(couchdbUri, user, password);
@@ -462,8 +365,8 @@ function shQuote(value: string): string {
 }
 
 export async function stopMinio(): Promise<void> {
-    await stopAndRemoveContainer(MINIO_CONTAINER);
-    untrackContainer(MINIO_CONTAINER);
+    await docker("stop", MINIO_CONTAINER);
+    await docker("rm", MINIO_CONTAINER);
 }
 
 async function initMinioBucket(
@@ -543,7 +446,6 @@ export async function startMinio(
         "--console-address",
         ":9001"
     );
-    trackContainer(MINIO_CONTAINER);
 
     console.log(`[INFO] initialising MinIO test bucket: ${bucket}`);
     let initialised = false;
@@ -591,8 +493,8 @@ EOF
 exec /app/strfry --config /tmp/strfry.conf relay`;
 
 export async function stopP2pRelay(): Promise<void> {
-    await stopAndRemoveContainer(P2P_RELAY_CONTAINER);
-    untrackContainer(P2P_RELAY_CONTAINER);
+    await docker("stop", P2P_RELAY_CONTAINER);
+    await docker("rm", P2P_RELAY_CONTAINER);
 }
 
 /**
@@ -621,7 +523,6 @@ export async function startP2pRelay(): Promise<void> {
         "-lc",
         STRFRY_BOOTSTRAP_SH
     );
-    trackContainer(P2P_RELAY_CONTAINER);
 }
 
 export function isLocalP2pRelay(relayUrl: string): boolean {

src/apps/cli/testdeno/helpers/net.ts

@@ -1,49 +0,0 @@
-type WaitForPortOptions = {
-    timeoutMs?: number;
-    intervalMs?: number;
-    connectTimeoutMs?: number;
-};
-
-function sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function connectWithTimeout(hostname: string, port: number, timeoutMs: number): Promise<void> {
-    let timer: number | undefined;
-    try {
-        const connPromise = Deno.connect({ hostname, port });
-        const timeoutPromise = new Promise<never>((_, reject) => {
-            timer = setTimeout(() => reject(new Error(`connect timeout after ${timeoutMs}ms`)), timeoutMs);
-        });
-        const conn = await Promise.race([connPromise, timeoutPromise]);
-        conn.close();
-    } finally {
-        if (timer !== undefined) {
-            clearTimeout(timer);
-        }
-    }
-}
-
-export async function waitForPort(hostname: string, port: number, options: WaitForPortOptions = {}): Promise<void> {
-    const timeoutMs = options.timeoutMs ?? 15000;
-    const intervalMs = options.intervalMs ?? 250;
-    const connectTimeoutMs = options.connectTimeoutMs ?? 1000;
-
-    const started = Date.now();
-    let lastError: unknown;
-
-    while (Date.now() - started < timeoutMs) {
-        try {
-            await connectWithTimeout(hostname, port, connectTimeoutMs);
-            return;
-        } catch (error) {
-            lastError = error;
-            await sleep(intervalMs);
-        }
-    }
-
-    throw new Error(
-        `Port ${hostname}:${port} did not become ready within ${timeoutMs}ms` +
-            (lastError ? ` (last error: ${String(lastError)})` : "")
-    );
-}

src/apps/cli/testdeno/helpers/p2p.ts

@@ -1,26 +1,11 @@
 import { runCli } from "./cli.ts";
 import { isLocalP2pRelay, startP2pRelay, stopP2pRelay } from "./docker.ts";
-import { waitForPort } from "./net.ts";
 
 export type PeerEntry = {
     id: string;
     name: string;
 };
 
-function sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function parseRelayEndpoint(relay: string): { hostname: string; port: number } {
-    const url = new URL(relay);
-    const port = url.port ? Number(url.port) : url.protocol === "ws:" ? 80 : url.protocol === "wss:" ? 443 : NaN;
-    if (!Number.isFinite(port)) {
-        throw new Error(`Unsupported relay URL: ${relay}`);
-    }
-    const hostname = url.hostname === "localhost" ? "127.0.0.1" : url.hostname;
-    return { hostname, port };
-}
-
 export function parsePeerLines(output: string): PeerEntry[] {
     return output
         .split(/\r?\n/)
@@ -35,55 +20,28 @@ export async function discoverPeer(
     timeoutSeconds: number,
     targetPeer?: string
 ): Promise<PeerEntry> {
-    const retries = Math.max(0, Number(Deno.env.get("LIVESYNC_P2P_PEERS_RETRY") ?? "3"));
-    let lastCombined = "";
-
-    for (let attempt = 0; attempt <= retries; attempt++) {
-        const result = await runCli(vaultDir, "--settings", settingsFile, "p2p-peers", String(timeoutSeconds));
-        lastCombined = result.combined;
-
-        if (result.code === 0) {
-            const peers = parsePeerLines(result.stdout);
-            if (targetPeer) {
-                const matched = peers.find((peer) => peer.id === targetPeer || peer.name === targetPeer);
-                if (matched) return matched;
-            }
-            if (peers.length > 0) {
-                return peers[0];
-            }
-
-            const fallback = result.combined.match(/Advertisement from\s+([^\s]+)/);
-            if (fallback?.[1]) {
-                return { id: fallback[1], name: fallback[1] };
-            }
-        }
-
-        if (attempt < retries) {
-            const waitMs = 400 * (attempt + 1);
-            console.warn(
-                `[WARN] p2p-peers returned no usable peers, retrying (${attempt + 1}/${retries}) in ${waitMs}ms`
-            );
-            await sleep(waitMs);
-            continue;
-        }
-
-        throw new Error(
-            result.code !== 0 ? `p2p-peers failed\n${result.combined}` : `No peers discovered\n${result.combined}`
-        );
+    const result = await runCli(vaultDir, "--settings", settingsFile, "p2p-peers", String(timeoutSeconds));
+    if (result.code !== 0) {
+        throw new Error(`p2p-peers failed\n${result.combined}`);
     }
-
-    throw new Error(`No peers discovered\n${lastCombined}`);
+    const peers = parsePeerLines(result.stdout);
+    if (targetPeer) {
+        const matched = peers.find((peer) => peer.id === targetPeer || peer.name === targetPeer);
+        if (matched) return matched;
+    }
+    if (peers.length === 0) {
+        const fallback = result.combined.match(/Advertisement from\s+([^\s]+)/);
+        if (fallback?.[1]) {
+            return { id: fallback[1], name: fallback[1] };
+        }
+        throw new Error(`No peers discovered\n${result.combined}`);
+    }
+    return peers[0];
 }
 
 export async function maybeStartLocalRelay(relay: string): Promise<boolean> {
     if (!isLocalP2pRelay(relay)) return false;
     await startP2pRelay();
-    const endpoint = parseRelayEndpoint(relay);
-    await waitForPort(endpoint.hostname, endpoint.port, {
-        timeoutMs: Number(Deno.env.get("LIVESYNC_P2P_RELAY_READY_TIMEOUT_MS") ?? "15000"),
-        intervalMs: Number(Deno.env.get("LIVESYNC_P2P_RELAY_READY_INTERVAL_MS") ?? "250"),
-        connectTimeoutMs: Number(Deno.env.get("LIVESYNC_P2P_RELAY_CONNECT_TIMEOUT_MS") ?? "1000"),
-    });
     return true;
 }
 

src/apps/cli/testdeno/test-p2p-peers-local-relay.ts

@@ -9,9 +9,6 @@ Deno.test("p2p-peers: discovers host through local relay", async () => {
     const roomId = Deno.env.get("ROOM_ID") ?? `room-${Date.now()}`;
     const passphrase = Deno.env.get("PASSPHRASE") ?? "test";
     const timeoutSeconds = Number(Deno.env.get("TIMEOUT_SECONDS") ?? "8");
-    const nonce = `${Date.now()}-${crypto.randomUUID().slice(0, 8)}`;
-    const hostPeerName = Deno.env.get("HOST_PEER_NAME") ?? `p2p-host-${nonce}`;
-    const clientPeerName = Deno.env.get("CLIENT_PEER_NAME") ?? `p2p-client-${nonce}`;
 
     await using workDir = await TempDir.create("livesync-cli-p2p-peers-local-relay");
     const hostVault = workDir.join("vault-host");
@@ -27,16 +24,15 @@ Deno.test("p2p-peers: discovers host through local relay", async () => {
         await initSettingsFile(clientSettings);
         await applyP2pSettings(hostSettings, roomId, passphrase, "self-hosted-livesync-cli-tests", relay);
         await applyP2pSettings(clientSettings, roomId, passphrase, "self-hosted-livesync-cli-tests", relay);
-        await applyP2pTestTweaks(hostSettings, hostPeerName, passphrase);
-        await applyP2pTestTweaks(clientSettings, clientPeerName, passphrase);
+        await applyP2pTestTweaks(hostSettings, "p2p-host", passphrase);
+        await applyP2pTestTweaks(clientSettings, "p2p-client", passphrase);
 
         const host = startCliInBackground(hostVault, "--settings", hostSettings, "p2p-host");
         try {
             await host.waitUntilContains("P2P host is running", 20000);
-            const peer = await discoverPeer(clientVault, clientSettings, timeoutSeconds, hostPeerName);
+            const peer = await discoverPeer(clientVault, clientSettings, timeoutSeconds);
             assert(peer.id.length > 0);
             assert(peer.name.length > 0);
-            assert(peer.name === hostPeerName, `expected peer '${hostPeerName}', got '${peer.name}'`);
         } finally {
             await host.stop();
         }

src/apps/cli/testdeno/test-p2p-sync.ts

@@ -11,9 +11,6 @@ Deno.test("p2p-sync: discovers peer and completes sync", async () => {
     const passphrase = Deno.env.get("PASSPHRASE") ?? "test";
     const peersTimeout = Number(Deno.env.get("PEERS_TIMEOUT") ?? "12");
     const syncTimeout = Number(Deno.env.get("SYNC_TIMEOUT") ?? "15");
-    const nonce = `${Date.now()}-${crypto.randomUUID().slice(0, 8)}`;
-    const hostPeerName = Deno.env.get("HOST_PEER_NAME") ?? `p2p-host-${nonce}`;
-    const clientPeerName = Deno.env.get("CLIENT_PEER_NAME") ?? `p2p-client-${nonce}`;
 
     await using workDir = await TempDir.create("livesync-cli-p2p-sync");
     const hostVault = workDir.join("vault-host");
@@ -29,8 +26,8 @@ Deno.test("p2p-sync: discovers peer and completes sync", async () => {
         await initSettingsFile(clientSettings);
         await applyP2pSettings(hostSettings, roomId, passphrase, "self-hosted-livesync-cli-tests", relay);
         await applyP2pSettings(clientSettings, roomId, passphrase, "self-hosted-livesync-cli-tests", relay);
-        await applyP2pTestTweaks(hostSettings, hostPeerName, passphrase);
-        await applyP2pTestTweaks(clientSettings, clientPeerName, passphrase);
+        await applyP2pTestTweaks(hostSettings, "p2p-host", passphrase);
+        await applyP2pTestTweaks(clientSettings, "p2p-client", passphrase);
 
         const host = startCliInBackground(hostVault, "--settings", hostSettings, "p2p-host");
         try {
@@ -39,7 +36,7 @@ Deno.test("p2p-sync: discovers peer and completes sync", async () => {
                 clientVault,
                 clientSettings,
                 peersTimeout,
-                Deno.env.get("TARGET_PEER") ?? hostPeerName
+                Deno.env.get("TARGET_PEER") ?? undefined
             );
             const syncResult = await runCli(
                 clientVault,

src/apps/cli/testdeno/test-p2p-three-nodes-conflict.ts

@@ -1,6 +1,6 @@
 import { assert } from "@std/assert";
 import { TempDir } from "./helpers/temp.ts";
-import { applyP2pSettings, applyP2pTestTweaks, initSettingsFile } from "./helpers/settings.ts";
+import { applyP2pSettings, initSettingsFile } from "./helpers/settings.ts";
 import { startCliInBackground } from "./helpers/backgroundCli.ts";
 import { discoverPeer, maybeStartLocalRelay, stopLocalRelayIfStarted } from "./helpers/p2p.ts";
 import { jsonStringField, runCliOrFail, runCliWithInputOrFail, sanitiseCatStdout } from "./helpers/cli.ts";
@@ -12,10 +12,6 @@ Deno.test("p2p: three nodes detect and resolve conflicts", async () => {
     const appId = Deno.env.get("APP_ID") ?? "self-hosted-livesync-cli-tests";
     const peersTimeout = Number(Deno.env.get("PEERS_TIMEOUT") ?? "10");
     const syncTimeout = Number(Deno.env.get("SYNC_TIMEOUT") ?? "15");
-    const nonce = `${Date.now()}-${crypto.randomUUID().slice(0, 8)}`;
-    const hostPeerName = Deno.env.get("HOST_PEER_NAME") ?? `p2p-host-${nonce}`;
-    const peerNameB = Deno.env.get("PEER_NAME_B") ?? `p2p-client-b-${nonce}`;
-    const peerNameC = Deno.env.get("PEER_NAME_C") ?? `p2p-client-c-${nonce}`;
 
     await using workDir = await TempDir.create("livesync-cli-p2p-3nodes");
     const vaultA = workDir.join("vault-a");
@@ -30,21 +26,16 @@ Deno.test("p2p: three nodes detect and resolve conflicts", async () => {
 
     const relayStarted = await maybeStartLocalRelay(relay);
     try {
-        await initSettingsFile(settingsA);
-        await initSettingsFile(settingsB);
-        await initSettingsFile(settingsC);
-        await applyP2pSettings(settingsA, roomId, passphrase, appId, relay);
-        await applyP2pSettings(settingsB, roomId, passphrase, appId, relay);
-        await applyP2pSettings(settingsC, roomId, passphrase, appId, relay);
-        await applyP2pTestTweaks(settingsA, hostPeerName, passphrase);
-        await applyP2pTestTweaks(settingsB, peerNameB, passphrase);
-        await applyP2pTestTweaks(settingsC, peerNameC, passphrase);
+        for (const settings of [settingsA, settingsB, settingsC]) {
+            await initSettingsFile(settings);
+            await applyP2pSettings(settings, roomId, passphrase, appId, relay);
+        }
 
         const host = startCliInBackground(vaultA, "--settings", settingsA, "p2p-host");
         try {
             await host.waitUntilContains("P2P host is running", 20000);
-            const peerFromB = await discoverPeer(vaultB, settingsB, peersTimeout, hostPeerName);
-            const peerFromC = await discoverPeer(vaultC, settingsC, peersTimeout, hostPeerName);
+            const peerFromB = await discoverPeer(vaultB, settingsB, peersTimeout);
+            const peerFromC = await discoverPeer(vaultC, settingsC, peersTimeout);
             const targetPath = "p2p/conflicted-from-two-clients.txt";
 
             await runCliWithInputOrFail("from-client-b-v1\n", vaultB, "--settings", settingsB, "put", targetPath);

src/common/utils.ts

@@ -128,7 +128,7 @@ export const _requestToCouchDBFetch = async (
     username: string,
     password: string,
     path?: string,
-    body?: string | any,
+    body?: any,
     method?: string
 ) => {
     const utf8str = String.fromCharCode.apply(null, [...writeString(`${username}:${password}`)]);
@@ -146,7 +146,7 @@ export const _requestToCouchDBFetch = async (
         contentType: "application/json",
         body: JSON.stringify(body),
     };
-    return await fetch(uri, requestParam);
+    return await _fetch(uri, requestParam);
 };
 
 export const _requestToCouchDB = async (
@@ -214,6 +214,7 @@ import { BASE_IS_NEW, EVEN, TARGET_IS_NEW } from "@lib/common/models/shared.cons
 export { BASE_IS_NEW, EVEN, TARGET_IS_NEW };
 // Why 2000? : ZIP FILE Does not have enough resolution.
 import { compareMTime } from "@lib/common/utils.ts";
+import { _fetch } from "@/lib/src/common/coreEnvFunctions.ts";
 export { compareMTime };
 function getKey(file: AnyEntry | string | UXFileInfoStub) {
     const key = typeof file == "string" ? file : stripAllPrefixes(file.path);

src/features/ConfigSync/CmdConfigSync.ts

@@ -68,9 +68,10 @@ import { ConflictResolveModal } from "../../modules/features/InteractiveConflict
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
 import { EVENT_REQUEST_OPEN_PLUGIN_SYNC_DIALOG, eventHub } from "../../common/events.ts";
 import { PluginDialogModal } from "./PluginDialogModal.ts";
-import { $msg } from "src/lib/src/common/i18n.ts";
+import { $msg } from "@/lib/src/common/i18n.ts";
 import type { InjectableServiceHub } from "../../lib/src/services/InjectableServices.ts";
 import type { LiveSyncCore } from "../../main.ts";
+import { LiveSyncError } from "@lib/common/LSError.ts";
 
 const d = "\u200b";
 const d2 = "\n";
@@ -564,7 +565,7 @@ export class ConfigSync extends LiveSyncCommands {
                 ...data,
                 documentPath: this.getPath(wx),
                 files: xFiles,
-            } as PluginDataExDisplay;
+            } satisfies PluginDataExDisplay;
         }
         return false;
     }
@@ -1069,10 +1070,10 @@ export class ConfigSync extends LiveSyncCommands {
         }
         const baseDir = this.configDir;
         try {
-            if (!data.documentPath) throw "InternalError: Document path not exist";
+            if (!data.documentPath) throw new LiveSyncError("InternalError: Document path not exist");
             const dx = await this.localDatabase.getDBEntry(data.documentPath);
             if (dx == false) {
-                throw "Not found on database";
+                throw new LiveSyncError("Not found on database");
             }
             const loadedData = deserialize(getDocDataAsArray(dx.data), {}) as PluginDataEx;
             for (const f of loadedData.files) {
@@ -1317,7 +1318,7 @@ export class ConfigSync extends LiveSyncCommands {
                     }
                     const docXDoc = await this.localDatabase.getDBEntryFromMeta(old, false, false);
                     if (docXDoc == false) {
-                        throw "Could not load the document";
+                        throw new LiveSyncError("Could not load the document");
                     }
                     const dataSrc = getDocData(docXDoc.data);
                     const dataStart = dataSrc.indexOf(DUMMY_END);

src/features/HiddenFileSync/CmdHiddenFileSync.ts

@@ -50,6 +50,7 @@ import { hiddenFilesEventCount, hiddenFilesProcessingCount } from "../../lib/src
 import { EVENT_SETTING_SAVED, eventHub } from "../../common/events.ts";
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
 import type { LiveSyncCore } from "../../main.ts";
+import { tryGetFilePath } from "@lib/common/utils.doc.ts";
 type SyncDirection = "push" | "pull" | "safe" | "pullForce" | "pushForce";
 
 declare global {
@@ -317,7 +318,7 @@ export class HiddenFileSync extends LiveSyncCommands {
         this._fileInfoLastProcessed.set(file, key);
     }
 
-    async updateLastProcessedAsActualFile(file: FilePath, stat?: UXStat | null | undefined) {
+    async updateLastProcessedAsActualFile(file: FilePath, stat?: UXStat | null) {
         if (!stat) stat = await this.core.storageAccess.statHidden(file);
         this._fileInfoLastProcessed.set(file, this.statToKey(stat));
     }
@@ -411,10 +412,7 @@ export class HiddenFileSync extends LiveSyncCommands {
         }
     }
 
-    async updateLastProcessedAsActualDatabase(
-        file: FilePath,
-        doc?: MetaEntry | LoadedEntry | null | undefined | false
-    ) {
+    async updateLastProcessedAsActualDatabase(file: FilePath, doc?: MetaEntry | LoadedEntry | null | false) {
         const dbPath = addPrefix(file, ICHeader);
         if (!doc) doc = await this.localDatabase.getDBEntryMeta(dbPath);
         if (!doc) return;
@@ -1050,7 +1048,7 @@ Offline Changed files: ${processFiles.length}`;
                 }
                 notifyProgress();
             } catch (ex) {
-                this._log(`Failed to process storage change file:${file}`, logLevel);
+                this._log(`Failed to process storage change file:${tryGetFilePath(file)}`, logLevel);
                 this._log(ex, LOG_LEVEL_VERBOSE);
             }
         });
@@ -1162,7 +1160,7 @@ Offline Changed files: ${files.length}`;
                 await this.trackDatabaseFileModification(path, "[Scanning]", true, onlyNew, file);
                 notifyProgress();
             } catch (ex) {
-                this._log(`Failed to process database changes:${file}`);
+                this._log(`Failed to process database changes:${tryGetFilePath(file)}`);
                 this._log(ex, LOG_LEVEL_VERBOSE);
             }
             return;
@@ -1500,7 +1498,7 @@ Offline Changed files: ${files.length}`;
     }
 
     async storeInternalFileToDatabase(file: InternalFileInfo | UXFileInfo, forceWrite = false) {
-        const storeFilePath = stripAllPrefixes(file.path as FilePath);
+        const storeFilePath = stripAllPrefixes(file.path);
         const storageFilePath = file.path;
         if (await this.services.vault.isIgnoredByIgnoreFile(storageFilePath)) {
             return undefined;

src/features/LocalDatabaseMainte/CmdLocalDatabaseMainte.ts

@@ -16,9 +16,8 @@ import { serialized } from "octagonal-wheels/concurrency/lock_v2";
 import { arrayToChunkedArray } from "octagonal-wheels/collection";
 import { EVENT_ANALYSE_DB_USAGE, EVENT_REQUEST_PERFORM_GC_V3, eventHub } from "@/common/events";
 import type { LiveSyncCouchDBReplicator } from "@/lib/src/replication/couchdb/LiveSyncReplicator";
-import { delay, parseHeaderValues } from "@/lib/src/common/utils";
-import { generateCredentialObject } from "@/lib/src/replication/httplib";
-import { _requestToCouchDB } from "@/common/utils";
+import { delay } from "@/lib/src/common/utils";
+// import { _requestToCouchDB } from "@/common/utils";
 const DB_KEY_SEQ = "gc-seq";
 const DB_KEY_CHUNK_SET = "chunk-set";
 const DB_KEY_DOC_USAGE_MAP = "doc-usage-map";
@@ -391,7 +390,7 @@ Note: **Make sure to synchronise all devices before deletion.**
                             .map((revInfo) => db.get(doc._id, { rev: revInfo.rev }))
                     ).then((docs) => docs.filter((doc) => doc));
                     for (const oldDoc of oldDocs) {
-                        await processDoc(oldDoc as EntryDoc, false);
+                        await processDoc(oldDoc, false);
                     }
                 }
             } catch (ex) {
@@ -533,7 +532,7 @@ Success: ${successCount}, Errored: ${errored}`;
         const docMap = new Map<DocumentID, Set<DocumentInfo>>();
         const info = await db.info();
         // Total number of revisions to process (approximate)
-        const maxSeq = new Number(info.update_seq);
+        const maxSeq = Number.parseInt(`${info.update_seq ?? 0}`, 10);
         let processed = 0;
         let read = 0;
         let errored = 0;
@@ -560,7 +559,7 @@ Success: ${successCount}, Errored: ${errored}`;
                         });
                         docMap.set(id, set);
                     } else if (doc.type === EntryTypes.CHUNK) {
-                        const id = doc._id as DocumentID;
+                        const id = doc._id;
                         if (chunkMap.has(id)) {
                             return;
                         }
@@ -759,68 +758,68 @@ Success: ${successCount}, Errored: ${errored}`;
         }
     }
 
-    /**
-     * Compact the database by temporarily setting the revision limit to 1.
-     * @returns
-     */
-    async compactDatabaseWithRevLimit() {
-        // Temporarily set revs_limit to 1, perform compaction, and restore the original revs_limit.
-        // Very dangerous operation, so now suppressed.
-        return false;
-        const replicator = this.core.replicator as LiveSyncCouchDBReplicator;
-        const remote = await replicator.connectRemoteCouchDBWithSetting(this.settings, false, false, true);
-        if (!remote) {
-            this._notice("Failed to connect to remote for compaction.");
-            return;
-        }
-        if (typeof remote == "string") {
-            this._notice(`Failed to connect to remote for compaction. ${remote}`);
-            return;
-        }
-        const customHeaders = parseHeaderValues(this.settings.couchDB_CustomHeaders);
-        const credential = generateCredentialObject(this.settings);
-        const request = async (path: string, method: string = "GET", body: any = undefined) => {
-            const req = await _requestToCouchDB(
-                this.settings.couchDB_URI.replace(/\/+$/, "") +
-                    (this.settings.couchDB_DBNAME ? `/${this.settings.couchDB_DBNAME}` : ""),
-                credential,
-                window.origin,
-                path,
-                body,
-                method,
-                customHeaders
-            );
-            return req;
-        };
-        let revsLimit = "";
-        const req = await request(`_revs_limit`, "GET");
-        if (req.status == 200) {
-            revsLimit = req.text.trim();
-            this._info(`Remote database _revs_limit: ${revsLimit}`);
-        } else {
-            this._notice(`Failed to get remote database _revs_limit. Status: ${req.status}`);
-            return;
-        }
-        const req2 = await request(`_revs_limit`, "PUT", 1);
-        if (req2.status == 200) {
-            this._info(`Set remote database _revs_limit to 1 for compaction.`);
-        }
-        try {
-            await this.compactDatabase();
-        } finally {
-            // Restore revs_limit
-            if (revsLimit) {
-                const req3 = await request(`_revs_limit`, "PUT", parseInt(revsLimit));
-                if (req3.status == 200) {
-                    this._info(`Restored remote database _revs_limit to ${revsLimit}.`);
-                } else {
-                    this._notice(
-                        `Failed to restore remote database _revs_limit. Status: ${req3.status} / ${req3.text}`
-                    );
-                }
-            }
-        }
-    }
+    // /**
+    //  * Compact the database by temporarily setting the revision limit to 1.
+    //  * @returns
+    //  */
+    // async compactDatabaseWithRevLimit() {
+    //     // Temporarily set revs_limit to 1, perform compaction, and restore the original revs_limit.
+    //     // Very dangerous operation, so now suppressed.
+    //     return Promise.resolve(false);
+    //     const replicator = this.core.replicator as LiveSyncCouchDBReplicator;
+    //     const remote = await replicator.connectRemoteCouchDBWithSetting(this.settings, false, false, true);
+    //     if (!remote) {
+    //         this._notice("Failed to connect to remote for compaction.");
+    //         return;
+    //     }
+    //     if (typeof remote == "string") {
+    //         this._notice(`Failed to connect to remote for compaction. ${remote}`);
+    //         return;
+    //     }
+    //     const customHeaders = parseHeaderValues(this.settings.couchDB_CustomHeaders);
+    //     const credential = generateCredentialObject(this.settings);
+    //     const request = async (path: string, method: string = "GET", body: any = undefined) => {
+    //         const req = await _requestToCouchDB(
+    //             this.settings.couchDB_URI.replace(/\/+$/, "") +
+    //             (this.settings.couchDB_DBNAME ? `/${this.settings.couchDB_DBNAME}` : ""),
+    //             credential,
+    //             window.origin,
+    //             path,
+    //             body,
+    //             method,
+    //             customHeaders
+    //         );
+    //         return req;
+    //     };
+    //     let revsLimit = "";
+    //     const req = await request(`_revs_limit`, "GET");
+    //     if (req.status == 200) {
+    //         revsLimit = req.text.trim();
+    //         this._info(`Remote database _revs_limit: ${revsLimit}`);
+    //     } else {
+    //         this._notice(`Failed to get remote database _revs_limit. Status: ${req.status}`);
+    //         return;
+    //     }
+    //     const req2 = await request(`_revs_limit`, "PUT", 1);
+    //     if (req2.status == 200) {
+    //         this._info(`Set remote database _revs_limit to 1 for compaction.`);
+    //     }
+    //     try {
+    //         await this.compactDatabase();
+    //     } finally {
+    //         // Restore revs_limit
+    //         if (revsLimit) {
+    //             const req3 = await request(`_revs_limit`, "PUT", parseInt(revsLimit));
+    //             if (req3.status == 200) {
+    //                 this._info(`Restored remote database _revs_limit to ${revsLimit}.`);
+    //             } else {
+    //                 this._notice(
+    //                     `Failed to restore remote database _revs_limit. Status: ${req3.status} / ${req3.text}`
+    //                 );
+    //             }
+    //         }
+    //     }
+    // }
     async gcv3() {
         if (!this.isAvailable()) return;
         const replicator = this.core.replicator as LiveSyncCouchDBReplicator;
@@ -929,7 +928,7 @@ This may indicate that some devices have not completed synchronisation, which co
                     usedChunks.add(chunkId);
                 }
             } else if (doc.type === EntryTypes.CHUNK) {
-                allChunks.set(doc._id as DocumentID, doc._rev);
+                allChunks.set(doc._id, doc._rev);
             }
         }
         this._notice(

src/features/P2PSync/P2PReplicator/P2PServerStatusCard.svelte

@@ -24,6 +24,7 @@
     let serverInfo = $state<P2PServerInfo | undefined>(undefined);
     let replicatorStatus = $state<P2PReplicatorStatus | undefined>(undefined);
     let roomSuffix = $state<string>(extractP2PRoomSuffix(core?.services.setting.currentSettings()?.P2P_roomID ?? ""));
+    let useDiagRTC = $state<boolean>(core?.services.setting.currentSettings()?.P2P_useDiagRTC ?? false);
 
     async function requestServerStatus() {
         await Promise.resolve(liveSyncReplicator.requestStatus());
@@ -48,6 +49,18 @@
         }
     }
 
+    async function toggleDiagRTC() {
+        if (!core) {
+            return;
+        }
+        const next = !useDiagRTC;
+        await core.services.setting.updateSettings((settings) => {
+            settings.P2P_useDiagRTC = next;
+            return settings;
+        }, true);
+        useDiagRTC = next;
+    }
+
     onMount(() => {
         const unsubscribe = eventHub.onEvent(EVENT_SERVER_STATUS, (status) => {
             serverInfo = status;
@@ -58,6 +71,7 @@
         });
         const unsubscribeSettings = eventHub.onEvent(EVENT_SETTING_SAVED, (settings) => {
             roomSuffix = extractP2PRoomSuffix(settings?.P2P_roomID ?? "");
+            useDiagRTC = settings?.P2P_useDiagRTC ?? false;
         });
 
         fireAndForget(async () => {
@@ -131,6 +145,48 @@
         </button>
     </div>
     {/if}
+
+    {#if core}
+    <div class="status-item status-action diag-toggle-row">
+        <label class="broadcast-label" for="diag-toggle">
+            🕵️ Diag
+        </label>
+        <button
+            id="diag-toggle"
+            class="broadcast-button {useDiagRTC ? 'is-on' : 'is-off'}"
+            onclick={toggleDiagRTC}
+            title={useDiagRTC
+                ? 'Diagnostic RTCPeerConnection is enabled'
+                : 'Use Diagnostic RTCPeerConnection for statistics'}
+        >
+            {useDiagRTC ? 'On' : 'Off'}
+        </button>
+    </div>
+    {/if}
+
+    {#if serverInfo}
+        <div class="diag-section">
+            <h4>Stats</h4>
+            <div class="diag-grid">
+                <div class="diag-item">
+                    <span>Incoming:</span>
+                    <span>{serverInfo.diag.totalNewConnections}</span>
+                </div>
+                <div class="diag-item">
+                    <span>Connected:</span>
+                    <span>{serverInfo.diag.totalSuccessfulConnections}</span>
+                </div>
+                <div class="diag-item">
+                    <span>Failed:</span>
+                    <span>{serverInfo.diag.totalFailedConnections}</span>
+                </div>
+                <div class="diag-item">
+                    <span>Closed:</span>
+                    <span>{serverInfo.diag.totalClosedConnections}</span>
+                </div>
+            </div>
+        </div>
+    {/if}
 </div>
 
 <style>
@@ -190,6 +246,11 @@
         margin-top: 0.25rem;
     }
 
+    .diag-toggle-row {
+        align-items: center;
+        margin-top: 0.25rem;
+    }
+
     .broadcast-label {
         font-size: 0.9rem;
         color: var(--text-normal);
@@ -221,4 +282,29 @@
         background-color: var(--interactive-hover);
         color: var(--text-normal);
     }
+
+    .diag-section {
+        border-top: 1px solid var(--divider-color);
+        margin-top: 0.75rem;
+        padding-top: 0.75rem;
+    }
+
+    .diag-section h4 {
+        margin: 0 0 0.5rem 0;
+        font-size: 0.9rem;
+        font-weight: 600;
+    }
+
+    .diag-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(130px, 1fr));
+        gap: 0.35rem 0.75rem;
+    }
+
+    .diag-item {
+        display: flex;
+        justify-content: space-between;
+        font-size: 0.85rem;
+        gap: 0.5rem;
+    }
 </style>

src/main.ts

@@ -12,8 +12,6 @@ import { ModuleObsidianEvents } from "./modules/essentialObsidian/ModuleObsidian
 import { ModuleObsidianSettingDialogue } from "./modules/features/ModuleObsidianSettingTab.ts";
 import { ModuleObsidianDocumentHistory } from "./modules/features/ModuleObsidianDocumentHistory.ts";
 import { ModuleObsidianGlobalHistory } from "./modules/features/ModuleGlobalHistory.ts";
-import { ModuleIntegratedTest } from "./modules/extras/ModuleIntegratedTest.ts";
-import { ModuleReplicateTest } from "./modules/extras/ModuleReplicateTest.ts";
 import { LocalDatabaseMaintenance } from "./features/LocalDatabaseMainte/CmdLocalDatabaseMainte.ts";
 import type { InjectableServiceHub } from "@lib/services/implements/injectable/InjectableServiceHub.ts";
 import { ObsidianServiceHub } from "./modules/services/ObsidianServiceHub.ts";
@@ -156,8 +154,6 @@ export default class ObsidianLiveSyncPlugin extends Plugin {
                     new ModuleInteractiveConflictResolver(this, core),
                     new ModuleObsidianGlobalHistory(this, core),
                     new ModuleDev(this, core),
-                    new ModuleReplicateTest(this, core),
-                    new ModuleIntegratedTest(this, core),
                     new SetupManager(core), // this should be moved to core?
                     new ModuleMigration(core),
                 ];

src/modules/coreObsidian/UILib/dialogs.ts

@@ -1,9 +1,11 @@
 import { ButtonComponent } from "@/deps.ts";
 import { App, FuzzySuggestModal, MarkdownRenderer, Modal, Plugin, Setting } from "../../../deps.ts";
 import { EVENT_PLUGIN_UNLOADED, eventHub } from "../../../common/events.ts";
+import { compatGlobal, type CompatIntervalHandle } from "@lib/common/coreEnvFunctions.ts";
 
 class AutoClosableModal extends Modal {
     _closeByUnload() {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         eventHub.off(EVENT_PLUGIN_UNLOADED, this._closeByUnload);
         this.close();
     }
@@ -11,9 +13,11 @@ class AutoClosableModal extends Modal {
     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);
     }
 }
@@ -121,7 +125,7 @@ export class PopoverSelectString extends FuzzySuggestModal<string> {
         this.callback = undefined;
     }
     override onClose(): void {
-        setTimeout(() => {
+        compatGlobal.setTimeout(() => {
             if (this.callback) {
                 this.callback("");
                 this.callback = undefined;
@@ -139,7 +143,7 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
     isManuallyClosed = false;
     defaultAction: string | undefined;
     timeout: number | undefined;
-    timer: ReturnType<typeof setInterval> | undefined = undefined;
+    timer: CompatIntervalHandle | undefined = undefined;
     defaultButtonComponent: ButtonComponent | undefined;
     wideButton: boolean;
 
@@ -165,12 +169,12 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
         this.timeout = timeout;
         this.wideButton = wideButton;
         if (this.timeout) {
-            this.timer = setInterval(() => {
+            this.timer = compatGlobal.setInterval(() => {
                 if (this.timeout === undefined) return;
                 this.timeout--;
                 if (this.timeout < 0) {
                     if (this.timer) {
-                        clearInterval(this.timer);
+                        compatGlobal.clearInterval(this.timer);
                         this.defaultButtonComponent?.setButtonText(`${defaultAction}`);
                         this.timer = undefined;
                     }
@@ -213,7 +217,7 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
             if (this.timer) {
                 labelWrapper.empty();
                 labelWrapper.style.display = "none";
-                clearInterval(this.timer);
+                compatGlobal.clearInterval(this.timer);
                 this.timer = undefined;
                 this.defaultButtonComponent?.setButtonText(`${this.defaultAction}`);
             }
@@ -224,7 +228,7 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
                     this.isManuallyClosed = true;
                     this.result = button;
                     if (this.timer) {
-                        clearInterval(this.timer);
+                        compatGlobal.clearInterval(this.timer);
                         this.timer = undefined;
                     }
                     this.close();
@@ -247,7 +251,7 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
         const { contentEl } = this;
         contentEl.empty();
         if (this.timer) {
-            clearInterval(this.timer);
+            compatGlobal.clearInterval(this.timer);
             this.timer = undefined;
         }
         if (this.isManuallyClosed) {

src/modules/essentialObsidian/APILib/ObsHttpHandler.ts

@@ -27,7 +27,6 @@ export class ObsHttpHandler extends FetchHttpHandler {
         this.requestTimeoutInMs = options === undefined ? undefined : options.requestTimeout;
         this.reverseProxyNoSignUrl = reverseProxyNoSignUrl;
     }
-    // eslint-disable-next-line require-await
     override async handle(
         request: HttpRequest,
         { abortSignal }: HttpHandlerOptions = {}

src/modules/essentialObsidian/ModuleObsidianEvents.ts

@@ -13,6 +13,7 @@ import {
     hiddenFilesProcessingCount,
 } from "../../lib/src/mock_and_interop/stores.ts";
 import type { LiveSyncCore } from "../../main.ts";
+import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
 
 export class ModuleObsidianEvents extends AbstractObsidianModule {
     _everyOnloadStart(): Promise<boolean> {
@@ -79,11 +80,19 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
         this.watchWindowVisibility = this.watchWindowVisibility.bind(this);
         this.watchWorkspaceOpen = this.watchWorkspaceOpen.bind(this);
         this.watchOnline = this.watchOnline.bind(this);
+        // Already bound
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         this.plugin.registerEvent(this.app.workspace.on("file-open", this.watchWorkspaceOpen));
-        this.plugin.registerDomEvent(document, "visibilitychange", this.watchWindowVisibility);
+        // Already bound
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        this.plugin.registerDomEvent(activeDocument, "visibilitychange", this.watchWindowVisibility);
         this.plugin.registerDomEvent(window, "focus", () => this.setHasFocus(true));
         this.plugin.registerDomEvent(window, "blur", () => this.setHasFocus(false));
+        // Already bound
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         this.plugin.registerDomEvent(window, "online", this.watchOnline);
+        // Already bound
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         this.plugin.registerDomEvent(window, "offline", this.watchOnline);
     }
 
@@ -222,9 +231,9 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
                 );
             });
             this.plugin.registerInterval(
-                setInterval(() => {
+                compatGlobal.setInterval(() => {
                     __tick.value++;
-                }, 1000) as unknown as number
+                }, 1000)
             );
 
             let stableCheck = 3;

src/modules/extras/ModuleDev.ts

@@ -111,7 +111,7 @@ export class ModuleDev extends AbstractObsidianModule {
                 const filename = "test-create-conflict.md";
                 const content = `# Test create conflict\n\n`;
                 const w = await this.core.databaseFileAccess.store({
-                    name: filename as FilePathWithPrefix,
+                    name: filename,
                     path: filename as FilePathWithPrefix,
                     body: new Blob([content], { type: "text/markdown" }),
                     stat: {

src/modules/extras/ModuleIntegratedTest.ts

@@ -1,446 +0,0 @@
-import { delay } from "octagonal-wheels/promises";
-import { LOG_LEVEL_NOTICE, REMOTE_MINIO, type FilePathWithPrefix } from "src/lib/src/common/types";
-import { shareRunningResult } from "octagonal-wheels/concurrency/lock";
-import { AbstractObsidianModule } from "../AbstractObsidianModule";
-
-export class ModuleIntegratedTest extends AbstractObsidianModule {
-    async waitFor(proc: () => Promise<boolean>, timeout = 10000): Promise<boolean> {
-        await delay(100);
-        const start = Date.now();
-        while (!(await proc())) {
-            if (timeout > 0) {
-                if (Date.now() - start > timeout) {
-                    this._log(`Timeout`);
-                    return false;
-                }
-            }
-            await delay(500);
-        }
-        return true;
-    }
-    waitWithReplicating(proc: () => Promise<boolean>, timeout = 10000): Promise<boolean> {
-        return this.waitFor(async () => {
-            await this.tryReplicate();
-            return await proc();
-        }, timeout);
-    }
-    async storageContentIsEqual(file: string, content: string): Promise<boolean> {
-        try {
-            const fileContent = await this.readStorageContent(file as FilePathWithPrefix);
-            if (fileContent === content) {
-                return true;
-            } else {
-                // this._log(`Content is not same \n Expected:${content}\n Actual:${fileContent}`, LOG_LEVEL_VERBOSE);
-                return false;
-            }
-        } catch (e) {
-            this._log(`Error: ${e}`);
-            return false;
-        }
-    }
-    async assert(proc: () => Promise<boolean>): Promise<boolean> {
-        if (!(await proc())) {
-            this._log(`Assertion failed`);
-            return false;
-        }
-        return true;
-    }
-    async __orDie(key: string, proc: () => Promise<boolean>): Promise<true> | never {
-        if (!(await this._test(key, proc))) {
-            throw new Error(`${key}`);
-        }
-        return true;
-    }
-    tryReplicate() {
-        if (!this.settings.liveSync) {
-            return shareRunningResult("replicate-test", async () => {
-                await this.services.replication.replicate();
-            });
-        }
-    }
-    async readStorageContent(file: FilePathWithPrefix): Promise<string | undefined> {
-        if (!(await this.core.storageAccess.isExistsIncludeHidden(file))) {
-            return undefined;
-        }
-        return await this.core.storageAccess.readHiddenFileText(file);
-    }
-    async __proceed(no: number, title: string): Promise<boolean> {
-        const stepFile = "_STEP.md" as FilePathWithPrefix;
-        const stepAckFile = "_STEP_ACK.md" as FilePathWithPrefix;
-        const stepContent = `Step ${no}`;
-        await this.services.conflict.resolveByNewest(stepFile);
-        await this.core.storageAccess.writeFileAuto(stepFile, stepContent);
-        await this.__orDie(`Wait for acknowledge ${no}`, async () => {
-            if (
-                !(await this.waitWithReplicating(async () => {
-                    return await this.storageContentIsEqual(stepAckFile, stepContent);
-                }, 20000))
-            )
-                return false;
-            return true;
-        });
-        return true;
-    }
-    async __join(no: number, title: string): Promise<boolean> {
-        const stepFile = "_STEP.md" as FilePathWithPrefix;
-        const stepAckFile = "_STEP_ACK.md" as FilePathWithPrefix;
-        // const otherStepFile = `_STEP_${isLeader ? "R" : "L"}.md` as FilePathWithPrefix;
-        const stepContent = `Step ${no}`;
-
-        await this.__orDie(`Wait for step ${no} (${title})`, async () => {
-            if (
-                !(await this.waitWithReplicating(async () => {
-                    return await this.storageContentIsEqual(stepFile, stepContent);
-                }, 20000))
-            )
-                return false;
-            return true;
-        });
-        await this.services.conflict.resolveByNewest(stepAckFile);
-        await this.core.storageAccess.writeFileAuto(stepAckFile, stepContent);
-        await this.tryReplicate();
-        return true;
-    }
-
-    async performStep({
-        step,
-        title,
-        isGameChanger,
-        proc,
-        check,
-    }: {
-        step: number;
-        title: string;
-        isGameChanger: boolean;
-        proc: () => Promise<any>;
-        check: () => Promise<boolean>;
-    }): Promise<boolean> {
-        if (isGameChanger) {
-            await this.__proceed(step, title);
-            try {
-                await proc();
-            } catch (e) {
-                this._log(`Error: ${e}`);
-                return false;
-            }
-            return await this.__orDie(`Step ${step} - ${title}`, async () => await this.waitWithReplicating(check));
-        } else {
-            return await this.__join(step, title);
-        }
-    }
-    // // see scenario.md
-    // async testLeader(testMain: (testFileName: FilePathWithPrefix) => Promise<boolean>): Promise<boolean> {
-
-    // }
-    // async testReceiver(testMain: (testFileName: FilePathWithPrefix) => Promise<boolean>): Promise<boolean> {
-
-    // }
-    async nonLiveTestRunner(
-        isLeader: boolean,
-        testMain: (testFileName: FilePathWithPrefix, isLeader: boolean) => Promise<boolean>
-    ): Promise<boolean> {
-        const storage = this.core.storageAccess;
-        // const database = this.core.databaseFileAccess;
-        // const _orDie = this._orDie.bind(this);
-        const testCommandFile = "IT.md" as FilePathWithPrefix;
-        const textCommandResponseFile = "ITx.md" as FilePathWithPrefix;
-        let testFileName: FilePathWithPrefix;
-        this.addTestResult(
-            "-------Starting ... ",
-            true,
-            `Test as ${isLeader ? "Leader" : "Receiver"} command file ${testCommandFile}`
-        );
-        if (isLeader) {
-            await this.__proceed(0, "start");
-        }
-        await this.tryReplicate();
-
-        await this.performStep({
-            step: 0,
-            title: "Make sure that command File Not Exists",
-            isGameChanger: isLeader,
-            proc: async () => await storage.removeHidden(testCommandFile),
-            check: async () => !(await storage.isExistsIncludeHidden(testCommandFile)),
-        });
-        await this.performStep({
-            step: 1,
-            title: "Make sure that command File Not Exists On Receiver",
-            isGameChanger: !isLeader,
-            proc: async () => await storage.removeHidden(textCommandResponseFile),
-            check: async () => !(await storage.isExistsIncludeHidden(textCommandResponseFile)),
-        });
-
-        await this.performStep({
-            step: 2,
-            title: "Decide the test file name",
-            isGameChanger: isLeader,
-            proc: async () => {
-                testFileName = (Date.now() + "-" + Math.ceil(Math.random() * 1000) + ".md") as FilePathWithPrefix;
-                const testCommandFile = "IT.md" as FilePathWithPrefix;
-                await storage.writeFileAuto(testCommandFile, testFileName);
-            },
-            check: () => Promise.resolve(true),
-        });
-        await this.performStep({
-            step: 3,
-            title: "Wait for the command file to be arrived",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => await storage.isExistsIncludeHidden(testCommandFile),
-        });
-
-        await this.performStep({
-            step: 4,
-            title: "Send the response file",
-            isGameChanger: !isLeader,
-            proc: async () => {
-                await storage.writeHiddenFileAuto(textCommandResponseFile, "!");
-            },
-            check: () => Promise.resolve(true),
-        });
-        await this.performStep({
-            step: 5,
-            title: "Wait for the response file to be arrived",
-            isGameChanger: isLeader,
-            proc: async () => {},
-            check: async () => await storage.isExistsIncludeHidden(textCommandResponseFile),
-        });
-
-        await this.performStep({
-            step: 6,
-            title: "Proceed to begin the test",
-            isGameChanger: isLeader,
-            proc: async () => {},
-            check: () => Promise.resolve(true),
-        });
-        await this.performStep({
-            step: 6,
-            title: "Begin the test",
-            isGameChanger: !false,
-            proc: async () => {},
-            check: () => {
-                return Promise.resolve(true);
-            },
-        });
-        // await this.step(0, isLeader, true);
-        try {
-            this.addTestResult("** Main------", true, ``);
-            if (isLeader) {
-                return await testMain(testFileName!, true);
-            } else {
-                const testFileName = await this.readStorageContent(testCommandFile);
-                this.addTestResult("testFileName", true, `Request client to use :${testFileName!}`);
-                return await testMain(testFileName! as FilePathWithPrefix, false);
-            }
-        } finally {
-            this.addTestResult("Teardown", true, `Deleting ${testFileName!}`);
-            await storage.removeHidden(testFileName!);
-        }
-
-        return true;
-        // Make sure the
-    }
-
-    async testBasic(filename: FilePathWithPrefix, isLeader: boolean): Promise<boolean> {
-        const storage = this.core.storageAccess;
-        const database = this.core.databaseFileAccess;
-
-        await this.addTestResult(
-            `---**Starting Basic Test**---`,
-            true,
-            `Test as ${isLeader ? "Leader" : "Receiver"} command file ${filename}`
-        );
-        // if (isLeader) {
-        //     await this._proceed(0);
-        // }
-        // await this.tryReplicate();
-
-        await this.performStep({
-            step: 0,
-            title: "Make sure that file is not exist",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => !(await storage.isExists(filename)),
-        });
-
-        await this.performStep({
-            step: 1,
-            title: "Write a file",
-            isGameChanger: isLeader,
-            proc: async () => await storage.writeFileAuto(filename, "Hello World"),
-            check: async () => await storage.isExists(filename),
-        });
-        await this.performStep({
-            step: 2,
-            title: "Make sure the file is arrived",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => await storage.isExists(filename),
-        });
-        await this.performStep({
-            step: 3,
-            title: "Update to Hello World 2",
-            isGameChanger: isLeader,
-            proc: async () => await storage.writeFileAuto(filename, "Hello World 2"),
-            check: async () => await this.storageContentIsEqual(filename, "Hello World 2"),
-        });
-        await this.performStep({
-            step: 4,
-            title: "Make sure the modified file is arrived",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => await this.storageContentIsEqual(filename, "Hello World 2"),
-        });
-        await this.performStep({
-            step: 5,
-            title: "Update to Hello World 3",
-            isGameChanger: !isLeader,
-            proc: async () => await storage.writeFileAuto(filename, "Hello World 3"),
-            check: async () => await this.storageContentIsEqual(filename, "Hello World 3"),
-        });
-        await this.performStep({
-            step: 6,
-            title: "Make sure the modified file is arrived",
-            isGameChanger: isLeader,
-            proc: async () => {},
-            check: async () => await this.storageContentIsEqual(filename, "Hello World 3"),
-        });
-
-        const multiLineContent = `Line1:A
-Line2:B
-Line3:C
-Line4:D`;
-
-        await this.performStep({
-            step: 7,
-            title: "Update to Multiline",
-            isGameChanger: isLeader,
-            proc: async () => await storage.writeFileAuto(filename, multiLineContent),
-            check: async () => await this.storageContentIsEqual(filename, multiLineContent),
-        });
-
-        await this.performStep({
-            step: 8,
-            title: "Make sure the modified file is arrived",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => await this.storageContentIsEqual(filename, multiLineContent),
-        });
-
-        // While LiveSync, possibly cannot cause the conflict.
-        if (!this.settings.liveSync) {
-            // Step 9 Make Conflict But Resolvable
-            const multiLineContentL = `Line1:A
-Line2:B
-Line3:C!
-Line4:D`;
-            const multiLineContentC = `Line1:A
-Line2:bbbbb
-Line3:C
-Line4:D`;
-
-            await this.performStep({
-                step: 9,
-                title: "Progress to be conflicted",
-                isGameChanger: isLeader,
-                proc: async () => {},
-                check: () => Promise.resolve(true),
-            });
-
-            await storage.writeFileAuto(filename, isLeader ? multiLineContentL : multiLineContentC);
-
-            await this.performStep({
-                step: 10,
-                title: "Update As Conflicted",
-                isGameChanger: !isLeader,
-                proc: async () => {},
-                check: () => Promise.resolve(true),
-            });
-
-            await this.performStep({
-                step: 10,
-                title: "Make sure Automatically resolved",
-                isGameChanger: isLeader,
-                proc: async () => {},
-                check: async () => (await database.getConflictedRevs(filename)).length === 0,
-            });
-            await this.performStep({
-                step: 11,
-                title: "Make sure Automatically resolved",
-                isGameChanger: !isLeader,
-                proc: async () => {},
-                check: async () => (await database.getConflictedRevs(filename)).length === 0,
-            });
-
-            const sensiblyMergedContent = `Line1:A
-Line2:bbbbb
-Line3:C!
-Line4:D`;
-
-            await this.performStep({
-                step: 12,
-                title: "Make sure Sensibly Merged on Leader",
-                isGameChanger: isLeader,
-                proc: async () => {},
-                check: async () => await this.storageContentIsEqual(filename, sensiblyMergedContent),
-            });
-            await this.performStep({
-                step: 13,
-                title: "Make sure Sensibly Merged on Receiver",
-                isGameChanger: !isLeader,
-                proc: async () => {},
-                check: async () => await this.storageContentIsEqual(filename, sensiblyMergedContent),
-            });
-        }
-        await this.performStep({
-            step: 14,
-            title: "Delete File",
-            isGameChanger: isLeader,
-            proc: async () => {
-                await storage.removeHidden(filename);
-            },
-            check: async () => !(await storage.isExists(filename)),
-        });
-
-        await this.performStep({
-            step: 15,
-            title: "Make sure File is deleted",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => !(await storage.isExists(filename)),
-        });
-        this._log(`The Basic Test has been completed`, LOG_LEVEL_NOTICE);
-        return true;
-    }
-
-    async testBasicEvent(isLeader: boolean) {
-        this.settings.liveSync = false;
-        await this.saveSettings();
-        await this._test("basic", async () => await this.nonLiveTestRunner(isLeader, (t, l) => this.testBasic(t, l)));
-    }
-    async testBasicLive(isLeader: boolean) {
-        this.settings.liveSync = true;
-        await this.saveSettings();
-        await this._test("basic", async () => await this.nonLiveTestRunner(isLeader, (t, l) => this.testBasic(t, l)));
-    }
-
-    async _everyModuleTestMultiDevice(): Promise<boolean> {
-        if (!this.settings.enableDebugTools) return Promise.resolve(true);
-        const isLeader = this.core.services.vault.vaultName().indexOf("recv") === -1;
-        this.addTestResult("-------", true, `Test as ${isLeader ? "Leader" : "Receiver"}`);
-        try {
-            this._log(`Starting Test`);
-            await this.testBasicEvent(isLeader);
-            if (this.settings.remoteType == REMOTE_MINIO) await this.testBasicLive(isLeader);
-        } catch (e) {
-            this._log(e);
-            this._log(`Error: ${e}`);
-            return Promise.resolve(false);
-        }
-
-        return Promise.resolve(true);
-    }
-    override onBindFunction(core: typeof this.core, services: typeof core.services): void {
-        services.test.testMultiDevice.addHandler(this._everyModuleTestMultiDevice.bind(this));
-    }
-}

src/modules/extras/ModuleReplicateTest.ts

@@ -1,590 +0,0 @@
-// I intend to discontinue maintenance of this class. It seems preferable to test it externally.
-import { delay } from "octagonal-wheels/promises";
-import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
-import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
-import { eventHub } from "../../common/events";
-import { getWebCrypto } from "../../lib/src/mods.ts";
-import { uint8ArrayToHexString } from "octagonal-wheels/binary/hex";
-import { parseYaml, requestUrl, stringifyYaml } from "@/deps.ts";
-import type { FilePath } from "../../lib/src/common/types.ts";
-import { scheduleTask } from "octagonal-wheels/concurrency/task";
-import { getFileRegExp } from "../../lib/src/common/utils.ts";
-import type { LiveSyncCore } from "../../main.ts";
-
-declare global {
-    interface LSEvents {
-        "debug-sync-status": string[];
-    }
-}
-
-export class ModuleReplicateTest extends AbstractObsidianModule {
-    testRootPath = "_test/";
-    testInfoPath = "_testinfo/";
-
-    get isLeader() {
-        return (
-            this.services.vault.getVaultName().indexOf("dev") >= 0 &&
-            this.services.vault.vaultName().indexOf("recv") < 0
-        );
-    }
-
-    get nameByKind() {
-        if (!this.isLeader) {
-            return "RECV";
-        } else if (this.isLeader) {
-            return "LEADER";
-        }
-    }
-    get pairName() {
-        if (this.isLeader) {
-            return "RECV";
-        } else if (!this.isLeader) {
-            return "LEADER";
-        }
-    }
-
-    watchIsSynchronised = false;
-
-    statusBarSyncStatus?: HTMLElement;
-    async readFileContent(file: string) {
-        try {
-            return await this.core.storageAccess.readHiddenFileText(file);
-        } catch {
-            return "";
-        }
-    }
-
-    async dumpList() {
-        if (this.settings.syncInternalFiles) {
-            this._log("Write file list (Include Hidden)");
-            await this.__dumpFileListIncludeHidden("files.md");
-        } else {
-            this._log("Write file list");
-            await this.__dumpFileList("files.md");
-        }
-    }
-    async _everyBeforeReplicate(showMessage: boolean): Promise<boolean> {
-        if (!this.settings.enableDebugTools) return Promise.resolve(true);
-        await this.dumpList();
-        return true;
-    }
-    private _everyOnloadAfterLoadSettings(): Promise<boolean> {
-        if (!this.settings.enableDebugTools) return Promise.resolve(true);
-        this.addCommand({
-            id: "dump-file-structure-normal",
-            name: `Dump Structure (Normal)`,
-            callback: () => {
-                void this.__dumpFileList("files.md").finally(() => {
-                    void this.refreshSyncStatus();
-                });
-            },
-        });
-        this.addCommand({
-            id: "dump-file-structure-ih",
-            name: "Dump Structure (Include Hidden)",
-            callback: () => {
-                const d = "files.md";
-                void this.__dumpFileListIncludeHidden(d);
-            },
-        });
-        this.addCommand({
-            id: "dump-file-structure-auto",
-            name: "Dump Structure",
-            callback: () => {
-                void this.dumpList();
-            },
-        });
-        this.addCommand({
-            id: "dump-file-test",
-            name: `Perform Test (Dev) ${this.isLeader ? "(Leader)" : "(Recv)"}`,
-            callback: () => {
-                void this.performTestManually();
-            },
-        });
-        this.addCommand({
-            id: "watch-sync-result",
-            name: `Watch sync result is matched between devices`,
-            callback: () => {
-                this.watchIsSynchronised = !this.watchIsSynchronised;
-                void this.refreshSyncStatus();
-            },
-        });
-        this.app.vault.on("modify", async (file) => {
-            if (file.path.startsWith(this.testInfoPath)) {
-                await this.refreshSyncStatus();
-            } else {
-                scheduleTask("dumpStatus", 125, async () => {
-                    await this.dumpList();
-                    return true;
-                });
-            }
-        });
-        this.statusBarSyncStatus = this.plugin.addStatusBarItem();
-        return Promise.resolve(true);
-    }
-    async getSyncStatusAsText() {
-        const fileMine = this.testInfoPath + this.nameByKind + "/" + "files.md";
-        const filePair = this.testInfoPath + this.pairName + "/" + "files.md";
-        const mine = parseYaml(await this.readFileContent(fileMine));
-        const pair = parseYaml(await this.readFileContent(filePair));
-        const result = [] as string[];
-        if (mine.length != pair.length) {
-            result.push(`File count is different: ${mine.length} vs ${pair.length}`);
-        }
-        const filesAll = new Set([...mine.map((e: any) => e.path), ...pair.map((e: any) => e.path)]);
-        for (const file of filesAll) {
-            const mineFile = mine.find((e: any) => e.path == file);
-            const pairFile = pair.find((e: any) => e.path == file);
-            if (!mineFile || !pairFile) {
-                result.push(`File not found: ${file}`);
-            } else {
-                if (mineFile.size != pairFile.size) {
-                    result.push(`Size is different: ${file} ${mineFile.size} vs ${pairFile.size}`);
-                }
-                if (mineFile.hash != pairFile.hash) {
-                    result.push(`Hash is different: ${file} ${mineFile.hash} vs ${pairFile.hash}`);
-                }
-            }
-        }
-        eventHub.emitEvent("debug-sync-status", result);
-        return result.join("\n");
-    }
-
-    async refreshSyncStatus() {
-        if (this.watchIsSynchronised) {
-            // Normal Files
-            const syncStatus = await this.getSyncStatusAsText();
-            if (syncStatus) {
-                this.statusBarSyncStatus!.setText(`Sync Status: Having Error`);
-                this._log(`Sync Status: Having Error\n${syncStatus}`, LOG_LEVEL_INFO);
-            } else {
-                this.statusBarSyncStatus!.setText(`Sync Status: Synchronised`);
-            }
-        } else {
-            this.statusBarSyncStatus!.setText("");
-        }
-    }
-
-    async __dumpFileList(outFile?: string) {
-        if (!this.core || !this.core.storageAccess) {
-            this._log("No storage access", LOG_LEVEL_INFO);
-            return;
-        }
-        const files = await this.core.storageAccess.getFiles();
-        const out = [] as any[];
-        const webcrypto = await getWebCrypto();
-        for (const file of files) {
-            if (!(await this.services.vault.isTargetFile(file.path))) {
-                continue;
-            }
-            if (file.path.startsWith(this.testInfoPath)) continue;
-            const stat = await this.core.storageAccess.stat(file.path);
-            if (stat) {
-                const hashSrc = await this.core.storageAccess.readHiddenFileBinary(file.path);
-                const hash = await webcrypto.subtle.digest("SHA-1", hashSrc);
-                const hashStr = uint8ArrayToHexString(new Uint8Array(hash));
-                const item = {
-                    path: file.path,
-                    name: file.name,
-                    size: stat.size,
-                    mtime: stat.mtime,
-                    hash: hashStr,
-                };
-                // const fileLine = `-${file.path}:${stat.size}:${stat.mtime}:${hashStr}`;
-                out.push(item);
-            }
-        }
-        out.sort((a, b) => a.path.localeCompare(b.path));
-        if (outFile) {
-            outFile = this.testInfoPath + this.nameByKind + "/" + outFile;
-            await this.core.storageAccess.ensureDir(outFile);
-            await this.core.storageAccess.writeHiddenFileAuto(outFile, stringifyYaml(out));
-        } else {
-            // console.dir(out);
-        }
-        this._log(`Dumped ${out.length} files`, LOG_LEVEL_INFO);
-    }
-
-    async __dumpFileListIncludeHidden(outFile?: string) {
-        const ignorePatterns = getFileRegExp(this.core.settings, "syncInternalFilesIgnorePatterns");
-        const targetPatterns = getFileRegExp(this.core.settings, "syncInternalFilesTargetPatterns");
-        const out = [] as any[];
-        const files = await this.core.storageAccess.getFilesIncludeHidden("", targetPatterns, ignorePatterns);
-        // console.dir(files);
-        const webcrypto = await getWebCrypto();
-        for (const file of files) {
-            // if (!await this.core.$$isTargetFile(file)) {
-            //     continue;
-            // }
-            if (file.startsWith(this.testInfoPath)) continue;
-            const stat = await this.core.storageAccess.statHidden(file);
-            if (stat) {
-                const hashSrc = await this.core.storageAccess.readHiddenFileBinary(file);
-                const hash = await webcrypto.subtle.digest("SHA-1", hashSrc);
-                const hashStr = uint8ArrayToHexString(new Uint8Array(hash));
-                const item = {
-                    path: file,
-                    name: file.split("/").pop(),
-                    size: stat.size,
-                    mtime: stat.mtime,
-                    hash: hashStr,
-                };
-                // const fileLine = `-${file.path}:${stat.size}:${stat.mtime}:${hashStr}`;
-                out.push(item);
-            }
-        }
-        out.sort((a, b) => a.path.localeCompare(b.path));
-        if (outFile) {
-            outFile = this.testInfoPath + this.nameByKind + "/" + outFile;
-            await this.core.storageAccess.ensureDir(outFile);
-            await this.core.storageAccess.writeHiddenFileAuto(outFile, stringifyYaml(out));
-        } else {
-            // console.dir(out);
-        }
-        this._log(`Dumped ${out.length} files`, LOG_LEVEL_NOTICE);
-    }
-
-    async collectTestFiles() {
-        const remoteTopDir = "https://raw.githubusercontent.com/vrtmrz/obsidian-livesync/refs/heads/main/";
-        const files = [
-            "README.md",
-            "docs/adding_translations.md",
-            "docs/design_docs_of_journalsync.md",
-            "docs/design_docs_of_keep_newborn_chunks.md",
-            "docs/design_docs_of_prefixed_hidden_file_sync.md",
-            "docs/design_docs_of_sharing_tweak_value.md",
-            "docs/quick_setup_cn.md",
-            "docs/quick_setup_ja.md",
-            "docs/quick_setup.md",
-            "docs/settings_ja.md",
-            "docs/settings.md",
-            "docs/setup_cloudant_ja.md",
-            "docs/setup_cloudant.md",
-            "docs/setup_flyio.md",
-            "docs/setup_own_server_cn.md",
-            "docs/setup_own_server_ja.md",
-            "docs/setup_own_server.md",
-            "docs/tech_info_ja.md",
-            "docs/tech_info.md",
-            "docs/terms.md",
-            "docs/troubleshooting.md",
-            "images/1.png",
-            "images/2.png",
-            "images/corrupted_data.png",
-            "images/hatch.png",
-            "images/lock_pattern1.png",
-            "images/lock_pattern2.png",
-            "images/quick_setup_1.png",
-            "images/quick_setup_2.png",
-            "images/quick_setup_3.png",
-            "images/quick_setup_3b.png",
-            "images/quick_setup_4.png",
-            "images/quick_setup_5.png",
-            "images/quick_setup_6.png",
-            "images/quick_setup_7.png",
-            "images/quick_setup_8.png",
-            "images/quick_setup_9_1.png",
-            "images/quick_setup_9_2.png",
-            "images/quick_setup_10.png",
-            "images/remote_db_setting.png",
-            "images/write_logs_into_the_file.png",
-        ];
-        for (const file of files) {
-            const remote = remoteTopDir + file;
-            const local = this.testRootPath + file;
-            try {
-                const f = (await requestUrl(remote)).arrayBuffer;
-                await this.core.storageAccess.ensureDir(local);
-                await this.core.storageAccess.writeHiddenFileAuto(local, f);
-            } catch (ex) {
-                this._log(`Could not fetch ${remote}`, LOG_LEVEL_VERBOSE);
-                this._log(ex, LOG_LEVEL_VERBOSE);
-            }
-        }
-
-        await this.dumpList();
-    }
-
-    async waitFor(proc: () => Promise<boolean>, timeout = 10000): Promise<boolean> {
-        await delay(100);
-        const start = Date.now();
-        while (!(await proc())) {
-            if (timeout > 0) {
-                if (Date.now() - start > timeout) {
-                    this._log(`Timeout`);
-                    return false;
-                }
-            }
-            await delay(500);
-        }
-        return true;
-    }
-
-    async testConflictedManually1() {
-        await this.services.replication.replicate();
-
-        const commonFile = `Resolve! 
-*****, the amazing chocolatier!!`;
-
-        if (this.isLeader) {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "wonka.md", commonFile);
-        }
-
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to begin the test conflict Manually 1?", {
-                timeout: 30,
-                defaultOption: "Yes",
-            })) == "no"
-        ) {
-            return;
-        }
-
-        const fileA = `Resolve to KEEP THIS
-Willy Wonka, Willy Wonka, the amazing chocolatier!!`;
-
-        const fileB = `Resolve to DISCARD THIS
-Charlie Bucket, Charlie Bucket, the amazing chocolatier!!`;
-
-        if (this.isLeader) {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "wonka.md", fileA);
-        } else {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "wonka.md", fileB);
-        }
-
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to check the result of Manually 1?", {
-                timeout: 30,
-                defaultOption: "Yes",
-            })) == "no"
-        ) {
-            return;
-        }
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-
-        if (
-            !(await this.waitFor(async () => {
-                await this.services.replication.replicate();
-                return (
-                    (await this.__assertStorageContent(
-                        (this.testRootPath + "wonka.md") as FilePath,
-                        fileA,
-                        false,
-                        true
-                    )) == true
-                );
-            }, 30000))
-        ) {
-            return await this.__assertStorageContent((this.testRootPath + "wonka.md") as FilePath, fileA, false, true);
-        }
-        return true;
-        // We have to check the result
-    }
-
-    async testConflictedManually2() {
-        await this.services.replication.replicate();
-
-        const commonFile = `Resolve To concatenate
-ABCDEFG`;
-
-        if (this.isLeader) {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "concat.md", commonFile);
-        }
-
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to begin the test conflict Manually 2?", {
-                timeout: 30,
-                defaultOption: "Yes",
-            })) == "no"
-        ) {
-            return;
-        }
-
-        const fileA = `Resolve to Concatenate
-ABCDEFGHIJKLMNOPQRSTYZ`;
-
-        const fileB = `Resolve to Concatenate
-AJKLMNOPQRSTUVWXYZ`;
-
-        const concatenated = `Resolve to Concatenate
-ABCDEFGHIJKLMNOPQRSTUVWXYZ`;
-        if (this.isLeader) {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "concat.md", fileA);
-        } else {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "concat.md", fileB);
-        }
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to test conflict Manually 2?", {
-                timeout: 30,
-                defaultOption: "Yes",
-            })) == "no"
-        ) {
-            return;
-        }
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-
-        if (
-            !(await this.waitFor(async () => {
-                await this.services.replication.replicate();
-                return (
-                    (await this.__assertStorageContent(
-                        (this.testRootPath + "concat.md") as FilePath,
-                        concatenated,
-                        false,
-                        true
-                    )) == true
-                );
-            }, 30000))
-        ) {
-            return await this.__assertStorageContent(
-                (this.testRootPath + "concat.md") as FilePath,
-                concatenated,
-                false,
-                true
-            );
-        }
-        return true;
-    }
-
-    async testConflictAutomatic() {
-        if (this.isLeader) {
-            const baseDoc = `Tasks!
-- [ ] Task 1
-- [ ] Task 2
-- [ ] Task 3
-- [ ] Task 4
-`;
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "task.md", baseDoc);
-        }
-        await delay(100);
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to test conflict?", {
-                timeout: 30,
-                defaultOption: "Yes",
-            })) == "no"
-        ) {
-            return;
-        }
-        const mod1Doc = `Tasks!
-- [ ] Task 1
-- [v] Task 2
-- [ ] Task 3
-- [ ] Task 4
-`;
-
-        const mod2Doc = `Tasks!
-- [ ] Task 1
-- [ ] Task 2
-- [v] Task 3
-- [ ] Task 4
-`;
-        if (this.isLeader) {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "task.md", mod1Doc);
-        } else {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "task.md", mod2Doc);
-        }
-
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-        await delay(1000);
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to check result?", { timeout: 30, defaultOption: "Yes" })) ==
-            "no"
-        ) {
-            return;
-        }
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-        const mergedDoc = `Tasks!
-- [ ] Task 1
-- [v] Task 2
-- [v] Task 3
-- [ ] Task 4
-`;
-        return this.__assertStorageContent((this.testRootPath + "task.md") as FilePath, mergedDoc, false, true);
-    }
-
-    // No longer tested
-    async checkConflictResolution() {
-        this._log("Before testing conflicted files, resolve all once", LOG_LEVEL_NOTICE);
-        await this.services.conflict.resolveAllConflictedFilesByNewerOnes();
-        await this.services.conflict.resolveAllConflictedFilesByNewerOnes();
-        await this.services.replication.replicate();
-        await delay(1000);
-        if (!(await this.testConflictAutomatic())) {
-            this._log("Conflict resolution (Auto) failed", LOG_LEVEL_NOTICE);
-            return false;
-        }
-        if (!(await this.testConflictedManually1())) {
-            this._log("Conflict resolution (Manual1) failed", LOG_LEVEL_NOTICE);
-            return false;
-        }
-        if (!(await this.testConflictedManually2())) {
-            this._log("Conflict resolution (Manual2) failed", LOG_LEVEL_NOTICE);
-            return false;
-        }
-        return true;
-    }
-
-    async __assertStorageContent(
-        fileName: FilePath,
-        content: string,
-        inverted = false,
-        showResult = false
-    ): Promise<boolean | string> {
-        try {
-            const fileContent = await this.core.storageAccess.readHiddenFileText(fileName);
-            let result = fileContent === content;
-            if (inverted) {
-                result = !result;
-            }
-            if (result) {
-                return true;
-            } else {
-                if (showResult) {
-                    this._log(`Content is not same \n Expected:${content}\n Actual:${fileContent}`, LOG_LEVEL_VERBOSE);
-                }
-                return `Content is not same \n Expected:${content}\n Actual:${fileContent}`;
-            }
-        } catch (e) {
-            this._log(`Cannot assert storage content: ${e}`);
-            return false;
-        }
-    }
-    async performTestManually() {
-        if (!this.settings.enableDebugTools) return Promise.resolve(true);
-        await this.checkConflictResolution();
-        // await this.collectTestFiles();
-    }
-
-    // testResults = writable<[boolean, string, string][]>([]);
-    // testResults: string[] = [];
-
-    // $$addTestResult(name: string, key: string, result: boolean, summary?: string, message?: string): void {
-    //     const logLine = `${name}: ${key} ${summary ?? ""}`;
-    //     this.testResults.update((results) => {
-    //         results.push([result, logLine, message ?? ""]);
-    //         return results;
-    //     });
-    // }
-    private async _everyModuleTestMultiDevice(): Promise<boolean> {
-        if (!this.settings.enableDebugTools) return Promise.resolve(true);
-        // this.core.$$addTestResult("DevModule", "Test", true);
-        // return Promise.resolve(true);
-        await this._test("Conflict resolution", async () => await this.checkConflictResolution());
-        return this.testDone();
-    }
-    override onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
-        services.appLifecycle.onSettingLoaded.addHandler(this._everyOnloadAfterLoadSettings.bind(this));
-        services.replication.onBeforeReplicate.addHandler(this._everyBeforeReplicate.bind(this));
-        services.test.testMultiDevice.addHandler(this._everyModuleTestMultiDevice.bind(this));
-    }
-}

src/modules/extras/devUtil/TestPane.svelte

@@ -1,17 +1,15 @@
 <script lang="ts">
-    import { onDestroy, onMount } from "svelte";
+    import { onMount } from "svelte";
     import type ObsidianLiveSyncPlugin from "../../../main.ts";
     import { perf_trench } from "./tests.ts";
     import { MarkdownRenderer, Notice } from "../../../deps.ts";
     import type { ModuleDev } from "../ModuleDev.ts";
     import { fireAndForget } from "octagonal-wheels/promises";
     import { EVENT_LAYOUT_READY, eventHub } from "../../../common/events.ts";
-    import { writable } from "svelte/store";
     export let plugin: ObsidianLiveSyncPlugin;
     export let moduleDev: ModuleDev;
     $: core = plugin.core;
     let performanceTestResult = "";
-    let functionCheckResult = "";
     let testRunning = false;
     let prefTestResultEl: HTMLDivElement;
     let isReady = false;

src/modules/extras/devUtil/TestPaneView.ts

@@ -3,6 +3,11 @@ import TestPaneComponent from "./TestPane.svelte";
 import type ObsidianLiveSyncPlugin from "../../../main.ts";
 import type { ModuleDev } from "../ModuleDev.ts";
 export const VIEW_TYPE_TEST = "ols-pane-test";
+declare global {
+    interface LSEvents {
+        "debug-sync-status": string[];
+    }
+}
 //Log view
 export class TestPaneView extends ItemView {
     component?: TestPaneComponent;

src/modules/features/DocumentHistory/DocumentHistoryModal.ts

@@ -16,6 +16,7 @@ import { fireAndForget, getDocData, readContent } from "../../../lib/src/common/
 import { isPlainText, stripPrefix } from "../../../lib/src/string_and_binary/path.ts";
 import { scheduleOnceIfDuplicated } from "octagonal-wheels/concurrency/lock";
 import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore.ts";
+import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
 
 function isImage(path: string) {
     const ext = path.split(".").splice(-1)[0].toLowerCase();
@@ -56,6 +57,7 @@ export class DocumentHistoryModal extends Modal {
     info!: HTMLDivElement;
     fileInfo!: HTMLDivElement;
     showDiff = false;
+    diffOnly = false;
     id?: DocumentID;
 
     file: FilePathWithPrefix;
@@ -70,6 +72,15 @@ export class DocumentHistoryModal extends Modal {
     currentDiffIndex = -1;
     diffNavContainer!: HTMLDivElement;
     diffNavIndicator!: HTMLSpanElement;
+    diffOnlyLabel!: HTMLLabelElement;
+
+    // Search state
+    searchKeyword = "";
+    searchResults: { rev: string; index: number; matchType: "Content" | "Diff" }[] = [];
+    currentSearchIndex = -1;
+    searchResultIndicator!: HTMLSpanElement;
+    searchProgressIndicator!: HTMLSpanElement;
+    searchTimeout: number | null = null;
 
     constructor(
         app: App,
@@ -88,9 +99,12 @@ export class DocumentHistoryModal extends Modal {
         if (!file && id) {
             this.file = this.services.path.id2path(id);
         }
-        if (localStorage.getItem("ols-history-highlightdiff") == "1") {
+        if (this.app.loadLocalStorage("ols-history-highlightdiff") == "1") {
             this.showDiff = true;
         }
+        if (this.app.loadLocalStorage("ols-history-diffonly") == "1") {
+            this.diffOnly = true;
+        }
     }
 
     async loadFile(initialRev?: string) {
@@ -151,17 +165,48 @@ export class DocumentHistoryModal extends Modal {
     }
 
     appendTextDiff(diff: [number, string][]) {
+        let hasOmitted = false;
         for (const [operation, text] of diff) {
             if (operation == DIFF_DELETE) {
-                this.contentView.createSpan({ text, cls: "history-deleted" });
+                this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-deleted" }), text);
+                hasOmitted = false;
             } else if (operation == DIFF_EQUAL) {
-                this.contentView.createSpan({ text, cls: "history-normal" });
+                if (this.diffOnly) {
+                    if (!hasOmitted) {
+                        this.contentView.appendText("\n...\n");
+                        hasOmitted = true;
+                    }
+                } else {
+                    this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-normal" }), text);
+                }
             } else if (operation == DIFF_INSERT) {
-                this.contentView.createSpan({ text, cls: "history-added" });
+                this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-added" }), text);
+                hasOmitted = false;
             }
         }
     }
 
+    appendSearchHighlightedText(container: HTMLElement, text: string) {
+        if (!this.searchKeyword) {
+            container.appendText(text);
+            return;
+        }
+        const escapedKeyword = this.searchKeyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(escapedKeyword, "gi");
+        let lastIndex = 0;
+        for (const match of text.matchAll(regex)) {
+            const index = match.index ?? 0;
+            if (index > lastIndex) {
+                container.appendText(text.slice(lastIndex, index));
+            }
+            container.createEl("mark", { text: match[0] });
+            lastIndex = index + match[0].length;
+        }
+        if (lastIndex < text.length) {
+            container.appendText(text.slice(lastIndex));
+        }
+    }
+
     appendImageDiff(baseSrc: string, overlaySrc?: string) {
         const wrap = this.contentView.createDiv({ cls: "ls-imgdiff-wrap" });
         const overlay = wrap.createDiv({ cls: "overlay" });
@@ -258,7 +303,7 @@ export class DocumentHistoryModal extends Modal {
                     if (this.currentDeleted) {
                         this.appendDeletedNotice();
                     }
-                    this.contentView.appendText(w1data);
+                    this.appendSearchHighlightedText(this.contentView, w1data);
                 }
             }
         }
@@ -266,6 +311,11 @@ export class DocumentHistoryModal extends Modal {
         this.resetDiffNavigation();
         if (this.showDiff) {
             this.navigateDiff("next");
+        } else if (this.searchKeyword) {
+            const firstMark = this.contentView.querySelector("mark");
+            if (firstMark) {
+                firstMark.scrollIntoView({ behavior: "smooth", block: "center" });
+            }
         }
     }
 
@@ -293,7 +343,7 @@ export class DocumentHistoryModal extends Modal {
         target.classList.add("diff-focused");
         target.scrollIntoView({ behavior: "smooth", block: "center" });
 
-        this.diffNavIndicator.textContent = `${this.currentDiffIndex + 1}/${diffElements.length}`;
+        this.diffNavIndicator.setText(`${this.currentDiffIndex + 1}/${diffElements.length}`);
     }
 
     /**
@@ -304,9 +354,9 @@ export class DocumentHistoryModal extends Modal {
         if (this.diffNavIndicator) {
             if (this.showDiff) {
                 const diffElements = this.contentView.querySelectorAll(".history-added, .history-deleted");
-                this.diffNavIndicator.textContent = diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014";
+                this.diffNavIndicator.setText(diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014");
             } else {
-                this.diffNavIndicator.textContent = "\u2014";
+                this.diffNavIndicator.setText("\u2014");
             }
         }
         this.updateDiffNavVisibility();
@@ -319,6 +369,117 @@ export class DocumentHistoryModal extends Modal {
         if (this.diffNavContainer) {
             this.diffNavContainer.style.display = this.showDiff ? "flex" : "none";
         }
+        if (this.diffOnlyLabel) {
+            this.diffOnlyLabel.style.display = this.showDiff ? "inline-block" : "none";
+        }
+    }
+
+    /**
+     * Search through the last 100 revisions for the given keyword.
+     */
+    async performSearch(keyword: string) {
+        this.searchKeyword = keyword;
+        this.searchResults = [];
+        this.currentSearchIndex = -1;
+
+        if (!keyword) {
+            this.searchResultIndicator.setText("");
+            this.searchProgressIndicator.setText("");
+            return;
+        }
+
+        const db = this.core.localDatabase;
+        const limit = 100;
+        const totalRevs = this.revs_info.length;
+        const end = Math.min(totalRevs, limit);
+
+        this.searchProgressIndicator.setText("Searching...");
+
+        const dmp = new diff_match_patch();
+
+        // 0 is the newest, higher index is older.
+        for (let i = 0; i < end; i++) {
+            const revInfo = this.revs_info[i];
+            const rev = revInfo.rev;
+
+            this.searchProgressIndicator.setText(`Searching ${i + 1}/${end}...`);
+
+            const doc = await db.getDBEntry(this.file, { rev: rev }, false, false, true);
+            if (doc === false) continue;
+
+            const content = readDocument(doc);
+            if (typeof content !== "string") continue;
+
+            const keywordLower = keyword.toLocaleLowerCase();
+
+            // Search in content
+            if (content.toLocaleLowerCase().includes(keywordLower)) {
+                this.searchResults.push({ rev, index: i, matchType: "Content" });
+                this.updateSearchUI();
+                continue;
+            }
+
+            // Search in diff (from older version to this version)
+            // Older version is at i + 1
+            if (i < totalRevs - 1) {
+                const olderRev = this.revs_info[i + 1].rev;
+                const olderDoc = await db.getDBEntry(this.file, { rev: olderRev }, false, false, true);
+                if (olderDoc !== false) {
+                    const olderContent = readDocument(olderDoc);
+                    if (typeof olderContent === "string") {
+                        const diffs = dmp.diff_main(olderContent, content);
+                        let foundInDiff = false;
+                        for (const d of diffs) {
+                            if (
+                                (d[0] === DIFF_INSERT || d[0] === DIFF_DELETE) &&
+                                d[1].toLocaleLowerCase().includes(keywordLower)
+                            ) {
+                                foundInDiff = true;
+                                break;
+                            }
+                        }
+                        if (foundInDiff) {
+                            this.searchResults.push({ rev, index: i, matchType: "Diff" });
+                            this.updateSearchUI();
+                        }
+                    }
+                }
+            }
+        }
+
+        this.searchProgressIndicator.setText("Done");
+        this.updateSearchUI();
+    }
+
+    updateSearchUI() {
+        if (this.searchResults.length === 0) {
+            this.searchResultIndicator.setText(this.searchKeyword ? "No matches found" : "");
+        } else {
+            const current = this.currentSearchIndex >= 0 ? this.currentSearchIndex + 1 : 0;
+            this.searchResultIndicator.setText(`${current}/${this.searchResults.length} matches`);
+        }
+    }
+
+    navigateSearch(direction: "prev" | "next") {
+        if (this.searchResults.length === 0) return;
+
+        if (direction === "next") {
+            this.currentSearchIndex = (this.currentSearchIndex + 1) % this.searchResults.length;
+        } else {
+            this.currentSearchIndex =
+                this.currentSearchIndex <= 0 ? this.searchResults.length - 1 : this.currentSearchIndex - 1;
+        }
+
+        const match = this.searchResults[this.currentSearchIndex];
+        this.range.value = `${this.revs_info.length - 1 - match.index}`;
+        void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+        this.updateSearchUI();
+
+        // If it's a diff match, make sure Highlight diff is on
+        if (match.matchType === "Diff" && !this.showDiff) {
+            // We could auto-enable it, but maybe just notify the user?
+            // For now, let's just let the user toggle it if they want to see the diff.
+        }
     }
 
     override onOpen() {
@@ -327,6 +488,42 @@ export class DocumentHistoryModal extends Modal {
         contentEl.empty();
         this.fileInfo = contentEl.createDiv("");
         this.fileInfo.addClass("op-info");
+
+        // Search Row
+        const searchRow = contentEl.createDiv("");
+        searchRow.addClass("op-info");
+        searchRow.addClass("search-row");
+        searchRow.addClass("history-search-row");
+
+        const searchInput = searchRow.createEl("input", {
+            type: "text",
+            placeholder: "Search in history (last 100)...",
+        });
+        searchInput.addClass("history-search-input");
+        searchInput.addEventListener("input", () => {
+            if (this.searchTimeout) {
+                compatGlobal.clearTimeout(this.searchTimeout);
+            }
+            this.searchTimeout = compatGlobal.setTimeout(() => {
+                void this.performSearch(searchInput.value);
+            }, 500);
+        });
+
+        searchRow.createEl("button", { text: "\u25B2" }, (e) => {
+            e.title = "Previous match";
+            e.addEventListener("click", () => this.navigateSearch("prev"));
+        });
+        searchRow.createEl("button", { text: "\u25BC" }, (e) => {
+            e.title = "Next match";
+            e.addEventListener("click", () => this.navigateSearch("next"));
+        });
+
+        this.searchResultIndicator = searchRow.createEl("span", { text: "" });
+        this.searchResultIndicator.addClass("history-search-result-indicator");
+
+        this.searchProgressIndicator = searchRow.createEl("span", { text: "" });
+        this.searchProgressIndicator.addClass("history-search-progress-indicator");
+
         const divView = contentEl.createDiv("");
         divView.addClass("op-flex");
 
@@ -342,24 +539,43 @@ export class DocumentHistoryModal extends Modal {
         const diffOptionsRow = contentEl.createDiv("");
         diffOptionsRow.addClass("op-info");
         diffOptionsRow.addClass("diff-options-row");
+        diffOptionsRow.addClass("history-diff-options-row");
 
-        diffOptionsRow.createEl("label", {}, (label) => {
-            label.appendChild(
-                createEl("input", { type: "checkbox" }, (checkbox) => {
-                    if (this.showDiff) {
-                        checkbox.checked = true;
-                    }
-                    checkbox.addEventListener("input", (evt: any) => {
-                        this.showDiff = checkbox.checked;
-                        localStorage.setItem("ols-history-highlightdiff", this.showDiff == true ? "1" : "");
-                        this.updateDiffNavVisibility();
-                        void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
-                    });
-                })
-            );
+        const highlightDiffContainer = diffOptionsRow.createDiv("");
+        highlightDiffContainer.addClass("history-highlight-diff-container");
+
+        highlightDiffContainer.createEl("label", {}, (label) => {
+            label.addClass("history-highlight-diff-label");
+            label.createEl("input", { type: "checkbox" }, (checkbox) => {
+                if (this.showDiff) {
+                    checkbox.checked = true;
+                }
+                checkbox.addEventListener("input", (evt: any) => {
+                    this.showDiff = checkbox.checked;
+                    this.app.saveLocalStorage("ols-history-highlightdiff", this.showDiff == true ? "1" : null);
+                    this.updateDiffNavVisibility();
+                    void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+                });
+            });
             label.appendText("Highlight diff");
         });
 
+        const diffOnlyLabel = diffOptionsRow.createEl("label", {});
+        diffOnlyLabel.createEl("input", { type: "checkbox" }, (checkbox) => {
+            if (this.diffOnly) {
+                checkbox.checked = true;
+            }
+            checkbox.addEventListener("input", (evt: any) => {
+                this.diffOnly = checkbox.checked;
+                this.app.saveLocalStorage("ols-history-diffonly", this.diffOnly == true ? "1" : null);
+                void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+            });
+        });
+        diffOnlyLabel.appendText("Diff only");
+        diffOnlyLabel.addClass("diff-only-label");
+        diffOnlyLabel.style.display = this.showDiff ? "inline-block" : "none";
+        this.diffOnlyLabel = diffOnlyLabel;
+
         // Diff navigation buttons
         this.diffNavContainer = diffOptionsRow.createDiv("");
         this.diffNavContainer.addClass("diff-nav");

src/modules/features/GlobalHistory/GlobalHistory.svelte

@@ -248,7 +248,7 @@
                     </td>
                     <td class="path">
                         <div class="filenames">
-                            <span class="path">/{entry.dirname.split("/").join(`​/`)}</span>
+                            <span class="path">/{entry.dirname.split("/").join(`\u200b/`)}</span>
                             <!-- svelte-ignore a11y-click-events-have-key-events -->
                             <!-- svelte-ignore a11y-no-static-element-interactions -->
                             <!-- svelte-ignore a11y-missing-attribute -->

src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts

@@ -27,6 +27,9 @@ export class ConflictResolveModal extends Modal {
     localName: string = "Base";
     remoteName: string = "Conflicted";
     offEvent?: ReturnType<typeof eventHub.onEvent>;
+    currentDiffIndex = -1;
+    diffView!: HTMLDivElement;
+    diffNavIndicator!: HTMLSpanElement;
 
     constructor(app: App, filename: string, diff: diff_result, pluginPickMode?: boolean, remoteName?: string) {
         super(app);
@@ -47,7 +50,7 @@ export class ConflictResolveModal extends Modal {
         const lines = text.split("\n");
         lines.forEach((line, index) => {
             const span = container.createSpan({ cls });
-            span.textContent = line;
+            span.setText(line);
             if (index < lines.length - 1) {
                 container.createSpan({ cls: "ls-mark-cr" });
                 container.createEl("br");
@@ -62,6 +65,33 @@ export class ConflictResolveModal extends Modal {
         container.createEl("br");
     }
 
+    navigateDiff(direction: "prev" | "next") {
+        const diffElements = this.diffView.querySelectorAll(".added, .deleted");
+        if (diffElements.length === 0) return;
+
+        const prevFocused = this.diffView.querySelector(".diff-focused");
+        if (prevFocused) {
+            prevFocused.classList.remove("diff-focused");
+        }
+
+        if (direction === "next") {
+            this.currentDiffIndex = (this.currentDiffIndex + 1) % diffElements.length;
+        } else {
+            this.currentDiffIndex = this.currentDiffIndex <= 0 ? diffElements.length - 1 : this.currentDiffIndex - 1;
+        }
+
+        const target = diffElements[this.currentDiffIndex];
+        target.classList.add("diff-focused");
+        target.scrollIntoView({ behavior: "smooth", block: "center" });
+        this.diffNavIndicator.setText(`${this.currentDiffIndex + 1}/${diffElements.length}`);
+    }
+
+    resetDiffNavigation() {
+        this.currentDiffIndex = -1;
+        const diffElements = this.diffView.querySelectorAll(".added, .deleted");
+        this.diffNavIndicator.setText(diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014");
+    }
+
     override onOpen() {
         const { contentEl } = this;
         // Send cancel signal for the previous merge dialogue
@@ -78,10 +108,26 @@ export class ConflictResolveModal extends Modal {
         // sendValue("close-resolve-conflict:" + this.filename, false);
         this.titleEl.setText(this.title);
         contentEl.empty();
-        contentEl.createEl("span", { text: this.filename });
-        const div = contentEl.createDiv("");
-        div.addClass("op-scrollable");
-        div.addClass("ls-dialog");
+        const diffOptionsRow = contentEl.createDiv("");
+        diffOptionsRow.addClass("diff-options-row");
+        diffOptionsRow.createEl("span", { text: this.filename });
+
+        const diffNavContainer = diffOptionsRow.createDiv("");
+        diffNavContainer.addClass("diff-nav");
+        diffNavContainer.createEl("button", { text: "\u25B2 Prev" }, (e) => {
+            e.addClass("diff-nav-btn");
+            e.addEventListener("click", () => this.navigateDiff("prev"));
+        });
+        diffNavContainer.createEl("button", { text: "\u25BC Next" }, (e) => {
+            e.addClass("diff-nav-btn");
+            e.addEventListener("click", () => this.navigateDiff("next"));
+        });
+        this.diffNavIndicator = diffNavContainer.createEl("span", { text: "\u2014" });
+        this.diffNavIndicator.addClass("diff-nav-indicator");
+
+        this.diffView = contentEl.createDiv("");
+        this.diffView.addClass("op-scrollable");
+        this.diffView.addClass("ls-dialog");
         let diffLength = 0;
         for (const v of this.result.diff) {
             const x1 = v[0];
@@ -91,12 +137,11 @@ export class ConflictResolveModal extends Modal {
                 continue;
             }
             if (x1 == DIFF_DELETE) {
-                this.appendDiffFragment(div, x2, "deleted");
-                div.createEl("span", { text: x2, cls: "deleted normal conflict-dev-name" });
+                this.appendDiffFragment(this.diffView, x2, "deleted");
             } else if (x1 == DIFF_EQUAL) {
-                this.appendDiffFragment(div, x2, "normal");
+                this.appendDiffFragment(this.diffView, x2, "normal");
             } else if (x1 == DIFF_INSERT) {
-                this.appendDiffFragment(div, x2, "added");
+                this.appendDiffFragment(this.diffView, x2, "added");
             }
         }
 
@@ -108,24 +153,30 @@ 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.addEventListener("click", () => this.sendResponse(this.result.right.rev))
-        ).style.marginRight = "4px";
-        contentEl.createEl("button", { text: `Use ${this.remoteName}` }, (e) =>
-            e.addEventListener("click", () => this.sendResponse(this.result.left.rev))
-        ).style.marginRight = "4px";
+        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) =>
-                e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT))
-            ).style.marginRight = "4px";
+            contentEl.createEl("button", { text: "Concat both" }, (e) => {
+                e.addClass("conflict-action-button");
+                e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT));
+            });
         }
-        contentEl.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) =>
-            e.addEventListener("click", () => this.sendResponse(CANCELLED))
-        ).style.marginRight = "4px";
+        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) {
-            div.empty();
-            div.innerText = "(Too large diff to display)";
+            this.diffView.empty();
+            this.diffView.setText("(Too large diff to display)");
         }
+        this.resetDiffNavigation();
+        this.navigateDiff("next");
     }
 
     sendResponse(result: MergeDialogResult) {

src/modules/features/Log/LogPane.svelte

@@ -1,11 +1,12 @@
 <script lang="ts">
-  import { onDestroy, onMount } from "svelte";
-  import { logMessages } from "../../../lib/src/mock_and_interop/stores";
-  import { reactive, type ReactiveInstance } from "octagonal-wheels/dataobject/reactive";
-  import { Logger } from "../../../lib/src/common/logger";
-  import { $msg as msg, currentLang as lang } from "../../../lib/src/common/i18n.ts";
+    import { onDestroy, onMount } from "svelte";
+    import { logMessages } from "../../../lib/src/mock_and_interop/stores";
+    import { reactive, type ReactiveInstance } from "octagonal-wheels/dataobject/reactive";
+    import { Logger } from "../../../lib/src/common/logger";
+    import { $msg as msg, currentLang as lang } from "../../../lib/src/common/i18n.ts";
+    import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
 
-  let unsubscribe: () => void;
+    let unsubscribe: () => void;
     let messages = $state([] as string[]);
     let wrapRight = $state(false);
     let autoScroll = $state(true);
@@ -16,90 +17,90 @@
     };
     let { close }: Props = $props();
     // export let close: () => void;
-  function updateLog(logs: ReactiveInstance<string[]>) {
-      const e = logs.value;
-      if (!suspended) {
-          messages = [...e];
-          setTimeout(() => {
-              if (scroll) scroll.scrollTop = scroll.scrollHeight;
-          }, 10);
-      }
-  }
-  onMount(async () => {
-      const _logMessages = reactive(() => logMessages.value);
-      _logMessages.onChanged(updateLog);
-      Logger(msg("logPane.logWindowOpened", {}, lang));
-      unsubscribe = () => _logMessages.offChanged(updateLog);
-  });
-  onDestroy(() => {
-      if (unsubscribe) unsubscribe();
-  });
-  let scroll: HTMLDivElement;
+    function updateLog(logs: ReactiveInstance<string[]>) {
+        const e = logs.value;
+        if (!suspended) {
+            messages = [...e];
+            compatGlobal.setTimeout(() => {
+                if (scroll) scroll.scrollTop = scroll.scrollHeight;
+            }, 10);
+        }
+    }
+    onMount(async () => {
+        const _logMessages = reactive(() => logMessages.value);
+        _logMessages.onChanged(updateLog);
+        Logger(msg("logPane.logWindowOpened", {}, lang));
+        unsubscribe = () => _logMessages.offChanged(updateLog);
+    });
+    onDestroy(() => {
+        if (unsubscribe) unsubscribe();
+    });
+    let scroll: HTMLDivElement;
     function closeDialogue() {
         close();
     }
 </script>
 
 <div class="logpane">
-  <!-- <h1>{msg("logPane.title", {}, lang)}</h1> -->
-  <div class="control">
-      <div class="row">
-          <label>
-              <input type="checkbox" bind:checked={wrapRight} />
-              <span>{msg("logPane.wrap", {}, lang)}</span>
-          </label>
-          <label>
-              <input type="checkbox" bind:checked={autoScroll} />
-              <span>{msg("logPane.autoScroll", {}, lang)}</span>
-          </label>
-          <label>
-              <input type="checkbox" bind:checked={suspended} />
-              <span>{msg("logPane.pause", {}, lang)}</span>
-          </label>
+    <!-- <h1>{msg("logPane.title", {}, lang)}</h1> -->
+    <div class="control">
+        <div class="row">
+            <label>
+                <input type="checkbox" bind:checked={wrapRight} />
+                <span>{msg("logPane.wrap", {}, lang)}</span>
+            </label>
+            <label>
+                <input type="checkbox" bind:checked={autoScroll} />
+                <span>{msg("logPane.autoScroll", {}, lang)}</span>
+            </label>
+            <label>
+                <input type="checkbox" bind:checked={suspended} />
+                <span>{msg("logPane.pause", {}, lang)}</span>
+            </label>
             <span class="spacer"></span>
             <button onclick={() => closeDialogue()}>Close</button>
-      </div>
-  </div>
-  <div class="log" bind:this={scroll}>
-      {#each messages as line}
-          <pre class:wrap-right={wrapRight}>{line}</pre>
-      {/each}
-  </div>
+        </div>
+    </div>
+    <div class="log" bind:this={scroll}>
+        {#each messages as line}
+            <pre class:wrap-right={wrapRight}>{line}</pre>
+        {/each}
+    </div>
 </div>
 
 <style>
-  * {
-      box-sizing: border-box;
-  }
-  .logpane {
-      display: flex;
-      height: 100%;
-      flex-direction: column;
-  }
-  .log {
-      overflow-y: scroll;
-      user-select: text;
+    * {
+        box-sizing: border-box;
+    }
+    .logpane {
+        display: flex;
+        height: 100%;
+        flex-direction: column;
+    }
+    .log {
+        overflow-y: scroll;
+        user-select: text;
         -webkit-user-select: text;
-      padding-bottom: 2em;
-  }
-  .log > pre {
-      margin: 0;
-  }
-  .log > pre.wrap-right {
-      word-break: break-all;
-      max-width: 100%;
-      width: 100%;
-      white-space: normal;
-  }
-  .row {
-      display: flex;
-      flex-direction: row;
-      justify-content: flex-end;
-  }
-  .row > label {
-      display: flex;
-      align-items: center;
-      min-width: 5em;
-      margin-right: 1em;
-  }
+        padding-bottom: 2em;
+    }
+    .log > pre {
+        margin: 0;
+    }
+    .log > pre.wrap-right {
+        word-break: break-all;
+        max-width: 100%;
+        width: 100%;
+        white-space: normal;
+    }
+    .row {
+        display: flex;
+        flex-direction: row;
+        justify-content: flex-end;
+    }
+    .row > label {
+        display: flex;
+        align-items: center;
+        min-width: 5em;
+        margin-right: 1em;
+    }
 </style>

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 "src/lib/src/common/i18n.ts";
+import { $msg } from "@lib/common/i18n.ts";
 import { mount } from "svelte";
 export const VIEW_TYPE_LOG = "log-log";
 //Log view

src/modules/features/ModuleInteractiveConflictResolver.ts

@@ -88,7 +88,7 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
                     return false;
                 }
             } else {
-                this._log(`Merge: Something went wrong: ${filename}, (${toDelete})`, LOG_LEVEL_NOTICE);
+                this._log(`Merge: Something went wrong: ${filename}, (${toDelete as string})`, LOG_LEVEL_NOTICE);
                 return false;
             }
             // In here, some merge has been processed.
@@ -163,7 +163,7 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
                 this._log(`There are no conflicting files`, LOG_LEVEL_VERBOSE);
             }
         } catch (e) {
-            this._log(`Error while scanning conflicted files: ${e}`, LOG_LEVEL_NOTICE);
+            this._log(`Error while scanning conflicted files...`, LOG_LEVEL_NOTICE);
             this._log(e, LOG_LEVEL_VERBOSE);
             return false;
         }

src/modules/features/ModuleLog.ts

@@ -29,7 +29,7 @@ import { addIcon, debounce, normalizePath, Notice, stringifyYaml, type Workspace
 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 "src/lib/src/common/i18n.ts";
+import { $msg } from "@lib/common/i18n.ts";
 import { P2PLogCollector } from "@/lib/src/replication/trystero/P2PLogCollector.ts";
 import type { LiveSyncCore } from "../../main.ts";
 import { LiveSyncError } from "@lib/common/LSError.ts";
@@ -262,7 +262,7 @@ export class ModuleLog extends AbstractObsidianModule {
             this.statusDiv.remove();
             // this.statusDiv.pa();
             const container = mdv.view.containerEl;
-            container.insertBefore(this.statusDiv, container.lastChild);
+            container.appendChild(this.statusDiv);
         }
     }
 
@@ -466,12 +466,14 @@ ${stringifyYaml(info)}
 
         this.observeForLogs();
 
-        this.statusDiv = this.app.workspace.containerEl.createDiv({ cls: "livesync-status" });
-        this.statusLine = this.statusDiv.createDiv({ cls: "livesync-status-statusline" });
-        this.messageArea = this.statusDiv.createDiv({ cls: "livesync-status-messagearea" });
-        this.logMessage = this.statusDiv.createDiv({ cls: "livesync-status-logmessage" });
-        this.logHistory = this.statusDiv.createDiv({ cls: "livesync-status-loghistory" });
-        this.statusDiv.style.display = this.settings?.showStatusOnEditor ? "" : "none";
+        if (this.settings.showStatusOnEditor) {
+            this.statusDiv = this.app.workspace.containerEl.createDiv({ cls: "livesync-status" });
+            this.statusLine = this.statusDiv.createDiv({ cls: "livesync-status-statusline" });
+            this.messageArea = this.statusDiv.createDiv({ cls: "livesync-status-messagearea" });
+            this.logMessage = this.statusDiv.createDiv({ cls: "livesync-status-logmessage" });
+            this.logHistory = this.statusDiv.createDiv({ cls: "livesync-status-loghistory" });
+            this.statusDiv.style.display = this.settings?.showStatusOnEditor ? "" : "none";
+        }
         eventHub.onEvent(EVENT_LAYOUT_READY, () => this.adjustStatusDivPosition());
         if (this.settings?.showStatusOnStatusbar) {
             this.statusBar = this.services.API.addStatusBarItem();
@@ -516,7 +518,12 @@ ${stringifyYaml(info)}
         let errorInfo = "";
         if (message instanceof Error) {
             if (message instanceof LiveSyncError) {
-                errorInfo = `${message.cause?.name}:${message.cause?.message}\n[StackTrace]: ${message.stack}\n[CausedBy]: ${message.cause?.stack}`;
+                if (message.cause && message.cause instanceof Error) {
+                    const causedError = message.cause;
+                    errorInfo = `${causedError?.name}:${causedError?.message}\n[StackTrace]: ${message.stack}\n[CausedBy]: ${causedError?.stack}`;
+                } else {
+                    errorInfo = `${message.name}:${message.message}\n[StackTrace]: ${message.stack}`;
+                }
             } else {
                 const thisStack = new Error().stack;
                 errorInfo = `${message.name}:${message.message}\n[StackTrace]: ${message.stack}\n[LogCallStack]: ${thisStack}`;

src/modules/features/SettingDialogue/LiveSyncSetting.ts

@@ -8,12 +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/src/common/types.ts";
+import { LEVEL_ADVANCED, LEVEL_POWER_USER, statusDisplay, type ConfigurationItem } from "@lib/common/types.ts";
 import { createStub, type ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import {
     type AllSettingItemKey,
@@ -23,7 +18,7 @@ import {
     type AllNumericItemKey,
     type AllBooleanItemKey,
 } from "./settingConstants.ts";
-import { $msg } from "src/lib/src/common/i18n.ts";
+import { $msg } from "@lib/common/i18n.ts";
 import { findAttrFromParent, wrapMemo, type AutoWireOption, type OnUpdateResult } from "./SettingPane.ts";
 
 export class LiveSyncSetting extends Setting {

src/modules/features/SettingDialogue/ObsidianLiveSyncSettingTab.ts

@@ -62,6 +62,7 @@ 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";
 
 // For creating a document
 const toc = new Set<string>();
@@ -141,7 +142,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
 
     async saveLocalSetting(key: keyof typeof OnDialogSettingsDefault) {
         if (key == "configPassphrase") {
-            localStorage.setItem("ls-setting-passphrase", this.editingSettings?.[key] ?? "");
+            compatGlobal.localStorage.setItem("ls-setting-passphrase", this.editingSettings?.[key] ?? "");
             return await Promise.resolve();
         }
         if (key == "deviceAndVaultName") {
@@ -180,7 +181,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
         // if (runOnSaved) {
         const handlers = this.onSavedHandlers
             .filter((e) => appliedKeys.indexOf(e.key) !== -1)
-            .map((e) => e.handler(this.editingSettings[e.key as AllSettingItemKey]));
+            .map((e) => Promise.resolve(e.handler(this.editingSettings[e.key as AllSettingItemKey])));
         await Promise.all(handlers);
         // }
         keys.forEach((e) => this.refreshSetting(e));
@@ -214,7 +215,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
 
     reloadAllLocalSettings() {
         const ret = { ...OnDialogSettingsDefault };
-        ret.configPassphrase = localStorage.getItem("ls-setting-passphrase") || "";
+        ret.configPassphrase = compatGlobal.localStorage.getItem("ls-setting-passphrase") || "";
         ret.preset = "";
         ret.deviceAndVaultName = this.services.setting.getDeviceAndVaultName();
         return ret;
@@ -349,7 +350,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
     createEl<T extends keyof HTMLElementTagNameMap>(
         el: HTMLElement,
         tag: T,
-        o?: string | DomElementInfo | undefined,
+        o?: string | DomElementInfo,
         callback?: (el: HTMLElementTagNameMap[T]) => void,
         func?: OnUpdateFunc
     ) {
@@ -361,7 +362,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
     addEl<T extends keyof HTMLElementTagNameMap>(
         el: HTMLElement,
         tag: T,
-        o?: string | DomElementInfo | undefined,
+        o?: string | DomElementInfo,
         callback?: (el: HTMLElementTagNameMap[T]) => void,
         func?: OnUpdateFunc
     ) {
@@ -647,7 +648,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             this.editingSettings.passphrase = "";
         }
         await this.saveAllDirtySettings();
-        await this.applyAllSettings();
+        await Promise.resolve(this.applyAllSettings());
         if (result == OPTION_FETCH) {
             await this.core.storageAccess.writeFileAuto(FLAGMD_REDFLAG3_HR, "");
             this.services.appLifecycle.scheduleRestart();
@@ -738,6 +739,8 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                 );
             }
             setLevelClass(el, level);
+            // TODO: Refactor to use Obsidian's recommended way to create heading.
+            // eslint-disable-next-line obsidianmd/settings-tab/no-manual-html-headings
             el.createEl("h3", { text: title, cls: "sls-setting-pane-title" });
             if (this.menuEl) {
                 this.menuEl.createEl(

src/modules/features/SettingDialogue/PaneHatch.ts

@@ -1,29 +1,16 @@
-import { stringifyYaml } from "../../../deps.ts";
 import {
-    type ObsidianLiveSyncSettings,
     type FilePathWithPrefix,
     type DocumentID,
     LOG_LEVEL_NOTICE,
     LOG_LEVEL_VERBOSE,
     type LoadedEntry,
-    REMOTE_COUCHDB,
-    REMOTE_MINIO,
     type MetaEntry,
     type FilePath,
-    DEFAULT_SETTINGS,
-} from "../../../lib/src/common/types.ts";
-import {
-    createBlob,
-    getFileRegExp,
-    isDocContentSame,
-    parseHeaderValues,
-    readAsBlob,
-} from "../../../lib/src/common/utils.ts";
-import { Logger } from "../../../lib/src/common/logger.ts";
-import { isCloudantURI } from "../../../lib/src/pouchdb/utils_couchdb.ts";
-import { requestToCouchDBWithCredentials } from "../../../common/utils.ts";
-import { addPrefix, shouldBeIgnored, stripAllPrefixes } from "../../../lib/src/string_and_binary/path.ts";
-import { $msg } from "../../../lib/src/common/i18n.ts";
+} from "@lib/common/types.ts";
+import { createBlob, getFileRegExp, isDocContentSame, readAsBlob } from "@lib/common/utils.ts";
+import { Logger } from "@lib/common/logger.ts";
+import { addPrefix, shouldBeIgnored, stripAllPrefixes } from "@lib/string_and_binary/path.ts";
+import { $msg } from "@lib/common/i18n.ts";
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import {
@@ -32,14 +19,13 @@ import {
     EVENT_REQUEST_RUN_DOCTOR,
     EVENT_REQUEST_RUN_FIX_INCOMPLETE,
     eventHub,
-} from "../../../common/events.ts";
-import { ICHeader, ICXHeader, PSCHeader } from "../../../common/types.ts";
-import { HiddenFileSync } from "../../../features/HiddenFileSync/CmdHiddenFileSync.ts";
-import { EVENT_REQUEST_SHOW_HISTORY } from "../../../common/obsidianEvents.ts";
-import { generateCredentialObject } from "../../../lib/src/replication/httplib.ts";
+} from "@/common/events.ts";
+import { ICHeader, ICXHeader, PSCHeader } from "@/common/types.ts";
+import { HiddenFileSync } from "@/features/HiddenFileSync/CmdHiddenFileSync.ts";
+import { EVENT_REQUEST_SHOW_HISTORY } from "@/common/obsidianEvents.ts";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import type { PageFunctions } from "./SettingPane.ts";
-import { generateReport } from "@/common/reportTool.ts";
+import { isNotFoundError } from "@lib/common/utils.doc.ts";
 export function paneHatch(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElement, { addPanel }: PageFunctions): void {
     // const hatchWarn = this.createEl(paneEl, "div", { text: `To stop the boot up sequence for fixing problems on databases, you can put redflag.md on top of your vault (Rebooting obsidian is required).` });
     // hatchWarn.addClass("op-warn-info");
@@ -160,14 +146,14 @@ export function paneHatch(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElement,
                                             }
                                             if (!(await addOn.storeInternalFileToDatabase(file, true))) {
                                                 Logger(
-                                                    `Failed to store the file to the database (Hidden file): ${file}`,
+                                                    `Failed to store the file to the database (Hidden file): ${file.path}`,
                                                     LOG_LEVEL_NOTICE
                                                 );
                                                 return;
                                             }
                                         }
                                     } else {
-                                        if (!(await this.core.fileHandler.storeFileToDB(file as FilePath, true))) {
+                                        if (!(await this.core.fileHandler.storeFileToDB(file, true))) {
                                             Logger(
                                                 `Failed to store the file to the database: ${file}`,
                                                 LOG_LEVEL_NOTICE
@@ -406,8 +392,8 @@ export function paneHatch(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElement,
                                         Logger(`Converting ${docName} Failed!`, LOG_LEVEL_NOTICE);
                                         Logger(ret, LOG_LEVEL_VERBOSE);
                                     }
-                                } catch (ex: any) {
-                                    if (ex?.status == 404) {
+                                } catch (ex: unknown) {
+                                    if (isNotFoundError(ex)) {
                                         // We can perform this safely
                                         if ((await this.core.localDatabase.putRaw(newDoc)).ok) {
                                             Logger(`${docName} has been converted`, LOG_LEVEL_NOTICE);

src/modules/features/SettingDialogue/PanePatches.ts

@@ -150,7 +150,7 @@ export function panePatches(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElemen
                 xxhash64: "xxhash64 (Fastest)",
                 "mixed-purejs": "PureJS fallback  (Fast, W/O WebAssembly)",
                 sha1: "Older fallback (Slow, W/O WebAssembly)",
-            } as Record<HashAlgorithm, string>,
+            } satisfies Record<HashAlgorithm, string>,
         });
         this.addOnSaved("hashAlg", async () => {
             await this.core.localDatabase._prepareHashFunctions();
@@ -188,7 +188,7 @@ export function panePatches(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElemen
                     }
                     this.requestUpdate();
                 };
-                text.inputEl.before((dateEl = document.createElement("span")));
+                text.inputEl.before((dateEl = activeDocument.createElement("span")));
                 text.inputEl.type = "datetime-local";
                 if (this.editingSettings.maxMTimeForReflectEvents > 0) {
                     const date = new Date(this.editingSettings.maxMTimeForReflectEvents);

src/modules/features/SettingDialogue/PaneRemoteConfig.ts

@@ -5,6 +5,7 @@ import {
     DEFAULT_SETTINGS,
     LOG_LEVEL_NOTICE,
     type ObsidianLiveSyncSettings,
+    LOG_LEVEL_VERBOSE,
 } from "../../../lib/src/common/types.ts";
 import { Menu } from "@/deps.ts";
 import { $msg } from "../../../lib/src/common/i18n.ts";
@@ -288,7 +289,8 @@ export function paneRemoteConfig(
                 try {
                     parsed = ConnectionStringParser.parse(trimmedURI);
                 } catch (ex) {
-                    this.services.API.addLog(`Failed to import remote configuration: ${ex}`, LOG_LEVEL_NOTICE);
+                    this.services.API.addLog(`Failed to import remote configuration!`, LOG_LEVEL_NOTICE);
+                    this.services.API.addLog(ex, LOG_LEVEL_VERBOSE);
                     return;
                 }
 
@@ -343,9 +345,10 @@ export function paneRemoteConfig(
                                 parsed = ConnectionStringParser.parse(config.uri);
                             } catch (ex) {
                                 this.services.API.addLog(
-                                    `Failed to parse remote configuration '${config.id}' for editing: ${ex}`,
+                                    `Failed to parse remote configuration '${config.id}' for editing!`,
                                     LOG_LEVEL_NOTICE
                                 );
+                                this.services.API.addLog(ex, LOG_LEVEL_VERBOSE);
                                 return;
                             }
                             const workSettings = createBaseRemoteSettings();
@@ -452,9 +455,10 @@ export function paneRemoteConfig(
                                             parsed = ConnectionStringParser.parse(config.uri);
                                         } catch (ex) {
                                             this.services.API.addLog(
-                                                `Failed to parse remote configuration '${config.id}': ${ex}`,
+                                                `Failed to parse remote configuration '${config.id}' for fetching settings!`,
                                                 LOG_LEVEL_NOTICE
                                             );
+                                            this.services.API.addLog(ex, LOG_LEVEL_VERBOSE);
                                             return;
                                         }
                                         const workSettings = createBaseRemoteSettings();

src/modules/features/SettingDialogue/settingUtils.ts

@@ -75,7 +75,7 @@ export function getSummaryFromPartialSettings(setting: Partial<ObsidianLiveSyncS
         if (config.isAdvanced && !showAdvanced) continue;
         const value =
             key != "E2EEAlgorithm"
-                ? `${setting[key]}`
+                ? `${setting[key] as string}`
                 : E2EEAlgorithmNames[`${setting[key]}` as keyof typeof E2EEAlgorithmNames];
         const displayValue = config.isHidden ? "•".repeat(value.length) : escapeStringToHTML(value);
         outputSummary[config.name] = displayValue;

src/modules/features/SetupManager.ts

@@ -1,13 +1,17 @@
 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/src/common/types.ts";
-import { generatePatchObj, isObjectDifferent } from "../../lib/src/common/utils.ts";
+} from "@lib/common/types.ts";
+import { isObjectDifferent } from "@lib/common/utils.ts";
 import Intro from "./SetupWizard/dialogs/Intro.svelte";
 import SelectMethodNewUser from "./SetupWizard/dialogs/SelectMethodNewUser.svelte";
 import SelectMethodExisting from "./SetupWizard/dialogs/SelectMethodExisting.svelte";
@@ -21,8 +25,21 @@ 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/src/API/processSetting.ts";
+import { decodeSettingsFromQRCodeData } from "@lib/API/processSetting.ts";
 import { AbstractModule } from "../AbstractModule.ts";
+import { ConnectionStringParser } from "@lib/common/ConnectionString.ts";
+import type {
+    OutroAskUserModeResultType,
+    OutroExistingUserResultType,
+    OutroNewUserResultType,
+    ScanQRCodeResultType,
+    SetupRemoteBucketResultType,
+    SetupRemoteCouchDBResultType,
+    SetupRemoteE2EEResultType,
+    SetupRemoteP2PResultType,
+    SetupRemoteResultType,
+    UseSetupURIResultType,
+} from "./SetupWizard/dialogs/setupDialogTypes.ts";
 
 /**
  * User modes for onboarding and setup
@@ -117,7 +134,10 @@ export class SetupManager extends AbstractModule {
      * @returns Promise that resolves to true if onboarding completed successfully, false otherwise
      */
     async onUseSetupURI(userMode: UserMode, setupURI: string = ""): Promise<boolean> {
-        const newSetting = await this.dialogManager.openWithExplicitCancel(UseSetupURI, setupURI);
+        const newSetting = await this.dialogManager.openWithExplicitCancel<UseSetupURIResultType, string>(
+            UseSetupURI,
+            setupURI
+        );
         if (newSetting === "cancelled") {
             this._log("Setup URI dialog cancelled.", LOG_LEVEL_NOTICE);
             return false;
@@ -140,7 +160,10 @@ export class SetupManager extends AbstractModule {
     ): 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(SetupRemoteCouchDB, originalSetting);
+        const couchConf = await this.dialogManager.openWithExplicitCancel<
+            SetupRemoteCouchDBResultType,
+            CouchDBConnection
+        >(SetupRemoteCouchDB, originalSetting);
         if (couchConf === "cancelled") {
             this._log("Manual configuration cancelled.", LOG_LEVEL_NOTICE);
             return await this.onOnboard(userMode);
@@ -164,7 +187,10 @@ export class SetupManager extends AbstractModule {
         currentSetting: ObsidianLiveSyncSettings,
         activate = true
     ): Promise<boolean> {
-        const bucketConf = await this.dialogManager.openWithExplicitCancel(SetupRemoteBucket, currentSetting);
+        const bucketConf = await this.dialogManager.openWithExplicitCancel<
+            SetupRemoteBucketResultType,
+            BucketSyncSetting
+        >(SetupRemoteBucket, currentSetting);
         if (bucketConf === "cancelled") {
             this._log("Manual configuration cancelled.", LOG_LEVEL_NOTICE);
             return await this.onOnboard(userMode);
@@ -188,14 +214,33 @@ export class SetupManager extends AbstractModule {
         currentSetting: ObsidianLiveSyncSettings,
         activate = true
     ): Promise<boolean> {
-        const p2pConf = await this.dialogManager.openWithExplicitCancel(SetupRemoteP2P, currentSetting);
+        const p2pConf = await this.dialogManager.openWithExplicitCancel<SetupRemoteP2PResultType, P2PSyncSetting>(
+            SetupRemoteP2P,
+            currentSetting
+        );
         if (p2pConf === "cancelled") {
             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;
         }
         return await this.onConfirmApplySettingsFromWizard(newSetting, userMode, activate);
     }
@@ -207,10 +252,13 @@ export class SetupManager extends AbstractModule {
      * @returns
      */
     async onlyE2EEConfiguration(userMode: UserMode, currentSetting: ObsidianLiveSyncSettings): Promise<boolean> {
-        const e2eeConf = await this.dialogManager.openWithExplicitCancel(SetupRemoteE2EE, currentSetting);
+        const e2eeConf = await this.dialogManager.openWithExplicitCancel<SetupRemoteE2EEResultType, EncryptionSettings>(
+            SetupRemoteE2EE,
+            currentSetting
+        );
         if (e2eeConf === "cancelled") {
             this._log("E2EE configuration cancelled.", LOG_LEVEL_NOTICE);
-            return await false;
+            return false;
         }
         const newSetting = {
             ...currentSetting,
@@ -226,7 +274,10 @@ export class SetupManager extends AbstractModule {
      * @returns
      */
     async onConfigureManually(originalSetting: ObsidianLiveSyncSettings, userMode: UserMode): Promise<boolean> {
-        const e2eeConf = await this.dialogManager.openWithExplicitCancel(SetupRemoteE2EE, originalSetting);
+        const e2eeConf = await this.dialogManager.openWithExplicitCancel<SetupRemoteE2EEResultType, EncryptionSettings>(
+            SetupRemoteE2EE,
+            originalSetting
+        );
         if (e2eeConf === "cancelled") {
             this._log("Manual configuration cancelled.", LOG_LEVEL_NOTICE);
             return await this.onOnboard(userMode);
@@ -245,7 +296,7 @@ export class SetupManager extends AbstractModule {
      * @returns
      */
     async onSelectServer(currentSetting: ObsidianLiveSyncSettings, userMode: UserMode): Promise<boolean> {
-        const method = await this.dialogManager.openWithExplicitCancel(SetupRemote);
+        const method = await this.dialogManager.openWithExplicitCancel<SetupRemoteResultType>(SetupRemote);
         if (method === "couchdb") {
             return await this.onCouchDBManualSetup(userMode, currentSetting, true);
         } else if (method === "bucket") {
@@ -285,9 +336,9 @@ export class SetupManager extends AbstractModule {
                 this._log("No changes in settings detected. Skipping applying settings from wizard.", LOG_LEVEL_NOTICE);
                 return true;
             }
-            const patch = generatePatchObj(this.settings, newConf);
-            console.log(`Changes:`);
-            console.dir(patch);
+            // const patch = generatePatchObj(this.settings, newConf);
+            // console.log(`Changes:`);
+            // console.dir(patch);
             if (!activate) {
                 extra();
                 await this.applySetting(newConf, UserMode.ExistingUser);
@@ -304,7 +355,8 @@ export class SetupManager extends AbstractModule {
                 this._log("Settings from wizard applied.", LOG_LEVEL_NOTICE);
                 return true;
             } else {
-                const userModeResult = await this.dialogManager.openWithExplicitCancel(OutroAskUserMode);
+                const userModeResult =
+                    await this.dialogManager.openWithExplicitCancel<OutroAskUserModeResultType>(OutroAskUserMode);
                 if (userModeResult === "new-user") {
                     userMode = UserMode.NewUser;
                 } else if (userModeResult === "existing-user") {
@@ -321,7 +373,9 @@ export class SetupManager extends AbstractModule {
             }
         }
         const component = userMode === UserMode.NewUser ? OutroNewUser : OutroExistingUser;
-        const confirm = await this.dialogManager.openWithExplicitCancel(component);
+        const confirm = await this.dialogManager.openWithExplicitCancel<
+            OutroNewUserResultType | OutroExistingUserResultType
+        >(component);
         if (confirm === "cancelled") {
             this._log("User cancelled applying settings from wizard..", LOG_LEVEL_NOTICE);
             return false;
@@ -347,10 +401,10 @@ export class SetupManager extends AbstractModule {
      */
 
     async onPromptQRCodeInstruction(): Promise<boolean> {
-        const qrResult = await this.dialogManager.open(ScanQRCode);
+        const qrResult = await this.dialogManager.open<ScanQRCodeResultType>(ScanQRCode);
         this._log("QR Code dialog closed.", LOG_LEVEL_VERBOSE);
         // Result is not used, but log it for debugging.
-        this._log(`QR Code result: ${qrResult}`, LOG_LEVEL_VERBOSE);
+        this._log(qrResult, LOG_LEVEL_VERBOSE);
         // QR Code instruction dialog never yields settings directly.
         return false;
     }

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

@@ -1,47 +1,30 @@
 <script lang="ts">
-    import DialogHeader from "@/lib/src/UI/components/DialogHeader.svelte";
-    import Guidance from "@/lib/src/UI/components/Guidance.svelte";
-    import Decision from "@/lib/src/UI/components/Decision.svelte";
-    import Question from "@/lib/src/UI/components/Question.svelte";
-    import Option from "@/lib/src/UI/components/Option.svelte";
-    import Options from "@/lib/src/UI/components/Options.svelte";
-    import Instruction from "@/lib/src/UI/components/Instruction.svelte";
-    import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
-    import InfoNote from "@/lib/src/UI/components/InfoNote.svelte";
-    import ExtraItems from "@/lib/src/UI/components/ExtraItems.svelte";
-    import Check from "@/lib/src/UI/components/Check.svelte";
-    const TYPE_IDENTICAL = "identical";
-    const TYPE_INDEPENDENT = "independent";
-    const TYPE_UNBALANCED = "unbalanced";
-    const TYPE_CANCEL = "cancelled";
+    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 {
+        TYPE_BACKUP_DONE,
+        TYPE_BACKUP_SKIPPED,
+        TYPE_CANCEL,
+        TYPE_IDENTICAL,
+        TYPE_INDEPENDENT,
+        TYPE_UNABLE_TO_BACKUP,
+        TYPE_UNBALANCED,
+        type FetchEverythingResult,
+        type ResultTypeBackup,
+        type ResultTypeVault,
+    } from "./setupDialogTypes";
 
-    const TYPE_BACKUP_DONE = "backup_done";
-    const TYPE_BACKUP_SKIPPED = "backup_skipped";
-    const TYPE_UNABLE_TO_BACKUP = "unable_to_backup";
-
-    type ResultTypeVault =
-        | typeof TYPE_IDENTICAL
-        | typeof TYPE_INDEPENDENT
-        | typeof TYPE_UNBALANCED
-        | typeof TYPE_CANCEL;
-    type ResultTypeBackup =
-        | typeof TYPE_BACKUP_DONE
-        | typeof TYPE_BACKUP_SKIPPED
-        | typeof TYPE_UNABLE_TO_BACKUP
-        | typeof TYPE_CANCEL;
-
-    type ResultTypeExtra = {
-        preventFetchingConfig: boolean;
-    };
-    type ResultType =
-        | {
-              vault: ResultTypeVault;
-              backup: ResultTypeBackup;
-              extra: ResultTypeExtra;
-          }
-        | typeof TYPE_CANCEL;
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: FetchEverythingResult) => void;
     };
     const { setResult }: Props = $props();
     let vaultType = $state<ResultTypeVault>(TYPE_CANCEL);

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

@@ -1,21 +1,19 @@
 <script lang="ts">
-    import DialogHeader from "@/lib/src/UI/components/DialogHeader.svelte";
-    import Guidance from "@/lib/src/UI/components/Guidance.svelte";
-    import Decision from "@/lib/src/UI/components/Decision.svelte";
-    import Question from "@/lib/src/UI/components/Question.svelte";
-    import Option from "@/lib/src/UI/components/Option.svelte";
-    import Options from "@/lib/src/UI/components/Options.svelte";
-    import Instruction from "@/lib/src/UI/components/Instruction.svelte";
-    import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
-    const TYPE_NEW_USER = "new-user";
-    const TYPE_EXISTING_USER = "existing-user";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_NEW_USER | typeof TYPE_EXISTING_USER | typeof TYPE_CANCELLED;
+    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 { TYPE_NEW_USER, TYPE_EXISTING_USER, TYPE_CANCELLED, type IntroResultType } from "./setupDialogTypes";
+
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: IntroResultType) => void;
     };
     const { setResult }: Props = $props();
-    let userType = $state<ResultType>(TYPE_CANCELLED);
+    let userType = $state<IntroResultType>(TYPE_CANCELLED);
     let proceedTitle = $derived.by(() => {
         if (userType === TYPE_NEW_USER) {
             return "Yes, I want to set up a new synchronisation";

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

@@ -7,16 +7,19 @@
     import Instruction from "@/lib/src/UI/components/Instruction.svelte";
     import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
     import InfoNote from "@/lib/src/UI/components/InfoNote.svelte";
-    const TYPE_EXISTING = "existing-user";
-    const TYPE_NEW = "new-user";
-    const TYPE_COMPATIBLE_EXISTING = "compatible-existing-user";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_EXISTING | typeof TYPE_NEW | typeof TYPE_COMPATIBLE_EXISTING | typeof TYPE_CANCELLED;
+    import {
+        type OutroAskUserModeResultType,
+        TYPE_CANCELLED,
+        TYPE_EXISTING,
+        TYPE_NEW,
+        TYPE_COMPATIBLE_EXISTING,
+    } from "./setupDialogTypes";
+
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: OutroAskUserModeResultType) => void;
     };
     const { setResult }: Props = $props();
-    let userType = $state<ResultType>(TYPE_CANCELLED);
+    let userType = $state<OutroAskUserModeResultType>(TYPE_CANCELLED);
     const canProceed = $derived.by(() => {
         return userType === TYPE_EXISTING || userType === TYPE_NEW || userType === TYPE_COMPATIBLE_EXISTING;
     });
@@ -41,7 +44,11 @@
 </Guidance>
 <Instruction>
     <Question>Please select your situation.</Question>
-    <Option title="I am setting up a new server for the first time / I want to reset my existing server." bind:value={userType} selectedValue={TYPE_NEW}>
+    <Option
+        title="I am setting up a new server for the first time / I want to reset my existing server."
+        bind:value={userType}
+        selectedValue={TYPE_NEW}
+    >
         <InfoNote>
             Selecting this option will result in the current data on this device being used to initialise the server.
             Any existing data on the server will be completely overwritten.

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

@@ -1,15 +1,14 @@
 <script lang="ts">
-    import DialogHeader from "@/lib/src/UI/components/DialogHeader.svelte";
-    import Guidance from "@/lib/src/UI/components/Guidance.svelte";
-    import Decision from "@/lib/src/UI/components/Decision.svelte";
-    import Question from "@/lib/src/UI/components/Question.svelte";
-    import Instruction from "@/lib/src/UI/components/Instruction.svelte";
-    import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
-        const TYPE_APPLY = "apply";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_APPLY | typeof TYPE_CANCELLED;
+    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 { TYPE_CANCELLED, TYPE_APPLY, type OutroExistingUserResultType } from "./setupDialogTypes";
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: OutroExistingUserResultType) => void;
     };
     const { setResult }: Props = $props();
 </script>

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

@@ -5,14 +5,13 @@
     import Question from "@/lib/src/UI/components/Question.svelte";
     import Instruction from "@/lib/src/UI/components/Instruction.svelte";
     import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
-        const TYPE_APPLY = "apply";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_APPLY | typeof TYPE_CANCELLED;
+    import { TYPE_APPLY, TYPE_CANCELLED, type OutroNewUserResultType } from "./setupDialogTypes";
+
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: OutroNewUserResultType) => void;
     };
     const { setResult }: Props = $props();
-    // let userType = $state<ResultType>(TYPE_CANCELLED);
+    // let userType = $state<OutroNewUserResultType>(TYPE_CANCELLED);
 </script>
 
 <DialogHeader title="Setup Complete: Preparing to Initialise Server" />

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

@@ -2,9 +2,9 @@
     /**
      * Panel to check and fix CouchDB configuration issues
      */
-    import type { ObsidianLiveSyncSettings } from "../../../../lib/src/common/types";
-    import Decision from "../../../../lib/src/UI/components/Decision.svelte";
-    import UserDecisions from "../../../../lib/src/UI/components/UserDecisions.svelte";
+    import type { ObsidianLiveSyncSettings } from "@lib/common/types";
+    import Decision from "@lib/UI/components/Decision.svelte";
+    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
     import { checkConfig, type ConfigCheckResult, type ResultError, type ResultErrorMessage } from "./utilCheckCouchDB";
     type Props = {
         trialRemoteSetting: ObsidianLiveSyncSettings;

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

@@ -10,29 +10,17 @@
     import InfoNote from "@/lib/src/UI/components/InfoNote.svelte";
     import ExtraItems from "@/lib/src/UI/components/ExtraItems.svelte";
     import Check from "@/lib/src/UI/components/Check.svelte";
-    const TYPE_CANCEL = "cancelled";
+    import {
+        TYPE_CANCEL,
+        TYPE_BACKUP_DONE,
+        TYPE_BACKUP_SKIPPED,
+        TYPE_UNABLE_TO_BACKUP,
+        type RebuildEverythingResult,
+        type ResultTypeBackup,
+    } from "./setupDialogTypes";
 
-    const TYPE_BACKUP_DONE = "backup_done";
-    const TYPE_BACKUP_SKIPPED = "backup_skipped";
-    const TYPE_UNABLE_TO_BACKUP = "unable_to_backup";
-
-    type ResultTypeBackup =
-        | typeof TYPE_BACKUP_DONE
-        | typeof TYPE_BACKUP_SKIPPED
-        | typeof TYPE_UNABLE_TO_BACKUP
-        | typeof TYPE_CANCEL;
-
-    type ResultTypeExtra = {
-        preventFetchingConfig: boolean;
-    };
-    type ResultType =
-        | {
-              backup: ResultTypeBackup;
-              extra: ResultTypeExtra;
-          }
-        | typeof TYPE_CANCEL;
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: RebuildEverythingResult) => void;
     };
     const { setResult }: Props = $props();
 

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

@@ -4,10 +4,10 @@
     import Decision from "@/lib/src/UI/components/Decision.svelte";
     import Instruction from "@/lib/src/UI/components/Instruction.svelte";
     import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
-    const TYPE_CLOSE = "close";
-    type ResultType = typeof TYPE_CLOSE;
+    import { TYPE_CLOSE, type ScanQRCodeResultType } from "./setupDialogTypes";
+
     type Props = {
-        setResult: (_result: ResultType) => void;
+        setResult: (_result: ScanQRCodeResultType) => void;
     };
     const { setResult }: Props = $props();
 </script>

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

@@ -7,19 +7,19 @@
     import Options from "@/lib/src/UI/components/Options.svelte";
     import Instruction from "@/lib/src/UI/components/Instruction.svelte";
     import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
-    import InfoNote from "@/lib/src/UI/components/InfoNote.svelte";
-    import ExtraItems from "@/lib/src/UI/components/ExtraItems.svelte";
-    import Check from "@/lib/src/UI/components/Check.svelte";
-    const TYPE_USE_SETUP_URI = "use-setup-uri";
-    const TYPE_SCAN_QR_CODE = "scan-qr-code";
-    const TYPE_CONFIGURE_MANUALLY = "configure-manually";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_USE_SETUP_URI | typeof TYPE_SCAN_QR_CODE | typeof TYPE_CONFIGURE_MANUALLY | typeof TYPE_CANCELLED;
+    import {
+        TYPE_USE_SETUP_URI,
+        TYPE_SCAN_QR_CODE,
+        TYPE_CONFIGURE_MANUALLY,
+        TYPE_CANCELLED,
+        type SelectMethodExistingResultType,
+    } from "./setupDialogTypes";
+
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: SelectMethodExistingResultType) => void;
     };
     const { setResult }: Props = $props();
-    let userType = $state<ResultType>(TYPE_CANCELLED);
+    let userType = $state<SelectMethodExistingResultType>(TYPE_CANCELLED);
     let proceedTitle = $derived.by(() => {
         if (userType === TYPE_USE_SETUP_URI) {
             return "Proceed with Setup URI";

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

@@ -7,18 +7,18 @@
     import Options from "@/lib/src/UI/components/Options.svelte";
     import Instruction from "@/lib/src/UI/components/Instruction.svelte";
     import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
-    import InfoNote from "@/lib/src/UI/components/InfoNote.svelte";
-    import ExtraItems from "@/lib/src/UI/components/ExtraItems.svelte";
-    import Check from "@/lib/src/UI/components/Check.svelte";
-    const TYPE_USE_SETUP_URI = "use-setup-uri";
-    const TYPE_CONFIGURE_MANUALLY = "configure-manually";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_USE_SETUP_URI | typeof TYPE_CONFIGURE_MANUALLY | typeof TYPE_CANCELLED;
+    import {
+        TYPE_USE_SETUP_URI,
+        TYPE_CONFIGURE_MANUALLY,
+        TYPE_CANCELLED,
+        type SelectMethodNewUserResultType,
+    } from "./setupDialogTypes";
+
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: SelectMethodNewUserResultType) => void;
     };
     const { setResult }: Props = $props();
-    let userType = $state<ResultType>(TYPE_CANCELLED);
+    let userType = $state<SelectMethodNewUserResultType>(TYPE_CANCELLED);
     let proceedTitle = $derived.by(() => {
         if (userType === TYPE_USE_SETUP_URI) {
             return "Proceed with Setup URI";

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

@@ -6,16 +6,19 @@
     import Options from "@/lib/src/UI/components/Options.svelte";
     import Instruction from "@/lib/src/UI/components/Instruction.svelte";
     import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
-    const TYPE_COUCHDB = "couchdb";
-    const TYPE_BUCKET = "bucket";
-    const TYPE_P2P = "p2p";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_COUCHDB | typeof TYPE_BUCKET | typeof TYPE_P2P | typeof TYPE_CANCELLED;
+    import {
+        TYPE_COUCHDB,
+        TYPE_BUCKET,
+        TYPE_P2P,
+        TYPE_CANCELLED,
+        type SetupRemoteResultType,
+    } from "./setupDialogTypes";
+
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: SetupRemoteResultType) => void;
     };
     const { setResult }: Props = $props();
-    let userType = $state<ResultType>(TYPE_CANCELLED);
+    let userType = $state<SetupRemoteResultType>(TYPE_CANCELLED);
     let proceedTitle = $derived.by(() => {
         if (userType === TYPE_COUCHDB) {
             return "Continue to CouchDB setup";

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

@@ -13,19 +13,18 @@
         DEFAULT_SETTINGS,
         PREFERRED_JOURNAL_SYNC,
         RemoteTypes,
-    } from "../../../../lib/src/common/types";
+    } from "@lib/common/types";
 
     import { onMount } from "svelte";
-    import { getDialogContext, type GuestDialogProps } from "../../../../lib/src/UI/svelteDialog";
-    import { copyTo, pickBucketSyncSettings } from "../../../../lib/src/common/utils";
+    import { getDialogContext, type GuestDialogProps } from "@lib/UI/svelteDialog";
+    import { copyTo, pickBucketSyncSettings } from "@lib/common/utils";
+    import { TYPE_CANCELLED, type SetupRemoteBucketResultType } from "./setupDialogTypes";
 
     const default_setting = pickBucketSyncSettings(DEFAULT_SETTINGS);
 
     let syncSetting = $state<BucketSyncSetting>({ ...default_setting });
 
-    type ResultType = typeof TYPE_CANCELLED | BucketSyncSetting;
-    type Props = GuestDialogProps<ResultType, BucketSyncSetting>;
-    const TYPE_CANCELLED = "cancelled";
+    type Props = GuestDialogProps<SetupRemoteBucketResultType, BucketSyncSetting>;
 
     const { setResult, getInitialData }: Props = $props();
 

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

@@ -14,20 +14,19 @@
         RemoteTypes,
         type CouchDBConnection,
         type ObsidianLiveSyncSettings,
-    } from "../../../../lib/src/common/types";
-    import { isCloudantURI } from "../../../../lib/src/pouchdb/utils_couchdb";
+    } from "@lib/common/types";
+    import { isCloudantURI } from "@lib/pouchdb/utils_couchdb";
 
     import { onMount } from "svelte";
-    import { getDialogContext, type GuestDialogProps } from "../../../../lib/src/UI/svelteDialog";
-    import { copyTo, pickCouchDBSyncSettings } from "../../../../lib/src/common/utils";
+    import { getDialogContext, type GuestDialogProps } from "@lib/UI/svelteDialog";
+    import { copyTo, pickCouchDBSyncSettings } from "@lib/common/utils";
     import PanelCouchDBCheck from "./PanelCouchDBCheck.svelte";
+    import { TYPE_CANCELLED, type SetupRemoteCouchDBResultType } from "./setupDialogTypes";
 
     const default_setting = pickCouchDBSyncSettings(DEFAULT_SETTINGS);
 
     let syncSetting = $state<CouchDBConnection>({ ...default_setting });
-    type ResultType = typeof TYPE_CANCELLED | CouchDBConnection;
-    const TYPE_CANCELLED = "cancelled";
-    type Props = GuestDialogProps<ResultType, CouchDBConnection>;
+    type Props = GuestDialogProps<SetupRemoteCouchDBResultType, CouchDBConnection>;
     const { setResult, getInitialData }: Props = $props();
     onMount(() => {
         if (getInitialData) {

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

@@ -12,13 +12,13 @@
         E2EEAlgorithmNames,
         E2EEAlgorithms,
         type EncryptionSettings,
-    } from "../../../../lib/src/common/types";
+    } from "@lib/common/types";
     import { onMount } from "svelte";
-    import type { GuestDialogProps } from "../../../../lib/src/UI/svelteDialog";
-    import { copyTo, pickEncryptionSettings } from "../../../../lib/src/common/utils";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_CANCELLED | EncryptionSettings;
-    type Props = GuestDialogProps<ResultType, EncryptionSettings>;
+    import type { GuestDialogProps } from "@lib/UI/svelteDialog";
+    import { copyTo, pickEncryptionSettings } from "@lib/common/utils";
+    import { TYPE_CANCELLED, type SetupRemoteE2EEResultType } from "./setupDialogTypes";
+
+    type Props = GuestDialogProps<SetupRemoteE2EEResultType, EncryptionSettings>;
     const { setResult, getInitialData }: Props = $props();
     let default_encryption: EncryptionSettings = {
         encrypt: true,

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

@@ -26,16 +26,14 @@
     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 { TYPE_CANCELLED, type SetupRemoteP2PResultType } from "./setupDialogTypes";
 
     const default_setting = pickP2PSyncSettings(DEFAULT_SETTINGS);
     let syncSetting = $state<P2PConnectionInfo>({ ...default_setting });
 
     const context = getDialogContext();
     let error = $state("");
-    const TYPE_CANCELLED = "cancelled";
-    type SettingInfo = P2PConnectionInfo;
-    type ResultType = typeof TYPE_CANCELLED | SettingInfo;
-    type Props = GuestDialogProps<ResultType, P2PSyncSetting>;
+    type Props = GuestDialogProps<SetupRemoteP2PResultType, P2PSyncSetting>;
 
     const { setResult, getInitialData }: Props = $props();
     onMount(() => {

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

@@ -1,6 +1,6 @@
 <script lang="ts">
-    import { configURIBase } from "../../../../common/types";
-    import type { ObsidianLiveSyncSettings } from "../../../../lib/src/common/types";
+    import { configURIBase } from "@/common/types";
+    import type { ObsidianLiveSyncSettings } from "@lib/common/types";
     import DialogHeader from "@/lib/src/UI/components/DialogHeader.svelte";
     import Guidance from "@/lib/src/UI/components/Guidance.svelte";
     import Decision from "@/lib/src/UI/components/Decision.svelte";
@@ -10,11 +10,11 @@
     import Password from "@/lib/src/UI/components/Password.svelte";
 
     import { onMount } from "svelte";
-    import { decryptString } from "../../../../lib/src/encryption/stringEncryption.ts";
-    import type { GuestDialogProps } from "../../../../lib/src/UI/svelteDialog.ts";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_CANCELLED | ObsidianLiveSyncSettings;
-    type Props = GuestDialogProps<ResultType, string>;
+    import { decryptString } from "@lib/encryption/stringEncryption.ts";
+    import type { GuestDialogProps } from "@lib/UI/svelteDialog.ts";
+    import { TYPE_CANCELLED, type UseSetupURIResultType } from "./setupDialogTypes";
+
+    type Props = GuestDialogProps<UseSetupURIResultType, string>;
     const { setResult, getInitialData }: Props = $props();
 
     let setupURI = $state("");

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

@@ -0,0 +1,108 @@
+import type {
+    BucketSyncSetting,
+    CouchDBConnection,
+    EncryptionSettings,
+    ObsidianLiveSyncSettings,
+    P2PConnectionInfo,
+} from "@lib/common/models/setting.type";
+
+export const TYPE_IDENTICAL = "identical";
+export const TYPE_INDEPENDENT = "independent";
+export const TYPE_UNBALANCED = "unbalanced";
+export const TYPE_CANCEL = "cancelled";
+
+export const TYPE_BACKUP_DONE = "backup_done";
+export const TYPE_BACKUP_SKIPPED = "backup_skipped";
+export const TYPE_UNABLE_TO_BACKUP = "unable_to_backup";
+
+// Intro
+export const TYPE_NEW_USER = "new-user";
+export const TYPE_EXISTING_USER = "existing-user";
+export const TYPE_CANCELLED = "cancelled";
+
+// Outro ask user mode
+export const TYPE_EXISTING = "existing-user";
+export const TYPE_NEW = "new-user";
+export const TYPE_COMPATIBLE_EXISTING = "compatible-existing-user";
+
+// OutroExistingUser
+export const TYPE_APPLY = "apply";
+
+// Select methods
+export const TYPE_USE_SETUP_URI = "use-setup-uri";
+export const TYPE_SCAN_QR_CODE = "scan-qr-code";
+export const TYPE_CONFIGURE_MANUALLY = "configure-manually";
+
+// ScanQRCode
+export const TYPE_CLOSE = "close";
+
+// SetupRemote
+export const TYPE_COUCHDB = "couchdb";
+export const TYPE_BUCKET = "bucket";
+export const TYPE_P2P = "p2p";
+
+export type ResultTypeVault =
+    | typeof TYPE_IDENTICAL
+    | typeof TYPE_INDEPENDENT
+    | typeof TYPE_UNBALANCED
+    | typeof TYPE_CANCEL;
+export type ResultTypeBackup =
+    | typeof TYPE_BACKUP_DONE
+    | typeof TYPE_BACKUP_SKIPPED
+    | typeof TYPE_UNABLE_TO_BACKUP
+    | typeof TYPE_CANCEL;
+
+export type ResultTypeExtra = {
+    preventFetchingConfig: boolean;
+};
+export type FetchEverythingResult =
+    | {
+          vault: ResultTypeVault;
+          backup: ResultTypeBackup;
+          extra: ResultTypeExtra;
+      }
+    | typeof TYPE_CANCEL;
+
+export type RebuildEverythingResult =
+    | {
+          backup: ResultTypeBackup;
+          extra: ResultTypeExtra;
+      }
+    | typeof TYPE_CANCEL;
+
+export type IntroResultType = typeof TYPE_NEW_USER | typeof TYPE_EXISTING_USER | typeof TYPE_CANCELLED;
+
+export type OutroAskUserModeResultType =
+    | typeof TYPE_EXISTING
+    | typeof TYPE_NEW
+    | typeof TYPE_COMPATIBLE_EXISTING
+    | typeof TYPE_CANCELLED;
+
+export type OutroExistingUserResultType = typeof TYPE_APPLY | typeof TYPE_CANCELLED;
+
+export type OutroNewUserResultType = typeof TYPE_APPLY | typeof TYPE_CANCELLED;
+
+export type SelectMethodNewUserResultType =
+    | typeof TYPE_USE_SETUP_URI
+    | typeof TYPE_CONFIGURE_MANUALLY
+    | typeof TYPE_CANCELLED;
+
+export type SelectMethodExistingResultType =
+    | typeof TYPE_USE_SETUP_URI
+    | typeof TYPE_SCAN_QR_CODE
+    | typeof TYPE_CONFIGURE_MANUALLY
+    | typeof TYPE_CANCELLED;
+
+export type SetupRemoteResultType = typeof TYPE_COUCHDB | typeof TYPE_BUCKET | typeof TYPE_P2P | typeof TYPE_CANCELLED;
+
+export type UseSetupURIResultType = typeof TYPE_CANCELLED | ObsidianLiveSyncSettings;
+
+export type SetupRemoteE2EEResultType = typeof TYPE_CANCELLED | EncryptionSettings;
+
+export type SetupRemoteBucketResultType = typeof TYPE_CANCELLED | BucketSyncSetting;
+
+export type SetupRemoteCouchDBResultType = typeof TYPE_CANCELLED | CouchDBConnection;
+
+export type SetupRemoteP2PResultType = typeof TYPE_CANCELLED | P2PConnectionInfo;
+
+export type ScanQRCodeResultType = typeof TYPE_CLOSE;

src/modules/main/ModuleLiveSyncMain.ts

@@ -13,6 +13,8 @@ import { AbstractModule } from "../AbstractModule.ts";
 import type { InjectableServiceHub } from "@lib/services/implements/injectable/InjectableServiceHub.ts";
 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";
 
 export class ModuleLiveSyncMain extends AbstractModule {
     async _onLiveSyncReady() {
@@ -89,11 +91,6 @@ export class ModuleLiveSyncMain extends AbstractModule {
             return false;
         }
         // this.addUIs();
-        //@ts-ignore
-        const manifestVersion: string = MANIFEST_VERSION || "0.0.0";
-        //@ts-ignore
-        const packageVersion: string = PACKAGE_VERSION || "0.0.0";
-
         this._log($msg("moduleLiveSyncMain.logPluginVersion", { manifestVersion, packageVersion }));
         await this.services.setting.loadSettings();
         if (!(await this.services.appLifecycle.onSettingLoaded())) {
@@ -101,7 +98,7 @@ export class ModuleLiveSyncMain extends AbstractModule {
             return false;
         }
         const lsKey = "obsidian-live-sync-ver" + this.services.vault.getVaultName();
-        const last_version = localStorage.getItem(lsKey);
+        const last_version = compatGlobal.localStorage.getItem(lsKey);
 
         const lastVersion = ~~(versionNumberString2Number(manifestVersion) / 1000);
         if (lastVersion > this.settings.lastReadUpdates && this.settings.isConfigured) {
@@ -123,7 +120,7 @@ export class ModuleLiveSyncMain extends AbstractModule {
             this.settings.versionUpFlash = $msg("moduleLiveSyncMain.logVersionUpdate");
             await this.saveSettings();
         }
-        localStorage.setItem(lsKey, `${VER}`);
+        compatGlobal.localStorage.setItem(lsKey, `${VER}`);
         await this.services.database.openDatabase({
             databaseEvents: this.services.databaseEvents,
             replicator: this.services.replicator,
@@ -133,7 +130,7 @@ export class ModuleLiveSyncMain extends AbstractModule {
         // this.$$replicate = this.$$replicate.bind(this);
         // this.core.$$onLiveSyncReady = this.core.$$onLiveSyncReady.bind(this);
         await this.core.services.appLifecycle.onLoaded();
-        await Promise.all(this.core.addOns.map((e) => e.onload()));
+        await Promise.all(this.core.addOns.map((e) => Promise.resolve(e.onload())));
         return true;
     }
 

src/modules/services/ObsidianAPIService.ts

@@ -5,9 +5,17 @@ import { ObsHttpHandler } from "../essentialObsidian/APILib/ObsHttpHandler";
 import { ObsidianConfirm } from "./ObsidianConfirm";
 import type { Confirm } from "@lib/interfaces/Confirm";
 import { requestUrl, type RequestUrlParam } from "@/deps";
+import { compatGlobal } from "@/lib/src/common/coreEnvFunctions";
 // All Services will be migrated to be based on Plain Services, not Injectable Services.
 // This is a migration step.
 
+declare module "obsidian" {
+    interface App {
+        appId?: string;
+        isMobile?: boolean;
+    }
+}
+
 export class ObsidianAPIService extends InjectableAPIService<ObsidianServiceContext> {
     _customHandler: ObsHttpHandler | undefined;
     _confirmInstance: Confirm;
@@ -83,8 +91,7 @@ export class ObsidianAPIService extends InjectableAPIService<ObsidianServiceCont
         }
     }
     override isMobile(): boolean {
-        //@ts-ignore : internal API
-        return this.app.isMobile;
+        return "isMobile" in this.app ? !!this.app.isMobile : false;
     }
     override getAppID(): string {
         return `${"appId" in this.app ? this.app.appId : ""}`;
@@ -95,7 +102,7 @@ export class ObsidianAPIService extends InjectableAPIService<ObsidianServiceCont
     }
 
     override getAppVersion(): string {
-        const navigatorString = globalThis.navigator?.userAgent ?? "";
+        const navigatorString = compatGlobal.navigator?.userAgent ?? "";
         const match = navigatorString.match(/obsidian\/([0-9]+\.[0-9]+\.[0-9]+)/);
         if (match && match.length >= 2) {
             return match[1];
@@ -196,7 +203,7 @@ export class ObsidianAPIService extends InjectableAPIService<ObsidianServiceCont
     }
 
     override setInterval(handler: () => void, timeout: number): number {
-        const timerId = globalThis.setInterval(handler, timeout) as unknown as number;
+        const timerId = compatGlobal.setInterval(handler, timeout);
         this.context.plugin.registerInterval(timerId);
         return timerId;
     }

src/modules/services/ObsidianSettingService.ts

@@ -1,3 +1,4 @@
+import { compatGlobal } from "@/lib/src/common/coreEnvFunctions";
 import { type ObsidianLiveSyncSettings } from "@lib/common/types";
 import { EVENT_REQUEST_RELOAD_SETTING_TAB, EVENT_SETTING_SAVED } from "@lib/events/coreEvents";
 import { eventHub } from "@lib/hub/hub";
@@ -17,13 +18,16 @@ export class ObsidianSettingService<T extends ObsidianServiceContext> extends Se
         });
     }
     protected setItem(key: string, value: string) {
-        return localStorage.setItem(key, value);
+        // TODO: Implement nativeLocalStorage.
+        return compatGlobal.localStorage.setItem(key, value);
     }
     protected getItem(key: string): string {
-        return localStorage.getItem(key) ?? "";
+        // TODO: Implement nativeLocalStorage.
+        return compatGlobal.localStorage.getItem(key) ?? "";
     }
     protected deleteItem(key: string): void {
-        localStorage.removeItem(key);
+        // TODO: Implement nativeLocalStorage.
+        compatGlobal.localStorage.removeItem(key);
     }
 
     protected override async saveData(data: ObsidianLiveSyncSettings): Promise<void> {

src/serviceFeatures/redFlag.ts

@@ -8,6 +8,10 @@ import { extractObject } from "octagonal-wheels/object";
 import { REMOTE_MINIO, REMOTE_P2P } from "@lib/common/models/setting.const";
 import type { ObsidianLiveSyncSettings } from "@lib/common/models/setting.type";
 import { TweakValuesShouldMatchedTemplate } from "@lib/common/models/tweak.definition";
+import type {
+    FetchEverythingResult,
+    RebuildEverythingResult,
+} from "@/modules/features/SetupWizard/dialogs/setupDialogTypes";
 
 /**
  * Flag file handler interface, similar to target filter pattern.
@@ -65,7 +69,8 @@ export function createFetchAllFlagHandler(
 
     // Handle the fetch all scheduled operation
     const onScheduled = async () => {
-        const method = await host.services.UI.dialogManager.openWithExplicitCancel(FetchEverything);
+        const method =
+            await host.services.UI.dialogManager.openWithExplicitCancel<FetchEverythingResult>(FetchEverything);
         if (method === "cancelled") {
             log("Fetch everything cancelled by user.", LOG_LEVEL_NOTICE);
             await cleanupFlag();
@@ -73,7 +78,7 @@ export function createFetchAllFlagHandler(
             return false;
         }
         const { vault, extra } = method;
-        const settings = await host.services.setting.currentSettings();
+        const settings = await Promise.resolve(host.services.setting.currentSettings());
         // If remote is MinIO, makeLocalChunkBeforeSync is not available. (because no-deduplication on sending).
         const makeLocalChunkBeforeSyncAvailable = settings.remoteType !== REMOTE_MINIO;
         const mapVaultStateToAction = {
@@ -296,7 +301,8 @@ export function createRebuildFlagHandler(
 
     // Handle the rebuild everything scheduled operation
     const onScheduled = async () => {
-        const method = await host.services.UI.dialogManager.openWithExplicitCancel(RebuildEverything);
+        const method =
+            await host.services.UI.dialogManager.openWithExplicitCancel<RebuildEverythingResult>(RebuildEverything);
         if (method === "cancelled") {
             log("Rebuild everything cancelled by user.", LOG_LEVEL_NOTICE);
             await cleanupFlag();

styles.css

@@ -17,6 +17,10 @@
     min-width: 5em;
 }
 
+.conflict-action-button {
+    margin-right: 4px;
+}
+
 .op-scrollable {
     overflow-y: scroll;
     /* min-height: 280px; */
@@ -167,7 +171,7 @@ body {
 
 .sls-setting-menu-buttons {
     border: 1px solid var(--sls-col-warn);
-    padding: 2px;
+    /* padding: 2px; */
     margin: 1px;
     border-radius: 4px;
     background-image: linear-gradient(-45deg,
@@ -176,7 +180,7 @@ body {
     background-size: 30px 30px;
     display: flex;
     flex-direction: row;
-    justify-content: flex-end;
+    /* justify-content: flex-end; */
     padding: 0.5em 0.25em;
     justify-content: center;
     align-items: center;
@@ -311,9 +315,9 @@ body {
 
 
 .sls-setting-obsolete {
-    background-image: linear-gradient(-45deg,
+    /* background-image: linear-gradient(-45deg,
             var(--sls-col-warn-stripe1) 25%, var(--sls-col-warn-stripe2) 25%, var(--sls-col-warn-stripe2) 50%,
-            var(--sls-col-warn-stripe1) 50%, var(--sls-col-warn-stripe1) 75%, var(--sls-col-warn-stripe2) 75%, var(--sls-col-warn-stripe2));
+            var(--sls-col-warn-stripe1) 50%, var(--sls-col-warn-stripe1) 75%, var(--sls-col-warn-stripe2) 75%, var(--sls-col-warn-stripe2)); */
     background-image: linear-gradient(-45deg,
             transparent 25%, rgba(var(--background-secondary), 0.1) 25%, rgba(var(--background-secondary), 0.1) 50%, transparent 50%, transparent 75%, rgba(var(--background-secondary), 0.1) 75%, rgba(var(--background-secondary), 0.1));
     background-size: 60px 60px;
@@ -521,8 +525,48 @@ div.workspace-leaf-content[data-type=bases]  .livesync-status {
     text-align: center;
 }
 
+.diff-only-label {
+    margin-left: 10px;
+}
+
+.history-search-row {
+    display: flex;
+    gap: 5px;
+    align-items: center;
+    margin-bottom: 10px;
+}
+
+.history-search-input {
+    flex-grow: 1;
+}
+
+.history-search-result-indicator {
+    font-size: 0.8em;
+    min-width: 80px;
+}
+
+.history-search-progress-indicator {
+    font-size: 0.8em;
+    color: var(--text-muted);
+}
+
+.history-diff-options-row {
+    justify-content: space-between;
+}
+
+.history-highlight-diff-container,
+.history-highlight-diff-label {
+    display: flex;
+    align-items: center;
+}
+
+.history-highlight-diff-label {
+    gap: 4px;
+}
+
 .diff-focused {
     outline: 2px solid var(--interactive-accent);
     outline-offset: 1px;
     border-radius: 2px;
-}
+}
+

tsconfig.json

@@ -2,7 +2,6 @@
     "extends": "@tsconfig/svelte/tsconfig.json",
     "inlineSourceMap": true,
     "compilerOptions": {
-        "baseUrl": ".",
         "module": "ESNext",
         "target": "ES2018",
         "allowJs": true,
@@ -20,8 +19,8 @@
         "strictBindCallApply": true,
         "strictFunctionTypes": true,
         "paths": {
-            "@/*": ["src/*"],
-            "@lib/*": ["src/lib/src/*"]
+            "@/*": ["./src/*"],
+            "@lib/*": ["./src/lib/src/*"]
         }
     },
     "include": ["**/*.ts", "test/**/*.test.ts", "**/*.unit.spec.ts"],

updates.md

@@ -3,6 +3,57 @@ Since 19th July, 2025 (beta1 in 0.25.0-beta1, 13th July, 2025)
 
 The head note of 0.25 is now in [updates_old.md](https://github.com/vrtmrz/obsidian-livesync/blob/main/updates_old.md). Because 0.25 got a lot of updates, thankfully, compatibility is kept and we do not need breaking changes! In other words, when get enough stabled. The next version will be v1.0.0. Even though it my hope.
 
+## 0.25.70-patch2
+
+1st June, 2026
+
+### Fixed
+- No longer the status element breaks other plugins' interaction (#930).
+
+## 0.25.70-patch1
+
+1st June, 2026
+
+This release does not include any changes to behaviour (if everything is as intended).
+However, this release had addressed a large number of errors and potential issues caused by the switch to a modern ESLint configuration, as well as unintended log output.
+I have also separated out some parts where the type definitions were a bit loose.
+
+As the diff has become too large, I am releasing it as a beta.
+To anyone who has submitted a pull request, please bear with me for a little while.
+
+### Refactored
+
+- Many 
+
+## 0.25.70
+
+25th May, 2026
+
+### New features
+- Diff dialogue now has great tools to navigate and understand the differences, including:
+  - A checkbox to toggle the visibility of collapsed identical sections, making it easier to focus on the actual differences (PR #889).
+  - A search feature to find specific text in past revisions, and navigate revisions with search results highlighted in the dialogue (PR #890).
+
+- Conflict resolution dialogue now has a navigation feature to jump between conflicts (PR #891).
+
+Thank you so much to @SeleiXi for implementing these features!
+
+### Improved
+
+- More diagnostic information for P2P connections is now shown, including why a connection failure occurred and the current connection status.
+
+## 0.25.69
+
+22nd May, 2026
+
+### Fixed
+- No longer does the P2P passphrase mismatch cause a server shutdown.
+- Settings related to P2P synchronisation are now correctly applied on start-up and no longer reverted.
+
+### New features
+- Diagnostic P2P connection stats are now available.
+  - These stats indicate the number of connection trials, successes, and failures.
+
 ## 0.25.68
 
 22nd May, 2026