@vrtmrz/livesync-commonlib 0.2.1 → 0.2.2

package/dist/API/processSetting.d.ts

@@ -62,6 +62,7 @@ export declare function decodeSettingsFromSetupURI(uri: string, passphrase: stri
     batchSaveInLiveSync?: boolean;
     syncOnSave: boolean;
     syncOnStart: boolean;
+    strictContentCheckOnStartup?: boolean;
     syncOnFileOpen: boolean;
     syncOnEditorSave: boolean;
     keepReplicationActiveInBackground: boolean;

package/dist/common/models/setting.const.defaults.js

@@ -43,6 +43,7 @@ const SETTINGS_SCHEMA_DEFAULTS = {
   batchSaveInLiveSync: false,
   syncOnSave: false,
   syncOnStart: false,
+  strictContentCheckOnStartup: false,
   savingDelay: 200,
   lessInformationInLog: false,
   gcDelay: 300,

package/dist/common/models/setting.const.qr.js

@@ -51,6 +51,8 @@ const KeyIndexOfSettings = {
   liveSync: 49,
   syncOnSave: 50,
   syncOnStart: 51,
+  strictContentCheckOnStartup: -1,
+  // Installation-local preference; do not encode into the QR Code.
   syncOnFileOpen: 52,
   syncOnEditorSave: 53,
   keepReplicationActiveInBackground: -1,

package/dist/common/models/setting.policy.d.ts

@@ -65,6 +65,10 @@ export declare const SETTINGS_PROPERTY_POLICY: {
         readonly markdown: "include";
         readonly persistence: "include";
     };
+    readonly strictContentCheckOnStartup: {
+        readonly markdown: "omit";
+        readonly persistence: "include";
+    };
     readonly syncOnFileOpen: {
         readonly markdown: "include";
         readonly persistence: "include";

package/dist/common/models/setting.policy.js

@@ -17,6 +17,7 @@ const SETTINGS_PROPERTY_POLICY = {
   batchSaveInLiveSync: SettingPolicies.Default,
   syncOnSave: SettingPolicies.Default,
   syncOnStart: SettingPolicies.Default,
+  strictContentCheckOnStartup: SettingPolicies.LocalOnly,
   syncOnFileOpen: SettingPolicies.Default,
   syncOnEditorSave: SettingPolicies.Default,
   keepReplicationActiveInBackground: SettingPolicies.Default,

package/dist/common/models/setting.type.d.ts

@@ -91,6 +91,10 @@ interface SyncMethodSettings {
      * automatically run sync on starting the plug-in.
      */
     syncOnStart: boolean;
+    /**
+     * Compare file contents during startup checks when modification time and size match.
+     */
+    strictContentCheckOnStartup?: boolean;
     /**
      * automatically run sync on opening a file.
      */

package/dist/common/models/tweak.definition.d.ts

@@ -145,6 +145,7 @@ export declare const TweakValuesTemplate: {
     batchSaveInLiveSync?: boolean;
     syncOnSave?: boolean;
     syncOnStart?: boolean;
+    strictContentCheckOnStartup?: boolean;
     syncOnFileOpen?: boolean;
     syncOnEditorSave?: boolean;
     keepReplicationActiveInBackground?: boolean;

package/dist/common/settingConstants.d.ts

@@ -33,6 +33,7 @@ export declare const AllSettingDefault: {
     batchSaveInLiveSync?: boolean;
     syncOnSave: boolean;
     syncOnStart: boolean;
+    strictContentCheckOnStartup?: boolean;
     syncOnFileOpen: boolean;
     syncOnEditorSave: boolean;
     keepReplicationActiveInBackground: boolean;

package/dist/common/settingConstants.js

@@ -104,6 +104,10 @@ const SettingInformation = {
     name: "Sync on Startup",
     desc: "Automatically Sync all files when opening Obsidian."
   },
+  strictContentCheckOnStartup: {
+    name: "Strict content check on startup",
+    desc: "Compare file contents even when modification time and size match. This can slow startup in large vaults."
+  },
   syncAfterMerge: {
     name: "Sync after merging file",
     desc: "Sync automatically after merging files"

package/dist/interfaces/FileHandler.d.ts

@@ -12,6 +12,8 @@ export interface IFileHandler {
      * operation never stores a document revision or writes to storage.
      */
     tryRecordUntrackedFileRevision(info: UXFileInfoStub | UXFileInfo, expectedRevision: string): Promise<boolean>;
+    /** Metadata-only scan hint; never certifies content equality or changes provenance. */
+    canSkipUnchangedFile?(info: UXFileInfoStub, expected: MetaEntry): Promise<boolean>;
     storeFileToDB(info: UXFileInfoStub | UXFileInfo | UXInternalFileInfoStub | FilePathWithPrefix, force?: boolean, onlyChunks?: boolean, options?: StoreFileOptions): Promise<boolean>;
     /**
      * Store the current storage content as a child of an exact live database revision.

package/dist/interfaces/StorageAccess.d.ts

@@ -12,6 +12,8 @@ export interface IStorageAccessManager {
 export interface StorageAccess {
     normalisePath(path: string): string;
     restoreState(): Promise<void>;
+    /** Includes queued, running, and failed work; absence requires a conservative content check. */
+    hasPendingFileEvent?(path: FilePath): boolean;
     deleteVaultItem(file: FilePathWithPrefix | UXFileInfoStub | UXFolderInfo): Promise<void>;
     renameFile(file: UXFileInfoStub | FilePathWithPrefix, newPath: FilePathWithPrefix): Promise<UXFileInfoStub | null>;
     writeFileAuto(path: string, data: string | ArrayBuffer, opt?: UXDataWriteOptions): Promise<boolean>;

package/dist/interfaces/StorageEventManager.d.ts

@@ -11,6 +11,8 @@ export declare abstract class StorageEventManager {
     abstract beginWatch(): Promise<void>;
     abstract appendQueue(items: FileEvent[], ctx?: unknown): Promise<void>;
     abstract isWaiting(filename: FilePath): boolean;
+    /** Compatibility hosts without an ownership view must retain content checks. */
+    hasPendingFileEvent?(_filename: FilePath): boolean;
     abstract waitForIdle(): Promise<void>;
     abstract restoreState(): Promise<void>;
     /**

package/dist/interfaces/StorageEventManager.js

@@ -1,4 +1,8 @@
 class StorageEventManager {
+  /** Compatibility hosts without an ownership view must retain content checks. */
+  hasPendingFileEvent(_filename) {
+    return true;
+  }
   /**
    * Complete accepted work before its storage closes. Custom hosts must stop
    * their watcher admission before invoking this default implementation.

package/dist/managers/StorageEventManager.d.ts

@@ -134,6 +134,7 @@ export declare abstract class StorageEventManagerBase<TAdapter extends IStorageE
     protected runQueuedEvents(options?: RunQueuedEventsOptions): Promise<void>;
     protected processingCount: number;
     protected requestProcessQueue(fei: FileEventItem): Promise<void>;
+    hasPendingFileEvent(filename: FilePath): boolean;
     isWaiting(filename: FilePath): boolean;
     protected handleFileEvent(queue: FileEventItem): Promise<void>;
     protected cancelRelativeEvent(item: FileEventItem): void;

package/dist/managers/StorageEventManager.js

@@ -530,6 +530,15 @@ class StorageEventManagerBase extends StorageEventManager {
       this.updateStatus();
     }
   }
+  hasPendingFileEvent(filename) {
+    for (const entry of this.pendingSnapshot.values()) {
+      if (entry.completed || entry.event.type === TYPE_SENTINEL_FLUSH) continue;
+      const event = entry.event;
+      const relatedPath = event.type === "RENAME" ? event.args.oldPath : event.args.renameTarget;
+      if ([event.args.file.path, relatedPath].some((path) => path && (filename === path || filename.startsWith(`${path}/`)))) return true;
+    }
+    return false;
+  }
   isWaiting(filename) {
     return this._waitingMap.has(filename);
   }

package/dist/replication/trystero/TrysteroReplicator.d.ts

@@ -147,6 +147,7 @@ export declare class TrysteroReplicator {
         batchSaveInLiveSync?: boolean;
         syncOnSave?: boolean;
         syncOnStart?: boolean;
+        strictContentCheckOnStartup?: boolean;
         syncOnFileOpen?: boolean;
         syncOnEditorSave?: boolean;
         keepReplicationActiveInBackground?: boolean;
@@ -336,6 +337,7 @@ export declare class TrysteroReplicator {
             batchSaveInLiveSync?: boolean;
             syncOnSave?: boolean;
             syncOnStart?: boolean;
+            strictContentCheckOnStartup?: boolean;
             syncOnFileOpen?: boolean;
             syncOnEditorSave?: boolean;
             keepReplicationActiveInBackground?: boolean;

package/dist/serviceFeatures/offlineScanner.d.ts

@@ -3,7 +3,7 @@ import { type LogFunction } from "../services/lib/logUtils.js";
 import type { NecessaryServices } from "../interfaces/ServiceModule.js";
 import type { IPathService } from "../services/base/IService.js";
 import { UnresolvedErrorManager } from "../services/base/UnresolvedErrorManager.js";
-import { VaultScanResults, type VaultScanResult } from "../services/base/VaultScanResult.js";
+import { VaultScanResults, type VaultScanResult, type VaultScanOptions } from "../services/base/VaultScanResult.js";
 export { VaultScanResults };
 export type { VaultScanResult };
 /**
@@ -156,7 +156,7 @@ export declare function getPathFromEntry(host: {
  * @param file Storage file information
  * @param doc Database entry
  */
-export declare function syncFileBetweenDBandStorage(host: NecessaryServices<"setting" | "vault" | "path", "storageAccess" | "fileHandler">, log: LogFunction, file: UXFileInfoStub, doc: MetaEntry): Promise<FilePairProcessResult>;
+export declare function syncFileBetweenDBandStorage(host: NecessaryServices<"setting" | "vault" | "path", "storageAccess" | "fileHandler">, log: LogFunction, file: UXFileInfoStub, doc: MetaEntry, scanOptions?: VaultScanOptions): Promise<FilePairProcessResult>;
 export declare function canProceedScan(host: NecessaryServices<"keyValueDB" | "setting", never>, errorManager: UnresolvedErrorManager, log: LogFunction, showingNotice?: boolean, ignoreSuspending?: boolean): boolean;
 /**
  * Normalise the logical comparison key and lower case it when filename case should be handled insensitively.
@@ -180,7 +180,7 @@ export declare function collectDatabaseFiles(host: NecessaryServices<"database"
 }>;
 export declare function updateToDatabase(host: NecessaryServices<"vault", "fileHandler">, log: LogFunction, logLevel: LOG_LEVEL, file: UXFileInfoStub): Promise<FilePairProcessResult>;
 export declare function updateToStorage(host: NecessaryServices<"vault" | "path", "fileHandler">, log: LogFunction, logLevel: LOG_LEVEL, w: MetaEntry): Promise<FilePairProcessResult>;
-export declare function syncStorageAndDatabase(host: NecessaryServices<"setting" | "vault" | "path", "storageAccess" | "fileHandler">, log: LogFunction, file: UXFileInfoStub, logLevel: LOG_LEVEL, doc: MetaEntry): Promise<FilePairProcessResult>;
+export declare function syncStorageAndDatabase(host: NecessaryServices<"setting" | "vault" | "path", "storageAccess" | "fileHandler">, log: LogFunction, file: UXFileInfoStub, logLevel: LOG_LEVEL, doc: MetaEntry, scanOptions?: VaultScanOptions): Promise<FilePairProcessResult>;
 export declare const FullScanModes: {
     readonly DB_APPLY: "db-apply";
     readonly NEWER_WINS: "newer-wins";
@@ -205,7 +205,7 @@ export declare const ExtraOnLocal: {
      */
     readonly APPEND_STORAGE_ONLY: "append-storage-only";
 };
-export interface FullScanOptions {
+export interface FullScanOptions extends VaultScanOptions {
     mode: FullScanMode;
     extraOnLocal?: (typeof ExtraOnLocal)[keyof typeof ExtraOnLocal];
     extraOnRemote?: (typeof ExtraOnRemote)[keyof typeof ExtraOnRemote];

package/dist/serviceFeatures/offlineScanner.js

@@ -350,7 +350,7 @@ function getPathFromEntry(host, doc) {
   const path = host.services.path.getPath(doc);
   return path;
 }
-async function syncFileBetweenDBandStorage(host, log, file, doc) {
+async function syncFileBetweenDBandStorage(host, log, file, doc, scanOptions) {
   const docPath = getPathFromEntry(host, doc);
   if (!doc) {
     throw new Error(`Missing doc:${docPath}`);
@@ -393,6 +393,10 @@ async function syncFileBetweenDBandStorage(host, log, file, doc) {
         log(`STORAGE ? DB : ${file.path} has been skipped due to file size exceeding the limit`, LOG_LEVEL_NOTICE);
         return FilePairProcessResults.SKIPPED;
       }
+      if (scanOptions?.strictContentCheck === false && await host.serviceModules.fileHandler.canSkipUnchangedFile?.(file, doc)) {
+        log(`STORAGE ? DB : ${file.path} skipped using unchanged storage and revision metadata`, LOG_LEVEL_DEBUG);
+        return FilePairProcessResults.SKIPPED;
+      }
       if (doc._rev && await host.serviceModules.fileHandler.tryRecordUntrackedFileRevision(file, doc._rev)) {
         log("STORAGE == DB :" + file.path, LOG_LEVEL_DEBUG);
         return FilePairProcessResults.COMPLETED;
@@ -549,13 +553,13 @@ async function updateToStorage(host, log, logLevel, w) {
     return FilePairProcessResults.FAILED;
   }
 }
-async function syncStorageAndDatabase(host, log, file, logLevel, doc) {
+async function syncStorageAndDatabase(host, log, file, logLevel, doc, scanOptions) {
   if ((doc._conflicts?.length ?? 0) > 0) {
     log(`SYNC DATABASE AND STORAGE: ${file.path} has conflicts. skipped`, LOG_LEVEL_INFO);
     return FilePairProcessResults.SKIPPED;
   }
   if (!host.services.vault.isFileSizeTooLarge(file.stat.size) && !host.services.vault.isFileSizeTooLarge(doc.size)) {
-    return await syncFileBetweenDBandStorage(host, log, file, doc);
+    return await syncFileBetweenDBandStorage(host, log, file, doc, scanOptions);
   } else {
     log(
       `SYNC DATABASE AND STORAGE: ${getPathFromEntry(host, doc)} has been skipped due to file size exceeding the limit`,
@@ -698,7 +702,7 @@ async function processFilePair(host, log, pair, options) {
         if (!file || !doc) {
           throw new Error(`Cannot compare freshness for ${path}`);
         }
-        const syncResult = await syncStorageAndDatabase(host, log, file, LOG_LEVEL_INFO, doc);
+        const syncResult = await syncStorageAndDatabase(host, log, file, LOG_LEVEL_INFO, doc, options);
         if (syncResult === FilePairProcessResults.COMPLETED) {
           updateFileMTimeInMap(host, fileMapKey, Math.max(file.stat.mtime, doc.mtime));
         }
@@ -922,11 +926,12 @@ async function performFullScan(host, log, errorManager, showingNoticeOrOptions =
 function useOfflineScanner(host) {
   const log = createInstanceLogFunction("SF:OfflineScanner", host.services.API);
   const errorManager = new UnresolvedErrorManager(host.services.appLifecycle, host.services.context.events);
-  const handleScanVault = async (showingNotice, ignoreSuspending = false, continueOnFileFailure = false) => {
+  const handleScanVault = async (showingNotice, ignoreSuspending = false, continueOnFileFailure = false, scanOptions) => {
     return await performFullScan(host, log, errorManager, {
       showingNotice,
       ignoreSuspending,
-      continueOnFileFailure
+      continueOnFileFailure,
+      strictContentCheck: scanOptions?.strictContentCheck
     });
   };
   host.services.vault.scanVault.addHandler(handleScanVault);

package/dist/serviceFeatures/prepareDatabaseForUse.d.ts

@@ -1,7 +1,7 @@
 import type { NecessaryServices } from "../interfaces/ServiceModule.js";
 import { UnresolvedErrorManager } from "../services/base/UnresolvedErrorManager.js";
 import { type LogFunction } from "../services/lib/logUtils.js";
-import { type VaultScanResult } from "../services/base/VaultScanResult.js";
+import { type VaultScanResult, type VaultScanOptions } from "../services/base/VaultScanResult.js";
 /**
  * Initialise the database and trigger a full vault scan.
  * @param host Services container
@@ -11,9 +11,10 @@ import { type VaultScanResult } from "../services/base/VaultScanResult.js";
  * @param reopenDatabase Whether to reopen the database connection
  * @param ignoreSuspending Whether to ignore suspension settings
  * @param continueOnFileFailure Whether individual file failures may satisfy application readiness
+ * @param scanOptions Optional content-check policy; omitted options keep strict checks
  * @returns The initialisation outcome, including accepted individual file failures
  */
-export declare function prepareDatabaseForUse(host: NecessaryServices<"appLifecycle" | "setting" | "vault" | "path" | "database" | "databaseEvents" | "fileProcessing" | "replicator", never>, log: LogFunction, errorManager: UnresolvedErrorManager, showingNotice?: boolean, reopenDatabase?: boolean, ignoreSuspending?: boolean, continueOnFileFailure?: boolean): Promise<VaultScanResult>;
+export declare function prepareDatabaseForUse(host: NecessaryServices<"appLifecycle" | "setting" | "vault" | "path" | "database" | "databaseEvents" | "fileProcessing" | "replicator", never>, log: LogFunction, errorManager: UnresolvedErrorManager, showingNotice?: boolean, reopenDatabase?: boolean, ignoreSuspending?: boolean, continueOnFileFailure?: boolean, scanOptions?: VaultScanOptions): Promise<VaultScanResult>;
 /**
  * Associate the initialiser file feature with the app lifecycle events.
  * This function binds initialization handlers to the appropriate lifecycle events.

package/dist/serviceFeatures/prepareDatabaseForUse.js

@@ -6,7 +6,7 @@ function reportPreparationFailure(log, message) {
   log(message, LOG_LEVEL_VERBOSE);
   return false;
 }
-async function prepareDatabaseForUse(host, log, errorManager, showingNotice = false, reopenDatabase = true, ignoreSuspending = false, continueOnFileFailure = false) {
+async function prepareDatabaseForUse(host, log, errorManager, showingNotice = false, reopenDatabase = true, ignoreSuspending = false, continueOnFileFailure = false, scanOptions) {
   const appLifecycle = host.services.appLifecycle;
   appLifecycle.resetIsReady();
   try {
@@ -25,7 +25,7 @@ async function prepareDatabaseForUse(host, log, errorManager, showingNotice = fa
         "Database preparation stopped because the local database is not ready."
       );
     }
-    const scanResult = await host.services.vault.scanVault(showingNotice, ignoreSuspending, continueOnFileFailure);
+    const scanResult = await host.services.vault.scanVault(showingNotice, ignoreSuspending, continueOnFileFailure, scanOptions);
     if (scanResult === VaultScanResults.FAILED) {
       return reportPreparationFailure(log, "Database preparation stopped because the Vault scan failed.");
     }
@@ -57,7 +57,7 @@ async function prepareDatabaseForUse(host, log, errorManager, showingNotice = fa
 function usePrepareDatabaseForUse(host) {
   const log = createInstanceLogFunction("SF:prepareDatabaseForUse", host.services.API);
   const errorManager = new UnresolvedErrorManager(host.services.appLifecycle, host.services.context.events);
-  const initialiseDatabaseHandler = async (showingNotice = false, reopenDatabase = true, ignoreSuspending = false, continueOnFileFailure = false) => {
+  const initialiseDatabaseHandler = async (showingNotice = false, reopenDatabase = true, ignoreSuspending = false, continueOnFileFailure = false, scanOptions) => {
     return await prepareDatabaseForUse(
       host,
       log,
@@ -65,7 +65,8 @@ function usePrepareDatabaseForUse(host) {
       showingNotice,
       reopenDatabase,
       ignoreSuspending,
-      continueOnFileFailure
+      continueOnFileFailure,
+      scanOptions
     );
   };
   host.services.databaseEvents.initialiseDatabase.addHandler(initialiseDatabaseHandler);

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

@@ -258,6 +258,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);

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.