@rocicorp/zero 1.6.0-canary.0 → 1.6.0-canary.10

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

@@ -0,0 +1 @@
+{"version":3,"file":"idb-databases-store.js","names":["#kvStore","#putDatabase"],"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  /** @deprecated No longer used. Kept for backwards compatibility when reading old data. */\n  readonly lastOpenedTimestampMS?: number | undefined;\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(\n      name === db.name,\n      () => `Expected record key \"${name}\" to match db.name \"${db.name}\"`,\n    );\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);\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"],"mappings":";;;;;;;AAaA,IAAM,UAAU;AAChB,IAAa,iBAAiB;AAkB9B,SAAS,8BACP,OAC0C;CAC1C,aAAa,KAAK;CAClB,KAAK,MAAM,CAAC,MAAM,OAAO,OAAO,QAAQ,KAAK,GAAG;EAC9C,aAAa,IAAI;EACjB,wBAAwB,EAAE;EAC1B,OACE,SAAS,GAAG,YACN,wBAAwB,KAAK,sBAAsB,GAAG,KAAK,EACnE;CACF;AACF;AAEA,SAAS,wBACP,OACoC;CACpC,aAAa,KAAK;CAClB,aAAa,MAAM,IAAI;CACvB,aAAa,MAAM,cAAc;CACjC,aAAa,MAAM,uBAAuB;CAC1C,aAAa,MAAM,aAAa;CAChC,IAAI,MAAM,0BAA0B,KAAA,GAClC,aAAa,MAAM,qBAAqB;AAE5C;AAEA,IAAa,oBAAb,MAA+B;CAC7B;CAEA,YAAY,eAA4B;EACtC,KAAKA,WAAW,cAAc,sBAAsB,CAAC;CACvD;CAEA,YAAY,IAAyD;EACnE,OAAO,KAAKC,aAAa,EAAE;CAC7B;CAEA,sBACE,IACkC;EAClC,OAAO,KAAKA,aAAa,EAAE;CAC7B;CAEA,aAAa,IAAyD;EACpE,OAAO,UAAU,KAAKD,UAAU,OAAM,UAAS;GAE7C,MAAM,WAAW;IACf,GAAG,MAFqB,aAAa,KAAK;KAGzC,GAAG,OAAO;GACb;GACA,MAAM,MAAM,IAAI,SAAS,QAAQ;GACjC,OAAO;EACT,CAAC;CACH;CAEA,iBAAgC;EAC9B,OAAO,UAAU,KAAKA,WAAU,UAAS,MAAM,IAAI,OAAO,CAAC;CAC7D;CAEA,gBAAgB,OAA+C;EAC7D,OAAO,UAAU,KAAKA,UAAU,OAAM,UAAS;GAE7C,MAAM,WAAW,EACf,GAAG,MAFqB,aAAa,KAAK,EAG5C;GACA,KAAK,MAAM,QAAQ,OACjB,OAAO,SAAS;GAElB,MAAM,MAAM,IAAI,SAAS,QAAQ;EACnC,CAAC;CACH;CAEA,eAAiD;EAC/C,OAAO,SAAS,KAAKA,UAAU,YAAY;CAC7C;CAEA,QAAuB;EACrB,OAAO,KAAKA,SAAS,MAAM;CAC7B;CAEA,eAAgC;EAC9B,OAAO,UAAU,KAAKA,UAAU,OAAM,UAAS;GAC7C,IAAI,YAAY,MAAM,MAAM,IAAI,cAAc;GAC9C,IAAI,cAAc,KAAA,GAAW;IAE3B,MAAM,oBAAoB,iBAAiB,cAAc;IACzD,IAAI,mBACF,YAAY,kBAAkB,QAAA,WAAsB,KAAK,KAAA;IAG3D,IAAI,cAAc,KAAA,GAEhB,YAAY,IAAI,aAAa;IAG/B,MAAM,MAAM,IAAI,gBAAgB,SAAS;IACzC,IAAI,mBACF,kBAAkB,QAAQ,gBAAgB,SAAS;GAEvD;GACA,aAAa,SAAS;GACtB,OAAO;EACT,CAAC;CACH;AACF;AAEA,eAAe,aAAa,MAA8C;CACxE,IAAI,WAAW,MAAM,KAAK,IAAI,OAAO;CACrC,IAAI,CAAC,UACH,WAAW,WAAW,CAAC,CAAC;CAE1B,8BAA8B,QAAQ;CACtC,OAAO;AACT"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"make-client-id.js","names":[],"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"],"mappings":";;;;;;AAMA,SAAgB,eAAuB;CACrC,MAAM,SAAS;CACf,MAAM,OAAO,aAAa;CAC1B,MAAM,MAAM,aAAa;CAEzB,QADkB,QAAQ,MAAO,KACjB,SAAS,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,QAAQ,GAAG;AAClE"}

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

@@ -0,0 +1,124 @@
+import { assert } from "../../../shared/src/asserts.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
+/**
+* Persists the client's memdag state to the client's perdag client group.
+*
+* Persists the base snapshot from memdag to the client's perdag client group,
+* but only if it’s newer than the client's perdag client group’s base snapshot.
+* The base snapshot is persisted by gathering all memory-only chunks in the dag
+* subgraph rooted at the base snapshot's commit and writing them to the perdag.
+* Once the base snapshot is persisted, rebases onto this new base snapshot all
+* local commits from the client's perdag client group that are not already
+* reflected in the base snapshot.
+*
+* Whether or not the base snapshot is persisted, rebases onto the client's
+* perdag client group all memdag local commits not already in the client's
+* perdag client group's history.
+*
+* Also updates the `lastMutationIDs` and `lastServerAckdMutationIDs` properties
+* of the client's client group's entry in the `ClientGroupMap`.
+*/
+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 mainClientGroupID = await getClientGroupIDForClient(clientID, perdagRead);
+		assert(mainClientGroupID, `No main client group for clientID: ${clientID}`);
+		const [, perdagMainClientGroupHeadCommit] = await getClientGroupInfo(perdagRead, mainClientGroupID);
+		const perdagLMID = await perdagMainClientGroupHeadCommit.getMutationID(clientID, perdagRead);
+		const perdagBaseSnapshot = await baseSnapshotFromCommit(perdagMainClientGroupHeadCommit, perdagRead);
+		assertSnapshotCommitDD31(perdagBaseSnapshot);
+		return [
+			perdagLMID,
+			perdagBaseSnapshot,
+			mainClientGroupID
+		];
+	});
+	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 memdagBaseSnapshot = await baseSnapshotFromCommit(memdagHeadCommit, memdagRead);
+		assertSnapshotCommitDD31(memdagBaseSnapshot);
+		let gatheredChunks;
+		if (compareCookiesForSnapshots(memdagBaseSnapshot, perdagBaseSnapshot) > 0) {
+			await onGatherMemOnlyChunksForTest();
+			const memdagBaseSnapshotHash = memdagBaseSnapshot.chunk.hash;
+			const visitor = new GatherMemoryOnlyVisitor(memdagRead);
+			await visitor.visit(memdagBaseSnapshotHash);
+			gatheredChunks = visitor.gatheredChunks;
+		}
+		return [
+			newMutations,
+			memdagBaseSnapshot,
+			gatheredChunks
+		];
+	});
+	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);
+		await setClientGroup(mainClientGroupID, {
+			...mainClientGroup,
+			headHash: newMainClientGroupHeadHash,
+			mutationIDs,
+			lastServerAckdMutationIDs
+		}, 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) {
+	const basisMutationIDs = /* @__PURE__ */ new Map();
+	const getBasisMutationID = (basisHash, clientID) => getOrInsertComputed(getOrInsert(basisMutationIDs, basisHash, /* @__PURE__ */ new Map()), clientID, () => commitFromHash(basisHash, write).then((commit) => commit.getMutationID(clientID, write)));
+	for (let i = mutations.length - 1; i >= 0; i--) {
+		const mutationCommit = mutations[i];
+		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;
+		}
+	}
+	return basis;
+}
+//#endregion
+export { persistDD31 };
+
+//# sourceMappingURL=persist.js.map

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

@@ -0,0 +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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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"refresh.js","names":[],"sources":["../../../../../../replicache/src/persist/refresh.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {LazyStore} from '../dag/lazy-store.ts';\nimport type {Store} from '../dag/store.ts';\nimport type {Commit} from '../db/commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type SnapshotMetaDD31,\n  assertSnapshotCommitDD31,\n  baseSnapshotFromCommit,\n  baseSnapshotFromHash,\n  baseSnapshotFromHead,\n  commitFromHash,\n  commitFromHead,\n  compareCookiesForSnapshots,\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} from '../replicache-options.ts';\nimport type {DiffsMap} from '../sync/diff.ts';\nimport {type DiffComputationConfig, diffCommits} from '../sync/diff.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport type {MutatorDefs} from '../types.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {\n  ClientStateNotFoundError,\n  type ClientV6,\n  assertClientV6,\n  getClientGroupForClient,\n  mustGetClient,\n  setClient,\n} from './clients.ts';\nimport {\n  type ChunkWithSize,\n  GatherNotCachedVisitor,\n} from './gather-not-cached-visitor.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nconst GATHER_SIZE_LIMIT = 5 * 2 ** 20; // 5 MB\n\ntype RefreshResult =\n  | {\n      type: 'aborted';\n      refreshHashesForRevert?: readonly Hash[] | undefined;\n    }\n  | {\n      type: 'complete';\n      diffs: DiffsMap;\n      newPerdagClientHeadHash: Hash;\n      oldHead: Hash;\n      newHead: Hash;\n    };\n\n/**\n * This returns the diff between the state of the btree before and after\n * refresh. It returns `undefined` if the refresh was aborted.\n */\nexport async function refresh(\n  lc: LogContext,\n  memdag: LazyStore,\n  perdag: Store,\n  clientID: ClientID,\n  mutators: MutatorDefs,\n  diffConfig: DiffComputationConfig,\n  closed: () => boolean,\n  formatVersion: FormatVersion,\n  zero: ZeroOption | undefined,\n): Promise<{oldHead: Hash; newHead: Hash; diffs: DiffsMap} | undefined> {\n  if (closed()) {\n    return;\n  }\n  const memdagBaseSnapshot = await withRead(memdag, memdagRead =>\n    baseSnapshotFromHead(DEFAULT_HEAD_NAME, memdagRead),\n  );\n  assertSnapshotCommitDD31(memdagBaseSnapshot);\n\n  type PerdagWriteResult = [\n    perdagClientGroupHeadHash: Hash,\n    perdagClientGroupBaseSnapshot: Commit<SnapshotMetaDD31>,\n    perdagLmid: number,\n    gatheredChunks: ReadonlyMap<Hash, ChunkWithSize>,\n    refreshHashesForRevert: readonly Hash[],\n  ];\n\n  // Suspend eviction and deletion of chunks cached by the lazy store\n  // to prevent cache misses.  If eviction and deletion are not suspended\n  // some chunks that are not gathered due to already being cached, may be\n  // evicted or deleted by the time the write lock is acquired on the memdag,\n  // which can lead to cache misses when performing the rebase and diff.\n  // It is important to avoid these cache misses because they often create jank\n  // because they block local mutations, pulls and queries on reading from idb.\n  // Cache misses can still happen during the rebase and diff, but only\n  // if the gather step hits its size limit.\n  const result: RefreshResult =\n    await memdag.withSuspendedSourceCacheEvictsAndDeletes(async () => {\n      const perdagWriteResult: PerdagWriteResult | undefined = await withWrite(\n        perdag,\n        async perdagWrite => {\n          const clientGroup = await getClientGroupForClient(\n            clientID,\n            perdagWrite,\n          );\n          if (!clientGroup) {\n            throw new ClientStateNotFoundError(clientID);\n          }\n\n          const perdagClientGroupHeadHash = clientGroup.headHash;\n          const perdagClientGroupHeadCommit = await commitFromHash(\n            perdagClientGroupHeadHash,\n            perdagWrite,\n          );\n          const perdagLmid = await perdagClientGroupHeadCommit.getMutationID(\n            clientID,\n            perdagWrite,\n          );\n\n          // Need to pull this head into memdag, but can't have it disappear if\n          // perdag moves forward while we're rebasing in memdag. Can't change\n          // client headHash until our rebase in memdag is complete, because if\n          // rebase fails, then nothing is keeping client's chunks alive in\n          // perdag.\n          const client = await mustGetClient(clientID, perdagWrite);\n          assertClientV6(client);\n          const perdagClientGroupBaseSnapshot = await baseSnapshotFromHash(\n            perdagClientGroupHeadHash,\n            perdagWrite,\n          );\n          assertSnapshotCommitDD31(perdagClientGroupBaseSnapshot);\n          if (\n            shouldAbortRefresh(\n              memdagBaseSnapshot,\n              perdagClientGroupBaseSnapshot,\n              perdagClientGroupHeadHash,\n            )\n          ) {\n            return undefined;\n          }\n\n          // To avoid pulling the entire perdag graph into the memdag\n          // the amount of chunk data gathered is limited by size.\n          const visitor = new GatherNotCachedVisitor(\n            perdagWrite,\n            memdag,\n            GATHER_SIZE_LIMIT,\n          );\n          await visitor.visit(perdagClientGroupHeadHash);\n          const {gatheredChunks} = visitor;\n\n          const refreshHashesSet = new Set(client.refreshHashes);\n          refreshHashesSet.add(perdagClientGroupHeadHash);\n\n          const newClient: ClientV6 = {\n            ...client,\n            refreshHashes: [...refreshHashesSet],\n          };\n\n          await setClient(clientID, newClient, perdagWrite);\n          return [\n            perdagClientGroupHeadHash,\n            perdagClientGroupBaseSnapshot,\n            perdagLmid,\n            gatheredChunks,\n            client.refreshHashes,\n          ];\n        },\n      );\n\n      if (closed() || !perdagWriteResult) {\n        return {\n          type: 'aborted',\n        } as const;\n      }\n\n      const [\n        perdagClientGroupHeadHash,\n        perdagClientGroupBaseSnapshot,\n        perdagLmid,\n        gatheredChunks,\n        refreshHashesForRevert,\n      ] = perdagWriteResult;\n      return withWrite(memdag, async memdagWrite => {\n        const memdagHeadCommit = await commitFromHead(\n          DEFAULT_HEAD_NAME,\n          memdagWrite,\n        );\n        const memdagBaseSnapshot = await baseSnapshotFromCommit(\n          memdagHeadCommit,\n          memdagWrite,\n        );\n        assertSnapshotCommitDD31(memdagBaseSnapshot);\n        if (\n          shouldAbortRefresh(\n            memdagBaseSnapshot,\n            perdagClientGroupBaseSnapshot,\n            perdagClientGroupHeadHash,\n          )\n        ) {\n          return {\n            type: 'aborted',\n            refreshHashesForRevert,\n          };\n        }\n\n        const newMemdagMutations = await localMutationsGreaterThan(\n          memdagHeadCommit,\n          {[clientID]: perdagLmid},\n          memdagWrite,\n        );\n        const ps = [];\n        for (const {chunk, size} of gatheredChunks.values()) {\n          ps.push(memdagWrite.putChunk(chunk, size));\n        }\n        await Promise.all(ps);\n\n        let newMemdagHeadHash = perdagClientGroupHeadHash;\n        if (newMemdagMutations.length > 0) {\n          const zeroData = await zero?.getTxData?.(newMemdagHeadHash, {\n            openLazyRead: memdagWrite,\n          });\n          for (let i = newMemdagMutations.length - 1; i >= 0; i--) {\n            newMemdagHeadHash = (\n              await rebaseMutationAndPutCommit(\n                newMemdagMutations[i],\n                memdagWrite,\n                newMemdagHeadHash,\n                mutators,\n                lc,\n                newMemdagMutations[i].meta.clientID,\n                formatVersion,\n                zeroData,\n              )\n            ).chunk.hash;\n          }\n        }\n\n        const newMemdagHeadCommit = await commitFromHash(\n          newMemdagHeadHash,\n          memdagWrite,\n        );\n        const diffs = await diffCommits(\n          memdagHeadCommit,\n          newMemdagHeadCommit,\n          memdagWrite,\n          diffConfig,\n          formatVersion,\n        );\n\n        await memdagWrite.setHead(DEFAULT_HEAD_NAME, newMemdagHeadHash);\n        return {\n          type: 'complete',\n          diffs,\n          oldHead: memdagHeadCommit.chunk.hash,\n          newHead: newMemdagHeadHash,\n          newPerdagClientHeadHash: perdagClientGroupHeadHash,\n        } as const;\n      });\n    });\n\n  if (closed()) {\n    return;\n  }\n\n  const setRefreshHashes = (refreshHashes: readonly Hash[]) =>\n    withWrite(perdag, async perdagWrite => {\n      const client = await mustGetClient(clientID, perdagWrite);\n      const newClient = {\n        ...client,\n        refreshHashes,\n      };\n\n      // If this cleanup never happens, it's no big deal, some data will stay\n      // alive longer but next refresh will fix it.\n      await setClient(clientID, newClient, perdagWrite);\n    });\n\n  if (result.type === 'aborted') {\n    if (result.refreshHashesForRevert) {\n      await setRefreshHashes(result.refreshHashesForRevert);\n    }\n    return undefined;\n  }\n\n  // Advance zero here before setting refresh hashes\n  // since we must advance before delegating control of the microtask\n  // loop.\n  zero?.advance(result.oldHead, result.newHead, result.diffs.get('') ?? []);\n  await setRefreshHashes([result.newPerdagClientHeadHash]);\n  return {\n    oldHead: result.oldHead,\n    newHead: result.newHead,\n    diffs: result.diffs,\n  };\n}\n\nfunction shouldAbortRefresh(\n  memdagBaseSnapshot: Commit<SnapshotMetaDD31>,\n  perdagClientGroupBaseSnapshot: Commit<SnapshotMetaDD31>,\n  perdagClientGroupHeadHash: Hash,\n): boolean {\n  const baseSnapshotCookieCompareResult = compareCookiesForSnapshots(\n    memdagBaseSnapshot,\n    perdagClientGroupBaseSnapshot,\n  );\n  return (\n    baseSnapshotCookieCompareResult > 0 ||\n    (baseSnapshotCookieCompareResult === 0 &&\n      perdagClientGroupHeadHash === perdagClientGroupBaseSnapshot.chunk.hash)\n  );\n}\n"],"mappings":"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"}

