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

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

@@ -1,261 +0,0 @@
-import { assert, assertObject } from "../../../shared/src/asserts.js";
-import { hasOwn } from "../../../shared/src/has-own.js";
-import { compareCookies } from "../cookies.js";
-import { deepFreeze } from "../frozen-json.js";
-import { assert as assert$1, readonlyArray, readonlyObject, valita_exports } from "../../../shared/src/valita.js";
-import { hashSchema } from "../hash.js";
-import { toRefs } from "../dag/chunk.js";
-import { emptyDataNode } from "../btree/node.js";
-import { BTreeRead } from "../btree/read.js";
-import { assertSnapshotCommitDD31, baseSnapshotFromHash, chunkIndexDefinitionEqualIgnoreName, getRefs, newSnapshotCommitDataDD31, toChunkIndexDefinition } from "../db/commit.js";
-import { createIndexBTree } from "../db/write.js";
-import { indexDefinitionsEqual } from "../index-defs.js";
-import { clientGroupIDSchema } from "../sync/ids.js";
-import { withWrite } from "../with-transactions.js";
-import { getClientGroup, getClientGroups, mutatorNamesEqual, setClientGroup } from "./client-groups.js";
-import { makeClientID } from "./make-client-id.js";
-//#region ../replicache/src/persist/clients.ts
-var clientV5Schema = readonlyObject({
-	heartbeatTimestampMs: valita_exports.number(),
-	headHash: hashSchema,
-	tempRefreshHash: hashSchema.nullable(),
-	clientGroupID: clientGroupIDSchema
-});
-var clientV6Schema = readonlyObject({
-	heartbeatTimestampMs: valita_exports.number(),
-	refreshHashes: readonlyArray(hashSchema),
-	persistHash: hashSchema.nullable(),
-	clientGroupID: clientGroupIDSchema
-});
-function isClientV6(client) {
-	return client.refreshHashes !== void 0;
-}
-var CLIENTS_HEAD_NAME = "clients";
-var clientSchema = valita_exports.union(clientV5Schema, clientV6Schema);
-function assertClient(value) {
-	assert$1(value, clientSchema);
-}
-function assertClientV6(value) {
-	assert$1(value, clientV6Schema);
-}
-function chunkDataToClientMap(chunkData) {
-	assertObject(chunkData);
-	const clients = /* @__PURE__ */ new Map();
-	for (const key in chunkData) if (hasOwn(chunkData, key)) {
-		const value = chunkData[key];
-		if (value !== void 0) {
-			assertClient(value);
-			clients.set(key, value);
-		}
-	}
-	return clients;
-}
-function clientMapToChunkData(clients, dagWrite) {
-	for (const client of clients.values()) if (isClientV6(client)) {
-		client.refreshHashes.forEach(dagWrite.assertValidHash);
-		if (client.persistHash) dagWrite.assertValidHash(client.persistHash);
-	} else {
-		dagWrite.assertValidHash(client.headHash);
-		if (client.tempRefreshHash) dagWrite.assertValidHash(client.tempRefreshHash);
-	}
-	return deepFreeze(Object.fromEntries(clients));
-}
-async function getClients(dagRead) {
-	return getClientsAtHash(await dagRead.getHead(CLIENTS_HEAD_NAME), dagRead);
-}
-async function getClientsAtHash(hash, dagRead) {
-	if (!hash) return /* @__PURE__ */ new Map();
-	return chunkDataToClientMap((await dagRead.getChunk(hash))?.data);
-}
-/**
-* Used to signal that a client does not exist. Maybe it was garbage collected?
-*/
-var ClientStateNotFoundError = class extends Error {
-	name = "ClientStateNotFoundError";
-	id;
-	constructor(id) {
-		super(`Client state not found, id: ${id}`);
-		this.id = id;
-	}
-};
-/**
-* Throws a `ClientStateNotFoundError` if the client does not exist.
-*/
-async function assertHasClientState(id, dagRead) {
-	if (!await hasClientState(id, dagRead)) throw new ClientStateNotFoundError(id);
-}
-async function hasClientState(id, dagRead) {
-	return !!await getClient(id, dagRead);
-}
-async function getClient(id, dagRead) {
-	return (await getClients(dagRead)).get(id);
-}
-async function mustGetClient(id, dagRead) {
-	const client = await getClient(id, dagRead);
-	if (!client) throw new ClientStateNotFoundError(id);
-	return client;
-}
-function initClientV6(newClientID, lc, perdag, mutatorNames, indexes, formatVersion, enableClientGroupForking) {
-	return withWrite(perdag, async (dagWrite) => {
-		async function setClientsAndClientGroupAndCommit(basisHash, cookieJSON, valueHash, indexRecords) {
-			const newSnapshotData = newSnapshotCommitDataDD31(basisHash, {}, cookieJSON, valueHash, indexRecords);
-			const chunk = dagWrite.createChunk(newSnapshotData, getRefs(newSnapshotData));
-			const newClientGroupID = makeClientID();
-			const newClient = {
-				heartbeatTimestampMs: Date.now(),
-				refreshHashes: [chunk.hash],
-				persistHash: null,
-				clientGroupID: newClientGroupID
-			};
-			const newClients = new Map(clients).set(newClientID, newClient);
-			const clientGroup = {
-				headHash: chunk.hash,
-				mutatorNames,
-				indexes,
-				mutationIDs: {},
-				lastServerAckdMutationIDs: {},
-				disabled: false
-			};
-			await Promise.all([
-				dagWrite.putChunk(chunk),
-				setClients(newClients, dagWrite),
-				setClientGroup(newClientGroupID, clientGroup, dagWrite)
-			]);
-			return [
-				newClient,
-				chunk.hash,
-				newClients,
-				true
-			];
-		}
-		const clients = await getClients(dagWrite);
-		const res = await findMatchingClient(dagWrite, mutatorNames, indexes);
-		if (res.type === 2) {
-			const { clientGroupID, headHash } = res;
-			const newClient = {
-				clientGroupID,
-				refreshHashes: [headHash],
-				heartbeatTimestampMs: Date.now(),
-				persistHash: null
-			};
-			const newClients = new Map(clients).set(newClientID, newClient);
-			await setClients(newClients, dagWrite);
-			return [
-				newClient,
-				headHash,
-				newClients,
-				false
-			];
-		}
-		if (!enableClientGroupForking || res.type === 0) {
-			const emptyBTreeChunk = dagWrite.createChunk(emptyDataNode, []);
-			await dagWrite.putChunk(emptyBTreeChunk);
-			const indexRecords = [];
-			for (const [name, indexDefinition] of Object.entries(indexes)) {
-				const chunkIndexDefinition = toChunkIndexDefinition(name, indexDefinition);
-				indexRecords.push({
-					definition: chunkIndexDefinition,
-					valueHash: emptyBTreeChunk.hash
-				});
-			}
-			return setClientsAndClientGroupAndCommit(null, null, emptyBTreeChunk.hash, indexRecords);
-		}
-		assert(res.type === 1, "Expected result type to be FORK");
-		const { snapshot } = res;
-		const indexRecords = [];
-		const { valueHash, indexes: oldIndexes } = snapshot;
-		const map = new BTreeRead(dagWrite, formatVersion, valueHash);
-		for (const [name, indexDefinition] of Object.entries(indexes)) {
-			const { prefix = "", jsonPointer, allowEmpty = false } = indexDefinition;
-			const chunkIndexDefinition = {
-				name,
-				keyPrefix: prefix,
-				jsonPointer,
-				allowEmpty
-			};
-			const oldIndex = findMatchingOldIndex(oldIndexes, chunkIndexDefinition);
-			if (oldIndex) indexRecords.push({
-				definition: chunkIndexDefinition,
-				valueHash: oldIndex.valueHash
-			});
-			else {
-				const indexBTree = await createIndexBTree(lc, dagWrite, map, prefix, jsonPointer, allowEmpty, formatVersion);
-				indexRecords.push({
-					definition: chunkIndexDefinition,
-					valueHash: await indexBTree.flush()
-				});
-			}
-		}
-		return setClientsAndClientGroupAndCommit(snapshot.meta.basisHash, snapshot.meta.cookieJSON, snapshot.valueHash, indexRecords);
-	});
-}
-function findMatchingOldIndex(oldIndexes, chunkIndexDefinition) {
-	return oldIndexes.find((index) => chunkIndexDefinitionEqualIgnoreName(index.definition, chunkIndexDefinition));
-}
-async function findMatchingClient(dagRead, mutatorNames, indexes) {
-	let newestCookie;
-	let bestSnapshot;
-	const mutatorNamesSet = new Set(mutatorNames);
-	const clientGroups = await getClientGroups(dagRead);
-	for (const [clientGroupID, clientGroup] of clientGroups) {
-		if (!clientGroup.disabled && mutatorNamesEqual(mutatorNamesSet, clientGroup.mutatorNames) && indexDefinitionsEqual(indexes, clientGroup.indexes)) return {
-			type: 2,
-			clientGroupID,
-			headHash: clientGroup.headHash
-		};
-		const clientGroupSnapshotCommit = await baseSnapshotFromHash(clientGroup.headHash, dagRead);
-		assertSnapshotCommitDD31(clientGroupSnapshotCommit);
-		const { cookieJSON } = clientGroupSnapshotCommit.meta;
-		if (newestCookie === void 0 || compareCookies(cookieJSON, newestCookie) > 0) {
-			newestCookie = cookieJSON;
-			bestSnapshot = clientGroupSnapshotCommit;
-		}
-	}
-	if (bestSnapshot) return {
-		type: 1,
-		snapshot: bestSnapshot
-	};
-	return { type: 0 };
-}
-function getRefsForClients(clients) {
-	const refs = /* @__PURE__ */ new Set();
-	for (const client of clients.values()) if (isClientV6(client)) {
-		for (const hash of client.refreshHashes) refs.add(hash);
-		if (client.persistHash) refs.add(client.persistHash);
-	} else {
-		refs.add(client.headHash);
-		if (client.tempRefreshHash) refs.add(client.tempRefreshHash);
-	}
-	return toRefs(refs);
-}
-async function getClientGroupForClient(clientID, read) {
-	const clientGroupID = await getClientGroupIDForClient(clientID, read);
-	if (!clientGroupID) return;
-	return getClientGroup(clientGroupID, read);
-}
-async function getClientGroupIDForClient(clientID, read) {
-	return (await getClient(clientID, read))?.clientGroupID;
-}
-/**
-* Adds a Client to the ClientMap and updates the 'clients' head to point at
-* the updated clients.
-*/
-async function setClient(clientID, client, dagWrite) {
-	const clients = await getClients(dagWrite);
-	return setClients(new Map(clients).set(clientID, client), dagWrite);
-}
-/**
-* Sets the ClientMap and updates the 'clients' head top point at the new
-* clients.
-*/
-async function setClients(clients, dagWrite) {
-	const chunkData = clientMapToChunkData(clients, dagWrite);
-	const chunk = dagWrite.createChunk(chunkData, getRefsForClients(clients));
-	await dagWrite.putChunk(chunk);
-	await dagWrite.setHead(CLIENTS_HEAD_NAME, chunk.hash);
-	return chunk.hash;
-}
-//#endregion
-export { ClientStateNotFoundError, assertClientV6, assertHasClientState, getClient, getClientGroupForClient, getClientGroupIDForClient, getClients, hasClientState, initClientV6, mustGetClient, setClient, setClients };
-
-//# sourceMappingURL=clients.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"clients.js","names":[],"sources":["../../../../../replicache/src/persist/clients.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert, assertObject} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport * as valita from '../../../shared/src/valita.ts';\nimport {emptyDataNode} from '../btree/node.ts';\nimport {BTreeRead} from '../btree/read.ts';\nimport {type FrozenCookie, compareCookies} from '../cookies.ts';\nimport {type Refs, toRefs} from '../dag/chunk.ts';\nimport type {Read, Store, Write} from '../dag/store.ts';\nimport type {Commit} from '../db/commit.ts';\nimport {\n  type ChunkIndexDefinition,\n  type IndexRecord,\n  type SnapshotMetaDD31,\n  assertSnapshotCommitDD31,\n  baseSnapshotFromHash,\n  chunkIndexDefinitionEqualIgnoreName,\n  getRefs,\n  newSnapshotCommitDataDD31,\n  toChunkIndexDefinition,\n} from '../db/commit.ts';\nimport {createIndexBTree} from '../db/write.ts';\nimport type {DeletedClients} from '../deleted-clients.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport {type FrozenJSONValue, deepFreeze} from '../frozen-json.ts';\nimport {type Hash, hashSchema} from '../hash.ts';\nimport {type IndexDefinitions, indexDefinitionsEqual} from '../index-defs.ts';\nimport {\n  type ClientGroupID,\n  type ClientID,\n  clientGroupIDSchema,\n} from '../sync/ids.ts';\nimport {withWrite} from '../with-transactions.ts';\nimport {\n  type ClientGroup,\n  getClientGroup,\n  getClientGroups,\n  mutatorNamesEqual,\n  setClientGroup,\n} from './client-groups.ts';\nimport {makeClientID} from './make-client-id.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport type ClientMap = ReadonlyMap<ClientID, ClientV5 | ClientV6>;\n\nconst clientV5Schema = valita.readonlyObject({\n  heartbeatTimestampMs: valita.number(),\n\n  headHash: hashSchema,\n\n  /**\n   * The hash of a commit we are in the middle of refreshing into this client's\n   * memdag.\n   */\n  tempRefreshHash: hashSchema.nullable(),\n\n  /**\n   * ID of this client's perdag client group. This needs to be sent in pull\n   * request (to enable syncing all last mutation ids in the client group).\n   */\n  clientGroupID: clientGroupIDSchema,\n});\n\nexport type ClientV5 = valita.Infer<typeof clientV5Schema>;\n\nconst clientV6Schema = valita.readonlyObject({\n  heartbeatTimestampMs: valita.number(),\n\n  /**\n   * A set of hashes, which contains:\n   * 1. The hash of the last commit this client refreshed from its client group\n   *    (this is the commit it bootstrapped from until it completes its first\n   *    refresh).\n   * 2. One or more hashes that were added to retain chunks of a commit while it\n   *    was being refreshed into this client's memdag. (This can be one or more\n   *    because refresh's cleanup step is a separate transaction and can fail).\n   * Upon refresh completing and successfully running its clean up step, this\n   * set will contain a single hash: the hash of the last commit this client\n   * refreshed.\n   */\n  refreshHashes: valita.readonlyArray(hashSchema),\n\n  /**\n   * The hash of the last snapshot commit persisted by this client to this\n   * client's client group, or null if has never persisted a snapshot.\n   */\n  persistHash: hashSchema.nullable(),\n\n  /**\n   * ID of this client's perdag client group. This needs to be sent in pull\n   * request (to enable syncing all last mutation ids in the client group).\n   */\n  clientGroupID: clientGroupIDSchema,\n});\n\nexport type ClientV6 = valita.Infer<typeof clientV6Schema>;\n\nexport type Client = ClientV5 | ClientV6;\n\nfunction isClientV6(client: Client): client is ClientV6 {\n  return (client as ClientV6).refreshHashes !== undefined;\n}\n\nexport const CLIENTS_HEAD_NAME = 'clients';\n\nconst clientSchema = valita.union(clientV5Schema, clientV6Schema);\n\nfunction assertClient(value: unknown): asserts value is Client {\n  valita.assert(value, clientSchema);\n}\n\nexport function assertClientV6(value: unknown): asserts value is ClientV6 {\n  valita.assert(value, clientV6Schema);\n}\n\nfunction chunkDataToClientMap(chunkData: unknown): ClientMap {\n  assertObject(chunkData);\n  const clients = new Map();\n  for (const key in chunkData) {\n    if (hasOwn(chunkData, key)) {\n      const value = chunkData[key];\n      if (value !== undefined) {\n        assertClient(value);\n        clients.set(key, value);\n      }\n    }\n  }\n  return clients;\n}\n\nfunction clientMapToChunkData(\n  clients: ClientMap,\n  dagWrite: Write,\n): FrozenJSONValue {\n  for (const client of clients.values()) {\n    if (isClientV6(client)) {\n      client.refreshHashes.forEach(dagWrite.assertValidHash);\n      if (client.persistHash) {\n        dagWrite.assertValidHash(client.persistHash);\n      }\n    } else {\n      dagWrite.assertValidHash(client.headHash);\n      if (client.tempRefreshHash) {\n        dagWrite.assertValidHash(client.tempRefreshHash);\n      }\n    }\n  }\n  return deepFreeze(Object.fromEntries(clients));\n}\n\nexport async function getClients(dagRead: Read): Promise<ClientMap> {\n  const hash = await dagRead.getHead(CLIENTS_HEAD_NAME);\n  return getClientsAtHash(hash, dagRead);\n}\n\nasync function getClientsAtHash(\n  hash: Hash | undefined,\n  dagRead: Read,\n): Promise<ClientMap> {\n  if (!hash) {\n    return new Map();\n  }\n  const chunk = await dagRead.getChunk(hash);\n  return chunkDataToClientMap(chunk?.data);\n}\n\n/**\n * Used to signal that a client does not exist. Maybe it was garbage collected?\n */\nexport class ClientStateNotFoundError extends Error {\n  name = 'ClientStateNotFoundError';\n  readonly id: string;\n  constructor(id: ClientID) {\n    super(`Client state not found, id: ${id}`);\n    this.id = id;\n  }\n}\n\n/**\n * Throws a `ClientStateNotFoundError` if the client does not exist.\n */\nexport async function assertHasClientState(\n  id: ClientID,\n  dagRead: Read,\n): Promise<void> {\n  if (!(await hasClientState(id, dagRead))) {\n    throw new ClientStateNotFoundError(id);\n  }\n}\n\nexport async function hasClientState(\n  id: ClientID,\n  dagRead: Read,\n): Promise<boolean> {\n  return !!(await getClient(id, dagRead));\n}\n\nexport async function getClient(\n  id: ClientID,\n  dagRead: Read,\n): Promise<Client | undefined> {\n  const clients = await getClients(dagRead);\n  return clients.get(id);\n}\n\nexport async function mustGetClient(\n  id: ClientID,\n  dagRead: Read,\n): Promise<Client> {\n  const client = await getClient(id, dagRead);\n  if (!client) {\n    throw new ClientStateNotFoundError(id);\n  }\n  return client;\n}\n\ntype InitClientV6Result = [\n  client: ClientV6,\n  hash: Hash,\n  clientMap: ClientMap,\n  newClientGroup: boolean,\n];\n\nexport function initClientV6(\n  newClientID: ClientID,\n  lc: LogContext,\n  perdag: Store,\n  mutatorNames: string[],\n  indexes: IndexDefinitions,\n  formatVersion: FormatVersion,\n  enableClientGroupForking: boolean,\n): Promise<InitClientV6Result> {\n  return withWrite(perdag, async dagWrite => {\n    async function setClientsAndClientGroupAndCommit(\n      basisHash: Hash | null,\n      cookieJSON: FrozenCookie,\n      valueHash: Hash,\n      indexRecords: readonly IndexRecord[],\n    ): Promise<InitClientV6Result> {\n      const newSnapshotData = newSnapshotCommitDataDD31(\n        basisHash,\n        {},\n        cookieJSON,\n        valueHash,\n        indexRecords,\n      );\n      const chunk = dagWrite.createChunk(\n        newSnapshotData,\n        getRefs(newSnapshotData),\n      );\n\n      const newClientGroupID = makeClientID();\n\n      const newClient: ClientV6 = {\n        heartbeatTimestampMs: Date.now(),\n        refreshHashes: [chunk.hash],\n        persistHash: null,\n        clientGroupID: newClientGroupID,\n      };\n\n      const newClients = new Map(clients).set(newClientID, newClient);\n\n      const clientGroup: ClientGroup = {\n        headHash: chunk.hash,\n        mutatorNames,\n        indexes,\n        mutationIDs: {},\n        lastServerAckdMutationIDs: {},\n        disabled: false,\n      };\n\n      await Promise.all([\n        dagWrite.putChunk(chunk),\n        setClients(newClients, dagWrite),\n        setClientGroup(newClientGroupID, clientGroup, dagWrite),\n      ]);\n\n      return [newClient, chunk.hash, newClients, true];\n    }\n\n    const clients = await getClients(dagWrite);\n\n    const res = await findMatchingClient(dagWrite, mutatorNames, indexes);\n    if (res.type === FIND_MATCHING_CLIENT_TYPE_HEAD) {\n      // We found a client group with matching mutators and indexes. We can\n      // reuse it.\n      const {clientGroupID, headHash} = res;\n\n      const newClient: ClientV6 = {\n        clientGroupID,\n        refreshHashes: [headHash],\n        heartbeatTimestampMs: Date.now(),\n        persistHash: null,\n      };\n      const newClients = new Map(clients).set(newClientID, newClient);\n      await setClients(newClients, dagWrite);\n\n      return [newClient, headHash, newClients, false];\n    }\n\n    if (\n      !enableClientGroupForking ||\n      res.type === FIND_MATCHING_CLIENT_TYPE_NEW\n    ) {\n      // No client group to fork from. Create empty snapshot.\n      const emptyBTreeChunk = dagWrite.createChunk(emptyDataNode, []);\n      await dagWrite.putChunk(emptyBTreeChunk);\n\n      // Create indexes\n      const indexRecords: IndexRecord[] = [];\n\n      // At this point the value of replicache is the empty tree so all index\n      // maps will also be the empty tree.\n      for (const [name, indexDefinition] of Object.entries(indexes)) {\n        const chunkIndexDefinition = toChunkIndexDefinition(\n          name,\n          indexDefinition,\n        );\n        indexRecords.push({\n          definition: chunkIndexDefinition,\n          valueHash: emptyBTreeChunk.hash,\n        });\n      }\n\n      return setClientsAndClientGroupAndCommit(\n        null,\n        null,\n        emptyBTreeChunk.hash,\n        indexRecords,\n      );\n    }\n\n    // Now we create a new client and client group that we fork from the found\n    // snapshot.\n    assert(\n      res.type === FIND_MATCHING_CLIENT_TYPE_FORK,\n      'Expected result type to be FORK',\n    );\n\n    const {snapshot} = res;\n\n    // Create indexes\n    const indexRecords: IndexRecord[] = [];\n    const {valueHash, indexes: oldIndexes} = snapshot;\n    const map = new BTreeRead(dagWrite, formatVersion, valueHash);\n\n    for (const [name, indexDefinition] of Object.entries(indexes)) {\n      const {prefix = '', jsonPointer, allowEmpty = false} = indexDefinition;\n      const chunkIndexDefinition: ChunkIndexDefinition = {\n        name,\n        keyPrefix: prefix,\n        jsonPointer,\n        allowEmpty,\n      };\n\n      const oldIndex = findMatchingOldIndex(oldIndexes, chunkIndexDefinition);\n      if (oldIndex) {\n        indexRecords.push({\n          definition: chunkIndexDefinition,\n          valueHash: oldIndex.valueHash,\n        });\n      } else {\n        const indexBTree = await createIndexBTree(\n          lc,\n          dagWrite,\n          map,\n          prefix,\n          jsonPointer,\n          allowEmpty,\n          formatVersion,\n        );\n        indexRecords.push({\n          definition: chunkIndexDefinition,\n          valueHash: await indexBTree.flush(),\n        });\n      }\n    }\n\n    return setClientsAndClientGroupAndCommit(\n      snapshot.meta.basisHash,\n      snapshot.meta.cookieJSON,\n      snapshot.valueHash,\n      indexRecords,\n    );\n  });\n}\n\nfunction findMatchingOldIndex(\n  oldIndexes: readonly IndexRecord[],\n  chunkIndexDefinition: ChunkIndexDefinition,\n) {\n  return oldIndexes.find(index =>\n    chunkIndexDefinitionEqualIgnoreName(index.definition, chunkIndexDefinition),\n  );\n}\n\nexport const FIND_MATCHING_CLIENT_TYPE_NEW = 0;\nexport const FIND_MATCHING_CLIENT_TYPE_FORK = 1;\nexport const FIND_MATCHING_CLIENT_TYPE_HEAD = 2;\n\nexport type FindMatchingClientResult =\n  | {\n      type: typeof FIND_MATCHING_CLIENT_TYPE_NEW;\n    }\n  | {\n      type: typeof FIND_MATCHING_CLIENT_TYPE_FORK;\n      snapshot: Commit<SnapshotMetaDD31>;\n    }\n  | {\n      type: typeof FIND_MATCHING_CLIENT_TYPE_HEAD;\n      clientGroupID: ClientGroupID;\n      headHash: Hash;\n    };\n\nexport async function findMatchingClient(\n  dagRead: Read,\n  mutatorNames: string[],\n  indexes: IndexDefinitions,\n): Promise<FindMatchingClientResult> {\n  let newestCookie: FrozenCookie | undefined;\n  let bestSnapshot: Commit<SnapshotMetaDD31> | undefined;\n  const mutatorNamesSet = new Set(mutatorNames);\n\n  const clientGroups = await getClientGroups(dagRead);\n  for (const [clientGroupID, clientGroup] of clientGroups) {\n    if (\n      !clientGroup.disabled &&\n      mutatorNamesEqual(mutatorNamesSet, clientGroup.mutatorNames) &&\n      indexDefinitionsEqual(indexes, clientGroup.indexes)\n    ) {\n      // exact match\n      return {\n        type: FIND_MATCHING_CLIENT_TYPE_HEAD,\n        clientGroupID,\n        headHash: clientGroup.headHash,\n      };\n    }\n\n    const clientGroupSnapshotCommit = await baseSnapshotFromHash(\n      clientGroup.headHash,\n      dagRead,\n    );\n    assertSnapshotCommitDD31(clientGroupSnapshotCommit);\n\n    const {cookieJSON} = clientGroupSnapshotCommit.meta;\n    if (\n      newestCookie === undefined ||\n      compareCookies(cookieJSON, newestCookie) > 0\n    ) {\n      newestCookie = cookieJSON;\n      bestSnapshot = clientGroupSnapshotCommit;\n    }\n  }\n\n  if (bestSnapshot) {\n    return {\n      type: FIND_MATCHING_CLIENT_TYPE_FORK,\n      snapshot: bestSnapshot,\n    };\n  }\n\n  return {type: FIND_MATCHING_CLIENT_TYPE_NEW};\n}\n\nfunction getRefsForClients(clients: ClientMap): Refs {\n  const refs: Set<Hash> = new Set();\n  for (const client of clients.values()) {\n    if (isClientV6(client)) {\n      for (const hash of client.refreshHashes) {\n        refs.add(hash);\n      }\n      if (client.persistHash) {\n        refs.add(client.persistHash);\n      }\n    } else {\n      refs.add(client.headHash);\n      if (client.tempRefreshHash) {\n        refs.add(client.tempRefreshHash);\n      }\n    }\n  }\n  return toRefs(refs);\n}\n\nexport async function getClientGroupForClient(\n  clientID: ClientID,\n  read: Read,\n): Promise<ClientGroup | undefined> {\n  const clientGroupID = await getClientGroupIDForClient(clientID, read);\n  if (!clientGroupID) {\n    return undefined;\n  }\n  return getClientGroup(clientGroupID, read);\n}\n\nexport async function getClientGroupIDForClient(\n  clientID: ClientID,\n  read: Read,\n): Promise<ClientGroupID | undefined> {\n  const client = await getClient(clientID, read);\n  return client?.clientGroupID;\n}\n\n/**\n * Adds a Client to the ClientMap and updates the 'clients' head to point at\n * the updated clients.\n */\nexport async function setClient(\n  clientID: ClientID,\n  client: Client,\n  dagWrite: Write,\n): Promise<Hash> {\n  const clients = await getClients(dagWrite);\n  const newClients = new Map(clients).set(clientID, client);\n  return setClients(newClients, dagWrite);\n}\n\n/**\n * Sets the ClientMap and updates the 'clients' head top point at the new\n * clients.\n */\nexport async function setClients(\n  clients: ClientMap,\n  dagWrite: Write,\n): Promise<Hash> {\n  const chunkData = clientMapToChunkData(clients, dagWrite);\n  const chunk = dagWrite.createChunk(chunkData, getRefsForClients(clients));\n  await dagWrite.putChunk(chunk);\n  await dagWrite.setHead(CLIENTS_HEAD_NAME, chunk.hash);\n  return chunk.hash;\n}\n\n/**\n * Callback function for when Replicache has deleted one or more clients.\n */\nexport type OnClientsDeleted = (\n  deletedClients: DeletedClients,\n) => Promise<void>;\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"collect-idb-databases.js","names":[],"sources":["../../../../../replicache/src/persist/collect-idb-databases.ts"],"sourcesContent":["import type {LogContext, LogLevel, LogSink} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {initBgIntervalProcess} from '../bg-interval.ts';\nimport {StoreImpl} from '../dag/store-impl.ts';\nimport type {Store} from '../dag/store.ts';\nimport {\n  addDeletedClients,\n  getDeletedClients,\n  mergeDeletedClients,\n  normalizeDeletedClients,\n  type DeletedClients,\n  type WritableDeletedClients,\n} from '../deleted-clients.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport {getKVStoreProvider} from '../get-kv-store-provider.ts';\nimport {assertHash, newRandomHash} from '../hash.ts';\nimport type {CreateStore, DropStore, StoreProvider} from '../kv/store.ts';\nimport {createLogContext} from '../log-options.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {\n  clientGroupHasPendingMutations,\n  getClientGroups,\n} from './client-groups.ts';\nimport type {OnClientsDeleted} from './clients.ts';\nimport {getClients} from './clients.ts';\nimport type {IndexedDBDatabase} from './idb-databases-store.ts';\nimport {IDBDatabasesStore} from './idb-databases-store.ts';\n\n/**\n * How frequently to try to collect\n */\nexport const COLLECT_IDB_INTERVAL = 12 * 60 * 60 * 1000; // 12 hours\n\n/**\n * We delay the initial collection to prevent doing it at startup.\n */\nexport const INITIAL_COLLECT_IDB_DELAY = 5 * 60 * 1000; // 5 minutes\n\nexport function initCollectIDBDatabases(\n  idbDatabasesStore: IDBDatabasesStore,\n  kvStoreProvider: StoreProvider,\n  collectInterval: number,\n  initialCollectDelay: number,\n  maxAge: number,\n  enableMutationRecovery: boolean,\n  onClientsDeleted: OnClientsDeleted,\n  lc: LogContext,\n  signal: AbortSignal,\n): void {\n  let initial = true;\n  initBgIntervalProcess(\n    'CollectIDBDatabases',\n    async () => {\n      await collectIDBDatabases(\n        idbDatabasesStore,\n        Date.now(),\n        maxAge,\n        kvStoreProvider,\n        enableMutationRecovery,\n        onClientsDeleted,\n      );\n    },\n    () => {\n      if (initial) {\n        initial = false;\n        return initialCollectDelay;\n      }\n      return collectInterval;\n    },\n    lc,\n    signal,\n  );\n}\n\n/**\n * Collects IDB databases that are no longer needed.\n */\nexport async function collectIDBDatabases(\n  idbDatabasesStore: IDBDatabasesStore,\n  now: number,\n  maxAge: number,\n  kvStoreProvider: StoreProvider,\n  enableMutationRecovery: boolean,\n  onClientsDeleted: OnClientsDeleted,\n  newDagStore = defaultNewDagStore,\n): Promise<void> {\n  const databases = await idbDatabasesStore.getDatabases();\n\n  const dbs = Object.values(databases);\n  const collectResults = await Promise.all(\n    dbs.map(\n      async db =>\n        [\n          db.name,\n          await gatherDatabaseInfoForCollect(\n            db,\n            now,\n            maxAge,\n            enableMutationRecovery,\n            kvStoreProvider.create,\n            newDagStore,\n          ),\n        ] as const,\n    ),\n  );\n\n  const dbNamesToRemove: string[] = [];\n  const dbNamesToKeep: string[] = [];\n  const deletedClientsToRemove: WritableDeletedClients = [];\n  for (const [dbName, [canCollect, deletedClients]] of collectResults) {\n    if (canCollect) {\n      dbNamesToRemove.push(dbName);\n      deletedClientsToRemove.push(...deletedClients);\n    } else {\n      dbNamesToKeep.push(dbName);\n    }\n  }\n\n  const {errors} = await dropDatabases(\n    idbDatabasesStore,\n    dbNamesToRemove,\n    kvStoreProvider.drop,\n  );\n  if (errors.length) {\n    throw errors[0];\n  }\n\n  if (deletedClientsToRemove.length > 0) {\n    // Add the deleted clients to all the dbs that survived the collection.\n    let allDeletedClients: DeletedClients = deletedClientsToRemove;\n    for (const name of dbNamesToKeep) {\n      await withWrite(\n        newDagStore(name, kvStoreProvider.create),\n        async dagWrite => {\n          const newDeletedClients = await addDeletedClients(\n            dagWrite,\n            deletedClientsToRemove,\n          );\n\n          allDeletedClients = mergeDeletedClients(\n            allDeletedClients,\n            newDeletedClients,\n          );\n        },\n      );\n    }\n    // normalize and dedupe\n    const normalizedDeletedClients = normalizeDeletedClients(allDeletedClients);\n\n    // Call the callback with the normalized deleted clients\n    await onClientsDeleted(normalizedDeletedClients);\n  }\n}\n\nasync function dropDatabaseInternal(\n  name: string,\n  idbDatabasesStore: IDBDatabasesStore,\n  kvDropStore: DropStore,\n) {\n  await kvDropStore(name);\n  await idbDatabasesStore.deleteDatabases([name]);\n}\n\nasync function dropDatabases(\n  idbDatabasesStore: IDBDatabasesStore,\n  namesToRemove: string[],\n  kvDropStore: DropStore,\n): Promise<{dropped: string[]; errors: unknown[]}> {\n  // Try to remove the databases in parallel. Don't let a single reject fail the\n  // other ones. We will check for failures afterwards.\n  const dropStoreResults = await Promise.allSettled(\n    namesToRemove.map(async name => {\n      await dropDatabaseInternal(name, idbDatabasesStore, kvDropStore);\n      return name;\n    }),\n  );\n\n  const dropped: string[] = [];\n  const errors: unknown[] = [];\n  for (const result of dropStoreResults) {\n    if (result.status === 'fulfilled') {\n      dropped.push(result.value);\n    } else {\n      errors.push(result.reason);\n    }\n  }\n\n  return {dropped, errors};\n}\n\nfunction defaultNewDagStore(name: string, kvCreateStore: CreateStore): Store {\n  const perKvStore = kvCreateStore(name);\n  return new StoreImpl(perKvStore, newRandomHash, assertHash);\n}\n\n/**\n * If any client has a recent heartbeat or there are pending mutations we\n * return `[false]`. Otherwise we return `[true, deletedClients]`.\n */\nfunction gatherDatabaseInfoForCollect(\n  db: IndexedDBDatabase,\n  now: number,\n  maxAge: number,\n  enableMutationRecovery: boolean,\n  kvCreateStore: CreateStore,\n  newDagStore: typeof defaultNewDagStore,\n): MaybePromise<\n  [canCollect: false] | [canCollect: true, deletedClients: DeletedClients]\n> {\n  if (db.replicacheFormatVersion > FormatVersion.Latest) {\n    return [false];\n  }\n\n  // If increase the format version we need to decide how to deal with this\n  // logic.\n  assert(\n    db.replicacheFormatVersion === FormatVersion.DD31 ||\n      db.replicacheFormatVersion === FormatVersion.V6 ||\n      db.replicacheFormatVersion === FormatVersion.V7,\n    () =>\n      `Expected replicacheFormatVersion to be DD31, V6, or V7, got ${db.replicacheFormatVersion}`,\n  );\n  return canDatabaseBeCollectedAndGetDeletedClientIDs(\n    enableMutationRecovery,\n    newDagStore(db.name, kvCreateStore),\n    now,\n    maxAge,\n  );\n}\n\n/**\n * Options for `dropDatabase` and `dropAllDatabases`.\n */\nexport type DropDatabaseOptions = {\n  /**\n   * Allows providing a custom implementation of the underlying storage layer.\n   * Default is `'idb'`.\n   */\n  kvStore?: 'idb' | 'mem' | StoreProvider | undefined;\n  /**\n   * Determines how much logging to do. When this is set to `'debug'`,\n   * Replicache will also log `'info'` and `'error'` messages. When set to\n   * `'info'` we log `'info'` and `'error'` but not `'debug'`. When set to\n   * `'error'` we only log `'error'` messages.\n   * Default is `'info'`.\n   */\n  logLevel?: LogLevel | undefined;\n  /**\n   * Enables custom handling of logs.\n   *\n   * By default logs are logged to the console.  If you would like logs to be\n   * sent elsewhere (e.g. to a cloud logging service like DataDog) you can\n   * provide an array of {@link LogSink}s.  Logs at or above\n   * {@link DropDatabaseOptions.logLevel} are sent to each of these {@link LogSink}s.\n   * If you would still like logs to go to the console, include\n   * `consoleLogSink` in the array.\n   *\n   * ```ts\n   * logSinks: [consoleLogSink, myCloudLogSink],\n   * ```\n   * Default is `[consoleLogSink]`.\n   */\n  logSinks?: LogSink[] | undefined;\n};\n\n/**\n * Drops the specified database.\n * @param dbName The name of the database to drop.\n * @param opts Options for dropping the database.\n */\nexport async function dropDatabase(dbName: string, opts?: DropDatabaseOptions) {\n  const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {\n    dropDatabase: undefined,\n  });\n  const kvStoreProvider = getKVStoreProvider(logContext, opts?.kvStore);\n  await dropDatabaseInternal(\n    dbName,\n    new IDBDatabasesStore(kvStoreProvider.create),\n    kvStoreProvider.drop,\n  );\n}\n\n/**\n * Deletes all IndexedDB data associated with Replicache.\n *\n * Returns an object with the names of the successfully dropped databases\n * and any errors encountered while dropping.\n */\nexport async function dropAllDatabases(opts?: DropDatabaseOptions): Promise<{\n  dropped: string[];\n  errors: unknown[];\n}> {\n  const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {\n    dropAllDatabases: undefined,\n  });\n  const kvStoreProvider = getKVStoreProvider(logContext, opts?.kvStore);\n  const store = new IDBDatabasesStore(kvStoreProvider.create);\n  const databases = await store.getDatabases();\n  const dbNames = Object.values(databases).map(db => db.name);\n  return dropDatabases(store, dbNames, kvStoreProvider.drop);\n}\n\n/**\n * Deletes all IndexedDB data associated with Replicache.\n *\n * Returns an object with the names of the successfully dropped databases\n * and any errors encountered while dropping.\n *\n * @deprecated Use `dropAllDatabases` instead.\n */\nexport function deleteAllReplicacheData(opts?: DropDatabaseOptions) {\n  return dropAllDatabases(opts);\n}\n\n/**\n * If there are pending mutations in any of the clients in this db we return\n * `[false]`. If any client has a recent heartbeat we also return `[false]`.\n * Otherwise we return `[true, deletedClients]`.\n */\nfunction canDatabaseBeCollectedAndGetDeletedClientIDs(\n  enableMutationRecovery: boolean,\n  perdag: Store,\n  now: number,\n  maxAge: number,\n): Promise<\n  [canCollect: false] | [canCollect: true, deletedClients: DeletedClients]\n> {\n  return withRead(perdag, async read => {\n    // If mutation recovery is disabled we do not care if there are pending\n    // mutations when we decide if we can collect the database.\n    if (enableMutationRecovery) {\n      const clientGroups = await getClientGroups(read);\n      for (const clientGroup of clientGroups.values()) {\n        if (clientGroupHasPendingMutations(clientGroup)) {\n          return [false];\n        }\n      }\n    }\n\n    const clients = await getClients(read);\n\n    // Don't collect if any client has a recent heartbeat (is still active).\n    // This is defense in depth - normally lastOpenedTimestampMS is kept fresh\n    // by the heartbeat, but this check protects against edge cases.\n    for (const [, client] of clients) {\n      if (now - client.heartbeatTimestampMs < maxAge) {\n        return [false];\n      }\n    }\n\n    const existingDeletedClients = await getDeletedClients(read);\n    const deletedClients: WritableDeletedClients = [...existingDeletedClients];\n\n    // Add all current clients to the deleted clients list\n    for (const [clientID, client] of clients) {\n      deletedClients.push({\n        clientID,\n        clientGroupID: client.clientGroupID,\n      });\n    }\n\n    // The normalization (deduping and sorting) will be done when storing\n    return [true, deletedClients];\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgCA,IAAa,uBAAuB,MAAU,KAAK;;;;AAKnD,IAAa,4BAA4B,MAAS;AAElD,SAAgB,wBACd,mBACA,iBACA,iBACA,qBACA,QACA,wBACA,kBACA,IACA,QACM;CACN,IAAI,UAAU;AACd,uBACE,uBACA,YAAY;AACV,QAAM,oBACJ,mBACA,KAAK,KAAK,EACV,QACA,iBACA,wBACA,iBACD;UAEG;AACJ,MAAI,SAAS;AACX,aAAU;AACV,UAAO;;AAET,SAAO;IAET,IACA,OACD;;;;;AAMH,eAAsB,oBACpB,mBACA,KACA,QACA,iBACA,wBACA,kBACA,cAAc,oBACC;CACf,MAAM,YAAY,MAAM,kBAAkB,cAAc;CAExD,MAAM,MAAM,OAAO,OAAO,UAAU;CACpC,MAAM,iBAAiB,MAAM,QAAQ,IACnC,IAAI,IACF,OAAM,OACJ,CACE,GAAG,MACH,MAAM,6BACJ,IACA,KACA,QACA,wBACA,gBAAgB,QAChB,YACD,CACF,CACJ,CACF;CAED,MAAM,kBAA4B,EAAE;CACpC,MAAM,gBAA0B,EAAE;CAClC,MAAM,yBAAiD,EAAE;AACzD,MAAK,MAAM,CAAC,QAAQ,CAAC,YAAY,oBAAoB,eACnD,KAAI,YAAY;AACd,kBAAgB,KAAK,OAAO;AAC5B,yBAAuB,KAAK,GAAG,eAAe;OAE9C,eAAc,KAAK,OAAO;CAI9B,MAAM,EAAC,WAAU,MAAM,cACrB,mBACA,iBACA,gBAAgB,KACjB;AACD,KAAI,OAAO,OACT,OAAM,OAAO;AAGf,KAAI,uBAAuB,SAAS,GAAG;EAErC,IAAI,oBAAoC;AACxC,OAAK,MAAM,QAAQ,cACjB,OAAM,UACJ,YAAY,MAAM,gBAAgB,OAAO,EACzC,OAAM,aAAY;GAChB,MAAM,oBAAoB,MAAM,kBAC9B,UACA,uBACD;AAED,uBAAoB,oBAClB,mBACA,kBACD;IAEJ;AAMH,QAAM,iBAH2B,wBAAwB,kBAAkB,CAG3B;;;AAIpD,eAAe,qBACb,MACA,mBACA,aACA;AACA,OAAM,YAAY,KAAK;AACvB,OAAM,kBAAkB,gBAAgB,CAAC,KAAK,CAAC;;AAGjD,eAAe,cACb,mBACA,eACA,aACiD;CAGjD,MAAM,mBAAmB,MAAM,QAAQ,WACrC,cAAc,IAAI,OAAM,SAAQ;AAC9B,QAAM,qBAAqB,MAAM,mBAAmB,YAAY;AAChE,SAAO;GACP,CACH;CAED,MAAM,UAAoB,EAAE;CAC5B,MAAM,SAAoB,EAAE;AAC5B,MAAK,MAAM,UAAU,iBACnB,KAAI,OAAO,WAAW,YACpB,SAAQ,KAAK,OAAO,MAAM;KAE1B,QAAO,KAAK,OAAO,OAAO;AAI9B,QAAO;EAAC;EAAS;EAAO;;AAG1B,SAAS,mBAAmB,MAAc,eAAmC;AAE3E,QAAO,IAAI,UADQ,cAAc,KAAK,EACL,eAAe,WAAW;;;;;;AAO7D,SAAS,6BACP,IACA,KACA,QACA,wBACA,eACA,aAGA;AACA,KAAI,GAAG,0BAA0B,EAC/B,QAAO,CAAC,MAAM;AAKhB,QACE,GAAG,4BAA4B,KAC7B,GAAG,4BAA4B,KAC/B,GAAG,4BAA4B,SAE/B,+DAA+D,GAAG,0BACrE;AACD,QAAO,6CACL,wBACA,YAAY,GAAG,MAAM,cAAc,EACnC,KACA,OACD;;;;;;;AA2CH,eAAsB,aAAa,QAAgB,MAA4B;CAI7E,MAAM,kBAAkB,mBAHL,iBAAiB,MAAM,UAAU,MAAM,UAAU,EAClE,cAAc,KAAA,GACf,CAAC,EACqD,MAAM,QAAQ;AACrE,OAAM,qBACJ,QACA,IAAI,kBAAkB,gBAAgB,OAAO,EAC7C,gBAAgB,KACjB;;;;;;;;AASH,eAAsB,iBAAiB,MAGpC;CAID,MAAM,kBAAkB,mBAHL,iBAAiB,MAAM,UAAU,MAAM,UAAU,EAClE,kBAAkB,KAAA,GACnB,CAAC,EACqD,MAAM,QAAQ;CACrE,MAAM,QAAQ,IAAI,kBAAkB,gBAAgB,OAAO;CAC3D,MAAM,YAAY,MAAM,MAAM,cAAc;AAE5C,QAAO,cAAc,OADL,OAAO,OAAO,UAAU,CAAC,KAAI,OAAM,GAAG,KAAK,EACtB,gBAAgB,KAAK;;;;;;;AAoB5D,SAAS,6CACP,wBACA,QACA,KACA,QAGA;AACA,QAAO,SAAS,QAAQ,OAAM,SAAQ;AAGpC,MAAI,wBAAwB;GAC1B,MAAM,eAAe,MAAM,gBAAgB,KAAK;AAChD,QAAK,MAAM,eAAe,aAAa,QAAQ,CAC7C,KAAI,+BAA+B,YAAY,CAC7C,QAAO,CAAC,MAAM;;EAKpB,MAAM,UAAU,MAAM,WAAW,KAAK;AAKtC,OAAK,MAAM,GAAG,WAAW,QACvB,KAAI,MAAM,OAAO,uBAAuB,OACtC,QAAO,CAAC,MAAM;EAKlB,MAAM,iBAAyC,CAAC,GADjB,MAAM,kBAAkB,KAAK,CACc;AAG1E,OAAK,MAAM,CAAC,UAAU,WAAW,QAC/B,gBAAe,KAAK;GAClB;GACA,eAAe,OAAO;GACvB,CAAC;AAIJ,SAAO,CAAC,MAAM,eAAe;GAC7B"}

