@rocicorp/zero 1.11.0-canary.3 → 1.11.0-canary.30

package/out/replicache/src/persist/client-group-gc.js.map

@@ -1 +1 @@
-{"version":3,"file":"client-group-gc.js","names":[],"sources":["../../../../../replicache/src/persist/client-group-gc.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {initBgIntervalProcess} from '../bg-interval.ts';\nimport type {Store} from '../dag/store.ts';\nimport type {ClientGroupID} from '../sync/ids.ts';\nimport {withWrite} from '../with-transactions.ts';\nimport {\n  clientGroupHasPendingMutations,\n  getClientGroups,\n  setClientGroups,\n  type ClientGroupMap,\n} from './client-groups.ts';\nimport {getClients} from './clients.ts';\n\nconst GC_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes\n\nlet latestGCUpdate: Promise<ClientGroupMap> | undefined;\nexport function getLatestGCUpdate(): Promise<ClientGroupMap> | undefined {\n  return latestGCUpdate;\n}\n\nexport function initClientGroupGC(\n  dagStore: Store,\n  enableMutationRecovery: boolean,\n  lc: LogContext,\n  signal: AbortSignal,\n): void {\n  initBgIntervalProcess(\n    'ClientGroupGC',\n    () => {\n      latestGCUpdate = gcClientGroups(dagStore, enableMutationRecovery);\n      return latestGCUpdate;\n    },\n    () => GC_INTERVAL_MS,\n    lc,\n    signal,\n  );\n}\n\n/**\n * This removes client groups that have no clients and no pending mutations.\n * If {@linkcode enableMutationRecovery} is true, it will keep client groups with\n * pending mutations. If it is false, it will remove client groups even when they\n * have pending mutations.\n */\nexport function gcClientGroups(\n  dagStore: Store,\n  enableMutationRecovery: boolean,\n): Promise<ClientGroupMap> {\n  return withWrite(dagStore, async tx => {\n    const clients = await getClients(tx);\n    const clientGroupIDs = new Set();\n    for (const client of clients.values()) {\n      clientGroupIDs.add(client.clientGroupID);\n    }\n    const clientGroups = new Map();\n    const removeClientGroups: Set<ClientGroupID> = new Set();\n    for (const [clientGroupID, clientGroup] of await getClientGroups(tx)) {\n      if (\n        clientGroupIDs.has(clientGroupID) ||\n        (enableMutationRecovery && clientGroupHasPendingMutations(clientGroup))\n      ) {\n        clientGroups.set(clientGroupID, clientGroup);\n      } else {\n        removeClientGroups.add(clientGroupID);\n      }\n    }\n    await setClientGroups(clientGroups, tx);\n    // Client group GC doesn't delete individual clients, so we don't call onClientsDeleted\n    return clientGroups;\n  });\n}\n"],"mappings":";;;;;AAaA,IAAM,iBAAiB,MAAS;AAEhC,IAAI;AAKJ,SAAgB,kBACd,UACA,wBACA,IACA,QACM;CACN,sBACE,uBACM;EACJ,iBAAiB,eAAe,UAAU,sBAAsB;EAChE,OAAO;CACT,SACM,gBACN,IACA,MACF;AACF;;;;;;;AAQA,SAAgB,eACd,UACA,wBACyB;CACzB,OAAO,UAAU,UAAU,OAAM,OAAM;EACrC,MAAM,UAAU,MAAM,WAAW,EAAE;EACnC,MAAM,iCAAiB,IAAI,IAAI;EAC/B,KAAK,MAAM,UAAU,QAAQ,OAAO,GAClC,eAAe,IAAI,OAAO,aAAa;EAEzC,MAAM,+BAAe,IAAI,IAAI;EAC7B,MAAM,qCAAyC,IAAI,IAAI;EACvD,KAAK,MAAM,CAAC,eAAe,gBAAgB,MAAM,gBAAgB,EAAE,GACjE,IACE,eAAe,IAAI,aAAa,KAC/B,0BAA0B,+BAA+B,WAAW,GAErE,aAAa,IAAI,eAAe,WAAW;OAE3C,mBAAmB,IAAI,aAAa;EAGxC,MAAM,gBAAgB,cAAc,EAAE;EAEtC,OAAO;CACT,CAAC;AACH"}
+{"version":3,"file":"client-group-gc.js","names":[],"sources":["../../../../../replicache/src/persist/client-group-gc.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {initBgIntervalProcess} from '../bg-interval.ts';\nimport type {Store} from '../dag/store.ts';\nimport type {StorageFailureError} from '../storage-failure.ts';\nimport type {ClientGroupID} from '../sync/ids.ts';\nimport {withWrite} from '../with-transactions.ts';\nimport {\n  clientGroupHasPendingMutations,\n  getClientGroups,\n  setClientGroups,\n  type ClientGroupMap,\n} from './client-groups.ts';\nimport {getClients} from './clients.ts';\n\nconst GC_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes\n\nlet latestGCUpdate: Promise<ClientGroupMap> | undefined;\nexport function getLatestGCUpdate(): Promise<ClientGroupMap> | undefined {\n  return latestGCUpdate;\n}\n\nexport function initClientGroupGC(\n  dagStore: Store,\n  enableMutationRecovery: boolean,\n  lc: LogContext,\n  signal: AbortSignal,\n  onStorageFailure?: ((failure: StorageFailureError) => void) | undefined,\n): void {\n  initBgIntervalProcess(\n    'ClientGroupGC',\n    () => {\n      latestGCUpdate = gcClientGroups(dagStore, enableMutationRecovery);\n      return latestGCUpdate;\n    },\n    () => GC_INTERVAL_MS,\n    lc,\n    signal,\n    onStorageFailure,\n  );\n}\n\n/**\n * This removes client groups that have no clients and no pending mutations.\n * If {@linkcode enableMutationRecovery} is true, it will keep client groups with\n * pending mutations. If it is false, it will remove client groups even when they\n * have pending mutations.\n */\nexport function gcClientGroups(\n  dagStore: Store,\n  enableMutationRecovery: boolean,\n): Promise<ClientGroupMap> {\n  return withWrite(dagStore, async tx => {\n    const clients = await getClients(tx);\n    const clientGroupIDs = new Set();\n    for (const client of clients.values()) {\n      clientGroupIDs.add(client.clientGroupID);\n    }\n    const clientGroups = new Map();\n    const removeClientGroups: Set<ClientGroupID> = new Set();\n    for (const [clientGroupID, clientGroup] of await getClientGroups(tx)) {\n      if (\n        clientGroupIDs.has(clientGroupID) ||\n        (enableMutationRecovery && clientGroupHasPendingMutations(clientGroup))\n      ) {\n        clientGroups.set(clientGroupID, clientGroup);\n      } else {\n        removeClientGroups.add(clientGroupID);\n      }\n    }\n    await setClientGroups(clientGroups, tx);\n    // Client group GC doesn't delete individual clients, so we don't call onClientsDeleted\n    return clientGroups;\n  });\n}\n"],"mappings":";;;;;AAcA,IAAM,iBAAiB,MAAS;AAEhC,IAAI;AAKJ,SAAgB,kBACd,UACA,wBACA,IACA,QACA,kBACM;CACN,sBACE,uBACM;EACJ,iBAAiB,eAAe,UAAU,sBAAsB;EAChE,OAAO;CACT,SACM,gBACN,IACA,QACA,gBACF;AACF;;;;;;;AAQA,SAAgB,eACd,UACA,wBACyB;CACzB,OAAO,UAAU,UAAU,OAAM,OAAM;EACrC,MAAM,UAAU,MAAM,WAAW,EAAE;EACnC,MAAM,iCAAiB,IAAI,IAAI;EAC/B,KAAK,MAAM,UAAU,QAAQ,OAAO,GAClC,eAAe,IAAI,OAAO,aAAa;EAEzC,MAAM,+BAAe,IAAI,IAAI;EAC7B,MAAM,qCAAyC,IAAI,IAAI;EACvD,KAAK,MAAM,CAAC,eAAe,gBAAgB,MAAM,gBAAgB,EAAE,GACjE,IACE,eAAe,IAAI,aAAa,KAC/B,0BAA0B,+BAA+B,WAAW,GAErE,aAAa,IAAI,eAAe,WAAW;OAE3C,mBAAmB,IAAI,aAAa;EAGxC,MAAM,gBAAgB,cAAc,EAAE;EAEtC,OAAO;CACT,CAAC;AACH"}

package/out/replicache/src/persist/clients.d.ts

