Merge tag '0.24.0.dev-rc8'

src/modules/AbstractModule.ts

@@ -0,0 +1,183 @@
+import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
+import type { LOG_LEVEL } from "../lib/src/common/types";
+import type { LiveSyncCore } from "../main";
+import { unique } from "octagonal-wheels/collection";
+import type { IObsidianModule } from "./AbstractObsidianModule.ts";
+import type { ICoreModuleBase, AllInjectableProps, AllExecuteProps, EveryExecuteProps, AnyExecuteProps, ICoreModule } from "./ModuleTypes";
+
+
+function isOverridableKey(key: string): key is keyof ICoreModuleBase {
+    return key.startsWith("$");
+}
+
+function isInjectableKey(key: string): key is keyof AllInjectableProps {
+    return key.startsWith("$$");
+}
+
+
+function isAllExecuteKey(key: string): key is keyof AllExecuteProps {
+    return key.startsWith("$all");
+}
+function isEveryExecuteKey(key: string): key is keyof EveryExecuteProps {
+    return key.startsWith("$every");
+}
+function isAnyExecuteKey(key: string): key is keyof AnyExecuteProps {
+    return key.startsWith("$any");
+}
+/**
+ * All $prefixed functions are hooked by the modules. Be careful to call them directly.
+ * Please refer to the module's source code to understand the function.
+ * $$     : Completely overridden functions.
+ * $all   : Process all modules and return all results.
+ * $every : Process all modules until the first failure.
+ * $any   : Process all modules until the first success.
+ * $      : Other interceptive points. You should manually assign the module
+ * All of above performed on injectModules function.
+ */
+export function injectModules<T extends ICoreModule>(target: T, modules: ICoreModule[]) {
+    const allKeys = unique([...Object.keys(Object.getOwnPropertyDescriptors(target)),
+    ...Object.keys(Object.getOwnPropertyDescriptors(Object.getPrototypeOf(target)))]).filter(e => e.startsWith("$")) as (keyof ICoreModule)[];
+    const moduleMap = new Map<string, IObsidianModule[]>();
+    for (const module of modules) {
+        for (const key of allKeys) {
+            if (isOverridableKey(key)) {
+                if (key in module) {
+                    const list = moduleMap.get(key) || [];
+                    if (typeof module[key] === 'function') {
+                        module[key] = module[key].bind(module) as any;
+                    }
+                    list.push(module);
+                    moduleMap.set(key, list);
+                }
+            }
+        }
+    }
+    Logger(`Injecting modules for ${target.constructor.name}`, LOG_LEVEL_VERBOSE);
+    for (const key of allKeys) {
+        const modules = moduleMap.get(key) || [];
+        if (isInjectableKey(key)) {
+            if (modules.length == 0) {
+                throw new Error(`No module injected for ${key}. This is a fatal error.`);
+            }
+            target[key] = modules[0][key]! as any;
+            Logger(`[${modules[0].constructor.name}]: Injected ${key} `, LOG_LEVEL_VERBOSE);
+        } else if (isAllExecuteKey(key)) {
+            const modules = moduleMap.get(key) || [];
+            target[key] = async (...args: any) => {
+                for (const module of modules) {
+                    try {
+                        //@ts-ignore
+                        await module[key]!(...args);
+                    } catch (ex) {
+                        Logger(`[${module.constructor.name}]: All handler for ${key} failed`, LOG_LEVEL_VERBOSE);
+                        Logger(ex, LOG_LEVEL_VERBOSE);
+                    }
+                }
+                return true;
+            }
+            for (const module of modules) {
+                Logger(`[${module.constructor.name}]: Injected (All) ${key} `, LOG_LEVEL_VERBOSE);
+            }
+        } else if (isEveryExecuteKey(key)) {
+            target[key] = async (...args: any) => {
+                for (const module of modules) {
+                    try {
+                        //@ts-ignore:2556
+                        const ret = await module[key]!(...args);
+                        if (ret !== undefined && !ret) {
+                            // Failed then return that falsy value.
+                            return ret;
+                        }
+                    } catch (ex) {
+                        Logger(`[${module.constructor.name}]: Every handler for ${key} failed`);
+                        Logger(ex, LOG_LEVEL_VERBOSE);
+                    }
+                }
+                return true;
+            }
+            for (const module of modules) {
+                Logger(`[${module.constructor.name}]: Injected (Every) ${key} `, LOG_LEVEL_VERBOSE);
+            }
+        } else if (isAnyExecuteKey(key)) {
+            //@ts-ignore
+            target[key] = async (...args: any[]) => {
+                for (const module of modules) {
+                    try {
+                        //@ts-ignore:2556
+                        const ret = await module[key](...args);
+                        // If truly value returned, then return that value.
+                        if (ret) {
+                            return ret;
+                        }
+                    } catch (ex) {
+                        Logger(`[${module.constructor.name}]: Any handler for ${key} failed`);
+                        Logger(ex, LOG_LEVEL_VERBOSE);
+                    }
+                }
+                return false;
+            }
+            for (const module of modules) {
+                Logger(`[${module.constructor.name}]: Injected (Any) ${key} `, LOG_LEVEL_VERBOSE);
+            }
+        } else {
+            Logger(`No injected handler for ${key} `, LOG_LEVEL_VERBOSE);
+        }
+    }
+    Logger(`Injected   modules for ${target.constructor.name}`, LOG_LEVEL_VERBOSE);
+    return true;
+}
+
+
+export abstract class AbstractModule {
+    _log = (msg: any, level: LOG_LEVEL = LOG_LEVEL_INFO, key?: string) => {
+        if (typeof msg === "string" && level !== LOG_LEVEL_NOTICE) {
+            msg = `[${this.constructor.name}]\u{200A} ${msg}`;
+        }
+        // console.log(msg);
+        Logger(msg, level, key);
+    };
+
+    get localDatabase() {
+        return this.core.localDatabase;
+    }
+    get settings() {
+        return this.core.settings;
+    }
+    set settings(value) {
+        this.core.settings = value;
+    }
+
+    constructor(public core: LiveSyncCore) {
+        Logger(`[${this.constructor.name}] Loaded`, LOG_LEVEL_VERBOSE);
+    }
+    saveSettings = this.core.saveSettings.bind(this.core);
+
+    // abstract $everyTest(): Promise<boolean>;
+    addTestResult(key: string, value: boolean, summary?: string, message?: string) {
+        this.core.$$addTestResult(`${this.constructor.name}`, key, value, summary, message);
+    }
+    testDone(result: boolean = true) {
+        return Promise.resolve(result);
+    }
+    testFail(message: string) {
+        this._log(message, LOG_LEVEL_NOTICE);
+        return this.testDone(false);
+    }
+
+    async _test(key: string, process: () => Promise<any>) {
+        this._log(`Testing ${key}`, LOG_LEVEL_VERBOSE);
+        try {
+            const ret = await process();
+            if (ret !== true) {
+                this.addTestResult(key, false, ret.toString());
+                return this.testFail(`${key} failed: ${ret}`);
+            }
+            this.addTestResult(key, true, "");
+        }
+        catch (ex: any) {
+            this.addTestResult(key, false, "Failed by Exception", ex.toString());
+            return this.testFail(`${key} failed: ${ex}`);
+        }
+        return this.testDone();
+    }
+}

src/modules/AbstractObsidianModule.ts

@@ -0,0 +1,55 @@
+import { type Prettify } from "../lib/src/common/types";
+import type { LiveSyncCore } from "../main";
+import type ObsidianLiveSyncPlugin from "../main";
+import { AbstractModule } from "./AbstractModule.ts";
+import type { ChainableExecuteFunction, OverridableFunctionsKeys } from "./ModuleTypes";
+
+
+export type IObsidianModuleBase = OverridableFunctionsKeys<ObsidianLiveSyncPlugin>;
+export type IObsidianModule = Prettify<Partial<IObsidianModuleBase>>
+export type ModuleKeys = keyof IObsidianModule;
+export type ChainableModuleProps = ChainableExecuteFunction<ObsidianLiveSyncPlugin>;
+
+
+export abstract class AbstractObsidianModule extends AbstractModule {
+
+    addCommand = this.plugin.addCommand.bind(this.plugin);
+    registerView = this.plugin.registerView.bind(this.plugin);
+    addRibbonIcon = this.plugin.addRibbonIcon.bind(this.plugin);
+    registerObsidianProtocolHandler = this.plugin.registerObsidianProtocolHandler.bind(this.plugin);
+
+    get localDatabase() {
+        return this.plugin.localDatabase;
+    }
+    get settings() {
+        return this.plugin.settings;
+    }
+    set settings(value) {
+        this.plugin.settings = value;
+    }
+    get app() {
+        return this.plugin.app;
+    }
+
+    constructor(public plugin: ObsidianLiveSyncPlugin, public core: LiveSyncCore) {
+        super(core);
+    }
+
+    saveSettings = this.plugin.saveSettings.bind(this.plugin);
+
+
+    _isMainReady() {
+        return this.core._isMainReady();
+    }
+    _isMainSuspended() {
+        return this.core._isMainSuspended();
+    }
+    _isDatabaseReady() {
+        return this.core._isDatabaseReady();
+    }
+
+    //should be overridden
+    _isThisModuleEnabled() {
+        return true
+    }
+}

src/modules/ModuleTypes.ts

@@ -0,0 +1,40 @@
+import type { Prettify } from "../lib/src/common/types";
+import type { LiveSyncCore } from "../main";
+
+
+export type OverridableFunctionsKeys<T> = {
+    [K in keyof T as K extends `$${string}` ? K : never]: T[K];
+}
+
+export type ChainableExecuteFunction<T> = {
+    [K in keyof T as K extends `$${string}` ? (T[K] extends (...args: any) => ChainableFunctionResult ? K : never) : never]: T[K];
+}
+
+export type ICoreModuleBase = OverridableFunctionsKeys<LiveSyncCore>;
+export type ICoreModule = Prettify<Partial<ICoreModuleBase>>
+export type CoreModuleKeys = keyof ICoreModule;
+
+export type ChainableFunctionResult =
+    Promise<boolean | undefined | string>
+    | Promise<boolean | undefined>
+    | Promise<boolean>
+    | Promise<void>;
+export type ChainableFunctionResultOrAll = Promise<boolean | undefined | string | void>;
+
+type AllExecuteFunction<T> = {
+    [K in keyof T as K extends `$all${string}` ? (T[K] extends (...args: any[]) => ChainableFunctionResultOrAll ? K : never) : never]: T[K];
+}
+type EveryExecuteFunction<T> = {
+    [K in keyof T as K extends `$every${string}` ? (T[K] extends (...args: any[]) => ChainableFunctionResult ? K : never) : never]: T[K];
+}
+type AnyExecuteFunction<T> = {
+    [K in keyof T as K extends `$any${string}` ? (T[K] extends (...args: any[]) => ChainableFunctionResult ? K : never) : never]: T[K];
+}
+type InjectableFunction<T> = {
+    [K in keyof T as K extends `$$${string}` ? (T[K] extends (...args: any[]) => any ? K : never) : never]: T[K];
+}
+export type AllExecuteProps = AllExecuteFunction<LiveSyncCore>;
+export type EveryExecuteProps = EveryExecuteFunction<LiveSyncCore>;
+export type AnyExecuteProps = AnyExecuteFunction<LiveSyncCore>;
+
+export type AllInjectableProps = InjectableFunction<LiveSyncCore>;

src/modules/core/ModuleDatabaseFileAccess.ts

@@ -0,0 +1,262 @@
+import { LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { EVENT_FILE_SAVED, eventHub } from "../../common/events";
+import { getPathFromUXFileInfo, isInternalMetadata, markChangesAreSame } from "../../common/utils";
+import type { UXFileInfoStub, FilePathWithPrefix, UXFileInfo, MetaEntry, LoadedEntry, FilePath, SavingEntry } from "../../lib/src/common/types";
+import type { DatabaseFileAccess } from "../interfaces/DatabaseFileAccess";
+import { type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { isPlainText, shouldBeIgnored } from "../../lib/src/string_and_binary/path";
+import { createBlob, createTextBlob, delay, determineTypeFromBlob, isDocContentSame, readContent } from "../../lib/src/common/utils";
+import { serialized } from "octagonal-wheels/concurrency/lock";
+import { AbstractModule } from "../AbstractModule.ts";
+
+
+export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidianModule, DatabaseFileAccess {
+    $everyOnload(): Promise<boolean> {
+        this.core.databaseFileAccess = this;
+        return Promise.resolve(true);
+    }
+
+    async $everyModuleTest(): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        const testString = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam nec purus nec nunc"
+        // Before test, we need to delete completely.
+        const conflicts = await this.getConflictedRevs("autoTest.md" as FilePathWithPrefix);
+        for (const rev of conflicts) {
+            await this.delete("autoTest.md" as FilePathWithPrefix, rev);
+        }
+        await this.delete("autoTest.md" as FilePathWithPrefix);
+        // OK, begin!
+
+        await this._test("storeContent", async () => (await this.storeContent("autoTest.md" as FilePathWithPrefix, testString)));
+        // For test, we need to clear the caches.
+        await this.localDatabase.hashCaches.clear();
+        await this._test("readContent", async () => {
+            const content = await this.fetch("autoTest.md" as FilePathWithPrefix);
+            if (!content) return "File not found";
+            if (content.deleted) return "File is deleted";
+            return (await content.body.text() == testString) ? true : `Content is not same ${await content.body.text()}`;
+        });
+        await this._test("delete", async () => (await this.delete("autoTest.md" as FilePathWithPrefix)));
+        await this._test("read deleted content", async () => {
+            const content = await this.fetch("autoTest.md" as FilePathWithPrefix);
+            if (!content) return true;
+            if (content.deleted) return true;
+            return `Still exist !:${await content.body.text()},${JSON.stringify(content, undefined, 2)}`;
+        });
+        await delay(100);
+        return this.testDone();
+    }
+
+    async checkIsTargetFile(file: UXFileInfoStub | FilePathWithPrefix): Promise<boolean> {
+        const path = getPathFromUXFileInfo(file);
+        if (!await this.core.$$isTargetFile(path)) {
+            this._log(`File is not target`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        if (shouldBeIgnored(path)) {
+            this._log(`File should be ignored`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        return true;
+    }
+
+    async delete(file: UXFileInfoStub | FilePathWithPrefix, rev?: string): Promise<boolean> {
+        if (!await this.checkIsTargetFile(file)) {
+            return true;
+        }
+        const fullPath = getPathFromUXFileInfo(file);
+        try {
+            this._log(`deleteDB By path:${fullPath}`);
+            return await this.deleteFromDBbyPath(fullPath, rev);
+        } catch (ex) {
+            this._log(`Failed to delete ${fullPath}`);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+    }
+
+    async createChunks(file: UXFileInfo, force: boolean = false, skipCheck?: boolean): Promise<boolean> {
+        return await this._store(file, force, skipCheck, true);
+    }
+
+    async store(file: UXFileInfo, force: boolean = false, skipCheck?: boolean): Promise<boolean> {
+        return await this._store(file, force, skipCheck, false);
+    }
+    async storeContent(path: FilePathWithPrefix, content: string): Promise<boolean> {
+        const blob = createTextBlob(content);
+        const bytes = (await blob.arrayBuffer()).byteLength;
+        const dummyUXFileInfo: UXFileInfo = {
+            name: path.split("/").pop() as string,
+            path: path,
+            stat: {
+                size: bytes,
+                ctime: Date.now(),
+                mtime: Date.now(),
+                type: "file",
+            },
+            body: blob,
+        }
+        return await this._store(dummyUXFileInfo, true, false, false);
+    }
+
+    async _store(file: UXFileInfo, force: boolean = false, skipCheck?: boolean, onlyChunks?: boolean): Promise<boolean> {
+        if (!skipCheck) {
+            if (!await this.checkIsTargetFile(file)) {
+                return true;
+            }
+        }
+        if (!file) {
+            this._log("File seems bad", LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        const path = getPathFromUXFileInfo(file);
+
+        const isPlain = isPlainText(file.name);
+        const possiblyLarge = !isPlain;
+        const content = file.body;
+        if (possiblyLarge) this._log(`Processing: ${path}`, LOG_LEVEL_VERBOSE);
+        const datatype = determineTypeFromBlob(content);
+        const fullPath = file.path;
+        const id = await this.core.$$path2id(fullPath);
+        const d: SavingEntry = {
+            _id: id,
+            path: file.path,
+            data: content,
+            ctime: file.stat.ctime,
+            mtime: file.stat.mtime,
+            size: file.stat.size,
+            children: [],
+            datatype: datatype,
+            type: datatype,
+            eden: {},
+        };
+        //upsert should locked
+        const msg = `STORAGE -> DB (${datatype}) `;
+        const isNotChanged = await serialized("file-" + fullPath, async () => {
+            // Commented out temporarily: this checks that the file was made ourself.
+            // if (this.core.storageAccess.recentlyTouched(file)) {
+            //     return true;
+            // }
+            try {
+                const old = await this.localDatabase.getDBEntry(fullPath, undefined, false, true, false);
+                if (old !== false) {
+                    const oldData = { data: old.data, deleted: old._deleted || old.deleted };
+                    const newData = { data: d.data, deleted: d._deleted || d.deleted };
+                    if (oldData.deleted != newData.deleted) return false;
+                    if (!await isDocContentSame(old.data, newData.data)) return false;
+                    this._log(msg + "Skipped (not changed) " + fullPath + ((d._deleted || d.deleted) ? " (deleted)" : ""), LOG_LEVEL_VERBOSE);
+                    markChangesAreSame(old, d.mtime, old.mtime);
+                    return true;
+                    // d._rev = old._rev;
+                }
+            } catch (ex) {
+                if (force) {
+                    this._log(msg + "Error, Could not check the diff for the old one." + (force ? "force writing." : "") + fullPath + ((d._deleted || d.deleted) ? " (deleted)" : ""), LOG_LEVEL_VERBOSE);
+                } else {
+                    this._log(msg + "Error, Could not check the diff for the old one." + fullPath + ((d._deleted || d.deleted) ? " (deleted)" : ""), LOG_LEVEL_VERBOSE);
+                }
+                this._log(ex, LOG_LEVEL_VERBOSE);
+                return !force;
+            }
+            return false;
+        });
+        if (isNotChanged) {
+            this._log(msg + " Skip " + fullPath, LOG_LEVEL_VERBOSE);
+            return true;
+        }
+        const ret = await this.localDatabase.putDBEntry(d, onlyChunks);
+        if (ret !== false) {
+            this._log(msg + fullPath);
+            eventHub.emitEvent(EVENT_FILE_SAVED);
+        }
+        return ret != false;
+    }
+
+    async getConflictedRevs(file: UXFileInfoStub | FilePathWithPrefix): Promise<string[]> {
+        if (!await this.checkIsTargetFile(file)) {
+            return [];
+        }
+        const filename = getPathFromUXFileInfo(file);
+        const doc = await this.localDatabase.getDBEntryMeta(filename, { conflicts: true }, true);
+        if (doc === false) {
+            return [];
+        }
+        return doc._conflicts || [];
+    }
+
+    async fetch(file: UXFileInfoStub | FilePathWithPrefix,
+        rev?: string, waitForReady?: boolean, skipCheck = false): Promise<UXFileInfo | false> {
+        if (skipCheck && !await this.checkIsTargetFile(file)) {
+            return false;
+        }
+
+        const entry = await this.fetchEntry(file, rev, waitForReady, true);
+        if (entry === false) {
+            return false;
+        }
+        const data = createBlob(readContent(entry));
+        const fileInfo: UXFileInfo = {
+            name: entry.path.split("/").pop() as string,
+            path: entry.path,
+            stat: {
+                size: entry.size,
+                ctime: entry.ctime,
+                mtime: entry.mtime,
+                type: "file",
+            },
+            body: data,
+            deleted: entry.deleted || entry._deleted,
+        }
+        if (isInternalMetadata(entry.path)) {
+            fileInfo.isInternal = true;
+        }
+        return fileInfo;
+    }
+    async fetchEntryMeta(file: UXFileInfoStub | FilePathWithPrefix,
+        rev?: string, skipCheck = false): Promise<MetaEntry | false> {
+        const filename = getPathFromUXFileInfo(file);
+        if (skipCheck && !await this.checkIsTargetFile(file)) {
+            return false;
+        }
+
+        const doc = await this.localDatabase.getDBEntryMeta(
+            filename, rev ? { rev: rev } : undefined, true);
+        if (doc === false) {
+            return false;
+        }
+        return doc as MetaEntry;
+    }
+    async fetchEntryFromMeta(meta: MetaEntry, waitForReady: boolean = true, skipCheck = false): Promise<LoadedEntry | false> {
+        if (skipCheck && !await this.checkIsTargetFile(meta.path)) {
+            return false;
+        }
+        const doc = await this.localDatabase.getDBEntryFromMeta(meta as LoadedEntry, undefined, false, waitForReady, true);
+        if (doc === false) {
+            return false;
+        }
+        return doc;
+    }
+    async fetchEntry(file: UXFileInfoStub | FilePathWithPrefix,
+        rev?: string, waitForReady: boolean = true, skipCheck = false): Promise<LoadedEntry | false> {
+        if (skipCheck && !await this.checkIsTargetFile(file)) {
+            return false;
+        }
+        const entry = await this.fetchEntryMeta(file, rev, true);
+        if (entry === false) {
+            return false;
+        }
+        const doc = await this.fetchEntryFromMeta(entry, waitForReady, true);
+        return doc;
+    }
+    async deleteFromDBbyPath(fullPath: FilePath | FilePathWithPrefix, rev?: string): Promise<boolean> {
+        if (!await this.checkIsTargetFile(fullPath)) {
+            this._log(`storeFromStorage: File is not target: ${fullPath}`);
+            return true;
+        }
+        const opt = rev ? { rev: rev } : undefined;
+        const ret = await this.localDatabase.deleteDBEntry(fullPath, opt);
+        eventHub.emitEvent(EVENT_FILE_SAVED);
+        return ret;
+    }
+
+}

src/modules/core/ModuleFileHandler.ts

@@ -0,0 +1,358 @@
+import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { serialized } from "octagonal-wheels/concurrency/lock";
+import type { FileEventItem } from "../../common/types";
+import type { FilePath, FilePathWithPrefix, MetaEntry, UXFileInfo, UXFileInfoStub, UXInternalFileInfoStub } from "../../lib/src/common/types";
+import { AbstractModule } from "../AbstractModule.ts";
+import { compareFileFreshness, EVEN, getPath, getPathFromUXFileInfo, getPathWithoutPrefix, markChangesAreSame } from "../../common/utils";
+import { getDocDataAsArray, isDocContentSame, readContent } from "../../lib/src/common/utils";
+import { shouldBeIgnored } from "../../lib/src/string_and_binary/path";
+import type { ICoreModule } from "../ModuleTypes";
+import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
+
+export class ModuleFileHandler extends AbstractModule implements ICoreModule {
+
+    get db() {
+        return this.core.databaseFileAccess;
+    }
+    get storage() {
+        return this.core.storageAccess;
+    }
+
+    $everyOnloadStart(): Promise<boolean> {
+        this.core.fileHandler = this;
+        return Promise.resolve(true);
+    }
+
+    async readFileFromStub(file: UXFileInfoStub | UXFileInfo) {
+        if ("body" in file && file.body) {
+            return file;
+        }
+        const readFile = await this.storage.readStubContent(file);
+        if (!readFile) {
+            throw new Error(`File ${file.path} is not exist on the storage`);
+        }
+        return readFile
+    }
+
+    async storeFileToDB(info: UXFileInfoStub | UXFileInfo | UXInternalFileInfoStub | FilePathWithPrefix, force: boolean = false, onlyChunks: boolean = false): Promise<boolean | undefined> {
+        const file = typeof info === "string" ? this.storage.getFileStub(info) : info;
+        if (file == null) {
+            this._log(`File ${info} is not exist on the storage`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        // const file = item.args.file;
+        if (file.isInternal) {
+            this._log(`Internal file ${file.path} is not allowed to be processed on processFileEvent`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        // First, check the file on the database 
+        const entry = await this.db.fetchEntry(file, undefined, true, true);
+
+        if (!entry || entry.deleted || entry._deleted) {
+            // If the file is not exist on the database, then it should be created.
+            const readFile = await this.readFileFromStub(file);
+            if (!onlyChunks) {
+                return await this.db.store(readFile);
+            } else {
+                return await this.db.createChunks(readFile, false, true);
+            }
+        }
+
+        // entry is exist on the database, check the difference between the file and the entry.
+
+        let shouldApplied = false;
+        if (!force && !onlyChunks) {
+            // 1. if the time stamp is far different, then it should be updated.
+            // Note: This checks only the mtime with the resolution reduced to 2 seconds.
+            //       2 seconds it for the ZIP file's mtime. If not, we cannot backup the vault as the ZIP file.
+            //       This is hardcoded on `compareMtime` of `src/common/utils.ts`.
+            if (compareFileFreshness(file, entry) !== EVEN) {
+                shouldApplied = true;
+            }
+            // 2. if not, the content should be checked.
+            let readFile: UXFileInfo | undefined = undefined;
+            if (!shouldApplied) {
+                readFile = await this.readFileFromStub(file);
+                if (await isDocContentSame(getDocDataAsArray(entry.data), readFile.body)) {
+                    if (shouldApplied) {
+                        // Timestamp is different but the content is same. therefore, two timestamps should be handled as same.
+                        // So, mark the changes are same.
+                        markChangesAreSame(file, file.stat.mtime, entry.mtime);
+                    }
+                } else {
+                    shouldApplied = true;
+                }
+            }
+
+            if (!shouldApplied) {
+                this._log(`File ${file.path} is not changed`, LOG_LEVEL_VERBOSE);
+                return true;
+            }
+            if (!readFile) readFile = await this.readFileFromStub(file);
+            // If the file is changed, then the file should be stored.
+            if (onlyChunks) {
+                return await this.db.createChunks(readFile, false, true);
+            } else {
+                return await this.db.store(readFile, false, true);
+            }
+        } else {
+            // If force is true, then it should be updated.
+            const readFile = await this.readFileFromStub(file);
+            if (onlyChunks) {
+                return await this.db.createChunks(readFile, true, true);
+            } else {
+                return await this.db.store(readFile, true, true);
+            }
+        }
+    }
+
+    async deleteFileFromDB(info: UXFileInfoStub | UXInternalFileInfoStub | FilePath): Promise<boolean | undefined> {
+        const file = typeof info === "string" ? this.storage.getFileStub(info) : info;
+        if (file == null) {
+            this._log(`File ${info} is not exist on the storage`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        // const file = item.args.file;
+        if (file.isInternal) {
+            this._log(`Internal file ${file.path} is not allowed to be processed on processFileEvent`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        // First, check the file on the database 
+        const entry = await this.db.fetchEntry(file, undefined, true, true);
+        if (!entry || entry.deleted || entry._deleted) {
+            this._log(`File ${file.path} is not exist or already deleted on the database`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        // Check the file is already conflicted. if so, only the conflicted one should be deleted.
+        const conflictedRevs = await this.db.getConflictedRevs(file);
+        if (conflictedRevs.length > 0) {
+            // If conflicted, then it should be deleted. entry._rev should be own file's rev.
+            // TODO: I BELIEVED SO. BUT I NOTICED THAT I AN NOT SURE. I SHOULD CHECK THIS.
+            //       ANYWAY, I SHOULD DELETE THE FILE. ACTUALLY WE SIMPLY DELETED THE FILE UNTIL PREVIOUS VERSIONS.
+            return await this.db.delete(file, entry._rev);
+        }
+        // Otherwise, the file should be deleted simply. This is the previous behaviour.
+        return await this.db.delete(file);
+    }
+
+    async deleteRevisionFromDB(info: UXFileInfoStub | FilePath | FilePathWithPrefix, rev: string): Promise<boolean | undefined> {
+        //TODO: Possibly check the conflicting.
+        return await this.db.delete(info, rev);
+    }
+
+
+    async resolveConflictedByDeletingRevision(info: UXFileInfoStub | FilePath, rev: string): Promise<boolean | undefined> {
+        if (!await this.deleteRevisionFromDB(info, rev)) {
+            this._log(`Failed to delete the conflicted revision ${rev} of ${getPathFromUXFileInfo(info)}`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        if (!await this.dbToStorageWithSpecificRev(info, rev, true)) {
+            this._log(`Failed to apply the resolved revision ${rev} of ${getPathFromUXFileInfo(info)} to the storage`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+    }
+
+    async dbToStorageWithSpecificRev(info: UXFileInfoStub | UXFileInfo | FilePath | null, rev: string, force?: boolean): Promise<boolean> {
+        const file = typeof info === "string" ? this.storage.getFileStub(info) : info;
+        if (file == null) {
+            this._log(`File ${info} is not exist on the storage`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        const docEntry = await this.db.fetchEntryMeta(file, rev, true);
+        if (!docEntry) {
+            this._log(`File ${file.path} is not exist on the database`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        return await this.dbToStorage(docEntry, file, force);
+    }
+
+    async dbToStorage(entryInfo: MetaEntry | FilePathWithPrefix, info: UXFileInfoStub | UXFileInfo | FilePath | null, force?: boolean): Promise<boolean> {
+        const file = typeof info === "string" ? this.storage.getFileStub(info) : info;
+        const mode = file == null ? "create" : "modify";
+
+        const docEntry = typeof entryInfo === "string" ?
+            await this.db.fetchEntryMeta(entryInfo, undefined, true) : await this.db.fetchEntryMeta(entryInfo.path, undefined, true);
+        if (!docEntry) {
+            this._log(`File ${entryInfo} is not exist on the database`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        const path = getPath(docEntry);
+
+        // 1. Check if it already conflicted.
+        const revs = await this.db.getConflictedRevs(path);
+        if (revs.length > 0) {
+            // Some conflicts are exist.
+            if (this.settings.writeDocumentsIfConflicted) {
+                // If configured to write the document even if conflicted, then it should be written.
+                // NO OP
+            } else {
+                // If not, then it should be checked. and will be processed later (i.e., after the conflict is resolved).
+                await this.core.$$queueConflictCheckIfOpen(path);
+                return true;
+            }
+        }
+
+        // 2. Check if the file is already exist on the storage.
+        const existDoc = this.storage.getStub(path);
+        if (existDoc && existDoc.isFolder) {
+            this._log(`Folder ${path} is already exist on the storage as a folder`, LOG_LEVEL_VERBOSE);
+            // We can do nothing, and other modules should also nothing to do.
+            return true;
+        }
+
+        // Check existence of both file and docEntry.
+        const existOnDB = !(docEntry._deleted || docEntry.deleted || false);
+        const existOnStorage = existDoc != null;
+        if (!existOnDB && !existOnStorage) {
+            this._log(`File ${path} seems to be deleted, but already not on storage`, LOG_LEVEL_VERBOSE);
+            return true;
+        }
+        if (!existOnDB && existOnStorage) {
+            // Deletion has been Transferred. Storage files will be deleted.
+            // Note: If the folder becomes empty, the folder will be deleted if not configured to keep it.
+            // This behaviour is implemented on the `ModuleFileAccessObsidian`.
+            // And it does not care actually deleted.
+            await this.storage.deleteVaultItem(path);
+            return true;
+        }
+        // Okay, the file is exist on the database. Let's check the file is exist on the storage.
+        const docRead = await this.db.fetchEntryFromMeta(docEntry);
+        if (!docRead) {
+            this._log(`File ${path} is not exist on the database`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        const docData = readContent(docRead);
+
+        if (!existOnStorage) {
+            // The file is not exist on the storage. We do not care about the differences.
+            await this.storage.ensureDir(path);
+            return await this.storage.writeFileAuto(path, docData, { ctime: docRead.ctime, mtime: docRead.mtime });
+        }
+        if (!force) {
+            // Ok, we have to compare.
+            let shouldApplied = false;
+            // 1. if the time stamp is far different, then it should be updated.
+            // Note: This checks only the mtime with the resolution reduced to 2 seconds.
+            //       2 seconds it for the ZIP file's mtime. If not, we cannot backup the vault as the ZIP file.
+            //       This is hardcoded on `compareMtime` of `src/common/utils.ts`.
+            if (compareFileFreshness(existDoc, docEntry) !== EVEN) {
+                shouldApplied = true;
+            }
+            // 2. if not, the content should be checked.
+
+            if (shouldApplied) {
+                const readFile = await this.readFileFromStub(existDoc);
+                if (await isDocContentSame(docData, readFile.body)) {
+                    // The content is same. So, we do not need to update the file.
+                    shouldApplied = false;
+                    // Timestamp is different but the content is same. therefore, two timestamps should be handled as same.
+                    // So, mark the changes are same.
+                    markChangesAreSame(docRead, docRead.mtime, existDoc.stat.mtime);
+                } else {
+                    shouldApplied = true;
+                }
+            }
+            if (!shouldApplied) {
+                this._log(`File ${docRead.path} is not changed`, LOG_LEVEL_VERBOSE);
+                return true;
+            }
+            // Let's apply the changes.
+        }
+        await this.storage.ensureDir(path);
+        const ret = await this.storage.writeFileAuto(path, docData, { ctime: docRead.ctime, mtime: docRead.mtime });
+        this.storage.touched(path);
+        this.storage.triggerFileEvent(mode, path);
+        return ret;
+    }
+
+    async $anyHandlerProcessesFileEvent(item: FileEventItem): Promise<boolean | undefined> {
+        const eventItem = item.args;
+        const type = item.type;
+        const path = eventItem.file.path;
+        if (!await this.core.$$isTargetFile(path)) {
+            this._log(`File ${path} is not the target file`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        if (shouldBeIgnored(path)) {
+            this._log(`File ${path} should be ignored`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        const lockKey = `processFileEvent-${path}`;
+        return await serialized(lockKey, async () => {
+            switch (type) {
+                case "CREATE":
+                case "CHANGED":
+                    return await this.storeFileToDB(item.args.file);
+                case "DELETE":
+                    return await this.deleteFileFromDB(item.args.file);
+                case "INTERNAL":
+                    // this should be handled on the other module.
+                    return false;
+                default:
+                    this._log(`Unsupported event type: ${type}`, LOG_LEVEL_VERBOSE);
+                    return false;
+            }
+        });
+    }
+
+    async $anyProcessReplicatedDoc(entry: MetaEntry): Promise<boolean | undefined> {
+        return await serialized(entry.path, async () => {
+            if (!await this.core.$$isTargetFile(entry.path)) {
+                this._log(`File ${entry.path} is not the target file`, LOG_LEVEL_VERBOSE);
+                return false;
+            }
+            if (shouldBeIgnored(entry.path)) {
+                this._log(`File ${entry.path} should be ignored`, LOG_LEVEL_VERBOSE);
+                return false;
+            }
+            const path = getPath(entry);
+
+            const targetFile = this.storage.getStub(getPathWithoutPrefix(entry));
+            if (targetFile && targetFile.isFolder) {
+                this._log(`${getPath(entry)} is already exist as the folder`);
+                // Nothing to do and other modules should also nothing to do.
+                return true;
+            } else {
+                this._log(`Processing ${path} (${entry._id.substring(0, 8)}: ${entry._rev?.substring(0, 5)}) :Started...`, LOG_LEVEL_VERBOSE);
+                const ret = await this.dbToStorage(entry, targetFile);
+                this._log(`Processing ${path} (${entry._id.substring(0, 8)} :${entry._rev?.substring(0, 5)}) : Done`);
+                return ret;
+            }
+        });
+
+    }
+
+    async createAllChunks(showingNotice?: boolean): Promise<void> {
+        this._log("Collecting local files on the storage", LOG_LEVEL_VERBOSE);
+        const semaphore = Semaphore(10);
+
+        let processed = 0;
+        const filesStorageSrc = this.storage.getFiles();
+        const incProcessed = () => {
+            processed++;
+            if (processed % 25 == 0) this._log(`Creating missing chunks: ${processed} of ${total} files`, showingNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "chunkCreation");
+        }
+        const total = filesStorageSrc.length;
+        const procAllChunks = filesStorageSrc.map(async (file) => {
+            if (!await this.core.$$isTargetFile(file)) {
+                incProcessed();
+                return true;
+            }
+            if (shouldBeIgnored(file.path)) {
+                incProcessed();
+                return true;
+            }
+            const release = await semaphore.acquire();
+            incProcessed();
+            try {
+                await this.storeFileToDB(file, false, true);
+            } catch (ex) {
+                this._log(ex, LOG_LEVEL_VERBOSE);
+            } finally {
+                release();
+            }
+        });
+        await Promise.all(procAllChunks);
+        this._log(`Creating chunks Done: ${processed} of ${total} files`, showingNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "chunkCreation");
+    }
+}

src/modules/core/ModuleLocalDatabaseObsidian.ts

@@ -0,0 +1,23 @@
+import { $f } from "../../lib/src/common/i18n";
+import { LiveSyncLocalDB } from "../../lib/src/pouchdb/LiveSyncLocalDB.ts";
+import { initializeStores } from "../../common/stores.ts";
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleLocalDatabaseObsidian extends AbstractModule implements ICoreModule {
+
+    $everyOnloadStart(): Promise<boolean> {
+        return Promise.resolve(true);
+    }
+    async $$openDatabase(): Promise<boolean> {
+        if (this.localDatabase != null) {
+            await this.localDatabase.close();
+        }
+        const vaultName = this.core.$$getVaultName();
+        this._log($f`Waiting for ready...`);
+        this.core.localDatabase = new LiveSyncLocalDB(vaultName, this.core);
+        initializeStores(vaultName);
+        return await this.localDatabase.initializeDatabase();
+    }
+
+}

src/modules/core/ModulePeriodicProcess.ts

@@ -0,0 +1,35 @@
+import { PeriodicProcessor } from "../../common/utils";
+import { AbstractModule } from "../AbstractModule";
+import type { ICoreModule } from "../ModuleTypes";
+
+export class ModulePeriodicProcess extends AbstractModule implements ICoreModule {
+
+    periodicSyncProcessor = new PeriodicProcessor(this.core, async () => await this.core.$$replicate());
+
+    _disablePeriodic() {
+        this.periodicSyncProcessor?.disable();
+        return Promise.resolve(true);
+    }
+    _resumePeriodic() {
+        this.periodicSyncProcessor.enable(this.settings.periodicReplication ? this.settings.periodicReplicationInterval * 1000 : 0);
+        return Promise.resolve(true);
+    }
+    $allOnUnload() {
+        return this._disablePeriodic();
+
+    }
+    $everyBeforeRealizeSetting(): Promise<boolean> {
+        return this._disablePeriodic();
+
+    }
+    $everyBeforeSuspendProcess(): Promise<boolean> {
+        return this._disablePeriodic();
+
+    }
+    $everyAfterResumeProcess(): Promise<boolean> {
+        return this._resumePeriodic();
+    }
+    $everyAfterRealizeSetting(): Promise<boolean> {
+        return this._resumePeriodic();
+    }
+}

src/modules/core/ModulePouchDB.ts

@@ -0,0 +1,16 @@
+import { AbstractModule } from "../AbstractModule";
+import type { ICoreModule } from "../ModuleTypes";
+import { PouchDB } from "../../lib/src/pouchdb/pouchdb-browser";
+
+export class ModulePouchDB extends AbstractModule implements ICoreModule {
+    $$createPouchDBInstance<T extends object>(name?: string, options?: PouchDB.Configuration.DatabaseConfiguration): PouchDB.Database<T> {
+        const optionPass = options ?? {};
+        if (this.settings.useIndexedDBAdapter) {
+            optionPass.adapter = "indexeddb";
+            //@ts-ignore :missing def
+            optionPass.purged_infos_limit = 1;
+            return new PouchDB(name + "-indexeddb", optionPass);
+        }
+        return new PouchDB(name, optionPass);
+    }
+}

src/modules/core/ModuleRebuilder.ts

@@ -0,0 +1,225 @@
+import { delay } from "octagonal-wheels/promises";
+import { FLAGMD_REDFLAG2_HR, FLAGMD_REDFLAG3_HR, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, REMOTE_COUCHDB, REMOTE_MINIO } from "../../lib/src/common/types.ts";
+import { AbstractModule } from "../AbstractModule.ts";
+import type { Rebuilder } from "../interfaces/DatabaseRebuilder.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+import type { LiveSyncCouchDBReplicator } from "../../lib/src/replication/couchdb/LiveSyncReplicator.ts";
+import { fetchAllUsedChunks } from "../../lib/src/pouchdb/utils_couchdb.ts";
+
+export class ModuleRebuilder extends AbstractModule implements ICoreModule, Rebuilder {
+
+    $everyOnload(): Promise<boolean> {
+        this.core.rebuilder = this;
+        return Promise.resolve(true);
+    }
+    async $performRebuildDB(method: "localOnly" | "remoteOnly" | "rebuildBothByThisDevice" | "localOnlyWithChunks"): Promise<void> {
+        if (method == "localOnly") {
+            await this.$fetchLocal();
+        }
+        if (method == "localOnlyWithChunks") {
+            await this.$fetchLocal(true);
+        }
+        if (method == "remoteOnly") {
+            await this.$rebuildRemote();
+        }
+        if (method == "rebuildBothByThisDevice") {
+            await this.$rebuildEverything();
+        }
+    }
+
+    async askUsingOptionalFeature(opt: {
+        enableFetch?: boolean;
+        enableOverwrite?: boolean;
+    }) {
+        if (await this.core.confirm.askYesNoDialog("Do you want to enable extra features? If you are new to Self-hosted LiveSync, try the core feature first!", { title: "Enable extra features", defaultOption: "No", timeout: 15 }) == "yes") {
+            await this.core.$allAskUsingOptionalSyncFeature(opt);
+        }
+    }
+
+    async rebuildRemote() {
+        await this.core.$allSuspendExtraSync();
+        this.core.settings.isConfigured = true;
+
+        await this.core.realizeSettingSyncMode();
+        await this.core.$$markRemoteLocked();
+        await this.core.$$tryResetRemoteDatabase();
+        await this.core.$$markRemoteLocked();
+        await delay(500);
+        await this.askUsingOptionalFeature({ enableOverwrite: true });
+        await delay(1000);
+        await this.core.$$replicateAllToServer(true);
+        await delay(1000);
+        await this.core.$$replicateAllToServer(true, true);
+    }
+    $rebuildRemote(): Promise<void> {
+        return this.rebuildRemote();
+    }
+
+
+    async rebuildEverything() {
+        await this.core.$allSuspendExtraSync();
+        await this.askUseNewAdapter();
+        this.core.settings.isConfigured = true;
+        await this.core.realizeSettingSyncMode();
+        await this.resetLocalDatabase();
+        await delay(1000);
+        await this.core.$$initializeDatabase(true);
+        await this.core.$$markRemoteLocked();
+        await this.core.$$tryResetRemoteDatabase();
+        await this.core.$$markRemoteLocked();
+        await delay(500);
+        await this.askUsingOptionalFeature({ enableOverwrite: true });
+        await delay(1000);
+        await this.core.$$replicateAllToServer(true);
+        await delay(1000);
+        await this.core.$$replicateAllToServer(true, true);
+
+    }
+
+    $rebuildEverything(): Promise<void> {
+        return this.rebuildEverything();
+    }
+
+    $fetchLocal(makeLocalChunkBeforeSync?: boolean): Promise<void> {
+        return this.fetchLocal(makeLocalChunkBeforeSync);
+    }
+
+    async scheduleRebuild(): Promise<void> {
+        try {
+            await this.core.storageAccess.writeFileAuto(FLAGMD_REDFLAG2_HR, "");
+        } catch (ex) {
+            this._log("Could not create red_flag_rebuild.md", LOG_LEVEL_NOTICE);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+        this.core.$$performRestart();
+    }
+    async scheduleFetch(): Promise<void> {
+        try {
+            await this.core.storageAccess.writeFileAuto(FLAGMD_REDFLAG3_HR, "");
+        } catch (ex) {
+            this._log("Could not create red_flag_fetch.md", LOG_LEVEL_NOTICE);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+        this.core.$$performRestart();
+    }
+
+    async $$tryResetRemoteDatabase(): Promise<void> {
+        await this.core.replicator.tryResetRemoteDatabase(this.settings);
+    }
+
+    async $$tryCreateRemoteDatabase(): Promise<void> {
+        await this.core.replicator.tryCreateRemoteDatabase(this.settings);
+    }
+
+    async $$resetLocalDatabase(): Promise<void> {
+        this.core.storageAccess.clearTouched();
+        await this.localDatabase.resetDatabase();
+    }
+
+
+    async suspendAllSync() {
+        this.core.settings.liveSync = false;
+        this.core.settings.periodicReplication = false;
+        this.core.settings.syncOnSave = false;
+        this.core.settings.syncOnEditorSave = false;
+        this.core.settings.syncOnStart = false;
+        this.core.settings.syncOnFileOpen = false;
+        this.core.settings.syncAfterMerge = false;
+        await this.core.$allSuspendExtraSync();
+    }
+    async suspendReflectingDatabase() {
+        if (this.core.settings.doNotSuspendOnFetching) return;
+        if (this.core.settings.remoteType == REMOTE_MINIO) return;
+        this._log(`Suspending reflection: Database and storage changes will not be reflected in each other until completely finished the fetching.`, LOG_LEVEL_NOTICE);
+        this.core.settings.suspendParseReplicationResult = true;
+        this.core.settings.suspendFileWatching = true;
+        await this.core.saveSettings();
+    }
+    async resumeReflectingDatabase() {
+        if (this.core.settings.doNotSuspendOnFetching) return;
+        if (this.core.settings.remoteType == REMOTE_MINIO) return;
+        this._log(`Database and storage reflection has been resumed!`, LOG_LEVEL_NOTICE);
+        this.core.settings.suspendParseReplicationResult = false;
+        this.core.settings.suspendFileWatching = false;
+        await this.core.$$performFullScan(true);
+        await this.core.$everyBeforeReplicate(false); //TODO: Check actual need of this.
+        await this.core.saveSettings();
+
+    }
+    async askUseNewAdapter() {
+        if (!this.core.settings.useIndexedDBAdapter) {
+            const message = `Now this core has been configured to use the old database adapter for keeping compatibility. Do you want to deactivate it?`;
+            const CHOICE_YES = "Yes, disable and use latest";
+            const CHOICE_NO = "No, keep compatibility";
+            const choices = [CHOICE_YES, CHOICE_NO];
+
+            const ret = await this.core.confirm.confirmWithMessage("Database adapter", message, choices, CHOICE_YES, 10);
+            if (ret == CHOICE_YES) {
+                this.core.settings.useIndexedDBAdapter = true;
+            }
+        }
+    }
+    async fetchLocal(makeLocalChunkBeforeSync?: boolean) {
+        await this.core.$allSuspendExtraSync();
+        await this.askUseNewAdapter();
+        this.core.settings.isConfigured = true;
+        await this.suspendReflectingDatabase();
+        await this.core.realizeSettingSyncMode();
+        await this.resetLocalDatabase();
+        await delay(1000);
+        await this.core.$$openDatabase();
+        this.core.isReady = true;
+        if (makeLocalChunkBeforeSync) {
+            await this.core.fileHandler.createAllChunks(true);
+        }
+        await this.core.$$markRemoteResolved();
+        await delay(500);
+        await this.core.$$replicateAllFromServer(true);
+        await delay(1000);
+        await this.core.$$replicateAllFromServer(true);
+        await this.resumeReflectingDatabase();
+        await this.askUsingOptionalFeature({ enableFetch: true });
+    }
+    async fetchLocalWithRebuild() {
+        return await this.fetchLocal(true);
+    }
+
+    async $allSuspendAllSync(): Promise<boolean> {
+        await this.suspendAllSync();
+        return true;
+    }
+
+    async resetLocalDatabase() {
+        if (this.core.settings.isConfigured && this.core.settings.additionalSuffixOfDatabaseName == "") {
+            // Discard the non-suffixed database
+            await this.core.$$resetLocalDatabase();
+        }
+        const suffix = (await this.core.$anyGetAppId()) || "";
+        this.core.settings.additionalSuffixOfDatabaseName = suffix;
+        await this.core.$$resetLocalDatabase();
+    }
+    async fetchRemoteChunks() {
+        if (!this.core.settings.doNotSuspendOnFetching && this.core.settings.readChunksOnline && this.core.settings.remoteType == REMOTE_COUCHDB) {
+            this._log(`Fetching chunks`, LOG_LEVEL_NOTICE);
+            const replicator = this.core.getReplicator() as LiveSyncCouchDBReplicator;
+            const remoteDB = await replicator.connectRemoteCouchDBWithSetting(this.settings, this.core.getIsMobile(), true);
+            if (typeof remoteDB == "string") {
+                this._log(remoteDB, LOG_LEVEL_NOTICE);
+            } else {
+                await fetchAllUsedChunks(this.localDatabase.localDatabase, remoteDB.db);
+            }
+            this._log(`Fetching chunks done`, LOG_LEVEL_NOTICE);
+        }
+    }
+    async resolveAllConflictedFilesByNewerOnes() {
+        this._log(`Resolving conflicts by newer ones`, LOG_LEVEL_NOTICE);
+        const files = this.core.storageAccess.getFileNames();
+
+        let i = 0;
+        for (const file of files) {
+            if (i++ % 10) this._log(`Check and Processing ${i} / ${files.length}`, LOG_LEVEL_NOTICE, "resolveAllConflictedFilesByNewerOnes");
+            await this.core.$anyResolveConflictByNewest(file);
+        }
+        this._log(`Done!`, LOG_LEVEL_NOTICE, "resolveAllConflictedFilesByNewerOnes");
+    }
+}

src/modules/core/ModuleReplicator.ts

@@ -0,0 +1,351 @@
+import { fireAndForget, yieldMicrotask } from "octagonal-wheels/promises";
+import type { LiveSyncLocalDB } from "../../lib/src/pouchdb/LiveSyncLocalDB";
+import { AbstractModule } from "../AbstractModule";
+import type { ICoreModule } from "../ModuleTypes";
+import { Logger, LOG_LEVEL_NOTICE, LOG_LEVEL_INFO, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { isLockAcquired, shareRunningResult, skipIfDuplicated } from "octagonal-wheels/concurrency/lock";
+import { purgeUnreferencedChunks, balanceChunkPurgedDBs } from "../../lib/src/pouchdb/utils_couchdb";
+import { LiveSyncCouchDBReplicator } from "../../lib/src/replication/couchdb/LiveSyncReplicator";
+import { throttle } from "octagonal-wheels/function";
+import { arrayToChunkedArray } from "octagonal-wheels/collection";
+import { SYNCINFO_ID, VER, type EntryBody, type EntryDoc, type LoadedEntry, type MetaEntry } from "../../lib/src/common/types";
+import { QueueProcessor } from "octagonal-wheels/concurrency/processor";
+import { getPath, isChunk, isValidPath, scheduleTask } from "../../common/utils";
+import { sendValue } from "octagonal-wheels/messagepassing/signal";
+import { isAnyNote } from "../../lib/src/common/utils";
+import { EVENT_FILE_SAVED, eventHub } from "../../common/events";
+
+export class ModuleReplicator extends AbstractModule implements ICoreModule {
+
+    $everyOnloadAfterLoadSettings(): Promise<boolean> {
+        eventHub.onEvent(EVENT_FILE_SAVED, () => {
+            if (this.settings.syncOnSave && !this.core.suspended) {
+                scheduleTask("perform-replicate-after-save", 250, () => this.core.$$waitForReplicationOnce());
+            }
+        })
+        return Promise.resolve(true);
+    }
+
+    async setReplicator() {
+        const replicator = await this.core.$anyNewReplicator();
+        if (!replicator) {
+            this._log("No replicator is available, this is the fatal error.", LOG_LEVEL_NOTICE);
+            return false
+        }
+        this.core.replicator = replicator;
+        await yieldMicrotask();
+        return true;
+    }
+    $everyOnInitializeDatabase(db: LiveSyncLocalDB): Promise<boolean> {
+        return this.setReplicator();
+    }
+
+    $everyOnResetDatabase(db: LiveSyncLocalDB): Promise<boolean> {
+        return this.setReplicator();
+
+    }
+
+    async $everyBeforeReplicate(showMessage: boolean): Promise<boolean> {
+        await this.loadQueuedFiles();
+        return true;
+    }
+    async $$replicate(showMessage: boolean = false): Promise<boolean | void> {
+        //--? 
+        if (!this.core.isReady) return;
+        if (isLockAcquired("cleanup")) {
+            Logger("Database cleaning up is in process. replication has been cancelled", LOG_LEVEL_NOTICE);
+            return;
+        }
+        if (this.settings.versionUpFlash != "") {
+            Logger("Open settings and check message, please. replication has been cancelled.", LOG_LEVEL_NOTICE);
+            return;
+        }
+        if (!await this.core.$everyCommitPendingFileEvent()) {
+            Logger("Some file events are pending. Replication has been cancelled.", LOG_LEVEL_NOTICE);
+            return false;
+        }
+        if (!await this.core.$everyBeforeReplicate(showMessage)) {
+            Logger(`Replication has been cancelled by some module failure`, LOG_LEVEL_NOTICE);
+            return false;
+        }
+
+        //<-- Here could be an module.
+        const ret = await this.core.replicator.openReplication(this.settings, false, showMessage, false);
+        if (!ret) {
+            if (this.core.replicator.tweakSettingsMismatched) {
+                await this.core.$$askResolvingMismatchedTweaks();
+
+            } else {
+                if (this.core.replicator?.remoteLockedAndDeviceNotAccepted) {
+                    if (this.core.replicator.remoteCleaned && this.settings.useIndexedDBAdapter) {
+                        Logger(`The remote database has been cleaned.`, showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO);
+                        await skipIfDuplicated("cleanup", async () => {
+                            const count = await purgeUnreferencedChunks(this.localDatabase.localDatabase, true);
+                            const message = `The remote database has been cleaned up.
+To synchronize, this device must be also cleaned up. ${count} chunk(s) will be erased from this device.
+However, If there are many chunks to be deleted, maybe fetching again is faster.
+We will lose the history of this device if we fetch the remote database again.
+Even if you choose to clean up, you will see this option again if you exit Obsidian and then synchronise again.`
+                            const CHOICE_FETCH = "Fetch again";
+                            const CHOICE_CLEAN = "Cleanup";
+                            const CHOICE_DISMISS = "Dismiss";
+                            const ret = await this.core.confirm.confirmWithMessage("Cleaned", message, [
+                                CHOICE_FETCH,
+                                CHOICE_CLEAN,
+                                CHOICE_DISMISS], CHOICE_DISMISS, 30);
+                            if (ret == CHOICE_FETCH) {
+                                await this.core.rebuilder.$performRebuildDB("localOnly");
+                            }
+                            if (ret == CHOICE_CLEAN) {
+                                const replicator = this.core.getReplicator();
+                                if (!(replicator instanceof LiveSyncCouchDBReplicator)) return;
+                                const remoteDB = await replicator.connectRemoteCouchDBWithSetting(this.settings, this.core.getIsMobile(), true);
+                                if (typeof remoteDB == "string") {
+                                    Logger(remoteDB, LOG_LEVEL_NOTICE);
+                                    return false;
+                                }
+
+                                await purgeUnreferencedChunks(this.localDatabase.localDatabase, false);
+                                this.localDatabase.hashCaches.clear();
+                                // Perform the synchronisation once.
+                                if (await this.core.replicator.openReplication(this.settings, false, showMessage, true)) {
+                                    await balanceChunkPurgedDBs(this.localDatabase.localDatabase, remoteDB.db);
+                                    await purgeUnreferencedChunks(this.localDatabase.localDatabase, false);
+                                    this.localDatabase.hashCaches.clear();
+                                    await this.core.getReplicator().markRemoteResolved(this.settings);
+                                    Logger("The local database has been cleaned up.", showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO)
+                                } else {
+                                    Logger("Replication has been cancelled. Please try it again.", showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO)
+                                }
+
+                            }
+                        });
+                    } else {
+                        const message = `
+The remote database has been rebuilt.
+To synchronize, this device must fetch everything again once.
+Or if you are sure know what had been happened, we can unlock the database from the setting dialog.
+                    `
+                        const CHOICE_FETCH = "Fetch again";
+                        const CHOICE_DISMISS = "Dismiss";
+                        const ret = await this.core.confirm.confirmWithMessage("Locked", message, [
+                            CHOICE_FETCH,
+                            CHOICE_DISMISS], CHOICE_DISMISS, 10);
+                        if (ret == CHOICE_FETCH) {
+                            const CHOICE_RESTART = "Restart";
+                            const CHOICE_WITHOUT_RESTART = "Without restart";
+                            if (await this.core.confirm.askSelectStringDialogue(
+                                "Self-hosted LiveSync restarts Obsidian to fetch everything safely. However, you can do it without restarting. Please choose one.",
+                                [CHOICE_RESTART, CHOICE_WITHOUT_RESTART], {
+                                title: "Fetch again",
+                                defaultAction: CHOICE_RESTART,
+                                timeout: 30,
+                            }
+                            ) == CHOICE_RESTART) {
+                                await this.core.rebuilder.scheduleFetch();
+                                // await this.core.$$scheduleAppReload();
+                                return;
+                            } else {
+                                await this.core.rebuilder.$performRebuildDB("localOnly");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return ret;
+    }
+
+    $$parseReplicationResult(docs: Array<PouchDB.Core.ExistingDocument<EntryDoc>>): void {
+        if (this.settings.suspendParseReplicationResult && !this.replicationResultProcessor.isSuspended) {
+            this.replicationResultProcessor.suspend()
+        }
+        this.replicationResultProcessor.enqueueAll(docs);
+        if (!this.settings.suspendParseReplicationResult && this.replicationResultProcessor.isSuspended) {
+            this.replicationResultProcessor.resume()
+        }
+    }
+    _saveQueuedFiles = throttle(() => {
+        const saveData = this.replicationResultProcessor._queue.filter(e => e !== undefined && e !== null).map((e) => e?._id ?? "" as string) as string[];
+        const kvDBKey = "queued-files"
+        // localStorage.setItem(lsKey, saveData);
+        fireAndForget(() => this.core.kvDB.set(kvDBKey, saveData));
+    }, 100);
+    saveQueuedFiles() {
+        this._saveQueuedFiles();
+    }
+    async loadQueuedFiles() {
+        if (this.settings.suspendParseReplicationResult) return;
+        if (!this.settings.isConfigured) return;
+        const kvDBKey = "queued-files"
+        // const ids = [...new Set(JSON.parse(localStorage.getItem(lsKey) || "[]"))] as string[];
+        const ids = [...new Set(await this.core.kvDB.get<string[]>(kvDBKey) ?? [])];
+        const batchSize = 100;
+        const chunkedIds = arrayToChunkedArray(ids, batchSize);
+        for await (const idsBatch of chunkedIds) {
+            const ret = await this.localDatabase.allDocsRaw<EntryDoc>({
+                keys: idsBatch,
+                include_docs: true,
+                limit: 100
+            });
+            const docs = ret.rows.filter(e => e.doc).map(e => e.doc) as PouchDB.Core.ExistingDocument<EntryDoc>[];
+            const errors = ret.rows.filter(e => !e.doc && !e.value.deleted);
+            if (errors.length > 0) {
+                Logger("Some queued processes were not resurrected");
+                Logger(JSON.stringify(errors), LOG_LEVEL_VERBOSE);
+            }
+            this.replicationResultProcessor.enqueueAll(docs);
+            await this.replicationResultProcessor.waitForAllProcessed();
+        }
+
+    }
+
+    replicationResultProcessor = new QueueProcessor(async (docs: PouchDB.Core.ExistingDocument<EntryDoc>[]) => {
+        if (this.settings.suspendParseReplicationResult) return;
+        const change = docs[0];
+        if (!change) return;
+        if (isChunk(change._id)) {
+            // SendSignal?
+            // this.parseIncomingChunk(change);
+            sendValue(`leaf-${change._id}`, change);
+            return;
+        }
+        if (await this.core.$anyModuleParsedReplicationResultItem(change)) return;
+        // any addon needs this item?
+        // for (const proc of this.core.addOns) {
+        //     if (await proc.parseReplicationResultItem(change)) {
+        //         return;
+        //     }
+        // }
+        if (change.type == "versioninfo") {
+            if (change.version > VER) {
+                this.core.replicator.closeReplication();
+                Logger(`Remote database updated to incompatible version. update your Self-hosted LiveSync plugin.`, LOG_LEVEL_NOTICE);
+            }
+            return;
+        }
+        if (change._id == SYNCINFO_ID || // Synchronisation information data
+            change._id.startsWith("_design") //design document
+        ) {
+            return;
+        }
+        if (isAnyNote(change)) {
+            const docPath = getPath(change);
+            if (!await this.core.$$isTargetFile(docPath)) {
+                Logger(`Skipped: ${docPath}`, LOG_LEVEL_VERBOSE);
+                return;
+            }
+            if (this.databaseQueuedProcessor._isSuspended) {
+                Logger(`Processing scheduled: ${docPath}`, LOG_LEVEL_INFO);
+            }
+            const size = change.size;
+            if (this.core.$$isFileSizeExceeded(size)) {
+                Logger(`Processing ${docPath} has been skipped due to file size exceeding the limit`, LOG_LEVEL_NOTICE);
+                return;
+            }
+            this.databaseQueuedProcessor.enqueue(change);
+        }
+        return;
+    }, {
+        batchSize: 1,
+        suspended: true,
+        concurrentLimit: 100,
+        delay: 0,
+        totalRemainingReactiveSource: this.core.replicationResultCount
+    }).replaceEnqueueProcessor((queue, newItem) => {
+        const q = queue.filter(e => e._id != newItem._id);
+        return [...q, newItem];
+    }).startPipeline().onUpdateProgress(() => {
+        this.saveQueuedFiles();
+    });
+
+    databaseQueuedProcessor = new QueueProcessor(async (docs: EntryBody[]) => {
+        const dbDoc = docs[0] as LoadedEntry; // It has no `data`
+        const path = getPath(dbDoc);
+
+        // If `Read chunks online` is disabled, chunks should be transferred before here.
+        // However, in some cases, chunks are after that. So, if missing chunks exist, we have to wait for them.
+        const doc = await this.localDatabase.getDBEntryFromMeta({ ...dbDoc }, {}, false, true, true);
+        if (!doc) {
+            Logger(`Something went wrong while gathering content of ${path} (${dbDoc._id.substring(0, 8)}, ${dbDoc._rev?.substring(0, 10)}) `, LOG_LEVEL_NOTICE)
+            return;
+        }
+
+        if (await this.core.$anyProcessOptionalSyncFiles(dbDoc)) {
+            // Already processed
+        } else if (isValidPath(getPath(doc))) {
+            this.storageApplyingProcessor.enqueue(doc as MetaEntry);
+        } else {
+            Logger(`Skipped: ${doc._id.substring(0, 8)}`, LOG_LEVEL_VERBOSE);
+        }
+        return;
+    }, {
+        suspended: true,
+        batchSize: 1,
+        concurrentLimit: 10,
+        yieldThreshold: 1,
+        delay: 0,
+        totalRemainingReactiveSource: this.core.databaseQueueCount
+    }).replaceEnqueueProcessor((queue, newItem) => {
+        const q = queue.filter(e => e._id != newItem._id);
+        return [...q, newItem];
+    }).startPipeline();
+
+
+    storageApplyingProcessor = new QueueProcessor(async (docs: MetaEntry[]) => {
+        const entry = docs[0];
+        await this.core.$anyProcessReplicatedDoc(entry);
+        return;
+    }, {
+        suspended: true,
+        batchSize: 1,
+        concurrentLimit: 6,
+        yieldThreshold: 1,
+        delay: 0,
+        totalRemainingReactiveSource: this.core.storageApplyingCount
+    }).replaceEnqueueProcessor((queue, newItem) => {
+        const q = queue.filter(e => e._id != newItem._id);
+        return [...q, newItem];
+    }).startPipeline()
+
+    $everyBeforeSuspendProcess(): Promise<boolean> {
+        this.core.replicator.closeReplication();
+        return Promise.resolve(true);
+    }
+
+    async $$replicateAllToServer(showingNotice: boolean = false, sendChunksInBulkDisabled: boolean = false): Promise<boolean> {
+        if (!this.core.isReady) return false;
+        if (!await this.core.$everyBeforeReplicate(showingNotice)) {
+            Logger(`Replication has been cancelled by some module failure`, LOG_LEVEL_NOTICE);
+            return false;
+        }
+        if (!sendChunksInBulkDisabled) {
+            if (this.core.replicator instanceof LiveSyncCouchDBReplicator) {
+                if (await this.core.confirm.askYesNoDialog("Do you want to send all chunks before replication?", { defaultOption: "No", timeout: 20 }) == "yes") {
+                    await this.core.replicator.sendChunks(this.core.settings, undefined, true, 0);
+                }
+            }
+        }
+        const ret = await this.core.replicator.replicateAllToServer(this.settings, showingNotice);
+        if (ret) return true;
+        const checkResult = await this.core.$anyAfterConnectCheckFailed();
+        if (checkResult == "CHECKAGAIN") return await this.core.$$replicateAllToServer(showingNotice);
+        return !checkResult;
+    }
+    async $$replicateAllFromServer(showingNotice: boolean = false): Promise<boolean> {
+        if (!this.core.isReady) return false;
+        const ret = await this.core.replicator.replicateAllFromServer(this.settings, showingNotice);
+        if (ret) return true;
+        const checkResult = await this.core.$anyAfterConnectCheckFailed();
+        if (checkResult == "CHECKAGAIN") return await this.core.$$replicateAllFromServer(showingNotice);
+        return !checkResult;
+    }
+
+    async $$waitForReplicationOnce(): Promise<boolean | void> {
+        return await shareRunningResult(`replication`, () => this.core.$$replicate());
+    }
+
+
+
+}

src/modules/core/ModuleReplicatorCouchDB.ts

@@ -0,0 +1,33 @@
+import { fireAndForget } from "octagonal-wheels/promises";
+import { REMOTE_MINIO, type RemoteDBSettings } from "../../lib/src/common/types";
+import { LiveSyncCouchDBReplicator } from "../../lib/src/replication/couchdb/LiveSyncReplicator";
+import type { LiveSyncAbstractReplicator } from "../../lib/src/replication/LiveSyncAbstractReplicator";
+import { AbstractModule } from "../AbstractModule";
+import type { ICoreModule } from "../ModuleTypes";
+
+export class ModuleReplicatorCouchDB extends AbstractModule implements ICoreModule {
+    $anyNewReplicator(settingOverride: Partial<RemoteDBSettings> = {}): Promise<LiveSyncAbstractReplicator> {
+        const settings = { ...this.settings, ...settingOverride };
+        // If new remote types were added, add them here. Do not use `REMOTE_COUCHDB` directly for the safety valve.
+        if (settings.remoteType == REMOTE_MINIO) {
+            return undefined!
+        }
+        return Promise.resolve(new LiveSyncCouchDBReplicator(this.core));
+
+    }
+    $everyAfterResumeProcess(): Promise<boolean> {
+        if (this.settings.remoteType != REMOTE_MINIO) {
+            // If LiveSync enabled, open replication
+            if (this.settings.liveSync) {
+                fireAndForget(() => this.core.replicator.openReplication(this.settings, true, false, false));
+            }
+            // If sync on start enabled, open replication
+            if (!this.settings.liveSync && this.settings.syncOnStart) {
+                // Possibly ok as if only share the result
+                fireAndForget(() => this.core.replicator.openReplication(this.settings, false, false, false));
+            }
+        }
+
+        return Promise.resolve(true);
+    }
+}

src/modules/core/ModuleReplicatorMinIO.ts

@@ -0,0 +1,17 @@
+import { REMOTE_MINIO, type RemoteDBSettings } from "../../lib/src/common/types";
+import { LiveSyncJournalReplicator } from "../../lib/src/replication/journal/LiveSyncJournalReplicator";
+import type { LiveSyncAbstractReplicator } from "../../lib/src/replication/LiveSyncAbstractReplicator";
+import { AbstractModule } from "../AbstractModule";
+import type { ICoreModule } from "../ModuleTypes";
+
+export class ModuleReplicatorMinIO extends AbstractModule implements ICoreModule {
+    $anyNewReplicator(settingOverride: Partial<RemoteDBSettings> = {}): Promise<LiveSyncAbstractReplicator> {
+        const settings = { ...this.settings, ...settingOverride };
+        if (settings.remoteType == REMOTE_MINIO) {
+            return Promise.resolve(new LiveSyncJournalReplicator(this.core));
+        }
+        return undefined!;
+    }
+
+
+}

src/modules/core/ModuleTargetFilter.ts

@@ -0,0 +1,146 @@
+import { LRUCache } from "octagonal-wheels/memory/LRUCache";
+import { getPathFromUXFileInfo, id2path, isInternalMetadata, path2id, stripInternalMetadataPrefix, useMemo } from "../../common/utils";
+import { LOG_LEVEL_VERBOSE, type DocumentID, type EntryHasPath, type FilePath, type FilePathWithPrefix, type ObsidianLiveSyncSettings, type UXFileInfoStub } from "../../lib/src/common/types";
+import { addPrefix, isAcceptedAll, stripAllPrefixes } from "../../lib/src/string_and_binary/path";
+import { AbstractModule } from "../AbstractModule";
+import type { ICoreModule } from "../ModuleTypes";
+import { EVENT_REQUEST_RELOAD_SETTING_TAB, EVENT_SETTING_SAVED, eventHub } from "../../common/events";
+import { isDirty } from "../../lib/src/common/utils";
+export class ModuleTargetFilter extends AbstractModule implements ICoreModule {
+
+    reloadIgnoreFiles() {
+        this.ignoreFiles = this.settings.ignoreFiles.split(",").map(e => e.trim());
+
+    }
+    $everyOnload(): Promise<boolean> {
+        eventHub.onEvent(EVENT_SETTING_SAVED, (evt: CustomEvent<ObsidianLiveSyncSettings>) => {
+            this.reloadIgnoreFiles();
+        });
+        eventHub.onEvent(EVENT_REQUEST_RELOAD_SETTING_TAB, (evt: CustomEvent<ObsidianLiveSyncSettings>) => {
+            this.reloadIgnoreFiles();
+        });
+        return Promise.resolve(true);
+    }
+
+    $$id2path(id: DocumentID, entry?: EntryHasPath, stripPrefix?: boolean): FilePathWithPrefix {
+        const tempId = id2path(id, entry);
+        if (stripPrefix && isInternalMetadata(tempId)) {
+            const out = stripInternalMetadataPrefix(tempId);
+            return out;
+        }
+        return tempId;
+    }
+    async $$path2id(filename: FilePathWithPrefix | FilePath, prefix?: string): Promise<DocumentID> {
+        const destPath = addPrefix(filename, prefix ?? "");
+        return await path2id(destPath, this.settings.usePathObfuscation ? this.settings.passphrase : "", !this.settings.handleFilenameCaseSensitive);
+    }
+
+
+    $$isFileSizeExceeded(size: number) {
+        if (this.settings.syncMaxSizeInMB > 0 && size > 0) {
+            if (this.settings.syncMaxSizeInMB * 1024 * 1024 < size) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    get fileListPossiblyChanged() {
+        if (isDirty("totalFileEventCount", this.core.totalFileEventCount)) {
+            return true;
+        }
+        return false;
+    }
+
+    async $$isTargetFile(file: string | UXFileInfoStub, keepFileCheckList = false) {
+
+        const fileCount = useMemo<Record<string, number>>({
+            key: "fileCount", // forceUpdate: !keepFileCheckList,
+        }, (ctx, prev) => {
+            if (keepFileCheckList && prev) return prev;
+            if (!keepFileCheckList && prev && !this.fileListPossiblyChanged) {
+                return prev;
+            }
+            const fileList = (ctx.get("fileList") ?? []) as FilePathWithPrefix[];
+            // const fileNameList = (ctx.get("fileNameList") ?? []) as FilePath[];
+            // const fileNames = 
+            const vaultFiles = this.core.storageAccess.getFileNames().sort();
+            if (prev && vaultFiles.length == fileList.length) {
+                const fl3 = new Set([...fileList, ...vaultFiles]);
+                if (fileList.length == fl3.size && vaultFiles.length == fl3.size) {
+                    return prev;
+                }
+            }
+            ctx.set("fileList", vaultFiles);
+
+
+            const fileCount: Record<string, number> = {};
+            for (const file of vaultFiles) {
+                const lc = file.toLowerCase();
+                if (!fileCount[lc]) {
+                    fileCount[lc] = 1;
+                } else {
+                    fileCount[lc]++;
+                }
+            }
+            return fileCount;
+        })
+
+        const filepath = getPathFromUXFileInfo(file);
+        const lc = filepath.toLowerCase();
+        if (this.core.shouldCheckCaseInsensitive) {
+            if (lc in fileCount && fileCount[lc] > 1) {
+                return false;
+            }
+        }
+        const fileNameLC = getPathFromUXFileInfo(file).split("/").pop()?.toLowerCase();
+        if (this.settings.useIgnoreFiles) {
+            if (this.ignoreFiles.some(e => e.toLowerCase() == fileNameLC)) {
+                // We must reload ignore files due to the its change.
+                await this.readIgnoreFile(filepath);
+            }
+            if (await this.core.$$isIgnoredByIgnoreFiles(file)) {
+                return false;
+            }
+        }
+        if (!this.localDatabase?.isTargetFile(filepath)) return false;
+        return true
+    }
+
+    ignoreFileCache = new LRUCache<string, string[] | false>(300, 250000, true);
+    ignoreFiles = [] as string[]
+    async readIgnoreFile(path: string) {
+        try {
+            const file = await this.core.storageAccess.readFileText(path);
+            const gitignore = file.split(/\r?\n/g);
+            this.ignoreFileCache.set(path, gitignore);
+            return gitignore;
+        } catch (ex) {
+            this._log(`Failed to read ignore file ${path}`);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+            this.ignoreFileCache.set(path, false);
+            return false;
+        }
+    }
+    async getIgnoreFile(path: string) {
+        if (this.ignoreFileCache.has(path)) {
+            return this.ignoreFileCache.get(path) ?? false;
+        } else {
+            return await this.readIgnoreFile(path);
+        }
+    }
+    async $$isIgnoredByIgnoreFiles(file: string | UXFileInfoStub): Promise<boolean> {
+        if (!this.settings.useIgnoreFiles) {
+            return false;
+        }
+        const filepath = getPathFromUXFileInfo(file)
+        if (this.ignoreFileCache.has(filepath)) {
+            // Renew
+            await this.readIgnoreFile(filepath);
+        }
+        if (!await isAcceptedAll(stripAllPrefixes(filepath), this.ignoreFiles, (filename) => this.getIgnoreFile(filename))) {
+            return true;
+        }
+        return false;
+    }
+}

src/modules/coreFeatures/ModuleCheckRemoteSize.ts

@@ -0,0 +1,101 @@
+import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { AbstractModule } from "../AbstractModule.ts";
+import { sizeToHumanReadable } from "octagonal-wheels/number";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleCheckRemoteSize extends AbstractModule implements ICoreModule {
+    async $allScanStat(): Promise<boolean> {
+        this._log(`Checking storage sizes`, LOG_LEVEL_VERBOSE);
+        if (this.settings.notifyThresholdOfRemoteStorageSize < 0) {
+            const message = `We can set a maximum database capacity warning, **to take action before running out of space on the remote storage**.
+Do you want to enable this?
+
+> [!MORE]-
+> - 0: Do not warn about storage size.
+>   This is recommended if you have enough space on the remote storage especially you have self-hosted. And you can check the storage size and rebuild manually.
+> - 800: Warn if the remote storage size exceeds 800MB.
+>   This is recommended if you are using fly.io with 1GB limit or IBM Cloudant.
+> - 2000: Warn if the remote storage size exceeds 2GB.
+
+If we have reached the limit, we will be asked to enlarge the limit step by step.
+`
+            const ANSWER_0 = "No, never warn please";
+            const ANSWER_800 = "800MB (Cloudant, fly.io)";
+            const ANSWER_2000 = "2GB (Standard)";
+            const ASK_ME_NEXT_TIME = "Ask me later";
+
+            const ret = await this.core.confirm.askSelectStringDialogue(message, [ANSWER_0, ANSWER_800, ANSWER_2000, ASK_ME_NEXT_TIME], {
+                defaultAction: ASK_ME_NEXT_TIME,
+                title: "Setting up database size notification", timeout: 40
+            });
+            if (ret == ANSWER_0) {
+                this.settings.notifyThresholdOfRemoteStorageSize = 0;
+                await this.core.saveSettings();
+            } else if (ret == ANSWER_800) {
+                this.settings.notifyThresholdOfRemoteStorageSize = 800;
+                await this.core.saveSettings();
+            } else if (ret == ANSWER_2000) {
+                this.settings.notifyThresholdOfRemoteStorageSize = 2000;
+                await this.core.saveSettings();
+            }
+        }
+        if (this.settings.notifyThresholdOfRemoteStorageSize > 0) {
+            const remoteStat = await this.core.replicator?.getRemoteStatus(this.settings);
+            if (remoteStat) {
+                const estimatedSize = remoteStat.estimatedSize;
+                if (estimatedSize) {
+                    const maxSize = this.settings.notifyThresholdOfRemoteStorageSize * 1024 * 1024;
+                    if (estimatedSize > maxSize) {
+                        const message = `**Your database is getting larger!** But do not worry, we can address it now. The time before running out of space on the remote storage.
+
+| Measured size | Configured size |
+| --- | --- |
+| ${sizeToHumanReadable(estimatedSize)} | ${sizeToHumanReadable(maxSize)} |
+
+> [!MORE]-
+> If you have been using it for many years, there may be unreferenced chunks - that is, garbage - accumulating in the database. Therefore, we recommend rebuilding everything. It will probably become much smaller.
+> 
+> If the volume of your vault is simply increasing, it is better to rebuild everything after organizing the files. Self-hosted LiveSync does not delete the actual data even if you delete it to speed up the process. It is roughly [documented](https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/tech_info.md).
+> 
+> If you don't mind the increase, you can increase the notification limit by 100MB. This is the case if you are running it on your own server. However, it is better to rebuild everything from time to time.
+> 
+
+> [!WARNING]
+> If you perform rebuild everything, make sure all devices are synchronised. The plug-in will merge as much as possible, though.
+
+\n`;
+                        const newMax = ~~(estimatedSize / 1024 / 1024) + 100;
+                        const ANSWER_ENLARGE_LIMIT = `increase to ${newMax}MB`;
+                        const ANSWER_REBUILD = "Rebuild Everything Now";
+                        const ANSWER_IGNORE = "Dismiss";
+                        const ret = await this.core.confirm.askSelectStringDialogue(message, [ANSWER_ENLARGE_LIMIT, ANSWER_REBUILD, ANSWER_IGNORE,], {
+                            defaultAction: ANSWER_IGNORE,
+                            title: "Remote storage size exceeded the limit", timeout: 60
+
+                        });
+                        if (ret == ANSWER_REBUILD) {
+                            const ret = await this.core.confirm.askYesNoDialog("This may take a bit of a long time. Do you really want to rebuild everything now?", { defaultOption: "No" });
+                            if (ret == "yes") {
+                                this.core.settings.notifyThresholdOfRemoteStorageSize = -1;
+                                await this.saveSettings();
+                                await this.core.rebuilder.scheduleRebuild();
+                            }
+                        } else if (ret == ANSWER_ENLARGE_LIMIT) {
+                            this.settings.notifyThresholdOfRemoteStorageSize = ~~(estimatedSize / 1024 / 1024) + 100;
+                            this._log(`Threshold has been enlarged to ${this.settings.notifyThresholdOfRemoteStorageSize}MB`, LOG_LEVEL_NOTICE);
+                            await this.core.saveSettings();
+                        } else {
+                            // Dismiss or Close the dialog
+                        }
+
+                        this._log(`Remote storage size: ${sizeToHumanReadable(estimatedSize)} exceeded ${sizeToHumanReadable(this.settings.notifyThresholdOfRemoteStorageSize * 1024 * 1024)} `, LOG_LEVEL_INFO);
+                    } else {
+                        this._log(`Remote storage size: ${sizeToHumanReadable(estimatedSize)}`, LOG_LEVEL_INFO);
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+}

src/modules/coreFeatures/ModuleConflictChecker.ts

@@ -0,0 +1,75 @@
+import { AbstractModule } from "../AbstractModule.ts";
+import { LOG_LEVEL_NOTICE, type FilePathWithPrefix } from "../../lib/src/common/types";
+import { QueueProcessor } from "octagonal-wheels/concurrency/processor";
+import { sendValue } from "octagonal-wheels/messagepassing/signal";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleConflictChecker extends AbstractModule implements ICoreModule {
+
+    async $$queueConflictCheckIfOpen(file: FilePathWithPrefix): Promise<void> {
+        const path = file;
+        if (this.settings.checkConflictOnlyOnOpen) {
+            const af = this.core.$$getActiveFilePath();
+            if (af && af != path) {
+                this._log(`${file} is conflicted, merging process has been postponed.`, LOG_LEVEL_NOTICE);
+                return;
+            }
+        }
+        await this.core.$$queueConflictCheck(path);
+    }
+
+    async $$queueConflictCheck(file: FilePathWithPrefix): Promise<void> {
+        const optionalConflictResult = await this.core.$anyGetOptionalConflictCheckMethod(file);
+        if (optionalConflictResult == true) {
+            // The conflict has been resolved by another process.
+            return;
+        } else if (optionalConflictResult === "newer") {
+            // The conflict should be resolved by the newer entry.
+            await this.core.$anyResolveConflictByNewest(file);
+        } else {
+            this.conflictCheckQueue.enqueue(file);
+        }
+    }
+
+    $$waitForAllConflictProcessed(): Promise<boolean> {
+        return this.conflictResolveQueue.waitForAllProcessed();
+    }
+
+    // TODO-> Move to ModuleConflictResolver?
+    conflictResolveQueue = new QueueProcessor(async (filenames: FilePathWithPrefix[]) => {
+        await this.core.$$resolveConflict(filenames[0]);
+    }, {
+        suspended: false,
+        batchSize: 1,
+        concurrentLimit: 1,
+        delay: 10,
+        keepResultUntilDownstreamConnected: false
+    }).replaceEnqueueProcessor((queue, newEntity) => {
+        const filename = newEntity;
+        sendValue("cancel-resolve-conflict:" + filename, true);
+        const newQueue = [...queue].filter(e => e != newEntity);
+        return [...newQueue, newEntity];
+    });
+
+
+    conflictCheckQueue = // First process - Check is the file actually need resolve -
+        new QueueProcessor((files: FilePathWithPrefix[]) => {
+            const filename = files[0];
+            // const file = await this.core.storageAccess.isExists(filename);
+            // if (!file) return [];
+            // if (!(file instanceof TFile)) return;
+            // if ((file instanceof TFolder)) return [];
+            // Check again?
+            return Promise.resolve([filename]);
+            // this.conflictResolveQueue.enqueueWithKey(filename, { filename, file });
+        }, {
+            suspended: false,
+            batchSize: 1,
+            concurrentLimit: 5,
+            delay: 10,
+            keepResultUntilDownstreamConnected: true,
+            pipeTo: this.conflictResolveQueue,
+            totalRemainingReactiveSource: this.core.conflictProcessQueueCount
+        });
+
+}

src/modules/coreFeatures/ModuleConflictResolver.ts

@@ -0,0 +1,141 @@
+import { serialized } from "octagonal-wheels/concurrency/lock";
+import { AbstractModule } from "../AbstractModule.ts";
+import { AUTO_MERGED, CANCELLED, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, MISSING_OR_ERROR, NOT_CONFLICTED, type diff_check_result, type FilePathWithPrefix } from "../../lib/src/common/types";
+import { compareMTime, displayRev, TARGET_IS_NEW } from "../../common/utils";
+import diff_match_patch from "diff-match-patch";
+import { stripAllPrefixes, isPlainText } from "../../lib/src/string_and_binary/path";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleConflictResolver extends AbstractModule implements ICoreModule {
+
+    async $$resolveConflictByDeletingRev(path: FilePathWithPrefix, deleteRevision: string, subTitle = ""): Promise<typeof MISSING_OR_ERROR | typeof AUTO_MERGED> {
+        const title = `Resolving ${subTitle ? `[${subTitle}]` : ""}:`;
+        if (!await this.core.fileHandler.deleteRevisionFromDB(path, deleteRevision)) {
+            this._log(`${title} Could not delete conflicted revision ${displayRev(deleteRevision)} of ${path}`, LOG_LEVEL_NOTICE);
+            return MISSING_OR_ERROR;
+        }
+        this._log(`${title} Conflicted revision deleted ${displayRev(deleteRevision)} ${path}`, LOG_LEVEL_INFO);
+        if ((await this.core.databaseFileAccess.getConflictedRevs(path)).length != 0) {
+            this._log(`${title} some conflicts are left in ${path}`, LOG_LEVEL_INFO);
+            return AUTO_MERGED;
+        }
+        // If no conflicts were found, write the resolved content to the storage.
+        if (!await this.core.fileHandler.dbToStorage(path, stripAllPrefixes(path), true)) {
+            this._log(`Could not write the resolved content to the storage: ${path}`, LOG_LEVEL_NOTICE);
+            return MISSING_OR_ERROR;
+        }
+        this._log(`${path} Has been merged automatically`, LOG_LEVEL_NOTICE);
+        return AUTO_MERGED;
+    }
+
+
+    async checkConflictAndPerformAutoMerge(path: FilePathWithPrefix): Promise<diff_check_result> {
+        //
+        const ret = await this.localDatabase.tryAutoMerge(path, !this.settings.disableMarkdownAutoMerge);
+        if ("ok" in ret) {
+            return ret.ok;
+        }
+
+        if ("result" in ret) {
+            const p = ret.result;
+            // Merged content is coming.
+            // 1. Store the merged content to the storage
+            if (!await this.core.databaseFileAccess.storeContent(path, p)) {
+                this._log(`Merged content cannot be stored:${path}`, LOG_LEVEL_NOTICE);
+                return MISSING_OR_ERROR;
+            }
+            // 2. As usual, delete the conflicted revision and if there are no conflicts, write the resolved content to the storage.
+            return await this.core.$$resolveConflictByDeletingRev(path, ret.conflictedRev, "Sensible");
+        }
+
+        const { rightRev, leftLeaf, rightLeaf } = ret;
+
+        // should be one or more conflicts;
+        if (leftLeaf == false) {
+            // what's going on..
+            this._log(`could not get current revisions:${path}`, LOG_LEVEL_NOTICE);
+            return MISSING_OR_ERROR;
+        }
+        if (rightLeaf == false) {
+            // Conflicted item could not load, delete this.
+            return await this.core.$$resolveConflictByDeletingRev(path, rightRev, "MISSING OLD REV");
+        }
+
+        const isSame = leftLeaf.data == rightLeaf.data && leftLeaf.deleted == rightLeaf.deleted;
+        const isBinary = !isPlainText(path);
+        const alwaysNewer = this.settings.resolveConflictsByNewerFile;
+        if (isSame || isBinary || alwaysNewer) {
+            const result = compareMTime(leftLeaf.mtime, rightLeaf.mtime)
+            let loser = leftLeaf;
+            // if (lMtime > rMtime) {
+            if (result != TARGET_IS_NEW) {
+                loser = rightLeaf;
+            }
+            const subTitle = [`${isSame ? "same" : ""}`, `${isBinary ? "binary" : ""}`, `${alwaysNewer ? "alwaysNewer" : ""}`].join(",");
+            return await this.core.$$resolveConflictByDeletingRev(path, loser.rev, subTitle);
+        }
+        // make diff.
+        const dmp = new diff_match_patch();
+        const diff = dmp.diff_main(leftLeaf.data, rightLeaf.data);
+        dmp.diff_cleanupSemantic(diff);
+        this._log(`conflict(s) found:${path}`);
+        return {
+            left: leftLeaf,
+            right: rightLeaf,
+            diff: diff,
+        };
+    }
+
+
+
+    async $$resolveConflict(filename: FilePathWithPrefix): Promise<void> {
+        // const filename = filenames[0];
+        return await serialized(`conflict-resolve:${filename}`, async () => {
+            const conflictCheckResult = await this.checkConflictAndPerformAutoMerge(filename);
+            if (conflictCheckResult === MISSING_OR_ERROR || conflictCheckResult === NOT_CONFLICTED || conflictCheckResult === CANCELLED) {
+                // nothing to do.
+                this._log(`conflict:Nothing to do:${filename}`);
+                return;
+            }
+            if (conflictCheckResult === AUTO_MERGED) {
+                //auto resolved, but need check again;
+                if (this.settings.syncAfterMerge && !this.core.suspended) {
+                    //Wait for the running replication, if not running replication, run it once.
+                    await this.core.$$waitForReplicationOnce();
+                }
+                this._log("conflict:Automatically merged, but we have to check it again");
+                await this.core.$$queueConflictCheck(filename);
+                return;
+            }
+            if (this.settings.showMergeDialogOnlyOnActive) {
+                const af = this.core.$$getActiveFilePath();
+                if (af && af != filename) {
+                    this._log(`${filename} is conflicted. Merging process has been postponed to the file have got opened.`, LOG_LEVEL_NOTICE);
+                    return;
+                }
+            }
+            this._log("conflict:Manual merge required!");
+            await this.core.$anyResolveConflictByUI(filename, conflictCheckResult);
+        });
+    }
+
+    async $anyResolveConflictByNewest(filename: FilePathWithPrefix): Promise<boolean> {
+        const revs = await this.core.databaseFileAccess.getConflictedRevs(filename);
+        if (revs.length == 0) {
+            return Promise.resolve(true);
+        }
+        const mTimeAndRev = (await Promise.all(revs.map(async (rev) => {
+            const leaf = await this.core.databaseFileAccess.fetchEntryMeta(filename, rev);
+            if (leaf == false) {
+                return [0, rev] as [number, string];
+            }
+            return [leaf.mtime, rev] as [number, string];
+        }))).sort((a, b) => b[0] - a[0]);
+        this._log(`Resolving conflict by newest: ${filename} (Newest: ${new Date(mTimeAndRev[0][0]).toLocaleString()}) (${mTimeAndRev.length} revisions exists)`);
+        for (let i = 1; i < mTimeAndRev.length; i++) {
+            this._log(`conflict: Deleting the older revision ${mTimeAndRev[i][1]} (${new Date(mTimeAndRev[i][0]).toLocaleString()}) of ${filename}`);
+            await this.core.$$resolveConflictByDeletingRev(filename, mTimeAndRev[i][1], "NEWEST");
+        }
+        return true;
+    }
+}

src/modules/coreFeatures/ModuleRedFlag.ts

@@ -0,0 +1,112 @@
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { normalizePath } from "../../deps.ts";
+import { FLAGMD_REDFLAG, FLAGMD_REDFLAG2, FLAGMD_REDFLAG2_HR, FLAGMD_REDFLAG3, FLAGMD_REDFLAG3_HR } from "../../lib/src/common/types.ts";
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleRedFlag extends AbstractModule implements ICoreModule {
+
+    async isFlagFileExist(path: string) {
+        const redflag = await this.core.storageAccess.isExists(normalizePath(path));
+        if (redflag) {
+            return true;
+        }
+        return false;
+    }
+
+    async deleteFlagFile(path: string) {
+        try {
+            const isFlagged = await this.core.storageAccess.isExists(normalizePath(path));
+            if (isFlagged) {
+                await this.core.storageAccess.delete(path, true);
+            }
+        } catch (ex) {
+            this._log(`Could not delete ${path}`);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+    }
+
+    isRedFlagRaised = async () => await this.isFlagFileExist(FLAGMD_REDFLAG)
+    isRedFlag2Raised = async () => await this.isFlagFileExist(FLAGMD_REDFLAG2) || await this.isFlagFileExist(FLAGMD_REDFLAG2_HR)
+    isRedFlag3Raised = async () => await this.isFlagFileExist(FLAGMD_REDFLAG3) || await this.isFlagFileExist(FLAGMD_REDFLAG3_HR)
+
+    async deleteRedFlag2() {
+        await this.deleteFlagFile(FLAGMD_REDFLAG2);
+        await this.deleteFlagFile(FLAGMD_REDFLAG2_HR);
+    }
+
+    async deleteRedFlag3() {
+        await this.deleteFlagFile(FLAGMD_REDFLAG3);
+        await this.deleteFlagFile(FLAGMD_REDFLAG3_HR);
+    }
+    async $everyOnLayoutReady(): Promise<boolean> {
+        try {
+            const isRedFlagRaised = await this.isRedFlagRaised();
+            const isRedFlag2Raised = await this.isRedFlag2Raised();
+            const isRedFlag3Raised = await this.isRedFlag3Raised();
+
+            if (isRedFlagRaised || isRedFlag2Raised || isRedFlag3Raised) {
+                if (isRedFlag2Raised) {
+                    if (await this.core.confirm.askYesNoDialog("Rebuild everything has been scheduled! Are you sure to rebuild everything?", { defaultOption: "Yes", timeout: 0 }) !== "yes") {
+                        await this.deleteRedFlag2();
+                        await this.core.$$performRestart();
+                        return false;
+                    }
+                }
+                if (isRedFlag3Raised) {
+                    if (await this.core.confirm.askYesNoDialog("Fetch again has been scheduled! Are you sure?", { defaultOption: "Yes", timeout: 0 }) !== "yes") {
+                        await this.deleteRedFlag3();
+                        await this.core.$$performRestart();
+                        return false;
+                    }
+                }
+                this.settings.batchSave = false;
+                await this.core.$allSuspendAllSync();
+                await this.core.$allSuspendExtraSync();
+                this.settings.suspendFileWatching = true;
+                await this.saveSettings();
+                if (isRedFlag2Raised) {
+                    this._log(`${FLAGMD_REDFLAG2} or ${FLAGMD_REDFLAG2_HR} has been detected! Self-hosted LiveSync suspends all sync and rebuild everything.`, LOG_LEVEL_NOTICE);
+                    await this.core.rebuilder.$rebuildEverything();
+                    await this.deleteRedFlag2();
+                    if (await this.core.confirm.askYesNoDialog("Do you want to resume file and database processing, and restart obsidian now?", { defaultOption: "Yes", timeout: 15 }) == "yes") {
+                        this.settings.suspendFileWatching = false;
+                        await this.saveSettings();
+                        this.core.$$performRestart();
+                        return false;
+                    }
+                } else if (isRedFlag3Raised) {
+                    this._log(`${FLAGMD_REDFLAG3} or ${FLAGMD_REDFLAG3_HR} has been detected! Self-hosted LiveSync will discard the local database and fetch everything from the remote once again.`, LOG_LEVEL_NOTICE);
+                    const makeLocalChunkBeforeSync = ((await this.core.confirm.askYesNoDialog(`Do you want to create local chunks before fetching? 
+> [!MORE]-
+> If creating local chunks before fetching, only the difference between the local and remote will be fetched.
+
+`, { defaultOption: "Yes", title: "Trick to transfer efficiently" })) == "yes");
+                    await this.core.rebuilder.$fetchLocal(makeLocalChunkBeforeSync);
+                    await this.deleteRedFlag3();
+                    if (this.settings.suspendFileWatching) {
+                        if (await this.core.confirm.askYesNoDialog("Do you want to resume file and database processing, and restart obsidian now?", { defaultOption: "Yes", timeout: 15 }) == "yes") {
+                            this.settings.suspendFileWatching = false;
+                            await this.saveSettings();
+                            this.core.$$performRestart();
+                            return false;
+                        }
+                    } else {
+                        this._log("Your content of files will be synchronised gradually. Please wait for the completion.", LOG_LEVEL_NOTICE);
+                    }
+                } else {
+                    // Case of FLAGMD_REDFLAG.
+                    this.settings.writeLogToTheFile = true;
+                    // await this.plugin.openDatabase();
+                    const warningMessage = "The red flag is raised! The whole initialize steps are skipped, and any file changes are not captured.";
+                    this._log(warningMessage, LOG_LEVEL_NOTICE);
+                }
+            }
+        } catch (ex) {
+            this._log("Something went wrong on FlagFile Handling", LOG_LEVEL_NOTICE);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+        return true;
+    }
+
+}

src/modules/coreFeatures/ModuleRemoteGovernor.ts

@@ -0,0 +1,16 @@
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleRemoteGovernor extends AbstractModule implements ICoreModule {
+    async $$markRemoteLocked(lockByClean: boolean = false): Promise<void> {
+        return await this.core.replicator.markRemoteLocked(this.settings, true, lockByClean);
+    }
+
+    async $$markRemoteUnlocked(): Promise<void> {
+        return await this.core.replicator.markRemoteLocked(this.settings, false, false);
+    }
+
+    async $$markRemoteResolved(): Promise<void> {
+        return await this.core.replicator.markRemoteResolved(this.settings);
+    }
+}

src/modules/coreFeatures/ModuleResolveMismatchedTweaks.ts

@@ -0,0 +1,97 @@
+import { Logger, LOG_LEVEL_NOTICE } from "octagonal-wheels/common/logger";
+import { extractObject } from "octagonal-wheels/object";
+import { TweakValuesShouldMatchedTemplate, CompatibilityBreakingTweakValues, confName, type TweakValues } from "../../lib/src/common/types.ts";
+import { escapeMarkdownValue } from "../../lib/src/common/utils.ts";
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleResolvingMismatchedTweaks extends AbstractModule implements ICoreModule {
+    async $anyAfterConnectCheckFailed(): Promise<boolean | "CHECKAGAIN" | undefined> {
+        if (!this.core.replicator.tweakSettingsMismatched) return false;
+        const ret = await this.core.$$askResolvingMismatchedTweaks();
+        if (ret == "OK") return false;
+        if (ret == "CHECKAGAIN") return "CHECKAGAIN";
+        if (ret == "IGNORE") return true;
+    }
+
+    async $$askResolvingMismatchedTweaks(): Promise<"OK" | "CHECKAGAIN" | "IGNORE"> {
+        if (!this.core.replicator.tweakSettingsMismatched) {
+            return "OK";
+        }
+        const preferred = extractObject(TweakValuesShouldMatchedTemplate, this.core.replicator.preferredTweakValue!);
+        const mine = extractObject(TweakValuesShouldMatchedTemplate, this.settings);
+        const items = Object.entries(TweakValuesShouldMatchedTemplate);
+        let rebuildRequired = false;
+
+        // Making tables:
+        let table = `| Value name | This device | Configured | \n` + `|: --- |: --- :|: ---- :| \n`;
+
+        // const items = [mine,preferred]
+        for (const v of items) {
+            const key = v[0] as keyof typeof TweakValuesShouldMatchedTemplate;
+            const valueMine = escapeMarkdownValue(mine[key]);
+            const valuePreferred = escapeMarkdownValue(preferred[key]);
+            if (valueMine == valuePreferred) continue;
+            if (CompatibilityBreakingTweakValues.indexOf(key) !== -1) {
+                rebuildRequired = true;
+            }
+            table += `| ${confName(key)} | ${valueMine} | ${valuePreferred} | \n`;
+        }
+
+        const additionalMessage = rebuildRequired ? `
+
+**Note**: We have detected that some of the values are different to make incompatible the local database with the remote database.
+If you choose to use the configured values, the local database will be rebuilt, and if you choose to use the values of this device, the remote database will be rebuilt. 
+Both of them takes a few minutes. Please choose after considering the situation.` : "";
+
+        const message = `
+Your configuration has not been matched with the one on the remote server.
+(Which you had decided once before, or set by initially synchronised device).
+
+Configured values:
+
+${table}
+
+Please select which one you want to use.
+
+- Use configured: Update settings of this device by configured one on the remote server.
+  You should select this if you have changed the settings on ** another device **.
+- Update with mine: Update settings on the remote server by the settings of this device.
+  You should select this if you have changed the settings on ** this device **.
+- Dismiss: Ignore this message and keep the current settings.
+  You cannot synchronise until you resolve this issue without enabling \`Do not check configuration mismatch before replication\`.${additionalMessage}`;
+
+        const CHOICE_USE_REMOTE = "Use configured";
+        const CHOICE_USR_MINE = "Update with mine";
+        const CHOICE_DISMISS = "Dismiss";
+        const CHOICE_AND_VALUES = [
+            [CHOICE_USE_REMOTE, preferred],
+            [CHOICE_USR_MINE, true],
+            [CHOICE_DISMISS, false]]
+        const CHOICES = Object.fromEntries(CHOICE_AND_VALUES) as Record<string, TweakValues | boolean>;
+        const retKey = await this.core.confirm.confirmWithMessage("Tweaks Mismatched or Changed", message, Object.keys(CHOICES), CHOICE_DISMISS, 60);
+        if (!retKey) return "IGNORE";
+        const conf = CHOICES[retKey];
+
+        if (conf === true) {
+            await this.core.replicator.setPreferredRemoteTweakSettings(this.settings);
+            if (rebuildRequired) {
+                await this.core.rebuilder.$rebuildRemote();
+            }
+            Logger(`Tweak values on the remote server have been updated. Your other device will see this message.`, LOG_LEVEL_NOTICE);
+            return "CHECKAGAIN";
+        }
+        if (conf) {
+            this.settings = { ...this.settings, ...conf };
+            await this.core.replicator.setPreferredRemoteTweakSettings(this.settings);
+            await this.core.$$saveSettingData();
+            if (rebuildRequired) {
+                await this.core.rebuilder.$fetchLocal();
+            }
+            Logger(`Configuration has been updated as configured by the other device.`, LOG_LEVEL_NOTICE);
+            return "CHECKAGAIN";
+        }
+        return "IGNORE";
+
+    }
+}

src/modules/coreObsidian/ModuleFileAccessObsidian.ts

@@ -0,0 +1,326 @@
+import { normalizePath, TFile, TFolder, type ListedFiles } from "obsidian";
+import { SerializedFileAccess } from "./storageLib/SerializedFileAccess";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { LOG_LEVEL_INFO, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import type { FilePath, FilePathWithPrefix, UXDataWriteOptions, UXFileInfo, UXFileInfoStub, UXFolderInfo, UXStat } from "../../lib/src/common/types";
+import { TFileToUXFileInfoStub, TFolderToUXFileInfoStub } from "./storageLib/utilObsidian.ts";
+import { StorageEventManagerObsidian, type StorageEventManager } from "./storageLib/StorageEventManager";
+import type { StorageAccess } from "../interfaces/StorageAccess";
+import { createBlob } from "../../lib/src/common/utils";
+
+
+export class ModuleFileAccessObsidian extends AbstractObsidianModule implements IObsidianModule, StorageAccess {
+    vaultAccess!: SerializedFileAccess;
+    vaultManager: StorageEventManager = new StorageEventManagerObsidian(this.plugin, this.core);
+    $everyOnload(): Promise<boolean> {
+        this.core.storageAccess = this;
+        return Promise.resolve(true);
+    }
+    $everyOnFirstInitialize(): Promise<boolean> {
+        this.vaultManager.beginWatch();
+        return Promise.resolve(true);
+    }
+    $allOnUnload(): Promise<boolean> {
+        // this.vaultManager.
+        return Promise.resolve(true);
+    }
+
+    // $$flushFileEventQueue(): void {
+    //     this.vaultManager.flushQueue();
+    // }
+
+    $everyCommitPendingFileEvent(): Promise<boolean> {
+        this.vaultManager.flushQueue();
+        return Promise.resolve(true);
+    }
+
+    $everyOnloadStart(): Promise<boolean> {
+        this.vaultAccess = new SerializedFileAccess(this.app, this.plugin);
+        return Promise.resolve(true);
+    }
+
+    $$isStorageInsensitive(): boolean {
+        return this.vaultAccess.isStorageInsensitive();
+    }
+
+    async writeFileAuto(path: string, data: string | ArrayBuffer, opt?: UXDataWriteOptions): Promise<boolean> {
+        const file = this.vaultAccess.getAbstractFileByPath(path);
+        if (file instanceof TFile) {
+            return this.vaultAccess.vaultModify(file, data, opt);
+        } else if (file === null) {
+            return await this.vaultAccess.vaultCreate(path, data, opt) instanceof TFile;
+        } else {
+            this._log(`Could not write file (Possibly already exists as a folder): ${path}`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+    }
+    readFileAuto(path: string): Promise<string | ArrayBuffer> {
+        const file = this.vaultAccess.getAbstractFileByPath(path);
+        if (file instanceof TFile) {
+            return this.vaultAccess.vaultRead(file);
+        } else {
+            throw new Error(`Could not read file (Possibly does not exist): ${path}`);
+        }
+    }
+    readFileText(path: string): Promise<string> {
+        const file = this.vaultAccess.getAbstractFileByPath(path);
+        if (file instanceof TFile) {
+            return this.vaultAccess.vaultRead(file);
+        } else {
+            throw new Error(`Could not read file (Possibly does not exist): ${path}`);
+        }
+    }
+    isExists(path: string): Promise<boolean> {
+        return Promise.resolve(this.vaultAccess.getAbstractFileByPath(path) instanceof TFile);
+    }
+    async writeHiddenFileAuto(path: string, data: string | ArrayBuffer, opt?: UXDataWriteOptions): Promise<boolean> {
+        try {
+            await this.vaultAccess.adapterWrite(path, data, opt);
+            return true;
+        } catch (e) {
+            this._log(`Could not write hidden file: ${path}`, LOG_LEVEL_VERBOSE);
+            this._log(e, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+    }
+    async appendHiddenFile(path: string, data: string, opt?: UXDataWriteOptions): Promise<boolean> {
+        try {
+
+            await this.vaultAccess.adapterAppend(path, data, opt);
+            return true;
+        } catch (e) {
+            this._log(`Could not append hidden file: ${path}`, LOG_LEVEL_VERBOSE);
+            this._log(e, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+    }
+    stat(path: string): Promise<UXStat | null> {
+        const file = this.vaultAccess.getAbstractFileByPath(path);
+        if (file === null) return Promise.resolve(null);
+        if (file instanceof TFile) {
+            return Promise.resolve({
+                ctime: file.stat.ctime,
+                mtime: file.stat.mtime,
+                size: file.stat.size,
+                type: "file"
+            });
+        } else {
+            throw new Error(`Could not stat file (Possibly does not exist): ${path}`);
+        }
+
+    }
+    statHidden(path: string): Promise<UXStat | null> {
+        return this.vaultAccess.adapterStat(path);
+    }
+    async removeHidden(path: string): Promise<boolean> {
+        try {
+            await this.vaultAccess.adapterRemove(path);
+            return true;
+        } catch (e) {
+            this._log(`Could not remove hidden file: ${path}`, LOG_LEVEL_VERBOSE);
+            this._log(e, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+    }
+    async readHiddenFileAuto(path: string): Promise<string | ArrayBuffer> {
+        return await this.vaultAccess.adapterReadAuto(path);
+    }
+    async readHiddenFileText(path: string): Promise<string> {
+        return await this.vaultAccess.adapterRead(path);
+    }
+    async readHiddenFileBinary(path: string): Promise<ArrayBuffer> {
+        return await this.vaultAccess.adapterReadBinary(path);
+    }
+    async isExistsIncludeHidden(path: string): Promise<boolean> {
+        return await this.vaultAccess.adapterStat(path) !== null;
+    }
+    async ensureDir(path: string): Promise<boolean> {
+        try {
+            await this.vaultAccess.ensureDirectory(path);
+            return true;
+        } catch (e) {
+            this._log(`Could not ensure directory: ${path}`, LOG_LEVEL_VERBOSE);
+            this._log(e, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+    }
+    triggerFileEvent(event: string, path: string): void {
+        // this.app.vault.trigger("file-change", path);
+        this.vaultAccess.trigger(event, this.vaultAccess.getAbstractFileByPath(normalizePath(path)));
+    }
+    async triggerHiddenFile(path: string): Promise<void> {
+        //@ts-ignore internal function
+        await this.app.vault.adapter.reconcileInternalFile(path);
+    }
+    // getFileStub(file: TFile): UXFileInfoStub {
+    //     return  TFileToUXFileInfoStub(file);
+    // }
+    getFileStub(path: string): UXFileInfoStub | null {
+        const file = this.vaultAccess.getAbstractFileByPath(path);
+        if (file instanceof TFile) {
+            return TFileToUXFileInfoStub(file);
+        } else {
+            return null;
+        }
+    }
+    async readStubContent(stub: UXFileInfoStub): Promise<UXFileInfo | false> {
+        const file = this.vaultAccess.getAbstractFileByPath(stub.path);
+        if (!(file instanceof TFile)) {
+            this._log(`Could not read file (Possibly does not exist or a folder): ${stub.path}`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        const data = await this.vaultAccess.vaultReadAuto(file);
+        return {
+            ...stub,
+            body: createBlob(data)
+        }
+    }
+    getStub(path: string): UXFileInfoStub | UXFolderInfo | null {
+        const file = this.vaultAccess.getAbstractFileByPath(path);
+        if (file instanceof TFile) {
+            return TFileToUXFileInfoStub(file);
+        } else if (file instanceof TFolder) {
+            return TFolderToUXFileInfoStub(file);
+        }
+        return null;
+    }
+    getFiles(): UXFileInfoStub[] {
+        return this.vaultAccess.getFiles().map(f => TFileToUXFileInfoStub(f));
+    }
+    getFileNames(): FilePath[] {
+        return this.vaultAccess.getFiles().map(f => f.path as FilePath);
+    }
+
+    async getFilesIncludeHidden(
+        basePath: string,
+        includeFilter?: RegExp[],
+        excludeFilter?: RegExp[],
+        skipFolder: string[] = [".git", ".trash", "node_modules"]
+    ): Promise<FilePath[]> {
+        let w: ListedFiles;
+        try {
+            w = await this.app.vault.adapter.list(basePath);
+        } catch (ex) {
+            this._log(`Could not traverse(getFilesIncludeHidden):${basePath}`, LOG_LEVEL_INFO);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+            return [];
+        }
+        skipFolder = skipFolder.map(e => e.toLowerCase());
+
+        let files = [] as string[];
+        for (const file of w.files) {
+            if (excludeFilter && excludeFilter.some(ee => file.match(ee))) {
+                // If excludeFilter and includeFilter are both set, the file will be included in the list.
+                if (includeFilter) {
+                    if (!includeFilter.some(e => file.match(e))) continue;
+                } else {
+                    continue;
+                }
+            }
+            if (includeFilter) {
+                if (!includeFilter.some(e => file.match(e))) continue;
+            }
+            if (await this.plugin.$$isIgnoredByIgnoreFiles(file)) continue;
+            files.push(file);
+        }
+
+        for (const v of w.folders) {
+            const folderName = (v.split("/").pop() ?? "").toLowerCase();
+            if (skipFolder.some(e => folderName === e)) {
+                continue
+            }
+            if (excludeFilter && excludeFilter.some(e => v.match(e))) {
+                if (includeFilter) {
+                    if (!includeFilter.some(e => v.match(e))) {
+                        continue;
+                    }
+                }
+            }
+
+            if (includeFilter) {
+                if (!includeFilter.some(e => v.match(e))) continue;
+            }
+            // OK, deep dive!
+            files = files.concat(await this.getFilesIncludeHidden(v, includeFilter, excludeFilter, skipFolder));
+        }
+        return files as FilePath[];
+    }
+    touched(file: UXFileInfoStub | FilePathWithPrefix): void {
+        const path = typeof file === "string" ? file : file.path;
+        this.vaultAccess.touch(path as FilePath);
+    }
+    recentlyTouched(file: UXFileInfoStub | FilePathWithPrefix): boolean {
+        const xFile = typeof file === "string" ? this.vaultAccess.getAbstractFileByPath(file) as TFile : file;
+        if (xFile === null) return false;
+        if (xFile instanceof TFolder) return false;
+        return this.vaultAccess.recentlyTouched(xFile);
+    }
+    clearTouched(): void {
+        this.vaultAccess.clearTouched();
+    }
+
+    delete(file: FilePathWithPrefix | UXFileInfoStub | string, force: boolean): Promise<void> {
+        const xPath = typeof file === "string" ? file : file.path;
+        const xFile = this.vaultAccess.getAbstractFileByPath(xPath);
+        if (xFile === null) return Promise.resolve();
+        if (!(xFile instanceof TFile) && !(xFile instanceof TFolder)) return Promise.resolve();
+        return this.vaultAccess.delete(xFile, force);
+    }
+    trash(file: FilePathWithPrefix | UXFileInfoStub | string, system: boolean): Promise<void> {
+        const xPath = typeof file === "string" ? file : file.path;
+        const xFile = this.vaultAccess.getAbstractFileByPath(xPath);
+        if (xFile === null) return Promise.resolve();
+        if (!(xFile instanceof TFile) && !(xFile instanceof TFolder)) return Promise.resolve();
+        return this.vaultAccess.trash(xFile, system);
+    }
+    // $readFileBinary(path: string): Promise<ArrayBuffer> {
+    //     const file = this.vaultAccess.getAbstractFileByPath(path);
+    //     if (file instanceof TFile) {
+    //         return this.vaultAccess.vaultReadBinary(file);
+    //     } else {
+    //         throw new Error(`Could not read file (Possibly does not exist): ${path}`);
+    //     }
+    // }
+    // async $appendFileAuto(path: string, data: string | ArrayBuffer, opt?: DataWriteOptions): Promise<boolean> {
+    //     const file = this.vaultAccess.getAbstractFileByPath(path);
+    //     if (file instanceof TFile) {
+    //         return this.vaultAccess.a(file, data, opt);
+    //     } else if (file !== null) {
+    //         return await this.vaultAccess.vaultCreate(path, data, opt) instanceof TFile;
+    //     } else {
+    //         this._log(`Could not append file (Possibly already exists as a folder): ${path}`, LOG_LEVEL_VERBOSE);
+    //         return false;
+    //     }
+    // }
+
+    async _deleteVaultItem(file: TFile | TFolder) {
+        if (file instanceof TFile) {
+            if (!await this.core.$$isTargetFile(file.path)) return;
+        }
+        const dir = file.parent;
+        if (this.settings.trashInsteadDelete) {
+            await this.vaultAccess.trash(file, false);
+        } else {
+            await this.vaultAccess.delete(file, true);
+        }
+        this._log(`xxx <- STORAGE (deleted) ${file.path}`);
+        if (dir) {
+            this._log(`files: ${dir.children.length}`);
+            if (dir.children.length == 0) {
+                if (!this.settings.doNotDeleteFolder) {
+                    this._log(`All files under the parent directory (${dir.path}) have been deleted, so delete this one.`);
+                    await this._deleteVaultItem(dir);
+                }
+            }
+        }
+    }
+
+    async deleteVaultItem(fileSrc: FilePathWithPrefix | UXFileInfoStub | UXFolderInfo): Promise<void> {
+        const path = typeof fileSrc === "string" ? fileSrc : fileSrc.path;
+        const file = this.vaultAccess.getAbstractFileByPath(path);
+        if (file === null) return;
+        if (file instanceof TFile || file instanceof TFolder) {
+            return await this._deleteVaultItem(file);
+        }
+    }
+}

src/modules/coreObsidian/ModuleInputUIObsidian.ts

@@ -0,0 +1,71 @@
+import { AbstractObsidianModule, type IObsidianModule } from '../AbstractObsidianModule.ts';
+import { scheduleTask } from 'octagonal-wheels/concurrency/task';
+import { disposeMemoObject, memoIfNotExist, memoObject, retrieveMemoObject } from '../../common/utils.ts';
+import { askSelectString, askString, askYesNo, confirmWithMessage, confirmWithMessageWithWideButton } from './UILib/dialogs.ts';
+import { Notice } from '../../deps.ts';
+import type { Confirm } from '../interfaces/Confirm.ts';
+
+// This module cannot be a common module because it depends on Obsidian's API.
+// However, we have to make compatible one for other platform.
+
+export class ModuleInputUIObsidian extends AbstractObsidianModule implements IObsidianModule, Confirm {
+
+    $everyOnload(): Promise<boolean> {
+        this.core.confirm = this;
+        return Promise.resolve(true);
+    }
+
+    askYesNo(message: string): Promise<"yes" | "no"> {
+        return askYesNo(this.app, message);
+    }
+    askString(title: string, key: string, placeholder: string, isPassword: boolean = false): Promise<string | false> {
+        return askString(this.app, title, key, placeholder, isPassword);
+    }
+
+    async askYesNoDialog(message: string, opt: { title?: string, defaultOption?: "Yes" | "No", timeout?: number } = { title: "Confirmation" }): Promise<"yes" | "no"> {
+        const ret = await confirmWithMessageWithWideButton(this.plugin, opt.title || "Confirmation", message, ["Yes", "No"], opt.defaultOption ?? "No", opt.timeout);
+        return ret == "Yes" ? "yes" : "no";
+    }
+
+    askSelectString(message: string, items: string[]): Promise<string> {
+        return askSelectString(this.app, message, items);
+    }
+
+    askSelectStringDialogue(message: string, buttons: string[], opt: { title?: string, defaultAction: (typeof buttons)[number], timeout?: number }): Promise<(typeof buttons)[number] | false> {
+        return confirmWithMessageWithWideButton(this.plugin, opt.title || "Select", message, buttons, opt.defaultAction, opt.timeout);
+    }
+
+    askInPopup(key: string, dialogText: string, anchorCallback: (anchor: HTMLAnchorElement) => void) {
+        const fragment = createFragment((doc) => {
+            const [beforeText, afterText] = dialogText.split("{HERE}", 2);
+            doc.createEl("span", undefined, (a) => {
+                a.appendText(beforeText);
+                a.appendChild(a.createEl("a", undefined, (anchor) => {
+                    anchorCallback(anchor);
+                }));
+                a.appendText(afterText);
+            });
+        });
+        const popupKey = "popup-" + key;
+        scheduleTask(popupKey, 1000, async () => {
+            const popup = await memoIfNotExist(popupKey, () => new Notice(fragment, 0));
+            const isShown = popup?.noticeEl?.isShown();
+            if (!isShown) {
+                memoObject(popupKey, new Notice(fragment, 0));
+            }
+            scheduleTask(popupKey + "-close", 20000, () => {
+                const popup = retrieveMemoObject<Notice>(popupKey);
+                if (!popup)
+                    return;
+                if (popup?.noticeEl?.isShown()) {
+                    popup.hide();
+                }
+                disposeMemoObject(popupKey);
+            });
+        });
+    }
+    confirmWithMessage(title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout?: number): Promise<(typeof buttons)[number] | false> {
+        return confirmWithMessage(this.plugin, title, contentMd, buttons, defaultAction, timeout);
+    }
+
+}

src/modules/coreObsidian/UILib/dialogs.ts

@@ -0,0 +1,281 @@
+import { ButtonComponent } from "obsidian";
+import { App, FuzzySuggestModal, MarkdownRenderer, Modal, Plugin, Setting } from "../../../deps.ts";
+import { EVENT_PLUGIN_UNLOADED, eventHub } from "../../../common/events.ts";
+import { delay } from "octagonal-wheels/promises";
+
+class AutoClosableModal extends Modal {
+    removeEvent: (() => void) | undefined;
+
+    constructor(app: App) {
+        super(app);
+        this.removeEvent = eventHub.on(EVENT_PLUGIN_UNLOADED, async () => {
+            await delay(100);
+            if (!this.removeEvent) return;
+            this.close();
+            this.removeEvent = undefined;
+        });
+    }
+    onClose() {
+        if (this.removeEvent) {
+            this.removeEvent();
+            this.removeEvent = undefined
+        }
+    }
+}
+
+export class InputStringDialog extends AutoClosableModal {
+    result: string | false = false;
+    onSubmit: (result: string | false) => void;
+    title: string;
+    key: string;
+    placeholder: string;
+    isManuallyClosed = false;
+    isPassword = false;
+
+    constructor(app: App, title: string, key: string, placeholder: string, isPassword: boolean, onSubmit: (result: string | false) => void) {
+        super(app);
+        this.onSubmit = onSubmit;
+        this.title = title;
+        this.placeholder = placeholder;
+        this.key = key;
+        this.isPassword = isPassword;
+    }
+
+    onOpen() {
+        const { contentEl } = this;
+        this.titleEl.setText(this.title);
+        const formEl = contentEl.createDiv();
+        new Setting(formEl).setName(this.key).setClass(this.isPassword ? "password-input" : "normal-input").addText((text) =>
+            text.onChange((value) => {
+                this.result = value;
+            })
+        );
+        new Setting(formEl).addButton((btn) =>
+            btn
+                .setButtonText("Ok")
+                .setCta()
+                .onClick(() => {
+                    this.isManuallyClosed = true;
+                    this.close();
+                })
+        ).addButton((btn) =>
+            btn
+                .setButtonText("Cancel")
+                .setCta()
+                .onClick(() => {
+                    this.close();
+                })
+        );
+    }
+
+    onClose() {
+        super.onClose();
+        const { contentEl } = this;
+        contentEl.empty();
+        if (this.isManuallyClosed) {
+            this.onSubmit(this.result);
+        } else {
+            this.onSubmit(false);
+        }
+    }
+}
+export class PopoverSelectString extends FuzzySuggestModal<string> {
+    app: App;
+    callback: ((e: string) => void) | undefined = () => { };
+    getItemsFun: () => string[] = () => {
+        return ["yes", "no"];
+
+    }
+
+    constructor(app: App, note: string, placeholder: string | undefined, getItemsFun: (() => string[]) | undefined, callback: (e: string) => void) {
+        super(app);
+        this.app = app;
+        this.setPlaceholder((placeholder ?? "y/n) ") + note);
+        if (getItemsFun) this.getItemsFun = getItemsFun;
+        this.callback = callback;
+    }
+
+    getItems(): string[] {
+        return this.getItemsFun();
+    }
+
+    getItemText(item: string): string {
+        return item;
+    }
+
+    onChooseItem(item: string, evt: MouseEvent | KeyboardEvent): void {
+        // debugger;
+        this.callback?.(item);
+        this.callback = undefined;
+    }
+    onClose(): void {
+        setTimeout(() => {
+            if (this.callback) {
+                this.callback("");
+                this.callback = undefined;
+            }
+        }, 100);
+    }
+}
+
+export class MessageBox extends AutoClosableModal {
+
+    plugin: Plugin;
+    title: string;
+    contentMd: string;
+    buttons: string[];
+    result: string | false = false;
+    isManuallyClosed = false;
+    defaultAction: string | undefined;
+    timeout: number | undefined;
+    timer: ReturnType<typeof setInterval> | undefined = undefined;
+    defaultButtonComponent: ButtonComponent | undefined;
+    wideButton: boolean;
+
+    onSubmit: (result: string | false) => void;
+
+    constructor(plugin: Plugin, title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout: number | undefined, wideButton: boolean, onSubmit: (result: (typeof buttons)[number] | false) => void) {
+        super(plugin.app);
+        this.plugin = plugin;
+        this.title = title;
+        this.contentMd = contentMd;
+        this.buttons = buttons;
+        this.onSubmit = onSubmit;
+        this.defaultAction = defaultAction;
+        this.timeout = timeout;
+        this.wideButton = wideButton;
+        if (this.timeout) {
+            this.timer = setInterval(() => {
+                if (this.timeout === undefined) return;
+                this.timeout--;
+                if (this.timeout < 0) {
+                    if (this.timer) {
+                        clearInterval(this.timer);
+                        this.defaultButtonComponent?.setButtonText(`${defaultAction}`);
+                        this.timer = undefined;
+                    }
+                    this.result = defaultAction;
+                    this.isManuallyClosed = true;
+                    this.close();
+                } else {
+                    this.defaultButtonComponent?.setButtonText(`( ${this.timeout} ) ${defaultAction}`);
+                }
+            }, 1000);
+        }
+    }
+
+    onOpen() {
+        const { contentEl } = this;
+        this.titleEl.setText(this.title);
+        const div = contentEl.createDiv();
+        div.style.userSelect = "text";
+        void MarkdownRenderer.render(this.plugin.app, this.contentMd, div, "/", this.plugin);
+        const buttonSetting = new Setting(contentEl);
+        const labelWrapper = contentEl.createDiv();
+        labelWrapper.addClass("sls-dialogue-note-wrapper");
+        const labelEl = labelWrapper.createEl("label", { text: "To stop the countdown, tap anywhere on the dialogue" });
+        labelEl.addClass("sls-dialogue-note-countdown");
+        if (!this.timeout || !this.timer) {
+            labelWrapper.empty();
+            labelWrapper.style.display = "none";
+        }
+
+        buttonSetting.infoEl.style.display = "none";
+        buttonSetting.controlEl.style.flexWrap = "wrap";
+        if (this.wideButton) {
+            buttonSetting.controlEl.style.flexDirection = "column";
+            buttonSetting.controlEl.style.alignItems = "center";
+            buttonSetting.controlEl.style.justifyContent = "center";
+            buttonSetting.controlEl.style.flexGrow = "1";
+        }
+        contentEl.addEventListener("click", () => {
+            if (this.timer) {
+                labelWrapper.empty();
+                labelWrapper.style.display = "none";
+                clearInterval(this.timer);
+                this.timer = undefined;
+                this.defaultButtonComponent?.setButtonText(`${this.defaultAction}`);
+            }
+        })
+        for (const button of this.buttons) {
+            buttonSetting.addButton((btn) => {
+                btn
+                    .setButtonText(button)
+                    .onClick(() => {
+                        this.isManuallyClosed = true;
+                        this.result = button;
+                        if (this.timer) {
+                            clearInterval(this.timer);
+                            this.timer = undefined;
+                        }
+                        this.close();
+                    })
+                if (button == this.defaultAction) {
+                    this.defaultButtonComponent = btn;
+                    btn.setCta();
+                }
+                if (this.wideButton) {
+                    btn.buttonEl.style.flexGrow = "1";
+                    btn.buttonEl.style.width = "100%";
+                }
+                return btn;
+            }
+            )
+        }
+    }
+
+    onClose() {
+        super.onClose();
+        const { contentEl } = this;
+        contentEl.empty();
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+        if (this.isManuallyClosed) {
+            this.onSubmit(this.result);
+        } else {
+            this.onSubmit(false);
+        }
+    }
+}
+
+
+
+
+export function confirmWithMessage(plugin: Plugin, title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout?: number): Promise<(typeof buttons)[number] | false> {
+    return new Promise((res) => {
+        const dialog = new MessageBox(plugin, title, contentMd, buttons, defaultAction, timeout, false, (result) => res(result));
+        dialog.open();
+    });
+}
+export function confirmWithMessageWithWideButton(plugin: Plugin, title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout?: number): Promise<(typeof buttons)[number] | false> {
+    return new Promise((res) => {
+        const dialog = new MessageBox(plugin, title, contentMd, buttons, defaultAction, timeout, true, (result) => res(result));
+        dialog.open();
+    });
+}
+
+export const askYesNo = (app: App, message: string): Promise<"yes" | "no"> => {
+    return new Promise((res) => {
+        const popover = new PopoverSelectString(app, message, undefined, undefined, (result) => res(result as "yes" | "no"));
+        popover.open();
+    });
+};
+
+export const askSelectString = (app: App, message: string, items: string[]): Promise<string> => {
+    const getItemsFun = () => items;
+    return new Promise((res) => {
+        const popover = new PopoverSelectString(app, message, "", getItemsFun, (result) => res(result));
+        popover.open();
+    });
+};
+
+
+export const askString = (app: App, title: string, key: string, placeholder: string, isPassword: boolean = false): Promise<string | false> => {
+    return new Promise((res) => {
+        const dialog = new InputStringDialog(app, title, key, placeholder, isPassword, (result) => res(result));
+        dialog.open();
+    });
+};
+

src/modules/coreObsidian/storageLib/SerializedFileAccess.ts

@@ -0,0 +1,209 @@
+import { type App, TFile, type DataWriteOptions, TFolder, TAbstractFile } from "../../../deps.ts";
+import { serialized } from "../../../lib/src/concurrency/lock.ts";
+import { Logger } from "../../../lib/src/common/logger.ts";
+import { isPlainText } from "../../../lib/src/string_and_binary/path.ts";
+import type { FilePath, HasSettings, UXFileInfoStub } from "../../../lib/src/common/types.ts";
+import { createBinaryBlob, isDocContentSame } from "../../../lib/src/common/utils.ts";
+import type { InternalFileInfo } from "../../../common/types.ts";
+import { markChangesAreSame } from "../../../common/utils.ts";
+import { type UXFileInfo } from "../../../lib/src/common/types.ts";
+
+function getFileLockKey(file: TFile | TFolder | string | UXFileInfo) {
+    return `fl:${typeof (file) == "string" ? file : file.path}`;
+}
+function toArrayBuffer(arr: Uint8Array | ArrayBuffer | DataView): ArrayBufferLike {
+    if (arr instanceof Uint8Array) {
+        return arr.buffer;
+    }
+    if (arr instanceof DataView) {
+        return arr.buffer;
+    }
+    return arr;
+}
+
+// function isFile(file: TFile | TFolder | string | UXFileInfo): boolean {
+//     file instanceof TFile;
+// }
+
+async function processReadFile<T>(file: TFile | TFolder | string | UXFileInfo, proc: () => Promise<T>) {
+    const ret = await serialized(getFileLockKey(file), () => proc());
+    return ret;
+}
+async function processWriteFile<T>(file: TFile | TFolder | string | UXFileInfo, proc: () => Promise<T>) {
+    const ret = await serialized(getFileLockKey(file), () => proc());
+    return ret;
+}
+
+export class SerializedFileAccess {
+    app: App
+    plugin: HasSettings<{ handleFilenameCaseSensitive: boolean }>
+    constructor(app: App, plugin: typeof this["plugin"]) {
+        this.app = app;
+        this.plugin = plugin;
+    }
+
+    async adapterStat(file: TFile | string) {
+        const path = file instanceof TFile ? file.path : file;
+        return await processReadFile(file, () => this.app.vault.adapter.stat(path));
+    }
+    async adapterExists(file: TFile | string) {
+        const path = file instanceof TFile ? file.path : file;
+        return await processReadFile(file, () => this.app.vault.adapter.exists(path));
+    }
+    async adapterRemove(file: TFile | string) {
+        const path = file instanceof TFile ? file.path : file;
+        return await processReadFile(file, () => this.app.vault.adapter.remove(path));
+    }
+
+    async adapterRead(file: TFile | string) {
+        const path = file instanceof TFile ? file.path : file;
+        return await processReadFile(file, () => this.app.vault.adapter.read(path));
+    }
+    async adapterReadBinary(file: TFile | string) {
+        const path = file instanceof TFile ? file.path : file;
+        return await processReadFile(file, () => this.app.vault.adapter.readBinary(path));
+    }
+
+    async adapterReadAuto(file: TFile | string) {
+        const path = file instanceof TFile ? file.path : file;
+        if (isPlainText(path)) return await processReadFile(file, () => this.app.vault.adapter.read(path));
+        return await processReadFile(file, () => this.app.vault.adapter.readBinary(path));
+    }
+
+    async adapterWrite(file: TFile | string, data: string | ArrayBuffer | Uint8Array, options?: DataWriteOptions) {
+        const path = file instanceof TFile ? file.path : file;
+        if (typeof (data) === "string") {
+            return await processWriteFile(file, () => this.app.vault.adapter.write(path, data, options));
+        } else {
+            return await processWriteFile(file, () => this.app.vault.adapter.writeBinary(path, toArrayBuffer(data), options));
+        }
+    }
+
+    async vaultCacheRead(file: TFile) {
+        return await processReadFile(file, () => this.app.vault.cachedRead(file));
+    }
+
+    async vaultRead(file: TFile) {
+        return await processReadFile(file, () => this.app.vault.read(file));
+    }
+
+    async vaultReadBinary(file: TFile) {
+        return await processReadFile(file, () => this.app.vault.readBinary(file));
+    }
+
+    async vaultReadAuto(file: TFile) {
+        const path = file.path;
+        if (isPlainText(path)) return await processReadFile(file, () => this.app.vault.read(file));
+        return await processReadFile(file, () => this.app.vault.readBinary(file));
+    }
+
+
+    async vaultModify(file: TFile, data: string | ArrayBuffer | Uint8Array, options?: DataWriteOptions) {
+        if (typeof (data) === "string") {
+            return await processWriteFile(file, async () => {
+                const oldData = await this.app.vault.read(file);
+                if (data === oldData) {
+                    if (options && options.mtime) markChangesAreSame(file.path, file.stat.mtime, options.mtime);
+                    return true;
+                }
+                await this.app.vault.modify(file, data, options)
+                return true;
+            }
+            );
+        } else {
+            return await processWriteFile(file, async () => {
+                const oldData = await this.app.vault.readBinary(file);
+                if (await isDocContentSame(createBinaryBlob(oldData), createBinaryBlob(data))) {
+                    if (options && options.mtime) markChangesAreSame(file.path, file.stat.mtime, options.mtime);
+                    return true;
+                }
+                await this.app.vault.modifyBinary(file, toArrayBuffer(data), options)
+                return true;
+            });
+        }
+    }
+    async vaultCreate(path: string, data: string | ArrayBuffer | Uint8Array, options?: DataWriteOptions): Promise<TFile> {
+        if (typeof (data) === "string") {
+            return await processWriteFile(path, () => this.app.vault.create(path, data, options));
+        } else {
+            return await processWriteFile(path, () => this.app.vault.createBinary(path, toArrayBuffer(data), options));
+        }
+    }
+
+    trigger(name: string, ...data: any[]) {
+        return this.app.vault.trigger(name, ...data);
+    }
+
+    async adapterAppend(normalizedPath: string, data: string, options?: DataWriteOptions) {
+        return await this.app.vault.adapter.append(normalizedPath, data, options)
+    }
+
+    async delete(file: TFile | TFolder, force = false) {
+        return await processWriteFile(file, () => this.app.vault.delete(file, force));
+    }
+    async trash(file: TFile | TFolder, force = false) {
+        return await processWriteFile(file, () => this.app.vault.trash(file, force));
+    }
+
+
+
+    isStorageInsensitive(): boolean {
+        //@ts-ignore
+        return this.app.vault.adapter.insensitive ?? true;
+    }
+
+    getAbstractFileByPathInsensitive(path: FilePath | string): TAbstractFile | null {
+        //@ts-ignore
+        return app.vault.getAbstractFileByPathInsensitive(path);
+    }
+
+    getAbstractFileByPath(path: FilePath | string): TAbstractFile | null {
+        if (!this.plugin.settings.handleFilenameCaseSensitive || this.isStorageInsensitive()) {
+            return this.getAbstractFileByPathInsensitive(path);
+        }
+        return this.app.vault.getAbstractFileByPath(path);
+    }
+
+    getFiles() {
+        return this.app.vault.getFiles();
+    }
+
+    async ensureDirectory(fullPath: string) {
+        const pathElements = fullPath.split("/");
+        pathElements.pop();
+        let c = "";
+        for (const v of pathElements) {
+            c += v;
+            try {
+                await this.app.vault.adapter.mkdir(c);
+            } catch (ex: any) {
+                if (ex?.message == "Folder already exists.") {
+                    // Skip if already exists.
+                } else {
+                    Logger("Folder Create Error");
+                    Logger(ex);
+                }
+            }
+            c += "/";
+        }
+    }
+
+
+    touchedFiles: string[] = [];
+
+
+    touch(file: TFile | FilePath) {
+        const f = file instanceof TFile ? file : this.getAbstractFileByPath(file) as TFile;
+        const key = `${f.path}-${f.stat.mtime}-${f.stat.size}`;
+        this.touchedFiles.unshift(key);
+        this.touchedFiles = this.touchedFiles.slice(0, 100);
+    }
+    recentlyTouched(file: TFile | InternalFileInfo | UXFileInfoStub) {
+        const key = "stat" in file ? `${file.path}-${file.stat.mtime}-${file.stat.size}` : `${file.path}-${file.mtime}-${file.size}`;
+        if (this.touchedFiles.indexOf(key) == -1) return false;
+        return true;
+    }
+    clearTouched() {
+        this.touchedFiles = [];
+    }
+}

src/modules/coreObsidian/storageLib/StorageEventManager.ts

@@ -0,0 +1,367 @@
+import { TAbstractFile, TFile, TFolder } from "../../../deps.ts";
+import { Logger } from "../../../lib/src/common/logger.ts";
+import { shouldBeIgnored } from "../../../lib/src/string_and_binary/path.ts";
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, type FilePath, type FilePathWithPrefix, type UXFileInfoStub, type UXInternalFileInfoStub } from "../../../lib/src/common/types.ts";
+import { delay, fireAndForget } from "../../../lib/src/common/utils.ts";
+import { type FileEventItem, type FileEventType } from "../../../common/types.ts";
+import { serialized, skipIfDuplicated } from "../../../lib/src/concurrency/lock.ts";
+import { finishAllWaitingForTimeout, finishWaitingForTimeout, isWaitingForTimeout, waitForTimeout } from "../../../lib/src/concurrency/task.ts";
+import { Semaphore } from "../../../lib/src/concurrency/semaphore.ts";
+import type { LiveSyncCore } from "../../../main.ts";
+import { InternalFileToUXFileInfoStub, TFileToUXFileInfoStub } from "./utilObsidian.ts";
+import ObsidianLiveSyncPlugin from "../../../main.ts";
+// import { InternalFileToUXFileInfo } from "../platforms/obsidian.ts";
+
+
+export type FileEvent = {
+    type: FileEventType;
+    file: UXFileInfoStub | UXInternalFileInfoStub;
+    oldPath?: string;
+    cachedData?: string;
+    skipBatchWait?: boolean;
+};
+
+
+export abstract class StorageEventManager {
+    abstract beginWatch(): void;
+    abstract flushQueue(): void;
+    abstract appendQueue(items: FileEvent[], ctx?: any): Promise<void>;
+    abstract cancelQueue(key: string): void;
+    abstract isWaiting(filename: FilePath): boolean;
+
+}
+
+
+export class StorageEventManagerObsidian extends StorageEventManager {
+
+    plugin: ObsidianLiveSyncPlugin;
+    core: LiveSyncCore;
+
+    get shouldBatchSave() {
+        return this.plugin.shouldBatchSave;
+    }
+    get batchSaveMinimumDelay(): number {
+        return this.plugin.batchSaveMinimumDelay;
+    }
+    get batchSaveMaximumDelay(): number {
+        return this.plugin.batchSaveMaximumDelay
+    }
+    constructor(plugin: ObsidianLiveSyncPlugin, core: LiveSyncCore) {
+        super();
+        this.plugin = plugin;
+        this.core = core;
+    }
+    beginWatch() {
+        const plugin = this.plugin;
+        this.watchVaultChange = this.watchVaultChange.bind(this);
+        this.watchVaultCreate = this.watchVaultCreate.bind(this);
+        this.watchVaultDelete = this.watchVaultDelete.bind(this);
+        this.watchVaultRename = this.watchVaultRename.bind(this);
+        this.watchVaultRawEvents = this.watchVaultRawEvents.bind(this);
+        this.watchEditorChange = this.watchEditorChange.bind(this);
+        plugin.registerEvent(plugin.app.vault.on("modify", this.watchVaultChange));
+        plugin.registerEvent(plugin.app.vault.on("delete", this.watchVaultDelete));
+        plugin.registerEvent(plugin.app.vault.on("rename", this.watchVaultRename));
+        plugin.registerEvent(plugin.app.vault.on("create", this.watchVaultCreate));
+        //@ts-ignore : Internal API
+        plugin.registerEvent(plugin.app.vault.on("raw", this.watchVaultRawEvents));
+        plugin.registerEvent(plugin.app.workspace.on("editor-change", this.watchEditorChange));
+
+        // plugin.fileEventQueue.startPipeline();
+    }
+    watchEditorChange(editor: any, info: any) {
+        if (!("path" in info)) {
+            return;
+        }
+        if (!this.shouldBatchSave) {
+            return;
+        }
+        const file = info?.file as TFile;
+        if (!file) return;
+        if (!this.isWaiting(file.path as FilePath)) {
+            return;
+        }
+        const data = info?.data as string;
+        const fi: FileEvent = {
+            type: "CHANGED", file: TFileToUXFileInfoStub(file), cachedData: data,
+        }
+        void this.appendQueue([
+            fi])
+    }
+
+    watchVaultCreate(file: TAbstractFile, ctx?: any) {
+        if (file instanceof TFolder) return;
+        const fileInfo = TFileToUXFileInfoStub(file);
+        void this.appendQueue([{ type: "CREATE", file: fileInfo }], ctx);
+    }
+
+    watchVaultChange(file: TAbstractFile, ctx?: any) {
+        if (file instanceof TFolder) return;
+        const fileInfo = TFileToUXFileInfoStub(file);
+        void this.appendQueue([{ type: "CHANGED", file: fileInfo }], ctx);
+    }
+
+    watchVaultDelete(file: TAbstractFile, ctx?: any) {
+        if (file instanceof TFolder) return;
+        const fileInfo = TFileToUXFileInfoStub(file, true);
+        void this.appendQueue([{ type: "DELETE", file: fileInfo }], ctx);
+    }
+    watchVaultRename(file: TAbstractFile, oldFile: string, ctx?: any) {
+        if (file instanceof TFile) {
+            const fileInfo = TFileToUXFileInfoStub(file);
+            void this.appendQueue([
+                {
+                    type: "DELETE", file: {
+                        path: oldFile as FilePath, name: file.name, stat: {
+                            mtime: file.stat.mtime,
+                            ctime: file.stat.ctime,
+                            size: file.stat.size,
+                            type: "file"
+                        }, deleted: true
+                    }, skipBatchWait: true
+                }, { type: "CREATE", file: fileInfo, skipBatchWait: true },], ctx);
+        }
+    }
+    // Watch raw events (Internal API)
+    watchVaultRawEvents(path: FilePath) {
+        // Only for internal files.
+        if (!this.plugin.settings) return;
+        // if (this.plugin.settings.useIgnoreFiles && this.plugin.ignoreFiles.some(e => path.endsWith(e.trim()))) {
+        if (this.plugin.settings.useIgnoreFiles) {
+            // If it is one of ignore files, refresh the cached one.
+            // (Calling$$isTargetFile will refresh the cache)
+            void this.plugin.$$isTargetFile(path).then(() => this._watchVaultRawEvents(path));
+        } else {
+            this._watchVaultRawEvents(path);
+        }
+    }
+
+    _watchVaultRawEvents(path: FilePath) {
+        if (!this.plugin.settings.syncInternalFiles && !this.plugin.settings.usePluginSync) return;
+        if (!this.plugin.settings.watchInternalFileChanges) return;
+        if (!path.startsWith(this.plugin.app.vault.configDir)) return;
+        const ignorePatterns = this.plugin.settings.syncInternalFilesIgnorePatterns
+            .replace(/\n| /g, "")
+            .split(",").filter(e => e).map(e => new RegExp(e, "i"));
+        if (ignorePatterns.some(e => path.match(e))) return;
+        if (path.endsWith("/")) {
+            // Folder 
+            return;
+        }
+        void this.appendQueue([
+            {
+                type: "INTERNAL", file: InternalFileToUXFileInfoStub(path),
+            }], null);
+    }
+    // Cache file and waiting to can be proceed.
+    async appendQueue(params: FileEvent[], ctx?: any) {
+        if (!this.plugin.settings.isConfigured) return;
+        if (this.plugin.settings.suspendFileWatching) return;
+        this.plugin.totalFileEventCount++;
+        // Flag up to be reload
+        const processFiles = new Set<FilePath>();
+        for (const param of params) {
+            if (shouldBeIgnored(param.file.path)) {
+                continue;
+            }
+            const atomicKey = [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0].map(e => `${Math.floor(Math.random() * 100000)}`).join("-");
+            const type = param.type;
+            const file = param.file;
+            const oldPath = param.oldPath;
+            if (type !== "INTERNAL") {
+                const size = (file as UXFileInfoStub).stat.size;
+                if (this.plugin.$$isFileSizeExceeded(size) && (type == "CREATE" || type == "CHANGED")) {
+                    Logger(`The storage file has been changed but exceeds the maximum size. Skipping: ${param.file.path}`, LOG_LEVEL_NOTICE);
+                    continue;
+                }
+            }
+            if (file instanceof TFolder) continue;
+            if (!await this.plugin.$$isTargetFile(file.path)) continue;
+
+            // Stop cache using to prevent the corruption;
+            // let cache: null | string | ArrayBuffer;
+            // new file or something changed, cache the changes.
+            if (file instanceof TFile && (type == "CREATE" || type == "CHANGED")) {
+                // Wait for a bit while to let the writer has marked `touched` at the file.
+                await delay(10);
+                if (this.plugin.storageAccess.recentlyTouched(file)) {
+                    continue;
+                }
+            }
+
+            let cache: string | undefined = undefined;
+            if (param.cachedData) {
+                cache = param.cachedData
+            }
+            this.enqueue({
+                type, args: {
+                    file: file, oldPath, cache, ctx,
+                }, skipBatchWait: param.skipBatchWait, key: atomicKey
+            })
+            processFiles.add(file.path as FilePath);
+            if (oldPath) {
+                processFiles.add(oldPath as FilePath);
+            }
+        }
+        for (const path of processFiles) {
+            fireAndForget(() => this.startStandingBy(path));
+        }
+    }
+    bufferedQueuedItems = [] as FileEventItem[];
+
+    enqueue(newItem: FileEventItem) {
+        const filename = newItem.args.file.path;
+        if (this.shouldBatchSave) {
+            Logger(`Request cancel for waiting of previous ${filename}`, LOG_LEVEL_DEBUG);
+            finishWaitingForTimeout(`storage-event-manager-batchsave-${filename}`);
+        }
+        this.bufferedQueuedItems.push(newItem);
+        // When deleting or renaming, the queue must be flushed once before processing subsequent processes to prevent unexpected race condition.
+        if (newItem.type == "DELETE") {
+            return this.flushQueue();
+        }
+    }
+    concurrentProcessing = Semaphore(5);
+    waitedSince = new Map<FilePath | FilePathWithPrefix, number>();
+    async startStandingBy(filename: FilePath) {
+        // If waited, cancel previous waiting.
+        await skipIfDuplicated(`storage-event-manager-${filename}`, async () => {
+            Logger(`Processing ${filename}: Starting`, LOG_LEVEL_DEBUG);
+            const release = await this.concurrentProcessing.acquire();
+            try {
+                Logger(`Processing ${filename}: Started`, LOG_LEVEL_DEBUG);
+                let noMoreFiles = false;
+                do {
+                    const target = this.bufferedQueuedItems.find(e => e.args.file.path == filename);
+                    if (target === undefined) {
+                        noMoreFiles = true;
+                        break;
+                    }
+                    const operationType = target.type;
+
+                    // if (target.waitedFrom + this.batchSaveMaximumDelay > now) {
+                    //     this.requestProcessQueue(target);
+                    //     continue;
+                    // }
+                    const type = target.type;
+                    if (target.cancelled) {
+                        Logger(`Processing ${filename}: Cancelled (scheduled): ${operationType}`, LOG_LEVEL_DEBUG)
+                        this.cancelStandingBy(target);
+                        continue;
+                    }
+                    if (!target.skipBatchWait) {
+                        if (this.shouldBatchSave && (type == "CREATE" || type == "CHANGED")) {
+                            const waitedSince = this.waitedSince.get(filename);
+                            let canWait = true;
+                            const now = Date.now();
+                            if (waitedSince !== undefined) {
+                                if (waitedSince + (this.batchSaveMaximumDelay * 1000) < now) {
+                                    Logger(`Processing ${filename}: Could not wait no more: ${operationType}`, LOG_LEVEL_INFO)
+                                    canWait = false;
+                                }
+                            }
+                            if (canWait) {
+                                if (waitedSince === undefined) this.waitedSince.set(filename, now)
+                                target.batched = true
+                                Logger(`Processing ${filename}: Waiting for batch save delay: ${operationType}`, LOG_LEVEL_DEBUG)
+                                this.updateStatus();
+                                const result = await waitForTimeout(`storage-event-manager-batchsave-${filename}`, this.batchSaveMinimumDelay * 1000);
+                                if (!result) {
+                                    Logger(`Processing ${filename}: Cancelled by new queue: ${operationType}`, LOG_LEVEL_DEBUG)
+                                    // If could not wait for the timeout, possibly we got a new queue. therefore, currently processing one should be cancelled
+                                    this.cancelStandingBy(target);
+                                    continue;
+                                }
+                            }
+                        }
+                    } else {
+                        Logger(`Processing ${filename}:Requested to perform immediately ${filename}: ${operationType}`, LOG_LEVEL_DEBUG)
+                    }
+                    Logger(`Processing ${filename}: Request main to process: ${operationType}`, LOG_LEVEL_DEBUG)
+                    await this.requestProcessQueue(target);
+                } while (!noMoreFiles)
+            } finally {
+                release()
+            }
+            Logger(`Processing ${filename}: Finished`, LOG_LEVEL_DEBUG);
+        })
+    }
+
+    cancelStandingBy(fei: FileEventItem) {
+        this.bufferedQueuedItems.remove(fei);
+        this.updateStatus();
+    }
+    processingCount = 0;
+    async requestProcessQueue(fei: FileEventItem) {
+        try {
+            this.processingCount++;
+            this.bufferedQueuedItems.remove(fei);
+            this.updateStatus()
+            this.waitedSince.delete(fei.args.file.path);
+            await this.handleFileEvent(fei);
+        } finally {
+            this.processingCount--;
+            this.updateStatus()
+        }
+    }
+    isWaiting(filename: FilePath) {
+        return isWaitingForTimeout(`storage-event-manager-batchsave-${filename}`);
+    }
+    flushQueue() {
+        this.bufferedQueuedItems.forEach(e => e.skipBatchWait = true)
+        finishAllWaitingForTimeout("storage-event-manager-batchsave-", true);
+    }
+    cancelQueue(key: string) {
+        this.bufferedQueuedItems.forEach(e => {
+            if (e.key === key) e.skipBatchWait = true
+        })
+    }
+    updateStatus() {
+        const allItems = this.bufferedQueuedItems.filter(e => !e.cancelled)
+        const batchedCount = allItems.filter(e => e.batched && !e.skipBatchWait).length;
+        this.core.batched.value = batchedCount
+        this.core.processing.value = this.processingCount;
+        this.core.totalQueued.value = allItems.length - batchedCount;
+    }
+
+    async handleFileEvent(queue: FileEventItem): Promise<any> {
+        const file = queue.args.file;
+        const lockKey = `handleFile:${file.path}`;
+        return await serialized(lockKey, async () => {
+            // TODO CHECK
+            const key = `file-last-proc-${queue.type}-${file.path}`;
+            const last = Number(await this.core.kvDB.get(key) || 0);
+            if (queue.type == "INTERNAL" || file.isInternal) {
+                await this.plugin.$anyProcessOptionalFileEvent(file.path as unknown as FilePath);
+            } else {
+                // let mtime = file.stat.mtime;
+                if (queue.type == "DELETE") {
+                    await this.plugin.$anyHandlerProcessesFileEvent(queue);
+                } else {
+                    if (file.stat.mtime == last) {
+                        Logger(`File has been already scanned on ${queue.type}, skip: ${file.path}`, LOG_LEVEL_VERBOSE);
+                        // Should Cancel the relative operations? (e.g. rename) 
+                        // this.cancelRelativeEvent(queue);
+                        return;
+                    }
+                    if (!await this.plugin.$anyHandlerProcessesFileEvent(queue)) {
+                        Logger(`STORAGE -> DB: Handler failed, cancel the relative operations: ${file.path}`, LOG_LEVEL_INFO);
+                        // cancel running queues and remove one of atomic operation (e.g. rename) 
+                        this.cancelRelativeEvent(queue);
+                        return;
+                    }
+                }
+            }
+        });
+    }
+
+    cancelRelativeEvent(item: FileEventItem): void {
+        this.cancelQueue(item.key);
+    }
+}

src/modules/coreObsidian/storageLib/utilObsidian.ts

@@ -0,0 +1,109 @@
+// Obsidian to LiveSync Utils
+
+import { TFile, type TAbstractFile, type TFolder } from "../../../deps.ts";
+import { ICHeader } from "../../../common/types.ts";
+import type { SerializedFileAccess } from "./SerializedFileAccess.ts";
+import { addPrefix, isPlainText } from "../../../lib/src/string_and_binary/path.ts";
+import { LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
+import { createBlob } from "../../../lib/src/common/utils.ts";
+import type { FilePath, FilePathWithPrefix, UXFileInfo, UXFileInfoStub, UXFolderInfo, UXInternalFileInfoStub } from "../../../lib/src/common/types.ts";
+import type { LiveSyncCore } from "../../../main.ts";
+
+export async function TFileToUXFileInfo(core: LiveSyncCore, file: TFile, prefix?: string, deleted?: boolean): Promise<UXFileInfo> {
+    const isPlain = isPlainText(file.name);
+    const possiblyLarge = !isPlain;
+    let content: Blob;
+    if (deleted) {
+        content = new Blob();
+    } else {
+        if (possiblyLarge) Logger(`Reading   : ${file.path}`, LOG_LEVEL_VERBOSE);
+        content = createBlob(await core.storageAccess.readFileAuto(file.path));
+        if (possiblyLarge) Logger(`Processing: ${file.path}`, LOG_LEVEL_VERBOSE);
+    }
+    // const datatype = determineTypeFromBlob(content);
+    const bareFullPath = file.path as FilePathWithPrefix;
+    const fullPath = prefix ? addPrefix(bareFullPath, prefix) : bareFullPath;
+
+    return {
+        name: file.name,
+        path: fullPath,
+        stat: {
+            size: content.size,
+            ctime: file.stat.ctime,
+            mtime: file.stat.mtime,
+            type: "file",
+        },
+        body: content,
+    }
+}
+
+export async function InternalFileToUXFileInfo(fullPath: string, vaultAccess: SerializedFileAccess, prefix: string = ICHeader): Promise<UXFileInfo> {
+
+    const name = fullPath.split("/").pop() as string;
+    const stat = await vaultAccess.adapterStat(fullPath);
+    if (stat == null) throw new Error(`File not found: ${fullPath}`);
+    if (stat.type == "folder") throw new Error(`File not found: ${fullPath}`);
+    const file = await vaultAccess.adapterReadAuto(fullPath);
+
+    const isPlain = isPlainText(name);
+    const possiblyLarge = !isPlain;
+    if (possiblyLarge) Logger(`Reading   : ${fullPath}`, LOG_LEVEL_VERBOSE);
+    const content = createBlob(file);
+    if (possiblyLarge) Logger(`Processing: ${fullPath}`, LOG_LEVEL_VERBOSE);
+    // const datatype = determineTypeFromBlob(content);
+    const bareFullPath = fullPath as FilePathWithPrefix;
+    const saveFullPath = prefix ? addPrefix(bareFullPath, prefix) : bareFullPath;
+
+    return {
+        name: name,
+        path: saveFullPath,
+        stat: {
+            size: content.size,
+            ctime: stat.ctime,
+            mtime: stat.mtime,
+            type: "file",
+        },
+        body: content,
+    }
+}
+
+export function TFileToUXFileInfoStub(file: TFile | TAbstractFile, deleted?: boolean): UXFileInfoStub {
+    if (!(file instanceof TFile)) {
+        throw new Error("Invalid file type");
+    }
+    const ret: UXFileInfoStub = {
+        name: file.name,
+        path: file.path as FilePathWithPrefix,
+        isFolder: false,
+        stat: {
+            size: file.stat.size,
+            mtime: file.stat.mtime,
+            ctime: file.stat.ctime,
+            type: "file",
+        },
+        deleted: deleted
+    }
+    return ret;
+}
+export function InternalFileToUXFileInfoStub(filename: FilePathWithPrefix, deleted?: boolean): UXInternalFileInfoStub {
+    const name = filename.split("/").pop() as string;
+    const ret: UXInternalFileInfoStub = {
+        name: name,
+        path: filename,
+        isFolder: false,
+        stat: undefined,
+        isInternal: true,
+        deleted
+    }
+    return ret;
+}
+export function TFolderToUXFileInfoStub(file: TFolder): UXFolderInfo {
+    const ret: UXFolderInfo = {
+        name: file.name,
+        path: file.path as FilePathWithPrefix,
+        parent: file.parent?.path as FilePath | undefined,
+        isFolder: true,
+        children: file.children.map(e => TFileToUXFileInfoStub(e)),
+    }
+    return ret;
+}

src/modules/essential/ModuleInitializerFile.ts

@@ -0,0 +1,328 @@
+import { unique } from "octagonal-wheels/collection";
+import { QueueProcessor } from "octagonal-wheels/concurrency/processor";
+import { throttle } from "octagonal-wheels/function";
+import { eventHub } from "../../common/events.ts";
+import { BASE_IS_NEW, compareFileFreshness, EVEN, getPath, isValidPath, TARGET_IS_NEW } from "../../common/utils.ts";
+import { type FilePathWithPrefixLC, type FilePathWithPrefix, type MetaEntry, isMetaEntry, type EntryDoc, LOG_LEVEL_VERBOSE, LOG_LEVEL_NOTICE, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, type UXFileInfoStub } from "../../lib/src/common/types.ts";
+import { isAnyNote } from "../../lib/src/common/utils.ts";
+import { stripAllPrefixes } from "../../lib/src/string_and_binary/path.ts";
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleInitializerFile extends AbstractModule implements ICoreModule {
+
+    async $$performFullScan(showingNotice?: boolean): Promise<void> {
+
+        this._log("Opening the key-value database", LOG_LEVEL_VERBOSE);
+        const isInitialized = await (this.core.kvDB.get<boolean>("initialized")) || false;
+        // synchronize all files between database and storage.
+        if (!this.settings.isConfigured) {
+            if (showingNotice) {
+                this._log("LiveSync is not configured yet. Synchronising between the storage and the local database is now prevented.", LOG_LEVEL_NOTICE, "syncAll");
+            }
+            return;
+        }
+
+        if (showingNotice) {
+            this._log("Initializing", LOG_LEVEL_NOTICE, "syncAll");
+        }
+
+        this._log("Initialize and checking database files");
+        this._log("Checking deleted files");
+        await this.collectDeletedFiles();
+
+        this._log("Collecting local files on the storage", LOG_LEVEL_VERBOSE);
+        const filesStorageSrc = this.core.storageAccess.getFiles();
+
+        const _filesStorage = [] as typeof filesStorageSrc;
+
+        for (const f of filesStorageSrc) {
+            if (await this.core.$$isTargetFile(f.path, f != filesStorageSrc[0])) {
+                _filesStorage.push(f);
+            }
+        }
+
+        const convertCase = <FilePathWithPrefix>(path: FilePathWithPrefix): FilePathWithPrefixLC => {
+            if (this.settings.handleFilenameCaseSensitive) {
+                return path as FilePathWithPrefixLC;
+            }
+            return (path as string).toLowerCase() as FilePathWithPrefixLC;
+        }
+
+        // If handleFilenameCaseSensitive is enabled, `FilePathWithPrefixLC` is the same as `FilePathWithPrefix`.
+
+        const storageFileNameMap = Object.fromEntries(_filesStorage.map((e) => [
+            e.path, e] as [FilePathWithPrefix, UXFileInfoStub]));
+
+        const storageFileNames = Object.keys(storageFileNameMap) as FilePathWithPrefix[];
+
+        const storageFileNameCapsPair = storageFileNames.map((e) => [
+            e, convertCase(e)] as [FilePathWithPrefix, FilePathWithPrefixLC]);
+
+        // const storageFileNameCS2CI = Object.fromEntries(storageFileNameCapsPair) as Record<FilePathWithPrefix, FilePathWithPrefixLC>;
+        const storageFileNameCI2CS = Object.fromEntries(storageFileNameCapsPair.map(e => [
+            e[1], e[0]])) as Record<FilePathWithPrefixLC, FilePathWithPrefix>;
+
+
+        this._log("Collecting local files on the DB", LOG_LEVEL_VERBOSE);
+        const _DBEntries = [] as MetaEntry[];
+        // const _DBEntriesTask = [] as (() => Promise<MetaEntry | false>)[];
+        let count = 0;
+        for await (const doc of this.localDatabase.findAllNormalDocs()) {
+            count++;
+            if (count % 25 == 0) this._log(`Collecting local files on the DB: ${count}`, showingNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "syncAll");
+            const path = getPath(doc);
+
+            if (isValidPath(path) && await this.core.$$isTargetFile(path, true)) {
+                if (!isMetaEntry(doc)) {
+                    this._log(`Invalid entry: ${path}`, LOG_LEVEL_INFO);
+                    continue;
+                }
+                _DBEntries.push(doc);
+            }
+        }
+
+        const databaseFileNameMap = Object.fromEntries(_DBEntries.map((e) => [
+            getPath(e), e] as [FilePathWithPrefix, MetaEntry]));
+        const databaseFileNames = Object.keys(databaseFileNameMap) as FilePathWithPrefix[];
+        const databaseFileNameCapsPair = databaseFileNames.map((e) => [
+            e, convertCase(e)] as [FilePathWithPrefix, FilePathWithPrefixLC]);
+        // const databaseFileNameCS2CI = Object.fromEntries(databaseFileNameCapsPair) as Record<FilePathWithPrefix, FilePathWithPrefixLC>;
+        const databaseFileNameCI2CS = Object.fromEntries(databaseFileNameCapsPair.map(e => [
+            e[1], e[0]])) as Record<FilePathWithPrefix, FilePathWithPrefixLC>;
+
+        const allFiles = unique([
+            ...Object.keys(databaseFileNameCI2CS),
+            ...Object.keys(storageFileNameCI2CS)]) as FilePathWithPrefixLC[];
+
+        this._log(`Total files in the database: ${databaseFileNames.length}`, LOG_LEVEL_VERBOSE, "syncAll");
+        this._log(`Total files in the storage: ${storageFileNames.length}`, LOG_LEVEL_VERBOSE, "syncAll");
+        this._log(`Total files: ${allFiles.length}`, LOG_LEVEL_VERBOSE, "syncAll");
+
+
+        const filesExistOnlyInStorage = allFiles.filter((e) => !databaseFileNameCI2CS[e]);
+        const filesExistOnlyInDatabase = allFiles.filter((e) => !storageFileNameCI2CS[e]);
+        const filesExistBoth = allFiles.filter((e) => databaseFileNameCI2CS[e] && storageFileNameCI2CS[e]);
+
+        this._log(`Files exist only in storage: ${filesExistOnlyInStorage.length}`, LOG_LEVEL_VERBOSE, "syncAll");
+        this._log(`Files exist only in database: ${filesExistOnlyInDatabase.length}`, LOG_LEVEL_VERBOSE, "syncAll");
+        this._log(`Files exist both in storage and database: ${filesExistBoth.length}`, LOG_LEVEL_VERBOSE, "syncAll");
+
+        this._log("Synchronising...");
+        const processStatus = {} as Record<string, string>;
+        const logLevel = showingNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+        const updateLog = throttle((key: string, msg: string) => {
+            processStatus[key] = msg;
+            const log = Object.values(processStatus).join("\n");
+            this._log(log, logLevel, "syncAll");
+        }, 25);
+
+        const initProcess = [];
+        const runAll = async <T>(procedureName: string, objects: T[], callback: (arg: T) => Promise<void>) => {
+            if (objects.length == 0) {
+                this._log(`${procedureName}: Nothing to do`);
+                return;
+            }
+            this._log(procedureName);
+            if (!this.localDatabase.isReady) throw Error("Database is not ready!");
+            let success = 0;
+            let failed = 0;
+            const step = 10;
+            const processor = new QueueProcessor(async (e) => {
+                try {
+                    await callback(e[0]);
+                    success++;
+                    // return 
+                } catch (ex) {
+                    this._log(`Error while ${procedureName}`, LOG_LEVEL_NOTICE);
+                    this._log(ex, LOG_LEVEL_VERBOSE);
+                    failed++;
+                }
+                if ((success + failed) % step == 0) {
+                    const msg = `${procedureName}: DONE:${success}, FAILED:${failed}, LAST:${processor._queue.length}`;
+                    updateLog(procedureName, msg);
+                }
+                return;
+            }, {
+                batchSize: 1,
+                concurrentLimit: 10,
+                delay: 0,
+                suspended: true,
+                maintainDelay: false,
+                interval: 0
+            }, objects)
+            await processor.waitForAllDoneAndTerminate();
+            const msg = `${procedureName} All done: DONE:${success}, FAILED:${failed}`;
+            updateLog(procedureName, msg)
+        }
+        initProcess.push(runAll("UPDATE DATABASE", filesExistOnlyInStorage, async (e) => {
+            // console.warn("UPDATE DATABASE", e);
+            const file = storageFileNameMap[storageFileNameCI2CS[e]];
+            if (!this.core.$$isFileSizeExceeded(file.stat.size)) {
+                const path = file.path;
+                await this.core.fileHandler.storeFileToDB(file);
+                // fireAndForget(() => this.checkAndApplySettingFromMarkdown(path, true));
+                eventHub.emitEvent("event-file-changed", { file: path, automated: true });
+            } else {
+                this._log(`UPDATE DATABASE: ${e} has been skipped due to file size exceeding the limit`, logLevel);
+            }
+        }));
+        initProcess.push(runAll("UPDATE STORAGE", filesExistOnlyInDatabase, async (e) => {
+            const w = databaseFileNameMap[databaseFileNameCI2CS[e]];
+            const path = getPath(w) ?? e;
+            if (w && !(w.deleted || w._deleted)) {
+                if (!this.core.$$isFileSizeExceeded(w.size)) {
+                    // await this.pullFile(path, undefined, false, undefined, false);
+                    // Memo: No need to force
+                    await this.core.fileHandler.dbToStorage(path, null, true);
+                    // fireAndForget(() => this.checkAndApplySettingFromMarkdown(e, true));
+                    eventHub.emitEvent("event-file-changed", {
+                        file: e, automated: true
+                    });
+                    this._log(`Check or pull from db:${path} OK`);
+                } else {
+                    this._log(`UPDATE STORAGE: ${path} has been skipped due to file size exceeding the limit`, logLevel);
+                }
+            } else if (w) {
+                this._log(`Deletion history skipped: ${path}`, LOG_LEVEL_VERBOSE);
+            } else {
+                this._log(`entry not found: ${path}`);
+            }
+        }));
+
+        const fileMap = filesExistBoth.map(path => {
+            const file = storageFileNameMap[storageFileNameCI2CS[path]];
+            const doc = databaseFileNameMap[databaseFileNameCI2CS[path]];
+            return { file, doc }
+        })
+        initProcess.push(runAll("SYNC DATABASE AND STORAGE", fileMap, async (e) => {
+            const { file, doc } = e;
+            if (!this.core.$$isFileSizeExceeded(file.stat.size) && !this.core.$$isFileSizeExceeded(doc.size)) {
+                await this.syncFileBetweenDBandStorage(file, doc);
+                // fireAndForget(() => this.checkAndApplySettingFromMarkdown(getPath(doc), true));
+                eventHub.emitEvent("event-file-changed", {
+                    file: getPath(doc), automated: true
+                });
+            } else {
+                this._log(`SYNC DATABASE AND STORAGE: ${getPath(doc)} has been skipped due to file size exceeding the limit`, logLevel);
+            }
+        }))
+
+        await Promise.all(initProcess);
+
+        // this.setStatusBarText(`NOW TRACKING!`);
+        this._log("Initialized, NOW TRACKING!");
+        if (!isInitialized) {
+            await (this.core.kvDB.set("initialized", true))
+        }
+        if (showingNotice) {
+            this._log("Initialize done!", LOG_LEVEL_NOTICE, "syncAll");
+        }
+    }
+
+    async syncFileBetweenDBandStorage(file: UXFileInfoStub, doc: MetaEntry) {
+        if (!doc) {
+            throw new Error(`Missing doc:${(file as any).path}`)
+        }
+        if ("path" in file) {
+            const w = this.core.storageAccess.getFileStub((file as any).path);
+            if (w) {
+                file = w;
+            } else {
+                throw new Error(`Missing file:${(file as any).path}`)
+            }
+        }
+
+        const compareResult = compareFileFreshness(file, doc);
+        switch (compareResult) {
+            case BASE_IS_NEW:
+                if (!this.core.$$isFileSizeExceeded(file.stat.size)) {
+                    this._log("STORAGE -> DB :" + file.path);
+                    await this.core.fileHandler.storeFileToDB(file);
+                    eventHub.emitEvent("event-file-changed", {
+                        file: file.path, automated: true
+                    });
+                } else {
+                    this._log(`STORAGE -> DB : ${file.path} has been skipped due to file size exceeding the limit`, LOG_LEVEL_NOTICE);
+                }
+                break;
+            case TARGET_IS_NEW:
+                if (!this.core.$$isFileSizeExceeded(doc.size)) {
+                    this._log("STORAGE <- DB :" + file.path);
+                    if (!await this.core.fileHandler.dbToStorage(doc, stripAllPrefixes(file.path), true)) {
+                        this._log(`STORAGE <- DB : Cloud not read ${file.path}, possibly deleted`, LOG_LEVEL_NOTICE);
+                    }
+                    return caches;
+                } else {
+                    this._log(`STORAGE <- DB : ${file.path} has been skipped due to file size exceeding the limit`, LOG_LEVEL_NOTICE);
+                }
+                break;
+            case EVEN:
+                this._log("STORAGE == DB :" + file.path + "", LOG_LEVEL_DEBUG);
+                break;
+            default:
+                this._log("STORAGE ?? DB :" + file.path + " Something got weird");
+        }
+
+    }
+
+
+    // This method uses an old version of database accessor, which is not recommended.
+    // TODO: Fix
+    async collectDeletedFiles() {
+        const limitDays = this.settings.automaticallyDeleteMetadataOfDeletedFiles;
+        if (limitDays <= 0) return;
+        this._log(`Checking expired file history`);
+        const limit = Date.now() - (86400 * 1000 * limitDays);
+        const notes: {
+            path: string,
+            mtime: number,
+            ttl: number,
+            doc: PouchDB.Core.ExistingDocument<EntryDoc & PouchDB.Core.AllDocsMeta>
+        }[] = [];
+        for await (const doc of this.localDatabase.findAllDocs({ conflicts: true })) {
+            if (isAnyNote(doc)) {
+                if (doc.deleted && (doc.mtime - limit) < 0) {
+                    notes.push({
+                        path: getPath(doc),
+                        mtime: doc.mtime,
+                        ttl: (doc.mtime - limit) / 1000 / 86400,
+                        doc: doc
+                    });
+                }
+            }
+        }
+        if (notes.length == 0) {
+            this._log("There are no old documents");
+            this._log(`Checking expired file history done`);
+            return;
+        }
+        for (const v of notes) {
+            this._log(`Deletion history expired: ${v.path}`);
+            const delDoc = v.doc;
+            delDoc._deleted = true;
+            await this.localDatabase.putRaw(delDoc);
+        }
+        this._log(`Checking expired file history done`);
+    }
+
+    async $$initializeDatabase(showingNotice: boolean = false, reopenDatabase = true): Promise<boolean> {
+        this.core.isReady = false;
+        if ((!reopenDatabase) || await this.core.$$openDatabase()) {
+            if (this.localDatabase.isReady) {
+                await this.core.$$performFullScan(showingNotice);
+            }
+            if (!await this.core.$everyOnDatabaseInitialized(showingNotice)) {
+                this._log(`Initializing database has been failed on some module`, LOG_LEVEL_NOTICE);
+                return false;
+            }
+            this.core.isReady = true;
+            // run queued event once.
+            await this.core.$everyCommitPendingFileEvent();
+            return true;
+        } else {
+            this.core.isReady = false;
+            return false;
+        }
+    }
+}

src/modules/essential/ModuleKeyValueDB.ts

@@ -0,0 +1,90 @@
+import { delay, yieldMicrotask } from "octagonal-wheels/promises";
+import { OpenKeyValueDatabase } from "../../common/KeyValueDB.ts";
+import type { LiveSyncLocalDB } from "../../lib/src/pouchdb/LiveSyncLocalDB.ts";
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleKeyValueDB extends AbstractModule implements ICoreModule {
+
+    tryCloseKvDB() {
+        try {
+            this.core.kvDB?.close();
+            return true;
+        } catch (e) {
+            this._log("Failed to close KeyValueDB", LOG_LEVEL_VERBOSE);
+            this._log(e);
+            return false;
+        }
+    }
+    async openKeyValueDB(): Promise<boolean> {
+        await delay(10);
+        try {
+            this.tryCloseKvDB();
+            await delay(10);
+            await yieldMicrotask();
+            this.core.kvDB = await OpenKeyValueDatabase(this.core.$$getVaultName() + "-livesync-kv");
+            await yieldMicrotask();
+            await delay(100);
+        } catch (e) {
+            this.core.kvDB = undefined!;
+            this._log("Failed to open KeyValueDB", LOG_LEVEL_NOTICE);
+            this._log(e, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        return true;
+    }
+    $allOnDBUnload(db: LiveSyncLocalDB): void {
+        if (this.core.kvDB) this.core.kvDB.close();
+    }
+    $allOnDBClose(db: LiveSyncLocalDB): void {
+        if (this.core.kvDB) this.core.kvDB.close();
+    }
+
+    async $everyOnloadAfterLoadSettings(): Promise<boolean> {
+        if (!await this.openKeyValueDB()) {
+            return false;
+        }
+        this.core.simpleStore = this.core.$$getSimpleStore<any>("os");
+        return Promise.resolve(true);
+    }
+    $$getSimpleStore<T>(kind: string) {
+        const prefix = `${kind}-`;
+        return {
+            get: async (key: string): Promise<T> => {
+                return await this.core.kvDB.get(`${prefix}${key}`);
+            },
+            set: async (key: string, value: any): Promise<void> => {
+                await this.core.kvDB.set(`${prefix}${key}`, value);
+            },
+            delete: async (key: string): Promise<void> => {
+                await this.core.kvDB.del(`${prefix}${key}`);
+            },
+            keys: async (from: string | undefined, to: string | undefined, count?: number | undefined): Promise<string[]> => {
+                const ret = this.core.kvDB.keys(IDBKeyRange.bound(`${prefix}${from || ""}`, `${prefix}${to || ""}`), count);
+                return (await ret).map(e => e.toString()).filter(e => e.startsWith(prefix)).map(e => e.substring(prefix.length));
+            }
+        }
+    }
+    $everyOnInitializeDatabase(db: LiveSyncLocalDB): Promise<boolean> {
+        return this.openKeyValueDB();
+    }
+
+    async $everyOnResetDatabase(db: LiveSyncLocalDB): Promise<boolean> {
+        try {
+            const kvDBKey = "queued-files"
+            await this.core.kvDB.del(kvDBKey);
+            // localStorage.removeItem(lsKey);
+            await this.core.kvDB.destroy();
+            await yieldMicrotask();
+            this.core.kvDB = await OpenKeyValueDatabase(this.core.$$getVaultName() + "-livesync-kv");
+            await delay(100);
+        } catch (e) {
+            this.core.kvDB = undefined!;
+            this._log("Failed to reset KeyValueDB", LOG_LEVEL_NOTICE);
+            this._log(e, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        return true;
+    }
+}

src/modules/essential/ModuleMigration.ts

@@ -0,0 +1,240 @@
+import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from 'octagonal-wheels/common/logger.js';
+import { SETTING_VERSION_SUPPORT_CASE_INSENSITIVE } from '../../lib/src/common/types.js';
+import { EVENT_REQUEST_OPEN_SETTING_WIZARD, EVENT_REQUEST_OPEN_SETTINGS, EVENT_REQUEST_OPEN_SETUP_URI, eventHub } from '../../common/events.ts';
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+const URI_DOC = "https://github.com/vrtmrz/obsidian-livesync/blob/main/README.md#how-to-use";
+
+export class ModuleMigration extends AbstractModule implements ICoreModule {
+
+    async migrateDisableBulkSend() {
+        if (this.settings.sendChunksBulk) {
+            this._log("Send chunks in bulk has been enabled, however, this feature had been corrupted. Sorry for your inconvenience. Automatically disabled.", LOG_LEVEL_NOTICE);
+            this.settings.sendChunksBulk = false;
+            this.settings.sendChunksBulkMaxSize = 1;
+            await this.saveSettings();
+        }
+    }
+    async migrationCheck() {
+        const old = this.settings.settingVersion;
+        const current = SETTING_VERSION_SUPPORT_CASE_INSENSITIVE;
+        // Check each migrations(old -> current)
+        if (!await this.migrateToCaseInsensitive(old, current)) {
+            this._log(`Migration failed or cancelled from ${old} to ${current}`, LOG_LEVEL_NOTICE);
+            return;
+        }
+    }
+    async migrateToCaseInsensitive(old: number, current: number) {
+        if (this.settings.handleFilenameCaseSensitive !== undefined && this.settings.doNotUseFixedRevisionForChunks !== undefined) {
+            if (current < SETTING_VERSION_SUPPORT_CASE_INSENSITIVE) {
+                this.settings.settingVersion = SETTING_VERSION_SUPPORT_CASE_INSENSITIVE;
+                await this.saveSettings();
+            }
+            return true;
+        }
+        if (old >= SETTING_VERSION_SUPPORT_CASE_INSENSITIVE && this.settings.handleFilenameCaseSensitive !== undefined && this.settings.doNotUseFixedRevisionForChunks !== undefined) {
+            return true;
+        }
+
+        let remoteHandleFilenameCaseSensitive: undefined | boolean = undefined;
+        let remoteDoNotUseFixedRevisionForChunks: undefined | boolean = undefined;
+        let remoteChecked = false;
+        try {
+            const remoteInfo = await this.core.replicator.getRemotePreferredTweakValues(this.settings);
+            if (remoteInfo) {
+                remoteHandleFilenameCaseSensitive = "handleFilenameCaseSensitive" in remoteInfo ? remoteInfo.handleFilenameCaseSensitive : false;
+                remoteDoNotUseFixedRevisionForChunks = "doNotUseFixedRevisionForChunks" in remoteInfo ? remoteInfo.doNotUseFixedRevisionForChunks : false;
+                if (remoteHandleFilenameCaseSensitive !== undefined || remoteDoNotUseFixedRevisionForChunks !== undefined) {
+                    remoteChecked = true;
+                }
+            } else {
+                this._log("Failed to fetch remote tweak values", LOG_LEVEL_INFO);
+            }
+        } catch (ex) {
+            this._log("Could not get remote tweak values", LOG_LEVEL_INFO);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+
+        if (remoteChecked) {
+            // The case that the remote could be checked.
+            if (remoteHandleFilenameCaseSensitive && remoteDoNotUseFixedRevisionForChunks) {
+                // Migrated, but configured as same as old behaviour.
+                this.settings.handleFilenameCaseSensitive = true;
+                this.settings.doNotUseFixedRevisionForChunks = true;
+                this.settings.settingVersion = SETTING_VERSION_SUPPORT_CASE_INSENSITIVE;
+                this._log(`Migrated to db:${current} with the same behaviour as before`, LOG_LEVEL_INFO);
+                await this.saveSettings();
+                return true;
+            }
+            const message = `As you may already know, the self-hosted LiveSync has changed its default behaviour and database structure.
+
+And thankfully, with your time and efforts, the remote database appears to have already been migrated. Congratulations!
+
+However, we need a bit more. The configuration of this device is not compatible with the remote database. We will need to fetch the remote database again. Should we fetch from the remote again now?
+
+___Note: We cannot synchronise until the configuration has been changed and the database has been fetched again.___
+___Note2: The chunks are completely immutable, we can fetch only the metadata and difference.___
+`;
+            const OPTION_FETCH = "Yes, fetch again";
+            const DISMISS = "No, please ask again";
+            const options = [OPTION_FETCH, DISMISS];
+            const ret = await this.core.confirm.confirmWithMessage("Case Sensitivity", message, options, "No, please ask again", 40);
+            if (ret == OPTION_FETCH) {
+                this.settings.handleFilenameCaseSensitive = remoteHandleFilenameCaseSensitive || false;
+                this.settings.doNotUseFixedRevisionForChunks = remoteDoNotUseFixedRevisionForChunks || false;
+                this.settings.settingVersion = SETTING_VERSION_SUPPORT_CASE_INSENSITIVE;
+                await this.saveSettings();
+                try {
+                    await this.core.rebuilder.scheduleFetch();
+                    return;
+                } catch (ex) {
+                    this._log("Failed to create redflag2", LOG_LEVEL_VERBOSE);
+                    this._log(ex, LOG_LEVEL_VERBOSE);
+                }
+                return false;
+            } else {
+                return false;
+            }
+
+        }
+
+        const ENABLE_BOTH = "Enable both";
+        const ENABLE_FILENAME_CASE_INSENSITIVE = "Enable only #1";
+        const ENABLE_FIXED_REVISION_FOR_CHUNKS = "Enable only #2";
+        const ADJUST_TO_REMOTE = "Adjust to remote";
+        const DISMISS = "Decide it later";
+        const KEEP = "Keep previous behaviour";
+        const message = `Since v0.23.21, the self-hosted LiveSync has changed the default behaviour and database structure. The following changes have been made:
+
+1. **Case sensitivity of filenames** 
+   The handling of filenames is now case-insensitive. This is a beneficial change for most platforms, other than Linux and iOS, which do not manage filename case sensitivity effectively.
+   (On These, a warning will be displayed for files with the same name but different cases).
+
+2. **Revision handling of the chunks** 
+   Chunks are immutable, which allows their revisions to be fixed. This change will enhance the performance of file saving.
+
+___However, to enable either of these changes, both remote and local databases need to be rebuilt. This process takes a few minutes, and we recommend doing it when you have ample time.___
+
+- If you wish to maintain the previous behaviour, you can skip this process by using \`${KEEP}\`.
+- If you do not have enough time, please choose \`${DISMISS}\`. You will be prompted again later.
+- If you have rebuilt the database on another device, please select \`${DISMISS}\` and try synchronizing again. Since a difference has been detected, you will be prompted again.
+`;
+        const options = [
+            ENABLE_BOTH,
+            ENABLE_FILENAME_CASE_INSENSITIVE,
+            ENABLE_FIXED_REVISION_FOR_CHUNKS];
+        if (remoteChecked) {
+            options.push(ADJUST_TO_REMOTE);
+        }
+        options.push(KEEP, DISMISS);
+        const ret = await this.core.confirm.confirmWithMessage("Case Sensitivity", message, options, DISMISS, 40);
+        console.dir(ret);
+        switch (ret) {
+            case ENABLE_BOTH:
+                this.settings.handleFilenameCaseSensitive = false;
+                this.settings.doNotUseFixedRevisionForChunks = false;
+                break;
+            case ENABLE_FILENAME_CASE_INSENSITIVE:
+                this.settings.handleFilenameCaseSensitive = false;
+                this.settings.doNotUseFixedRevisionForChunks = true;
+                break;
+            case ENABLE_FIXED_REVISION_FOR_CHUNKS:
+                this.settings.doNotUseFixedRevisionForChunks = false;
+                this.settings.handleFilenameCaseSensitive = true;
+                break;
+            case KEEP:
+                this.settings.handleFilenameCaseSensitive = true;
+                this.settings.doNotUseFixedRevisionForChunks = true;
+                this.settings.settingVersion = SETTING_VERSION_SUPPORT_CASE_INSENSITIVE;
+                await this.saveSettings();
+                return true;
+            case DISMISS:
+            default:
+                return false;
+
+        }
+        this.settings.settingVersion = SETTING_VERSION_SUPPORT_CASE_INSENSITIVE;
+        await this.saveSettings();
+        await this.core.rebuilder.scheduleRebuild();
+        await this.core.$$performRestart();
+
+    }
+
+    async initialMessage() {
+        const message = `Your device has **not been set up yet**. Let me guide you through the setup process.
+
+Please keep in mind that every dialogue content can be copied to the clipboard. If you need to refer to it later, you can paste it into a note in Obsidian. You can also translate it into your language using a translation tool.
+
+First, do you have **Setup URI**?
+
+Note: If you do not know what it is, please refer to the [documentation](${URI_DOC}).
+`;
+
+        const USE_SETUP = "Yes, I have";
+        const NEXT = "No, I do not have";
+
+        const ret = await this.core.confirm.askSelectStringDialogue(message, [
+            USE_SETUP, NEXT], {
+            title: "Welcome to Self-hosted LiveSync",
+            defaultAction: USE_SETUP
+        });
+        if (ret === USE_SETUP) {
+            eventHub.emitEvent(EVENT_REQUEST_OPEN_SETUP_URI);
+            return false;
+        }
+        else if (ret == NEXT) {
+            return true;
+        }
+        return false;
+    }
+
+    async askAgainForSetupURI() {
+        const message = `We strongly recommend that you generate a set-up URI and use it.
+If you do not have knowledge about it, please refer to the [documentation](${URI_DOC}) (Sorry again, but it is important).
+
+How do you want to set it up manually?`;
+
+        const USE_MINIMAL = "Take me into the setup wizard";
+        const USE_SETUP = "Set it up all manually";
+        const NEXT = "Remind me at the next launch";
+
+        const ret = await this.core.confirm.askSelectStringDialogue(message, [
+            USE_MINIMAL, USE_SETUP, NEXT], {
+            title: "Recommendation to use Setup URI",
+            defaultAction: USE_MINIMAL
+        });
+        if (ret === USE_MINIMAL) {
+            eventHub.emitEvent(EVENT_REQUEST_OPEN_SETTING_WIZARD);
+            return false;
+        }
+        if (ret === USE_SETUP) {
+            eventHub.emitEvent(EVENT_REQUEST_OPEN_SETTINGS);
+            return false;
+        }
+        else if (ret == NEXT) {
+            return false;
+        }
+        return false;
+    }
+
+    async $everyOnFirstInitialize(): Promise<boolean> {
+        if (!this.localDatabase.isReady) {
+            this._log(`Something went wrong! The local database is not ready`, LOG_LEVEL_NOTICE);
+            return false;
+        }
+        if (this.settings.isConfigured) {
+            await this.migrationCheck();
+            await this.migrateDisableBulkSend();
+        }
+        if (!this.settings.isConfigured) {
+            // Case sensitivity
+            if (!await this.initialMessage() || !await this.askAgainForSetupURI()) {
+                this._log("The setup has been cancelled, Self-hosted LiveSync waiting for your setup!", LOG_LEVEL_NOTICE);
+                return false;
+            }
+
+        }
+        return true;
+    }
+}

src/modules/essentialObsidian/APILib/ObsHttpHandler.ts

@@ -0,0 +1,134 @@
+// This file is based on a file that was published by the @remotely-save, under the Apache 2 License.
+// I would love to express my deepest gratitude to the original authors for their hard work and dedication. Without their contributions, this project would not have been possible.
+// 
+// Original Implementation is here: https://github.com/remotely-save/remotely-save/blob/28b99557a864ef59c19d2ad96101196e401718f0/src/remoteForS3.ts
+
+import {
+    FetchHttpHandler,
+    type FetchHttpHandlerOptions,
+} from "@smithy/fetch-http-handler";
+import { HttpRequest, HttpResponse, type HttpHandlerOptions } from "@smithy/protocol-http";
+//@ts-ignore
+import { requestTimeout } from "@smithy/fetch-http-handler/dist-es/request-timeout";
+import { buildQueryString } from "@smithy/querystring-builder";
+import { requestUrl, type RequestUrlParam } from "../../../deps.ts";
+////////////////////////////////////////////////////////////////////////////////
+// special handler using Obsidian requestUrl
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * This is close to origin implementation of FetchHttpHandler
+ * https://github.com/aws/aws-sdk-js-v3/blob/main/packages/fetch-http-handler/src/fetch-http-handler.ts
+ * that is released under Apache 2 License.
+ * But this uses Obsidian requestUrl instead.
+ */
+export class ObsHttpHandler extends FetchHttpHandler {
+    requestTimeoutInMs: number | undefined;
+    reverseProxyNoSignUrl: string | undefined;
+    constructor(
+        options?: FetchHttpHandlerOptions,
+        reverseProxyNoSignUrl?: string
+    ) {
+        super(options);
+        this.requestTimeoutInMs =
+            options === undefined ? undefined : options.requestTimeout;
+        this.reverseProxyNoSignUrl = reverseProxyNoSignUrl;
+    }
+    // eslint-disable-next-line require-await
+    async handle(
+        request: HttpRequest,
+        { abortSignal }: HttpHandlerOptions = {}
+    ): Promise<{ response: HttpResponse }> {
+        if (abortSignal?.aborted) {
+            const abortError = new Error("Request aborted");
+            abortError.name = "AbortError";
+            return Promise.reject(abortError);
+        }
+
+        let path = request.path;
+        if (request.query) {
+            const queryString = buildQueryString(request.query);
+            if (queryString) {
+                path += `?${queryString}`;
+            }
+        }
+
+        const { port, method } = request;
+        let url = `${request.protocol}//${request.hostname}${port ? `:${port}` : ""
+            }${path}`;
+        if (
+            this.reverseProxyNoSignUrl !== undefined &&
+            this.reverseProxyNoSignUrl !== ""
+        ) {
+            const urlObj = new URL(url);
+            urlObj.host = this.reverseProxyNoSignUrl;
+            url = urlObj.href;
+        }
+        const body =
+            method === "GET" || method === "HEAD" ? undefined : request.body;
+
+        const transformedHeaders: Record<string, string> = {};
+        for (const key of Object.keys(request.headers)) {
+            const keyLower = key.toLowerCase();
+            if (keyLower === "host" || keyLower === "content-length") {
+                continue;
+            }
+            transformedHeaders[keyLower] = request.headers[key];
+        }
+
+        let contentType: string | undefined = undefined;
+        if (transformedHeaders["content-type"] !== undefined) {
+            contentType = transformedHeaders["content-type"];
+        }
+
+        let transformedBody: any = body;
+        if (ArrayBuffer.isView(body)) {
+            transformedBody = new Uint8Array(body.buffer).buffer;
+        }
+
+        const param: RequestUrlParam = {
+            body: transformedBody,
+            headers: transformedHeaders,
+            method: method,
+            url: url,
+            contentType: contentType,
+        };
+
+        const raceOfPromises = [
+            requestUrl(param).then((rsp) => {
+                const headers = rsp.headers;
+                const headersLower: Record<string, string> = {};
+                for (const key of Object.keys(headers)) {
+                    headersLower[key.toLowerCase()] = headers[key];
+                }
+                const stream = new ReadableStream<Uint8Array>({
+                    start(controller) {
+                        controller.enqueue(new Uint8Array(rsp.arrayBuffer));
+                        controller.close();
+                    },
+                });
+                return {
+                    response: new HttpResponse({
+                        headers: headersLower,
+                        statusCode: rsp.status,
+                        body: stream,
+                    }),
+                };
+            }),
+            requestTimeout(this.requestTimeoutInMs),
+        ];
+
+        if (abortSignal) {
+            raceOfPromises.push(
+                new Promise<never>((resolve, reject) => {
+                    abortSignal.onabort = () => {
+                        const abortError = new Error("Request aborted");
+                        abortError.name = "AbortError";
+                        reject(abortError);
+                    };
+                })
+            );
+        }
+        return Promise.race(raceOfPromises);
+    }
+}

src/modules/essentialObsidian/ModuleObsidianAPI.ts

@@ -0,0 +1,207 @@
+import { AbstractObsidianModule, type IObsidianModule } from '../AbstractObsidianModule.ts';
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE } from 'octagonal-wheels/common/logger';
+import { Notice, requestUrl, type RequestUrlParam, type RequestUrlResponse } from '../../deps.ts';
+import { type EntryDoc, type FilePathWithPrefix } from '../../lib/src/common/types.ts';
+import { getPathFromTFile } from '../../common/utils.ts';
+import { disableEncryption, enableEncryption, isCloudantURI, isValidRemoteCouchDBURI, replicationFilter } from '../../lib/src/pouchdb/utils_couchdb.ts';
+import { setNoticeClass } from '../../lib/src/mock_and_interop/wrapper.ts';
+import { ObsHttpHandler } from './APILib/ObsHttpHandler.ts';
+import { PouchDB } from '../../lib/src/pouchdb/pouchdb-browser.ts';
+import { reactive, reactiveSource } from 'octagonal-wheels/dataobject/reactive';
+
+setNoticeClass(Notice);
+
+
+async function fetchByAPI(request: RequestUrlParam): Promise<RequestUrlResponse> {
+    const ret = await requestUrl(request);
+    if (ret.status - (ret.status % 100) !== 200) {
+        const er: Error & { status?: number } = new Error(`Request Error:${ret.status}`);
+        if (ret.json) {
+            er.message = ret.json.reason;
+            er.name = `${ret.json.error ?? ""}:${ret.json.message ?? ""}`;
+        }
+        er.status = ret.status;
+        throw er;
+    }
+    return ret;
+}
+
+export class ModuleObsidianAPI extends AbstractObsidianModule implements IObsidianModule {
+
+    _customHandler!: ObsHttpHandler;
+    authHeaderSource = reactiveSource<string>("");
+    authHeader = reactive(() =>
+        this.authHeaderSource.value == "" ? "" : "Basic " + window.btoa(this.authHeaderSource.value));
+
+    $$customFetchHandler(): ObsHttpHandler {
+        if (!this._customHandler) this._customHandler = new ObsHttpHandler(undefined, undefined);
+        return this._customHandler;
+    }
+
+    async $$connectRemoteCouchDB(uri: string, auth: { username: string; password: string }, disableRequestURI: boolean, passphrase: string | false, useDynamicIterationCount: boolean, performSetup: boolean, skipInfo: boolean, compression: boolean): Promise<string | { db: PouchDB.Database<EntryDoc>; info: PouchDB.Core.DatabaseInfo }> {
+        if (!isValidRemoteCouchDBURI(uri)) return "Remote URI is not valid";
+        if (uri.toLowerCase() != uri) return "Remote URI and database name could not contain capital letters.";
+        if (uri.indexOf(" ") !== -1) return "Remote URI and database name could not contain spaces.";
+        const userNameAndPassword = (auth.username && auth.password) ? `${auth.username}:${auth.password}` : "";
+        if (this.authHeaderSource.value != userNameAndPassword) {
+            this.authHeaderSource.value = userNameAndPassword;
+        }
+        const authHeader = this.authHeader.value;
+        // const _this = this;
+
+        const conf: PouchDB.HttpAdapter.HttpAdapterConfiguration = {
+            adapter: "http",
+            auth,
+            skip_setup: !performSetup,
+            fetch: async (url: string | Request, opts?: RequestInit) => {
+                let size = "";
+                const localURL = url.toString().substring(uri.length);
+                const method = opts?.method ?? "GET";
+                if (opts?.body) {
+                    const opts_length = opts.body.toString().length;
+                    if (opts_length > 1000 * 1000 * 10) {
+                        // over 10MB
+                        if (isCloudantURI(uri)) {
+                            this.plugin.last_successful_post = false;
+                            this._log("This request should fail on IBM Cloudant.", LOG_LEVEL_VERBOSE);
+                            throw new Error("This request should fail on IBM Cloudant.");
+                        }
+                    }
+                    size = ` (${opts_length})`;
+                }
+                if (!disableRequestURI && typeof url == "string" && typeof (opts?.body ?? "") == "string") {
+                    const body = opts?.body as string;
+
+                    const transformedHeaders = { ...(opts?.headers as Record<string, string>) };
+                    if (authHeader != "") transformedHeaders["authorization"] = authHeader;
+                    delete transformedHeaders["host"];
+                    delete transformedHeaders["Host"];
+                    delete transformedHeaders["content-length"];
+                    delete transformedHeaders["Content-Length"];
+                    const requestParam: RequestUrlParam = {
+                        url,
+                        method: opts?.method,
+                        body: body,
+                        headers: transformedHeaders,
+                        contentType: "application/json",
+                        // contentType: opts.headers,
+                    };
+
+                    try {
+                        this.plugin.requestCount.value = this.plugin.requestCount.value + 1;
+                        const r = await fetchByAPI(requestParam);
+                        if (method == "POST" || method == "PUT") {
+                            this.plugin.last_successful_post = r.status - (r.status % 100) == 200;
+                        } else {
+                            this.plugin.last_successful_post = true;
+                        }
+                        this._log(`HTTP:${method}${size} to:${localURL} -> ${r.status}`, LOG_LEVEL_DEBUG);
+
+                        return new Response(r.arrayBuffer, {
+                            headers: r.headers,
+                            status: r.status,
+                            statusText: `${r.status}`,
+                        });
+                    } catch (ex) {
+                        this._log(`HTTP:${method}${size} to:${localURL} -> failed`, LOG_LEVEL_VERBOSE);
+                        // limit only in bulk_docs.
+                        if (url.toString().indexOf("_bulk_docs") !== -1) {
+                            this.plugin.last_successful_post = false;
+                        }
+                        this._log(ex);
+                        throw ex;
+                    } finally {
+                        this.plugin.responseCount.value = this.plugin.responseCount.value + 1;
+                    }
+                }
+
+                try {
+                    if (this.settings.enableDebugTools) {
+                        // Issue #407
+                        (opts!.headers as Headers).append("ngrok-skip-browser-warning", "123");
+                    }
+                    this.plugin.requestCount.value = this.plugin.requestCount.value + 1;
+                    const response: Response = await fetch(url, opts);
+                    if (method == "POST" || method == "PUT") {
+                        this.plugin.last_successful_post = response.ok;
+                    } else {
+                        this.plugin.last_successful_post = true;
+                    }
+                    this._log(`HTTP:${method}${size} to:${localURL} -> ${response.status}`, LOG_LEVEL_DEBUG);
+                    if (Math.floor(response.status / 100) !== 2) {
+                        if (method != "GET" && localURL.indexOf("/_local/") === -1 && !localURL.endsWith("/")) {
+                            const r = response.clone();
+                            this._log(`The request may have failed. The reason sent by the server: ${r.status}: ${r.statusText}`);
+
+                            try {
+                                this._log(await (await r.blob()).text(), LOG_LEVEL_VERBOSE);
+                            } catch (_) {
+                                this._log("Cloud not parse response", LOG_LEVEL_VERBOSE);
+                                this._log(_, LOG_LEVEL_VERBOSE);
+                            }
+                        } else {
+                            this._log(`Just checkpoint or some server information has been missing. The 404 error shown above is not an error.`, LOG_LEVEL_VERBOSE)
+                        }
+                    }
+                    return response;
+                } catch (ex) {
+                    this._log(`HTTP:${method}${size} to:${localURL} -> failed`, LOG_LEVEL_VERBOSE);
+                    // limit only in bulk_docs.
+                    if (url.toString().indexOf("_bulk_docs") !== -1) {
+                        this.plugin.last_successful_post = false;
+                    }
+                    this._log(ex);
+                    throw ex;
+                } finally {
+                    this.plugin.responseCount.value = this.plugin.responseCount.value + 1;
+                }
+                // return await fetch(url, opts);
+            },
+        };
+
+        const db: PouchDB.Database<EntryDoc> = new PouchDB<EntryDoc>(uri, conf);
+        replicationFilter(db, compression);
+        disableEncryption();
+        if (passphrase !== "false" && typeof passphrase === "string") {
+            enableEncryption(db, passphrase, useDynamicIterationCount, false);
+        }
+        if (skipInfo) {
+            return { db: db, info: { db_name: "", doc_count: 0, update_seq: "" } };
+        }
+        try {
+            const info = await db.info();
+            return { db: db, info: info };
+        } catch (ex: any) {
+            let msg = `${ex?.name}:${ex?.message}`;
+            if (ex?.name == "TypeError" && ex?.message == "Failed to fetch") {
+                msg += "\n**Note** This error caused by many reasons. The only sure thing is you didn't touch the server.\nTo check details, open inspector.";
+            }
+            this._log(ex, LOG_LEVEL_VERBOSE);
+            return msg;
+        }
+    }
+
+    $$isMobile(): boolean {
+        //@ts-ignore : internal API
+        return this.app.isMobile;
+    }
+
+    $$vaultName(): string {
+        return this.app.vault.getName();
+    }
+    $$getVaultName(): string {
+        return this.core.$$vaultName() + (this.settings?.additionalSuffixOfDatabaseName ? ("-" + this.settings.additionalSuffixOfDatabaseName) : "");
+    }
+    $$getActiveFilePath(): FilePathWithPrefix | undefined {
+        const file = this.app.workspace.getActiveFile();
+        if (file) {
+            return getPathFromTFile(file);
+        }
+        return undefined;
+    }
+
+    $anyGetAppId(): Promise<string | undefined> {
+        return Promise.resolve(`${("appId" in this.app ? this.app.appId : "")}`);
+    }
+
+}

src/modules/essentialObsidian/ModuleObsidianEvents.ts

@@ -0,0 +1,217 @@
+import { AbstractObsidianModule, type IObsidianModule } from '../AbstractObsidianModule.ts';
+import { EVENT_FILE_RENAMED, EVENT_LEAF_ACTIVE_CHANGED, eventHub } from '../../common/events.js';
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from 'octagonal-wheels/common/logger';
+import { scheduleTask } from 'octagonal-wheels/concurrency/task';
+import { type TFile } from '../../deps.ts';
+import { fireAndForget } from 'octagonal-wheels/promises';
+import { type FilePathWithPrefix } from '../../lib/src/common/types.ts';
+import { reactive, reactiveSource } from 'octagonal-wheels/dataobject/reactive';
+import { collectingChunks, pluginScanningCount, hiddenFilesEventCount, hiddenFilesProcessingCount } from '../../lib/src/mock_and_interop/stores.ts';
+
+export class ModuleObsidianEvents extends AbstractObsidianModule implements IObsidianModule {
+
+    $everyOnloadStart(): Promise<boolean> {
+        // this.registerEvent(this.app.workspace.on("editor-change", ));
+        this.plugin.registerEvent(this.app.vault.on("rename", (file, oldPath) => {
+            eventHub.emitEvent(EVENT_FILE_RENAMED, { newPath: file.path, old: oldPath });
+        }));
+        this.plugin.registerEvent(this.app.workspace.on("active-leaf-change", () => eventHub.emitEvent(EVENT_LEAF_ACTIVE_CHANGED)));
+        return Promise.resolve(true);
+    }
+
+
+    $$performRestart(): void {
+        this._performAppReload();
+    }
+
+    _performAppReload() {
+        //@ts-ignore
+        this.app.commands.executeCommandById("app:reload");
+    }
+
+    initialCallback: any;
+
+    swapSaveCommand() {
+        this._log("Modifying callback of the save command", LOG_LEVEL_VERBOSE);
+        const saveCommandDefinition = (this.app as any).commands?.commands?.[
+            "editor:save-file"
+        ];
+        const save = saveCommandDefinition?.callback;
+        if (typeof save === "function") {
+            this.initialCallback = save;
+            saveCommandDefinition.callback = () => {
+                scheduleTask("syncOnEditorSave", 250, () => {
+                    if (this.plugin._unloaded) {
+                        this._log("Unload and remove the handler.", LOG_LEVEL_VERBOSE);
+                        saveCommandDefinition.callback = this.initialCallback;
+                        this.initialCallback = undefined;
+                    } else {
+                        if (this.settings.syncOnEditorSave) {
+                            this._log("Sync on Editor Save.", LOG_LEVEL_VERBOSE);
+                            fireAndForget(() => this.core.$$replicate());
+                        }
+                    }
+                });
+                save();
+            };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const _this = this;
+        //@ts-ignore
+        window.CodeMirrorAdapter.commands.save = () => {
+            //@ts-ignore
+            _this.app.commands.executeCommandById('editor:save-file')
+            // _this.app.performCommand('editor:save-file');
+        };
+    }
+
+    registerWatchEvents() {
+        this.setHasFocus = this.setHasFocus.bind(this);
+        this.watchWindowVisibility = this.watchWindowVisibility.bind(this);
+        this.watchWorkspaceOpen = this.watchWorkspaceOpen.bind(this);
+        this.watchOnline = this.watchOnline.bind(this);
+        this.plugin.registerEvent(this.app.workspace.on("file-open", this.watchWorkspaceOpen));
+        this.plugin.registerDomEvent(document, "visibilitychange", this.watchWindowVisibility);
+        this.plugin.registerDomEvent(window, "focus", () => this.setHasFocus(true));
+        this.plugin.registerDomEvent(window, "blur", () => this.setHasFocus(false));
+        this.plugin.registerDomEvent(window, "online", this.watchOnline);
+        this.plugin.registerDomEvent(window, "offline", this.watchOnline);
+    }
+
+    hasFocus = true;
+    isLastHidden = false;
+
+    setHasFocus(hasFocus: boolean) {
+        this.hasFocus = hasFocus;
+        this.watchWindowVisibility();
+    }
+
+    watchWindowVisibility() {
+        scheduleTask("watch-window-visibility", 100, () => fireAndForget(() => this.watchWindowVisibilityAsync()));
+    }
+
+    watchOnline() {
+        scheduleTask("watch-online", 500, () => fireAndForget(() => this.watchOnlineAsync()));
+    }
+    async watchOnlineAsync() {
+        // If some files were failed to retrieve, scan files again.
+        // TODO:FIXME AT V0.17.31, this logic has been disabled.
+        if (navigator.onLine && this.localDatabase.needScanning) {
+            this.localDatabase.needScanning = false;
+            await this.plugin.$$performFullScan();
+        }
+    }
+
+    async watchWindowVisibilityAsync() {
+        if (this.settings.suspendFileWatching) return;
+        if (!this.settings.isConfigured) return;
+        if (!this.plugin.isReady) return;
+
+        if (this.isLastHidden && !this.hasFocus) {
+            // NO OP while non-focused after made hidden;
+            return;
+        }
+
+        const isHidden = document.hidden;
+        if (this.isLastHidden === isHidden) {
+            return;
+        }
+        this.isLastHidden = isHidden;
+
+        await this.core.$everyCommitPendingFileEvent();
+
+        if (isHidden) {
+            await this.core.$everyBeforeSuspendProcess();
+        } else {
+            // suspend all temporary.
+            if (this.plugin.suspended) return;
+            if (!this.hasFocus) return;
+            await this.core.$everyOnResumeProcess();
+            await this.core.$everyAfterResumeProcess();
+        }
+    }
+    watchWorkspaceOpen(file: TFile | null) {
+        if (this.settings.suspendFileWatching) return;
+        if (!this.settings.isConfigured) return;
+        if (!this.plugin.isReady) return;
+        if (!file) return;
+        scheduleTask("watch-workspace-open", 500, () => fireAndForget(() => this.watchWorkspaceOpenAsync(file)));
+    }
+
+    async watchWorkspaceOpenAsync(file: TFile) {
+        if (this.settings.suspendFileWatching) return;
+        if (!this.settings.isConfigured) return;
+        if (!this.plugin.isReady) return;
+        await this.core.$everyCommitPendingFileEvent();
+        if (file == null) {
+            return;
+        }
+        if (this.settings.syncOnFileOpen && !this.plugin.suspended) {
+            await this.core.$$replicate();
+        }
+        await this.core.$$queueConflictCheckIfOpen(file.path as FilePathWithPrefix);
+    }
+
+    $everyOnLayoutReady(): Promise<boolean> {
+        this.swapSaveCommand();
+        this.registerWatchEvents();
+        return Promise.resolve(true);
+    }
+
+
+    $$askReload(message?: string) {
+        if (this.core.isReloadingScheduled) {
+            this._log(`Reloading is already scheduled`, LOG_LEVEL_VERBOSE);
+            return;
+        }
+        scheduleTask("configReload", 250, async () => {
+            const RESTART_NOW = "Yes, restart immediately";
+            const RESTART_AFTER_STABLE = "Yes, schedule a restart after stabilisation";
+            const RETRY_LATER = "No, Leave it to me";
+            const ret = await this.core.confirm.askSelectStringDialogue(message || "Do you want to restart and reload Obsidian now?", [
+                RESTART_AFTER_STABLE,
+                RESTART_NOW,
+                RETRY_LATER], { defaultAction: RETRY_LATER });
+            if (ret == RESTART_NOW) {
+                this._performAppReload();
+            } else if (ret == RESTART_AFTER_STABLE) {
+                this.core.$$scheduleAppReload();
+            }
+        })
+    }
+    $$scheduleAppReload() {
+        if (!this.core._totalProcessingCount) {
+            const __tick = reactiveSource(0);
+            this.core._totalProcessingCount = reactive(() => {
+                const dbCount = this.core.databaseQueueCount.value;
+                const replicationCount = this.core.replicationResultCount.value;
+                const storageApplyingCount = this.core.storageApplyingCount.value;
+                const chunkCount = collectingChunks.value;
+                const pluginScanCount = pluginScanningCount.value;
+                const hiddenFilesCount = hiddenFilesEventCount.value + hiddenFilesProcessingCount.value;
+                const conflictProcessCount = this.core.conflictProcessQueueCount.value;
+                const e = this.core.pendingFileEventCount.value;
+                const proc = this.core.processingFileEventCount.value;
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const __ = __tick.value;
+                return dbCount + replicationCount + storageApplyingCount + chunkCount + pluginScanCount + hiddenFilesCount + conflictProcessCount + e + proc;
+            })
+            this.plugin.registerInterval(setInterval(() => {
+                __tick.value++;
+            }, 1000) as unknown as number);
+
+            let stableCheck = 3;
+            this.core._totalProcessingCount.onChanged(e => {
+                if (e.value == 0) {
+                    if (stableCheck-- <= 0) {
+                        this._performAppReload();
+                    }
+                    this._log(`Obsidian will be restarted soon! (Within ${stableCheck} seconds)`, LOG_LEVEL_NOTICE, "restart-notice");
+                } else {
+                    stableCheck = 3;
+                }
+            })
+        }
+    }
+
+}

src/modules/essentialObsidian/ModuleObsidianMenu.ts

@@ -0,0 +1,136 @@
+import { fireAndForget } from "octagonal-wheels/promises";
+import { addIcon, type Editor, type MarkdownFileInfo, type MarkdownView } from "../../deps.ts";
+import { LOG_LEVEL_NOTICE, type FilePathWithPrefix } from "../../lib/src/common/types.ts";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+
+export class ModuleObsidianMenu extends AbstractObsidianModule implements IObsidianModule {
+
+    $everyOnloadStart(): Promise<boolean> {
+
+        // UI
+        addIcon(
+            "replicate",
+            `<g transform="matrix(1.15 0 0 1.15 -8.31 -9.52)" fill="currentColor" fill-rule="evenodd">
+            <path d="m85 22.2c-0.799-4.74-4.99-8.37-9.88-8.37-0.499 0-1.1 0.101-1.6 0.101-2.4-3.03-6.09-4.94-10.3-4.94-6.09 0-11.2 4.14-12.8 9.79-5.59 1.11-9.78 6.05-9.78 12 0 6.76 5.39 12.2 12 12.2h29.9c5.79 0 10.1-4.74 10.1-10.6 0-4.84-3.29-8.88-7.68-10.2zm-2.99 14.7h-29.5c-2.3-0.202-4.29-1.51-5.29-3.53-0.899-2.12-0.699-4.54 0.698-6.46 1.2-1.61 2.99-2.52 4.89-2.52 0.299 0 0.698 0 0.998 0.101l1.8 0.303v-2.02c0-3.63 2.4-6.76 5.89-7.57 0.599-0.101 1.2-0.202 1.8-0.202 2.89 0 5.49 1.62 6.79 4.24l0.598 1.21 1.3-0.504c0.599-0.202 1.3-0.303 2-0.303 1.3 0 2.5 0.404 3.59 1.11 1.6 1.21 2.6 3.13 2.6 5.15v1.61h2c2.6 0 4.69 2.12 4.69 4.74-0.099 2.52-2.2 4.64-4.79 4.64z"/>
+            <path d="m53.2 49.2h-41.6c-1.8 0-3.2 1.4-3.2 3.2v28.6c0 1.8 1.4 3.2 3.2 3.2h15.8v4h-7v6h24v-6h-7v-4h15.8c1.8 0 3.2-1.4 3.2-3.2v-28.6c0-1.8-1.4-3.2-3.2-3.2zm-2.8 29h-36v-23h36z"/>
+            <path d="m73 49.2c1.02 1.29 1.53 2.97 1.53 4.56 0 2.97-1.74 5.65-4.39 7.04v-4.06l-7.46 7.33 7.46 7.14v-4.06c7.66-1.98 12.2-9.61 10-17-0.102-0.297-0.205-0.595-0.307-0.892z"/>
+            <path d="m24.1 43c-0.817-0.991-1.53-2.97-1.53-4.56 0-2.97 1.74-5.65 4.39-7.04v4.06l7.46-7.33-7.46-7.14v4.06c-7.66 1.98-12.2 9.61-10 17 0.102 0.297 0.205 0.595 0.307 0.892z"/>
+           </g>`
+        );
+
+        this.addRibbonIcon("replicate", "Replicate", async () => {
+            await this.plugin.$$replicate(true);
+        }).addClass("livesync-ribbon-replicate");
+
+
+        this.addCommand({
+            id: "livesync-replicate",
+            name: "Replicate now",
+            callback: async () => {
+                await this.plugin.$$replicate();
+            },
+        });
+        this.addCommand({
+            id: "livesync-dump",
+            name: "Dump information of this doc ",
+            callback: () => {
+                const file = this.plugin.$$getActiveFilePath();
+                if (!file) return;
+                fireAndForget(() => this.localDatabase.getDBEntry(file, {}, true, false));
+            },
+        });
+        this.addCommand({
+            id: "livesync-checkdoc-conflicted",
+            name: "Resolve if conflicted.",
+            editorCallback: (editor: Editor, view: MarkdownView | MarkdownFileInfo) => {
+                const file = view.file;
+                if (!file) return;
+                void this.plugin.$$queueConflictCheckIfOpen(file.path as FilePathWithPrefix);
+            },
+        });
+
+        this.addCommand({
+            id: "livesync-toggle",
+            name: "Toggle LiveSync",
+            callback: async () => {
+                if (this.settings.liveSync) {
+                    this.settings.liveSync = false;
+                    this._log("LiveSync Disabled.", LOG_LEVEL_NOTICE);
+                } else {
+                    this.settings.liveSync = true;
+                    this._log("LiveSync Enabled.", LOG_LEVEL_NOTICE);
+                }
+                await this.plugin.realizeSettingSyncMode();
+                await this.plugin.saveSettings();
+            },
+        });
+        this.addCommand({
+            id: "livesync-suspendall",
+            name: "Toggle All Sync.",
+            callback: async () => {
+                if (this.plugin.suspended) {
+                    this.plugin.suspended = false;
+                    this._log("Self-hosted LiveSync resumed", LOG_LEVEL_NOTICE);
+                } else {
+                    this.plugin.suspended = true;
+                    this._log("Self-hosted LiveSync suspended", LOG_LEVEL_NOTICE);
+                }
+                await this.plugin.realizeSettingSyncMode();
+                await this.plugin.saveSettings();
+            },
+        });
+
+        this.addCommand({
+            id: "livesync-scan-files",
+            name: "Scan storage and database again",
+            callback: async () => {
+                await this.plugin.$$performFullScan(true)
+            }
+        })
+
+        this.addCommand({
+            id: "livesync-runbatch",
+            name: "Run pended batch processes",
+            callback: async () => {
+                await this.core.$everyCommitPendingFileEvent();
+            },
+        })
+
+        // TODO, Replicator is possibly one of features. It should be moved to features.
+        this.addCommand({
+            id: "livesync-abortsync",
+            name: "Abort synchronization immediately",
+            callback: () => {
+                this.plugin.replicator.terminateSync();
+            },
+        })
+        return Promise.resolve(true);
+
+    }
+    $everyOnload(): Promise<boolean> {
+        this.app.workspace.onLayoutReady(this.plugin.onLiveSyncReady.bind(this.plugin));
+        // eslint-disable-next-line no-unused-labels
+        return Promise.resolve(true);
+    }
+
+    async $$showView(viewType: string) {
+        const leaves = this.app.workspace.getLeavesOfType(viewType);
+        if (leaves.length == 0) {
+            await this.app.workspace.getLeaf(true).setViewState({
+                type: viewType,
+                active: true,
+            });
+        } else {
+            await leaves[0].setViewState({
+                type: viewType,
+                active: true,
+            })
+        }
+        if (leaves.length > 0) {
+            this.app.workspace.revealLeaf(
+                leaves[0]
+            );
+        }
+    }
+
+}

src/modules/extras/ModuleDev.ts

@@ -0,0 +1,114 @@
+import { fireAndForget } from "octagonal-wheels/promises";
+import { __onMissingTranslation } from "../../lib/src/common/i18n";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { eventHub } from "../../common/events";
+import { enableTestFunction } from "./devUtil/testUtils.ts";
+import { TestPaneView, VIEW_TYPE_TEST } from "./devUtil/TestPaneView.ts";
+import { writable } from "svelte/store";
+
+export class ModuleDev extends AbstractObsidianModule implements IObsidianModule {
+
+    $everyOnloadStart(): Promise<boolean> {
+        __onMissingTranslation(() => { });
+        return Promise.resolve(true);
+    }
+    $everyOnloadAfterLoadSettings(): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        // eslint-disable-next-line no-unused-labels
+        __onMissingTranslation((key) => {
+            const now = new Date();
+            const filename = `missing-translation-`
+            const time = now.toISOString().split("T")[0];
+            const outFile = `${filename}${time}.jsonl`;
+            const piece = JSON.stringify(
+                {
+                    [key]: {}
+                }
+            )
+            const writePiece = piece.substring(1, piece.length - 1) + ",";
+            fireAndForget(async () => {
+                try {
+                    await this.core.storageAccess.ensureDir(this.app.vault.configDir + "/ls-debug/");
+                    await this.core.storageAccess.appendHiddenFile(this.app.vault.configDir + "/ls-debug/" + outFile, writePiece + "\n")
+                } catch (ex) {
+                    this._log(`Could not write ${outFile}`, LOG_LEVEL_VERBOSE);
+                    this._log(`Missing translation: ${writePiece}`, LOG_LEVEL_VERBOSE);
+                    this._log(ex, LOG_LEVEL_VERBOSE);
+                }
+            });
+        })
+        type STUB = {
+            toc: Set<string>,
+            stub: { [key: string]: { [key: string]: Map<string, Record<string, string>> } }
+        };
+        eventHub.onEvent("document-stub-created", (e: CustomEvent<STUB>) => {
+            fireAndForget(async () => {
+                const stub = e.detail.stub;
+                const toc = e.detail.toc;
+
+                const stubDocX =
+                    Object.entries(stub).map(([key, value]) => {
+                        return [`## ${key}`, Object.entries(value).
+                            map(([key2, value2]) => {
+                                return [`### ${key2}`,
+                                ([...(value2.entries())].map(([key3, value3]) => {
+                                    // return `#### ${key3}` + "\n" + JSON.stringify(value3);
+                                    const isObsolete = value3["is_obsolete"] ? " (obsolete)" : "";
+                                    const desc = value3["desc"] ?? "";
+                                    const key = value3["key"] ? "Setting key: " + value3["key"] + "\n" : "";
+                                    return `#### ${key3}${isObsolete}\n${key}${desc}\n`
+                                }))].flat()
+                            }).flat()].flat()
+                    }).flat();
+                const stubDocMD = `
+| Icon  | Description                                                       |
+| :---: | ----------------------------------------------------------------- |
+` +
+                    [...toc.values()].map(e => `${e}`).join("\n") + "\n\n" +
+                    stubDocX.join("\n");
+                await this.core.storageAccess.writeHiddenFileAuto(this.app.vault.configDir + "/ls-debug/stub-doc.md", stubDocMD);
+            })
+        });
+
+        enableTestFunction(this.plugin);
+        this.registerView(
+            VIEW_TYPE_TEST,
+            (leaf) => new TestPaneView(leaf, this.plugin, this)
+        );
+        this.addCommand({
+            id: "view-test",
+            name: "Open Test dialogue",
+            callback: () => {
+                void this.core.$$showView(VIEW_TYPE_TEST);
+            }
+        });
+        return Promise.resolve(true);
+    }
+    async $everyOnLayoutReady(): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        if (await this.core.storageAccess.isExistsIncludeHidden("_SHOWDIALOGAUTO.md")) {
+            void this.core.$$showView(VIEW_TYPE_TEST);
+        }
+        return true;
+    }
+    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;
+        });
+    }
+    $everyModuleTest(): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        // this.core.$$addTestResult("DevModule", "Test", true);
+        // return Promise.resolve(true);
+        // this.addTestResult("Test of test1", true, "Just OK", "This is a test of test");
+        // this.addTestResult("Test of test2", true, "Just OK?");
+        // this.addTestResult("Test of test3", true);
+        return this.testDone();
+    }
+}

src/modules/extras/ModuleIntegratedTest.ts

@@ -0,0 +1,441 @@
+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, type IObsidianModule } from "../AbstractObsidianModule";
+
+export class ModuleIntegratedTest extends AbstractObsidianModule implements IObsidianModule {
+
+    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.core.$$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.core.$anyResolveConflictByNewest(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.core.$anyResolveConflictByNewest(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.$$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);
+    }
+}

src/modules/extras/ModuleReplicateTest.ts

@@ -0,0 +1,528 @@
+import { delay } from "octagonal-wheels/promises";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { eventHub } from "../../common/events";
+import { webcrypto } from "crypto";
+import { uint8ArrayToHexString } from "octagonal-wheels/binary/hex";
+import { parseYaml, requestUrl, stringifyYaml } from "obsidian";
+import type { FilePath } from "../../lib/src/common/types.ts";
+import { scheduleTask } from "octagonal-wheels/concurrency/task";
+
+export class ModuleReplicateTest extends AbstractObsidianModule implements IObsidianModule {
+
+
+    testRootPath = "_test/";
+    testInfoPath = "_testinfo/";
+
+    get isLeader() {
+        return this.core.$$getVaultName().indexOf("dev") >= 0 && this.core.$$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;
+    }
+    $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) {
+        const files = this.core.storageAccess.getFiles();
+        const out = [] as any[];
+        for (const file of files) {
+            if (!await this.core.$$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 = this.settings.syncInternalFilesIgnorePatterns
+            .replace(/\n| /g, "")
+            .split(",").filter(e => e).map(e => new RegExp(e, "i"));
+        const out = [] as any[];
+        const files = await this.core.storageAccess.getFilesIncludeHidden("", undefined, ignorePatterns);
+        console.dir(files);
+        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.core.$$replicate();
+
+        const commonFile = `Resolve! 
+*****, the amazing chocolatier!!`;
+
+        if (this.isLeader) {
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "wonka.md", commonFile);
+        }
+
+        await this.core.$$replicate();
+        await this.core.$$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.core.$$replicate();
+        await this.core.$$replicate();
+
+
+        if (!await this.waitFor(async () => {
+            await this.core.$$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.core.$$replicate();
+
+        const commonFile = `Resolve To concatenate
+ABCDEFG`;
+
+        if (this.isLeader) {
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "concat.md", commonFile);
+        }
+
+        await this.core.$$replicate();
+        await this.core.$$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.core.$$replicate();
+        await this.core.$$replicate();
+
+
+        if (!await this.waitFor(async () => {
+            await this.core.$$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.core.$$replicate();
+        await this.core.$$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.core.$$replicate();
+        await this.core.$$replicate();
+        await delay(1000);
+        if (await this.core.confirm.askYesNoDialog("Ready to check result?", { timeout: 30, defaultOption: "Yes" }) == "no") {
+            return;
+        }
+        await this.core.$$replicate();
+        await this.core.$$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);
+    }
+
+    async checkConflictResolution() {
+        this._log("Before testing conflicted files, resolve all once", LOG_LEVEL_NOTICE);
+        await this.core.rebuilder.resolveAllConflictedFilesByNewerOnes();
+        await this.core.rebuilder.resolveAllConflictedFilesByNewerOnes();
+        await this.core.$$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;
+    //     });
+    // }
+    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();
+    }
+}

src/modules/extras/devUtil/TestPane.svelte

@@ -0,0 +1,119 @@
+<script lang="ts">
+    import { onDestroy, 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;
+    let performanceTestResult = "";
+    let functionCheckResult = "";
+    let testRunning = false;
+    let prefTestResultEl: HTMLDivElement;
+    let isReady = false;
+    $: {
+        if (performanceTestResult != "" && isReady) {
+            MarkdownRenderer.render(plugin.app, performanceTestResult, prefTestResultEl, "/", plugin);
+        }
+    }
+
+    async function performTest() {
+        try {
+            testRunning = true;
+            performanceTestResult = await perf_trench(plugin);
+        } finally {
+            testRunning = false;
+        }
+    }
+    function clearResult() {
+        moduleDev.testResults.update((v) => {
+            v = [];
+            return v;
+        });
+    }
+    function clearPerfTestResult() {
+        prefTestResultEl.empty();
+    }
+    onMount(async () => {
+        isReady = true;
+        // performTest();
+
+        eventHub.once(EVENT_LAYOUT_READY, async () => {
+            if (await plugin.storageAccess.isExistsIncludeHidden("_AUTO_TEST.md")) {
+                new Notice("Auto test file found, running tests...");
+                fireAndForget(async () => {
+                    await allTest();
+                });
+            } else {
+                // new Notice("No auto test file found, skipping tests...");
+            }
+        });
+    });
+
+    let moduleTesting = false;
+    function moduleMultiDeviceTest() {
+        if (moduleTesting) return;
+        moduleTesting = true;
+        plugin.$everyModuleTestMultiDevice().finally(() => {
+            moduleTesting = false;
+        });
+    }
+    function moduleSingleDeviceTest() {
+        if (moduleTesting) return;
+        moduleTesting = true;
+        plugin.$everyModuleTest().finally(() => {
+            moduleTesting = false;
+        });
+    }
+    async function allTest() {
+        if (moduleTesting) return;
+        moduleTesting = true;
+        try {
+            await plugin.$everyModuleTest();
+            await plugin.$everyModuleTestMultiDevice();
+        } finally {
+            moduleTesting = false;
+        }
+    }
+
+    const results = moduleDev.testResults;
+    $: resultLines = $results;
+
+    let syncStatus = [] as string[];
+    eventHub.on<string[]>("debug-sync-status", (status) => {
+        syncStatus = [...status];
+    });
+</script>
+
+<h2>TESTING BENCH: Self-hosted LiveSync</h2>
+
+<h3>Module Checks</h3>
+<button on:click={() => moduleMultiDeviceTest()} disabled={moduleTesting}>MultiDevice Test</button>
+<button on:click={() => moduleSingleDeviceTest()} disabled={moduleTesting}>SingleDevice Test</button>
+<button on:click={() => allTest()} disabled={moduleTesting}>All Test</button>
+<button on:click={() => clearResult()}>Clear</button>
+
+{#each resultLines as [result, line, message]}
+    <details open={!result}>
+        <summary>[{result ? "PASS" : "FAILED"}] {line}</summary>
+        <pre>{message}</pre>
+    </details>
+{/each}
+
+<h3>Synchronisation Result Status</h3>
+<pre>{syncStatus.join("\n")}</pre>
+
+<h3>Performance test</h3>
+<button on:click={() => performTest()} disabled={testRunning}>Test!</button>
+<button on:click={() => clearPerfTestResult()}>Clear</button>
+
+<div bind:this={prefTestResultEl}></div>
+
+<style>
+    * {
+        box-sizing: border-box;
+    }
+</style>

src/modules/extras/devUtil/TestPaneView.ts

@@ -0,0 +1,55 @@
+import {
+    ItemView,
+    WorkspaceLeaf
+} from "obsidian";
+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";
+//Log view
+export class TestPaneView extends ItemView {
+
+    component?: TestPaneComponent;
+    plugin: ObsidianLiveSyncPlugin;
+    moduleDev: ModuleDev;
+    icon = "view-log";
+    title: string = "Self-hosted LiveSync Test and Results"
+    navigation = true;
+
+    getIcon(): string {
+        return "view-log";
+    }
+
+    constructor(leaf: WorkspaceLeaf, plugin: ObsidianLiveSyncPlugin, moduleDev: ModuleDev) {
+        super(leaf);
+        this.plugin = plugin;
+        this.moduleDev = moduleDev;
+    }
+
+
+    getViewType() {
+        return VIEW_TYPE_TEST;
+    }
+
+    getDisplayText() {
+        return "Self-hosted LiveSync Test and Results";
+    }
+
+    // eslint-disable-next-line require-await
+    async onOpen() {
+        this.component = new TestPaneComponent({
+            target: this.contentEl,
+            props: {
+                plugin: this.plugin,
+                moduleDev: this.moduleDev
+            },
+        });
+        await Promise.resolve();
+    }
+
+    // eslint-disable-next-line require-await
+    async onClose() {
+        this.component?.$destroy();
+        await Promise.resolve();
+    }
+}

src/modules/extras/devUtil/testUtils.ts

@@ -0,0 +1,46 @@
+import { fireAndForget } from "../../../lib/src/common/utils.ts";
+import { serialized } from "../../../lib/src/concurrency/lock.ts";
+import type ObsidianLiveSyncPlugin from "../../../main.ts";
+
+let plugin: ObsidianLiveSyncPlugin;
+export function enableTestFunction(plugin_: ObsidianLiveSyncPlugin) {
+    plugin = plugin_;
+}
+export function addDebugFileLog(message: any, stackLog = false) {
+    fireAndForget(serialized("debug-log", async () => {
+        const now = new Date();
+        const filename = `debug-log`
+        const time = now.toISOString().split("T")[0];
+        const outFile = `${filename}${time}.jsonl`;
+        // const messageContent = typeof message == "string" ? message : message instanceof Error ? `${message.name}:${message.message}` : JSON.stringify(message, null, 2);
+        const timestamp = now.toLocaleString();
+        const timestampEpoch = now;
+        let out = { "timestamp": timestamp, epoch: timestampEpoch, } as Record<string, any>;
+        if (message instanceof Error) {
+            // debugger;
+            // console.dir(message.stack);
+            out = { ...out, message };
+        } else if (stackLog) {
+            if (stackLog) {
+                const stackE = new Error();
+                const stack = stackE.stack;
+                out = { ...out, stack }
+            }
+        }
+        if (typeof message == "object") {
+            out = { ...out, ...message, }
+        } else {
+            out = {
+                result: message
+            }
+        }
+        // const out = "--" + timestamp + "--\n" + messageContent + " " + (stack || "");
+        // const out
+        try {
+            await plugin.storageAccess.appendHiddenFile(plugin.app.vault.configDir + "/ls-debug/" + outFile, JSON.stringify(out) + "\n")
+        } catch {
+
+            //NO OP
+        }
+    }));
+}

src/modules/extras/devUtil/tests.ts

@@ -0,0 +1,71 @@
+import { Trench } from "../../../lib/src/memory/memutil.ts";
+import type ObsidianLiveSyncPlugin from "../../../main.ts";
+type MeasureResult = [times: number, spent: number];
+type NamedMeasureResult = [name: string, result: MeasureResult];
+const measures = new Map<string, MeasureResult>();
+
+function clearResult(name: string) {
+    measures.set(name, [0, 0]);
+}
+async function measureEach(name: string, proc: () => (void | Promise<void>)) {
+    const [times, spent] = measures.get(name) ?? [0, 0];
+
+    const start = performance.now();
+    const result = proc();
+    if (result instanceof Promise) await result;
+    const end = performance.now();
+    measures.set(name, [times + 1, spent + (end - start)]);
+
+}
+function formatNumber(num: number) {
+    return num.toLocaleString('en-US', { maximumFractionDigits: 2 });
+}
+async function measure(name: string, proc: () => (void | Promise<void>), times: number = 10000, duration: number = 1000): Promise<NamedMeasureResult> {
+    const from = Date.now();
+    let last = times;
+    clearResult(name);
+    do {
+        await measureEach(name, proc);
+    } while (last-- > 0 && (Date.now() - from) < duration)
+    return [name, measures.get(name) as MeasureResult];
+}
+
+// eslint-disable-next-line require-await, @typescript-eslint/require-await
+async function formatPerfResults(items: NamedMeasureResult[]) {
+    return `| Name | Runs | Each | Total |\n| --- | --- | --- | --- | \n` + items.map(e => `| ${e[0]} | ${e[1][0]} | ${e[1][0] != 0 ? formatNumber(e[1][1] / e[1][0]) : "-"} | ${formatNumber(e[1][0])} |`).join("\n");
+
+}
+export async function perf_trench(plugin: ObsidianLiveSyncPlugin) {
+    clearResult("trench");
+    const trench = new Trench(plugin.simpleStore);
+    const result = [] as NamedMeasureResult[];
+    result.push(await measure("trench-short-string", async () => {
+        const p = trench.evacuate("string");
+        await p();
+    }));
+    {
+        const testBinary = await plugin.storageAccess.readHiddenFileBinary("testdata/10kb.png");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-10kb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    {
+        const testBinary = await plugin.storageAccess.readHiddenFileBinary("testdata/100kb.jpeg");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-100kb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    {
+        const testBinary = await plugin.storageAccess.readHiddenFileBinary("testdata/1mb.png");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-1mb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    return formatPerfResults(result);
+}

src/modules/features/DocumentHistory/DocumentHistoryModal.ts

@@ -0,0 +1,293 @@
+import { TFile, Modal, App, DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, diff_match_patch } from "../../../deps.ts";
+import { getPathFromTFile, isValidPath } from "../../../common/utils.ts";
+import { decodeBinary, escapeStringToHTML, readString } from "../../../lib/src/string_and_binary/convert.ts";
+import ObsidianLiveSyncPlugin from "../../../main.ts";
+import { type DocumentID, type FilePathWithPrefix, type LoadedEntry, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../../../lib/src/common/types.ts";
+import { Logger } from "../../../lib/src/common/logger.ts";
+import { isErrorOfMissingDoc } from "../../../lib/src/pouchdb/utils_couchdb.ts";
+import { fireAndForget, getDocData, readContent } from "../../../lib/src/common/utils.ts";
+import { isPlainText, stripPrefix } from "../../../lib/src/string_and_binary/path.ts";
+import { scheduleOnceIfDuplicated } from "octagonal-wheels/concurrency/lock";
+
+function isImage(path: string) {
+    const ext = path.split(".").splice(-1)[0].toLowerCase();
+    return ["png", "jpg", "jpeg", "gif", "bmp", "webp"].includes(ext);
+}
+function isComparableText(path: string) {
+    const ext = path.split(".").splice(-1)[0].toLowerCase();
+    return isPlainText(path) || ["md", "mdx", "txt", "json"].includes(ext);
+}
+function isComparableTextDecode(path: string) {
+    const ext = path.split(".").splice(-1)[0].toLowerCase();
+    return ["json"].includes(ext)
+}
+function readDocument(w: LoadedEntry) {
+    if (w.data.length == 0) return "";
+    if (isImage(w.path)) {
+        return new Uint8Array(decodeBinary(w.data));
+    }
+    if (w.type == "plain" || w.datatype == "plain") return getDocData(w.data);
+    if (isComparableTextDecode(w.path)) return readString(new Uint8Array(decodeBinary(w.data)));
+    if (isComparableText(w.path)) return getDocData(w.data);
+    try {
+        return readString(new Uint8Array(decodeBinary(w.data)));
+    } catch (ex) {
+        Logger(ex, LOG_LEVEL_VERBOSE);
+        // NO OP.
+    }
+    return getDocData(w.data);
+}
+export class DocumentHistoryModal extends Modal {
+    plugin: ObsidianLiveSyncPlugin;
+    range!: HTMLInputElement;
+    contentView!: HTMLDivElement;
+    info!: HTMLDivElement;
+    fileInfo!: HTMLDivElement;
+    showDiff = false;
+    id?: DocumentID;
+
+    file: FilePathWithPrefix;
+
+    revs_info: PouchDB.Core.RevisionInfo[] = [];
+    currentDoc?: LoadedEntry;
+    currentText = "";
+    currentDeleted = false;
+    initialRev?: string;
+
+    constructor(app: App, plugin: ObsidianLiveSyncPlugin, file: TFile | FilePathWithPrefix, id?: DocumentID, revision?: string) {
+        super(app);
+        this.plugin = plugin;
+        this.file = (file instanceof TFile) ? getPathFromTFile(file) : file;
+        this.id = id;
+        this.initialRev = revision;
+        if (!file && id) {
+            this.file = this.plugin.$$id2path(id);
+        }
+        if (localStorage.getItem("ols-history-highlightdiff") == "1") {
+            this.showDiff = true;
+        }
+    }
+
+    async loadFile(initialRev?: string) {
+        if (!this.id) {
+            this.id = await this.plugin.$$path2id(this.file);
+        }
+        const db = this.plugin.localDatabase;
+        try {
+            const w = await db.getRaw(this.id, { revs_info: true });
+            this.revs_info = w._revs_info?.filter((e) => e?.status == "available") ?? [];
+            this.range.max = `${Math.max(this.revs_info.length - 1, 0)}`;
+            this.range.value = this.range.max;
+            this.fileInfo.setText(`${this.file} / ${this.revs_info.length} revisions`);
+            await this.loadRevs(initialRev);
+        } catch (ex) {
+            if (isErrorOfMissingDoc(ex)) {
+                this.range.max = "0";
+                this.range.value = "";
+                this.range.disabled = true;
+                this.contentView.setText(`History of this file was not recorded.`);
+            } else {
+                this.contentView.setText(`Error occurred.`);
+                Logger(ex, LOG_LEVEL_VERBOSE);
+            }
+        }
+    }
+    async loadRevs(initialRev?: string) {
+        if (this.revs_info.length == 0) return;
+        if (initialRev) {
+            const rIndex = this.revs_info.findIndex(e => e.rev == initialRev);
+            if (rIndex >= 0) {
+                this.range.value = `${this.revs_info.length - 1 - rIndex}`;
+            }
+        }
+        const index = this.revs_info.length - 1 - (this.range.value as any) / 1;
+        const rev = this.revs_info[index];
+        await this.showExactRev(rev.rev);
+    }
+    BlobURLs = new Map<string, string>();
+
+    revokeURL(key: string) {
+        const v = this.BlobURLs.get(key);
+        if (v) {
+            URL.revokeObjectURL(v);
+        }
+        this.BlobURLs.delete(key);
+    }
+    generateBlobURL(key: string, data: Uint8Array) {
+        this.revokeURL(key);
+        const v = URL.createObjectURL(new Blob([data], { endings: "transparent", type: "application/octet-stream" }));
+        this.BlobURLs.set(key, v);
+        return v;
+    }
+
+    async showExactRev(rev: string) {
+        const db = this.plugin.localDatabase;
+        const w = await db.getDBEntry(this.file, { rev: rev }, false, false, true);
+        this.currentText = "";
+        this.currentDeleted = false;
+        if (w === false) {
+            this.currentDeleted = true;
+            this.info.innerHTML = "";
+            this.contentView.innerHTML = `Could not read this revision<br>(${rev})`;
+        } else {
+            this.currentDoc = w;
+            this.info.innerHTML = `Modified:${new Date(w.mtime).toLocaleString()}`;
+            let result = undefined;
+            const w1data = readDocument(w);
+            this.currentDeleted = !!w.deleted;
+            // this.currentText = w1data;
+            if (this.showDiff) {
+                const prevRevIdx = this.revs_info.length - 1 - ((this.range.value as any) / 1 - 1);
+                if (prevRevIdx >= 0 && prevRevIdx < this.revs_info.length) {
+                    const oldRev = this.revs_info[prevRevIdx].rev;
+                    const w2 = await db.getDBEntry(this.file, { rev: oldRev }, false, false, true);
+                    if (w2 != false) {
+                        if (typeof w1data == "string") {
+                            result = "";
+                            const dmp = new diff_match_patch();
+                            const w2data = readDocument(w2) as string;
+                            const diff = dmp.diff_main(w2data, w1data);
+                            dmp.diff_cleanupSemantic(diff);
+                            for (const v of diff) {
+                                const x1 = v[0];
+                                const x2 = v[1];
+                                if (x1 == DIFF_DELETE) {
+                                    result += "<span class='history-deleted'>" + escapeStringToHTML(x2) + "</span>";
+                                } else if (x1 == DIFF_EQUAL) {
+                                    result += "<span class='history-normal'>" + escapeStringToHTML(x2) + "</span>";
+                                } else if (x1 == DIFF_INSERT) {
+                                    result += "<span class='history-added'>" + escapeStringToHTML(x2) + "</span>";
+                                }
+                            }
+                            result = result.replace(/\n/g, "<br>");
+                        } else if (isImage(this.file)) {
+                            const src = this.generateBlobURL("base", w1data);
+                            const overlay = this.generateBlobURL("overlay", readDocument(w2) as Uint8Array);
+                            result =
+                                `<div class='ls-imgdiff-wrap'>
+    <div class='overlay'>
+        <img class='img-base' src="${src}">
+        <img class='img-overlay' src='${overlay}'>
+    </div>
+</div>`;
+                            this.contentView.removeClass("op-pre");
+                        }
+                    }
+                }
+
+            }
+            if (result == undefined) {
+                if (typeof w1data != "string") {
+                    if (isImage(this.file)) {
+                        const src = this.generateBlobURL("base", w1data);
+                        result =
+                            `<div class='ls-imgdiff-wrap'>
+<div class='overlay'>
+<img class='img-base' src="${src}">
+</div>
+</div>`;
+                        this.contentView.removeClass("op-pre");
+                    }
+                } else {
+                    result = escapeStringToHTML(w1data);
+                }
+            }
+            if (result == undefined) result = typeof w1data == "string" ? escapeStringToHTML(w1data) : "Binary file";
+            this.contentView.innerHTML = (this.currentDeleted ? "(At this revision, the file has been deleted)\n" : "") + result;
+        }
+    }
+
+    onOpen() {
+        const { contentEl } = this;
+        this.titleEl.setText("Document History");
+        contentEl.empty();
+        this.fileInfo = contentEl.createDiv("");
+        this.fileInfo.addClass("op-info");
+        const divView = contentEl.createDiv("");
+        divView.addClass("op-flex");
+
+        divView.createEl("input", { type: "range" }, (e) => {
+            this.range = e;
+            e.addEventListener("change", (e) => {
+                void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+            });
+            e.addEventListener("input", (e) => {
+                void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+            });
+        });
+        contentEl
+            .createDiv("", (e) => {
+                e.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" : "");
+                                void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+                            });
+                        })
+                    );
+                    label.appendText("Highlight diff");
+                });
+            })
+            .addClass("op-info");
+        this.info = contentEl.createDiv("");
+        this.info.addClass("op-info");
+        fireAndForget(async () => await this.loadFile(this.initialRev));
+        const div = contentEl.createDiv({ text: "Loading old revisions..." });
+        this.contentView = div;
+        div.addClass("op-scrollable");
+        div.addClass("op-pre");
+        const buttons = contentEl.createDiv("");
+        buttons.createEl("button", { text: "Copy to clipboard" }, (e) => {
+            e.addClass("mod-cta");
+            e.addEventListener("click", () => {
+                fireAndForget(async () => {
+                    await navigator.clipboard.writeText(this.currentText);
+                    Logger(`Old content copied to clipboard`, LOG_LEVEL_NOTICE);
+                });
+            });
+        });
+        const focusFile = async (path: string) => {
+            const targetFile = this.plugin.app.vault.getFileByPath(path);
+            if (targetFile) {
+                const leaf = this.plugin.app.workspace.getLeaf(false);
+                await leaf.openFile(targetFile);
+            } else {
+                Logger("The file could not view on the editor", LOG_LEVEL_NOTICE)
+            }
+        }
+        buttons.createEl("button", { text: "Back to this revision" }, (e) => {
+            e.addClass("mod-cta");
+            e.addEventListener("click", () => {
+                fireAndForget(async () => {
+                    // const pathToWrite = this.plugin.id2path(this.id, true);
+                    const pathToWrite = stripPrefix(this.file);
+                    if (!isValidPath(pathToWrite)) {
+                        Logger("Path is not valid to write content.", LOG_LEVEL_INFO);
+                        return;
+                    }
+                    if (!this.currentDoc) {
+                        Logger("No active file loaded.", LOG_LEVEL_INFO);
+                        return;
+                    }
+                    const d = readContent(this.currentDoc);
+                    await this.plugin.storageAccess.writeHiddenFileAuto(pathToWrite, d);
+                    await focusFile(pathToWrite);
+                    this.close();
+                });
+            });
+        });
+    }
+    onClose() {
+        const { contentEl } = this;
+        contentEl.empty();
+        this.BlobURLs.forEach(value => {
+            console.log(value);
+            if (value) URL.revokeObjectURL(value);
+        })
+    }
+}

src/modules/features/GlobalHistory/GlobalHistory.svelte

@@ -0,0 +1,325 @@
+<script lang="ts">
+    import ObsidianLiveSyncPlugin from "../../../main.ts";
+    import { onDestroy, onMount } from "svelte";
+    import type { AnyEntry, FilePathWithPrefix } from "../../../lib/src/common/types.ts";
+    import { getDocData, isAnyNote, isDocContentSame, readAsBlob } from "../../../lib/src/common/utils.ts";
+    import { diff_match_patch } from "../../../deps.ts";
+    import { DocumentHistoryModal } from "../DocumentHistory/DocumentHistoryModal.ts";
+    import { isPlainText, stripAllPrefixes } from "../../../lib/src/string_and_binary/path.ts";
+    import { TFile } from "../../../deps.ts";
+    import { getPath } from "../../../common/utils.ts";
+    export let plugin: ObsidianLiveSyncPlugin;
+
+    let showDiffInfo = false;
+    let showChunkCorrected = false;
+    let checkStorageDiff = false;
+
+    let range_from_epoch = Date.now() - 3600000 * 24 * 7;
+    let range_to_epoch = Date.now() + 3600000 * 24 * 2;
+    const timezoneOffset = new Date().getTimezoneOffset();
+    let dispDateFrom = new Date(range_from_epoch - timezoneOffset).toISOString().split("T")[0];
+    let dispDateTo = new Date(range_to_epoch - timezoneOffset).toISOString().split("T")[0];
+    $: {
+        range_from_epoch = new Date(dispDateFrom).getTime() + timezoneOffset;
+        range_to_epoch = new Date(dispDateTo).getTime() + timezoneOffset;
+
+        getHistory(showDiffInfo, showChunkCorrected, checkStorageDiff);
+    }
+    function mtimeToDate(mtime: number) {
+        return new Date(mtime).toLocaleString();
+    }
+
+    type HistoryData = {
+        id: string;
+        rev?: string;
+        path: string;
+        dirname: string;
+        filename: string;
+        mtime: number;
+        mtimeDisp: string;
+        isDeleted: boolean;
+        size: number;
+        changes: string;
+        chunks: string;
+        isPlain: boolean;
+    };
+    let history = [] as HistoryData[];
+    let loading = false;
+
+    async function fetchChanges(): Promise<HistoryData[]> {
+        try {
+            const db = plugin.localDatabase;
+            let result = [] as typeof history;
+            for await (const docA of db.findAllNormalDocs()) {
+                if (docA.mtime < range_from_epoch) {
+                    continue;
+                }
+                if (!isAnyNote(docA)) continue;
+                const path = getPath(docA as AnyEntry);
+                const isPlain = isPlainText(docA.path);
+                const revs = await db.getRaw(docA._id, { revs_info: true });
+                let p: string | undefined = undefined;
+                const reversedRevs = (revs._revs_info ?? []).reverse();
+                const DIFF_DELETE = -1;
+
+                const DIFF_EQUAL = 0;
+                const DIFF_INSERT = 1;
+
+                for (const revInfo of reversedRevs) {
+                    if (revInfo.status == "available") {
+                        const doc = (!isPlain && showDiffInfo) || (checkStorageDiff && revInfo.rev == docA._rev) ? await db.getDBEntry(path, { rev: revInfo.rev }, false, false, true) : await db.getDBEntryMeta(path, { rev: revInfo.rev }, true);
+                        if (doc === false) continue;
+                        const rev = revInfo.rev;
+
+                        const mtime = "mtime" in doc ? doc.mtime : 0;
+                        if (range_from_epoch > mtime) {
+                            continue;
+                        }
+                        if (range_to_epoch < mtime) {
+                            continue;
+                        }
+
+                        let diffDetail = "";
+                        if (showDiffInfo && !isPlain) {
+                            const data = getDocData(doc.data);
+                            if (p === undefined) {
+                                p = data;
+                            }
+                            if (p != data) {
+                                const dmp = new diff_match_patch();
+                                const diff = dmp.diff_main(p, data);
+                                dmp.diff_cleanupSemantic(diff);
+                                p = data;
+                                const pxInit = {
+                                    [DIFF_DELETE]: 0,
+                                    [DIFF_EQUAL]: 0,
+                                    [DIFF_INSERT]: 0,
+                                } as { [key: number]: number };
+                                const px = diff.reduce((p, c) => ({ ...p, [c[0]]: (p[c[0]] ?? 0) + c[1].length }), pxInit);
+                                diffDetail = `-${px[DIFF_DELETE]}, +${px[DIFF_INSERT]}`;
+                            }
+                        }
+                        const isDeleted = doc._deleted || (doc as any)?.deleted || false;
+                        if (isDeleted) {
+                            diffDetail += " 🗑️";
+                        }
+                        if (rev == docA._rev) {
+                            if (checkStorageDiff) {
+                                const isExist = await plugin.storageAccess.isExists(stripAllPrefixes(getPath(docA)));
+                                if (isExist) {
+                                    const data = await plugin.storageAccess.readFileAuto(stripAllPrefixes(getPath(docA)));
+                                    const d = readAsBlob(doc);
+                                    const result = await isDocContentSame(data, d);
+                                    if (result) {
+                                        diffDetail += " ⚖️";
+                                    } else {
+                                        diffDetail += " ⚠️";
+                                    }
+                                }
+                            }
+                        }
+                        const docPath = getPath(doc as AnyEntry);
+                        const [filename, ...pathItems] = docPath.split("/").reverse();
+
+                        let chunksStatus = "";
+                        if (showChunkCorrected) {
+                            const chunks = (doc as any)?.children ?? [];
+                            const loadedChunks = await db.allDocsRaw({ keys: [...chunks] });
+                            const totalCount = loadedChunks.rows.length;
+                            const errorCount = loadedChunks.rows.filter((e) => "error" in e).length;
+                            if (errorCount == 0) {
+                                chunksStatus = `✅ ${totalCount}`;
+                            } else {
+                                chunksStatus = `🔎 ${errorCount} ✅ ${totalCount}`;
+                            }
+                        }
+
+                        result.push({
+                            id: doc._id,
+                            rev: doc._rev,
+                            path: docPath,
+                            dirname: pathItems.reverse().join("/"),
+                            filename: filename,
+                            mtime: mtime,
+                            mtimeDisp: mtimeToDate(mtime),
+                            size: (doc as any)?.size ?? 0,
+                            isDeleted: isDeleted,
+                            changes: diffDetail,
+                            chunks: chunksStatus,
+                            isPlain: isPlain,
+                        });
+                    }
+                }
+            }
+
+            return [...result].sort((a, b) => b.mtime - a.mtime);
+        } finally {
+            loading = false;
+        }
+    }
+    async function getHistory(showDiffInfo: boolean, showChunkCorrected: boolean, checkStorageDiff: boolean) {
+        loading = true;
+        const newDisplay = [];
+        const page = await fetchChanges();
+        newDisplay.push(...page);
+        history = [...newDisplay];
+    }
+
+    function nextWeek() {
+        dispDateTo = new Date(range_to_epoch - timezoneOffset + 3600 * 1000 * 24 * 7).toISOString().split("T")[0];
+    }
+    function prevWeek() {
+        dispDateFrom = new Date(range_from_epoch - timezoneOffset - 3600 * 1000 * 24 * 7).toISOString().split("T")[0];
+    }
+
+    onMount(async () => {
+        await getHistory(showDiffInfo, showChunkCorrected, checkStorageDiff);
+    });
+    onDestroy(() => {});
+
+    function showHistory(file: string, rev: string) {
+        new DocumentHistoryModal(plugin.app, plugin, file as unknown as FilePathWithPrefix, undefined, rev).open();
+    }
+    function openFile(file: string) {
+        plugin.app.workspace.openLinkText(file, file);
+    }
+</script>
+
+<div class="globalhistory">
+    <h1>Vault history</h1>
+    <div class="control">
+        <div class="row"><label for="">From:</label><input type="date" bind:value={dispDateFrom} disabled={loading} /></div>
+        <div class="row"><label for="">To:</label><input type="date" bind:value={dispDateTo} disabled={loading} /></div>
+        <div class="row">
+            <label for="">Info:</label>
+            <label><input type="checkbox" bind:checked={showDiffInfo} disabled={loading} /><span>Diff</span></label>
+            <label><input type="checkbox" bind:checked={showChunkCorrected} disabled={loading} /><span>Chunks</span></label>
+            <label><input type="checkbox" bind:checked={checkStorageDiff} disabled={loading} /><span>File integrity</span></label>
+        </div>
+    </div>
+    {#if loading}
+        <div class="">Gathering information...</div>
+    {/if}
+    <table>
+        <tr>
+            <th> Date </th>
+            <th> Path </th>
+            <th> Rev </th>
+            <th> Stat </th>
+            {#if showChunkCorrected}
+                <th> Chunks </th>
+            {/if}
+        </tr>
+        <tr>
+            <td colspan="5" class="more">
+                {#if loading}
+                    <div class="" />
+                {:else}
+                    <div><button on:click={() => nextWeek()}>+1 week</button></div>
+                {/if}
+            </td>
+        </tr>
+        {#each history as entry}
+            <tr>
+                <td class="mtime">
+                    {entry.mtimeDisp}
+                </td>
+                <td class="path">
+                    <div class="filenames">
+                        <span class="path">/{entry.dirname.split("/").join(`​/`)}</span>
+                        <!-- svelte-ignore a11y-click-events-have-key-events -->
+                        <!-- svelte-ignore a11y-no-static-element-interactions -->
+                        <!-- svelte-ignore a11y-missing-attribute -->
+                        <span class="filename"><a on:click={() => openFile(entry.path)}>{entry.filename}</a></span>
+                    </div>
+                </td>
+                <td>
+                    <span class="rev">
+                        {#if entry.isPlain}
+                            <!-- svelte-ignore a11y-click-events-have-key-events -->
+                            <!-- svelte-ignore a11y-no-static-element-interactions -->
+                            <!-- svelte-ignore a11y-missing-attribute -->
+                            <a on:click={() => showHistory(entry.path, entry?.rev || "")}>{entry.rev}</a>
+                        {:else}
+                            {entry.rev}
+                        {/if}
+                    </span>
+                </td>
+                <td>
+                    {entry.changes}
+                </td>
+                {#if showChunkCorrected}
+                    <td>
+                        {entry.chunks}
+                    </td>
+                {/if}
+            </tr>
+        {/each}
+        <tr>
+            <td colspan="5" class="more">
+                {#if loading}
+                    <div class="" />
+                {:else}
+                    <div><button on:click={() => prevWeek()}>+1 week</button></div>
+                {/if}
+            </td>
+        </tr>
+    </table>
+</div>
+
+<style>
+    * {
+        box-sizing: border-box;
+    }
+    .globalhistory {
+        margin-bottom: 2em;
+    }
+    table {
+        width: 100%;
+    }
+    .more > div {
+        display: flex;
+    }
+    .more > div > button {
+        flex-grow: 1;
+    }
+    th {
+        position: sticky;
+        top: 0;
+        backdrop-filter: blur(10px);
+    }
+    td.mtime {
+        white-space: break-spaces;
+    }
+    td.path {
+        word-break: break-word;
+    }
+    .row {
+        display: flex;
+        flex-direction: row;
+        flex-wrap: wrap;
+    }
+    .row > label {
+        display: flex;
+        align-items: center;
+        min-width: 5em;
+    }
+    .row > input {
+        flex-grow: 1;
+    }
+
+    .filenames {
+        display: flex;
+        flex-direction: column;
+    }
+    .filenames > .path {
+        font-size: 70%;
+    }
+    .rev {
+        text-overflow: ellipsis;
+        max-width: 3em;
+        display: inline-block;
+        overflow: hidden;
+        white-space: nowrap;
+    }
+</style>

src/modules/features/GlobalHistory/GlobalHistoryView.ts

@@ -0,0 +1,49 @@
+import {
+    ItemView,
+    WorkspaceLeaf
+} from "../../../deps.ts";
+import GlobalHistoryComponent from "./GlobalHistory.svelte";
+import type ObsidianLiveSyncPlugin from "../../../main.ts";
+
+export const VIEW_TYPE_GLOBAL_HISTORY = "global-history";
+export class GlobalHistoryView extends ItemView {
+
+    component?: GlobalHistoryComponent;
+    plugin: ObsidianLiveSyncPlugin;
+    icon = "clock";
+    title: string = "";
+    navigation = true;
+
+    getIcon(): string {
+        return "clock";
+    }
+
+    constructor(leaf: WorkspaceLeaf, plugin: ObsidianLiveSyncPlugin) {
+        super(leaf);
+        this.plugin = plugin;
+    }
+
+
+    getViewType() {
+        return VIEW_TYPE_GLOBAL_HISTORY;
+    }
+
+    getDisplayText() {
+        return "Vault history";
+    }
+
+    async onOpen() {
+        this.component = new GlobalHistoryComponent({
+            target: this.contentEl,
+            props: {
+                plugin: this.plugin,
+            },
+        });
+        await Promise.resolve();
+    }
+
+    async onClose() {
+        this.component?.$destroy();
+        await Promise.resolve();
+    }
+}

src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts

@@ -0,0 +1,109 @@
+import { App, Modal } from "../../../deps.ts";
+import { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT } from "diff-match-patch";
+import { CANCELLED, LEAVE_TO_SUBSEQUENT, RESULT_TIMED_OUT, type diff_result } from "../../../lib/src/common/types.ts";
+import { escapeStringToHTML } from "../../../lib/src/string_and_binary/convert.ts";
+import { delay, fireAndForget, sendValue, waitForValue } from "../../../lib/src/common/utils.ts";
+
+export type MergeDialogResult = typeof LEAVE_TO_SUBSEQUENT | typeof CANCELLED | string;
+export class ConflictResolveModal extends Modal {
+    result: diff_result;
+    filename: string;
+
+    response: MergeDialogResult = CANCELLED;
+    isClosed = false;
+    consumed = false;
+
+    title: string = "Conflicting changes";
+
+    pluginPickMode: boolean = false;
+    localName: string = "Keep A";
+    remoteName: string = "Keep B";
+
+    constructor(app: App, filename: string, diff: diff_result, pluginPickMode?: boolean, remoteName?: string) {
+        super(app);
+        this.result = diff;
+        this.filename = filename;
+        this.pluginPickMode = pluginPickMode || false;
+        if (this.pluginPickMode) {
+            this.title = "Pick a version";
+            this.remoteName = `Use ${remoteName || "Remote"}`;
+            this.localName = "Use Local"
+        }
+        // Send cancel signal for the previous merge dialogue
+        // if not there, simply be ignored.
+        // sendValue("close-resolve-conflict:" + this.filename, false);
+        sendValue("cancel-resolve-conflict:" + this.filename, true);
+    }
+
+    onOpen() {
+        const { contentEl } = this;
+        // Send cancel signal for the previous merge dialogue
+        // if not there, simply be ignored.
+        sendValue("cancel-resolve-conflict:" + this.filename, true);
+        setTimeout(() => {
+            fireAndForget(async () => {
+                const forceClose = await waitForValue("cancel-resolve-conflict:" + this.filename);
+                // debugger;
+                if (forceClose) {
+                    this.sendResponse(CANCELLED);
+                }
+            });
+        }, 10)
+        // 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");
+        let diff = "";
+        for (const v of this.result.diff) {
+            const x1 = v[0];
+            const x2 = v[1];
+            if (x1 == DIFF_DELETE) {
+                diff += "<span class='deleted'>" + escapeStringToHTML(x2).replace(/\n/g, "<span class='ls-mark-cr'></span>\n") + "</span>";
+            } else if (x1 == DIFF_EQUAL) {
+                diff += "<span class='normal'>" + escapeStringToHTML(x2).replace(/\n/g, "<span class='ls-mark-cr'></span>\n") + "</span>";
+            } else if (x1 == DIFF_INSERT) {
+                diff += "<span class='added'>" + escapeStringToHTML(x2).replace(/\n/g, "<span class='ls-mark-cr'></span>\n") + "</span>";
+            }
+        }
+
+        diff = diff.replace(/\n/g, "<br>");
+        div.innerHTML = diff;
+        const div2 = contentEl.createDiv("");
+        const date1 = new Date(this.result.left.mtime).toLocaleString() + (this.result.left.deleted ? " (Deleted)" : "");
+        const date2 = new Date(this.result.right.mtime).toLocaleString() + (this.result.right.deleted ? " (Deleted)" : "");
+        div2.innerHTML = `
+<span class='deleted'>A:${date1}</span><br /><span class='added'>B:${date2}</span><br> 
+        `;
+        contentEl.createEl("button", { text: this.localName }, (e) => e.addEventListener("click", () => this.sendResponse(this.result.right.rev))).style.marginRight = "4px";
+        contentEl.createEl("button", { text: this.remoteName }, (e) => e.addEventListener("click", () => this.sendResponse(this.result.left.rev))).style.marginRight = "4px";
+        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: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) => e.addEventListener("click", () => this.sendResponse(CANCELLED))).style.marginRight = "4px";
+    }
+
+    sendResponse(result: MergeDialogResult) {
+        this.response = result;
+        this.close();
+    }
+
+    onClose() {
+        const { contentEl } = this;
+        contentEl.empty();
+        if (this.consumed) {
+            return;
+        }
+        this.consumed = true;
+        sendValue("close-resolve-conflict:" + this.filename, this.response);
+        sendValue("cancel-resolve-conflict:" + this.filename, false);
+    }
+
+    async waitForResult(): Promise<MergeDialogResult> {
+        await delay(100);
+        const r = await waitForValue<MergeDialogResult>("close-resolve-conflict:" + this.filename);
+        if (r === RESULT_TIMED_OUT) return CANCELLED;
+        return r;
+    }
+}

src/modules/features/Log/LogPane.svelte

@@ -0,0 +1,82 @@
+<script lang="ts">
+    import { onDestroy, onMount } from "svelte";
+    import { logMessages } from "../../../lib/src/mock_and_interop/stores";
+    import type { ReactiveInstance } from "../../../lib/src/dataobject/reactive";
+    import { Logger } from "../../../lib/src/common/logger";
+
+    let unsubscribe: () => void;
+    let messages = [] as string[];
+    let wrapRight = false;
+    let autoScroll = true;
+    let suspended = false;
+    function updateLog(logs: ReactiveInstance<string[]>) {
+        const e = logs.value;
+        if (!suspended) {
+            messages = [...e];
+            setTimeout(() => {
+                if (scroll) scroll.scrollTop = scroll.scrollHeight;
+            }, 10);
+        }
+    }
+    onMount(async () => {
+        logMessages.onChanged(updateLog);
+        Logger("Log window opened");
+        unsubscribe = () => logMessages.offChanged(updateLog);
+    });
+    onDestroy(() => {
+        if (unsubscribe) unsubscribe();
+    });
+    let scroll: HTMLDivElement;
+</script>
+
+<div class="logpane">
+    <!-- <h1>Self-hosted LiveSync Log</h1> -->
+    <div class="control">
+        <div class="row">
+            <label><input type="checkbox" bind:checked={wrapRight} /><span>Wrap</span></label>
+            <label><input type="checkbox" bind:checked={autoScroll} /><span>Auto scroll</span></label>
+            <label><input type="checkbox" bind:checked={suspended} /><span>Pause</span></label>
+        </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;
+        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

@@ -0,0 +1,48 @@
+import {
+    ItemView,
+    WorkspaceLeaf
+} from "obsidian";
+import LogPaneComponent from "./LogPane.svelte";
+import type ObsidianLiveSyncPlugin from "../../../main.ts";
+export const VIEW_TYPE_LOG = "log-log";
+//Log view
+export class LogPaneView extends ItemView {
+
+    component?: LogPaneComponent;
+    plugin: ObsidianLiveSyncPlugin;
+    icon = "view-log";
+    title: string = "";
+    navigation = true;
+
+    getIcon(): string {
+        return "view-log";
+    }
+
+    constructor(leaf: WorkspaceLeaf, plugin: ObsidianLiveSyncPlugin) {
+        super(leaf);
+        this.plugin = plugin;
+    }
+
+
+    getViewType() {
+        return VIEW_TYPE_LOG;
+    }
+
+    getDisplayText() {
+        return "Self-hosted LiveSync Log";
+    }
+
+    async onOpen() {
+        this.component = new LogPaneComponent({
+            target: this.contentEl,
+            props: {
+            },
+        });
+        await Promise.resolve();
+    }
+
+    async onClose() {
+        this.component?.$destroy();
+        await Promise.resolve();
+    }
+}

src/modules/features/ModuleGlobalHistory.ts

@@ -0,0 +1,29 @@
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { VIEW_TYPE_GLOBAL_HISTORY, GlobalHistoryView } from "./GlobalHistory/GlobalHistoryView.ts";
+
+
+export class ModuleObsidianGlobalHistory extends AbstractObsidianModule implements IObsidianModule {
+
+    $everyOnloadStart(): Promise<boolean> {
+
+        this.addCommand({
+            id: "livesync-global-history",
+            name: "Show vault history",
+            callback: () => {
+                this.showGlobalHistory()
+            }
+        })
+
+        this.registerView(
+            VIEW_TYPE_GLOBAL_HISTORY,
+            (leaf) => new GlobalHistoryView(leaf, this.plugin)
+        );
+
+        return Promise.resolve(true);
+    }
+
+    showGlobalHistory() {
+        void this.core.$$showView(VIEW_TYPE_GLOBAL_HISTORY);
+    }
+
+}

src/modules/features/ModuleInteractiveConflictResolver.ts

@@ -0,0 +1,134 @@
+import { CANCELLED, LEAVE_TO_SUBSEQUENT, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, MISSING_OR_ERROR, type DocumentID, type FilePathWithPrefix, type diff_result } from "../../lib/src/common/types.ts";
+import { ConflictResolveModal } from "./InteractiveConflictResolving/ConflictResolveModal.ts";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { displayRev, getPath, getPathWithoutPrefix } from "../../common/utils.ts";
+import { fireAndForget } from "octagonal-wheels/promises";
+
+export class ModuleInteractiveConflictResolver extends AbstractObsidianModule implements IObsidianModule {
+
+    $everyOnloadStart(): Promise<boolean> {
+        this.addCommand({
+            id: "livesync-conflictcheck",
+            name: "Pick a file to resolve conflict",
+            callback: async () => {
+                await this.pickFileForResolve();
+            },
+        })
+        this.addCommand({
+            id: "livesync-all-conflictcheck",
+            name: "Resolve all conflicted files",
+            callback: async () => {
+                await this.allConflictCheck();
+            },
+        })
+        return Promise.resolve(true);
+    }
+
+    async $anyResolveConflictByUI(filename: FilePathWithPrefix, conflictCheckResult: diff_result): Promise<boolean> {
+        this._log("Merge:open conflict dialog", LOG_LEVEL_VERBOSE);
+        const dialog = new ConflictResolveModal(this.app, filename, conflictCheckResult);
+        dialog.open();
+        const selected = await dialog.waitForResult();
+        if (selected === CANCELLED) {
+            // Cancelled by UI, or another conflict.
+            this._log(`Merge: Cancelled ${filename}`, LOG_LEVEL_INFO);
+            return false;
+        }
+        const testDoc = await this.localDatabase.getDBEntry(filename, { conflicts: true }, false, true, true);
+        if (testDoc === false) {
+            this._log(`Merge: Could not read ${filename} from the local database`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        if (!testDoc._conflicts) {
+            this._log(`Merge: Nothing to do ${filename}`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        const toDelete = selected;
+        // const toKeep = conflictCheckResult.left.rev != toDelete ? conflictCheckResult.left.rev : conflictCheckResult.right.rev;
+        if (toDelete === LEAVE_TO_SUBSEQUENT) {
+            // Concatenate both conflicted revisions.
+            // Create a new file by concatenating both conflicted revisions.
+            const p = conflictCheckResult.diff.map((e) => e[1]).join("");
+            const delRev = testDoc._conflicts[0];
+            if (!await this.core.databaseFileAccess.storeContent(filename, p)) {
+                this._log(`Concatenated content cannot be stored:${filename}`, LOG_LEVEL_NOTICE);
+                return false;
+            }
+            // 2. As usual, delete the conflicted revision and if there are no conflicts, write the resolved content to the storage.
+            if (await this.core.$$resolveConflictByDeletingRev(filename, delRev, "UI Concatenated") == MISSING_OR_ERROR) {
+                this._log(`Concatenated saved, but cannot delete conflicted revisions: ${filename}, (${displayRev(delRev)})`, LOG_LEVEL_NOTICE);
+                return false;
+            }
+        } else if (typeof toDelete === "string") {
+            // Select one of the conflicted revision to delete.
+            if (await this.core.$$resolveConflictByDeletingRev(filename, toDelete, "UI Selected") == MISSING_OR_ERROR) {
+                this._log(`Merge: Something went wrong: ${filename}, (${toDelete})`, LOG_LEVEL_NOTICE);
+                return false;
+            }
+        } else {
+            this._log(`Merge: Something went wrong: ${filename}, (${toDelete})`, LOG_LEVEL_NOTICE);
+            return false;
+        }
+        // In here, some merge has been processed.
+        // So we have to run replication if configured.
+        // TODO: Make this is as a event request
+        if (this.settings.syncAfterMerge && !this.plugin.suspended) {
+            await this.core.$$waitForReplicationOnce();
+        }
+        // And, check it again.
+        await this.core.$$queueConflictCheck(filename);
+        return false;
+    }
+    async allConflictCheck() {
+        while (await this.pickFileForResolve());
+    }
+
+
+    async pickFileForResolve() {
+        const notes: { id: DocumentID, path: FilePathWithPrefix, dispPath: string, mtime: number }[] = [];
+        for await (const doc of this.localDatabase.findAllDocs({ conflicts: true })) {
+            if (!("_conflicts" in doc)) continue;
+            notes.push({ id: doc._id, path: getPath(doc), dispPath: getPathWithoutPrefix(doc), mtime: doc.mtime });
+        }
+        notes.sort((a, b) => b.mtime - a.mtime);
+        const notesList = notes.map(e => e.dispPath);
+        if (notesList.length == 0) {
+            this._log("There are no conflicted documents", LOG_LEVEL_NOTICE);
+            return false;
+        }
+        const target = await this.plugin.confirm.askSelectString("File to resolve conflict", notesList);
+        if (target) {
+            const targetItem = notes.find(e => e.dispPath == target)!;
+            await this.core.$$queueConflictCheck(targetItem.path);
+            await this.core.$$waitForAllConflictProcessed();
+            return true;
+        }
+        return false;
+    }
+
+    async $allScanStat(): Promise<boolean> {
+        const notes: { path: string, mtime: number }[] = [];
+        this._log(`Checking conflicted files`, LOG_LEVEL_VERBOSE);
+        for await (const doc of this.localDatabase.findAllDocs({ conflicts: true })) {
+            if (!("_conflicts" in doc)) continue;
+            notes.push({ path: getPath(doc), mtime: doc.mtime });
+        }
+        if (notes.length > 0) {
+            this.plugin.confirm.askInPopup(`conflicting-detected-on-safety`, `Some files have been left conflicted! Press {HERE} to resolve them, or you can do it later by "Pick a file to resolve conflict`, (anchor) => {
+                anchor.text = "HERE";
+                anchor.addEventListener("click", () => {
+                    fireAndForget(() => this.allConflictCheck())
+                });
+            }
+            );
+            this._log(`Some files have been left conflicted! Please resolve them by "Pick a file to resolve conflict". The list is written in the log.`, LOG_LEVEL_VERBOSE);
+            for (const note of notes) {
+                this._log(`Conflicted: ${note.path}`);
+            }
+        } else {
+            this._log(`There are no conflicted files`, LOG_LEVEL_VERBOSE);
+        }
+        return true;
+    }
+
+}

src/modules/features/ModuleLog.ts

@@ -0,0 +1,377 @@
+import { computed, reactive, reactiveSource, type ReactiveValue } from "octagonal-wheels/dataobject/reactive";
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_VERBOSE, PREFIXMD_LOGFILE, type DatabaseConnectingStatus, type LOG_LEVEL } from "../../lib/src/common/types.ts";
+import { cancelTask, scheduleTask } from "octagonal-wheels/concurrency/task";
+import { fireAndForget, isDirty, throttle } from "../../lib/src/common/utils.ts";
+import { collectingChunks, pluginScanningCount, hiddenFilesEventCount, hiddenFilesProcessingCount, type LogEntry, logStore, logMessages } from "../../lib/src/mock_and_interop/stores.ts";
+import { eventHub } from "../../lib/src/hub/hub.ts";
+import { EVENT_FILE_RENAMED, EVENT_LAYOUT_READY, EVENT_LEAF_ACTIVE_CHANGED } from "../../common/events.ts";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { addIcon, normalizePath, Notice } from "../../deps.ts";
+import { LOG_LEVEL_NOTICE, setGlobalLogFunction } from "octagonal-wheels/common/logger";
+import { QueueProcessor } from "octagonal-wheels/concurrency/processor";
+import { LogPaneView, VIEW_TYPE_LOG } from "./Log/LogPaneView.ts";
+import { serialized } from "octagonal-wheels/concurrency/lock";
+
+// This module cannot be a core module because it depends on the Obsidian UI.
+
+// DI the log again.
+setGlobalLogFunction((message: any, level?: number, key?: string) => {
+    const entry = { message, level, key } as LogEntry;
+    logStore.enqueue(entry);
+});
+let recentLogs = [] as string[];
+
+// Recent log splicer
+const recentLogProcessor = new QueueProcessor((logs: string[]) => {
+    recentLogs = [...recentLogs, ...logs].splice(-200);
+    logMessages.value = recentLogs;
+}, { batchSize: 25, delay: 10, suspended: false, concurrentLimit: 1 }).resumePipeLine();
+// logStore.intercept(e => e.slice(Math.min(e.length - 200, 0)));
+
+
+export class ModuleLog extends AbstractObsidianModule implements IObsidianModule {
+
+    registerView = this.plugin.registerView.bind(this.plugin);
+
+    statusBar?: HTMLElement;
+
+    statusDiv?: HTMLElement;
+    statusLine?: HTMLDivElement;
+    logMessage?: HTMLDivElement;
+    logHistory?: HTMLDivElement;
+    messageArea?: HTMLDivElement;
+
+    statusBarLabels!: ReactiveValue<{ message: string, status: string }>;
+    statusLog = reactiveSource("");
+    notifies: { [key: string]: { notice: Notice; count: number } } = {};
+
+    observeForLogs() {
+        const padSpaces = `\u{2007}`.repeat(10);
+        // const emptyMark = `\u{2003}`;
+        function padLeftSpComputed(numI: ReactiveValue<number>, mark: string) {
+            const formatted = reactiveSource("");
+            let timer: ReturnType<typeof setTimeout> | undefined = undefined;
+            let maxLen = 1;
+            numI.onChanged(numX => {
+                const num = numX.value;
+                const numLen = `${Math.abs(num)}`.length + 1;
+                maxLen = maxLen < numLen ? numLen : maxLen;
+                if (timer) clearTimeout(timer);
+                if (num == 0) {
+                    timer = setTimeout(() => {
+                        formatted.value = "";
+                        maxLen = 1;
+                    }, 3000);
+                }
+                formatted.value = ` ${mark}${`${padSpaces}${num}`.slice(-(maxLen))}`;
+            })
+            return computed(() => formatted.value);
+        }
+        const labelReplication = padLeftSpComputed(this.plugin.replicationResultCount, `📥`);
+        const labelDBCount = padLeftSpComputed(this.plugin.databaseQueueCount, `📄`);
+        const labelStorageCount = padLeftSpComputed(this.plugin.storageApplyingCount, `💾`);
+        const labelChunkCount = padLeftSpComputed(collectingChunks, `🧩`);
+        const labelPluginScanCount = padLeftSpComputed(pluginScanningCount, `🔌`);
+        const labelConflictProcessCount = padLeftSpComputed(this.plugin.conflictProcessQueueCount, `🔩`);
+        const hiddenFilesCount = reactive(() => hiddenFilesEventCount.value + hiddenFilesProcessingCount.value);
+        const labelHiddenFilesCount = padLeftSpComputed(hiddenFilesCount, `⚙️`)
+        const queueCountLabelX = reactive(() => {
+            return `${labelReplication()}${labelDBCount()}${labelStorageCount()}${labelChunkCount()}${labelPluginScanCount()}${labelHiddenFilesCount()}${labelConflictProcessCount()}`;
+        })
+        const queueCountLabel = () => queueCountLabelX.value;
+
+        const requestingStatLabel = computed(() => {
+            const diff = this.plugin.requestCount.value - this.plugin.responseCount.value;
+            return diff != 0 ? "📲 " : "";
+        })
+
+        const replicationStatLabel = computed(() => {
+            const e = this.plugin.replicationStat.value;
+            const sent = e.sent;
+            const arrived = e.arrived;
+            const maxPullSeq = e.maxPullSeq;
+            const maxPushSeq = e.maxPushSeq;
+            const lastSyncPullSeq = e.lastSyncPullSeq;
+            const lastSyncPushSeq = e.lastSyncPushSeq;
+            let pushLast = "";
+            let pullLast = "";
+            let w = "";
+            const labels: Partial<Record<DatabaseConnectingStatus, string>> = {
+                "CONNECTED": "⚡",
+                "JOURNAL_SEND": "📦↑",
+                "JOURNAL_RECEIVE": "📦↓",
+            }
+            switch (e.syncStatus) {
+                case "CLOSED":
+                case "COMPLETED":
+                case "NOT_CONNECTED":
+                    w = "⏹";
+                    break;
+                case "STARTED":
+                    w = "🌀";
+                    break;
+                case "PAUSED":
+                    w = "💤";
+                    break;
+                case "CONNECTED":
+                case "JOURNAL_SEND":
+                case "JOURNAL_RECEIVE":
+                    w = labels[e.syncStatus] || "⚡";
+                    pushLast = ((lastSyncPushSeq == 0) ? "" : (lastSyncPushSeq >= maxPushSeq ? " (LIVE)" : ` (${maxPushSeq - lastSyncPushSeq})`));
+                    pullLast = ((lastSyncPullSeq == 0) ? "" : (lastSyncPullSeq >= maxPullSeq ? " (LIVE)" : ` (${maxPullSeq - lastSyncPullSeq})`));
+                    break;
+                case "ERRORED":
+                    w = "⚠";
+                    break;
+                default:
+                    w = "?";
+            }
+            return { w, sent, pushLast, arrived, pullLast };
+        })
+        const labelProc = padLeftSpComputed(this.plugin.processing, `⏳`);
+        const labelPend = padLeftSpComputed(this.plugin.totalQueued, `🛫`);
+        const labelInBatchDelay = padLeftSpComputed(this.plugin.batched, `📬`);
+        const waitingLabel = computed(() => {
+            return `${labelProc()}${labelPend()}${labelInBatchDelay()}`;
+        })
+        const statusLineLabel = computed(() => {
+            const { w, sent, pushLast, arrived, pullLast } = replicationStatLabel();
+            const queued = queueCountLabel();
+            const waiting = waitingLabel();
+            const networkActivity = requestingStatLabel();
+            return {
+                message: `${networkActivity}Sync: ${w} ↑ ${sent}${pushLast} ↓ ${arrived}${pullLast}${waiting}${queued}`,
+            };
+        })
+        const statusBarLabels = reactive(() => {
+            const scheduleMessage = this.plugin.isReloadingScheduled ? `WARNING! RESTARTING OBSIDIAN IS SCHEDULED!\n` : "";
+            const { message } = statusLineLabel();
+            const status = scheduleMessage + this.statusLog.value;
+
+            return {
+                message, status
+            }
+        })
+        this.statusBarLabels = statusBarLabels;
+
+        const applyToDisplay = throttle((label: typeof statusBarLabels.value) => {
+            // const v = label;
+            this.applyStatusBarText();
+
+        }, 20);
+        statusBarLabels.onChanged(label => applyToDisplay(label.value))
+    }
+
+    $everyOnload(): Promise<boolean> {
+        eventHub.onEvent(EVENT_LEAF_ACTIVE_CHANGED, () => this.onActiveLeafChange());
+        eventHub.onceEvent(EVENT_LAYOUT_READY, () => this.onActiveLeafChange());
+        return Promise.resolve(true);
+    }
+    adjustStatusDivPosition() {
+        const mdv = this.app.workspace.getMostRecentLeaf();
+        if (mdv && this.statusDiv) {
+            this.statusDiv.remove();
+            // this.statusDiv.pa();
+            const container = mdv.view.containerEl;
+            container.insertBefore(this.statusDiv, container.lastChild);
+        }
+    }
+
+    async getActiveFileStatus() {
+        const thisFile = this.app.workspace.getActiveFile();
+        if (!thisFile) return "";
+        // Case Sensitivity
+        if (this.core.shouldCheckCaseInsensitive) {
+            const f = this.core.storageAccess.getFiles().map(e => e.path).filter(e => e.toLowerCase() == thisFile.path.toLowerCase());
+            if (f.length > 1) return "Not synchronised: There are multiple files with the same name";
+        }
+        if (!await this.core.$$isTargetFile(thisFile.path)) return "Not synchronised: not a target file";
+        if (this.core.$$isFileSizeExceeded(thisFile.stat.size)) return "Not synchronised: File size exceeded";
+        return "";
+    }
+    async setFileStatus() {
+        this.messageArea!.innerText = await this.getActiveFileStatus();
+    }
+    onActiveLeafChange() {
+        fireAndForget(async () => {
+            this.adjustStatusDivPosition();
+            await this.setFileStatus();
+        });
+
+    }
+
+    nextFrameQueue: ReturnType<typeof requestAnimationFrame> | undefined = undefined;
+    logLines: { ttl: number, message: string }[] = [];
+
+    applyStatusBarText() {
+        if (this.nextFrameQueue) {
+            return;
+        }
+        this.nextFrameQueue = requestAnimationFrame(() => {
+            this.nextFrameQueue = undefined;
+            const { message, status } = this.statusBarLabels.value;
+            // const recent = logMessages.value;
+            const newMsg = message;
+            let newLog = this.settings?.showOnlyIconsOnEditor ? "" : status;
+            const moduleTagEnd = newLog.indexOf(`]\u{200A}`);
+            if (moduleTagEnd != -1) {
+                newLog = newLog.substring(moduleTagEnd + 2);
+            }
+
+            this.statusBar?.setText(newMsg.split("\n")[0]);
+            if (this.settings?.showStatusOnEditor && this.statusDiv) {
+                if (this.settings.showLongerLogInsideEditor) {
+                    const now = new Date().getTime();
+                    this.logLines = this.logLines.filter(e => e.ttl > now);
+                    const minimumNext = this.logLines.reduce((a, b) => a < b.ttl ? a : b.ttl, Number.MAX_SAFE_INTEGER);
+                    if (this.logLines.length > 0) setTimeout(() => this.applyStatusBarText(), minimumNext - now);
+                    const recent = this.logLines.map(e => e.message);
+                    const recentLogs = recent.reverse().join("\n");
+                    if (isDirty("recentLogs", recentLogs)) this.logHistory!.innerText = recentLogs;
+                }
+                if (isDirty("newMsg", newMsg)) this.statusLine!.innerText = newMsg;
+                if (isDirty("newLog", newLog)) this.logMessage!.innerText = newLog;
+            } else {
+                // const root = activeDocument.documentElement;
+                // root.style.setProperty("--log-text", "'" + (newMsg + "\\A " + newLog) + "'");
+            }
+        });
+
+        scheduleTask("log-hide", 3000, () => { this.statusLog.value = "" });
+    }
+
+    $allStartOnUnload(): Promise<boolean> {
+        if (this.statusDiv) {
+            this.statusDiv.remove();
+        }
+        document.querySelectorAll(`.livesync-status`)?.forEach(e => e.remove());
+        return Promise.resolve(true);
+    }
+    $everyOnloadStart(): Promise<boolean> {
+        addIcon(
+            "view-log",
+            `<g transform="matrix(1.28 0 0 1.28 -131 -411)" fill="currentColor" fill-rule="evenodd">
+        <path d="m103 330h76v12h-76z"/>
+        <path d="m106 346v44h70v-44zm45 16h-20v-8h20z"/>
+       </g>`
+        );
+        this.addRibbonIcon("view-log", "Show log", () => {
+            void this.core.$$showView(VIEW_TYPE_LOG);
+        }).addClass("livesync-ribbon-showlog");
+
+        this.addCommand({
+            id: "view-log",
+            name: "Show log",
+            callback: () => {
+                void this.core.$$showView(VIEW_TYPE_LOG);
+            }
+        });
+        this.registerView(
+            VIEW_TYPE_LOG,
+            (leaf) => new LogPaneView(leaf, this.plugin)
+        );
+        return Promise.resolve(true);
+    }
+    $everyOnloadAfterLoadSettings(): Promise<boolean> {
+        logStore.pipeTo(new QueueProcessor(logs => logs.forEach(e => this.core.$$addLog(e.message, e.level, e.key)), { suspended: false, batchSize: 20, concurrentLimit: 1, delay: 0 })).startPipeline();
+        eventHub.onEvent(EVENT_FILE_RENAMED, (evt: CustomEvent<{ oldPath: string, newPath: string }>) => {
+            void this.setFileStatus();
+        });
+
+        const w = document.querySelectorAll(`.livesync-status`);
+        w.forEach(e => e.remove());
+
+        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" });
+        eventHub.onEvent(EVENT_LAYOUT_READY, () => this.adjustStatusDivPosition());
+        if (this.settings?.showStatusOnStatusbar) {
+            this.statusBar = this.plugin.addStatusBarItem();
+            this.statusBar.addClass("syncstatusbar");
+        }
+        this.adjustStatusDivPosition();
+        return Promise.resolve(true);
+    }
+
+    writeLogToTheFile(now: Date, vaultName: string, newMessage: string) {
+        fireAndForget(() => serialized("writeLog", async () => {
+            const time = now.toISOString().split("T")[0];
+            const logDate = `${PREFIXMD_LOGFILE}${time}.md`;
+            const file = await this.core.storageAccess.isExists(normalizePath(logDate));
+            if (!file) {
+                await this.core.storageAccess.appendHiddenFile(normalizePath(logDate), "```\n");
+            }
+            await this.core.storageAccess.appendHiddenFile(normalizePath(logDate), vaultName + ":" + newMessage + "\n");
+        }));
+    }
+    $$addLog(message: any, level: LOG_LEVEL = LOG_LEVEL_INFO, key = ""): void {
+        if (level == LOG_LEVEL_DEBUG) {
+            return;
+        }
+        if (level < LOG_LEVEL_INFO && this.settings && this.settings.lessInformationInLog) {
+            return;
+        }
+        if (this.settings && !this.settings.showVerboseLog && level == LOG_LEVEL_VERBOSE) {
+            return;
+        }
+        const vaultName = this.plugin.$$getVaultName();
+        const now = new Date();
+        const timestamp = now.toLocaleString();
+        const messageContent = typeof message == "string" ? message : message instanceof Error ? `${message.name}:${message.message}` : JSON.stringify(message, null, 2);
+        if (message instanceof Error) {
+            // debugger;
+            console.dir(message.stack);
+        }
+        const newMessage = timestamp + "->" + messageContent;
+
+        console.log(vaultName + ":" + newMessage);
+        if (!this.settings?.showOnlyIconsOnEditor) {
+            this.statusLog.value = messageContent;
+        }
+        if (this.settings?.writeLogToTheFile) {
+            this.writeLogToTheFile(now, vaultName, newMessage);
+        }
+        recentLogProcessor.enqueue(newMessage);
+        this.logLines.push({ ttl: now.getTime() + 3000, message: newMessage });
+
+        if (level >= LOG_LEVEL_NOTICE) {
+            if (!key) key = messageContent;
+            if (key in this.notifies) {
+                // @ts-ignore
+                const isShown = this.notifies[key].notice.noticeEl?.isShown()
+                if (!isShown) {
+                    this.notifies[key].notice = new Notice(messageContent, 0);
+                }
+                cancelTask(`notify-${key}`);
+                if (key == messageContent) {
+                    this.notifies[key].count++;
+                    this.notifies[key].notice.setMessage(`(${this.notifies[key].count}):${messageContent}`);
+                } else {
+                    this.notifies[key].notice.setMessage(`${messageContent}`);
+                }
+            } else {
+                const notify = new Notice(messageContent, 0);
+                this.notifies[key] = {
+                    count: 0,
+                    notice: notify,
+                };
+            }
+            const timeout = 5000;
+            scheduleTask(`notify-${key}`, timeout, () => {
+                const notify = this.notifies[key].notice;
+                delete this.notifies[key];
+                try {
+                    notify.hide();
+                } catch {
+                    // NO OP
+                }
+            })
+        }
+    }
+
+}
+

src/modules/features/ModuleObsidianDocumentHistory.ts

@@ -0,0 +1,56 @@
+import { type TFile } from "obsidian";
+import { eventHub, EVENT_REQUEST_SHOW_HISTORY } from "../../common/events.ts";
+import type { FilePathWithPrefix, LoadedEntry, DocumentID } from "../../lib/src/common/types.ts";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { DocumentHistoryModal } from "./DocumentHistory/DocumentHistoryModal.ts";
+import { getPath } from "../../common/utils.ts";
+import { fireAndForget } from "octagonal-wheels/promises";
+
+
+
+export class ModuleObsidianDocumentHistory extends AbstractObsidianModule implements IObsidianModule {
+
+
+    $everyOnloadStart(): Promise<boolean> {
+
+        this.addCommand({
+            id: "livesync-history",
+            name: "Show history",
+            callback: () => {
+                const file = this.core.$$getActiveFilePath();
+                if (file) this.showHistory(file, undefined);
+            }
+        });
+
+        this.addCommand({
+            id: "livesync-filehistory",
+            name: "Pick a file to show history",
+            callback: () => {
+                fireAndForget(async () => await this.fileHistory());
+            },
+        });
+        eventHub.on(EVENT_REQUEST_SHOW_HISTORY, ({ file, fileOnDB }: { file: TFile, fileOnDB: LoadedEntry }) => {
+            this.showHistory(file, fileOnDB._id);
+        })
+        return Promise.resolve(true);
+    }
+
+    showHistory(file: TFile | FilePathWithPrefix, id?: DocumentID) {
+        new DocumentHistoryModal(this.app, this.plugin, file, id).open();
+    }
+
+    async fileHistory() {
+        const notes: { id: DocumentID, path: FilePathWithPrefix, dispPath: string, mtime: number }[] = [];
+        for await (const doc of this.localDatabase.findAllDocs()) {
+            notes.push({ id: doc._id, path: getPath(doc), dispPath: getPath(doc), mtime: doc.mtime });
+        }
+        notes.sort((a, b) => b.mtime - a.mtime);
+        const notesList = notes.map(e => e.dispPath);
+        const target = await this.plugin.confirm.askSelectString("File to view History", notesList);
+        if (target) {
+            const targetId = notes.find(e => e.dispPath == target)!;
+            this.showHistory(targetId.path, targetId.id);
+        }
+    }
+
+}

src/modules/features/ModuleObsidianSetting.ts

@@ -0,0 +1,207 @@
+import { type IObsidianModule, AbstractObsidianModule } from "../AbstractObsidianModule.ts";
+// import { PouchDB } from "../../lib/src/pouchdb/pouchdb-browser";
+import { EVENT_REQUEST_RELOAD_SETTING_TAB, EVENT_SETTING_SAVED, eventHub } from "../../common/events";
+import { type BucketSyncSetting, type ConfigPassphraseStore, type CouchDBConnection, DEFAULT_SETTINGS, type ObsidianLiveSyncSettings, SALT_OF_PASSPHRASE } from "../../lib/src/common/types";
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_URGENT } from "octagonal-wheels/common/logger";
+import { encrypt, tryDecrypt } from "octagonal-wheels/encryption";
+import { setLang } from "../../lib/src/common/i18n";
+import { isCloudantURI } from "../../lib/src/pouchdb/utils_couchdb";
+export class ModuleObsidianSettings extends AbstractObsidianModule implements IObsidianModule {
+
+    getPassphrase(settings: ObsidianLiveSyncSettings) {
+        const methods: Record<ConfigPassphraseStore, (() => Promise<string | false>)> = {
+            "": () => Promise.resolve("*"),
+            "LOCALSTORAGE": () => Promise.resolve(localStorage.getItem("ls-setting-passphrase") ?? false),
+            "ASK_AT_LAUNCH": () => this.plugin.confirm.askString("Passphrase", "passphrase", "")
+        }
+        const method = settings.configPassphraseStore;
+        const methodFunc = method in methods ? methods[method] : methods[""];
+        return methodFunc();
+    }
+
+    $$saveDeviceAndVaultName(): void {
+        const lsKey = "obsidian-live-sync-vaultanddevicename-" + this.plugin.$$getVaultName();
+        localStorage.setItem(lsKey, this.plugin.deviceAndVaultName || "");
+    }
+
+    usedPassphrase = "";
+    $$clearUsedPassphrase(): void {
+        this.usedPassphrase = "";
+    }
+
+
+    async decryptConfigurationItem(encrypted: string, passphrase: string) {
+        const dec = await tryDecrypt(encrypted, passphrase + SALT_OF_PASSPHRASE, false);
+        if (dec) {
+            this.usedPassphrase = passphrase;
+            return dec;
+        }
+        return false;
+    }
+
+
+    async encryptConfigurationItem(src: string, settings: ObsidianLiveSyncSettings) {
+        if (this.usedPassphrase != "") {
+            return await encrypt(src, this.usedPassphrase + SALT_OF_PASSPHRASE, false);
+        }
+
+        const passphrase = await this.getPassphrase(settings);
+        if (passphrase === false) {
+            this._log("Could not determine passphrase to save data.json! You probably make the configuration sure again!", LOG_LEVEL_URGENT);
+            return "";
+        }
+        const dec = await encrypt(src, passphrase + SALT_OF_PASSPHRASE, false);
+        if (dec) {
+            this.usedPassphrase = passphrase;
+            return dec;
+        }
+
+        return "";
+    }
+
+    get appId() {
+        return `${("appId" in this.app ? this.app.appId : "")}`;
+    }
+
+    async $$saveSettingData() {
+        this.plugin.$$saveDeviceAndVaultName();
+        const settings = { ...this.settings };
+        settings.deviceAndVaultName = "";
+        if (this.usedPassphrase == "" && !await this.getPassphrase(settings)) {
+            this._log("Could not determine passphrase for saving data.json! Our data.json have insecure items!", LOG_LEVEL_NOTICE);
+        } else {
+            if (settings.couchDB_PASSWORD != "" || settings.couchDB_URI != "" || settings.couchDB_USER != "" || settings.couchDB_DBNAME) {
+                const connectionSetting: CouchDBConnection & BucketSyncSetting = {
+                    couchDB_DBNAME: settings.couchDB_DBNAME,
+                    couchDB_PASSWORD: settings.couchDB_PASSWORD,
+                    couchDB_URI: settings.couchDB_URI,
+                    couchDB_USER: settings.couchDB_USER,
+                    accessKey: settings.accessKey,
+                    bucket: settings.bucket,
+                    endpoint: settings.endpoint,
+                    region: settings.region,
+                    secretKey: settings.secretKey,
+                    useCustomRequestHandler: settings.useCustomRequestHandler
+                };
+                settings.encryptedCouchDBConnection = await this.encryptConfigurationItem(JSON.stringify(connectionSetting), settings);
+                settings.couchDB_PASSWORD = "";
+                settings.couchDB_DBNAME = "";
+                settings.couchDB_URI = "";
+                settings.couchDB_USER = "";
+                settings.accessKey = "";
+                settings.bucket = "";
+                settings.region = "";
+                settings.secretKey = "";
+                settings.endpoint = "";
+            }
+            if (settings.encrypt && settings.passphrase != "") {
+                settings.encryptedPassphrase = await this.encryptConfigurationItem(settings.passphrase, settings);
+                settings.passphrase = "";
+            }
+
+        }
+        await this.core.saveData(settings);
+        eventHub.emitEvent(EVENT_SETTING_SAVED, settings);
+    }
+
+    tryDecodeJson(encoded: string | false): object | false {
+        try {
+            if (!encoded) return false;
+            return JSON.parse(encoded);
+        } catch {
+            return false;
+        }
+    }
+
+    async $$loadSettings(): Promise<void> {
+        const settings = Object.assign({}, DEFAULT_SETTINGS, await this.core.loadData()) as ObsidianLiveSyncSettings;
+
+        if (typeof settings.isConfigured == "undefined") {
+            // If migrated, mark true
+            if (JSON.stringify(settings) !== JSON.stringify(DEFAULT_SETTINGS)) {
+                settings.isConfigured = true;
+            } else {
+                settings.additionalSuffixOfDatabaseName = this.appId;
+                settings.isConfigured = false;
+            }
+        }
+        const passphrase = await this.getPassphrase(settings);
+        if (passphrase === false) {
+            this._log("Could not determine passphrase for reading data.json! DO NOT synchronize with the remote before making sure your configuration is!", LOG_LEVEL_URGENT);
+        } else {
+            if (settings.encryptedCouchDBConnection) {
+                const keys = [
+                    "couchDB_URI",
+                    "couchDB_USER",
+                    "couchDB_PASSWORD",
+                    "couchDB_DBNAME",
+                    "accessKey",
+                    "bucket",
+                    "endpoint",
+                    "region",
+                    "secretKey"] as (keyof CouchDBConnection | keyof BucketSyncSetting)[];
+                const decrypted = this.tryDecodeJson(await this.decryptConfigurationItem(settings.encryptedCouchDBConnection, passphrase)) as (CouchDBConnection & BucketSyncSetting);
+                if (decrypted) {
+                    for (const key of keys) {
+                        if (key in decrypted) {
+                            //@ts-ignore
+                            settings[key] = decrypted[key]
+                        }
+                    }
+                } else {
+                    this._log("Could not decrypt passphrase for reading data.json! DO NOT synchronize with the remote before making sure your configuration is!", LOG_LEVEL_URGENT);
+                    for (const key of keys) {
+                        //@ts-ignore
+                        settings[key] = "";
+                    }
+                }
+            }
+            if (settings.encrypt && settings.encryptedPassphrase) {
+                const encrypted = settings.encryptedPassphrase;
+                const decrypted = await this.decryptConfigurationItem(encrypted, passphrase);
+                if (decrypted) {
+                    settings.passphrase = decrypted;
+                } else {
+                    this._log("Could not decrypt passphrase for reading data.json! DO NOT synchronize with the remote before making sure your configuration is!", LOG_LEVEL_URGENT);
+                    settings.passphrase = "";
+                }
+            }
+
+        }
+        this.settings = settings;
+        setLang(this.settings.displayLanguage);
+
+        if ("workingEncrypt" in this.settings) delete this.settings.workingEncrypt;
+        if ("workingPassphrase" in this.settings) delete this.settings.workingPassphrase;
+
+        // Delete this feature to avoid problems on mobile.
+        this.settings.disableRequestURI = true;
+
+        // GC is disabled.
+        this.settings.gcDelay = 0;
+        // So, use history is always enabled.
+        this.settings.useHistory = true;
+
+        const lsKey = "obsidian-live-sync-vaultanddevicename-" + this.plugin.$$getVaultName();
+        if (this.settings.deviceAndVaultName != "") {
+            if (!localStorage.getItem(lsKey)) {
+                this.core.deviceAndVaultName = this.settings.deviceAndVaultName;
+                localStorage.setItem(lsKey, this.core.deviceAndVaultName);
+                this.settings.deviceAndVaultName = "";
+            }
+        }
+        if (isCloudantURI(this.settings.couchDB_URI) && this.settings.customChunkSize != 0) {
+            this._log("Configuration verification founds problems with your configuration. This has been fixed automatically. But you may already have data that cannot be synchronised. If this is the case, please rebuild everything.", LOG_LEVEL_NOTICE)
+            this.settings.customChunkSize = 0;
+        }
+        this.core.deviceAndVaultName = localStorage.getItem(lsKey) || "";
+        if (this.core.deviceAndVaultName == "") {
+            if (this.settings.usePluginSync) {
+                this._log("Device name is not set. Plug-in sync has been disabled.", LOG_LEVEL_NOTICE);
+                this.settings.usePluginSync = false;
+            }
+        }
+        // this.core.ignoreFiles = this.settings.ignoreFiles.split(",").map(e => e.trim());
+        eventHub.emitEvent(EVENT_REQUEST_RELOAD_SETTING_TAB);
+    }
+}

src/modules/features/ModuleObsidianSettingAsMarkdown.ts

@@ -0,0 +1,212 @@
+import { type IObsidianModule, AbstractObsidianModule } from "../AbstractObsidianModule.ts";
+// import { PouchDB } from "../../lib/src/pouchdb/pouchdb-browser";
+import { isObjectDifferent } from "octagonal-wheels/object";
+import { EVENT_SETTING_SAVED, eventHub } from "../../common/events";
+import { fireAndForget } from "octagonal-wheels/promises";
+import { DEFAULT_SETTINGS, type FilePathWithPrefix, type ObsidianLiveSyncSettings } from "../../lib/src/common/types";
+import { parseYaml, stringifyYaml } from "../../deps";
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+const SETTING_HEADER = "````yaml:livesync-setting\n";
+const SETTING_FOOTER = "\n````";
+export class ModuleObsidianSettingsAsMarkdown extends AbstractObsidianModule implements IObsidianModule {
+
+    $everyOnloadStart(): Promise<boolean> {
+        this.addCommand({
+            id: "livesync-export-config",
+            name: "Write setting markdown manually",
+            checkCallback: (checking) => {
+                if (checking) {
+                    return this.settings.settingSyncFile != "";
+                }
+                fireAndForget(async () => {
+                    await this.plugin.$$saveSettingData();
+                });
+            }
+        })
+        this.addCommand({
+            id: "livesync-import-config",
+            name: "Parse setting file",
+            editorCheckCallback: (checking, editor, ctx) => {
+                if (checking) {
+                    const doc = editor.getValue();
+                    const ret = this.extractSettingFromWholeText(doc);
+                    return ret.body != "";
+                }
+                if (ctx.file) {
+                    const file = ctx.file
+                    fireAndForget(async () => await this.checkAndApplySettingFromMarkdown(file.path, false));
+                }
+            },
+        })
+        eventHub.on("event-file-changed", (info: {
+            file: FilePathWithPrefix, automated: boolean
+        }) => {
+            fireAndForget(() => this.checkAndApplySettingFromMarkdown(info.file, info.automated));
+        });
+        eventHub.onEvent(EVENT_SETTING_SAVED, (evt: CustomEvent<ObsidianLiveSyncSettings>) => {
+            const settings = evt.detail;
+            if (settings.settingSyncFile != "") {
+                fireAndForget(() => this.saveSettingToMarkdown(settings.settingSyncFile));
+            }
+        })
+        return Promise.resolve(true);
+    }
+
+
+    extractSettingFromWholeText(data: string): {
+        preamble: string, body: string, postscript: string
+    } {
+        if (data.indexOf(SETTING_HEADER) === -1) {
+            return {
+                preamble: data, body: "", postscript: ""
+            }
+        }
+        const startMarkerPos = data.indexOf(SETTING_HEADER);
+        const dataStartPos = startMarkerPos == -1 ? data.length : startMarkerPos;
+        const endMarkerPos = startMarkerPos == -1 ? data.length : data.indexOf(SETTING_FOOTER, dataStartPos);
+        const dataEndPos = endMarkerPos == -1 ? data.length : endMarkerPos;
+        const body = data.substring(dataStartPos + SETTING_HEADER.length, dataEndPos);
+        const ret = {
+            preamble: data.substring(0, dataStartPos),
+            body,
+            postscript: data.substring(dataEndPos + SETTING_FOOTER.length + 1)
+        }
+        return ret;
+    }
+
+    async parseSettingFromMarkdown(filename: string, data?: string) {
+        const file = await this.core.storageAccess.isExists(filename);
+        if (!file) return {
+            preamble: "", body: "", postscript: "",
+        };
+        if (data) {
+            return this.extractSettingFromWholeText(data);
+        }
+        const parseData = data ?? await this.core.storageAccess.readFileText(filename);
+        return this.extractSettingFromWholeText(parseData);
+    }
+
+    async checkAndApplySettingFromMarkdown(filename: string, automated?: boolean) {
+        if (automated && !this.settings.notifyAllSettingSyncFile) {
+            if (!this.settings.settingSyncFile || this.settings.settingSyncFile != filename) {
+                this._log(`Setting file (${filename}) is not matched to the current configuration. skipped.`, LOG_LEVEL_DEBUG);
+                return;
+            }
+        }
+        const { body } = await this.parseSettingFromMarkdown(filename);
+        let newSetting = {} as Partial<ObsidianLiveSyncSettings>;
+        try {
+            newSetting = parseYaml(body);
+        } catch (ex) {
+            this._log("Could not parse YAML", LOG_LEVEL_NOTICE);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+            return;
+        }
+
+        if ("settingSyncFile" in newSetting && newSetting.settingSyncFile != filename) {
+            this._log("This setting file seems to backed up one. Please fix the filename or settingSyncFile value.", automated ? LOG_LEVEL_INFO : LOG_LEVEL_NOTICE);
+            return;
+        }
+
+
+        let settingToApply = { ...DEFAULT_SETTINGS } as ObsidianLiveSyncSettings;
+        settingToApply = { ...settingToApply, ...newSetting }
+        if (!(settingToApply?.writeCredentialsForSettingSync)) {
+            //New setting does not contains credentials. 
+            settingToApply.couchDB_USER = this.settings.couchDB_USER;
+            settingToApply.couchDB_PASSWORD = this.settings.couchDB_PASSWORD;
+            settingToApply.passphrase = this.settings.passphrase;
+        }
+        const oldSetting = this.generateSettingForMarkdown(this.settings, settingToApply.writeCredentialsForSettingSync);
+        if (!isObjectDifferent(oldSetting, this.generateSettingForMarkdown(settingToApply))) {
+            this._log("Setting markdown has been detected, but not changed.", automated ? LOG_LEVEL_INFO : LOG_LEVEL_NOTICE);
+            return
+        }
+        const addMsg = this.settings.settingSyncFile != filename ? " (This is not-active file)" : "";
+        this.plugin.confirm.askInPopup("apply-setting-from-md", `Setting markdown ${filename}${addMsg} has been detected. Apply this from {HERE}.`, (anchor) => {
+            anchor.text = "HERE";
+            anchor.addEventListener("click", () => {
+                fireAndForget(async () => {
+                    const APPLY_ONLY = "Apply settings";
+                    const APPLY_AND_RESTART = "Apply settings and restart obsidian";
+                    const APPLY_AND_REBUILD = "Apply settings and restart obsidian with red_flag_rebuild.md";
+                    const APPLY_AND_FETCH = "Apply settings and restart obsidian with red_flag_fetch.md";
+                    const CANCEL = "Cancel";
+                    const result = await this.plugin.confirm.askSelectStringDialogue("Ready for apply the setting.", [
+                        APPLY_AND_RESTART,
+                        APPLY_ONLY,
+                        APPLY_AND_FETCH,
+                        APPLY_AND_REBUILD,
+                        CANCEL], { defaultAction: APPLY_AND_RESTART });
+                    if (result == APPLY_ONLY || result == APPLY_AND_RESTART || result == APPLY_AND_REBUILD || result == APPLY_AND_FETCH) {
+                        this.plugin.settings = settingToApply;
+                        await this.plugin.$$saveSettingData();
+                        if (result == APPLY_ONLY) {
+                            this._log("Loaded settings have been applied!", LOG_LEVEL_NOTICE);
+                            return;
+                        }
+                        if (result == APPLY_AND_REBUILD) {
+                            await this.plugin.rebuilder.scheduleRebuild();
+                        }
+                        if (result == APPLY_AND_FETCH) {
+                            await this.plugin.rebuilder.scheduleFetch();
+                        }
+                        this.plugin.$$performRestart();
+                    }
+                })
+            })
+        })
+    }
+
+    generateSettingForMarkdown(settings?: ObsidianLiveSyncSettings, keepCredential?: boolean): Partial<ObsidianLiveSyncSettings> {
+        const saveData = { ...(settings ? settings : this.settings) } as Partial<ObsidianLiveSyncSettings>;
+        delete saveData.encryptedCouchDBConnection;
+        delete saveData.encryptedPassphrase;
+        delete saveData.additionalSuffixOfDatabaseName;
+        if (!saveData.writeCredentialsForSettingSync && !keepCredential) {
+            delete saveData.couchDB_USER;
+            delete saveData.couchDB_PASSWORD;
+            delete saveData.passphrase;
+        }
+        return saveData;
+    }
+
+    async saveSettingToMarkdown(filename: string) {
+        const saveData = this.generateSettingForMarkdown();
+        const file = await this.core.storageAccess.isExists(filename);
+
+
+        if (!file) {
+            await this.core.storageAccess.ensureDir(filename);
+            const initialContent = `This file contains Self-hosted LiveSync settings as YAML.
+Except for the \`livesync-setting\` code block, we can add a note for free.
+
+If the name of this file matches the value of the "settingSyncFile" setting inside the \`livesync-setting\` block, LiveSync will tell us whenever the settings change. We can decide to accept or decline the remote setting. (In other words, we can back up this file by renaming it to another name).
+
+We can perform a command in this file.
+- \`Parse setting file\` : load the setting from the file.
+
+**Note** Please handle it with all of your care if you have configured to write credentials in.
+
+
+`
+            await this.core.storageAccess.writeFileAuto(filename, initialContent + SETTING_HEADER + "\n" + SETTING_FOOTER);
+        }
+        // if (!(file instanceof TFile)) {
+        //     this._log(`Markdown Setting: ${filename} already exists as a folder`, LOG_LEVEL_NOTICE);
+        //     return;
+        // }
+
+        const data = await this.core.storageAccess.readFileText(filename);
+        const { preamble, body, postscript } = this.extractSettingFromWholeText(data);
+        const newBody = stringifyYaml(saveData);
+
+        if (newBody == body) {
+            this._log("Markdown setting: Nothing had been changed", LOG_LEVEL_VERBOSE);
+        } else {
+            await this.core.storageAccess.writeFileAuto(filename, preamble + SETTING_HEADER + newBody + SETTING_FOOTER + postscript);
+            this._log(`Markdown setting: ${filename} has been updated!`, LOG_LEVEL_VERBOSE);
+        }
+    }
+
+}

src/modules/features/ModuleObsidianSettingTab.ts

@@ -0,0 +1,35 @@
+import { ObsidianLiveSyncSettingTab } from "./SettingDialogue/ObsidianLiveSyncSettingTab.ts";
+import { type IObsidianModule, AbstractObsidianModule } from "../AbstractObsidianModule.ts";
+// import { PouchDB } from "../../lib/src/pouchdb/pouchdb-browser";
+import { EVENT_REQUEST_OPEN_SETTING_WIZARD, EVENT_REQUEST_OPEN_SETTINGS, eventHub } from "../../common/events.ts";
+
+export class ModuleObsidianSettingDialogue extends AbstractObsidianModule implements IObsidianModule {
+
+    settingTab!: ObsidianLiveSyncSettingTab;
+
+    $everyOnloadStart(): Promise<boolean> {
+        this.settingTab = new ObsidianLiveSyncSettingTab(this.app, this.plugin);
+        this.plugin.addSettingTab(this.settingTab);
+        eventHub.onEvent(EVENT_REQUEST_OPEN_SETTINGS, () => this.openSetting());
+        eventHub.onEvent(EVENT_REQUEST_OPEN_SETTING_WIZARD, () => {
+            this.openSetting();
+            void this.settingTab.enableMinimalSetup();
+        });
+
+        return Promise.resolve(true);
+    }
+
+    openSetting() {
+        // Undocumented API
+        //@ts-ignore
+        this.app.setting.open();
+        //@ts-ignore
+        this.app.setting.openTabById("obsidian-livesync");
+    }
+
+    get appId() {
+        return `${("appId" in this.app ? this.app.appId : "")}`;
+    }
+
+
+}

src/modules/features/ModuleSetupObsidian.ts

@@ -0,0 +1,205 @@
+import { type ObsidianLiveSyncSettings, DEFAULT_SETTINGS, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../../lib/src/common/types.ts";
+import { configURIBase } from "../../common/types.ts";
+// import { PouchDB } from "../../lib/src/pouchdb/pouchdb-browser.js";
+import { decrypt, encrypt } from "../../lib/src/encryption/e2ee_v2.ts";
+import { fireAndForget } from "../../lib/src/common/utils.ts";
+import { EVENT_REQUEST_COPY_SETUP_URI, EVENT_REQUEST_OPEN_SETUP_URI, eventHub } from "../../common/events.ts";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+
+
+export class ModuleSetupObsidian extends AbstractObsidianModule implements IObsidianModule {
+    $everyOnload(): Promise<boolean> {
+        this.registerObsidianProtocolHandler("setuplivesync", async (conf: any) => await this.setupWizard(conf.settings));
+
+        this.addCommand({
+            id: "livesync-copysetupuri",
+            name: "Copy settings as a new setup URI",
+            callback: () => fireAndForget(this.command_copySetupURI()),
+        });
+        this.addCommand({
+            id: "livesync-copysetupuri-short",
+            name: "Copy settings as a new setup URI (With customization sync)",
+            callback: () => fireAndForget(this.command_copySetupURIWithSync()),
+        });
+
+        this.addCommand({
+            id: "livesync-copysetupurifull",
+            name: "Copy settings as a new setup URI (Full)",
+            callback: () => fireAndForget(this.command_copySetupURIFull()),
+        });
+
+        this.addCommand({
+            id: "livesync-opensetupuri",
+            name: "Use the copied setup URI (Formerly Open setup URI)",
+            callback: () => fireAndForget(this.command_openSetupURI()),
+        });
+        eventHub.onEvent(EVENT_REQUEST_OPEN_SETUP_URI, () => fireAndForget(() => this.command_openSetupURI()));
+        eventHub.onEvent(EVENT_REQUEST_COPY_SETUP_URI, () => fireAndForget(() => this.command_copySetupURI()));
+        return Promise.resolve(true);
+    }
+
+    async command_copySetupURI(stripExtra = true) {
+        const encryptingPassphrase = await this.core.confirm.askString("Encrypt your settings", "The passphrase to encrypt the setup URI", "", true);
+        if (encryptingPassphrase === false)
+            return;
+        const setting = { ...this.settings, configPassphraseStore: "", encryptedCouchDBConnection: "", encryptedPassphrase: "" } as Partial<ObsidianLiveSyncSettings>;
+        if (stripExtra) {
+            delete setting.pluginSyncExtendedSetting;
+        }
+        const keys = Object.keys(setting) as (keyof ObsidianLiveSyncSettings)[];
+        for (const k of keys) {
+            if (JSON.stringify(k in setting ? setting[k] : "") == JSON.stringify(k in DEFAULT_SETTINGS ? DEFAULT_SETTINGS[k] : "*")) {
+                delete setting[k];
+            }
+        }
+        const encryptedSetting = encodeURIComponent(await encrypt(JSON.stringify(setting), encryptingPassphrase, false));
+        const uri = `${configURIBase}${encryptedSetting}`;
+        await navigator.clipboard.writeText(uri);
+        this._log("Setup URI copied to clipboard", LOG_LEVEL_NOTICE);
+    }
+    async command_copySetupURIFull() {
+        const encryptingPassphrase = await this.core.confirm.askString("Encrypt your settings", "The passphrase to encrypt the setup URI", "", true);
+        if (encryptingPassphrase === false)
+            return;
+        const setting = { ...this.settings, configPassphraseStore: "", encryptedCouchDBConnection: "", encryptedPassphrase: "" };
+        const encryptedSetting = encodeURIComponent(await encrypt(JSON.stringify(setting), encryptingPassphrase, false));
+        const uri = `${configURIBase}${encryptedSetting}`;
+        await navigator.clipboard.writeText(uri);
+        this._log("Setup URI copied to clipboard", LOG_LEVEL_NOTICE);
+    }
+    async command_copySetupURIWithSync() {
+        await this.command_copySetupURI(false);
+    }
+    async command_openSetupURI() {
+        const setupURI = await this.core.confirm.askString("Easy setup", "Set up URI", `${configURIBase}aaaaa`);
+        if (setupURI === false)
+            return;
+        if (!setupURI.startsWith(`${configURIBase}`)) {
+            this._log("Set up URI looks wrong.", LOG_LEVEL_NOTICE);
+            return;
+        }
+        const config = decodeURIComponent(setupURI.substring(configURIBase.length));
+        console.dir(config);
+        await this.setupWizard(config);
+    }
+    async setupWizard(confString: string) {
+        try {
+            const oldConf = JSON.parse(JSON.stringify(this.settings));
+            const encryptingPassphrase = await this.core.confirm.askString("Passphrase", "The passphrase to decrypt your setup URI", "", true);
+            if (encryptingPassphrase === false)
+                return;
+            const newConf = await JSON.parse(await decrypt(confString, encryptingPassphrase, false));
+            if (newConf) {
+                const result = await this.core.confirm.askYesNoDialog("Importing Configuration from the Setup-URI. Are you sure to proceed?", {});
+                if (result == "yes") {
+                    const newSettingW = Object.assign({}, DEFAULT_SETTINGS, newConf) as ObsidianLiveSyncSettings;
+                    this.core.replicator.closeReplication();
+                    this.settings.suspendFileWatching = true;
+                    console.dir(newSettingW);
+                    // Back into the default method once.
+                    newSettingW.configPassphraseStore = "";
+                    newSettingW.encryptedPassphrase = "";
+                    newSettingW.encryptedCouchDBConnection = "";
+                    newSettingW.additionalSuffixOfDatabaseName = `${("appId" in this.app ? this.app.appId : "")}`
+                    const setupJustImport = "Just import setting";
+                    const setupAsNew = "Set it up as secondary or subsequent device";
+                    const setupAsMerge = "Secondary device but try keeping local changes";
+                    const setupAgain = "Reconfigure and reconstitute the data";
+                    const setupManually = "Leave everything to me";
+                    newSettingW.syncInternalFiles = false;
+                    newSettingW.usePluginSync = false;
+                    newSettingW.isConfigured = true;
+                    // Migrate completely obsoleted configuration.
+                    if (!newSettingW.useIndexedDBAdapter) {
+                        newSettingW.useIndexedDBAdapter = true;
+                    }
+
+                    const setupType = await this.core.confirm.askSelectStringDialogue("How would you like to set it up?", [setupAsNew, setupAgain, setupAsMerge, setupJustImport, setupManually], { defaultAction: setupAsNew });
+                    if (setupType == setupJustImport) {
+                        this.core.settings = newSettingW;
+                        this.core.$$clearUsedPassphrase();
+                        await this.core.saveSettings();
+                    } else if (setupType == setupAsNew) {
+                        this.core.settings = newSettingW;
+                        this.core.$$clearUsedPassphrase();
+                        await this.core.rebuilder.$fetchLocal();
+                    } else if (setupType == setupAsMerge) {
+                        this.core.settings = newSettingW;
+                        this.core.$$clearUsedPassphrase();
+                        await this.core.rebuilder.$fetchLocal(true);
+                    } else if (setupType == setupAgain) {
+                        const confirm = "I know this operation will rebuild all my databases with files on this device, and files that are on the remote database and I didn't synchronize to any other devices will be lost and want to proceed indeed.";
+                        if (await this.core.confirm.askSelectStringDialogue("Do you really want to do this?", ["Cancel", confirm], { defaultAction: "Cancel" }) != confirm) {
+                            return;
+                        }
+                        this.core.settings = newSettingW;
+                        this.core.$$clearUsedPassphrase();
+                        await this.core.rebuilder.$rebuildEverything();
+                    } else if (setupType == setupManually) {
+                        const keepLocalDB = await this.core.confirm.askYesNoDialog("Keep local DB?", { defaultOption: "No" });
+                        const keepRemoteDB = await this.core.confirm.askYesNoDialog("Keep remote DB?", { defaultOption: "No" });
+                        if (keepLocalDB == "yes" && keepRemoteDB == "yes") {
+                            // nothing to do. so peaceful.
+                            this.core.settings = newSettingW;
+                            this.core.$$clearUsedPassphrase();
+                            await this.core.$allSuspendAllSync();
+                            await this.core.$allSuspendExtraSync();
+                            await this.core.saveSettings();
+                            const replicate = await this.core.confirm.askYesNoDialog("Unlock and replicate?", { defaultOption: "Yes" });
+                            if (replicate == "yes") {
+                                await this.core.$$replicate(true);
+                                await this.core.$$markRemoteUnlocked();
+                            }
+                            this._log("Configuration loaded.", LOG_LEVEL_NOTICE);
+                            return;
+                        }
+                        if (keepLocalDB == "no" && keepRemoteDB == "no") {
+                            const reset = await this.core.confirm.askYesNoDialog("Drop everything?", { defaultOption: "No" });
+                            if (reset != "yes") {
+                                this._log("Cancelled", LOG_LEVEL_NOTICE);
+                                this.core.settings = oldConf;
+                                return;
+                            }
+                        }
+                        let initDB;
+                        this.core.settings = newSettingW;
+                        this.core.$$clearUsedPassphrase();
+                        await this.core.saveSettings();
+                        if (keepLocalDB == "no") {
+                            await this.core.$$resetLocalDatabase();
+                            await this.core.localDatabase.initializeDatabase();
+                            const rebuild = await this.core.confirm.askYesNoDialog("Rebuild the database?", { defaultOption: "Yes" });
+                            if (rebuild == "yes") {
+                                initDB = this.core.$$initializeDatabase(true);
+                            } else {
+                                await this.core.$$markRemoteResolved();
+                            }
+                        }
+                        if (keepRemoteDB == "no") {
+                            await this.core.$$tryResetRemoteDatabase();
+                            await this.core.$$markRemoteLocked();
+                        }
+                        if (keepLocalDB == "no" || keepRemoteDB == "no") {
+                            const replicate = await this.core.confirm.askYesNoDialog("Replicate once?", { defaultOption: "Yes" });
+                            if (replicate == "yes") {
+                                if (initDB != null) {
+                                    await initDB;
+                                }
+                                await this.core.$$replicate(true);
+                            }
+                        }
+                    }
+                }
+
+                this._log("Configuration loaded.", LOG_LEVEL_NOTICE);
+            } else {
+                this._log("Cancelled.", LOG_LEVEL_NOTICE);
+            }
+        } catch (ex) {
+            this._log("Couldn't parse or decrypt configuration uri.", LOG_LEVEL_NOTICE);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+    }
+
+
+}

src/modules/features/SettingDialogue/LiveSyncSetting.ts

@@ -0,0 +1,339 @@
+import { Setting, TextComponent, type ToggleComponent, type DropdownComponent, ButtonComponent, type TextAreaComponent, type ValueComponent } from "obsidian";
+import { unique } from "octagonal-wheels/collection";
+import { LEVEL_ADVANCED, LEVEL_POWER_USER, statusDisplay, type ConfigurationItem } from "../../../lib/src/common/types.ts";
+import { type ObsidianLiveSyncSettingTab, type AutoWireOption, wrapMemo, type OnUpdateResult, createStub, findAttrFromParent } from "./ObsidianLiveSyncSettingTab.ts";
+import { type AllSettingItemKey, getConfig, type AllSettings, type AllStringItemKey, type AllNumericItemKey, type AllBooleanItemKey } from "./settingConstants.ts";
+
+
+export class LiveSyncSetting extends Setting {
+    autoWiredComponent?: TextComponent | ToggleComponent | DropdownComponent | ButtonComponent | TextAreaComponent;
+    applyButtonComponent?: ButtonComponent;
+    selfKey?: AllSettingItemKey;
+    watchDirtyKeys = [] as AllSettingItemKey[];
+    holdValue: boolean = false;
+    static env: ObsidianLiveSyncSettingTab;
+
+    descBuf: string | DocumentFragment = "";
+    nameBuf: string | DocumentFragment = "";
+    placeHolderBuf: string = "";
+    hasPassword: boolean = false;
+
+    invalidateValue?: () => void;
+    setValue?: (value: any) => void;
+    constructor(containerEl: HTMLElement) {
+        super(containerEl);
+        LiveSyncSetting.env.settingComponents.push(this);
+    }
+
+    _createDocStub(key: string, value: string | DocumentFragment) {
+        DEV: {
+            const paneName = findAttrFromParent(this.settingEl, "data-pane");
+            const panelName = findAttrFromParent(this.settingEl, "data-panel");
+            const itemName = typeof this.nameBuf == "string" ? this.nameBuf : this.nameBuf.textContent?.toString() ?? "";
+            const strValue = typeof value == "string" ? value : value.textContent?.toString() ?? "";
+
+            createStub(itemName, key, strValue, panelName, paneName);
+        }
+    }
+
+    setDesc(desc: string | DocumentFragment): this {
+        this.descBuf = desc;
+        DEV: {
+            this._createDocStub("desc", desc);
+        }
+        super.setDesc(desc);
+        return this;
+    }
+    setName(name: string | DocumentFragment): this {
+        this.nameBuf = name;
+        DEV: {
+            this._createDocStub("name", name);
+        }
+        super.setName(name);
+        return this;
+    }
+    setAuto(key: AllSettingItemKey, opt?: AutoWireOption) {
+        this.autoWireSetting(key, opt);
+        return this;
+    }
+    autoWireSetting(key: AllSettingItemKey, opt?: AutoWireOption) {
+        const conf = getConfig(key);
+        if (!conf) {
+            // throw new Error(`No such setting item :${key}`)
+            return;
+        }
+        const name = `${conf.name}${statusDisplay(conf.status)}`;
+        this.setName(name);
+        if (conf.desc) {
+            this.setDesc(conf.desc);
+        }
+        DEV: {
+            this._createDocStub("key", key);
+            if (conf.obsolete) this._createDocStub("is_obsolete", "true");
+            if (conf.level) this._createDocStub("level", conf.level);
+        }
+
+        this.holdValue = opt?.holdValue || this.holdValue;
+        this.selfKey = key;
+        if (conf.obsolete || opt?.obsolete) {
+            this.settingEl.toggleClass("sls-setting-obsolete", true);
+        }
+        if (opt?.onUpdate) this.addOnUpdate(opt.onUpdate);
+        const stat = this._getComputedStatus();
+        if (stat.visibility === false) {
+            this.settingEl.toggleClass("sls-setting-hidden", !stat.visibility);
+        }
+        return conf;
+    }
+    autoWireComponent(component: ValueComponent<any>, conf?: ConfigurationItem, opt?: AutoWireOption) {
+        this.placeHolderBuf = conf?.placeHolder || opt?.placeHolder || "";
+        if (conf?.level == LEVEL_ADVANCED) {
+            this.settingEl.toggleClass("sls-setting-advanced", true);
+        } else if (conf?.level == LEVEL_POWER_USER) {
+            this.settingEl.toggleClass("sls-setting-poweruser", true);
+        }
+        if (this.placeHolderBuf && component instanceof TextComponent) {
+            component.setPlaceholder(this.placeHolderBuf);
+        }
+        if (opt?.onUpdate) this.addOnUpdate(opt.onUpdate);
+    }
+    async commitValue<T extends AllSettingItemKey>(value: AllSettings[T]) {
+        const key = this.selfKey as T;
+        if (key !== undefined) {
+            if (value != LiveSyncSetting.env.editingSettings[key]) {
+                LiveSyncSetting.env.editingSettings[key] = value;
+                if (!this.holdValue) {
+                    await LiveSyncSetting.env.saveSettings([key]);
+                }
+            }
+        }
+        LiveSyncSetting.env.requestUpdate();
+    }
+    autoWireText(key: AllStringItemKey, opt?: AutoWireOption) {
+        const conf = this.autoWireSetting(key, opt);
+        this.addText(text => {
+            this.autoWiredComponent = text;
+            const setValue = wrapMemo((value: string) => { text.setValue(value) });
+            this.invalidateValue = () => setValue(`${LiveSyncSetting.env.editingSettings[key]}`);
+            this.invalidateValue();
+            text.onChange(async (value) => {
+                await this.commitValue(value);
+            });
+            if (opt?.isPassword) {
+                text.inputEl.setAttribute("type", "password");
+                this.hasPassword = true;
+            }
+            this.autoWireComponent(this.autoWiredComponent, conf, opt);
+        });
+        return this;
+    }
+    autoWireTextArea(key: AllStringItemKey, opt?: AutoWireOption) {
+        const conf = this.autoWireSetting(key, opt);
+        this.addTextArea(text => {
+            this.autoWiredComponent = text;
+            const setValue = wrapMemo((value: string) => { text.setValue(value) });
+            this.invalidateValue = () => setValue(`${LiveSyncSetting.env.editingSettings[key]}`);
+            this.invalidateValue();
+            text.onChange(async (value) => {
+                await this.commitValue(value);
+            });
+            if (opt?.isPassword) {
+                text.inputEl.setAttribute("type", "password");
+                this.hasPassword = true;
+            }
+            this.autoWireComponent(this.autoWiredComponent, conf, opt);
+        });
+        return this;
+    }
+    autoWireNumeric(key: AllNumericItemKey, opt: AutoWireOption & { clampMin?: number; clampMax?: number; acceptZero?: boolean; }) {
+        const conf = this.autoWireSetting(key, opt);
+        this.addText(text => {
+            this.autoWiredComponent = text;
+            if (opt.clampMin) {
+                text.inputEl.setAttribute("min", `${opt.clampMin}`);
+            }
+            if (opt.clampMax) {
+                text.inputEl.setAttribute("max", `${opt.clampMax}`);
+            }
+            let lastError = false;
+            const setValue = wrapMemo((value: string) => { text.setValue(value) });
+            this.invalidateValue = () => {
+                if (!lastError) setValue(`${LiveSyncSetting.env.editingSettings[key]}`);
+            };
+            this.invalidateValue();
+            text.onChange(async (TextValue) => {
+                const parsedValue = Number(TextValue);
+                const value = parsedValue;
+                let hasError = false;
+                if (isNaN(value)) hasError = true;
+                if (opt.clampMax && opt.clampMax < value) hasError = true;
+                if (opt.clampMin && opt.clampMin > value) {
+                    if (opt.acceptZero && value == 0) {
+                        // This is ok.
+                    } else {
+                        hasError = true;
+                    }
+                }
+                if (!hasError) {
+                    lastError = false;
+                    this.setTooltip(``);
+                    text.inputEl.toggleClass("sls-item-invalid-value", false);
+                    await this.commitValue(value);
+                } else {
+                    this.setTooltip(`The value should ${opt.clampMin || "~"} < value < ${opt.clampMax || "~"}`);
+                    text.inputEl.toggleClass("sls-item-invalid-value", true);
+                    lastError = true;
+                    return false;
+                }
+            });
+            text.inputEl.setAttr("type", "number");
+            this.autoWireComponent(this.autoWiredComponent, conf, opt);
+        });
+        return this;
+    }
+    autoWireToggle(key: AllBooleanItemKey, opt?: AutoWireOption) {
+        const conf = this.autoWireSetting(key, opt);
+        this.addToggle(toggle => {
+            this.autoWiredComponent = toggle;
+            const setValue = wrapMemo((value: boolean) => { toggle.setValue(opt?.invert ? !value : value) });
+            this.invalidateValue = () => setValue(LiveSyncSetting.env.editingSettings[key] ?? false);
+            this.invalidateValue();
+
+            toggle.onChange(async (value) => {
+                await this.commitValue(opt?.invert ? !value : value);
+            });
+
+            this.autoWireComponent(this.autoWiredComponent, conf, opt);
+        });
+        return this;
+    }
+    autoWireDropDown<T extends string>(key: AllStringItemKey, opt: AutoWireOption & { options: Record<T, string>; }) {
+        const conf = this.autoWireSetting(key, opt);
+        this.addDropdown(dropdown => {
+            this.autoWiredComponent = dropdown;
+            const setValue = wrapMemo((value: string) => {
+                dropdown.setValue(value);
+            });
+
+            dropdown
+                .addOptions(opt.options);
+
+            this.invalidateValue = () => setValue(LiveSyncSetting.env.editingSettings[key] || "");
+            this.invalidateValue();
+            dropdown.onChange(async (value) => {
+                await this.commitValue(value);
+            });
+            this.autoWireComponent(this.autoWiredComponent, conf, opt);
+        });
+        return this;
+    }
+    addApplyButton(keys: AllSettingItemKey[], text?: string) {
+        this.addButton((button) => {
+            this.applyButtonComponent = button;
+            this.watchDirtyKeys = unique([...keys, ...this.watchDirtyKeys]);
+            button.setButtonText(text ?? "Apply");
+            button.onClick(async () => {
+                await LiveSyncSetting.env.saveSettings(keys);
+                LiveSyncSetting.env.reloadAllSettings();
+            });
+            LiveSyncSetting.env.requestUpdate();
+        });
+        return this;
+    }
+    addOnUpdate(func: () => OnUpdateResult) {
+        this.updateHandlers.add(func);
+        // this._applyOnUpdateHandlers();
+        return this;
+    }
+    updateHandlers = new Set<() => OnUpdateResult>();
+
+    prevStatus: OnUpdateResult = {};
+
+    _getComputedStatus() {
+        let newConf = {} as OnUpdateResult;
+        for (const handler of this.updateHandlers) {
+            newConf = {
+                ...newConf,
+                ...handler(),
+            };
+        }
+        return newConf;
+    }
+    _applyOnUpdateHandlers() {
+        if (this.updateHandlers.size > 0) {
+            const newConf = this._getComputedStatus();
+            const keys = Object.keys(newConf) as [keyof OnUpdateResult];
+            for (const k of keys) {
+
+                if (k in this.prevStatus && this.prevStatus[k] == newConf[k]) {
+                    continue;
+                }
+                // const newValue = newConf[k];
+                switch (k) {
+                    case "visibility":
+                        this.settingEl.toggleClass("sls-setting-hidden", !(newConf[k] || false));
+                        this.prevStatus[k] = newConf[k];
+                        break;
+                    case "classes":
+                        break;
+                    case "disabled":
+                        this.setDisabled((newConf[k] || false));
+                        this.settingEl.toggleClass("sls-setting-disabled", (newConf[k] || false));
+                        this.prevStatus[k] = newConf[k];
+                        break;
+                    case "isCta":
+                        {
+                            const component = this.autoWiredComponent;
+                            if (component instanceof ButtonComponent) {
+                                if (newConf[k]) {
+                                    component.setCta();
+                                } else {
+                                    component.removeCta();
+                                }
+                            }
+                            this.prevStatus[k] = newConf[k];
+                        }
+                        break;
+                    case "isWarning":
+                        {
+                            const component = this.autoWiredComponent;
+                            if (component instanceof ButtonComponent) {
+                                if (newConf[k]) {
+                                    component.setWarning();
+                                } else {
+                                    //TODO:IMPLEMENT
+                                    // component.removeCta();
+                                }
+                            }
+                            this.prevStatus[k] = newConf[k];
+                        }
+                        break;
+                }
+            }
+        }
+    }
+    _onUpdate() {
+        if (this.applyButtonComponent) {
+            const isDirty = LiveSyncSetting.env.isSomeDirty(this.watchDirtyKeys);
+            this.applyButtonComponent.setDisabled(!isDirty);
+            if (isDirty) {
+                this.applyButtonComponent.setCta();
+            } else {
+                this.applyButtonComponent.removeCta();
+            }
+        }
+        if (this.selfKey && !LiveSyncSetting.env.isDirty(this.selfKey) && this.invalidateValue) {
+            this.invalidateValue();
+        }
+        if (this.holdValue && this.selfKey) {
+            const isDirty = LiveSyncSetting.env.isDirty(this.selfKey);
+            const alt = isDirty ? `Original: ${LiveSyncSetting.env.initialSettings![this.selfKey]}` : "";
+            this.controlEl.toggleClass("sls-item-dirty", isDirty);
+            if (!this.hasPassword) {
+                this.nameEl.toggleClass("sls-item-dirty-help", isDirty);
+                this.setTooltip(alt, { delay: 10, placement: "right" });
+            }
+        }
+        this._applyOnUpdateHandlers();
+    }
+}

src/modules/features/SettingDialogue/MultipleRegExpControl.svelte

@@ -0,0 +1,88 @@
+<script lang="ts">
+    export let patterns = [] as string[];
+    export let originals = [] as string[];
+
+    export let apply: (args: string[]) => Promise<void> = (_: string[]) => Promise.resolve();
+    function revert() {
+        patterns = [...originals];
+    }
+    const CHECK_OK = "✔";
+    const CHECK_NG = "⚠";
+    const MARK_MODIFIED = "✏ ";
+    function checkRegExp(pattern: string) {
+        if (pattern.trim() == "") return "";
+        try {
+            new RegExp(pattern);
+            return CHECK_OK;
+        } catch (ex) {
+            return CHECK_NG;
+        }
+    }
+    $: statusName = patterns.map((e) => checkRegExp(e));
+    $: modified = patterns.map((e, i) => (e != (originals?.[i] ?? "") ? MARK_MODIFIED : ""));
+
+    function remove(idx: number) {
+        patterns[idx] = "";
+    }
+    function add() {
+        patterns = [...patterns, ""];
+    }
+</script>
+
+<ul>
+    {#each patterns as pattern, idx}
+        <!-- svelte-ignore a11y-label-has-associated-control -->
+        <li>
+            <label>{modified[idx]}{statusName[idx]}</label><input type="text" bind:value={pattern} class={modified[idx]} />
+            <button class="iconbutton" on:click={() => remove(idx)}>🗑</button>
+        </li>
+    {/each}
+    <li>
+        <label>
+            <button on:click={() => add()}>Add</button>
+        </label>
+    </li>
+    <li class="buttons">
+        <button on:click={() => apply(patterns)} disabled={statusName.some((e) => e === CHECK_NG) || modified.every((e) => e === "")}>Apply </button>
+        <button on:click={() => revert()} disabled={statusName.some((e) => e === CHECK_NG) || modified.every((e) => e === "")}>Revert </button>
+    </li>
+</ul>
+
+<style>
+    label {
+        min-width: 4em;
+        width: 4em;
+        display: inline-flex;
+        flex-direction: row;
+        justify-content: flex-end;
+    }
+
+    ul {
+        flex-grow: 1;
+        display: inline-flex;
+        flex-direction: column;
+        list-style-type: none;
+        margin-block-start: 0;
+        margin-block-end: 0;
+        margin-inline-start: 0;
+        margin-inline-end: 0;
+        padding-inline-start: 0;
+    }
+
+    li {
+        padding: var(--size-2-1) var(--size-4-1);
+        display: inline-flex;
+        flex-grow: 1;
+        align-items: center;
+        justify-content: flex-end;
+        gap: var(--size-4-2);
+    }
+
+    li input {
+        min-width: 10em;
+    }
+
+    button.iconbutton {
+        max-width: 4em;
+    }
+</style>

src/modules/features/SettingDialogue/settingConstants.ts

@@ -0,0 +1,388 @@
+import { $t } from "../../../lib/src/common/i18n.ts";
+import { DEFAULT_SETTINGS, configurationNames, type ConfigurationItem, type FilterBooleanKeys, type FilterNumberKeys, type FilterStringKeys, type ObsidianLiveSyncSettings } from "../../../lib/src/common/types.ts";
+
+export type OnDialogSettings = {
+    configPassphrase: string,
+    preset: "" | "PERIODIC" | "LIVESYNC" | "DISABLE",
+    syncMode: "ONEVENTS" | "PERIODIC" | "LIVESYNC"
+    dummy: number,
+    deviceAndVaultName: string,
+}
+
+export const OnDialogSettingsDefault: OnDialogSettings = {
+    configPassphrase: "",
+    preset: "",
+    syncMode: "ONEVENTS",
+    dummy: 0,
+    deviceAndVaultName: "",
+}
+export const AllSettingDefault =
+    { ...DEFAULT_SETTINGS, ...OnDialogSettingsDefault }
+
+export type AllSettings = ObsidianLiveSyncSettings & OnDialogSettings;
+export type AllStringItemKey = FilterStringKeys<AllSettings>;
+export type AllNumericItemKey = FilterNumberKeys<AllSettings>;
+export type AllBooleanItemKey = FilterBooleanKeys<AllSettings>;
+export type AllSettingItemKey = AllStringItemKey | AllNumericItemKey | AllBooleanItemKey;
+
+export type ValueOf<T extends AllSettingItemKey> =
+    T extends AllStringItemKey ? string :
+    T extends AllNumericItemKey ? number :
+    T extends AllBooleanItemKey ? boolean :
+    AllSettings[T];
+
+export const SettingInformation: Partial<Record<keyof AllSettings, ConfigurationItem>> = {
+    "liveSync": {
+        "name": "Sync Mode"
+    },
+    "couchDB_URI": {
+        "name": "URI",
+        "placeHolder": "https://........"
+    },
+    "couchDB_USER": {
+        "name": "Username",
+        "desc": "username"
+    },
+    "couchDB_PASSWORD": {
+        "name": "Password",
+        "desc": "password"
+    },
+    "couchDB_DBNAME": {
+        "name": "Database name"
+    },
+    "passphrase": {
+        "name": "Passphrase",
+        "desc": "Encrypting passphrase. If you change the passphrase of an existing database, overwriting the remote database is strongly recommended."
+    },
+    "showStatusOnEditor": {
+        "name": "Show status inside the editor",
+        "desc": "Reflected after reboot"
+    },
+    "showOnlyIconsOnEditor": {
+        "name": "Show status as icons only"
+    },
+    "showStatusOnStatusbar": {
+        "name": "Show status on the status bar",
+        "desc": "Reflected after reboot."
+    },
+    "lessInformationInLog": {
+        "name": "Show only notifications",
+        "desc": "Prevent logging and show only notification. Please disable when you report the logs"
+    },
+    "showVerboseLog": {
+        "name": "Verbose Log",
+        "desc": "Show verbose log. Please enable when you report the logs"
+    },
+    "hashCacheMaxCount": {
+        "name": "Memory cache size (by total items)"
+    },
+    "hashCacheMaxAmount": {
+        "name": "Memory cache size (by total characters)",
+        "desc": "(Mega chars)"
+    },
+    "writeCredentialsForSettingSync": {
+        "name": "Write credentials in the file",
+        "desc": "(Not recommended) If set, credentials will be stored in the file."
+    },
+    "notifyAllSettingSyncFile": {
+        "name": "Notify all setting files"
+    },
+    "configPassphrase": {
+        "name": "Passphrase of sensitive configuration items",
+        "desc": "This passphrase will not be copied to another device. It will be set to `Default` until you configure it again."
+    },
+    "configPassphraseStore": {
+        "name": "Encrypting sensitive configuration items"
+    },
+    "syncOnSave": {
+        "name": "Sync on Save",
+        "desc": "When you save a file, sync automatically"
+    },
+    "syncOnEditorSave": {
+        "name": "Sync on Editor Save",
+        "desc": "When you save a file in the editor, sync automatically"
+    },
+    "syncOnFileOpen": {
+        "name": "Sync on File Open",
+        "desc": "When you open a file, sync automatically"
+    },
+    "syncOnStart": {
+        "name": "Sync on Start",
+        "desc": "Start synchronization after launching Obsidian."
+    },
+    "syncAfterMerge": {
+        "name": "Sync after merging file",
+        "desc": "Sync automatically after merging files"
+    },
+    "trashInsteadDelete": {
+        "name": "Use the trash bin",
+        "desc": "Do not delete files that are deleted in remote, just move to trash."
+    },
+    "doNotDeleteFolder": {
+        "name": "Keep empty folder",
+        "desc": "Normally, a folder is deleted when it becomes empty after a synchronization. Enabling this will prevent it from getting deleted"
+    },
+    "resolveConflictsByNewerFile": {
+        "name": "Always overwrite with a newer file (beta)",
+        "desc": "(Def off) Resolve conflicts by newer files automatically."
+    },
+    "checkConflictOnlyOnOpen": {
+        "name": "Postpone resolution of inactive files"
+    },
+    "showMergeDialogOnlyOnActive": {
+        "name": "Postpone manual resolution of inactive files"
+    },
+    "disableMarkdownAutoMerge": {
+        "name": "Always resolve conflicts manually",
+        "desc": "If this switch is turned on, a merge dialog will be displayed, even if the sensible-merge is possible automatically. (Turn on to previous behavior)"
+    },
+    "writeDocumentsIfConflicted": {
+        "name": "Always reflect synchronized changes even if the note has a conflict",
+        "desc": "Turn on to previous behavior"
+    },
+    "syncInternalFilesInterval": {
+        "name": "Scan hidden files periodically",
+        "desc": "Seconds, 0 to disable"
+    },
+    "batchSave": {
+        "name": "Batch database update",
+        "desc": "Reducing the frequency with which on-disk changes are reflected into the DB"
+    },
+    "readChunksOnline": {
+        "name": "Fetch chunks on demand",
+        "desc": "(ex. Read chunks online) If this option is enabled, LiveSync reads chunks online directly instead of replicating them locally. Increasing Custom chunk size is recommended."
+    },
+    "syncMaxSizeInMB": {
+        "name": "Maximum file size",
+        "desc": "(MB) If this is set, changes to local and remote files that are larger than this will be skipped. If the file becomes smaller again, a newer one will be used."
+    },
+    "useIgnoreFiles": {
+        "name": "(Beta) Use ignore files",
+        "desc": "If this is set, changes to local files which are matched by the ignore files will be skipped. Remote changes are determined using local ignore files."
+    },
+    "ignoreFiles": {
+        "name": "Ignore files",
+        "desc": "We can use multiple ignore files, e.g.) `.gitignore, .dockerignore`"
+    },
+    "batch_size": {
+        "name": "Batch size",
+        "desc": "Number of change feed items to process at a time. Defaults to 50. Minimum is 2."
+    },
+    "batches_limit": {
+        "name": "Batch limit",
+        "desc": "Number of batches to process at a time. Defaults to 40. Minimum is 2. This along with batch size controls how many docs are kept in memory at a time."
+    },
+    "useTimeouts": {
+        "name": "Use timeouts instead of heartbeats",
+        "desc": "If this option is enabled, PouchDB will hold the connection open for 60 seconds, and if no change arrives in that time, close and reopen the socket, instead of holding it open indefinitely. Useful when a proxy limits request duration but can increase resource usage."
+    },
+    "concurrencyOfReadChunksOnline": {
+        "name": "Batch size of on-demand fetching"
+    },
+    "minimumIntervalOfReadChunksOnline": {
+        "name": "The delay for consecutive on-demand fetches"
+    },
+    "suspendFileWatching": {
+        "name": "Suspend file watching",
+        "desc": "Stop watching for file change."
+    },
+    "suspendParseReplicationResult": {
+        "name": "Suspend database reflecting",
+        "desc": "Stop reflecting database changes to storage files."
+    },
+    "writeLogToTheFile": {
+        "name": "Write logs into the file",
+        "desc": "Warning! This will have a serious impact on performance. And the logs will not be synchronised under the default name. Please be careful with logs; they often contain your confidential information."
+    },
+    "deleteMetadataOfDeletedFiles": {
+        "name": "Do not keep metadata of deleted files."
+    },
+    "useIndexedDBAdapter": {
+        "name": "(Obsolete) Use an old adapter for compatibility",
+        "desc": "Before v0.17.16, we used an old adapter for the local database. Now the new adapter is preferred. However, it needs local database rebuilding. Please disable this toggle when you have enough time. If leave it enabled, also while fetching from the remote database, you will be asked to disable this.",
+        "obsolete": true
+    },
+    "watchInternalFileChanges": {
+        "name": "Scan changes on customization sync",
+        "desc": "Do not use internal API"
+    },
+    "doNotSuspendOnFetching": {
+        "name": "Fetch database with previous behaviour"
+    },
+    "disableCheckingConfigMismatch": {
+        "name": "Do not check configuration mismatch before replication"
+    },
+    "usePluginSync": {
+        "name": "Enable customization sync"
+    },
+    "autoSweepPlugins": {
+        "name": "Scan customization automatically",
+        "desc": "Scan customization before replicating."
+    },
+    "autoSweepPluginsPeriodic": {
+        "name": "Scan customization periodically",
+        "desc": "Scan customization every 1 minute."
+    },
+    "notifyPluginOrSettingUpdated": {
+        "name": "Notify customized",
+        "desc": "Notify when other device has newly customized."
+    },
+    "remoteType": {
+        "name": "Remote Type",
+        "desc": "Remote server type"
+    },
+    "endpoint": {
+        "name": "Endpoint URL",
+        "placeHolder": "https://........"
+    },
+    "accessKey": {
+        "name": "Access Key"
+    },
+    "secretKey": {
+        "name": "Secret Key"
+    },
+    "region": {
+        "name": "Region",
+        "placeHolder": "auto"
+    },
+    "bucket": {
+        "name": "Bucket Name"
+    },
+    "useCustomRequestHandler": {
+        "name": "Use Custom HTTP Handler",
+        "desc": "If your Object Storage could not configured accepting CORS, enable this."
+    },
+    "maxChunksInEden": {
+        "name": "Maximum Incubating Chunks",
+        "desc": "The maximum number of chunks that can be incubated within the document. Chunks exceeding this number will immediately graduate to independent chunks."
+    },
+    "maxTotalLengthInEden": {
+        "name": "Maximum Incubating Chunk Size",
+        "desc": "The maximum total size of chunks that can be incubated within the document. Chunks exceeding this size will immediately graduate to independent chunks."
+    },
+    "maxAgeInEden": {
+        "name": "Maximum Incubation Period",
+        "desc": "The maximum duration for which chunks can be incubated within the document. Chunks exceeding this period will graduate to independent chunks."
+    },
+    "settingSyncFile": {
+        "name": "Filename",
+        "desc": "If you set this, all settings are saved in a markdown file. You will be notified when new settings arrive. You can set different files by the platform."
+    },
+    "preset": {
+        "name": "Presets",
+        "desc": "Apply preset configuration"
+    },
+    "syncMode": {
+        name: "Sync Mode",
+    },
+    "periodicReplicationInterval": {
+        "name": "Periodic Sync interval",
+        "desc": "Interval (sec)"
+    },
+    "syncInternalFilesBeforeReplication": {
+        "name": "Scan for hidden files before replication"
+    },
+    "automaticallyDeleteMetadataOfDeletedFiles": {
+        "name": "Delete old metadata of deleted files on start-up",
+        "desc": "(Days passed, 0 to disable automatic-deletion)"
+    },
+    "additionalSuffixOfDatabaseName": {
+        "name": "Database suffix",
+        "desc": "LiveSync could not handle multiple vaults which have same name without different prefix, This should be automatically configured."
+    },
+    "hashAlg": {
+        "name": configurationNames["hashAlg"]?.name || "",
+        "desc": "xxhash64 is the current default."
+    },
+    "deviceAndVaultName": {
+        "name": "Device name",
+        "desc": "Unique name between all synchronized devices. To edit this setting, please disable customization sync once."
+    },
+    "displayLanguage": {
+        "name": "Display Language",
+        "desc": "Not all messages have been translated. And, please revert to \"Default\" when reporting errors."
+    },
+    enableChunkSplitterV2: {
+        name: "Use splitting-limit-capped chunk splitter",
+        desc: "If enabled, chunks will be split into no more than 100 items. However, dedupe is slightly weaker."
+    },
+    disableWorkerForGeneratingChunks: {
+        name: "Do not split chunks in the background",
+        desc: "If disabled(toggled), chunks will be split on the UI thread (Previous behaviour)."
+    },
+    processSmallFilesInUIThread: {
+        name: "Process small files in the foreground",
+        desc: "If enabled, the file under 1kb will be processed in the UI thread."
+    },
+    batchSaveMinimumDelay: {
+        name: "Minimum delay for batch database updating",
+        desc: "Seconds. Saving to the local database will be delayed until this value after we stop typing or saving."
+    },
+    batchSaveMaximumDelay: {
+        name: "Maximum delay for batch database updating",
+        desc: "Saving will be performed forcefully after this number of seconds."
+    },
+    "notifyThresholdOfRemoteStorageSize": {
+        name: "Notify when the estimated remote storage size exceeds on start up",
+        desc: "MB (0 to disable)."
+    },
+    "usePluginSyncV2": {
+        name: "Enable per-file customization sync",
+        desc: "If enabled, efficient per-file customization sync will be used. A minor migration is required when enabling this feature, and all devices must be updated to v0.23.18. Enabling this feature will result in losing compatibility with older versions."
+    }
+    "handleFilenameCaseSensitive": {
+        name: "Handle files as Case-Sensitive",
+        desc: "If this enabled, All files are handled as case-Sensitive (Previous behaviour)."
+    },
+    "doNotUseFixedRevisionForChunks": {
+        name: "Compute revisions for chunks (Previous behaviour)",
+        desc: "If this enabled, all chunks will be stored with the revision made from its content. (Previous behaviour)"
+    },
+    "sendChunksBulkMaxSize": {
+        name: "Maximum size of chunks to send in one request",
+        desc: "MB"
+    },
+    "useAdvancedMode": {
+        name: "Enable advanced features",
+        // desc: "Enable advanced mode"
+    },
+    usePowerUserMode: {
+        name: "Enable power user features",
+        // desc: "Enable power user mode",
+        // level: LEVEL_ADVANCED
+    },
+    useEdgeCaseMode: {
+        name: "Enable edge case treatment features",
+    },
+    "enableDebugTools": {
+        name: "Enable Developers' Debug Tools.",
+        desc: "You need a restart to apply this setting."
+    }
+}
+function translateInfo(infoSrc: ConfigurationItem | undefined | false) {
+    if (!infoSrc) return false;
+    const info = { ...infoSrc };
+    info.name = $t(info.name);
+    if (info.desc) {
+        info.desc = $t(info.desc);
+    }
+    return info;
+}
+function _getConfig(key: AllSettingItemKey) {
+
+    if (key in configurationNames) {
+        return configurationNames[key as keyof ObsidianLiveSyncSettings];
+    }
+    if (key in SettingInformation) {
+        return SettingInformation[key as keyof ObsidianLiveSyncSettings];
+    }
+    return false;
+}
+export function getConfig(key: AllSettingItemKey) {
+    return translateInfo(_getConfig(key));
+}
+export function getConfName(key: AllSettingItemKey) {
+    const conf = getConfig(key);
+    if (!conf) return `${key} (No info)`;
+    return conf.name;
+}

src/modules/interfaces/Confirm.ts

@@ -0,0 +1,14 @@
+export interface Confirm {
+    askYesNo(message: string): Promise<"yes" | "no">;
+    askString(title: string, key: string, placeholder: string, isPassword?: boolean): Promise<string | false>;
+
+    askYesNoDialog(message: string, opt: { title?: string, defaultOption?: "Yes" | "No", timeout?: number }): Promise<"yes" | "no">;
+
+    askSelectString(message: string, items: string[]): Promise<string>
+
+    askSelectStringDialogue(message: string, buttons: string[], opt: { title?: string, defaultAction: (typeof buttons)[number], timeout?: number }): Promise<(typeof buttons)[number] | false>;
+
+    askInPopup(key: string, dialogText: string, anchorCallback: (anchor: HTMLAnchorElement) => void): void;
+
+    confirmWithMessage(title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout?: number): Promise<(typeof buttons)[number] | false>;
+}

src/modules/interfaces/DatabaseFileAccess.ts

@@ -0,0 +1,18 @@
+import type { FilePathWithPrefix, LoadedEntry, MetaEntry, UXFileInfo, UXFileInfoStub } from "../../lib/src/common/types";
+
+export interface DatabaseFileAccess {
+    delete: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string) => Promise<boolean>;
+    store: (file: UXFileInfo, force?: boolean, skipCheck?: boolean) => Promise<boolean>;
+    storeContent(path: FilePathWithPrefix, content: string): Promise<boolean>;
+    createChunks: (file: UXFileInfo, force?: boolean, skipCheck?: boolean) => Promise<boolean>;
+    fetch: (file: UXFileInfoStub | FilePathWithPrefix,
+        rev?: string, waitForReady?: boolean, skipCheck?: boolean) => Promise<UXFileInfo | false>;
+    fetchEntryFromMeta: (meta: MetaEntry,
+        waitForReady?: boolean, skipCheck?: boolean) => Promise<LoadedEntry | false>;
+    fetchEntryMeta: (file: UXFileInfoStub | FilePathWithPrefix,
+        rev?: string, skipCheck?: boolean) => Promise<MetaEntry | false>;
+    fetchEntry: (file: UXFileInfoStub | FilePathWithPrefix,
+        rev?: string, waitForReady?: boolean, skipCheck?: boolean) => Promise<LoadedEntry | false>;
+    getConflictedRevs: (file: UXFileInfoStub | FilePathWithPrefix) => Promise<string[]>;
+    // storeFromStorage: (file: UXFileInfoStub | FilePathWithPrefix, force?: boolean) => Promise<boolean>;
+}

src/modules/interfaces/DatabaseRebuilder.ts

@@ -0,0 +1,11 @@
+export interface Rebuilder {
+    $performRebuildDB(method: "localOnly" | "remoteOnly" | "rebuildBothByThisDevice" | "localOnlyWithChunks"): Promise<void>;
+    $rebuildRemote(): Promise<void>;
+    $rebuildEverything(): Promise<void>;
+    $fetchLocal(makeLocalChunkBeforeSync?: boolean): Promise<void>;
+
+    scheduleRebuild(): Promise<void>;
+    scheduleFetch(): Promise<void>;
+    resolveAllConflictedFilesByNewerOnes(): Promise<void>;
+
+}

src/modules/interfaces/StorageAccess.ts

@@ -0,0 +1,48 @@
+import type { FilePath, FilePathWithPrefix, UXDataWriteOptions, UXFileInfo, UXFileInfoStub, UXFolderInfo, UXStat } from "../../lib/src/common/types"
+
+export interface StorageAccess {
+
+    deleteVaultItem(file: FilePathWithPrefix | UXFileInfoStub | UXFolderInfo): Promise<void>
+
+    writeFileAuto(path: string, data: string | ArrayBuffer, opt?: UXDataWriteOptions): Promise<boolean>
+
+    readFileAuto(path: string): Promise<string | ArrayBuffer>
+    readFileText(path: string): Promise<string>
+    isExists(path: string): Promise<boolean>
+    writeHiddenFileAuto(path: string, data: string | ArrayBuffer, opt?: UXDataWriteOptions): Promise<boolean>
+    appendHiddenFile(path: string, data: string, opt?: UXDataWriteOptions): Promise<boolean>
+
+    stat(path: string): Promise<UXStat | null>
+    statHidden(path: string): Promise<UXStat | null>
+    removeHidden(path: string): Promise<boolean>
+    readHiddenFileAuto(path: string): Promise<string | ArrayBuffer>
+    readHiddenFileBinary(path: string): Promise<ArrayBuffer>
+    readHiddenFileText(path: string): Promise<string>
+    isExistsIncludeHidden(path: string): Promise<boolean>
+    // This could be work also for the hidden files.
+    ensureDir(path: string): Promise<boolean>
+    triggerFileEvent(event: string, path: string): void
+    triggerHiddenFile(path: string): Promise<void>
+
+    getFileStub(path: string): UXFileInfoStub | null
+    readStubContent(stub: UXFileInfoStub): Promise<UXFileInfo | false>;
+    getStub(path: string): UXFileInfoStub | UXFolderInfo | null
+
+    getFiles(): UXFileInfoStub[]
+    getFileNames(): FilePathWithPrefix[]
+
+    touched(file: UXFileInfoStub | FilePathWithPrefix): void
+    recentlyTouched(file: UXFileInfoStub | FilePathWithPrefix): boolean
+    clearTouched(): void
+
+    // -- Low-Level 
+    delete(file: FilePathWithPrefix | UXFileInfoStub | string, force: boolean): Promise<void>
+    trash(file: FilePathWithPrefix | UXFileInfoStub | string, system: boolean): Promise<void>
+
+    getFilesIncludeHidden(
+        basePath: string,
+        includeFilter?: RegExp[],
+        excludeFilter?: RegExp[],
+        skipFolder?: string[]
+    ): Promise<FilePath[]>;
+}

src/modules/modules.md

@@ -0,0 +1,45 @@
+# Dynamic Load Modules
+
+## Introduction
+
+Self-hosted LiveSync has gradually but steadily become very feature-rich and they have created a very heavy `Main` class. This is very difficult to understand and maintain especially new contributors or futures contributors.
+And some of the features are not used by all users, we should limit the inter-dependencies between modules. And also inter-effects between modules.
+Hence, to make the code more readable and maintainable, I decided to split the code into multiple modules.
+
+I also got a little greedy here, but I have an another objective now, which is to reduce the difficulty when porting to other platforms.
+
+Therefore, almost all feature of the plug-in can be implemented as a module. And the `Main` class will be responsible for loading these modules.
+
+## Modules
+
+### Sorts
+
+Modules can be sorted into two categories in some sorts:
+
+-   `CoreModule` and `ObsidianModule`
+-   `Core`, `Essential`, and `Feature` ... 
+
+### How it works
+
+After instancing `Core` and Modules, you should call `injectModules`. Then, the specific function will be injected into the stub of it of `Core` class by following rules:
+
+| Function prefix | Description                                                       |
+| --------------- | ----------------------------------------------------------------- |
+| `$$`            | Completely overridden functions.                                  |
+| `$all`          | Process all modules and return all results.                       |
+| `$every`        | Process all modules until the first failure.                      |
+| `$any`          | Process all modules until the first success.                      |
+| `$`             | Other interceptive points. You should manually assign the module. |
+
+Note1: `Core` class should implement the same function as the module. If not, the module will be ignored.
+
+And, basically, the Module has a `Core` class as `core` property. You should call any of inject functions by `this.core.$xxxxxx`. This rule is also applied to the function which implemented itself. Because some other modules possibly injects the function again, for the specific purpose.
+
+### CoreModule
+
+This Module is independent from Obsidian, and can be used in any platform. However, it can be call (or use) functions which has implemented in `ObsidianModule`.
+To porting, you should implement shim functions for `ObsidianModule`.
+
+### ObsidianModule
+
+(TBW)