package/out/replicache/src/persist/gather-mem-only-visitor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gather-mem-only-visitor.js","names":["#gatheredChunks","#lazyRead"],"sources":["../../../../../replicache/src/persist/gather-mem-only-visitor.ts"],"sourcesContent":["import {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport type {Chunk} from '../dag/chunk.ts';\nimport type {LazyRead} from '../dag/lazy-store.ts';\nimport {Visitor} from '../dag/visitor.ts';\nimport type {Hash} from '../hash.ts';\n\nexport class GatherMemoryOnlyVisitor extends Visitor {\n  readonly #gatheredChunks: Map<Hash, Chunk> = new Map();\n  readonly #lazyRead: LazyRead;\n\n  constructor(dagRead: LazyRead) {\n    super(dagRead);\n    this.#lazyRead = dagRead;\n  }\n\n  get gatheredChunks(): ReadonlyMap<Hash, Chunk> {\n    return this.#gatheredChunks;\n  }\n\n  override visit(h: Hash): Promise<void> {\n    if (!this.#lazyRead.isMemOnlyChunkHash(h)) {\n      // Not a memory-only hash, no need to visit anything else.\n      return promiseVoid;\n    }\n    return super.visit(h);\n  }\n\n  override visitChunk(chunk: Chunk): Promise<void> {\n    this.#gatheredChunks.set(chunk.hash, chunk);\n    return super.visitChunk(chunk);\n  }\n}\n"],"mappings":";;;AAMA,IAAa,0BAAb,cAA6C,QAAQ;CACnD,kCAA6C,IAAI,KAAK;CACtD;CAEA,YAAY,SAAmB;AAC7B,QAAM,QAAQ;AACd,QAAA,WAAiB;;CAGnB,IAAI,iBAA2C;AAC7C,SAAO,MAAA;;CAGT,MAAe,GAAwB;AACrC,MAAI,CAAC,MAAA,SAAe,mBAAmB,EAAE,CAEvC,QAAO;AAET,SAAO,MAAM,MAAM,EAAE;;CAGvB,WAAoB,OAA6B;AAC/C,QAAA,eAAqB,IAAI,MAAM,MAAM,MAAM;AAC3C,SAAO,MAAM,WAAW,MAAM"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"gather-not-cached-visitor.js","names":["#gatheredChunks","#lazyStore","#gatherSizeLimit","#getSizeOfChunk","#gatheredChunksTotalSize"],"sources":["../../../../../replicache/src/persist/gather-not-cached-visitor.ts"],"sourcesContent":["import {promiseVoid} from '../../../shared/src/resolved-promises.ts';\nimport {getSizeOfValue} from '../../../shared/src/size-of-value.ts';\nimport type {Chunk} from '../dag/chunk.ts';\nimport type {LazyStore} from '../dag/lazy-store.ts';\nimport type {Read} from '../dag/store.ts';\nimport {Visitor} from '../dag/visitor.ts';\nimport type {Hash} from '../hash.ts';\n\nexport type ChunkWithSize = {chunk: Chunk; size: number};\n\nexport class GatherNotCachedVisitor extends Visitor {\n  readonly #gatheredChunks: Map<Hash, ChunkWithSize> = new Map();\n  #gatheredChunksTotalSize = 0;\n  readonly #lazyStore: LazyStore;\n  readonly #gatherSizeLimit: number;\n  readonly #getSizeOfChunk: (chunk: Chunk) => number;\n\n  constructor(\n    dagRead: Read,\n    lazyStore: LazyStore,\n    gatherSizeLimit: number,\n    getSizeOfChunk: (chunk: Chunk) => number = getSizeOfValue,\n  ) {\n    super(dagRead);\n    this.#lazyStore = lazyStore;\n    this.#gatherSizeLimit = gatherSizeLimit;\n    this.#getSizeOfChunk = getSizeOfChunk;\n  }\n\n  get gatheredChunks(): ReadonlyMap<Hash, ChunkWithSize> {\n    return this.#gatheredChunks;\n  }\n\n  override visit(h: Hash): Promise<void> {\n    if (\n      this.#gatheredChunksTotalSize >= this.#gatherSizeLimit ||\n      this.#lazyStore.isCached(h)\n    ) {\n      return promiseVoid;\n    }\n    return super.visit(h);\n  }\n\n  override visitChunk(chunk: Chunk): Promise<void> {\n    if (this.#gatheredChunksTotalSize < this.#gatherSizeLimit) {\n      const size = this.#getSizeOfChunk(chunk);\n      this.#gatheredChunks.set(chunk.hash, {chunk, size});\n      this.#gatheredChunksTotalSize += size;\n    }\n\n    return super.visitChunk(chunk);\n  }\n}\n"],"mappings":";;;;AAUA,IAAa,yBAAb,cAA4C,QAAQ;CAClD,kCAAqD,IAAI,KAAK;CAC9D,2BAA2B;CAC3B;CACA;CACA;CAEA,YACE,SACA,WACA,iBACA,iBAA2C,gBAC3C;AACA,QAAM,QAAQ;AACd,QAAA,YAAkB;AAClB,QAAA,kBAAwB;AACxB,QAAA,iBAAuB;;CAGzB,IAAI,iBAAmD;AACrD,SAAO,MAAA;;CAGT,MAAe,GAAwB;AACrC,MACE,MAAA,2BAAiC,MAAA,mBACjC,MAAA,UAAgB,SAAS,EAAE,CAE3B,QAAO;AAET,SAAO,MAAM,MAAM,EAAE;;CAGvB,WAAoB,OAA6B;AAC/C,MAAI,MAAA,0BAAgC,MAAA,iBAAuB;GACzD,MAAM,OAAO,MAAA,eAAqB,MAAM;AACxC,SAAA,eAAqB,IAAI,MAAM,MAAM;IAAC;IAAO;IAAK,CAAC;AACnD,SAAA,2BAAiC;;AAGnC,SAAO,MAAM,WAAW,MAAM"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"heartbeat.js","names":[],"sources":["../../../../../replicache/src/persist/heartbeat.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {initBgIntervalProcess} from '../bg-interval.ts';\nimport type {Store} from '../dag/store.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport {withWrite} from '../with-transactions.ts';\nimport {\n  type ClientMap,\n  ClientStateNotFoundError,\n  getClients,\n  setClients,\n} from './clients.ts';\n\nexport const HEARTBEAT_INTERVAL = 60 * 1000;\n\nexport let latestHeartbeatUpdate: Promise<ClientMap> | undefined;\n\nexport function startHeartbeats(\n  clientID: ClientID,\n  dagStore: Store,\n  onClientStateNotFound: () => void,\n  heartbeatIntervalMs: number,\n  lc: LogContext,\n  signal: AbortSignal,\n): void {\n  initBgIntervalProcess(\n    'Heartbeat',\n    async () => {\n      latestHeartbeatUpdate = writeHeartbeat(clientID, dagStore);\n      try {\n        return await latestHeartbeatUpdate;\n      } catch (e) {\n        if (e instanceof ClientStateNotFoundError) {\n          onClientStateNotFound();\n          return;\n        }\n        throw e;\n      }\n    },\n    () => heartbeatIntervalMs,\n    lc,\n    signal,\n  );\n}\n\nexport function writeHeartbeat(\n  clientID: ClientID,\n  dagStore: Store,\n): Promise<ClientMap> {\n  return withWrite(dagStore, async dagWrite => {\n    const clients = await getClients(dagWrite);\n    const client = clients.get(clientID);\n    if (!client) {\n      throw new ClientStateNotFoundError(clientID);\n    }\n\n    const newClient = {\n      ...client,\n      heartbeatTimestampMs: Date.now(),\n    };\n    const newClients = new Map(clients).set(clientID, newClient);\n\n    await setClients(newClients, dagWrite);\n    return newClients;\n  });\n}\n"],"mappings":";;;;AAYA,IAAa,qBAAqB,KAAK;AAEvC,IAAW;AAEX,SAAgB,gBACd,UACA,UACA,uBACA,qBACA,IACA,QACM;AACN,uBACE,aACA,YAAY;AACV,0BAAwB,eAAe,UAAU,SAAS;AAC1D,MAAI;AACF,UAAO,MAAM;WACN,GAAG;AACV,OAAI,aAAa,0BAA0B;AACzC,2BAAuB;AACvB;;AAEF,SAAM;;UAGJ,qBACN,IACA,OACD;;AAGH,SAAgB,eACd,UACA,UACoB;AACpB,QAAO,UAAU,UAAU,OAAM,aAAY;EAC3C,MAAM,UAAU,MAAM,WAAW,SAAS;EAC1C,MAAM,SAAS,QAAQ,IAAI,SAAS;AACpC,MAAI,CAAC,OACH,OAAM,IAAI,yBAAyB,SAAS;EAG9C,MAAM,YAAY;GAChB,GAAG;GACH,sBAAsB,KAAK,KAAK;GACjC;EACD,MAAM,aAAa,IAAI,IAAI,QAAQ,CAAC,IAAI,UAAU,UAAU;AAE5D,QAAM,WAAW,YAAY,SAAS;AACtC,SAAO;GACP"}

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

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

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

