@rocicorp/zero 0.10.2025010800 → 0.10.2025011100

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

@@ -16,10 +16,53 @@ import {
   unreachable
 } from "./chunk-Y6OVFUGE.js";
 import {
-  __export,
-  __reExport
+  assert as assert2,
+  parse,
+  readonly,
+  readonlyArray,
+  readonlyObject,
+  readonlyRecord,
+  valita_exports
+} from "./chunk-ZRR54VX5.js";
+import {
+  __export
 } 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";
 
@@ -77,73 +120,73 @@ function deepEqual(a, b) {
   }
   return aSize === bSize;
 }
-function assertJSONValue(v2) {
+function assertJSONValue(v) {
   if (isProd) {
     return;
   }
-  switch (typeof v2) {
+  switch (typeof v) {
     case "boolean":
     case "number":
     case "string":
       return;
     case "object":
-      if (v2 === null) {
+      if (v === null) {
         return;
       }
-      if (Array.isArray(v2)) {
-        return assertJSONArray(v2);
+      if (Array.isArray(v)) {
+        return assertJSONArray(v);
       }
-      return assertObjectIsJSONObject(v2);
+      return assertObjectIsJSONObject(v);
   }
-  throwInvalidType(v2, "JSON value");
+  throwInvalidType(v, "JSON value");
 }
-function assertJSONObject(v2) {
-  assertObject(v2);
-  assertObjectIsJSONObject(v2);
+function assertJSONObject(v) {
+  assertObject(v);
+  assertObjectIsJSONObject(v);
 }
-function assertObjectIsJSONObject(v2) {
-  for (const k in v2) {
-    if (hasOwn(v2, k)) {
-      const value = v2[k];
+function assertObjectIsJSONObject(v) {
+  for (const k in v) {
+    if (hasOwn(v, k)) {
+      const value = v[k];
       if (value !== void 0) {
         assertJSONValue(value);
       }
     }
   }
 }
-function assertJSONArray(v2) {
-  for (const item of v2) {
+function assertJSONArray(v) {
+  for (const item of v) {
     assertJSONValue(item);
   }
 }
-function isJSONValue(v2, path2) {
-  switch (typeof v2) {
+function isJSONValue(v, path2) {
+  switch (typeof v) {
     case "boolean":
     case "number":
     case "string":
       return true;
     case "object":
-      if (v2 === null) {
+      if (v === null) {
         return true;
       }
-      if (Array.isArray(v2)) {
-        return isJSONArray(v2, path2);
+      if (Array.isArray(v)) {
+        return isJSONArray(v, path2);
       }
-      return objectIsJSONObject(v2, path2);
+      return objectIsJSONObject(v, path2);
   }
   return false;
 }
-function isJSONObject(v2, path2) {
-  if (typeof v2 !== "object" || v2 === null) {
+function isJSONObject(v, path2) {
+  if (typeof v !== "object" || v === null) {
     return false;
   }
-  return objectIsJSONObject(v2, path2);
+  return objectIsJSONObject(v, path2);
 }
-function objectIsJSONObject(v2, path2) {
-  for (const k in v2) {
-    if (hasOwn(v2, k)) {
+function objectIsJSONObject(v, path2) {
+  for (const k in v) {
+    if (hasOwn(v, k)) {
       path2.push(k);
-      const value = v2[k];
+      const value = v[k];
       if (value !== void 0 && !isJSONValue(value, path2)) {
         return false;
       }
@@ -152,10 +195,10 @@ function objectIsJSONObject(v2, path2) {
   }
   return true;
 }
-function isJSONArray(v2, path2) {
-  for (let i = 0; i < v2.length; i++) {
+function isJSONArray(v, path2) {
+  for (let i = 0; i < v.length; i++) {
     path2.push(i);
-    if (!isJSONValue(v2[i], path2)) {
+    if (!isJSONValue(v[i], path2)) {
       return false;
     }
     path2.pop();
@@ -163,41 +206,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) {
@@ -233,12 +241,12 @@ function getCompareValue(cookie) {
   }
   return cookie.order;
 }
-function assertCookie(v2) {
-  if (v2 === null || typeof v2 === "string" || typeof v2 === "number") {
+function assertCookie(v) {
+  if (v === null || typeof v === "string" || typeof v === "number") {
     return;
   }
-  assertJSONObject(v2);
-  if (typeof v2.order === "string" || typeof v2.order === "number") {
+  assertJSONObject(v);
+  if (typeof v.order === "string" || typeof v.order === "number") {
     return;
   }
   throw new Error("Invalid cookie");
@@ -251,14 +259,14 @@ function isError(obj, type) {
 function isErrorResponse(obj) {
   return typeof obj.error === "string";
 }
-function isClientStateNotFoundResponse(v2) {
-  return isError(v2, "ClientStateNotFound");
+function isClientStateNotFoundResponse(v) {
+  return isError(v, "ClientStateNotFound");
 }
-function isVersionNotSupportedResponse(v2) {
-  if (!isError(v2, "VersionNotSupported")) {
+function isVersionNotSupportedResponse(v) {
+  if (!isError(v, "VersionNotSupported")) {
     return false;
   }
-  const { versionType } = v2;
+  const { versionType } = v;
   switch (versionType) {
     case void 0:
     case "pull":
@@ -268,15 +276,15 @@ function isVersionNotSupportedResponse(v2) {
   }
   return false;
 }
-function assertVersionNotSupportedResponse(v2) {
-  assert(isVersionNotSupportedResponse(v2));
+function assertVersionNotSupportedResponse(v) {
+  assert(isVersionNotSupportedResponse(v));
 }
 
 // ../replicache/src/http-request-info.ts
-function assertHTTPRequestInfo(v2) {
-  assertObject(v2);
-  assertNumber(v2.httpStatusCode);
-  assertString(v2.errorMessage);
+function assertHTTPRequestInfo(v) {
+  assertObject(v);
+  assertNumber(v.httpStatusCode);
+  assertString(v.errorMessage);
 }
 
 // ../replicache/src/patch-operation.ts
@@ -341,29 +349,17 @@ 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)) {
+function assertPullResponseV1(v) {
+  assertObject(v);
+  if (isClientStateNotFoundResponse(v) || isVersionNotSupportedResponse(v)) {
     return;
   }
-  const v22 = v2;
-  if (v22.cookie !== void 0) {
-    assertCookie(v22.cookie);
+  const v2 = v;
+  if (v2.cookie !== void 0) {
+    assertCookie(v2.cookie);
   }
-  assertLastMutationIDChanges(v22.lastMutationIDChanges);
-  assertPatchOperations(v22.patch);
+  assertLastMutationIDChanges(v2.lastMutationIDChanges);
+  assertPatchOperations(v2.patch);
 }
 function assertLastMutationIDChanges(lastMutationIDChanges) {
   assertObject(lastMutationIDChanges);
@@ -372,18 +368,11 @@ function assertLastMutationIDChanges(lastMutationIDChanges) {
     assertNumber(value);
   }
 }
-function assertPullerResultV1(v2) {
-  assertObject(v2);
-  assertHTTPRequestInfo(v2.httpRequestInfo);
-  if (v2.response !== void 0) {
-    assertPullResponseV1(v2.response);
-  }
-}
-function assertPullerResultV0(v2) {
-  assertObject(v2);
-  assertHTTPRequestInfo(v2.httpRequestInfo);
-  if (v2.response !== void 0) {
-    assertPullResponseV0(v2.response);
+function assertPullerResultV1(v) {
+  assertObject(v);
+  assertHTTPRequestInfo(v.httpRequestInfo);
+  if (v.response !== void 0) {
+    assertPullResponseV1(v.response);
   }
 }
 
@@ -398,15 +387,15 @@ var promiseVoid = Promise.resolve();
 
 // ../replicache/src/frozen-json.ts
 var deepFrozenObjects = /* @__PURE__ */ new WeakSet();
-function deepFreeze(v2) {
+function deepFreeze(v) {
   if (isProd) {
-    return v2;
+    return v;
   }
-  deepFreezeInternal(v2, []);
-  return v2;
+  deepFreezeInternal(v, []);
+  return v;
 }
-function deepFreezeInternal(v2, seen) {
-  switch (typeof v2) {
+function deepFreezeInternal(v, seen) {
+  switch (typeof v) {
     case "undefined":
       throw new TypeError("Unexpected value undefined");
     case "boolean":
@@ -414,84 +403,84 @@ function deepFreezeInternal(v2, seen) {
     case "string":
       return;
     case "object": {
-      if (v2 === null) {
+      if (v === null) {
         return;
       }
-      if (deepFrozenObjects.has(v2)) {
+      if (deepFrozenObjects.has(v)) {
         return;
       }
-      deepFrozenObjects.add(v2);
-      if (seen.includes(v2)) {
-        throwInvalidType(v2, "Cyclic JSON object");
+      deepFrozenObjects.add(v);
+      if (seen.includes(v)) {
+        throwInvalidType(v, "Cyclic JSON object");
       }
-      seen.push(v2);
-      Object.freeze(v2);
-      if (Array.isArray(v2)) {
-        deepFreezeArray(v2, seen);
+      seen.push(v);
+      Object.freeze(v);
+      if (Array.isArray(v)) {
+        deepFreezeArray(v, seen);
       } else {
-        deepFreezeObject(v2, seen);
+        deepFreezeObject(v, seen);
       }
       seen.pop();
       return;
     }
     default:
-      throwInvalidType(v2, "JSON value");
+      throwInvalidType(v, "JSON value");
   }
 }
-function deepFreezeArray(v2, seen) {
-  for (const item of v2) {
+function deepFreezeArray(v, seen) {
+  for (const item of v) {
     deepFreezeInternal(item, seen);
   }
 }
-function deepFreezeObject(v2, seen) {
-  for (const k in v2) {
-    if (hasOwn(v2, k)) {
-      const value = v2[k];
+function deepFreezeObject(v, seen) {
+  for (const k in v) {
+    if (hasOwn(v, k)) {
+      const value = v[k];
       if (value !== void 0) {
         deepFreezeInternal(value, seen);
       }
     }
   }
 }
-function assertDeepFrozen(v2) {
+function assertDeepFrozen(v) {
   if (isProd) {
     return;
   }
-  if (!isDeepFrozen(v2, [])) {
+  if (!isDeepFrozen(v, [])) {
     throw new Error("Expected frozen object");
   }
 }
-function isDeepFrozen(v2, seen) {
-  switch (typeof v2) {
+function isDeepFrozen(v, seen) {
+  switch (typeof v) {
     case "boolean":
     case "number":
     case "string":
       return true;
     case "object":
-      if (v2 === null) {
+      if (v === null) {
         return true;
       }
-      if (deepFrozenObjects.has(v2)) {
+      if (deepFrozenObjects.has(v)) {
         return true;
       }
-      if (!Object.isFrozen(v2)) {
+      if (!Object.isFrozen(v)) {
         return false;
       }
-      if (seen.includes(v2)) {
-        throwInvalidType(v2, "Cyclic JSON object");
+      if (seen.includes(v)) {
+        throwInvalidType(v, "Cyclic JSON object");
       }
-      seen.push(v2);
-      if (Array.isArray(v2)) {
-        for (const item of v2) {
+      seen.push(v);
+      if (Array.isArray(v)) {
+        for (const item of v) {
           if (!isDeepFrozen(item, seen)) {
             seen.pop();
             return false;
           }
         }
       } else {
-        for (const k in v2) {
-          if (hasOwn(v2, k)) {
-            const value = v2[k];
+        for (const k in v) {
+          if (hasOwn(v, k)) {
+            const value = v[k];
             if (value !== void 0 && !isDeepFrozen(value, seen)) {
               seen.pop();
               return false;
@@ -499,18 +488,18 @@ function isDeepFrozen(v2, seen) {
           }
         }
       }
-      deepFrozenObjects.add(v2);
+      deepFrozenObjects.add(v);
       seen.pop();
       return true;
     default:
-      throwInvalidType(v2, "JSON value");
+      throwInvalidType(v, "JSON value");
   }
 }
-function deepFreezeAllowUndefined(v2) {
-  if (v2 === void 0) {
+function deepFreezeAllowUndefined(v) {
+  if (v === void 0) {
     return void 0;
   }
-  return deepFreeze(v2);
+  return deepFreeze(v);
 }
 
 // ../replicache/src/kv/write-impl-base.ts
@@ -532,16 +521,16 @@ var WriteImplBase = class {
     }
   }
   async get(key) {
-    const v2 = this._pending.get(key);
-    switch (v2) {
+    const v = this._pending.get(key);
+    switch (v) {
       case deleteSentinel:
         return void 0;
       case void 0: {
-        const v3 = await this.#read.get(key);
-        return deepFreezeAllowUndefined(v3);
+        const v2 = await this.#read.get(key);
+        return deepFreezeAllowUndefined(v2);
       }
       default:
-        return v2;
+        return v;
     }
   }
   put(key, value) {
@@ -1454,14 +1443,14 @@ var Chunk = class {
     this.meta = refs;
   }
 };
-function assertRefs(v2) {
-  if (!Array.isArray(v2)) {
+function assertRefs(v) {
+  if (!Array.isArray(v)) {
     throw new Error("Refs must be an array");
   }
-  if (v2.length > 0) {
-    assertString(v2[0]);
-    for (let i = 1; i < v2.length; i++) {
-      assertString(v2[i]);
+  if (v.length > 0) {
+    assertString(v[0]);
+    for (let i = 1; i < v.length; i++) {
+      assertString(v[i]);
     }
   }
 }
@@ -1480,215 +1469,6 @@ function randomUint64() {
   return BigInt(high) << 32n | BigInt(low);
 }
 
-// ../shared/src/valita.ts
-var valita_exports = {};
-__export(valita_exports, {
-  assert: () => assert2,
-  deepPartial: () => deepPartial,
-  instanceOfAbstractType: () => instanceOfAbstractType,
-  is: () => is,
-  parse: () => parse,
-  readonly: () => readonly,
-  readonlyArray: () => readonlyArray,
-  readonlyObject: () => readonlyObject,
-  readonlyRecord: () => readonlyRecord,
-  test: () => test,
-  testOptional: () => testOptional
-});
-__reExport(valita_exports, valita_star);
-import * as v from "@badrap/valita";
-import * as valita_star from "@badrap/valita";
-function toDisplay(value) {
-  switch (typeof value) {
-    case "string":
-    case "number":
-    case "boolean":
-      return JSON.stringify(value);
-    case "undefined":
-      return "undefined";
-    case "bigint":
-      return value.toString() + "n";
-    default:
-      if (value === null) {
-        return "null";
-      }
-      if (Array.isArray(value)) {
-        return "array";
-      }
-      return typeof value;
-  }
-}
-function toDisplayAtPath(v2, path2) {
-  if (!path2?.length) {
-    return toDisplay(v2);
-  }
-  let cur = v2;
-  for (const p of path2) {
-    cur = cur[p];
-  }
-  return toDisplay(cur);
-}
-function displayList(word, expected, toDisplay2 = (x) => String(x)) {
-  if (expected.length === 1) {
-    return toDisplay2(expected[0]);
-  }
-  const suffix = `${toDisplay2(
-    expected[expected.length - 2]
-  )} ${word} ${toDisplay2(expected[expected.length - 1])}`;
-  if (expected.length === 2) {
-    return suffix;
-  }
-  return `${expected.slice(0, -2).map(toDisplay2).join(", ")}, ${suffix}`;
-}
-function getMessage(err2, v2, schema, mode) {
-  const firstIssue = err2.issues[0];
-  const { path: path2 } = firstIssue;
-  const atPath = path2?.length ? ` at ${path2.join(".")}` : "";
-  switch (firstIssue.code) {
-    case "invalid_type":
-      return `Expected ${displayList(
-        "or",
-        firstIssue.expected
-      )}${atPath}. Got ${toDisplayAtPath(v2, path2)}`;
-    case "missing_value": {
-      const atPath2 = path2 && path2.length > 1 ? ` at ${path2.slice(0, -1).join(".")}` : "";
-      if (firstIssue.path?.length) {
-        return `Missing property ${firstIssue.path.at(-1)}${atPath2}`;
-      }
-      return `TODO Unknown missing property${atPath2}`;
-    }
-    case "invalid_literal":
-      return `Expected literal value ${displayList(
-        "or",
-        firstIssue.expected,
-        toDisplay
-      )}${atPath} Got ${toDisplayAtPath(v2, path2)}`;
-    case "invalid_length": {
-      return `Expected array with length ${firstIssue.minLength === firstIssue.maxLength ? firstIssue.minLength : `between ${firstIssue.minLength} and ${firstIssue.maxLength}`}${atPath}. Got array with length ${v2.length}`;
-    }
-    case "unrecognized_keys":
-      if (firstIssue.keys.length === 1) {
-        return `Unexpected property ${firstIssue.keys[0]}${atPath}`;
-      }
-      return `Unexpected properties ${displayList(
-        "and",
-        firstIssue.keys
-      )}${atPath}`;
-    case "invalid_union":
-      return schema.name === "union" ? getDeepestUnionParseError(v2, schema, mode ?? "strict") : `Invalid union value${atPath}`;
-    case "custom_error": {
-      const { error } = firstIssue;
-      const message = !error ? "unknown" : typeof error === "string" ? error : error.message ?? "unknown";
-      return `${message}${atPath}. Got ${toDisplayAtPath(v2, path2)}`;
-    }
-  }
-}
-function getDeepestUnionParseError(value, schema, mode) {
-  const failures = [];
-  for (const type of schema.options) {
-    const r = type.try(value, { mode });
-    if (!r.ok) {
-      failures.push({ type, err: r });
-    }
-  }
-  if (failures.length) {
-    failures.sort(pathCmp);
-    if (failures.length === 1 || pathCmp(failures[0], failures[1]) < 0) {
-      return getMessage(failures[0].err, value, failures[0].type, mode);
-    }
-  }
-  try {
-    const str = JSON.stringify(value);
-    return `Invalid union value: ${str}`;
-  } catch (e) {
-    return `Invalid union value`;
-  }
-}
-function pathCmp(a, b) {
-  const aPath = a.err.issues[0].path;
-  const bPath = b.err.issues[0].path;
-  if (aPath.length !== bPath.length) {
-    return bPath.length - aPath.length;
-  }
-  for (let i = 0; i < aPath.length; i++) {
-    if (bPath[i] > aPath[i]) {
-      return -1;
-    }
-    if (bPath[i] < aPath[i]) {
-      return 1;
-    }
-  }
-  return 0;
-}
-function parse(value, schema, mode) {
-  const res = test(value, schema, mode);
-  if (!res.ok) {
-    throw new TypeError(res.error);
-  }
-  return res.value;
-}
-function is(value, schema, mode) {
-  return test(value, schema, mode).ok;
-}
-function assert2(value, schema, mode) {
-  parse(value, schema, mode);
-}
-function test(value, schema, mode) {
-  const res = schema.try(value, mode ? { mode } : void 0);
-  if (!res.ok) {
-    return {
-      ok: false,
-      error: getMessage(res, value, schema, mode)
-    };
-  }
-  return res;
-}
-function testOptional(value, schema, mode) {
-  let flags = 1;
-  if (mode === "passthrough") {
-    flags = 0;
-  } else if (mode === "strip") {
-    flags = 2;
-  }
-  const res = schema.func(value, flags);
-  if (res === void 0) {
-    return { ok: true, value };
-  } else if (res.ok) {
-    return res;
-  }
-  const err2 = new v.ValitaError(res);
-  return { ok: false, error: getMessage(err2, value, schema, mode) };
-}
-function readonly(t2) {
-  return t2;
-}
-function readonlyObject(t2) {
-  return v.object(t2);
-}
-function readonlyArray(t2) {
-  return v.array(t2);
-}
-function readonlyRecord(t2) {
-  return v.record(t2);
-}
-var AbstractType = Object.getPrototypeOf(
-  Object.getPrototypeOf(v.string().optional())
-).constructor;
-function instanceOfAbstractType(obj) {
-  return obj instanceof AbstractType;
-}
-function deepPartial(s) {
-  const shape = {};
-  for (const [key, type] of Object.entries(s.shape)) {
-    if (type.name === "object") {
-      shape[key] = deepPartial(type).optional();
-    } else {
-      shape[key] = type.optional();
-    }
-  }
-  return v.object(shape);
-}
-
 // ../replicache/src/hash.ts
 var STRING_LENGTH = 22;
 var hashRe = /^[0-9a-v-]+$/;
@@ -2095,11 +1875,11 @@ var LazyWrite = class extends LazyRead {
   }
   async #setHead(name, hash2) {
     const oldHash = await this.getHead(name);
-    const v2 = this._pendingHeadChanges.get(name);
-    if (v2 === void 0) {
+    const v = this._pendingHeadChanges.get(name);
+    if (v === void 0) {
       this._pendingHeadChanges.set(name, { new: hash2, old: oldHash });
     } else {
-      v2.new = hash2;
+      v.new = hash2;
     }
   }
   isMemOnlyChunkHash(hash2) {
@@ -2473,11 +2253,11 @@ var WriteImpl3 = class extends ReadImpl3 {
     } else {
       p1 = this._tx.put(hk, hash2);
     }
-    const v2 = this.#changedHeads.get(name);
-    if (v2 === void 0) {
+    const v = this.#changedHeads.get(name);
+    if (v === void 0) {
       this.#changedHeads.set(name, { new: hash2, old: oldHash });
     } else {
-      v2.new = hash2;
+      v.new = hash2;
     }
     await p1;
   }
@@ -2537,31 +2317,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 +2354,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 +2428,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,48 +2457,32 @@ async function commitFromHead(name, dagRead) {
   const hash2 = await mustGetHeadHash(name, dagRead);
   return commitFromHash(hash2, dagRead);
 }
-function assertIndexChangeMeta(v2) {
-  assertNumber(v2.lastMutationID);
-}
-function assertLocalMetaSDD(v2) {
-  assertNumber(v2.mutationID);
-  assertString(v2.mutatorName);
-  if (!v2.mutatorName) {
+function assertLocalMetaDD31(v) {
+  assertString(v.clientID);
+  assertNumber(v.mutationID);
+  assertString(v.mutatorName);
+  if (!v.mutatorName) {
     throw new Error("Missing mutator name");
   }
-  assertJSONValue(v2.mutatorArgsJSON);
-  if (v2.originalHash !== null) {
-    assertHash(v2.originalHash);
+  assertJSONValue(v.mutatorArgsJSON);
+  if (v.originalHash !== null) {
+    assertHash(v.originalHash);
   }
-  assertNumber(v2.timestamp);
-}
-function assertLocalMetaDD31(v2) {
-  assertString(v2.clientID);
-  assertLocalMetaSDD(v2);
+  assertNumber(v.timestamp);
 }
 function isLocalMetaDD31(meta) {
   return meta.type === LocalDD31;
 }
-function isLocalMetaSDD(meta) {
-  return meta.type === LocalSDD;
-}
-function assertSnapshotMetaBase(v2) {
-  if (v2.basisHash !== null) {
-    assertHash(v2.basisHash);
+function assertSnapshotMetaDD31(v) {
+  if (v.basisHash !== null) {
+    assertHash(v.basisHash);
   }
-  assertJSONValue(v2.cookieJSON);
+  assertJSONValue(v.cookieJSON);
+  assertLastMutationIDs(v.lastMutationIDs);
 }
-function assertSnapshotMetaSDD(v2) {
-  assertSnapshotMetaBase(v2);
-  assertNumber(v2.lastMutationID);
-}
-function assertSnapshotMetaDD31(v2) {
-  assertSnapshotMetaBase(v2);
-  assertLastMutationIDs(v2.lastMutationIDs);
-}
-function assertLastMutationIDs(v2) {
-  assertObject(v2);
-  for (const e of Object.values(v2)) {
+function assertLastMutationIDs(v) {
+  assertObject(v);
+  for (const e of Object.values(v)) {
     assertNumber(e);
   }
 }
@@ -2749,47 +2492,35 @@ function assertSnapshotCommitDD31(c) {
 function isSnapshotMetaDD31(meta) {
   return meta.type === SnapshotDD31;
 }
-function isSnapshotMetaSDD(meta) {
-  return meta.type === SnapshotSDD;
-}
-function assertMeta(v2) {
-  assertObject(v2);
-  assertDeepFrozen(v2);
-  if (v2.basisHash !== null) {
-    assertString(v2.basisHash);
+function assertMeta(v) {
+  assertObject(v);
+  assertDeepFrozen(v);
+  if (v.basisHash !== null) {
+    assertString(v.basisHash);
   }
-  assertNumber(v2.type);
-  switch (v2.type) {
-    case IndexChangeSDD:
-      assertIndexChangeMeta(v2);
-      break;
-    case LocalSDD:
-      assertLocalMetaSDD(v2);
-      break;
+  assertNumber(v.type);
+  switch (v.type) {
     case LocalDD31:
-      assertLocalMetaDD31(v2);
-      break;
-    case SnapshotSDD:
-      assertSnapshotMetaSDD(v2);
+      assertLocalMetaDD31(v);
       break;
     case SnapshotDD31:
-      assertSnapshotMetaDD31(v2);
+      assertSnapshotMetaDD31(v);
       break;
     default:
-      throw new Error(`Invalid enum value ${v2.type}`);
+      throw new Error(`Invalid enum value ${v.type}`);
   }
 }
 function chunkIndexDefinitionEqualIgnoreName(a, b) {
   return a.jsonPointer === b.jsonPointer && (a.allowEmpty ?? false) === (b.allowEmpty ?? false) && a.keyPrefix === b.keyPrefix;
 }
-function assertChunkIndexDefinition(v2) {
-  assertObject(v2);
-  assertDeepFrozen(v2);
-  assertString(v2.name);
-  assertString(v2.keyPrefix);
-  assertString(v2.jsonPointer);
-  if (v2.allowEmpty !== void 0) {
-    assertBoolean(v2.allowEmpty);
+function assertChunkIndexDefinition(v) {
+  assertObject(v);
+  assertDeepFrozen(v);
+  assertString(v.name);
+  assertString(v.keyPrefix);
+  assertString(v.jsonPointer);
+  if (v.allowEmpty !== void 0) {
+    assertBoolean(v.allowEmpty);
   }
 }
 function toChunkIndexDefinition(name, indexDefinition) {
@@ -2800,34 +2531,19 @@ function toChunkIndexDefinition(name, indexDefinition) {
     allowEmpty: indexDefinition.allowEmpty ?? false
   };
 }
-function assertIndexRecord(v2) {
-  assertObject(v2);
-  assertDeepFrozen(v2);
-  assertChunkIndexDefinition(v2.definition);
-  assertString(v2.valueHash);
+function assertIndexRecord(v) {
+  assertObject(v);
+  assertDeepFrozen(v);
+  assertChunkIndexDefinition(v.definition);
+  assertString(v.valueHash);
 }
-function assertIndexRecords(v2) {
-  assertArray(v2);
-  assertDeepFrozen(v2);
-  for (const ir of v2) {
+function assertIndexRecords(v) {
+  assertArray(v);
+  assertDeepFrozen(v);
+  for (const ir of v) {
     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 +2561,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 +2573,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 +2582,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 +2594,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:
@@ -2935,15 +2614,15 @@ function makeCommitData(meta, valueHash, indexes) {
     indexes
   });
 }
-function assertCommitData(v2) {
+function assertCommitData(v) {
   if (isProd) {
     return;
   }
-  assertObject(v2);
-  assertDeepFrozen(v2);
-  assertMeta(v2.meta);
-  assertString(v2.valueHash);
-  assertIndexRecords(v2.indexes);
+  assertObject(v);
+  assertDeepFrozen(v);
+  assertMeta(v.meta);
+  assertString(v.valueHash);
+  assertIndexRecords(v.indexes);
 }
 function validateChunk(chunk) {
   const { data } = chunk;
@@ -3013,14 +2692,14 @@ function binarySearch2(key, entries) {
 function binarySearchFound(i, entries, key) {
   return i !== entries.length && entries[i][0] === key;
 }
-function parseBTreeNode(v2, formatVersion, getSizeOfEntry2) {
+function parseBTreeNode(v, formatVersion, getSizeOfEntry2) {
   if (isProd && formatVersion >= V7) {
-    return v2;
+    return v;
   }
-  assertArray(v2);
-  assertDeepFrozen(v2);
-  assert(v2.length >= 2);
-  const [level, entries] = v2;
+  assertArray(v);
+  assertDeepFrozen(v);
+  assert(v.length >= 2);
+  const [level, entries] = v;
   assertNumber(level);
   assertArray(entries);
   const f = level > 0 ? assertString : assertJSONValue;
@@ -3028,7 +2707,7 @@ function parseBTreeNode(v2, formatVersion, getSizeOfEntry2) {
     for (const e of entries) {
       assertEntry(e, f);
     }
-    return v2;
+    return v;
   }
   const newEntries = entries.map((e) => convertNonV7Entry(e, f, getSizeOfEntry2));
   return [level, newEntries];
@@ -3122,13 +2801,13 @@ var DataNodeImpl = class extends NodeImpl {
     }
   }
 };
-function readonlySplice(array10, start, deleteCount, ...items) {
-  const arr = array10.slice(0, start);
+function readonlySplice(array9, start, deleteCount, ...items) {
+  const arr = array9.slice(0, start);
   for (let i = 0; i < items.length; i++) {
     arr.push(items[i]);
   }
-  for (let i = start + deleteCount; i < array10.length; i++) {
-    arr.push(array10[i]);
+  for (let i = start + deleteCount; i < array9.length; i++) {
+    arr.push(array9[i]);
   }
   return arr;
 }
@@ -3880,8 +3559,8 @@ import { greaterThan } from "compare-utf8";
 // ../replicache/src/async-iterable-to-array.ts
 async function asyncIterableToArray(it) {
   const arr = [];
-  for await (const v2 of it) {
-    arr.push(v2);
+  for await (const v of it) {
+    arr.push(v);
   }
   return arr;
 }
@@ -4452,9 +4131,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 +4139,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 +4146,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 +4167,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 +4192,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 +4205,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 +4279,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 +4294,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);
@@ -4911,11 +4503,11 @@ function createLogContext(logLevel = "info", logSinks = [consoleLogSink], contex
 }
 
 // ../replicache/src/format-version.ts
-function parseReplicacheFormatVersion(v2) {
-  if (v2 !== (v2 | 0) || v2 < SDD || v2 > Latest) {
-    throw new Error(`Unsupported format version: ${v2}`);
+function parseReplicacheFormatVersion(v) {
+  if (v !== (v | 0) || v < SDD || v > Latest) {
+    throw new Error(`Unsupported format version: ${v}`);
   }
-  return v2;
+  return v;
 }
 
 // ../replicache/src/index-defs.ts
@@ -5111,9 +4703,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,1763 +4734,1339 @@ 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/sync/handle-pull-response-result-type-enum.ts
+var Applied = 0;
+var NoOp = 1;
+var CookieMismatch = 2;
 
-// ../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);
+// ../replicache/src/sync/patch.ts
+async function apply(lc, dbWrite, patch) {
+  for (const p of patch) {
+    switch (p.op) {
+      case "put": {
+        await dbWrite.put(lc, p.key, deepFreeze(p.value));
+        break;
       }
-    } else {
-      dagWrite.assertValidHash(client.headHash);
-      if (isClientV5(client) && client.tempRefreshHash) {
-        dagWrite.assertValidHash(client.tempRefreshHash);
+      case "update": {
+        const existing = await dbWrite.get(p.key);
+        const entries = [];
+        const addToEntries = (toAdd) => {
+          for (const [key, value] of Object.entries(toAdd)) {
+            if (!p.constrain || p.constrain.length === 0 || p.constrain.indexOf(key) > -1) {
+              entries.push([key, value]);
+            }
+          }
+        };
+        if (existing !== void 0) {
+          assertObject(existing);
+          addToEntries(existing);
+        }
+        if (p.merge) {
+          addToEntries(p.merge);
+        }
+        await dbWrite.put(lc, p.key, deepFreeze(Object.fromEntries(entries)));
+        break;
       }
+      case "del":
+        await dbWrite.del(lc, p.key);
+        break;
+      case "clear":
+        await dbWrite.clear();
+        break;
     }
   }
-  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;
+
+// ../replicache/src/sync/pull-error.ts
+var PullError = class extends Error {
+  name = "PullError";
+  // causedBy is used instead of cause, because while cause has been proposed as a
+  // JavaScript language standard for this purpose (see
+  // https://github.com/tc39/proposal-error-cause) current browser behavior is
+  // inconsistent.
+  causedBy;
+  constructor(causedBy) {
+    super("Failed to pull");
+    this.causedBy = causedBy;
   }
 };
-async function assertHasClientState(id, dagRead) {
-  if (!await hasClientState(id, dagRead)) {
-    throw new ClientStateNotFoundError(id);
+
+// ../replicache/src/sync/sync-head-name.ts
+var SYNC_HEAD_NAME = "sync";
+
+// ../replicache/src/sync/pull.ts
+var PULL_VERSION_DD31 = 1;
+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);
+    if (!mainHeadHash) {
+      throw new Error("Internal no main head found");
+    }
+    const baseSnapshot = await baseSnapshotFromHash(mainHeadHash, dagRead);
+    const baseSnapshotMeta = baseSnapshot.meta;
+    assertSnapshotMetaDD31(baseSnapshotMeta);
+    return baseSnapshotMeta.cookieJSON;
+  });
+  const pullReq = {
+    profileID,
+    clientGroupID,
+    cookie: baseCookie,
+    pullVersion: PULL_VERSION_DD31,
+    schemaVersion
+  };
+  const { response, httpRequestInfo } = await callPuller(
+    lc,
+    puller,
+    pullReq,
+    requestID
+  );
+  if (!response) {
+    return {
+      httpRequestInfo,
+      syncHead: emptyHash
+    };
   }
-}
-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);
+  if (!createSyncBranch || isErrorResponse(response)) {
+    return {
+      httpRequestInfo,
+      pullResponse: response,
+      syncHead: emptyHash
+    };
   }
-  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 result = await handlePullResponseV1(
+    lc,
+    store,
+    baseCookie,
+    response,
+    clientID,
+    formatVersion
+  );
+  return {
+    httpRequestInfo,
+    pullResponse: response,
+    syncHead: result.type === Applied ? result.syncHead : emptyHash
+  };
+}
+async function callPuller(lc, puller, pullReq, requestID) {
+  lc.debug?.("Starting pull...");
+  const pullStart = Date.now();
+  let pullerResult;
+  try {
+    pullerResult = await puller(pullReq, requestID);
+    lc.debug?.(
+      `...Pull ${pullerResult.response ? "complete" : "failed"} in `,
+      Date.now() - pullStart,
+      "ms"
+    );
+  } catch (e) {
+    throw new PullError(toError(e));
+  }
+  try {
+    assertPullerResultV1(pullerResult);
+    return pullerResult;
+  } catch (e) {
+    throw new ReportError("Invalid puller result", toError(e));
+  }
+}
+function badOrderMessage(name, receivedValue, lastSnapshotValue) {
+  return `Received ${name} ${receivedValue} is < than last snapshot ${name} ${lastSnapshotValue}; ignoring client view`;
+}
+function handlePullResponseV1(lc, store, expectedBaseCookie, response, clientID, formatVersion) {
+  return withWriteNoImplicitCommit(store, async (dagWrite) => {
+    const dagRead = dagWrite;
+    const mainHead = await dagRead.getHead(DEFAULT_HEAD_NAME);
+    if (mainHead === void 0) {
+      throw new Error("Main head disappeared");
     }
-    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 baseSnapshot = await baseSnapshotFromHash(mainHead, dagRead);
+    const baseSnapshotMeta = baseSnapshot.meta;
+    assertSnapshotMetaDD31(baseSnapshotMeta);
+    const baseCookie = baseSnapshotMeta.cookieJSON;
+    if (!deepEqual(expectedBaseCookie, baseCookie)) {
+      lc.debug?.(
+        "handlePullResponse: cookie mismatch, response is not applicable"
+      );
+      return {
+        type: CookieMismatch
       };
-      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
+    for (const [clientID2, lmidChange] of Object.entries(
+      response.lastMutationIDChanges
+    )) {
+      const lastMutationID = baseSnapshotMeta.lastMutationIDs[clientID2];
+      if (lastMutationID !== void 0 && lmidChange < lastMutationID) {
+        throw new Error(
+          badOrderMessage(
+            `${clientID2} lastMutationID`,
+            String(lmidChange),
+            String(lastMutationID)
+          )
         );
-        indexRecords2.push({
-          definition: chunkIndexDefinition,
-          valueHash: emptyBTreeChunk.hash
-        });
       }
-      return setClientsAndClientGroupAndCommit(
-        null,
-        null,
-        emptyBTreeChunk.hash,
-        indexRecords2
+    }
+    const frozenResponseCookie = deepFreeze(response.cookie);
+    if (compareCookies(frozenResponseCookie, baseCookie) < 0) {
+      throw new Error(
+        badOrderMessage(
+          "cookie",
+          JSON.stringify(frozenResponseCookie),
+          JSON.stringify(baseCookie)
+        )
       );
     }
-    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
+    if (deepEqual(frozenResponseCookie, baseCookie)) {
+      if (response.patch.length > 0) {
+        lc.error?.(
+          `handlePullResponse: cookie ${JSON.stringify(
+            baseCookie
+          )} did not change, but patch is not empty`
+        );
+      }
+      if (Object.keys(response.lastMutationIDChanges).length > 0) {
+        console.log(response.lastMutationIDChanges);
+        lc.error?.(
+          `handlePullResponse: cookie ${JSON.stringify(
+            baseCookie
+          )} did not change, but lastMutationIDChanges is not empty`
         );
-        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
+        type: NoOp
       };
     }
-    const clientGroupSnapshotCommit = await baseSnapshotFromHash(
-      clientGroup.headHash,
-      dagRead
+    const dbWrite = await newWriteSnapshotDD31(
+      baseSnapshot.chunk.hash,
+      { ...baseSnapshotMeta.lastMutationIDs, ...response.lastMutationIDChanges },
+      frozenResponseCookie,
+      dagWrite,
+      clientID,
+      formatVersion
     );
-    assertSnapshotCommitDD31(clientGroupSnapshotCommit);
-    const { cookieJSON } = clientGroupSnapshotCommit.meta;
-    if (newestCookie === void 0 || compareCookies(cookieJSON, newestCookie) > 0) {
-      newestCookie = cookieJSON;
-      bestSnapshot = clientGroupSnapshotCommit;
-    }
-  }
-  if (bestSnapshot) {
+    await apply(lc, dbWrite, response.patch);
     return {
-      type: FIND_MATCHING_CLIENT_TYPE_FORK,
-      snapshot: bestSnapshot
+      type: Applied,
+      syncHead: await dbWrite.commit(SYNC_HEAD_NAME)
     };
-  }
-  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);
-      }
+function maybeEndPull(store, lc, expectedSyncHead, clientID, diffConfig, formatVersion) {
+  return withWriteNoImplicitCommit(store, async (dagWrite) => {
+    const dagRead = dagWrite;
+    const syncHeadHash = await dagRead.getHead(SYNC_HEAD_NAME);
+    if (syncHeadHash === void 0) {
+      throw new Error("Missing sync head");
     }
-  }
-  return toRefs(refs);
-}
-async function getClientGroupForClient(clientID, read) {
-  const clientGroupID = await getClientGroupIDForClient(clientID, read);
-  if (!clientGroupID) {
-    return void 0;
-  }
-  return getClientGroup(clientGroupID, read);
+    if (syncHeadHash !== expectedSyncHead) {
+      lc.error?.(
+        "maybeEndPull, Wrong sync head. Expecting:",
+        expectedSyncHead,
+        "got:",
+        syncHeadHash
+      );
+      throw new Error("Wrong sync head");
+    }
+    const syncSnapshot = await baseSnapshotFromHash(syncHeadHash, dagRead);
+    const mainHeadHash = await dagRead.getHead(DEFAULT_HEAD_NAME);
+    if (mainHeadHash === void 0) {
+      throw new Error("Missing main head");
+    }
+    const mainSnapshot = await baseSnapshotFromHash(mainHeadHash, dagRead);
+    const { meta } = syncSnapshot;
+    const syncSnapshotBasis = meta.basisHash;
+    if (syncSnapshot === null) {
+      throw new Error("Sync snapshot with no basis");
+    }
+    if (syncSnapshotBasis !== mainSnapshot.chunk.hash) {
+      throw new Error("Overlapping syncs");
+    }
+    const syncHead = await commitFromHash(syncHeadHash, dagRead);
+    const pending = [];
+    const localMutations2 = await localMutations(mainHeadHash, dagRead);
+    for (const commit of localMutations2) {
+      let cid = clientID;
+      assert(commitIsLocalDD31(commit));
+      cid = commit.meta.clientID;
+      if (await commit.getMutationID(cid, dagRead) > await syncHead.getMutationID(cid, dagRead)) {
+        pending.push(commit);
+      }
+    }
+    pending.reverse();
+    const diffsMap = new DiffsMap();
+    if (pending.length > 0) {
+      return {
+        syncHead: syncHeadHash,
+        replayMutations: pending,
+        // The changed keys are not reported when further replays are
+        // needed. The diffs will be reported at the end when there
+        // are no more mutations to be replay and then it will be reported
+        // relative to DEFAULT_HEAD_NAME.
+        diffs: diffsMap
+      };
+    }
+    const mainHead = await commitFromHash(mainHeadHash, dagRead);
+    if (diffConfig.shouldComputeDiffs()) {
+      const mainHeadMap = new BTreeRead(
+        dagRead,
+        formatVersion,
+        mainHead.valueHash
+      );
+      const syncHeadMap = new BTreeRead(
+        dagRead,
+        formatVersion,
+        syncHead.valueHash
+      );
+      const valueDiff = await diff(mainHeadMap, syncHeadMap);
+      diffsMap.set("", valueDiff);
+      await addDiffsForIndexes(
+        mainHead,
+        syncHead,
+        dagRead,
+        diffsMap,
+        diffConfig,
+        formatVersion
+      );
+    }
+    await Promise.all([
+      dagWrite.setHead(DEFAULT_HEAD_NAME, syncHeadHash),
+      dagWrite.removeHead(SYNC_HEAD_NAME)
+    ]);
+    await dagWrite.commit();
+    if (lc.debug) {
+      const [oldLastMutationID, oldCookie] = snapshotMetaParts(
+        mainSnapshot,
+        clientID
+      );
+      const [newLastMutationID, newCookie] = snapshotMetaParts(
+        syncSnapshot,
+        clientID
+      );
+      lc.debug(
+        `Successfully pulled new snapshot with lastMutationID:`,
+        newLastMutationID,
+        `(prev:`,
+        oldLastMutationID,
+        `), cookie: `,
+        newCookie,
+        `(prev:`,
+        oldCookie,
+        `), sync head hash:`,
+        syncHeadHash,
+        ", main head hash:",
+        mainHeadHash,
+        `, valueHash:`,
+        syncHead.valueHash,
+        `(prev:`,
+        mainSnapshot.valueHash
+      );
+    }
+    return {
+      syncHead: syncHeadHash,
+      replayMutations: [],
+      diffs: diffsMap
+    };
+  });
 }
-async function getClientGroupIDForClient(clientID, read) {
-  const client = await getClient(clientID, read);
-  if (!client || !isClientV5(client)) {
-    return void 0;
+
+// ../shared/src/json-schema.ts
+import * as valita from "@badrap/valita";
+var path = [];
+var jsonSchema = valita_exports.unknown().chain((v) => {
+  if (isProd) {
+    return valita.ok(v);
   }
-  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;
-}
+  const rv = isJSONValue(v, path) ? valita.ok(v) : valita.err({
+    message: `Not a JSON value`,
+    path: path.slice()
+  });
+  path.length = 0;
+  return rv;
+});
+var jsonObjectSchema = valita_exports.unknown().chain((v) => {
+  if (isProd) {
+    return valita.ok(v);
+  }
+  const rv = isJSONObject(v, path) ? valita.ok(v) : valita.err({
+    message: `Not a JSON object`,
+    path: path.slice()
+  });
+  path.length = 0;
+  return rv;
+});
 
-// ../replicache/src/to-error.ts
-function toError(e) {
-  if (e instanceof Error) {
-    return e;
+// ../replicache/src/pusher.ts
+function assertPusherResult(v) {
+  assertObject(v);
+  assertHTTPRequestInfo(v.httpRequestInfo);
+  if (v.response !== void 0) {
+    assertPushResponse(v.response);
   }
-  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/patch.ts
-async function apply(lc, dbWrite, patch) {
-  for (const p of patch) {
-    switch (p.op) {
-      case "put": {
-        await dbWrite.put(lc, p.key, deepFreeze(p.value));
-        break;
-      }
-      case "update": {
-        const existing = await dbWrite.get(p.key);
-        const entries = [];
-        const addToEntries = (toAdd) => {
-          for (const [key, value] of Object.entries(toAdd)) {
-            if (!p.constrain || p.constrain.length === 0 || p.constrain.indexOf(key) > -1) {
-              entries.push([key, value]);
-            }
-          }
-        };
-        if (existing !== void 0) {
-          assertObject(existing);
-          addToEntries(existing);
-        }
-        if (p.merge) {
-          addToEntries(p.merge);
-        }
-        await dbWrite.put(lc, p.key, deepFreeze(Object.fromEntries(entries)));
-        break;
-      }
-      case "del":
-        await dbWrite.del(lc, p.key);
-        break;
-      case "clear":
-        await dbWrite.clear();
-        break;
-    }
+function assertPushResponse(v) {
+  if (isClientStateNotFoundResponse(v)) {
+    return;
   }
+  assertVersionNotSupportedResponse(v);
 }
-
-// ../replicache/src/sync/pull-error.ts
-var PullError = class extends Error {
-  name = "PullError";
+var PushError = class extends Error {
+  name = "PushError";
   // causedBy is used instead of cause, because while cause has been proposed as a
   // JavaScript language standard for this purpose (see
   // https://github.com/tc39/proposal-error-cause) current browser behavior is
   // inconsistent.
   causedBy;
   constructor(causedBy) {
-    super("Failed to pull");
+    super("Failed to push");
     this.causedBy = causedBy;
   }
 };
 
-// ../replicache/src/sync/sync-head-name.ts
-var SYNC_HEAD_NAME = "sync";
+// ../replicache/src/sync/ids.ts
+var clientGroupIDSchema = valita_exports.string();
+var clientIDSchema = valita_exports.string();
 
-// ../replicache/src/sync/pull.ts
-var PULL_VERSION_SDD = 0;
-var PULL_VERSION_DD31 = 1;
-function isPullRequestV1(pr) {
-  return pr.pullVersion === PULL_VERSION_DD31;
+// ../replicache/src/sync/push.ts
+var PUSH_VERSION_DD31 = 1;
+var mutationV1Schema = readonlyObject({
+  id: valita_exports.number(),
+  name: valita_exports.string(),
+  args: jsonSchema,
+  timestamp: valita_exports.number(),
+  clientID: clientIDSchema
+});
+var pushRequestV1Schema = valita_exports.object({
+  pushVersion: valita_exports.literal(1),
+  schemaVersion: valita_exports.string(),
+  profileID: valita_exports.string(),
+  clientGroupID: clientGroupIDSchema,
+  mutations: valita_exports.array(mutationV1Schema)
+});
+function convertDD31(lm) {
+  return {
+    id: lm.mutationID,
+    name: lm.mutatorName,
+    args: lm.mutatorArgsJSON,
+    timestamp: lm.timestamp,
+    clientID: lm.clientID
+  };
 }
-async function beginPullV0(profileID, clientID, schemaVersion, puller, requestID, store, formatVersion, lc, createSyncBranch = true) {
-  const [lastMutationID, baseCookie] = await withRead(store, async (dagRead) => {
+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) {
-      throw new Error("Internal no main head found");
+      throw new Error("Internal no main head");
     }
-    const baseSnapshot = await baseSnapshotFromHash(mainHeadHash, dagRead);
-    const baseSnapshotMeta = baseSnapshot.meta;
-    const baseCookie2 = baseSnapshotMeta.cookieJSON;
-    const lastMutationID2 = await baseSnapshot.getMutationID(clientID, dagRead);
-    return [lastMutationID2, baseCookie2];
+    return localMutations(mainHeadHash, dagRead);
   });
-  const pullReq = {
+  if (pending.length === 0) {
+    return void 0;
+  }
+  pending.reverse();
+  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");
+    }
+  }
+  assert(clientGroupID);
+  const pushReq = {
     profileID,
-    clientID,
-    cookie: baseCookie,
-    lastMutationID,
-    pullVersion: PULL_VERSION_SDD,
+    clientGroupID,
+    mutations: pushMutations,
+    pushVersion: PUSH_VERSION_DD31,
     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);
-    if (!mainHeadHash) {
-      throw new Error("Internal no main head found");
-    }
-    const baseSnapshot = await baseSnapshotFromHash(mainHeadHash, dagRead);
-    const baseSnapshotMeta = baseSnapshot.meta;
-    assertSnapshotMetaDD31(baseSnapshotMeta);
-    return baseSnapshotMeta.cookieJSON;
-  });
-  const pullReq = {
-    profileID,
-    clientGroupID,
-    cookie: baseCookie,
-    pullVersion: PULL_VERSION_DD31,
-    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 handlePullResponseV1(
-    lc,
-    store,
-    baseCookie,
-    response,
-    clientID,
-    formatVersion
-  );
-  return {
-    httpRequestInfo,
-    pullResponse: response,
-    syncHead: result.type === Applied ? result.syncHead : emptyHash
-  };
+  lc.debug?.("Starting push...");
+  const pushStart = Date.now();
+  const pusherResult = await callPusher(pusher, pushReq, requestID);
+  lc.debug?.("...Push complete in ", Date.now() - pushStart, "ms");
+  return pusherResult;
 }
-async function callPuller(lc, puller, pullReq, requestID) {
-  lc.debug?.("Starting pull...");
-  const pullStart = Date.now();
-  let pullerResult;
+async function callPusher(pusher, body, requestID) {
+  let pusherResult;
   try {
-    pullerResult = await puller(pullReq, requestID);
-    lc.debug?.(
-      `...Pull ${pullerResult.response ? "complete" : "failed"} in `,
-      Date.now() - pullStart,
-      "ms"
-    );
+    pusherResult = await pusher(body, requestID);
   } catch (e) {
-    throw new PullError(toError(e));
+    throw new PushError(toError(e));
   }
   try {
-    if (isPullRequestV1(pullReq)) {
-      assertPullerResultV1(pullerResult);
-    } else {
-      assertPullerResultV0(pullerResult);
-    }
-    return pullerResult;
+    assertPusherResult(pusherResult);
+    return pusherResult;
   } catch (e) {
-    throw new ReportError("Invalid puller result", toError(e));
+    throw new ReportError("Invalid pusher 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
-      };
+
+// ../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;
+  }
+  async recoverMutations(ready, perdag, idbDatabase, idbDatabases, createStore) {
+    const { lc, enableMutationRecovery, isPushDisabled, delegate } = this.#options;
+    if (!enableMutationRecovery || this.#recoveringMutations || !delegate.online || delegate.closed || isPushDisabled()) {
+      return false;
     }
-    const chain = await commitChain(mainHead, dagRead);
-    let lastIntegrated;
-    for (const commit of chain) {
-      if (await commit.getMutationID(clientID, dagRead) <= response.lastMutationID) {
-        lastIntegrated = commit;
-        break;
+    const stepDescription = "Recovering mutations.";
+    lc.debug?.("Start:", stepDescription);
+    try {
+      this.#recoveringMutations = true;
+      await ready;
+      await recoverMutationsFromPerdag(idbDatabase, this.#options, perdag);
+      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,
+                createStore
+              );
+          }
+        }
       }
+    } catch (e) {
+      logMutationRecoveryError(e, lc, stepDescription, delegate);
+    } finally {
+      lc.debug?.("End:", stepDescription);
+      this.#recoveringMutations = false;
     }
-    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
+    return true;
+  }
+};
+function logMutationRecoveryError(e, lc, stepDescription, closedDelegate) {
+  if (closedDelegate.closed) {
+    lc.debug?.(
+      `Mutation recovery error likely due to close during:
+${stepDescription}
+Error:
+`,
+      e
     );
-    await apply(lc, dbWrite, response.patch);
-    const lastIntegratedMap = new BTreeRead(
-      dagRead,
-      formatVersion,
-      lastIntegrated.valueHash
+  } else {
+    lc.error?.(
+      `Mutation recovery error during:
+${stepDescription}
+Error:
+`,
+      e
     );
-    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`;
+async function recoverMutationsWithNewPerdag(database, options, createStore) {
+  const perKvStore = createStore(database.name);
+  const perdag = new StoreImpl(perKvStore, newRandomHash, assertHash);
+  try {
+    await recoverMutationsFromPerdag(database, options, perdag);
+  } finally {
+    await perdag.close();
+  }
 }
-function handlePullResponseV1(lc, store, expectedBaseCookie, response, clientID, formatVersion) {
-  return withWriteNoImplicitCommit(store, async (dagWrite) => {
-    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 baseSnapshotMeta = baseSnapshot.meta;
-    assertSnapshotMetaDD31(baseSnapshotMeta);
-    const baseCookie = baseSnapshotMeta.cookieJSON;
-    if (!deepEqual(expectedBaseCookie, baseCookie)) {
-      lc.debug?.(
-        "handlePullResponse: cookie mismatch, response is not applicable"
-      );
-      return {
-        type: CookieMismatch
-      };
-    }
-    for (const [clientID2, lmidChange] of Object.entries(
-      response.lastMutationIDChanges
-    )) {
-      const lastMutationID = baseSnapshotMeta.lastMutationIDs[clientID2];
-      if (lastMutationID !== void 0 && lmidChange < lastMutationID) {
-        throw new Error(
-          badOrderMessage(
-            `${clientID2} lastMutationID`,
-            String(lmidChange),
-            String(lastMutationID)
-          )
-        );
-      }
-    }
-    const frozenResponseCookie = deepFreeze(response.cookie);
-    if (compareCookies(frozenResponseCookie, baseCookie) < 0) {
-      throw new Error(
-        badOrderMessage(
-          "cookie",
-          JSON.stringify(frozenResponseCookie),
-          JSON.stringify(baseCookie)
-        )
-      );
-    }
-    if (deepEqual(frozenResponseCookie, baseCookie)) {
-      if (response.patch.length > 0) {
-        lc.error?.(
-          `handlePullResponse: cookie ${JSON.stringify(
-            baseCookie
-          )} did not change, but patch is not empty`
-        );
-      }
-      if (Object.keys(response.lastMutationIDChanges).length > 0) {
-        console.log(response.lastMutationIDChanges);
-        lc.error?.(
-          `handlePullResponse: cookie ${JSON.stringify(
-            baseCookie
-          )} did not change, but lastMutationIDChanges is not empty`
-        );
+function recoverMutationsFromPerdag(database, options, perdag) {
+  assert(database.replicacheFormatVersion >= DD31);
+  return recoverMutationsFromPerdagDD31(database, options, perdag);
+}
+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;
+          }
+        }
       }
-      return {
-        type: NoOp
-      };
+      clientGroups = newClientGroups;
     }
-    const dbWrite = await newWriteSnapshotDD31(
-      baseSnapshot.chunk.hash,
-      { ...baseSnapshotMeta.lastMutationIDs, ...response.lastMutationIDChanges },
-      frozenResponseCookie,
-      dagWrite,
-      clientID,
-      formatVersion
+  } catch (e) {
+    logMutationRecoveryError(e, lc, stepDescription, delegate);
+  }
+  lc.debug?.("End:", stepDescription);
+}
+function isResponseThatShouldDisableClientGroup(response) {
+  return isClientStateNotFoundResponse(response) || isVersionNotSupportedResponse(response);
+}
+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.`
     );
-    await apply(lc, dbWrite, response.patch);
-    return {
-      type: Applied,
-      syncHead: await dbWrite.commit(SYNC_HEAD_NAME)
-    };
-  });
+  } 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.`
+    );
+  }
+  await withWrite(
+    perdag,
+    (perdagWrite) => disableClientGroup(clientGroupID, perdagWrite)
+  );
 }
-function maybeEndPull(store, lc, expectedSyncHead, clientID, diffConfig, formatVersion) {
-  return withWriteNoImplicitCommit(store, async (dagWrite) => {
-    const dagRead = dagWrite;
-    const syncHeadHash = await dagRead.getHead(SYNC_HEAD_NAME);
-    if (syncHeadHash === void 0) {
-      throw new Error("Missing sync head");
+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;
     }
-    if (syncHeadHash !== expectedSyncHead) {
-      lc.error?.(
-        "maybeEndPull, Wrong sync head. Expecting:",
-        expectedSyncHead,
-        "got:",
-        syncHeadHash
+  }
+  if (allAckd) {
+    return;
+  }
+  if (clientGroup.disabled) {
+    lc.debug?.(
+      `Not recovering mutations for client group ${clientGroupID} because group is disabled.`
+    );
+    return;
+  }
+  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.`
       );
-      throw new Error("Wrong sync head");
-    }
-    const syncSnapshot = await baseSnapshotFromHash(syncHeadHash, dagRead);
-    const mainHeadHash = await dagRead.getHead(DEFAULT_HEAD_NAME);
-    if (mainHeadHash === void 0) {
-      throw new Error("Missing main head");
-    }
-    const mainSnapshot = await baseSnapshotFromHash(mainHeadHash, dagRead);
-    const { meta } = syncSnapshot;
-    const syncSnapshotBasis = meta.basisHash;
-    if (syncSnapshot === null) {
-      throw new Error("Sync snapshot with no basis");
-    }
-    if (syncSnapshotBasis !== mainSnapshot.chunk.hash) {
-      throw new Error("Overlapping syncs");
+      return;
     }
-    const syncHead = await commitFromHash(syncHeadHash, dagRead);
-    const pending = [];
-    const localMutations2 = await localMutations(mainHeadHash, dagRead);
-    for (const commit of localMutations2) {
-      let cid = clientID;
-      if (commitIsLocalDD31(commit)) {
-        cid = commit.meta.clientID;
+    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
+      );
+      if (!pusherResult) {
+        return false;
       }
-      if (await commit.getMutationID(cid, dagRead) > await syncHead.getMutationID(cid, dagRead)) {
-        pending.push(commit);
+      const pusherResponse = pusherResult.response;
+      if (isResponseThatShouldDisableClientGroup(pusherResponse)) {
+        await disableClientGroup2(
+          lc,
+          selfClientGroupID,
+          clientGroupID,
+          pusherResponse,
+          perdag
+        );
+        return false;
       }
-    }
-    pending.reverse();
-    const diffsMap = new DiffsMap();
-    if (pending.length > 0) {
-      return {
-        syncHead: syncHeadHash,
-        replayMutations: pending,
-        // The changed keys are not reported when further replays are
-        // needed. The diffs will be reported at the end when there
-        // are no more mutations to be replay and then it will be reported
-        // relative to DEFAULT_HEAD_NAME.
-        diffs: diffsMap
-      };
-    }
-    const mainHead = await commitFromHash(mainHeadHash, dagRead);
-    if (diffConfig.shouldComputeDiffs()) {
-      const mainHeadMap = new BTreeRead(
-        dagRead,
-        formatVersion,
-        mainHead.valueHash
+      return pusherResult.httpRequestInfo.httpStatusCode === 200;
+    }, pushDescription);
+    if (!pushSucceeded) {
+      lc.debug?.(
+        `Failed to recover mutations for client ${clientGroupID} due to a push error.`
       );
-      const syncHeadMap = new BTreeRead(
-        dagRead,
-        formatVersion,
-        syncHead.valueHash
-      );
-      const valueDiff = await diff(mainHeadMap, syncHeadMap);
-      diffsMap.set("", valueDiff);
-      await addDiffsForIndexes(
-        mainHead,
-        syncHead,
-        dagRead,
-        diffsMap,
-        diffConfig,
-        formatVersion
+      return;
+    }
+    if (isPullDisabled()) {
+      lc.debug?.(
+        `Cannot confirm mutations were recovered for client ${clientGroupID} because pull is disabled.`
       );
+      return;
     }
-    await Promise.all([
-      dagWrite.setHead(DEFAULT_HEAD_NAME, syncHeadHash),
-      dagWrite.removeHead(SYNC_HEAD_NAME)
-    ]);
-    await dagWrite.commit();
-    if (lc.debug) {
-      const [oldLastMutationID, oldCookie] = snapshotMetaParts(
-        mainSnapshot,
-        clientID
-      );
-      const [newLastMutationID, newCookie] = snapshotMetaParts(
-        syncSnapshot,
-        clientID
+    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
       );
-      lc.debug(
-        `Successfully pulled new snapshot with lastMutationID:`,
-        newLastMutationID,
-        `(prev:`,
-        oldLastMutationID,
-        `), cookie: `,
-        newCookie,
-        `(prev:`,
-        oldCookie,
-        `), sync head hash:`,
-        syncHeadHash,
-        ", main head hash:",
-        mainHeadHash,
-        `, valueHash:`,
-        syncHead.valueHash,
-        `(prev:`,
-        mainSnapshot.valueHash
+      const { pullResponse } = beginPullResponse;
+      if (isResponseThatShouldDisableClientGroup(pullResponse)) {
+        await disableClientGroup2(
+          lc,
+          selfClientGroupID,
+          clientGroupID,
+          pullResponse,
+          perdag
+        );
+        return false;
+      }
+      if (!pullResponse || beginPullResponse.httpRequestInfo.httpStatusCode !== 200) {
+        return false;
+      }
+      okPullResponse = pullResponse;
+      return true;
+    }, pullDescription);
+    if (!pullSucceeded) {
+      lc.debug?.(
+        `Failed to recover mutations for client ${clientGroupID} due to a pull error.`
       );
+      return;
     }
-    return {
-      syncHead: syncHeadHash,
-      replayMutations: [],
-      diffs: diffsMap
-    };
-  });
+    assert(okPullResponse);
+    lc.debug?.(
+      `Client group ${selfClientGroupID} recovered mutations for client group ${clientGroupID}.  Details`,
+      {
+        mutationIDs: clientGroup.mutationIDs,
+        lastServerAckdMutationIDs: clientGroup.lastServerAckdMutationIDs,
+        lastMutationIDChanges: okPullResponse.lastMutationIDChanges
+      }
+    );
+    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;
 }
 
-// ../shared/src/json-schema.ts
-import * as valita from "@badrap/valita";
-var path = [];
-var jsonSchema = valita_exports.unknown().chain((v2) => {
-  if (isProd) {
-    return valita.ok(v2);
+// ../replicache/src/broadcast-channel.ts
+var NoopBroadcastChannel = class {
+  name;
+  onmessage = null;
+  onmessageerror = null;
+  constructor(name) {
+    this.name = name;
   }
-  const rv = isJSONValue(v2, path) ? valita.ok(v2) : valita.err({
-    message: `Not a JSON value`,
-    path: path.slice()
-  });
-  path.length = 0;
-  return rv;
-});
-var jsonObjectSchema = valita_exports.unknown().chain((v2) => {
-  if (isProd) {
-    return valita.ok(v2);
+  addEventListener() {
   }
-  const rv = isJSONObject(v2, path) ? valita.ok(v2) : valita.err({
-    message: `Not a JSON object`,
-    path: path.slice()
-  });
-  path.length = 0;
-  return rv;
-});
-
-// ../replicache/src/pusher.ts
-function assertPusherResult(v2) {
-  assertObject(v2);
-  assertHTTPRequestInfo(v2.httpRequestInfo);
-  if (v2.response !== void 0) {
-    assertPushResponse(v2.response);
+  removeEventListener() {
   }
-}
-function assertPushResponse(v2) {
-  if (isClientStateNotFoundResponse(v2)) {
-    return;
+  dispatchEvent() {
+    return false;
   }
-  assertVersionNotSupportedResponse(v2);
-}
-var PushError = class extends Error {
-  name = "PushError";
-  // causedBy is used instead of cause, because while cause has been proposed as a
-  // JavaScript language standard for this purpose (see
-  // https://github.com/tc39/proposal-error-cause) current browser behavior is
-  // inconsistent.
-  causedBy;
-  constructor(causedBy) {
-    super("Failed to push");
-    this.causedBy = causedBy;
+  close() {
+  }
+  postMessage() {
   }
 };
+var bc = typeof BroadcastChannel === "undefined" ? NoopBroadcastChannel : BroadcastChannel;
 
-// ../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(),
-  args: jsonSchema,
-  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(),
-  profileID: valita_exports.string(),
-  clientGroupID: clientGroupIDSchema,
-  mutations: valita_exports.array(mutationV1Schema)
-});
-function convertSDD(lm) {
-  return {
-    id: lm.mutationID,
-    name: lm.mutatorName,
-    args: lm.mutatorArgsJSON,
-    timestamp: lm.timestamp
-  };
+// ../replicache/src/new-client-channel.ts
+function makeChannelNameV0(replicacheName) {
+  return `replicache-new-client-group:${replicacheName}`;
 }
-function convertDD31(lm) {
-  return {
-    id: lm.mutationID,
-    name: lm.mutatorName,
-    args: lm.mutatorArgsJSON,
-    timestamp: lm.timestamp,
-    clientID: lm.clientID
-  };
+function makeChannelNameV1(replicacheName) {
+  return `replicache-new-client-group-v1:${replicacheName}`;
 }
-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) {
-      throw new Error("Internal no main head");
-    }
-    return localMutations(mainHeadHash, dagRead);
-  });
-  if (pending.length === 0) {
-    return void 0;
+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;
   }
-  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");
-      }
-    }
-    pushReq = {
-      profileID,
-      clientID,
-      mutations: pushMutations,
-      pushVersion: PUSH_VERSION_SDD,
-      schemaVersion
-    };
+  const channelV1 = new bc(makeChannelNameV1(replicacheName));
+  if (isNewClientGroup) {
+    channelV1.postMessage({ clientGroupID, idbName });
+    const channelV0 = new bc(makeChannelNameV0(replicacheName));
+    channelV0.postMessage([clientGroupID]);
+    channelV0.close();
   }
-  lc.debug?.("Starting push...");
-  const pushStart = Date.now();
-  const pusherResult = await callPusher(pusher, pushReq, requestID);
-  lc.debug?.("...Push complete in ", Date.now() - pushStart, "ms");
-  return pusherResult;
+  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;
+        }
+      }
+    }
+  };
+  signal.addEventListener("abort", () => channelV1.close(), { once: true });
 }
-async function callPusher(pusher, body, requestID) {
-  let pusherResult;
-  try {
-    pusherResult = await pusher(body, requestID);
-  } catch (e) {
-    throw new PushError(toError(e));
-  }
-  try {
-    assertPusherResult(pusherResult);
-    return pusherResult;
-  } catch (e) {
-    throw new ReportError("Invalid pusher result", toError(e));
+
+// ../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 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);
+  };
 }
 
-// ../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/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;
   }
-  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);
+  lc = lc.withContext("bgIntervalProcess", processName);
+  lc.debug?.("Starting");
+  while (!signal.aborted) {
     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
-              );
-          }
+      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);
         }
       }
-    } 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
-    );
   }
+  lc.debug?.("Stopping");
 }
-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;
-  }
-  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.`
-      );
-      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
-          }
-        );
-      }
-    }
-    return await withWrite(perdag, async (dagWrite) => {
-      const clients = await getClients(dagWrite);
-      const clientToUpdate = clients.get(clientID);
-      if (!clientToUpdate) {
-        return clients;
-      }
-      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;
-}
-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();
-  }
-}
-function recoverMutationsFromPerdag(database, options, perdag, preReadClientMap) {
-  if (database.replicacheFormatVersion >= DD31) {
-    return recoverMutationsFromPerdagDD31(database, options, perdag);
-  }
-  return recoverMutationsFromPerdagSDD(
-    database,
-    options,
-    perdag,
-    preReadClientMap
-  );
-}
-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;
-          }
-        }
-      }
-      clientMap = newClientMap;
-    }
-  } catch (e) {
-    logMutationRecoveryError(e, lc, stepDescription, delegate);
-  }
-  lc.debug?.("End:", stepDescription);
+
+// ../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");
 }
-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;
-          }
-        }
-      }
-      clientGroups = newClientGroups;
-    }
-  } catch (e) {
-    logMutationRecoveryError(e, lc, stepDescription, delegate);
-  }
-  lc.debug?.("End:", stepDescription);
+
+// ../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 isResponseThatShouldDisableClientGroup(response) {
-  return isClientStateNotFoundResponse(response) || isVersionNotSupportedResponse(response);
+function isClientV5(client) {
+  return client.clientGroupID !== void 0;
 }
-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.`
-    );
-  }
-  await withWrite(
-    perdag,
-    (perdagWrite) => disableClientGroup(clientGroupID, perdagWrite)
-  );
+var CLIENTS_HEAD_NAME = "clients";
+var clientSchema = valita_exports.union(
+  clientV4Schema,
+  clientV5Schema,
+  clientV6Schema
+);
+function assertClient(value) {
+  assert2(value, clientSchema);
 }
-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;
-    }
-  }
-  if (allAckd) {
-    return;
-  }
-  if (clientGroup.disabled) {
-    lc.debug?.(
-      `Not recovering mutations for client group ${clientGroupID} because group is disabled.`
-    );
-    return;
-  }
-  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;
-    }
-    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
-      );
-      if (!pusherResult) {
-        return false;
-      }
-      const pusherResponse = pusherResult.response;
-      if (isResponseThatShouldDisableClientGroup(pusherResponse)) {
-        await disableClientGroup2(
-          lc,
-          selfClientGroupID,
-          clientGroupID,
-          pusherResponse,
-          perdag
-        );
-        return false;
+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 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;
     }
-    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(
-          lc,
-          selfClientGroupID,
-          clientGroupID,
-          pullResponse,
-          perdag
-        );
-        return false;
+  }
+  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);
       }
-      if (!pullResponse || beginPullResponse.httpRequestInfo.httpStatusCode !== 200) {
-        return false;
+    } else {
+      dagWrite.assertValidHash(client.headHash);
+      if (isClientV5(client) && client.tempRefreshHash) {
+        dagWrite.assertValidHash(client.tempRefreshHash);
       }
-      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 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;
+  return deepFreeze(Object.fromEntries(clients));
 }
-
-// ../replicache/src/broadcast-channel.ts
-var NoopBroadcastChannel = class {
-  name;
-  onmessage = null;
-  onmessageerror = null;
-  constructor(name) {
-    this.name = name;
-  }
-  addEventListener() {
-  }
-  removeEventListener() {
+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();
   }
-  dispatchEvent() {
-    return false;
+  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;
   }
-  close() {
+};
+async function assertHasClientState(id, dagRead) {
+  if (!await hasClientState(id, dagRead)) {
+    throw new ClientStateNotFoundError(id);
   }
-  postMessage() {
+}
+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);
   }
-};
-var bc = typeof BroadcastChannel === "undefined" ? NoopBroadcastChannel : BroadcastChannel;
-
-// ../replicache/src/new-client-channel.ts
-function makeChannelNameV0(replicacheName) {
-  return `replicache-new-client-group:${replicacheName}`;
+  return client;
 }
-function makeChannelNameV1(replicacheName) {
-  return `replicache-new-client-group-v1:${replicacheName}`;
+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 isNewClientChannelMessageV1(message) {
-  return typeof message === "object" && typeof message.clientGroupID === "string" && typeof message.idbName === "string";
+function findMatchingOldIndex(oldIndexes, chunkIndexDefinition) {
+  return oldIndexes.find(
+    (index) => chunkIndexDefinitionEqualIgnoreName(index.definition, chunkIndexDefinition)
+  );
 }
-function initNewClientChannel(replicacheName, idbName, signal, clientGroupID, isNewClientGroup, onUpdateNeeded, perdag) {
-  if (signal.aborted) {
-    return;
+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;
+    }
   }
-  const channelV1 = new bc(makeChannelNameV1(replicacheName));
-  if (isNewClientGroup) {
-    channelV1.postMessage({ clientGroupID, idbName });
-    const channelV0 = new bc(makeChannelNameV0(replicacheName));
-    channelV0.postMessage([clientGroupID]);
-    channelV0.close();
+  if (bestSnapshot) {
+    return {
+      type: FIND_MATCHING_CLIENT_TYPE_FORK,
+      snapshot: bestSnapshot
+    };
   }
-  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;
-        }
+  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);
       }
     }
-  };
-  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
@@ -8109,14 +7281,14 @@ function diffBinarySearch(diff2, prefix, compareKey) {
 }
 
 // ../shared/src/random-values.ts
-function getNonCryptoRandomValues(array10) {
-  if (array10 === null) {
+function getNonCryptoRandomValues(array9) {
+  if (array9 === null) {
     throw new TypeError("array cannot be null");
   }
-  for (let i = 0; i < array10.length; i++) {
-    array10[i] = Math.floor(Math.random() * 256);
+  for (let i = 0; i < array9.length; i++) {
+    array9[i] = Math.floor(Math.random() * 256);
   }
-  return array10;
+  return array9;
 }
 
 // ../replicache/src/sync/request-id.ts
@@ -8427,7 +7599,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 +7664,7 @@ var ReplicacheImpl = class {
       RECOVER_MUTATIONS_INTERVAL_MS,
       signal
     );
-    void this.recoverMutations(clients);
+    void this.recoverMutations();
     getBrowserGlobal("document")?.addEventListener(
       "visibilitychange",
       this.#onVisibilityChange
@@ -9209,9 +8381,8 @@ var ReplicacheImpl = class {
     }
     return ex;
   }
-  recoverMutations(preReadClientMap) {
+  recoverMutations() {
     const result = this.#mutationRecovery.recoverMutations(
-      preReadClientMap,
       this.#ready,
       this.perdag,
       this.#idbDatabase,
@@ -9304,9 +8475,9 @@ __export(column_exports, {
   enumeration: () => enumeration,
   json: () => json,
   number: () => number4,
-  string: () => string7
+  string: () => string6
 });
-function string7(optional) {
+function string6(optional) {
   return {
     type: "string",
     optional: optional ?? false,
@@ -9355,8 +8526,8 @@ function isJunctionRelationship(relationship) {
 }
 
 // ../shared/src/sorted-entries.ts
-function sortedEntries(object18) {
-  return Object.entries(object18).sort((a, b) => stringCompare(a[0], b[0]));
+function sortedEntries(object17) {
+  return Object.entries(object17).sort((a, b) => stringCompare(a[0], b[0]));
 }
 
 // ../zero-schema/src/normalize-table-schema.ts
@@ -9365,32 +8536,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 +8574,8 @@ function normalizeTableSchemaWithCache(tableSchema, expectedName, tableSchemaCac
   }
   normalizedTableSchema = new NormalizedTableSchema(
     tableSchema,
-    tableSchemaCache
+    tableSchemaCache,
+    assertFieldRelation
   );
   return normalizedTableSchema;
 }
@@ -9443,50 +8620,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 +8711,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 +8746,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;
 }
@@ -9941,8 +9187,8 @@ var negateOperatorMap = {
 function negateOperator(op) {
   return must(negateOperatorMap[op]);
 }
-function filterUndefined(array10) {
-  return array10.filter((e) => e !== void 0);
+function filterUndefined(array9) {
+  return array9.filter((e) => e !== void 0);
 }
 function filterTrue(conditions) {
   return conditions.filter((c) => !isAlwaysTrue(c));
@@ -10013,8 +9259,8 @@ function compareValues(a, b) {
   }
   throw new Error(`Unsupported type: ${a}`);
 }
-function normalizeUndefined(v2) {
-  return v2 ?? null;
+function normalizeUndefined(v) {
+  return v ?? null;
 }
 function makeComparator(order, reverse) {
   return (a, b) => {
@@ -10042,8 +9288,8 @@ function* take(stream, limit) {
     return;
   }
   let count = 0;
-  for (const v2 of stream) {
-    yield v2;
+  for (const v of stream) {
+    yield v;
     if (++count === limit) {
       break;
     }
@@ -12244,9 +11490,9 @@ var QueryImpl = class extends AbstractQuery {
     return view;
   }
   run() {
-    const v2 = this.materialize();
-    const ret = v2.data;
-    v2.destroy();
+    const v = this.materialize();
+    const ret = v.data;
+    v.destroy();
     return ret;
   }
   preload() {
@@ -12285,12 +11531,12 @@ function addPrimaryKeysToAst(schema, ast) {
   };
 }
 function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit, queryComplete) {
-  const v2 = new ArrayView(input, format, queryComplete);
-  v2.onDestroy = onDestroy;
+  const v = new ArrayView(input, format, queryComplete);
+  v.onDestroy = onDestroy;
   onTransactionCommit(() => {
-    v2.flush();
+    v.flush();
   });
-  return v2;
+  return v;
 }
 
 // ../zql/src/query/auth-query.ts
@@ -12432,12 +11678,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;
 }
 
@@ -12896,7 +12137,7 @@ var BTree = class _BTree {
   forEach(callback, thisArg) {
     if (thisArg !== void 0)
       callback = callback.bind(thisArg);
-    return this.forEachPair((k, v2) => callback(v2, k, this));
+    return this.forEachPair((k, v) => callback(v, k, this));
   }
   /** Runs a function for each key-value pair, in order from smallest to
    *  largest key. The callback can return {break:R} (where R is any value
@@ -13021,8 +12262,8 @@ var BTree = class _BTree {
   filter(callback, returnThisIfUnchanged) {
     var nu = this.greedyClone();
     var del;
-    nu.editAll((k, v2, i) => {
-      if (!callback(k, v2, i))
+    nu.editAll((k, v, i) => {
+      if (!callback(k, v, i))
         return del = Delete;
       return void 0;
     });
@@ -13034,8 +12275,8 @@ var BTree = class _BTree {
   mapValues(callback) {
     var tmp = {};
     var nu = this.greedyClone();
-    nu.editAll((k, v2, i) => {
-      return tmp.value = callback(v2, k, i), tmp;
+    nu.editAll((k, v, i) => {
+      return tmp.value = callback(v, k, i), tmp;
     });
     return nu;
   }
@@ -13507,8 +12748,8 @@ var BTree = class _BTree {
       false,
       this,
       0,
-      (_k, v2) => {
-        results.push(v2);
+      (_k, v) => {
+        results.push(v);
       }
     );
     return results;
@@ -13623,8 +12864,8 @@ var BTree = class _BTree {
    */
   getRange(low, high, includeHigh, maxLength = 67108863) {
     var results = [];
-    this._root.forRange(low, high, includeHigh, false, this, 0, (k, v2) => {
-      results.push([k, v2]);
+    this._root.forRange(low, high, includeHigh, false, this, 0, (k, v) => {
+      results.push([k, v]);
       return results.length > maxLength ? Break : void 0;
     });
     return results;
@@ -13885,10 +13126,10 @@ var BNode = class _BNode {
     return reusedArray;
   }
   clone() {
-    var v2 = this.values;
+    var v = this.values;
     return new _BNode(
       this.keys.slice(0),
-      v2 === undefVals ? v2 : v2.slice(0)
+      v === undefVals ? v : v.slice(0)
     );
   }
   greedyClone(force) {
@@ -13988,24 +13229,24 @@ var BNode = class _BNode {
     return true;
   }
   takeFromRight(rhs) {
-    var v2 = this.values;
+    var v = this.values;
     if (rhs.values === undefVals) {
-      if (v2 !== undefVals)
-        v2.push(void 0);
+      if (v !== undefVals)
+        v.push(void 0);
     } else {
-      v2 = this.reifyValues();
-      v2.push(rhs.values.shift());
+      v = this.reifyValues();
+      v.push(rhs.values.shift());
     }
     this.keys.push(rhs.keys.shift());
   }
   takeFromLeft(lhs) {
-    var v2 = this.values;
+    var v = this.values;
     if (lhs.values === undefVals) {
-      if (v2 !== undefVals)
-        v2.unshift(void 0);
+      if (v !== undefVals)
+        v.unshift(void 0);
     } else {
-      v2 = this.reifyValues();
-      v2.unshift(lhs.values.pop());
+      v = this.reifyValues();
+      v.unshift(lhs.values.pop());
     }
     this.keys.unshift(lhs.keys.pop());
   }
@@ -15478,7 +14719,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.10.2025010800+ca1811";
+var version2 = "0.10.2025011100+4a1fd2";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -17509,4 +16750,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-PPRTDNXA.js.map
+//# sourceMappingURL=chunk-FEVIDCUL.js.map