@rocicorp/zero 0.10.2025010800 → 0.10.2025011400

package/out/{chunk-PPRTDNXA.js → chunk-TS7IMB6J.js}

@@ -7,19 +7,53 @@ import {
   assertArray,
   assertBoolean,
   assertNotNull,
-  assertNotUndefined,
   assertNumber,
   assertObject,
   assertString,
   must,
   throwInvalidType,
   unreachable
-} from "./chunk-Y6OVFUGE.js";
+} from "./chunk-I5GSZARI.js";
 import {
   __export,
   __reExport
 } from "./chunk-F5QR3K72.js";
 
+// ../replicache/src/call-default-fetch.ts
+async function callDefaultFetch(url, auth, requestID, requestBody) {
+  const init = {
+    headers: {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      "Content-type": "application/json",
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      "Authorization": auth,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      "X-Replicache-RequestID": requestID
+    },
+    body: JSON.stringify(requestBody),
+    method: "POST"
+  };
+  const request = new Request(url, init);
+  const response = await fetch(request);
+  const httpStatusCode = response.status;
+  if (httpStatusCode !== 200) {
+    return [
+      void 0,
+      {
+        httpStatusCode,
+        errorMessage: await response.text()
+      }
+    ];
+  }
+  return [
+    response,
+    {
+      httpStatusCode,
+      errorMessage: ""
+    }
+  ];
+}
+
 // ../shared/src/config.ts
 var isProd = process.env.NODE_ENV === "production";
 
@@ -163,41 +197,6 @@ function isJSONArray(v2, path2) {
   return true;
 }
 