@@ -1 +0,0 @@
-{"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;AAC1C,cAAa,MAAM;AACnB,MAAK,MAAM,CAAC,MAAM,OAAO,OAAO,QAAQ,MAAM,EAAE;AAC9C,eAAa,KAAK;AAClB,0BAAwB,GAAG;AAC3B,SACE,SAAS,GAAG,YACN,wBAAwB,KAAK,sBAAsB,GAAG,KAAK,GAClE;;;AAIL,SAAS,wBACP,OACoC;AACpC,cAAa,MAAM;AACnB,cAAa,MAAM,KAAK;AACxB,cAAa,MAAM,eAAe;AAClC,cAAa,MAAM,wBAAwB;AAC3C,cAAa,MAAM,cAAc;AACjC,KAAI,MAAM,0BAA0B,KAAA,EAClC,cAAa,MAAM,sBAAsB;;AAI7C,IAAa,oBAAb,MAA+B;CAC7B;CAEA,YAAY,eAA4B;AACtC,QAAA,UAAgB,cAAc,uBAAuB,CAAC;;CAGxD,YAAY,IAAyD;AACnE,SAAO,MAAA,YAAkB,GAAG;;CAG9B,sBACE,IACkC;AAClC,SAAO,MAAA,YAAkB,GAAG;;CAG9B,aAAa,IAAyD;AACpE,SAAO,UAAU,MAAA,SAAe,OAAM,UAAS;GAE7C,MAAM,WAAW;IACf,GAFkB,MAAM,aAAa,MAAM;KAG1C,GAAG,OAAO;IACZ;AACD,SAAM,MAAM,IAAI,SAAS,SAAS;AAClC,UAAO;IACP;;CAGJ,iBAAgC;AAC9B,SAAO,UAAU,MAAA,UAAe,UAAS,MAAM,IAAI,QAAQ,CAAC;;CAG9D,gBAAgB,OAA+C;AAC7D,SAAO,UAAU,MAAA,SAAe,OAAM,UAAS;GAE7C,MAAM,WAAW,EACf,GAFkB,MAAM,aAAa,MAAM,EAG5C;AACD,QAAK,MAAM,QAAQ,MACjB,QAAO,SAAS;AAElB,SAAM,MAAM,IAAI,SAAS,SAAS;IAClC;;CAGJ,eAAiD;AAC/C,SAAO,SAAS,MAAA,SAAe,aAAa;;CAG9C,QAAuB;AACrB,SAAO,MAAA,QAAc,OAAO;;CAG9B,eAAgC;AAC9B,SAAO,UAAU,MAAA,SAAe,OAAM,UAAS;GAC7C,IAAI,YAAY,MAAM,MAAM,IAAI,eAAe;AAC/C,OAAI,cAAc,KAAA,GAAW;IAE3B,MAAM,oBAAoB,iBAAiB,eAAe;AAC1D,QAAI,kBACF,aAAY,kBAAkB,QAAA,YAAuB,IAAI,KAAA;AAG3D,QAAI,cAAc,KAAA,EAEhB,aAAY,IAAI,cAAc;AAGhC,UAAM,MAAM,IAAI,gBAAgB,UAAU;AAC1C,QAAI,kBACF,mBAAkB,QAAQ,gBAAgB,UAAU;;AAGxD,gBAAa,UAAU;AACvB,UAAO;IACP;;;AAIN,eAAe,aAAa,MAA8C;CACxE,IAAI,WAAW,MAAM,KAAK,IAAI,QAAQ;AACtC,KAAI,CAAC,SACH,YAAW,WAAW,EAAE,CAAC;AAE3B,+BAA8B,SAAS;AACvC,QAAO"}

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

