Refactored, please refer updates.md

docs/datastructure.md

@@ -0,0 +1,168 @@
+# Data Structures of Self-Hosted LiveSync
+## Overview
+
+Self-hosted LiveSync uses the following types of documents:
+
+- Metadata
+    - Legacy Metadata
+    - Binary Metadata
+    - Plain Metadata
+- Chunk
+- Versioning
+- Synchronise Information
+- Synchronise Parameters
+- Milestone Information
+
+## Description of Each Data Structure
+
+All documents inherit from the `DatabaseEntry` interface. This is necessary for conflict resolution and deletion flags.
+
+```ts
+export interface DatabaseEntry {
+    _id: DocumentID;
+    _rev?: string;
+    _deleted?: boolean;
+}
+```
+
+### Versioning Document
+
+This document stores version information for Self-hosted LiveSync.
+The ID is fixed as `obsydian_livesync_version` [VERSIONING_DOCID]. Yes, the typo has become a curse.
+When Self-hosted LiveSync detects changes to this document via Replication, it reads the version information and checks compatibility.
+In that case, if there are major changes, synchronisation may be stopped.
+Please refer to negotiation.ts.
+
+### Synchronise Information Document
+
+This document stores information that should be verified in synchronisation settings.
+The ID is fixed as `syncinfo` [SYNCINFO_ID].
+The information stored in this document is only the conditions necessary for synchronisation to succeed, and as of v0.25.43, only a random string is stored.
+This document is only used during rebuilds from the settings screen for CouchDB-based synchronisation, making it like an appendix. It may be removed in the future.
+
+### Synchronise Parameters Document
+
+This document stores synchronisation parameters.
+Synchronisation parameters include the protocol version and salt used for encryption, but do not include chunking settings.
+
+The ID is fixed as `_local/obsidian_livesync_sync_parameters` [DOCID_SYNC_PARAMETERS] or `_obsidian_livesync_journal_sync_parameters.json` [DOCID_JOURNAL_SYNC_PARAMETERS].
+
+This document exists only on the remote and not locally.
+This document stores the following information.
+It is read each time before connecting and is used to verify that E2EE settings match.
+This mismatch cannot be ignored and synchronisation will be stopped.
+
+```ts
+export interface SyncParameters extends DatabaseEntry {
+    _id: typeof DOCID_SYNC_PARAMETERS;
+    type: (typeof EntryTypes)["SYNC_PARAMETERS"];
+    protocolVersion: ProtocolVersion;
+    pbkdf2salt: string;
+}
+```
+
+#### protocolVersion
+
+This field indicates the protocol version used by the remote. Mostly, this value should be `2` (ProtocolVersions.ADVANCED_E2EE), which indicates safer E2EE support.
+
+#### pbkdf2salt
+
+This field stores the salt used for PBKDF2 key derivation on the remote. This salt and the passphrase provides E2EE encryption keys.
+
+### Milestone Information Document
+
+This document stores information about how the remote accepts and recognises clients.
+The ID is fixed as `_local/obsidian_livesync_milestone` [MILESTONE_DOCID].
+This document exists only on the remote and not locally.
+This document is used to indicate synchronisation progress and includes the version range of accepted chunks for each node and adjustment values for each node.
+Tweak Mismatched is determined based on the information in this document.
+
+For details, please refer to LiveSyncReplicator.ts, LiveSyncJournalReplicator.ts, and LiveSyncDBFunctions.ts.
+
+```ts
+export interface EntryMilestoneInfo extends DatabaseEntry {
+    _id: typeof MILESTONE_DOCID;
+    type: EntryTypes["MILESTONE_INFO"];
+    created: number;
+    accepted_nodes: string[];
+    node_info: { [key: NodeKey]: NodeData };
+    locked: boolean;
+    cleaned?: boolean;
+    node_chunk_info: { [key: NodeKey]: ChunkVersionRange };
+    tweak_values: { [key: NodeKey]: TweakValues };
+}
+```
+
+### locked
+
+If the remote has been requested to lock out from any client, this is set to true.
+When set to true, clients will stop synchronisation unless they are included in accepted_nodes.
+
+### cleaned
+
+If the remote has been cleaned up from any client, this is set to true.
+In this case, clients will stop synchronisation as they need to rebuild again.
+
+### Metadata Document
+
+Metadata documents store metadata for Obsidian notes.
+
+```ts
+export interface MetadataDocument extends DatabaseEntry {
+    _id: DocumentID;
+    ctime: number;
+    mtime: number;
+    size: number;
+    deleted?: boolean;
+    eden: Record<string, EdenChunk>; // Obsolete
+    path: FilePathWithPrefix;
+    children: string[];
+    type: EntryTypes["NOTE_LEGACY" | "NOTE_BINARY" | "NOTE_PLAIN"];
+}
+```
+
+### type
+
+This field indicates the type of Metadata document.
+By convention, Self-hosted LiveSync does not save the mime type of the file, but distinguishes them with this field. Please note this.
+Possible values are as follows:
+
+- NOTE_LEGACY: Legacy metadata document
+    - Please do not use
+- NOTE_BINARY: Binary metadata document (newnote)
+- NOTE_PLAIN: Plain metadata document (plain)
+
+#### children
+
+This field stores an array of Chunk Document IDs.
+
+#### \_id, path
+
+\_id is generated based on the path of the Obsidian note.
+
+- If the path starts with `_`, it is converted to `/_` for convenience.
+- If Case Sensitive is disabled, it is converted to lowercase.
+
+When Obfuscation is enabled, the path field contains `f:{obfuscated path}`.
+The path field stores the path as is. However, when Obfuscation is enabled, the obfuscated path is stored.
+
+When Property Encryption is enabled, the path field stores all properties including children, mtime, ctime, and size in an encrypted state. Please refer to encryption.ts.
+
+### Chunk Document
+
+```ts
+export type EntryLeaf = DatabaseEntry & {
+    _id: DocumentID;
+    type: EntryTypes["CHUNK"];
+    data: string;
+};
+```
+
+Chunk documents store parts of note content.
+
+- The type field is always `[CHUNK]`, `leaf`.
+- The data field stores the chunk content.
+- The \_id field is generated based on a hash of the content and the passphrase.
+
+Hash functions used include xxHash and SHA-1, depending on settings.
+Chunking methods used include Contextual Chunking and Rabin-Karp Chunking, depending on settings.

manifest.json

