@rocicorp/zero 0.2.2024101101 → 0.3.2024102500

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

@@ -0,0 +1,38 @@
+import { initBgIntervalProcess } from '../bg-interval.js';
+import { withWrite } from '../with-transactions.js';
+import { getClients, setClients } from './clients.js';
+/**
+ * The maximum time a client can be inactive before it is garbage collected.
+ * This means that this is the maximum time a tab can be in the background
+ * (frozen) and still be able to sync when it comes back to the foreground.
+ */
+export const CLIENT_MAX_INACTIVE_TIME = 24 * 60 * 60 * 1000; // 24 hours
+/**
+ * How frequently to try to garbage collect clients.
+ */
+export const GC_INTERVAL = 5 * 60 * 1000; // 5 minutes
+let latestGCUpdate;
+export function getLatestGCUpdate() {
+    return latestGCUpdate;
+}
+export function initClientGC(clientID, dagStore, clientMaxInactiveTime, gcInterval, lc, signal) {
+    initBgIntervalProcess('ClientGC', () => {
+        latestGCUpdate = gcClients(clientID, dagStore, clientMaxInactiveTime);
+        return latestGCUpdate;
+    }, () => gcInterval, lc, signal);
+}
+function gcClients(clientID, dagStore, clientMaxInactiveTime) {
+    return withWrite(dagStore, async (dagWrite) => {
+        const now = Date.now();
+        const clients = await getClients(dagWrite);
+        const clientsAfterGC = Array.from(clients).filter(([id, client]) => id === clientID /* never collect ourself */ ||
+            now - client.heartbeatTimestampMs <= clientMaxInactiveTime);
+        if (clientsAfterGC.length === clients.size) {
+            return clients;
+        }
+        const newClients = new Map(clientsAfterGC);
+        await setClients(newClients, dagWrite);
+        return newClients;
+    });
+}
+//# sourceMappingURL=client-gc.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client-gc.js","sourceRoot":"","sources":["../../../../../replicache/src/persist/client-gc.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,qBAAqB,EAAC,MAAM,mBAAmB,CAAC;AAGxD,OAAO,EAAC,SAAS,EAAC,MAAM,yBAAyB,CAAC;AAClD,OAAO,EAAiB,UAAU,EAAE,UAAU,EAAC,MAAM,cAAc,CAAC;AAEpE;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,WAAW;AAExE;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,YAAY;AAEtD,IAAI,cAA8C,CAAC;AACnD,MAAM,UAAU,iBAAiB;IAC/B,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,YAAY,CAC1B,QAAkB,EAClB,QAAe,EACf,qBAA6B,EAC7B,UAAkB,EAClB,EAAc,EACd,MAAmB;IAEnB,qBAAqB,CACnB,UAAU,EACV,GAAG,EAAE;QACH,cAAc,GAAG,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,qBAAqB,CAAC,CAAC;QACtE,OAAO,cAAc,CAAC;IACxB,CAAC,EACD,GAAG,EAAE,CAAC,UAAU,EAChB,EAAE,EACF,MAAM,CACP,CAAC;AACJ,CAAC;AAED,SAAS,SAAS,CAChB,QAAkB,EAClB,QAAe,EACf,qBAA6B;IAE7B,OAAO,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAC,QAAQ,EAAC,EAAE;QAC1C,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,OAAO,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,CAAC;QAC3C,MAAM,cAAc,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAC/C,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,CACf,EAAE,KAAK,QAAQ,CAAC,2BAA2B;YAC3C,GAAG,GAAG,MAAM,CAAC,oBAAoB,IAAI,qBAAqB,CAC7D,CAAC;QACF,IAAI,cAAc,CAAC,MAAM,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC;YAC3C,OAAO,OAAO,CAAC;QACjB,CAAC;QACD,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC;QAC3C,MAAM,UAAU,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QACvC,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC,CAAC;AACL,CAAC"}

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

