@rocicorp/zero 0.10.2025011100 → 0.11.2025011401

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

@@ -7,25 +7,16 @@ import {
   assertArray,
   assertBoolean,
   assertNotNull,
-  assertNotUndefined,
   assertNumber,
   assertObject,
   assertString,
   must,
   throwInvalidType,
   unreachable
-} from "./chunk-Y6OVFUGE.js";
+} from "./chunk-I5GSZARI.js";
 import {
-  assert as assert2,
-  parse,
-  readonly,
-  readonlyArray,
-  readonlyObject,
-  readonlyRecord,
-  valita_exports
-} from "./chunk-ZRR54VX5.js";
-import {
-  __export
+  __export,
+  __reExport
 } from "./chunk-F5QR3K72.js";
 
 // ../replicache/src/call-default-fetch.ts
@@ -120,73 +111,73 @@ function deepEqual(a, b) {
   }
   return aSize === bSize;
 }
-function assertJSONValue(v) {
+function assertJSONValue(v2) {
   if (isProd) {
     return;
   }
-  switch (typeof v) {
+  switch (typeof v2) {
     case "boolean":
     case "number":
     case "string":
       return;
     case "object":
-      if (v === null) {
+      if (v2 === null) {
         return;
       }
-      if (Array.isArray(v)) {
-        return assertJSONArray(v);
+      if (Array.isArray(v2)) {
+        return assertJSONArray(v2);
       }
-      return assertObjectIsJSONObject(v);
+      return assertObjectIsJSONObject(v2);
   }
-  throwInvalidType(v, "JSON value");
+  throwInvalidType(v2, "JSON value");
 }
-function assertJSONObject(v) {
-  assertObject(v);
-  assertObjectIsJSONObject(v);
+function assertJSONObject(v2) {
+  assertObject(v2);
+  assertObjectIsJSONObject(v2);
 }
-function assertObjectIsJSONObject(v) {
-  for (const k in v) {
-    if (hasOwn(v, k)) {
-      const value = v[k];
+function assertObjectIsJSONObject(v2) {
+  for (const k in v2) {
+    if (hasOwn(v2, k)) {
+      const value = v2[k];
       if (value !== void 0) {
         assertJSONValue(value);
       }
     }
   }
 }
-function assertJSONArray(v) {
-  for (const item of v) {
+function assertJSONArray(v2) {
+  for (const item of v2) {
     assertJSONValue(item);
   }
 }
-function isJSONValue(v, path2) {
-  switch (typeof v) {
+function isJSONValue(v2, path2) {
+  switch (typeof v2) {
     case "boolean":
     case "number":
     case "string":
       return true;
     case "object":
-      if (v === null) {
+      if (v2 === null) {
         return true;
       }
-      if (Array.isArray(v)) {
-        return isJSONArray(v, path2);
+      if (Array.isArray(v2)) {
+        return isJSONArray(v2, path2);
       }
-      return objectIsJSONObject(v, path2);
+      return objectIsJSONObject(v2, path2);
   }
   return false;
 }
-function isJSONObject(v, path2) {
-  if (typeof v !== "object" || v === null) {
+function isJSONObject(v2, path2) {
+  if (typeof v2 !== "object" || v2 === null) {
     return false;
   }
-  return objectIsJSONObject(v, path2);
+  return objectIsJSONObject(v2, path2);
 }
-function objectIsJSONObject(v, path2) {
-  for (const k in v) {
-    if (hasOwn(v, k)) {
+function objectIsJSONObject(v2, path2) {
+  for (const k in v2) {
+    if (hasOwn(v2, k)) {
       path2.push(k);
-      const value = v[k];
+      const value = v2[k];
       if (value !== void 0 && !isJSONValue(value, path2)) {
         return false;
       }
@@ -195,10 +186,10 @@ function objectIsJSONObject(v, path2) {
   }
   return true;
 }
-function isJSONArray(v, path2) {
-  for (let i = 0; i < v.length; i++) {
+function isJSONArray(v2, path2) {
+  for (let i = 0; i < v2.length; i++) {
     path2.push(i);
-    if (!isJSONValue(v[i], path2)) {
+    if (!isJSONValue(v2[i], path2)) {
       return false;
     }
     path2.pop();
@@ -241,12 +232,12 @@ function getCompareValue(cookie) {
   }
   return cookie.order;
 }
-function assertCookie(v) {
-  if (v === null || typeof v === "string" || typeof v === "number") {
+function assertCookie(v2) {
+  if (v2 === null || typeof v2 === "string" || typeof v2 === "number") {
     return;
   }
-  assertJSONObject(v);
-  if (typeof v.order === "string" || typeof v.order === "number") {
+  assertJSONObject(v2);
+  if (typeof v2.order === "string" || typeof v2.order === "number") {
     return;
   }
   throw new Error("Invalid cookie");
@@ -259,14 +250,14 @@ function isError(obj, type) {
 function isErrorResponse(obj) {
   return typeof obj.error === "string";
 }
-function isClientStateNotFoundResponse(v) {
-  return isError(v, "ClientStateNotFound");
+function isClientStateNotFoundResponse(v2) {
+  return isError(v2, "ClientStateNotFound");
 }
-function isVersionNotSupportedResponse(v) {
-  if (!isError(v, "VersionNotSupported")) {
+function isVersionNotSupportedResponse(v2) {
+  if (!isError(v2, "VersionNotSupported")) {
     return false;
   }
-  const { versionType } = v;
+  const { versionType } = v2;
   switch (versionType) {
     case void 0:
     case "pull":
@@ -276,15 +267,15 @@ function isVersionNotSupportedResponse(v) {
   }
   return false;
 }
-function assertVersionNotSupportedResponse(v) {
-  assert(isVersionNotSupportedResponse(v));
+function assertVersionNotSupportedResponse(v2) {
+  assert(isVersionNotSupportedResponse(v2));
 }
 
 // ../replicache/src/http-request-info.ts
-function assertHTTPRequestInfo(v) {
-  assertObject(v);
-  assertNumber(v.httpStatusCode);
-  assertString(v.errorMessage);
+function assertHTTPRequestInfo(v2) {
+  assertObject(v2);
+  assertNumber(v2.httpStatusCode);
+  assertString(v2.errorMessage);
 }
 
 // ../replicache/src/patch-operation.ts
@@ -349,17 +340,17 @@ var defaultPullers = /* @__PURE__ */ new WeakSet();
 function isDefaultPuller(puller) {
   return defaultPullers.has(puller);
 }
-function assertPullResponseV1(v) {
-  assertObject(v);
-  if (isClientStateNotFoundResponse(v) || isVersionNotSupportedResponse(v)) {
+function assertPullResponseV1(v2) {
+  assertObject(v2);
+  if (isClientStateNotFoundResponse(v2) || isVersionNotSupportedResponse(v2)) {
     return;
   }
-  const v2 = v;
-  if (v2.cookie !== void 0) {
-    assertCookie(v2.cookie);
+  const v22 = v2;
+  if (v22.cookie !== void 0) {
+    assertCookie(v22.cookie);
   }
-  assertLastMutationIDChanges(v2.lastMutationIDChanges);
-  assertPatchOperations(v2.patch);
+  assertLastMutationIDChanges(v22.lastMutationIDChanges);
+  assertPatchOperations(v22.patch);
 }
 function assertLastMutationIDChanges(lastMutationIDChanges) {
   assertObject(lastMutationIDChanges);
@@ -368,11 +359,11 @@ function assertLastMutationIDChanges(lastMutationIDChanges) {
     assertNumber(value);
   }
 }
-function assertPullerResultV1(v) {
-  assertObject(v);
-  assertHTTPRequestInfo(v.httpRequestInfo);
-  if (v.response !== void 0) {
-    assertPullResponseV1(v.response);
+function assertPullerResultV1(v2) {
+  assertObject(v2);
+  assertHTTPRequestInfo(v2.httpRequestInfo);
+  if (v2.response !== void 0) {
+    assertPullResponseV1(v2.response);
   }
 }
 
@@ -387,15 +378,15 @@ var promiseVoid = Promise.resolve();
 
 // ../replicache/src/frozen-json.ts
 var deepFrozenObjects = /* @__PURE__ */ new WeakSet();
-function deepFreeze(v) {
+function deepFreeze(v2) {
   if (isProd) {
-    return v;
+    return v2;
   }
-  deepFreezeInternal(v, []);
-  return v;
+  deepFreezeInternal(v2, []);
+  return v2;
 }
-function deepFreezeInternal(v, seen) {
-  switch (typeof v) {
+function deepFreezeInternal(v2, seen) {
+  switch (typeof v2) {
     case "undefined":
       throw new TypeError("Unexpected value undefined");
     case "boolean":
@@ -403,84 +394,84 @@ function deepFreezeInternal(v, seen) {
     case "string":
       return;
     case "object": {
-      if (v === null) {
+      if (v2 === null) {
         return;
       }
-      if (deepFrozenObjects.has(v)) {
+      if (deepFrozenObjects.has(v2)) {
         return;
       }
-      deepFrozenObjects.add(v);
-      if (seen.includes(v)) {
-        throwInvalidType(v, "Cyclic JSON object");
+      deepFrozenObjects.add(v2);
+      if (seen.includes(v2)) {
+        throwInvalidType(v2, "Cyclic JSON object");
       }
-      seen.push(v);
-      Object.freeze(v);
-      if (Array.isArray(v)) {
-        deepFreezeArray(v, seen);
+      seen.push(v2);
+      Object.freeze(v2);
+      if (Array.isArray(v2)) {
+        deepFreezeArray(v2, seen);
       } else {
-        deepFreezeObject(v, seen);
+        deepFreezeObject(v2, seen);
       }
       seen.pop();
       return;
     }
     default:
-      throwInvalidType(v, "JSON value");
+      throwInvalidType(v2, "JSON value");
   }
 }
-function deepFreezeArray(v, seen) {
-  for (const item of v) {
+function deepFreezeArray(v2, seen) {
+  for (const item of v2) {
     deepFreezeInternal(item, seen);
   }
 }
-function deepFreezeObject(v, seen) {
-  for (const k in v) {
-    if (hasOwn(v, k)) {
-      const value = v[k];
+function deepFreezeObject(v2, seen) {
+  for (const k in v2) {
+    if (hasOwn(v2, k)) {
+      const value = v2[k];
       if (value !== void 0) {
         deepFreezeInternal(value, seen);
       }
     }
   }
 }
-function assertDeepFrozen(v) {
+function assertDeepFrozen(v2) {
   if (isProd) {
     return;
   }
-  if (!isDeepFrozen(v, [])) {
+  if (!isDeepFrozen(v2, [])) {
     throw new Error("Expected frozen object");
   }
 }
-function isDeepFrozen(v, seen) {
-  switch (typeof v) {
+function isDeepFrozen(v2, seen) {
+  switch (typeof v2) {
     case "boolean":
     case "number":
     case "string":
       return true;
     case "object":
-      if (v === null) {
+      if (v2 === null) {
         return true;
       }
-      if (deepFrozenObjects.has(v)) {
+      if (deepFrozenObjects.has(v2)) {
         return true;
       }
-      if (!Object.isFrozen(v)) {
+      if (!Object.isFrozen(v2)) {
         return false;
       }
-      if (seen.includes(v)) {
-        throwInvalidType(v, "Cyclic JSON object");
+      if (seen.includes(v2)) {
+        throwInvalidType(v2, "Cyclic JSON object");
       }
-      seen.push(v);
-      if (Array.isArray(v)) {
-        for (const item of v) {
+      seen.push(v2);
+      if (Array.isArray(v2)) {
+        for (const item of v2) {
           if (!isDeepFrozen(item, seen)) {
             seen.pop();
             return false;
           }
         }
       } else {
-        for (const k in v) {
-          if (hasOwn(v, k)) {
-            const value = v[k];
+        for (const k in v2) {
+          if (hasOwn(v2, k)) {
+            const value = v2[k];
             if (value !== void 0 && !isDeepFrozen(value, seen)) {
               seen.pop();
               return false;
@@ -488,18 +479,18 @@ function isDeepFrozen(v, seen) {
           }
         }
       }
-      deepFrozenObjects.add(v);
+      deepFrozenObjects.add(v2);
       seen.pop();
       return true;
     default:
-      throwInvalidType(v, "JSON value");
+      throwInvalidType(v2, "JSON value");
   }
 }
-function deepFreezeAllowUndefined(v) {
-  if (v === void 0) {
+function deepFreezeAllowUndefined(v2) {
+  if (v2 === void 0) {
     return void 0;
   }
-  return deepFreeze(v);
+  return deepFreeze(v2);
 }
 
 // ../replicache/src/kv/write-impl-base.ts
@@ -521,16 +512,16 @@ var WriteImplBase = class {
     }
   }
   async get(key) {
-    const v = this._pending.get(key);
-    switch (v) {
+    const v2 = this._pending.get(key);
+    switch (v2) {
       case deleteSentinel:
         return void 0;
       case void 0: {
-        const v2 = await this.#read.get(key);
-        return deepFreezeAllowUndefined(v2);
+        const v3 = await this.#read.get(key);
+        return deepFreezeAllowUndefined(v3);
       }
       default:
-        return v;
+        return v2;
     }
   }
   put(key, value) {
@@ -735,7 +726,6 @@ function rejectIfClosed(tx) {
 }
 
 // ../replicache/src/format-version-enum.ts
-var SDD = 4;
 var DD31 = 5;
 var V6 = 6;
 var V7 = 7;
@@ -1443,14 +1433,14 @@ var Chunk = class {
     this.meta = refs;
   }
 };
-function assertRefs(v) {
-  if (!Array.isArray(v)) {
+function assertRefs(v2) {
+  if (!Array.isArray(v2)) {
     throw new Error("Refs must be an array");
   }
-  if (v.length > 0) {
-    assertString(v[0]);
-    for (let i = 1; i < v.length; i++) {
-      assertString(v[i]);
+  if (v2.length > 0) {
+    assertString(v2[0]);
+    for (let i = 1; i < v2.length; i++) {
+      assertString(v2[i]);
     }
   }
 }
@@ -1458,9 +1448,6 @@ function createChunk(data, refs, chunkHasher) {
   const hash2 = chunkHasher();
   return new Chunk(hash2, data, refs);
 }
-function throwChunkHasher() {
-  throw new Error("unexpected call to compute chunk hash");
-}
 
 // ../shared/src/random-uint64.ts
 function randomUint64() {
@@ -1469,6 +1456,215 @@ 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-]+$/;
@@ -1875,11 +2071,11 @@ var LazyWrite = class extends LazyRead {
   }
   async #setHead(name, hash2) {
     const oldHash = await this.getHead(name);
-    const v = this._pendingHeadChanges.get(name);
-    if (v === void 0) {
+    const v2 = this._pendingHeadChanges.get(name);
+    if (v2 === void 0) {
       this._pendingHeadChanges.set(name, { new: hash2, old: oldHash });
     } else {
-      v.new = hash2;
+      v2.new = hash2;
     }
   }
   isMemOnlyChunkHash(hash2) {
@@ -2253,11 +2449,11 @@ var WriteImpl3 = class extends ReadImpl3 {
     } else {
       p1 = this._tx.put(hk, hash2);
     }
-    const v = this.#changedHeads.get(name);
-    if (v === void 0) {
+    const v2 = this.#changedHeads.get(name);
+    if (v2 === void 0) {
       this.#changedHeads.set(name, { new: hash2, old: oldHash });
     } else {
-      v.new = hash2;
+      v2.new = hash2;
     }
     await p1;
   }
@@ -2457,32 +2653,32 @@ async function commitFromHead(name, dagRead) {
   const hash2 = await mustGetHeadHash(name, dagRead);
   return commitFromHash(hash2, dagRead);
 }
-function assertLocalMetaDD31(v) {
-  assertString(v.clientID);
-  assertNumber(v.mutationID);
-  assertString(v.mutatorName);
-  if (!v.mutatorName) {
+function assertLocalMetaDD31(v2) {
+  assertString(v2.clientID);
+  assertNumber(v2.mutationID);
+  assertString(v2.mutatorName);
+  if (!v2.mutatorName) {
     throw new Error("Missing mutator name");
   }
-  assertJSONValue(v.mutatorArgsJSON);
-  if (v.originalHash !== null) {
-    assertHash(v.originalHash);
+  assertJSONValue(v2.mutatorArgsJSON);
+  if (v2.originalHash !== null) {
+    assertHash(v2.originalHash);
   }
-  assertNumber(v.timestamp);
+  assertNumber(v2.timestamp);
 }
 function isLocalMetaDD31(meta) {
   return meta.type === LocalDD31;
 }
-function assertSnapshotMetaDD31(v) {
-  if (v.basisHash !== null) {
-    assertHash(v.basisHash);
+function assertSnapshotMetaDD31(v2) {
+  if (v2.basisHash !== null) {
+    assertHash(v2.basisHash);
   }
-  assertJSONValue(v.cookieJSON);
-  assertLastMutationIDs(v.lastMutationIDs);
+  assertJSONValue(v2.cookieJSON);
+  assertLastMutationIDs(v2.lastMutationIDs);
 }
-function assertLastMutationIDs(v) {
-  assertObject(v);
-  for (const e of Object.values(v)) {
+function assertLastMutationIDs(v2) {
+  assertObject(v2);
+  for (const e of Object.values(v2)) {
     assertNumber(e);
   }
 }
@@ -2492,35 +2688,35 @@ function assertSnapshotCommitDD31(c) {
 function isSnapshotMetaDD31(meta) {
   return meta.type === SnapshotDD31;
 }
-function assertMeta(v) {
-  assertObject(v);
-  assertDeepFrozen(v);
-  if (v.basisHash !== null) {
-    assertString(v.basisHash);
+function assertMeta(v2) {
+  assertObject(v2);
+  assertDeepFrozen(v2);
+  if (v2.basisHash !== null) {
+    assertString(v2.basisHash);
   }
-  assertNumber(v.type);
-  switch (v.type) {
+  assertNumber(v2.type);
+  switch (v2.type) {
     case LocalDD31:
-      assertLocalMetaDD31(v);
+      assertLocalMetaDD31(v2);
       break;
     case SnapshotDD31:
-      assertSnapshotMetaDD31(v);
+      assertSnapshotMetaDD31(v2);
       break;
     default:
-      throw new Error(`Invalid enum value ${v.type}`);
+      throw new Error(`Invalid enum value ${v2.type}`);
   }
 }
 function chunkIndexDefinitionEqualIgnoreName(a, b) {
   return a.jsonPointer === b.jsonPointer && (a.allowEmpty ?? false) === (b.allowEmpty ?? false) && a.keyPrefix === b.keyPrefix;
 }
-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 assertChunkIndexDefinition(v2) {
+  assertObject(v2);
+  assertDeepFrozen(v2);
+  assertString(v2.name);
+  assertString(v2.keyPrefix);
+  assertString(v2.jsonPointer);
+  if (v2.allowEmpty !== void 0) {
+    assertBoolean(v2.allowEmpty);
   }
 }
 function toChunkIndexDefinition(name, indexDefinition) {
@@ -2531,16 +2727,16 @@ function toChunkIndexDefinition(name, indexDefinition) {
     allowEmpty: indexDefinition.allowEmpty ?? false
   };
 }
-function assertIndexRecord(v) {
-  assertObject(v);
-  assertDeepFrozen(v);
-  assertChunkIndexDefinition(v.definition);
-  assertString(v.valueHash);
+function assertIndexRecord(v2) {
+  assertObject(v2);
+  assertDeepFrozen(v2);
+  assertChunkIndexDefinition(v2.definition);
+  assertString(v2.valueHash);
 }
-function assertIndexRecords(v) {
-  assertArray(v);
-  assertDeepFrozen(v);
-  for (const ir of v) {
+function assertIndexRecords(v2) {
+  assertArray(v2);
+  assertDeepFrozen(v2);
+  for (const ir of v2) {
     assertIndexRecord(ir);
   }
 }
@@ -2614,15 +2810,15 @@ function makeCommitData(meta, valueHash, indexes) {
     indexes
   });
 }
-function assertCommitData(v) {
+function assertCommitData(v2) {
   if (isProd) {
     return;
   }
-  assertObject(v);
-  assertDeepFrozen(v);
-  assertMeta(v.meta);
-  assertString(v.valueHash);
-  assertIndexRecords(v.indexes);
+  assertObject(v2);
+  assertDeepFrozen(v2);
+  assertMeta(v2.meta);
+  assertString(v2.valueHash);
+  assertIndexRecords(v2.indexes);
 }
 function validateChunk(chunk) {
   const { data } = chunk;
@@ -2692,14 +2888,14 @@ function binarySearch2(key, entries) {
 function binarySearchFound(i, entries, key) {
   return i !== entries.length && entries[i][0] === key;
 }
-function parseBTreeNode(v, formatVersion, getSizeOfEntry2) {
+function parseBTreeNode(v2, formatVersion, getSizeOfEntry2) {
   if (isProd && formatVersion >= V7) {
-    return v;
+    return v2;
   }
-  assertArray(v);
-  assertDeepFrozen(v);
-  assert(v.length >= 2);
-  const [level, entries] = v;
+  assertArray(v2);
+  assertDeepFrozen(v2);
+  assert(v2.length >= 2);
+  const [level, entries] = v2;
   assertNumber(level);
   assertArray(entries);
   const f = level > 0 ? assertString : assertJSONValue;
@@ -2707,7 +2903,7 @@ function parseBTreeNode(v, formatVersion, getSizeOfEntry2) {
     for (const e of entries) {
       assertEntry(e, f);
     }
-    return v;
+    return v2;
   }
   const newEntries = entries.map((e) => convertNonV7Entry(e, f, getSizeOfEntry2));
   return [level, newEntries];
@@ -2801,13 +2997,13 @@ var DataNodeImpl = class extends NodeImpl {
     }
   }
 };
-function readonlySplice(array9, start, deleteCount, ...items) {
-  const arr = array9.slice(0, start);
+function readonlySplice(array10, start, deleteCount, ...items) {
+  const arr = array10.slice(0, start);
   for (let i = 0; i < items.length; i++) {
     arr.push(items[i]);
   }
-  for (let i = start + deleteCount; i < array9.length; i++) {
-    arr.push(array9[i]);
+  for (let i = start + deleteCount; i < array10.length; i++) {
+    arr.push(array10[i]);
   }
   return arr;
 }
@@ -3559,8 +3755,8 @@ import { greaterThan } from "compare-utf8";
 // ../replicache/src/async-iterable-to-array.ts
 async function asyncIterableToArray(it) {
   const arr = [];
-  for await (const v of it) {
-    arr.push(v);
+  for await (const v2 of it) {
+    arr.push(v2);
   }
   return arr;
 }
@@ -4502,14 +4698,6 @@ function createLogContext(logLevel = "info", logSinks = [consoleLogSink], contex
   return new LogContext(logLevel, context, logSink);
 }
 
-// ../replicache/src/format-version.ts
-function parseReplicacheFormatVersion(v) {
-  if (v !== (v | 0) || v < SDD || v > Latest) {
-    throw new Error(`Unsupported format version: ${v}`);
-  }
-  return v;
-}
-
 // ../replicache/src/index-defs.ts
 var indexDefinitionSchema = readonlyObject({
   prefix: valita_exports.string().optional(),
@@ -5070,22 +5258,22 @@ function maybeEndPull(store, lc, expectedSyncHead, clientID, diffConfig, formatV
 // ../shared/src/json-schema.ts
 import * as valita from "@badrap/valita";
 var path = [];
-var jsonSchema = valita_exports.unknown().chain((v) => {
+var jsonSchema = valita_exports.unknown().chain((v2) => {
   if (isProd) {
-    return valita.ok(v);
+    return valita.ok(v2);
   }
-  const rv = isJSONValue(v, path) ? valita.ok(v) : valita.err({
+  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((v) => {
+var jsonObjectSchema = valita_exports.unknown().chain((v2) => {
   if (isProd) {
-    return valita.ok(v);
+    return valita.ok(v2);
   }
-  const rv = isJSONObject(v, path) ? valita.ok(v) : valita.err({
+  const rv = isJSONObject(v2, path) ? valita.ok(v2) : valita.err({
     message: `Not a JSON object`,
     path: path.slice()
   });
@@ -5094,18 +5282,18 @@ var jsonObjectSchema = valita_exports.unknown().chain((v) => {
 });
 
 // ../replicache/src/pusher.ts
-function assertPusherResult(v) {
-  assertObject(v);
-  assertHTTPRequestInfo(v.httpRequestInfo);
-  if (v.response !== void 0) {
-    assertPushResponse(v.response);
+function assertPusherResult(v2) {
+  assertObject(v2);
+  assertHTTPRequestInfo(v2.httpRequestInfo);
+  if (v2.response !== void 0) {
+    assertPushResponse(v2.response);
   }
 }
-function assertPushResponse(v) {
-  if (isClientStateNotFoundResponse(v)) {
+function assertPushResponse(v2) {
+  if (isClientStateNotFoundResponse(v2)) {
     return;
   }
-  assertVersionNotSupportedResponse(v);
+  assertVersionNotSupportedResponse(v2);
 }
 var PushError = class extends Error {
   name = "PushError";
@@ -5201,346 +5389,6 @@ async function callPusher(pusher, body, requestID) {
 
 // ../replicache/src/mutation-recovery.ts
 var MUTATION_RECOVERY_LAZY_STORE_SOURCE_CHUNK_CACHE_SIZE_LIMIT = 10 * 2 ** 20;
-var MutationRecovery = class {
-  #recoveringMutations = false;
-  #options;
-  constructor(options) {
-    this.#options = options;
-  }
-  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 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;
-    }
-    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
-    );
-  }
-}
-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 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;
-          }
-        }
-      }
-      clientGroups = newClientGroups;
-    }
-  } 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.`
-    );
-  } 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)
-  );
-}
-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;
-      }
-      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;
-      }
-      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;
-    }
-    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;
-}
 
 // ../replicache/src/broadcast-channel.ts
 var NoopBroadcastChannel = class {
@@ -7281,14 +7129,14 @@ function diffBinarySearch(diff2, prefix, compareKey) {
 }
 
 // ../shared/src/random-values.ts
-function getNonCryptoRandomValues(array9) {
-  if (array9 === null) {
+function getNonCryptoRandomValues(array10) {
+  if (array10 === null) {
     throw new TypeError("array cannot be null");
   }
-  for (let i = 0; i < array9.length; i++) {
-    array9[i] = Math.floor(Math.random() * 256);
+  for (let i = 0; i < array10.length; i++) {
+    array10[i] = Math.floor(Math.random() * 256);
   }
-  return array9;
+  return array10;
 }
 
 // ../replicache/src/sync/request-id.ts
@@ -7568,16 +7416,18 @@ var ReplicacheImpl = class {
     this.#profileIDPromise = profileIDResolver.promise;
     const clientGroupIDResolver = resolver6();
     this.#clientGroupIDPromise = clientGroupIDResolver.promise;
-    this.#mutationRecovery = new MutationRecovery({
-      delegate: this,
-      lc: this.#lc,
-      enableMutationRecovery,
-      wrapInOnlineCheck: this.#wrapInOnlineCheck.bind(this),
-      wrapInReauthRetries: this.#wrapInReauthRetries.bind(this),
-      isPullDisabled: this.#isPullDisabled.bind(this),
-      isPushDisabled: this.#isPushDisabled.bind(this),
-      clientGroupIDPromise: this.#clientGroupIDPromise
-    });
+    if (false) {
+      this.#mutationRecovery = new MutationRecovery({
+        delegate: this,
+        lc: this.#lc,
+        enableMutationRecovery,
+        wrapInOnlineCheck: this.#wrapInOnlineCheck.bind(this),
+        wrapInReauthRetries: this.#wrapInReauthRetries.bind(this),
+        isPullDisabled: this.#isPullDisabled.bind(this),
+        isPushDisabled: this.#isPushDisabled.bind(this),
+        clientGroupIDPromise: this.#clientGroupIDPromise
+      });
+    }
     this.#onPersist = initOnPersistChannel(
       this.name,
       this.#closeAbortController.signal,
@@ -8382,17 +8232,19 @@ var ReplicacheImpl = class {
     return ex;
   }
   recoverMutations() {
-    const result = this.#mutationRecovery.recoverMutations(
-      this.#ready,
-      this.perdag,
-      this.#idbDatabase,
-      this.#idbDatabases,
-      this.#kvStoreProvider.create
-    );
     if (false) {
-      void this.onRecoverMutations(result);
+      const result = this.#mutationRecovery.recoverMutations(
+        this.#ready,
+        this.perdag,
+        this.#idbDatabase,
+        this.#idbDatabases,
+        this.#kvStoreProvider.create
+      );
+      if (false) {
+        void this.onRecoverMutations(result);
+      }
+      return result;
     }
-    return result;
   }
   /**
    * List of pending mutations. The order of this is from oldest to newest.
@@ -8475,9 +8327,9 @@ __export(column_exports, {
   enumeration: () => enumeration,
   json: () => json,
   number: () => number4,
-  string: () => string6
+  string: () => string7
 });
-function string6(optional) {
+function string7(optional) {
   return {
     type: "string",
     optional: optional ?? false,
@@ -8526,8 +8378,8 @@ function isJunctionRelationship(relationship) {
 }
 
 // ../shared/src/sorted-entries.ts
-function sortedEntries(object17) {
-  return Object.entries(object17).sort((a, b) => stringCompare(a[0], b[0]));
+function sortedEntries(object18) {
+  return Object.entries(object18).sort((a, b) => stringCompare(a[0], b[0]));
 }
 
 // ../zero-schema/src/normalize-table-schema.ts
@@ -9187,8 +9039,8 @@ var negateOperatorMap = {
 function negateOperator(op) {
   return must(negateOperatorMap[op]);
 }
-function filterUndefined(array9) {
-  return array9.filter((e) => e !== void 0);
+function filterUndefined(array10) {
+  return array10.filter((e) => e !== void 0);
 }
 function filterTrue(conditions) {
   return conditions.filter((c) => !isAlwaysTrue(c));
@@ -9259,8 +9111,8 @@ function compareValues(a, b) {
   }
   throw new Error(`Unsupported type: ${a}`);
 }
-function normalizeUndefined(v) {
-  return v ?? null;
+function normalizeUndefined(v2) {
+  return v2 ?? null;
 }
 function makeComparator(order, reverse) {
   return (a, b) => {
@@ -9288,8 +9140,8 @@ function* take(stream, limit) {
     return;
   }
   let count = 0;
-  for (const v of stream) {
-    yield v;
+  for (const v2 of stream) {
+    yield v2;
     if (++count === limit) {
       break;
     }
@@ -11490,9 +11342,9 @@ var QueryImpl = class extends AbstractQuery {
     return view;
   }
   run() {
-    const v = this.materialize();
-    const ret = v.data;
-    v.destroy();
+    const v2 = this.materialize();
+    const ret = v2.data;
+    v2.destroy();
     return ret;
   }
   preload() {
@@ -11531,12 +11383,12 @@ function addPrimaryKeysToAst(schema, ast) {
   };
 }
 function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit, queryComplete) {
-  const v = new ArrayView(input, format, queryComplete);
-  v.onDestroy = onDestroy;
+  const v2 = new ArrayView(input, format, queryComplete);
+  v2.onDestroy = onDestroy;
   onTransactionCommit(() => {
-    v.flush();
+    v2.flush();
   });
-  return v;
+  return v2;
 }
 
 // ../zql/src/query/auth-query.ts
@@ -11691,6 +11543,23 @@ function escapeLike(val) {
 import { LogContext as LogContext4 } from "@rocicorp/logger";
 import { resolver as resolver8 } from "@rocicorp/resolver";
 
+// ../zero-protocol/src/error-kind-enum.ts
+var AuthInvalidated = "AuthInvalidated";
+var ClientNotFound = "ClientNotFound";
+var InvalidConnectionRequest = "InvalidConnectionRequest";
+var InvalidConnectionRequestBaseCookie = "InvalidConnectionRequestBaseCookie";
+var InvalidConnectionRequestLastMutationID = "InvalidConnectionRequestLastMutationID";
+var InvalidConnectionRequestClientDeleted = "InvalidConnectionRequestClientDeleted";
+var InvalidMessage = "InvalidMessage";
+var InvalidPush = "InvalidPush";
+var MutationFailed = "MutationFailed";
+var MutationRateLimited = "MutationRateLimited";
+var Unauthorized = "Unauthorized";
+var VersionNotSupported = "VersionNotSupported";
+var SchemaVersionNotSupported = "SchemaVersionNotSupported";
+var ServerOverloaded = "ServerOverloaded";
+var Internal = "Internal";
+
 // ../zero-protocol/src/queries-patch.ts
 var putOpSchema = valita_exports.object({
   op: valita_exports.literal("put"),
@@ -11757,27 +11626,27 @@ function encodeSecProtocols(initConnectionMessage, authToken) {
 
 // ../zero-protocol/src/error.ts
 var errorKindSchema = valita_exports.union(
-  valita_exports.literal("AuthInvalidated" /* AuthInvalidated */),
-  valita_exports.literal("ClientNotFound" /* ClientNotFound */),
-  valita_exports.literal("InvalidConnectionRequest" /* InvalidConnectionRequest */),
-  valita_exports.literal("InvalidConnectionRequestBaseCookie" /* InvalidConnectionRequestBaseCookie */),
-  valita_exports.literal("InvalidConnectionRequestLastMutationID" /* InvalidConnectionRequestLastMutationID */),
-  valita_exports.literal("InvalidConnectionRequestClientDeleted" /* InvalidConnectionRequestClientDeleted */),
-  valita_exports.literal("InvalidMessage" /* InvalidMessage */),
-  valita_exports.literal("InvalidPush" /* InvalidPush */),
-  valita_exports.literal("MutationRateLimited" /* MutationRateLimited */),
-  valita_exports.literal("MutationFailed" /* MutationFailed */),
-  valita_exports.literal("Unauthorized" /* Unauthorized */),
-  valita_exports.literal("VersionNotSupported" /* VersionNotSupported */),
-  valita_exports.literal("SchemaVersionNotSupported" /* SchemaVersionNotSupported */),
-  valita_exports.literal("Internal" /* Internal */)
+  valita_exports.literal(AuthInvalidated),
+  valita_exports.literal(ClientNotFound),
+  valita_exports.literal(InvalidConnectionRequest),
+  valita_exports.literal(InvalidConnectionRequestBaseCookie),
+  valita_exports.literal(InvalidConnectionRequestLastMutationID),
+  valita_exports.literal(InvalidConnectionRequestClientDeleted),
+  valita_exports.literal(InvalidMessage),
+  valita_exports.literal(InvalidPush),
+  valita_exports.literal(MutationRateLimited),
+  valita_exports.literal(MutationFailed),
+  valita_exports.literal(Unauthorized),
+  valita_exports.literal(VersionNotSupported),
+  valita_exports.literal(SchemaVersionNotSupported),
+  valita_exports.literal(Internal)
 );
 var basicErrorBodySchema = valita_exports.object({
   kind: errorKindSchema,
   message: valita_exports.string()
 });
 var serverOverloadedBodySchema = valita_exports.object({
-  kind: valita_exports.literal("ServerOverloaded" /* ServerOverloaded */),
+  kind: valita_exports.literal(ServerOverloaded),
   message: valita_exports.string(),
   minBackoffMs: valita_exports.number().optional()
 });
@@ -11937,6 +11806,10 @@ var downstreamSchema = valita_exports.union(
 var pingBodySchema = valita_exports.object({});
 var pingMessageSchema = valita_exports.tuple([valita_exports.literal("ping"), pingBodySchema]);
 
+// ../zero-protocol/src/mutation-type-enum.ts
+var CRUD = "crud";
+var Custom = "custom";
+
 // ../zero-protocol/src/push.ts
 var CRUD_MUTATION_NAME = "_zero_crud";
 var insertOpSchema = valita_exports.object({
@@ -11976,7 +11849,7 @@ var crudArgSchema = valita_exports.object({
 });
 var crudArgsSchema = valita_exports.tuple([crudArgSchema]);
 var crudMutationSchema = valita_exports.object({
-  type: valita_exports.literal("crud" /* CRUD */),
+  type: valita_exports.literal(CRUD),
   id: valita_exports.number(),
   clientID: valita_exports.string(),
   name: valita_exports.literal(CRUD_MUTATION_NAME),
@@ -11984,7 +11857,7 @@ var crudMutationSchema = valita_exports.object({
   timestamp: valita_exports.number()
 });
 var customMutationSchema = valita_exports.object({
-  type: valita_exports.literal("custom" /* Custom */),
+  type: valita_exports.literal(Custom),
   id: valita_exports.number(),
   clientID: valita_exports.string(),
   name: valita_exports.string(),
@@ -12049,6 +11922,11 @@ function send(ws, data) {
   ws.send(JSON.stringify(data));
 }
 
+// ../zero-client/src/client/connection-state-enum.ts
+var Disconnected = 0;
+var Connecting = 1;
+var Connected = 2;
+
 // ../btree/b+tree.ts
 function defaultComparator(a, b) {
   if (Number.isFinite(a) && Number.isFinite(b)) {
@@ -12137,7 +12015,7 @@ var BTree = class _BTree {
   forEach(callback, thisArg) {
     if (thisArg !== void 0)
       callback = callback.bind(thisArg);
-    return this.forEachPair((k, v) => callback(v, k, this));
+    return this.forEachPair((k, v2) => callback(v2, 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
@@ -12262,8 +12140,8 @@ var BTree = class _BTree {
   filter(callback, returnThisIfUnchanged) {
     var nu = this.greedyClone();
     var del;
-    nu.editAll((k, v, i) => {
-      if (!callback(k, v, i))
+    nu.editAll((k, v2, i) => {
+      if (!callback(k, v2, i))
         return del = Delete;
       return void 0;
     });
@@ -12275,8 +12153,8 @@ var BTree = class _BTree {
   mapValues(callback) {
     var tmp = {};
     var nu = this.greedyClone();
-    nu.editAll((k, v, i) => {
-      return tmp.value = callback(v, k, i), tmp;
+    nu.editAll((k, v2, i) => {
+      return tmp.value = callback(v2, k, i), tmp;
     });
     return nu;
   }
@@ -12748,8 +12626,8 @@ var BTree = class _BTree {
       false,
       this,
       0,
-      (_k, v) => {
-        results.push(v);
+      (_k, v2) => {
+        results.push(v2);
       }
     );
     return results;
@@ -12864,8 +12742,8 @@ var BTree = class _BTree {
    */
   getRange(low, high, includeHigh, maxLength = 67108863) {
     var results = [];
-    this._root.forRange(low, high, includeHigh, false, this, 0, (k, v) => {
-      results.push([k, v]);
+    this._root.forRange(low, high, includeHigh, false, this, 0, (k, v2) => {
+      results.push([k, v2]);
       return results.length > maxLength ? Break : void 0;
     });
     return results;
@@ -13126,10 +13004,10 @@ var BNode = class _BNode {
     return reusedArray;
   }
   clone() {
-    var v = this.values;
+    var v2 = this.values;
     return new _BNode(
       this.keys.slice(0),
-      v === undefVals ? v : v.slice(0)
+      v2 === undefVals ? v2 : v2.slice(0)
     );
   }
   greedyClone(force) {
@@ -13229,24 +13107,24 @@ var BNode = class _BNode {
     return true;
   }
   takeFromRight(rhs) {
-    var v = this.values;
+    var v2 = this.values;
     if (rhs.values === undefVals) {
-      if (v !== undefVals)
-        v.push(void 0);
+      if (v2 !== undefVals)
+        v2.push(void 0);
     } else {
-      v = this.reifyValues();
-      v.push(rhs.values.shift());
+      v2 = this.reifyValues();
+      v2.push(rhs.values.shift());
     }
     this.keys.push(rhs.keys.shift());
   }
   takeFromLeft(lhs) {
-    var v = this.values;
+    var v2 = this.values;
     if (lhs.values === undefVals) {
-      if (v !== undefVals)
-        v.unshift(void 0);
+      if (v2 !== undefVals)
+        v2.unshift(void 0);
     } else {
-      v = this.reifyValues();
-      v.unshift(lhs.values.pop());
+      v2 = this.reifyValues();
+      v2.unshift(lhs.values.pop());
     }
     this.keys.unshift(lhs.keys.pop());
   }
@@ -14719,7 +14597,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.10.2025011100+4a1fd2";
+var version2 = "0.11.2025011401+3a8f35";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14775,6 +14653,14 @@ function createLogOptions(options, createDatadogLogSink = (options2) => new Data
   };
 }
 
+// ../zero-client/src/client/metric-name-enum.ts
+var TimeToConnectMs = "time_to_connect_ms";
+var LastConnectError = "last_connect_error";
+var TimeToConnectMsV2 = "time_to_connect_ms_v2";
+var LastConnectErrorV2 = "last_connect_error_v2";
+var TotalTimeToConnectMs = "total_time_to_connect_ms";
+var NotConnected = "not_connected";
+
 // ../zero-client/src/client/metrics.ts
 var DID_NOT_CONNECT_VALUE = 100 * 1e3;
 var REPORT_INTERVAL_MS = 5e3;
@@ -14826,7 +14712,7 @@ var MetricManager = class {
   // be encapsulated with the ConnectionState. This will probably happen as part
   // of https://github.com/rocicorp/reflect-server/issues/255.
   timeToConnectMs = this.#register(
-    new Gauge("time_to_connect_ms" /* TimeToConnectMs */)
+    new Gauge(TimeToConnectMs)
   );
   // lastConnectError records the last error that occurred when connecting,
   // if any. It is cleared when connecting successfully or when reported, so this
@@ -14834,28 +14720,28 @@ var MetricManager = class {
   // we are still not connected.
   lastConnectError = this.#register(
     new State(
-      "last_connect_error" /* LastConnectError */,
+      LastConnectError,
       true
       // clearOnFlush
     )
   );
   // notConnected records the reason why the client is not currently connected.
   // It is cleared when the client successfully connects.
-  #notConnected = this.#register(new State("not_connected" /* NotConnected */));
+  #notConnected = this.#register(new State(NotConnected));
   // The time from the call to connect() to receiving the 'connected' ws message
   // for the current connection.  Cleared when the client is not connected.
   // TODO: Not actually currently cleared on disconnect untill there is a
   // connect error, or client reports disconnected and waiting for visible.
   // Should have a value iff _notConnected has no value.
   #timeToConnectMsV2 = this.#register(
-    new Gauge("time_to_connect_ms_v2" /* TimeToConnectMsV2 */)
+    new Gauge(TimeToConnectMsV2)
   );
   // lastConnectErrorV2 records the last error that occurred when connecting,
   // if any. It is cleared when the client successfully connects or
   // stops trying to connect due to being hidden.
   // Should have a value iff notConnected state is NotConnectedReason.Error.
   #lastConnectErrorV2 = this.#register(
-    new State("last_connect_error_v2" /* LastConnectErrorV2 */)
+    new State(LastConnectErrorV2)
   );
   // The total time it took to connect across retries for the current
   // connection.  Cleared when the client is not connected.
@@ -14864,7 +14750,7 @@ var MetricManager = class {
   // See Zero.#totalToConnectStart for details of how this total is computed.
   // Should have a value iff _notConnected has no value.
   #totalTimeToConnectMs = this.#register(
-    new Gauge("total_time_to_connect_ms" /* TotalTimeToConnectMs */)
+    new Gauge(TotalTimeToConnectMs)
   );
   #setNotConnectedReason(reason) {
     this.#notConnected.set(reason);
@@ -15005,6 +14891,10 @@ var State = class {
   }
 };
 
+// ../zero-client/src/client/ping-result-enum.ts
+var TimedOut = 0;
+var Success = 1;
+
 // ../zero-client/src/client/query-manager.ts
 var QueryManager = class {
   #clientID;
@@ -15259,10 +15149,10 @@ function isAuthError(ex) {
   return isServerError(ex) && isAuthErrorKind(ex.kind);
 }
 function isAuthErrorKind(kind) {
-  return kind === "AuthInvalidated" /* AuthInvalidated */ || kind === "Unauthorized" /* Unauthorized */;
+  return kind === AuthInvalidated || kind === Unauthorized;
 }
 function isServerOverloadedError(ex) {
-  return isServerError(ex) && ex.errorBody.kind === "ServerOverloaded" /* ServerOverloaded */ ? ex.errorBody : void 0;
+  return isServerError(ex) && ex.errorBody.kind === ServerOverloaded ? ex.errorBody : void 0;
 }
 
 // ../zero-client/src/client/server-option.ts
@@ -15698,7 +15588,7 @@ var Zero = class {
   #closeAbortController = new AbortController();
   #visibilityWatcher;
   // We use an accessor pair to allow the subclass to override the setter.
-  #connectionState = 0 /* Disconnected */;
+  #connectionState = Disconnected;
   #setConnectionState(state) {
     if (state === this.#connectionState) {
       return;
@@ -15884,7 +15774,7 @@ var Zero = class {
     }
   }
   #sendChangeDesiredQueries(msg) {
-    if (this.#socket && this.#connectionState === 2 /* Connected */) {
+    if (this.#socket && this.#connectionState === Connected) {
       send(this.#socket, msg);
     }
   }
@@ -15981,7 +15871,7 @@ var Zero = class {
    */
   close() {
     const lc = this.#lc.withContext("close");
-    if (this.#connectionState !== 0 /* Disconnected */) {
+    if (this.#connectionState !== Disconnected) {
       this.#disconnect(lc, {
         client: "ClientClosed"
       });
@@ -16062,7 +15952,7 @@ var Zero = class {
   // An error on the connection is fatal for the connection.
   async #handleErrorMessage(lc, downMessage) {
     const [, { kind, message }] = downMessage;
-    if (kind === "MutationRateLimited" /* MutationRateLimited */) {
+    if (kind === MutationRateLimited) {
       this.#lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
       lc.error?.("Mutation rate limited", { message });
       return;
@@ -16073,15 +15963,15 @@ var Zero = class {
     lc.debug?.("Rejecting connect resolver due to error", error);
     this.#connectResolver.reject(error);
     this.#disconnect(lc, { server: kind });
-    if (kind === "VersionNotSupported" /* VersionNotSupported */) {
+    if (kind === VersionNotSupported) {
       this.#onUpdateNeeded?.({ type: kind }, message);
-    } else if (kind === "SchemaVersionNotSupported" /* SchemaVersionNotSupported */) {
+    } else if (kind === SchemaVersionNotSupported) {
       await this.#rep.disableClientGroup();
       this.#onUpdateNeeded?.({ type: "SchemaVersionNotSupported" }, message);
-    } else if (kind === "ClientNotFound" /* ClientNotFound */) {
+    } else if (kind === ClientNotFound) {
       await this.#rep.disableClientGroup();
       this.#onClientStateNotFound?.(onClientStateNotFoundServerReason(message));
-    } else if (kind === "InvalidConnectionRequestLastMutationID" /* InvalidConnectionRequestLastMutationID */ || kind === "InvalidConnectionRequestBaseCookie" /* InvalidConnectionRequestBaseCookie */) {
+    } else if (kind === InvalidConnectionRequestLastMutationID || kind === InvalidConnectionRequestBaseCookie) {
       await dropDatabase(this.#rep.idbName);
       reloadWithReason(lc, this.#reload, serverAheadReloadReason(kind));
     }
@@ -16152,7 +16042,7 @@ var Zero = class {
       ]);
     }
     this.#initConnectionQueries = void 0;
-    this.#setConnectionState(2 /* Connected */);
+    this.#setConnectionState(Connected);
     this.#connectResolver.resolve();
   }
   /**
@@ -16173,11 +16063,11 @@ var Zero = class {
    */
   async #connect(l) {
     assert(this.#server);
-    assert(this.#connectionState === 0 /* Disconnected */);
+    assert(this.#connectionState === Disconnected);
     const wsid = nanoid();
     l = addWebSocketIDToLogContext(wsid, l);
     l.info?.("Connecting...", { navigatorOnline: localNavigator?.onLine });
-    this.#setConnectionState(1 /* Connecting */);
+    this.#setConnectionState(Connecting);
     assert(this.#connectStart === void 0);
     const now = Date.now();
     this.#connectStart = now;
@@ -16242,7 +16132,7 @@ var Zero = class {
     }
   }
   #disconnect(l, reason) {
-    if (this.#connectionState === 1 /* Connecting */) {
+    if (this.#connectionState === Connecting) {
       this.#connectErrorCount++;
     }
     l.info?.("disconnecting", {
@@ -16257,7 +16147,7 @@ var Zero = class {
       connectErrorCount: this.#connectErrorCount
     });
     switch (this.#connectionState) {
-      case 2 /* Connected */: {
+      case Connected: {
         if (this.#connectStart !== void 0) {
           l.error?.(
             "disconnect() called while connected but connect start time is defined. This should not happen."
@@ -16265,7 +16155,7 @@ var Zero = class {
         }
         break;
       }
-      case 1 /* Connecting */: {
+      case Connecting: {
         this.#metrics.lastConnectError.set(getLastConnectErrorValue(reason));
         this.#metrics.timeToConnectMs.set(DID_NOT_CONNECT_VALUE);
         this.#metrics.setConnectError(reason);
@@ -16281,14 +16171,14 @@ var Zero = class {
         }
         break;
       }
-      case 0 /* Disconnected */:
+      case Disconnected:
         l.error?.("disconnect() called while disconnected");
         break;
     }
     this.#socketResolver = resolver8();
     l.debug?.("Creating new connect resolver");
     this.#connectResolver = resolver8();
-    this.#setConnectionState(0 /* Disconnected */);
+    this.#setConnectionState(Disconnected);
     this.#messageCount = 0;
     this.#connectStart = void 0;
     this.#connectedAt = 0;
@@ -16322,9 +16212,9 @@ var Zero = class {
     const lc = this.#lc;
     lc.info?.(
       "poke error, disconnecting?",
-      this.#connectionState !== 0 /* Disconnected */
+      this.#connectionState !== Disconnected
     );
-    if (this.#connectionState !== 0 /* Disconnected */) {
+    if (this.#connectionState !== Disconnected) {
       this.#disconnect(lc, {
         client: "UnexpectedBaseCookie"
       });
@@ -16365,14 +16255,14 @@ var Zero = class {
       const m = req.mutations[i];
       const timestamp = now - Math.round(performance.now() - m.timestamp);
       const zeroM = m.name === CRUD_MUTATION_NAME ? {
-        type: "crud" /* CRUD */,
+        type: CRUD,
         timestamp,
         id: m.id,
         clientID: m.clientID,
         name: m.name,
         args: [m.args]
       } : {
-        type: "custom" /* Custom */,
+        type: Custom,
         timestamp,
         id: m.id,
         clientID: m.clientID,
@@ -16436,7 +16326,7 @@ var Zero = class {
       backoffMs = RUN_LOOP_INTERVAL_MS;
       try {
         switch (this.#connectionState) {
-          case 0 /* Disconnected */: {
+          case Disconnected: {
             if (this.#visibilityWatcher.visibilityState === "hidden") {
               this.#metrics.setDisconnectedWaitingForVisible();
               this.#totalToConnectStart = void 0;
@@ -16460,11 +16350,11 @@ var Zero = class {
             this.#setOnline(true);
             break;
           }
-          case 1 /* Connecting */:
+          case Connecting:
             lc.error?.("unreachable");
             gotError = true;
             break;
-          case 2 /* Connected */: {
+          case Connected: {
             const controller = new AbortController();
             this.#abortPingTimeout = () => controller.abort();
             const [pingTimeoutPromise, pingTimeoutAborted] = sleepWithAbort(
@@ -16472,11 +16362,8 @@ var Zero = class {
               controller.signal
             );
             this.#rejectMessageError = resolver8();
-            let RaceCases;
-            ((RaceCases2) => {
-              RaceCases2[RaceCases2["Ping"] = 0] = "Ping";
-              RaceCases2[RaceCases2["Hidden"] = 2] = "Hidden";
-            })(RaceCases || (RaceCases = {}));
+            const PING = 0;
+            const HIDDEN = 2;
             const raceResult = await promiseRace([
               pingTimeoutPromise,
               pingTimeoutAborted,
@@ -16489,17 +16376,17 @@ var Zero = class {
               break;
             }
             switch (raceResult) {
-              case 0 /* Ping */: {
+              case PING: {
                 const pingResult = await this.#ping(
                   lc,
                   this.#rejectMessageError.promise
                 );
-                if (pingResult === 0 /* TimedOut */) {
+                if (pingResult === TimedOut) {
                   gotError = true;
                 }
                 break;
               }
-              case 2 /* Hidden */:
+              case HIDDEN:
                 this.#disconnect(lc, {
                   client: "Hidden"
                 });
@@ -16510,7 +16397,7 @@ var Zero = class {
           }
         }
       } catch (ex) {
-        if (this.#connectionState !== 2 /* Connected */) {
+        if (this.#connectionState !== Connected) {
           lc.error?.("Failed to connect", ex, {
             lmid: this.#lastMutationIDReceived,
             baseCookie: this.#connectCookie
@@ -16579,20 +16466,17 @@ var Zero = class {
     const pullResponseResolver = resolver8();
     this.#pendingPullsByRequestID.set(requestID, pullResponseResolver);
     try {
-      let RaceCases;
-      ((RaceCases2) => {
-        RaceCases2[RaceCases2["Timeout"] = 0] = "Timeout";
-        RaceCases2[RaceCases2["Response"] = 1] = "Response";
-      })(RaceCases || (RaceCases = {}));
+      const TIMEOUT = 0;
+      const RESPONSE = 1;
       const raceResult = await promiseRace([
         sleep(PULL_TIMEOUT_MS),
         pullResponseResolver.promise
       ]);
       switch (raceResult) {
-        case 0 /* Timeout */:
+        case TIMEOUT:
           lc.debug?.("Mutation recovery pull timed out");
           throw new Error("Pull timed out");
-        case 1 /* Response */: {
+        case RESPONSE: {
           lc.debug?.("Returning mutation recovery pull response");
           const response = await pullResponseResolver.promise;
           return {
@@ -16654,10 +16538,10 @@ var Zero = class {
       this.#disconnect(l, {
         client: "PingTimeout"
       });
-      return 0 /* TimedOut */;
+      return TimedOut;
     }
     l.debug?.("ping succeeded in", delta, "ms");
-    return 1 /* Success */;
+    return Success;
   }
   // Sends a set of metrics to the server. Throws unless the server
   // returns 200.
@@ -16750,4 +16634,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-FEVIDCUL.js.map
+//# sourceMappingURL=chunk-JWWOECJ3.js.map