@vrtmrz/livesync-commonlib 0.2.2 → 0.3.0

package/dist/rpc/RpcRoom.js

@@ -1,4 +1,7 @@
 import { compatGlobal } from "../common/coreEnvFunctions.js";
+import {
+  createDeferredAction
+} from "octagonal-wheels/concurrency/deferredAction";
 import { IncomingChunkBuffer, estimateBytes, splitIntoChunks } from "./chunking.js";
 import { asRpcErrorShape, RpcError } from "./errors.js";
 import { RpcSession } from "./RpcSession.js";
@@ -12,6 +15,10 @@ function newId(prefix) {
 function validNamespacedMethod(method) {
   return method.includes(".") || method.includes("/");
 }
+const scheduleRpcTimeout = (callback, delayMs) => {
+  const handle = compatGlobal.setTimeout(callback, delayMs);
+  return () => compatGlobal.clearTimeout(handle);
+};
 class RpcRoom {
   options;
   pending = /* @__PURE__ */ new Map();
@@ -21,7 +28,7 @@ class RpcRoom {
   sessions = /* @__PURE__ */ new Map();
   outgoingChunkMap = /* @__PURE__ */ new Map();
   incomingChunkMap = /* @__PURE__ */ new Map();
-  incomingChunkTimers = /* @__PURE__ */ new Map();
+  incomingChunkWaits = /* @__PURE__ */ new Map();
   peerVersion = /* @__PURE__ */ new Map();
   disposers = [];
   closed = false;
@@ -83,8 +90,8 @@ class RpcRoom {
     this.sessions.clear();
     this.outgoingChunkMap.clear();
     this.incomingChunkMap.clear();
-    this.incomingChunkTimers.forEach((h) => compatGlobal.clearTimeout(h));
-    this.incomingChunkTimers.clear();
+    this.incomingChunkWaits.forEach((wait) => wait.dispose());
+    this.incomingChunkWaits.clear();
   }
   session(peerId) {
     const existing = this.sessions.get(peerId);
@@ -125,30 +132,32 @@ class RpcRoom {
     const requestId = newId("req");
     let pending;
     const p = new Promise((resolve, reject) => {
+      const signal = options.signal;
+      const onAbort = () => {
+        const current = this.pending.get(requestId);
+        if (!current) return;
+        this.rejectPending(requestId, new RpcError("CANCELLED", `RPC cancelled: ${method}`), true);
+      };
+      const deadline = timeoutMs > 0 ? createDeferredAction(() => {
+        this.rejectPending(requestId, new RpcError("TIMEOUT", `RPC timed out: ${method}`), true);
+      }, scheduleRpcTimeout) : void 0;
       pending = {
         peerId,
         method,
         resolve,
         reject,
-        signal: options.signal,
+        releaseWait: () => {
+          deadline?.dispose();
+          signal?.removeEventListener("abort", onAbort);
+        },
         requestSent: false,
         cancelRequested: false
       };
-      if (timeoutMs > 0) {
-        pending.timeoutHandle = compatGlobal.setTimeout(() => {
-          this.rejectPending(requestId, new RpcError("TIMEOUT", `RPC timed out: ${method}`), true);
-        }, timeoutMs);
-      }
+      deadline?.schedule(timeoutMs);
       this.pending.set(requestId, pending);
-      if (options.signal) {
-        const onAbort = () => {
-          const current = this.pending.get(requestId);
-          if (!current) return;
-          this.rejectPending(requestId, new RpcError("CANCELLED", `RPC cancelled: ${method}`), true);
-        };
-        pending.abortListener = onAbort;
-        options.signal.addEventListener("abort", onAbort, { once: true });
-        if (options.signal.aborted) onAbort();
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted) onAbort();
       }
     });
     const sendTask = this.sendEnvelope(peerId, {
@@ -191,12 +200,7 @@ class RpcRoom {
     const pending = this.pending.get(requestId);
     if (!pending) return void 0;
     this.pending.delete(requestId);
-    if (pending.timeoutHandle !== void 0) {
-      compatGlobal.clearTimeout(pending.timeoutHandle);
-    }
-    if (pending.signal && pending.abortListener) {
-      pending.signal.removeEventListener("abort", pending.abortListener);
-    }
+    pending.releaseWait();
     return pending;
   }
   rejectPending(requestId, error, notifyRemote = false) {
@@ -229,28 +233,25 @@ class RpcRoom {
     const chunks = splitIntoChunks(serialized, this.options.maxWirePayloadBytes);
     this.outgoingChunkMap.set(streamId, { peerId, chunks });
     for (let i = 0; i < chunks.length; i++) {
-      await this.options.transport.send(
-        {
-          wire: "chunk",
-          streamId,
-          index: i,
-          total: chunks.length,
-          payload: chunks[i]
-        },
-        peerId
-      );
+      await this.sendChunk(peerId, streamId, chunks.length, i, chunks[i]);
     }
   }
+  sendChunk(peerId, streamId, total, index, payload) {
+    return this.options.transport.send({ wire: "chunk", streamId, index, total, payload }, peerId);
+  }
+  sendErrorResponse(peerId, requestId, error) {
+    return this.sendEnvelope(peerId, { kind: "response", requestId, ok: false, error });
+  }
   scheduleMissingAck(streamId, peerId) {
-    const existing = this.incomingChunkTimers.get(streamId);
-    if (existing) compatGlobal.clearTimeout(existing);
-    const handle = compatGlobal.setTimeout(() => {
+    this.incomingChunkWaits.get(streamId)?.dispose();
+    const wait = createDeferredAction(() => {
       const state = this.incomingChunkMap.get(streamId);
       if (!state || state.isComplete()) return;
       const missing = state.missingIndices();
       void this.options.transport.send({ wire: "chunk-ack", streamId, missing }, peerId);
-    }, this.options.chunkMissingRetryMs);
-    this.incomingChunkTimers.set(streamId, handle);
+    }, scheduleRpcTimeout);
+    wait.schedule(this.options.chunkMissingRetryMs);
+    this.incomingChunkWaits.set(streamId, wait);
   }
   async onWireMessage(message, peerId) {
     if (message.wire === "raw") {
@@ -266,9 +267,8 @@ class RpcRoom {
       state2.add(message.index, message.payload);
       this.scheduleMissingAck(message.streamId, peerId);
       if (state2.isComplete()) {
-        const timer = this.incomingChunkTimers.get(message.streamId);
-        if (timer) compatGlobal.clearTimeout(timer);
-        this.incomingChunkTimers.delete(message.streamId);
+        this.incomingChunkWaits.get(message.streamId)?.dispose();
+        this.incomingChunkWaits.delete(message.streamId);
         this.incomingChunkMap.delete(message.streamId);
         await this.options.transport.send(
           { wire: "chunk-ack", streamId: message.streamId, missing: [] },
@@ -287,16 +287,7 @@ class RpcRoom {
     for (const index of message.missing) {
       const payload = state.chunks[index];
       if (payload === void 0) continue;
-      await this.options.transport.send(
-        {
-          wire: "chunk",
-          streamId: message.streamId,
-          index,
-          total: state.chunks.length,
-          payload
-        },
-        state.peerId
-      );
+      await this.sendChunk(state.peerId, message.streamId, state.chunks.length, index, payload);
     }
   }
   async onEnvelopePayload(payload, peerId) {
@@ -319,8 +310,8 @@ class RpcRoom {
       return;
     }
     if (envelope.kind === "cancel") {
-      const ctx2 = this.inboundCalls.get(envelope.requestId);
-      if (ctx2 && ctx2.peerId === peerId) this.abortInboundCall(envelope.requestId, ctx2);
+      const ctx = this.inboundCalls.get(envelope.requestId);
+      if (ctx && ctx.peerId === peerId) this.abortInboundCall(envelope.requestId, ctx);
       return;
     }
     if (envelope.kind === "response") {
@@ -335,6 +326,9 @@ class RpcRoom {
       }
       return;
     }
+    return this.onRequest(envelope, peerId);
+  }
+  async onRequest(envelope, peerId) {
     const controller = new AbortController();
     const ctx = { controller, signal: controller.signal, peerId };
     this.inboundCalls.set(envelope.requestId, ctx);
@@ -344,12 +338,7 @@ class RpcRoom {
     } catch (ex) {
       this.inboundCalls.delete(envelope.requestId);
       if (!ctx.signal.aborted && !this.closed) {
-        await this.sendEnvelope(peerId, {
-          kind: "response",
-          requestId: envelope.requestId,
-          ok: false,
-          error: asRpcErrorShape(ex)
-        });
+        await this.sendErrorResponse(peerId, envelope.requestId, asRpcErrorShape(ex));
       }
       return;
     }
@@ -364,14 +353,9 @@ class RpcRoom {
     const version = this.peerVersion.get(peerId);
     if (version && version.major !== RPC_VERSION_MAJOR) {
       if (!ctx.signal.aborted && !this.closed) {
-        await this.sendEnvelope(peerId, {
-          kind: "response",
-          requestId: envelope.requestId,
-          ok: false,
-          error: {
-            code: "REMOTE_ERROR",
-            message: `RPC major mismatch: local=${RPC_VERSION_MAJOR}, remote=${version.major}`
-          }
+        await this.sendErrorResponse(peerId, envelope.requestId, {
+          code: "REMOTE_ERROR",
+          message: `RPC major mismatch: local=${RPC_VERSION_MAJOR}, remote=${version.major}`
         });
       }
       this.inboundCalls.delete(envelope.requestId);
@@ -386,48 +370,15 @@ class RpcRoom {
     const method = this.methods.get(envelope.method);
     if (!method) {
       if (!ctx.signal.aborted && !this.closed) {
-        await this.sendEnvelope(peerId, {
-          kind: "response",
-          requestId: envelope.requestId,
-          ok: false,
-          error: {
-            code: "REMOTE_ERROR",
-            message: `Method not found: ${envelope.method}`
-          }
+        await this.sendErrorResponse(peerId, envelope.requestId, {
+          code: "REMOTE_ERROR",
+          message: `Method not found: ${envelope.method}`
         });
       }
       this.inboundCalls.delete(envelope.requestId);
       return;
     }
-    const runner = async () => {
-      try {
-        if (ctx.signal.aborted || this.closed) return;
-        const data = method.cancellationAware ? await method.handler(
-          ctx,
-          peerId,
-          ...envelope.args
-        ) : await method.handler(peerId, ...envelope.args);
-        if (ctx.signal.aborted || this.closed) return;
-        await this.sendEnvelope(peerId, {
-          kind: "response",
-          requestId: envelope.requestId,
-          ok: true,
-          data
-        });
-      } catch (ex) {
-        if (ctx.signal.aborted || this.closed) return;
-        await this.sendEnvelope(peerId, {
-          kind: "response",
-          requestId: envelope.requestId,
-          ok: false,
-          error: asRpcErrorShape(ex)
-        });
-      } finally {
-        if (this.inboundCalls.get(envelope.requestId) === ctx) {
-          this.inboundCalls.delete(envelope.requestId);
-        }
-      }
-    };
+    const runner = () => this.runMethod(method, envelope, peerId, ctx);
     if (method.serial) {
       method.queue = method.queue.then(runner, runner);
       await method.queue;
@@ -435,6 +386,30 @@ class RpcRoom {
       await runner();
     }
   }
+  async runMethod(method, envelope, peerId, ctx) {
+    try {
+      if (ctx.signal.aborted || this.closed) return;
+      const data = method.cancellationAware ? await method.handler(
+        ctx,
+        peerId,
+        ...envelope.args
+      ) : await method.handler(peerId, ...envelope.args);
+      if (ctx.signal.aborted || this.closed) return;
+      await this.sendEnvelope(peerId, {
+        kind: "response",
+        requestId: envelope.requestId,
+        ok: true,
+        data
+      });
+    } catch (ex) {
+      if (ctx.signal.aborted || this.closed) return;
+      await this.sendErrorResponse(peerId, envelope.requestId, asRpcErrorShape(ex));
+    } finally {
+      if (this.inboundCalls.get(envelope.requestId) === ctx) {
+        this.inboundCalls.delete(envelope.requestId);
+      }
+    }
+  }
 }
 export {
   RpcRoom

package/dist/serviceFeatures/offlineScanner.d.ts

@@ -245,7 +245,7 @@ export declare function resolveFilePairAction(state: FilePairState, options: Ful
  * @param options Full scan options
  * @returns The scan result for all file pairs
  */
-export declare function synchroniseAllFilesBetweenDBandStorage(host: NecessaryServices<"setting" | "vault" | "path" | "fileProcessing" | "database" | "keyValueDB", "storageAccess" | "fileHandler">, log: LogFunction, errorManager: UnresolvedErrorManager, options: FullScanOptions): Promise<VaultScanResult>;
+export declare function synchroniseAllFilesBetweenDBandStorage(host: NecessaryServices<"setting" | "vault" | "path" | "database" | "keyValueDB", "storageAccess" | "fileHandler">, log: LogFunction, errorManager: UnresolvedErrorManager, options: FullScanOptions): Promise<VaultScanResult>;
 export declare function normaliseFullScanOptions(showingNoticeOrOptions: Partial<FullScanOptions> | boolean | undefined, ignoreSuspending?: boolean): FullScanOptions;
 /**
  * Remove one path from the Offline Scanner's durable last-seen state.
@@ -264,11 +264,11 @@ export declare function clearOfflineScannerLastSeen(host: NecessaryServices<"set
  * @param ignoreSuspending Legacy suspension flag used with the notice flag
  * @returns The scan outcome, including accepted individual file failures
  */
-export declare function performFullScan(host: NecessaryServices<"setting" | "vault" | "path" | "fileProcessing" | "database" | "keyValueDB", "storageAccess" | "fileHandler">, log: LogFunction, errorManager: UnresolvedErrorManager, options?: Partial<FullScanOptions>): Promise<VaultScanResult>;
-export declare function performFullScan(host: NecessaryServices<"setting" | "vault" | "path" | "fileProcessing" | "database" | "keyValueDB", "storageAccess" | "fileHandler">, log: LogFunction, errorManager: UnresolvedErrorManager, showingNotice?: boolean, ignoreSuspending?: boolean): Promise<VaultScanResult>;
+export declare function performFullScan(host: NecessaryServices<"setting" | "vault" | "path" | "database" | "keyValueDB", "storageAccess" | "fileHandler">, log: LogFunction, errorManager: UnresolvedErrorManager, options?: Partial<FullScanOptions>): Promise<VaultScanResult>;
+export declare function performFullScan(host: NecessaryServices<"setting" | "vault" | "path" | "database" | "keyValueDB", "storageAccess" | "fileHandler">, log: LogFunction, errorManager: UnresolvedErrorManager, showingNotice?: boolean, ignoreSuspending?: boolean): Promise<VaultScanResult>;
 /**
  * Associate the initialiser file feature with the app lifecycle events.
  * This function binds initialization handlers to the appropriate lifecycle events.
  * @param host Services container with required dependencies
  */
-export declare function useOfflineScanner(host: NecessaryServices<"API" | "appLifecycle" | "setting" | "vault" | "path" | "database" | "databaseEvents" | "fileProcessing" | "keyValueDB" | "replicator", "storageAccess" | "fileHandler">): void;
+export declare function useOfflineScanner(host: NecessaryServices<"API" | "appLifecycle" | "setting" | "vault" | "path" | "database" | "keyValueDB", "storageAccess" | "fileHandler">): void;

package/dist/serviceFeatures/offlineScanner.js

@@ -15,7 +15,7 @@ import { BASE_IS_NEW, EVEN, TARGET_IS_NEW } from "../common/models/shared.const.
 import { UnresolvedErrorManager } from "../services/base/UnresolvedErrorManager.js";
 import { compatGlobal } from "../common/coreEnvFunctions.js";
 import { ICHeader, ICXHeader, PSCHeader } from "../common/models/fileaccess.const.js";
-import { serialized } from "octagonal-wheels/concurrency/lock";
+import { serialized, withLocks } from "octagonal-wheels/concurrency/lock";
 import { VaultScanResults } from "../services/base/VaultScanResult.js";
 const FilePairProcessResults = {
   COMPLETED: "completed",
@@ -218,17 +218,10 @@ function createReaddressedMetadata(source, expectedDocumentId) {
 }
 async function serializedByMetadataDocumentIds(documentIds, callback) {
   const lockKeys = [...new Set(documentIds)].sort().map((documentId) => `processFileEvent-${documentId}`);
-  const acquire = async (index) => {
-    const key = lockKeys[index];
-    if (key === void 0) return await callback();
-    return await serialized(key, () => acquire(index + 1));
-  };
-  return await acquire(0);
+  return await withLocks(lockKeys, callback);
 }
 function findRepairEntry(entries, actualDocumentId) {
-  return entries.find(
-    ({ inspection }) => inspection.diagnostic.actualDocumentId === actualDocumentId
-  );
+  return entries.find(({ inspection }) => inspection.diagnostic.actualDocumentId === actualDocumentId);
 }
 async function repairMetadataDocumentIdentity(host, request) {
   const baseResult = {
@@ -443,6 +436,9 @@ function convertCase(settings, path) {
   }
   return normalisedPath.toLowerCase();
 }
+function createComparisonPathLookup(settings, paths) {
+  return Object.fromEntries(paths.map((path) => [convertCase(settings, path), path]));
+}
 async function collectFilesOnStorage(host, settings, log) {
   log("Collecting local files on the storage", LOG_LEVEL_VERBOSE);
   const filesStorageSrc = await host.serviceModules.storageAccess.getFiles();
@@ -455,8 +451,7 @@ async function collectFilesOnStorage(host, settings, log) {
   }
   const storageFileNameMap = Object.fromEntries(_filesStorage.map((e) => [e.path, e]));
   const storageFileNames = Object.keys(storageFileNameMap);
-  const storageFileNameCapsPair = storageFileNames.map((e) => [e, convertCase(settings, e)]);
-  const storageFileNameCI2CS = Object.fromEntries(storageFileNameCapsPair.map((e) => [e[1], e[0]]));
+  const storageFileNameCI2CS = createComparisonPathLookup(settings, storageFileNames);
   return { storageFileNameMap, storageFileNames, storageFileNameCI2CS };
 }
 async function collectDatabaseFiles(host, settings, log, showingNotice) {
@@ -500,8 +495,7 @@ async function collectDatabaseFiles(host, settings, log, showingNotice) {
   }
   const databaseFileNameMap = Object.fromEntries(_DBEntries.map((e) => [getPathFromEntry(host, e), e]));
   const databaseFileNames = Object.keys(databaseFileNameMap);
-  const databaseFileNameCapsPair = databaseFileNames.map((e) => [e, convertCase(settings, e)]);
-  const databaseFileNameCI2CS = Object.fromEntries(databaseFileNameCapsPair.map((e) => [e[1], e[0]]));
+  const databaseFileNameCI2CS = createComparisonPathLookup(settings, databaseFileNames);
   const quarantinedFileNamesLC = new Set(
     [...unresolvedFileNamesLC].filter((path) => !resolvableFileNamesLC.has(path))
   );
@@ -750,7 +744,12 @@ async function synchroniseAllFilesBetweenDBandStorage(host, log, errorManager, o
   const showingNotice = options.showingNotice ?? false;
   await loadFileStatus(host);
   const { storageFileNameMap, storageFileNameCI2CS } = await collectFilesOnStorage(host, settings, log);
-  const { databaseFileNameMap, databaseFileNameCI2CS, quarantinedFileNamesLC } = await collectDatabaseFiles(host, settings, log, showingNotice);
+  const { databaseFileNameMap, databaseFileNameCI2CS, quarantinedFileNamesLC } = await collectDatabaseFiles(
+    host,
+    settings,
+    log,
+    showingNotice
+  );
   const pairs = [];
   for (const fileNameLC of unique([
     ...Object.keys(storageFileNameCI2CS),

package/dist/serviceFeatures/prepareDatabaseForUse.d.ts

@@ -14,10 +14,10 @@ import { type VaultScanResult, type VaultScanOptions } from "../services/base/Va
  * @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, scanOptions?: VaultScanOptions): Promise<VaultScanResult>;
+export declare function prepareDatabaseForUse(host: NecessaryServices<"appLifecycle" | "vault" | "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.
  * @param host Services container with required dependencies
  */
-export declare function usePrepareDatabaseForUse(host: NecessaryServices<"API" | "appLifecycle" | "setting" | "vault" | "path" | "database" | "databaseEvents" | "fileProcessing" | "replicator", never>): void;
+export declare function usePrepareDatabaseForUse(host: NecessaryServices<"API" | "appLifecycle" | "vault" | "database" | "databaseEvents" | "fileProcessing" | "replicator", never>): void;

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/Rebuilder.d.ts

@@ -66,6 +66,7 @@ export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilder
     private scheduleInitialisation;
     scheduleRebuild(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
     scheduleFetch(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
+    private markRemoteLockedForRebuild;
     private _tryResetRemoteDatabase;
     private _onResetLocalDatabase;
     suspendAllSync(): Promise<void>;

package/dist/serviceModules/Rebuilder.js

@@ -26,6 +26,12 @@ const FAST_FETCH_RETRY_DELAYS = [2e3, 5e3, 1e4, 2e4];
 function canResetCentralRemote(replicator) {
   return "tryResetRemoteDatabase" in replicator && typeof replicator.tryResetRemoteDatabase === "function";
 }
+function canCheckJournalPathIdentity(replicator) {
+  return "assertRemotePathIdentity" in replicator && typeof replicator.assertRemotePathIdentity === "function";
+}
+function canLockJournalForRebuild(replicator) {
+  return canResetCentralRemote(replicator) && "markRemoteLockedForRebuild" in replicator && typeof replicator.markRemoteLockedForRebuild === "function";
+}
 class ServiceRebuilder extends ServiceModuleBase {
   events;
   appLifecycle;
@@ -100,7 +106,7 @@ Please enable them from the settings screen after setup is complete.`,
       notifyThresholdOfRemoteStorageSize: DEFAULT_SETTINGS.notifyThresholdOfRemoteStorageSize
     });
     await this.control.applySettings();
-    await this.replication.markLocked();
+    await this.markRemoteLockedForRebuild();
     await this._tryResetRemoteDatabase();
     await this.replication.markLocked();
     await delay(500);
@@ -145,7 +151,7 @@ Please enable them from the settings screen after setup is complete.`,
       }
       return;
     }
-    await this.replication.markLocked();
+    await this.markRemoteLockedForRebuild();
     await this._tryResetRemoteDatabase();
     await this.replication.markLocked();
     await delay(500);
@@ -170,9 +176,6 @@ Please enable them from the settings screen after setup is complete.`,
       await assertDatabasePathIdentity(this.database.localDatabase.localDatabase, settings);
     }
     if (getPathNormalizationVersion(settings) === 0) return;
-    if (settings.remoteType !== REMOTE_COUCHDB) {
-      throw new Error("NFC path identity is supported only with CouchDB. No database has been reset.");
-    }
     const paths = await this.storageAccess.getFileNames();
     const selected = [];
     const databaseReady = this.database.isDatabaseReady();
@@ -191,6 +194,19 @@ Please enable them from the settings screen after setup is complete.`,
   }
   async checkRemotePathIdentityBeforeFetch() {
     const settings = this.setting.currentSettings();
+    if (settings.remoteType === REMOTE_MINIO) {
+      const trial = await this.replicator.getNewReplicator(settings);
+      if (!trial) throw new Error("Could not create a Journal replicator for the Fetch identity check.");
+      try {
+        if (!canCheckJournalPathIdentity(trial)) {
+          throw new Error("The Journal replicator does not support the Fetch identity check.");
+        }
+        await trial.assertRemotePathIdentity(settings);
+      } finally {
+        await trial.closeReplication();
+      }
+      return;
+    }
     if (settings.remoteType !== REMOTE_COUCHDB) return;
     const remote = settings.couchDB_URI.replace(/\/+$/, "") + (settings.couchDB_DBNAME === "" ? "" : "/" + settings.couchDB_DBNAME);
     const connection = await this.remote.connect(
@@ -262,6 +278,18 @@ Please enable them from the settings screen after setup is complete.`,
   scheduleFetch(prepareBeforeRestart) {
     return this.scheduleInitialisation(FlagFilesHumanReadable.FETCH_ALL, prepareBeforeRestart);
   }
+  async markRemoteLockedForRebuild() {
+    const settings = this.setting.currentSettings();
+    if (settings.remoteType !== REMOTE_MINIO) {
+      await this.replication.markLocked();
+      return;
+    }
+    const replicator = this.replicator.getActiveReplicator();
+    if (!replicator || !canLockJournalForRebuild(replicator)) {
+      throw new Error("The active Journal replicator does not support safe reconstruction.");
+    }
+    await replicator.markRemoteLockedForRebuild(settings);
+  }
   async _tryResetRemoteDatabase() {
     const currentReplicator = this.replicator.getActiveReplicator();
     const settings = this.setting.currentSettings();

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);
@@ -1200,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/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.