@vrtmrz/livesync-commonlib 0.2.1 → 0.2.3

package/dist/diagnostics/integrity.js

@@ -1,3 +1,4 @@
+import { withScope } from "octagonal-wheels/resource/scope";
 import {
   DOCID_SYNC_PARAMETERS,
   EntryTypes,
@@ -749,12 +750,11 @@ async function analyseDatabaseIntegrity(options) {
   let wasCancelled = cancelled(options);
   let configurationChanged = false;
   let pathEquivalenceGroups = [];
-  let ownedRemote;
   if (!wasCancelled && !isConfigurationCurrent(options)) {
     configurationChanged = true;
     appendError(errors, "configuration", "configuration-changed");
   }
-  try {
+  await withScope(void 0, async (scope) => {
     if (!wasCancelled && !configurationChanged) {
       const localRun = makeSourceRun("local", options.local);
       runs.push(localRun);
@@ -768,7 +768,14 @@ async function analyseDatabaseIntegrity(options) {
           runs.push(remoteRun);
         } else {
           try {
-            ownedRemote = await options.remote();
+            const ownedRemote = await options.remote();
+            scope.defer(async () => {
+              try {
+                await ownedRemote.close();
+              } catch {
+                appendError(errors, "remote", "source-unavailable");
+              }
+            });
             if (cancelled(options)) {
               wasCancelled = true;
             } else {
@@ -851,15 +858,7 @@ async function analyseDatabaseIntegrity(options) {
         }
       }
     }
-  } finally {
-    if (ownedRemote) {
-      try {
-        await ownedRemote.close();
-      } catch {
-        appendError(errors, "remote", "source-unavailable");
-      }
-    }
-  }
+  });
   if (cancelled(options)) wasCancelled = true;
   if (!wasCancelled && !configurationChanged && !isConfigurationCurrent(options)) {
     configurationChanged = true;

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

@@ -20,29 +20,49 @@ export interface ServiceModules {
      */
     rebuilder: Rebuilder;
 }
-export type RequiredServices<T extends keyof ServiceHub> = Pick<ServiceHub, T | "context">;
+/**
+ * Selects service dependencies from the host's service type.
+ * A context is retained when the selected source exposes one. The default
+ * source preserves the existing ServiceHub dependency contract.
+ */
+export type RequiredServices<T extends keyof THub, THub = ServiceHub> = Pick<THub, T | Extract<"context", keyof THub>>;
 export type RequiredServiceModules<T extends keyof ServiceModules> = Pick<ServiceModules, T>;
-export type RequiredServicesInterfaces<T extends keyof IServiceHub> = Pick<IServiceHub, T>;
+export type RequiredServicesInterfaces<T extends keyof IServiceHub> = RequiredServices<T, IServiceHub>;
 export type RequiredServiceModulesInterfaces<T extends keyof ServiceModules> = Pick<ServiceModules, T>;
-export type NecessaryServices<T extends keyof ServiceHub, U extends keyof ServiceModules> = {
-    services: RequiredServices<T>;
+/**
+ * Declares the Services and ServiceModules consumed by a feature.
+ * Select a more specific source to retain injectable handlers or an extended
+ * host context, or use IServiceHub for operation-only interfaces. Additional
+ * collaborators, such as a borrowed LogFunction, belong in the feature's own
+ * dependency type. This type neither selects runtime values nor owns them.
+ */
+export type NecessaryServices<T extends keyof THub, U extends keyof ServiceModules, THub = ServiceHub> = {
+    services: RequiredServices<T, THub>;
     serviceModules: RequiredServiceModules<U>;
 };
-export type NecessaryServicesInterfaces<T extends keyof IServiceHub, U extends keyof ServiceModules> = {
-    services: RequiredServicesInterfaces<T>;
-    serviceModules: RequiredServiceModulesInterfaces<U>;
-};
-export type ServiceFeatureFunction<T extends keyof ServiceHub, U extends keyof ServiceModules, TR> = (host: NecessaryServices<T, U>) => TR;
+export type NecessaryServicesInterfaces<T extends keyof IServiceHub, U extends keyof ServiceModules> = NecessaryServices<T, U, IServiceHub>;
+export type ServiceFeatureFunction<T extends keyof THub, U extends keyof ServiceModules, TR, THub = ServiceHub> = (host: NecessaryServices<T, U, THub>) => TR;
 type ServiceFeatureContext<T> = T & {
     _log: LogFunction;
 };
-export type ServiceFeatureFunctionWithContext<T extends keyof ServiceHub, U extends keyof ServiceModules, C, TR> = (host: NecessaryServices<T, U>, context: ServiceFeatureContext<C>) => TR;
+export type ServiceFeatureFunctionWithContext<T extends keyof THub, U extends keyof ServiceModules, C, TR, THub = ServiceHub> = (host: NecessaryServices<T, U, THub>, context: ServiceFeatureContext<C>) => TR;
+type AnyServiceFeature = (...args: never[]) => unknown;
+type ServiceFeatureWithArguments<T extends keyof THub, U extends keyof ServiceModules, THub = ServiceHub> = (host: NecessaryServices<T, U, THub>, ...args: never[]) => unknown;
 /**
- * Helper function to create a service feature with proper typing.
- * @param featureFunction The feature function to be wrapped.
- * @returns The same feature function with proper typing.
+ * Retains a service feature's complete function type and identity.
+ * Declare the dependency type on the feature parameter so that required
+ * collaborators, concrete service types, and returned views remain explicit.
+ * Optional arguments, overloads, generic signatures, and asynchronous results
+ * are preserved. Older unannotated callbacks retain their ServiceHub context;
+ * their dependency keys cannot be inferred from the callback body.
+ *
+ * This helper does not invoke the feature, acquire or release its dependencies,
+ * or wrap its return value or errors. The host owns composition and disposal.
+ * @param featureFunction The feature function to retain.
+ * @returns The supplied function without a runtime wrapper.
  * @example
- * const useIndexFeature = createServiceFeature((host: NecessaryServices<"appLifecycle", "storageAccess">) => {
+ * type IndexHost = NecessaryServices<"appLifecycle", "storageAccess">;
+ * const useIndexFeature = createServiceFeature((host: IndexHost) => {
  *   const { appLifecycle } = host.services;
  *   const { storageAccess } = host.serviceModules;
  *
@@ -51,18 +71,16 @@ export type ServiceFeatureFunctionWithContext<T extends keyof ServiceHub, U exte
  *     return true;
  *   });
  * });
- *
- * useIndexFeature({
- *   services: { context: serviceHub.context, appLifecycle: serviceHub.appLifecycle },
- *   serviceModules: { storageAccess },
- * });
  */
+export declare function createServiceFeature<TFeature extends ServiceFeatureWithArguments<keyof ServiceHub, keyof ServiceModules>>(featureFunction: TFeature): TFeature;
+export declare function createServiceFeature<TFeature extends AnyServiceFeature>(featureFunction: TFeature): TFeature;
 export declare function createServiceFeature<T extends keyof ServiceHub, U extends keyof ServiceModules, TR>(featureFunction: ServiceFeatureFunction<T, U, TR>): ServiceFeatureFunction<T, U, TR>;
-type ContextFactory<T extends keyof ServiceHub, U extends keyof ServiceModules, C> = (host: NecessaryServices<T, U>) => ServiceFeatureContext<C>;
-export declare function serviceFeature<T extends keyof ServiceHub, U extends keyof ServiceModules>(): {
-    create<TR>(featureFunction: ServiceFeatureFunction<T, U, TR>): ServiceFeatureFunction<T, U, TR>;
-    withContext<C extends object = object>(ContextFactory: ContextFactory<T, U, C>): {
-        create: <TR>(featureFunction: ServiceFeatureFunctionWithContext<T, U, C, TR>) => (host: NecessaryServices<T, U>, context: ServiceFeatureContext<C>) => TR;
+type ContextFactory<T extends keyof THub, U extends keyof ServiceModules, C, THub = ServiceHub> = (host: NecessaryServices<T, U, THub>) => ServiceFeatureContext<C>;
+/** Selects the host type for the existing service-feature builder. */
+export declare function serviceFeature<T extends keyof THub, U extends keyof ServiceModules, THub = ServiceHub>(): {
+    create: <TR, TFeature extends (host: NecessaryServices<T, U, THub>, ...args: never[]) => TR = ServiceFeatureFunction<T, U, TR, THub>>(featureFunction: TFeature) => TFeature;
+    withContext<C extends object = object>(ContextFactory: ContextFactory<T, U, C, THub>): {
+        create: <TR>(featureFunction: ServiceFeatureFunctionWithContext<T, U, C, TR, THub>) => (host: NecessaryServices<T, U, THub>, context: ServiceFeatureContext<C>) => TR;
     };
 };
 export {};

package/dist/interfaces/ServiceModule.js

@@ -2,10 +2,11 @@ function createServiceFeature(featureFunction) {
   return featureFunction;
 }
 function serviceFeature() {
+  function create(featureFunction) {
+    return featureFunction;
+  }
   return {
-    create(featureFunction) {
-      return featureFunction;
-    },
+    create,
     withContext(ContextFactory) {
       return {
         create: (featureFunction) => (host, context) => featureFunction(host, ContextFactory(host))

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

@@ -1,5 +1,6 @@
 import { type FileEventType, type FilePath, type UXFileInfoStub, type UXFolderInfo, type UXInternalFileInfoStub } from "../common/types.js";
 import { type FileEventItem } from "../common/types.js";
+import { type DeferredAction } from "octagonal-wheels/concurrency/deferredAction";
 import type { IStorageAccessManager } from "../interfaces/StorageAccess.js";
 import { type PromiseWithResolvers } from "octagonal-wheels/promises";
 import { StorageEventManager, type FileEvent } from "../interfaces/StorageEventManager.js";
@@ -8,12 +9,11 @@ import type { SettingService } from "../services/base/SettingService.js";
 import type { FileProcessingService } from "../services/base/FileProcessingService.js";
 import { createInstanceLogFunction } from "../services/lib/logUtils.js";
 import type { IStorageEventManagerAdapter } from "./adapters/index.js";
-import { type CompatTimeoutHandle } from "../common/coreEnvFunctions.js";
 type WaitInfo = {
     since: number;
     type: FileEventType;
     canProceed: PromiseWithResolvers<boolean>;
-    timerHandler: CompatTimeoutHandle;
+    deadline: DeferredAction;
     event: FileEventItem;
 };
 declare const TYPE_SENTINEL_FLUSH = "SENTINEL_FLUSH";
@@ -88,7 +88,7 @@ export declare abstract class StorageEventManagerBase<TAdapter extends IStorageE
     enqueue(newItem: FileEventItem): void;
     private _triggerTakeSnapshot;
     triggerTakeSnapshot: import("octagonal-wheels/function").ThrottledFunction<() => void>;
-    protected concurrentProcessing: import("octagonal-wheels/concurrency/semaphore_v2").SemaphoreObject;
+    protected concurrentProcessing: import("octagonal-wheels/concurrency/semaphore").SemaphoreObject;
     protected _waitingMap: Map<string, WaitInfo>;
     private pendingOperations;
     private releaseOperations;
@@ -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

@@ -10,10 +10,17 @@ import { delay, fireAndForget, isRemediationModeActive, throttle } from "../comm
 import {} from "../common/types.js";
 import { serialized } from "octagonal-wheels/concurrency/lock";
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
+import {
+  createDeferredAction
+} from "octagonal-wheels/concurrency/deferredAction";
 import { promiseWithResolvers } from "octagonal-wheels/promises";
 import { StorageEventManager } from "../interfaces/StorageEventManager.js";
 import { createInstanceLogFunction } from "../services/lib/logUtils.js";
 import { compatGlobal } from "../common/coreEnvFunctions.js";
+const scheduleStorageTimeout = (callback, delayMs) => {
+  const handle = compatGlobal.setTimeout(callback, delayMs);
+  return () => compatGlobal.clearTimeout(handle);
+};
 const TYPE_SENTINEL_FLUSH = "SENTINEL_FLUSH";
 class StorageEventManagerBase extends StorageEventManager {
   _log;
@@ -311,7 +318,7 @@ class StorageEventManagerBase extends StorageEventManager {
     const waitInfo = this._waitingMap.get(key);
     if (waitInfo) {
       waitInfo.canProceed.resolve(true);
-      compatGlobal.clearTimeout(waitInfo.timerHandler);
+      waitInfo.deadline.dispose();
       this._waitingMap.delete(key);
     }
     this.triggerTakeSnapshot();
@@ -323,7 +330,7 @@ class StorageEventManagerBase extends StorageEventManager {
     const waitInfo = this._waitingMap.get(key);
     if (waitInfo) {
       waitInfo.canProceed.resolve(false);
-      compatGlobal.clearTimeout(waitInfo.timerHandler);
+      waitInfo.deadline.dispose();
       this._waitingMap.delete(key);
     }
     this.triggerTakeSnapshot();
@@ -355,16 +362,18 @@ class StorageEventManagerBase extends StorageEventManager {
         LOG_LEVEL_DEBUG
       );
     }
+    const deadline = createDeferredAction(() => {
+      this._log(`Processing ${key}: Batch save timeout reached: ${event.type}`, LOG_LEVEL_DEBUG);
+      this._proceedWaiting(key);
+    }, scheduleStorageTimeout);
     const waitInfo = {
       since,
       type: event.type,
       event,
       canProceed: resolver,
-      timerHandler: compatGlobal.setTimeout(() => {
-        this._log(`Processing ${key}: Batch save timeout reached: ${event.type}`, LOG_LEVEL_DEBUG);
-        this._proceedWaiting(key);
-      }, nextDelay)
+      deadline
     };
+    deadline.schedule(nextDelay);
     this._waitingMap.set(key, waitInfo);
     this.triggerTakeSnapshot();
     return waitInfo;
@@ -530,6 +539,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/pouchdb/LiveSyncLocalDB.js

@@ -185,6 +185,7 @@ class LiveSyncLocalDB {
         this._log("Database initialisation was rejected by a required module.", LOG_LEVEL_NOTICE);
         return false;
       }
+      manager.changeManager.restartWatch();
       this._log("Opening Database...");
       this._log("Database info", LOG_LEVEL_VERBOSE);
       this._log(JSON.stringify(await openedDatabase.info(), null, 2), LOG_LEVEL_VERBOSE);

package/dist/pouchdb/chunks.d.ts

@@ -1,10 +1,26 @@
 import type { CouchDBConnection } from "../common/types.js";
 export declare function purgeUnreferencedChunks(db: PouchDB.Database, dryRun: boolean, connSetting?: CouchDBConnection, performCompact?: boolean): Promise<number>;
+/**
+ * Copy chunks missing from the destination, preserving their source revisions.
+ *
+ * @deprecated Obsolete purge-based cleanup compatibility helper. Retained for
+ * existing package consumers; current Self-hosted LiveSync no longer calls it.
+ * Garbage Collection V3 propagates ordinary deletion revisions instead.
+ */
 export declare function transferChunks(key: string, label: string, dbFrom: PouchDB.Database, dbTo: PouchDB.Database, items: {
     id: string;
     rev: string;
 }[]): Promise<boolean>;
+/**
+ * Complement chunks between databases which were separately purged.
+ * @deprecated Obsolete cleanup compatibility wrapper around transferChunks.
+ * Current Self-hosted LiveSync uses its standard locked-remote recovery flow.
+ */
 export declare function balanceChunkPurgedDBs(local: PouchDB.Database, remote: PouchDB.Database): Promise<void>;
+/**
+ * @deprecated Obsolete transferChunks compatibility wrapper with no callers in
+ * the current Commonlib or Self-hosted LiveSync source trees.
+ */
 export declare function fetchAllUsedChunks(local: PouchDB.Database, remote: PouchDB.Database): Promise<void>;
 export declare function purgeChunksLocal(db: PouchDB.Database, docs: {
     id: string;

package/dist/pouchdb/pouchdb-browser.js

@@ -6,91 +6,9 @@ import mapreduce from "pouchdb-mapreduce";
 import replication from "pouchdb-replication";
 import find from "pouchdb-find";
 import transform from "transform-pouch";
-import { findPathToLeaf } from "pouchdb-merge";
-import { adapterFun } from "pouchdb-utils";
-import { createError, MISSING_DOC, UNKNOWN_ERROR } from "pouchdb-errors";
-import { mapAllTasksWithConcurrencyLimit, unwrapTaskResult } from "octagonal-wheels/concurrency/task";
+import { installPurgeMulti } from "./purgeMulti.js";
 PouchDB.plugin(IDBPouch).plugin(INDEXEDDBPouch).plugin(HttpPouch).plugin(mapreduce).plugin(replication).plugin(find).plugin(transform);
-function appendPurgeSeqs(db, docs) {
-  return db.get("_local/purges").then(function(doc) {
-    for (const [docId, rev$$1] of docs) {
-      const purgeSeq = doc.purgeSeq + 1;
-      doc.purges.push({
-        docId,
-        rev: rev$$1,
-        purgeSeq
-      });
-      if (doc.purges.length > db.purged_infos_limit) {
-        doc.purges.splice(0, doc.purges.length - db.purged_infos_limit);
-      }
-      doc.purgeSeq = purgeSeq;
-    }
-    return doc;
-  }).catch(function(err) {
-    if (err.status !== 404) {
-      throw err;
-    }
-    return {
-      _id: "_local/purges",
-      purges: docs.map(([docId, rev$$1], idx) => ({
-        docId,
-        rev: rev$$1,
-        purgeSeq: idx
-      })),
-      purgeSeq: docs.length
-    };
-  }).then(function(doc) {
-    return db.put(doc);
-  });
-}
-PouchDB.prototype.purgeMulti = adapterFun(
-  "_purgeMulti",
-  function(docs, callback) {
-    if (typeof this._purge === "undefined") {
-      return callback(
-        //@ts-ignore: this ts-ignore might be hiding a `this` bug where we don't have "this" conext.
-        createError(UNKNOWN_ERROR, "Purge is not implemented in the " + this.adapter + " adapter.")
-      );
-    }
-    const self = this;
-    const tasks = docs.map(
-      (param) => () => new Promise((res, rej) => {
-        const [docId, rev$$1] = param;
-        self._getRevisionTree(docId, (error, revs) => {
-          if (error) {
-            return res([param, error]);
-          }
-          if (!revs) {
-            return res([param, createError(MISSING_DOC)]);
-          }
-          let path;
-          try {
-            path = findPathToLeaf(revs, rev$$1);
-          } catch (error2) {
-            return res([param, error2.message || error2]);
-          }
-          self._purge(docId, path, (error2, result) => {
-            if (error2) {
-              return res([param, error2]);
-            } else {
-              return res([param, result]);
-            }
-          });
-        });
-      })
-    );
-    (async () => {
-      const ret = await mapAllTasksWithConcurrencyLimit(1, tasks);
-      const retAll = ret.map((e) => unwrapTaskResult(e));
-      await appendPurgeSeqs(
-        self,
-        retAll.filter((e) => "ok" in e[1]).map((e) => e[0])
-      );
-      const result = Object.fromEntries(retAll.map((e) => [e[0][0], e[1]]));
-      return result;
-    })().then((result) => callback(void 0, result)).catch((error) => callback(error));
-  }
-);
+installPurgeMulti(PouchDB);
 export {
   PouchDB
 };

package/dist/pouchdb/pouchdb-http.js

@@ -4,91 +4,9 @@ import mapreduce from "pouchdb-mapreduce";
 import replication from "pouchdb-replication";
 import find from "pouchdb-find";
 import transform from "transform-pouch";
-import { findPathToLeaf } from "pouchdb-merge";
-import { adapterFun } from "pouchdb-utils";
-import { createError, MISSING_DOC, UNKNOWN_ERROR } from "pouchdb-errors";
-import { mapAllTasksWithConcurrencyLimit, unwrapTaskResult } from "octagonal-wheels/concurrency/task";
+import { installPurgeMulti } from "./purgeMulti.js";
 PouchDB.plugin(HttpPouch).plugin(mapreduce).plugin(replication).plugin(find).plugin(transform);
-function appendPurgeSeqs(db, docs) {
-  return db.get("_local/purges").then(function(doc) {
-    for (const [docId, rev$$1] of docs) {
-      const purgeSeq = doc.purgeSeq + 1;
-      doc.purges.push({
-        docId,
-        rev: rev$$1,
-        purgeSeq
-      });
-      if (doc.purges.length > db.purged_infos_limit) {
-        doc.purges.splice(0, doc.purges.length - db.purged_infos_limit);
-      }
-      doc.purgeSeq = purgeSeq;
-    }
-    return doc;
-  }).catch(function(err) {
-    if (err.status !== 404) {
-      throw err;
-    }
-    return {
-      _id: "_local/purges",
-      purges: docs.map(([docId, rev$$1], idx) => ({
-        docId,
-        rev: rev$$1,
-        purgeSeq: idx
-      })),
-      purgeSeq: docs.length
-    };
-  }).then(function(doc) {
-    return db.put(doc);
-  });
-}
-PouchDB.prototype.purgeMulti = adapterFun(
-  "_purgeMulti",
-  function(docs, callback) {
-    if (typeof this._purge === "undefined") {
-      return callback(
-        //@ts-ignore: this ts-ignore might be hiding a `this` bug where we don't have "this" conext.
-        createError(UNKNOWN_ERROR, "Purge is not implemented in the " + this.adapter + " adapter.")
-      );
-    }
-    const self = this;
-    const tasks = docs.map(
-      (param) => () => new Promise((res, rej) => {
-        const [docId, rev$$1] = param;
-        self._getRevisionTree(docId, (error, revs) => {
-          if (error) {
-            return res([param, error]);
-          }
-          if (!revs) {
-            return res([param, createError(MISSING_DOC)]);
-          }
-          let path;
-          try {
-            path = findPathToLeaf(revs, rev$$1);
-          } catch (error2) {
-            return res([param, error2.message || error2]);
-          }
-          self._purge(docId, path, (error2, result) => {
-            if (error2) {
-              return res([param, error2]);
-            } else {
-              return res([param, result]);
-            }
-          });
-        });
-      })
-    );
-    (async () => {
-      const ret = await mapAllTasksWithConcurrencyLimit(1, tasks);
-      const retAll = ret.map((e) => unwrapTaskResult(e));
-      await appendPurgeSeqs(
-        self,
-        retAll.filter((e) => "ok" in e[1]).map((e) => e[0])
-      );
-      const result = Object.fromEntries(retAll.map((e) => [e[0][0], e[1]]));
-      return result;
-    })().then((result) => callback(void 0, result)).catch((error) => callback(error));
-  }
-);
+installPurgeMulti(PouchDB);
 export {
   PouchDB
 };

package/dist/pouchdb/purgeMulti.d.ts

@@ -0,0 +1,4 @@
+import type PouchDB from "pouchdb-core";
+type PouchDBConstructor = typeof PouchDB;
+export declare function installPurgeMulti(PouchDB: PouchDBConstructor): void;
+export {};

package/dist/pouchdb/purgeMulti.js

@@ -0,0 +1,89 @@
+import { findPathToLeaf } from "pouchdb-merge";
+import { adapterFun } from "pouchdb-utils";
+import { createError, MISSING_DOC, UNKNOWN_ERROR } from "pouchdb-errors";
+import { mapAllTasksWithConcurrencyLimit, unwrapTaskResult } from "octagonal-wheels/concurrency/task";
+function appendPurgeSeqs(db, docs) {
+  return db.get("_local/purges").then(function(doc) {
+    for (const [docId, rev$$1] of docs) {
+      const purgeSeq = doc.purgeSeq + 1;
+      doc.purges.push({
+        docId,
+        rev: rev$$1,
+        purgeSeq
+      });
+      if (doc.purges.length > db.purged_infos_limit) {
+        doc.purges.splice(0, doc.purges.length - db.purged_infos_limit);
+      }
+      doc.purgeSeq = purgeSeq;
+    }
+    return doc;
+  }).catch(function(err) {
+    if (err.status !== 404) {
+      throw err;
+    }
+    return {
+      _id: "_local/purges",
+      purges: docs.map(([docId, rev$$1], idx) => ({
+        docId,
+        rev: rev$$1,
+        purgeSeq: idx
+      })),
+      purgeSeq: docs.length
+    };
+  }).then(function(doc) {
+    return db.put(doc);
+  });
+}
+function installPurgeMulti(PouchDB) {
+  PouchDB.prototype.purgeMulti = adapterFun(
+    "_purgeMulti",
+    function(docs, callback) {
+      if (typeof this._purge === "undefined") {
+        return callback(
+          //@ts-ignore: this ts-ignore might be hiding a `this` bug where we don't have "this" conext.
+          createError(UNKNOWN_ERROR, "Purge is not implemented in the " + this.adapter + " adapter.")
+        );
+      }
+      const self = this;
+      const tasks = docs.map(
+        (param) => () => new Promise((res, rej) => {
+          const [docId, rev$$1] = param;
+          self._getRevisionTree(docId, (error, revs) => {
+            if (error) {
+              return res([param, error]);
+            }
+            if (!revs) {
+              return res([param, createError(MISSING_DOC)]);
+            }
+            let path;
+            try {
+              path = findPathToLeaf(revs, rev$$1);
+            } catch (error2) {
+              return res([param, error2.message || error2]);
+            }
+            self._purge(docId, path, (error2, result) => {
+              if (error2) {
+                return res([param, error2]);
+              } else {
+                return res([param, result]);
+              }
+            });
+          });
+        })
+      );
+      (async () => {
+        const ret = await mapAllTasksWithConcurrencyLimit(1, tasks);
+        const retAll = ret.map((e) => unwrapTaskResult(e));
+        await appendPurgeSeqs(
+          self,
+          retAll.filter((e) => "ok" in e[1]).map((e) => e[0])
+        );
+        const result = Object.fromEntries(retAll.map((e) => [e[0][0], e[1]]));
+        return result;
+      })().then((result) => callback(void 0, result)).catch((error) => callback(error));
+    }
+  );
+}
+export {
+  installPurgeMulti
+};

package/dist/replication/journal/JournalSyncCore.js

@@ -677,7 +677,12 @@ class JournalSyncCore {
             const piece = decompressed.slice(idxFrom, idxTo);
             const strPiece = d.decode(piece);
             if (strPiece.startsWith("~")) {
-              const [idPart, dataPart] = strPiece.substring(1).split(UNIT_SPLIT);
+              const separatorIndex = strPiece.indexOf(UNIT_SPLIT);
+              if (separatorIndex === -1) {
+                throw new Error("Invalid journal chunk record: missing separator");
+              }
+              const idPart = strPiece.substring(1, separatorIndex);
+              const dataPart = strPiece.substring(separatorIndex + 1);
               result.push({
                 _id: idPart,
                 data: unescapeNewLineFromString(dataPart),

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;