@@ -1 +0,0 @@
-{"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,cAAc;CAC3B,MAAM,MAAM,cAAc;AAE1B,SADkB,QAAQ,MAAO,KACjB,SAAS,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,QAAQ,IAAI"}

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

@@ -1,122 +0,0 @@
-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 { 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) {
-	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;
-}
-//#endregion
-export { persistDD31 };
-
-//# sourceMappingURL=persist.js.map

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

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

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

@@ -1 +0,0 @@
-{"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/replicache/src/process-scheduler.js.map

@@ -1 +0,0 @@
-{"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,SAAS;CAC/B,mBAAmB,QAAQ,SAAS;;;;;;;;;;;;;;CAepC,YACE,SACA,eACA,YACA,aACA,gBAAc,aACd;AACA,QAAA,UAAgB;AAChB,QAAA,gBAAsB;AACtB,QAAA,aAAmB;AACnB,QAAA,cAAoB;AACpB,QAAA,cAAoB;AACpB,QAAA,YAAkB,iBAChB,eACM;GACJ,MAAM,aAAa,IAAI,WAAW,UAAU;AAC5C,SAAA,aAAmB,OAAO,WAAW;AACrC,SAAA,mBAAyB,OAAO,WAAW;AAC3C,SAAA,cAAoB,KAAA;AACpB,SAAA,oBAA0B,KAAA;KAE5B,EAAC,MAAM,MAAK,CACb;;;;;;;;;;;CAYH,WAA0B;AACxB,MAAI,MAAA,YAAkB,QACpB,QAAO,QAAQ,OAAO,IAAI,WAAW,UAAU,CAAC;AAElD,MAAI,MAAA,kBACF,QAAO,MAAA,kBAAwB;AAEjC,QAAA,oBAA0B,UAAU;AAC/B,QAAA,kBAAwB;AAC7B,SAAO,MAAA,kBAAwB;;;;;;;;;;;;;;;CAgBjC,MAAM,MAAqB;AACzB,MAAI,MAAA,YAAkB,QACpB,QAAO,QAAQ,OAAO,IAAI,WAAW,UAAU,CAAC;EAMlD,MAAM,oBAAoB,MAAA;AAC1B,QAAA,oBAA0B,KAAA;EAI1B,MAAM,iBAAiB,MAAA;EAEvB,MAAM,UAAU,YAAY;AAC1B,OAAI;AACF,UAAM;WACA;AAIR,OAAI,MAAA,YAAkB,QACpB,OAAM,IAAI,WAAW,UAAU;AAGjC,UAAO,MAAA,SAAe;;EAGxB,MAAM,mBAAmB,SAAS;AAClC,QAAA,aAAmB;AAGnB,QAAA,kBAAwB,SAAS,MAAA,YAAkB,MAAA,YAAkB;AAErE,MAAI;AACF,SAAM;AACN,sBAAmB,SAAS;WACrB,GAAG;AACV,sBAAmB,OAAO,EAAE;AAC5B,SAAM;;;CAIV,OAAA,mBAAyC;AACvC,MAAI;AACF,SAAM,MAAA;UAIA;AACR,QAAM,MAAA;AACN,MAAI,CAAC,MAAA,kBACH;AAEF,QAAM,MAAA,YAAkB,MAAA,cAAoB;AAC5C,MAAI,CAAC,MAAA,kBACH;AAEF,QAAA,kBAAwB,SAAS,MAAA,YAAkB,MAAA,YAAkB;AACrE,QAAA,cAAoB,MAAA;AACpB,QAAA,oBAA0B,KAAA;AAC1B,MAAI;AACF,SAAA,aAAmB,MAAA,SAAe;AAClC,SAAM,MAAA;AACN,SAAA,aAAmB,SAAS;WACrB,GAAG;AACV,SAAA,aAAmB,OAAO,EAAE;;AAE9B,QAAA,cAAoB,KAAA;;;AAIxB,eAAe,SACb,QACA,aACe;AACf,KAAI;AACF,QAAM,MAAM,QAAQ,YAAY;UACzB,GAAG;AACV,SACE,aAAa,YACb,4CACD"}

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

@@ -1 +0,0 @@
-{"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;AACxE,cAAa,EAAE;AACf,uBAAsB,EAAE,gBAAgB;AACxC,KAAI,EAAE,aAAa,KAAA,EACjB,oBAAmB,EAAE,SAAS;;AAIlC,SAAS,mBAAmB,GAAuC;AACjE,KAAI,8BAA8B,EAAE,CAClC;AAEF,mCAAkC,EAAE;;;;;AAsBtC,IAAa,YAAb,cAA+B,MAAM;CACnC,OAAO;CAKP;CACA,YAAY,UAAkB;AAC5B,QAAM,iBAAiB;AACvB,OAAK,WAAW"}