@@ -20,7 +20,7 @@ declare const clientV5Schema: valita.ObjectType<Readonly<{
      * The hash of a commit we are in the middle of refreshing into this client's
      * memdag.
      */
-    tempRefreshHash: valita.Type<Hash | null>;
+    tempRefreshHash: valita.UnionType<[valita.Type<null>, valita.Type<Hash>]>;
     /**
      * ID of this client's perdag client group. This needs to be sent in pull
      * request (to enable syncing all last mutation ids in the client group).
@@ -47,7 +47,7 @@ declare const clientV6Schema: valita.ObjectType<Readonly<{
      * The hash of the last snapshot commit persisted by this client to this
      * client's client group, or null if has never persisted a snapshot.
      */
-    persistHash: valita.Type<Hash | null>;
+    persistHash: valita.UnionType<[valita.Type<null>, valita.Type<Hash>]>;
     /**
      * ID of this client's perdag client group. This needs to be sent in pull
      * request (to enable syncing all last mutation ids in the client group).

package/out/replicache/src/persist/collect-idb-databases.d.ts

@@ -1,7 +1,9 @@
 import type { LogContext, LogLevel, LogSink } from '@rocicorp/logger';
 import type { Store } from '../dag/store.ts';
-import type { CreateStore, StoreProvider } from '../kv/store.ts';
+import type { CreateStore, DropStore, StoreProvider } from '../kv/store.ts';
+import type { StorageFailureError } from '../storage-failure.ts';
 import type { OnClientsDeleted } from './clients.ts';
+import type { IndexedDBDatabase } from './idb-databases-store.ts';
 import { IDBDatabasesStore } from './idb-databases-store.ts';
 /**
  * How frequently to try to collect
@@ -11,12 +13,18 @@ export declare const COLLECT_IDB_INTERVAL: number;
  * We delay the initial collection to prevent doing it at startup.
  */
 export declare const INITIAL_COLLECT_IDB_DELAY: number;
-export declare function initCollectIDBDatabases(idbDatabasesStore: IDBDatabasesStore, kvStoreProvider: StoreProvider, collectInterval: number, initialCollectDelay: number, maxAge: number, enableMutationRecovery: boolean, onClientsDeleted: OnClientsDeleted, lc: LogContext, signal: AbortSignal): void;
+export declare function initCollectIDBDatabases(idbDatabasesStore: IDBDatabasesStore, kvStoreProvider: StoreProvider, collectInterval: number, initialCollectDelay: number, maxAge: number, enableMutationRecovery: boolean, onClientsDeleted: OnClientsDeleted, lc: LogContext, signal: AbortSignal, newDagStore?: NewDagStore, onStorageFailure?: ((failure: StorageFailureError) => void) | undefined): void;
 /**
  * Collects IDB databases that are no longer needed.
  */
-export declare function collectIDBDatabases(idbDatabasesStore: IDBDatabasesStore, now: number, maxAge: number, kvStoreProvider: StoreProvider, enableMutationRecovery: boolean, onClientsDeleted: OnClientsDeleted, newDagStore?: typeof defaultNewDagStore): Promise<void>;
-declare function defaultNewDagStore(name: string, kvCreateStore: CreateStore): Store;
+export declare function collectIDBDatabases(idbDatabasesStore: IDBDatabasesStore, now: number, maxAge: number, kvStoreProvider: StoreProvider, enableMutationRecovery: boolean, onClientsDeleted: OnClientsDeleted, newDagStore?: NewDagStore): Promise<void>;
+export declare function dropDatabaseInternal(name: string, idbDatabasesStore: IDBDatabasesStore, kvDropStore: DropStore): Promise<void>;
+/**
+ * Creates the dag store used to inspect and update a database during
+ * collection. Callers can override it to install store hooks, for example so
+ * a corrupt ref count found while writing deleted clients is recovered from.
+ */
+export type NewDagStore = (name: string, kvCreateStore: CreateStore) => Store;
 /**
  * Options for `dropDatabase` and `dropAllDatabases`.
  */
@@ -52,21 +60,34 @@ export type DropDatabaseOptions = {
     logSinks?: LogSink[] | undefined;
 };
 /**
- * Drops the specified database.
+ * Drops the specified database, from memory as well as from the configured
+ * store (see `onStorageFailure`). Rejects if the configured store cannot be
+ * opened or dropped.
  * @param dbName The name of the database to drop.
  * @param opts Options for dropping the database.
  */
 export declare function dropDatabase(dbName: string, opts?: DropDatabaseOptions): Promise<void>;
 /**
- * Deletes all IndexedDB data associated with Replicache.
+ * Deletes all IndexedDB data associated with Replicache, and the in-memory
+ * databases instances ran on after a storage failure (see
+ * `onStorageFailure`).
  *
  * Returns an object with the names of the successfully dropped databases
- * and any errors encountered while dropping.
+ * and any errors encountered while dropping. Rejects if the configured store
+ * cannot be opened.
  */
 export declare function dropAllDatabases(opts?: DropDatabaseOptions): Promise<{
     dropped: string[];
     errors: unknown[];
 }>;
+/**
+ * Like {@link dropAllDatabases}, for the databases whose registry record
+ * matches `predicate`.
+ */
+export declare function dropMatchingDatabases(predicate: (db: IndexedDBDatabase) => boolean, opts?: DropDatabaseOptions): Promise<{
+    dropped: string[];
+    errors: unknown[];
+}>;
 /**
  * Deletes all IndexedDB data associated with Replicache.
  *
@@ -79,5 +100,4 @@ export declare function deleteAllReplicacheData(opts?: DropDatabaseOptions): Pro
     dropped: string[];
     errors: unknown[];
 }>;
-export {};
 //# sourceMappingURL=collect-idb-databases.d.ts.map

package/out/replicache/src/persist/collect-idb-databases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collect-idb-databases.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/collect-idb-databases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAC,MAAM,kBAAkB,CAAC;AAKpE,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAY3C,OAAO,KAAK,EAAC,WAAW,EAAa,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAO1E,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAGnD,OAAO,EAAC,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAE3D;;GAEG;AACH,eAAO,MAAM,oBAAoB,QAAsB,CAAC;AAExD;;GAEG;AACH,eAAO,MAAM,yBAAyB,QAAgB,CAAC;AAEvD,wBAAgB,uBAAuB,CACrC,iBAAiB,EAAE,iBAAiB,EACpC,eAAe,EAAE,aAAa,EAC9B,eAAe,EAAE,MAAM,EACvB,mBAAmB,EAAE,MAAM,EAC3B,MAAM,EAAE,MAAM,EACd,sBAAsB,EAAE,OAAO,EAC/B,gBAAgB,EAAE,gBAAgB,EAClC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,WAAW,GAClB,IAAI,CAwBN;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,iBAAiB,EAAE,iBAAiB,EACpC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,aAAa,EAC9B,sBAAsB,EAAE,OAAO,EAC/B,gBAAgB,EAAE,gBAAgB,EAClC,WAAW,4BAAqB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAmEf;AAsCD,iBAAS,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,GAAG,KAAK,CAG3E;AAqCD;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;OAGG;IACH,OAAO,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,aAAa,GAAG,SAAS,CAAC;IACpD;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC;CAClC,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,mBAAmB,iBAU5E;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC;IAC1E,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB,CAAC,CASD;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,CAAC,EAAE,mBAAmB;aArBvD,MAAM,EAAE;YACT,OAAO,EAAE;GAsBlB"}
+{"version":3,"file":"collect-idb-databases.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/collect-idb-databases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAC,MAAM,kBAAkB,CAAC;AAMpE,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAgB3C,OAAO,KAAK,EAAC,WAAW,EAAE,SAAS,EAAE,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAE1E,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAM/D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAGnD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAC,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAE3D;;GAEG;AACH,eAAO,MAAM,oBAAoB,QAAsB,CAAC;AAExD;;GAEG;AACH,eAAO,MAAM,yBAAyB,QAAgB,CAAC;AAEvD,wBAAgB,uBAAuB,CACrC,iBAAiB,EAAE,iBAAiB,EACpC,eAAe,EAAE,aAAa,EAC9B,eAAe,EAAE,MAAM,EACvB,mBAAmB,EAAE,MAAM,EAC3B,MAAM,EAAE,MAAM,EACd,sBAAsB,EAAE,OAAO,EAC/B,gBAAgB,EAAE,gBAAgB,EAClC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,WAAW,EACnB,WAAW,GAAE,WAAgC,EAC7C,gBAAgB,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,mBAAmB,KAAK,IAAI,CAAC,GAAG,SAAS,GACtE,IAAI,CA0BN;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,iBAAiB,EAAE,iBAAiB,EACpC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,aAAa,EAC9B,sBAAsB,EAAE,OAAO,EAC/B,gBAAgB,EAAE,gBAAgB,EAClC,WAAW,GAAE,WAAgC,GAC5C,OAAO,CAAC,IAAI,CAAC,CAyEf;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,iBAAiB,EACpC,WAAW,EAAE,SAAS,iBAIvB;AA6BD;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,KAAK,KAAK,CAAC;AA0C9E;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;OAGG;IACH,OAAO,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,aAAa,GAAG,SAAS,CAAC;IACpD;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC;CAClC,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,mBAAmB,iBAe5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC;IACpE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB,CAAC,CAED;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,CAAC,EAAE,EAAE,iBAAiB,KAAK,OAAO,EAC7C,IAAI,CAAC,EAAE,mBAAmB,GACzB,OAAO,CAAC;IACT,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB,CAAC,CAqBD;AA0CD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,CAAC,EAAE,mBAAmB;aAvFvD,MAAM,EAAE;YACT,OAAO,EAAE;GAwFlB"}

package/out/replicache/src/persist/collect-idb-databases.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../shared/src/asserts.js";
 import { initBgIntervalProcess } from "../bg-interval.js";
+import { InvalidRefCountError } from "../dag/invalid-ref-count-error.js";
 import { assertHash, newRandomHash } from "../hash.js";
 import { StoreImpl } from "../dag/store-impl.js";
 import { withRead, withWrite } from "../with-transactions.js";
@@ -7,7 +8,9 @@ import { clientGroupHasPendingMutations, getClientGroups } from "./client-groups
 import { getClients } from "./clients.js";
 import { addDeletedClients, getDeletedClients, mergeDeletedClients, normalizeDeletedClients } from "../deleted-clients.js";
 import { getKVStoreProvider } from "../get-kv-store-provider.js";
+import { fallbackStoreProvider, isFallbackStore } from "../kv/mem-fallback-store.js";
 import { createLogContext } from "../log-options.js";
+import { getIDBDatabasesDBName } from "./idb-databases-store-db-name.js";
 import { IDBDatabasesStore } from "./idb-databases-store.js";
 //#region ../replicache/src/persist/collect-idb-databases.ts
 /**
@@ -18,17 +21,17 @@ var COLLECT_IDB_INTERVAL = 720 * 60 * 1e3;
 * We delay the initial collection to prevent doing it at startup.
 */
 var INITIAL_COLLECT_IDB_DELAY = 300 * 1e3;
-function initCollectIDBDatabases(idbDatabasesStore, kvStoreProvider, collectInterval, initialCollectDelay, maxAge, enableMutationRecovery, onClientsDeleted, lc, signal) {
+function initCollectIDBDatabases(idbDatabasesStore, kvStoreProvider, collectInterval, initialCollectDelay, maxAge, enableMutationRecovery, onClientsDeleted, lc, signal, newDagStore = defaultNewDagStore, onStorageFailure) {
 	let initial = true;
 	initBgIntervalProcess("CollectIDBDatabases", async () => {
-		await collectIDBDatabases(idbDatabasesStore, Date.now(), maxAge, kvStoreProvider, enableMutationRecovery, onClientsDeleted);
+		await collectIDBDatabases(idbDatabasesStore, Date.now(), maxAge, kvStoreProvider, enableMutationRecovery, onClientsDeleted, newDagStore);
 	}, () => {
 		if (initial) {
 			initial = false;
 			return initialCollectDelay;
 		}
 		return collectInterval;
-	}, lc, signal);
+	}, lc, signal, onStorageFailure);
 }
 /**
 * Collects IDB databases that are no longer needed.
@@ -47,12 +50,18 @@ async function collectIDBDatabases(idbDatabasesStore, now, maxAge, kvStoreProvid
 	const { errors } = await dropDatabases(idbDatabasesStore, dbNamesToRemove, kvStoreProvider.drop);
 	if (errors.length) throw errors[0];
 	if (deletedClientsToRemove.length > 0) {
-		let allDeletedClients = deletedClientsToRemove;
-		for (const name of dbNamesToKeep) await withWrite(newDagStore(name, kvStoreProvider.create), async (dagWrite) => {
-			const newDeletedClients = await addDeletedClients(dagWrite, deletedClientsToRemove);
-			allDeletedClients = mergeDeletedClients(allDeletedClients, newDeletedClients);
-		});
-		await onClientsDeleted(normalizeDeletedClients(allDeletedClients));
+		let newDeletedClients = deletedClientsToRemove;
+		for (const name of dbNamesToKeep) {
+			let dbDeletedClients;
+			try {
+				dbDeletedClients = await withWrite(newDagStore(name, kvStoreProvider.create), (dagWrite) => addDeletedClients(dagWrite, deletedClientsToRemove));
+			} catch (e) {
+				if (!(e instanceof InvalidRefCountError)) throw e;
+				continue;
+			}
+			newDeletedClients = mergeDeletedClients(newDeletedClients, dbDeletedClients);
+		}
+		await onClientsDeleted(normalizeDeletedClients(newDeletedClients));
 	}
 }
 async function dropDatabaseInternal(name, idbDatabasesStore, kvDropStore) {
@@ -86,25 +95,93 @@ function gatherDatabaseInfoForCollect(db, now, maxAge, enableMutationRecovery, k
 	return canDatabaseBeCollectedAndGetDeletedClientIDs(enableMutationRecovery, newDagStore(db.name, kvCreateStore), now, maxAge);
 }
 /**
-* Drops the specified database.
+* Drops the specified database, from memory as well as from the configured
+* store (see `onStorageFailure`). Rejects if the configured store cannot be
+* opened or dropped.
 * @param dbName The name of the database to drop.
 * @param opts Options for dropping the database.
 */
 async function dropDatabase(dbName, opts) {
-	const kvStoreProvider = getKVStoreProvider(createLogContext(opts?.logLevel, opts?.logSinks, { dropDatabase: void 0 }), opts?.kvStore);
-	await dropDatabaseInternal(dbName, new IDBDatabasesStore(kvStoreProvider.create), kvStoreProvider.drop);
+	const logContext = createLogContext(opts?.logLevel, opts?.logSinks, { dropDatabase: void 0 });
+	for (const { provider, drops } of dropTargets(logContext, opts)) {
+		if (!drops(dbName)) continue;
+		const store = new IDBDatabasesStore(provider.create);
+		try {
+			await dropDatabaseInternal(dbName, store, provider.drop);
+		} finally {
+			await closeIgnoringErrors(store);
+		}
+	}
 }
 /**
-* Deletes all IndexedDB data associated with Replicache.
+* Deletes all IndexedDB data associated with Replicache, and the in-memory
+* databases instances ran on after a storage failure (see
+* `onStorageFailure`).
 *
 * Returns an object with the names of the successfully dropped databases
-* and any errors encountered while dropping.
+* and any errors encountered while dropping. Rejects if the configured store
+* cannot be opened.
+*/
+function dropAllDatabases(opts) {
+	return dropMatchingDatabases(() => true, opts);
+}
+/**
+* Like {@link dropAllDatabases}, for the databases whose registry record
+* matches `predicate`.
+*/
+async function dropMatchingDatabases(predicate, opts) {
+	const logContext = createLogContext(opts?.logLevel, opts?.logSinks, { dropDatabases: void 0 });
+	const dropped = /* @__PURE__ */ new Set();
+	const errors = [];
+	for (const { provider, drops } of dropTargets(logContext, opts)) {
+		const store = new IDBDatabasesStore(provider.create);
+		try {
+			const databases = await store.getDatabases();
+			const result = await dropDatabases(store, Object.values(databases).filter((db) => predicate(db) && drops(db.name)).map((db) => db.name), provider.drop);
+			result.dropped.forEach((name) => dropped.add(name));
+			errors.push(...result.errors);
+		} finally {
+			await closeIgnoringErrors(store);
+		}
+	}
+	return {
+		dropped: [...dropped],
+		errors
+	};
+}
+/**
+* The memory stores instances fell back to first, then the configured store.
+* An instance whose store failed to open runs on memory stores of the same
+* names (see `onStorageFailure`), and memory stores outlive the instance for
+* the life of the process, so a drop clears them whatever the configured
+* store is. Only those: the memory stores of `kvStore: 'mem'` instances are
+* left alone unless `'mem'` is the store being dropped from. The configured
+* store is still dropped, and its failure is reported: it may hold data on
+* disk.
+*/
+function dropTargets(lc, opts) {
+	const all = () => true;
+	if (opts?.kvStore === "mem") return [{
+		provider: getKVStoreProvider(lc, "mem"),
+		drops: all
+	}];
+	const targets = [];
+	if (isFallbackStore(getIDBDatabasesDBName())) targets.push({
+		provider: fallbackStoreProvider,
+		drops: isFallbackStore
+	});
+	targets.push({
+		provider: getKVStoreProvider(lc, opts?.kvStore),
+		drops: all
+	});
+	return targets;
+}
+/**
+* A store that failed to open may also fail to close; the drop's own result
+* is what the caller needs.
 */
