@rocicorp/zero 0.25.0 → 0.26.0-canary.0

package/out/replicache/src/persist/gather-not-cached-visitor.js

@@ -0,0 +1,37 @@
+import { promiseVoid } from "../../../shared/src/resolved-promises.js";
+import { getSizeOfValue } from "../../../shared/src/size-of-value.js";
+import { Visitor } from "../dag/visitor.js";
+class GatherNotCachedVisitor extends Visitor {
+  #gatheredChunks = /* @__PURE__ */ new Map();
+  #gatheredChunksTotalSize = 0;
+  #lazyStore;
+  #gatherSizeLimit;
+  #getSizeOfChunk;
+  constructor(dagRead, lazyStore, gatherSizeLimit, getSizeOfChunk = getSizeOfValue) {
+    super(dagRead);
+    this.#lazyStore = lazyStore;
+    this.#gatherSizeLimit = gatherSizeLimit;
+    this.#getSizeOfChunk = getSizeOfChunk;
+  }
+  get gatheredChunks() {
+    return this.#gatheredChunks;
+  }
+  visit(h) {
+    if (this.#gatheredChunksTotalSize >= this.#gatherSizeLimit || this.#lazyStore.isCached(h)) {
+      return promiseVoid;
+    }
+    return super.visit(h);
+  }
+  visitChunk(chunk) {
+    if (this.#gatheredChunksTotalSize < this.#gatherSizeLimit) {
+      const size = this.#getSizeOfChunk(chunk);
+      this.#gatheredChunks.set(chunk.hash, { chunk, size });
+      this.#gatheredChunksTotalSize += size;
+    }
+    return super.visitChunk(chunk);
+  }
+}
+export {
+  GatherNotCachedVisitor
+};
+//# sourceMappingURL=gather-not-cached-visitor.js.map