package/out/packages/replicache/src/process-scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-scheduler.js","names":["#process","#idleTimeoutMs","#throttleMs","#abortSignal","#requestIdle","#runResolver","#scheduledResolver","#scheduleInternal","#runPromise","#throttlePromise"],"sources":["../../../../../replicache/src/process-scheduler.ts"],"sourcesContent":["import {type Resolver, resolver} from '@rocicorp/resolver';\nimport {AbortError} from '../../shared/src/abort-error.ts';\nimport {assert} from '../../shared/src/asserts.ts';\nimport {sleep} from '../../shared/src/sleep.ts';\nimport {requestIdle as defaultRequestIdle} from './request-idle.ts';\n\nexport class ProcessScheduler {\n  readonly #process: () => Promise<void>;\n  readonly #idleTimeoutMs: number;\n  readonly #throttleMs: number;\n  readonly #abortSignal: AbortSignal;\n  readonly #requestIdle: typeof defaultRequestIdle;\n  #scheduledResolver: Resolver<void> | undefined = undefined;\n  #runResolver: Resolver<void> | undefined = undefined;\n  #runPromise = Promise.resolve();\n  #throttlePromise = Promise.resolve();\n\n  /**\n   * Supports scheduling a `process` to be run with certain constraints.\n   *  - Process runs are never concurrent.\n   *  - Multiple calls to schedule will be fulfilled by a single process\n   *    run started after the call to schedule.  A call is never fulfilled by an\n   *    already running process run.  This can be thought of as debouncing.\n   *  - Process runs are throttled so that the process runs at most once every\n   *    `throttleMs`.\n   *  - Process runs try to run during an idle period, but will delay at most\n   *    `idleTimeoutMs`.\n   *  - Scheduled runs which have not completed when `abortSignal` is aborted\n   *    will reject with an `AbortError`.\n   */\n  constructor(\n    process: () => Promise<void>,\n    idleTimeoutMs: number,\n    throttleMs: number,\n    abortSignal: AbortSignal,\n    requestIdle = defaultRequestIdle,\n  ) {\n    this.#process = process;\n    this.#idleTimeoutMs = idleTimeoutMs;\n    this.#throttleMs = throttleMs;\n    this.#abortSignal = abortSignal;\n    this.#requestIdle = requestIdle;\n    this.#abortSignal.addEventListener(\n      'abort',\n      () => {\n        const abortError = new AbortError('Aborted');\n        this.#runResolver?.reject(abortError);\n        this.#scheduledResolver?.reject(abortError);\n        this.#runResolver = undefined;\n        this.#scheduledResolver = undefined;\n      },\n      {once: true},\n    );\n  }\n\n  /**\n   * Schedules the process to run.\n   *\n   * The returned promise resolves when the process has completed running.\n   * If the process throws an error, the returned promise rejects with that error.\n   *\n   * If `schedule()` is called multiple times while a process is running/scheduled,\n   * they will be debounced into a single run.\n   */\n  schedule(): Promise<void> {\n    if (this.#abortSignal.aborted) {\n      return Promise.reject(new AbortError('Aborted'));\n    }\n    if (this.#scheduledResolver) {\n      return this.#scheduledResolver.promise;\n    }\n    this.#scheduledResolver = resolver();\n    void this.#scheduleInternal();\n    return this.#scheduledResolver.promise;\n  }\n\n  /**\n   * Runs the process immediately, skipping throttle and idle checks.\n   *\n   * The returned promise resolves when the process has completed running.\n   * If the process throws an error, the returned promise rejects with that error.\n   *\n   * If there is a scheduled run pending (waiting for idle or throttle), this run\n   * will effectively \"take over\" that scheduled run, and the promise returned\n   * by `schedule()` will resolve when this run completes.\n   *\n   * If there is a process currently running, this run will wait for it to finish\n   * before starting, satisfying the non-concurrency constraint.\n   */\n  async run(): Promise<void> {\n    if (this.#abortSignal.aborted) {\n      return Promise.reject(new AbortError('Aborted'));\n    }\n\n    // \"Steal\" the scheduled resolver if it exists.\n    // This effectively cancels the pending scheduled run (the idle/throttle wait),\n    // and fulfills that promise with this run.\n    const resolverToResolve = this.#scheduledResolver;\n    this.#scheduledResolver = undefined;\n\n    // Wait for any currently running process to finish.\n    // We create a new promise that represents \"Wait for current, then run me\"\n    const prevRunPromise = this.#runPromise;\n\n    const runTask = async () => {\n      try {\n        await prevRunPromise;\n      } catch {\n        // ignore errors from previous run\n      }\n\n      if (this.#abortSignal.aborted) {\n        throw new AbortError('Aborted');\n      }\n\n      return this.#process();\n    };\n\n    const executionPromise = runTask();\n    this.#runPromise = executionPromise;\n\n    // Reset throttle promise so future runs respect the throttle relative to this run.\n    this.#throttlePromise = throttle(this.#throttleMs, this.#abortSignal);\n\n    try {\n      await executionPromise;\n      resolverToResolve?.resolve();\n    } catch (e) {\n      resolverToResolve?.reject(e);\n      throw e;\n    }\n  }\n\n  async #scheduleInternal(): Promise<void> {\n    try {\n      await this.#runPromise;\n      // Prevent errors thrown by process from cancelling scheduled runs.\n      // this._runPromise is also awaited below and errors are explicitly\n      // propagated to promises returned from schedule.\n    } catch {}\n    await this.#throttlePromise;\n    if (!this.#scheduledResolver) {\n      return;\n    }\n    await this.#requestIdle(this.#idleTimeoutMs);\n    if (!this.#scheduledResolver) {\n      return;\n    }\n    this.#throttlePromise = throttle(this.#throttleMs, this.#abortSignal);\n    this.#runResolver = this.#scheduledResolver;\n    this.#scheduledResolver = undefined;\n    try {\n      this.#runPromise = this.#process();\n      await this.#runPromise;\n      this.#runResolver?.resolve();\n    } catch (e) {\n      this.#runResolver?.reject(e);\n    }\n    this.#runResolver = undefined;\n  }\n}\n\nasync function throttle(\n  timeMs: number,\n  abortSignal: AbortSignal,\n): Promise<void> {\n  try {\n    await sleep(timeMs, abortSignal);\n  } catch (e) {\n    assert(\n      e instanceof AbortError,\n      'Expected caught error to be an AbortError',\n    );\n  }\n}\n"],"mappings":";;;;;;AAMA,IAAa,mBAAb,MAA8B;CAC5B;CACA;CACA;CACA;CACA;CACA,qBAAiD,KAAA;CACjD,eAA2C,KAAA;CAC3C,cAAc,QAAQ,QAAQ;CAC9B,mBAAmB,QAAQ,QAAQ;;;;;;;;;;;;;;CAenC,YACE,SACA,eACA,YACA,aACA,gBAAc,aACd;EACA,KAAKA,WAAW;EAChB,KAAKC,iBAAiB;EACtB,KAAKC,cAAc;EACnB,KAAKC,eAAe;EACpB,KAAKC,eAAe;EACpB,KAAKD,aAAa,iBAChB,eACM;GACJ,MAAM,aAAa,IAAI,WAAW,SAAS;GAC3C,KAAKE,cAAc,OAAO,UAAU;GACpC,KAAKC,oBAAoB,OAAO,UAAU;GAC1C,KAAKD,eAAe,KAAA;GACpB,KAAKC,qBAAqB,KAAA;EAC5B,GACA,EAAC,MAAM,KAAI,CACb;CACF;;;;;;;;;;CAWA,WAA0B;EACxB,IAAI,KAAKH,aAAa,SACpB,OAAO,QAAQ,OAAO,IAAI,WAAW,SAAS,CAAC;EAEjD,IAAI,KAAKG,oBACP,OAAO,KAAKA,mBAAmB;EAEjC,KAAKA,qBAAqB,SAAS;EACnC,KAAUC,kBAAkB;EAC5B,OAAO,KAAKD,mBAAmB;CACjC;;;;;;;;;;;;;;CAeA,MAAM,MAAqB;EACzB,IAAI,KAAKH,aAAa,SACpB,OAAO,QAAQ,OAAO,IAAI,WAAW,SAAS,CAAC;EAMjD,MAAM,oBAAoB,KAAKG;EAC/B,KAAKA,qBAAqB,KAAA;EAI1B,MAAM,iBAAiB,KAAKE;EAE5B,MAAM,UAAU,YAAY;GAC1B,IAAI;IACF,MAAM;GACR,QAAQ,CAER;GAEA,IAAI,KAAKL,aAAa,SACpB,MAAM,IAAI,WAAW,SAAS;GAGhC,OAAO,KAAKH,SAAS;EACvB;EAEA,MAAM,mBAAmB,QAAQ;EACjC,KAAKQ,cAAc;EAGnB,KAAKC,mBAAmB,SAAS,KAAKP,aAAa,KAAKC,YAAY;EAEpE,IAAI;GACF,MAAM;GACN,mBAAmB,QAAQ;EAC7B,SAAS,GAAG;GACV,mBAAmB,OAAO,CAAC;GAC3B,MAAM;EACR;CACF;CAEA,MAAMI,oBAAmC;EACvC,IAAI;GACF,MAAM,KAAKC;EAIb,QAAQ,CAAC;EACT,MAAM,KAAKC;EACX,IAAI,CAAC,KAAKH,oBACR;EAEF,MAAM,KAAKF,aAAa,KAAKH,cAAc;EAC3C,IAAI,CAAC,KAAKK,oBACR;EAEF,KAAKG,mBAAmB,SAAS,KAAKP,aAAa,KAAKC,YAAY;EACpE,KAAKE,eAAe,KAAKC;EACzB,KAAKA,qBAAqB,KAAA;EAC1B,IAAI;GACF,KAAKE,cAAc,KAAKR,SAAS;GACjC,MAAM,KAAKQ;GACX,KAAKH,cAAc,QAAQ;EAC7B,SAAS,GAAG;GACV,KAAKA,cAAc,OAAO,CAAC;EAC7B;EACA,KAAKA,eAAe,KAAA;CACtB;AACF;AAEA,eAAe,SACb,QACA,aACe;CACf,IAAI;EACF,MAAM,MAAM,QAAQ,WAAW;CACjC,SAAS,GAAG;EACV,OACE,aAAa,YACb,2CACF;CACF;AACF"}

