@vrtmrz/livesync-commonlib 0.2.1 → 0.2.3

package/dist/serviceFeatures/remoteConfig.d.ts

@@ -3,6 +3,10 @@ import { type RemoteConfigurationResult } from "../common/ConnectionString.js";
 import type { ObsidianLiveSyncSettings, RemoteConfiguration } from "../common/models/setting.type.js";
 import type { NecessaryServices } from "../interfaces/ServiceModule.js";
 export type RemoteConfigHost = NecessaryServices<"setting" | "UI" | "replication" | "control" | "appLifecycle" | "API", never>;
+type RemoteConfigMigrationHost = NecessaryServices<"setting" | "API", never>;
+type RemoteConfigMigrationFeatureHost = NecessaryServices<"setting" | "API" | "appLifecycle", never>;
+type RemoteConfigSwitchHost = NecessaryServices<"setting" | "UI" | "control" | "API", never>;
+type RemoteConfigReplicationHost = NecessaryServices<"setting" | "UI" | "replication" | "control" | "API", never>;
 export declare function migrateLegacyRemoteConfigurationsInPlace(settings: ObsidianLiveSyncSettings, log?: (message: string, level?: LOG_LEVEL) => void): boolean;
 /**
  * Generate a unique ID for a new remote configuration.
@@ -54,7 +58,7 @@ export declare function migrateP2PActiveRemoteConfigurationIdInPlace(settings: O
 /**
  * Migrates existing flat settings to the new multiple remote configurations list.
  */
-export declare function migrateToMultipleRemoteConfigurations(host: RemoteConfigHost): Promise<boolean>;
+export declare function migrateToMultipleRemoteConfigurations(host: RemoteConfigMigrationHost): Promise<boolean>;
 /**
  * Logic to switch the active configuration.
  */
@@ -67,16 +71,17 @@ export declare function activateP2PRemoteConfiguration(settings: ObsidianLiveSyn
 /**
  * Command: Switch active connection
  */
-export declare function commandSwitchActiveRemote(host: RemoteConfigHost): Promise<void>;
+export declare function commandSwitchActiveRemote(host: RemoteConfigSwitchHost): Promise<void>;
 /**
  * Command: Sync with a saved connection
  */
-export declare function commandReplicateWithSpecificRemote(host: RemoteConfigHost): Promise<void>;
+export declare function commandReplicateWithSpecificRemote(host: RemoteConfigReplicationHost): Promise<void>;
 /**
  * Migration feature to be used during initialisation.
  */
-export declare function useRemoteConfigurationMigration(host: RemoteConfigHost): void;
+export declare function useRemoteConfigurationMigration(host: RemoteConfigMigrationFeatureHost): void;
 /**
  * Hook to set up remote configuration features (Commands).
  */
-export declare function useRemoteConfiguration(host: RemoteConfigHost): boolean;
+export declare function useRemoteConfiguration(host: RemoteConfigReplicationHost): boolean;
+export {};

package/dist/serviceModules/ServiceFileAccessBase.d.ts

@@ -26,6 +26,7 @@ export declare class ServiceFileAccessBase<TAdapter extends IFileSystemAdapter<a
     private vault;
     private setting;
     constructor(services: StorageAccessBaseDependencies<TAdapter>);
+    hasPendingFileEvent(path: FilePath): boolean;
     restoreState(): Promise<void>;
     _everyOnFirstInitialize(): Promise<boolean>;
     _everyCommitPendingFileEvent(): Promise<boolean>;

package/dist/serviceModules/ServiceFileAccessBase.js

@@ -21,6 +21,9 @@ class ServiceFileAccessBase extends ServiceModuleBase {
       return true;
     });
   }
+  hasPendingFileEvent(path) {
+    return this.vaultManager.hasPendingFileEvent?.(path) ?? true;
+  }
   restoreState() {
     return this.vaultManager.restoreState();
   }

package/dist/serviceModules/ServiceFileHandlerBase.d.ts