package/out/replicache/src/persist/gather-not-cached-visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gather-not-cached-visitor.js","sources":["../../../../../replicache/src/persist/gather-not-cached-visitor.ts"],"sourcesContent":["import {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport {getSizeOfValue} from '../../../shared/src/size-of-value.ts';\nimport type {Chunk} from '../dag/chunk.ts';\nimport type {LazyStore} from '../dag/lazy-store.ts';\nimport type {Read} from '../dag/store.ts';\nimport {Visitor} from '../dag/visitor.ts';\nimport type {Hash} from '../hash.ts';\n\nexport type ChunkWithSize = {chunk: Chunk; size: number};\n\nexport class GatherNotCachedVisitor extends Visitor {\n  readonly #gatheredChunks: Map<Hash, ChunkWithSize> = new Map();\n  #gatheredChunksTotalSize = 0;\n  readonly #lazyStore: LazyStore;\n  readonly #gatherSizeLimit: number;\n  readonly #getSizeOfChunk: (chunk: Chunk) => number;\n\n  constructor(\n    dagRead: Read,\n    lazyStore: LazyStore,\n    gatherSizeLimit: number,\n    getSizeOfChunk: (chunk: Chunk) => number = getSizeOfValue,\n  ) {\n    super(dagRead);\n    this.#lazyStore = lazyStore;\n    this.#gatherSizeLimit = gatherSizeLimit;\n    this.#getSizeOfChunk = getSizeOfChunk;\n  }\n\n  get gatheredChunks(): ReadonlyMap<Hash, ChunkWithSize> {\n    return this.#gatheredChunks;\n  }\n\n  override visit(h: Hash): Promise<void> {\n    if (\n      this.#gatheredChunksTotalSize >= this.#gatherSizeLimit ||\n      this.#lazyStore.isCached(h)\n    ) {\n      return promiseVoid;\n    }\n    return super.visit(h);\n  }\n\n  override visitChunk(chunk: Chunk): Promise<void> {\n    if (this.#gatheredChunksTotalSize < this.#gatherSizeLimit) {\n      const size = this.#getSizeOfChunk(chunk);\n      this.#gatheredChunks.set(chunk.hash, {chunk, size});\n      this.#gatheredChunksTotalSize += size;\n    }\n\n    return super.visitChunk(chunk);\n  }\n}\n"],"names":[],"mappings":";;;AAUO,MAAM,+BAA+B,QAAQ;AAAA,EACzC,sCAAgD,IAAA;AAAA,EACzD,2BAA2B;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EAET,YACE,SACA,WACA,iBACA,iBAA2C,gBAC3C;AACA,UAAM,OAAO;AACb,SAAK,aAAa;AAClB,SAAK,mBAAmB;AACxB,SAAK,kBAAkB;AAAA,EACzB;AAAA,EAEA,IAAI,iBAAmD;AACrD,WAAO,KAAK;AAAA,EACd;AAAA,EAES,MAAM,GAAwB;AACrC,QACE,KAAK,4BAA4B,KAAK,oBACtC,KAAK,WAAW,SAAS,CAAC,GAC1B;AACA,aAAO;AAAA,IACT;AACA,WAAO,MAAM,MAAM,CAAC;AAAA,EACtB;AAAA,EAES,WAAW,OAA6B;AAC/C,QAAI,KAAK,2BAA2B,KAAK,kBAAkB;AACzD,YAAM,OAAO,KAAK,gBAAgB,KAAK;AACvC,WAAK,gBAAgB,IAAI,MAAM,MAAM,EAAC,OAAO,MAAK;AAClD,WAAK,4BAA4B;AAAA,IACnC;AAEA,WAAO,MAAM,WAAW,KAAK;AAAA,EAC/B;AACF;"}

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

@@ -0,0 +1,48 @@
+import { initBgIntervalProcess } from "../bg-interval.js";
+import { withWrite } from "../with-transactions.js";
+import { ClientStateNotFoundError, getClients, setClients } from "./clients.js";
+const HEARTBEAT_INTERVAL = 60 * 1e3;
+let latestHeartbeatUpdate;
+function startHeartbeats(clientID, dagStore, onClientStateNotFound, heartbeatIntervalMs, lc, signal) {
+  initBgIntervalProcess(
+    "Heartbeat",
+    async () => {
+      latestHeartbeatUpdate = writeHeartbeat(clientID, dagStore);
+      try {
+        return await latestHeartbeatUpdate;
+      } catch (e) {
+        if (e instanceof ClientStateNotFoundError) {
+          onClientStateNotFound();
+          return;
+        }
+        throw e;
+      }
+    },
+    () => heartbeatIntervalMs,
+    lc,
+    signal
+  );
+}
+function writeHeartbeat(clientID, dagStore) {
+  return withWrite(dagStore, async (dagWrite) => {
+    const clients = await getClients(dagWrite);
+    const client = clients.get(clientID);
+    if (!client) {
+      throw new ClientStateNotFoundError(clientID);
+    }
+    const newClient = {
+      ...client,
+      heartbeatTimestampMs: Date.now()
+    };
+    const newClients = new Map(clients).set(clientID, newClient);
+    await setClients(newClients, dagWrite);
+    return newClients;
+  });
+}
+export {
+  HEARTBEAT_INTERVAL,
+  latestHeartbeatUpdate,
+  startHeartbeats,
+  writeHeartbeat
+};
+//# sourceMappingURL=heartbeat.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat.js","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"],"names":[],"mappings":";;;AAYO,MAAM,qBAAqB,KAAK;AAEhC,IAAI;AAEJ,SAAS,gBACd,UACA,UACA,uBACA,qBACA,IACA,QACM;AACN;AAAA,IACE;AAAA,IACA,YAAY;AACV,8BAAwB,eAAe,UAAU,QAAQ;AACzD,UAAI;AACF,eAAO,MAAM;AAAA,MACf,SAAS,GAAG;AACV,YAAI,aAAa,0BAA0B;AACzC,gCAAA;AACA;AAAA,QACF;AACA,cAAM;AAAA,MACR;AAAA,IACF;AAAA,IACA,MAAM;AAAA,IACN;AAAA,IACA;AAAA,EAAA;AAEJ;AAEO,SAAS,eACd,UACA,UACoB;AACpB,SAAO,UAAU,UAAU,OAAM,aAAY;AAC3C,UAAM,UAAU,MAAM,WAAW,QAAQ;AACzC,UAAM,SAAS,QAAQ,IAAI,QAAQ;AACnC,QAAI,CAAC,QAAQ;AACX,YAAM,IAAI,yBAAyB,QAAQ;AAAA,IAC7C;AAEA,UAAM,YAAY;AAAA,MAChB,GAAG;AAAA,MACH,sBAAsB,KAAK,IAAA;AAAA,IAAI;AAEjC,UAAM,aAAa,IAAI,IAAI,OAAO,EAAE,IAAI,UAAU,SAAS;AAE3D,UAAM,WAAW,YAAY,QAAQ;AACrC,WAAO;AAAA,EACT,CAAC;AACH;"}

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

@@ -0,0 +1,14 @@
+import "../../../shared/src/resolved-promises.js";
+import "@rocicorp/resolver";
+import "../../../shared/src/config.js";
+import "@rocicorp/lock";
+const IDB_DATABASES_VERSION = 0;
+const IDB_DATABASES_DB_NAME = "replicache-dbs-v" + IDB_DATABASES_VERSION;
+let testNamespace = "";
+function getIDBDatabasesDBName() {
+  return testNamespace + IDB_DATABASES_DB_NAME;
+}
+export {
+  getIDBDatabasesDBName
+};
+//# sourceMappingURL=idb-databases-store-db-name.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"idb-databases-store-db-name.js","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"],"names":[],"mappings":";;;;AAGA,MAAM,wBAAwB;AAC9B,MAAM,wBAAwB,qBAAqB;AAEnD,IAAI,gBAAgB;AAab,SAAS,wBAAgC;AAC9C,SAAO,gBAAgB;AACzB;"}

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

@@ -1,4 +1,5 @@
 import type { CreateStore } from '../kv/store.ts';
+export declare const PROFILE_ID_KEY = "profileId";
 export type IndexedDBName = string;
 export type IndexedDBDatabase = {
     readonly name: IndexedDBName;

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

@@ -1 +1 @@
-{"version":3,"file":"idb-databases-store.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/idb-databases-store.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,WAAW,EAAc,MAAM,gBAAgB,CAAC;AAS7D,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAEnC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,EAAE,IAAI,EAAE,aAAa,GAAG,iBAAiB,CAAC;CACnD,CAAC;AA0BF,qBAAa,iBAAiB;;gBAGhB,aAAa,EAAE,WAAW;IAItC,WAAW,CAAC,EAAE,EAAE,iBAAiB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAIpE,qBAAqB,CACnB,EAAE,EAAE,iBAAiB,GACpB,OAAO,CAAC,uBAAuB,CAAC;IAgBnC,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAa9D,YAAY,IAAI,OAAO,CAAC,uBAAuB,CAAC;IAIhD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;CAYhC"}
+{"version":3,"file":"idb-databases-store.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/idb-databases-store.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,WAAW,EAAc,MAAM,gBAAgB,CAAC;AAM7D,eAAO,MAAM,cAAc,cAAc,CAAC;AAG1C,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAEnC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,EAAE,IAAI,EAAE,aAAa,GAAG,iBAAiB,CAAC;CACnD,CAAC;AA0BF,qBAAa,iBAAiB;;gBAGhB,aAAa,EAAE,WAAW;IAItC,WAAW,CAAC,EAAE,EAAE,iBAAiB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAIpE,qBAAqB,CACnB,EAAE,EAAE,iBAAiB,GACpB,OAAO,CAAC,uBAAuB,CAAC;IAgBnC,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAa9D,YAAY,IAAI,OAAO,CAAC,uBAAuB,CAAC;IAIhD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;CAwBhC"}

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

@@ -0,0 +1,103 @@
+import { assertString, assertObject, assert, assertNumber } from "../../../shared/src/asserts.js";
+import { getBrowserGlobal } from "../../../shared/src/browser-env.js";
+import { deepFreeze } from "../frozen-json.js";
+import { withWrite, withRead } from "../with-transactions.js";
+import { getIDBDatabasesDBName } from "./idb-databases-store-db-name.js";
+import { makeClientID } from "./make-client-id.js";
+const DBS_KEY = "dbs";
+const PROFILE_ID_KEY = "profileId";
+function assertIndexedDBDatabaseRecord(value) {
+  assertObject(value);
+  for (const [name, db] of Object.entries(value)) {
+    assertString(name);
+    assertIndexedDBDatabase(db);
+    assert(name === db.name);
+  }
+}
+function assertIndexedDBDatabase(value) {
+  assertObject(value);
+  assertString(value.name);
+  assertString(value.replicacheName);
+  assertNumber(value.replicacheFormatVersion);
+  assertString(value.schemaVersion);
+  if (value.lastOpenedTimestampMS !== void 0) {
+    assertNumber(value.lastOpenedTimestampMS);
+  }
+}
+class IDBDatabasesStore {
+  #kvStore;
+  constructor(createKVStore) {
+    this.#kvStore = createKVStore(getIDBDatabasesDBName());
+  }
+  putDatabase(db) {
+    return this.#putDatabase({ ...db, lastOpenedTimestampMS: Date.now() });
+  }
+  putDatabaseForTesting(db) {
+    return this.#putDatabase(db);
+  }
+  #putDatabase(db) {
+    return withWrite(this.#kvStore, async (write) => {
+      const oldDbRecord = await getDatabases(write);
+      const dbRecord = {
+        ...oldDbRecord,
+        [db.name]: db
+      };
+      await write.put(DBS_KEY, dbRecord);
+      return dbRecord;
+    });
+  }
+  clearDatabases() {
+    return withWrite(this.#kvStore, (write) => write.del(DBS_KEY));
+  }
+  deleteDatabases(names) {
+    return withWrite(this.#kvStore, async (write) => {
+      const oldDbRecord = await getDatabases(write);
+      const dbRecord = {
+        ...oldDbRecord
+      };
+      for (const name of names) {
+        delete dbRecord[name];
+      }
+      await write.put(DBS_KEY, dbRecord);
+    });
+  }
+  getDatabases() {
+    return withRead(this.#kvStore, getDatabases);
+  }
+  close() {
+    return this.#kvStore.close();
+  }
+  getProfileID() {
+    return withWrite(this.#kvStore, async (write) => {
+      let profileId = await write.get(PROFILE_ID_KEY);
+      if (profileId === void 0) {
+        const maybeLocalStorage = getBrowserGlobal("localStorage");
+        if (maybeLocalStorage) {
+          profileId = maybeLocalStorage.getItem(PROFILE_ID_KEY) ?? void 0;
+        }
+        if (profileId === void 0) {
+          profileId = `p${makeClientID()}`;
+        }
+        await write.put(PROFILE_ID_KEY, profileId);
+        if (maybeLocalStorage) {
+          maybeLocalStorage.setItem(PROFILE_ID_KEY, profileId);
+        }
+      }
+      assertString(profileId);
+      return profileId;
+    });
+  }
+}
+async function getDatabases(read) {
+  let dbRecord = await read.get(DBS_KEY);
+  if (!dbRecord) {
+    dbRecord = deepFreeze({});
+  }
+  assertIndexedDBDatabaseRecord(dbRecord);
+  return dbRecord;
+}
+export {
+  IDBDatabasesStore,
+  PROFILE_ID_KEY
+};
+//# sourceMappingURL=idb-databases-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"idb-databases-store.js","sources":["../../../../../replicache/src/persist/idb-databases-store.ts"],"sourcesContent":["import {\n  assert,\n  assertNumber,\n  assertObject,\n  assertString,\n} from '../../../shared/src/asserts.ts';\nimport {getBrowserGlobal} from '../../../shared/src/browser-env.ts';\nimport {deepFreeze} from '../frozen-json.ts';\nimport type {CreateStore, Read, Store} from '../kv/store.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {getIDBDatabasesDBName} from './idb-databases-store-db-name.ts';\nimport {makeClientID} from './make-client-id.ts';\n\nconst DBS_KEY = 'dbs';\nexport const PROFILE_ID_KEY = 'profileId';\n\n// TODO: make an opaque type\nexport type IndexedDBName = string;\n\nexport type IndexedDBDatabase = {\n  readonly name: IndexedDBName;\n  readonly replicacheName: string;\n  readonly replicacheFormatVersion: number;\n  readonly schemaVersion: string;\n  readonly lastOpenedTimestampMS?: number;\n};\n\nexport type IndexedDBDatabaseRecord = {\n  readonly [name: IndexedDBName]: IndexedDBDatabase;\n};\n\nfunction assertIndexedDBDatabaseRecord(\n  value: unknown,\n): asserts value is IndexedDBDatabaseRecord {\n  assertObject(value);\n  for (const [name, db] of Object.entries(value)) {\n    assertString(name);\n    assertIndexedDBDatabase(db);\n    assert(name === db.name);\n  }\n}\n\nfunction assertIndexedDBDatabase(\n  value: unknown,\n): asserts value is IndexedDBDatabase {\n  assertObject(value);\n  assertString(value.name);\n  assertString(value.replicacheName);\n  assertNumber(value.replicacheFormatVersion);\n  assertString(value.schemaVersion);\n  if (value.lastOpenedTimestampMS !== undefined) {\n    assertNumber(value.lastOpenedTimestampMS);\n  }\n}\n\nexport class IDBDatabasesStore {\n  readonly #kvStore: Store;\n\n  constructor(createKVStore: CreateStore) {\n    this.#kvStore = createKVStore(getIDBDatabasesDBName());\n  }\n\n  putDatabase(db: IndexedDBDatabase): Promise<IndexedDBDatabaseRecord> {\n    return this.#putDatabase({...db, lastOpenedTimestampMS: Date.now()});\n  }\n\n  putDatabaseForTesting(\n    db: IndexedDBDatabase,\n  ): Promise<IndexedDBDatabaseRecord> {\n    return this.#putDatabase(db);\n  }\n\n  #putDatabase(db: IndexedDBDatabase): Promise<IndexedDBDatabaseRecord> {\n    return withWrite(this.#kvStore, async write => {\n      const oldDbRecord = await getDatabases(write);\n      const dbRecord = {\n        ...oldDbRecord,\n        [db.name]: db,\n      };\n      await write.put(DBS_KEY, dbRecord);\n      return dbRecord;\n    });\n  }\n\n  clearDatabases(): Promise<void> {\n    return withWrite(this.#kvStore, write => write.del(DBS_KEY));\n  }\n\n  deleteDatabases(names: Iterable<IndexedDBName>): Promise<void> {\n    return withWrite(this.#kvStore, async write => {\n      const oldDbRecord = await getDatabases(write);\n      const dbRecord = {\n        ...oldDbRecord,\n      };\n      for (const name of names) {\n        delete dbRecord[name];\n      }\n      await write.put(DBS_KEY, dbRecord);\n    });\n  }\n\n  getDatabases(): Promise<IndexedDBDatabaseRecord> {\n    return withRead(this.#kvStore, getDatabases);\n  }\n\n  close(): Promise<void> {\n    return this.#kvStore.close();\n  }\n\n  getProfileID(): Promise<string> {\n    return withWrite(this.#kvStore, async write => {\n      let profileId = await write.get(PROFILE_ID_KEY);\n      if (profileId === undefined) {\n        // Not in the kv store. Try localStorage in case we are using a non persistent kv store.\n        const maybeLocalStorage = getBrowserGlobal('localStorage');\n        if (maybeLocalStorage) {\n          profileId = maybeLocalStorage.getItem(PROFILE_ID_KEY) ?? undefined;\n        }\n\n        if (profileId === undefined) {\n          // Profile id is 'p' followed by a random number.\n          profileId = `p${makeClientID()}`;\n        }\n\n        await write.put(PROFILE_ID_KEY, profileId);\n        if (maybeLocalStorage) {\n          maybeLocalStorage.setItem(PROFILE_ID_KEY, profileId);\n        }\n      }\n      assertString(profileId);\n      return profileId;\n    });\n  }\n}\n\nasync function getDatabases(read: Read): Promise<IndexedDBDatabaseRecord> {\n  let dbRecord = await read.get(DBS_KEY);\n  if (!dbRecord) {\n    dbRecord = deepFreeze({});\n  }\n  assertIndexedDBDatabaseRecord(dbRecord);\n  return dbRecord;\n}\n"],"names":[],"mappings":";;;;;;AAaA,MAAM,UAAU;AACT,MAAM,iBAAiB;AAiB9B,SAAS,8BACP,OAC0C;AAC1C,eAAa,KAAK;AAClB,aAAW,CAAC,MAAM,EAAE,KAAK,OAAO,QAAQ,KAAK,GAAG;AAC9C,iBAAa,IAAI;AACjB,4BAAwB,EAAE;AAC1B,WAAO,SAAS,GAAG,IAAI;AAAA,EACzB;AACF;AAEA,SAAS,wBACP,OACoC;AACpC,eAAa,KAAK;AAClB,eAAa,MAAM,IAAI;AACvB,eAAa,MAAM,cAAc;AACjC,eAAa,MAAM,uBAAuB;AAC1C,eAAa,MAAM,aAAa;AAChC,MAAI,MAAM,0BAA0B,QAAW;AAC7C,iBAAa,MAAM,qBAAqB;AAAA,EAC1C;AACF;AAEO,MAAM,kBAAkB;AAAA,EACpB;AAAA,EAET,YAAY,eAA4B;AACtC,SAAK,WAAW,cAAc,uBAAuB;AAAA,EACvD;AAAA,EAEA,YAAY,IAAyD;AACnE,WAAO,KAAK,aAAa,EAAC,GAAG,IAAI,uBAAuB,KAAK,IAAA,GAAM;AAAA,EACrE;AAAA,EAEA,sBACE,IACkC;AAClC,WAAO,KAAK,aAAa,EAAE;AAAA,EAC7B;AAAA,EAEA,aAAa,IAAyD;AACpE,WAAO,UAAU,KAAK,UAAU,OAAM,UAAS;AAC7C,YAAM,cAAc,MAAM,aAAa,KAAK;AAC5C,YAAM,WAAW;AAAA,QACf,GAAG;AAAA,QACH,CAAC,GAAG,IAAI,GAAG;AAAA,MAAA;AAEb,YAAM,MAAM,IAAI,SAAS,QAAQ;AACjC,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,iBAAgC;AAC9B,WAAO,UAAU,KAAK,UAAU,WAAS,MAAM,IAAI,OAAO,CAAC;AAAA,EAC7D;AAAA,EAEA,gBAAgB,OAA+C;AAC7D,WAAO,UAAU,KAAK,UAAU,OAAM,UAAS;AAC7C,YAAM,cAAc,MAAM,aAAa,KAAK;AAC5C,YAAM,WAAW;AAAA,QACf,GAAG;AAAA,MAAA;AAEL,iBAAW,QAAQ,OAAO;AACxB,eAAO,SAAS,IAAI;AAAA,MACtB;AACA,YAAM,MAAM,IAAI,SAAS,QAAQ;AAAA,IACnC,CAAC;AAAA,EACH;AAAA,EAEA,eAAiD;AAC/C,WAAO,SAAS,KAAK,UAAU,YAAY;AAAA,EAC7C;AAAA,EAEA,QAAuB;AACrB,WAAO,KAAK,SAAS,MAAA;AAAA,EACvB;AAAA,EAEA,eAAgC;AAC9B,WAAO,UAAU,KAAK,UAAU,OAAM,UAAS;AAC7C,UAAI,YAAY,MAAM,MAAM,IAAI,cAAc;AAC9C,UAAI,cAAc,QAAW;AAE3B,cAAM,oBAAoB,iBAAiB,cAAc;AACzD,YAAI,mBAAmB;AACrB,sBAAY,kBAAkB,QAAQ,cAAc,KAAK;AAAA,QAC3D;AAEA,YAAI,cAAc,QAAW;AAE3B,sBAAY,IAAI,cAAc;AAAA,QAChC;AAEA,cAAM,MAAM,IAAI,gBAAgB,SAAS;AACzC,YAAI,mBAAmB;AACrB,4BAAkB,QAAQ,gBAAgB,SAAS;AAAA,QACrD;AAAA,MACF;AACA,mBAAa,SAAS;AACtB,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AACF;AAEA,eAAe,aAAa,MAA8C;AACxE,MAAI,WAAW,MAAM,KAAK,IAAI,OAAO;AACrC,MAAI,CAAC,UAAU;AACb,eAAW,WAAW,EAAE;AAAA,EAC1B;AACA,gCAA8B,QAAQ;AACtC,SAAO;AACT;"}

package/out/replicache/src/persist/make-client-id.js

@@ -0,0 +1,12 @@
+import { randomUint64 } from "../../../shared/src/random-uint64.js";
+function makeClientID() {
+  const length = 18;
+  const high = randomUint64();
+  const low = randomUint64();
+  const combined = high << 64n | low;
+  return combined.toString(32).slice(-length).padStart(length, "0");
+}
+export {
+  makeClientID
+};
+//# sourceMappingURL=make-client-id.js.map

package/out/replicache/src/persist/make-client-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-client-id.js","sources":["../../../../../replicache/src/persist/make-client-id.ts"],"sourcesContent":["import {randomUint64} from '../../../shared/src/random-uint64.ts';\n\n/**\n * Returns a random 18 character string encoded in base32 suitable as a client\n * ID.\n */\nexport function makeClientID(): string {\n  const length = 18;\n  const high = randomUint64();\n  const low = randomUint64();\n  const combined = (high << 64n) | low;\n  return combined.toString(32).slice(-length).padStart(length, '0');\n}\n"],"names":[],"mappings":";AAMO,SAAS,eAAuB;AACrC,QAAM,SAAS;AACf,QAAM,OAAO,aAAA;AACb,QAAM,MAAM,aAAA;AACZ,QAAM,WAAY,QAAQ,MAAO;AACjC,SAAO,SAAS,SAAS,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,QAAQ,GAAG;AAClE;"}

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

@@ -2,10 +2,10 @@ import type { LogContext } from '@rocicorp/logger';
 import type { Enum } from '../../../shared/src/enum.ts';
 import type { LazyStore } from '../dag/lazy-store.ts';
 import type { Store } from '../dag/store.ts';
-import * as FormatVersion from '../format-version-enum.ts';
+import type * as FormatVersion from '../format-version-enum.ts';
+import type { ZeroOption } from '../replicache-options.ts';
 import type { ClientID } from '../sync/ids.ts';
 import type { MutatorDefs } from '../types.ts';
-import type { ZeroOption } from '../replicache-options.ts';
 type FormatVersion = Enum<typeof FormatVersion>;
 /**
  * Persists the client's memdag state to the client's perdag client group.

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;AAEtD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAO,KAAK,EAAQ,MAAM,iBAAiB,CAAC;AAexD,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,KAAK,EAAgB,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAC5D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAe7C,OAAO,KAAK,EAAC,UAAU,EAAa,MAAM,0BAA0B,CAAC;AAErE,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;AAEtD,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"}

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

@@ -0,0 +1,183 @@
+import { assert } from "../../../shared/src/asserts.js";
+import { baseSnapshotFromCommit, assertSnapshotCommitDD31, commitFromHead, localMutationsGreaterThan, compareCookiesForSnapshots, localMutationsDD31, commitFromHash, DEFAULT_HEAD_NAME } from "../db/commit.js";
+import { rebaseMutationAndPutCommit } from "../db/rebase.js";
+import { withRead, withWrite } from "../with-transactions.js";
+import { setClientGroup, getClientGroup } from "./client-groups.js";
+import { assertHasClientState, getClientGroupIDForClient, mustGetClient, assertClientV6, setClient } from "./clients.js";
+import { GatherMemoryOnlyVisitor } from "./gather-mem-only-visitor.js";
+async function persistDD31(lc, clientID, memdag, perdag, mutators, closed, formatVersion, getZeroData, onGatherMemOnlyChunksForTest = () => Promise.resolve()) {
+  if (closed()) {
+    return;
+  }
+  const [perdagLMID, perdagBaseSnapshot, mainClientGroupID] = await withRead(
+    perdag,
+    async (perdagRead) => {
+      await assertHasClientState(clientID, perdagRead);
+      const mainClientGroupID2 = await getClientGroupIDForClient(
+        clientID,
+        perdagRead
+      );
+      assert(
+        mainClientGroupID2,
+        `No main client group for clientID: ${clientID}`
+      );
+      const [, perdagMainClientGroupHeadCommit] = await getClientGroupInfo(
+        perdagRead,
+        mainClientGroupID2
+      );
+      const perdagLMID2 = await perdagMainClientGroupHeadCommit.getMutationID(
+        clientID,
+        perdagRead
+      );
+      const perdagBaseSnapshot2 = await baseSnapshotFromCommit(
+        perdagMainClientGroupHeadCommit,
+        perdagRead
+      );
+      assertSnapshotCommitDD31(perdagBaseSnapshot2);
+      return [perdagLMID2, perdagBaseSnapshot2, mainClientGroupID2];
+    }
+  );
+  if (closed()) {
+    return;
+  }
+  const [newMemdagMutations, memdagBaseSnapshot, gatheredChunks] = await withRead(memdag, async (memdagRead) => {
+    const memdagHeadCommit = await commitFromHead(
+      DEFAULT_HEAD_NAME,
+      memdagRead
+    );
+    const newMutations = await localMutationsGreaterThan(
+      memdagHeadCommit,
+      { [clientID]: perdagLMID || 0 },
+      memdagRead
+    );
+    const memdagBaseSnapshot2 = await baseSnapshotFromCommit(
+      memdagHeadCommit,
+      memdagRead
+    );
+    assertSnapshotCommitDD31(memdagBaseSnapshot2);
+    let gatheredChunks2;
+    if (compareCookiesForSnapshots(memdagBaseSnapshot2, perdagBaseSnapshot) > 0) {
+      await onGatherMemOnlyChunksForTest();
+      const memdagBaseSnapshotHash = memdagBaseSnapshot2.chunk.hash;
+      const visitor = new GatherMemoryOnlyVisitor(memdagRead);
+      await visitor.visit(memdagBaseSnapshotHash);
+      gatheredChunks2 = visitor.gatheredChunks;
+    }
+    return [newMutations, memdagBaseSnapshot2, gatheredChunks2];
+  });
+  if (closed()) {
+    return;
+  }
+  let memdagBaseSnapshotPersisted = false;
+  const zeroDataForMemdagBaseSnapshot = getZeroData && await getZeroData(memdagBaseSnapshot.chunk.hash);
+  await withWrite(perdag, async (perdagWrite) => {
+    const [mainClientGroup, latestPerdagMainClientGroupHeadCommit] = await getClientGroupInfo(perdagWrite, mainClientGroupID);
+    let newMainClientGroupHeadHash = latestPerdagMainClientGroupHeadCommit.chunk.hash;
+    let mutationIDs = {
+      ...mainClientGroup.mutationIDs
+    };
+    let { lastServerAckdMutationIDs } = mainClientGroup;
+    if (gatheredChunks) {
+      const client = await mustGetClient(clientID, perdagWrite);
+      assertClientV6(client);
+      const latestPerdagBaseSnapshot = await baseSnapshotFromCommit(
+        latestPerdagMainClientGroupHeadCommit,
+        perdagWrite
+      );
+      assertSnapshotCommitDD31(latestPerdagBaseSnapshot);
+      if (compareCookiesForSnapshots(
+        memdagBaseSnapshot,
+        latestPerdagBaseSnapshot
+      ) > 0) {
+        memdagBaseSnapshotPersisted = true;
+        await Promise.all(
+          Array.from(gatheredChunks.values(), (c) => perdagWrite.putChunk(c))
+        );
+        await setClient(
+          clientID,
+          {
+            ...client,
+            persistHash: memdagBaseSnapshot.chunk.hash
+          },
+          perdagWrite
+        );
+        newMainClientGroupHeadHash = memdagBaseSnapshot.chunk.hash;
+        const mainClientGroupLocalMutations = await localMutationsDD31(
+          mainClientGroup.headHash,
+          perdagWrite
+        );
+        lastServerAckdMutationIDs = memdagBaseSnapshot.meta.lastMutationIDs;
+        mutationIDs = { ...lastServerAckdMutationIDs };
+        newMainClientGroupHeadHash = await rebase(
+          mainClientGroupLocalMutations,
+          newMainClientGroupHeadHash,
+          perdagWrite,
+          mutators,
+          mutationIDs,
+          lc,
+          formatVersion,
+          zeroDataForMemdagBaseSnapshot
+        );
+      }
+    }
+    let zeroDataForPerdagHeadCommit;
+    if (!memdagBaseSnapshotPersisted) {
+      zeroDataForPerdagHeadCommit = getZeroData && await getZeroData(newMainClientGroupHeadHash, {
+        openLazySourceRead: perdagWrite
+      });
+    }
+    newMainClientGroupHeadHash = await rebase(
+      newMemdagMutations,
+      newMainClientGroupHeadHash,
+      perdagWrite,
+      mutators,
+      mutationIDs,
+      lc,
+      formatVersion,
+      zeroDataForPerdagHeadCommit ?? zeroDataForMemdagBaseSnapshot
+    );
+    const newMainClientGroup = {
+      ...mainClientGroup,
+      headHash: newMainClientGroupHeadHash,
+      mutationIDs,
+      lastServerAckdMutationIDs
+    };
+    await setClientGroup(mainClientGroupID, newMainClientGroup, perdagWrite);
+  });
+  if (gatheredChunks && memdagBaseSnapshotPersisted) {
+    await withWrite(
+      memdag,
+      (memdagWrite) => memdagWrite.chunksPersisted([...gatheredChunks.keys()])
+    );
+  }
+}
+async function getClientGroupInfo(perdagRead, clientGroupID) {
+  const clientGroup = await getClientGroup(clientGroupID, perdagRead);
+  assert(clientGroup, `No client group for clientGroupID: ${clientGroupID}`);
+  return [clientGroup, await commitFromHash(clientGroup.headHash, perdagRead)];
+}
+async function rebase(mutations, basis, write, mutators, mutationIDs, lc, formatVersion, zeroData) {
+  for (let i = mutations.length - 1; i >= 0; i--) {
+    const mutationCommit = mutations[i];
+    const { meta } = mutationCommit;
+    const newMainHead = await commitFromHash(basis, write);
+    if (await mutationCommit.getMutationID(meta.clientID, write) > await newMainHead.getMutationID(meta.clientID, write)) {
+      mutationIDs[meta.clientID] = meta.mutationID;
+      basis = (await rebaseMutationAndPutCommit(
+        mutationCommit,
+        write,
+        basis,
+        mutators,
+        lc,
+        meta.clientID,
+        formatVersion,
+        zeroData
+      )).chunk.hash;
+    }
+  }
+  return basis;
+}
+export {
+  persistDD31
+};
+//# sourceMappingURL=persist.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"persist.js","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 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  for (let i = mutations.length - 1; i >= 0; i--) {\n    const mutationCommit = mutations[i];\n    const {meta} = mutationCommit;\n    const newMainHead = await commitFromHash(basis, write);\n    if (\n      (await mutationCommit.getMutationID(meta.clientID, write)) >\n      (await newMainHead.getMutationID(meta.clientID, write))\n    ) {\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"],"names":["mainClientGroupID","perdagLMID","perdagBaseSnapshot","memdagBaseSnapshot","gatheredChunks"],"mappings":"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"}

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

@@ -2,12 +2,13 @@ import type { LogContext } from '@rocicorp/logger';
 import type { Enum } from '../../../shared/src/enum.ts';
 import type { LazyStore } from '../dag/lazy-store.ts';
 import type { Store } from '../dag/store.ts';
-import * as FormatVersion from '../format-version-enum.ts';
+import type * as FormatVersion from '../format-version-enum.ts';
 import type { Hash } from '../hash.ts';
-import { type DiffComputationConfig, DiffsMap } from '../sync/diff.ts';
+import type { ZeroOption } from '../replicache-options.ts';
+import type { DiffsMap } from '../sync/diff.ts';
+import { type DiffComputationConfig } from '../sync/diff.ts';
 import type { ClientID } from '../sync/ids.ts';
 import type { MutatorDefs } from '../types.ts';
-import type { ZeroOption } from '../replicache-options.ts';
 type FormatVersion = Enum<typeof FormatVersion>;
 /**
  * This returns the diff between the state of the btree before and after

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

@@ -1 +1 @@
-{"version":3,"file":"refresh.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/refresh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAEtD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAe3C,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AACrC,OAAO,EACL,KAAK,qBAAqB,EAC1B,QAAQ,EAET,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAc7C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAC;AAEzD,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAkBhD;;;GAGG;AACH,wBAAsB,OAAO,CAC3B,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,KAAK,EACb,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,WAAW,EACrB,UAAU,EAAE,qBAAqB,EACjC,MAAM,EAAE,MAAM,OAAO,EACrB,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,UAAU,GAAG,SAAS,GAC3B,OAAO,CAAC;IAAC,OAAO,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAC,GAAG,SAAS,CAAC,CA8OtE"}
+{"version":3,"file":"refresh.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/refresh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAEtD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAe3C,OAAO,KAAK,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AACrC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAC,KAAK,qBAAqB,EAAc,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAe7C,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAkBhD;;;GAGG;AACH,wBAAsB,OAAO,CAC3B,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,KAAK,EACb,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,WAAW,EACrB,UAAU,EAAE,qBAAqB,EACjC,MAAM,EAAE,MAAM,OAAO,EACrB,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,UAAU,GAAG,SAAS,GAC3B,OAAO,CAAC;IAAC,OAAO,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAC,GAAG,SAAS,CAAC,CA8OtE"}