@@ -1,7 +1,7 @@
 {
     "id": "obsidian-livesync",
     "name": "Self-hosted LiveSync",
-    "version": "0.25.43",
+    "version": "0.25.43-patched-1",
     "minAppVersion": "0.9.12",
     "description": "Community implementation of self-hosted livesync. Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "author": "vorotamoroz",

package-lock.json

@@ -1,12 +1,12 @@
 {
     "name": "obsidian-livesync",
-    "version": "0.25.43",
+    "version": "0.25.43-patched-1",
     "lockfileVersion": 2,
     "requires": true,
     "packages": {
         "": {
             "name": "obsidian-livesync",
-            "version": "0.25.43",
+            "version": "0.25.43-patched-1",
             "license": "MIT",
             "dependencies": {
                 "@aws-sdk/client-s3": "^3.808.0",

package.json

@@ -1,6 +1,6 @@
 {
     "name": "obsidian-livesync",
-    "version": "0.25.43",
+    "version": "0.25.43-patched-1",
     "description": "Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "main": "main.js",
     "type": "module",

src/apps/webpeer/package.json

@@ -20,6 +20,7 @@
         "vite": "^7.3.0"
     },
     "imports": {
-        "../../src/worker/bgWorker.ts": "../../src/worker/bgWorker.mock.ts"
+        "../../src/worker/bgWorker.ts": "../../src/worker/bgWorker.mock.ts",
+        "@lib/worker/bgWorker.ts": "@lib/worker/bgWorker.mock.ts"
     }
 }

src/apps/webpeer/src/P2PReplicatorShim.ts

@@ -35,6 +35,7 @@ import { SETTING_KEY_P2P_DEVICE_NAME } from "@lib/common/types";
 import { ServiceContext } from "@lib/services/base/ServiceBase";
 import type { InjectableServiceHub } from "@lib/services/InjectableServices";
 import { Menu } from "@/lib/src/services/implements/browser/Menu";
+import type { InjectableVaultServiceCompat } from "@/lib/src/services/implements/injectable/InjectableVaultService";
 
 function addToList(item: string, list: string) {
     return unique(
@@ -79,7 +80,13 @@ export class P2PReplicatorShim implements P2PReplicatorBase, CommandShim {
     constructor() {
         const browserServiceHub = new BrowserServiceHub<ServiceContext>();
         this.services = browserServiceHub;
-        this.services.vault.getVaultName.setHandler(() => "p2p-livesync-web-peer");
+        (this.services.vault as InjectableVaultServiceCompat<ServiceContext>).vaultName.setHandler(
+            () => "p2p-livesync-web-peer"
+        );
+
+        this.services.setting.currentSettings.setHandler(() => {
+            return this.settings as any;
+        });
     }
     async init() {
         // const { simpleStoreAPI } = await getWrappedSynchromesh();

src/common/types.ts

@@ -49,21 +49,16 @@ export type queueItem = {
     warned?: boolean;
 };
 
-// Hidden items (Now means `chunk`)
-export const CHeader = "h:";
-
-// Plug-in Stored Container (Obsolete)
-export const PSCHeader = "ps:";
-export const PSCHeaderEnd = "ps;";
-
-// Internal data Container
-export const ICHeader = "i:";
-export const ICHeaderEnd = "i;";
-export const ICHeaderLength = ICHeader.length;
-
-// Internal data Container (eXtended)
-export const ICXHeader = "ix:";
-
 export const FileWatchEventQueueMax = 10;
 
 export { configURIBase, configURIBaseQR } from "../lib/src/common/types.ts";
+
+export {
+    CHeader,
+    PSCHeader,
+    PSCHeaderEnd,
+    ICHeader,
+    ICHeaderEnd,
+    ICHeaderLength,
+    ICXHeader,
+} from "../lib/src/common/models/fileaccess.const.ts";

src/common/utils.ts

@@ -23,7 +23,7 @@ import {
     type UXFileInfo,
     type UXFileInfoStub,
 } from "../lib/src/common/types.ts";
-import { CHeader, ICHeader, ICHeaderLength, ICXHeader, PSCHeader } from "./types.ts";
+import { ICHeader, ICXHeader } from "./types.ts";
 import type ObsidianLiveSyncPlugin from "../main.ts";
 import { writeString } from "../lib/src/string_and_binary/convert.ts";
 import { fireAndForget } from "../lib/src/common/utils.ts";
@@ -63,23 +63,12 @@ export function id2path(id: DocumentID, entry?: EntryHasPath): FilePathWithPrefi
     const fixedPath = temp.join(":") as FilePathWithPrefix;
     return fixedPath;
 }
-export function getPath(entry: AnyEntry) {
-    return id2path(entry._id, entry);
-}
-export function getPathWithoutPrefix(entry: AnyEntry) {
-    const f = getPath(entry);
-    return stripAllPrefixes(f);
-}
 
 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;
-}
+import { isInternalFile } from "@lib/common/typeUtils.ts";
 export function getPathFromUXFileInfo(file: UXFileInfoStub | string | FilePathWithPrefix) {
     if (typeof file == "string") return file as FilePathWithPrefix;
     return file.path;
@@ -137,32 +126,14 @@ export function trimPrefix(target: string, prefix: string) {
     return target.startsWith(prefix) ? target.substring(prefix.length) : target;
 }
 
-/**
- * returns is internal chunk of file
- * @param id ID
- * @returns
- */
-export function isInternalMetadata(id: FilePath | FilePathWithPrefix | DocumentID): boolean {
-    return id.startsWith(ICHeader);
-}
-export function stripInternalMetadataPrefix<T extends FilePath | FilePathWithPrefix | DocumentID>(id: T): T {
-    return id.substring(ICHeaderLength) as T;
-}
-export function id2InternalMetadataId(id: DocumentID): DocumentID {
-    return (ICHeader + id) as DocumentID;
-}
-
-// const CHeaderLength = CHeader.length;
-export function isChunk(str: string): boolean {
-    return str.startsWith(CHeader);
-}
-
-export function isPluginMetadata(str: string): boolean {
-    return str.startsWith(PSCHeader);
-}
-export function isCustomisationSyncMetadata(str: string): boolean {
-    return str.startsWith(ICXHeader);
-}
+export {
+    isInternalMetadata,
+    id2InternalMetadataId,
+    isChunk,
+    isCustomisationSyncMetadata,
+    isPluginMetadata,
+    stripInternalMetadataPrefix,
+} from "@lib/common/typeUtils.ts";
 
 export class PeriodicProcessor {
     _process: () => Promise<any>;
@@ -430,30 +401,6 @@ export function displayRev(rev: string) {
     return `${number}-${hash.substring(0, 6)}`;
 }
 
-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;
 }

src/features/HiddenFileSync/CmdHiddenFileSync.ts

@@ -30,19 +30,18 @@ import {
 import {
     compareMTime,
     unmarkChanges,
-    getPath,
     isInternalMetadata,
     markChangesAreSame,
     PeriodicProcessor,
     TARGET_IS_NEW,
     scheduleTask,
-    getDocProps,
     getLogLevel,
     autosaveCache,
     type MapLike,
     onlyInNTimes,
     BASE_IS_NEW,
     EVEN,
+    displayRev,
 } from "../../common/utils.ts";
 import { serialized, skipIfDuplicated } from "octagonal-wheels/concurrency/lock";
 import { JsonResolveModal } from "../HiddenFileCommon/JsonResolveModal.ts";
@@ -139,6 +138,7 @@ export class HiddenFileSync extends LiveSyncCommands {
             this.updateSettingCache();
         });
     }
+
     // We cannot initialise autosaveCache because kvDB is not ready yet
     // async _everyOnInitializeDatabase(db: LiveSyncLocalDB): Promise<boolean> {
     //     this._fileInfoLastProcessed = await autosaveCache(this.kvDB, "hidden-file-lastProcessed");
@@ -243,7 +243,7 @@ export class HiddenFileSync extends LiveSyncCommands {
         if (isInternalMetadata(doc._id)) {
             if (this.isThisModuleEnabled()) {
                 //system file
-                const filename = getPath(doc);
+                const filename = this.getPath(doc);
                 if (await this.services.vault.isTargetFile(filename)) {
                     // this.procInternalFile(filename);
                     await this.processReplicationResult(doc);
@@ -843,9 +843,32 @@ Offline Changed files: ${processFiles.length}`;
     // <-- Conflict processing
 
     // --> Event Source Handler (Database)
-
+    getDocProps(doc: LoadedEntry) {
+        /*
+            type DocumentProps = {
+                id: DocumentID;
+                rev?: string;
+                prefixedPath: FilePathWithPrefix;
+                path: FilePath;
+                isDeleted: boolean;
+                revDisplay: string;
+                shortenedId: string;
+                shortenedPath: string;
+            };
+        */
+        const id = doc._id;
+        const shortenedId = id.substring(0, 10);
+        const prefixedPath = this.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 };
+    }
     async processReplicationResult(doc: LoadedEntry): Promise<boolean> {
-        const info = getDocProps(doc);
+        const info = this.getDocProps(doc);
         const path = info.path;
         const headerLine = `Tracking DB ${info.path} (${info.revDisplay}) :`;
         const ret = await this.trackDatabaseFileModification(path, headerLine);
@@ -1007,7 +1030,7 @@ Offline Changed files: ${processFiles.length}`;
             p.log("Enumerating database files...");
             const currentDatabaseFiles = await this.getAllDatabaseFiles();
             const allDatabaseMap = Object.fromEntries(
-                currentDatabaseFiles.map((e) => [stripAllPrefixes(getPath(e)), e])
+                currentDatabaseFiles.map((e) => [stripAllPrefixes(this.getPath(e)), e])
             );
             const currentDatabaseFileNames = [...Object.keys(allDatabaseMap)] as FilePath[];
             const untrackedLocal = currentStorageFiles.filter((e) => !this._fileInfoLastProcessed.has(e));
@@ -1250,14 +1273,14 @@ Offline Changed files: ${files.length}`;
             : currentStorageFilesAll;
         p.log("Enumerating database files...");
         const allDatabaseFiles = await this.getAllDatabaseFiles();
-        const allDatabaseMap = new Map(allDatabaseFiles.map((e) => [stripAllPrefixes(getPath(e)), e]));
+        const allDatabaseMap = new Map(allDatabaseFiles.map((e) => [stripAllPrefixes(this.getPath(e)), e]));
         const currentDatabaseFiles = targetFiles
-            ? allDatabaseFiles.filter((e) => targetFiles.some((f) => f == stripAllPrefixes(getPath(e))))
+            ? allDatabaseFiles.filter((e) => targetFiles.some((f) => f == stripAllPrefixes(this.getPath(e))))
             : allDatabaseFiles;
 
         const allFileNames = new Set([
             ...currentStorageFiles,
-            ...currentDatabaseFiles.map((e) => stripAllPrefixes(getPath(e))),
+            ...currentDatabaseFiles.map((e) => stripAllPrefixes(this.getPath(e))),
         ]);
         const storageToDatabase = [] as FilePath[];
         const databaseToStorage = [] as MetaEntry[];
@@ -1340,7 +1363,7 @@ Offline Changed files: ${files.length}`;
         // 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.filter((e) => targetFiles.some((f) => f == stripAllPrefixes(this.getPath(e))))
             : allFiles;
 
         p.once(`Database to Storage: ${currentFiles.length} files.`);
@@ -1383,7 +1406,7 @@ Offline Changed files: ${files.length}`;
             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)));
+            const updatedFiles = updatedEntries.map((e) => stripAllPrefixes(this.getPath(e)));
             // making doubly sure, No more losing files.
             await this.adoptCurrentStorageFilesAsProcessed(updatedFiles);
             await this.adoptCurrentDatabaseFilesAsProcessed(updatedFiles);

src/features/LiveSyncCommands.ts

@@ -1,5 +1,4 @@
 import { LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
-import { getPath } from "../common/utils.ts";
 import {
     LOG_LEVEL_INFO,
     LOG_LEVEL_NOTICE,
@@ -36,8 +35,9 @@ export abstract class LiveSyncCommands {
     async path2id(filename: FilePathWithPrefix | FilePath, prefix?: string): Promise<DocumentID> {
         return await this.services.path.path2id(filename, prefix);
     }
+
     getPath(entry: AnyEntry): FilePathWithPrefix {
-        return getPath(entry);
+        return this.services.path.getPath(entry);
     }
 
     constructor(plugin: ObsidianLiveSyncPlugin) {

src/features/P2PSync/P2PReplicator/P2PReplicatorPane.svelte

@@ -33,18 +33,15 @@
     const initialSettings = { ...plugin.settings };
 
     let settings = $state<P2PSyncSetting>(initialSettings);
-    // const vaultName = service.vault.getVaultName();
-    // const dbKey = `${vaultName}-p2p-device-name`;
 
-    const initialDeviceName = cmdSync.getConfig(SETTING_KEY_P2P_DEVICE_NAME) ?? plugin.services.vault.getVaultName();
-    let deviceName = $state<string>(initialDeviceName);
+    let deviceName = $state<string>("");
 
     let eP2PEnabled = $state<boolean>(initialSettings.P2P_Enabled);
     let eRelay = $state<string>(initialSettings.P2P_relays);
     let eRoomId = $state<string>(initialSettings.P2P_roomID);
     let ePassword = $state<string>(initialSettings.P2P_passphrase);
     let eAppId = $state<string>(initialSettings.P2P_AppID);
-    let eDeviceName = $state<string>(initialDeviceName);
+    let eDeviceName = $state<string>("");
     let eAutoAccept = $state<boolean>(initialSettings.P2P_AutoAccepting == AutoAccepting.ALL);
     let eAutoStart = $state<boolean>(initialSettings.P2P_AutoStart);
     let eAutoBroadcast = $state<boolean>(initialSettings.P2P_AutoBroadcast);
@@ -103,6 +100,11 @@
     let serverInfo = $state<P2PServerInfo | undefined>(undefined);
     let replicatorInfo = $state<P2PReplicatorStatus | undefined>(undefined);
     const applyLoadSettings = (d: P2PSyncSetting, force: boolean) => {
+        if(force){
+            const initDeviceName = cmdSync.getConfig(SETTING_KEY_P2P_DEVICE_NAME) ?? plugin.services.vault.getVaultName();
+            deviceName = initDeviceName;
+            eDeviceName = initDeviceName;
+        }
         const { P2P_relays, P2P_roomID, P2P_passphrase, P2P_AppID, P2P_AutoAccepting } = d;
         if (force || !isP2PEnabledModified) eP2PEnabled = d.P2P_Enabled;
         if (force || !isRelayModified) eRelay = P2P_relays;

src/main.ts

@@ -126,31 +126,31 @@ export default class ObsidianLiveSyncPlugin
         new ModuleRemoteGovernor(this),
         new ModuleTargetFilter(this),
         new ModulePeriodicProcess(this),
-        // Obsidian modules
+        // Essential Modules
         new ModuleKeyValueDB(this),
         new ModuleInitializerFile(this),
         new ModuleObsidianAPI(this, this),
         new ModuleObsidianEvents(this, this),
         new ModuleFileAccessObsidian(this, this),
-        new ModuleObsidianSettings(this, this),
+        new ModuleObsidianSettings(this),
         new ModuleResolvingMismatchedTweaks(this),
-        new ModuleObsidianSettingsAsMarkdown(this, this),
+        new ModuleObsidianSettingsAsMarkdown(this),
         new ModuleObsidianSettingDialogue(this, this),
         new ModuleLog(this, this),
-        new ModuleObsidianMenu(this, this),
+        new ModuleObsidianMenu(this),
         new ModuleRebuilder(this),
-        new ModuleSetupObsidian(this, this),
+        new ModuleSetupObsidian(this),
         new ModuleObsidianDocumentHistory(this, this),
         new ModuleMigration(this),
         new ModuleRedFlag(this),
         new ModuleInteractiveConflictResolver(this, this),
         new ModuleObsidianGlobalHistory(this, this),
-        new ModuleCheckRemoteSize(this, this),
+        new ModuleCheckRemoteSize(this),
         // Test and Dev Modules
         new ModuleDev(this, this),
         new ModuleReplicateTest(this, this),
         new ModuleIntegratedTest(this, this),
-        new SetupManager(this, this),
+        new SetupManager(this),
     ] as (IObsidianModule | AbstractModule)[];
 
     getModule<T extends IObsidianModule>(constructor: new (...args: any[]) => T): T {

src/modules/AbstractModule.ts

@@ -1,7 +1,8 @@
 import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
-import type { LOG_LEVEL } from "../lib/src/common/types";
-import type { LiveSyncCore } from "../main";
-import { __$checkInstanceBinding } from "../lib/src/dev/checks";
+import type { AnyEntry, FilePathWithPrefix, LOG_LEVEL } from "@lib/common/types";
+import type { LiveSyncCore } from "@/main";
+import { __$checkInstanceBinding } from "@lib/dev/checks";
+import { stripAllPrefixes } from "@lib/string_and_binary/path";
 
 export abstract class AbstractModule {
     _log = (msg: any, level: LOG_LEVEL = LOG_LEVEL_INFO, key?: string) => {
@@ -12,6 +13,11 @@ export abstract class AbstractModule {
         Logger(msg, level, key);
     };
 
+    addCommand = this.services.API.addCommand.bind(this.services.API);
+    registerView = this.services.API.registerWindow.bind(this.services.API);
+    addRibbonIcon = this.services.API.addRibbonIcon.bind(this.services.API);
+    registerObsidianProtocolHandler = this.services.API.registerProtocolHandler.bind(this.services.API);
+
     get localDatabase() {
         return this.core.localDatabase;
     }
@@ -22,6 +28,14 @@ export abstract class AbstractModule {
         this.core.settings = value;
     }
 
+    getPath(entry: AnyEntry): FilePathWithPrefix {
+        return this.services.path.getPath(entry);
+    }
+
+    getPathWithoutPrefix(entry: AnyEntry): FilePathWithPrefix {
+        return stripAllPrefixes(this.services.path.getPath(entry));
+    }
+
     onBindFunction(core: LiveSyncCore, services: typeof core.services) {
         // Override if needed.
     }
@@ -62,4 +76,14 @@ export abstract class AbstractModule {
     get services() {
         return this.core._services;
     }
+
+    isMainReady() {
+        return this.services.appLifecycle.isReady();
+    }
+    isMainSuspended() {
+        return this.services.appLifecycle.isSuspended();
+    }
+    isDatabaseReady() {
+        return this.services.database.isDatabaseReady();
+    }
 }

src/modules/AbstractObsidianModule.ts

@@ -10,20 +10,6 @@ export type ModuleKeys = keyof IObsidianModule;
 export type ChainableModuleProps = ChainableExecuteFunction<ObsidianLiveSyncPlugin>;
 
 export abstract class AbstractObsidianModule extends AbstractModule {
-    addCommand = this.plugin.addCommand.bind(this.plugin);
-    registerView = this.plugin.registerView.bind(this.plugin);
-    addRibbonIcon = this.plugin.addRibbonIcon.bind(this.plugin);
-    registerObsidianProtocolHandler = this.plugin.registerObsidianProtocolHandler.bind(this.plugin);
-
-    get localDatabase() {
-        return this.plugin.localDatabase;
-    }
-    get settings() {
-        return this.plugin.settings;
-    }
-    set settings(value) {
-        this.plugin.settings = value;
-    }
     get app() {
         return this.plugin.app;
     }
@@ -35,18 +21,6 @@ export abstract class AbstractObsidianModule extends AbstractModule {
         super(core);
     }
 
-    saveSettings = this.plugin.saveSettings.bind(this.plugin);
-
-    isMainReady() {
-        return this.services.appLifecycle.isReady();
-    }
-    isMainSuspended() {
-        return this.services.appLifecycle.isSuspended();
-    }
-    isDatabaseReady() {
-        return this.services.database.isDatabaseReady();
-    }
-
     //should be overridden
     isThisModuleEnabled() {
         return true;

src/modules/core/ModuleFileHandler.ts

@@ -10,14 +10,7 @@ import type {
     UXInternalFileInfoStub,
 } from "../../lib/src/common/types";
 import { AbstractModule } from "../AbstractModule.ts";
-import {
-    compareFileFreshness,
-    EVEN,
-    getPath,
-    getPathWithoutPrefix,
-    getStoragePathFromUXFileInfo,
-    markChangesAreSame,
-} from "../../common/utils";
+import { compareFileFreshness, EVEN, getStoragePathFromUXFileInfo, markChangesAreSame } from "../../common/utils";
 import { getDocDataAsArray, isDocContentSame, readAsBlob, readContent } from "../../lib/src/common/utils";
 import { shouldBeIgnored } from "../../lib/src/string_and_binary/path";
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
@@ -209,13 +202,13 @@ export class ModuleFileHandler extends AbstractModule {
     ): Promise<boolean> {
         const file = typeof info === "string" ? this.storage.getFileStub(info) : info;
         const mode = file == null ? "create" : "modify";
-        const pathFromEntryInfo = typeof entryInfo === "string" ? entryInfo : getPath(entryInfo);
+        const pathFromEntryInfo = typeof entryInfo === "string" ? entryInfo : this.getPath(entryInfo);
         const docEntry = await this.db.fetchEntryMeta(pathFromEntryInfo, undefined, true);
         if (!docEntry) {
             this._log(`File ${pathFromEntryInfo} is not exist on the database`, LOG_LEVEL_VERBOSE);
             return false;
         }
-        const path = getPath(docEntry);
+        const path = this.getPath(docEntry);
 
         // 1. Check if it already conflicted.
         const revs = await this.db.getConflictedRevs(path);
@@ -364,11 +357,11 @@ export class ModuleFileHandler extends AbstractModule {
                 this._log(`File ${entry.path} should be ignored`, LOG_LEVEL_VERBOSE);
                 return false;
             }
-            const path = getPath(entry);
+            const path = this.getPath(entry);
 
-            const targetFile = this.storage.getStub(getPathWithoutPrefix(entry));
+            const targetFile = this.storage.getStub(this.getPathWithoutPrefix(entry));
             if (targetFile && targetFile.isFolder) {
-                this._log(`${getPath(entry)} is already exist as the folder`);
+                this._log(`${path} is already exist as the folder`);
                 // Nothing to do and other modules should also nothing to do.
                 return true;
             } else {

src/modules/core/ModuleLocalDatabaseObsidian.ts

@@ -22,9 +22,9 @@ export class ModuleLocalDatabaseObsidian extends AbstractModule {
                 return getDB();
             },
             getActiveReplicator: () => this.core.replicator,
-            id2path: this.services.path.id2path,
+            id2path: this.services.path.id2path.bind(this.services.path),
             // path2id: this.core.$$path2id.bind(this.core),
-            path2id: this.services.path.path2id,
+            path2id: this.services.path.path2id.bind(this.services.path),
             get settings() {
                 return getSettings();
             },

src/modules/core/ModuleTargetFilter.ts

@@ -1,185 +1,155 @@
-import { LRUCache } from "octagonal-wheels/memory/LRUCache";
-import {
-    getStoragePathFromUXFileInfo,
-    id2path,
-    isInternalMetadata,
-    path2id,
-    stripInternalMetadataPrefix,
-    useMemo,
-} from "../../common/utils";
-import {
-    LOG_LEVEL_VERBOSE,
-    type DocumentID,
-    type EntryHasPath,
-    type FilePath,
-    type FilePathWithPrefix,
-    type ObsidianLiveSyncSettings,
-    type UXFileInfoStub,
-} from "../../lib/src/common/types";
-import { addPrefix, isAcceptedAll } from "../../lib/src/string_and_binary/path";
+import { getStoragePathFromUXFileInfo } from "../../common/utils";
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE, type UXFileInfoStub } from "../../lib/src/common/types";
+import { isAcceptedAll } from "../../lib/src/string_and_binary/path";
 import { AbstractModule } from "../AbstractModule";
-import { EVENT_REQUEST_RELOAD_SETTING_TAB, EVENT_SETTING_SAVED, eventHub } from "../../common/events";
-import { isDirty } from "../../lib/src/common/utils";
 import type { LiveSyncCore } from "../../main";
+import { Computed } from "octagonal-wheels/dataobject/Computed";
 export class ModuleTargetFilter extends AbstractModule {
-    reloadIgnoreFiles() {
+    ignoreFiles: string[] = [];
+    private refreshSettings() {
         this.ignoreFiles = this.settings.ignoreFiles.split(",").map((e) => e.trim());
-    }
-    private _everyOnload(): Promise<boolean> {
-        this.reloadIgnoreFiles();
-        eventHub.onEvent(EVENT_SETTING_SAVED, (evt: ObsidianLiveSyncSettings) => {
-            this.reloadIgnoreFiles();
-        });
-        eventHub.onEvent(EVENT_REQUEST_RELOAD_SETTING_TAB, () => {
-            this.reloadIgnoreFiles();
-        });
         return Promise.resolve(true);
     }
 
-    _id2path(id: DocumentID, entry?: EntryHasPath, stripPrefix?: boolean): FilePathWithPrefix {
-        const tempId = id2path(id, entry);
-        if (stripPrefix && isInternalMetadata(tempId)) {
-            const out = stripInternalMetadataPrefix(tempId);
-            return out;
-        }
-        return tempId;
-    }
-    async _path2id(filename: FilePathWithPrefix | FilePath, prefix?: string): Promise<DocumentID> {
-        const destPath = addPrefix(filename, prefix ?? "");
-        return await path2id(
-            destPath,
-            this.settings.usePathObfuscation ? this.settings.passphrase : "",
-            !this.settings.handleFilenameCaseSensitive
-        );
-    }
-
-    private _isFileSizeExceeded(size: number) {
-        if (this.settings.syncMaxSizeInMB > 0 && size > 0) {
-            if (this.settings.syncMaxSizeInMB * 1024 * 1024 < size) {
-                return true;
-            }
-        }
-        return false;
+    private _everyOnload(): Promise<boolean> {
+        void this.refreshSettings();
+        return Promise.resolve(true);
     }
 
     _markFileListPossiblyChanged(): void {
         this.totalFileEventCount++;
     }
-    totalFileEventCount = 0;
-    get fileListPossiblyChanged() {
-        if (isDirty("totalFileEventCount", this.totalFileEventCount)) {
-            return true;
-        }
-        return false;
-    }
 
-    private async _isTargetFile(file: string | UXFileInfoStub, keepFileCheckList = false) {
-        const fileCount = useMemo<Record<string, number>>(
-            {
-                key: "fileCount", // forceUpdate: !keepFileCheckList,
-            },
-            (ctx, prev) => {
-                if (keepFileCheckList && prev) return prev;
-                if (!keepFileCheckList && prev && !this.fileListPossiblyChanged) {
-                    return prev;
+    fileCountMap = new Computed({
+        evaluation: (fileEventCount: number) => {
+            const vaultFiles = this.core.storageAccess.getFileNames().sort();
+            const fileCountMap: Record<string, number> = {};
+            for (const file of vaultFiles) {
+                const lc = file.toLowerCase();
+                if (!fileCountMap[lc]) {
+                    fileCountMap[lc] = 1;
+                } else {
+                    fileCountMap[lc]++;
                 }
-                const fileList = (ctx.get("fileList") ?? []) as FilePathWithPrefix[];
-                // const fileNameList = (ctx.get("fileNameList") ?? []) as FilePath[];
-                // const fileNames =
-                const vaultFiles = this.core.storageAccess.getFileNames().sort();
-                if (prev && vaultFiles.length == fileList.length) {
-                    const fl3 = new Set([...fileList, ...vaultFiles]);
-                    if (fileList.length == fl3.size && vaultFiles.length == fl3.size) {
-                        return prev;
-                    }
-                }
-                ctx.set("fileList", vaultFiles);
-
-                const fileCount: Record<string, number> = {};
-                for (const file of vaultFiles) {
-                    const lc = file.toLowerCase();
-                    if (!fileCount[lc]) {
-                        fileCount[lc] = 1;
-                    } else {
-                        fileCount[lc]++;
-                    }
-                }
-                return fileCount;
             }
-        );
+            return fileCountMap;
+        },
+        requiresUpdate: (args, previousArgs, previousResult) => {
+            if (!previousResult) return true;
+            if (previousResult instanceof Error) return true;
+            if (!previousArgs) return true;
+            if (args[0] === previousArgs[0]) {
+                return false;
+            }
+            return true;
+        },
+    });
+
+    totalFileEventCount = 0;
+
+    private async _isTargetFileByFileNameDuplication(file: string | UXFileInfoStub) {
+        await this.fileCountMap.updateValue(this.totalFileEventCount);
+        const fileCountMap = this.fileCountMap.value;
+        if (!fileCountMap) {
+            this._log("File count map is not ready yet.");
+            return false;
+        }
 
         const filepath = getStoragePathFromUXFileInfo(file);
         const lc = filepath.toLowerCase();
-        if (this.services.setting.shouldCheckCaseInsensitively()) {
-            if (lc in fileCount && fileCount[lc] > 1) {
+        if (this.services.vault.shouldCheckCaseInsensitively()) {
+            if (lc in fileCountMap && fileCountMap[lc] > 1) {
+                this._log("File is duplicated (case-insensitive): " + filepath);
                 return false;
             }
         }
-        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.
-                await this.readIgnoreFile(filepath);
-            }
-            if (await this.services.vault.isIgnoredByIgnoreFile(file)) {
-                return false;
-            }
-        }
-        if (!this.localDatabase?.isTargetFile(filepath)) return false;
+        this._log("File is not duplicated: " + filepath, LOG_LEVEL_DEBUG);
         return true;
     }
 
-    ignoreFileCache = new LRUCache<string, string[] | false>(300, 250000, true);
-    ignoreFiles = [] as string[];
-    async readIgnoreFile(path: string) {
+    private ignoreFileCacheMap = new Map<string, string[] | undefined | false>();
+
+    private invalidateIgnoreFileCache(path: string) {
+        // This erases `/path/to/.ignorefile` from cache, therefore, next access will reload it.
+        // When detecting edited the ignore file, this method should be called.
+        // Do not check whether it exists in cache or not; just delete it.
+        const key = path.toLowerCase();
+        this.ignoreFileCacheMap.delete(key);
+    }
+    private async getIgnoreFile(path: string): Promise<string[] | false> {
+        const key = path.toLowerCase();
+        const cached = this.ignoreFileCacheMap.get(key);
+        if (cached !== undefined) {
+            // if cached is not undefined, cache hit (neither exists or not exists, string[] or false).
+            return cached;
+        }
         try {
-            // this._log(`[ignore]Reading ignore file: ${path}`, LOG_LEVEL_VERBOSE);
+            // load the ignore file
             if (!(await this.core.storageAccess.isExistsIncludeHidden(path))) {
-                this.ignoreFileCache.set(path, false);
-                // this._log(`[ignore]Ignore file not found: ${path}`, LOG_LEVEL_VERBOSE);
+                // file does not exist, cache as not exists
+                this.ignoreFileCacheMap.set(key, false);
                 return false;
             }
             const file = await this.core.storageAccess.readHiddenFileText(path);
-            const gitignore = file.split(/\r?\n/g);
-            this.ignoreFileCache.set(path, gitignore);
-            this._log(`[ignore]Ignore file loaded: ${path}`, LOG_LEVEL_VERBOSE);
+            const gitignore = file
+                .split(/\r?\n/g)
+                .map((e) => e.replace(/\r$/, ""))
+                .map((e) => e.trim());
+            this.ignoreFileCacheMap.set(key, gitignore);
+            this._log(`[ignore] Ignore file loaded: ${path}`, LOG_LEVEL_VERBOSE);
             return gitignore;
         } catch (ex) {
-            this._log(`[ignore]Failed to read ignore file ${path}`);
+            // Failed to read the ignore file, delete cache.
+            this._log(`[ignore] Failed to read ignore file ${path}`);
             this._log(ex, LOG_LEVEL_VERBOSE);
-            this.ignoreFileCache.set(path, false);
+            this.ignoreFileCacheMap.set(key, undefined);
             return false;
         }
     }
-    async getIgnoreFile(path: string) {
-        if (this.ignoreFileCache.has(path)) {
-            return this.ignoreFileCache.get(path) ?? false;
-        } else {
-            return await this.readIgnoreFile(path);
-        }
-    }
-    private async _isIgnoredByIgnoreFiles(file: string | UXFileInfoStub): Promise<boolean> {
-        if (!this.settings.useIgnoreFiles) {
-            return false;
-        }
+
+    private async _isTargetFileByLocalDB(file: string | UXFileInfoStub) {
         const filepath = getStoragePathFromUXFileInfo(file);
-        if (this.ignoreFileCache.has(filepath)) {
-            // Renew
-            await this.readIgnoreFile(filepath);
+        if (!this.localDatabase?.isTargetFile(filepath)) {
+            this._log("File is not target by local DB: " + filepath);
+            return false;
         }
-        if (!(await isAcceptedAll(filepath, this.ignoreFiles, (filename) => this.getIgnoreFile(filename)))) {
+        this._log("File is target by local DB: " + filepath, LOG_LEVEL_DEBUG);
+        return await Promise.resolve(true);
+    }
+
+    private async _isTargetFileFinal(file: string | UXFileInfoStub) {
+        this._log("File is target finally: " + getStoragePathFromUXFileInfo(file), LOG_LEVEL_DEBUG);
+        return await Promise.resolve(true);
+    }
+
+    private async _isTargetIgnoredByIgnoreFiles(file: string | UXFileInfoStub): Promise<boolean> {
+        if (!this.settings.useIgnoreFiles) {
             return true;
         }
-        return false;
+        const filepath = getStoragePathFromUXFileInfo(file);
+        this.invalidateIgnoreFileCache(filepath);
+        this._log("Checking ignore files for: " + filepath, LOG_LEVEL_DEBUG);
+        if (!(await isAcceptedAll(filepath, this.ignoreFiles, (filename) => this.getIgnoreFile(filename)))) {
+            this._log("File is ignored by ignore files: " + filepath);
+            return false;
+        }
+        this._log("File is not ignored by ignore files: " + filepath, LOG_LEVEL_DEBUG);
+        return true;
     }
 
     onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
         services.vault.markFileListPossiblyChanged.setHandler(this._markFileListPossiblyChanged.bind(this));
-        services.path.id2path.setHandler(this._id2path.bind(this));
-        services.path.path2id.setHandler(this._path2id.bind(this));
         services.appLifecycle.onLoaded.addHandler(this._everyOnload.bind(this));
-        services.vault.isFileSizeTooLarge.setHandler(this._isFileSizeExceeded.bind(this));
-        services.vault.isIgnoredByIgnoreFile.setHandler(this._isIgnoredByIgnoreFiles.bind(this));
-        services.vault.isTargetFile.setHandler(this._isTargetFile.bind(this));
+        services.vault.isIgnoredByIgnoreFile.setHandler(this._isTargetIgnoredByIgnoreFiles.bind(this));
+        services.vault.isTargetFile.addHandler(this._isTargetFileByFileNameDuplication.bind(this));
+        services.vault.isTargetFile.addHandler(this._isTargetIgnoredByIgnoreFiles.bind(this));
+        services.vault.isTargetFile.addHandler(this._isTargetFileByLocalDB.bind(this));
+        services.vault.isTargetFile.addHandler(this._isTargetFileFinal.bind(this));
+        services.setting.onSettingRealised.addHandler(this.refreshSettings.bind(this));
+        // services.vault.isTargetFile.use((ctx, next) => {
+        //     const [fileName, keepFileCheckList] = ctx.args;
+        //     const file = getS
+
+        // });
     }
 }

src/modules/core/ReplicateResultProcessor.ts

@@ -8,7 +8,7 @@ import {
     type MetaEntry,
 } from "@/lib/src/common/types";
 import type { ModuleReplicator } from "./ModuleReplicator";
-import { getPath, isChunk, isValidPath } from "@/common/utils";
+import { isChunk, isValidPath } from "@/common/utils";
 import type { LiveSyncCore } from "@/main";
 import {
     LOG_LEVEL_DEBUG,
@@ -58,6 +58,10 @@ export class ReplicateResultProcessor {
         return this.replicator.core;
     }
 
+    getPath(entry: AnyEntry): string {
+        return this.services.path.getPath(entry);
+    }
+
     public suspend() {
         this._suspended = true;
     }
@@ -230,7 +234,7 @@ export class ReplicateResultProcessor {
      */
     protected enqueueChange(doc: PouchDB.Core.ExistingDocument<EntryDoc>) {
         const old = this._queuedChanges.find((e) => e._id == doc._id);
-        const path = "path" in doc ? getPath(doc) : "<unknown>";
+        const path = "path" in doc ? this.getPath(doc) : "<unknown>";
         const docNote = `${path} (${shortenId(doc._id)}, ${shortenRev(doc._rev)})`;
         if (old) {
             if (old._rev == doc._rev) {
@@ -322,7 +326,7 @@ export class ReplicateResultProcessor {
                 const docMtime = change.mtime ?? 0;
                 const maxMTime = this.replicator.settings.maxMTimeForReflectEvents;
                 if (maxMTime > 0 && docMtime > maxMTime) {
-                    const docPath = getPath(change);
+                    const docPath = this.getPath(change);
                     this.log(
                         `Processing ${docPath} has been skipped due to modification time (${new Date(
                             docMtime * 1000
@@ -336,7 +340,7 @@ export class ReplicateResultProcessor {
             if (await this.services.replication.processVirtualDocument(change)) return;
             // If the document is version info, check compatibility and return.
             if (isAnyNote(change)) {
-                const docPath = getPath(change);
+                const docPath = this.getPath(change);
                 if (!(await this.services.vault.isTargetFile(docPath))) {
                     this.log(`Skipped: ${docPath}`, LOG_LEVEL_VERBOSE);
                     return;
@@ -383,7 +387,7 @@ export class ReplicateResultProcessor {
     // This function is serialized per document to avoid race-condition for the same document.
     private _applyToDatabase(doc_: PouchDB.Core.ExistingDocument<AnyEntry>) {
         const dbDoc = doc_ as LoadedEntry; // It has no `data`
-        const path = getPath(dbDoc);
+        const path = this.getPath(dbDoc);
         return serialized(`replication-process:${dbDoc._id}`, async () => {
             const docNote = `${path} (${shortenId(dbDoc._id)}, ${shortenRev(dbDoc._rev)})`;
             const isRequired = await this.checkIsChangeRequiredForDatabaseProcessing(dbDoc);
@@ -409,7 +413,7 @@ export class ReplicateResultProcessor {
             if (await this.services.replication.processOptionalSynchroniseResult(dbDoc)) {
                 // Already processed
                 this.log(`Processed by other processor: ${docNote}`, LOG_LEVEL_DEBUG);
-            } else if (isValidPath(getPath(doc))) {
+            } else if (isValidPath(this.getPath(doc))) {
                 // Apply to storage if the path is valid
                 await this.applyToStorage(doc as MetaEntry);
                 this.log(`Processed: ${docNote}`, LOG_LEVEL_DEBUG);
@@ -437,7 +441,7 @@ export class ReplicateResultProcessor {
      * @returns True if processing is required; false otherwise
      */
     protected async checkIsChangeRequiredForDatabaseProcessing(dbDoc: LoadedEntry): Promise<boolean> {
-        const path = getPath(dbDoc);
+        const path = this.getPath(dbDoc);
         try {
             const savedDoc = await this.localDatabase.getRaw<LoadedEntry>(dbDoc._id, {
                 conflicts: true,

src/modules/coreObsidian/ModuleFileAccessObsidian.ts

@@ -56,10 +56,6 @@ export class ModuleFileAccessObsidian extends AbstractObsidianModule implements
     restoreState() {
         return this.vaultManager.restoreState();
     }
-    private _everyOnload(): Promise<boolean> {
-        this.core.storageAccess = this;
-        return Promise.resolve(true);
-    }
     async _everyOnFirstInitialize(): Promise<boolean> {
         await this.vaultManager.beginWatch();
         return Promise.resolve(true);
@@ -76,18 +72,10 @@ export class ModuleFileAccessObsidian extends AbstractObsidianModule implements
 
     _everyOnloadStart(): Promise<boolean> {
         this.vaultAccess = new SerializedFileAccess(this.app, this.plugin, this);
+        this.core.storageAccess = this;
         return Promise.resolve(true);
     }
 
-    _isStorageInsensitive(): boolean {
-        return this.vaultAccess.isStorageInsensitive();
-    }
-
-    _shouldCheckCaseInsensitive(): boolean {
-        if (this.services.vault.isStorageInsensitive()) return false;
-        return !this.settings.handleFilenameCaseSensitive;
-    }
-
     async writeFileAuto(path: string, data: string | ArrayBuffer, opt?: UXDataWriteOptions): Promise<boolean> {
         const file = this.vaultAccess.getAbstractFileByPath(path);
         if (file instanceof TFile) {
@@ -386,11 +374,8 @@ export class ModuleFileAccessObsidian extends AbstractObsidianModule implements
         super(plugin, core);
     }
     onBindFunction(core: LiveSyncCore, services: InjectableServiceHub): void {
-        services.vault.isStorageInsensitive.setHandler(this._isStorageInsensitive.bind(this));
-        services.setting.shouldCheckCaseInsensitively.setHandler(this._shouldCheckCaseInsensitive.bind(this));
         services.appLifecycle.onFirstInitialise.addHandler(this._everyOnFirstInitialize.bind(this));
         services.appLifecycle.onInitialise.addHandler(this._everyOnloadStart.bind(this));
-        services.appLifecycle.onLoaded.addHandler(this._everyOnload.bind(this));
         services.fileProcessing.commitPendingFileEvents.addHandler(this._everyCommitPendingFileEvent.bind(this));
     }
 }

src/modules/coreObsidian/storageLib/SerializedFileAccess.ts

@@ -1,11 +1,12 @@
 import { type App, TFile, type DataWriteOptions, TFolder, TAbstractFile } from "../../../deps.ts";
 import { Logger } from "../../../lib/src/common/logger.ts";
 import { isPlainText } from "../../../lib/src/string_and_binary/path.ts";
-import type { FilePath, HasSettings, UXFileInfoStub } from "../../../lib/src/common/types.ts";
+import type { FilePath, UXFileInfoStub } from "../../../lib/src/common/types.ts";
 import { createBinaryBlob, isDocContentSame } from "../../../lib/src/common/utils.ts";
 import type { InternalFileInfo } from "../../../common/types.ts";
 import { markChangesAreSame } from "../../../common/utils.ts";
 import type { StorageAccess } from "../../interfaces/StorageAccess.ts";
+import type { LiveSyncCore } from "@/main.ts";
 function toArrayBuffer(arr: Uint8Array<ArrayBuffer> | ArrayBuffer | DataView<ArrayBuffer>): ArrayBuffer {
     if (arr instanceof Uint8Array) {
         return arr.buffer;
@@ -18,9 +19,9 @@ function toArrayBuffer(arr: Uint8Array<ArrayBuffer> | ArrayBuffer | DataView<Arr
 
 export class SerializedFileAccess {
     app: App;
-    plugin: HasSettings<{ handleFilenameCaseSensitive: boolean }>;
+    plugin: LiveSyncCore;
     storageAccess: StorageAccess;
-    constructor(app: App, plugin: SerializedFileAccess["plugin"], storageAccess: StorageAccess) {
+    constructor(app: App, plugin: LiveSyncCore, storageAccess: StorageAccess) {
         this.app = app;
         this.plugin = plugin;
         this.storageAccess = storageAccess;
@@ -163,8 +164,7 @@ export class SerializedFileAccess {
     }
 
     isStorageInsensitive(): boolean {
-        //@ts-ignore
-        return this.app.vault.adapter.insensitive ?? true;
+        return this.plugin.services.vault.isStorageInsensitive();
     }
 
     getAbstractFileByPathInsensitive(path: FilePath | string): TAbstractFile | null {

src/modules/essential/ModuleInitializerFile.ts

@@ -1,7 +1,7 @@
 import { unique } from "octagonal-wheels/collection";
 import { throttle } from "octagonal-wheels/function";
 import { EVENT_ON_UNRESOLVED_ERROR, eventHub } from "../../common/events.ts";
-import { BASE_IS_NEW, compareFileFreshness, EVEN, getPath, isValidPath, TARGET_IS_NEW } from "../../common/utils.ts";
+import { BASE_IS_NEW, compareFileFreshness, EVEN, isValidPath, TARGET_IS_NEW } from "../../common/utils.ts";
 import {
     type FilePathWithPrefixLC,
     type FilePathWithPrefix,
@@ -120,7 +120,7 @@ export class ModuleInitializerFile extends AbstractModule {
                     showingNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
                     "syncAll"
                 );
-            const path = getPath(doc);
+            const path = this.getPath(doc);
 
             if (isValidPath(path) && (await this.services.vault.isTargetFile(path, true))) {
                 if (!isMetaEntry(doc)) {
@@ -132,7 +132,7 @@ export class ModuleInitializerFile extends AbstractModule {
         }
 
         const databaseFileNameMap = Object.fromEntries(
-            _DBEntries.map((e) => [getPath(e), e] as [FilePathWithPrefix, MetaEntry])
+            _DBEntries.map((e) => [this.getPath(e), e] as [FilePathWithPrefix, MetaEntry])
         );
         const databaseFileNames = Object.keys(databaseFileNameMap) as FilePathWithPrefix[];
         const databaseFileNameCapsPair = databaseFileNames.map(
@@ -224,7 +224,7 @@ export class ModuleInitializerFile extends AbstractModule {
             runAll("UPDATE STORAGE", filesExistOnlyInDatabase, async (e) => {
                 const w = databaseFileNameMap[databaseFileNameCI2CS[e]];
                 // Exists in database but not in storage.
-                const path = getPath(w) ?? e;
+                const path = this.getPath(w) ?? e;
                 if (w && !(w.deleted || w._deleted)) {
                     if (!this.services.vault.isFileSizeTooLarge(w.size)) {
                         // Prevent applying the conflicted state to the storage.
@@ -275,7 +275,7 @@ export class ModuleInitializerFile extends AbstractModule {
                     await this.syncFileBetweenDBandStorage(file, doc);
                 } else {
                     this._log(
-                        `SYNC DATABASE AND STORAGE: ${getPath(doc)} has been skipped due to file size exceeding the limit`,
+                        `SYNC DATABASE AND STORAGE: ${this.getPath(doc)} has been skipped due to file size exceeding the limit`,
                         logLevel
                     );
                 }
@@ -365,7 +365,7 @@ export class ModuleInitializerFile extends AbstractModule {
             if (isAnyNote(doc)) {
                 if (doc.deleted && doc.mtime - limit < 0) {
                     notes.push({
-                        path: getPath(doc),
+                        path: this.getPath(doc),
                         mtime: doc.mtime,
                         ttl: (doc.mtime - limit) / 1000 / 86400,
                         doc: doc,

src/modules/essential/ModuleMigration.ts

@@ -10,7 +10,7 @@ import {
 import { AbstractModule } from "../AbstractModule.ts";
 import { $msg } from "src/lib/src/common/i18n.ts";
 import { performDoctorConsultation, RebuildOptions } from "../../lib/src/common/configForDoc.ts";
-import { getPath, isValidPath } from "../../common/utils.ts";
+import { isValidPath } from "../../common/utils.ts";
 import { isMetaEntry } from "../../lib/src/common/types.ts";
 import { isDeletedEntry, isDocContentSame, isLoadedEntry, readAsBlob } from "../../lib/src/common/utils.ts";
 import { countCompromisedChunks } from "../../lib/src/pouchdb/negotiation.ts";
@@ -128,7 +128,7 @@ export class ModuleMigration extends AbstractModule {
 
         const errorFiles = [] as ErrorInfo[];
         for await (const metaDoc of this.localDatabase.findAllNormalDocs({ conflicts: true })) {
-            const path = getPath(metaDoc);
+            const path = this.getPath(metaDoc);
 
             if (!isValidPath(path)) {
                 continue;

src/modules/essentialObsidian/ModuleCheckRemoteSize.ts

@@ -2,10 +2,10 @@ import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-w
 import { sizeToHumanReadable } from "octagonal-wheels/number";
 import { $msg } from "src/lib/src/common/i18n.ts";
 import type { LiveSyncCore } from "../../main.ts";
-import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
 import { EVENT_REQUEST_CHECK_REMOTE_SIZE, eventHub } from "@/common/events.ts";
+import { AbstractModule } from "../AbstractModule.ts";
 
-export class ModuleCheckRemoteSize extends AbstractObsidianModule {
+export class ModuleCheckRemoteSize extends AbstractModule {
     checkRemoteSize(): Promise<boolean> {
         this.settings.notifyThresholdOfRemoteStorageSize = 1;
         return this._allScanStat();

src/modules/essentialObsidian/ModuleObsidianAPI.ts

@@ -8,8 +8,7 @@ import {
     type LOG_LEVEL,
 } from "octagonal-wheels/common/logger";
 import { Notice, requestUrl, type RequestUrlParam, type RequestUrlResponse } from "../../deps.ts";
-import { type CouchDBCredentials, type EntryDoc, type FilePath } from "../../lib/src/common/types.ts";
-import { getPathFromTFile } from "../../common/utils.ts";
+import { type CouchDBCredentials, type EntryDoc } from "../../lib/src/common/types.ts";
 import { isCloudantURI, isValidRemoteCouchDBURI } from "../../lib/src/pouchdb/utils_couchdb.ts";
 import { replicationFilter } from "@/lib/src/pouchdb/compress.ts";
 import { disableEncryption } from "@/lib/src/pouchdb/encryption.ts";
@@ -279,23 +278,6 @@ export class ModuleObsidianAPI extends AbstractObsidianModule {
         }
     }
 
-    _vaultName(): string {
-        return this.app.vault.getName();
-    }
-    _getVaultName(): string {
-        return (
-            this.services.vault.vaultName() +
-            (this.settings?.additionalSuffixOfDatabaseName ? "-" + this.settings.additionalSuffixOfDatabaseName : "")
-        );
-    }
-    _getActiveFilePath(): FilePath | undefined {
-        const file = this.app.workspace.getActiveFile();
-        if (file) {
-            return getPathFromTFile(file);
-        }
-        return undefined;
-    }
-
     private _reportUnresolvedMessages(): Promise<(string | Error)[]> {
         return Promise.resolve([...this._previousErrors]);
     }
@@ -303,9 +285,6 @@ export class ModuleObsidianAPI extends AbstractObsidianModule {
     onBindFunction(core: LiveSyncCore, services: typeof core.services) {
         services.API.isLastPostFailedDueToPayloadSize.setHandler(this._getLastPostFailedBySize.bind(this));
         services.remote.connect.setHandler(this._connectRemoteCouchDB.bind(this));
-        services.vault.getVaultName.setHandler(this._getVaultName.bind(this));
-        services.vault.vaultName.setHandler(this._vaultName.bind(this));
-        services.vault.getActiveFilePath.setHandler(this._getActiveFilePath.bind(this));
         services.appLifecycle.getUnresolvedMessages.addHandler(this._reportUnresolvedMessages.bind(this));
     }
 }

src/modules/essentialObsidian/ModuleObsidianEvents.ts

@@ -31,13 +31,8 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
         return Promise.resolve(true);
     }
 
-    private _performRestart(): void {
-        this.__performAppReload();
-    }
-
     __performAppReload() {
-        //@ts-ignore
-        this.app.commands.executeCommandById("app:reload");
+        this.services.appLifecycle.performRestart();
     }
 
     initialCallback: any;
@@ -193,6 +188,7 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
             }
         });
     }
+    // TODO: separate
     private _scheduleAppReload() {
         if (!this.core._totalProcessingCount) {
             const __tick = reactiveSource(0);
@@ -246,7 +242,6 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
     onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
         services.appLifecycle.onLayoutReady.addHandler(this._everyOnLayoutReady.bind(this));
         services.appLifecycle.onInitialise.addHandler(this._everyOnloadStart.bind(this));
-        services.appLifecycle.performRestart.setHandler(this._performRestart.bind(this));
         services.appLifecycle.askRestart.setHandler(this._askReload.bind(this));
         services.appLifecycle.scheduleRestart.setHandler(this._scheduleAppReload.bind(this));
     }

src/modules/essentialObsidian/ModuleObsidianMenu.ts

@@ -1,11 +1,11 @@
 import { fireAndForget } from "octagonal-wheels/promises";
 import { addIcon, type Editor, type MarkdownFileInfo, type MarkdownView } from "../../deps.ts";
 import { LOG_LEVEL_NOTICE, type FilePathWithPrefix } from "../../lib/src/common/types.ts";
-import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
 import { $msg } from "src/lib/src/common/i18n.ts";
 import type { LiveSyncCore } from "../../main.ts";
+import { AbstractModule } from "../AbstractModule.ts";
 
-export class ModuleObsidianMenu extends AbstractObsidianModule {
+export class ModuleObsidianMenu extends AbstractModule {
     _everyOnloadStart(): Promise<boolean> {
         // UI
         addIcon(
@@ -105,16 +105,8 @@ export class ModuleObsidianMenu extends AbstractObsidianModule {
         });
         return Promise.resolve(true);
     }
-    private __onWorkspaceReady() {
-        void this.services.appLifecycle.onReady();
-    }
-    private _everyOnload(): Promise<boolean> {
-        this.app.workspace.onLayoutReady(this.__onWorkspaceReady.bind(this));
-        return Promise.resolve(true);
-    }
 
     onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
         services.appLifecycle.onInitialise.addHandler(this._everyOnloadStart.bind(this));
-        services.appLifecycle.onLoaded.addHandler(this._everyOnload.bind(this));
     }
 }

src/modules/features/GlobalHistory/GlobalHistory.svelte

@@ -6,7 +6,6 @@
     import { diff_match_patch } from "../../../deps.ts";
     import { DocumentHistoryModal } from "../DocumentHistory/DocumentHistoryModal.ts";
     import { isPlainText, stripAllPrefixes } from "../../../lib/src/string_and_binary/path.ts";
-    import { getPath } from "../../../common/utils.ts";
     export let plugin: ObsidianLiveSyncPlugin;
 
     let showDiffInfo = false;
@@ -44,6 +43,9 @@
     };
     let history = [] as HistoryData[];
     let loading = false;
+    function getPath(entry: AnyEntry): FilePathWithPrefix {
+        return plugin.services.path.getPath(entry);
+    }
 
     async function fetchChanges(): Promise<HistoryData[]> {
         try {
@@ -219,69 +221,69 @@
     {/if}
     <table>
         <tbody>
-        <tr>
-            <th> Date </th>
-            <th> Path </th>
-            <th> Rev </th>
-            <th> Stat </th>
-            {#if showChunkCorrected}
-                <th> Chunks </th>
-            {/if}
-        </tr>
-        <tr>
-            <td colspan="5" class="more">
-                {#if loading}
-                        <div class=""></div>
-                {:else}
-                    <div><button on:click={() => nextWeek()}>+1 week</button></div>
-                {/if}
-            </td>
-        </tr>
-        {#each history as entry}
             <tr>
-                <td class="mtime">
-                    {entry.mtimeDisp}
+                <th> Date </th>
+                <th> Path </th>
+                <th> Rev </th>
+                <th> Stat </th>
+                {#if showChunkCorrected}
+                    <th> Chunks </th>
+                {/if}
+            </tr>
+            <tr>
+                <td colspan="5" class="more">
+                    {#if loading}
+                        <div class=""></div>
+                    {:else}
+                        <div><button on:click={() => nextWeek()}>+1 week</button></div>
+                    {/if}
                 </td>
-                <td class="path">
-                    <div class="filenames">
-                        <span class="path">/{entry.dirname.split("/").join(`​/`)}</span>
-                        <!-- svelte-ignore a11y-click-events-have-key-events -->
-                        <!-- svelte-ignore a11y-no-static-element-interactions -->
-                        <!-- svelte-ignore a11y-missing-attribute -->
-                        <span class="filename"><a on:click={() => openFile(entry.path)}>{entry.filename}</a></span>
-                    </div>
-                </td>
-                <td>
-                    <span class="rev">
-                        {#if entry.isPlain}
+            </tr>
+            {#each history as entry}
+                <tr>
+                    <td class="mtime">
+                        {entry.mtimeDisp}
+                    </td>
+                    <td class="path">
+                        <div class="filenames">
+                            <span class="path">/{entry.dirname.split("/").join(`​/`)}</span>
                             <!-- svelte-ignore a11y-click-events-have-key-events -->
                             <!-- svelte-ignore a11y-no-static-element-interactions -->
                             <!-- svelte-ignore a11y-missing-attribute -->
-                            <a on:click={() => showHistory(entry.path, entry?.rev || "")}>{entry.rev}</a>
-                        {:else}
-                            {entry.rev}
-                        {/if}
-                    </span>
-                </td>
-                <td>
-                    {entry.changes}
-                </td>
-                {#if showChunkCorrected}
-                    <td>
-                        {entry.chunks}
+                            <span class="filename"><a on:click={() => openFile(entry.path)}>{entry.filename}</a></span>
+                        </div>
                     </td>
-                {/if}
-            </tr>
-        {/each}
-        <tr>
-            <td colspan="5" class="more">
-                {#if loading}
+                    <td>
+                        <span class="rev">
+                            {#if entry.isPlain}
+                                <!-- svelte-ignore a11y-click-events-have-key-events -->
+                                <!-- svelte-ignore a11y-no-static-element-interactions -->
+                                <!-- svelte-ignore a11y-missing-attribute -->
+                                <a on:click={() => showHistory(entry.path, entry?.rev || "")}>{entry.rev}</a>
+                            {:else}
+                                {entry.rev}
+                            {/if}
+                        </span>
+                    </td>
+                    <td>
+                        {entry.changes}
+                    </td>
+                    {#if showChunkCorrected}
+                        <td>
+                            {entry.chunks}
+                        </td>
+                    {/if}
+                </tr>
+            {/each}
+            <tr>
+                <td colspan="5" class="more">
+                    {#if loading}
                         <div class=""></div>
-                {:else}
-                    <div><button on:click={() => prevWeek()}>+1 week</button></div>
-                {/if}
-            </td>
-        </tr>
+                    {:else}
+                        <div><button on:click={() => prevWeek()}>+1 week</button></div>
+                    {/if}
+                </td>
+            </tr>
         </tbody>
     </table>
 </div>

src/modules/features/ModuleInteractiveConflictResolver.ts

@@ -11,7 +11,7 @@ import {
 } from "../../lib/src/common/types.ts";
 import { ConflictResolveModal } from "./InteractiveConflictResolving/ConflictResolveModal.ts";
 import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
-import { displayRev, getPath, getPathWithoutPrefix } from "../../common/utils.ts";
+import { displayRev } from "../../common/utils.ts";
 import { fireAndForget } from "octagonal-wheels/promises";
 import { serialized } from "octagonal-wheels/concurrency/lock";
 import type { LiveSyncCore } from "../../main.ts";
@@ -110,7 +110,12 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
         const notes: { id: DocumentID; path: FilePathWithPrefix; dispPath: string; mtime: number }[] = [];
         for await (const doc of this.localDatabase.findAllDocs({ conflicts: true })) {
             if (!("_conflicts" in doc)) continue;
-            notes.push({ id: doc._id, path: getPath(doc), dispPath: getPathWithoutPrefix(doc), mtime: doc.mtime });
+            notes.push({
+                id: doc._id,
+                path: this.getPath(doc),
+                dispPath: this.getPathWithoutPrefix(doc),
+                mtime: doc.mtime,
+            });
         }
         notes.sort((a, b) => b.mtime - a.mtime);
         const notesList = notes.map((e) => e.dispPath);
@@ -134,7 +139,7 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
         try {
             for await (const doc of this.localDatabase.findAllDocs({ conflicts: true })) {
                 if (!("_conflicts" in doc)) continue;
-                notes.push({ path: getPath(doc), mtime: doc.mtime });
+                notes.push({ path: this.getPath(doc), mtime: doc.mtime });
             }
             if (notes.length > 0) {
                 this.core.confirm.askInPopup(

src/modules/features/ModuleLog.ts

@@ -63,8 +63,6 @@ function addLog(log: string) {
 const showDebugLog = false;
 export const MARK_DONE = "\u{2009}\u{2009}";
 export class ModuleLog extends AbstractObsidianModule {
-    registerView = this.plugin.registerView.bind(this.plugin);
-
     statusBar?: HTMLElement;
 
     statusDiv?: HTMLElement;
@@ -251,7 +249,7 @@ export class ModuleLog extends AbstractObsidianModule {
             }
         }
         // Case Sensitivity
-        if (this.services.setting.shouldCheckCaseInsensitively()) {
+        if (this.services.vault.shouldCheckCaseInsensitively()) {
             const f = this.core.storageAccess
                 .getFiles()
                 .map((e) => e.path)

src/modules/features/ModuleObsidianDocumentHistory.ts

@@ -4,7 +4,6 @@ import { EVENT_REQUEST_SHOW_HISTORY } from "../../common/obsidianEvents.ts";
 import type { FilePathWithPrefix, LoadedEntry, DocumentID } from "../../lib/src/common/types.ts";
 import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
 import { DocumentHistoryModal } from "./DocumentHistory/DocumentHistoryModal.ts";
-import { getPath } from "../../common/utils.ts";
 import { fireAndForget } from "octagonal-wheels/promises";
 
 export class ModuleObsidianDocumentHistory extends AbstractObsidianModule {
@@ -41,7 +40,7 @@ export class ModuleObsidianDocumentHistory extends AbstractObsidianModule {
     async fileHistory() {
         const notes: { id: DocumentID; path: FilePathWithPrefix; dispPath: string; mtime: number }[] = [];
         for await (const doc of this.localDatabase.findAllDocs()) {
-            notes.push({ id: doc._id, path: getPath(doc), dispPath: getPath(doc), mtime: doc.mtime });
+            notes.push({ id: doc._id, path: this.getPath(doc), dispPath: this.getPath(doc), mtime: doc.mtime });
         }
         notes.sort((a, b) => b.mtime - a.mtime);
         const notesList = notes.map((e) => e.dispPath);

src/modules/features/ModuleObsidianSetting.ts

@@ -1,4 +1,3 @@
-import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
 // import { PouchDB } from "../../lib/src/pouchdb/pouchdb-browser";
 import { EVENT_REQUEST_RELOAD_SETTING_TAB, EVENT_SETTING_SAVED, eventHub } from "../../common/events.ts";
 import {
@@ -18,7 +17,8 @@ import { getLanguage } from "@/deps.ts";
 import { SUPPORTED_I18N_LANGS, type I18N_LANGS } from "../../lib/src/common/rosetta.ts";
 import { decryptString, encryptString } from "@/lib/src/encryption/stringEncryption.ts";
 import type { LiveSyncCore } from "../../main.ts";
-export class ModuleObsidianSettings extends AbstractObsidianModule {
+import { AbstractModule } from "../AbstractModule.ts";
+export class ModuleObsidianSettings extends AbstractModule {
     async _everyOnLayoutReady(): Promise<boolean> {
         let isChanged = false;
         if (this.settings.displayLanguage == "") {
@@ -105,7 +105,7 @@ export class ModuleObsidianSettings extends AbstractObsidianModule {
     }
 
     get appId() {
-        return `${"appId" in this.app ? this.app.appId : ""}`;
+        return this.services.API.getAppID();
     }
 
     async _saveSettingData() {

src/modules/features/ModuleObsidianSettingAsMarkdown.ts

@@ -1,4 +1,3 @@
-import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
 // import { PouchDB } from "../../lib/src/pouchdb/pouchdb-browser";
 import { isObjectDifferent } from "octagonal-wheels/object";
 import { EVENT_SETTING_SAVED, eventHub } from "../../common/events";
@@ -6,9 +5,13 @@ import { fireAndForget } from "octagonal-wheels/promises";
 import { DEFAULT_SETTINGS, type FilePathWithPrefix, type ObsidianLiveSyncSettings } from "../../lib/src/common/types";
 import { parseYaml, stringifyYaml } from "../../deps";
 import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ServiceContext } from "@/lib/src/services/base/ServiceBase.ts";
+import type { InjectableServiceHub } from "@/lib/src/services/InjectableServices.ts";
+import type { LiveSyncCore } from "@/main.ts";
 const SETTING_HEADER = "````yaml:livesync-setting\n";
 const SETTING_FOOTER = "\n````";
-export class ModuleObsidianSettingsAsMarkdown extends AbstractObsidianModule {
+export class ModuleObsidianSettingsAsMarkdown extends AbstractModule {
     _everyOnloadStart(): Promise<boolean> {
         this.addCommand({
             id: "livesync-export-config",
@@ -242,7 +245,8 @@ We can perform a command in this file.
             this._log(`Markdown setting: ${filename} has been updated!`, LOG_LEVEL_VERBOSE);
         }
     }
-    onBindFunction(core: typeof this.plugin, services: typeof core.services): void {
+
+    onBindFunction(core: LiveSyncCore, services: InjectableServiceHub<ServiceContext>): void {
         services.appLifecycle.onInitialise.addHandler(this._everyOnloadStart.bind(this));
     }
 }

src/modules/features/ModuleSetupObsidian.ts

@@ -9,7 +9,6 @@ import {
     EVENT_REQUEST_SHOW_SETUP_QR,
     eventHub,
 } from "../../common/events.ts";
-import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
 import { $msg } from "../../lib/src/common/i18n.ts";
 // import { performDoctorConsultation, RebuildOptions } from "@/lib/src/common/configForDoc.ts";
 import type { LiveSyncCore } from "../../main.ts";
@@ -20,11 +19,12 @@ import {
     OutputFormat,
 } from "../../lib/src/API/processSetting.ts";
 import { SetupManager, UserMode } from "./SetupManager.ts";
+import { AbstractModule } from "../AbstractModule.ts";
 
-export class ModuleSetupObsidian extends AbstractObsidianModule {
+export class ModuleSetupObsidian extends AbstractModule {
     private _setupManager!: SetupManager;
     private _everyOnload(): Promise<boolean> {
-        this._setupManager = this.plugin.getModule(SetupManager);
+        this._setupManager = this.core.getModule(SetupManager);
         this.registerObsidianProtocolHandler("setuplivesync", async (conf: any) => {
             if (conf.settings) {
                 await this._setupManager.onUseSetupURI(

src/modules/features/SettingDialogue/PaneHatch.ts

@@ -21,7 +21,7 @@ import {
 } from "../../../lib/src/common/utils.ts";
 import { Logger } from "../../../lib/src/common/logger.ts";
 import { isCloudantURI } from "../../../lib/src/pouchdb/utils_couchdb.ts";
-import { getPath, requestToCouchDBWithCredentials } from "../../../common/utils.ts";
+import { requestToCouchDBWithCredentials } from "../../../common/utils.ts";
 import { addPrefix, shouldBeIgnored, stripAllPrefixes } from "../../../lib/src/string_and_binary/path.ts";
 import { $msg } from "../../../lib/src/common/i18n.ts";
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
@@ -388,7 +388,7 @@ ${stringifyYaml({
 
                         const adn = this.plugin.localDatabase.findAllDocs();
                         for await (const i of adn) {
-                            const path = getPath(i);
+                            const path = this.services.path.getPath(i);
                             if (path.startsWith(ICXHeader)) continue;
                             if (path.startsWith(PSCHeader)) continue;
                             if (!this.plugin.settings.syncInternalFiles && path.startsWith(ICHeader)) continue;

src/modules/features/SetupManager.ts

@@ -8,7 +8,6 @@ import {
     REMOTE_P2P,
 } from "../../lib/src/common/types.ts";
 import { generatePatchObj, isObjectDifferent } from "../../lib/src/common/utils.ts";
-import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
 import Intro from "./SetupWizard/dialogs/Intro.svelte";
 import SelectMethodNewUser from "./SetupWizard/dialogs/SelectMethodNewUser.svelte";
 import SelectMethodExisting from "./SetupWizard/dialogs/SelectMethodExisting.svelte";
@@ -23,6 +22,7 @@ import SetupRemoteBucket from "./SetupWizard/dialogs/SetupRemoteBucket.svelte";
 import SetupRemoteP2P from "./SetupWizard/dialogs/SetupRemoteP2P.svelte";
 import SetupRemoteE2EE from "./SetupWizard/dialogs/SetupRemoteE2EE.svelte";
 import { decodeSettingsFromQRCodeData } from "../../lib/src/API/processSetting.ts";
+import { AbstractModule } from "../AbstractModule.ts";
 
 /**
  * User modes for onboarding and setup
@@ -50,7 +50,7 @@ export const enum UserMode {
 /**
  * Setup Manager to handle onboarding and configuration setup
  */
-export class SetupManager extends AbstractObsidianModule {
+export class SetupManager extends AbstractModule {
     // /**
     //  * Dialog manager for handling Svelte dialogs
     //  */

src/modules/main/ModuleLiveSyncMain.ts

@@ -16,7 +16,7 @@ import { AbstractModule } from "../AbstractModule.ts";
 import { EVENT_PLATFORM_UNLOADED } from "@lib/events/coreEvents";
 import type { InjectableServiceHub } from "@lib/services/implements/injectable/InjectableServiceHub.ts";
 import type { LiveSyncCore } from "../../main.ts";
-import { initialiseWorkerModule } from "@/lib/src/worker/bgWorker.ts";
+import { initialiseWorkerModule } from "@lib/worker/bgWorker.ts";
 
 export class ModuleLiveSyncMain extends AbstractModule {
     async _onLiveSyncReady() {

src/modules/services/ObsidianAppLifecycleService.ts

@@ -0,0 +1,21 @@
+import { AppLifecycleServiceBase } from "@/lib/src/services/implements/injectable/InjectableAppLifecycleService";
+import type { ObsidianServiceContext } from "@/lib/src/services/implements/obsidian/ObsidianServiceContext";
+declare module "obsidian" {
+    interface App {
+        commands: {
+            executeCommandById: (id: string) => Promise<void>;
+        };
+    }
+}
+// InjectableAppLifecycleService
+export class ObsidianAppLifecycleService<T extends ObsidianServiceContext> extends AppLifecycleServiceBase<T> {
+    constructor(context: T) {
+        super(context);
+        // The main entry point when Obsidian's workspace is ready
+        const onReady = this.onReady;
+        this.context.app.workspace.onLayoutReady(onReady);
+    }
+    performRestart(): void {
+        void this.context.plugin.app.commands.executeCommandById("app:reload");
+    }
+}

src/modules/services/ObsidianPathService.ts

@@ -0,0 +1,8 @@
+import type { ObsidianServiceContext } from "@lib/services/implements/obsidian/ObsidianServiceContext";
+import { normalizePath } from "@/deps";
+import { PathService } from "@/lib/src/services/base/PathService";
+export class ObsidianPathService extends PathService<ObsidianServiceContext> {
+    protected normalizePath(path: string): string {
+        return normalizePath(path);
+    }
+}

src/modules/services/ObsidianServiceHub.ts

@@ -4,7 +4,6 @@ import type { ServiceInstances } from "@/lib/src/services/ServiceHub";
 import type ObsidianLiveSyncPlugin from "@/main";
 import {
     ObsidianAPIService,
-    ObsidianAppLifecycleService,
     ObsidianConflictService,
     ObsidianDatabaseService,
     ObsidianFileProcessingService,
@@ -13,12 +12,13 @@ import {
     ObsidianRemoteService,
     ObsidianSettingService,
     ObsidianTweakValueService,
-    ObsidianVaultService,
     ObsidianTestService,
     ObsidianDatabaseEventService,
-    ObsidianPathService,
     ObsidianConfigService,
 } from "./ObsidianServices";
+import { ObsidianAppLifecycleService } from "./ObsidianAppLifecycleService";
+import { ObsidianPathService } from "./ObsidianPathService";
+import { ObsidianVaultService } from "./ObsidianVaultService";
 import { ObsidianUIService } from "./ObsidianUIService";
 
 // InjectableServiceHub
@@ -37,10 +37,14 @@ export class ObsidianServiceHub extends InjectableServiceHub<ObsidianServiceCont
         const remote = new ObsidianRemoteService(context);
         const setting = new ObsidianSettingService(context);
         const tweakValue = new ObsidianTweakValueService(context);
-        const vault = new ObsidianVaultService(context);
+        const vault = new ObsidianVaultService(context, {
+            settingService: setting,
+        });
         const test = new ObsidianTestService(context);
         const databaseEvents = new ObsidianDatabaseEventService(context);
-        const path = new ObsidianPathService(context);
+        const path = new ObsidianPathService(context, {
+            settingService: setting,
+        });
         const config = new ObsidianConfigService(context, vault);
         const ui = new ObsidianUIService(context, {
             appLifecycle,

src/modules/services/ObsidianServices.ts

@@ -1,17 +1,14 @@
 import { InjectableAPIService } from "@lib/services/implements/injectable/InjectableAPIService";
-import { InjectableAppLifecycleService } from "@lib/services/implements/injectable/InjectableAppLifecycleService";
 import { InjectableConflictService } from "@lib/services/implements/injectable/InjectableConflictService";
 import { InjectableDatabaseEventService } from "@lib/services/implements/injectable/InjectableDatabaseEventService";
 import { InjectableDatabaseService } from "@lib/services/implements/injectable/InjectableDatabaseService";
 import { InjectableFileProcessingService } from "@lib/services/implements/injectable/InjectableFileProcessingService";
-import { InjectablePathService } from "@lib/services/implements/injectable/InjectablePathService";
 import { InjectableRemoteService } from "@lib/services/implements/injectable/InjectableRemoteService";
 import { InjectableReplicationService } from "@lib/services/implements/injectable/InjectableReplicationService";
 import { InjectableReplicatorService } from "@lib/services/implements/injectable/InjectableReplicatorService";
 import { InjectableSettingService } from "@lib/services/implements/injectable/InjectableSettingService";
 import { InjectableTestService } from "@lib/services/implements/injectable/InjectableTestService";
 import { InjectableTweakValueService } from "@lib/services/implements/injectable/InjectableTweakValueService";
-import { InjectableVaultService } from "@lib/services/implements/injectable/InjectableVaultService";
 import { ConfigServiceBrowserCompat } from "@lib/services/implements/browser/ConfigServiceBrowserCompat";
 import type { ObsidianServiceContext } from "@lib/services/implements/obsidian/ObsidianServiceContext.ts";
 import { Platform } from "@/deps";
@@ -19,6 +16,7 @@ import type { SimpleStore } from "@/lib/src/common/utils";
 import type { IDatabaseService } from "@/lib/src/services/base/IService";
 import { handlers } from "@/lib/src/services/lib/HandlerUtils";
 import { ObsHttpHandler } from "../essentialObsidian/APILib/ObsHttpHandler";
+import type { Command, ViewCreator } from "obsidian";
 
 // All Services will be migrated to be based on Plain Services, not Injectable Services.
 // This is a migration step.
@@ -92,8 +90,21 @@ export class ObsidianAPIService extends InjectableAPIService<ObsidianServiceCont
     override getPluginVersion(): string {
         return this.context.plugin.manifest.version;
     }
+
+    addCommand<TCommand extends Command>(command: TCommand): TCommand {
+        return this.context.plugin.addCommand(command) as TCommand;
+    }
+
+    registerWindow(type: string, factory: ViewCreator): void {
+        return this.context.plugin.registerView(type, factory);
+    }
+    addRibbonIcon(icon: string, title: string, callback: (evt: MouseEvent) => any): HTMLElement {
+        return this.context.plugin.addRibbonIcon(icon, title, callback);
+    }
+    registerProtocolHandler(action: string, handler: (params: Record<string, string>) => any): void {
+        return this.context.plugin.registerObsidianProtocolHandler(action, handler);
+    }
 }
-export class ObsidianPathService extends InjectablePathService<ObsidianServiceContext> {}
 export class ObsidianDatabaseService extends InjectableDatabaseService<ObsidianServiceContext> {
     openSimpleStore = handlers<IDatabaseService>().binder("openSimpleStore") as (<T>(
         kind: string
@@ -111,14 +122,10 @@ export class ObsidianReplicationService extends InjectableReplicationService<Obs
 export class ObsidianRemoteService extends InjectableRemoteService<ObsidianServiceContext> {}
 // InjectableConflictService
 export class ObsidianConflictService extends InjectableConflictService<ObsidianServiceContext> {}
-// InjectableAppLifecycleService
-export class ObsidianAppLifecycleService extends InjectableAppLifecycleService<ObsidianServiceContext> {}
 // InjectableSettingService
 export class ObsidianSettingService extends InjectableSettingService<ObsidianServiceContext> {}
 // InjectableTweakValueService
 export class ObsidianTweakValueService extends InjectableTweakValueService<ObsidianServiceContext> {}
-// InjectableVaultService
-export class ObsidianVaultService extends InjectableVaultService<ObsidianServiceContext> {}
 // InjectableTestService
 export class ObsidianTestService extends InjectableTestService<ObsidianServiceContext> {}
 export class ObsidianConfigService extends ConfigServiceBrowserCompat<ObsidianServiceContext> {}

src/modules/services/ObsidianUIService.ts

@@ -5,7 +5,7 @@ import { UIService } from "@lib/services//implements/base/UIService";
 import { ObsidianServiceContext } from "@/lib/src/services/implements/obsidian/ObsidianServiceContext";
 import { ObsidianSvelteDialogManager } from "./SvelteDialogObsidian";
 import { ObsidianConfirm } from "./ObsidianConfirm";
-
+import DialogToCopy from "@/lib/src/UI/dialogues/DialogueToCopy.svelte";
 export type ObsidianUIServiceDependencies<T extends ObsidianServiceContext = ObsidianServiceContext> = {
     appLifecycle: AppLifecycleService<T>;
     config: ConfigService<T>;
@@ -13,6 +13,9 @@ export type ObsidianUIServiceDependencies<T extends ObsidianServiceContext = Obs
 };
 
 export class ObsidianUIService extends UIService<ObsidianServiceContext> {
+    override get dialogToCopy() {
+        return DialogToCopy;
+    }
     constructor(context: ObsidianServiceContext, dependents: ObsidianUIServiceDependencies<ObsidianServiceContext>) {
         const obsidianConfirm = new ObsidianConfirm(context);
         const obsidianSvelteDialogManager = new ObsidianSvelteDialogManager<ObsidianServiceContext>(context, {

src/modules/services/ObsidianVaultService.ts

@@ -0,0 +1,33 @@
+import { getPathFromTFile } from "@/common/utils";
+import { InjectableVaultService } from "@/lib/src/services/implements/injectable/InjectableVaultService";
+import type { ObsidianServiceContext } from "@/lib/src/services/implements/obsidian/ObsidianServiceContext";
+import type { FilePath } from "@/lib/src/common/types";
+
+declare module "obsidian" {
+    interface DataAdapter {
+        insensitive?: boolean;
+    }
+}
+
+// InjectableVaultService
+export class ObsidianVaultService extends InjectableVaultService<ObsidianServiceContext> {
+    vaultName(): string {
+        return this.context.app.vault.getName();
+    }
+    getActiveFilePath(): FilePath | undefined {
+        const file = this.context.app.workspace.getActiveFile();
+        if (file) {
+            return getPathFromTFile(file);
+        }
+        return undefined;
+    }
+    isStorageInsensitive(): boolean {
+        return this.context.app.vault.adapter.insensitive ?? true;
+    }
+
+    override shouldCheckCaseInsensitively(): boolean {
+        // If the storage is insensitive, always return false, that because no need to check again.
+        if (this.isStorageInsensitive()) return false;
+        return super.shouldCheckCaseInsensitively(); // Check the setting
+    }
+}

src/modules/services/SvelteDialogObsidian.ts

@@ -7,8 +7,8 @@ import {
     type SvelteDialogManagerDependencies,
 } from "@lib/services/implements/base/SvelteDialog";
 import type { ObsidianServiceContext } from "@lib/services/implements/obsidian/ObsidianServiceContext";
-
-export const SvelteDialogBase = SvelteDialogMixIn(Modal);
+import DialogHost from "@/lib/src/UI/DialogHost.svelte";
+export const SvelteDialogBase = SvelteDialogMixIn(Modal, DialogHost);
 export class SvelteDialogObsidian<
     T,
     U,

updates.md

@@ -3,6 +3,50 @@ Since 19th July, 2025 (beta1 in 0.25.0-beta1, 13th July, 2025)
 
 The head note of 0.25 is now in [updates_old.md](https://github.com/vrtmrz/obsidian-livesync/blob/main/updates_old.md). Because 0.25 got a lot of updates, thankfully, compatibility is kept and we do not need breaking changes! In other words, when get enough stabled. The next version will be v1.0.0. Even though it my hope.
 
+## 0.25.43-patched-1
+
+13th February, 2026
+
+You know this is a patch version, is the beta-release practically? Do not worry about the following memos, as they are indeed freaking us out. I trust that you have thought this was too large; you're right.
+
+If this cannot be stable, I will revert to 0.24.43 and try again.
+
+### Refactored
+
+- Now resolving unexpected and inexplicable dependency order issues...
+- The function which is able to implement to the service is now moved to each service.
+    - AppLifecycleService.performRestart
+- VaultService.isTargetFile is now uses separated multiple checkers instead of a single function.
+    - This change allows better separation of concerns and easier extension in the future.
+- Application LifeCycle has now started in ServiceHub, not ObsidianMenuModule.
+
+    - It was on a QUITE unexpected place..., isn't it?
+    - Instead of, we should call `await this.services.appLifecycle.onReady()` in other platforms.
+    - As in browser platform, it will be called at `DOMContentLoaded` event.
+
+- ModuleTargetFilter, which is responsible for parsing ignore files has been refined.
+    - This should be separated to a TargetFilter and a IgnoreFileFilter for better maintainability.
+- Using `API.addCommand` or some Obsidian API and shimmer APIs, Many modules have been refactored to be derived to AbstractModule from AbstractObsidianModule, to clarify the dependencies. (we should make `app` usage clearer...)
+- Fixed initialising `storageAccess` too late in `FileAccessObsidian` module (I am still wonder why it worked before...).
+- Remove some redundant overrides in modules.
+
+### Planned
+
+- Some services have ambiguous name, such as `Injectable`. These will be renamed in the future for better clarity.
+- Following properties of `ObsidianLiveSyncPlugin` should be initialised more explicitly:
+    - property : where it is initialised currently
+    - `localDatabase` : `ModuleLocalDatabaseObsidian`
+    - `managers` : `ModuleLocalDatabaseObsidian`
+    - `replicator` : `ModuleReplicator`
+    - `simpleStore` : `ModuleKeyValueDB`
+    - `storageAccess` : `ModuleFileAccessObsidian`
+    - `databaseFileAccess` : `ModuleDatabaseFileAccess`
+    - `fileHandler` : `ModuleFileHandler`
+    - `rebuilder` : `ModuleRebuilder`
+    - `kvDB`: `ModuleKeyValueDB`
+    - And I think that having feature in modules directly is not good for maintainability, these should be separated to some module (loader) and implementation (not only service, but also independent something).
+- Plug-in statuses such as requestCount, responseCount... should be moved to a status service or somewhere for better separation of concerns.
+
 ## 0.25.43
 
 5th, February, 2026
@@ -17,7 +61,6 @@ The head note of 0.25 is now in [updates_old.md](https://github.com/vrtmrz/obsid
 
 Quite a few packages have been updated in this release. Please report if you find any unexpected behaviour after this update.
 
-
 ## 0.25.42
 
 2nd, February, 2026