@@ -98,6 +98,7 @@ export declare abstract class ServiceFileHandlerBase extends ServiceModuleBase<S
     getPath(entry: AnyEntry): FilePathWithPrefix;
     getPathWithoutPrefix(entry: AnyEntry): FilePathWithPrefix;
     readFileFromStub(file: UXFileInfoStub | UXFileInfo): Promise<UXFileInfo>;
+    canSkipUnchangedFile(info: UXFileInfoStub, expected: MetaEntry): Promise<boolean>;
     tryRecordUntrackedFileRevision(info: UXFileInfoStub | UXFileInfo, expectedRevision: string): Promise<boolean>;
     private infoToStub;
     storeFileToDB(info: UXFileInfoStub | UXFileInfo | UXInternalFileInfoStub | FilePathWithPrefix, force?: boolean, onlyChunks?: boolean, options?: StoreFileOptions): Promise<boolean>;

package/dist/serviceModules/ServiceFileHandlerBase.js

@@ -1,5 +1,5 @@
 import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
-import { serialized } from "octagonal-wheels/concurrency/lock";
+import { withLocks } from "octagonal-wheels/concurrency/lock";
 import {
   createBlob,
   getDocDataAsArray,
@@ -15,11 +15,6 @@ import { getStoragePathFromUXFileInfo } from "../common/typeUtils.js";
 import { EVEN } from "../common/models/shared.const.symbols.js";
 import { tryGetFilePath } from "../common/utils.doc.js";
 import { getPathNormalizationVersion, normalisePathForIdentity } from "../common/pathNormalization.js";
-async function serializedByKeys(keys, callback) {
-  const [key, ...remainingKeys] = keys;
-  if (key === void 0) return await callback();
-  return await serialized(key, () => serializedByKeys(remainingKeys, callback));
-}
 function getParentPath(path) {
   const lastSeparator = path.lastIndexOf("/");
   return lastSeparator < 0 ? "" : path.slice(0, lastSeparator);
@@ -258,6 +253,27 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     }
     return readFile;
   }