-// ../replicache/src/call-default-fetch.ts
-async function callDefaultFetch(url, auth, requestID, requestBody) {
-  const init = {
-    headers: {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      "Content-type": "application/json",
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      "Authorization": auth,
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      "X-Replicache-RequestID": requestID
-    },
-    body: JSON.stringify(requestBody),
-    method: "POST"
-  };
-  const request = new Request(url, init);
-  const response = await fetch(request);
-  const httpStatusCode = response.status;
-  if (httpStatusCode !== 200) {
-    return [
-      void 0,
-      {
-        httpStatusCode,
-        errorMessage: await response.text()
-      }
-    ];
-  }
-  return [
-    response,
-    {
-      httpStatusCode,
-      errorMessage: ""
-    }
-  ];
-}
-
 // ../shared/src/string-compare.ts
 function stringCompare(a, b) {
   if (a === b) {
@@ -341,18 +340,6 @@ var defaultPullers = /* @__PURE__ */ new WeakSet();
 function isDefaultPuller(puller) {
   return defaultPullers.has(puller);
 }
-function assertPullResponseV0(v2) {
-  assertObject(v2);
-  if (isClientStateNotFoundResponse(v2) || isVersionNotSupportedResponse(v2)) {
-    return;
-  }
-  const v22 = v2;
-  if (v22.cookie !== void 0) {
-    assertJSONValue(v22.cookie);
-  }
-  assertNumber(v22.lastMutationID);
-  assertPatchOperations(v22.patch);
-}
 function assertPullResponseV1(v2) {
   assertObject(v2);
   if (isClientStateNotFoundResponse(v2) || isVersionNotSupportedResponse(v2)) {
@@ -379,13 +366,6 @@ function assertPullerResultV1(v2) {
     assertPullResponseV1(v2.response);
   }
 }
-function assertPullerResultV0(v2) {
-  assertObject(v2);
-  assertHTTPRequestInfo(v2.httpRequestInfo);
-  if (v2.response !== void 0) {
-    assertPullResponseV0(v2.response);
-  }
-}
 
 // ../replicache/src/kv/idb-store.ts
 import { resolver } from "@rocicorp/resolver";
@@ -746,7 +726,6 @@ function rejectIfClosed(tx) {
 }
 
 // ../replicache/src/format-version-enum.ts
-var SDD = 4;
 var DD31 = 5;
 var V6 = 6;
 var V7 = 7;
@@ -1469,9 +1448,6 @@ function createChunk(data, refs, chunkHasher) {
   const hash2 = chunkHasher();
   return new Chunk(hash2, data, refs);
 }
-function throwChunkHasher() {
-  throw new Error("unexpected call to compute chunk hash");
-}
 
 // ../shared/src/random-uint64.ts
 function randomUint64() {
@@ -2537,31 +2513,19 @@ var WriteImpl3 = class extends ReadImpl3 {
 };
 
 // ../replicache/src/db/meta-type-enum.ts
-var IndexChangeSDD = 1;
-var LocalSDD = 2;
-var SnapshotSDD = 3;
 var LocalDD31 = 4;
 var SnapshotDD31 = 5;
 
 // ../replicache/src/db/commit.ts
 var DEFAULT_HEAD_NAME = "main";
-function commitIsLocalSDD(commit) {
-  return isLocalMetaSDD(commit.meta);
-}
 function commitIsLocalDD31(commit) {
   return isLocalMetaDD31(commit.meta);
 }
 function commitIsLocal(commit) {
-  return commitIsLocalDD31(commit) || commitIsLocalSDD(commit);
-}
-function commitIsSnapshotDD31(commit) {
-  return isSnapshotMetaDD31(commit.meta);
-}
-function commitIsSnapshotSDD(commit) {
-  return isSnapshotMetaSDD(commit.meta);
+  return commitIsLocalDD31(commit);
 }
 function commitIsSnapshot(commit) {
-  return commitIsSnapshotDD31(commit) || commitIsSnapshotSDD(commit);
+  return isSnapshotMetaDD31(commit.meta);
 }
 var Commit = class {
   chunk;
@@ -2586,14 +2550,8 @@ var Commit = class {
 };
 async function getMutationID(clientID, dagRead, meta) {
   switch (meta.type) {
-    case IndexChangeSDD:
-      return meta.lastMutationID;
-    case SnapshotSDD:
-      return meta.lastMutationID;
     case SnapshotDD31:
       return meta.lastMutationIDs[clientID] ?? 0;
-    case LocalSDD:
-      return meta.mutationID;
     case LocalDD31: {
       if (meta.clientID === clientID) {
         return meta.mutationID;
@@ -2666,11 +2624,8 @@ async function baseSnapshotFromCommit(commit, dagRead) {
 }
 function snapshotMetaParts(c, clientID) {
   const m = c.meta;
-  if (isSnapshotMetaDD31(m)) {
-    const lmid = m.lastMutationIDs[clientID] ?? 0;
-    return [lmid, m.cookieJSON];
-  }
-  return [m.lastMutationID, m.cookieJSON];
+  const lmid = m.lastMutationIDs[clientID] ?? 0;
+  return [lmid, m.cookieJSON];
 }
 function compareCookiesForSnapshots(a, b) {
   return compareCookies(a.meta.cookieJSON, b.meta.cookieJSON);
@@ -2698,10 +2653,8 @@ async function commitFromHead(name, dagRead) {
   const hash2 = await mustGetHeadHash(name, dagRead);
   return commitFromHash(hash2, dagRead);
 }
-function assertIndexChangeMeta(v2) {
-  assertNumber(v2.lastMutationID);
-}
-function assertLocalMetaSDD(v2) {
+function assertLocalMetaDD31(v2) {
+  assertString(v2.clientID);
   assertNumber(v2.mutationID);
   assertString(v2.mutatorName);
   if (!v2.mutatorName) {
@@ -2713,28 +2666,14 @@ function assertLocalMetaSDD(v2) {
   }
   assertNumber(v2.timestamp);
 }
-function assertLocalMetaDD31(v2) {
-  assertString(v2.clientID);
-  assertLocalMetaSDD(v2);
-}
 function isLocalMetaDD31(meta) {
   return meta.type === LocalDD31;
 }
-function isLocalMetaSDD(meta) {
-  return meta.type === LocalSDD;
-}
-function assertSnapshotMetaBase(v2) {
+function assertSnapshotMetaDD31(v2) {
   if (v2.basisHash !== null) {
     assertHash(v2.basisHash);
   }
   assertJSONValue(v2.cookieJSON);
-}
-function assertSnapshotMetaSDD(v2) {
-  assertSnapshotMetaBase(v2);
-  assertNumber(v2.lastMutationID);
-}
-function assertSnapshotMetaDD31(v2) {
-  assertSnapshotMetaBase(v2);
   assertLastMutationIDs(v2.lastMutationIDs);
 }
 function assertLastMutationIDs(v2) {
@@ -2749,9 +2688,6 @@ function assertSnapshotCommitDD31(c) {
 function isSnapshotMetaDD31(meta) {
   return meta.type === SnapshotDD31;
 }
-function isSnapshotMetaSDD(meta) {
-  return meta.type === SnapshotSDD;
-}
 function assertMeta(v2) {
   assertObject(v2);
   assertDeepFrozen(v2);
@@ -2760,18 +2696,9 @@ function assertMeta(v2) {
   }
   assertNumber(v2.type);
   switch (v2.type) {
-    case IndexChangeSDD:
-      assertIndexChangeMeta(v2);
-      break;
-    case LocalSDD:
-      assertLocalMetaSDD(v2);
-      break;
     case LocalDD31:
       assertLocalMetaDD31(v2);
       break;
-    case SnapshotSDD:
-      assertSnapshotMetaSDD(v2);
-      break;
     case SnapshotDD31:
       assertSnapshotMetaDD31(v2);
       break;
@@ -2813,21 +2740,6 @@ function assertIndexRecords(v2) {
     assertIndexRecord(ir);
   }
 }
-function newLocalSDD(createChunk2, basisHash, mutationID, mutatorName, mutatorArgsJSON, originalHash, valueHash, indexes, timestamp) {
-  const meta = {
-    type: LocalSDD,
-    basisHash,
-    mutationID,
-    mutatorName,
-    mutatorArgsJSON,
-    originalHash,
-    timestamp
-  };
-  return commitFromCommitData(
-    createChunk2,
-    makeCommitData(meta, valueHash, indexes)
-  );
-}
 function newLocalDD31(createChunk2, basisHash, baseSnapshotHash, mutationID, mutatorName, mutatorArgsJSON, originalHash, valueHash, indexes, timestamp, clientID) {
   const meta = {
     type: LocalDD31,
@@ -2845,18 +2757,6 @@ function newLocalDD31(createChunk2, basisHash, baseSnapshotHash, mutationID, mut
     makeCommitData(meta, valueHash, indexes)
   );
 }
-function newSnapshotSDD(createChunk2, basisHash, lastMutationID, cookieJSON, valueHash, indexes) {
-  return commitFromCommitData(
-    createChunk2,
-    newSnapshotCommitDataSDD(
-      basisHash,
-      lastMutationID,
-      cookieJSON,
-      valueHash,
-      indexes
-    )
-  );
-}
 function newSnapshotDD31(createChunk2, basisHash, lastMutationIDs, cookieJSON, valueHash, indexes) {
   return commitFromCommitData(
     createChunk2,
@@ -2869,15 +2769,6 @@ function newSnapshotDD31(createChunk2, basisHash, lastMutationIDs, cookieJSON, v
     )
   );
 }
-function newSnapshotCommitDataSDD(basisHash, lastMutationID, cookieJSON, valueHash, indexes) {
-  const meta = {
-    type: SnapshotSDD,
-    basisHash,
-    lastMutationID,
-    cookieJSON
-  };
-  return makeCommitData(meta, valueHash, indexes);
-}
 function newSnapshotCommitDataDD31(basisHash, lastMutationIDs, cookieJSON, valueHash, indexes) {
   const meta = {
     type: SnapshotDD31,
@@ -2887,17 +2778,6 @@ function newSnapshotCommitDataDD31(basisHash, lastMutationIDs, cookieJSON, value
   };
   return makeCommitData(meta, valueHash, indexes);
 }
-function newIndexChange(createChunk2, basisHash, lastMutationID, valueHash, indexes) {
-  const meta = {
-    type: IndexChangeSDD,
-    basisHash,
-    lastMutationID
-  };
-  return commitFromCommitData(
-    createChunk2,
-    makeCommitData(meta, valueHash, indexes)
-  );
-}
 function fromChunk(chunk) {
   validateChunk(chunk);
   return new Commit(chunk);
@@ -2910,14 +2790,9 @@ function getRefs(data) {
   refs.add(data.valueHash);
   const { meta } = data;
   switch (meta.type) {
-    case IndexChangeSDD:
-      meta.basisHash && refs.add(meta.basisHash);
-      break;
-    case LocalSDD:
     case LocalDD31:
       meta.basisHash && refs.add(meta.basisHash);
       break;
-    case SnapshotSDD:
     case SnapshotDD31:
       break;
     default:
@@ -4452,9 +4327,6 @@ var Write = class extends Read {
    * comparison as well as returned in `get`.
    */
   async put(lc, key, value) {
-    if (this.#meta.type === IndexChangeSDD) {
-      throw new Error("Not allowed");
-    }
     const oldVal = lazy(() => this.map.get(key));
     await updateIndexes(lc, this.indexes, key, oldVal, value);
     await this.map.put(key, value);
@@ -4463,9 +4335,6 @@ var Write = class extends Read {
     return getMutationID(this.#clientID, this.#dagWrite, this.#meta);
   }
   async del(lc, key) {
-    if (this.#meta.type === IndexChangeSDD) {
-      throw new Error("Not allowed");
-    }
     const oldVal = lazy(() => this.map.get(key));
     if (oldVal !== void 0) {
       await updateIndexes(lc, this.indexes, key, oldVal, void 0);
@@ -4473,9 +4342,6 @@ var Write = class extends Read {
     return this.map.del(key);
   }
   async clear() {
-    if (this.#meta.type === IndexChangeSDD) {
-      throw new Error("Not allowed");
-    }
     await this.map.clear();
     const ps = [];
     for (const idx of this.indexes.values()) {
@@ -4497,28 +4363,6 @@ var Write = class extends Read {
     let commit;
     const meta = this.#meta;
     switch (meta.type) {
-      case LocalSDD: {
-        const {
-          basisHash,
-          mutationID,
-          mutatorName,
-          mutatorArgsJSON,
-          originalHash,
-          timestamp
-        } = meta;
-        commit = newLocalSDD(
-          this.#dagWrite.createChunk,
-          basisHash,
-          mutationID,
-          mutatorName,
-          mutatorArgsJSON,
-          originalHash,
-          valueHash,
-          indexRecords,
-          timestamp
-        );
-        break;
-      }
       case LocalDD31: {
         assert(this.#formatVersion >= DD31);
         const {
@@ -4544,19 +4388,6 @@ var Write = class extends Read {
         );
         break;
       }
-      case SnapshotSDD: {
-        assert(this.#formatVersion <= SDD);
-        const { basisHash, lastMutationID, cookieJSON } = meta;
-        commit = newSnapshotSDD(
-          this.#dagWrite.createChunk,
-          basisHash,
-          lastMutationID,
-          cookieJSON,
-          valueHash,
-          indexRecords
-        );
-        break;
-      }
       case SnapshotDD31: {
         assert(this.#formatVersion > DD31);
         const { basisHash, lastMutationIDs, cookieJSON } = meta;
@@ -4570,28 +4401,6 @@ var Write = class extends Read {
         );
         break;
       }
-      case IndexChangeSDD: {
-        const { basisHash, lastMutationID } = meta;
-        if (this.#basis !== void 0) {
-          if (await this.#basis.getMutationID(
-            this.#clientID,
-            this.#dagWrite
-          ) !== lastMutationID) {
-            throw new Error("Index change must not change mutationID");
-          }
-          if (this.#basis.valueHash !== valueHash) {
-            throw new Error("Index change must not change valueHash");
-          }
-        }
-        commit = newIndexChange(
-          this.#dagWrite.createChunk,
-          basisHash,
-          lastMutationID,
-          valueHash,
-          indexRecords
-        );
-        break;
-      }
     }
     await this.#dagWrite.putChunk(commit.chunk);
     return commit;
@@ -4666,11 +4475,12 @@ async function newWriteLocal(basisHash, mutatorName, mutatorArgsJSON, originalHa
   const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);
   const mutationID = await basis.getNextMutationID(clientID, dagWrite);
   const indexes = readIndexesForWrite(basis, dagWrite, formatVersion);
+  assert(formatVersion >= DD31);
   return new Write(
     dagWrite,
     bTreeWrite,
     basis,
-    formatVersion >= DD31 ? {
+    {
       type: LocalDD31,
       basisHash,
       baseSnapshotHash: await baseSnapshotHashFromHash(basisHash, dagWrite),
@@ -4680,34 +4490,12 @@ async function newWriteLocal(basisHash, mutatorName, mutatorArgsJSON, originalHa
       originalHash,
       timestamp,
       clientID
-    } : {
-      type: LocalSDD,
-      basisHash,
-      mutatorName,
-      mutatorArgsJSON,
-      mutationID,
-      originalHash,
-      timestamp
     },
     indexes,
     clientID,
     formatVersion
   );
 }
-async function newWriteSnapshotSDD(basisHash, lastMutationID, cookieJSON, dagWrite, indexes, clientID, formatVersion) {
-  assert(formatVersion <= SDD);
-  const basis = await commitFromHash(basisHash, dagWrite);
-  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);
-  return new Write(
-    dagWrite,
-    bTreeWrite,
-    basis,
-    { basisHash, type: SnapshotSDD, lastMutationID, cookieJSON },
-    indexes,
-    clientID,
-    formatVersion
-  );
-}
 async function newWriteSnapshotDD31(basisHash, lastMutationIDs, cookieJSON, dagWrite, clientID, formatVersion) {
   const basis = await commitFromHash(basisHash, dagWrite);
   const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);
@@ -4910,14 +4698,6 @@ function createLogContext(logLevel = "info", logSinks = [consoleLogSink], contex
   return new LogContext(logLevel, context, logSink);
 }
 
-// ../replicache/src/format-version.ts
-function parseReplicacheFormatVersion(v2) {
-  if (v2 !== (v2 | 0) || v2 < SDD || v2 > Latest) {
-    throw new Error(`Unsupported format version: ${v2}`);
-  }
-  return v2;
-}
-
 // ../replicache/src/index-defs.ts
 var indexDefinitionSchema = readonlyObject({
   prefix: valita_exports.string().optional(),
@@ -5111,9 +4891,13 @@ async function disableClientGroup(clientGroupID, dagWrite) {
   await setClientGroup(clientGroupID, disabledClientGroup, dagWrite);
 }
 
-// ../replicache/src/sync/ids.ts
-var clientGroupIDSchema = valita_exports.string();
-var clientIDSchema = valita_exports.string();
+// ../replicache/src/to-error.ts
+function toError(e) {
+  if (e instanceof Error) {
+    return e;
+  }
+  return new Error(String(e));
+}
 
 // ../replicache/src/with-transactions.ts
 function withRead(store, fn) {
@@ -5138,404 +4922,10 @@ async function using(x, fn) {
   }
 }
 
-// ../replicache/src/persist/make-client-id.ts
-function makeClientID() {
-  const length = 18;
-  const high = randomUint64();
-  const low = randomUint64();
-  const combined = high << 64n | low;
-  return combined.toString(32).slice(-length).padStart(length, "0");
-}
-
-// ../replicache/src/persist/clients.ts
-var clientV4Schema = 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_exports.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_exports.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_exports.number()
-});
-var clientV5Schema = readonlyObject({
-  heartbeatTimestampMs: valita_exports.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
-});
-var clientV6Schema = readonlyObject({
-  heartbeatTimestampMs: valita_exports.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: 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 !== void 0;
-}
-function isClientV5(client) {
-  return client.clientGroupID !== void 0;
-}
-var CLIENTS_HEAD_NAME = "clients";
-var clientSchema = valita_exports.union(
-  clientV4Schema,
-  clientV5Schema,
-  clientV6Schema
-);
-function assertClient(value) {
-  assert2(value, clientSchema);
-}
-function assertClientV4(value) {
-  assert2(value, clientV4Schema);
-}
-function assertClientV6(value) {
-  assert2(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 (isClientV5(client) && client.tempRefreshHash) {
-        dagWrite.assertValidHash(client.tempRefreshHash);
-      }
-    }
-  }
-  return deepFreeze(Object.fromEntries(clients));
-}
-async function getClients(dagRead) {
-  const hash2 = await dagRead.getHead(CLIENTS_HEAD_NAME);
-  return getClientsAtHash(hash2, dagRead);
-}
-async function getClientsAtHash(hash2, dagRead) {
-  if (!hash2) {
-    return /* @__PURE__ */ new Map();
-  }
-  const chunk = await dagRead.getChunk(hash2);
-  return chunkDataToClientMap(chunk?.data);
-}
-var ClientStateNotFoundError = class extends Error {
-  name = "ClientStateNotFoundError";
-  id;
-  constructor(id) {
-    super(`Client state not found, id: ${id}`);
-    this.id = id;
-  }
-};
-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) {
-  const clients = await getClients(dagRead);
-  return clients.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 withWriteNoImplicitCommit(perdag, async (dagWrite) => {
-    async function setClientsAndClientGroupAndCommit(basisHash, cookieJSON, valueHash2, indexRecords2) {
-      const newSnapshotData = newSnapshotCommitDataDD31(
-        basisHash,
-        {},
-        cookieJSON,
-        valueHash2,
-        indexRecords2
-      );
-      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) {
-      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) {
-      const emptyBTreeChunk = dagWrite.createChunk(emptyDataNode, []);
-      await dagWrite.putChunk(emptyBTreeChunk);
-      const indexRecords2 = [];
-      for (const [name, indexDefinition] of Object.entries(indexes)) {
-        const chunkIndexDefinition = toChunkIndexDefinition(
-          name,
-          indexDefinition
-        );
-        indexRecords2.push({
-          definition: chunkIndexDefinition,
-          valueHash: emptyBTreeChunk.hash
-        });
-      }
-      return setClientsAndClientGroupAndCommit(
-        null,
-        null,
-        emptyBTreeChunk.hash,
-        indexRecords2
-      );
-    }
-    assert(res.type === FIND_MATCHING_CLIENT_TYPE_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)
-  );
-}
-var FIND_MATCHING_CLIENT_TYPE_NEW = 0;
-var FIND_MATCHING_CLIENT_TYPE_FORK = 1;
-var FIND_MATCHING_CLIENT_TYPE_HEAD = 2;
-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: FIND_MATCHING_CLIENT_TYPE_HEAD,
-        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: FIND_MATCHING_CLIENT_TYPE_FORK,
-      snapshot: bestSnapshot
-    };
-  }
-  return { type: FIND_MATCHING_CLIENT_TYPE_NEW };
-}
-function getRefsForClients(clients) {
-  const refs = /* @__PURE__ */ new Set();
-  for (const client of clients.values()) {
-    if (isClientV6(client)) {
-      for (const hash2 of client.refreshHashes) {
-        refs.add(hash2);
-      }
-      if (client.persistHash) {
-        refs.add(client.persistHash);
-      }
-    } else {
-      refs.add(client.headHash);
-      if (isClientV5(client) && client.tempRefreshHash) {
-        refs.add(client.tempRefreshHash);
-      }
-    }
-  }
-  return toRefs(refs);
-}
-async function getClientGroupForClient(clientID, read) {
-  const clientGroupID = await getClientGroupIDForClient(clientID, read);
-  if (!clientGroupID) {
-    return void 0;
-  }
-  return getClientGroup(clientGroupID, read);
-}
-async function getClientGroupIDForClient(clientID, read) {
-  const client = await getClient(clientID, read);
-  if (!client || !isClientV5(client)) {
-    return void 0;
-  }
-  return client.clientGroupID;
-}
-async function setClient(clientID, client, dagWrite) {
-  const clients = await getClients(dagWrite);
-  const newClients = new Map(clients).set(clientID, client);
-  return setClients(newClients, dagWrite);
-}
-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;
-}
-
-// ../replicache/src/to-error.ts
-function toError(e) {
-  if (e instanceof Error) {
-    return e;
-  }
-  return new Error(String(e));
-}
-
-// ../replicache/src/sync/handle-pull-response-result-type-enum.ts
-var Applied = 0;
-var NoOp = 1;
-var CookieMismatch = 2;
+// ../replicache/src/sync/handle-pull-response-result-type-enum.ts
+var Applied = 0;
+var NoOp = 1;
+var CookieMismatch = 2;
 
 // ../replicache/src/sync/patch.ts
 async function apply(lc, dbWrite, patch) {
@@ -5593,67 +4983,7 @@ var PullError = class extends Error {
 var SYNC_HEAD_NAME = "sync";
 
 // ../replicache/src/sync/pull.ts
-var PULL_VERSION_SDD = 0;
 var PULL_VERSION_DD31 = 1;
-function isPullRequestV1(pr) {
-  return pr.pullVersion === PULL_VERSION_DD31;
-}
-async function beginPullV0(profileID, clientID, schemaVersion, puller, requestID, store, formatVersion, lc, createSyncBranch = true) {
-  const [lastMutationID, baseCookie] = await withRead(store, async (dagRead) => {
-    const mainHeadHash = await dagRead.getHead(DEFAULT_HEAD_NAME);
-    if (!mainHeadHash) {
-      throw new Error("Internal no main head found");
-    }
-    const baseSnapshot = await baseSnapshotFromHash(mainHeadHash, dagRead);
-    const baseSnapshotMeta = baseSnapshot.meta;
-    const baseCookie2 = baseSnapshotMeta.cookieJSON;
-    const lastMutationID2 = await baseSnapshot.getMutationID(clientID, dagRead);
-    return [lastMutationID2, baseCookie2];
-  });
-  const pullReq = {
-    profileID,
-    clientID,
-    cookie: baseCookie,
-    lastMutationID,
-    pullVersion: PULL_VERSION_SDD,
-    schemaVersion
-  };
-  const { response, httpRequestInfo } = await callPuller(
-    lc,
-    puller,
-    pullReq,
-    requestID
-  );
-  if (!response) {
-    return {
-      httpRequestInfo,
-      syncHead: emptyHash
-    };
-  }
-  if (!createSyncBranch || isErrorResponse(response)) {
-    return {
-      httpRequestInfo,
-      pullResponse: response,
-      syncHead: emptyHash
-    };
-  }
-  const result = await handlePullResponseV0(
-    lc,
-    store,
-    baseCookie,
-    response,
-    clientID,
-    formatVersion
-  );
-  if (result.type === CookieMismatch) {
-    throw new Error("Overlapping sync");
-  }
-  return {
-    httpRequestInfo,
-    pullResponse: response,
-    syncHead: result.type === Applied ? result.syncHead : emptyHash
-  };
-}
 async function beginPullV1(profileID, clientID, clientGroupID, schemaVersion, puller, requestID, store, formatVersion, lc, createSyncBranch = true) {
   const baseCookie = await withRead(store, async (dagRead) => {
     const mainHeadHash = await dagRead.getHead(DEFAULT_HEAD_NAME);
@@ -5720,104 +5050,12 @@ async function callPuller(lc, puller, pullReq, requestID) {
     throw new PullError(toError(e));
   }
   try {
-    if (isPullRequestV1(pullReq)) {
-      assertPullerResultV1(pullerResult);
-    } else {
-      assertPullerResultV0(pullerResult);
-    }
+    assertPullerResultV1(pullerResult);
     return pullerResult;
   } catch (e) {
     throw new ReportError("Invalid puller result", toError(e));
   }
 }
-function handlePullResponseV0(lc, store, expectedBaseCookie, response, clientID, formatVersion) {
-  return withWriteNoImplicitCommit(store, async (dagWrite) => {
-    assert(formatVersion <= SDD);
-    const dagRead = dagWrite;
-    const mainHead = await dagRead.getHead(DEFAULT_HEAD_NAME);
-    if (mainHead === void 0) {
-      throw new Error("Main head disappeared");
-    }
-    const baseSnapshot = await baseSnapshotFromHash(mainHead, dagRead);
-    const [baseLastMutationID, baseCookie] = snapshotMetaParts(
-      baseSnapshot,
-      clientID
-    );
-    if (!deepEqual(expectedBaseCookie, baseCookie)) {
-      return {
-        type: CookieMismatch
-      };
-    }
-    if (response.lastMutationID < baseLastMutationID) {
-      throw new Error(
-        badOrderMessage(
-          `lastMutationID`,
-          String(response.lastMutationID),
-          String(baseLastMutationID)
-        )
-      );
-    }
-    const frozenCookie = deepFreeze(response.cookie ?? null);
-    if (deepEqual(frozenCookie, baseCookie)) {
-      if (response.patch.length > 0) {
-        lc.error?.(
-          `handlePullResponse: cookie ${JSON.stringify(
-            baseCookie
-          )} did not change, but patch is not empty`
-        );
-      }
-      if (response.lastMutationID !== baseLastMutationID) {
-        lc.error?.(
-          `handlePullResponse: cookie ${JSON.stringify(
-            baseCookie
-          )} did not change, but lastMutationID did change`
-        );
-      }
-      return {
-        type: NoOp
-      };
-    }
-    const chain = await commitChain(mainHead, dagRead);
-    let lastIntegrated;
-    for (const commit of chain) {
-      if (await commit.getMutationID(clientID, dagRead) <= response.lastMutationID) {
-        lastIntegrated = commit;
-        break;
-      }
-    }
-    if (!lastIntegrated) {
-      throw new Error("Internal invalid chain");
-    }
-    const dbWrite = await newWriteSnapshotSDD(
-      baseSnapshot.chunk.hash,
-      response.lastMutationID,
-      frozenCookie,
-      dagWrite,
-      readIndexesForWrite(lastIntegrated, dagWrite, formatVersion),
-      clientID,
-      formatVersion
-    );
-    await apply(lc, dbWrite, response.patch);
-    const lastIntegratedMap = new BTreeRead(
-      dagRead,
-      formatVersion,
-      lastIntegrated.valueHash
-    );
-    for await (const change of dbWrite.map.diff(lastIntegratedMap)) {
-      await updateIndexes(
-        lc,
-        dbWrite.indexes,
-        change.key,
-        () => Promise.resolve(change.oldValue),
-        change.newValue
-      );
-    }
-    return {
-      type: Applied,
-      syncHead: await dbWrite.commit(SYNC_HEAD_NAME)
-    };
-  });
-}
 function badOrderMessage(name, receivedValue, lastSnapshotValue) {
   return `Received ${name} ${receivedValue} is < than last snapshot ${name} ${lastSnapshotValue}; ignoring client view`;
 }
@@ -5934,9 +5172,8 @@ function maybeEndPull(store, lc, expectedSyncHead, clientID, diffConfig, formatV
     const localMutations2 = await localMutations(mainHeadHash, dagRead);
     for (const commit of localMutations2) {
       let cid = clientID;
-      if (commitIsLocalDD31(commit)) {
-        cid = commit.meta.clientID;
-      }
+      assert(commitIsLocalDD31(commit));
+      cid = commit.meta.clientID;
       if (await commit.getMutationID(cid, dagRead) > await syncHead.getMutationID(cid, dagRead)) {
         pending.push(commit);
       }
@@ -6071,15 +5308,12 @@ var PushError = class extends Error {
   }
 };
 
+// ../replicache/src/sync/ids.ts
+var clientGroupIDSchema = valita_exports.string();
+var clientIDSchema = valita_exports.string();
+
 // ../replicache/src/sync/push.ts
-var PUSH_VERSION_SDD = 0;
 var PUSH_VERSION_DD31 = 1;
-var mutationV0Schema = readonlyObject({
-  id: valita_exports.number(),
-  name: valita_exports.string(),
-  args: jsonSchema,
-  timestamp: valita_exports.number()
-});
 var mutationV1Schema = readonlyObject({
   id: valita_exports.number(),
   name: valita_exports.string(),
@@ -6087,13 +5321,6 @@ var mutationV1Schema = readonlyObject({
   timestamp: valita_exports.number(),
   clientID: clientIDSchema
 });
-var pushRequestV0Schema = valita_exports.object({
-  pushVersion: valita_exports.literal(0),
-  schemaVersion: valita_exports.string(),
-  profileID: valita_exports.string(),
-  clientID: clientIDSchema,
-  mutations: valita_exports.array(mutationV0Schema)
-});
 var pushRequestV1Schema = valita_exports.object({
   pushVersion: valita_exports.literal(1),
   schemaVersion: valita_exports.string(),
@@ -6101,14 +5328,6 @@ var pushRequestV1Schema = valita_exports.object({
   clientGroupID: clientGroupIDSchema,
   mutations: valita_exports.array(mutationV1Schema)
 });
-function convertSDD(lm) {
-  return {
-    id: lm.mutationID,
-    name: lm.mutatorName,
-    args: lm.mutatorArgsJSON,
-    timestamp: lm.timestamp
-  };
-}
 function convertDD31(lm) {
   return {
     id: lm.mutationID,
@@ -6118,7 +5337,7 @@ function convertDD31(lm) {
     clientID: lm.clientID
   };
 }
-async function push(requestID, store, lc, profileID, clientGroupID, clientID, pusher, schemaVersion, pushVersion) {
+async function push(requestID, store, lc, profileID, clientGroupID, _clientID, pusher, schemaVersion, pushVersion) {
   const pending = await withRead(store, async (dagRead) => {
     const mainHeadHash = await dagRead.getHead(DEFAULT_HEAD_NAME);
     if (!mainHeadHash) {
@@ -6130,43 +5349,23 @@ async function push(requestID, store, lc, profileID, clientGroupID, clientID, pu
     return void 0;
   }
   pending.reverse();
-  let pushReq;
-  if (pushVersion === PUSH_VERSION_DD31) {
-    const pushMutations = [];
-    for (const commit of pending) {
-      if (commitIsLocalDD31(commit)) {
-        pushMutations.push(convertDD31(commit.meta));
-      } else {
-        throw new Error("Internal non local pending commit");
-      }
-    }
-    assert(clientGroupID);
-    const r = {
-      profileID,
-      clientGroupID,
-      mutations: pushMutations,
-      pushVersion: PUSH_VERSION_DD31,
-      schemaVersion
-    };
-    pushReq = r;
-  } else {
-    assert(pushVersion === PUSH_VERSION_SDD);
-    const pushMutations = [];
-    for (const commit of pending) {
-      if (commitIsLocalSDD(commit)) {
-        pushMutations.push(convertSDD(commit.meta));
-      } else {
-        throw new Error("Internal non local pending commit");
-      }
+  assert(pushVersion === PUSH_VERSION_DD31);
+  const pushMutations = [];
+  for (const commit of pending) {
+    if (commitIsLocalDD31(commit)) {
+      pushMutations.push(convertDD31(commit.meta));
+    } else {
+      throw new Error("Internal non local pending commit");
     }
-    pushReq = {
-      profileID,
-      clientID,
-      mutations: pushMutations,
-      pushVersion: PUSH_VERSION_SDD,
-      schemaVersion
-    };
   }
+  assert(clientGroupID);
+  const pushReq = {
+    profileID,
+    clientGroupID,
+    mutations: pushMutations,
+    pushVersion: PUSH_VERSION_DD31,
+    schemaVersion
+  };
   lc.debug?.("Starting push...");
   const pushStart = Date.now();
   const pusherResult = await callPusher(pusher, pushReq, requestID);
@@ -6190,711 +5389,532 @@ async function callPusher(pusher, body, requestID) {
 
 // ../replicache/src/mutation-recovery.ts
 var MUTATION_RECOVERY_LAZY_STORE_SOURCE_CHUNK_CACHE_SIZE_LIMIT = 10 * 2 ** 20;
-var MutationRecovery = class {
-  #recoveringMutations = false;
-  #options;
-  constructor(options) {
-    this.#options = options;
+
+// ../replicache/src/broadcast-channel.ts
+var NoopBroadcastChannel = class {
+  name;
+  onmessage = null;
+  onmessageerror = null;
+  constructor(name) {
+    this.name = name;
   }
-  async recoverMutations(preReadClientMap, ready, perdag, idbDatabase, idbDatabases, createStore) {
-    const { lc, enableMutationRecovery, isPushDisabled, delegate } = this.#options;
-    if (!enableMutationRecovery || this.#recoveringMutations || !delegate.online || delegate.closed || isPushDisabled()) {
-      return false;
-    }
-    const stepDescription = "Recovering mutations.";
-    lc.debug?.("Start:", stepDescription);
-    try {
-      this.#recoveringMutations = true;
-      await ready;
-      await recoverMutationsFromPerdag(
-        idbDatabase,
-        this.#options,
-        perdag,
-        preReadClientMap
-      );
-      for (const database of Object.values(await idbDatabases.getDatabases())) {
-        if (delegate.closed) {
-          lc.debug?.("Exiting early due to close:", stepDescription);
-          return true;
-        }
-        if (database.replicacheName === delegate.name && database.name !== delegate.idbName) {
-          switch (database.replicacheFormatVersion) {
-            case SDD:
-            case DD31:
-            case V6:
-            case V7:
-              await recoverMutationsWithNewPerdag(
-                database,
-                this.#options,
-                void 0,
-                createStore
-              );
+  addEventListener() {
+  }
+  removeEventListener() {
+  }
+  dispatchEvent() {
+    return false;
+  }
+  close() {
+  }
+  postMessage() {
+  }
+};
+var bc = typeof BroadcastChannel === "undefined" ? NoopBroadcastChannel : BroadcastChannel;
+
+// ../replicache/src/new-client-channel.ts
+function makeChannelNameV0(replicacheName) {
+  return `replicache-new-client-group:${replicacheName}`;
+}
+function makeChannelNameV1(replicacheName) {
+  return `replicache-new-client-group-v1:${replicacheName}`;
+}
+function isNewClientChannelMessageV1(message) {
+  return typeof message === "object" && typeof message.clientGroupID === "string" && typeof message.idbName === "string";
+}
+function initNewClientChannel(replicacheName, idbName, signal, clientGroupID, isNewClientGroup, onUpdateNeeded, perdag) {
+  if (signal.aborted) {
+    return;
+  }
+  const channelV1 = new bc(makeChannelNameV1(replicacheName));
+  if (isNewClientGroup) {
+    channelV1.postMessage({ clientGroupID, idbName });
+    const channelV0 = new bc(makeChannelNameV0(replicacheName));
+    channelV0.postMessage([clientGroupID]);
+    channelV0.close();
+  }
+  channelV1.onmessage = async (e) => {
+    const { data } = e;
+    if (isNewClientChannelMessageV1(data)) {
+      const { clientGroupID: newClientGroupID, idbName: newClientIDBName } = data;
+      if (newClientGroupID !== clientGroupID) {
+        if (newClientIDBName === idbName) {
+          const updateNeeded = await withRead(
+            perdag,
+            async (perdagRead) => await getClientGroup(newClientGroupID, perdagRead) !== void 0
+          );
+          if (updateNeeded) {
+            onUpdateNeeded();
           }
+        } else {
+          onUpdateNeeded();
+          return;
         }
       }
-    } catch (e) {
-      logMutationRecoveryError(e, lc, stepDescription, delegate);
-    } finally {
-      lc.debug?.("End:", stepDescription);
-      this.#recoveringMutations = false;
     }
-    return true;
-  }
-};
-function logMutationRecoveryError(e, lc, stepDescription, closedDelegate) {
-  if (closedDelegate.closed) {
-    lc.debug?.(
-      `Mutation recovery error likely due to close during:
-${stepDescription}
-Error:
-`,
-      e
-    );
-  } else {
-    lc.error?.(
-      `Mutation recovery error during:
-${stepDescription}
-Error:
-`,
-      e
-    );
-  }
+  };
+  signal.addEventListener("abort", () => channelV1.close(), { once: true });
 }
-async function recoverMutationsOfClientV4(client, clientID, perdag, database, options, formatVersion) {
-  assert(database.replicacheFormatVersion === SDD);
-  assertClientV4(client);
-  const {
-    delegate,
-    lc,
-    wrapInOnlineCheck,
-    wrapInReauthRetries,
-    isPushDisabled,
-    isPullDisabled
-  } = options;
-  const selfClientID = delegate.clientID;
-  if (selfClientID === clientID) {
-    return;
-  }
-  if (client.lastServerAckdMutationID >= client.mutationID) {
-    return;
+
+// ../replicache/src/on-persist-channel.ts
+function makeChannelName(replicacheName) {
+  return `replicache-on-persist:${replicacheName}`;
+}
+function assertPersistInfo(value) {
+  assertObject(value);
+  assertString(value.clientGroupID);
+  assertString(value.clientID);
+}
+function initOnPersistChannel(replicacheName, signal, handlePersist) {
+  if (signal.aborted) {
+    return () => void 0;
   }
-  const stepDescription = `Recovering mutations for ${clientID}.`;
-  lc.debug?.("Start:", stepDescription);
-  const lazyDagForOtherClient = new LazyStore(
-    perdag,
-    MUTATION_RECOVERY_LAZY_STORE_SOURCE_CHUNK_CACHE_SIZE_LIMIT,
-    throwChunkHasher,
-    assertHash
-  );
-  try {
-    await withWrite(
-      lazyDagForOtherClient,
-      (write) => write.setHead(DEFAULT_HEAD_NAME, client.headHash)
-    );
-    if (isPushDisabled()) {
-      lc.debug?.(
-        `Cannot recover mutations for client ${clientID} because push is disabled.`
-      );
-      return;
-    }
-    const { pusher } = delegate;
-    const pushDescription = "recoveringMutationsPush";
-    const pushSucceeded = await wrapInOnlineCheck(async () => {
-      const { result: pusherResult } = await wrapInReauthRetries(
-        async (requestID, requestLc) => {
-          assertNotUndefined(lazyDagForOtherClient);
-          const pusherResult2 = await push(
-            requestID,
-            lazyDagForOtherClient,
-            requestLc,
-            await delegate.profileID,
-            void 0,
-            clientID,
-            pusher,
-            database.schemaVersion,
-            PUSH_VERSION_SDD
-          );
-          return {
-            result: pusherResult2,
-            httpRequestInfo: pusherResult2?.httpRequestInfo
-          };
-        },
-        pushDescription,
-        lc
-      );
-      return !!pusherResult && pusherResult.httpRequestInfo.httpStatusCode === 200;
-    }, pushDescription);
-    if (!pushSucceeded) {
-      lc.debug?.(
-        `Failed to recover mutations for client ${clientID} due to a push error.`
-      );
-      return;
-    }
-    if (isPullDisabled()) {
-      lc.debug?.(
-        `Cannot confirm mutations were recovered for client ${clientID} because pull is disabled.`
-      );
-      return;
-    }
-    const { puller } = delegate;
-    const pullDescription = "recoveringMutationsPull";
-    let pullResponse;
-    const pullSucceeded = await wrapInOnlineCheck(async () => {
-      const { result: beginPullResponse } = await wrapInReauthRetries(
-        async (requestID, requestLc) => {
-          const beginPullResponse2 = await beginPullV0(
-            await delegate.profileID,
-            clientID,
-            database.schemaVersion,
-            puller,
-            requestID,
-            lazyDagForOtherClient,
-            formatVersion,
-            requestLc,
-            false
-          );
-          return {
-            result: beginPullResponse2,
-            httpRequestInfo: beginPullResponse2.httpRequestInfo
-          };
-        },
-        pullDescription,
-        lc
-      );
-      ({ pullResponse } = beginPullResponse);
-      return !!pullResponse && beginPullResponse.httpRequestInfo.httpStatusCode === 200;
-    }, pullDescription);
-    if (!pullSucceeded) {
-      lc.debug?.(
-        `Failed to recover mutations for client ${clientID} due to a pull error.`
-      );
+  const channel = new bc(makeChannelName(replicacheName));
+  channel.onmessage = (e) => {
+    const { data } = e;
+    assertPersistInfo(data);
+    handlePersist({
+      clientGroupID: data.clientGroupID,
+      clientID: data.clientID
+    });
+  };
+  signal.addEventListener("abort", () => channel.close(), { once: true });
+  return (persistInfo) => {
+    if (signal.aborted) {
       return;
     }
-    if (lc.debug && pullResponse) {
-      if (isClientStateNotFoundResponse(pullResponse)) {
-        lc.debug?.(
-          `Client ${selfClientID} cannot recover mutations for client ${clientID}. The client no longer exists on the server.`
-        );
-      } else if (isVersionNotSupportedResponse(pullResponse)) {
-        lc.debug?.(
-          `Version is not supported on the server. versionType: ${pullResponse.versionType}. Cannot recover mutations for client ${clientID}.`
-        );
-      } else {
-        lc.debug?.(
-          `Client ${selfClientID} recovered mutations for client ${clientID}.  Details`,
-          {
-            mutationID: client.mutationID,
-            lastServerAckdMutationID: client.lastServerAckdMutationID,
-            lastMutationID: pullResponse.lastMutationID
-          }
-        );
+    channel.postMessage(persistInfo);
+    handlePersist(persistInfo);
+  };
+}
+
+// ../replicache/src/pending-mutations.ts
+async function pendingMutationsForAPI(dagRead) {
+  const mainHeadHash = await mustGetHeadHash(DEFAULT_HEAD_NAME, dagRead);
+  const pending = await localMutationsDD31(mainHeadHash, dagRead);
+  return pending.map((p) => ({
+    id: p.meta.mutationID,
+    name: p.meta.mutatorName,
+    args: p.meta.mutatorArgsJSON,
+    clientID: p.meta.clientID
+  })).reverse();
+}
+
+// ../replicache/src/bg-interval.ts
+function initBgIntervalProcess(processName, process2, delayMs, lc, signal) {
+  void runBgIntervalProcess(processName, process2, delayMs, lc, signal);
+}
+async function runBgIntervalProcess(processName, process2, delayMs, lc, signal) {
+  if (signal.aborted) {
+    return;
+  }
+  lc = lc.withContext("bgIntervalProcess", processName);
+  lc.debug?.("Starting");
+  while (!signal.aborted) {
+    try {
+      await sleep(delayMs(), signal);
+    } catch (e) {
+      if (!(e instanceof AbortError)) {
+        throw e;
       }
     }
-    return await withWrite(perdag, async (dagWrite) => {
-      const clients = await getClients(dagWrite);
-      const clientToUpdate = clients.get(clientID);
-      if (!clientToUpdate) {
-        return clients;
+    if (!signal.aborted) {
+      lc.debug?.("Running");
+      try {
+        await process2();
+      } catch (e) {
+        if (signal.aborted) {
+          lc.debug?.("Error running most likely due to close.", e);
+        } else {
+          lc.error?.("Error running.", e);
+        }
       }
-      assertClientV4(clientToUpdate);
-      const setNewClients = async (newClients2) => {
-        await setClients(newClients2, dagWrite);
-        return newClients2;
-      };
-      if (isClientStateNotFoundResponse(pullResponse) || // Even though SDD did not have VersionNotSupported we can still get
-      // this if the server was upgraded to handle this. It seems better to
-      // delete the client at this point.
-      isVersionNotSupportedResponse(pullResponse)) {
-        const newClients2 = new Map(clients);
-        newClients2.delete(clientID);
-        return setNewClients(newClients2);
-      }
-      assert(pullResponse);
-      if (clientToUpdate.lastServerAckdMutationID >= pullResponse.lastMutationID) {
-        return clients;
-      }
-      const newClients = new Map(clients).set(clientID, {
-        ...clientToUpdate,
-        lastServerAckdMutationID: pullResponse.lastMutationID
-      });
-      return setNewClients(newClients);
-    });
-  } catch (e) {
-    logMutationRecoveryError(e, lc, stepDescription, delegate);
-  } finally {
-    await lazyDagForOtherClient.close();
-    lc.debug?.("End:", stepDescription);
+    }
   }
-  return;
+  lc.debug?.("Stopping");
 }
-async function recoverMutationsWithNewPerdag(database, options, preReadClientMap, createStore) {
-  const perKvStore = createStore(database.name);
-  const perdag = new StoreImpl(perKvStore, newRandomHash, assertHash);
-  try {
-    await recoverMutationsFromPerdag(
-      database,
-      options,
-      perdag,
-      preReadClientMap
-    );
-  } finally {
-    await perdag.close();
-  }
+
+// ../replicache/src/persist/make-client-id.ts
+function makeClientID() {
+  const length = 18;
+  const high = randomUint64();
+  const low = randomUint64();
+  const combined = high << 64n | low;
+  return combined.toString(32).slice(-length).padStart(length, "0");
+}
+
+// ../replicache/src/persist/clients.ts
+var clientV4Schema = 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_exports.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_exports.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_exports.number()
+});
+var clientV5Schema = readonlyObject({
+  heartbeatTimestampMs: valita_exports.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
+});
+var clientV6Schema = readonlyObject({
+  heartbeatTimestampMs: valita_exports.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: 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 !== void 0;
+}
+function isClientV5(client) {
+  return client.clientGroupID !== void 0;
+}
+var CLIENTS_HEAD_NAME = "clients";
+var clientSchema = valita_exports.union(
+  clientV4Schema,
+  clientV5Schema,
+  clientV6Schema
+);
+function assertClient(value) {
+  assert2(value, clientSchema);
 }
-function recoverMutationsFromPerdag(database, options, perdag, preReadClientMap) {
-  if (database.replicacheFormatVersion >= DD31) {
-    return recoverMutationsFromPerdagDD31(database, options, perdag);
-  }
-  return recoverMutationsFromPerdagSDD(
-    database,
-    options,
-    perdag,
-    preReadClientMap
-  );
+function assertClientV6(value) {
+  assert2(value, clientV6Schema);
 }
-async function recoverMutationsFromPerdagSDD(database, options, perdag, preReadClientMap) {
-  const { delegate, lc } = options;
-  const stepDescription = `Recovering mutations from db ${database.name}.`;
-  lc.debug?.("Start:", stepDescription);
-  try {
-    const formatVersion = parseReplicacheFormatVersion(database.replicacheFormatVersion);
-    let clientMap = preReadClientMap || await withRead(perdag, (read) => getClients(read));
-    const clientIDsVisited = /* @__PURE__ */ new Set();
-    while (clientMap) {
-      let newClientMap;
-      for (const [clientID, client] of clientMap) {
-        if (delegate.closed) {
-          lc.debug?.("Exiting early due to close:", stepDescription);
-          return;
-        }
-        if (!clientIDsVisited.has(clientID)) {
-          clientIDsVisited.add(clientID);
-          newClientMap = await recoverMutationsOfClientV4(
-            client,
-            clientID,
-            perdag,
-            database,
-            options,
-            formatVersion
-          );
-          if (newClientMap) {
-            break;
-          }
-        }
+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);
       }
-      clientMap = newClientMap;
     }
-  } catch (e) {
-    logMutationRecoveryError(e, lc, stepDescription, delegate);
   }
-  lc.debug?.("End:", stepDescription);
+  return clients;
 }
-async function recoverMutationsFromPerdagDD31(database, options, perdag) {
-  const { delegate, lc } = options;
-  const stepDescription = `Recovering mutations from db ${database.name}.`;
-  lc.debug?.("Start:", stepDescription);
-  try {
-    const formatVersion = parseReplicacheFormatVersion(database.replicacheFormatVersion);
-    let clientGroups = await withRead(
-      perdag,
-      (read) => getClientGroups(read)
-    );
-    const clientGroupIDsVisited = /* @__PURE__ */ new Set();
-    while (clientGroups) {
-      let newClientGroups;
-      for (const [clientGroupID, clientGroup] of clientGroups) {
-        if (delegate.closed) {
-          lc.debug?.("Exiting early due to close:", stepDescription);
-          return;
-        }
-        if (!clientGroupIDsVisited.has(clientGroupID)) {
-          clientGroupIDsVisited.add(clientGroupID);
-          newClientGroups = await recoverMutationsOfClientGroupDD31(
-            clientGroup,
-            clientGroupID,
-            perdag,
-            database,
-            options,
-            formatVersion
-          );
-          if (newClientGroups) {
-            break;
-          }
-        }
+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);
       }
-      clientGroups = newClientGroups;
     }
-  } catch (e) {
-    logMutationRecoveryError(e, lc, stepDescription, delegate);
   }
-  lc.debug?.("End:", stepDescription);
+  return deepFreeze(Object.fromEntries(clients));
 }
-function isResponseThatShouldDisableClientGroup(response) {
-  return isClientStateNotFoundResponse(response) || isVersionNotSupportedResponse(response);
+async function getClients(dagRead) {
+  const hash2 = await dagRead.getHead(CLIENTS_HEAD_NAME);
+  return getClientsAtHash(hash2, dagRead);
 }
-async function disableClientGroup2(lc, selfClientGroupID, clientGroupID, response, perdag) {
-  if (isClientStateNotFoundResponse(response)) {
-    lc.debug?.(
-      `Client group ${selfClientGroupID} cannot recover mutations for client group ${clientGroupID}. The client group is unknown on the server. Marking it as disabled.`
-    );
-  } else if (isVersionNotSupportedResponse(response)) {
-    lc.debug?.(
-      `Client group ${selfClientGroupID} cannot recover mutations for client group ${clientGroupID}. The client group's version is not supported on the server. versionType: ${response.versionType}. Marking it as disabled.`
-    );
+async function getClientsAtHash(hash2, dagRead) {
+  if (!hash2) {
+    return /* @__PURE__ */ new Map();
   }
-  await withWrite(
-    perdag,
-    (perdagWrite) => disableClientGroup(clientGroupID, perdagWrite)
-  );
+  const chunk = await dagRead.getChunk(hash2);
+  return chunkDataToClientMap(chunk?.data);
 }
-async function recoverMutationsOfClientGroupDD31(clientGroup, clientGroupID, perdag, database, options, formatVersion) {
-  assert(database.replicacheFormatVersion >= DD31);
-  const {
-    delegate,
-    lc,
-    wrapInOnlineCheck,
-    wrapInReauthRetries,
-    isPushDisabled,
-    isPullDisabled,
-    clientGroupIDPromise
-  } = options;
-  const selfClientGroupID = await clientGroupIDPromise;
-  assertNotUndefined(selfClientGroupID);
-  if (selfClientGroupID === clientGroupID) {
-    return;
-  }
-  let clientID;
-  let allAckd = true;
-  for (const [cid, mutationID] of Object.entries(clientGroup.mutationIDs)) {
-    if (!clientGroup.lastServerAckdMutationIDs[cid] || clientGroup.lastServerAckdMutationIDs[cid] < mutationID) {
-      clientID = cid;
-      allAckd = false;
-      break;
-    }
+var ClientStateNotFoundError = class extends Error {
+  name = "ClientStateNotFoundError";
+  id;
+  constructor(id) {
+    super(`Client state not found, id: ${id}`);
+    this.id = id;
   }
-  if (allAckd) {
-    return;
+};
+async function assertHasClientState(id, dagRead) {
+  if (!await hasClientState(id, dagRead)) {
+    throw new ClientStateNotFoundError(id);
   }
-  if (clientGroup.disabled) {
-    lc.debug?.(
-      `Not recovering mutations for client group ${clientGroupID} because group is disabled.`
-    );
-    return;
+}
+async function hasClientState(id, dagRead) {
+  return !!await getClient(id, dagRead);
+}
+async function getClient(id, dagRead) {
+  const clients = await getClients(dagRead);
+  return clients.get(id);
+}
+async function mustGetClient(id, dagRead) {
+  const client = await getClient(id, dagRead);
+  if (!client) {
+    throw new ClientStateNotFoundError(id);
   }
-  const stepDescription = `Recovering mutations for client group ${clientGroupID}.`;
-  lc.debug?.("Start:", stepDescription);
-  const lazyDagForOtherClientGroup = new LazyStore(
-    perdag,
-    MUTATION_RECOVERY_LAZY_STORE_SOURCE_CHUNK_CACHE_SIZE_LIMIT,
-    throwChunkHasher,
-    assertHash
-  );
-  try {
-    await withWrite(
-      lazyDagForOtherClientGroup,
-      (write) => write.setHead(DEFAULT_HEAD_NAME, clientGroup.headHash)
-    );
-    if (isPushDisabled()) {
-      lc.debug?.(
-        `Cannot recover mutations for client group ${clientGroupID} because push is disabled.`
+  return client;
+}
+function initClientV6(newClientID, lc, perdag, mutatorNames, indexes, formatVersion, enableClientGroupForking) {
+  return withWriteNoImplicitCommit(perdag, async (dagWrite) => {
+    async function setClientsAndClientGroupAndCommit(basisHash, cookieJSON, valueHash2, indexRecords2) {
+      const newSnapshotData = newSnapshotCommitDataDD31(
+        basisHash,
+        {},
+        cookieJSON,
+        valueHash2,
+        indexRecords2
       );
-      return;
-    }
-    const { pusher } = delegate;
-    const pushDescription = "recoveringMutationsPush";
-    const pushSucceeded = await wrapInOnlineCheck(async () => {
-      const { result: pusherResult } = await wrapInReauthRetries(
-        async (requestID, requestLc) => {
-          assert(clientID);
-          assert(lazyDagForOtherClientGroup);
-          const pusherResult2 = await push(
-            requestID,
-            lazyDagForOtherClientGroup,
-            requestLc,
-            await delegate.profileID,
-            clientGroupID,
-            // TODO(DD31): clientID is not needed in DD31. It is currently kept for debugging purpose.
-            clientID,
-            pusher,
-            database.schemaVersion,
-            PUSH_VERSION_DD31
-          );
-          return {
-            result: pusherResult2,
-            httpRequestInfo: pusherResult2?.httpRequestInfo
-          };
-        },
-        pushDescription,
-        lc
+      const chunk = dagWrite.createChunk(
+        newSnapshotData,
+        getRefs(newSnapshotData)
       );
-      if (!pusherResult) {
-        return false;
-      }
-      const pusherResponse = pusherResult.response;
-      if (isResponseThatShouldDisableClientGroup(pusherResponse)) {
-        await disableClientGroup2(
-          lc,
-          selfClientGroupID,
-          clientGroupID,
-          pusherResponse,
-          perdag
+      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) {
+      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) {
+      const emptyBTreeChunk = dagWrite.createChunk(emptyDataNode, []);
+      await dagWrite.putChunk(emptyBTreeChunk);
+      const indexRecords2 = [];
+      for (const [name, indexDefinition] of Object.entries(indexes)) {
+        const chunkIndexDefinition = toChunkIndexDefinition(
+          name,
+          indexDefinition
         );
-        return false;
+        indexRecords2.push({
+          definition: chunkIndexDefinition,
+          valueHash: emptyBTreeChunk.hash
+        });
       }
-      return pusherResult.httpRequestInfo.httpStatusCode === 200;
-    }, pushDescription);
-    if (!pushSucceeded) {
-      lc.debug?.(
-        `Failed to recover mutations for client ${clientGroupID} due to a push error.`
-      );
-      return;
-    }
-    if (isPullDisabled()) {
-      lc.debug?.(
-        `Cannot confirm mutations were recovered for client ${clientGroupID} because pull is disabled.`
+      return setClientsAndClientGroupAndCommit(
+        null,
+        null,
+        emptyBTreeChunk.hash,
+        indexRecords2
       );
-      return;
     }
-    const { puller } = delegate;
-    const pullDescription = "recoveringMutationsPull";
-    let okPullResponse;
-    const pullSucceeded = await wrapInOnlineCheck(async () => {
-      const { result: beginPullResponse } = await wrapInReauthRetries(
-        async (requestID, requestLc) => {
-          assert(clientID);
-          const beginPullResponse2 = await beginPullV1(
-            await delegate.profileID,
-            clientID,
-            clientGroupID,
-            database.schemaVersion,
-            puller,
-            requestID,
-            lazyDagForOtherClientGroup,
-            formatVersion,
-            requestLc,
-            false
-          );
-          return {
-            result: beginPullResponse2,
-            httpRequestInfo: beginPullResponse2.httpRequestInfo
-          };
-        },
-        pullDescription,
-        lc
-      );
-      const { pullResponse } = beginPullResponse;
-      if (isResponseThatShouldDisableClientGroup(pullResponse)) {
-        await disableClientGroup2(
+    assert(res.type === FIND_MATCHING_CLIENT_TYPE_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,
-          selfClientGroupID,
-          clientGroupID,
-          pullResponse,
-          perdag
+          dagWrite,
+          map,
+          prefix,
+          jsonPointer,
+          allowEmpty,
+          formatVersion
         );
-        return false;
-      }
-      if (!pullResponse || beginPullResponse.httpRequestInfo.httpStatusCode !== 200) {
-        return false;
+        indexRecords.push({
+          definition: chunkIndexDefinition,
+          valueHash: await indexBTree.flush()
+        });
       }
-      okPullResponse = pullResponse;
-      return true;
-    }, pullDescription);
-    if (!pullSucceeded) {
-      lc.debug?.(
-        `Failed to recover mutations for client ${clientGroupID} due to a pull error.`
-      );
-      return;
     }
-    assert(okPullResponse);
-    lc.debug?.(
-      `Client group ${selfClientGroupID} recovered mutations for client group ${clientGroupID}.  Details`,
-      {
-        mutationIDs: clientGroup.mutationIDs,
-        lastServerAckdMutationIDs: clientGroup.lastServerAckdMutationIDs,
-        lastMutationIDChanges: okPullResponse.lastMutationIDChanges
-      }
+    return setClientsAndClientGroupAndCommit(
+      snapshot.meta.basisHash,
+      snapshot.meta.cookieJSON,
+      snapshot.valueHash,
+      indexRecords
+    );
+  });
+}
+function findMatchingOldIndex(oldIndexes, chunkIndexDefinition) {
+  return oldIndexes.find(
+    (index) => chunkIndexDefinitionEqualIgnoreName(index.definition, chunkIndexDefinition)
+  );
+}
+var FIND_MATCHING_CLIENT_TYPE_NEW = 0;
+var FIND_MATCHING_CLIENT_TYPE_FORK = 1;
+var FIND_MATCHING_CLIENT_TYPE_HEAD = 2;
+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: FIND_MATCHING_CLIENT_TYPE_HEAD,
+        clientGroupID,
+        headHash: clientGroup.headHash
+      };
+    }
+    const clientGroupSnapshotCommit = await baseSnapshotFromHash(
+      clientGroup.headHash,
+      dagRead
     );
-    return await withWrite(perdag, async (dagWrite) => {
-      const clientGroups = await getClientGroups(dagWrite);
-      const clientGroupToUpdate = clientGroups.get(clientGroupID);
-      if (!clientGroupToUpdate) {
-        return clientGroups;
-      }
-      assert(okPullResponse);
-      const lastServerAckdMutationIDsUpdates = {};
-      let anyMutationIDsUpdated = false;
-      for (const [clientID2, lastMutationIDChange] of Object.entries(
-        okPullResponse.lastMutationIDChanges
-      )) {
-        if ((clientGroupToUpdate.lastServerAckdMutationIDs[clientID2] ?? 0) < lastMutationIDChange) {
-          lastServerAckdMutationIDsUpdates[clientID2] = lastMutationIDChange;
-          anyMutationIDsUpdated = true;
-        }
-      }
-      if (!anyMutationIDsUpdated) {
-        return clientGroups;
-      }
-      const newClientGroups = new Map(clientGroups).set(clientGroupID, {
-        ...clientGroupToUpdate,
-        lastServerAckdMutationIDs: {
-          ...clientGroupToUpdate.lastServerAckdMutationIDs,
-          ...lastServerAckdMutationIDsUpdates
-        }
-      });
-      await setClientGroups(newClientGroups, dagWrite);
-      return newClientGroups;
-    });
-  } catch (e) {
-    logMutationRecoveryError(e, lc, stepDescription, delegate);
-  } finally {
-    await lazyDagForOtherClientGroup.close();
-    lc.debug?.("End:", stepDescription);
-  }
-  return;
-}
-
-// ../replicache/src/broadcast-channel.ts
-var NoopBroadcastChannel = class {
-  name;
-  onmessage = null;
-  onmessageerror = null;
-  constructor(name) {
-    this.name = name;
-  }
-  addEventListener() {
-  }
-  removeEventListener() {
-  }
-  dispatchEvent() {
-    return false;
-  }
-  close() {
+    assertSnapshotCommitDD31(clientGroupSnapshotCommit);
+    const { cookieJSON } = clientGroupSnapshotCommit.meta;
+    if (newestCookie === void 0 || compareCookies(cookieJSON, newestCookie) > 0) {
+      newestCookie = cookieJSON;
+      bestSnapshot = clientGroupSnapshotCommit;
+    }
   }
-  postMessage() {
+  if (bestSnapshot) {
+    return {
+      type: FIND_MATCHING_CLIENT_TYPE_FORK,
+      snapshot: bestSnapshot
+    };
   }
-};
-var bc = typeof BroadcastChannel === "undefined" ? NoopBroadcastChannel : BroadcastChannel;
-
-// ../replicache/src/new-client-channel.ts
-function makeChannelNameV0(replicacheName) {
-  return `replicache-new-client-group:${replicacheName}`;
-}
-function makeChannelNameV1(replicacheName) {
-  return `replicache-new-client-group-v1:${replicacheName}`;
-}
-function isNewClientChannelMessageV1(message) {
-  return typeof message === "object" && typeof message.clientGroupID === "string" && typeof message.idbName === "string";
+  return { type: FIND_MATCHING_CLIENT_TYPE_NEW };
 }
-function initNewClientChannel(replicacheName, idbName, signal, clientGroupID, isNewClientGroup, onUpdateNeeded, perdag) {
-  if (signal.aborted) {
-    return;
-  }
-  const channelV1 = new bc(makeChannelNameV1(replicacheName));
-  if (isNewClientGroup) {
-    channelV1.postMessage({ clientGroupID, idbName });
-    const channelV0 = new bc(makeChannelNameV0(replicacheName));
-    channelV0.postMessage([clientGroupID]);
-    channelV0.close();
-  }
-  channelV1.onmessage = async (e) => {
-    const { data } = e;
-    if (isNewClientChannelMessageV1(data)) {
-      const { clientGroupID: newClientGroupID, idbName: newClientIDBName } = data;
-      if (newClientGroupID !== clientGroupID) {
-        if (newClientIDBName === idbName) {
-          const updateNeeded = await withRead(
-            perdag,
-            async (perdagRead) => await getClientGroup(newClientGroupID, perdagRead) !== void 0
-          );
-          if (updateNeeded) {
-            onUpdateNeeded();
-          }
-        } else {
-          onUpdateNeeded();
-          return;
-        }
+function getRefsForClients(clients) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const client of clients.values()) {
+    if (isClientV6(client)) {
+      for (const hash2 of client.refreshHashes) {
+        refs.add(hash2);
+      }
+      if (client.persistHash) {
+        refs.add(client.persistHash);
+      }
+    } else {
+      refs.add(client.headHash);
+      if (isClientV5(client) && client.tempRefreshHash) {
+        refs.add(client.tempRefreshHash);
       }
     }
-  };
-  signal.addEventListener("abort", () => channelV1.close(), { once: true });
-}
-
-// ../replicache/src/on-persist-channel.ts
-function makeChannelName(replicacheName) {
-  return `replicache-on-persist:${replicacheName}`;
-}
-function assertPersistInfo(value) {
-  assertObject(value);
-  assertString(value.clientGroupID);
-  assertString(value.clientID);
+  }
+  return toRefs(refs);
 }
-function initOnPersistChannel(replicacheName, signal, handlePersist) {
-  if (signal.aborted) {
-    return () => void 0;
+async function getClientGroupForClient(clientID, read) {
+  const clientGroupID = await getClientGroupIDForClient(clientID, read);
+  if (!clientGroupID) {
+    return void 0;
   }
-  const channel = new bc(makeChannelName(replicacheName));
-  channel.onmessage = (e) => {
-    const { data } = e;
-    assertPersistInfo(data);
-    handlePersist({
-      clientGroupID: data.clientGroupID,
-      clientID: data.clientID
-    });
-  };
-  signal.addEventListener("abort", () => channel.close(), { once: true });
-  return (persistInfo) => {
-    if (signal.aborted) {
-      return;
-    }
-    channel.postMessage(persistInfo);
-    handlePersist(persistInfo);
-  };
+  return getClientGroup(clientGroupID, read);
 }
-
-// ../replicache/src/pending-mutations.ts
-async function pendingMutationsForAPI(dagRead) {
-  const mainHeadHash = await mustGetHeadHash(DEFAULT_HEAD_NAME, dagRead);
-  const pending = await localMutationsDD31(mainHeadHash, dagRead);
-  return pending.map((p) => ({
-    id: p.meta.mutationID,
-    name: p.meta.mutatorName,
-    args: p.meta.mutatorArgsJSON,
-    clientID: p.meta.clientID
-  })).reverse();
+async function getClientGroupIDForClient(clientID, read) {
+  const client = await getClient(clientID, read);
+  if (!client || !isClientV5(client)) {
+    return void 0;
+  }
+  return client.clientGroupID;
 }
-
-// ../replicache/src/bg-interval.ts
-function initBgIntervalProcess(processName, process2, delayMs, lc, signal) {
-  void runBgIntervalProcess(processName, process2, delayMs, lc, signal);
+async function setClient(clientID, client, dagWrite) {
+  const clients = await getClients(dagWrite);
+  const newClients = new Map(clients).set(clientID, client);
+  return setClients(newClients, dagWrite);
 }
-async function runBgIntervalProcess(processName, process2, delayMs, lc, signal) {
-  if (signal.aborted) {
-    return;
-  }
-  lc = lc.withContext("bgIntervalProcess", processName);
-  lc.debug?.("Starting");
-  while (!signal.aborted) {
-    try {
-      await sleep(delayMs(), signal);
-    } catch (e) {
-      if (!(e instanceof AbortError)) {
-        throw e;
-      }
-    }
-    if (!signal.aborted) {
-      lc.debug?.("Running");
-      try {
-        await process2();
-      } catch (e) {
-        if (signal.aborted) {
-          lc.debug?.("Error running most likely due to close.", e);
-        } else {
-          lc.error?.("Error running.", e);
-        }
-      }
-    }
-  }
-  lc.debug?.("Stopping");
+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;
 }
 
 // ../replicache/src/persist/client-gc.ts
@@ -8396,16 +7416,18 @@ var ReplicacheImpl = class {
     this.#profileIDPromise = profileIDResolver.promise;
     const clientGroupIDResolver = resolver6();
     this.#clientGroupIDPromise = clientGroupIDResolver.promise;
-    this.#mutationRecovery = new MutationRecovery({
-      delegate: this,
-      lc: this.#lc,
-      enableMutationRecovery,
-      wrapInOnlineCheck: this.#wrapInOnlineCheck.bind(this),
-      wrapInReauthRetries: this.#wrapInReauthRetries.bind(this),
-      isPullDisabled: this.#isPullDisabled.bind(this),
-      isPushDisabled: this.#isPushDisabled.bind(this),
-      clientGroupIDPromise: this.#clientGroupIDPromise
-    });
+    if (false) {
+      this.#mutationRecovery = new MutationRecovery({
+        delegate: this,
+        lc: this.#lc,
+        enableMutationRecovery,
+        wrapInOnlineCheck: this.#wrapInOnlineCheck.bind(this),
+        wrapInReauthRetries: this.#wrapInReauthRetries.bind(this),
+        isPullDisabled: this.#isPullDisabled.bind(this),
+        isPushDisabled: this.#isPushDisabled.bind(this),
+        clientGroupIDPromise: this.#clientGroupIDPromise
+      });
+    }
     this.#onPersist = initOnPersistChannel(
       this.name,
       this.#closeAbortController.signal,
@@ -8427,7 +7449,7 @@ var ReplicacheImpl = class {
     await closingInstances.get(this.name);
     await this.#idbDatabases.getProfileID().then(profileIDResolver);
     await this.#idbDatabases.putDatabase(this.#idbDatabase);
-    const [client, headHash, clients, isNewClientGroup] = await initClientV6(
+    const [client, headHash, , isNewClientGroup] = await initClientV6(
       clientID,
       this.#lc,
       this.perdag,
@@ -8492,7 +7514,7 @@ var ReplicacheImpl = class {
       RECOVER_MUTATIONS_INTERVAL_MS,
       signal
     );
-    void this.recoverMutations(clients);
+    void this.recoverMutations();
     getBrowserGlobal("document")?.addEventListener(
       "visibilitychange",
       this.#onVisibilityChange
@@ -9209,19 +8231,20 @@ var ReplicacheImpl = class {
     }
     return ex;
   }
-  recoverMutations(preReadClientMap) {
-    const result = this.#mutationRecovery.recoverMutations(
-      preReadClientMap,
-      this.#ready,
-      this.perdag,
-      this.#idbDatabase,
-      this.#idbDatabases,
-      this.#kvStoreProvider.create
-    );
+  recoverMutations() {
     if (false) {
-      void this.onRecoverMutations(result);
+      const result = this.#mutationRecovery.recoverMutations(
+        this.#ready,
+        this.perdag,
+        this.#idbDatabase,
+        this.#idbDatabases,
+        this.#kvStoreProvider.create
+      );
+      if (false) {
+        void this.onRecoverMutations(result);
+      }
+      return result;
     }
-    return result;
   }
   /**
    * List of pending mutations. The order of this is from oldest to newest.
@@ -9365,32 +8388,37 @@ var NormalizedTableSchema = class {
   primaryKey;
   columns;
   relationships;
-  constructor(tableSchema, tableSchemaCache) {
+  constructor(tableSchema, tableSchemaCache, assertFieldRelation) {
     this.tableName = tableSchema.tableName;
     const primaryKey = normalizePrimaryKey(tableSchema.primaryKey);
     this.primaryKey = primaryKey;
     this.columns = normalizeColumns(tableSchema.columns, primaryKey);
     tableSchemaCache.set(tableSchema, this);
     this.relationships = normalizeRelationships(
+      this.tableName,
       tableSchema.relationships,
-      tableSchemaCache
+      tableSchemaCache,
+      assertFieldRelation
     );
   }
 };
+var noop3 = () => {
+};
 function normalizeTableSchema(tableSchema) {
   return normalizeTableSchemaWithCache(
     tableSchema,
     tableSchema.tableName,
-    /* @__PURE__ */ new Map()
+    /* @__PURE__ */ new Map(),
+    noop3
   );
 }
-function normalizeTableSchemaWithCache(tableSchema, expectedName, tableSchemaCache) {
+function normalizeTableSchemaWithCache(tableSchema, expectedTableName, tableSchemaCache, assertFieldRelation) {
   if (tableSchema instanceof NormalizedTableSchema) {
     return tableSchema;
   }
   assert(
-    tableSchema.tableName === expectedName,
-    `Table name mismatch: "${tableSchema.tableName}" !== "${expectedName}"`
+    tableSchema.tableName === expectedTableName,
+    `Table name mismatch: "${tableSchema.tableName}" !== "${expectedTableName}"`
   );
   let normalizedTableSchema = tableSchemaCache.get(tableSchema);
   if (normalizedTableSchema) {
@@ -9398,7 +8426,8 @@ function normalizeTableSchemaWithCache(tableSchema, expectedName, tableSchemaCac
   }
   normalizedTableSchema = new NormalizedTableSchema(
     tableSchema,
-    tableSchemaCache
+    tableSchemaCache,
+    assertFieldRelation
   );
   return normalizedTableSchema;
 }
@@ -9443,50 +8472,86 @@ function normalizeColumn(value) {
     optional: value.optional ?? false
   };
 }
-function normalizeRelationships(relationships, tableSchemaCache) {
+function normalizeRelationships(tableName, relationships, tableSchemaCache, assertFieldRelation) {
   const rv = {};
   if (relationships) {
-    for (const [name, relationship] of sortedEntries(relationships)) {
-      rv[name] = normalizeRelationship(relationship, tableSchemaCache);
+    for (const [relationshipName, relationship] of sortedEntries(
+      relationships
+    )) {
+      rv[relationshipName] = normalizeRelationship(
+        tableName,
+        relationshipName,
+        relationship,
+        tableSchemaCache,
+        assertFieldRelation
+      );
     }
   }
   return rv;
 }
-function normalizeRelationship(relationship, tableSchemaCache) {
+function normalizeRelationship(tableName, relationshipName, relationship, tableSchemaCache, assertFieldRelation) {
   if (isFieldRelationship(relationship)) {
-    return normalizeFieldRelationship(relationship, tableSchemaCache);
+    return normalizeFieldRelationship(
+      tableName,
+      relationshipName,
+      relationship,
+      tableSchemaCache,
+      assertFieldRelation
+    );
   }
-  return normalizeJunctionRelationship(relationship, tableSchemaCache);
+  return normalizeJunctionRelationship(
+    tableName,
+    relationshipName,
+    relationship,
+    tableSchemaCache,
+    assertFieldRelation
+  );
 }
-function normalizeFieldRelationship(relationship, tableSchemaCache) {
+function normalizeFieldRelationship(tableName, relationshipName, relationship, tableSchemaCache, assertFieldRelation) {
   const sourceField = normalizeFieldName(relationship.sourceField);
   const destField = normalizeFieldName(relationship.destField);
   assert(
     sourceField.length === destField.length,
     "Source and destination fields must have the same length"
   );
-  return {
+  const destSchema = normalizeLazyTableSchema(
+    relationship.destSchema,
+    tableSchemaCache,
+    assertFieldRelation
+  );
+  const normalized = {
     sourceField,
     destField,
-    destSchema: normalizeLazyTableSchema(
-      relationship.destSchema,
-      tableSchemaCache
-    )
+    destSchema
   };
+  assertFieldRelation(tableName, relationshipName, normalized);
+  return normalized;
 }
-function normalizeJunctionRelationship(relationship, tableSchemaCache) {
-  return [
-    normalizeFieldRelationship(relationship[0], tableSchemaCache),
-    normalizeFieldRelationship(relationship[1], tableSchemaCache)
-  ];
+function normalizeJunctionRelationship(tableName, relationshipName, relationship, tableSchemaCache, assertFieldRelation) {
+  const first2 = normalizeFieldRelationship(
+    tableName,
+    relationshipName,
+    relationship[0],
+    tableSchemaCache,
+    assertFieldRelation
+  );
+  const second = normalizeFieldRelationship(
+    first2.destSchema.tableName,
+    relationshipName,
+    relationship[1],
+    tableSchemaCache,
+    assertFieldRelation
+  );
+  return [first2, second];
 }
-function normalizeLazyTableSchema(tableSchema, buildCache) {
+function normalizeLazyTableSchema(tableSchema, buildCache, assertFieldRelation) {
   const tableSchemaInstance = typeof tableSchema === "function" ? tableSchema() : tableSchema;
   return normalizeTableSchemaWithCache(
     tableSchemaInstance,
     tableSchemaInstance.tableName,
     // Don't care about name here.
-    buildCache
+    buildCache,
+    assertFieldRelation
   );
 }
 function normalizeFieldName(sourceField) {
@@ -9498,18 +8563,29 @@ function normalizeFieldName(sourceField) {
 }
 function normalizeTables(tables) {
   const result = {};
+  const assertFieldRelation = (tableName) => tableName in tables;
   for (const [name, table] of sortedEntries(tables)) {
-    result[name] = normalizeTableSchemaWithCache(table, name, /* @__PURE__ */ new Map());
+    result[name] = normalizeTableSchemaWithCache(
+      table,
+      name,
+      /* @__PURE__ */ new Map(),
+      assertFieldRelation
+    );
   }
   return result;
 }
 
 // ../zero-schema/src/normalized-schema.ts
+var normalizedCache = /* @__PURE__ */ new WeakMap();
 function normalizeSchema(schema) {
   if (schema instanceof NormalizedSchema) {
     return schema;
   }
-  return new NormalizedSchema(schema);
+  let s;
+  if (!(s = normalizedCache.get(schema))) {
+    normalizedCache.set(schema, s = new NormalizedSchema(schema));
+  }
+  return s;
 }
 var NormalizedSchema = class {
   version;
@@ -9522,8 +8598,30 @@ var NormalizedSchema = class {
 function normalizeTables2(tables) {
   const rv = {};
   const tableSchemaCache = /* @__PURE__ */ new Map();
+  function assertFieldRelation(tableName, relationShipName, relation) {
+    const destTableName = relation.destSchema.tableName;
+    assert(
+      destTableName in tables,
+      `Relationship "${tableName}"."${relationShipName}" destination "${destTableName}" is missing in schema`
+    );
+    assertColumns(relation.sourceField, tables[tableName]);
+    assertColumns(relation.destField, tables[destTableName]);
+  }
+  function assertColumns(columnNames, table) {
+    for (const columnName of columnNames) {
+      assert(
+        columnName in table.columns,
+        `Column "${columnName}" is missing in table "${table.tableName}"`
+      );
+    }
+  }
   for (const [name, table] of sortedEntries(tables)) {
-    rv[name] = normalizeTableSchemaWithCache(table, name, tableSchemaCache);
+    rv[name] = normalizeTableSchemaWithCache(
+      table,
+      name,
+      tableSchemaCache,
+      assertFieldRelation
+    );
   }
   return rv;
 }
@@ -12432,12 +11530,7 @@ var preMutationRowRef = baseTracker("preMutationRow");
 
 // ../zero-schema/src/schema.ts
 function createSchema(schema) {
-  for (const [tableName, table] of Object.entries(schema.tables)) {
-    assert(
-      tableName === table.tableName,
-      `createSchema tableName mismatch, expected ${tableName} === ${table.tableName}`
-    );
-  }
+  normalizeSchema(schema);
   return schema;
 }
 
@@ -12450,6 +11543,23 @@ function escapeLike(val) {
 import { LogContext as LogContext4 } from "@rocicorp/logger";
 import { resolver as resolver8 } from "@rocicorp/resolver";
 
+// ../zero-protocol/src/error-kind-enum.ts
+var AuthInvalidated = "AuthInvalidated";
+var ClientNotFound = "ClientNotFound";
+var InvalidConnectionRequest = "InvalidConnectionRequest";
+var InvalidConnectionRequestBaseCookie = "InvalidConnectionRequestBaseCookie";
+var InvalidConnectionRequestLastMutationID = "InvalidConnectionRequestLastMutationID";
+var InvalidConnectionRequestClientDeleted = "InvalidConnectionRequestClientDeleted";
+var InvalidMessage = "InvalidMessage";
+var InvalidPush = "InvalidPush";
+var MutationFailed = "MutationFailed";
+var MutationRateLimited = "MutationRateLimited";
+var Unauthorized = "Unauthorized";
+var VersionNotSupported = "VersionNotSupported";
+var SchemaVersionNotSupported = "SchemaVersionNotSupported";
+var ServerOverloaded = "ServerOverloaded";
+var Internal = "Internal";
+
 // ../zero-protocol/src/queries-patch.ts
 var putOpSchema = valita_exports.object({
   op: valita_exports.literal("put"),
@@ -12516,27 +11626,27 @@ function encodeSecProtocols(initConnectionMessage, authToken) {
 
 // ../zero-protocol/src/error.ts
 var errorKindSchema = valita_exports.union(
-  valita_exports.literal("AuthInvalidated" /* AuthInvalidated */),
-  valita_exports.literal("ClientNotFound" /* ClientNotFound */),
-  valita_exports.literal("InvalidConnectionRequest" /* InvalidConnectionRequest */),
-  valita_exports.literal("InvalidConnectionRequestBaseCookie" /* InvalidConnectionRequestBaseCookie */),
-  valita_exports.literal("InvalidConnectionRequestLastMutationID" /* InvalidConnectionRequestLastMutationID */),
-  valita_exports.literal("InvalidConnectionRequestClientDeleted" /* InvalidConnectionRequestClientDeleted */),
-  valita_exports.literal("InvalidMessage" /* InvalidMessage */),
-  valita_exports.literal("InvalidPush" /* InvalidPush */),
-  valita_exports.literal("MutationRateLimited" /* MutationRateLimited */),
-  valita_exports.literal("MutationFailed" /* MutationFailed */),
-  valita_exports.literal("Unauthorized" /* Unauthorized */),
-  valita_exports.literal("VersionNotSupported" /* VersionNotSupported */),
-  valita_exports.literal("SchemaVersionNotSupported" /* SchemaVersionNotSupported */),
-  valita_exports.literal("Internal" /* Internal */)
+  valita_exports.literal(AuthInvalidated),
+  valita_exports.literal(ClientNotFound),
+  valita_exports.literal(InvalidConnectionRequest),
+  valita_exports.literal(InvalidConnectionRequestBaseCookie),
+  valita_exports.literal(InvalidConnectionRequestLastMutationID),
+  valita_exports.literal(InvalidConnectionRequestClientDeleted),
+  valita_exports.literal(InvalidMessage),
+  valita_exports.literal(InvalidPush),
+  valita_exports.literal(MutationRateLimited),
+  valita_exports.literal(MutationFailed),
+  valita_exports.literal(Unauthorized),
+  valita_exports.literal(VersionNotSupported),
+  valita_exports.literal(SchemaVersionNotSupported),
+  valita_exports.literal(Internal)
 );
 var basicErrorBodySchema = valita_exports.object({
   kind: errorKindSchema,
   message: valita_exports.string()
 });
 var serverOverloadedBodySchema = valita_exports.object({
-  kind: valita_exports.literal("ServerOverloaded" /* ServerOverloaded */),
+  kind: valita_exports.literal(ServerOverloaded),
   message: valita_exports.string(),
   minBackoffMs: valita_exports.number().optional()
 });
@@ -12696,6 +11806,10 @@ var downstreamSchema = valita_exports.union(
 var pingBodySchema = valita_exports.object({});
 var pingMessageSchema = valita_exports.tuple([valita_exports.literal("ping"), pingBodySchema]);
 
+// ../zero-protocol/src/mutation-type-enum.ts
+var CRUD = "crud";
+var Custom = "custom";
+
 // ../zero-protocol/src/push.ts
 var CRUD_MUTATION_NAME = "_zero_crud";
 var insertOpSchema = valita_exports.object({
@@ -12735,7 +11849,7 @@ var crudArgSchema = valita_exports.object({
 });
 var crudArgsSchema = valita_exports.tuple([crudArgSchema]);
 var crudMutationSchema = valita_exports.object({
-  type: valita_exports.literal("crud" /* CRUD */),
+  type: valita_exports.literal(CRUD),
   id: valita_exports.number(),
   clientID: valita_exports.string(),
   name: valita_exports.literal(CRUD_MUTATION_NAME),
@@ -12743,7 +11857,7 @@ var crudMutationSchema = valita_exports.object({
   timestamp: valita_exports.number()
 });
 var customMutationSchema = valita_exports.object({
-  type: valita_exports.literal("custom" /* Custom */),
+  type: valita_exports.literal(Custom),
   id: valita_exports.number(),
   clientID: valita_exports.string(),
   name: valita_exports.string(),
@@ -12808,6 +11922,11 @@ function send(ws, data) {
   ws.send(JSON.stringify(data));
 }
 
+// ../zero-client/src/client/connection-state-enum.ts
+var Disconnected = 0;
+var Connecting = 1;
+var Connected = 2;
+
 // ../btree/b+tree.ts
 function defaultComparator(a, b) {
   if (Number.isFinite(a) && Number.isFinite(b)) {
@@ -15478,7 +14597,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.10.2025010800+ca1811";
+var version2 = "0.10.2025011400+efc861";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -15534,6 +14653,14 @@ function createLogOptions(options, createDatadogLogSink = (options2) => new Data
   };
 }
 
+// ../zero-client/src/client/metric-name-enum.ts
+var TimeToConnectMs = "time_to_connect_ms";
+var LastConnectError = "last_connect_error";
+var TimeToConnectMsV2 = "time_to_connect_ms_v2";
+var LastConnectErrorV2 = "last_connect_error_v2";
+var TotalTimeToConnectMs = "total_time_to_connect_ms";
+var NotConnected = "not_connected";
+
 // ../zero-client/src/client/metrics.ts
 var DID_NOT_CONNECT_VALUE = 100 * 1e3;
 var REPORT_INTERVAL_MS = 5e3;
@@ -15585,7 +14712,7 @@ var MetricManager = class {
   // be encapsulated with the ConnectionState. This will probably happen as part
   // of https://github.com/rocicorp/reflect-server/issues/255.
   timeToConnectMs = this.#register(
-    new Gauge("time_to_connect_ms" /* TimeToConnectMs */)
+    new Gauge(TimeToConnectMs)
   );
   // lastConnectError records the last error that occurred when connecting,
   // if any. It is cleared when connecting successfully or when reported, so this
@@ -15593,28 +14720,28 @@ var MetricManager = class {
   // we are still not connected.
   lastConnectError = this.#register(
     new State(
-      "last_connect_error" /* LastConnectError */,
+      LastConnectError,
       true
       // clearOnFlush
     )
   );
   // notConnected records the reason why the client is not currently connected.
   // It is cleared when the client successfully connects.
-  #notConnected = this.#register(new State("not_connected" /* NotConnected */));
+  #notConnected = this.#register(new State(NotConnected));
   // The time from the call to connect() to receiving the 'connected' ws message
   // for the current connection.  Cleared when the client is not connected.
   // TODO: Not actually currently cleared on disconnect untill there is a
   // connect error, or client reports disconnected and waiting for visible.
   // Should have a value iff _notConnected has no value.
   #timeToConnectMsV2 = this.#register(
-    new Gauge("time_to_connect_ms_v2" /* TimeToConnectMsV2 */)
+    new Gauge(TimeToConnectMsV2)
   );
   // lastConnectErrorV2 records the last error that occurred when connecting,
   // if any. It is cleared when the client successfully connects or
   // stops trying to connect due to being hidden.
   // Should have a value iff notConnected state is NotConnectedReason.Error.
   #lastConnectErrorV2 = this.#register(
-    new State("last_connect_error_v2" /* LastConnectErrorV2 */)
+    new State(LastConnectErrorV2)
   );
   // The total time it took to connect across retries for the current
   // connection.  Cleared when the client is not connected.
@@ -15623,7 +14750,7 @@ var MetricManager = class {
   // See Zero.#totalToConnectStart for details of how this total is computed.
   // Should have a value iff _notConnected has no value.
   #totalTimeToConnectMs = this.#register(
-    new Gauge("total_time_to_connect_ms" /* TotalTimeToConnectMs */)
+    new Gauge(TotalTimeToConnectMs)
   );
   #setNotConnectedReason(reason) {
     this.#notConnected.set(reason);
@@ -15764,6 +14891,10 @@ var State = class {
   }
 };
 
+// ../zero-client/src/client/ping-result-enum.ts
+var TimedOut = 0;
+var Success = 1;
+
 // ../zero-client/src/client/query-manager.ts
 var QueryManager = class {
   #clientID;
@@ -16018,10 +15149,10 @@ function isAuthError(ex) {
   return isServerError(ex) && isAuthErrorKind(ex.kind);
 }
 function isAuthErrorKind(kind) {
-  return kind === "AuthInvalidated" /* AuthInvalidated */ || kind === "Unauthorized" /* Unauthorized */;
+  return kind === AuthInvalidated || kind === Unauthorized;
 }
 function isServerOverloadedError(ex) {
-  return isServerError(ex) && ex.errorBody.kind === "ServerOverloaded" /* ServerOverloaded */ ? ex.errorBody : void 0;
+  return isServerError(ex) && ex.errorBody.kind === ServerOverloaded ? ex.errorBody : void 0;
 }
 
 // ../zero-client/src/client/server-option.ts
@@ -16457,7 +15588,7 @@ var Zero = class {
   #closeAbortController = new AbortController();
   #visibilityWatcher;
   // We use an accessor pair to allow the subclass to override the setter.
-  #connectionState = 0 /* Disconnected */;
+  #connectionState = Disconnected;
   #setConnectionState(state) {
     if (state === this.#connectionState) {
       return;
@@ -16643,7 +15774,7 @@ var Zero = class {
     }
   }
   #sendChangeDesiredQueries(msg) {
-    if (this.#socket && this.#connectionState === 2 /* Connected */) {
+    if (this.#socket && this.#connectionState === Connected) {
       send(this.#socket, msg);
     }
   }
@@ -16740,7 +15871,7 @@ var Zero = class {
    */
   close() {
     const lc = this.#lc.withContext("close");
-    if (this.#connectionState !== 0 /* Disconnected */) {
+    if (this.#connectionState !== Disconnected) {
       this.#disconnect(lc, {
         client: "ClientClosed"
       });
@@ -16821,7 +15952,7 @@ var Zero = class {
   // An error on the connection is fatal for the connection.
   async #handleErrorMessage(lc, downMessage) {
     const [, { kind, message }] = downMessage;
-    if (kind === "MutationRateLimited" /* MutationRateLimited */) {
+    if (kind === MutationRateLimited) {
       this.#lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
       lc.error?.("Mutation rate limited", { message });
       return;
@@ -16832,15 +15963,15 @@ var Zero = class {
     lc.debug?.("Rejecting connect resolver due to error", error);
     this.#connectResolver.reject(error);
     this.#disconnect(lc, { server: kind });
-    if (kind === "VersionNotSupported" /* VersionNotSupported */) {
+    if (kind === VersionNotSupported) {
       this.#onUpdateNeeded?.({ type: kind }, message);
-    } else if (kind === "SchemaVersionNotSupported" /* SchemaVersionNotSupported */) {
+    } else if (kind === SchemaVersionNotSupported) {
       await this.#rep.disableClientGroup();
       this.#onUpdateNeeded?.({ type: "SchemaVersionNotSupported" }, message);
-    } else if (kind === "ClientNotFound" /* ClientNotFound */) {
+    } else if (kind === ClientNotFound) {
       await this.#rep.disableClientGroup();
       this.#onClientStateNotFound?.(onClientStateNotFoundServerReason(message));
-    } else if (kind === "InvalidConnectionRequestLastMutationID" /* InvalidConnectionRequestLastMutationID */ || kind === "InvalidConnectionRequestBaseCookie" /* InvalidConnectionRequestBaseCookie */) {
+    } else if (kind === InvalidConnectionRequestLastMutationID || kind === InvalidConnectionRequestBaseCookie) {
       await dropDatabase(this.#rep.idbName);
       reloadWithReason(lc, this.#reload, serverAheadReloadReason(kind));
     }
@@ -16911,7 +16042,7 @@ var Zero = class {
       ]);
     }
     this.#initConnectionQueries = void 0;
-    this.#setConnectionState(2 /* Connected */);
+    this.#setConnectionState(Connected);
     this.#connectResolver.resolve();
   }
   /**
@@ -16932,11 +16063,11 @@ var Zero = class {
    */
   async #connect(l) {
     assert(this.#server);
-    assert(this.#connectionState === 0 /* Disconnected */);
+    assert(this.#connectionState === Disconnected);
     const wsid = nanoid();
     l = addWebSocketIDToLogContext(wsid, l);
     l.info?.("Connecting...", { navigatorOnline: localNavigator?.onLine });
-    this.#setConnectionState(1 /* Connecting */);
+    this.#setConnectionState(Connecting);
     assert(this.#connectStart === void 0);
     const now = Date.now();
     this.#connectStart = now;
@@ -17001,7 +16132,7 @@ var Zero = class {
     }
   }
   #disconnect(l, reason) {
-    if (this.#connectionState === 1 /* Connecting */) {
+    if (this.#connectionState === Connecting) {
       this.#connectErrorCount++;
     }
     l.info?.("disconnecting", {
@@ -17016,7 +16147,7 @@ var Zero = class {
       connectErrorCount: this.#connectErrorCount
     });
     switch (this.#connectionState) {
-      case 2 /* Connected */: {
+      case Connected: {
         if (this.#connectStart !== void 0) {
           l.error?.(
             "disconnect() called while connected but connect start time is defined. This should not happen."
@@ -17024,7 +16155,7 @@ var Zero = class {
         }
         break;
       }
-      case 1 /* Connecting */: {
+      case Connecting: {
         this.#metrics.lastConnectError.set(getLastConnectErrorValue(reason));
         this.#metrics.timeToConnectMs.set(DID_NOT_CONNECT_VALUE);
         this.#metrics.setConnectError(reason);
@@ -17040,14 +16171,14 @@ var Zero = class {
         }
         break;
       }
-      case 0 /* Disconnected */:
+      case Disconnected:
         l.error?.("disconnect() called while disconnected");
         break;
     }
     this.#socketResolver = resolver8();
     l.debug?.("Creating new connect resolver");
     this.#connectResolver = resolver8();
-    this.#setConnectionState(0 /* Disconnected */);
+    this.#setConnectionState(Disconnected);
     this.#messageCount = 0;
     this.#connectStart = void 0;
     this.#connectedAt = 0;
@@ -17081,9 +16212,9 @@ var Zero = class {
     const lc = this.#lc;
     lc.info?.(
       "poke error, disconnecting?",
-      this.#connectionState !== 0 /* Disconnected */
+      this.#connectionState !== Disconnected
     );
-    if (this.#connectionState !== 0 /* Disconnected */) {
+    if (this.#connectionState !== Disconnected) {
       this.#disconnect(lc, {
         client: "UnexpectedBaseCookie"
       });
@@ -17124,14 +16255,14 @@ var Zero = class {
       const m = req.mutations[i];
       const timestamp = now - Math.round(performance.now() - m.timestamp);
       const zeroM = m.name === CRUD_MUTATION_NAME ? {
-        type: "crud" /* CRUD */,
+        type: CRUD,
         timestamp,
         id: m.id,
         clientID: m.clientID,
         name: m.name,
         args: [m.args]
       } : {
-        type: "custom" /* Custom */,
+        type: Custom,
         timestamp,
         id: m.id,
         clientID: m.clientID,
@@ -17195,7 +16326,7 @@ var Zero = class {
       backoffMs = RUN_LOOP_INTERVAL_MS;
       try {
         switch (this.#connectionState) {
-          case 0 /* Disconnected */: {
+          case Disconnected: {
             if (this.#visibilityWatcher.visibilityState === "hidden") {
               this.#metrics.setDisconnectedWaitingForVisible();
               this.#totalToConnectStart = void 0;
@@ -17219,11 +16350,11 @@ var Zero = class {
             this.#setOnline(true);
             break;
           }
-          case 1 /* Connecting */:
+          case Connecting:
             lc.error?.("unreachable");
             gotError = true;
             break;
-          case 2 /* Connected */: {
+          case Connected: {
             const controller = new AbortController();
             this.#abortPingTimeout = () => controller.abort();
             const [pingTimeoutPromise, pingTimeoutAborted] = sleepWithAbort(
@@ -17231,11 +16362,8 @@ var Zero = class {
               controller.signal
             );
             this.#rejectMessageError = resolver8();
-            let RaceCases;
-            ((RaceCases2) => {
-              RaceCases2[RaceCases2["Ping"] = 0] = "Ping";
-              RaceCases2[RaceCases2["Hidden"] = 2] = "Hidden";
-            })(RaceCases || (RaceCases = {}));
+            const PING = 0;
+            const HIDDEN = 2;
             const raceResult = await promiseRace([
               pingTimeoutPromise,
               pingTimeoutAborted,
@@ -17248,17 +16376,17 @@ var Zero = class {
               break;
             }
             switch (raceResult) {
-              case 0 /* Ping */: {
+              case PING: {
                 const pingResult = await this.#ping(
                   lc,
                   this.#rejectMessageError.promise
                 );
-                if (pingResult === 0 /* TimedOut */) {
+                if (pingResult === TimedOut) {
                   gotError = true;
                 }
                 break;
               }
-              case 2 /* Hidden */:
+              case HIDDEN:
                 this.#disconnect(lc, {
                   client: "Hidden"
                 });
@@ -17269,7 +16397,7 @@ var Zero = class {
           }
         }
       } catch (ex) {
-        if (this.#connectionState !== 2 /* Connected */) {
+        if (this.#connectionState !== Connected) {
           lc.error?.("Failed to connect", ex, {
             lmid: this.#lastMutationIDReceived,
             baseCookie: this.#connectCookie
@@ -17338,20 +16466,17 @@ var Zero = class {
     const pullResponseResolver = resolver8();
     this.#pendingPullsByRequestID.set(requestID, pullResponseResolver);
     try {
-      let RaceCases;
-      ((RaceCases2) => {
-        RaceCases2[RaceCases2["Timeout"] = 0] = "Timeout";
-        RaceCases2[RaceCases2["Response"] = 1] = "Response";
-      })(RaceCases || (RaceCases = {}));
+      const TIMEOUT = 0;
+      const RESPONSE = 1;
       const raceResult = await promiseRace([
         sleep(PULL_TIMEOUT_MS),
         pullResponseResolver.promise
       ]);
       switch (raceResult) {
-        case 0 /* Timeout */:
+        case TIMEOUT:
           lc.debug?.("Mutation recovery pull timed out");
           throw new Error("Pull timed out");
-        case 1 /* Response */: {
+        case RESPONSE: {
           lc.debug?.("Returning mutation recovery pull response");
           const response = await pullResponseResolver.promise;
           return {
@@ -17413,10 +16538,10 @@ var Zero = class {
       this.#disconnect(l, {
         client: "PingTimeout"
       });
-      return 0 /* TimedOut */;
+      return TimedOut;
     }
     l.debug?.("ping succeeded in", delta, "ms");
-    return 1 /* Success */;
+    return Success;
   }
   // Sends a set of metrics to the server. Throws unless the server
   // returns 200.
@@ -17509,4 +16634,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-PPRTDNXA.js.map
+//# sourceMappingURL=chunk-TS7IMB6J.js.map