diff --git a/src/common/utils.ts b/src/common/utils.ts
index 9282279..d0a687e 100644
--- a/src/common/utils.ts
+++ b/src/common/utils.ts
@@ -11,6 +11,8 @@ import {
 
 import { Logger } from "../lib/src/common/logger.ts";
 import {
+    LOG_LEVEL_INFO,
+    LOG_LEVEL_NOTICE,
     LOG_LEVEL_VERBOSE,
     type AnyEntry,
     type DocumentID,
@@ -25,15 +27,11 @@ import type ObsidianLiveSyncPlugin from "../main.ts";
 import { writeString } from "../lib/src/string_and_binary/convert.ts";
 import { fireAndForget } from "../lib/src/common/utils.ts";
 import { sameChangePairs } from "./stores.ts";
+import type { KeyValueDatabase } from "./KeyValueDB.ts";
+import { scheduleTask } from "octagonal-wheels/concurrency/task";
+import { EVENT_PLUGIN_UNLOADED, eventHub } from "./events.ts";
 
-export {
-    scheduleTask,
-    setPeriodicTask,
-    cancelTask,
-    cancelAllTasks,
-    cancelPeriodicTask,
-    cancelAllPeriodicTask,
-} from "../lib/src/concurrency/task.ts";
+export { scheduleTask, cancelTask, cancelAllTasks } from "../lib/src/concurrency/task.ts";
 
 // For backward compatibility, using the path for determining id.
 // Only CouchDB unacceptable ID (that starts with an underscore) has been prefixed with "/".
@@ -72,10 +70,25 @@ export function getPathWithoutPrefix(entry: AnyEntry) {
 export function getPathFromTFile(file: TAbstractFile) {
     return file.path as FilePath;
 }
+
+export function isInternalFile(file: UXFileInfoStub | string | FilePathWithPrefix) {
+    if (typeof file == "string") return file.startsWith(ICHeader);
+    if (file.isInternal) return true;
+    return false;
+}
 export function getPathFromUXFileInfo(file: UXFileInfoStub | string | FilePathWithPrefix) {
     if (typeof file == "string") return file as FilePathWithPrefix;
     return file.path;
 }
+export function getStoragePathFromUXFileInfo(file: UXFileInfoStub | string | FilePathWithPrefix) {
+    if (typeof file == "string") return stripAllPrefixes(file as FilePathWithPrefix);
+    return stripAllPrefixes(file.path);
+}
+export function getDatabasePathFromUXFileInfo(file: UXFileInfoStub | string | FilePathWithPrefix) {
+    const prefix = isInternalFile(file) ? ICHeader : "";
+    if (typeof file == "string") return (prefix + stripAllPrefixes(file as FilePathWithPrefix)) as FilePathWithPrefix;
+    return (prefix + stripAllPrefixes(file.path)) as FilePathWithPrefix;
+}
 
 const memos: { [key: string]: any } = {};
 export function memoObject<T>(key: string, obj: T): T {
@@ -148,11 +161,14 @@ export function isCustomisationSyncMetadata(str: string): boolean {
 
 export class PeriodicProcessor {
     _process: () => Promise<any>;
-    _timer?: number;
+    _timer?: number = undefined;
     _plugin: ObsidianLiveSyncPlugin;
     constructor(plugin: ObsidianLiveSyncPlugin, process: () => Promise<any>) {
         this._plugin = plugin;
         this._process = process;
+        eventHub.onceEvent(EVENT_PLUGIN_UNLOADED, () => {
+            this.disable();
+        });
     }
     async process() {
         try {
@@ -265,9 +281,14 @@ export function compareMTime(
     throw new Error("Unexpected error");
 }
 
+function getKey(file: AnyEntry | string | UXFileInfoStub) {
+    const key = typeof file == "string" ? file : stripAllPrefixes(file.path);
+    return key;
+}
+
 export function markChangesAreSame(file: AnyEntry | string | UXFileInfoStub, mtime1: number, mtime2: number) {
     if (mtime1 === mtime2) return true;
-    const key = typeof file == "string" ? file : "_id" in file ? file._id : file.path;
+    const key = getKey(file);
     const pairs = sameChangePairs.get(key, []) || [];
     if (pairs.some((e) => e == mtime1 || e == mtime2)) {
         sameChangePairs.set(key, [...new Set([...pairs, mtime1, mtime2])]);
@@ -275,8 +296,13 @@ export function markChangesAreSame(file: AnyEntry | string | UXFileInfoStub, mti
         sameChangePairs.set(key, [mtime1, mtime2]);
     }
 }
+
+export function unmarkChanges(file: AnyEntry | string | UXFileInfoStub) {
+    const key = getKey(file);
+    sameChangePairs.delete(key);
+}
 export function isMarkedAsSameChanges(file: UXFileInfoStub | AnyEntry | string, mtimes: number[]) {
-    const key = typeof file == "string" ? file : "_id" in file ? file._id : file.path;
+    const key = getKey(file);
     const pairs = sameChangePairs.get(key, []) || [];
     if (mtimes.every((e) => pairs.indexOf(e) !== -1)) {
         return EVEN;
@@ -374,6 +400,95 @@ export function displayRev(rev: string) {
     return `${number}-${hash.substring(0, 6)}`;
 }
 
-// export function getPathFromUXFileInfo(file: UXFileInfoStub | UXFileInfo | string) {
-//     return (typeof file == "string" ? file : file.path) as FilePathWithPrefix;
-// }
+type DocumentProps = {
+    id: DocumentID;
+    rev?: string;
+    prefixedPath: FilePathWithPrefix;
+    path: FilePath;
+    isDeleted: boolean;
+    revDisplay: string;
+    shortenedId: string;
+    shortenedPath: string;
+};
+
+export function getDocProps(doc: AnyEntry): DocumentProps {
+    const id = doc._id;
+    const shortenedId = id.substring(0, 10);
+    const prefixedPath = getPath(doc);
+    const path = stripAllPrefixes(prefixedPath);
+    const rev = doc._rev;
+    const revDisplay = rev ? displayRev(rev) : "0-NOREVS";
+    // const prefix = prefixedPath.substring(0, prefixedPath.length - path.length);
+    const shortenedPath = path.substring(0, 10);
+    const isDeleted = doc._deleted || doc.deleted || false;
+    return { id, rev, revDisplay, prefixedPath, path, isDeleted, shortenedId, shortenedPath };
+}
+
+export function getLogLevel(showNotice: boolean) {
+    return showNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+}
+
+export type MapLike<K, V> = {
+    set(key: K, value: V): Map<K, V>;
+    clear(): void;
+    delete(key: K): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    keys: () => IterableIterator<K>;
+    get size(): number;
+};
+
+export async function autosaveCache<K, V>(db: KeyValueDatabase, mapKey: string): Promise<MapLike<K, V>> {
+    const savedData = (await db.get<Map<K, V>>(mapKey)) ?? new Map<K, V>();
+    const _commit = () => {
+        try {
+            scheduleTask("commit-map-save-" + mapKey, 250, async () => {
+                await db.set(mapKey, savedData);
+            });
+        } catch {
+            // NO OP.
+        }
+    };
+    return {
+        set(key: K, value: V) {
+            const modified = savedData.get(key) !== value;
+            const result = savedData.set(key, value);
+            if (modified) {
+                _commit();
+            }
+            return result;
+        },
+        clear(): void {
+            savedData.clear();
+            _commit();
+        },
+        delete(key: K): boolean {
+            const result = savedData.delete(key);
+            if (result) {
+                _commit();
+            }
+            return result;
+        },
+        get(key: K): V | undefined {
+            return savedData.get(key);
+        },
+        has(key) {
+            return savedData.has(key);
+        },
+        keys() {
+            return savedData.keys();
+        },
+        get size() {
+            return savedData.size;
+        },
+    };
+}
+
+export function onlyInNTimes(n: number, proc: (progress: number) => any) {
+    let counter = 0;
+    return function () {
+        if (counter++ % n == 0) {
+            proc(counter);
+        }
+    };
+}
diff --git a/src/features/ConfigSync/PluginPane.svelte b/src/features/ConfigSync/PluginPane.svelte
index 32ca84c..6ed27cb 100644
--- a/src/features/ConfigSync/PluginPane.svelte
+++ b/src/features/ConfigSync/PluginPane.svelte
@@ -1,11 +1,24 @@
 <script lang="ts">
     import { onMount } from "svelte";
     import ObsidianLiveSyncPlugin from "../../main";
-    import { ConfigSync, type IPluginDataExDisplay, pluginIsEnumerating, pluginList, pluginManifestStore, pluginV2Progress } from "./CmdConfigSync.ts";
+    import {
+        ConfigSync,
+        type IPluginDataExDisplay,
+        pluginIsEnumerating,
+        pluginList,
+        pluginManifestStore,
+        pluginV2Progress,
+    } from "./CmdConfigSync.ts";
     import PluginCombo from "./PluginCombo.svelte";
     import { Menu, type PluginManifest } from "obsidian";
     import { unique } from "../../lib/src/common/utils";
-    import { MODE_SELECTIVE, MODE_AUTOMATIC, MODE_PAUSED, type SYNC_MODE, type PluginSyncSettingEntry, MODE_SHINY } from "../../lib/src/common/types";
+    import {
+        MODE_SELECTIVE,
+        MODE_AUTOMATIC,
+        MODE_PAUSED,
+        type SYNC_MODE,
+        MODE_SHINY,
+    } from "../../lib/src/common/types";
     import { normalizePath } from "../../deps";
     import { HiddenFileSync } from "../HiddenFileSync/CmdHiddenFileSync.ts";
     import { LOG_LEVEL_NOTICE, Logger } from "octagonal-wheels/common/logger";
@@ -16,13 +29,15 @@
 
     const addOn = plugin.getAddOn(ConfigSync.name) as ConfigSync;
     if (!addOn) {
-        const msg = "AddOn Module (ConfigSync) has not been loaded. This is very unexpected situation. Please report this issue.";
+        const msg =
+            "AddOn Module (ConfigSync) has not been loaded. This is very unexpected situation. Please report this issue.";
         Logger(msg, LOG_LEVEL_NOTICE);
         throw new Error(msg);
     }
     const addOnHiddenFileSync = plugin.getAddOn(HiddenFileSync.name) as HiddenFileSync;
     if (!addOnHiddenFileSync) {
-        const msg = "AddOn Module (HiddenFileSync) has not been loaded. This is very unexpected situation. Please report this issue.";
+        const msg =
+            "AddOn Module (HiddenFileSync) has not been loaded. This is very unexpected situation. Please report this issue.";
         Logger(msg, LOG_LEVEL_NOTICE);
         throw new Error(msg);
     }
@@ -99,7 +114,11 @@
     async function applyData(data: IPluginDataExDisplay): Promise<boolean> {
         return await addOn.applyData(data);
     }
-    async function compareData(docA: IPluginDataExDisplay, docB: IPluginDataExDisplay, compareEach = false): Promise<boolean> {
+    async function compareData(
+        docA: IPluginDataExDisplay,
+        docB: IPluginDataExDisplay,
+        compareEach = false
+    ): Promise<boolean> {
         return await addOn.compareUsingDisplayData(docA, docB, compareEach);
     }
     async function deleteData(data: IPluginDataExDisplay): Promise<boolean> {
@@ -130,7 +149,7 @@
         setMode(key, MODE_AUTOMATIC);
         const configDir = normalizePath(plugin.app.vault.configDir);
         const files = (plugin.settings.pluginSyncExtendedSetting[key]?.files ?? []).map((e) => `${configDir}/${e}`);
-        addOnHiddenFileSync.syncInternalFilesAndDatabase(direction, true, false, files);
+        addOnHiddenFileSync.initialiseInternalFileSync(direction, true, files);
     }
     function askOverwriteModeForAutomatic(evt: MouseEvent, key: string) {
         const menu = new Menu();
@@ -199,7 +218,7 @@
                 .filter((e) => `${e.category}/${e.name}` == key)
                 .map((e) => e.files)
                 .flat()
-                .map((e) => e.filename),
+                .map((e) => e.filename)
         );
         if (mode == MODE_SELECTIVE) {
             automaticList.delete(key);
@@ -249,7 +268,15 @@
                 .map((e) => ({ category: e[0], name: e[1], displayName: e[1] })),
         ]
             .sort((a, b) => (a.displayName ?? a.name).localeCompare(b.displayName ?? b.name))
-            .reduce((p, c) => ({ ...p, [c.category]: unique(c.category in p ? [...p[c.category], c.displayName ?? c.name] : [c.displayName ?? c.name]) }), {} as Record<string, string[]>);
+            .reduce(
+                (p, c) => ({
+                    ...p,
+                    [c.category]: unique(
+                        c.category in p ? [...p[c.category], c.displayName ?? c.name] : [c.displayName ?? c.name]
+                    ),
+                }),
+                {} as Record<string, string[]>
+            );
     }
     $: {
         displayKeys = computeDisplayKeys(list);
@@ -337,7 +364,12 @@
                         </div>
                         <div class="body">
                             {#if mode == MODE_SELECTIVE || mode == MODE_SHINY}
-                                <PluginCombo {...options} isFlagged={mode == MODE_SHINY} list={list.filter((e) => e.category == key && e.name == name)} hidden={false} />
+                                <PluginCombo
+                                    {...options}
+                                    isFlagged={mode == MODE_SHINY}
+                                    list={list.filter((e) => e.category == key && e.name == name)}
+                                    hidden={false}
+                                />
                             {:else}
                                 <div class="statusnote">{TITLES[mode]}</div>
                             {/if}
@@ -359,7 +391,10 @@
                 {@const modeEtc = automaticListDisp.get(bindKeyETC) ?? MODE_SELECTIVE}
                 <div class="labelrow {hideEven ? 'hideeven' : ''}">
                     <div class="title">
-                        <button class="status" on:click={(evt) => askMode(evt, `${PREFIX_PLUGIN_ALL}/${name}`, bindKeyAll)}>
+                        <button
+                            class="status"
+                            on:click={(evt) => askMode(evt, `${PREFIX_PLUGIN_ALL}/${name}`, bindKeyAll)}
+                        >
                             {getIcon(modeAll)}
                         </button>
                         <span class="name">{nameMap.get(`plugins/${name}`) || name}</span>
@@ -373,14 +408,22 @@
                 {#if modeAll == MODE_SELECTIVE || modeAll == MODE_SHINY}
                     <div class="filerow {hideEven ? 'hideeven' : ''}">
                         <div class="filetitle">
-                            <button class="status" on:click={(evt) => askMode(evt, `${PREFIX_PLUGIN_MAIN}/${name}/MAIN`, bindKeyMain)}>
+                            <button
+                                class="status"
+                                on:click={(evt) => askMode(evt, `${PREFIX_PLUGIN_MAIN}/${name}/MAIN`, bindKeyMain)}
+                            >
                                 {getIcon(modeMain)}
                             </button>
                             <span class="name">MAIN</span>
                         </div>
                         <div class="body">
                             {#if modeMain == MODE_SELECTIVE || modeMain == MODE_SHINY}
-                                <PluginCombo {...options} isFlagged={modeMain == MODE_SHINY} list={filterList(listX, ["PLUGIN_MAIN"])} hidden={false} />
+                                <PluginCombo
+                                    {...options}
+                                    isFlagged={modeMain == MODE_SHINY}
+                                    list={filterList(listX, ["PLUGIN_MAIN"])}
+                                    hidden={false}
+                                />
                             {:else}
                                 <div class="statusnote">{TITLES[modeMain]}</div>
                             {/if}
@@ -388,14 +431,22 @@
                     </div>
                     <div class="filerow {hideEven ? 'hideeven' : ''}">
                         <div class="filetitle">
-                            <button class="status" on:click={(evt) => askMode(evt, `${PREFIX_PLUGIN_DATA}/${name}`, bindKeyData)}>
+                            <button
+                                class="status"
+                                on:click={(evt) => askMode(evt, `${PREFIX_PLUGIN_DATA}/${name}`, bindKeyData)}
+                            >
                                 {getIcon(modeData)}
                             </button>
                             <span class="name">DATA</span>
                         </div>
                         <div class="body">
                             {#if modeData == MODE_SELECTIVE || modeData == MODE_SHINY}
-                                <PluginCombo {...options} isFlagged={modeData == MODE_SHINY} list={filterList(listX, ["PLUGIN_DATA"])} hidden={false} />
+                                <PluginCombo
+                                    {...options}
+                                    isFlagged={modeData == MODE_SHINY}
+                                    list={filterList(listX, ["PLUGIN_DATA"])}
+                                    hidden={false}
+                                />
                             {:else}
                                 <div class="statusnote">{TITLES[modeData]}</div>
                             {/if}
@@ -404,14 +455,22 @@
                     {#if useSyncPluginEtc}
                         <div class="filerow {hideEven ? 'hideeven' : ''}">
                             <div class="filetitle">
-                                <button class="status" on:click={(evt) => askMode(evt, `${PREFIX_PLUGIN_ETC}/${name}`, bindKeyETC)}>
+                                <button
+                                    class="status"
+                                    on:click={(evt) => askMode(evt, `${PREFIX_PLUGIN_ETC}/${name}`, bindKeyETC)}
+                                >
                                     {getIcon(modeEtc)}
                                 </button>
                                 <span class="name">Other files</span>
                             </div>
                             <div class="body">
                                 {#if modeEtc == MODE_SELECTIVE || modeEtc == MODE_SHINY}
-                                    <PluginCombo {...options} isFlagged={modeEtc == MODE_SHINY} list={filterList(listX, ["PLUGIN_ETC"])} hidden={false} />
+                                    <PluginCombo
+                                        {...options}
+                                        isFlagged={modeEtc == MODE_SHINY}
+                                        list={filterList(listX, ["PLUGIN_ETC"])}
+                                        hidden={false}
+                                    />
                                 {:else}
                                     <div class="statusnote">{TITLES[modeEtc]}</div>
                                 {/if}
diff --git a/src/features/HiddenFileSync/CmdHiddenFileSync.ts b/src/features/HiddenFileSync/CmdHiddenFileSync.ts
index 539e5f5..70dc1ba 100644
--- a/src/features/HiddenFileSync/CmdHiddenFileSync.ts
+++ b/src/features/HiddenFileSync/CmdHiddenFileSync.ts
@@ -1,8 +1,6 @@
 import { normalizePath, type PluginManifest, type ListedFiles } from "../../deps.ts";
 import {
-    type EntryDoc,
     type LoadedEntry,
-    type InternalFileEntry,
     type FilePathWithPrefix,
     type FilePath,
     LOG_LEVEL_INFO,
@@ -12,9 +10,12 @@ import {
     MODE_PAUSED,
     type SavingEntry,
     type DocumentID,
-    type UXStat,
-    MODE_AUTOMATIC,
     type FilePathWithPrefixLC,
+    type UXFileInfo,
+    type UXStat,
+    LOG_LEVEL_DEBUG,
+    type MetaEntry,
+    type UXDataWriteOptions,
 } from "../../lib/src/common/types.ts";
 import { type InternalFileInfo, ICHeader, ICHeaderEnd } from "../../common/types.ts";
 import {
@@ -26,17 +27,23 @@ import {
     fireAndForget,
 } from "../../lib/src/common/utils.ts";
 import {
-    BASE_IS_NEW,
     compareMTime,
-    EVEN,
+    unmarkChanges,
     getPath,
     isInternalMetadata,
-    isMarkedAsSameChanges,
     markChangesAreSame,
     PeriodicProcessor,
     TARGET_IS_NEW,
+    scheduleTask,
+    getDocProps,
+    getLogLevel,
+    autosaveCache,
+    type MapLike,
+    onlyInNTimes,
+    BASE_IS_NEW,
+    EVEN,
 } from "../../common/utils.ts";
-import { serialized } from "../../lib/src/concurrency/lock.ts";
+import { serialized, skipIfDuplicated } from "../../lib/src/concurrency/lock.ts";
 import { JsonResolveModal } from "../HiddenFileCommon/JsonResolveModal.ts";
 import { LiveSyncCommands } from "../LiveSyncCommands.ts";
 import { addPrefix, stripAllPrefixes } from "../../lib/src/string_and_binary/path.ts";
@@ -44,6 +51,24 @@ import { QueueProcessor } from "../../lib/src/concurrency/processor.ts";
 import { hiddenFilesEventCount, hiddenFilesProcessingCount } from "../../lib/src/mock_and_interop/stores.ts";
 import type { IObsidianModule } from "../../modules/AbstractObsidianModule.ts";
 import { EVENT_SETTING_SAVED, eventHub } from "../../common/events.ts";
+import type { LiveSyncLocalDB } from "../../lib/src/pouchdb/LiveSyncLocalDB.ts";
+import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
+type SyncDirection = "push" | "pull" | "safe" | "pullForce" | "pushForce";
+
+function getComparingMTime(
+    doc: (MetaEntry | LoadedEntry | false) | UXFileInfo | UXStat | null | undefined,
+    includeDeleted = false
+) {
+    if (doc === null) return 0;
+    if (doc === false) return 0;
+    if (doc === undefined) return 0;
+    if (!includeDeleted) {
+        if ("deleted" in doc && doc.deleted) return 0;
+        if ("_deleted" in doc && doc._deleted) return 0;
+    }
+    if ("stat" in doc) return doc.stat?.mtime ?? 0;
+    return doc.mtime ?? 0;
+}
 
 export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule {
     _isThisModuleEnabled() {
@@ -52,10 +77,7 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
 
     periodicInternalFileScanProcessor: PeriodicProcessor = new PeriodicProcessor(
         this.plugin,
-        async () =>
-            this._isThisModuleEnabled() &&
-            this._isDatabaseReady() &&
-            (await this.syncInternalFilesAndDatabase("push", false))
+        async () => this._isThisModuleEnabled() && this._isDatabaseReady() && (await this.scanAllStorageChanges(false))
     );
 
     get kvDB() {
@@ -69,26 +91,58 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
     }
     onload() {
         this.plugin.addCommand({
-            id: "livesync-scaninternal",
-            name: "Sync hidden files",
+            id: "livesync-sync-internal",
+            name: "(re)initialise hidden files between storage and database",
             callback: () => {
-                void this.syncInternalFilesAndDatabase("safe", true);
+                if (this.isReady()) {
+                    void this.initialiseInternalFileSync("safe", true);
+                }
+            },
+        });
+        this.plugin.addCommand({
+            id: "livesync-scaninternal-storage",
+            name: "Scan hidden file changes on the storage",
+            callback: () => {
+                if (this.isReady()) {
+                    void this.scanAllStorageChanges(true);
+                }
+            },
+        });
+        this.plugin.addCommand({
+            id: "livesync-scaninternal-database",
+            name: "Scan hidden file changes on the local database",
+            callback: () => {
+                if (this.isReady()) {
+                    void this.scanAllDatabaseChanges(true);
+                }
+            },
+        });
+        this.plugin.addCommand({
+            id: "livesync-internal-scan-offline-changes",
+            name: "Scan and apply all offline hidden-file changes",
+            callback: () => {
+                if (this.isReady()) {
+                    void this.applyOfflineChanges(true);
+                }
             },
         });
         eventHub.onEvent(EVENT_SETTING_SAVED, () => {
             this.updateSettingCache();
         });
     }
+    async $everyOnInitializeDatabase(db: LiveSyncLocalDB): Promise<boolean> {
+        this._fileInfoLastProcessed = await autosaveCache(this.kvDB, "hidden-file-lastProcessed");
+        this._databaseInfoLastProcessed = await autosaveCache(this.kvDB, "hidden-file-lastProcessed-database");
+        this._fileInfoLastKnown = await autosaveCache(this.kvDB, "hidden-file-lastKnown");
+        return true;
+    }
     async $everyOnDatabaseInitialized(showNotice: boolean) {
-        this.knownChanges = (await this.plugin.kvDB.get("knownChanges")) ?? {};
         if (this._isThisModuleEnabled()) {
-            try {
-                this._log("Synchronizing hidden files...");
-                await this.syncInternalFilesAndDatabase("push", showNotice);
-                this._log("Synchronizing hidden files done");
-            } catch (ex) {
-                this._log("Synchronizing hidden files failed");
-                this._log(ex, LOG_LEVEL_VERBOSE);
+            if (this._fileInfoLastProcessed.size == 0 && this._fileInfoLastProcessed.size == 0) {
+                this._log(`No cache found. Performing startup scan.`, LOG_LEVEL_VERBOSE);
+                await this.performStartupScan(true);
+            } else {
+                await this.performStartupScan(showNotice);
             }
         }
         return true;
@@ -100,7 +154,7 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
             this.settings.syncInternalFilesBeforeReplication &&
             !this.settings.watchInternalFileChanges
         ) {
-            await this.syncInternalFilesAndDatabase("push", showNotice);
+            await this.scanAllStorageChanges();
         }
         return true;
     }
@@ -129,13 +183,24 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
         this.shouldSkipFile = shouldSKip as FilePathWithPrefixLC[];
         this._log(`Hidden file will skip ${this.shouldSkipFile.length} files`, LOG_LEVEL_INFO);
     }
+
+    isReady() {
+        if (!this._isMainReady) return false;
+        if (this._isMainSuspended()) return false;
+        if (!this._isThisModuleEnabled()) return false;
+        return true;
+    }
     shouldSkipFile = [] as FilePathWithPrefixLC[];
 
+    async performStartupScan(showNotice: boolean) {
+        await this.applyOfflineChanges(showNotice);
+    }
+
     async $everyOnResumeProcess(): Promise<boolean> {
         this.periodicInternalFileScanProcessor?.disable();
         if (this._isMainSuspended()) return true;
         if (this._isThisModuleEnabled()) {
-            await this.syncInternalFilesAndDatabase("safe", false);
+            await this.performStartupScan(false);
         }
         this.periodicInternalFileScanProcessor.enable(
             this._isThisModuleEnabled() && this.settings.syncInternalFilesInterval
@@ -163,76 +228,396 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
         return Promise.resolve(true);
     }
 
-    procInternalFile(filename: string) {
-        this.internalFileProcessor.enqueue(filename);
-    }
-    internalFileProcessor = new QueueProcessor<string, any>(
-        async (filenames) => {
-            this._log(`START :Applying hidden ${filenames.length} files change`, LOG_LEVEL_VERBOSE);
-            await this.syncInternalFilesAndDatabase("pull", false, false, filenames);
-            this._log(`DONE  :Applying hidden ${filenames.length} files change`, LOG_LEVEL_VERBOSE);
-            return;
-        },
-        {
-            batchSize: 100,
-            concurrentLimit: 1,
-            delay: 10,
-            yieldThreshold: 100,
-            suspended: false,
-            totalRemainingReactiveSource: hiddenFilesEventCount,
-        }
-    );
-
     async $anyProcessOptionalFileEvent(path: FilePath): Promise<boolean | undefined> {
-        return await this.watchVaultRawEventsAsync(path);
+        if (this.isReady()) {
+            return await this.trackStorageFileModification(path);
+        }
     }
-    async watchVaultRawEventsAsync(path: FilePath): Promise<boolean | undefined> {
-        if (!this._isMainReady) return false;
-        if (this._isMainSuspended()) return false;
-        if (!this._isThisModuleEnabled()) return false;
 
+    $anyGetOptionalConflictCheckMethod(path: FilePathWithPrefix): Promise<boolean | "newer"> {
+        if (isInternalMetadata(path)) {
+            this.queueConflictCheck(path);
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+    }
+
+    async $anyProcessOptionalSyncFiles(doc: LoadedEntry): Promise<boolean | undefined> {
+        if (isInternalMetadata(doc._id)) {
+            if (this._isThisModuleEnabled()) {
+                //system file
+                const filename = getPath(doc);
+                if (await this.plugin.$$isTargetFile(filename)) {
+                    // this.procInternalFile(filename);
+                    await this.processReplicationResult(doc);
+                    return true;
+                } else {
+                    this._log(`Skipped (Not target:${filename})`, LOG_LEVEL_VERBOSE);
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    async loadFileWithInfo(path: FilePath): Promise<UXFileInfo> {
+        const stat = await this.plugin.storageAccess.statHidden(path);
+        if (!stat)
+            return {
+                name: path.split("/").pop() ?? "",
+                path,
+                stat: {
+                    size: 0,
+                    mtime: 0,
+                    ctime: 0,
+                    type: "file",
+                },
+                isInternal: true,
+                deleted: true,
+                body: createBlob(new Uint8Array(0)),
+            };
+        const content = await this.plugin.storageAccess.readHiddenFileAuto(path);
+        return {
+            name: path.split("/").pop() ?? "",
+            path,
+            stat,
+            isInternal: true,
+            deleted: false,
+            body: createBlob(content),
+        };
+    }
+
+    _fileInfoLastProcessed!: MapLike<string, string>;
+    _fileInfoLastKnown!: MapLike<string, number>;
+    _databaseInfoLastProcessed!: MapLike<string, string>;
+
+    statToKey(stat: UXStat | null) {
+        return `${stat?.mtime ?? 0}-${stat?.size ?? 0}`;
+    }
+    docToKey(doc: LoadedEntry | MetaEntry) {
+        return `${doc.mtime}-${doc.size}-${doc._rev}-${doc._deleted || doc.deleted || false ? "-0" : "-1"}`;
+    }
+    async fileToStatKey(file: FilePath, stat: UXStat | null = null) {
+        if (!stat) stat = await this.plugin.storageAccess.statHidden(file);
+        return this.statToKey(stat);
+    }
+
+    updateLastProcessedFile(file: FilePath, keySrc: string | UXStat) {
+        const key = typeof keySrc == "string" ? keySrc : this.statToKey(keySrc);
+        const splitted = key.split("-");
+        if (splitted[0] != "0") {
+            this._fileInfoLastKnown.set(file, Number(splitted[0]));
+        }
+        this._fileInfoLastProcessed.set(file, key);
+    }
+
+    async updateLastProcessedAsActualFile(file: FilePath, stat?: UXStat | null | undefined) {
+        if (!stat) stat = await this.plugin.storageAccess.statHidden(file);
+        this._fileInfoLastProcessed.set(file, this.statToKey(stat));
+    }
+
+    resetLastProcessedFile(targetFiles: FilePath[] | false) {
+        if (targetFiles) {
+            for (const key of targetFiles) {
+                this._fileInfoLastProcessed.delete(key);
+            }
+        } else {
+            this._log(`Delete all processed mark.`, LOG_LEVEL_VERBOSE);
+            // THINKING: Should we...
+            // - delete all `Known file` processed mark? (This is current implementation)
+            // - delete all `Existing file` processed mark?
+            // - delete all files inside the config folder of current device mark?
+            this._fileInfoLastProcessed.clear();
+        }
+    }
+
+    getLastProcessedFileMTime(file: FilePath) {
+        const key = this._fileInfoLastKnown.get(file);
+        if (!key) return 0;
+        return key;
+    }
+
+    getLastProcessedFileKey(file: FilePath) {
+        return this._fileInfoLastProcessed.get(file);
+    }
+
+    getLastProcessedDatabaseKey(file: FilePath) {
+        return this._databaseInfoLastProcessed.get(file);
+    }
+    updateLastProcessedDatabase(file: FilePath, keySrc: string | MetaEntry | LoadedEntry) {
+        const key = typeof keySrc == "string" ? keySrc : this.docToKey(keySrc);
+        this._databaseInfoLastProcessed.set(file, key);
+    }
+    updateLastProcessed(path: FilePath, db: MetaEntry | LoadedEntry, stat: UXStat) {
+        this.updateLastProcessedDatabase(path, db);
+        this.updateLastProcessedFile(path, this.statToKey(stat));
+        const dbMTime = getComparingMTime(db);
+        const storageMTime = getComparingMTime(stat);
+        if (dbMTime == 0 || storageMTime == 0) {
+            unmarkChanges(path);
+        } else {
+            markChangesAreSame(path, getComparingMTime(db), getComparingMTime(stat));
+        }
+    }
+    updateLastProcessedDeletion(path: FilePath, db: MetaEntry | LoadedEntry | false) {
+        unmarkChanges(path);
+        if (db) this.updateLastProcessedDatabase(path, db);
+        this.updateLastProcessedFile(path, this.statToKey(null));
+    }
+    async ensureDir(path: FilePath) {
+        const isExists = await this.plugin.storageAccess.isExistsIncludeHidden(path);
+        if (!isExists) {
+            await this.plugin.storageAccess.ensureDir(path);
+        }
+    }
+
+    async writeFile(path: FilePath, data: string | ArrayBuffer, opt?: UXDataWriteOptions): Promise<UXStat | null> {
+        await this.plugin.storageAccess.writeHiddenFileAuto(path, data, opt);
+        const stat = await this.plugin.storageAccess.statHidden(path);
+        // this.updateLastProcessedFile(path, this.statToKey(stat));
+        return stat;
+    }
+
+    async __removeFile(path: FilePath): Promise<"OK" | "ALREADY" | false> {
+        try {
+            if (!(await this.plugin.storageAccess.isExistsIncludeHidden(path))) {
+                // Already deleted
+                // this.updateLastProcessedFile(path, this.statToKey(null));
+                return "ALREADY";
+            }
+            if (await this.plugin.storageAccess.removeHidden(path)) {
+                // this.updateLastProcessedFile(path, this.statToKey(null));
+                return "OK";
+            }
+        } catch (ex) {
+            this._log(`Failed to remove file:${path}`);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+        return false;
+    }
+    async triggerEvent(path: FilePath) {
+        try {
+            // await this.app.vault.adapter.reconcileInternalFile(filename);
+            await this.plugin.storageAccess.triggerHiddenFile(path);
+        } catch (ex) {
+            this._log("Failed to call internal API(reconcileInternalFile)", LOG_LEVEL_VERBOSE);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+    }
+
+    async updateLastProcessedAsActualDatabase(
+        file: FilePath,
+        doc?: MetaEntry | LoadedEntry | null | undefined | false
+    ) {
+        const dbPath = addPrefix(file, ICHeader);
+        if (!doc) doc = await this.localDatabase.getDBEntryMeta(dbPath);
+        if (!doc) return;
+        this._databaseInfoLastProcessed.set(file, this.docToKey(doc));
+    }
+
+    resetLastProcessedDatabase(targetFiles: FilePath[] | false) {
+        if (targetFiles) {
+            for (const key of targetFiles) {
+                this._databaseInfoLastProcessed.delete(key);
+            }
+        } else {
+            this._log(`Delete all processed mark.`, LOG_LEVEL_VERBOSE);
+            // THINKING: Should we...
+            // - delete all `Known file` processed mark? (This is current implementation)
+            // - delete all `Existing file` processed mark?
+            // - delete all files inside the config folder of current device mark?
+            this._databaseInfoLastProcessed.clear();
+        }
+    }
+
+    async adoptCurrentStorageFilesAsProcessed(targetFiles: FilePath[] | false) {
+        const allFiles = await this.scanInternalFileNames();
+        const files = targetFiles ? allFiles.filter((e) => targetFiles.some((t) => e.indexOf(t) !== -1)) : allFiles;
+        for (const file of files) {
+            await this.updateLastProcessedAsActualFile(file);
+        }
+    }
+    async adoptCurrentDatabaseFilesAsProcessed(targetFiles: FilePath[] | false) {
+        const allFiles = await this.getAllDatabaseFiles();
+        const files = targetFiles
+            ? allFiles.filter((e) => targetFiles.some((t) => e.path.indexOf(t) !== -1))
+            : allFiles;
+        for (const file of files) {
+            const path = stripAllPrefixes(this.getPath(file));
+            await this.updateLastProcessedAsActualDatabase(path, file);
+        }
+    }
+
+    semaphore = Semaphore(10);
+    async serializedForEvent<T>(file: FilePath, fn: () => Promise<T>) {
+        hiddenFilesEventCount.value++;
+        const rel = await this.semaphore.acquire();
+        try {
+            return await serialized(`hidden-file-event:${file}`, async () => {
+                hiddenFilesProcessingCount.value++;
+                try {
+                    return await fn();
+                } finally {
+                    hiddenFilesProcessingCount.value--;
+                }
+            });
+        } finally {
+            rel();
+            hiddenFilesEventCount.value--;
+        }
+    }
+
+    async useStorageFiles(files: FilePath[], showNotice = false, onlyNew = false) {
+        return await this.trackScannedStorageChanges(files, showNotice, onlyNew, true);
+    }
+
+    async trackScannedStorageChanges(
+        processFiles: FilePath[],
+        showNotice: boolean = false,
+        onlyNew = false,
+        forceWriteAll = false,
+        includeDeleted = true
+    ) {
+        const logLevel = getLogLevel(showNotice);
+        const p = this._progress(`[⚙ Storage -> DB ]\n`, logLevel);
+        const notifyProgress = onlyInNTimes(100, (progress) => p.log(`${progress}/${processFiles.length}`));
+        const processes = processFiles.map(async (file, i) => {
+            try {
+                await this.trackStorageFileModification(file, onlyNew, forceWriteAll, includeDeleted);
+                notifyProgress();
+            } catch (ex) {
+                p.once(`Failed to process storage change file:${file}`);
+                this._log(ex, LOG_LEVEL_VERBOSE);
+            }
+        });
+        await Promise.all(processes);
+        p.done();
+    }
+    async scanAllStorageChanges(
+        showNotice: boolean = false,
+        onlyNew = false,
+        forceWriteAll = false,
+        includeDeleted = true
+    ) {
+        return await skipIfDuplicated("scanAllStorageChanges", async () => {
+            const logLevel = getLogLevel(showNotice);
+            const p = this._progress(`[⚙ Scanning Storage -> DB ]\n`, logLevel);
+            p.log(`Scanning storage files...`);
+            const knownNames = [...this._fileInfoLastProcessed.keys()] as FilePath[];
+            const existNames = await this.scanInternalFileNames();
+            const files = new Set([...knownNames, ...existNames]);
+
+            this._log(
+                `Known/Exist ${knownNames.length}/${existNames.length}, Totally ${files.size} files.`,
+                LOG_LEVEL_VERBOSE
+            );
+            const taskNameAndMeta = [...files].map(
+                async (e) => [e, await this.plugin.storageAccess.statHidden(e)] as const
+            );
+            const nameAndMeta = await Promise.all(taskNameAndMeta);
+            const processFiles = nameAndMeta
+                .filter(([path, stat]) => {
+                    if (forceWriteAll) return true;
+                    const key = this.getLastProcessedFileKey(path);
+                    const newKey = this.statToKey(stat);
+                    return key != newKey;
+                })
+                .map(([path, stat]) => path);
+
+            const staticsMessage = `[Storage hidden file statics]
+Known files: ${knownNames.length}
+Actual files: ${existNames.length}
+All files: ${files.size}
+Offline Changed files: ${processFiles.length}`;
+            // this._log(staticsMessage, logLevel, "scan-changes");
+            p.once(staticsMessage);
+            await this.trackScannedStorageChanges(processFiles, showNotice, onlyNew, forceWriteAll, includeDeleted);
+            p.done();
+        });
+    }
+
+    /**
+     * check the file is changed or not, and if changed, process it.
+     */
+    async trackStorageFileModification(
+        path: FilePath,
+        onlyNew = false,
+        forceWrite = false,
+        includeDeleted = true
+    ): Promise<boolean | undefined> {
         if (this.shouldSkipFile.some((e) => e.startsWith(path.toLowerCase()))) {
             this._log(`Hidden file skipped: ${path} is synchronized in customization sync.`, LOG_LEVEL_VERBOSE);
             return false;
         }
-
-        const stat = await this.plugin.storageAccess.statHidden(path);
-        // sometimes folder is coming.
-        if (stat != null && stat.type != "file") {
-            return false;
-        }
-
-        if (this.isKnownChange(path, stat?.mtime ?? 0)) {
-            // This could be caused by self. so return true to prevent further processing.
-            return true;
-        }
-        const mtime = stat == null ? 0 : (stat?.mtime ?? 0);
-        const storageMTime = ~~(mtime / 1000);
-
-        const prefixedFileName = addPrefix(path, ICHeader);
-        const filesOnDB = await this.localDatabase.getDBEntryMeta(prefixedFileName);
-        const dbMTime = ~~(((filesOnDB && filesOnDB.mtime) || 0) / 1000);
-
-        // Skip unchanged file.
-        if (dbMTime == storageMTime) {
-            // this._log(`STORAGE --> DB:${path}: (hidden) Nothing changed`);
-            // Handled, but nothing changed. also return true to prevent further processing.
-            return true;
-        }
-
         try {
-            if (storageMTime == 0) {
-                await this.deleteInternalFileOnDatabase(path);
-            } else {
-                await this.storeInternalFileToDatabase({
-                    path: path,
-                    mtime,
-                    ctime: stat?.ctime ?? mtime,
-                    size: stat?.size ?? 0,
-                });
-            }
-            // Surely processed.
-            return true;
+            return await this.serializedForEvent(path, async () => {
+                let stat = await this.plugin.storageAccess.statHidden(path);
+                // sometimes folder is coming.
+                if (stat != null && stat.type != "file") {
+                    return false;
+                }
+                const key = await this.fileToStatKey(path, stat);
+                // At here, we need to check to not to respond the same event.
+                // (a raw event occurs even at the file reading).
+                // This is only for the events. Not for scanning. Because of the scan is for not to miss any changes.
+                // Mostly all of before scanning, we should processed the files at the event.
+                const lastKey = this.getLastProcessedFileKey(path);
+                if (lastKey == key) {
+                    this._log(`${path} Already processed.`, LOG_LEVEL_DEBUG);
+                    return true;
+                }
+                // We should cache the file
+                const cache = await this.loadFileWithInfo(path);
+                const cacheMTime = getComparingMTime(cache.stat);
+                const statMtime = getComparingMTime(stat);
+                if (cacheMTime != statMtime) {
+                    this._log(`Hidden file:${path} is changed.`, LOG_LEVEL_VERBOSE);
+                    stat = cache.stat;
+                }
+                this.updateLastProcessedFile(path, stat!);
+                const lastIsNotFound = !lastKey || lastKey.endsWith("-0-0");
+                const nowIsNotFound = cache.deleted;
+                const type = lastIsNotFound && nowIsNotFound ? "invalid" : nowIsNotFound ? "delete" : "modified";
+
+                if (type == "invalid") {
+                    // Maybe the folder is deleted.
+                    return false;
+                }
+
+                const storageMTimeActual = getComparingMTime(stat);
+                const storageMTime =
+                    storageMTimeActual == 0 ? this.getLastProcessedFileMTime(path) : storageMTimeActual;
+
+                if (onlyNew) {
+                    // If the file is deleted, and it was not new, we should process it.
+                    const prefixedFileName = addPrefix(path, ICHeader);
+                    const filesOnDB = await this.localDatabase.getDBEntryMeta(prefixedFileName);
+                    const dbMTime = getComparingMTime(filesOnDB, includeDeleted);
+                    const diff = compareMTime(storageMTime, dbMTime);
+
+                    if (diff != TARGET_IS_NEW) {
+                        this._log(`Hidden file:${path} is not new.`, LOG_LEVEL_VERBOSE);
+                        if (filesOnDB && stat) {
+                            // OnlyNew not handles the deletion.
+                            this.updateLastProcessed(path, filesOnDB, stat);
+                        }
+                        return true;
+                    }
+                }
+
+                if (type == "delete") {
+                    this._log(`Deletion detected: ${path}`);
+                    const result = await this.deleteInternalFileOnDatabase(path, forceWrite);
+                    return result;
+                } else if (type == "modified") {
+                    this._log(`Modification detected:${path}`, LOG_LEVEL_VERBOSE);
+                    const result = await this.storeInternalFileToDatabase(cache, forceWrite);
+                    const resultText = result === undefined ? "Nothing changed" : result ? "Updated" : "Failed";
+                    this._log(`${resultText}: ${path} ${resultText}`, LOG_LEVEL_VERBOSE);
+                    return result;
+                }
+            });
         } catch (ex) {
             this._log(`Failed to process hidden file:${path}`);
             this._log(ex, LOG_LEVEL_VERBOSE);
@@ -241,6 +626,12 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
         return true;
     }
 
+    // --> Conflict processing
+
+    queueConflictCheck(path: FilePathWithPrefix) {
+        this.conflictResolutionProcessor.enqueue(path);
+    }
+
     async resolveConflictOnInternalFiles() {
         // Scan all conflicted internal files
         const conflicted = this.localDatabase.findEntries(ICHeader, ICHeaderEnd, { conflicts: true });
@@ -262,15 +653,15 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
     async resolveByNewerEntry(
         id: DocumentID,
         path: FilePathWithPrefix,
-        currentDoc: EntryDoc,
+        currentDoc: MetaEntry,
         currentRev: string,
         conflictedRev: string
     ) {
-        const conflictedDoc = await this.localDatabase.getRaw(id, { rev: conflictedRev });
+        const conflictedDoc = await this.localDatabase.getRaw<MetaEntry>(id, { rev: conflictedRev });
         // determine which revision should been deleted.
         // simply check modified time
-        const mtimeCurrent = ("mtime" in currentDoc && currentDoc.mtime) || 0;
-        const mtimeConflicted = ("mtime" in conflictedDoc && conflictedDoc.mtime) || 0;
+        const mtimeCurrent = getComparingMTime(currentDoc, true);
+        const mtimeConflicted = getComparingMTime(conflictedDoc, true);
         // this._log(`Revisions:${new Date(mtimeA).toLocaleString} and ${new Date(mtimeB).toLocaleString}`);
         // console.log(`mtime:${mtimeA} - ${mtimeB}`);
         const delRev = mtimeCurrent < mtimeConflicted ? currentRev : conflictedRev;
@@ -292,10 +683,7 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
             try {
                 // Retrieve data
                 const id = await this.path2id(path, ICHeader);
-                const doc = await this.localDatabase.getRaw(id, { conflicts: true });
-                // if (!("_conflicts" in doc)){
-                //     return [];
-                // }
+                const doc = await this.localDatabase.getRaw<MetaEntry>(id, { conflicts: true });
                 if (doc._conflicts === undefined) return [];
                 if (doc._conflicts.length == 0) return [];
                 this._log(`Hidden file conflicted:${path}`);
@@ -307,7 +695,7 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
                     const conflictedRev = conflicts[0];
                     const conflictedRevNo = Number(conflictedRev.split("-")[0]);
                     //Search
-                    const revFrom = await this.localDatabase.getRaw<EntryDoc>(id, { revs_info: true });
+                    const revFrom = await this.localDatabase.getRaw<MetaEntry>(id, { revs_info: true });
                     const commonBase =
                         revFrom._revs_info
                             ?.filter((e) => e.status == "available" && Number(e.rev.split("-")[0]) < conflictedRevNo)
@@ -321,12 +709,8 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
                     if (result) {
                         this._log(`Object merge:${path}`, LOG_LEVEL_INFO);
                         const filename = stripAllPrefixes(path);
-                        const isExists = await this.plugin.storageAccess.isExistsIncludeHidden(filename);
-                        if (!isExists) {
-                            await this.plugin.storageAccess.ensureDir(filename);
-                        }
-                        await this.plugin.storageAccess.writeHiddenFileAuto(filename, result);
-                        const stat = await this.plugin.storageAccess.statHidden(filename);
+                        await this.ensureDir(filename);
+                        const stat = await this.writeFile(filename, result);
                         if (!stat) {
                             throw new Error(`conflictResolutionProcessor: Failed to stat file ${filename}`);
                         }
@@ -359,8 +743,9 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
             pipeTo: new QueueProcessor(
                 async (results) => {
                     const { id, doc, path, revA, revB } = results[0];
-                    const docAMerge = await this.localDatabase.getDBEntry(path, { rev: revA });
-                    const docBMerge = await this.localDatabase.getDBEntry(path, { rev: revB });
+                    const prefixedPath = addPrefix(path, ICHeader);
+                    const docAMerge = await this.localDatabase.getDBEntry(prefixedPath, { rev: revA });
+                    const docBMerge = await this.localDatabase.getDBEntry(prefixedPath, { rev: revB });
                     if (docAMerge != false && docBMerge != false) {
                         if (await this.showJSONMergeDialogAndMerge(docAMerge, docBMerge)) {
                             // Again for other conflicted revisions.
@@ -384,558 +769,6 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
         }
     );
 
-    $anyGetOptionalConflictCheckMethod(path: FilePathWithPrefix): Promise<boolean | "newer"> {
-        if (isInternalMetadata(path)) {
-            this.queueConflictCheck(path);
-            return Promise.resolve(true);
-        }
-        return Promise.resolve(false);
-    }
-
-    async $anyProcessOptionalSyncFiles(doc: LoadedEntry): Promise<boolean | undefined> {
-        if (isInternalMetadata(doc._id) && this._isThisModuleEnabled()) {
-            //system file
-            const filename = getPath(doc);
-            if (await this.plugin.$$isTargetFile(filename)) {
-                this.procInternalFile(filename);
-                return true;
-            } else {
-                this._log(`Skipped (Not target:${filename})`, LOG_LEVEL_VERBOSE);
-                return false;
-            }
-        }
-        return false;
-    }
-    queueConflictCheck(path: FilePathWithPrefix) {
-        this.conflictResolutionProcessor.enqueue(path);
-    }
-
-    knownChanges: { [key: string]: number } = {};
-    markAsKnownChange(path: string, mtime: number) {
-        this.knownChanges[path] = mtime;
-    }
-    isKnownChange(path: string, mtime: number) {
-        return this.knownChanges[path] == mtime;
-    }
-    ignorePatterns: RegExp[] = [];
-    //TODO: Tidy up. Even though it is experimental feature, So dirty...
-    async syncInternalFilesAndDatabase(
-        direction: "push" | "pull" | "safe" | "pullForce" | "pushForce",
-        showMessage: boolean,
-        filesAll: InternalFileInfo[] | false = false,
-        targetFilesSrc: string[] | false = false
-    ) {
-        const targetFiles = targetFilesSrc
-            ? targetFilesSrc.map((e) => stripAllPrefixes(e as FilePathWithPrefix))
-            : false;
-        // debugger;
-        await this.resolveConflictOnInternalFiles();
-        const logLevel = showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
-        this._log("Scanning hidden files.", logLevel, "sync_internal");
-
-        const configDir = normalizePath(this.app.vault.configDir);
-        let files: InternalFileInfo[] = filesAll ? filesAll : await this.scanInternalFiles();
-        const allowedInHiddenFileSync = this.settings.usePluginSync
-            ? Object.values(this.settings.pluginSyncExtendedSetting)
-                  .filter((e) => e.mode == MODE_AUTOMATIC)
-                  .map((e) => e.files)
-                  .flat()
-                  .map((e) => `${configDir}/${e}`.toLowerCase())
-            : undefined;
-        if (allowedInHiddenFileSync) {
-            const systemOrNot = files.reduce(
-                (acc, cur) => {
-                    if (cur.path.startsWith(configDir)) {
-                        acc.system.push(cur);
-                    } else {
-                        acc.user.push(cur);
-                    }
-                    return acc;
-                },
-                { system: [] as InternalFileInfo[], user: [] as InternalFileInfo[] }
-            );
-
-            files = [
-                ...systemOrNot.user,
-                ...systemOrNot.system.filter((file) =>
-                    allowedInHiddenFileSync.some((filterFile) => file.path.toLowerCase().startsWith(filterFile))
-                ),
-            ];
-        }
-
-        const filesOnDB = (
-            (
-                await this.localDatabase.allDocsRaw({ startkey: ICHeader, endkey: ICHeaderEnd, include_docs: true })
-            ).rows.map((e) => e.doc) as InternalFileEntry[]
-        ).filter((e) => !e.deleted);
-        const allFileNamesSrc = [
-            ...new Set([
-                ...files.map((e) => normalizePath(e.path)),
-                ...filesOnDB.map((e) => stripAllPrefixes(this.getPath(e))),
-            ]),
-        ];
-        let allFileNames = allFileNamesSrc.filter(
-            (filename) => !targetFiles || (targetFiles && targetFiles.indexOf(filename) !== -1)
-        );
-        if (allowedInHiddenFileSync) {
-            allFileNames = allFileNames.filter((file) =>
-                allowedInHiddenFileSync.some((filterFile) => file.toLowerCase().startsWith(filterFile))
-            );
-        }
-
-        const fileCount = allFileNames.length;
-        let processed = 0;
-        let filesChanged = 0;
-        // count updated files up as like this below:
-        // .obsidian: 2
-        // .obsidian/workspace: 1
-        // .obsidian/plugins: 1
-        // .obsidian/plugins/recent-files-obsidian: 1
-        // .obsidian/plugins/recent-files-obsidian/data.json: 1
-        const updatedFolders: { [key: string]: number } = {};
-        const countUpdatedFolder = (path: string) => {
-            const pieces = path.split("/");
-            let c = pieces.shift();
-            let pathPieces = "";
-            filesChanged++;
-            while (c) {
-                pathPieces += (pathPieces != "" ? "/" : "") + c;
-                pathPieces = normalizePath(pathPieces);
-                if (!(pathPieces in updatedFolders)) {
-                    updatedFolders[pathPieces] = 0;
-                }
-                updatedFolders[pathPieces]++;
-                c = pieces.shift();
-            }
-        };
-
-        const filesMap = files.reduce(
-            (acc, cur) => {
-                acc[cur.path] = cur;
-                return acc;
-            },
-            {} as { [key: string]: InternalFileInfo }
-        );
-        const filesOnDBMap = filesOnDB.reduce(
-            (acc, cur) => {
-                acc[stripAllPrefixes(this.getPath(cur))] = cur;
-                return acc;
-            },
-            {} as { [key: string]: InternalFileEntry }
-        );
-        await new QueueProcessor(
-            async (filenames: FilePath[]) => {
-                const filename = filenames[0];
-                processed++;
-                if (processed % 100 == 0) {
-                    this._log(`Hidden file: ${processed}/${fileCount}`, logLevel, "sync_internal");
-                }
-                if (!filename) return [];
-                if (this.ignorePatterns.some((e) => filename.match(e))) return [];
-                if (await this.plugin.$$isIgnoredByIgnoreFiles(filename)) {
-                    return [];
-                }
-
-                const fileOnStorage = filename in filesMap ? filesMap[filename] : undefined;
-                const fileOnDatabase = filename in filesOnDBMap ? filesOnDBMap[filename] : undefined;
-
-                return [
-                    {
-                        filename,
-                        fileOnStorage,
-                        fileOnDatabase,
-                    },
-                ];
-            },
-            {
-                suspended: true,
-                batchSize: 1,
-                concurrentLimit: 10,
-                delay: 0,
-                totalRemainingReactiveSource: hiddenFilesProcessingCount,
-            }
-        )
-            .pipeTo(
-                new QueueProcessor(
-                    async (params) => {
-                        const { filename, fileOnStorage: xFileOnStorage, fileOnDatabase: xFileOnDatabase } = params[0];
-                        const xFileOnDatabaseExists =
-                            xFileOnDatabase !== undefined && !(xFileOnDatabase.deleted || xFileOnDatabase._deleted);
-                        if (xFileOnStorage && xFileOnDatabaseExists) {
-                            // Both => Synchronize
-                            if (
-                                direction != "pullForce" &&
-                                direction != "pushForce" &&
-                                isMarkedAsSameChanges(filename, [xFileOnDatabase.mtime, xFileOnStorage.mtime]) == EVEN
-                            ) {
-                                this._log(`Hidden file skipped: ${filename} is marked as same`, LOG_LEVEL_VERBOSE);
-                                return;
-                            }
-
-                            const nw = compareMTime(xFileOnStorage.mtime, xFileOnDatabase.mtime);
-                            if (nw == BASE_IS_NEW || direction == "pushForce") {
-                                if ((await this.storeInternalFileToDatabase(xFileOnStorage)) !== false) {
-                                    // countUpdatedFolder(filename);
-                                }
-                            } else if (nw == TARGET_IS_NEW || direction == "pullForce") {
-                                // skip if not extraction performed.
-                                if (await this.extractInternalFileFromDatabase(filename)) countUpdatedFolder(filename);
-                            } else {
-                                // Even, or not forced. skip.
-                            }
-                        } else if (!xFileOnStorage && xFileOnDatabaseExists) {
-                            if (direction == "push" || direction == "pushForce") {
-                                if (xFileOnDatabase.deleted) return;
-                                await this.deleteInternalFileOnDatabase(filename, false);
-                            } else if (direction == "pull" || direction == "pullForce") {
-                                if (await this.extractInternalFileFromDatabase(filename)) {
-                                    countUpdatedFolder(filename);
-                                }
-                            } else if (direction == "safe") {
-                                if (xFileOnDatabase.deleted) return;
-                                if (await this.extractInternalFileFromDatabase(filename)) {
-                                    countUpdatedFolder(filename);
-                                }
-                            }
-                        } else if (xFileOnStorage && !xFileOnDatabaseExists) {
-                            if (direction == "push" || direction == "pushForce" || direction == "safe") {
-                                await this.storeInternalFileToDatabase(xFileOnStorage);
-                            } else {
-                                // Apply the deletion
-                                if (await this.extractInternalFileFromDatabase(xFileOnStorage.path)) {
-                                    countUpdatedFolder(xFileOnStorage.path);
-                                }
-                            }
-                        } else {
-                            throw new Error("Invalid state on hidden file sync");
-                            // Something corrupted?
-                        }
-                        return;
-                    },
-                    { suspended: true, batchSize: 1, concurrentLimit: 5, delay: 0 }
-                )
-            )
-            .root.enqueueAll(allFileNames)
-            .startPipeline()
-            .waitForAllDoneAndTerminate();
-
-        // When files has been retrieved from the database. they must be reloaded.
-        if ((direction == "pull" || direction == "pullForce") && filesChanged != 0) {
-            // Show notification to restart obsidian when something has been changed in configDir.
-            if (configDir in updatedFolders) {
-                // Numbers of updated files that is below of configDir.
-                let updatedCount = updatedFolders[configDir];
-                try {
-                    //@ts-ignore
-                    const manifests = Object.values(this.app.plugins.manifests) as any as PluginManifest[];
-                    //@ts-ignore
-                    const enabledPlugins = this.app.plugins.enabledPlugins as Set<string>;
-                    const enabledPluginManifests = manifests.filter((e) => enabledPlugins.has(e.id));
-                    for (const manifest of enabledPluginManifests) {
-                        if (manifest.dir && manifest.dir in updatedFolders) {
-                            // If notified about plug-ins, reloading Obsidian may not be necessary.
-                            updatedCount -= updatedFolders[manifest.dir];
-                            const updatePluginId = manifest.id;
-                            const updatePluginName = manifest.name;
-                            this.plugin.confirm.askInPopup(
-                                `updated-${updatePluginId}`,
-                                `Files in ${updatePluginName} has been updated, Press {HERE} to reload ${updatePluginName}, or press elsewhere to dismiss this message.`,
-                                (anchor) => {
-                                    anchor.text = "HERE";
-                                    anchor.addEventListener("click", () => {
-                                        fireAndForget(async () => {
-                                            this._log(
-                                                `Unloading plugin: ${updatePluginName}`,
-                                                LOG_LEVEL_NOTICE,
-                                                "plugin-reload-" + updatePluginId
-                                            );
-                                            // @ts-ignore
-                                            await this.app.plugins.unloadPlugin(updatePluginId);
-                                            // @ts-ignore
-                                            await this.app.plugins.loadPlugin(updatePluginId);
-                                            this._log(
-                                                `Plugin reloaded: ${updatePluginName}`,
-                                                LOG_LEVEL_NOTICE,
-                                                "plugin-reload-" + updatePluginId
-                                            );
-                                        });
-                                    });
-                                }
-                            );
-                        }
-                    }
-                } catch (ex) {
-                    this._log("Error on checking plugin status.");
-                    this._log(ex, LOG_LEVEL_VERBOSE);
-                }
-
-                // If something changes left, notify for reloading Obsidian.
-                if (updatedCount != 0) {
-                    if (!this.plugin.$$isReloadingScheduled()) {
-                        this.plugin.confirm.askInPopup(
-                            `updated-any-hidden`,
-                            `Hidden files have been synchronised, Press {HERE} to schedule a reload of Obsidian, or press elsewhere to dismiss this message.`,
-                            (anchor) => {
-                                anchor.text = "HERE";
-                                anchor.addEventListener("click", () => {
-                                    this.plugin.$$scheduleAppReload();
-                                });
-                            }
-                        );
-                    }
-                }
-            }
-        }
-
-        this._log(`Hidden files scanned: ${filesChanged} files had been modified`, logLevel, "sync_internal");
-    }
-
-    async storeInternalFileToDatabase(file: InternalFileInfo, forceWrite = false) {
-        const storeFilePath = file.path;
-        const storageFilePath = file.path;
-        if (await this.plugin.$$isIgnoredByIgnoreFiles(storageFilePath)) {
-            return undefined;
-        }
-
-        const id = await this.path2id(storeFilePath, ICHeader);
-        const prefixedFileName = addPrefix(storeFilePath, ICHeader);
-        const content = createBlob(await this.plugin.storageAccess.readHiddenFileAuto(storageFilePath));
-        const mtime = file.mtime;
-        return await serialized("file-" + prefixedFileName, async () => {
-            try {
-                const old = await this.localDatabase.getDBEntry(prefixedFileName, undefined, false, false);
-                let saveData: SavingEntry;
-                if (old === false) {
-                    saveData = {
-                        _id: id,
-                        path: prefixedFileName,
-                        data: content,
-                        mtime,
-                        ctime: mtime,
-                        datatype: "newnote",
-                        size: file.size,
-                        children: [],
-                        deleted: false,
-                        type: "newnote",
-                        eden: {},
-                    };
-                } else {
-                    if ((await isDocContentSame(readAsBlob(old), content)) && !forceWrite) {
-                        // this._log(`STORAGE --> DB:${file.path}: (hidden) Not changed`, LOG_LEVEL_VERBOSE);
-                        const stat = await this.plugin.storageAccess.statHidden(storageFilePath);
-                        if (stat) {
-                            markChangesAreSame(storageFilePath, old.mtime, stat.mtime);
-                        }
-                        return undefined;
-                    }
-                    saveData = {
-                        ...old,
-                        data: content,
-                        mtime,
-                        size: file.size,
-                        datatype: old.datatype,
-                        children: [],
-                        deleted: false,
-                        type: old.datatype,
-                    };
-                }
-                const ret = await this.localDatabase.putDBEntry(saveData);
-                if (ret !== false) {
-                    this._log(`STORAGE --> DB:${storageFilePath}: (hidden) Done`);
-                    return true;
-                } else {
-                    this._log(`STORAGE --> DB:${storageFilePath}: (hidden) Failed`);
-                    return false;
-                }
-            } catch (ex) {
-                this._log(`STORAGE --> DB:${storageFilePath}: (hidden) Failed`);
-                this._log(ex, LOG_LEVEL_VERBOSE);
-                return false;
-            }
-        });
-    }
-
-    async deleteInternalFileOnDatabase(filenameSrc: FilePath, forceWrite = false) {
-        const storeFilePath = filenameSrc;
-        const storageFilePath = filenameSrc;
-        const displayFileName = filenameSrc;
-        const id = await this.path2id(storeFilePath, ICHeader);
-        const prefixedFileName = addPrefix(storeFilePath, ICHeader);
-        const mtime = new Date().getTime();
-        if (await this.plugin.$$isIgnoredByIgnoreFiles(storageFilePath)) {
-            return undefined;
-        }
-        return await serialized("file-" + prefixedFileName, async () => {
-            try {
-                const old = (await this.localDatabase.getDBEntryMeta(prefixedFileName, undefined, true)) as
-                    | InternalFileEntry
-                    | false;
-                let saveData: InternalFileEntry;
-                if (old === false) {
-                    saveData = {
-                        _id: id,
-                        path: prefixedFileName,
-                        mtime,
-                        ctime: mtime,
-                        size: 0,
-                        children: [],
-                        deleted: true,
-                        type: "newnote",
-                        eden: {},
-                    };
-                } else {
-                    // Remove all conflicted before deleting.
-                    const conflicts = await this.localDatabase.getRaw(old._id, { conflicts: true });
-                    if (conflicts._conflicts !== undefined) {
-                        for (const conflictRev of conflicts._conflicts) {
-                            await this.localDatabase.removeRevision(old._id, conflictRev);
-                            this._log(
-                                `STORAGE -x> DB: ${displayFileName}: (hidden) conflict removed ${old._rev} =>  ${conflictRev}`,
-                                LOG_LEVEL_VERBOSE
-                            );
-                        }
-                    }
-                    if (old.deleted) {
-                        this._log(`STORAGE -x> DB: ${displayFileName}: (hidden) already deleted`);
-                        return undefined;
-                    }
-                    saveData = {
-                        ...old,
-                        mtime,
-                        size: 0,
-                        children: [],
-                        deleted: true,
-                        type: "newnote",
-                    };
-                }
-                const ret = await this.localDatabase.putRaw(saveData);
-                if (ret && ret.ok) {
-                    this._log(`STORAGE -x> DB: ${displayFileName}: (hidden) Done`);
-                    return true;
-                } else {
-                    this._log(`STORAGE -x> DB: ${displayFileName}: (hidden) Failed`);
-                    return false;
-                }
-            } catch (ex) {
-                this._log(`STORAGE -x> DB: ${displayFileName}: (hidden) Failed`);
-                this._log(ex, LOG_LEVEL_VERBOSE);
-                return false;
-            }
-        });
-    }
-
-    async extractInternalFileFromDatabase(filenameSrc: FilePath, force = false) {
-        const storeFilePath = filenameSrc;
-        const storageFilePath = filenameSrc;
-        const isExists = await this.plugin.storageAccess.isExistsIncludeHidden(storageFilePath);
-        const prefixedFileName = addPrefix(storeFilePath, ICHeader);
-        const displayFileName = `${storeFilePath}`;
-        if (await this.plugin.$$isIgnoredByIgnoreFiles(storageFilePath)) {
-            return undefined;
-        }
-        return await serialized("file-" + prefixedFileName, async () => {
-            try {
-                // Check conflicted status
-                const fileOnDB = await this.localDatabase.getDBEntry(
-                    prefixedFileName,
-                    { conflicts: true },
-                    false,
-                    true,
-                    true
-                );
-                if (fileOnDB === false) throw new Error(`File not found on database.:${displayFileName}`);
-                // Prevent overwrite for Prevent overwriting while some conflicted revision exists.
-                if (fileOnDB?._conflicts?.length) {
-                    this._log(
-                        `Hidden file ${displayFileName} has conflicted revisions, to keep in safe, writing to storage has been prevented`,
-                        LOG_LEVEL_INFO
-                    );
-                    return false;
-                }
-                const deleted = fileOnDB.deleted || fileOnDB._deleted || false;
-                if (deleted) {
-                    if (!isExists) {
-                        this._log(
-                            `STORAGE <x- DB: ${displayFileName}: deleted (hidden) Deleted on DB, but the file is already not found on storage.`
-                        );
-                    } else {
-                        this._log(`STORAGE <x- DB: ${displayFileName}: deleted (hidden).`);
-                        if (await this.plugin.storageAccess.removeHidden(storageFilePath)) {
-                            try {
-                                await this.plugin.storageAccess.triggerHiddenFile(storageFilePath);
-                            } catch (ex) {
-                                this._log("Failed to call internal API(reconcileInternalFile)", LOG_LEVEL_VERBOSE);
-                                this._log(ex, LOG_LEVEL_VERBOSE);
-                            }
-                        } else {
-                            this._log(`STORAGE <x- DB: ${storageFilePath}: deleted (hidden) Failed`);
-                            return false;
-                        }
-                    }
-                    return true;
-                }
-                if (!isExists) {
-                    await this.plugin.storageAccess.ensureDir(storageFilePath);
-                    await this.plugin.storageAccess.writeHiddenFileAuto(storageFilePath, readContent(fileOnDB), {
-                        mtime: fileOnDB.mtime,
-                        ctime: fileOnDB.ctime,
-                    });
-                    try {
-                        await this.plugin.storageAccess.triggerHiddenFile(storageFilePath);
-                    } catch (ex) {
-                        this._log("Failed to call internal API(reconcileInternalFile)", LOG_LEVEL_VERBOSE);
-                        this._log(ex, LOG_LEVEL_VERBOSE);
-                    }
-                    this._log(`STORAGE <-- DB: ${displayFileName}: written (hidden,new${force ? ", force" : ""})`);
-                    return true;
-                } else {
-                    const content = await this.plugin.storageAccess.readHiddenFileAuto(storageFilePath);
-                    const docContent = readContent(fileOnDB);
-                    if ((await isDocContentSame(content, docContent)) && !force) {
-                        // this._log(`STORAGE <-- DB:${filename}: skipped (hidden) Not changed`, LOG_LEVEL_VERBOSE);
-                        const stat = await this.plugin.storageAccess.statHidden(storageFilePath);
-                        if (stat) {
-                            markChangesAreSame(storageFilePath, fileOnDB.mtime, stat.mtime);
-                        }
-                        return undefined;
-                    }
-                    if (
-                        await this.plugin.storageAccess.writeHiddenFileAuto(storageFilePath, docContent, {
-                            mtime: fileOnDB.mtime,
-                            ctime: fileOnDB.ctime,
-                        })
-                    ) {
-                        const stat = (await this.plugin.storageAccess.statHidden(storageFilePath)) as UXStat;
-                        this.markAsKnownChange(storageFilePath, stat.mtime);
-                        try {
-                            // await this.app.vault.adapter.reconcileInternalFile(filename);
-                            await this.plugin.storageAccess.triggerHiddenFile(storageFilePath);
-                        } catch (ex) {
-                            this._log("Failed to call internal API(reconcileInternalFile)", LOG_LEVEL_VERBOSE);
-                            this._log(ex, LOG_LEVEL_VERBOSE);
-                        }
-                        this._log(
-                            `STORAGE <-- DB: ${displayFileName}: written (hidden, overwrite${force ? ", force" : ""})`
-                        );
-
-                        return true;
-                    } else {
-                        this._log(
-                            `STORAGE <-- DB: ${displayFileName}: written (hidden, overwrite${force ? ", force" : ""}) Failed`
-                        );
-                        return false;
-                    }
-                }
-            } catch (ex) {
-                this._log(
-                    `STORAGE <-- DB: ${displayFileName}: written (hidden, overwrite${force ? ", force" : ""}) Failed`
-                );
-                this._log(ex, LOG_LEVEL_VERBOSE);
-                return false;
-            }
-        });
-    }
-
     showJSONMergeDialogAndMerge(docA: LoadedEntry, docB: LoadedEntry): Promise<boolean> {
         return new Promise((res) => {
             this._log("Opening data-merging dialog", LOG_LEVEL_VERBOSE);
@@ -971,23 +804,16 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
                         if (!isExists) {
                             await this.plugin.storageAccess.ensureDir(storageFilePath);
                         }
-                        await this.plugin.storageAccess.writeHiddenFileAuto(storageFilePath, result);
-                        const stat = await this.plugin.storageAccess.statHidden(storageFilePath);
+                        const stat = await this.writeFile(storageFilePath, result);
                         if (!stat) {
                             throw new Error("Stat failed");
                         }
-                        const mtime = stat?.mtime ?? 0;
+                        const mtime = getComparingMTime(stat);
                         await this.storeInternalFileToDatabase(
                             { path: storageFilePath, mtime, ctime: stat?.ctime ?? mtime, size: stat?.size ?? 0 },
                             true
                         );
-                        try {
-                            //@ts-ignore internalAPI
-                            await this.app.vault.adapter.reconcileInternalFile(storageFilePath);
-                        } catch (ex) {
-                            this._log("Failed to call internal API(reconcileInternalFile)", LOG_LEVEL_VERBOSE);
-                            this._log(ex, LOG_LEVEL_VERBOSE);
-                        }
+                        await this.triggerEvent(storageFilePath);
                         this._log(`STORAGE <-- DB:${displayFilename}: written (hidden,merged)`);
                     }
                     if (needFlush) {
@@ -1007,6 +833,752 @@ export class HiddenFileSync extends LiveSyncCommands implements IObsidianModule
             modal.open();
         });
     }
+    // <-- Conflict processing
+
+    // --> Event Source Handler (Database)
+
+    async processReplicationResult(doc: LoadedEntry): Promise<boolean> {
+        const info = getDocProps(doc);
+        const path = info.path;
+        const headerLine = `Tracking DB ${info.path} (${info.revDisplay}) :`;
+        const ret = await this.trackDatabaseFileModification(path, headerLine);
+        this._log(`${headerLine} Done: ${info.shortenedId})`, LOG_LEVEL_VERBOSE);
+        return ret;
+    }
+
+    // <-- Event Source Handler (Database)
+
+    // --> Database Event Functions
+
+    async trackScannedDatabaseChange(
+        processFiles: MetaEntry[],
+        showNotice: boolean = false,
+        onlyNew = false,
+        forceWriteAll = false,
+        includeDeletion = true
+    ) {
+        const logLevel = getLogLevel(showNotice);
+        const p = this._progress(`[⚙ DB -> Storage ]\n`, logLevel);
+        const notifyProgress = onlyInNTimes(100, (progress) => p.log(`${progress}/${processFiles.length}`));
+        const processes = processFiles.map(async (file) => {
+            try {
+                const path = stripAllPrefixes(this.getPath(file));
+                await this.trackDatabaseFileModification(
+                    path,
+                    "[Hidden file scan]",
+                    !forceWriteAll,
+                    onlyNew,
+                    file,
+                    includeDeletion
+                );
+                notifyProgress();
+            } catch (ex) {
+                this._log(`Failed to process storage change file:${file}`, logLevel);
+                this._log(ex, LOG_LEVEL_VERBOSE);
+            }
+        });
+        await Promise.all(processes);
+        p.done();
+    }
+
+    async applyOfflineChanges(showNotice: boolean) {
+        const logLevel = getLogLevel(showNotice);
+        return await serialized("applyOfflineChanges", async () => {
+            const p = this._progress("[⚙ Apply untracked changes ]\n", logLevel);
+            this._log(`Track changes.`, logLevel);
+            p.log("Enumerating local files...");
+            const currentStorageFiles = await this.scanInternalFileNames();
+            p.log("Enumerating database files...");
+            const currentDatabaseFiles = await this.getAllDatabaseFiles();
+            const allDatabaseMap = Object.fromEntries(
+                currentDatabaseFiles.map((e) => [stripAllPrefixes(getPath(e)), e])
+            );
+            const currentDatabaseFileNames = [...Object.keys(allDatabaseMap)] as FilePath[];
+            const untrackedLocal = currentStorageFiles.filter((e) => !this._fileInfoLastProcessed.has(e));
+            const untrackedDatabase = currentDatabaseFileNames.filter((e) => !this._databaseInfoLastProcessed.has(e));
+            const bothUntracked = untrackedLocal.filter((e) => untrackedDatabase.indexOf(e) !== -1);
+            p.log("Applying untracked changes...");
+            const stat = `Tracking statics:
+Local files: ${currentStorageFiles.length}
+Database files: ${currentDatabaseFileNames.length}
+Untracked local files: ${untrackedLocal.length}
+Untracked database files: ${untrackedDatabase.length}
+Common untracked files: ${bothUntracked.length}`;
+            p.once(stat);
+            const semaphores = Semaphore(10);
+            const notifyProgress = onlyInNTimes(25, (progress) => p.log(`${progress}/${bothUntracked.length}`));
+            const allProcesses = bothUntracked.map(async (file) => {
+                notifyProgress();
+                const rel = await semaphores.acquire();
+                try {
+                    const fileStat = await this.plugin.storageAccess.statHidden(file);
+                    if (fileStat == null) {
+                        // This should not be happened. But, if it happens, we should skip this.
+                        this._log(`Unexpected error: Failed to stat file during applyOfflineChange :${file}`);
+                        return;
+                    }
+                    const dbInfo = allDatabaseMap[file];
+                    if (dbInfo.deleted || dbInfo._deleted) {
+                        // Applying deletion can be harmful if the local file is not tracked.
+                        // So, we should skip this.
+                        return;
+                    }
+                    const fileMTime = getComparingMTime(fileStat);
+                    const dbMTime = getComparingMTime(dbInfo);
+                    const diff = compareMTime(fileMTime, dbMTime);
+                    if (diff == BASE_IS_NEW) {
+                        // Local file is newer than the database file.
+                        // So, we should apply the local file to the database.
+                        await this.trackStorageFileModification(file, true);
+                    } else if (diff == TARGET_IS_NEW) {
+                        // Database file is newer than the local file.
+                        // So, we should apply the database file to the local file.
+                        await this.trackDatabaseFileModification(file, "[Apply]", true, true, dbInfo);
+                    } else if (diff == EVEN) {
+                        // Both are same, we may skip this but should update the last processed key.
+                        this.updateLastProcessed(file, dbInfo, fileStat);
+                    }
+                } finally {
+                    rel();
+                }
+            });
+            await Promise.all(allProcesses);
+            await this.scanAllStorageChanges(showNotice);
+            await this.scanAllDatabaseChanges(showNotice);
+
+            p.done();
+        });
+    }
+
+    async scanAllDatabaseChanges(
+        showNotice: boolean = false,
+        onlyNew = false,
+        forceWriteAll = false,
+        includeDeletion = true
+    ) {
+        return await skipIfDuplicated("scanAllDatabaseChanges", async () => {
+            const databaseFiles = await this.getAllDatabaseFiles();
+            const files = databaseFiles.filter((e) => {
+                const doc = e;
+                const key = this.docToKey(doc);
+                const path = stripAllPrefixes(this.getPath(doc));
+                const lastKey = this.getLastProcessedDatabaseKey(path);
+                return lastKey != key;
+            });
+            const logLevel = getLogLevel(showNotice);
+            const staticsMessage = `[Database hidden file statics]
+All files: ${databaseFiles.length}
+Offline Changed files: ${files.length}`;
+            this._log(staticsMessage, logLevel, "scan-changes");
+            return await this.trackScannedDatabaseChange(files, showNotice, onlyNew, forceWriteAll, includeDeletion);
+        });
+    }
+
+    async useDatabaseFiles(files: MetaEntry[], showNotice = false, onlyNew = false) {
+        const logLevel = getLogLevel(showNotice);
+        const p = this._progress(`[⚙ Scanning DB -> Storage ]\n`, logLevel);
+        p.log("Scanning database files...");
+        const notifyProgress = onlyInNTimes(25, (progress) => p.log(`${progress}/${files.length}`));
+        const processFiles = files.map(async (file) => {
+            try {
+                const path = stripAllPrefixes(this.getPath(file));
+                await this.trackDatabaseFileModification(path, "[Scanning]", true, onlyNew, file);
+                notifyProgress();
+            } catch (ex) {
+                this._log(`Failed to process database changes:${file}`);
+                this._log(ex, LOG_LEVEL_VERBOSE);
+            }
+            return;
+        });
+        await Promise.all(processFiles);
+        p.done();
+        return true;
+    }
+
+    async trackDatabaseFileModification(
+        path: FilePath,
+        headerLine: string,
+        preventDoubleProcess = false,
+        onlyNew = false,
+        meta: MetaEntry | false = false,
+        includeDeletion = true
+    ): Promise<boolean> {
+        return await this.serializedForEvent(path, async () => {
+            try {
+                // Fetch the document with conflicts
+                const prefixedPath = addPrefix(path, ICHeader);
+                const docMeta = meta
+                    ? meta
+                    : await this.localDatabase.getDBEntryMeta(prefixedPath, { conflicts: true }, true);
+                if (docMeta === false) {
+                    this._log(`${headerLine}: Failed to read detail of ${path}`);
+                    throw new Error(`Failed to read detail ${path}`);
+                }
+                // Check if the file is conflicted, and if so, enqueue to resolve.
+                // Until the conflict is resolved, the file will not be processed.
+                if (docMeta._conflicts && docMeta._conflicts.length > 0) {
+                    this.conflictResolutionProcessor.enqueue(path);
+                    this._log(`${headerLine} Hidden file conflicted, enqueued to resolve`);
+                    return true;
+                }
+                // And, extract (or delete) the file to storage.
+                const extractResult = await this.extractInternalFileFromDatabase(
+                    path,
+                    false,
+                    docMeta,
+                    preventDoubleProcess,
+                    onlyNew,
+                    includeDeletion
+                );
+                if (extractResult) {
+                    this._log(`${headerLine} Hidden file processed`);
+                }
+            } catch (ex) {
+                this._log(`${headerLine} Failed to process hidden file`);
+                this._log(ex, LOG_LEVEL_VERBOSE);
+            }
+            return true;
+        });
+    }
+
+    // <-- Database Event Functions
+
+    // --> Notification for Config Change
+    queuedNotificationFiles = new Set<string>();
+    notifyConfigChange() {
+        const updatedFolders = [...this.queuedNotificationFiles];
+        this.queuedNotificationFiles.clear();
+        try {
+            //@ts-ignore
+            const manifests = Object.values(this.app.plugins.manifests) as any as PluginManifest[];
+            //@ts-ignore
+            const enabledPlugins = this.app.plugins.enabledPlugins as Set<string>;
+            const enabledPluginManifests = manifests.filter((e) => enabledPlugins.has(e.id));
+            const modifiedManifests = enabledPluginManifests.filter((e) => updatedFolders.indexOf(e?.dir ?? "") >= 0);
+            for (const manifest of modifiedManifests) {
+                // If notified about plug-ins, reloading Obsidian may not be necessary.
+                const updatePluginId = manifest.id;
+                const updatePluginName = manifest.name;
+                this.plugin.confirm.askInPopup(
+                    `updated-${updatePluginId}`,
+                    `Files in ${updatePluginName} has been updated!\nPress {HERE} to reload ${updatePluginName}, or press elsewhere to dismiss this message.`,
+                    (anchor) => {
+                        anchor.text = "HERE";
+                        anchor.addEventListener("click", () => {
+                            fireAndForget(async () => {
+                                this._log(
+                                    `Unloading plugin: ${updatePluginName}`,
+                                    LOG_LEVEL_NOTICE,
+                                    "plugin-reload-" + updatePluginId
+                                );
+                                // @ts-ignore
+                                await this.app.plugins.unloadPlugin(updatePluginId);
+                                // @ts-ignore
+                                await this.app.plugins.loadPlugin(updatePluginId);
+                                this._log(
+                                    `Plugin reloaded: ${updatePluginName}`,
+                                    LOG_LEVEL_NOTICE,
+                                    "plugin-reload-" + updatePluginId
+                                );
+                            });
+                        });
+                    }
+                );
+            }
+        } catch (ex) {
+            this._log("Error on checking plugin status.");
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+
+        // If something changes left, notify for reloading Obsidian.
+        if (updatedFolders.indexOf(this.plugin.app.vault.configDir) >= 0) {
+            if (!this.plugin.$$isReloadingScheduled()) {
+                this.plugin.confirm.askInPopup(
+                    `updated-any-hidden`,
+                    `Some setting files have been modified\nPress {HERE} to schedule a reload of Obsidian, or press elsewhere to dismiss this message.`,
+                    (anchor) => {
+                        anchor.text = "HERE";
+                        anchor.addEventListener("click", () => {
+                            this.plugin.$$scheduleAppReload();
+                        });
+                    }
+                );
+            }
+        }
+    }
+
+    queueNotification(key: FilePath) {
+        const configDir = this.plugin.app.vault.configDir;
+        if (!key.startsWith(configDir)) return;
+        const dirName = key.split("/").slice(0, -1).join("/");
+        this.queuedNotificationFiles.add(dirName);
+        scheduleTask("notify-config-change", 1000, () => {
+            this.notifyConfigChange();
+        });
+    }
+    // <-- Notification for Config Change
+
+    // --> Initialization functions
+
+    async rebuildMerging(showNotice: boolean, targetFiles: FilePath[] | false = false) {
+        const logLevel = getLogLevel(showNotice);
+        const p = this._progress("[⚙ Rebuild by Merge ]\n", logLevel);
+        this._log(`Rebuilding hidden files from the storage and the local database.`, logLevel);
+        p.log("Enumerating local files...");
+        const currentStorageFilesAll = await this.scanInternalFileNames();
+        const currentStorageFiles = targetFiles
+            ? currentStorageFilesAll.filter((e) => targetFiles.some((f) => f == e))
+            : currentStorageFilesAll;
+        p.log("Enumerating database files...");
+        const allDatabaseFiles = await this.getAllDatabaseFiles();
+        const allDatabaseMap = new Map(allDatabaseFiles.map((e) => [stripAllPrefixes(getPath(e)), e]));
+        const currentDatabaseFiles = targetFiles
+            ? allDatabaseFiles.filter((e) => targetFiles.some((f) => f == stripAllPrefixes(getPath(e))))
+            : allDatabaseFiles;
+
+        const allFileNames = new Set([
+            ...currentStorageFiles,
+            ...currentDatabaseFiles.map((e) => stripAllPrefixes(getPath(e))),
+        ]);
+        const storageToDatabase = [] as FilePath[];
+        const databaseToStorage = [] as MetaEntry[];
+
+        const eachProgress = onlyInNTimes(100, (progress) => p.log(`Checking ${progress}/${allFileNames.size}`));
+        for (const file of allFileNames) {
+            eachProgress();
+            const storageMTime = await this.plugin.storageAccess.statHidden(file);
+            const mtimeStorage = getComparingMTime(storageMTime);
+            const dbEntry = allDatabaseMap.get(file)!;
+            const mtimeDB = getComparingMTime(dbEntry);
+            const diff = compareMTime(mtimeStorage, mtimeDB);
+            if (diff == BASE_IS_NEW) {
+                storageToDatabase.push(file);
+            } else if (diff == TARGET_IS_NEW) {
+                databaseToStorage.push(dbEntry);
+            } else if (diff == EVEN) {
+                // For safety, storage to database.
+                storageToDatabase.push(file);
+            }
+        }
+        p.once(
+            `Storage to Database: ${storageToDatabase.length} files\n Database to Storage: ${databaseToStorage.length} files`
+        );
+        this.resetLastProcessedDatabase(targetFiles);
+        this.resetLastProcessedFile(targetFiles);
+        const processes = [
+            this.useStorageFiles(storageToDatabase, showNotice, false),
+            this.useDatabaseFiles(databaseToStorage, showNotice, false),
+        ];
+        p.log("Start processing...");
+        await Promise.all(processes);
+        p.done();
+        return [...allFileNames];
+    }
+
+    async rebuildFromStorage(showNotice: boolean, targetFiles: FilePath[] | false = false, onlyNew = false) {
+        // reset processed file markers
+        const logLevel = getLogLevel(showNotice);
+        this._verbose(`Rebuilding hidden files from the storage.`);
+        this._log(`Rebuilding hidden files from the storage.`, logLevel);
+        const p = this._progress("[⚙ Rebuild by Storage ]\n", logLevel);
+        p.log("Enumerating local files...");
+        const currentFilesAll = await this.scanInternalFileNames();
+        const currentFiles = targetFiles
+            ? currentFilesAll.filter((e) => targetFiles.some((f) => f == e))
+            : currentFilesAll;
+        p.once(`Storage to Database: ${currentFiles.length} files.`);
+        p.log("Start processing...");
+        this.resetLastProcessedFile(targetFiles);
+        await this.useStorageFiles(currentFiles, showNotice, onlyNew);
+        p.done();
+        return currentFiles;
+    }
+
+    async getAllDatabaseFiles() {
+        const allFiles = (
+            await this.localDatabase.allDocsRaw({ startkey: ICHeader, endkey: ICHeaderEnd, include_docs: true })
+        ).rows
+            .filter((e) => isInternalMetadata(e.id as DocumentID))
+            .map((e) => e.doc) as MetaEntry[];
+        return allFiles;
+    }
+
+    async rebuildFromDatabase(showNotice: boolean, targetFiles: FilePath[] | false = false, onlyNew = false) {
+        const logLevel = getLogLevel(showNotice);
+        this._verbose(`Rebuilding hidden files from the local database.`);
+        const p = this._progress("[⚙ Rebuild by Database ]\n", logLevel);
+        p.log("Enumerating database files...");
+        const allFiles = await this.getAllDatabaseFiles();
+
+        // THINKING: Should we exclude conflicted or deleted files?
+        // Current implementation is to include all files, and following processes will handle for them.
+        // However, in perspective of performance and future-proofing, I feel somewhat justified in doing it here.
+
+        const currentFiles = targetFiles
+            ? allFiles.filter((e) => targetFiles.some((f) => f == stripAllPrefixes(getPath(e))))
+            : allFiles;
+
+        p.once(`Database to Storage: ${currentFiles.length} files.`);
+        this.resetLastProcessedDatabase(targetFiles);
+        p.log("Start processing...");
+        await this.useDatabaseFiles(currentFiles, showNotice, onlyNew);
+        p.done();
+        return currentFiles;
+    }
+
+    async initialiseInternalFileSync(
+        direction: SyncDirection,
+        showMessage: boolean,
+        // filesAll: InternalFileInfo[] | false = false,
+        targetFilesSrc: string[] | false = false
+    ) {
+        const logLevel = showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+        const p = this._progress("[⚙ Initialise]\n", logLevel);
+        // p.log("Resolving conflicts before starting...");
+        // await this.resolveConflictOnInternalFiles();
+        p.log("Initialising hidden files sync...");
+        // TODO: Handling ignore files cannot be performed to the hidden files.
+
+        const targetFiles = targetFilesSrc
+            ? targetFilesSrc.map((e) => stripAllPrefixes(e as FilePathWithPrefix))
+            : false;
+        if (direction == "pushForce" || direction == "push") {
+            const onlyNew = direction == "push";
+            p.log(`Started: Storage --> Database ${onlyNew ? "(Only New)" : ""}`);
+            const updatedFiles = await this.rebuildFromStorage(showMessage, targetFiles, onlyNew);
+            // making doubly sure, No more losing files.
+            // I did so many times during the development.
+            await this.adoptCurrentStorageFilesAsProcessed(updatedFiles);
+            await this.adoptCurrentDatabaseFilesAsProcessed(updatedFiles);
+            // And, scan other changes on the database (i.e. files which are on only other devices)
+            await this.scanAllStorageChanges(showMessage, true, false);
+            await this.scanAllDatabaseChanges(showMessage, true, false);
+        }
+        if (direction == "pullForce" || direction == "pull") {
+            const onlyNew = direction == "pull";
+            p.log(`Started: Database --> Storage ${onlyNew ? "(Only New)" : ""}`);
+            const updatedEntries = await this.rebuildFromDatabase(showMessage, targetFiles, onlyNew);
+            const updatedFiles = updatedEntries.map((e) => stripAllPrefixes(getPath(e)));
+            // making doubly sure, No more losing files.
+            await this.adoptCurrentStorageFilesAsProcessed(updatedFiles);
+            await this.adoptCurrentDatabaseFilesAsProcessed(updatedFiles);
+            // And, scan other changes on the database (i.e. files which are on only other devices)
+            await this.scanAllDatabaseChanges(showMessage, true, false);
+            await this.scanAllStorageChanges(showMessage, true, false);
+        }
+        if (direction == "safe") {
+            p.log(`Started: Database <--> Storage (by modified date)`);
+            const updatedFiles = await this.rebuildMerging(showMessage, targetFiles);
+            await this.adoptCurrentStorageFilesAsProcessed(updatedFiles);
+            await this.adoptCurrentDatabaseFilesAsProcessed(updatedFiles);
+            // And, scan other changes on the database (i.e. files which are on only other devices)
+            await this.scanAllStorageChanges(showMessage, true, false);
+            await this.scanAllDatabaseChanges(showMessage, true, false);
+        }
+        p.done();
+    }
+    // <-- Initialization functions
+
+    // --> Storage To Database Functions
+
+    async __loadBaseSaveData(file: FilePath, includeContent = true): Promise<LoadedEntry | false> {
+        const prefixedFileName = addPrefix(file, ICHeader);
+        const id = await this.path2id(prefixedFileName, ICHeader);
+        try {
+            const old = includeContent
+                ? await this.localDatabase.getDBEntry(prefixedFileName, undefined, false, true)
+                : await this.localDatabase.getDBEntryMeta(prefixedFileName, { conflicts: true }, true);
+            if (old === false) {
+                const baseSaveData: LoadedEntry = {
+                    _id: id,
+                    data: [],
+                    path: prefixedFileName,
+                    mtime: 0,
+                    ctime: 0,
+                    datatype: "newnote",
+                    children: [],
+                    size: 0,
+                    deleted: false,
+                    type: "newnote",
+                    eden: {},
+                };
+                return baseSaveData;
+            } else {
+                return old;
+            }
+        } catch (ex) {
+            this._log(`Getting base save data failed`);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+    }
+
+    async storeInternalFileToDatabase(file: InternalFileInfo | UXFileInfo, forceWrite = false) {
+        const storeFilePath = stripAllPrefixes(file.path as FilePath);
+        const storageFilePath = file.path;
+        if (await this.plugin.$$isIgnoredByIgnoreFiles(storageFilePath)) {
+            return undefined;
+        }
+        const prefixedFileName = addPrefix(storeFilePath, ICHeader);
+
+        return await serialized("file-" + prefixedFileName, async () => {
+            try {
+                const fileInfo = "stat" in file && "body" in file ? file : await this.loadFileWithInfo(storeFilePath);
+                if (fileInfo.deleted) {
+                    throw new Error(`Hidden file:${storeFilePath} is deleted. This should not be occurred.`);
+                }
+                const baseData = await this.__loadBaseSaveData(storeFilePath, true);
+                if (baseData === false) throw new Error("Failed to load base data");
+                if (baseData._rev && !forceWrite) {
+                    // Not newly created,  we should check the content is actually modified.
+                    const isSame = await isDocContentSame(readAsBlob(baseData), fileInfo.body);
+                    if (isSame) {
+                        this.updateLastProcessed(storeFilePath, baseData, fileInfo.stat);
+                        // Not changed. skip.
+                        // TODO: Mark as same?
+                        return undefined;
+                    }
+                }
+                const saveData: SavingEntry = {
+                    ...baseData,
+                    data: fileInfo.body,
+                    mtime: fileInfo.stat.mtime,
+                    size: fileInfo.stat.size,
+                    children: [],
+                    deleted: false,
+                    type: baseData.datatype,
+                };
+                const ret = await this.localDatabase.putDBEntry(saveData);
+                if (ret && ret.ok) {
+                    saveData._rev = ret.rev;
+                    this.updateLastProcessed(storeFilePath, saveData, fileInfo.stat);
+                }
+                const success = ret && ret.ok;
+                this._log(`STORAGE --> DB:${storageFilePath}: (hidden) ${success ? "Done" : "Failed"}`);
+                return success;
+            } catch (ex) {
+                this._log(`STORAGE --> DB:${storageFilePath}: (hidden) Failed`);
+                this._log(ex, LOG_LEVEL_VERBOSE);
+                return false;
+            }
+        });
+    }
+
+    async deleteInternalFileOnDatabase(filenameSrc: FilePath, forceWrite = false) {
+        const storeFilePath = filenameSrc;
+        const storageFilePath = filenameSrc;
+        const displayFileName = filenameSrc;
+        const prefixedFileName = addPrefix(storeFilePath, ICHeader);
+        const mtime = new Date().getTime();
+        if (await this.plugin.$$isIgnoredByIgnoreFiles(storageFilePath)) {
+            return undefined;
+        }
+        return await serialized("file-" + prefixedFileName, async () => {
+            try {
+                const baseData = await this.__loadBaseSaveData(storeFilePath, false);
+                if (baseData === false) throw new Error("Failed to load base data during deleting");
+                if (baseData._conflicts !== undefined) {
+                    for (const conflictRev of baseData._conflicts) {
+                        await this.localDatabase.removeRevision(baseData._id, conflictRev);
+                        this._log(
+                            `STORAGE -x> DB: ${displayFileName}: (hidden) conflict removed ${baseData._rev} =>  ${conflictRev}`,
+                            LOG_LEVEL_VERBOSE
+                        );
+                    }
+                }
+                if (baseData.deleted) {
+                    this._log(`STORAGE -x> DB: ${displayFileName}: (hidden) already deleted`, LOG_LEVEL_VERBOSE);
+                    this.updateLastProcessedDeletion(storeFilePath, baseData);
+                    return true;
+                }
+                const saveData: LoadedEntry = {
+                    ...baseData,
+                    mtime,
+                    size: 0,
+                    children: [],
+                    deleted: true,
+                    type: baseData.datatype,
+                };
+                const ret = await this.localDatabase.putRaw(saveData);
+                if (ret && ret.ok) {
+                    this._log(`STORAGE -x> DB: ${displayFileName}: (hidden) Done`);
+                    saveData._rev = ret.rev;
+                    this.updateLastProcessedDeletion(storeFilePath, saveData);
+                    return true;
+                } else {
+                    this._log(`STORAGE -x> DB: ${displayFileName}: (hidden) Failed`);
+                    return false;
+                }
+            } catch (ex) {
+                this._log(`STORAGE -x> DB: ${displayFileName}: (hidden) Failed`);
+                this._log(ex, LOG_LEVEL_VERBOSE);
+                return false;
+            }
+        });
+    }
+
+    // <-- Storage To Database Functions
+
+    // --> Database To Storage Functions
+
+    async extractInternalFileFromDatabase(
+        storageFilePath: FilePath,
+        force = false,
+        metaEntry?: MetaEntry | LoadedEntry,
+        preventDoubleProcess = true,
+        onlyNew = false,
+        includeDeletion = true
+    ) {
+        const prefixedFileName = addPrefix(storageFilePath, ICHeader);
+        if (await this.plugin.$$isIgnoredByIgnoreFiles(storageFilePath)) {
+            return undefined;
+        }
+        return await serialized("file-" + prefixedFileName, async () => {
+            try {
+                // Check conflicted status
+                const metaOnDB = metaEntry
+                    ? metaEntry
+                    : await this.localDatabase.getDBEntryMeta(prefixedFileName, { conflicts: true }, true);
+                if (metaOnDB === false) throw new Error(`File not found on database.:${storageFilePath}`);
+                // Prevent overwrite for Prevent overwriting while some conflicted revision exists.
+                if (metaOnDB?._conflicts?.length) {
+                    this._log(
+                        `Hidden file ${storageFilePath} has conflicted revisions, to keep in safe, writing to storage has been prevented`,
+                        LOG_LEVEL_INFO
+                    );
+                    return false;
+                }
+                if (preventDoubleProcess) {
+                    const key = this.docToKey(metaOnDB);
+                    if (this.getLastProcessedDatabaseKey(storageFilePath) == key && !force) {
+                        this._log(
+                            `STORAGE <-- DB: ${storageFilePath}: skipped (hidden, overwrite${force ? ", force" : ""}) (Previously processed)`
+                        );
+                        return;
+                    }
+                }
+                if (onlyNew) {
+                    // Check the file is new or not.
+                    const dbMTime = getComparingMTime(metaOnDB, includeDeletion); // metaOnDB.mtime;
+                    const storageStat = await this.plugin.storageAccess.statHidden(storageFilePath);
+                    const storageMTimeActual = storageStat?.mtime ?? 0;
+                    const storageMTime =
+                        storageMTimeActual == 0 ? this.getLastProcessedFileMTime(storageFilePath) : storageMTimeActual;
+                    const diff = compareMTime(storageMTime, dbMTime);
+                    if (diff != TARGET_IS_NEW) {
+                        this._log(
+                            `STORAGE <-- DB: ${storageFilePath}: skipped (hidden, overwrite${force ? ", force" : ""}) (Not new)`
+                        );
+                        // And this case, we should update the last processed key.
+                        this.updateLastProcessedDatabase(storageFilePath, metaOnDB);
+                        if (storageStat) this.updateLastProcessedFile(storageFilePath, storageStat);
+                        return;
+                    }
+                }
+                const deleted = metaOnDB.deleted || metaOnDB._deleted || false;
+                if (deleted) {
+                    const result = await this._deleteFile(storageFilePath);
+                    if (result == "OK") {
+                        this.updateLastProcessedDeletion(storageFilePath, metaOnDB);
+                        return true;
+                    } else if (result == "ALREADY") {
+                        this.updateLastProcessedDatabase(storageFilePath, metaOnDB);
+                        return true;
+                    }
+                    return false;
+                } else {
+                    const fileOnDB = await this.localDatabase.getDBEntryFromMeta(metaOnDB, {}, false, true, true);
+                    if (fileOnDB === false) {
+                        throw new Error(`Failed to read file from database:${storageFilePath}`);
+                    }
+                    const resultStat = await this._writeFile(storageFilePath, fileOnDB, force);
+                    if (resultStat) {
+                        this.updateLastProcessed(storageFilePath, metaOnDB, resultStat);
+                        this.queueNotification(storageFilePath);
+                        this._log(
+                            `STORAGE <-- DB: ${storageFilePath}: written (hidden, overwrite${force ? ", force" : ""}) Done`
+                        );
+                        return true;
+                    }
+                }
+                return false;
+            } catch (ex) {
+                this._log(
+                    `STORAGE <-- DB: ${storageFilePath}: written (hidden, overwrite${force ? ", force" : ""}) Failed`
+                );
+                this._log(ex, LOG_LEVEL_VERBOSE);
+                return false;
+            }
+        });
+    }
+
+    async __checkIsNeedToWriteFile(storageFilePath: FilePath, content: string | ArrayBuffer): Promise<boolean> {
+        try {
+            const storageContent = await this.plugin.storageAccess.readHiddenFileAuto(storageFilePath);
+            const needWrite = !(await isDocContentSame(storageContent, content));
+            return needWrite;
+        } catch (ex) {
+            this._log(`Cannot check the content of ${storageFilePath}`);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+            return true;
+        }
+    }
+
+    async _writeFile(storageFilePath: FilePath, fileOnDB: LoadedEntry, force: boolean): Promise<false | UXStat> {
+        try {
+            const statBefore = await this.plugin.storageAccess.statHidden(storageFilePath);
+            const isExist = statBefore != null;
+            const writeContent = readContent(fileOnDB);
+            await this.ensureDir(storageFilePath);
+            // We have to compare the content, so read it once.
+            const needWrite =
+                force || !isExist || (isExist && (await this.__checkIsNeedToWriteFile(storageFilePath, writeContent)));
+
+            if (!needWrite) {
+                this._log(`STORAGE <-- DB: ${storageFilePath}: skipped (hidden) Not changed`, LOG_LEVEL_DEBUG);
+                return statBefore;
+            }
+
+            const writeResultStat = await this.writeFile(storageFilePath, writeContent, {
+                mtime: fileOnDB.mtime,
+                ctime: fileOnDB.ctime,
+            });
+
+            if (writeResultStat == null) {
+                this._log(
+                    `STORAGE <-- DB: ${storageFilePath}: written (hidden,new${force ? ", force" : ""}) Failed (writeResult)`
+                );
+                return false;
+            }
+            // await this.triggerEvent(storageFilePath);
+            // markChangesAreSame(storageFilePath, getComparingMTime(writeResultStat), getComparingMTime(fileOnDB));
+            this._log(`STORAGE <-- DB: ${storageFilePath}: written (hidden, overwrite${force ? ", force" : ""})`);
+            return writeResultStat;
+        } catch (ex) {
+            this._log(
+                `STORAGE <-- DB: ${storageFilePath}: written (hidden, overwrite${force ? ", force" : ""}) Failed`
+            );
+            this._log(ex, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+    }
+
+    async _deleteFile(storageFilePath: FilePath): Promise<false | "OK" | "ALREADY"> {
+        const result = await this.__removeFile(storageFilePath);
+        if (result === false) {
+            this._log(`STORAGE <x- DB: ${storageFilePath}: deleting (hidden) Failed`);
+            return false;
+        }
+        if (result === "OK") {
+            await this.triggerEvent(storageFilePath);
+        }
+        this._log(
+            `STORAGE <x- DB: ${storageFilePath}: deleting (hidden) ${result == "OK" ? "Done" : "Already not found"}`
+        );
+        return result;
+    }
+
+    // <-- Database To Storage Functions
 
     async $allAskUsingOptionalSyncFeature(opt: { enableFetch?: boolean; enableOverwrite?: boolean }) {
         await this._askHiddenFileConfiguration(opt);
@@ -1069,6 +1641,7 @@ ${messageFetch}${messageOverwrite}${messageMerge}
         return Promise.resolve(true);
     }
 
+    // --> Configuration handling
     async $anyConfigureOptionalSyncFeature(mode: "FETCH" | "OVERWRITE" | "MERGE" | "DISABLE" | "DISABLE_HIDDEN") {
         await this.configureHiddenFileSync(mode);
     }
@@ -1092,18 +1665,23 @@ ${messageFetch}${messageOverwrite}${messageMerge}
         }
         this._log("Gathering files for enabling Hidden File Sync", LOG_LEVEL_NOTICE);
         if (mode == "FETCH") {
-            await this.syncInternalFilesAndDatabase("pullForce", true);
+            await this.initialiseInternalFileSync("pullForce", true);
         } else if (mode == "OVERWRITE") {
-            await this.syncInternalFilesAndDatabase("pushForce", true);
+            await this.initialiseInternalFileSync("pushForce", true);
         } else if (mode == "MERGE") {
-            await this.syncInternalFilesAndDatabase("safe", true);
+            await this.initialiseInternalFileSync("safe", true);
         }
         this.plugin.settings.useAdvancedMode = true;
         this.plugin.settings.syncInternalFiles = true;
+
         await this.plugin.saveSettings();
         this._log(`Done! Restarting the app is strongly recommended!`, LOG_LEVEL_NOTICE);
     }
-    async scanInternalFiles(): Promise<InternalFileInfo[]> {
+    // <-- Configuration handling
+
+    // --> Local Storage SubFunctions
+    ignorePatterns: RegExp[] = [];
+    async scanInternalFileNames() {
         const configDir = normalizePath(this.app.vault.configDir);
         const ignoreFilter = this.settings.syncInternalFilesIgnorePatterns
             .replace(/\n| /g, "")
@@ -1123,16 +1701,20 @@ ${messageFetch}${messageOverwrite}${messageMerge}
         const filenames = (await this.getFiles(findRoot, [], undefined, ignoreFilter))
             .filter((e) => e.startsWith("."))
             .filter((e) => !e.startsWith(".trash"));
-        const files = filenames
-            .filter((path) =>
-                synchronisedInConfigSync.every((filterFile) => !path.toLowerCase().startsWith(filterFile))
-            )
-            .map(async (e) => {
-                return {
-                    path: e as FilePath,
-                    stat: await this.plugin.storageAccess.statHidden(e), // this.plugin.vaultAccess.adapterStat(e)
-                };
-            });
+        const files = filenames.filter((path) =>
+            synchronisedInConfigSync.every((filterFile) => !path.toLowerCase().startsWith(filterFile))
+        );
+        return files as FilePath[];
+    }
+
+    async scanInternalFiles(): Promise<InternalFileInfo[]> {
+        const fileNames = await this.scanInternalFileNames();
+        const files = fileNames.map(async (e) => {
+            return {
+                path: e,
+                stat: await this.plugin.storageAccess.statHidden(e), // this.plugin.vaultAccess.adapterStat(e)
+            };
+        });
         const result: InternalFileInfo[] = [];
         for (const f of files) {
             const w = await f;
@@ -1190,4 +1772,6 @@ ${messageFetch}${messageOverwrite}${messageMerge}
         }
         return files;
     }
+
+    // <-- Local Storage SubFunctions
 }
diff --git a/src/features/LiveSyncCommands.ts b/src/features/LiveSyncCommands.ts
index 50ae617..4ab188a 100644
--- a/src/features/LiveSyncCommands.ts
+++ b/src/features/LiveSyncCommands.ts
@@ -1,4 +1,4 @@
-import { Logger } from "octagonal-wheels/common/logger";
+import { LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
 import { getPath } from "../common/utils.ts";
 import {
     LOG_LEVEL_INFO,
@@ -11,7 +11,9 @@ import {
     type LOG_LEVEL,
 } from "../lib/src/common/types.ts";
 import type ObsidianLiveSyncPlugin from "../main.ts";
+import { MARK_DONE } from "../modules/features/ModuleLog.ts";
 
+let noticeIndex = 0;
 export abstract class LiveSyncCommands {
     plugin: ObsidianLiveSyncPlugin;
     get app() {
@@ -57,4 +59,34 @@ export abstract class LiveSyncCommands {
         // console.log(msg);
         Logger(msg, level, key);
     };
+
+    _verbose = (msg: any, key?: string) => {
+        this._log(msg, LOG_LEVEL_VERBOSE, key);
+    };
+
+    _info = (msg: any, key?: string) => {
+        this._log(msg, LOG_LEVEL_INFO, key);
+    };
+
+    _notice = (msg: any, key?: string) => {
+        this._log(msg, LOG_LEVEL_NOTICE, key);
+    };
+    _progress = (prefix: string = "", level: LOG_LEVEL = LOG_LEVEL_NOTICE) => {
+        const key = `keepalive-progress-${noticeIndex++}`;
+        return {
+            log: (msg: any) => {
+                this._log(prefix + msg, level, key);
+            },
+            once: (msg: any) => {
+                this._log(prefix + msg, level);
+            },
+            done: (msg: string = "Done") => {
+                this._log(prefix + msg + MARK_DONE, level, key);
+            },
+        };
+    };
+
+    _debug = (msg: any, key?: string) => {
+        this._log(msg, LOG_LEVEL_VERBOSE, key);
+    };
 }
diff --git a/src/lib b/src/lib
index e1688ac..2e156a9 160000
--- a/src/lib
+++ b/src/lib
@@ -1 +1 @@
-Subproject commit e1688acb0f28abdcc84191d06e386052a9dff989
+Subproject commit 2e156a988bdce705878f24483c9efc2a69fb24b4
diff --git a/src/modules/core/ModuleDatabaseFileAccess.ts b/src/modules/core/ModuleDatabaseFileAccess.ts
index a6d4ba6..0077f1e 100644
--- a/src/modules/core/ModuleDatabaseFileAccess.ts
+++ b/src/modules/core/ModuleDatabaseFileAccess.ts
@@ -1,6 +1,11 @@
 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 {
+    getDatabasePathFromUXFileInfo,
+    getStoragePathFromUXFileInfo,
+    isInternalMetadata,
+    markChangesAreSame,
+} from "../../common/utils";
 import type {
     UXFileInfoStub,
     FilePathWithPrefix,
@@ -9,10 +14,11 @@ import type {
     LoadedEntry,
     FilePath,
     SavingEntry,
+    DocumentID,
 } 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 { isPlainText, shouldBeIgnored, stripAllPrefixes } from "../../lib/src/string_and_binary/path";
 import {
     createBlob,
     createTextBlob,
@@ -23,6 +29,7 @@ import {
 } from "../../lib/src/common/utils";
 import { serialized } from "octagonal-wheels/concurrency/lock";
 import { AbstractModule } from "../AbstractModule.ts";
+import { ICHeader } from "../../common/types.ts";
 
 export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidianModule, DatabaseFileAccess {
     $everyOnload(): Promise<boolean> {
@@ -67,7 +74,7 @@ export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidia
     }
 
     async checkIsTargetFile(file: UXFileInfoStub | FilePathWithPrefix): Promise<boolean> {
-        const path = getPathFromUXFileInfo(file);
+        const path = getStoragePathFromUXFileInfo(file);
         if (!(await this.core.$$isTargetFile(path))) {
             this._log(`File is not target`, LOG_LEVEL_VERBOSE);
             return false;
@@ -83,7 +90,7 @@ export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidia
         if (!(await this.checkIsTargetFile(file))) {
             return true;
         }
-        const fullPath = getPathFromUXFileInfo(file);
+        const fullPath = getDatabasePathFromUXFileInfo(file);
         try {
             this._log(`deleteDB By path:${fullPath}`);
             return await this.deleteFromDBbyPath(fullPath, rev);
@@ -104,6 +111,7 @@ export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidia
     async storeContent(path: FilePathWithPrefix, content: string): Promise<boolean> {
         const blob = createTextBlob(content);
         const bytes = (await blob.arrayBuffer()).byteLength;
+        const isInternal = path.startsWith(".") ? true : undefined;
         const dummyUXFileInfo: UXFileInfo = {
             name: path.split("/").pop() as string,
             path: path,
@@ -114,6 +122,7 @@ export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidia
                 type: "file",
             },
             body: blob,
+            isInternal,
         };
         return await this._store(dummyUXFileInfo, true, false, false);
     }
@@ -133,18 +142,47 @@ export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidia
             this._log("File seems bad", LOG_LEVEL_VERBOSE);
             return false;
         }
-        const path = getPathFromUXFileInfo(file);
-
+        // 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 idPrefix = file.isInternal ? ICHeader : "";
+        const fullPath = getStoragePathFromUXFileInfo(file);
+        const fullPathOnDB = getDatabasePathFromUXFileInfo(file);
+
+        if (possiblyLarge) this._log(`Processing: ${fullPath}`, LOG_LEVEL_VERBOSE);
+
+        // if (isInternalMetadata(fullPath)) {
+        //     this._log(`Internal file: ${fullPath}`, LOG_LEVEL_VERBOSE);
+        //     return false;
+        // }
+        if (file.isInternal) {
+            if (file.deleted) {
+                file.stat = {
+                    size: 0,
+                    ctime: Date.now(),
+                    mtime: Date.now(),
+                    type: "file",
+                };
+            } else if (file.stat == undefined) {
+                const stat = await this.core.storageAccess.statHidden(file.path);
+                if (!stat) {
+                    // We stored actually deleted or not since here, so this is an unexpected case. we should raise an error.
+                    this._log(`Internal file not found: ${fullPath}`, LOG_LEVEL_VERBOSE);
+                    return false;
+                }
+                file.stat = stat;
+            }
+        }
+
+        const idMain = await this.core.$$path2id(fullPath);
+
+        const id = (idPrefix + idMain) as DocumentID;
         const d: SavingEntry = {
             _id: id,
-            path: file.path,
+            path: fullPathOnDB,
             data: content,
             ctime: file.stat.ctime,
             mtime: file.stat.mtime,
@@ -166,7 +204,7 @@ export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidia
             //     return true;
             // }
             try {
-                const old = await this.localDatabase.getDBEntry(fullPath, undefined, false, true, false);
+                const old = await this.localDatabase.getDBEntry(d.path, 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 };
@@ -181,24 +219,14 @@ export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidia
                     // 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(
+                    msg +
+                        "Error, Could not check the diff for the old one." +
+                        (force ? "force writing." : "") +
+                        fullPath +
+                        (d._deleted || d.deleted ? " (deleted)" : ""),
+                    LOG_LEVEL_VERBOSE
+                );
                 this._log(ex, LOG_LEVEL_VERBOSE);
                 return !force;
             }
@@ -220,7 +248,7 @@ export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidia
         if (!(await this.checkIsTargetFile(file))) {
             return [];
         }
-        const filename = getPathFromUXFileInfo(file);
+        const filename = getDatabasePathFromUXFileInfo(file);
         const doc = await this.localDatabase.getDBEntryMeta(filename, { conflicts: true }, true);
         if (doc === false) {
             return [];
@@ -243,9 +271,10 @@ export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidia
             return false;
         }
         const data = createBlob(readContent(entry));
+        const path = stripAllPrefixes(entry.path);
         const fileInfo: UXFileInfo = {
-            name: entry.path.split("/").pop() as string,
-            path: entry.path,
+            name: path.split("/").pop() as string,
+            path: path,
             stat: {
                 size: entry.size,
                 ctime: entry.ctime,
@@ -265,12 +294,12 @@ export class ModuleDatabaseFileAccess extends AbstractModule implements IObsidia
         rev?: string,
         skipCheck = false
     ): Promise<MetaEntry | false> {
-        const filename = getPathFromUXFileInfo(file);
+        const dbFileName = getDatabasePathFromUXFileInfo(file);
         if (skipCheck && !(await this.checkIsTargetFile(file))) {
             return false;
         }
 
-        const doc = await this.localDatabase.getDBEntryMeta(filename, rev ? { rev: rev } : undefined, true);
+        const doc = await this.localDatabase.getDBEntryMeta(dbFileName, rev ? { rev: rev } : undefined, true);
         if (doc === false) {
             return false;
         }
diff --git a/src/modules/core/ModuleFileHandler.ts b/src/modules/core/ModuleFileHandler.ts
index 25fba94..d56e3e5 100644
--- a/src/modules/core/ModuleFileHandler.ts
+++ b/src/modules/core/ModuleFileHandler.ts
@@ -14,8 +14,8 @@ import {
     compareFileFreshness,
     EVEN,
     getPath,
-    getPathFromUXFileInfo,
     getPathWithoutPrefix,
+    getStoragePathFromUXFileInfo,
     markChangesAreSame,
 } from "../../common/utils";
 import { getDocDataAsArray, isDocContentSame, readContent } from "../../lib/src/common/utils";
@@ -94,11 +94,9 @@ export class ModuleFileHandler extends AbstractModule implements ICoreModule {
             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);
-                    }
+                    // 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;
                 }
@@ -170,18 +168,13 @@ export class ModuleFileHandler extends AbstractModule implements ICoreModule {
         info: UXFileInfoStub | FilePath,
         rev: string
     ): Promise<boolean | undefined> {
+        const path = getStoragePathFromUXFileInfo(info);
         if (!(await this.deleteRevisionFromDB(info, rev))) {
-            this._log(
-                `Failed to delete the conflicted revision ${rev} of ${getPathFromUXFileInfo(info)}`,
-                LOG_LEVEL_VERBOSE
-            );
+            this._log(`Failed to delete the conflicted revision ${rev} of ${path}`, 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
-            );
+            this._log(`Failed to apply the resolved revision ${rev} of ${path} to the storage`, LOG_LEVEL_VERBOSE);
             return false;
         }
     }
diff --git a/src/modules/core/ModuleRebuilder.ts b/src/modules/core/ModuleRebuilder.ts
index 4d39a6c..745f9d6 100644
--- a/src/modules/core/ModuleRebuilder.ts
+++ b/src/modules/core/ModuleRebuilder.ts
@@ -77,7 +77,8 @@ export class ModuleRebuilder extends AbstractModule implements ICoreModule, Rebu
         await this.core.$$tryResetRemoteDatabase();
         await this.core.$$markRemoteLocked();
         await delay(500);
-        await this.askUsingOptionalFeature({ enableOverwrite: true });
+        // We do not have any other devices' data, so we do not need to ask for overwriting.
+        await this.askUsingOptionalFeature({ enableOverwrite: false });
         await delay(1000);
         await this.core.$$replicateAllToServer(true);
         await delay(1000);
diff --git a/src/modules/core/ModuleReplicator.ts b/src/modules/core/ModuleReplicator.ts
index 87e7ebf..4eb4925 100644
--- a/src/modules/core/ModuleReplicator.ts
+++ b/src/modules/core/ModuleReplicator.ts
@@ -329,7 +329,7 @@ Or if you are sure know what had been happened, we can unlock the database from
             } else if (isValidPath(getPath(doc))) {
                 this.storageApplyingProcessor.enqueue(doc as MetaEntry);
             } else {
-                Logger(`Skipped: ${doc._id.substring(0, 8)}`, LOG_LEVEL_VERBOSE);
+                Logger(`Skipped: ${path} (${doc._id.substring(0, 8)})`, LOG_LEVEL_VERBOSE);
             }
             return;
         },
diff --git a/src/modules/core/ModuleTargetFilter.ts b/src/modules/core/ModuleTargetFilter.ts
index 853d933..5d7b5d5 100644
--- a/src/modules/core/ModuleTargetFilter.ts
+++ b/src/modules/core/ModuleTargetFilter.ts
@@ -1,6 +1,6 @@
 import { LRUCache } from "octagonal-wheels/memory/LRUCache";
 import {
-    getPathFromUXFileInfo,
+    getStoragePathFromUXFileInfo,
     id2path,
     isInternalMetadata,
     path2id,
@@ -16,7 +16,7 @@ import {
     type ObsidianLiveSyncSettings,
     type UXFileInfoStub,
 } from "../../lib/src/common/types";
-import { addPrefix, isAcceptedAll, stripAllPrefixes } from "../../lib/src/string_and_binary/path";
+import { addPrefix, isAcceptedAll } 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";
@@ -107,14 +107,14 @@ export class ModuleTargetFilter extends AbstractModule implements ICoreModule {
             }
         );
 
-        const filepath = getPathFromUXFileInfo(file);
+        const filepath = getStoragePathFromUXFileInfo(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();
+        const fileNameLC = getStoragePathFromUXFileInfo(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.
@@ -154,16 +154,12 @@ export class ModuleTargetFilter extends AbstractModule implements ICoreModule {
         if (!this.settings.useIgnoreFiles) {
             return false;
         }
-        const filepath = getPathFromUXFileInfo(file);
+        const filepath = getStoragePathFromUXFileInfo(file);
         if (this.ignoreFileCache.has(filepath)) {
             // Renew
             await this.readIgnoreFile(filepath);
         }
-        if (
-            !(await isAcceptedAll(stripAllPrefixes(filepath), this.ignoreFiles, (filename) =>
-                this.getIgnoreFile(filename)
-            ))
-        ) {
+        if (!(await isAcceptedAll(filepath, this.ignoreFiles, (filename) => this.getIgnoreFile(filename)))) {
             return true;
         }
         return false;
diff --git a/src/modules/coreFeatures/ModuleConflictResolver.ts b/src/modules/coreFeatures/ModuleConflictResolver.ts
index dff2bad..bc33786 100644
--- a/src/modules/coreFeatures/ModuleConflictResolver.ts
+++ b/src/modules/coreFeatures/ModuleConflictResolver.ts
@@ -5,6 +5,7 @@ import {
     CANCELLED,
     LOG_LEVEL_INFO,
     LOG_LEVEL_NOTICE,
+    LOG_LEVEL_VERBOSE,
     MISSING_OR_ERROR,
     NOT_CONFLICTED,
     type diff_check_result,
@@ -114,7 +115,7 @@ export class ModuleConflictResolver extends AbstractModule implements ICoreModul
                 conflictCheckResult === CANCELLED
             ) {
                 // nothing to do.
-                this._log(`conflict:Nothing to do:${filename}`);
+                this._log(`[conflict] Not conflicted or cancelled: ${filename}`, LOG_LEVEL_VERBOSE);
                 return;
             }
             if (conflictCheckResult === AUTO_MERGED) {
@@ -123,7 +124,7 @@ export class ModuleConflictResolver extends AbstractModule implements ICoreModul
                     //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");
+                this._log("[conflict] Automatically merged, but we have to check it again");
                 await this.core.$$queueConflictCheck(filename);
                 return;
             }
@@ -131,13 +132,13 @@ export class ModuleConflictResolver extends AbstractModule implements ICoreModul
                 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.`,
+                        `[conflict] ${filename} is conflicted. Merging process has been postponed to the file have got opened.`,
                         LOG_LEVEL_NOTICE
                     );
                     return;
                 }
             }
-            this._log("conflict:Manual merge required!");
+            this._log("[conflict] Manual merge required!");
             await this.core.$anyResolveConflictByUI(filename, conflictCheckResult);
         });
     }
diff --git a/src/modules/coreObsidian/ModuleFileAccessObsidian.ts b/src/modules/coreObsidian/ModuleFileAccessObsidian.ts
index ab9070e..8d61a5d 100644
--- a/src/modules/coreObsidian/ModuleFileAccessObsidian.ts
+++ b/src/modules/coreObsidian/ModuleFileAccessObsidian.ts
@@ -120,12 +120,12 @@ export class ModuleFileAccessObsidian extends AbstractObsidianModule implements
         }
     }
     statHidden(path: string): Promise<UXStat | null> {
-        return this.vaultAccess.adapterStat(path);
+        return this.vaultAccess.tryAdapterStat(path);
     }
     async removeHidden(path: string): Promise<boolean> {
         try {
             await this.vaultAccess.adapterRemove(path);
-            if (this.vaultAccess.adapterStat(path) !== null) {
+            if (this.vaultAccess.tryAdapterStat(path) !== null) {
                 return false;
             }
             return true;
@@ -145,7 +145,7 @@ export class ModuleFileAccessObsidian extends AbstractObsidianModule implements
         return await this.vaultAccess.adapterReadBinary(path);
     }
     async isExistsIncludeHidden(path: string): Promise<boolean> {
-        return (await this.vaultAccess.adapterStat(path)) !== null;
+        return (await this.vaultAccess.tryAdapterStat(path)) !== null;
     }
     async ensureDir(path: string): Promise<boolean> {
         try {
diff --git a/src/modules/coreObsidian/storageLib/SerializedFileAccess.ts b/src/modules/coreObsidian/storageLib/SerializedFileAccess.ts
index 3967c13..42a8388 100644
--- a/src/modules/coreObsidian/storageLib/SerializedFileAccess.ts
+++ b/src/modules/coreObsidian/storageLib/SerializedFileAccess.ts
@@ -42,6 +42,13 @@ export class SerializedFileAccess {
         this.plugin = plugin;
     }
 
+    async tryAdapterStat(file: TFile | string) {
+        const path = file instanceof TFile ? file.path : file;
+        return await processReadFile(file, async () => {
+            if (!(await this.app.vault.adapter.exists(path))) return null;
+            return this.app.vault.adapter.stat(path);
+        });
+    }
     async adapterStat(file: TFile | string) {
         const path = file instanceof TFile ? file.path : file;
         return await processReadFile(file, () => this.app.vault.adapter.stat(path));
diff --git a/src/modules/coreObsidian/storageLib/StorageEventManager.ts b/src/modules/coreObsidian/storageLib/StorageEventManager.ts
index aafd65c..5ed0b55 100644
--- a/src/modules/coreObsidian/storageLib/StorageEventManager.ts
+++ b/src/modules/coreObsidian/storageLib/StorageEventManager.ts
@@ -171,11 +171,13 @@ export class StorageEventManagerObsidian extends StorageEventManager {
             // Folder
             return;
         }
+
         void this.appendQueue(
             [
                 {
                     type: "INTERNAL",
                     file: InternalFileToUXFileInfoStub(path),
+                    skipBatchWait: true, // Internal files should be processed immediately.
                 },
             ],
             null
@@ -212,11 +214,14 @@ export class StorageEventManagerObsidian extends StorageEventManager {
             // 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.core.storageAccess.recentlyTouched(file)) {
-                    continue;
+            // if (file instanceof TFile && (type == "CREATE" || type == "CHANGED")) {
+            if (file instanceof TFile || !file.isFolder) {
+                if (type == "CREATE" || type == "CHANGED") {
+                    // Wait for a bit while to let the writer has marked `touched` at the file.
+                    await delay(10);
+                    if (this.core.storageAccess.recentlyTouched(file.path)) {
+                        continue;
+                    }
                 }
             }
 
@@ -380,13 +385,11 @@ export class StorageEventManagerObsidian extends StorageEventManager {
         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.core.$anyProcessOptionalFileEvent(file.path as unknown as FilePath);
             } else {
-                // let mtime = file.stat.mtime;
+                const key = `file-last-proc-${queue.type}-${file.path}`;
+                const last = Number((await this.core.kvDB.get(key)) || 0);
                 if (queue.type == "DELETE") {
                     await this.core.$anyHandlerProcessesFileEvent(queue);
                 } else {
diff --git a/src/modules/coreObsidian/storageLib/utilObsidian.ts b/src/modules/coreObsidian/storageLib/utilObsidian.ts
index 3e8ed71..65719ae 100644
--- a/src/modules/coreObsidian/storageLib/utilObsidian.ts
+++ b/src/modules/coreObsidian/storageLib/utilObsidian.ts
@@ -55,7 +55,7 @@ export async function InternalFileToUXFileInfo(
     prefix: string = ICHeader
 ): Promise<UXFileInfo> {
     const name = fullPath.split("/").pop() as string;
-    const stat = await vaultAccess.adapterStat(fullPath);
+    const stat = await vaultAccess.tryAdapterStat(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);
diff --git a/src/modules/essential/ModuleInitializerFile.ts b/src/modules/essential/ModuleInitializerFile.ts
index 4d71ed4..9f15bbd 100644
--- a/src/modules/essential/ModuleInitializerFile.ts
+++ b/src/modules/essential/ModuleInitializerFile.ts
@@ -238,10 +238,10 @@ export class ModuleInitializerFile extends AbstractModule implements ICoreModule
                 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,
-                    });
+                    // 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`,
@@ -282,10 +282,6 @@ export class ModuleInitializerFile extends AbstractModule implements ICoreModule
                 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`,
@@ -296,7 +292,12 @@ export class ModuleInitializerFile extends AbstractModule implements ICoreModule
             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))) {
+                    if (await this.core.fileHandler.dbToStorage(doc, stripAllPrefixes(file.path), true)) {
+                        eventHub.emitEvent("event-file-changed", {
+                            file: file.path,
+                            automated: true,
+                        });
+                    } else {
                         this._log(`STORAGE <- DB : Cloud not read ${file.path}, possibly deleted`, LOG_LEVEL_NOTICE);
                     }
                     return caches;
diff --git a/src/modules/extras/ModuleDev.ts b/src/modules/extras/ModuleDev.ts
index abfb0bf..1b9ce73 100644
--- a/src/modules/extras/ModuleDev.ts
+++ b/src/modules/extras/ModuleDev.ts
@@ -12,31 +12,34 @@ export class ModuleDev extends AbstractObsidianModule implements IObsidianModule
         __onMissingTranslation(() => {});
         return Promise.resolve(true);
     }
+    async onMissingTranslation(key: string): Promise<void> {
+        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) + ",";
+        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);
+        }
+    }
+
     $everyOnloadAfterLoadSettings(): Promise<boolean> {
         if (!this.settings.enableDebugTools) return Promise.resolve(true);
         // eslint-disable-next-line no-unused-labels
+        this.onMissingTranslation = this.onMissingTranslation.bind(this);
         __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);
-                }
-            });
+            void this.onMissingTranslation(key);
         });
         type STUB = {
             toc: Set<string>;
diff --git a/src/modules/features/ModuleLog.ts b/src/modules/features/ModuleLog.ts
index bf803cf..2df01be 100644
--- a/src/modules/features/ModuleLog.ts
+++ b/src/modules/features/ModuleLog.ts
@@ -46,6 +46,8 @@ const recentLogProcessor = new QueueProcessor(
 ).resumePipeLine();
 // logStore.intercept(e => e.slice(Math.min(e.length - 200, 0)));
 
+const showDebugLog = false;
+export const MARK_DONE = "\u{2009}\u{2009}";
 export class ModuleLog extends AbstractObsidianModule implements IObsidianModule {
     registerView = this.plugin.registerView.bind(this.plugin);
 
@@ -89,7 +91,7 @@ export class ModuleLog extends AbstractObsidianModule implements IObsidianModule
         const labelChunkCount = padLeftSpComputed(collectingChunks, `🧩`);
         const labelPluginScanCount = padLeftSpComputed(pluginScanningCount, `🔌`);
         const labelConflictProcessCount = padLeftSpComputed(this.core.conflictProcessQueueCount, `🔩`);
-        const hiddenFilesCount = reactive(() => hiddenFilesEventCount.value + hiddenFilesProcessingCount.value);
+        const hiddenFilesCount = reactive(() => hiddenFilesEventCount.value - hiddenFilesProcessingCount.value);
         const labelHiddenFilesCount = padLeftSpComputed(hiddenFilesCount, `⚙️`);
         const queueCountLabelX = reactive(() => {
             return `${labelReplication()}${labelDBCount()}${labelStorageCount()}${labelChunkCount()}${labelPluginScanCount()}${labelHiddenFilesCount()}${labelConflictProcessCount()}`;
@@ -355,7 +357,7 @@ export class ModuleLog extends AbstractObsidianModule implements IObsidianModule
         );
     }
     $$addLog(message: any, level: LOG_LEVEL = LOG_LEVEL_INFO, key = ""): void {
-        if (level == LOG_LEVEL_DEBUG) {
+        if (level == LOG_LEVEL_DEBUG && !showDebugLog) {
             return;
         }
         if (level < LOG_LEVEL_INFO && this.settings && this.settings.lessInformationInLog) {
@@ -412,15 +414,17 @@ export class ModuleLog extends AbstractObsidianModule implements IObsidianModule
                 };
             }
             const timeout = 5000;
-            scheduleTask(`notify-${key}`, timeout, () => {
-                const notify = this.notifies[key].notice;
-                delete this.notifies[key];
-                try {
-                    notify.hide();
-                } catch {
-                    // NO OP
-                }
-            });
+            if (!key.startsWith("keepalive-") || messageContent.indexOf(MARK_DONE) !== -1) {
+                scheduleTask(`notify-${key}`, timeout, () => {
+                    const notify = this.notifies[key].notice;
+                    delete this.notifies[key];
+                    try {
+                        notify.hide();
+                    } catch {
+                        // NO OP
+                    }
+                });
+            }
         }
     }
 }
diff --git a/src/modules/features/SettingDialogue/ObsidianLiveSyncSettingTab.ts b/src/modules/features/SettingDialogue/ObsidianLiveSyncSettingTab.ts
index 43d4e62..62c478d 100644
--- a/src/modules/features/SettingDialogue/ObsidianLiveSyncSettingTab.ts
+++ b/src/modules/features/SettingDialogue/ObsidianLiveSyncSettingTab.ts
@@ -1905,7 +1905,7 @@ However, your report is needed to stabilise this. I appreciate you for your grea
                 }
 
                 new Setting(paneEl).setClass("wizardHidden").autoWireToggle("syncInternalFilesBeforeReplication", {
-                    onUpdate: visibleOnly(() => this.isConfiguredAs("watchInternalFileChanges", false)),
+                    onUpdate: visibleOnly(() => this.isConfiguredAs("watchInternalFileChanges", true)),
                 });
 
                 new Setting(paneEl).setClass("wizardHidden").autoWireNumeric("syncInternalFilesInterval", {