+  async canSkipUnchangedFile(info, expected) {
+    const path = getStoragePathFromUXFileInfo(info);
+    const provenance = this.fileReflectionProvenance;
+    if (!provenance || !expected._rev || expected.deleted || expected._deleted || expected._conflicts?.length || this.storage.hasPendingFileEvent?.(path) !== false) return false;
+    try {
+      return await this.serializedByFileEventPaths([path], async () => {
+        const provenancePath = this.getProvenancePath(path);
+        const record = await provenance.get(provenancePath);
+        if (!record || !hasContentHash(record) || record.revision !== expected._rev || !Number.isFinite(record.observedStorageMtime) || record.observedStorageMtime !== info.stat.mtime || record.contentSize !== info.stat.size) return false;
+        const current = await this.db.fetchEntryMeta(path, void 0, true);
+        if (!current || current._rev !== record.revision || current.deleted || current._deleted || (await this.db.getConflictedRevs(path)).length > 0) return false;
+        const stat = await this.storage.stat(path);
+        if (!stat || stat.type !== "file" || stat.mtime !== record.observedStorageMtime || stat.size !== record.contentSize) return false;
+        return sameProvenance(await provenance.get(provenancePath), record) && this.storage.hasPendingFileEvent?.(path) === false;
+      });
+    } catch (error) {
+      this._log(`Could not inspect unchanged file metadata for ${path}`, LOG_LEVEL_VERBOSE);
+      this._log(error, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
   async tryRecordUntrackedFileRevision(info, expectedRevision) {
     if (!this.fileReflectionProvenance || !expectedRevision) return false;
     const path = getStoragePathFromUXFileInfo(info);
@@ -1179,7 +1195,7 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     let failed = false;
     let failure;
     try {
-      result = await serializedByKeys(lockKeys, async () => {
+      result = await withLocks(lockKeys, async () => {
         for (const id of uniqueIds) this.deferredConflictChecks.set(id, pending);
         try {
           return await callback(documentIds.length === 2 && documentIds[0] === documentIds[1]);

package/dist/services/base/DatabaseEventService.d.ts

@@ -34,5 +34,5 @@ export declare abstract class DatabaseEventService<T extends ServiceContext = Se
      * @param reopenDatabase Whether to reopen the database if it is already open.
      * @param ignoreSuspending Whether to ignore any suspending state.
      */
-    readonly initialiseDatabase: import("../lib/HandlerUtils.js").MultipleHandlerFunction<(showingNotice?: boolean, reopenDatabase?: boolean, ignoreSuspending?: boolean, continueOnFileFailure?: boolean) => Promise<import("./VaultScanResult.js").VaultScanResult>, unknown>;
+    readonly initialiseDatabase: import("../lib/HandlerUtils.js").MultipleHandlerFunction<(showingNotice?: boolean, reopenDatabase?: boolean, ignoreSuspending?: boolean, continueOnFileFailure?: boolean, scanOptions?: import("./VaultScanResult.js").VaultScanOptions) => Promise<import("./VaultScanResult.js").VaultScanResult>, unknown>;
 }

package/dist/services/base/IService.d.ts

@@ -17,7 +17,7 @@ import type { ActiveReplicatorContext, ContinuousReplicationRequest, Replication
 import type { RemoteResourceKind, RemoteResourceMap } from "../../replication/RemoteResource.js";
 import type { CentralRemoteAdministrationRequest, CentralRemoteAdministrationResult } from "../../replication/CentralRemoteAdministration.js";
 import type { HandlerOutcome, MultipleHandlerFunction } from "../lib/HandlerUtils.js";
-import type { VaultScanResult } from "./VaultScanResult.js";
+import type { VaultScanResult, VaultScanOptions } from "./VaultScanResult.js";
 import type { UICommandRegistry } from "../../uiCommands.js";
 declare global {
     interface OPTIONAL_SYNC_FEATURES {
@@ -91,7 +91,7 @@ export interface IDatabaseEventService {
     onDatabaseInitialised(showNotice: boolean): Promise<boolean>;
     onDatabaseHasReady(): Promise<boolean>;
     onResetDatabase(db: LiveSyncLocalDB): Promise<boolean>;
-    initialiseDatabase(showingNotice?: boolean, reopenDatabase?: boolean, ignoreSuspending?: boolean, continueOnFileFailure?: boolean): Promise<VaultScanResult>;
+    initialiseDatabase(showingNotice?: boolean, reopenDatabase?: boolean, ignoreSuspending?: boolean, continueOnFileFailure?: boolean, scanOptions?: VaultScanOptions): Promise<VaultScanResult>;
 }
 export interface IKeyValueDBService {
     openSimpleStore<T>(kind: string): SimpleStore<T>;
@@ -355,7 +355,7 @@ export interface ITweakValueService {
 export interface IVaultService {
     vaultName(): string;
     getVaultName(): string;
-    scanVault(showingNotice?: boolean, ignoreSuspending?: boolean, continueOnFileFailure?: boolean): Promise<VaultScanResult>;
+    scanVault(showingNotice?: boolean, ignoreSuspending?: boolean, continueOnFileFailure?: boolean, scanOptions?: VaultScanOptions): Promise<VaultScanResult>;
     isIgnoredByIgnoreFile(file: string | UXFileInfoStub): Promise<boolean>;
     isTargetFile(file: string | UXFileInfoStub, 
     /** Inspect selection policy without treating a filename collision as an exclusion. */

package/dist/services/base/VaultScanResult.d.ts

@@ -10,4 +10,9 @@ export declare const VaultScanResults: {
     readonly COMPLETED: true;
     readonly COMPLETED_WITH_FILE_FAILURES: "completed-with-file-failures";
 };
+/** Optional policy for an ordinary scan; omitted options retain strict content checks. */
+export interface VaultScanOptions {
+    /** False permits unchanged tracked files to be skipped using storage and revision metadata. */
+    strictContentCheck?: boolean;
+}
 export type VaultScanResult = (typeof VaultScanResults)[keyof typeof VaultScanResults];

package/dist/services/base/VaultService.d.ts

@@ -26,7 +26,7 @@ export declare abstract class VaultService<T extends ServiceContext = ServiceCon
      * @param showingNotice Whether to show a notice to the user.
      * @param ignoreSuspending Whether to ignore any suspending state.
      */
-    readonly scanVault: import("../lib/HandlerUtils.js").MultipleHandlerFunction<(showingNotice?: boolean, ignoreSuspending?: boolean, continueOnFileFailure?: boolean) => Promise<import("./VaultScanResult.js").VaultScanResult>, unknown>;
+    readonly scanVault: import("../lib/HandlerUtils.js").MultipleHandlerFunction<(showingNotice?: boolean, ignoreSuspending?: boolean, continueOnFileFailure?: boolean, scanOptions?: import("./VaultScanResult.js").VaultScanOptions) => Promise<import("./VaultScanResult.js").VaultScanResult>, unknown>;
     /**
      * Check if a file is ignored by the ignore file (e.g., .gitignore, .obsidianignore).
      * @param file The file path or file info stub to check.

package/dist/services/implements/injectable/InjectableConflictService.d.ts

@@ -1,11 +1,11 @@
 import { ConflictService } from "../../base/ConflictService.js";
 import type { ServiceContext } from "../../base/ServiceBase.js";
 export declare class InjectableConflictService<T extends ServiceContext> extends ConflictService<T> {
-    queueCheckForIfOpen: import("../../lib/HandlerUtils.js").HandlerFunction<(path: import("../../../common/types.js").FilePathWithPrefix) => Promise<void>, unknown>;
-    queueCheckFor: import("../../lib/HandlerUtils.js").HandlerFunction<(path: import("../../../common/types.js").FilePathWithPrefix) => Promise<void>, unknown>;
+    queueCheckForIfOpen: import("../../lib/HandlerUtils.js").HandlerFunction<(path: import("../../../conflicts.js").FilePathWithPrefix) => Promise<void>, unknown>;
+    queueCheckFor: import("../../lib/HandlerUtils.js").HandlerFunction<(path: import("../../../conflicts.js").FilePathWithPrefix) => Promise<void>, unknown>;
     ensureAllProcessed: import("../../lib/HandlerUtils.js").HandlerFunction<() => Promise<boolean>, unknown>;
-    resolveByDeletingRevision: import("../../lib/HandlerUtils.js").HandlerFunction<(path: import("../../../common/types.js").FilePathWithPrefix, deleteRevision: string, title: string) => Promise<typeof import("../../../common/types.js").MISSING_OR_ERROR | typeof import("../../../common/types.js").AUTO_MERGED>, unknown>;
-    resolve: import("../../lib/HandlerUtils.js").HandlerFunction<(filename: import("../../../common/types.js").FilePathWithPrefix) => Promise<void>, unknown>;
-    resolveByNewest: import("../../lib/HandlerUtils.js").HandlerFunction<(filename: import("../../../common/types.js").FilePathWithPrefix) => Promise<boolean>, unknown>;
+    resolveByDeletingRevision: import("../../lib/HandlerUtils.js").HandlerFunction<(path: import("../../../conflicts.js").FilePathWithPrefix, deleteRevision: string, title: string) => Promise<typeof import("../../../common/types.js").MISSING_OR_ERROR | typeof import("../../../common/types.js").AUTO_MERGED>, unknown>;
+    resolve: import("../../lib/HandlerUtils.js").HandlerFunction<(filename: import("../../../conflicts.js").FilePathWithPrefix) => Promise<void>, unknown>;
+    resolveByNewest: import("../../lib/HandlerUtils.js").HandlerFunction<(filename: import("../../../conflicts.js").FilePathWithPrefix) => Promise<boolean>, unknown>;
     resolveAllConflictedFilesByNewerOnes: import("../../lib/HandlerUtils.js").HandlerFunction<() => Promise<void>, unknown>;
 }

package/dist/services/lib/HandlerUtils.d.ts

@@ -94,11 +94,12 @@ export declare class Binder<T extends (...args: any[]) => any> implements Binder
      */
     constructor(name: string, initialCallback?: T);
     private _callback;
+    private _registrationToken;
     /**
      * Assigns a new handler function.
      * @param callback The new handler function to assign.
      */
-    assign(callback: T, override?: boolean): () => void;
+    assign(callback: T, override?: boolean): UnregisterFunction;
     /**
      * Invokes the assigned handler function with the provided arguments.
      * @param args  The arguments to pass to the handler function.
@@ -114,13 +115,14 @@ export declare class LazyBinder<T extends (...args: any[]) => any> implements Bi
     private _name;
     private _callbackPromise;
     private _callback;
+    private _registrationToken;
     /**
      * Creates a new LazyBinder instance.
      * @param name  The name of the handler.
      * @param initialCallback An optional initial callback function to assign.
      */
     constructor(name: string, initialCallback?: T);
-    assign(callback: T, override?: boolean): () => void;
+    assign(callback: T, override?: boolean): UnregisterFunction;
     /**
      * Invokes the assigned handler function with the provided arguments.
      * @param args The arguments to pass to the handler function.
@@ -300,9 +302,9 @@ export interface HandlerFunction<TFunc extends (...args: any[]) => U | Promise<U
      * Assigns a new handler function.
      * @param callback The new handler function to assign.
      * @param override Whether to override the existing handler if one is already assigned.
-     * @returns A function to unregister the assigned handler.
+     * @returns A function that unregisters this registration if it is still current.
      */
-    setHandler: (callback: TFunc, override?: boolean) => void;
+    setHandler: (callback: TFunc, override?: boolean) => UnregisterFunction;
 }
 /**
  * A function type that can be used as a handler with assignable functionality.
@@ -316,9 +318,9 @@ export interface LazyHandlerFunction<TFunc extends (...args: any[]) => U | Promi
      * Assigns a new handler function.
      * @param callback The new handler function to assign.
      * @param override Whether to override the existing handler if one is already assigned.
-     * @returns A function to unregister the assigned handler.
+     * @returns A function that unregisters this registration if it is still current.
      */
-    setHandler: (callback: TFunc, override?: boolean) => void;
+    setHandler: (callback: TFunc, override?: boolean) => UnregisterFunction;
 }
 /**
  * A function type that can be used as a multiple handler with add/remove functionality.

package/dist/services/lib/HandlerUtils.js

@@ -14,6 +14,7 @@ class Binder {
     }
   }
   _callback = null;
+  _registrationToken = null;
   /**
    * Assigns a new handler function.
    * @param callback The new handler function to assign.
@@ -22,8 +23,14 @@ class Binder {
     if (this._callback && !override) {
       throw new Error(`Handler ${this._name} is already assigned.`);
     }
+    const registrationToken = /* @__PURE__ */ Symbol();
+    this._registrationToken = registrationToken;
     this._callback = callback;
     return () => {
+      if (this._registrationToken !== registrationToken) {
+        return;
+      }
+      this._registrationToken = null;
       this._callback = null;
     };
   }
@@ -43,6 +50,7 @@ class LazyBinder {
   _name;
   _callbackPromise = promiseWithResolvers();
   _callback = null;
+  _registrationToken = null;
   /**
    * Creates a new LazyBinder instance.
    * @param name  The name of the handler.
@@ -59,9 +67,15 @@ class LazyBinder {
     if (this._callback && !override) {
       throw new Error(`Handler ${this._name} is already assigned.`);
     }
+    const registrationToken = /* @__PURE__ */ Symbol();
+    this._registrationToken = registrationToken;
     this._callback = callback;
     this._callbackPromise.resolve();
     return () => {
+      if (this._registrationToken !== registrationToken) {
+        return;
+      }
+      this._registrationToken = null;
       this._callback = null;
       this._callbackPromise = promiseWithResolvers();
     };