@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"persist.js","sources":["../../../../../replicache/src/persist/persist.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {Chunk} from '../dag/chunk.ts';\nimport type {LazyStore} from '../dag/lazy-store.ts';\nimport type {Read, Store, Write} from '../dag/store.ts';\nimport type {Commit} from '../db/commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type LocalMetaDD31,\n  type Meta,\n  assertSnapshotCommitDD31,\n  baseSnapshotFromCommit,\n  commitFromHash,\n  commitFromHead,\n  compareCookiesForSnapshots,\n  localMutationsDD31,\n  localMutationsGreaterThan,\n} from '../db/commit.ts';\nimport {rebaseMutationAndPutCommit} from '../db/rebase.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {Hash} from '../hash.ts';\nimport type {ZeroOption, ZeroTxData} from '../replicache-options.ts';\nimport type {ClientGroupID, ClientID} from '../sync/ids.ts';\nimport type {MutatorDefs} from '../types.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {\n  type ClientGroup,\n  getClientGroup,\n  setClientGroup,\n} from './client-groups.ts';\nimport {\n  assertClientV6,\n  assertHasClientState,\n  getClientGroupIDForClient,\n  mustGetClient,\n  setClient,\n} from './clients.ts';\nimport {GatherMemoryOnlyVisitor} from './gather-mem-only-visitor.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\n/**\n * Persists the client's memdag state to the client's perdag client group.\n *\n * Persists the base snapshot from memdag to the client's perdag client group,\n * but only if it’s newer than the client's perdag client group’s base snapshot.\n * The base snapshot is persisted by gathering all memory-only chunks in the dag\n * subgraph rooted at the base snapshot's commit and writing them to the perdag.\n * Once the base snapshot is persisted, rebases onto this new base snapshot all\n * local commits from the client's perdag client group that are not already\n * reflected in the base snapshot.\n *\n * Whether or not the base snapshot is persisted, rebases onto the client's\n * perdag client group all memdag local commits not already in the client's\n * perdag client group's history.\n *\n * Also updates the `lastMutationIDs` and `lastServerAckdMutationIDs` properties\n * of the client's client group's entry in the `ClientGroupMap`.\n */\nexport async function persistDD31(\n  lc: LogContext,\n  clientID: ClientID,\n  memdag: LazyStore,\n  perdag: Store,\n  mutators: MutatorDefs,\n  closed: () => boolean,\n  formatVersion: FormatVersion,\n  getZeroData: ZeroOption['getTxData'] | undefined,\n  onGatherMemOnlyChunksForTest = () => Promise.resolve(),\n): Promise<void> {\n  if (closed()) {\n    return;\n  }\n\n  const [perdagLMID, perdagBaseSnapshot, mainClientGroupID] = await withRead(\n    perdag,\n    async perdagRead => {\n      await assertHasClientState(clientID, perdagRead);\n      const mainClientGroupID = await getClientGroupIDForClient(\n        clientID,\n        perdagRead,\n      );\n      assert(\n        mainClientGroupID,\n        `No main client group for clientID: ${clientID}`,\n      );\n      const [, perdagMainClientGroupHeadCommit] = await getClientGroupInfo(\n        perdagRead,\n        mainClientGroupID,\n      );\n      const perdagLMID = await perdagMainClientGroupHeadCommit.getMutationID(\n        clientID,\n        perdagRead,\n      );\n      const perdagBaseSnapshot = await baseSnapshotFromCommit(\n        perdagMainClientGroupHeadCommit,\n        perdagRead,\n      );\n      assertSnapshotCommitDD31(perdagBaseSnapshot);\n      return [perdagLMID, perdagBaseSnapshot, mainClientGroupID];\n    },\n  );\n\n  if (closed()) {\n    return;\n  }\n  const [newMemdagMutations, memdagBaseSnapshot, gatheredChunks] =\n    await withRead(memdag, async memdagRead => {\n      const memdagHeadCommit = await commitFromHead(\n        DEFAULT_HEAD_NAME,\n        memdagRead,\n      );\n      const newMutations = await localMutationsGreaterThan(\n        memdagHeadCommit,\n        {[clientID]: perdagLMID || 0},\n        memdagRead,\n      );\n      const memdagBaseSnapshot = await baseSnapshotFromCommit(\n        memdagHeadCommit,\n        memdagRead,\n      );\n      assertSnapshotCommitDD31(memdagBaseSnapshot);\n\n      let gatheredChunks: ReadonlyMap<Hash, Chunk> | undefined;\n      if (\n        compareCookiesForSnapshots(memdagBaseSnapshot, perdagBaseSnapshot) > 0\n      ) {\n        await onGatherMemOnlyChunksForTest();\n        // Might need to persist snapshot, we will have to double check\n        // after gathering the snapshot chunks from memdag\n        const memdagBaseSnapshotHash = memdagBaseSnapshot.chunk.hash;\n        // Gather all memory only chunks from base snapshot on the memdag.\n        const visitor = new GatherMemoryOnlyVisitor(memdagRead);\n        await visitor.visit(memdagBaseSnapshotHash);\n        gatheredChunks = visitor.gatheredChunks;\n      }\n\n      return [newMutations, memdagBaseSnapshot, gatheredChunks];\n    });\n\n  if (closed()) {\n    return;\n  }\n\n  let memdagBaseSnapshotPersisted = false;\n  const zeroDataForMemdagBaseSnapshot =\n    getZeroData && (await getZeroData(memdagBaseSnapshot.chunk.hash));\n\n  await withWrite(perdag, async perdagWrite => {\n    const [mainClientGroup, latestPerdagMainClientGroupHeadCommit] =\n      await getClientGroupInfo(perdagWrite, mainClientGroupID);\n\n    // These initial values for newMainClientGroupHeadHash, mutationIDs,\n    // lastServerAckdMutationIDs are correct for the case where the memdag\n    // snapshot is *not* persisted.  If the memdag snapshot is persisted\n    // these values are overwritten appropriately.\n    let newMainClientGroupHeadHash: Hash =\n      latestPerdagMainClientGroupHeadCommit.chunk.hash;\n    let mutationIDs: Record<ClientID, number> = {\n      ...mainClientGroup.mutationIDs,\n    };\n    let {lastServerAckdMutationIDs} = mainClientGroup;\n\n    if (gatheredChunks) {\n      // check if memdag snapshot still newer than perdag snapshot\n\n      const client = await mustGetClient(clientID, perdagWrite);\n      assertClientV6(client);\n\n      const latestPerdagBaseSnapshot = await baseSnapshotFromCommit(\n        latestPerdagMainClientGroupHeadCommit,\n        perdagWrite,\n      );\n      assertSnapshotCommitDD31(latestPerdagBaseSnapshot);\n\n      // check if memdag snapshot still newer than perdag snapshot\n      if (\n        compareCookiesForSnapshots(\n          memdagBaseSnapshot,\n          latestPerdagBaseSnapshot,\n        ) > 0\n      ) {\n        // still newer, persist memdag snapshot by writing chunks\n        memdagBaseSnapshotPersisted = true;\n        await Promise.all(\n          Array.from(gatheredChunks.values(), c => perdagWrite.putChunk(c)),\n        );\n\n        await setClient(\n          clientID,\n          {\n            ...client,\n            persistHash: memdagBaseSnapshot.chunk.hash,\n          },\n          perdagWrite,\n        );\n        // Rebase local mutations from perdag main client group onto new\n        // snapshot\n        newMainClientGroupHeadHash = memdagBaseSnapshot.chunk.hash;\n        const mainClientGroupLocalMutations = await localMutationsDD31(\n          mainClientGroup.headHash,\n          perdagWrite,\n        );\n\n        lastServerAckdMutationIDs = memdagBaseSnapshot.meta.lastMutationIDs;\n        mutationIDs = {...lastServerAckdMutationIDs};\n\n        newMainClientGroupHeadHash = await rebase(\n          mainClientGroupLocalMutations,\n          newMainClientGroupHeadHash,\n          perdagWrite,\n          mutators,\n          mutationIDs,\n          lc,\n          formatVersion,\n          zeroDataForMemdagBaseSnapshot,\n        );\n      }\n    }\n\n    let zeroDataForPerdagHeadCommit: ZeroTxData | undefined;\n    if (!memdagBaseSnapshotPersisted) {\n      zeroDataForPerdagHeadCommit =\n        getZeroData &&\n        (await getZeroData(newMainClientGroupHeadHash, {\n          openLazySourceRead: perdagWrite,\n        }));\n    }\n\n    // rebase new memdag mutations onto perdag\n    newMainClientGroupHeadHash = await rebase(\n      newMemdagMutations,\n      newMainClientGroupHeadHash,\n      perdagWrite,\n      mutators,\n      mutationIDs,\n      lc,\n      formatVersion,\n      zeroDataForPerdagHeadCommit ?? zeroDataForMemdagBaseSnapshot,\n    );\n\n    const newMainClientGroup = {\n      ...mainClientGroup,\n      headHash: newMainClientGroupHeadHash,\n      mutationIDs,\n      lastServerAckdMutationIDs,\n    };\n\n    await setClientGroup(mainClientGroupID, newMainClientGroup, perdagWrite);\n  });\n\n  if (gatheredChunks && memdagBaseSnapshotPersisted) {\n    await withWrite(memdag, memdagWrite =>\n      memdagWrite.chunksPersisted([...gatheredChunks.keys()]),\n    );\n  }\n}\n\nasync function getClientGroupInfo(\n  perdagRead: Read,\n  clientGroupID: ClientGroupID,\n): Promise<[ClientGroup, Commit<Meta>]> {\n  const clientGroup = await getClientGroup(clientGroupID, perdagRead);\n  assert(clientGroup, `No client group for clientGroupID: ${clientGroupID}`);\n  return [clientGroup, await commitFromHash(clientGroup.headHash, perdagRead)];\n}\n\nasync function rebase(\n  mutations: Commit<LocalMetaDD31>[],\n  basis: Hash,\n  write: Write,\n  mutators: MutatorDefs,\n  mutationIDs: Record<ClientID, number>,\n  lc: LogContext,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<Hash> {\n  for (let i = mutations.length - 1; i >= 0; i--) {\n    const mutationCommit = mutations[i];\n    const {meta} = mutationCommit;\n    const newMainHead = await commitFromHash(basis, write);\n    if (\n      (await mutationCommit.getMutationID(meta.clientID, write)) >\n      (await newMainHead.getMutationID(meta.clientID, write))\n    ) {\n      mutationIDs[meta.clientID] = meta.mutationID;\n      basis = (\n        await rebaseMutationAndPutCommit(\n          mutationCommit,\n          write,\n          basis,\n          mutators,\n          lc,\n          meta.clientID,\n          formatVersion,\n          zeroData,\n        )\n      ).chunk.hash;\n    }\n  }\n  return basis;\n}\n"],"names":["mainClientGroupID","perdagLMID","perdagBaseSnapshot","memdagBaseSnapshot","gatheredChunks"],"mappings":"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"}
+{"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 type {Chunk} from '../dag/chunk.ts';\nimport type {LazyStore} from '../dag/lazy-store.ts';\nimport type {Read, Store, Write} from '../dag/store.ts';\nimport type {Commit} from '../db/commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type LocalMetaDD31,\n  type Meta,\n  assertSnapshotCommitDD31,\n  baseSnapshotFromCommit,\n  commitFromHash,\n  commitFromHead,\n  compareCookiesForSnapshots,\n  localMutationsDD31,\n  localMutationsGreaterThan,\n} from '../db/commit.ts';\nimport {rebaseMutationAndPutCommit} from '../db/rebase.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {Hash} from '../hash.ts';\nimport type {ZeroOption, ZeroTxData} from '../replicache-options.ts';\nimport type {ClientGroupID, ClientID} from '../sync/ids.ts';\nimport type {MutatorDefs} from '../types.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {\n  type ClientGroup,\n  getClientGroup,\n  setClientGroup,\n} from './client-groups.ts';\nimport {\n  assertClientV6,\n  assertHasClientState,\n  getClientGroupIDForClient,\n  mustGetClient,\n  setClient,\n} from './clients.ts';\nimport {GatherMemoryOnlyVisitor} from './gather-mem-only-visitor.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\n/**\n * Persists the client's memdag state to the client's perdag client group.\n *\n * Persists the base snapshot from memdag to the client's perdag client group,\n * but only if it’s newer than the client's perdag client group’s base snapshot.\n * The base snapshot is persisted by gathering all memory-only chunks in the dag\n * subgraph rooted at the base snapshot's commit and writing them to the perdag.\n * Once the base snapshot is persisted, rebases onto this new base snapshot all\n * local commits from the client's perdag client group that are not already\n * reflected in the base snapshot.\n *\n * Whether or not the base snapshot is persisted, rebases onto the client's\n * perdag client group all memdag local commits not already in the client's\n * perdag client group's history.\n *\n * Also updates the `lastMutationIDs` and `lastServerAckdMutationIDs` properties\n * of the client's client group's entry in the `ClientGroupMap`.\n */\nexport async function persistDD31(\n  lc: LogContext,\n  clientID: ClientID,\n  memdag: LazyStore,\n  perdag: Store,\n  mutators: MutatorDefs,\n  closed: () => boolean,\n  formatVersion: FormatVersion,\n  getZeroData: ZeroOption['getTxData'] | undefined,\n  onGatherMemOnlyChunksForTest = () => Promise.resolve(),\n): Promise<void> {\n  if (closed()) {\n    return;\n  }\n\n  const [perdagLMID, perdagBaseSnapshot, mainClientGroupID] = await withRead(\n    perdag,\n    async perdagRead => {\n      await assertHasClientState(clientID, perdagRead);\n      const mainClientGroupID = await getClientGroupIDForClient(\n        clientID,\n        perdagRead,\n      );\n      assert(\n        mainClientGroupID,\n        `No main client group for clientID: ${clientID}`,\n      );\n      const [, perdagMainClientGroupHeadCommit] = await getClientGroupInfo(\n        perdagRead,\n        mainClientGroupID,\n      );\n      const perdagLMID = await perdagMainClientGroupHeadCommit.getMutationID(\n        clientID,\n        perdagRead,\n      );\n      const perdagBaseSnapshot = await baseSnapshotFromCommit(\n        perdagMainClientGroupHeadCommit,\n        perdagRead,\n      );\n      assertSnapshotCommitDD31(perdagBaseSnapshot);\n      return [perdagLMID, perdagBaseSnapshot, mainClientGroupID];\n    },\n  );\n\n  if (closed()) {\n    return;\n  }\n  const [newMemdagMutations, memdagBaseSnapshot, gatheredChunks] =\n    await withRead(memdag, async memdagRead => {\n      const memdagHeadCommit = await commitFromHead(\n        DEFAULT_HEAD_NAME,\n        memdagRead,\n      );\n      const newMutations = await localMutationsGreaterThan(\n        memdagHeadCommit,\n        {[clientID]: perdagLMID || 0},\n        memdagRead,\n      );\n      const memdagBaseSnapshot = await baseSnapshotFromCommit(\n        memdagHeadCommit,\n        memdagRead,\n      );\n      assertSnapshotCommitDD31(memdagBaseSnapshot);\n\n      let gatheredChunks: ReadonlyMap<Hash, Chunk> | undefined;\n      if (\n        compareCookiesForSnapshots(memdagBaseSnapshot, perdagBaseSnapshot) > 0\n      ) {\n        await onGatherMemOnlyChunksForTest();\n        // Might need to persist snapshot, we will have to double check\n        // after gathering the snapshot chunks from memdag\n        const memdagBaseSnapshotHash = memdagBaseSnapshot.chunk.hash;\n        // Gather all memory only chunks from base snapshot on the memdag.\n        const visitor = new GatherMemoryOnlyVisitor(memdagRead);\n        await visitor.visit(memdagBaseSnapshotHash);\n        gatheredChunks = visitor.gatheredChunks;\n      }\n\n      return [newMutations, memdagBaseSnapshot, gatheredChunks];\n    });\n\n  if (closed()) {\n    return;\n  }\n\n  let memdagBaseSnapshotPersisted = false;\n  const zeroDataForMemdagBaseSnapshot =\n    getZeroData && (await getZeroData(memdagBaseSnapshot.chunk.hash));\n\n  await withWrite(perdag, async perdagWrite => {\n    const [mainClientGroup, latestPerdagMainClientGroupHeadCommit] =\n      await getClientGroupInfo(perdagWrite, mainClientGroupID);\n\n    // These initial values for newMainClientGroupHeadHash, mutationIDs,\n    // lastServerAckdMutationIDs are correct for the case where the memdag\n    // snapshot is *not* persisted.  If the memdag snapshot is persisted\n    // these values are overwritten appropriately.\n    let newMainClientGroupHeadHash: Hash =\n      latestPerdagMainClientGroupHeadCommit.chunk.hash;\n    let mutationIDs: Record<ClientID, number> = {\n      ...mainClientGroup.mutationIDs,\n    };\n    let {lastServerAckdMutationIDs} = mainClientGroup;\n\n    if (gatheredChunks) {\n      // check if memdag snapshot still newer than perdag snapshot\n\n      const client = await mustGetClient(clientID, perdagWrite);\n      assertClientV6(client);\n\n      const latestPerdagBaseSnapshot = await baseSnapshotFromCommit(\n        latestPerdagMainClientGroupHeadCommit,\n        perdagWrite,\n      );\n      assertSnapshotCommitDD31(latestPerdagBaseSnapshot);\n\n      // check if memdag snapshot still newer than perdag snapshot\n      if (\n        compareCookiesForSnapshots(\n          memdagBaseSnapshot,\n          latestPerdagBaseSnapshot,\n        ) > 0\n      ) {\n        // still newer, persist memdag snapshot by writing chunks\n        memdagBaseSnapshotPersisted = true;\n        await Promise.all(\n          Array.from(gatheredChunks.values(), c => perdagWrite.putChunk(c)),\n        );\n\n        await setClient(\n          clientID,\n          {\n            ...client,\n            persistHash: memdagBaseSnapshot.chunk.hash,\n          },\n          perdagWrite,\n        );\n        // Rebase local mutations from perdag main client group onto new\n        // snapshot\n        newMainClientGroupHeadHash = memdagBaseSnapshot.chunk.hash;\n        const mainClientGroupLocalMutations = await localMutationsDD31(\n          mainClientGroup.headHash,\n          perdagWrite,\n        );\n\n        lastServerAckdMutationIDs = memdagBaseSnapshot.meta.lastMutationIDs;\n        mutationIDs = {...lastServerAckdMutationIDs};\n\n        newMainClientGroupHeadHash = await rebase(\n          mainClientGroupLocalMutations,\n          newMainClientGroupHeadHash,\n          perdagWrite,\n          mutators,\n          mutationIDs,\n          lc,\n          formatVersion,\n          zeroDataForMemdagBaseSnapshot,\n        );\n      }\n    }\n\n    let zeroDataForPerdagHeadCommit: ZeroTxData | undefined;\n    if (!memdagBaseSnapshotPersisted) {\n      zeroDataForPerdagHeadCommit =\n        getZeroData &&\n        (await getZeroData(newMainClientGroupHeadHash, {\n          openLazySourceRead: perdagWrite,\n        }));\n    }\n\n    // rebase new memdag mutations onto perdag\n    newMainClientGroupHeadHash = await rebase(\n      newMemdagMutations,\n      newMainClientGroupHeadHash,\n      perdagWrite,\n      mutators,\n      mutationIDs,\n      lc,\n      formatVersion,\n      zeroDataForPerdagHeadCommit ?? zeroDataForMemdagBaseSnapshot,\n    );\n\n    const newMainClientGroup = {\n      ...mainClientGroup,\n      headHash: newMainClientGroupHeadHash,\n      mutationIDs,\n      lastServerAckdMutationIDs,\n    };\n\n    await setClientGroup(mainClientGroupID, newMainClientGroup, perdagWrite);\n  });\n\n  if (gatheredChunks && memdagBaseSnapshotPersisted) {\n    await withWrite(memdag, memdagWrite =>\n      memdagWrite.chunksPersisted([...gatheredChunks.keys()]),\n    );\n  }\n}\n\nasync function getClientGroupInfo(\n  perdagRead: Read,\n  clientGroupID: ClientGroupID,\n): Promise<[ClientGroup, Commit<Meta>]> {\n  const clientGroup = await getClientGroup(clientGroupID, perdagRead);\n  assert(clientGroup, `No client group for clientGroupID: ${clientGroupID}`);\n  return [clientGroup, await commitFromHash(clientGroup.headHash, perdagRead)];\n}\n\nasync function rebase(\n  mutations: Commit<LocalMetaDD31>[],\n  basis: Hash,\n  write: Write,\n  mutators: MutatorDefs,\n  mutationIDs: Record<ClientID, number>,\n  lc: LogContext,\n  formatVersion: FormatVersion,\n  zeroData: ZeroTxData | undefined,\n): Promise<Hash> {\n  for (let i = mutations.length - 1; i >= 0; i--) {\n    const mutationCommit = mutations[i];\n    const {meta} = mutationCommit;\n    const newMainHead = await commitFromHash(basis, write);\n    if (\n      (await mutationCommit.getMutationID(meta.clientID, write)) >\n      (await newMainHead.getMutationID(meta.clientID, write))\n    ) {\n      mutationIDs[meta.clientID] = meta.mutationID;\n      basis = (\n        await rebaseMutationAndPutCommit(\n          mutationCommit,\n          write,\n          basis,\n          mutators,\n          lc,\n          meta.clientID,\n          formatVersion,\n          zeroData,\n        )\n      ).chunk.hash;\n    }\n  }\n  return basis;\n}\n"],"mappings":"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"}