@@ -0,0 +1,38 @@
+import { initBgIntervalProcess } from '../bg-interval.js';
+import { withWrite } from '../with-transactions.js';
+import { clientGroupHasPendingMutations, getClientGroups, setClientGroups, } from './client-groups.js';
+import { assertClientV6, getClients } from './clients.js';
+const GC_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+let latestGCUpdate;
+export function getLatestGCUpdate() {
+    return latestGCUpdate;
+}
+export function initClientGroupGC(dagStore, lc, signal) {
+    initBgIntervalProcess('ClientGroupGC', () => {
+        latestGCUpdate = gcClientGroups(dagStore);
+        return latestGCUpdate;
+    }, () => GC_INTERVAL_MS, lc, signal);
+}
+/**
+ * This removes client groups that have no clients and no pending mutations.
+ */
+export function gcClientGroups(dagStore) {
+    return withWrite(dagStore, async (tx) => {
+        const clients = await getClients(tx);
+        const clientGroupIDs = new Set();
+        for (const client of clients.values()) {
+            assertClientV6(client);
+            clientGroupIDs.add(client.clientGroupID);
+        }
+        const clientGroups = new Map();
+        for (const [clientGroupID, clientGroup] of await getClientGroups(tx)) {
+            if (clientGroupIDs.has(clientGroupID) ||
+                clientGroupHasPendingMutations(clientGroup)) {
+                clientGroups.set(clientGroupID, clientGroup);
+            }
+        }
+        await setClientGroups(clientGroups, tx);
+        return clientGroups;
+    });
+}
+//# sourceMappingURL=client-group-gc.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client-group-gc.js","sourceRoot":"","sources":["../../../../../replicache/src/persist/client-group-gc.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,qBAAqB,EAAC,MAAM,mBAAmB,CAAC;AAExD,OAAO,EAAC,SAAS,EAAC,MAAM,yBAAyB,CAAC;AAClD,OAAO,EAEL,8BAA8B,EAC9B,eAAe,EACf,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAC,cAAc,EAAE,UAAU,EAAC,MAAM,cAAc,CAAC;AAExD,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,YAAY;AAElD,IAAI,cAAmD,CAAC;AACxD,MAAM,UAAU,iBAAiB;IAC/B,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,iBAAiB,CAC/B,QAAe,EACf,EAAc,EACd,MAAmB;IAEnB,qBAAqB,CACnB,eAAe,EACf,GAAG,EAAE;QACH,cAAc,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;QAC1C,OAAO,cAAc,CAAC;IACxB,CAAC,EACD,GAAG,EAAE,CAAC,cAAc,EACpB,EAAE,EACF,MAAM,CACP,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,QAAe;IAC5C,OAAO,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAC,EAAE,EAAC,EAAE;QACpC,MAAM,OAAO,GAAG,MAAM,UAAU,CAAC,EAAE,CAAC,CAAC;QACrC,MAAM,cAAc,GAAG,IAAI,GAAG,EAAE,CAAC;QACjC,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;YACtC,cAAc,CAAC,MAAM,CAAC,CAAC;YACvB,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAC3C,CAAC;QACD,MAAM,YAAY,GAAG,IAAI,GAAG,EAAE,CAAC;QAC/B,KAAK,MAAM,CAAC,aAAa,EAAE,WAAW,CAAC,IAAI,MAAM,eAAe,CAAC,EAAE,CAAC,EAAE,CAAC;YACrE,IACE,cAAc,CAAC,GAAG,CAAC,aAAa,CAAC;gBACjC,8BAA8B,CAAC,WAAW,CAAC,EAC3C,CAAC;gBACD,YAAY,CAAC,GAAG,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC;QACD,MAAM,eAAe,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;QACxC,OAAO,YAAY,CAAC;IACtB,CAAC,CAAC,CAAC;AACL,CAAC"}

package/out/replicache/src/persist/client-groups.js