package/out/packages/replicache/src/pusher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pusher.js","names":[],"sources":["../../../../../replicache/src/pusher.ts"],"sourcesContent":["import {assertObject} from '../../shared/src/asserts.ts';\nimport {\n  assertVersionNotSupportedResponse,\n  type ClientStateNotFoundResponse,\n  isClientStateNotFoundResponse,\n  type VersionNotSupportedResponse,\n} from './error-responses.ts';\nimport {\n  assertHTTPRequestInfo,\n  type HTTPRequestInfo,\n} from './http-request-info.ts';\nimport type {PushRequest} from './sync/push.ts';\n\nexport type PusherResult = {\n  response?: PushResponse | undefined;\n  httpRequestInfo: HTTPRequestInfo;\n};\n\n/**\n * The response from a push can contain information about error conditions.\n */\nexport type PushResponse =\n  | ClientStateNotFoundResponse\n  | VersionNotSupportedResponse;\n\nexport function assertPusherResult(v: unknown): asserts v is PusherResult {\n  assertObject(v);\n  assertHTTPRequestInfo(v.httpRequestInfo);\n  if (v.response !== undefined) {\n    assertPushResponse(v.response);\n  }\n}\n\nfunction assertPushResponse(v: unknown): asserts v is PushResponse {\n  if (isClientStateNotFoundResponse(v)) {\n    return;\n  }\n  assertVersionNotSupportedResponse(v);\n}\n\n/**\n * Pusher is the function type used to do the fetch part of a push. The request\n * is a POST request where the body is JSON with the type {@link PushRequest}.\n *\n * The return value should either be a {@link HTTPRequestInfo} or a\n * {@link PusherResult}. The reason for the two different return types is that\n * we didn't use to care about the response body of the push request. The\n * default pusher implementation checks if the response body is JSON and if it\n * matches the type {@link PusherResponse}. If it does, it is included in the\n * return value.\n */\nexport type Pusher = (\n  requestBody: PushRequest,\n  requestID: string,\n) => Promise<PusherResult>;\n\n/**\n * This error is thrown when the pusher fails for any reason.\n */\nexport class PushError extends Error {\n  name = 'PushError';\n  // causedBy is used instead of cause, because while cause has been proposed as a\n  // JavaScript language standard for this purpose (see\n  // https://github.com/tc39/proposal-error-cause) current browser behavior is\n  // inconsistent.\n  causedBy?: Error | undefined;\n  constructor(causedBy?: Error) {\n    super('Failed to push');\n    this.causedBy = causedBy;\n  }\n}\n"],"mappings":";;;;AAyBA,SAAgB,mBAAmB,GAAuC;CACxE,aAAa,CAAC;CACd,sBAAsB,EAAE,eAAe;CACvC,IAAI,EAAE,aAAa,KAAA,GACjB,mBAAmB,EAAE,QAAQ;AAEjC;AAEA,SAAS,mBAAmB,GAAuC;CACjE,IAAI,8BAA8B,CAAC,GACjC;CAEF,kCAAkC,CAAC;AACrC;;;;AAqBA,IAAa,YAAb,cAA+B,MAAM;CACnC,OAAO;CAKP;CACA,YAAY,UAAkB;EAC5B,MAAM,gBAAgB;EACtB,KAAK,WAAW;CAClB;AACF"}

package/out/packages/replicache/src/replicache-impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replicache-impl.js","names":["#subscriptions","#mutationRecovery","#kvStoreProvider","#zero","#auth","#idbDatabase","#clientID","#ready","#profileIDPromise","#clientGroupIDPromise","#mutatorRegistry","#requestOptions","#idbDatabases","#lc","#closeAbortController","#persistLock","#enableScheduledPersist","#enableScheduledRefresh","#enableRefresh","#enablePullAndPushInOpen","#onPersist","#queryInternal","#pullConnectionLoop","#invokePull","#pushConnectionLoop","#invokePush","#registerMutators","#wrapInOnlineCheck","#wrapInReauthRetries","#isPullDisabled","#isPushDisabled","#handlePersist","#open","#clientStateNotFoundOnClient","#fireOnUpdateNeeded","#onVisibilityChange","#closed","#checkForClientStateNotFoundAndCallHandler","#online","#schedulePersist","#changeSyncCounters","#convertToClientStateNotFoundError","#handleVersionNotSupportedResponse","#clientStateNotFoundOnServer","#fireOnClientStateNotFound","#schedule","#persistScheduler","#scheduleRefresh","#refreshScheduler","#pushCounter","#pullCounter","#mutate","#register"],"sources":["../../../../../replicache/src/replicache-impl.ts"],"sourcesContent":["import {Lock} from '@rocicorp/lock';\nimport type {LogContext} from '@rocicorp/logger';\nimport {consoleLogSink} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport {AbortError} from '../../shared/src/abort-error.ts';\nimport {assert} from '../../shared/src/asserts.ts';\nimport {getBrowserGlobal} from '../../shared/src/browser-env.ts';\nimport {getDocumentVisibilityWatcher} from '../../shared/src/document-visible.ts';\nimport type {JSONValue, ReadonlyJSONValue} from '../../shared/src/json.ts';\nimport {promiseVoid} from '../../shared/src/resolved-promises.ts';\nimport {TESTING} from '../../shared/src/testing.ts';\nimport type {MaybePromise} from '../../shared/src/types.ts';\nimport {PullDelegate, PushDelegate} from './connection-loop-delegates.ts';\nimport {ConnectionLoop, MAX_DELAY_MS, MIN_DELAY_MS} from './connection-loop.ts';\nimport {assertCookie, type Cookie} from './cookies.ts';\nimport {LazyStore} from './dag/lazy-store.ts';\nimport {StoreImpl} from './dag/store-impl.ts';\nimport {ChunkNotFoundError, mustGetHeadHash, type Store} from './dag/store.ts';\nimport {\n  baseSnapshotFromHash,\n  DEFAULT_HEAD_NAME,\n  isLocalMetaDD31,\n  type LocalMeta,\n} from './db/commit.ts';\nimport {readFromDefaultHead} from './db/read.ts';\nimport {rebaseMutationAndCommit} from './db/rebase.ts';\nimport {newWriteLocal} from './db/write.ts';\nimport {\n  isClientStateNotFoundResponse,\n  isVersionNotSupportedResponse,\n  type VersionNotSupportedResponse,\n} from './error-responses.ts';\nimport * as FormatVersion from './format-version-enum.ts';\nimport {deepFreeze} from './frozen-json.ts';\nimport {getDefaultPuller, isDefaultPuller} from './get-default-puller.ts';\nimport {getDefaultPusher, isDefaultPusher} from './get-default-pusher.ts';\nimport {getKVStoreProvider} from './get-kv-store-provider.ts';\nimport {assertHash, emptyHash, type Hash, newRandomHash} from './hash.ts';\nimport type {HTTPRequestInfo} from './http-request-info.ts';\nimport {httpStatusUnauthorized} from './http-status-unauthorized.ts';\nimport type {IndexDefinitions} from './index-defs.ts';\nimport type {StoreProvider} from './kv/store.ts';\nimport {createLogContext} from './log-options.ts';\nimport {makeIDBName} from './make-idb-name.ts';\nimport {MutationRecovery} from './mutation-recovery.ts';\nimport {initNewClientChannel} from './new-client-channel.ts';\nimport {\n  initOnPersistChannel,\n  type OnPersist,\n  type PersistInfo,\n} from './on-persist-channel.ts';\nimport {\n  type PendingMutation,\n  pendingMutationsForAPI,\n} from './pending-mutations.ts';\nimport {\n  CLIENT_MAX_INACTIVE_TIME,\n  GC_INTERVAL,\n  initClientGC,\n} from './persist/client-gc.ts';\nimport {initClientGroupGC} from './persist/client-group-gc.ts';\nimport {disableClientGroup} from './persist/client-groups.ts';\nimport {\n  ClientStateNotFoundError,\n  initClientV6,\n  type OnClientsDeleted,\n  hasClientState as persistHasClientState,\n} from './persist/clients.ts';\nimport {\n  COLLECT_IDB_INTERVAL,\n  initCollectIDBDatabases,\n  INITIAL_COLLECT_IDB_DELAY,\n} from './persist/collect-idb-databases.ts';\nimport {HEARTBEAT_INTERVAL, startHeartbeats} from './persist/heartbeat.ts';\nimport {\n  IDBDatabasesStore,\n  type IndexedDBDatabase,\n} from './persist/idb-databases-store.ts';\nimport {makeClientID} from './persist/make-client-id.ts';\nimport {persistDD31} from './persist/persist.ts';\nimport {refresh} from './persist/refresh.ts';\nimport {ProcessScheduler} from './process-scheduler.ts';\nimport type {Puller} from './puller.ts';\nimport {type Pusher, PushError} from './pusher.ts';\nimport type {\n  MutationTrackingData,\n  ReplicacheOptions,\n  ZeroOption,\n} from './replicache-options.ts';\nimport {ReportError} from './report-error.ts';\nimport {setIntervalWithSignal} from './set-interval-with-signal.ts';\nimport {\n  type SubscribeOptions,\n  SubscriptionImpl,\n  type SubscriptionsManager,\n  SubscriptionsManagerImpl,\n  type WatchCallback,\n  type WatchCallbackForOptions,\n  type WatchNoIndexCallback,\n  type WatchOptions,\n  WatchSubscription,\n} from './subscriptions.ts';\nimport type {DiffsMap} from './sync/diff.ts';\nimport * as HandlePullResponseResultEnum from './sync/handle-pull-response-result-type-enum.ts';\nimport type {ClientGroupID, ClientID} from './sync/ids.ts';\nimport {PullError} from './sync/pull-error.ts';\nimport {beginPullV1, handlePullResponseV1, maybeEndPull} from './sync/pull.ts';\nimport {push, PUSH_VERSION_DD31} from './sync/push.ts';\nimport {newRequestID} from './sync/request-id.ts';\nimport {SYNC_HEAD_NAME} from './sync/sync-head-name.ts';\nimport {throwIfClosed} from './transaction-closed-error.ts';\nimport type {ReadTransaction, WriteTransaction} from './transactions.ts';\nimport {ReadTransactionImpl, WriteTransactionImpl} from './transactions.ts';\nimport type {\n  BeginPullResult,\n  MakeMutator,\n  MakeMutators,\n  MutatorDefs,\n  MutatorReturn,\n  PokeInternal,\n  QueryInternal,\n  RequestOptions,\n  UpdateNeededReason,\n} from './types.ts';\nimport {version} from './version.ts';\nimport {\n  withRead,\n  withWrite,\n  withWriteNoImplicitCommit,\n} from './with-transactions.ts';\n\ndeclare const process: {\n  env: {\n    ['DISABLE_MUTATION_RECOVERY']?: string | undefined;\n  };\n};\n\n/**\n * The maximum number of time to call out to getAuth before giving up\n * and throwing an error.\n */\nconst MAX_REAUTH_TRIES = 8;\n\nconst PERSIST_IDLE_TIMEOUT_MS = 1000;\nconst REFRESH_IDLE_TIMEOUT_MS = 1000;\n\nconst PERSIST_THROTTLE_MS = 500;\nconst REFRESH_THROTTLE_MS = 500;\n\nconst LAZY_STORE_SOURCE_CHUNK_CACHE_SIZE_LIMIT = 100 * 2 ** 20; // 100 MB\n\nconst RECOVER_MUTATIONS_INTERVAL_MS = 5 * 60 * 1000; // 5 mins\n\nconst noop = () => {\n  // noop\n};\n\nconst updateNeededReasonNewClientGroup: UpdateNeededReason = {\n  type: 'NewClientGroup',\n} as const;\n\n/** @deprecated Not used any more */\nexport interface MakeSubscriptionsManager {\n  (queryInternal: QueryInternal, lc: LogContext): SubscriptionsManager;\n}\n\nexport interface ReplicacheImplOptions {\n  /**\n   * Defaults to true.\n   */\n  enableMutationRecovery?: boolean | undefined;\n\n  /**\n   * Defaults to true.\n   */\n  enableScheduledPersist?: boolean | undefined;\n\n  /**\n   * Defaults to true.\n   */\n  enableScheduledRefresh?: boolean | undefined;\n\n  /**\n   * Defaults to `() => true`.\n   */\n  enableRefresh?: (() => boolean) | undefined;\n\n  /**\n   * Defaults to true.\n   */\n  enablePullAndPushInOpen?: boolean | undefined;\n\n  /**\n   * @deprecated Not used anymore.\n   */\n  makeSubscriptionsManager?: unknown;\n\n  /**\n   * Default is `true`.  If `false` if an exact match client group\n   * is not found, a new client group is always made instead of forking\n   * from an existing client group.\n   */\n  enableClientGroupForking?: boolean | undefined;\n\n  /**\n   * Callback for when Replicache has deleted clients.\n   */\n  onClientsDeleted?: OnClientsDeleted | undefined;\n\n  /**\n   * Internal option used by Zero.\n   * Replicache will call this to and, if zero is enabled, will\n   * invoke various hooks to allow Zero the keep IVM in sync with Replicache's b-trees.\n   */\n  zero?: ZeroOption | undefined;\n}\n\nexport class ReplicacheImpl<MD extends MutatorDefs = {}> {\n  /** The URL to use when doing a pull request. */\n  pullURL: string;\n\n  /** The URL to use when doing a push request. */\n  pushURL: string;\n\n  /** The authorization token used when doing a push request. */\n  #auth: string;\n\n  /** The name of the Replicache database. Populated by {@link ReplicacheOptions#name}. */\n  readonly name: string;\n\n  readonly #subscriptions: SubscriptionsManager;\n  readonly #mutationRecovery: MutationRecovery | undefined;\n\n  /**\n   * Client groups gets disabled when the server does not know about it.\n   * A disabled client group prevents the client from pushing and pulling.\n   */\n  isClientGroupDisabled = false;\n\n  readonly #kvStoreProvider: StoreProvider;\n\n  lastMutationID: number = 0;\n\n  /**\n   * This is the name Replicache uses for the IndexedDB database where data is\n   * stored.\n   */\n  get idbName(): string {\n    return makeIDBName(this.name, this.schemaVersion);\n  }\n\n  set auth(auth: string) {\n    if (this.#zero) {\n      this.#zero.auth = auth;\n    }\n\n    this.#auth = auth;\n  }\n\n  get auth() {\n    return this.#auth;\n  }\n\n  /** The schema version of the data understood by this application. */\n  readonly schemaVersion: string;\n\n  get #idbDatabase(): IndexedDBDatabase {\n    return {\n      name: this.idbName,\n      replicacheName: this.name,\n      replicacheFormatVersion: FormatVersion.Latest,\n      schemaVersion: this.schemaVersion,\n    };\n  }\n  #closed = false;\n  #online = true;\n  readonly #clientID = makeClientID();\n  readonly #ready: Promise<void>;\n  readonly #profileIDPromise: Promise<string>;\n  readonly #clientGroupIDPromise: Promise<string>;\n  readonly #mutatorRegistry: MutatorDefs = {};\n\n  /**\n   * The mutators that was registered in the constructor.\n   */\n  readonly mutate: MakeMutators<MD>;\n\n  // Number of pushes/pulls at the moment.\n  #pushCounter = 0;\n  #pullCounter = 0;\n\n  #pullConnectionLoop: ConnectionLoop;\n  #pushConnectionLoop: ConnectionLoop;\n\n  /**\n   * The duration between each periodic {@link pull}. Setting this to `null`\n   * disables periodic pull completely. Pull will still happen if you call\n   * {@link pull} manually.\n   */\n  pullInterval: number | null;\n\n  /**\n   * The delay between when a change is made to Replicache and when Replicache\n   * attempts to push that change.\n   */\n  pushDelay: number;\n\n  readonly #requestOptions: Required<RequestOptions>;\n\n  /**\n   * The function to use to pull data from the server.\n   */\n  puller: Puller;\n\n  /**\n   * The function to use to push data to the server.\n   */\n  pusher: Pusher;\n\n  readonly memdag: LazyStore;\n  readonly perdag: Store;\n  readonly #idbDatabases: IDBDatabasesStore;\n  readonly #lc: LogContext;\n  readonly #zero: ZeroOption | undefined;\n\n  readonly #closeAbortController = new AbortController();\n\n  readonly #persistLock = new Lock();\n  readonly #enableScheduledPersist: boolean;\n  readonly #enableScheduledRefresh: boolean;\n  readonly #enableRefresh: () => boolean;\n  readonly #enablePullAndPushInOpen: boolean;\n  #persistScheduler = new ProcessScheduler(\n    () => this.persist(),\n    PERSIST_IDLE_TIMEOUT_MS,\n    PERSIST_THROTTLE_MS,\n    this.#closeAbortController.signal,\n  );\n  readonly #onPersist: OnPersist;\n  #refreshScheduler = new ProcessScheduler(\n    () => this.refresh(),\n    REFRESH_IDLE_TIMEOUT_MS,\n    REFRESH_THROTTLE_MS,\n    this.#closeAbortController.signal,\n  );\n\n  /**\n   * The options used to control the {@link pull} and push request behavior. This\n   * object is live so changes to it will affect the next pull or push call.\n   */\n  get requestOptions(): Required<RequestOptions> {\n    return this.#requestOptions;\n  }\n\n  /**\n   * `onSync(true)` is called when Replicache transitions from no push or pull\n   * happening to at least one happening. `onSync(false)` is called in the\n   * opposite case: when Replicache transitions from at least one push or pull\n   * happening to none happening.\n   *\n   * This can be used in a React like app by doing something like the following:\n   *\n   * ```js\n   * const [syncing, setSyncing] = useState(false);\n   * useEffect(() => {\n   *   rep.onSync = setSyncing;\n   * }, [rep]);\n   * ```\n   */\n  onSync: ((syncing: boolean) => void) | null = null;\n\n  /**\n   * `onClientStateNotFound` is called when the persistent client has been\n   * garbage collected. This can happen if the client has no pending mutations\n   * and has not been used for a while.\n   *\n   * The default behavior is to reload the page (using `location.reload()`). Set\n   * this to `null` or provide your own function to prevent the page from\n   * reloading automatically.\n   */\n  onClientStateNotFound: (() => void) | null = reload;\n\n  /**\n   * `onUpdateNeeded` is called when a code update is needed.\n   *\n   * A code update can be needed because:\n   * - the server no longer supports the {@link pushVersion},\n   *   {@link pullVersion} or {@link schemaVersion} of the current code.\n   * - a new Replicache client has created a new client group, because its code\n   *   has different mutators, indexes, schema version and/or format version\n   *   from this Replicache client. This is likely due to the new client having\n   *   newer code. A code update is needed to be able to locally sync with this\n   *   new Replicache client (i.e. to sync while offline, the clients can still\n   *   sync with each other via the server).\n   *\n   * The default behavior is to reload the page (using `location.reload()`). Set\n   * this to `null` or provide your own function to prevent the page from\n   * reloading automatically. You may want to provide your own function to\n   * display a toast to inform the end user there is a new version of your app\n   * available and prompting them to refresh.\n   */\n  onUpdateNeeded: ((reason: UpdateNeededReason) => void) | null = reload;\n\n  /**\n   * This gets called when we get an HTTP unauthorized (401) response from the\n   * push or pull endpoint. Set this to a function that will ask your user to\n   * reauthenticate.\n   */\n  getAuth: (() => MaybePromise<string | null | undefined>) | null | undefined =\n    null;\n\n  // These three are used for testing\n  onPushInvoked = () => undefined;\n  onBeginPull = () => undefined;\n  onRecoverMutations = (r: Promise<boolean>) => r;\n\n  constructor(\n    options: ReplicacheOptions<MD>,\n    implOptions: ReplicacheImplOptions = {},\n  ) {\n    validateOptions(options);\n    const {\n      name,\n      logLevel = 'info',\n      logSinks = [consoleLogSink],\n      pullURL = '',\n      auth,\n      pushDelay = 10,\n      pushURL = '',\n      schemaVersion = '',\n      pullInterval = 60000,\n      mutators = {} as MD,\n      requestOptions = {},\n      puller,\n      pusher,\n      indexes = {},\n      clientMaxAgeMs = CLIENT_MAX_INACTIVE_TIME,\n    } = options;\n    const {\n      enableMutationRecovery = true,\n      enableScheduledPersist = true,\n      enableScheduledRefresh = true,\n      enableRefresh = () => true,\n      enablePullAndPushInOpen = true,\n      enableClientGroupForking = true,\n      onClientsDeleted = () => promiseVoid,\n    } = implOptions;\n    this.#zero = implOptions.zero;\n    this.#auth = auth ?? '';\n    this.pullURL = pullURL;\n    this.pushURL = pushURL;\n    this.name = name;\n    this.schemaVersion = schemaVersion;\n    this.pullInterval = pullInterval;\n    this.pushDelay = pushDelay;\n    this.puller = puller ?? getDefaultPuller(this);\n    this.pusher = pusher ?? getDefaultPusher(this);\n\n    this.#enableScheduledPersist = enableScheduledPersist;\n    this.#enableScheduledRefresh = enableScheduledRefresh;\n    this.#enableRefresh = enableRefresh;\n    this.#enablePullAndPushInOpen = enablePullAndPushInOpen;\n\n    this.#lc = createLogContext(logLevel, logSinks, {name});\n    this.#lc.debug?.('Constructing Replicache', {\n      name,\n      'replicache version': version,\n    });\n\n    this.#subscriptions = new SubscriptionsManagerImpl(\n      this.#queryInternal,\n      this.#lc,\n      this.#closeAbortController.signal,\n    );\n\n    const kvStoreProvider = getKVStoreProvider(this.#lc, options.kvStore);\n    this.#kvStoreProvider = kvStoreProvider;\n\n    const perKVStore = kvStoreProvider.create(this.idbName);\n\n    this.#idbDatabases = new IDBDatabasesStore(kvStoreProvider.create);\n    this.perdag = new StoreImpl(perKVStore, newRandomHash, assertHash);\n    this.memdag = new LazyStore(\n      this.perdag,\n      LAZY_STORE_SOURCE_CHUNK_CACHE_SIZE_LIMIT,\n      newRandomHash,\n      assertHash,\n    );\n\n    // Use a promise-resolve pair so that we have a promise to use even before\n    // we call the Open RPC.\n    const readyResolver = resolver<void>();\n    this.#ready = readyResolver.promise;\n\n    const {minDelayMs = MIN_DELAY_MS, maxDelayMs = MAX_DELAY_MS} =\n      requestOptions;\n    this.#requestOptions = {maxDelayMs, minDelayMs};\n\n    const visibilityWatcher = getDocumentVisibilityWatcher(\n      getBrowserGlobal('document'),\n      0,\n      this.#closeAbortController.signal,\n    );\n\n    this.#pullConnectionLoop = new ConnectionLoop(\n      this.#lc.withContext('PULL'),\n      new PullDelegate(this, () => this.#invokePull()),\n      visibilityWatcher,\n    );\n\n    this.#pushConnectionLoop = new ConnectionLoop(\n      this.#lc.withContext('PUSH'),\n      new PushDelegate(this, () => this.#invokePush()),\n    );\n\n    this.mutate = this.#registerMutators(mutators);\n\n    const profileIDResolver = resolver<string>();\n    this.#profileIDPromise = profileIDResolver.promise;\n    const clientGroupIDResolver = resolver<string>();\n    this.#clientGroupIDPromise = clientGroupIDResolver.promise;\n\n    if (!process.env.DISABLE_MUTATION_RECOVERY) {\n      this.#mutationRecovery = new MutationRecovery({\n        delegate: this,\n        lc: this.#lc,\n        enableMutationRecovery,\n        wrapInOnlineCheck: this.#wrapInOnlineCheck.bind(this),\n        wrapInReauthRetries: this.#wrapInReauthRetries.bind(this),\n        isPullDisabled: this.#isPullDisabled.bind(this),\n        isPushDisabled: this.#isPushDisabled.bind(this),\n        clientGroupIDPromise: this.#clientGroupIDPromise,\n      });\n    }\n\n    this.#onPersist = initOnPersistChannel(\n      this.name,\n      this.#closeAbortController.signal,\n      persistInfo => {\n        void this.#handlePersist(persistInfo);\n      },\n    );\n\n    void this.#open(\n      indexes,\n      enableClientGroupForking,\n      enableMutationRecovery,\n      clientMaxAgeMs,\n      profileIDResolver.resolve,\n      clientGroupIDResolver.resolve,\n      readyResolver.resolve,\n      onClientsDeleted,\n    );\n  }\n\n  async #open(\n    indexes: IndexDefinitions,\n    enableClientGroupForking: boolean,\n    enableMutationRecovery: boolean,\n    clientMaxAgeMs: number,\n    profileIDResolver: (profileID: string) => void,\n    resolveClientGroupID: (clientGroupID: ClientGroupID) => void,\n    resolveReady: () => void,\n    onClientsDeleted: OnClientsDeleted,\n  ): Promise<void> {\n    const {clientID} = this;\n    // If we are currently closing a Replicache instance with the same name,\n    // wait for it to finish closing.\n    await closingInstances.get(this.name);\n    await this.#idbDatabases.getProfileID().then(profileIDResolver);\n    await this.#idbDatabases.putDatabase(this.#idbDatabase);\n    const [client, headHash, , isNewClientGroup] = await initClientV6(\n      clientID,\n      this.#lc,\n      this.perdag,\n      Object.keys(this.#mutatorRegistry),\n      indexes,\n      FormatVersion.Latest,\n      enableClientGroupForking,\n    );\n\n    resolveClientGroupID(client.clientGroupID);\n    await withWrite(this.memdag, write =>\n      write.setHead(DEFAULT_HEAD_NAME, headHash),\n    );\n\n    // Now we have a profileID, a clientID, a clientGroupID and DB!\n    await this.#zero?.init(headHash, this.memdag);\n    resolveReady();\n\n    if (this.#enablePullAndPushInOpen) {\n      this.pull().catch(noop);\n      this.push().catch(noop);\n    }\n\n    const {signal} = this.#closeAbortController;\n\n    startHeartbeats(\n      clientID,\n      this.perdag,\n      () => {\n        this.#clientStateNotFoundOnClient(clientID);\n      },\n      HEARTBEAT_INTERVAL,\n      this.#lc,\n      signal,\n    );\n    initClientGC(\n      clientID,\n      this.perdag,\n      clientMaxAgeMs,\n      GC_INTERVAL,\n      onClientsDeleted,\n      this.#lc,\n      signal,\n    );\n    initCollectIDBDatabases(\n      this.#idbDatabases,\n      this.#kvStoreProvider,\n      COLLECT_IDB_INTERVAL,\n      INITIAL_COLLECT_IDB_DELAY,\n      2 * clientMaxAgeMs,\n      enableMutationRecovery,\n      onClientsDeleted,\n      this.#lc,\n      signal,\n    );\n    initClientGroupGC(this.perdag, enableMutationRecovery, this.#lc, signal);\n    initNewClientChannel(\n      this.name,\n      this.idbName,\n      signal,\n      client.clientGroupID,\n      isNewClientGroup,\n      () => {\n        this.#fireOnUpdateNeeded(updateNeededReasonNewClientGroup);\n      },\n      this.perdag,\n    );\n\n    setIntervalWithSignal(\n      () => this.recoverMutations(),\n      RECOVER_MUTATIONS_INTERVAL_MS,\n      signal,\n    );\n    void this.recoverMutations();\n\n    getBrowserGlobal('document')?.addEventListener(\n      'visibilitychange',\n      this.#onVisibilityChange,\n    );\n  }\n\n  #onVisibilityChange = async () => {\n    if (this.#closed) {\n      return;\n    }\n\n    // In case of running in a worker, we don't have a document.\n    if (getBrowserGlobal('document')?.visibilityState !== 'visible') {\n      return;\n    }\n\n    await this.#checkForClientStateNotFoundAndCallHandler();\n  };\n\n  async #checkForClientStateNotFoundAndCallHandler(): Promise<boolean> {\n    const {clientID} = this;\n    const hasClientState = await withRead(this.perdag, read =>\n      persistHasClientState(clientID, read),\n    );\n    if (!hasClientState) {\n      this.#clientStateNotFoundOnClient(clientID);\n    }\n    return !hasClientState;\n  }\n\n  /**\n   * The browser profile ID for this browser profile. Every instance of Replicache\n   * browser-profile-wide shares the same profile ID.\n   */\n  get profileID(): Promise<string> {\n    return this.#profileIDPromise;\n  }\n\n  /**\n   * The client ID for this instance of Replicache. Each instance of Replicache\n   * gets a unique client ID.\n   */\n  get clientID(): string {\n    return this.#clientID;\n  }\n\n  /**\n   * The client group ID for this instance of Replicache. Instances of\n   * Replicache will have the same client group ID if and only if they have\n   * the same name, mutators, indexes, schema version, format version, and\n   * browser profile.\n   */\n  get clientGroupID(): Promise<string> {\n    return this.#clientGroupIDPromise;\n  }\n\n  /**\n   * `onOnlineChange` is called when the {@link online} property changes. See\n   * {@link online} for more details.\n   */\n  onOnlineChange: ((online: boolean) => void) | null = null;\n\n  /**\n   * A rough heuristic for whether the client is currently online. Note that\n   * there is no way to know for certain whether a client is online - the next\n   * request can always fail. This property returns true if the last sync attempt succeeded,\n   * and false otherwise.\n   */\n  get online(): boolean {\n    return this.#online;\n  }\n\n  /**\n   * Whether the Replicache database has been closed. Once Replicache has been\n   * closed it no longer syncs and you can no longer read or write data out of\n   * it. After it has been closed it is pretty much useless and should not be\n   * used any more.\n   */\n  get closed(): boolean {\n    return this.#closed;\n  }\n\n  /**\n   * Closes this Replicache instance.\n   *\n   * When closed all subscriptions end and no more read or writes are allowed.\n   */\n  async close(): Promise<void> {\n    this.#closed = true;\n    const {promise, resolve} = resolver();\n    closingInstances.set(this.name, promise);\n\n    this.#closeAbortController.abort();\n\n    getBrowserGlobal('document')?.removeEventListener(\n      'visibilitychange',\n      this.#onVisibilityChange,\n    );\n\n    await this.#ready;\n    const closingPromises = [\n      this.memdag.close(),\n      this.perdag.close(),\n      this.#idbDatabases.close(),\n    ];\n\n    this.#pullConnectionLoop.close();\n    this.#pushConnectionLoop.close();\n\n    this.#subscriptions.clear();\n\n    await Promise.all(closingPromises);\n    closingInstances.delete(this.name);\n    resolve();\n  }\n\n  async maybeEndPull(syncHead: Hash, requestID: string): Promise<void> {\n    for (;;) {\n      if (this.#closed) {\n        return;\n      }\n\n      await this.#ready;\n      const {clientID} = this;\n      const lc = this.#lc\n        .withContext('maybeEndPull')\n        .withContext('requestID', requestID);\n      const {replayMutations, diffs, oldMainHead, mainHead} =\n        await maybeEndPull<LocalMeta>(\n          this.memdag,\n          lc,\n          syncHead,\n          clientID,\n          this.#subscriptions,\n          FormatVersion.Latest,\n        );\n\n      if (!replayMutations || replayMutations.length === 0) {\n        // All done.\n        this.#zero?.advance(oldMainHead, mainHead, diffs.get('') ?? []);\n        await this.#subscriptions.fire(diffs);\n        void this.#schedulePersist();\n        return;\n      }\n\n      // Replay.\n      const zeroData = await this.#zero?.getTxData?.(syncHead);\n      for (const mutation of replayMutations) {\n        // TODO(greg): I'm not sure why this was in Replicache#_mutate...\n        // Ensure that we run initial pending subscribe functions before starting a\n        // write transaction.\n        if (this.#subscriptions.hasPendingSubscriptionRuns) {\n          await Promise.resolve();\n        }\n        const {meta} = mutation;\n        syncHead = await withWriteNoImplicitCommit(this.memdag, dagWrite =>\n          rebaseMutationAndCommit(\n            mutation,\n            dagWrite,\n            syncHead,\n            SYNC_HEAD_NAME,\n            this.#mutatorRegistry,\n            lc,\n            isLocalMetaDD31(meta) ? meta.clientID : clientID,\n            FormatVersion.Latest,\n            zeroData,\n          ),\n        );\n      }\n    }\n  }\n\n  #invokePull(): Promise<boolean> {\n    if (this.#isPullDisabled()) {\n      return Promise.resolve(true);\n    }\n\n    return this.#wrapInOnlineCheck(async () => {\n      try {\n        this.#changeSyncCounters(0, 1);\n        const {syncHead, requestID, ok} = await this.beginPull();\n        if (!ok) {\n          return false;\n        }\n        if (syncHead !== emptyHash) {\n          await this.maybeEndPull(syncHead, requestID);\n        }\n      } catch (e) {\n        throw await this.#convertToClientStateNotFoundError(e);\n      } finally {\n        this.#changeSyncCounters(0, -1);\n      }\n      return true;\n    }, 'Pull');\n  }\n\n  #isPullDisabled() {\n    return (\n      this.isClientGroupDisabled ||\n      (this.pullURL === '' && isDefaultPuller(this.puller))\n    );\n  }\n\n  async #wrapInOnlineCheck(\n    f: () => Promise<boolean>,\n    name: string,\n  ): Promise<boolean> {\n    let online = true;\n\n    try {\n      return await f();\n    } catch (e) {\n      // The error paths of beginPull and maybeEndPull need to be reworked.\n      //\n      // We want to distinguish between:\n      // a) network requests failed -- we're offline basically\n      // b) sync was aborted because one's already in progress\n      // c) oh noes - something unexpected happened\n      //\n      // Right now, all of these come out as errors. We distinguish (b) with a\n      // hacky string search. (a) and (c) are not distinguishable currently\n      // because repc doesn't provide sufficient information, so we treat all\n      // errors that aren't (b) as (a).\n      if (e instanceof PushError || e instanceof PullError) {\n        online = false;\n        this.#lc.debug?.(`${name} threw:\\n`, e, '\\nwith cause:\\n', e.causedBy);\n      } else if (e instanceof ReportError) {\n        this.#lc.error?.(e);\n      } else {\n        this.#lc.info?.(`${name} threw:\\n`, e);\n      }\n      return false;\n    } finally {\n      if (this.#online !== online) {\n        this.#online = online;\n        this.onOnlineChange?.(online);\n        if (online) {\n          void this.recoverMutations();\n        }\n      }\n    }\n  }\n\n  async #wrapInReauthRetries<R>(\n    f: (\n      requestID: string,\n      requestLc: LogContext,\n    ) => Promise<{\n      httpRequestInfo: HTTPRequestInfo | undefined;\n      result: R;\n    }>,\n    verb: string,\n    lc: LogContext,\n    preAuth: () => MaybePromise<void> = noop,\n    postAuth: () => MaybePromise<void> = noop,\n  ): Promise<{\n    result: R;\n    authFailure: boolean;\n  }> {\n    const {clientID} = this;\n    let reauthAttempts = 0;\n    let lastResult;\n    lc = lc.withContext(verb);\n    do {\n      const requestID = newRequestID(clientID);\n      const requestLc = lc.withContext('requestID', requestID);\n      const {httpRequestInfo, result} = await f(requestID, requestLc);\n      lastResult = result;\n      if (!httpRequestInfo) {\n        return {\n          result,\n          authFailure: false,\n        };\n      }\n      const {errorMessage, httpStatusCode} = httpRequestInfo;\n\n      if (errorMessage || httpStatusCode !== 200) {\n        // TODO(arv): Maybe we should not log the server URL when the error comes\n        // from a Pusher/Puller?\n        requestLc.error?.(\n          `Got a non 200 response doing ${verb}: ${httpStatusCode}` +\n            (errorMessage ? `: ${errorMessage}` : ''),\n        );\n      }\n      if (httpStatusCode !== httpStatusUnauthorized) {\n        return {\n          result,\n          authFailure: false,\n        };\n      }\n      if (!this.getAuth) {\n        return {\n          result,\n          authFailure: true,\n        };\n      }\n      let auth;\n      try {\n        await preAuth();\n        auth = await this.getAuth();\n      } finally {\n        await postAuth();\n      }\n      if (auth === null || auth === undefined) {\n        return {\n          result,\n          authFailure: true,\n        };\n      }\n      this.auth = auth;\n      reauthAttempts++;\n    } while (reauthAttempts < MAX_REAUTH_TRIES);\n    lc.info?.('Tried to reauthenticate too many times');\n    return {\n      result: lastResult,\n      authFailure: true,\n    };\n  }\n\n  #isPushDisabled() {\n    return (\n      this.isClientGroupDisabled ||\n      (this.pushURL === '' && isDefaultPusher(this.pusher))\n    );\n  }\n\n  async #invokePush(): Promise<boolean> {\n    if (TESTING) {\n      this.onPushInvoked();\n    }\n    if (this.#isPushDisabled()) {\n      return true;\n    }\n\n    await this.#ready;\n    const profileID = await this.#profileIDPromise;\n    const {clientID} = this;\n    const clientGroupID = await this.#clientGroupIDPromise;\n    return this.#wrapInOnlineCheck(async () => {\n      const {result: pusherResult} = await this.#wrapInReauthRetries(\n        async (requestID: string, requestLc: LogContext) => {\n          try {\n            this.#changeSyncCounters(1, 0);\n            const pusherResult = await push(\n              requestID,\n              this.memdag,\n              requestLc,\n              profileID,\n              clientGroupID,\n              clientID,\n              this.pusher,\n              this.schemaVersion,\n              PUSH_VERSION_DD31,\n            );\n            return {\n              result: pusherResult,\n              httpRequestInfo: pusherResult?.httpRequestInfo,\n            };\n          } finally {\n            this.#changeSyncCounters(-1, 0);\n          }\n        },\n        'push',\n        this.#lc,\n      );\n\n      if (pusherResult === undefined) {\n        // No pending mutations.\n        return true;\n      }\n\n      const {response, httpRequestInfo} = pusherResult;\n\n      if (isVersionNotSupportedResponse(response)) {\n        this.#handleVersionNotSupportedResponse(response);\n      } else if (isClientStateNotFoundResponse(response)) {\n        await this.#clientStateNotFoundOnServer();\n      }\n\n      // No pushResponse means we didn't do a push because there were no\n      // pending mutations.\n      return httpRequestInfo.httpStatusCode === 200;\n    }, 'Push');\n  }\n\n  #handleVersionNotSupportedResponse(response: VersionNotSupportedResponse) {\n    const reason: UpdateNeededReason = {\n      type: response.error,\n    };\n    if (response.versionType) {\n      reason.versionType = response.versionType;\n    }\n    this.#fireOnUpdateNeeded(reason);\n  }\n\n  /**\n   * Push pushes pending changes to the {@link pushURL}.\n   *\n   * You do not usually need to manually call push. If {@link pushDelay} is\n   * non-zero (which it is by default) pushes happen automatically shortly after\n   * mutations.\n   *\n   * If the server endpoint fails push will be continuously retried with an\n   * exponential backoff.\n   *\n   * @param [now=false] If true, push will happen immediately and ignore\n   *   {@link pushDelay}, {@link RequestOptions.minDelayMs} as well as the\n   *   exponential backoff in case of errors.\n   * @returns A promise that resolves when the next push completes. In case of\n   * errors the first error will reject the returned promise. Subsequent errors\n   * will not be reflected in the promise.\n   */\n  push({now = false} = {}): Promise<void> {\n    return throwIfError(this.#pushConnectionLoop.send(now));\n  }\n\n  /**\n   * Pull pulls changes from the {@link pullURL}. If there are any changes local\n   * changes will get replayed on top of the new server state.\n   *\n   * If the server endpoint fails pull will be continuously retried with an\n   * exponential backoff.\n   *\n   * @param [now=false] If true, pull will happen immediately and ignore\n   *   {@link RequestOptions.minDelayMs} as well as the exponential backoff in\n   *   case of errors.\n   * @returns A promise that resolves when the next pull completes. In case of\n   * errors the first error will reject the returned promise. Subsequent errors\n   * will not be reflected in the promise.\n   */\n  pull({now = false} = {}): Promise<void> {\n    return throwIfError(this.#pullConnectionLoop.send(now));\n  }\n\n  /**\n   * Applies an update from the server to Replicache.\n   * Throws an error if cookie does not match. In that case the server thinks\n   * this client has a different cookie than it does; the caller should disconnect\n   * from the server and re-register, which transmits the cookie the client actually\n   * has.\n   *\n   * @experimental This method is under development and its semantics will change.\n   */\n  async poke(poke: PokeInternal): Promise<void> {\n    await this.#ready;\n    // TODO(MP) Previously we created a request ID here and included it with the\n    // PullRequest to the server so we could tie events across client and server\n    // together. Since the direction is now reversed, creating and adding a request ID\n    // here is kind of silly. We should consider creating the request ID\n    // on the *server* and passing it down in the poke for inclusion here in the log\n    // context\n    const {clientID} = this;\n    const requestID = newRequestID(clientID);\n    const lc = this.#lc\n      .withContext('handlePullResponse')\n      .withContext('requestID', requestID);\n\n    const {pullResponse} = poke;\n\n    if (isVersionNotSupportedResponse(pullResponse)) {\n      this.#handleVersionNotSupportedResponse(pullResponse);\n      return;\n    }\n\n    if (isClientStateNotFoundResponse(pullResponse)) {\n      await this.#clientStateNotFoundOnServer();\n      return;\n    }\n\n    const result = await handlePullResponseV1(\n      lc,\n      this.memdag,\n      deepFreeze(poke.baseCookie),\n      pullResponse,\n      clientID,\n      FormatVersion.Latest,\n    );\n\n    switch (result.type) {\n      case HandlePullResponseResultEnum.Applied:\n        await this.maybeEndPull(result.syncHead, requestID);\n        break;\n      case HandlePullResponseResultEnum.CookieMismatch:\n        throw new Error(\n          'unexpected base cookie for poke: ' + JSON.stringify(poke),\n        );\n      case HandlePullResponseResultEnum.NoOp:\n        break;\n    }\n  }\n\n  async beginPull(): Promise<BeginPullResult> {\n    if (TESTING) {\n      this.onBeginPull();\n    }\n    await this.#ready;\n    const profileID = await this.profileID;\n    const {clientID} = this;\n    const clientGroupID = await this.#clientGroupIDPromise;\n    const {\n      result: {beginPullResponse, requestID},\n    } = await this.#wrapInReauthRetries(\n      async (requestID: string, requestLc: LogContext) => {\n        const beginPullResponse = await beginPullV1(\n          profileID,\n          clientID,\n          clientGroupID,\n          this.schemaVersion,\n          this.puller,\n          requestID,\n          this.memdag,\n          FormatVersion.Latest,\n          requestLc,\n        );\n        return {\n          result: {beginPullResponse, requestID},\n          httpRequestInfo: beginPullResponse.httpRequestInfo,\n        };\n      },\n      'pull',\n      this.#lc,\n      () => this.#changeSyncCounters(0, -1),\n      () => this.#changeSyncCounters(0, 1),\n    );\n\n    const {pullResponse} = beginPullResponse;\n    if (isVersionNotSupportedResponse(pullResponse)) {\n      this.#handleVersionNotSupportedResponse(pullResponse);\n    } else if (isClientStateNotFoundResponse(beginPullResponse.pullResponse)) {\n      await this.#clientStateNotFoundOnServer();\n    }\n\n    const {syncHead, httpRequestInfo} = beginPullResponse;\n    return {requestID, syncHead, ok: httpRequestInfo.httpStatusCode === 200};\n  }\n\n  persist(): Promise<void> {\n    // Prevent multiple persist calls from running at the same time.\n    return this.#persistLock.withLock(async () => {\n      const {clientID} = this;\n      await this.#ready;\n      if (this.#closed) {\n        return;\n      }\n      try {\n        await persistDD31(\n          this.#lc,\n          clientID,\n          this.memdag,\n          this.perdag,\n          this.#mutatorRegistry,\n          () => this.#closed,\n          FormatVersion.Latest,\n          this.#zero?.getTxData,\n        );\n      } catch (e) {\n        if (e instanceof ClientStateNotFoundError) {\n          this.#clientStateNotFoundOnClient(clientID);\n        } else if (this.#closed) {\n          this.#lc.debug?.('Exception persisting during close', e);\n        } else {\n          throw e;\n        }\n      }\n\n      const clientGroupID = await this.#clientGroupIDPromise;\n      assert(clientGroupID, 'Expected clientGroupID to be defined');\n      this.#onPersist({clientID, clientGroupID});\n    });\n  }\n\n  async refresh(): Promise<void> {\n    await this.#ready;\n    const {clientID} = this;\n    if (this.#closed || !this.#enableRefresh()) {\n      return;\n    }\n    let refreshResult: Awaited<ReturnType<typeof refresh>>;\n    try {\n      refreshResult = await refresh(\n        this.#lc,\n        this.memdag,\n        this.perdag,\n        clientID,\n        this.#mutatorRegistry,\n        this.#subscriptions,\n        () => this.closed,\n        FormatVersion.Latest,\n        this.#zero,\n      );\n    } catch (e) {\n      if (e instanceof ClientStateNotFoundError) {\n        this.#clientStateNotFoundOnClient(clientID);\n      } else if (this.#closed) {\n        this.#lc.debug?.('Exception refreshing during close', e);\n      } else {\n        throw e;\n      }\n    }\n    if (refreshResult !== undefined) {\n      await this.#subscriptions.fire(refreshResult.diffs);\n    }\n  }\n\n  #fireOnClientStateNotFound() {\n    this.onClientStateNotFound?.();\n  }\n\n  #clientStateNotFoundOnClient(clientID: ClientID) {\n    this.#lc.error?.(`Client state not found on client, clientID: ${clientID}`);\n    this.#fireOnClientStateNotFound();\n  }\n\n  async #clientStateNotFoundOnServer() {\n    const clientGroupID = await this.#clientGroupIDPromise;\n    this.#lc.error?.(\n      `Client state not found on server, clientGroupID: ${clientGroupID}`,\n    );\n    await this.disableClientGroup();\n    this.#fireOnClientStateNotFound();\n  }\n\n  async disableClientGroup(): Promise<void> {\n    const clientGroupID = await this.#clientGroupIDPromise;\n    assert(clientGroupID, 'Expected clientGroupID to be defined');\n    this.isClientGroupDisabled = true;\n    await withWrite(this.perdag, dagWrite =>\n      disableClientGroup(clientGroupID, dagWrite),\n    );\n  }\n\n  #fireOnUpdateNeeded(reason: UpdateNeededReason) {\n    this.#lc.debug?.(`Update needed, reason: ${reason}`);\n    this.onUpdateNeeded?.(reason);\n  }\n\n  async #schedulePersist(): Promise<void> {\n    if (!this.#enableScheduledPersist) {\n      return;\n    }\n    await this.#schedule('persist', this.#persistScheduler);\n  }\n\n  async #handlePersist(persistInfo: PersistInfo): Promise<void> {\n    this.#lc.debug?.('Handling persist', persistInfo);\n    const clientGroupID = await this.#clientGroupIDPromise;\n    if (persistInfo.clientGroupID === clientGroupID) {\n      void this.#scheduleRefresh();\n    }\n  }\n\n  async #scheduleRefresh(): Promise<void> {\n    if (!this.#enableScheduledRefresh) {\n      return;\n    }\n    await this.#schedule('refresh from storage', this.#refreshScheduler);\n  }\n\n  async #schedule(name: string, scheduler: ProcessScheduler): Promise<void> {\n    try {\n      await scheduler.schedule();\n    } catch (e) {\n      if (e instanceof AbortError) {\n        this.#lc.debug?.(`Scheduled ${name} did not complete before close.`);\n      } else {\n        this.#lc.error?.(`Error during ${name}`, e);\n      }\n    }\n  }\n\n  /**\n   * Runs a refresh as soon as possible through the refresh scheduler.\n   */\n  runRefresh(): Promise<void> {\n    return this.#refreshScheduler.run();\n  }\n\n  #changeSyncCounters(pushDelta: 0, pullDelta: 1 | -1): void;\n  #changeSyncCounters(pushDelta: 1 | -1, pullDelta: 0): void;\n  #changeSyncCounters(pushDelta: number, pullDelta: number): void {\n    this.#pushCounter += pushDelta;\n    this.#pullCounter += pullDelta;\n    const delta = pushDelta + pullDelta;\n    const counter = this.#pushCounter + this.#pullCounter;\n    if ((delta === 1 && counter === 1) || counter === 0) {\n      const syncing = counter > 0;\n      // Run in a new microtask.\n      void Promise.resolve().then(() => this.onSync?.(syncing));\n    }\n  }\n\n  /**\n   * Subscribe to the result of a {@link query}. The `body` function is\n   * evaluated once and its results are returned via `onData`.\n   *\n   * Thereafter, each time the the result of `body` changes, `onData` is fired\n   * again with the new result.\n   *\n   * `subscribe()` goes to significant effort to avoid extraneous work\n   * re-evaluating subscriptions:\n   *\n   * 1. subscribe tracks the keys that `body` accesses each time it runs. `body`\n   *    is only re-evaluated when those keys change.\n   * 2. subscribe only re-fires `onData` in the case that a result changes by\n   *    way of the `isEqual` option which defaults to doing a deep JSON value\n   *    equality check.\n   *\n   * Because of (1), `body` must be a pure function of the data in Replicache.\n   * `body` must not access anything other than the `tx` parameter passed to it.\n   *\n   * Although subscribe is as efficient as it can be, it is somewhat constrained\n   * by the goal of returning an arbitrary computation of the cache. For even\n   * better performance (but worse dx), see {@link experimentalWatch}.\n   *\n   * If an error occurs in the `body` the `onError` function is called if\n   * present. Otherwise, the error is logged at log level 'error'.\n   *\n   * To cancel the subscription, call the returned function.\n   *\n   * @param body The function to evaluate to get the value to pass into\n   *    `onData`.\n   * @param options Options is either a function or an object. If it is a\n   *    function it is equivalent to passing it as the `onData` property of an\n   *    object.\n   */\n  subscribe<R>(\n    body: (tx: ReadTransaction) => Promise<R>,\n    options: SubscribeOptions<R> | ((result: R) => void),\n  ): () => void {\n    if (typeof options === 'function') {\n      options = {onData: options};\n    }\n\n    const {onData, onError, onDone, isEqual} = options;\n    return this.#subscriptions.add(\n      new SubscriptionImpl(body, onData, onError, onDone, isEqual),\n    );\n  }\n\n  /**\n   * Watches Replicache for changes.\n   *\n   * The `callback` gets called whenever the underlying data changes and the\n   * `key` changes matches the `prefix` of {@link ExperimentalWatchIndexOptions} or\n   * {@link ExperimentalWatchNoIndexOptions} if present. If a change\n   * occurs to the data but the change does not impact the key space the\n   * callback is not called. In other words, the callback is never called with\n   * an empty diff.\n   *\n   * This gets called after commit (a mutation or a rebase).\n   *\n   * @experimental This method is under development and its semantics will\n   * change.\n   */\n  experimentalWatch(callback: WatchNoIndexCallback): () => void;\n  experimentalWatch<Options extends WatchOptions>(\n    callback: WatchCallbackForOptions<Options>,\n    options?: Options,\n  ): () => void;\n  experimentalWatch<Options extends WatchOptions>(\n    callback: WatchCallbackForOptions<Options>,\n    options?: Options,\n  ): () => void {\n    return this.#subscriptions.add(\n      new WatchSubscription(callback as WatchCallback, options),\n    );\n  }\n\n  /**\n   * Query is used for read transactions. It is recommended to use transactions\n   * to ensure you get a consistent view across multiple calls to `get`, `has`\n   * and `scan`.\n   */\n  query<R>(body: (tx: ReadTransaction) => Promise<R> | R): Promise<R> {\n    return this.#queryInternal(body);\n  }\n\n  get cookie(): Promise<Cookie> {\n    return this.#ready.then(() =>\n      withRead(this.memdag, async dagRead => {\n        const mainHeadHash = await dagRead.getHead(DEFAULT_HEAD_NAME);\n        if (!mainHeadHash) {\n          throw new Error('Internal no main head found');\n        }\n        const baseSnapshot = await baseSnapshotFromHash(mainHeadHash, dagRead);\n        const baseSnapshotMeta = baseSnapshot.meta;\n        const cookie = baseSnapshotMeta.cookieJSON;\n        assertCookie(cookie);\n        return cookie;\n      }),\n    );\n  }\n\n  #queryInternal: QueryInternal = async body => {\n    await this.#ready;\n    const {clientID} = this;\n    return withRead(this.memdag, async dagRead => {\n      try {\n        const dbRead = await readFromDefaultHead(dagRead, FormatVersion.Latest);\n        const tx = new ReadTransactionImpl(clientID, dbRead, this.#lc);\n        return await body(tx);\n      } catch (ex) {\n        throw await this.#convertToClientStateNotFoundError(ex);\n      }\n    });\n  };\n\n  #register<Return extends ReadonlyJSONValue | void, Args extends JSONValue>(\n    name: string,\n    mutatorImpl: (tx: WriteTransaction, args?: Args) => MaybePromise<Return>,\n  ): (\n    args?: Args,\n  ) => Promise<Return> | {client: Promise<Return>; server: Promise<unknown>} {\n    this.#mutatorRegistry[name] = mutatorImpl as (\n      tx: WriteTransaction,\n      args: JSONValue | undefined,\n    ) => Promise<void | JSONValue>;\n\n    return (\n      args?: Args,\n    ):\n      | Promise<Return>\n      | {client: Promise<Return>; server: Promise<unknown>} => {\n      // DO NOT track CRUD mutations as they do not receive responses from\n      // the server.\n      const trackingData =\n        name === '_zero_crud' ? undefined : this.#zero?.trackMutation();\n\n      const result = this.#mutate(\n        trackingData,\n        name,\n        mutatorImpl,\n        args,\n        performance.now(),\n      );\n\n      if (trackingData) {\n        return {\n          client: result,\n          server: trackingData.serverPromise,\n        };\n      }\n\n      return result;\n    };\n  }\n\n  #registerMutators<\n    M extends {\n      [key: string]: (\n        tx: WriteTransaction,\n        args?: ReadonlyJSONValue,\n      ) => MutatorReturn;\n    },\n  >(regs: M): MakeMutators<M> {\n    type Mut = MakeMutators<M>;\n    const rv: Partial<Mut> = Object.create(null);\n    for (const k in regs) {\n      rv[k] = this.#register(k, regs[k]) as MakeMutator<M[typeof k]>;\n    }\n    return rv as Mut;\n  }\n\n  async #mutate<\n    R extends ReadonlyJSONValue | void,\n    A extends ReadonlyJSONValue,\n  >(\n    trackingData: MutationTrackingData | undefined,\n    name: string,\n    mutatorImpl: (tx: WriteTransaction, args?: A) => MaybePromise<R>,\n    args: A | undefined,\n    timestamp: number,\n  ): Promise<R> {\n    const frozenArgs = deepFreeze(args ?? null);\n\n    // Ensure that we run initial pending subscribe functions before starting a\n    // write transaction.\n    if (this.#subscriptions.hasPendingSubscriptionRuns) {\n      await Promise.resolve();\n    }\n\n    await this.#ready;\n    const {clientID} = this;\n    return withWriteNoImplicitCommit(this.memdag, async dagWrite => {\n      try {\n        let result: R;\n        let newHead: Hash;\n        let diffs: DiffsMap;\n        let headHash: Hash;\n        try {\n          headHash = await mustGetHeadHash(DEFAULT_HEAD_NAME, dagWrite);\n          const originalHash = null;\n\n          const dbWrite = await newWriteLocal(\n            headHash,\n            name,\n            frozenArgs,\n            originalHash,\n            dagWrite,\n            timestamp,\n            clientID,\n            FormatVersion.Latest,\n          );\n\n          const mutationID = await dbWrite.getMutationID();\n          const tx = new WriteTransactionImpl(\n            clientID,\n            mutationID,\n            'initial',\n            await this.#zero?.getTxData(headHash, {\n              openLazyRead: dagWrite,\n            }),\n            dbWrite,\n            this.#lc,\n          );\n\n          if (trackingData) {\n            this.#zero?.mutationIDAssigned(\n              trackingData.ephemeralID,\n              mutationID,\n            );\n          }\n\n          result = await mutatorImpl(tx, args);\n\n          throwIfClosed(dbWrite);\n          const lastMutationID = await dbWrite.getMutationID();\n          [newHead, diffs] = await dbWrite.commitWithDiffs(\n            DEFAULT_HEAD_NAME,\n            this.#subscriptions,\n          );\n\n          // Update this after the commit in case the commit fails.\n          this.lastMutationID = lastMutationID;\n        } catch (e) {\n          // If we threw before we could persist the mutation\n          // then we need to reject the mutation.\n          if (trackingData) {\n            this.#zero?.rejectMutation(trackingData.ephemeralID, e);\n          }\n          throw e;\n        }\n\n        this.#zero?.advance(headHash, newHead, diffs.get('') ?? []);\n\n        // Send is not supposed to reject\n        this.#pushConnectionLoop.send(false).catch(() => void 0);\n        await this.#subscriptions.fire(diffs);\n        void this.#schedulePersist();\n        return result;\n      } catch (ex) {\n        throw await this.#convertToClientStateNotFoundError(ex);\n      }\n    });\n  }\n\n  /**\n   * In the case we get a ChunkNotFoundError we check if the client got garbage\n   * collected and if so change the error to a ClientStateNotFoundError instead\n   */\n  async #convertToClientStateNotFoundError(ex: unknown): Promise<unknown> {\n    if (\n      ex instanceof ChunkNotFoundError &&\n      (await this.#checkForClientStateNotFoundAndCallHandler())\n    ) {\n      return new ClientStateNotFoundError(this.clientID);\n    }\n\n    return ex;\n  }\n\n  recoverMutations(): Promise<boolean> | void {\n    if (!process.env.DISABLE_MUTATION_RECOVERY) {\n      // oxlint-disable-next-line no-non-null-assertion\n      const result = this.#mutationRecovery!.recoverMutations(\n        this.#ready,\n        this.perdag,\n        this.#idbDatabase,\n        this.#idbDatabases,\n        this.#kvStoreProvider.create,\n      );\n      if (TESTING) {\n        void this.onRecoverMutations(result);\n      }\n      return result;\n    }\n  }\n\n  /**\n   * List of pending mutations. The order of this is from oldest to newest.\n   *\n   * Gives a list of local mutations that have `mutationID` >\n   * `syncHead.mutationID` that exists on the main client group.\n   *\n   * @experimental This method is experimental and may change in the future.\n   */\n  experimentalPendingMutations(): Promise<readonly PendingMutation[]> {\n    return withRead(this.memdag, pendingMutationsForAPI);\n  }\n}\n\n// This map is used to keep track of closing instances of Replicache. When an\n// instance is opening we wait for any currently closing instances.\nconst closingInstances: Map<string, Promise<unknown>> = new Map();\n\nasync function throwIfError(p: Promise<undefined | {error: unknown}>) {\n  const res = await p;\n  if (res) {\n    throw res.error;\n  }\n}\n\nfunction reload(): void {\n  if (typeof location !== 'undefined') {\n    location.reload();\n  }\n}\n\nfunction validateOptions<MD extends MutatorDefs>(\n  options: ReplicacheOptions<MD>,\n): void {\n  const {name, clientMaxAgeMs} = options;\n  if (typeof name !== 'string' || !name) {\n    throw new TypeError('name is required and must be non-empty');\n  }\n\n  if (clientMaxAgeMs !== undefined) {\n    const min = Math.max(GC_INTERVAL, HEARTBEAT_INTERVAL);\n    if (typeof clientMaxAgeMs !== 'number' || clientMaxAgeMs <= min) {\n      throw new TypeError(\n        `clientAgeMaxMs must be a number larger than ${min}ms`,\n      );\n    }\n  }\n}\n"],"mappings":"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"}

package/out/packages/replicache/src/report-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-error.js","names":[],"sources":["../../../../../replicache/src/report-error.ts"],"sourcesContent":["/**\n * Wrapper error class that should be reported as error (logger.error)\n */\nexport class ReportError extends Error {}\n"],"mappings":";;;;AAGA,IAAa,cAAb,cAAiC,MAAM,CAAC"}

package/out/packages/replicache/src/request-idle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-idle.js","names":[],"sources":["../../../../../replicache/src/request-idle.ts"],"sourcesContent":["// TODO(arv): Remove workaround once docs/ builds cleanly without this.\ndeclare function requestIdleCallback(\n  callback: () => void,\n  options?: {timeout?: number},\n): number;\n\n/**\n * A Promise wrapper for requestIdleCallback with fallback to setTimeout for\n * browsers without support (aka Safari)\n */\nexport function requestIdle(timeout: number): Promise<void> {\n  return new Promise(resolve => {\n    if (typeof requestIdleCallback === 'function') {\n      requestIdleCallback(() => resolve(), {timeout});\n    } else {\n      setTimeout(resolve, timeout);\n    }\n  });\n}\n"],"mappings":";;;;;AAUA,SAAgB,YAAY,SAAgC;CAC1D,OAAO,IAAI,SAAQ,YAAW;EAC5B,IAAI,OAAO,wBAAwB,YACjC,0BAA0B,QAAQ,GAAG,EAAC,QAAO,CAAC;OAE9C,WAAW,SAAS,OAAO;CAE/B,CAAC;AACH"}

package/out/packages/replicache/src/scan-iterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-iterator.js","names":["#iter","#options","#dbDelegateOptions","#onLimitKey","#newIterator","#it"],"sources":["../../../../../replicache/src/scan-iterator.ts"],"sourcesContent":["import {greaterThan} from 'compare-utf8';\nimport type {ReadonlyJSONValue} from '../../shared/src/json.ts';\nimport {asyncIterableToArray} from './async-iterable-to-array.ts';\nimport {type IndexKey, encodeIndexScanKey} from './db/index.ts';\nimport type {IterableUnion} from './iterable-union.ts';\nimport {\n  type KeyTypeForScanOptions,\n  type ScanIndexOptions,\n  type ScanOptionIndexedStartKey,\n  type ScanOptions,\n  isScanIndexOptions,\n  normalizeScanOptionIndexedStartKey,\n} from './scan-options.ts';\nimport {type Closed, throwIfClosed} from './transaction-closed-error.ts';\nimport {type EntryForOptions, fromKeyForNonIndexScan} from './transactions.ts';\n\ntype ScanKey = string | IndexKey;\n\ntype ToValue<Options extends ScanOptions, Value> = (\n  entry: EntryForOptions<Options, ReadonlyJSONValue>,\n) => Value;\n\n/**\n * This class is used for the results of {@link ReadTransaction.scan | scan}. It\n * implements `AsyncIterable<JSONValue>` which allows you to use it in a `for\n * await` loop. There are also methods to iterate over the {@link keys},\n * {@link entries} or {@link values}.\n */\nexport class ScanResultImpl<\n  Options extends ScanOptions,\n  V,\n> implements ScanResult<KeyTypeForScanOptions<Options>, V> {\n  readonly #iter: AsyncIterable<EntryForOptions<Options, ReadonlyJSONValue>>;\n  readonly #options: Options;\n  readonly #dbDelegateOptions: Closed;\n  readonly #onLimitKey: (inclusiveLimitKey: string) => void;\n\n  constructor(\n    iter: AsyncIterable<EntryForOptions<Options, ReadonlyJSONValue>>,\n    options: Options,\n    dbDelegateOptions: Closed,\n    onLimitKey: (inclusiveLimitKey: string) => void,\n  ) {\n    this.#iter = iter;\n    this.#options = options;\n    this.#dbDelegateOptions = dbDelegateOptions;\n    this.#onLimitKey = onLimitKey;\n  }\n\n  /** The default AsyncIterable. This is the same as {@link values}. */\n  [Symbol.asyncIterator](): AsyncIterableIteratorToArray<V> {\n    return this.values();\n  }\n\n  /** Async iterator over the values of the {@link ReadTransaction.scan | scan} call. */\n  values(): AsyncIterableIteratorToArray<V> {\n    return new AsyncIterableIteratorToArrayWrapperImpl(\n      this.#newIterator(e => e[1] as V),\n    );\n  }\n\n  /**\n   * Async iterator over the keys of the {@link ReadTransaction.scan | scan}\n   * call. If the {@link ReadTransaction.scan | scan} is over an index the key\n   * is a tuple of `[secondaryKey: string, primaryKey]`\n   */\n  keys(): AsyncIterableIteratorToArray<KeyTypeForScanOptions<Options>> {\n    type K = KeyTypeForScanOptions<Options>;\n    return new AsyncIterableIteratorToArrayWrapperImpl<K>(\n      this.#newIterator<K>(e => e[0] as K),\n    );\n  }\n\n  /**\n   * Async iterator over the entries of the {@link ReadTransaction.scan | scan}\n   * call. An entry is a tuple of key values. If the\n   * {@link ReadTransaction.scan | scan} is over an index the key is a tuple of\n   * `[secondaryKey: string, primaryKey]`\n   */\n  entries(): AsyncIterableIteratorToArray<\n    readonly [KeyTypeForScanOptions<Options>, V]\n  > {\n    type Key = KeyTypeForScanOptions<Options>;\n    type Entry = readonly [Key, V];\n    return new AsyncIterableIteratorToArrayWrapperImpl(\n      this.#newIterator<Entry>(e => [e[0] as Key, e[1] as V]),\n    );\n  }\n\n  /** Returns all the values as an array. Same as `values().toArray()` */\n  toArray(): Promise<V[]> {\n    return this.values().toArray();\n  }\n\n  #newIterator<T>(toValue: ToValue<Options, T>): AsyncIterableIterator<T> {\n    return scanIterator(\n      toValue,\n      this.#iter,\n      this.#options,\n      this.#dbDelegateOptions,\n      this.#onLimitKey,\n    );\n  }\n}\n\nexport interface ScanResult<K extends ScanKey, V> extends AsyncIterable<V> {\n  /** The default AsyncIterable. This is the same as {@link values}. */\n  [Symbol.asyncIterator](): AsyncIterableIteratorToArray<V>;\n\n  /** Async iterator over the values of the {@link ReadTransaction.scan | scan} call. */\n  values(): AsyncIterableIteratorToArray<V>;\n\n  /**\n   * Async iterator over the keys of the {@link ReadTransaction.scan | scan}\n   * call. If the {@link ReadTransaction.scan | scan} is over an index the key\n   * is a tuple of `[secondaryKey: string, primaryKey]`\n   */\n  keys(): AsyncIterableIteratorToArray<K>;\n\n  /**\n   * Async iterator over the entries of the {@link ReadTransaction.scan | scan}\n   * call. An entry is a tuple of key values. If the\n   * {@link ReadTransaction.scan | scan} is over an index the key is a tuple of\n   * `[secondaryKey: string, primaryKey]`\n   */\n  entries(): AsyncIterableIteratorToArray<readonly [K, V]>;\n\n  /** Returns all the values as an array. Same as `values().toArray()` */\n  toArray(): Promise<V[]>;\n}\n\n/**\n * An interface that adds a {@link toArray} method to `AsyncIterableIterator`.\n *\n * Usage:\n *\n * ```ts\n * const keys: string[] = await rep.scan().keys().toArray();\n * ```\n */\nexport interface AsyncIterableIteratorToArray<\n  V,\n> extends AsyncIterableIterator<V> {\n  toArray(): Promise<V[]>;\n}\n\nclass AsyncIterableIteratorToArrayWrapperImpl<\n  V,\n> implements AsyncIterableIterator<V> {\n  readonly #it: AsyncIterableIterator<V>;\n\n  constructor(it: AsyncIterableIterator<V>) {\n    this.#it = it;\n  }\n\n  next() {\n    return this.#it.next();\n  }\n\n  [Symbol.asyncIterator](): AsyncIterableIterator<V> {\n    return this.#it[Symbol.asyncIterator]();\n  }\n\n  toArray(): Promise<V[]> {\n    return asyncIterableToArray(this.#it);\n  }\n}\n\nasync function* scanIterator<Options extends ScanOptions, Value>(\n  toValue: ToValue<Options, Value>,\n  iter: AsyncIterable<EntryForOptions<Options, ReadonlyJSONValue>>,\n  options: Options,\n  closed: Closed,\n  onLimitKey: (inclusiveLimitKey: string) => void,\n): AsyncIterableIterator<Value> {\n  throwIfClosed(closed);\n\n  let {limit = Infinity} = options;\n  const {prefix = ''} = options;\n  let exclusive = options.start?.exclusive;\n\n  const isIndexScan = isScanIndexOptions(options);\n\n  // iter has already been moved to the first entry\n  for await (const entry of iter) {\n    const key = entry[0];\n    const keyToMatch: string = isIndexScan ? key[0] : (key as string);\n    if (!keyToMatch.startsWith(prefix)) {\n      return;\n    }\n\n    if (exclusive) {\n      exclusive = true;\n      if (isIndexScan) {\n        // oxlint-disable-next-line @typescript-eslint/no-non-null-assertion\n        if (shouldSkipIndexScan(key as IndexKey, options.start!.key)) {\n          continue;\n        }\n      } else {\n        // oxlint-disable-next-line @typescript-eslint/no-non-null-assertion\n        if (shouldSkipNonIndexScan(key as string, options.start!.key)) {\n          continue;\n        }\n      }\n    }\n\n    yield toValue(entry);\n\n    if (--limit === 0) {\n      // We do not do the limit optimization for index scans in subscriptions.\n      if (!isIndexScan) {\n        onLimitKey(key as string);\n      }\n      return;\n    }\n  }\n}\n\nfunction shouldSkipIndexScan(\n  key: IndexKey,\n  startKey: ScanOptionIndexedStartKey,\n): boolean {\n  const [secondaryStartKey, primaryStartKey] =\n    normalizeScanOptionIndexedStartKey(startKey);\n  const [secondaryKey, primaryKey] = normalizeScanOptionIndexedStartKey(key);\n  if (secondaryKey !== secondaryStartKey) {\n    return false;\n  }\n  if (primaryStartKey === undefined) {\n    return true;\n  }\n  return primaryKey === primaryStartKey;\n}\n\nfunction shouldSkipNonIndexScan(key: string, startKey: string): boolean {\n  return key === startKey;\n}\n\nexport type Entry<V> = readonly [key: string, value: V];\n\n/**\n * This is called when doing a {@link ReadTransaction.scan | scan} without an\n * `indexName`.\n *\n * @param fromKey The `fromKey` is computed by `scan` and is the key of the\n * first entry to return in the iterator. It is based on `prefix` and\n * `start.key` of the {@link ScanNoIndexOptions}.\n */\nexport type GetScanIterator = (\n  fromKey: string,\n) => IterableUnion<Entry<ReadonlyJSONValue>>;\n\n/**\n * When using {@link makeScanResult} this is the type used for the function called when doing a {@link ReadTransaction.scan | scan} with an\n * `indexName`.\n *\n * @param indexName The name of the index we are scanning over.\n * @param fromSecondaryKey The `fromSecondaryKey` is computed by `scan` and is\n * the secondary key of the first entry to return in the iterator. It is based\n * on `prefix` and `start.key` of the {@link ScanIndexOptions}.\n * @param fromPrimaryKey The `fromPrimaryKey` is computed by `scan` and is the\n * primary key of the first entry to return in the iterator. It is based on\n * `prefix` and `start.key` of the {@link ScanIndexOptions}.\n */\nexport type GetIndexScanIterator = (\n  indexName: string,\n  fromSecondaryKey: string,\n  fromPrimaryKey: string | undefined,\n) => IterableUnion<readonly [key: IndexKey, value: ReadonlyJSONValue]>;\n\n/**\n * A helper function that makes it easier to implement {@link ReadTransaction.scan}\n * with a custom backend.\n *\n * If you are implementing a custom backend and have an in memory pending async\n * iterable we provide two helper functions to make it easier to merge these\n * together. {@link mergeAsyncIterables} and {@link filterAsyncIterable}.\n *\n * For example:\n *\n * ```ts\n * const scanResult = makeScanResult(\n *   options,\n *   options.indexName\n *     ? () => {\n *         throw Error('not implemented');\n *       }\n *     : fromKey => {\n *         const persisted: AsyncIterable<Entry<ReadonlyJSONValue>> = ...;\n *         const pending: AsyncIterable<Entry<ReadonlyJSONValue | undefined>> = ...;\n *         const iter = await mergeAsyncIterables(persisted, pending);\n *         const filteredIter = await filterAsyncIterable(\n *           iter,\n *           entry => entry[1] !== undefined,\n *         );\n *         return filteredIter;\n *       },\n * );\n * ```\n */\nexport function makeScanResult<Options extends ScanOptions>(\n  options: Options,\n  getScanIterator: Options extends ScanIndexOptions\n    ? GetIndexScanIterator\n    : GetScanIterator,\n): ScanResult<KeyTypeForScanOptions<Options>, ReadonlyJSONValue> {\n  type AsyncIter = AsyncIterable<EntryForOptions<Options, ReadonlyJSONValue>>;\n\n  if (isScanIndexOptions(options)) {\n    const [fromSecondaryKey, fromPrimaryKey] = fromKeyForIndexScan(options);\n    return new ScanResultImpl(\n      (getScanIterator as GetIndexScanIterator)(\n        options.indexName,\n        fromSecondaryKey,\n        fromPrimaryKey,\n      ) as AsyncIter,\n      options,\n      {closed: false},\n      _ => {\n        // noop\n      },\n    );\n  }\n  const fromKey = fromKeyForNonIndexScan(options);\n  return new ScanResultImpl(\n    (getScanIterator as GetScanIterator)(fromKey) as AsyncIter,\n    options,\n    {closed: false},\n    _ => {\n      // noop\n    },\n  );\n}\n\nexport function fromKeyForIndexScan(\n  options: ScanIndexOptions,\n): readonly [secondary: string, primary?: string | undefined] {\n  const {prefix, start} = options;\n  const prefixNormalized: [secondary: string, primary?: string | undefined] = [\n    prefix ?? '',\n    undefined,\n  ];\n\n  if (!start) {\n    return prefixNormalized;\n  }\n\n  const startKeyNormalized = normalizeScanOptionIndexedStartKey(start.key);\n  if (greaterThan(startKeyNormalized[0], prefixNormalized[0])) {\n    return startKeyNormalized;\n  }\n  if (\n    startKeyNormalized[0] === prefixNormalized[0] &&\n    startKeyNormalized[1] !== undefined\n  ) {\n    return startKeyNormalized;\n  }\n\n  return prefixNormalized;\n}\n\nexport function fromKeyForIndexScanInternal(options: ScanIndexOptions): string {\n  const {prefix, start} = options;\n  let prefix2 = '';\n  if (prefix !== undefined) {\n    prefix2 = encodeIndexScanKey(prefix, undefined);\n  }\n  if (!start) {\n    return prefix2;\n  }\n\n  const {key} = start;\n  const [secondary, primary] = normalizeScanOptionIndexedStartKey(key);\n  const startKey = encodeIndexScanKey(secondary, primary);\n\n  if (greaterThan(startKey, prefix2)) {\n    return startKey;\n  }\n\n  return prefix2;\n}\n"],"mappings":";;;;;;;;;;;;;AA4BA,IAAa,iBAAb,MAG2D;CACzD;CACA;CACA;CACA;CAEA,YACE,MACA,SACA,mBACA,YACA;EACA,KAAKA,QAAQ;EACb,KAAKC,WAAW;EAChB,KAAKC,qBAAqB;EAC1B,KAAKC,cAAc;CACrB;;CAGA,CAAC,OAAO,iBAAkD;EACxD,OAAO,KAAK,OAAO;CACrB;;CAGA,SAA0C;EACxC,OAAO,IAAI,wCACT,KAAKC,cAAa,MAAK,EAAE,EAAO,CAClC;CACF;;;;;;CAOA,OAAqE;EAEnE,OAAO,IAAI,wCACT,KAAKA,cAAgB,MAAK,EAAE,EAAO,CACrC;CACF;;;;;;;CAQA,UAEE;EAGA,OAAO,IAAI,wCACT,KAAKA,cAAoB,MAAK,CAAC,EAAE,IAAW,EAAE,EAAO,CAAC,CACxD;CACF;;CAGA,UAAwB;EACtB,OAAO,KAAK,OAAO,EAAE,QAAQ;CAC/B;CAEA,aAAgB,SAAwD;EACtE,OAAO,aACL,SACA,KAAKJ,OACL,KAAKC,UACL,KAAKC,oBACL,KAAKC,WACP;CACF;AACF;AA2CA,IAAM,0CAAN,MAEsC;CACpC;CAEA,YAAY,IAA8B;EACxC,KAAKE,MAAM;CACb;CAEA,OAAO;EACL,OAAO,KAAKA,IAAI,KAAK;CACvB;CAEA,CAAC,OAAO,iBAA2C;EACjD,OAAO,KAAKA,IAAI,OAAO,eAAe;CACxC;CAEA,UAAwB;EACtB,OAAO,qBAAqB,KAAKA,GAAG;CACtC;AACF;AAEA,gBAAgB,aACd,SACA,MACA,SACA,QACA,YAC8B;CAC9B,cAAc,MAAM;CAEpB,IAAI,EAAC,QAAQ,aAAY;CACzB,MAAM,EAAC,SAAS,OAAM;CACtB,IAAI,YAAY,QAAQ,OAAO;CAE/B,MAAM,cAAc,mBAAmB,OAAO;CAG9C,WAAW,MAAM,SAAS,MAAM;EAC9B,MAAM,MAAM,MAAM;EAElB,IAAI,EADuB,cAAc,IAAI,KAAM,KACnC,WAAW,MAAM,GAC/B;EAGF,IAAI,WAAW;GACb,YAAY;GACZ,IAAI;QAEE,oBAAoB,KAAiB,QAAQ,MAAO,GAAG,GACzD;GAAA,OAIF,IAAI,uBAAuB,KAAe,QAAQ,MAAO,GAAG,GAC1D;EAGN;EAEA,MAAM,QAAQ,KAAK;EAEnB,IAAI,EAAE,UAAU,GAAG;GAEjB,IAAI,CAAC,aACH,WAAW,GAAa;GAE1B;EACF;CACF;AACF;AAEA,SAAS,oBACP,KACA,UACS;CACT,MAAM,CAAC,mBAAmB,mBACxB,mCAAmC,QAAQ;CAC7C,MAAM,CAAC,cAAc,cAAc,mCAAmC,GAAG;CACzE,IAAI,iBAAiB,mBACnB,OAAO;CAET,IAAI,oBAAoB,KAAA,GACtB,OAAO;CAET,OAAO,eAAe;AACxB;AAEA,SAAS,uBAAuB,KAAa,UAA2B;CACtE,OAAO,QAAQ;AACjB;AA6HA,SAAgB,4BAA4B,SAAmC;CAC7E,MAAM,EAAC,QAAQ,UAAS;CACxB,IAAI,UAAU;CACd,IAAI,WAAW,KAAA,GACb,UAAU,mBAAmB,QAAQ,KAAA,CAAS;CAEhD,IAAI,CAAC,OACH,OAAO;CAGT,MAAM,EAAC,QAAO;CACd,MAAM,CAAC,WAAW,WAAW,mCAAmC,GAAG;CACnE,MAAM,WAAW,mBAAmB,WAAW,OAAO;CAEtD,IAAI,YAAY,UAAU,OAAO,GAC/B,OAAO;CAGT,OAAO;AACT"}

package/out/packages/replicache/src/scan-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-options.js","names":[],"sources":["../../../../../replicache/src/scan-options.ts"],"sourcesContent":["import type {IndexKey} from './db/index.ts';\nimport type {ScanOptions as DbScanOptions} from './db/scan.ts';\n\n/**\n * Options for {@link ReadTransaction.scan | scan}\n */\nexport type ScanOptions = ScanIndexOptions | ScanNoIndexOptions;\n\n/**\n * Options for {@link ReadTransaction.scan | scan} when scanning over the entire key\n * space.\n */\nexport type ScanNoIndexOptions = {\n  /** Only include keys starting with `prefix`. */\n  prefix?: string | undefined;\n\n  /** Only include up to `limit` results. */\n  limit?: number | undefined;\n\n  /** When provided the scan starts at this key. */\n  start?:\n    | {\n        key: string;\n\n        /** Whether the `key` is exclusive or inclusive. */\n        exclusive?: boolean | undefined;\n      }\n    | undefined;\n};\n\n/**\n * Options for {@link ReadTransaction.scan | scan} when scanning over an index. When\n * scanning over and index you need to provide the `indexName` and the `start`\n * `key` is now a tuple consisting of secondary and primary key\n */\nexport type ScanIndexOptions = {\n  /** Only include results starting with the *secondary* keys starting with `prefix`. */\n  prefix?: string | undefined;\n\n  /** Only include up to `limit` results. */\n  limit?: number | undefined;\n\n  /** Do a {@link ReadTransaction.scan | scan} over a named index. The `indexName` is\n   * the name of an index defined when creating the {@link Replicache} instance using\n   * {@link ReplicacheOptions.indexes}. */\n  indexName: string;\n\n  /** When provided the scan starts at this key. */\n  start?:\n    | {\n        key: ScanOptionIndexedStartKey;\n\n        /** Whether the `key` is exclusive or inclusive. */\n        exclusive?: boolean | undefined;\n      }\n    | undefined;\n};\n\n/**\n * Type narrowing of {@link ScanOptions}.\n */\nexport function isScanIndexOptions(\n  options: ScanOptions,\n): options is ScanIndexOptions {\n  return (options as ScanIndexOptions).indexName !== undefined;\n}\n\n/**\n * If the options contains an `indexName` then the key type is a tuple of\n * secondary and primary.\n */\nexport type KeyTypeForScanOptions<O extends ScanOptions> =\n  O extends ScanIndexOptions ? IndexKey : string;\n\n/**\n * The key to start scanning at.\n *\n * If you are scanning the primary index (i.e., you did not specify\n * `indexName`), then pass a single string for this field, which is the key in\n * the primary index to scan at.\n *\n * If you are scanning a secondary index (i.e., you specified `indexName`), then\n * use the tuple form. In that case, `secondary` is the secondary key to start\n * scanning at, and `primary` (if any) is the primary key to start scanning at.\n */\nexport type ScanOptionIndexedStartKey =\n  | readonly [secondary: string, primary?: string | undefined]\n  | string;\n\nexport function normalizeScanOptionIndexedStartKey(\n  startKey: string | readonly [secondary: string, primary?: string | undefined],\n): readonly [secondary: string, primary?: string | undefined] {\n  if (typeof startKey === 'string') {\n    return [startKey];\n  }\n  return startKey;\n}\n\nexport function toDbScanOptions(options?: ScanOptions): DbScanOptions {\n  if (!options) {\n    return {};\n  }\n  let key: string | ScanOptionIndexedStartKey | undefined;\n  let exclusive: boolean | undefined;\n  let primary: string | undefined;\n  let secondary: string | undefined;\n  type MaybeIndexName = {indexName?: string};\n  if (options.start) {\n    ({key, exclusive} = options.start);\n    if ((options as MaybeIndexName).indexName) {\n      if (typeof key === 'string') {\n        secondary = key;\n      } else {\n        secondary = key[0];\n        primary = key[1];\n      }\n    } else {\n      primary = key as string;\n    }\n  }\n\n  return {\n    prefix: options.prefix,\n    startSecondaryKey: secondary,\n    startKey: primary,\n    startExclusive: exclusive,\n    limit: options.limit,\n    indexName: (options as MaybeIndexName).indexName,\n  };\n}\n"],"mappings":";;;;AA6DA,SAAgB,mBACd,SAC6B;CAC7B,OAAQ,QAA6B,cAAc,KAAA;AACrD;AAwBA,SAAgB,mCACd,UAC4D;CAC5D,IAAI,OAAO,aAAa,UACtB,OAAO,CAAC,QAAQ;CAElB,OAAO;AACT;AAEA,SAAgB,gBAAgB,SAAsC;CACpE,IAAI,CAAC,SACH,OAAO,CAAC;CAEV,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,IAAI,QAAQ,OAAO;EACjB,CAAC,CAAC,KAAK,aAAa,QAAQ;EAC5B,IAAK,QAA2B,WAC9B,IAAI,OAAO,QAAQ,UACjB,YAAY;OACP;GACL,YAAY,IAAI;GAChB,UAAU,IAAI;EAChB;OAEA,UAAU;CAEd;CAEA,OAAO;EACL,QAAQ,QAAQ;EAChB,mBAAmB;EACnB,UAAU;EACV,gBAAgB;EAChB,OAAO,QAAQ;EACf,WAAY,QAA2B;CACzC;AACF"}

package/out/packages/replicache/src/set-interval-with-signal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-interval-with-signal.js","names":[],"sources":["../../../../../replicache/src/set-interval-with-signal.ts"],"sourcesContent":["export function setIntervalWithSignal(\n  fn: () => void,\n  ms: number,\n  signal: AbortSignal,\n): void {\n  if (!signal.aborted) {\n    const interval = setInterval(fn, ms);\n    signal.addEventListener('abort', () => {\n      clearInterval(interval);\n    });\n  }\n}\n"],"mappings":";AAAA,SAAgB,sBACd,IACA,IACA,QACM;CACN,IAAI,CAAC,OAAO,SAAS;EACnB,MAAM,WAAW,YAAY,IAAI,EAAE;EACnC,OAAO,iBAAiB,eAAe;GACrC,cAAc,QAAQ;EACxB,CAAC;CACH;AACF"}

package/out/packages/replicache/src/subscriptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions.js","names":["#body","#onData","#isEqual","#scans","#keys","#lastValue","#callback","#prefix","#indexName","#initialValuesInFirstDiff","#subscriptions","#pendingSubscriptions","#queryInternal","#lc","#signal","#scheduleInitialSubscriptionRun","#fireSubscriptions"],"sources":["../../../../../replicache/src/subscriptions.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {compareUTF8, greaterThan, lessThan, lessThanEq} from 'compare-utf8';\nimport {assert} from '../../shared/src/asserts.ts';\nimport {binarySearch} from '../../shared/src/binary-search.ts';\nimport type {Enum} from '../../shared/src/enum.ts';\nimport {deepEqual} from '../../shared/src/json.ts';\nimport type {\n  Diff,\n  DiffOperation,\n  IndexDiff,\n  InternalDiff,\n  InternalDiffOperation,\n  NoIndexDiff,\n} from './btree/node.ts';\nimport type {IndexKey} from './db/index.ts';\nimport {decodeIndexKey} from './db/index.ts';\nimport type {ScanOptions} from './db/scan.ts';\nimport * as InvokeKind from './invoke-kind-enum.ts';\nimport type {DiffComputationConfig, DiffsMap} from './sync/diff.ts';\nimport {\n  type ReadTransaction,\n  SubscriptionTransactionWrapper,\n} from './transactions.ts';\nimport type {QueryInternal} from './types.ts';\n\ntype InvokeKind = Enum<typeof InvokeKind>;\n\nexport interface Subscription<R> {\n  hasIndexSubscription(indexName: string): boolean;\n\n  invoke(\n    tx: ReadTransaction,\n    kind: InvokeKind,\n    diffs: DiffsMap | undefined,\n  ): Promise<R>;\n\n  matches(diffs: DiffsMap): boolean;\n\n  updateDeps(\n    keys: ReadonlySet<string>,\n    scans: ReadonlyArray<Readonly<ScanSubscriptionInfo>>,\n  ): void;\n\n  readonly onData: (result: R) => void;\n  readonly onError: ((error: unknown) => void) | undefined;\n  readonly onDone: (() => void) | undefined;\n}\n\nconst emptySet: ReadonlySet<string> = new Set();\n\nconst unitializedLastValue = Symbol();\ntype UnitializedLastValue = typeof unitializedLastValue;\n\nexport class SubscriptionImpl<R> implements Subscription<R> {\n  readonly #body: (tx: ReadTransaction) => Promise<R>;\n  readonly #onData: (result: R) => void;\n  #lastValue: R | UnitializedLastValue = unitializedLastValue;\n  #keys = emptySet;\n  #scans: readonly Readonly<ScanSubscriptionInfo>[] = [];\n\n  readonly onError: ((error: unknown) => void) | undefined;\n  readonly onDone: (() => void) | undefined;\n  readonly #isEqual: (a: R, b: R) => boolean;\n\n  constructor(\n    body: (tx: ReadTransaction) => Promise<R>,\n    onData: (result: R) => void,\n    onError: ((error: unknown) => void) | undefined,\n    onDone: (() => void) | undefined,\n    // deepEqual operates on any JSON value but argument might be more specific.\n    isEqual: (a: R, b: R) => boolean = deepEqual as (a: R, b: R) => boolean,\n  ) {\n    this.#body = body;\n    this.#onData = onData;\n    this.onError = onError;\n    this.onDone = onDone;\n    this.#isEqual = isEqual;\n  }\n\n  hasIndexSubscription(indexName: string): boolean {\n    for (const scan of this.#scans) {\n      if (scan.options.indexName === indexName) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  invoke(\n    tx: ReadTransaction,\n    _kind: InvokeKind,\n    _diffs: DiffsMap | undefined,\n  ): Promise<R> {\n    return this.#body(tx);\n  }\n\n  matches(diffs: DiffsMap): boolean {\n    for (const [indexName, diff] of diffs) {\n      if (diffMatchesSubscription(this.#keys, this.#scans, indexName, diff)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  updateDeps(\n    keys: ReadonlySet<string>,\n    scans: readonly Readonly<ScanSubscriptionInfo>[],\n  ): void {\n    this.#keys = keys;\n    this.#scans = scans;\n  }\n\n  onData(result: R): void {\n    if (\n      this.#lastValue === unitializedLastValue ||\n      !this.#isEqual(this.#lastValue, result)\n    ) {\n      this.#lastValue = result;\n      this.#onData(result);\n    }\n  }\n}\n\nexport {SubscriptionImpl as SubscriptionImplForTesting};\n\n/**\n * Function that gets passed into {@link Replicache.experimentalWatch} and gets\n * called when the data in Replicache changes.\n *\n * @experimental This type is experimental and may change in the future.\n */\nexport type WatchNoIndexCallback = (diff: NoIndexDiff) => void;\n\nexport type WatchCallbackForOptions<Options extends WatchOptions> =\n  Options extends WatchIndexOptions ? WatchIndexCallback : WatchNoIndexCallback;\n\n/**\n * Function that gets passed into {@link Replicache.experimentalWatch} when doing a\n * watch on a secondary index map and gets called when the data in Replicache\n * changes.\n *\n * @experimental This type is experimental and may change in the future.\n */\nexport type WatchIndexCallback = (diff: IndexDiff) => void;\n\n/**\n * Options for {@link Replicache.experimentalWatch}.\n *\n * @experimental This interface is experimental and may change in the future.\n */\nexport type WatchOptions = WatchIndexOptions | WatchNoIndexOptions;\n\n/**\n * Options object passed to {@link Replicache.experimentalWatch}. This is for an\n * index watch.\n */\nexport type WatchIndexOptions = WatchNoIndexOptions & {\n  /**\n   * When provided, the `watch` is limited to the changes that apply to the index map.\n   */\n  indexName: string;\n};\n\n/**\n * Options object passed to {@link Replicache.experimentalWatch}. This is for a non\n * index watch.\n */\nexport type WatchNoIndexOptions = {\n  /**\n   * When provided, the `watch` is limited to changes where the `key` starts\n   * with `prefix`.\n   */\n  prefix?: string | undefined;\n\n  /**\n   * When this is set to `true` (default is `false`), the `watch` callback will\n   * be called once asynchronously when watch is called. The arguments in that\n   * case is a diff where we consider all the existing values in Replicache as\n   * being added.\n   */\n  initialValuesInFirstDiff?: boolean | undefined;\n};\n\nexport type WatchCallback = (diff: Diff) => void;\n\nexport class WatchSubscription implements Subscription<Diff | undefined> {\n  readonly #callback: WatchCallback;\n  readonly #prefix: string;\n  readonly #indexName: string | undefined;\n  readonly #initialValuesInFirstDiff: boolean;\n\n  readonly onError: ((error: unknown) => void) | undefined = undefined;\n  readonly onDone: (() => void) | undefined = undefined;\n\n  constructor(callback: WatchCallback, options?: WatchOptions) {\n    this.#callback = callback;\n    this.#prefix = options?.prefix ?? '';\n    this.#indexName = (options as WatchIndexOptions)?.indexName;\n    this.#initialValuesInFirstDiff = options?.initialValuesInFirstDiff ?? false;\n  }\n\n  hasIndexSubscription(indexName: string): boolean {\n    return this.#indexName === indexName;\n  }\n\n  onData(result: Diff | undefined): void {\n    if (result !== undefined) {\n      this.#callback(result);\n    }\n  }\n\n  invoke(\n    tx: ReadTransaction,\n    kind: InvokeKind,\n    diffs: DiffsMap | undefined,\n  ): Promise<Diff | undefined> {\n    const invoke = async <Key extends IndexKey | string>(\n      indexName: string | undefined,\n      prefix: string,\n      compareKey: (diff: DiffOperation<Key>) => string,\n      convertInternalDiff: (\n        diff: InternalDiff,\n      ) => readonly DiffOperation<Key>[],\n    ): Promise<readonly DiffOperation<Key>[] | undefined> => {\n      let diff: readonly DiffOperation<Key>[];\n      if (kind === InvokeKind.InitialRun) {\n        if (!this.#initialValuesInFirstDiff) {\n          // We are using `undefined` here as a sentinel value to indicate that we\n          // should not call the callback in `onDone`.\n          return undefined;\n        }\n\n        // For the initial run, we need to get the \"diffs\" for the whole tree.\n        assert(\n          diffs === undefined,\n          'Expected diffs to be undefined on initial run',\n        );\n\n        const newDiff: DiffOperation<Key>[] = [];\n        for await (const entry of tx.scan({prefix, indexName}).entries()) {\n          newDiff.push({\n            op: 'add',\n            key: entry[0] as Key,\n            newValue: entry[1],\n          });\n        }\n        diff = newDiff;\n      } else {\n        assert(diffs, 'Expected diffs to be defined for non-initial run');\n        const maybeDiff = diffs.get(indexName ?? '') ?? [];\n        diff = convertInternalDiff(maybeDiff);\n      }\n      const newDiff: DiffOperation<Key>[] = [];\n      const {length} = diff;\n      for (\n        let i = diffBinarySearch(diff, prefix, compareKey);\n        i < length;\n        i++\n      ) {\n        if (compareKey(diff[i]).startsWith(prefix)) {\n          newDiff.push(diff[i]);\n        } else {\n          break;\n        }\n      }\n\n      // For initial run we should always return something.\n      return kind === InvokeKind.InitialRun || newDiff.length > 0\n        ? newDiff\n        : undefined;\n    };\n\n    if (this.#indexName) {\n      return invoke<IndexKey>(\n        this.#indexName,\n        this.#prefix,\n        diff => diff.key[0],\n        internalDiff => convertDiffValues(internalDiff, decodeIndexKey),\n      );\n    }\n\n    return invoke<string>(\n      undefined,\n      this.#prefix,\n      diff => diff.key,\n      internalDiff => convertDiffValues(internalDiff, k => k),\n    );\n  }\n\n  matches(diffs: DiffsMap): boolean {\n    const diff = diffs.get(this.#indexName ?? '');\n    if (diff === undefined) {\n      return false;\n    }\n\n    return watcherMatchesDiff(diff, this.#prefix, this.#indexName);\n  }\n\n  updateDeps(\n    _keys: ReadonlySet<string>,\n    _scans: readonly Readonly<ScanSubscriptionInfo>[],\n  ): void {\n    // not used\n  }\n}\n\nfunction convertDiffValues<Key>(\n  diff: InternalDiff,\n  convertKey: (k: string) => Key,\n): DiffOperation<Key>[] {\n  return diff.map(op => {\n    const key = convertKey(op.key);\n    switch (op.op) {\n      case 'add':\n        return {\n          op: 'add',\n          key,\n          newValue: op.newValue,\n        };\n      case 'change':\n        return {\n          op: 'change',\n          key,\n          oldValue: op.oldValue,\n          newValue: op.newValue,\n        };\n      case 'del':\n        return {\n          op: 'del',\n          key,\n          oldValue: op.oldValue,\n        };\n    }\n  });\n}\n\n/**\n * The options passed to {@link Replicache.subscribe}.\n */\nexport interface SubscribeOptions<R> {\n  /**\n   * Called when the return value of the body function changes.\n   */\n  onData: (result: R) => void;\n\n  /**\n   * If present, called when an error occurs.\n   */\n  onError?: ((error: unknown) => void) | undefined;\n\n  /**\n   * If present, called when the subscription is removed/done.\n   */\n  onDone?: (() => void) | undefined;\n\n  /**\n   * If present this function is used to determine if the value returned by the\n   * body function has changed. If not provided a JSON deep equality check is\n   * used.\n   */\n  isEqual?: ((a: R, b: R) => boolean) | undefined;\n}\n\nexport type UnknownSubscription = Subscription<unknown>;\n\ntype SubscriptionSet = Set<UnknownSubscription>;\n\nexport interface SubscriptionsManager extends DiffComputationConfig {\n  clear(): void;\n  fire(diffs: DiffsMap): Promise<void>;\n  hasPendingSubscriptionRuns: boolean;\n  add<R>(subscription: Subscription<R>): () => void;\n}\n\nexport class SubscriptionsManagerImpl implements SubscriptionsManager {\n  readonly #subscriptions: SubscriptionSet = new Set();\n  readonly #pendingSubscriptions: SubscriptionSet = new Set();\n  readonly #queryInternal: QueryInternal;\n  readonly #lc: LogContext;\n  hasPendingSubscriptionRuns = false;\n  readonly #signal: AbortSignal;\n\n  constructor(\n    queryInternal: QueryInternal,\n    lc: LogContext,\n    signal: AbortSignal,\n  ) {\n    this.#queryInternal = queryInternal;\n    this.#lc = lc;\n    this.#signal = signal;\n  }\n\n  add<R>(subscription: Subscription<R>): () => void {\n    this.#subscriptions.add(subscription as UnknownSubscription);\n    void this.#scheduleInitialSubscriptionRun(\n      subscription as UnknownSubscription,\n    );\n    return () =>\n      this.#subscriptions.delete(subscription as UnknownSubscription);\n  }\n\n  clear(): void {\n    for (const subscription of this.#subscriptions) {\n      subscription.onDone?.();\n    }\n    this.#subscriptions.clear();\n  }\n\n  fire(diffs: DiffsMap): Promise<void> {\n    const subscriptions = subscriptionsForDiffs(this.#subscriptions, diffs);\n    return this.#fireSubscriptions(subscriptions, InvokeKind.Regular, diffs);\n  }\n\n  async #fireSubscriptions(\n    subscriptions: Iterable<UnknownSubscription>,\n    kind: InvokeKind,\n    diffs: DiffsMap | undefined,\n  ) {\n    if (this.#signal.aborted) {\n      return;\n    }\n\n    const subs = [...subscriptions] as readonly Subscription<unknown>[];\n    if (subs.length === 0) {\n      return;\n    }\n\n    // Use allSettled to gather fulfilled and rejected promises.\n    const results = await this.#queryInternal(tx =>\n      Promise.allSettled(\n        subs.map(async s => {\n          const stx = new SubscriptionTransactionWrapper(tx);\n          try {\n            return await s.invoke(stx, kind, diffs);\n          } finally {\n            // We need to keep track of the subscription keys even if there was an\n            // exception because changes to the keys can make the subscription\n            // body succeed.\n            s.updateDeps(stx.keys, stx.scans);\n          }\n        }),\n      ),\n    );\n\n    this.callCallbacks(subs, results);\n  }\n\n  // Public method so that ZQL can wrap it in a transaction.\n  callCallbacks(\n    subs: readonly Subscription<unknown>[],\n    results: PromiseSettledResult<unknown>[],\n  ) {\n    for (let i = 0; i < subs.length; i++) {\n      const s = subs[i];\n      const result = results[i];\n      if (result.status === 'fulfilled') {\n        s.onData(result.value);\n      } else {\n        if (s.onError) {\n          s.onError(result.reason);\n        } else {\n          this.#lc.error?.('Error in subscription body:', result.reason);\n        }\n      }\n    }\n  }\n\n  async #scheduleInitialSubscriptionRun(s: UnknownSubscription) {\n    this.#pendingSubscriptions.add(s);\n\n    if (!this.hasPendingSubscriptionRuns) {\n      this.hasPendingSubscriptionRuns = true;\n      await Promise.resolve();\n      this.hasPendingSubscriptionRuns = false;\n      const subscriptions = [...this.#pendingSubscriptions];\n      this.#pendingSubscriptions.clear();\n      await this.#fireSubscriptions(\n        subscriptions,\n        InvokeKind.InitialRun,\n        undefined,\n      );\n    }\n  }\n\n  shouldComputeDiffs(): boolean {\n    return this.#subscriptions.size > 0;\n  }\n\n  shouldComputeDiffsForIndex(indexName: string): boolean {\n    for (const s of this.#subscriptions) {\n      if (s.hasIndexSubscription(indexName)) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n\nexport type ScanSubscriptionInfo = {\n  options: ScanOptions;\n  inclusiveLimitKey?: string | undefined;\n};\n\nfunction diffMatchesSubscription(\n  keys: ReadonlySet<string>,\n  scans: Iterable<Readonly<ScanSubscriptionInfo>>,\n  indexName: string,\n  diff: InternalDiff,\n): boolean {\n  // Keys can only match for non index scans.\n  if (indexName === '') {\n    for (const diffEntry of diff) {\n      if (keys.has(diffEntry.key)) {\n        return true;\n      }\n    }\n  }\n\n  for (const scanInfo of scans) {\n    if (scanInfoMatchesDiff(scanInfo, indexName, diff)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction scanInfoMatchesDiff(\n  scanInfo: ScanSubscriptionInfo,\n  changeIndexName: string,\n  diff: InternalDiff,\n): boolean {\n  // TODO(arv): Use binary search\n  for (const diffEntry of diff) {\n    if (scanInfoMatchesKey(scanInfo, changeIndexName, diffEntry.key)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nexport function scanInfoMatchesKey(\n  scanInfo: ScanSubscriptionInfo,\n  changeIndexName: string,\n  changedKey: string,\n): boolean {\n  const {\n    indexName = '',\n    limit,\n    prefix,\n    startKey,\n    startExclusive,\n    startSecondaryKey,\n  } = scanInfo.options;\n\n  if (changeIndexName !== indexName) {\n    return false;\n  }\n\n  if (!indexName) {\n    // A scan with limit <= 0 can have no matches\n    if (limit !== undefined && limit <= 0) {\n      return false;\n    }\n\n    // No prefix and no start. Must recompute the subscription because all keys\n    // will have an effect on the subscription.\n    if (!prefix && !startKey) {\n      return true;\n    }\n\n    if (\n      prefix &&\n      (!changedKey.startsWith(prefix) ||\n        isKeyPastInclusiveLimit(scanInfo, changedKey))\n    ) {\n      return false;\n    }\n\n    if (\n      startKey &&\n      ((startExclusive && lessThanEq(changedKey, startKey)) ||\n        lessThan(changedKey, startKey) ||\n        isKeyPastInclusiveLimit(scanInfo, changedKey))\n    ) {\n      return false;\n    }\n\n    return true;\n  }\n\n  // No prefix and no start. Must recompute the subscription because all keys\n  // will have an effect on the subscription.\n  if (!prefix && !startKey && !startSecondaryKey) {\n    return true;\n  }\n\n  const [changedKeySecondary, changedKeyPrimary] = decodeIndexKey(changedKey);\n\n  if (prefix) {\n    if (!changedKeySecondary.startsWith(prefix)) {\n      return false;\n    }\n  }\n\n  if (\n    startSecondaryKey &&\n    ((startExclusive && lessThanEq(changedKeySecondary, startSecondaryKey)) ||\n      lessThan(changedKeySecondary, startSecondaryKey))\n  ) {\n    return false;\n  }\n\n  if (\n    startKey &&\n    ((startExclusive && lessThanEq(changedKeyPrimary, startKey)) ||\n      lessThan(changedKeyPrimary, startKey))\n  ) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction isKeyPastInclusiveLimit(\n  scanInfo: ScanSubscriptionInfo,\n  changedKey: string,\n): boolean {\n  const {inclusiveLimitKey} = scanInfo;\n  return (\n    scanInfo.options.limit !== undefined &&\n    inclusiveLimitKey !== undefined &&\n    greaterThan(changedKey, inclusiveLimitKey)\n  );\n}\n\nfunction* subscriptionsForDiffs<V>(\n  subscriptions: Set<Subscription<V>>,\n  diffs: DiffsMap,\n): Generator<Subscription<V>> {\n  for (const subscription of subscriptions) {\n    if (subscription.matches(diffs)) {\n      yield subscription;\n    }\n  }\n}\n\nfunction watcherMatchesDiff(\n  diff: InternalDiff,\n  prefix: string,\n  indexName: string | undefined,\n): boolean {\n  if (prefix === '') {\n    return true;\n  }\n\n  const compareKey = indexName\n    ? (diffOp: InternalDiffOperation) => decodeIndexKey(diffOp.key)[0]\n    : (diffOp: InternalDiffOperation) => diffOp.key;\n  const i = diffBinarySearch(diff, prefix, compareKey);\n  return i < diff.length && compareKey(diff[i]).startsWith(prefix);\n}\n\nexport function diffBinarySearch<Key, Value>(\n  diff: readonly InternalDiffOperation<Key, Value>[],\n  prefix: string,\n  compareKey: (diff: InternalDiffOperation<Key, Value>) => string,\n): number {\n  return binarySearch(diff.length, i =>\n    compareUTF8(prefix, compareKey(diff[i])),\n  );\n}\n"],"mappings":"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"}

package/out/packages/replicache/src/sync/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","names":[],"sources":["../../../../../../replicache/src/sync/diff.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {diff as btreeDiff} from '../btree/diff.ts';\nimport type {InternalDiff} from '../btree/node.ts';\nimport {allEntriesAsDiff, BTreeRead} from '../btree/read.ts';\nimport type {Read} from '../dag/store.ts';\nimport type {Commit} from '../db/commit.ts';\nimport {commitFromHash, type Meta} from '../db/commit.ts';\nimport {readIndexesForRead} from '../db/read.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {Hash} from '../hash.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\n/**\n * Interface allowing different diff functions to skip costly diff computations.\n */\nexport interface DiffComputationConfig {\n  shouldComputeDiffs(): boolean;\n  shouldComputeDiffsForIndex(name: string): boolean;\n}\n\n/**\n * The diffs in different indexes. The key of the map is the index name.\n * \"\" is used for the primary index.\n */\nexport class DiffsMap extends Map<string, InternalDiff> {\n  override set(key: string, value: InternalDiff): this {\n    if (value.length === 0) {\n      return this;\n    }\n    return super.set(key, value);\n  }\n}\n\n/**\n * Diffs the state of the db at two different hashes.\n * It will include the primary indexes as well as all the secondary indexes.\n */\nexport async function diff(\n  oldHash: Hash,\n  newHash: Hash,\n  read: Read,\n  diffConfig: DiffComputationConfig,\n  formatVersion: FormatVersion,\n): Promise<DiffsMap> {\n  const [oldCommit, newCommit] = await Promise.all([\n    commitFromHash(oldHash, read),\n    commitFromHash(newHash, read),\n  ]);\n\n  return diffCommits(oldCommit, newCommit, read, diffConfig, formatVersion);\n}\n\n/**\n * Diffs the state of the db at two different commits.\n * It will include the primary indexes as well as all the secondary indexes.\n */\n// TODO: this should probably move to db/\nexport async function diffCommits(\n  oldCommit: Commit<Meta>,\n  newCommit: Commit<Meta>,\n  read: Read,\n  diffConfig: DiffComputationConfig,\n  formatVersion: FormatVersion,\n): Promise<DiffsMap> {\n  const diffsMap = new DiffsMap();\n  if (!diffConfig.shouldComputeDiffs()) {\n    return diffsMap;\n  }\n\n  const oldMap = new BTreeRead(read, formatVersion, oldCommit.valueHash);\n  const newMap = new BTreeRead(read, formatVersion, newCommit.valueHash);\n  const valueDiff = await btreeDiff(oldMap, newMap);\n  diffsMap.set('', valueDiff);\n\n  await addDiffsForIndexes(\n    oldCommit,\n    newCommit,\n    read,\n    diffsMap,\n    diffConfig,\n    formatVersion,\n  );\n\n  return diffsMap;\n}\n\nexport async function addDiffsForIndexes(\n  mainCommit: Commit<Meta>,\n  syncCommit: Commit<Meta>,\n  read: Read,\n  diffsMap: DiffsMap,\n  diffConfig: DiffComputationConfig,\n  formatVersion: FormatVersion,\n) {\n  const oldIndexes = readIndexesForRead(mainCommit, read, formatVersion);\n  const newIndexes = readIndexesForRead(syncCommit, read, formatVersion);\n\n  for (const [oldIndexName, oldIndex] of oldIndexes) {\n    if (!diffConfig.shouldComputeDiffsForIndex(oldIndexName)) {\n      continue;\n    }\n\n    const newIndex = newIndexes.get(oldIndexName);\n    if (newIndex !== undefined) {\n      assert(\n        newIndex !== oldIndex,\n        'Expected newIndex to differ from oldIndex',\n      );\n      const diffs = await btreeDiff(oldIndex.map, newIndex.map);\n      newIndexes.delete(oldIndexName);\n      diffsMap.set(oldIndexName, diffs);\n    } else {\n      // old index name is not in the new indexes. All entries removed!\n      const diffs = await allEntriesAsDiff(oldIndex.map, 'del');\n      diffsMap.set(oldIndexName, diffs);\n    }\n  }\n\n  for (const [newIndexName, newIndex] of newIndexes) {\n    if (!diffConfig.shouldComputeDiffsForIndex(newIndexName)) {\n      continue;\n    }\n    // new index name is not in the old indexes. All keys added!\n    const diffs = await allEntriesAsDiff(newIndex.map, 'add');\n    diffsMap.set(newIndexName, diffs);\n  }\n}\n"],"mappings":";;;;;;;;;;AA0BA,IAAa,WAAb,cAA8B,IAA0B;CACtD,IAAa,KAAa,OAA2B;EACnD,IAAI,MAAM,WAAW,GACnB,OAAO;EAET,OAAO,MAAM,IAAI,KAAK,KAAK;CAC7B;AACF;;;;;AAMA,eAAsB,KACpB,SACA,SACA,MACA,YACA,eACmB;CACnB,MAAM,CAAC,WAAW,aAAa,MAAM,QAAQ,IAAI,CAC/C,eAAe,SAAS,IAAI,GAC5B,eAAe,SAAS,IAAI,CAC9B,CAAC;CAED,OAAO,YAAY,WAAW,WAAW,MAAM,YAAY,aAAa;AAC1E;;;;;AAOA,eAAsB,YACpB,WACA,WACA,MACA,YACA,eACmB;CACnB,MAAM,WAAW,IAAI,SAAS;CAC9B,IAAI,CAAC,WAAW,mBAAmB,GACjC,OAAO;CAKT,MAAM,YAAY,MAAM,OAAU,IAFf,UAAU,MAAM,eAAe,UAAU,SAE1B,GAAQ,IADvB,UAAU,MAAM,eAAe,UAAU,SAClB,CAAM;CAChD,SAAS,IAAI,IAAI,SAAS;CAE1B,MAAM,mBACJ,WACA,WACA,MACA,UACA,YACA,aACF;CAEA,OAAO;AACT;AAEA,eAAsB,mBACpB,YACA,YACA,MACA,UACA,YACA,eACA;CACA,MAAM,aAAa,mBAAmB,YAAY,MAAM,aAAa;CACrE,MAAM,aAAa,mBAAmB,YAAY,MAAM,aAAa;CAErE,KAAK,MAAM,CAAC,cAAc,aAAa,YAAY;EACjD,IAAI,CAAC,WAAW,2BAA2B,YAAY,GACrD;EAGF,MAAM,WAAW,WAAW,IAAI,YAAY;EAC5C,IAAI,aAAa,KAAA,GAAW;GAC1B,OACE,aAAa,UACb,2CACF;GACA,MAAM,QAAQ,MAAM,OAAU,SAAS,KAAK,SAAS,GAAG;GACxD,WAAW,OAAO,YAAY;GAC9B,SAAS,IAAI,cAAc,KAAK;EAClC,OAAO;GAEL,MAAM,QAAQ,MAAM,iBAAiB,SAAS,KAAK,KAAK;GACxD,SAAS,IAAI,cAAc,KAAK;EAClC;CACF;CAEA,KAAK,MAAM,CAAC,cAAc,aAAa,YAAY;EACjD,IAAI,CAAC,WAAW,2BAA2B,YAAY,GACrD;EAGF,MAAM,QAAQ,MAAM,iBAAiB,SAAS,KAAK,KAAK;EACxD,SAAS,IAAI,cAAc,KAAK;CAClC;AACF"}

package/out/packages/replicache/src/sync/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","names":[],"sources":["../../../../../../replicache/src/sync/ids.ts"],"sourcesContent":["import * as valita from '../../../shared/src/valita.ts';\n\n/**\n * The ID describing a group of clients. All clients in the same group share a\n * persistent storage (IDB).\n */\nexport type ClientGroupID = string;\n\nexport const clientGroupIDSchema: valita.Type<ClientGroupID> = valita.string();\n\n/**\n * The ID describing a client.\n */\nexport type ClientID = string;\n\nexport const clientIDSchema: valita.Type<ClientID> = valita.string();\n"],"mappings":";;AAQA,IAAa,sBAAkD,eAAO,OAAO;AAO7E,IAAa,iBAAwC,eAAO,OAAO"}

package/out/packages/replicache/src/sync/patch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.js","names":[],"sources":["../../../../../../replicache/src/sync/patch.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {compareUTF8} from 'compare-utf8';\nimport {assertObject} from '../../../shared/src/asserts.ts';\nimport type {\n  ReadonlyJSONObject,\n  ReadonlyJSONValue,\n} from '../../../shared/src/json.ts';\nimport type {DiffOperation} from '../btree/node.ts';\nimport type {Write} from '../db/write.ts';\nimport {\n  type FrozenJSONObject,\n  type FrozenJSONValue,\n  deepFreeze,\n} from '../frozen-json.ts';\nimport type {PatchOperationInternal} from '../patch-operation.ts';\n\nexport type Diff =\n  | DiffOperation<string>\n  | {\n      op: 'clear';\n    };\n\n/**\n * Optimizes a patch array by:\n * 1. Dropping all operations before the last 'clear'\n * 2. For each key: put/del replace all previous operations\n * 3. Removing standalone 'del' operations after a clear (deleting from empty tree)\n * 4. Update are not used in Zero/Replicache so just return original patch.\n * Note: Order is preserved for operations on the same key, but operations\n * on different keys can be reordered.\n */\nexport function optimizePatch(\n  patch: readonly PatchOperationInternal[],\n): readonly PatchOperationInternal[] {\n  if (patch.length === 0) {\n    return [];\n  }\n\n  // Build result array\n  const result: PatchOperationInternal[] = [];\n\n  // Find the last clear operation, add it to result, and track start index\n  let i = 0;\n  let clearIndex = -1;\n  for (i = patch.length - 1; i >= 0; i--) {\n    if (patch[i].op === 'clear') {\n      result.push(patch[i]);\n      clearIndex = i;\n      break;\n    }\n  }\n  // After loop: i is either the clear index (if found) or -1 (if not found)\n  // Increment to get the start index for processing remaining operations\n  i++;\n\n  // Track operations for each key\n  // del and put replace all previous operations\n  // updates are not used so if we see one we return the original patch.\n  const keyOps = new Map<string, PatchOperationInternal>();\n\n  for (; i < patch.length; i++) {\n    const p = patch[i];\n\n    switch (p.op) {\n      case 'put':\n      case 'del': {\n        // put and del replaces all previous operations on that key\n        keyOps.set(p.key, p);\n        break;\n      }\n      case 'update': {\n        // 'update' is not used but to be safe just exit early.\n        return clearIndex === -1 ? patch : patch.slice(clearIndex);\n      }\n    }\n  }\n\n  // Add all remaining key operations, but skip standalone del after clear\n  for (const op of keyOps.values()) {\n    // Skip standalone del operations after clear (deleting from empty tree is pointless)\n    if (clearIndex !== -1 && op.op === 'del') {\n      continue;\n    }\n    result.push(op);\n  }\n\n  return result.sort((a, b) => {\n    if (a.op === 'clear') return -1;\n    if (b.op === 'clear') return 1;\n    return compareUTF8(a.key, b.key);\n  });\n}\n\nexport async function apply(\n  lc: LogContext,\n  dbWrite: Write,\n  patch: readonly PatchOperationInternal[],\n): Promise<void> {\n  // Optimize the patch to remove redundant operations\n  const optimized = optimizePatch(patch);\n\n  let i = 0;\n\n  // Handle clear if present (always at index 0 after optimization)\n  if (optimized.length > 0 && optimized[0].op === 'clear') {\n    await dbWrite.clear();\n    i = 1;\n  }\n\n  // Check if we can bulk load put some operations\n  const bulkLoadStart = i;\n  while (i < optimized.length && optimized[i].op === 'put') {\n    i++;\n  }\n\n  if (i > bulkLoadStart) {\n    await bulkLoadPuts(lc, dbWrite, optimized.slice(bulkLoadStart, i));\n  }\n\n  // Apply remaining operations individually\n  for (; i < optimized.length; i++) {\n    const op = optimized[i];\n\n    switch (op.op) {\n      case 'put': {\n        const frozen = deepFreeze(op.value);\n        await dbWrite.put(lc, op.key, frozen);\n        break;\n      }\n      case 'update': {\n        const existing = await dbWrite.get(op.key);\n        if (existing !== undefined) {\n          assertObject(existing);\n        }\n        const frozen = mergeUpdate(op, existing);\n        await dbWrite.put(lc, op.key, frozen);\n        break;\n      }\n      case 'del': {\n        const existing = await dbWrite.get(op.key);\n        if (existing !== undefined) {\n          await dbWrite.del(lc, op.key);\n        }\n        break;\n      }\n    }\n  }\n}\n\nexport function mergeUpdate(\n  op: Extract<PatchOperationInternal, {op: 'update'}>,\n  existing: ReadonlyJSONObject | undefined,\n) {\n  const entries: [string, FrozenJSONValue | ReadonlyJSONValue | undefined][] =\n    [];\n  const addToEntries = (toAdd: FrozenJSONObject | ReadonlyJSONObject) => {\n    for (const [key, value] of Object.entries(toAdd)) {\n      if (\n        !op.constrain ||\n        op.constrain.length === 0 ||\n        op.constrain.includes(key)\n      ) {\n        entries.push([key, value]);\n      }\n    }\n  };\n  if (existing !== undefined) {\n    addToEntries(existing);\n  }\n  if (op.merge) {\n    addToEntries(op.merge);\n  }\n  return deepFreeze(Object.fromEntries(entries));\n}\n\nasync function bulkLoadPuts(\n  lc: LogContext,\n  dbWrite: Write,\n  puts: readonly PatchOperationInternal[],\n): Promise<void> {\n  if (puts.length === 0) {\n    return;\n  }\n\n  // Sort entries by key for bulk loading\n  const entries: [string, FrozenJSONValue][] = puts.map(p => {\n    if (p.op !== 'put') {\n      throw new Error('Expected put operation');\n    }\n    return [p.key, deepFreeze(p.value)];\n  });\n\n  // already sorted\n\n  await dbWrite.putMany(lc, entries);\n}\n"],"mappings":"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"}

package/out/packages/replicache/src/sync/pull-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull-error.js","names":[],"sources":["../../../../../../replicache/src/sync/pull-error.ts"],"sourcesContent":["/**\n * This error is thrown when the puller fails for any reason.\n */\n\nexport class PullError extends Error {\n  name = 'PullError';\n  // causedBy is used instead of cause, because while cause has been proposed as a\n  // JavaScript language standard for this purpose (see\n  // https://github.com/tc39/proposal-error-cause) current browser behavior is\n  // inconsistent.\n  causedBy?: Error | undefined;\n  constructor(causedBy?: Error) {\n    super('Failed to pull');\n    this.causedBy = causedBy;\n  }\n}\n"],"mappings":";;;;AAIA,IAAa,YAAb,cAA+B,MAAM;CACnC,OAAO;CAKP;CACA,YAAY,UAAkB;EAC5B,MAAM,gBAAgB;EACtB,KAAK,WAAW;CAClB;AACF"}