-async function dropAllDatabases(opts) {
-	const kvStoreProvider = getKVStoreProvider(createLogContext(opts?.logLevel, opts?.logSinks, { dropAllDatabases: void 0 }), opts?.kvStore);
-	const store = new IDBDatabasesStore(kvStoreProvider.create);
-	const databases = await store.getDatabases();
-	return dropDatabases(store, Object.values(databases).map((db) => db.name), kvStoreProvider.drop);
+function closeIgnoringErrors(store) {
+	return store.close().catch(() => void 0);
 }
 /**
 * If there are pending mutations in any of the clients in this db we return
@@ -128,6 +205,6 @@ function canDatabaseBeCollectedAndGetDeletedClientIDs(enableMutationRecovery, pe
 	});
 }
 //#endregion
-export { COLLECT_IDB_INTERVAL, INITIAL_COLLECT_IDB_DELAY, dropAllDatabases, dropDatabase, initCollectIDBDatabases };
+export { COLLECT_IDB_INTERVAL, INITIAL_COLLECT_IDB_DELAY, dropAllDatabases, dropDatabase, dropDatabaseInternal, dropMatchingDatabases, initCollectIDBDatabases };
 
 //# sourceMappingURL=collect-idb-databases.js.map

package/out/replicache/src/persist/collect-idb-databases.js.map

@@ -1 +1 @@
-{"version":3,"file":"collect-idb-databases.js","names":[],"sources":["../../../../../replicache/src/persist/collect-idb-databases.ts"],"sourcesContent":["import type {LogContext, LogLevel, LogSink} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {initBgIntervalProcess} from '../bg-interval.ts';\nimport {StoreImpl} from '../dag/store-impl.ts';\nimport type {Store} from '../dag/store.ts';\nimport {\n  addDeletedClients,\n  getDeletedClients,\n  mergeDeletedClients,\n  normalizeDeletedClients,\n  type DeletedClients,\n  type WritableDeletedClients,\n} from '../deleted-clients.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport {getKVStoreProvider} from '../get-kv-store-provider.ts';\nimport {assertHash, newRandomHash} from '../hash.ts';\nimport type {CreateStore, DropStore, StoreProvider} from '../kv/store.ts';\nimport {createLogContext} from '../log-options.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {\n  clientGroupHasPendingMutations,\n  getClientGroups,\n} from './client-groups.ts';\nimport type {OnClientsDeleted} from './clients.ts';\nimport {getClients} from './clients.ts';\nimport type {IndexedDBDatabase} from './idb-databases-store.ts';\nimport {IDBDatabasesStore} from './idb-databases-store.ts';\n\n/**\n * How frequently to try to collect\n */\nexport const COLLECT_IDB_INTERVAL = 12 * 60 * 60 * 1000; // 12 hours\n\n/**\n * We delay the initial collection to prevent doing it at startup.\n */\nexport const INITIAL_COLLECT_IDB_DELAY = 5 * 60 * 1000; // 5 minutes\n\nexport function initCollectIDBDatabases(\n  idbDatabasesStore: IDBDatabasesStore,\n  kvStoreProvider: StoreProvider,\n  collectInterval: number,\n  initialCollectDelay: number,\n  maxAge: number,\n  enableMutationRecovery: boolean,\n  onClientsDeleted: OnClientsDeleted,\n  lc: LogContext,\n  signal: AbortSignal,\n): void {\n  let initial = true;\n  initBgIntervalProcess(\n    'CollectIDBDatabases',\n    async () => {\n      await collectIDBDatabases(\n        idbDatabasesStore,\n        Date.now(),\n        maxAge,\n        kvStoreProvider,\n        enableMutationRecovery,\n        onClientsDeleted,\n      );\n    },\n    () => {\n      if (initial) {\n        initial = false;\n        return initialCollectDelay;\n      }\n      return collectInterval;\n    },\n    lc,\n    signal,\n  );\n}\n\n/**\n * Collects IDB databases that are no longer needed.\n */\nexport async function collectIDBDatabases(\n  idbDatabasesStore: IDBDatabasesStore,\n  now: number,\n  maxAge: number,\n  kvStoreProvider: StoreProvider,\n  enableMutationRecovery: boolean,\n  onClientsDeleted: OnClientsDeleted,\n  newDagStore = defaultNewDagStore,\n): Promise<void> {\n  const databases = await idbDatabasesStore.getDatabases();\n\n  const dbs = Object.values(databases);\n  const collectResults = await Promise.all(\n    dbs.map(\n      async db =>\n        [\n          db.name,\n          await gatherDatabaseInfoForCollect(\n            db,\n            now,\n            maxAge,\n            enableMutationRecovery,\n            kvStoreProvider.create,\n            newDagStore,\n          ),\n        ] as const,\n    ),\n  );\n\n  const dbNamesToRemove: string[] = [];\n  const dbNamesToKeep: string[] = [];\n  const deletedClientsToRemove: WritableDeletedClients = [];\n  for (const [dbName, [canCollect, deletedClients]] of collectResults) {\n    if (canCollect) {\n      dbNamesToRemove.push(dbName);\n      deletedClientsToRemove.push(...deletedClients);\n    } else {\n      dbNamesToKeep.push(dbName);\n    }\n  }\n\n  const {errors} = await dropDatabases(\n    idbDatabasesStore,\n    dbNamesToRemove,\n    kvStoreProvider.drop,\n  );\n  if (errors.length) {\n    throw errors[0];\n  }\n\n  if (deletedClientsToRemove.length > 0) {\n    // Add the deleted clients to all the dbs that survived the collection.\n    let allDeletedClients: DeletedClients = deletedClientsToRemove;\n    for (const name of dbNamesToKeep) {\n      await withWrite(\n        newDagStore(name, kvStoreProvider.create),\n        async dagWrite => {\n          const newDeletedClients = await addDeletedClients(\n            dagWrite,\n            deletedClientsToRemove,\n          );\n\n          allDeletedClients = mergeDeletedClients(\n            allDeletedClients,\n            newDeletedClients,\n          );\n        },\n      );\n    }\n    // normalize and dedupe\n    const normalizedDeletedClients = normalizeDeletedClients(allDeletedClients);\n\n    // Call the callback with the normalized deleted clients\n    await onClientsDeleted(normalizedDeletedClients);\n  }\n}\n\nasync function dropDatabaseInternal(\n  name: string,\n  idbDatabasesStore: IDBDatabasesStore,\n  kvDropStore: DropStore,\n) {\n  await kvDropStore(name);\n  await idbDatabasesStore.deleteDatabases([name]);\n}\n\nasync function dropDatabases(\n  idbDatabasesStore: IDBDatabasesStore,\n  namesToRemove: string[],\n  kvDropStore: DropStore,\n): Promise<{dropped: string[]; errors: unknown[]}> {\n  // Try to remove the databases in parallel. Don't let a single reject fail the\n  // other ones. We will check for failures afterwards.\n  const dropStoreResults = await Promise.allSettled(\n    namesToRemove.map(async name => {\n      await dropDatabaseInternal(name, idbDatabasesStore, kvDropStore);\n      return name;\n    }),\n  );\n\n  const dropped: string[] = [];\n  const errors: unknown[] = [];\n  for (const result of dropStoreResults) {\n    if (result.status === 'fulfilled') {\n      dropped.push(result.value);\n    } else {\n      errors.push(result.reason);\n    }\n  }\n\n  return {dropped, errors};\n}\n\nfunction defaultNewDagStore(name: string, kvCreateStore: CreateStore): Store {\n  const perKvStore = kvCreateStore(name);\n  return new StoreImpl(perKvStore, newRandomHash, assertHash);\n}\n\n/**\n * If any client has a recent heartbeat or there are pending mutations we\n * return `[false]`. Otherwise we return `[true, deletedClients]`.\n */\nfunction gatherDatabaseInfoForCollect(\n  db: IndexedDBDatabase,\n  now: number,\n  maxAge: number,\n  enableMutationRecovery: boolean,\n  kvCreateStore: CreateStore,\n  newDagStore: typeof defaultNewDagStore,\n): MaybePromise<\n  [canCollect: false] | [canCollect: true, deletedClients: DeletedClients]\n> {\n  if (db.replicacheFormatVersion > FormatVersion.Latest) {\n    return [false];\n  }\n\n  // If increase the format version we need to decide how to deal with this\n  // logic.\n  assert(\n    db.replicacheFormatVersion === FormatVersion.DD31 ||\n      db.replicacheFormatVersion === FormatVersion.V6 ||\n      db.replicacheFormatVersion === FormatVersion.V7,\n    () =>\n      `Expected replicacheFormatVersion to be DD31, V6, or V7, got ${db.replicacheFormatVersion}`,\n  );\n  return canDatabaseBeCollectedAndGetDeletedClientIDs(\n    enableMutationRecovery,\n    newDagStore(db.name, kvCreateStore),\n    now,\n    maxAge,\n  );\n}\n\n/**\n * Options for `dropDatabase` and `dropAllDatabases`.\n */\nexport type DropDatabaseOptions = {\n  /**\n   * Allows providing a custom implementation of the underlying storage layer.\n   * Default is `'idb'`.\n   */\n  kvStore?: 'idb' | 'mem' | StoreProvider | undefined;\n  /**\n   * Determines how much logging to do. When this is set to `'debug'`,\n   * Replicache will also log `'info'` and `'error'` messages. When set to\n   * `'info'` we log `'info'` and `'error'` but not `'debug'`. When set to\n   * `'error'` we only log `'error'` messages.\n   * Default is `'info'`.\n   */\n  logLevel?: LogLevel | undefined;\n  /**\n   * Enables custom handling of logs.\n   *\n   * By default logs are logged to the console.  If you would like logs to be\n   * sent elsewhere (e.g. to a cloud logging service like DataDog) you can\n   * provide an array of {@link LogSink}s.  Logs at or above\n   * {@link DropDatabaseOptions.logLevel} are sent to each of these {@link LogSink}s.\n   * If you would still like logs to go to the console, include\n   * `consoleLogSink` in the array.\n   *\n   * ```ts\n   * logSinks: [consoleLogSink, myCloudLogSink],\n   * ```\n   * Default is `[consoleLogSink]`.\n   */\n  logSinks?: LogSink[] | undefined;\n};\n\n/**\n * Drops the specified database.\n * @param dbName The name of the database to drop.\n * @param opts Options for dropping the database.\n */\nexport async function dropDatabase(dbName: string, opts?: DropDatabaseOptions) {\n  const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {\n    dropDatabase: undefined,\n  });\n  const kvStoreProvider = getKVStoreProvider(logContext, opts?.kvStore);\n  await dropDatabaseInternal(\n    dbName,\n    new IDBDatabasesStore(kvStoreProvider.create),\n    kvStoreProvider.drop,\n  );\n}\n\n/**\n * Deletes all IndexedDB data associated with Replicache.\n *\n * Returns an object with the names of the successfully dropped databases\n * and any errors encountered while dropping.\n */\nexport async function dropAllDatabases(opts?: DropDatabaseOptions): Promise<{\n  dropped: string[];\n  errors: unknown[];\n}> {\n  const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {\n    dropAllDatabases: undefined,\n  });\n  const kvStoreProvider = getKVStoreProvider(logContext, opts?.kvStore);\n  const store = new IDBDatabasesStore(kvStoreProvider.create);\n  const databases = await store.getDatabases();\n  const dbNames = Object.values(databases).map(db => db.name);\n  return dropDatabases(store, dbNames, kvStoreProvider.drop);\n}\n\n/**\n * Deletes all IndexedDB data associated with Replicache.\n *\n * Returns an object with the names of the successfully dropped databases\n * and any errors encountered while dropping.\n *\n * @deprecated Use `dropAllDatabases` instead.\n */\nexport function deleteAllReplicacheData(opts?: DropDatabaseOptions) {\n  return dropAllDatabases(opts);\n}\n\n/**\n * If there are pending mutations in any of the clients in this db we return\n * `[false]`. If any client has a recent heartbeat we also return `[false]`.\n * Otherwise we return `[true, deletedClients]`.\n */\nfunction canDatabaseBeCollectedAndGetDeletedClientIDs(\n  enableMutationRecovery: boolean,\n  perdag: Store,\n  now: number,\n  maxAge: number,\n): Promise<\n  [canCollect: false] | [canCollect: true, deletedClients: DeletedClients]\n> {\n  return withRead(perdag, async read => {\n    // If mutation recovery is disabled we do not care if there are pending\n    // mutations when we decide if we can collect the database.\n    if (enableMutationRecovery) {\n      const clientGroups = await getClientGroups(read);\n      for (const clientGroup of clientGroups.values()) {\n        if (clientGroupHasPendingMutations(clientGroup)) {\n          return [false];\n        }\n      }\n    }\n\n    const clients = await getClients(read);\n\n    // Don't collect if any client has a recent heartbeat (is still active).\n    // This is defense in depth - normally lastOpenedTimestampMS is kept fresh\n    // by the heartbeat, but this check protects against edge cases.\n    for (const [, client] of clients) {\n      if (now - client.heartbeatTimestampMs < maxAge) {\n        return [false];\n      }\n    }\n\n    const existingDeletedClients = await getDeletedClients(read);\n    const deletedClients: WritableDeletedClients = [...existingDeletedClients];\n\n    // Add all current clients to the deleted clients list\n    for (const [clientID, client] of clients) {\n      deletedClients.push({\n        clientID,\n        clientGroupID: client.clientGroupID,\n      });\n    }\n\n    // The normalization (deduping and sorting) will be done when storing\n    return [true, deletedClients];\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"collect-idb-databases.js","names":[],"sources":["../../../../../replicache/src/persist/collect-idb-databases.ts"],"sourcesContent":["import type {LogContext, LogLevel, LogSink} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {initBgIntervalProcess} from '../bg-interval.ts';\nimport {InvalidRefCountError} from '../dag/invalid-ref-count-error.ts';\nimport {StoreImpl} from '../dag/store-impl.ts';\nimport type {Store} from '../dag/store.ts';\nimport {\n  addDeletedClients,\n  getDeletedClients,\n  mergeDeletedClients,\n  normalizeDeletedClients,\n  type DeletedClients,\n  type WritableDeletedClients,\n} from '../deleted-clients.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport {getKVStoreProvider} from '../get-kv-store-provider.ts';\nimport {assertHash, newRandomHash} from '../hash.ts';\nimport {\n  fallbackStoreProvider,\n  isFallbackStore,\n} from '../kv/mem-fallback-store.ts';\nimport type {CreateStore, DropStore, StoreProvider} from '../kv/store.ts';\nimport {createLogContext} from '../log-options.ts';\nimport type {StorageFailureError} from '../storage-failure.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {\n  clientGroupHasPendingMutations,\n  getClientGroups,\n} from './client-groups.ts';\nimport type {OnClientsDeleted} from './clients.ts';\nimport {getClients} from './clients.ts';\nimport {getIDBDatabasesDBName} from './idb-databases-store-db-name.ts';\nimport type {IndexedDBDatabase} from './idb-databases-store.ts';\nimport {IDBDatabasesStore} from './idb-databases-store.ts';\n\n/**\n * How frequently to try to collect\n */\nexport const COLLECT_IDB_INTERVAL = 12 * 60 * 60 * 1000; // 12 hours\n\n/**\n * We delay the initial collection to prevent doing it at startup.\n */\nexport const INITIAL_COLLECT_IDB_DELAY = 5 * 60 * 1000; // 5 minutes\n\nexport function initCollectIDBDatabases(\n  idbDatabasesStore: IDBDatabasesStore,\n  kvStoreProvider: StoreProvider,\n  collectInterval: number,\n  initialCollectDelay: number,\n  maxAge: number,\n  enableMutationRecovery: boolean,\n  onClientsDeleted: OnClientsDeleted,\n  lc: LogContext,\n  signal: AbortSignal,\n  newDagStore: NewDagStore = defaultNewDagStore,\n  onStorageFailure?: ((failure: StorageFailureError) => void) | undefined,\n): void {\n  let initial = true;\n  initBgIntervalProcess(\n    'CollectIDBDatabases',\n    async () => {\n      await collectIDBDatabases(\n        idbDatabasesStore,\n        Date.now(),\n        maxAge,\n        kvStoreProvider,\n        enableMutationRecovery,\n        onClientsDeleted,\n        newDagStore,\n      );\n    },\n    () => {\n      if (initial) {\n        initial = false;\n        return initialCollectDelay;\n      }\n      return collectInterval;\n    },\n    lc,\n    signal,\n    onStorageFailure,\n  );\n}\n\n/**\n * Collects IDB databases that are no longer needed.\n */\nexport async function collectIDBDatabases(\n  idbDatabasesStore: IDBDatabasesStore,\n  now: number,\n  maxAge: number,\n  kvStoreProvider: StoreProvider,\n  enableMutationRecovery: boolean,\n  onClientsDeleted: OnClientsDeleted,\n  newDagStore: NewDagStore = defaultNewDagStore,\n): Promise<void> {\n  const databases = await idbDatabasesStore.getDatabases();\n\n  const dbs = Object.values(databases);\n  const collectResults = await Promise.all(\n    dbs.map(\n      async db =>\n        [\n          db.name,\n          await gatherDatabaseInfoForCollect(\n            db,\n            now,\n            maxAge,\n            enableMutationRecovery,\n            kvStoreProvider.create,\n            newDagStore,\n          ),\n        ] as const,\n    ),\n  );\n\n  const dbNamesToRemove: string[] = [];\n  const dbNamesToKeep: string[] = [];\n  const deletedClientsToRemove: WritableDeletedClients = [];\n  for (const [dbName, [canCollect, deletedClients]] of collectResults) {\n    if (canCollect) {\n      dbNamesToRemove.push(dbName);\n      deletedClientsToRemove.push(...deletedClients);\n    } else {\n      dbNamesToKeep.push(dbName);\n    }\n  }\n\n  const {errors} = await dropDatabases(\n    idbDatabasesStore,\n    dbNamesToRemove,\n    kvStoreProvider.drop,\n  );\n  if (errors.length) {\n    throw errors[0];\n  }\n\n  if (deletedClientsToRemove.length > 0) {\n    // Add the deleted clients to all the dbs that survived the collection.\n    let newDeletedClients: DeletedClients = deletedClientsToRemove;\n    for (const name of dbNamesToKeep) {\n      let dbDeletedClients: DeletedClients;\n      try {\n        dbDeletedClients = await withWrite(\n          newDagStore(name, kvStoreProvider.create),\n          dagWrite => addDeletedClients(dagWrite, deletedClientsToRemove),\n        );\n      } catch (e) {\n        if (!(e instanceof InvalidRefCountError)) {\n          throw e;\n        }\n        // This database is corrupt. Its own instance will find out and\n        // recover the next time it writes to it; here, just skip it and keep\n        // collecting into the others, instead of letting one corrupt\n        // database break every collection run forever.\n        continue;\n      }\n      newDeletedClients = mergeDeletedClients(\n        newDeletedClients,\n        dbDeletedClients,\n      );\n    }\n    // normalize and dedupe\n    const normalizedDeletedClients = normalizeDeletedClients(newDeletedClients);\n\n    // Call the callback with the normalized deleted clients\n    await onClientsDeleted(normalizedDeletedClients);\n  }\n}\n\nexport async function dropDatabaseInternal(\n  name: string,\n  idbDatabasesStore: IDBDatabasesStore,\n  kvDropStore: DropStore,\n) {\n  await kvDropStore(name);\n  await idbDatabasesStore.deleteDatabases([name]);\n}\n\nasync function dropDatabases(\n  idbDatabasesStore: IDBDatabasesStore,\n  namesToRemove: string[],\n  kvDropStore: DropStore,\n): Promise<{dropped: string[]; errors: unknown[]}> {\n  // Try to remove the databases in parallel. Don't let a single reject fail the\n  // other ones. We will check for failures afterwards.\n  const dropStoreResults = await Promise.allSettled(\n    namesToRemove.map(async name => {\n      await dropDatabaseInternal(name, idbDatabasesStore, kvDropStore);\n      return name;\n    }),\n  );\n\n  const dropped: string[] = [];\n  const errors: unknown[] = [];\n  for (const result of dropStoreResults) {\n    if (result.status === 'fulfilled') {\n      dropped.push(result.value);\n    } else {\n      errors.push(result.reason);\n    }\n  }\n\n  return {dropped, errors};\n}\n\n/**\n * Creates the dag store used to inspect and update a database during\n * collection. Callers can override it to install store hooks, for example so\n * a corrupt ref count found while writing deleted clients is recovered from.\n */\nexport type NewDagStore = (name: string, kvCreateStore: CreateStore) => Store;\n\nfunction defaultNewDagStore(name: string, kvCreateStore: CreateStore): Store {\n  const perKvStore = kvCreateStore(name);\n  return new StoreImpl(perKvStore, newRandomHash, assertHash);\n}\n\n/**\n * If any client has a recent heartbeat or there are pending mutations we\n * return `[false]`. Otherwise we return `[true, deletedClients]`.\n */\nfunction gatherDatabaseInfoForCollect(\n  db: IndexedDBDatabase,\n  now: number,\n  maxAge: number,\n  enableMutationRecovery: boolean,\n  kvCreateStore: CreateStore,\n  newDagStore: NewDagStore,\n): MaybePromise<\n  [canCollect: false] | [canCollect: true, deletedClients: DeletedClients]\n> {\n  if (db.replicacheFormatVersion > FormatVersion.Latest) {\n    return [false];\n  }\n\n  // If increase the format version we need to decide how to deal with this\n  // logic.\n  assert(\n    db.replicacheFormatVersion === FormatVersion.DD31 ||\n      db.replicacheFormatVersion === FormatVersion.V6 ||\n      db.replicacheFormatVersion === FormatVersion.V7,\n    () =>\n      `Expected replicacheFormatVersion to be DD31, V6, or V7, got ${db.replicacheFormatVersion}`,\n  );\n  return canDatabaseBeCollectedAndGetDeletedClientIDs(\n    enableMutationRecovery,\n    newDagStore(db.name, kvCreateStore),\n    now,\n    maxAge,\n  );\n}\n\n/**\n * Options for `dropDatabase` and `dropAllDatabases`.\n */\nexport type DropDatabaseOptions = {\n  /**\n   * Allows providing a custom implementation of the underlying storage layer.\n   * Default is `'idb'`.\n   */\n  kvStore?: 'idb' | 'mem' | StoreProvider | undefined;\n  /**\n   * Determines how much logging to do. When this is set to `'debug'`,\n   * Replicache will also log `'info'` and `'error'` messages. When set to\n   * `'info'` we log `'info'` and `'error'` but not `'debug'`. When set to\n   * `'error'` we only log `'error'` messages.\n   * Default is `'info'`.\n   */\n  logLevel?: LogLevel | undefined;\n  /**\n   * Enables custom handling of logs.\n   *\n   * By default logs are logged to the console.  If you would like logs to be\n   * sent elsewhere (e.g. to a cloud logging service like DataDog) you can\n   * provide an array of {@link LogSink}s.  Logs at or above\n   * {@link DropDatabaseOptions.logLevel} are sent to each of these {@link LogSink}s.\n   * If you would still like logs to go to the console, include\n   * `consoleLogSink` in the array.\n   *\n   * ```ts\n   * logSinks: [consoleLogSink, myCloudLogSink],\n   * ```\n   * Default is `[consoleLogSink]`.\n   */\n  logSinks?: LogSink[] | undefined;\n};\n\n/**\n * Drops the specified database, from memory as well as from the configured\n * store (see `onStorageFailure`). Rejects if the configured store cannot be\n * opened or dropped.\n * @param dbName The name of the database to drop.\n * @param opts Options for dropping the database.\n */\nexport async function dropDatabase(dbName: string, opts?: DropDatabaseOptions) {\n  const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {\n    dropDatabase: undefined,\n  });\n  for (const {provider, drops} of dropTargets(logContext, opts)) {\n    if (!drops(dbName)) {\n      continue;\n    }\n    const store = new IDBDatabasesStore(provider.create);\n    try {\n      await dropDatabaseInternal(dbName, store, provider.drop);\n    } finally {\n      await closeIgnoringErrors(store);\n    }\n  }\n}\n\n/**\n * Deletes all IndexedDB data associated with Replicache, and the in-memory\n * databases instances ran on after a storage failure (see\n * `onStorageFailure`).\n *\n * Returns an object with the names of the successfully dropped databases\n * and any errors encountered while dropping. Rejects if the configured store\n * cannot be opened.\n */\nexport function dropAllDatabases(opts?: DropDatabaseOptions): Promise<{\n  dropped: string[];\n  errors: unknown[];\n}> {\n  return dropMatchingDatabases(() => true, opts);\n}\n\n/**\n * Like {@link dropAllDatabases}, for the databases whose registry record\n * matches `predicate`.\n */\nexport async function dropMatchingDatabases(\n  predicate: (db: IndexedDBDatabase) => boolean,\n  opts?: DropDatabaseOptions,\n): Promise<{\n  dropped: string[];\n  errors: unknown[];\n}> {\n  const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {\n    dropDatabases: undefined,\n  });\n  const dropped = new Set<string>();\n  const errors: unknown[] = [];\n  for (const {provider, drops} of dropTargets(logContext, opts)) {\n    const store = new IDBDatabasesStore(provider.create);\n    try {\n      const databases = await store.getDatabases();\n      const dbNames = Object.values(databases)\n        .filter(db => predicate(db) && drops(db.name))\n        .map(db => db.name);\n      const result = await dropDatabases(store, dbNames, provider.drop);\n      result.dropped.forEach(name => dropped.add(name));\n      errors.push(...result.errors);\n    } finally {\n      await closeIgnoringErrors(store);\n    }\n  }\n  return {dropped: [...dropped], errors};\n}\n\ntype DropTarget = {\n  provider: StoreProvider;\n  /** Whether a database of this name is dropped from `provider`. */\n  drops: (name: string) => boolean;\n};\n\n/**\n * The memory stores instances fell back to first, then the configured store.\n * An instance whose store failed to open runs on memory stores of the same\n * names (see `onStorageFailure`), and memory stores outlive the instance for\n * the life of the process, so a drop clears them whatever the configured\n * store is. Only those: the memory stores of `kvStore: 'mem'` instances are\n * left alone unless `'mem'` is the store being dropped from. The configured\n * store is still dropped, and its failure is reported: it may hold data on\n * disk.\n */\nfunction dropTargets(\n  lc: LogContext,\n  opts: DropDatabaseOptions | undefined,\n): DropTarget[] {\n  const all = () => true;\n  if (opts?.kvStore === 'mem') {\n    return [{provider: getKVStoreProvider(lc, 'mem'), drops: all}];\n  }\n  const targets: DropTarget[] = [];\n  if (isFallbackStore(getIDBDatabasesDBName())) {\n    targets.push({provider: fallbackStoreProvider, drops: isFallbackStore});\n  }\n  targets.push({provider: getKVStoreProvider(lc, opts?.kvStore), drops: all});\n  return targets;\n}\n\n/**\n * A store that failed to open may also fail to close; the drop's own result\n * is what the caller needs.\n */\nfunction closeIgnoringErrors(store: IDBDatabasesStore): Promise<void> {\n  return store.close().catch(() => undefined);\n}\n\n/**\n * Deletes all IndexedDB data associated with Replicache.\n *\n * Returns an object with the names of the successfully dropped databases\n * and any errors encountered while dropping.\n *\n * @deprecated Use `dropAllDatabases` instead.\n */\nexport function deleteAllReplicacheData(opts?: DropDatabaseOptions) {\n  return dropAllDatabases(opts);\n}\n\n/**\n * If there are pending mutations in any of the clients in this db we return\n * `[false]`. If any client has a recent heartbeat we also return `[false]`.\n * Otherwise we return `[true, deletedClients]`.\n */\nfunction canDatabaseBeCollectedAndGetDeletedClientIDs(\n  enableMutationRecovery: boolean,\n  perdag: Store,\n  now: number,\n  maxAge: number,\n): Promise<\n  [canCollect: false] | [canCollect: true, deletedClients: DeletedClients]\n> {\n  return withRead(perdag, async read => {\n    // If mutation recovery is disabled we do not care if there are pending\n    // mutations when we decide if we can collect the database.\n    if (enableMutationRecovery) {\n      const clientGroups = await getClientGroups(read);\n      for (const clientGroup of clientGroups.values()) {\n        if (clientGroupHasPendingMutations(clientGroup)) {\n          return [false];\n        }\n      }\n    }\n\n    const clients = await getClients(read);\n\n    // Don't collect if any client has a recent heartbeat (is still active).\n    // This is defense in depth - normally lastOpenedTimestampMS is kept fresh\n    // by the heartbeat, but this check protects against edge cases.\n    for (const [, client] of clients) {\n      if (now - client.heartbeatTimestampMs < maxAge) {\n        return [false];\n      }\n    }\n\n    const existingDeletedClients = await getDeletedClients(read);\n    const deletedClients: WritableDeletedClients = [...existingDeletedClients];\n\n    // Add all current clients to the deleted clients list\n    for (const [clientID, client] of clients) {\n      deletedClients.push({\n        clientID,\n        clientGroupID: client.clientGroupID,\n      });\n    }\n\n    // The normalization (deduping and sorting) will be done when storing\n    return [true, deletedClients];\n  });\n}\n"],"mappings":"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"}

package/out/replicache/src/persist/heartbeat.d.ts

@@ -1,9 +1,10 @@
 import type { LogContext } from '@rocicorp/logger';
 import type { Store } from '../dag/store.ts';
+import type { StorageFailureError } from '../storage-failure.ts';
 import type { ClientID } from '../sync/ids.ts';
 import { type ClientMap } from './clients.ts';
 export declare const HEARTBEAT_INTERVAL: number;
 export declare let latestHeartbeatUpdate: Promise<ClientMap> | undefined;
-export declare function startHeartbeats(clientID: ClientID, dagStore: Store, onClientStateNotFound: () => void, heartbeatIntervalMs: number, lc: LogContext, signal: AbortSignal): void;
+export declare function startHeartbeats(clientID: ClientID, dagStore: Store, onClientStateNotFound: () => void, heartbeatIntervalMs: number, lc: LogContext, signal: AbortSignal, onStorageFailure?: ((failure: StorageFailureError) => void) | undefined): void;
 export declare function writeHeartbeat(clientID: ClientID, dagStore: Store): Promise<ClientMap>;
 //# sourceMappingURL=heartbeat.d.ts.map

package/out/replicache/src/persist/heartbeat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/heartbeat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EACL,KAAK,SAAS,EAIf,MAAM,cAAc,CAAC;AAEtB,eAAO,MAAM,kBAAkB,QAAY,CAAC;AAE5C,eAAO,IAAI,qBAAqB,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;AAEjE,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,KAAK,EACf,qBAAqB,EAAE,MAAM,IAAI,EACjC,mBAAmB,EAAE,MAAM,EAC3B,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,WAAW,GAClB,IAAI,CAmBN;AAED,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,KAAK,GACd,OAAO,CAAC,SAAS,CAAC,CAiBpB"}
+{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/heartbeat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EACL,KAAK,SAAS,EAIf,MAAM,cAAc,CAAC;AAEtB,eAAO,MAAM,kBAAkB,QAAY,CAAC;AAE5C,eAAO,IAAI,qBAAqB,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;AAEjE,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,KAAK,EACf,qBAAqB,EAAE,MAAM,IAAI,EACjC,mBAAmB,EAAE,MAAM,EAC3B,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,WAAW,EACnB,gBAAgB,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,mBAAmB,KAAK,IAAI,CAAC,GAAG,SAAS,GACtE,IAAI,CAoBN;AAED,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,KAAK,GACd,OAAO,CAAC,SAAS,CAAC,CAiBpB"}

package/out/replicache/src/persist/heartbeat.js

@@ -4,7 +4,7 @@ import { ClientStateNotFoundError, getClients, setClients } from "./clients.js";
 //#region ../replicache/src/persist/heartbeat.ts
 var HEARTBEAT_INTERVAL = 60 * 1e3;
 var latestHeartbeatUpdate;
-function startHeartbeats(clientID, dagStore, onClientStateNotFound, heartbeatIntervalMs, lc, signal) {
+function startHeartbeats(clientID, dagStore, onClientStateNotFound, heartbeatIntervalMs, lc, signal, onStorageFailure) {
 	initBgIntervalProcess("Heartbeat", async () => {
 		latestHeartbeatUpdate = writeHeartbeat(clientID, dagStore);
 		try {
@@ -16,7 +16,7 @@ function startHeartbeats(clientID, dagStore, onClientStateNotFound, heartbeatInt
 			}
 			throw e;
 		}
-	}, () => heartbeatIntervalMs, lc, signal);
+	}, () => heartbeatIntervalMs, lc, signal, onStorageFailure);
 }
 function writeHeartbeat(clientID, dagStore) {
 	return withWrite(dagStore, async (dagWrite) => {

package/out/replicache/src/persist/heartbeat.js.map

@@ -1 +1 @@
-{"version":3,"file":"heartbeat.js","names":[],"sources":["../../../../../replicache/src/persist/heartbeat.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {initBgIntervalProcess} from '../bg-interval.ts';\nimport type {Store} from '../dag/store.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport {withWrite} from '../with-transactions.ts';\nimport {\n  type ClientMap,\n  ClientStateNotFoundError,\n  getClients,\n  setClients,\n} from './clients.ts';\n\nexport const HEARTBEAT_INTERVAL = 60 * 1000;\n\nexport let latestHeartbeatUpdate: Promise<ClientMap> | undefined;\n\nexport function startHeartbeats(\n  clientID: ClientID,\n  dagStore: Store,\n  onClientStateNotFound: () => void,\n  heartbeatIntervalMs: number,\n  lc: LogContext,\n  signal: AbortSignal,\n): void {\n  initBgIntervalProcess(\n    'Heartbeat',\n    async () => {\n      latestHeartbeatUpdate = writeHeartbeat(clientID, dagStore);\n      try {\n        return await latestHeartbeatUpdate;\n      } catch (e) {\n        if (e instanceof ClientStateNotFoundError) {\n          onClientStateNotFound();\n          return;\n        }\n        throw e;\n      }\n    },\n    () => heartbeatIntervalMs,\n    lc,\n    signal,\n  );\n}\n\nexport function writeHeartbeat(\n  clientID: ClientID,\n  dagStore: Store,\n): Promise<ClientMap> {\n  return withWrite(dagStore, async dagWrite => {\n    const clients = await getClients(dagWrite);\n    const client = clients.get(clientID);\n    if (!client) {\n      throw new ClientStateNotFoundError(clientID);\n    }\n\n    const newClient = {\n      ...client,\n      heartbeatTimestampMs: Date.now(),\n    };\n    const newClients = new Map(clients).set(clientID, newClient);\n\n    await setClients(newClients, dagWrite);\n    return newClients;\n  });\n}\n"],"mappings":";;;;AAYA,IAAa,qBAAqB,KAAK;AAEvC,IAAW;AAEX,SAAgB,gBACd,UACA,UACA,uBACA,qBACA,IACA,QACM;CACN,sBACE,aACA,YAAY;EACV,wBAAwB,eAAe,UAAU,QAAQ;EACzD,IAAI;GACF,OAAO,MAAM;EACf,SAAS,GAAG;GACV,IAAI,aAAa,0BAA0B;IACzC,sBAAsB;IACtB;GACF;GACA,MAAM;EACR;CACF,SACM,qBACN,IACA,MACF;AACF;AAEA,SAAgB,eACd,UACA,UACoB;CACpB,OAAO,UAAU,UAAU,OAAM,aAAY;EAC3C,MAAM,UAAU,MAAM,WAAW,QAAQ;EACzC,MAAM,SAAS,QAAQ,IAAI,QAAQ;EACnC,IAAI,CAAC,QACH,MAAM,IAAI,yBAAyB,QAAQ;EAG7C,MAAM,YAAY;GAChB,GAAG;GACH,sBAAsB,KAAK,IAAI;EACjC;EACA,MAAM,aAAa,IAAI,IAAI,OAAO,EAAE,IAAI,UAAU,SAAS;EAE3D,MAAM,WAAW,YAAY,QAAQ;EACrC,OAAO;CACT,CAAC;AACH"}
+{"version":3,"file":"heartbeat.js","names":[],"sources":["../../../../../replicache/src/persist/heartbeat.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {initBgIntervalProcess} from '../bg-interval.ts';\nimport type {Store} from '../dag/store.ts';\nimport type {StorageFailureError} from '../storage-failure.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport {withWrite} from '../with-transactions.ts';\nimport {\n  type ClientMap,\n  ClientStateNotFoundError,\n  getClients,\n  setClients,\n} from './clients.ts';\n\nexport const HEARTBEAT_INTERVAL = 60 * 1000;\n\nexport let latestHeartbeatUpdate: Promise<ClientMap> | undefined;\n\nexport function startHeartbeats(\n  clientID: ClientID,\n  dagStore: Store,\n  onClientStateNotFound: () => void,\n  heartbeatIntervalMs: number,\n  lc: LogContext,\n  signal: AbortSignal,\n  onStorageFailure?: ((failure: StorageFailureError) => void) | undefined,\n): void {\n  initBgIntervalProcess(\n    'Heartbeat',\n    async () => {\n      latestHeartbeatUpdate = writeHeartbeat(clientID, dagStore);\n      try {\n        return await latestHeartbeatUpdate;\n      } catch (e) {\n        if (e instanceof ClientStateNotFoundError) {\n          onClientStateNotFound();\n          return;\n        }\n        throw e;\n      }\n    },\n    () => heartbeatIntervalMs,\n    lc,\n    signal,\n    onStorageFailure,\n  );\n}\n\nexport function writeHeartbeat(\n  clientID: ClientID,\n  dagStore: Store,\n): Promise<ClientMap> {\n  return withWrite(dagStore, async dagWrite => {\n    const clients = await getClients(dagWrite);\n    const client = clients.get(clientID);\n    if (!client) {\n      throw new ClientStateNotFoundError(clientID);\n    }\n\n    const newClient = {\n      ...client,\n      heartbeatTimestampMs: Date.now(),\n    };\n    const newClients = new Map(clients).set(clientID, newClient);\n\n    await setClients(newClients, dagWrite);\n    return newClients;\n  });\n}\n"],"mappings":";;;;AAaA,IAAa,qBAAqB,KAAK;AAEvC,IAAW;AAEX,SAAgB,gBACd,UACA,UACA,uBACA,qBACA,IACA,QACA,kBACM;CACN,sBACE,aACA,YAAY;EACV,wBAAwB,eAAe,UAAU,QAAQ;EACzD,IAAI;GACF,OAAO,MAAM;EACf,SAAS,GAAG;GACV,IAAI,aAAa,0BAA0B;IACzC,sBAAsB;IACtB;GACF;GACA,MAAM;EACR;CACF,SACM,qBACN,IACA,QACA,gBACF;AACF;AAEA,SAAgB,eACd,UACA,UACoB;CACpB,OAAO,UAAU,UAAU,OAAM,aAAY;EAC3C,MAAM,UAAU,MAAM,WAAW,QAAQ;EACzC,MAAM,SAAS,QAAQ,IAAI,QAAQ;EACnC,IAAI,CAAC,QACH,MAAM,IAAI,yBAAyB,QAAQ;EAG7C,MAAM,YAAY;GAChB,GAAG;GACH,sBAAsB,KAAK,IAAI;EACjC;EACA,MAAM,aAAa,IAAI,IAAI,OAAO,EAAE,IAAI,UAAU,SAAS;EAE3D,MAAM,WAAW,YAAY,QAAQ;EACrC,OAAO;CACT,CAAC;AACH"}

package/out/replicache/src/persist/idb-databases-store-db-name.js

@@ -1,4 +1,4 @@
-import "../kv/idb-store-with-mem-fallback.js";
+import "../kv/idb-store.js";
 //#region ../replicache/src/persist/idb-databases-store-db-name.ts
 var IDB_DATABASES_DB_NAME = "replicache-dbs-v0";
 var testNamespace = "";

package/out/replicache/src/persist/idb-databases-store-db-name.js.map

@@ -1 +1 @@
-{"version":3,"file":"idb-databases-store-db-name.js","names":[],"sources":["../../../../../replicache/src/persist/idb-databases-store-db-name.ts"],"sourcesContent":["import {randomUint64} from '../../../shared/src/random-uint64.ts';\nimport {dropIDBStoreWithMemFallback} from '../kv/idb-store-with-mem-fallback.ts';\n\nconst IDB_DATABASES_VERSION = 0;\nconst IDB_DATABASES_DB_NAME = 'replicache-dbs-v' + IDB_DATABASES_VERSION;\n\nlet testNamespace = '';\n\n/** Namespace db name in test to isolate tests' indexeddb state. */\nexport function setupForTest(): void {\n  testNamespace = randomUint64().toString(36);\n}\n\nexport function teardownForTest(): Promise<void> {\n  const idbDatabasesDBName = getIDBDatabasesDBName();\n  testNamespace = '';\n  return dropIDBStoreWithMemFallback(idbDatabasesDBName);\n}\n\nexport function getIDBDatabasesDBName(): string {\n  return testNamespace + IDB_DATABASES_DB_NAME;\n}\n"],"mappings":";;AAIA,IAAM,wBAAwB;AAE9B,IAAI,gBAAgB;AAapB,SAAgB,wBAAgC;CAC9C,OAAO,gBAAgB;AACzB"}
+{"version":3,"file":"idb-databases-store-db-name.js","names":[],"sources":["../../../../../replicache/src/persist/idb-databases-store-db-name.ts"],"sourcesContent":["import {randomUint64} from '../../../shared/src/random-uint64.ts';\nimport {dropIDBStore} from '../kv/idb-store.ts';\n\nconst IDB_DATABASES_VERSION = 0;\nconst IDB_DATABASES_DB_NAME = 'replicache-dbs-v' + IDB_DATABASES_VERSION;\n\nlet testNamespace = '';\n\n/** Namespace db name in test to isolate tests' indexeddb state. */\nexport function setupForTest(): void {\n  testNamespace = randomUint64().toString(36);\n}\n\nexport function teardownForTest(): Promise<void> {\n  const idbDatabasesDBName = getIDBDatabasesDBName();\n  testNamespace = '';\n  return dropIDBStore(idbDatabasesDBName);\n}\n\nexport function getIDBDatabasesDBName(): string {\n  return testNamespace + IDB_DATABASES_DB_NAME;\n}\n"],"mappings":";;AAIA,IAAM,wBAAwB;AAE9B,IAAI,gBAAgB;AAapB,SAAgB,wBAAgC;CAC9C,OAAO,gBAAgB;AACzB"}

package/out/replicache/src/persist/persist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"persist.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/persist.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAGtD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAO,KAAK,EAAQ,MAAM,iBAAiB,CAAC;AAexD,OAAO,KAAK,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAEhE,OAAO,KAAK,EAAC,UAAU,EAAa,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAgB,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAC5D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAgB7C,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,WAAW,CAC/B,EAAE,EAAE,UAAU,EACd,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,KAAK,EACb,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE,MAAM,OAAO,EACrB,aAAa,EAAE,aAAa,EAC5B,WAAW,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,SAAS,EAChD,4BAA4B,sBAA0B,GACrD,OAAO,CAAC,IAAI,CAAC,CA2Lf"}
+{"version":3,"file":"persist.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/persist.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAGtD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAO,KAAK,EAAQ,MAAM,iBAAiB,CAAC;AAexD,OAAO,KAAK,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAEhE,OAAO,KAAK,EAAC,UAAU,EAAa,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAgB,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAC5D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAgB7C,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,WAAW,CAC/B,EAAE,EAAE,UAAU,EACd,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,KAAK,EACb,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE,MAAM,OAAO,EACrB,aAAa,EAAE,aAAa,EAC5B,WAAW,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,SAAS,EAChD,4BAA4B,sBAA0B,GACrD,OAAO,CAAC,IAAI,CAAC,CAwNf"}

package/out/replicache/src/persist/persist.js

@@ -1,10 +1,10 @@
 import { assert } from "../../../shared/src/asserts.js";
+import { getOrInsert, getOrInsertComputed } from "../../../shared/src/map.js";
 import { DEFAULT_HEAD_NAME, assertSnapshotCommitDD31, baseSnapshotFromCommit, commitFromHash, commitFromHead, compareCookiesForSnapshots, localMutationsDD31, localMutationsGreaterThan } from "../db/commit.js";
 import { withRead, withWrite } from "../with-transactions.js";
 import { getClientGroup, setClientGroup } from "./client-groups.js";
 import { assertClientV6, assertHasClientState, getClientGroupIDForClient, mustGetClient, setClient } from "./clients.js";
 import { rebaseMutationAndPutCommit } from "../db/rebase.js";
-import { getOrInsert, getOrInsertComputed } from "../../../shared/src/map.js";
 import { GatherMemoryOnlyVisitor } from "./gather-mem-only-visitor.js";
 //#region ../replicache/src/persist/persist.ts
 /**
@@ -42,28 +42,31 @@ async function persistDD31(lc, clientID, memdag, perdag, mutators, closed, forma
 		];
 	});
 	if (closed()) return;
-	const [newMemdagMutations, memdagBaseSnapshot, gatheredChunks] = await withRead(memdag, async (memdagRead) => {
+	const [newMemdagMutations, memdagBaseSnapshot, gatheredChunks, zeroDataForBaseSnapshot] = await withRead(memdag, async (memdagRead) => {
 		const memdagHeadCommit = await commitFromHead(DEFAULT_HEAD_NAME, memdagRead);
 		const newMutations = await localMutationsGreaterThan(memdagHeadCommit, { [clientID]: perdagLMID || 0 }, memdagRead);
 		const memdagBaseSnapshot = await baseSnapshotFromCommit(memdagHeadCommit, memdagRead);
 		assertSnapshotCommitDD31(memdagBaseSnapshot);
 		let gatheredChunks;
+		let zeroData;
 		if (compareCookiesForSnapshots(memdagBaseSnapshot, perdagBaseSnapshot) > 0) {
 			await onGatherMemOnlyChunksForTest();
 			const memdagBaseSnapshotHash = memdagBaseSnapshot.chunk.hash;
 			const visitor = new GatherMemoryOnlyVisitor(memdagRead);
 			await visitor.visit(memdagBaseSnapshotHash);
 			gatheredChunks = visitor.gatheredChunks;
+			zeroData = getZeroData && await getZeroData(memdagBaseSnapshotHash, { openLazyRead: memdagRead });
 		}
 		return [
 			newMutations,
 			memdagBaseSnapshot,
-			gatheredChunks
+			gatheredChunks,
+			zeroData
 		];
 	});
 	if (closed()) return;
 	let memdagBaseSnapshotPersisted = false;
-	const zeroDataForMemdagBaseSnapshot = getZeroData && await getZeroData(memdagBaseSnapshot.chunk.hash);
+	let zeroDataForRebase = zeroDataForBaseSnapshot;
 	await withWrite(perdag, async (perdagWrite) => {
 		const [mainClientGroup, latestPerdagMainClientGroupHeadCommit] = await getClientGroupInfo(perdagWrite, mainClientGroupID);
 		let newMainClientGroupHeadHash = latestPerdagMainClientGroupHeadCommit.chunk.hash;
@@ -85,12 +88,14 @@ async function persistDD31(lc, clientID, memdag, perdag, mutators, closed, forma
 				const mainClientGroupLocalMutations = await localMutationsDD31(mainClientGroup.headHash, perdagWrite);
 				lastServerAckdMutationIDs = memdagBaseSnapshot.meta.lastMutationIDs;
 				mutationIDs = { ...lastServerAckdMutationIDs };
-				newMainClientGroupHeadHash = await rebase(mainClientGroupLocalMutations, newMainClientGroupHeadHash, perdagWrite, mutators, mutationIDs, lc, formatVersion, zeroDataForMemdagBaseSnapshot);
+				const rebased = await rebase(mainClientGroupLocalMutations, newMainClientGroupHeadHash, perdagWrite, mutators, mutationIDs, lc, formatVersion, zeroDataForRebase);
+				newMainClientGroupHeadHash = rebased.hash;
+				zeroDataForRebase = rebased.zeroData;
 			}
 		}
 		let zeroDataForPerdagHeadCommit;
 		if (!memdagBaseSnapshotPersisted) zeroDataForPerdagHeadCommit = getZeroData && await getZeroData(newMainClientGroupHeadHash, { openLazySourceRead: perdagWrite });
-		newMainClientGroupHeadHash = await rebase(newMemdagMutations, newMainClientGroupHeadHash, perdagWrite, mutators, mutationIDs, lc, formatVersion, zeroDataForPerdagHeadCommit ?? zeroDataForMemdagBaseSnapshot);
+		newMainClientGroupHeadHash = (await rebase(newMemdagMutations, newMainClientGroupHeadHash, perdagWrite, mutators, mutationIDs, lc, formatVersion, zeroDataForPerdagHeadCommit ?? zeroDataForRebase)).hash;
 		await setClientGroup(mainClientGroupID, {
 			...mainClientGroup,
 			headHash: newMainClientGroupHeadHash,
@@ -113,10 +118,15 @@ async function rebase(mutations, basis, write, mutators, mutationIDs, lc, format
 		const { meta } = mutationCommit;
 		if (meta.mutationID > await getBasisMutationID(basis, meta.clientID)) {
 			mutationIDs[meta.clientID] = meta.mutationID;
-			basis = (await rebaseMutationAndPutCommit(mutationCommit, write, basis, mutators, lc, meta.clientID, formatVersion, zeroData)).chunk.hash;
+			const { result, zeroData: next } = await rebaseMutationAndPutCommit(mutationCommit, write, basis, mutators, lc, meta.clientID, formatVersion, zeroData);
+			basis = result.chunk.hash;
+			zeroData = next;
 		}
 	}
-	return basis;
+	return {
+		hash: basis,
+		zeroData
+	};
 }
 //#endregion
 export { persistDD31 };

package/out/replicache/src/persist/persist.js.map

@@ -1 +1 @@
-{"version":3,"file":"persist.js","names":[],"sources":["../../../../../replicache/src/persist/persist.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {getOrInsert, getOrInsertComputed} from '../../../shared/src/map.ts';\nimport type {Chunk} from '../dag/chunk.ts';\nimport type {LazyStore} from '../dag/lazy-store.ts';\nimport type {Read, Store, Write} from '../dag/store.ts';\nimport type {Commit} from '../db/commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type LocalMetaDD31,\n  type Meta,\n  assertSnapshotCommitDD31,\n  baseSnapshotFromCommit,\n  commitFromHash,\n  commitFromHead,\n  compareCookiesForSnapshots,\n  localMutationsDD31,\n  localMutationsGreaterThan,\n} from '../db/commit.ts';\nimport {rebaseMutationAndPutCommit} from '../db/rebase.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {Hash} from '../hash.ts';\nimport type {ZeroOption, ZeroTxData} from '../replicache-options.ts';\nimport type {ClientGroupID, ClientID} from '../sync/ids.ts';\nimport type {MutatorDefs} from '../types.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {\n  type ClientGroup,\n  getClientGroup,\n  setClientGroup,\n} from './client-groups.ts';\nimport {\n  assertClientV6,\n  assertHasClientState,\n  getClientGroupIDForClient,\n  mustGetClient,\n  setClient,\n} from './clients.ts';\nimport {GatherMemoryOnlyVisitor} from './gather-mem-only-visitor.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\n/**\n * Persists the client's memdag state to the client's perdag client group.\n *\n * Persists the base snapshot from memdag to the client's perdag client group,\n * but only if it’s newer than the client's perdag client group’s base snapshot.\n * The base snapshot is persisted by gathering all memory-only chunks in the dag\n * subgraph rooted at the base snapshot's commit and writing them to the perdag.\n * Once the base snapshot is persisted, rebases onto this new base snapshot all\n * local commits from the client's perdag client group that are not already\n * reflected in the base snapshot.\n *\n * Whether or not the base snapshot is persisted, rebases onto the client's\n * perdag client group all memdag local commits not already in the client's\n * perdag client group's history.\n *\n * Also updates the `lastMutationIDs` and `lastServerAckdMutationIDs` properties\n * of the client's client group's entry in the `ClientGroupMap`.\n */\nexport async function persistDD31(\n  lc: LogContext,\n  clientID: ClientID,\n  memdag: LazyStore,\n  perdag: Store,\n  mutators: MutatorDefs,\n  closed: () => boolean,\n  formatVersion: FormatVersion,\n  getZeroData: ZeroOption['getTxData'] | undefined,\n  onGatherMemOnlyChunksForTest = () => Promise.resolve(),\n): Promise<void> {\n  if (closed()) {\n    return;\n  }\n\n  const [perdagLMID, perdagBaseSnapshot, mainClientGroupID] = await withRead(\n    perdag,\n    async perdagRead => {\n      await assertHasClientState(clientID, perdagRead);\n      const mainClientGroupID = await getClientGroupIDForClient(\n        clientID,\n        perdagRead,\n      );\n      assert(\n        mainClientGroupID,\n        `No main client group for clientID: ${clientID}`,\n      );\n      const [, perdagMainClientGroupHeadCommit] = await getClientGroupInfo(\n        perdagRead,\n        mainClientGroupID,\n      );\n      const perdagLMID = await perdagMainClientGroupHeadCommit.getMutationID(\n        clientID,\n        perdagRead,\n      );\n      const perdagBaseSnapshot = await baseSnapshotFromCommit(\n        perdagMainClientGroupHeadCommit,\n        perdagRead,\n      );\n      assertSnapshotCommitDD31(perdagBaseSnapshot);\n      return [perdagLMID, perdagBaseSnapshot, mainClientGroupID];\n    },\n  );\n\n  if (closed()) {\n    return;\n  }\n  const [newMemdagMutations, memdagBaseSnapshot, gatheredChunks] =\n    await withRead(memdag, async memdagRead => {\n      const memdagHeadCommit = await commitFromHead(\n        DEFAULT_HEAD_NAME,\n        memdagRead,\n      );\n      const newMutations = await localMutationsGreaterThan(\n        memdagHeadCommit,\n        {[clientID]: perdagLMID || 0},\n        memdagRead,\n      );\n      const memdagBaseSnapshot = await baseSnapshotFromCommit(\n        memdagHeadCommit,\n        memdagRead,\n      );\n      assertSnapshotCommitDD31(memdagBaseSnapshot);\n\n      let gatheredChunks: ReadonlyMap<Hash, Chunk> | undefined;\n      if (\n        compareCookiesForSnapshots(memdagBaseSnapshot, perdagBaseSnapshot) > 0\n      ) {\n        await onGatherMemOnlyChunksForTest();\n        // Might need to persist snapshot, we will have to double check\n        // after gathering the snapshot chunks from memdag\n        const memdagBaseSnapshotHash = memdagBaseSnapshot.chunk.hash;\n        // Gather all memory only chunks from base snapshot on the memdag.\n        const visitor = new GatherMemoryOnlyVisitor(memdagRead);\n        await visitor.visit(memdagBaseSnapshotHash);\n        gatheredChunks = visitor.gatheredChunks;\n      }\n\n      return [newMutations, memdagBaseSnapshot, gatheredChunks];\n    });\n\n  if (closed()) {\n    return;\n  }\n\n  let memdagBaseSnapshotPersisted = false;\n  const zeroDataForMemdagBaseSnapshot =\n    getZeroData && (await getZeroData(memdagBaseSnapshot.chunk.hash));\n\n  await withWrite(perdag, async perdagWrite => {\n    const [mainClientGroup, latestPerdagMainClientGroupHeadCommit] =\n      await getClientGroupInfo(perdagWrite, mainClientGroupID);\n\n    // These initial values for newMainClientGroupHeadHash, mutationIDs,\n    // lastServerAckdMutationIDs are correct for the case where the memdag\n    // snapshot is *not* persisted.  If the memdag snapshot is persisted\n    // these values are overwritten appropriately.\n    let newMainClientGroupHeadHash: Hash =\n      latestPerdagMainClientGroupHeadCommit.chunk.hash;\n    let mutationIDs: Record<ClientID, number> = {\n      ...mainClientGroup.mutationIDs,\n    };\n    let {lastServerAckdMutationIDs} = mainClientGroup;\n\n    if (gatheredChunks) {\n      // check if memdag snapshot still newer than perdag snapshot\n\n      const client = await mustGetClient(clientID, perdagWrite);\n      assertClientV6(client);\n\n      const latestPerdagBaseSnapshot = await baseSnapshotFromCommit(\n        latestPerdagMainClientGroupHeadCommit,\n        perdagWrite,\n      );\n      assertSnapshotCommitDD31(latestPerdagBaseSnapshot);\n\n      // check if memdag snapshot still newer than perdag snapshot\n      if (\n        compareCookiesForSnapshots(\n          memdagBaseSnapshot,\n          latestPerdagBaseSnapshot,\n        ) > 0\n      ) {\n        // still newer, persist memdag snapshot by writing chunks\n        memdagBaseSnapshotPersisted = true;\n        await Promise.all(\n          Array.from(gatheredChunks.values(), c => perdagWrite.putChunk(c)),\n        );\n\n        await setClient(\n          clientID,\n          {\n            ...client,\n            persistHash: memdagBaseSnapshot.chunk.hash,\n          },\n          perdagWrite,\n        );\n        // Rebase local mutations from perdag main client group onto new\n        // snapshot\n        newMainClientGroupHeadHash = memdagBaseSnapshot.chunk.hash;\n        const mainClientGroupLocalMutations = await localMutationsDD31(\n          mainClientGroup.headHash,\n          perdagWrite,\n        );\n\n        lastServerAckdMutationIDs = memdagBaseSnapshot.meta.lastMutationIDs;\n        mutationIDs = {...lastServerAckdMutationIDs};\n\n        newMainClientGroupHeadHash = await rebase(\n          mainClientGroupLocalMutations,\n          newMainClientGroupHeadHash,\n          perdagWrite,\n          mutators,\n          mutationIDs,\n          lc,\n          formatVersion,\n          zeroDataForMemdagBaseSnapshot,\n        );\n      }\n    }\n\n    let zeroDataForPerdagHeadCommit: ZeroTxData | undefined;\n    if (!memdagBaseSnapshotPersisted) {\n      zeroDataForPerdagHeadCommit =\n        getZeroData &&\n        (await getZeroData(newMainClientGroupHeadHash, {\n          openLazySourceRead: perdagWrite,\n        }));\n    }\n\n    // rebase new memdag mutations onto perdag\n    newMainClientGroupHeadHash = await rebase(\n      newMemdagMutations,\n      newMainClientGroupHeadHash,\n      perdagWrite,\n      mutators,\n      mutationIDs,\n      lc,\n      formatVersion,\n      zeroDataForPerdagHeadCommit ?? zeroDataForMemdagBaseSnapshot,\n    );\n\n    const newMainClientGroup = {\n      ...mainClientGroup,\n      headHash: newMainClientGroupHeadHash,\n      mutationIDs,\n      lastServerAckdMutationIDs,\n    };\n\n    await setClientGroup(mainClientGroupID, newMainClientGroup, perdagWrite);\n  });\n\n  if (gatheredChunks && memdagBaseSnapshotPersisted) {\n    await withWrite(memdag, memdagWrite =>\n      memdagWrite.chunksPersisted([...gatheredChunks.keys()]),\n    );\n  }\n}\n\nasync function getClientGroupInfo(\n  perdagRead: Read,\n  clientGroupID: ClientGroupID,\n): Promise<[ClientGroup, Commit<Meta>]> {\n  const clientGroup = await getClientGroup(clientGroupID, perdagRead);\n  assert(clientGroup, `No client group for clientGroupID: ${clientGroupID}`);\n  return [clientGroup, await commitFromHash(clientGroup.headHash, perdagRead)];\n}\n\nasync function rebase(\n  mutations: Commit<LocalMetaDD31>[],\n  basis: Hash,\n  write: Write,\n  mutators: MutatorDefs,\n  mutationIDs: Record<ClientID, number>,\n  lc: LogContext,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<Hash> {\n  const basisMutationIDs = new Map<Hash, Map<ClientID, Promise<number>>>();\n  const getBasisMutationID = (\n    basisHash: Hash,\n    clientID: ClientID,\n  ): Promise<number> =>\n    getOrInsertComputed(\n      getOrInsert(basisMutationIDs, basisHash, new Map()),\n      clientID,\n      () =>\n        commitFromHash(basisHash, write).then(commit =>\n          commit.getMutationID(clientID, write),\n        ),\n    );\n  for (let i = mutations.length - 1; i >= 0; i--) {\n    const mutationCommit = mutations[i];\n    const {meta} = mutationCommit;\n    if (meta.mutationID > (await getBasisMutationID(basis, meta.clientID))) {\n      mutationIDs[meta.clientID] = meta.mutationID;\n      basis = (\n        await rebaseMutationAndPutCommit(\n          mutationCommit,\n          write,\n          basis,\n          mutators,\n          lc,\n          meta.clientID,\n          formatVersion,\n          zeroData,\n        )\n      ).chunk.hash;\n    }\n  }\n  return basis;\n}\n"],"mappings":"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"}
+{"version":3,"file":"persist.js","names":[],"sources":["../../../../../replicache/src/persist/persist.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {getOrInsert, getOrInsertComputed} from '../../../shared/src/map.ts';\nimport type {Chunk} from '../dag/chunk.ts';\nimport type {LazyStore} from '../dag/lazy-store.ts';\nimport type {Read, Store, Write} from '../dag/store.ts';\nimport type {Commit} from '../db/commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type LocalMetaDD31,\n  type Meta,\n  assertSnapshotCommitDD31,\n  baseSnapshotFromCommit,\n  commitFromHash,\n  commitFromHead,\n  compareCookiesForSnapshots,\n  localMutationsDD31,\n  localMutationsGreaterThan,\n} from '../db/commit.ts';\nimport {rebaseMutationAndPutCommit} from '../db/rebase.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {Hash} from '../hash.ts';\nimport type {ZeroOption, ZeroTxData} from '../replicache-options.ts';\nimport type {ClientGroupID, ClientID} from '../sync/ids.ts';\nimport type {MutatorDefs} from '../types.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {\n  type ClientGroup,\n  getClientGroup,\n  setClientGroup,\n} from './client-groups.ts';\nimport {\n  assertClientV6,\n  assertHasClientState,\n  getClientGroupIDForClient,\n  mustGetClient,\n  setClient,\n} from './clients.ts';\nimport {GatherMemoryOnlyVisitor} from './gather-mem-only-visitor.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\n/**\n * Persists the client's memdag state to the client's perdag client group.\n *\n * Persists the base snapshot from memdag to the client's perdag client group,\n * but only if it’s newer than the client's perdag client group’s base snapshot.\n * The base snapshot is persisted by gathering all memory-only chunks in the dag\n * subgraph rooted at the base snapshot's commit and writing them to the perdag.\n * Once the base snapshot is persisted, rebases onto this new base snapshot all\n * local commits from the client's perdag client group that are not already\n * reflected in the base snapshot.\n *\n * Whether or not the base snapshot is persisted, rebases onto the client's\n * perdag client group all memdag local commits not already in the client's\n * perdag client group's history.\n *\n * Also updates the `lastMutationIDs` and `lastServerAckdMutationIDs` properties\n * of the client's client group's entry in the `ClientGroupMap`.\n */\nexport async function persistDD31(\n  lc: LogContext,\n  clientID: ClientID,\n  memdag: LazyStore,\n  perdag: Store,\n  mutators: MutatorDefs,\n  closed: () => boolean,\n  formatVersion: FormatVersion,\n  getZeroData: ZeroOption['getTxData'] | undefined,\n  onGatherMemOnlyChunksForTest = () => Promise.resolve(),\n): Promise<void> {\n  if (closed()) {\n    return;\n  }\n\n  const [perdagLMID, perdagBaseSnapshot, mainClientGroupID] = await withRead(\n    perdag,\n    async perdagRead => {\n      await assertHasClientState(clientID, perdagRead);\n      const mainClientGroupID = await getClientGroupIDForClient(\n        clientID,\n        perdagRead,\n      );\n      assert(\n        mainClientGroupID,\n        `No main client group for clientID: ${clientID}`,\n      );\n      const [, perdagMainClientGroupHeadCommit] = await getClientGroupInfo(\n        perdagRead,\n        mainClientGroupID,\n      );\n      const perdagLMID = await perdagMainClientGroupHeadCommit.getMutationID(\n        clientID,\n        perdagRead,\n      );\n      const perdagBaseSnapshot = await baseSnapshotFromCommit(\n        perdagMainClientGroupHeadCommit,\n        perdagRead,\n      );\n      assertSnapshotCommitDD31(perdagBaseSnapshot);\n      return [perdagLMID, perdagBaseSnapshot, mainClientGroupID];\n    },\n  );\n\n  if (closed()) {\n    return;\n  }\n  const [\n    newMemdagMutations,\n    memdagBaseSnapshot,\n    gatheredChunks,\n    zeroDataForBaseSnapshot,\n  ] = await withRead(memdag, async memdagRead => {\n    const memdagHeadCommit = await commitFromHead(\n      DEFAULT_HEAD_NAME,\n      memdagRead,\n    );\n    const newMutations = await localMutationsGreaterThan(\n      memdagHeadCommit,\n      {[clientID]: perdagLMID || 0},\n      memdagRead,\n    );\n    const memdagBaseSnapshot = await baseSnapshotFromCommit(\n      memdagHeadCommit,\n      memdagRead,\n    );\n    assertSnapshotCommitDD31(memdagBaseSnapshot);\n\n    let gatheredChunks: ReadonlyMap<Hash, Chunk> | undefined;\n    let zeroData: ZeroTxData | undefined;\n    if (\n      compareCookiesForSnapshots(memdagBaseSnapshot, perdagBaseSnapshot) > 0\n    ) {\n      await onGatherMemOnlyChunksForTest();\n      // Might need to persist snapshot, we will have to double check\n      // after gathering the snapshot chunks from memdag\n      const memdagBaseSnapshotHash = memdagBaseSnapshot.chunk.hash;\n      // Gather all memory only chunks from base snapshot on the memdag.\n      const visitor = new GatherMemoryOnlyVisitor(memdagRead);\n      await visitor.visit(memdagBaseSnapshotHash);\n      gatheredChunks = visitor.gatheredChunks;\n\n      // Fork Zero's IVM state to the base snapshot while this read is still\n      // held. The fork is a diff from the IVM's current head (the memdag main\n      // head) to the base snapshot, and both are memdag chunks that a\n      // concurrent poke is free to collect the moment this read is released:\n      // moving the main head drops the superseded local commits, and a\n      // snapshot commit carries no ref to its basis. Taking the fork under\n      // the same lock that fixed `memdagBaseSnapshot` is what keeps the\n      // diff's endpoints alive; taken afterwards it raced every poke, and\n      // lost as `ChunkNotFoundError` out of persist. It is only needed when\n      // the snapshot may be persisted; otherwise the perdag rebase below\n      // forks to the perdag head instead.\n      zeroData =\n        getZeroData &&\n        (await getZeroData(memdagBaseSnapshotHash, {\n          openLazyRead: memdagRead,\n        }));\n    }\n\n    return [newMutations, memdagBaseSnapshot, gatheredChunks, zeroData];\n  });\n\n  if (closed()) {\n    return;\n  }\n\n  let memdagBaseSnapshotPersisted = false;\n  // Carried across both rebase batches below: each batch continues from the\n  // branch the previous one ended on.\n  let zeroDataForRebase = zeroDataForBaseSnapshot;\n\n  await withWrite(perdag, async perdagWrite => {\n    const [mainClientGroup, latestPerdagMainClientGroupHeadCommit] =\n      await getClientGroupInfo(perdagWrite, mainClientGroupID);\n\n    // These initial values for newMainClientGroupHeadHash, mutationIDs,\n    // lastServerAckdMutationIDs are correct for the case where the memdag\n    // snapshot is *not* persisted.  If the memdag snapshot is persisted\n    // these values are overwritten appropriately.\n    let newMainClientGroupHeadHash: Hash =\n      latestPerdagMainClientGroupHeadCommit.chunk.hash;\n    let mutationIDs: Record<ClientID, number> = {\n      ...mainClientGroup.mutationIDs,\n    };\n    let {lastServerAckdMutationIDs} = mainClientGroup;\n\n    if (gatheredChunks) {\n      // check if memdag snapshot still newer than perdag snapshot\n\n      const client = await mustGetClient(clientID, perdagWrite);\n      assertClientV6(client);\n\n      const latestPerdagBaseSnapshot = await baseSnapshotFromCommit(\n        latestPerdagMainClientGroupHeadCommit,\n        perdagWrite,\n      );\n      assertSnapshotCommitDD31(latestPerdagBaseSnapshot);\n\n      // check if memdag snapshot still newer than perdag snapshot\n      if (\n        compareCookiesForSnapshots(\n          memdagBaseSnapshot,\n          latestPerdagBaseSnapshot,\n        ) > 0\n      ) {\n        // still newer, persist memdag snapshot by writing chunks\n        memdagBaseSnapshotPersisted = true;\n        await Promise.all(\n          Array.from(gatheredChunks.values(), c => perdagWrite.putChunk(c)),\n        );\n\n        await setClient(\n          clientID,\n          {\n            ...client,\n            persistHash: memdagBaseSnapshot.chunk.hash,\n          },\n          perdagWrite,\n        );\n        // Rebase local mutations from perdag main client group onto new\n        // snapshot\n        newMainClientGroupHeadHash = memdagBaseSnapshot.chunk.hash;\n        const mainClientGroupLocalMutations = await localMutationsDD31(\n          mainClientGroup.headHash,\n          perdagWrite,\n        );\n\n        lastServerAckdMutationIDs = memdagBaseSnapshot.meta.lastMutationIDs;\n        mutationIDs = {...lastServerAckdMutationIDs};\n\n        const rebased = await rebase(\n          mainClientGroupLocalMutations,\n          newMainClientGroupHeadHash,\n          perdagWrite,\n          mutators,\n          mutationIDs,\n          lc,\n          formatVersion,\n          zeroDataForRebase,\n        );\n        newMainClientGroupHeadHash = rebased.hash;\n        // The mutations rebased below run after these, so they have to see\n        // what these wrote.\n        zeroDataForRebase = rebased.zeroData;\n      }\n    }\n\n    let zeroDataForPerdagHeadCommit: ZeroTxData | undefined;\n    if (!memdagBaseSnapshotPersisted) {\n      zeroDataForPerdagHeadCommit =\n        getZeroData &&\n        (await getZeroData(newMainClientGroupHeadHash, {\n          openLazySourceRead: perdagWrite,\n        }));\n    }\n\n    // rebase new memdag mutations onto perdag\n    newMainClientGroupHeadHash = (\n      await rebase(\n        newMemdagMutations,\n        newMainClientGroupHeadHash,\n        perdagWrite,\n        mutators,\n        mutationIDs,\n        lc,\n        formatVersion,\n        zeroDataForPerdagHeadCommit ?? zeroDataForRebase,\n      )\n    ).hash;\n\n    const newMainClientGroup = {\n      ...mainClientGroup,\n      headHash: newMainClientGroupHeadHash,\n      mutationIDs,\n      lastServerAckdMutationIDs,\n    };\n\n    await setClientGroup(mainClientGroupID, newMainClientGroup, perdagWrite);\n  });\n\n  if (gatheredChunks && memdagBaseSnapshotPersisted) {\n    await withWrite(memdag, memdagWrite =>\n      memdagWrite.chunksPersisted([...gatheredChunks.keys()]),\n    );\n  }\n}\n\nasync function getClientGroupInfo(\n  perdagRead: Read,\n  clientGroupID: ClientGroupID,\n): Promise<[ClientGroup, Commit<Meta>]> {\n  const clientGroup = await getClientGroup(clientGroupID, perdagRead);\n  assert(clientGroup, `No client group for clientGroupID: ${clientGroupID}`);\n  return [clientGroup, await commitFromHash(clientGroup.headHash, perdagRead)];\n}\n\ntype RebasedBatch = {\n  hash: Hash;\n  zeroData: ZeroTxData | undefined;\n};\n\nasync function rebase(\n  mutations: Commit<LocalMetaDD31>[],\n  basis: Hash,\n  write: Write,\n  mutators: MutatorDefs,\n  mutationIDs: Record<ClientID, number>,\n  lc: LogContext,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<RebasedBatch> {\n  const basisMutationIDs = new Map<Hash, Map<ClientID, Promise<number>>>();\n  const getBasisMutationID = (\n    basisHash: Hash,\n    clientID: ClientID,\n  ): Promise<number> =>\n    getOrInsertComputed(\n      getOrInsert(basisMutationIDs, basisHash, new Map()),\n      clientID,\n      () =>\n        commitFromHash(basisHash, write).then(commit =>\n          commit.getMutationID(clientID, write),\n        ),\n    );\n  for (let i = mutations.length - 1; i >= 0; i--) {\n    const mutationCommit = mutations[i];\n    const {meta} = mutationCommit;\n    if (meta.mutationID > (await getBasisMutationID(basis, meta.clientID))) {\n      mutationIDs[meta.clientID] = meta.mutationID;\n      const {result, zeroData: next} = await rebaseMutationAndPutCommit(\n        mutationCommit,\n        write,\n        basis,\n        mutators,\n        lc,\n        meta.clientID,\n        formatVersion,\n        zeroData,\n      );\n      basis = result.chunk.hash;\n      zeroData = next;\n    }\n  }\n  return {hash: basis, zeroData};\n}\n"],"mappings":"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"}