@vrtmrz/livesync-commonlib 0.2.2 → 0.3.0

package/dist/managers/ChunkFetcher.js

@@ -327,20 +327,25 @@ class ChunkFetcher {
       await this.resolveLocallyAvailableRetries(requestClaims);
       let pendingIDs = await this.waitBeforeRemoteRequest(requestIDs, requestClaims, localCheckCompletionVersion);
       if (pendingIDs.length === 0) return;
-      const replicator = this.options.replicatorService.getActiveReplicator();
-      if (!replicator) {
-        Logger("No active replicator was found to request missing chunks.");
-        return;
-      }
-      if (!canFetchRemoteChunks(replicator)) {
-        Logger("The active replicator does not support fetching individual remote chunks.");
-        for (const chunkID of pendingIDs) {
-          this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
+      const requestCompletionVersion = this.finiteCompletionVersion;
+      let fetched;
+      if (this.options.source) {
+        fetched = await this.options.source.fetchChunks(pendingIDs);
+      } else {
+        const replicator = this.options.replicatorService.getActiveReplicator();
+        if (!replicator) {
+          Logger("No active replicator was found to request missing chunks.");
+          return;
         }
-        return;
+        if (!canFetchRemoteChunks(replicator)) {
+          Logger("The active replicator does not support fetching individual remote chunks.");
+          for (const chunkID of pendingIDs) {
+            this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
+          }
+          return;
+        }
+        fetched = await replicator.fetchRemoteChunks(pendingIDs, false);
       }
-      const requestCompletionVersion = this.finiteCompletionVersion;
-      const fetched = await replicator.fetchRemoteChunks(pendingIDs, false);
       pendingIDs = this.getActiveClaimIds(pendingIDs, requestClaims);
       this.touchClaims(pendingIDs, requestClaims);
       if (!fetched) {
@@ -354,7 +359,9 @@ class ChunkFetcher {
       this.logFetchedChunks(pendingIDs, classification);
       const { chunks, missingIds, invalidIds } = classification;
       try {
-        if (chunks.length > 0) {
+        if (chunks.length > 0 && this.options.source) {
+          await this.options.source.storeChunks(chunks);
+        } else if (chunks.length > 0) {
           Logger(`Writing fetched chunks (${chunks.length}) to the database...`);
           const result = await this.chunkManager.write(
             chunks,

package/dist/managers/LiveSyncManagers.d.ts

@@ -2,6 +2,7 @@ import { type EntryDoc } from "../common/types.js";
 import { ContentSplitter } from "../ContentSplitter/ContentSplitters.js";
 import { ChangeManager } from "./ChangeManager.js";
 import { ChunkFetcher } from "./ChunkFetcher.js";
+import type { ChunkFetchSource } from "./chunkFetchSource.js";
 import { ChunkManager } from "./ChunkManager.js";
 import { ConflictManager } from "./ConflictManager.js";
 import { EntryManager } from "./EntryManager/EntryManager.js";
@@ -15,6 +16,7 @@ export interface LiveSyncManagersOptions<TSettingService extends ISettingService
     pathService: IPathService;
     replicatorService: IReplicatorService;
     APIService: IAPIService;
+    chunkFetchSource?: ChunkFetchSource;
 }
 export declare class LiveSyncManagers {
     protected _pathService: IPathService;

package/dist/managers/LiveSyncManagers.js

@@ -76,6 +76,7 @@ class LiveSyncManagers {
     });
     const chunkFetcher = new ChunkFetcher({
       chunkManager,
+      source: this.options.chunkFetchSource,
       replicatorService: this.options.replicatorService,
       settingService: this.options.settingService
     });

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;

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;

package/dist/managers/chunkFetchSource.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentID, EntryDoc, EntryLeaf } from "../common/types.js";
+/** IO supplied by a host whose chunk source does not use the active replicator. */
+export interface ChunkFetchSource {
+    /** Missing identifiers are omitted; false means that this request could not retrieve chunks. */
+    fetchChunks(ids: DocumentID[]): Promise<EntryLeaf[] | false>;
+    /** Accept fetched chunks before notifying waiting readers. */
+    storeChunks(chunks: EntryLeaf[]): Promise<void>;
+}
+/**
+ * Read through the prepared direct database, including its decryption transforms.
+ * The source already owns these documents, so accepting them performs no write.
+ * Construct a new source for each database lifetime.
+ */
+export declare function createDirectChunkFetchSource(database: PouchDB.Database<EntryDoc>): ChunkFetchSource;

package/dist/managers/chunkFetchSource.js

@@ -0,0 +1,12 @@
+function createDirectChunkFetchSource(database) {
+  return {
+    async fetchChunks(ids) {
+      const result = await database.allDocs({ keys: ids, include_docs: true });
+      return result.rows.flatMap((row) => "doc" in row && row.doc ? [row.doc] : []);
+    },
+    storeChunks: () => Promise.resolve()
+  };
+}
+export {
+  createDirectChunkFetchSource
+};

package/dist/pouchdb/LiveSyncDBFunctions.js

@@ -6,6 +6,7 @@ import {
 } from "../common/types.js";
 import { extractObject, isObjectDifferent, resolveWithIgnoreKnownError } from "../common/utils.js";
 import { assessTweakCompatibility } from "../common/models/tweak.compatibility.js";
+import { getPathNormalizationVersion } from "../common/pathNormalization.js";
 import { usesEncryptedInternalMetadata } from "./remoteFeatureCompatibility.js";
 function getEffectiveTweakValues(setting) {
   return {
@@ -56,6 +57,10 @@ async function ensureRemoteIsCompatible(infoSrc, setting, deviceNodeID, currentV
   if (tweakAssessment.entries.some(({ key, relation }) => key === "idDerivationVersion" && relation === "different")) {
     return "ID_KEY_MISMATCH";
   }
+  if (getPathNormalizationVersion(currentTweakValues) !== getPathNormalizationVersion(preferred_tweak)) {
+    recordTweakAssessment?.(tweakAssessment);
+    return ["MISMATCHED", preferred_tweak];
+  }
   if (!setting.disableCheckingConfigMismatch) {
     recordTweakAssessment?.(tweakAssessment);
     if (tweakAssessment.alignment === "mismatched") {

package/dist/pouchdb/LiveSyncLocalDB.d.ts

@@ -1,6 +1,7 @@
 import { type EntryDoc, type EntryLeaf, type Credential, type RemoteDBSettings, type DocumentID, type FilePathWithPrefix, type FilePath, type DatabaseEntry, type LoadedEntry, type MetaEntry, type SavingEntry, type diff_result_leaf } from "../common/types.js";
 import type { LiveSyncEventHub } from "../hub/hub.js";
 import { LiveSyncManagers } from "../managers/LiveSyncManagers.js";
+import type { ChunkFetchSource } from "../managers/chunkFetchSource.js";
 import type { AutoMergeResult } from "../managers/ConflictManager.js";
 import type { IServiceHub } from "../services/base/IService.js";
 import type { ServiceContext } from "../services/base/ServiceBase.js";
@@ -33,7 +34,12 @@ export type GeneratedChunk = {
     id: DocumentID;
     piece: string;
 };
+/** Optional host IO bound afresh to each prepared database instance. */
+export interface LiveSyncLocalDBRuntimeOptions {
+    createChunkFetchSource?: (database: PouchDB.Database<EntryDoc>) => ChunkFetchSource;
+}
 export declare class LiveSyncLocalDB {
+    private readonly runtimeOptions;
     auth: Credential;
     dbname: string;
     settings: RemoteDBSettings;
@@ -52,7 +58,7 @@ export declare class LiveSyncLocalDB {
     /** Share owner retirement across every close path for one physical database lifetime. */
     private activeReplicationClose?;
     private databaseUnloadNotification?;
-    constructor(dbname: string, env: LiveSyncLocalDBEnv);
+    constructor(dbname: string, env: LiveSyncLocalDBEnv, runtimeOptions?: LiveSyncLocalDBRuntimeOptions);
     /** Notify dependent services at most once for each physical database lifecycle. */
     private notifyDatabaseUnload;
     onunload(): void;

package/dist/pouchdb/LiveSyncLocalDB.js

@@ -16,6 +16,18 @@ function getNoFromRev(rev) {
   return parseInt(rev.split("-")[0]);
 }
 class LiveSyncLocalDB {
+  constructor(dbname, env, runtimeOptions = {}) {
+    this.runtimeOptions = runtimeOptions;
+    this.auth = {
+      username: "",
+      password: ""
+    };
+    this.dbname = dbname;
+    this.env = env;
+    this._log = createInstanceLogFunction("LiveSyncLocalDB", this.env.services.API);
+    this.refreshSettings();
+  }
+  runtimeOptions;
   auth;
   dbname;
   settings;
@@ -47,16 +59,6 @@ class LiveSyncLocalDB {
   /** Share owner retirement across every close path for one physical database lifetime. */
   activeReplicationClose;
   databaseUnloadNotification;
-  constructor(dbname, env) {
-    this.auth = {
-      username: "",
-      password: ""
-    };
-    this.dbname = dbname;
-    this.env = env;
-    this._log = createInstanceLogFunction("LiveSyncLocalDB", this.env.services.API);
-    this.refreshSettings();
-  }
   /** Notify dependent services at most once for each physical database lifecycle. */
   notifyDatabaseUnload() {
     if (!this.databaseUnloadNotification) {
@@ -170,6 +172,7 @@ class LiveSyncLocalDB {
     this.databaseUnloadNotification = void 0;
     const manager = new LiveSyncManagers({
       database: this.localDatabase,
+      chunkFetchSource: this.runtimeOptions?.createChunkFetchSource?.(this.localDatabase),
       APIService: this.env.services.API,
       pathService: this.env.services.path,
       replicatorService: this.env.services.replicator,
@@ -185,6 +188,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/pathIdentityCompatibility.d.ts

@@ -2,6 +2,14 @@ import { type EntryDoc } from "../common/types.js";
 type PathIdentitySettings = {
     pathNormalizationVersion?: number;
 };
+export type PathIdentityInspection = {
+    readonly status: "empty";
+} | {
+    readonly status: "configured";
+    readonly pathNormalizationVersion: 0 | 1;
+};
+/** Read the existing declaration without changing a remote or declaring a new identity. */
+export declare function inspectDatabasePathIdentity(database: PouchDB.Database<EntryDoc>): Promise<PathIdentityInspection>;
 export declare function assertMatchingPathIdentityFeature(document: unknown, settings: PathIdentitySettings): void;
 /** Refuse an implicit migration. A fresh database may declare its identity before its first Metadata write. */
 export declare function assertDatabasePathIdentity(database: PouchDB.Database<EntryDoc>, settings: PathIdentitySettings, declare?: boolean): Promise<void>;

package/dist/pouchdb/pathIdentityCompatibility.js

@@ -2,11 +2,28 @@ import { VERSIONING_DOCID } from "../common/types.js";
 import { getPathNormalizationVersion } from "../common/pathNormalization.js";
 import {
   assessRemoteFeatureDocument,
+  describeRemoteFeatureRejection,
   NFC_PATH_IDENTITY_FEATURE,
   REMOTE_FEATURE_GENERATION
 } from "./remoteFeatureCompatibility.js";
 import { isErrorOfMissingDoc } from "./utils_couchdb.js";
 import { bumpRemoteVersion } from "./negotiation.js";
+async function inspectDatabasePathIdentity(database) {
+  let document;
+  try {
+    document = await database.get(VERSIONING_DOCID);
+  } catch (error) {
+    if (!isErrorOfMissingDoc(error)) throw error;
+    return (await database.info()).doc_count === 0 ? { status: "empty" } : { status: "configured", pathNormalizationVersion: 0 };
+  }
+  const assessment = assessRemoteFeatureDocument(document);
+  if (assessment.status === "older-generation") return { status: "configured", pathNormalizationVersion: 0 };
+  if (assessment.status !== "supported") throw new Error(describeRemoteFeatureRejection(assessment));
+  return {
+    status: "configured",
+    pathNormalizationVersion: assessment.usedFeatures.includes(NFC_PATH_IDENTITY_FEATURE) ? 1 : 0
+  };
+}
 function assertMatchingPathIdentityFeature(document, settings) {
   const assessment = assessRemoteFeatureDocument(document);
   const declared = assessment.status === "supported" && assessment.usedFeatures.includes(NFC_PATH_IDENTITY_FEATURE);
@@ -60,5 +77,6 @@ async function assertDatabasePathIdentity(database, settings, declare = false) {
 }
 export {
   assertDatabasePathIdentity,
-  assertMatchingPathIdentityFeature
+  assertMatchingPathIdentityFeature,
+  inspectDatabasePathIdentity
 };

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
+};