@@ -0,0 +1,180 @@
+import { assert, assertObject } from '../../../shared/src/asserts.js';
+import * as valita from '../../../shared/src/valita.js';
+import { toRefs } from '../dag/chunk.js';
+import { deepFreeze } from '../frozen-json.js';
+import { hashSchema } from '../hash.js';
+import { indexDefinitionsEqual, indexDefinitionsSchema } from '../index-defs.js';
+const clientGroupSchema = valita.readonlyObject({
+    /**
+     * The hash of the commit in the perdag last persisted to this client group.
+     * Should only be updated by clients assigned to this client group.
+     */
+    headHash: hashSchema,
+    /**
+     * Set of mutator names common to all clients assigned to this client group.
+     */
+    mutatorNames: valita.readonlyArray(valita.string()),
+    /**
+     * Index definitions common to all clients assigned to this client group.
+     */
+    indexes: indexDefinitionsSchema,
+    /**
+     * The highest mutation ID of every client assigned to this client group.
+     * Should only be updated by clients assigned to this client group. Read by
+     * other clients to determine if there are unacknowledged pending mutations
+     * for them to try to recover. This is redundant with information in the
+     * commit graph at `headHash`, but allows other clients to determine if there
+     * are unacknowledged pending mutations without having to load the commit
+     * graph.
+     */
+    mutationIDs: valita.readonlyRecord(valita.number()),
+    /**
+     * The highest lastMutationID received from the server for every client
+     * assigned to this client group.
+     *
+     * Should be updated by the clients assigned to this client group whenever
+     * they persist to this client group. Read by other clients to determine if
+     * there are unacknowledged pending mutations for them to recover and
+     * *updated* by other clients upon successfully recovering pending mutations
+     * to avoid redundant pushes of pending mutations.
+     *
+     * Note: This will be the same as the `lastMutationIDs` of the base snapshot
+     * of the client group's commit graph when written by clients assigned to this
+     * client group.  However, when written by another client recovering mutations
+     * it may be different because the other client does not update the commit
+     * graph.
+     */
+    lastServerAckdMutationIDs: valita.record(valita.number()),
+    /**
+     * If the server deletes this client group it can signal that the client group
+     * was deleted. If that happens we mark this client group as disabled so that
+     * we do not use it again when creating new clients.
+     */
+    disabled: valita.boolean(),
+});
+export const CLIENT_GROUPS_HEAD_NAME = 'client-groups';
+function assertClientGroup(value) {
+    valita.assert(value, clientGroupSchema);
+}
+function chunkDataToClientGroupMap(chunkData) {
+    assertObject(chunkData);
+    const clientGroups = new Map();
+    for (const [key, value] of Object.entries(chunkData)) {
+        if (value !== undefined) {
+            assertClientGroup(value);
+            clientGroups.set(key, value);
+        }
+    }
+    return clientGroups;
+}
+function clientGroupMapToChunkData(clientGroups, dagWrite) {
+    const chunkData = {};
+    for (const [clientGroupID, clientGroup] of clientGroups.entries()) {
+        dagWrite.assertValidHash(clientGroup.headHash);
+        chunkData[clientGroupID] = {
+            ...clientGroup,
+            mutatorNames: [...clientGroup.mutatorNames.values()],
+        };
+    }
+    return deepFreeze(chunkData);
+}
+async function getClientGroupsAtHash(hash, dagRead) {
+    const chunk = await dagRead.getChunk(hash);
+    return chunkDataToClientGroupMap(chunk?.data);
+}
+export async function getClientGroups(dagRead) {
+    const hash = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
+    if (!hash) {
+        return new Map();
+    }
+    return getClientGroupsAtHash(hash, dagRead);
+}
+export async function setClientGroups(clientGroups, dagWrite) {
+    const currClientGroups = await getClientGroups(dagWrite);
+    for (const [clientGroupID, clientGroup] of clientGroups) {
+        const currClientGroup = currClientGroups.get(clientGroupID);
+        validateClientGroupUpdate(clientGroup, currClientGroup);
+    }
+    return setValidatedClientGroups(clientGroups, dagWrite);
+}
+export async function setClientGroup(clientGroupID, clientGroup, dagWrite) {
+    const currClientGroups = await getClientGroups(dagWrite);
+    const currClientGroup = currClientGroups.get(clientGroupID);
+    validateClientGroupUpdate(clientGroup, currClientGroup);
+    const newClientGroups = new Map(currClientGroups);
+    newClientGroups.set(clientGroupID, clientGroup);
+    return setValidatedClientGroups(newClientGroups, dagWrite);
+}
+export async function deleteClientGroup(clientGroupID, dagWrite) {
+    const currClientGroups = await getClientGroups(dagWrite);
+    if (!currClientGroups.has(clientGroupID)) {
+        return currClientGroups;
+    }
+    const newClientGroups = new Map(currClientGroups.entries());
+    newClientGroups.delete(clientGroupID);
+    return setValidatedClientGroups(newClientGroups, dagWrite);
+}
+function validateClientGroupUpdate(clientGroup, currClientGroup) {
+    const mutatorNamesSet = new Set(clientGroup.mutatorNames);
+    assert(mutatorNamesSet.size === clientGroup.mutatorNames.length, "A client group's mutatorNames must be a set.");
+    if (currClientGroup !== undefined) {
+        assert(indexDefinitionsEqual(currClientGroup.indexes, clientGroup.indexes), "A client group's index definitions must never change.");
+        assert(mutatorNamesEqual(mutatorNamesSet, currClientGroup.mutatorNames), "A client group's mutatorNames must never change.");
+    }
+}
+async function setValidatedClientGroups(clientGroups, dagWrite) {
+    const chunkData = clientGroupMapToChunkData(clientGroups, dagWrite);
+    const refs = new Set();
+    for (const clientGroup of clientGroups.values()) {
+        refs.add(clientGroup.headHash);
+    }
+    const chunk = dagWrite.createChunk(chunkData, toRefs(refs));
+    await dagWrite.putChunk(chunk);
+    await dagWrite.setHead(CLIENT_GROUPS_HEAD_NAME, chunk.hash);
+    return clientGroups;
+}
+export function mutatorNamesEqual(mutatorNamesSet, mutatorNames) {
+    if (mutatorNames.length !== mutatorNamesSet.size) {
+        return false;
+    }
+    for (const mutatorName of mutatorNames) {
+        if (!mutatorNamesSet.has(mutatorName)) {
+            return false;
+        }
+    }
+    return true;
+}
+export async function getClientGroup(id, dagRead) {
+    const clientGroups = await getClientGroups(dagRead);
+    return clientGroups.get(id);
+}
+export function clientGroupHasPendingMutations(clientGroup) {
+    for (const [clientID, mutationID] of Object.entries(clientGroup.mutationIDs)) {
+        const lastServerAckdMutationID = clientGroup.lastServerAckdMutationIDs[clientID];
+        if ((lastServerAckdMutationID === undefined && mutationID !== 0) ||
+            lastServerAckdMutationID < mutationID) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Marks a client group as disabled. This can happen if the server deletes the
+ * client group (servers should not delete clients or client groups but it often
+ * happens in practice when developing).
+ *
+ * A disabled client group prevents pulls and pushes from happening.
+ */
+export async function disableClientGroup(clientGroupID, dagWrite) {
+    const clientGroup = await getClientGroup(clientGroupID, dagWrite);
+    if (!clientGroup) {
+        // No client group matching in the database, so nothing to do.
+        return;
+    }
+    const disabledClientGroup = {
+        ...clientGroup,
+        disabled: true,
+    };
+    await setClientGroup(clientGroupID, disabledClientGroup, dagWrite);
+}
+//# sourceMappingURL=client-groups.js.map

package/out/replicache/src/persist/client-groups.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-groups.js","sourceRoot":"","sources":["../../../../../replicache/src/persist/client-groups.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,390 @@
+import { assert, assertObject } from '../../../shared/src/asserts.js';
+import { hasOwn } from '../../../shared/src/has-own.js';
+import * as valita from '../../../shared/src/valita.js';
+import { emptyDataNode } from '../btree/node.js';
+import { BTreeRead } from '../btree/read.js';
+import { compareCookies } from '../cookies.js';
+import { toRefs } from '../dag/chunk.js';
+import { Commit, assertSnapshotCommitDD31, baseSnapshotFromHash, chunkIndexDefinitionEqualIgnoreName, getRefs, newSnapshotCommitDataDD31, toChunkIndexDefinition, } from '../db/commit.js';
+import { createIndexBTree } from '../db/write.js';
+import { deepFreeze } from '../frozen-json.js';
+import { hashSchema } from '../hash.js';
+import { indexDefinitionsEqual } from '../index-defs.js';
+import { clientGroupIDSchema, } from '../sync/ids.js';
+import { withWriteNoImplicitCommit } from '../with-transactions.js';
+import { getClientGroup, getClientGroups, mutatorNamesEqual, setClientGroup, } from './client-groups.js';
+import { makeClientID } from './make-client-id.js';
+const clientV4Schema = valita.readonlyObject({
+    /**
+     * A UNIX timestamp in milliseconds updated by the client once a minute
+     * while it is active and every time the client persists its state to
+     * the perdag.
+     * Should only be updated by the client represented by this structure.
+     */
+    heartbeatTimestampMs: valita.number(),
+    /**
+     * The hash of the commit in the perdag this client last persisted.
+     * Should only be updated by the client represented by this structure.
+     */
+    headHash: hashSchema,
+    /**
+     * The mutationID of the commit at headHash (mutationID if it is a
+     * local commit, lastMutationID if it is an index change or snapshot commit).
+     * Should only be updated by the client represented by this structure.
+     * Read by other clients to determine if there are unacknowledged pending
+     * mutations for them to push on behalf of the client represented by this
+     * structure.
+     * This is redundant with information in the commit graph at headHash,
+     * but allows other clients to determine if there are unacknowledged pending
+     * mutations without having to load the commit graph at headHash.
+     */
+    mutationID: valita.number(),
+    /**
+     * The highest lastMutationID received from the server for this client.
+     *
+     * Should be updated by the client represented by this structure whenever
+     * it persists its state to the perdag.
+     * Read by other clients to determine if there are unacknowledged pending
+     * mutations for them to push on behalf of the client represented by this
+     * structure, and *updated* by other clients upon successfully pushing
+     * pending mutations to avoid redundant pushes of those mutations.
+     *
+     * Note: This will be the same as the lastMutationID of the base snapshot of
+     * the commit graph at headHash when written by the client represented by this
+     * structure.  However, when written by another client pushing pending
+     * mutations on this client's behalf it will be different.  This is because
+     * the other client does not update the commit graph (it is unsafe to update
+     * another client's commit graph).
+     */
+    lastServerAckdMutationID: valita.number(),
+});
+const clientV5Schema = valita.readonlyObject({
+    heartbeatTimestampMs: valita.number(),
+    headHash: hashSchema,
+    /**
+     * The hash of a commit we are in the middle of refreshing into this client's
+     * memdag.
+     */
+    tempRefreshHash: hashSchema.nullable(),
+    /**
+     * ID of this client's perdag client group. This needs to be sent in pull
+     * request (to enable syncing all last mutation ids in the client group).
+     */
+    clientGroupID: clientGroupIDSchema,
+});
+const clientV6Schema = valita.readonlyObject({
+    heartbeatTimestampMs: valita.number(),
+    /**
+     * A set of hashes, which contains:
+     * 1. The hash of the last commit this client refreshed from its client group
+     *    (this is the commit it bootstrapped from until it completes its first
+     *    refresh).
+     * 2. One or more hashes that were added to retain chunks of a commit while it
+     *    was being refreshed into this client's memdag. (This can be one or more
+     *    because refresh's cleanup step is a separate transaction and can fail).
+     * Upon refresh completing and successfully running its clean up step, this
+     * set will contain a single hash: the hash of the last commit this client
+     * refreshed.
+     */
+    refreshHashes: valita.readonlyArray(hashSchema),
+    /**
+     * The hash of the last snapshot commit persisted by this client to this
+     * client's client group, or null if has never persisted a snapshot.
+     */
+    persistHash: hashSchema.nullable(),
+    /**
+     * ID of this client's perdag client group. This needs to be sent in pull
+     * request (to enable syncing all last mutation ids in the client group).
+     */
+    clientGroupID: clientGroupIDSchema,
+});
+function isClientV6(client) {
+    return client.refreshHashes !== undefined;
+}
+function isClientV5(client) {
+    return client.clientGroupID !== undefined;
+}
+export function isClientV4(client) {
+    return client.lastServerAckdMutationID !== undefined;
+}
+export const CLIENTS_HEAD_NAME = 'clients';
+const clientSchema = valita.union(clientV4Schema, clientV5Schema, clientV6Schema);
+function assertClient(value) {
+    valita.assert(value, clientSchema);
+}
+export function assertClientV4(value) {
+    valita.assert(value, clientV4Schema);
+}
+export function assertClientV5(value) {
+    valita.assert(value, clientV5Schema);
+}
+export function assertClientV6(value) {
+    valita.assert(value, clientV6Schema);
+}
+function chunkDataToClientMap(chunkData) {
+    assertObject(chunkData);
+    const clients = new Map();
+    for (const key in chunkData) {
+        if (hasOwn(chunkData, key)) {
+            const value = chunkData[key];
+            if (value !== undefined) {
+                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 (isClientV5(client) && client.tempRefreshHash) {
+                dagWrite.assertValidHash(client.tempRefreshHash);
+            }
+        }
+    }
+    return deepFreeze(Object.fromEntries(clients));
+}
+export async function getClients(dagRead) {
+    const hash = await dagRead.getHead(CLIENTS_HEAD_NAME);
+    return getClientsAtHash(hash, dagRead);
+}
+async function getClientsAtHash(hash, dagRead) {
+    if (!hash) {
+        return new Map();
+    }
+    const chunk = await dagRead.getChunk(hash);
+    return chunkDataToClientMap(chunk?.data);
+}
+/**
+ * Used to signal that a client does not exist. Maybe it was garbage collected?
+ */
+export class ClientStateNotFoundError 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.
+ */
+export async function assertHasClientState(id, dagRead) {
+    if (!(await hasClientState(id, dagRead))) {
+        throw new ClientStateNotFoundError(id);
+    }
+}
+export async function hasClientState(id, dagRead) {
+    return !!(await getClient(id, dagRead));
+}
+export async function getClient(id, dagRead) {
+    const clients = await getClients(dagRead);
+    return clients.get(id);
+}
+export async function mustGetClient(id, dagRead) {
+    const client = await getClient(id, dagRead);
+    if (!client) {
+        throw new ClientStateNotFoundError(id);
+    }
+    return client;
+}
+export function initClientV6(newClientID, lc, perdag, mutatorNames, indexes, formatVersion, enableClientGroupForking) {
+    return withWriteNoImplicitCommit(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),
+            ]);
+            await dagWrite.commit();
+            return [newClient, chunk.hash, newClients, true];
+        }
+        const clients = await getClients(dagWrite);
+        const res = await findMatchingClient(dagWrite, mutatorNames, indexes);
+        if (res.type === FIND_MATCHING_CLIENT_TYPE_HEAD) {
+            // We found a client group with matching mutators and indexes. We can
+            // reuse it.
+            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);
+            await dagWrite.commit();
+            return [newClient, headHash, newClients, false];
+        }
+        if (!enableClientGroupForking ||
+            res.type === FIND_MATCHING_CLIENT_TYPE_NEW) {
+            // No client group to fork from. Create empty snapshot.
+            const emptyBTreeChunk = dagWrite.createChunk(emptyDataNode, []);
+            await dagWrite.putChunk(emptyBTreeChunk);
+            // Create indexes
+            const indexRecords = [];
+            // At this point the value of replicache is the empty tree so all index
+            // maps will also be the empty tree.
+            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);
+        }
+        // Now we create a new client and client group that we fork from the found
+        // snapshot.
+        assert(res.type === FIND_MATCHING_CLIENT_TYPE_FORK);
+        const { snapshot } = res;
+        // Create indexes
+        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));
+}
+export const FIND_MATCHING_CLIENT_TYPE_NEW = 0;
+export const FIND_MATCHING_CLIENT_TYPE_FORK = 1;
+export const FIND_MATCHING_CLIENT_TYPE_HEAD = 2;
+export 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)) {
+            // exact match
+            return {
+                type: FIND_MATCHING_CLIENT_TYPE_HEAD,
+                clientGroupID,
+                headHash: clientGroup.headHash,
+            };
+        }
+        const clientGroupSnapshotCommit = await baseSnapshotFromHash(clientGroup.headHash, dagRead);
+        assertSnapshotCommitDD31(clientGroupSnapshotCommit);
+        const { cookieJSON } = clientGroupSnapshotCommit.meta;
+        if (newestCookie === undefined ||
+            compareCookies(cookieJSON, newestCookie) > 0) {
+            newestCookie = cookieJSON;
+            bestSnapshot = clientGroupSnapshotCommit;
+        }
+    }
+    if (bestSnapshot) {
+        return {
+            type: FIND_MATCHING_CLIENT_TYPE_FORK,
+            snapshot: bestSnapshot,
+        };
+    }
+    return { type: FIND_MATCHING_CLIENT_TYPE_NEW };
+}
+function getRefsForClients(clients) {
+    const refs = 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 (isClientV5(client) && client.tempRefreshHash) {
+                refs.add(client.tempRefreshHash);
+            }
+        }
+    }
+    return toRefs(refs);
+}
+export async function getClientGroupForClient(clientID, read) {
+    const clientGroupID = await getClientGroupIDForClient(clientID, read);
+    if (!clientGroupID) {
+        return undefined;
+    }
+    return getClientGroup(clientGroupID, read);
+}
+export async function getClientGroupIDForClient(clientID, read) {
+    const client = await getClient(clientID, read);
+    if (!client || !isClientV5(client)) {
+        return undefined;
+    }
+    return client.clientGroupID;
+}
+/**
+ * Adds a Client to the ClientMap and updates the 'clients' head to point at
+ * the updated clients.
+ */
+export async function setClient(clientID, client, dagWrite) {
+    const clients = await getClients(dagWrite);
+    const newClients = new Map(clients).set(clientID, client);
+    return setClients(newClients, dagWrite);
+}
+/**
+ * Sets the ClientMap and updates the 'clients' head top point at the new
+ * clients.
+ */
+export 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;
+}
+//# sourceMappingURL=clients.js.map