@rocicorp/zero 0.19.2025040901 → 0.19.2025041100

package/out/{chunk-JW7AJ755.js → chunk-GTRWLUIW.js}

@@ -1,13 +1,8 @@
 import {
-  DEFAULT_TTL,
-  hasOwn
-} from "./chunk-MB3DEFRC.js";
-import {
+  __export,
+  __reExport,
   applyChange,
   assert,
-  assertArray,
-  assertBoolean,
-  assertNumber,
   assertObject,
   assertString,
   compareValues,
@@ -17,11 +12,7 @@ import {
   throwInvalidType,
   unreachable,
   valuesEqual
-} from "./chunk-2NCGIK6G.js";
-import {
-  __export,
-  __reExport
-} from "./chunk-424PT5DM.js";
+} from "./chunk-SKR5JO2A.js";
 
 // ../shared/src/valita.ts
 var valita_exports = {};
@@ -232,33 +223,101 @@ function deepPartial(s) {
   return v.object(shape);
 }
 
-// ../replicache/src/dag/store.ts
-var ChunkNotFoundError = class extends Error {
-  name = "ChunkNotFoundError";
-  hash;
-  constructor(hash2) {
-    super(`Chunk not found ${hash2}`);
-    this.hash = hash2;
-  }
+// ../zql/src/query/ttl.ts
+var DEFAULT_TTL = "none";
+var multiplier = {
+  s: 1e3,
+  m: 60 * 1e3,
+  h: 60 * 60 * 1e3,
+  d: 24 * 60 * 60 * 1e3,
+  y: 365 * 24 * 60 * 60 * 1e3
 };
-async function mustGetChunk(store, hash2) {
-  const chunk = await store.getChunk(hash2);
-  if (chunk) {
-    return chunk;
+function parseTTL(ttl) {
+  if (typeof ttl === "number") {
+    return Number.isNaN(ttl) ? 0 : !Number.isFinite(ttl) || ttl < 0 ? -1 : ttl;
+  }
+  if (ttl === "none") {
+    return 0;
+  }
+  if (ttl === "forever") {
+    return -1;
+  }
+  const multi = multiplier[ttl[ttl.length - 1]];
+  return Number(ttl.slice(0, -1)) * multi;
+}
+function compareTTL(a, b) {
+  const ap = parseTTL(a);
+  const bp = parseTTL(b);
+  if (ap === -1 && bp !== -1) {
+    return 1;
+  }
+  if (ap !== -1 && bp === -1) {
+    return -1;
+  }
+  return ap - bp;
+}
+function normalizeTTL(ttl) {
+  if (typeof ttl === "string") {
+    return ttl;
+  }
+  if (ttl < 0) {
+    return "forever";
+  }
+  if (ttl === 0) {
+    return "none";
+  }
+  let shortest = ttl.toString();
+  const lengthOfNumber = shortest.length;
+  for (const unit of ["y", "d", "h", "m", "s"]) {
+    const multi = multiplier[unit];
+    const value = ttl / multi;
+    const candidate = `${value}${unit}`;
+    if (candidate.length < shortest.length) {
+      shortest = candidate;
+    }
   }
-  throw new ChunkNotFoundError(hash2);
+  return shortest.length < lengthOfNumber ? shortest : ttl;
 }
-async function mustGetHeadHash(name, store) {
-  const hash2 = await store.getHead(name);
-  assert(hash2, `Missing head ${name}`);
+
+// ../shared/src/has-own.ts
+var { hasOwn } = Object;
+
+// ../shared/src/hash.ts
+import { xxHash32 } from "js-xxhash";
+var h64 = (s) => hash(s, 2);
+var h128 = (s) => hash(s, 4);
+function hash(str, words) {
+  let hash2 = 0n;
+  for (let i = 0; i < words; i++) {
+    hash2 = (hash2 << 32n) + BigInt(xxHash32(str, i));
+  }
   return hash2;
 }
 
-// ../replicache/src/format-version-enum.ts
-var DD31 = 5;
-var V6 = 6;
-var V7 = 7;
-var Latest = V7;
+// ../zero-protocol/src/ast.ts
+import { compareUTF8 } from "compare-utf8";
+
+// ../shared/src/arrays.ts
+function defined(arr) {
+  let i = arr.findIndex((x) => x === void 0);
+  if (i < 0) {
+    return arr;
+  }
+  const defined2 = arr.slice(0, i);
+  for (i++; i < arr.length; i++) {
+    const x = arr[i];
+    if (x !== void 0) {
+      defined2.push(x);
+    }
+  }
+  return defined2;
+}
+function areEqual(arr1, arr2) {
+  return arr1.length === arr2.length && arr1.every((e, i) => e === arr2[i]);
+}
+
+// ../shared/src/json-schema.ts
+import * as valita from "@badrap/valita";
 
 // ../shared/src/config.ts
 var isProd = process.env.NODE_ENV === "production";
@@ -298,2812 +357,112 @@ function deepEqual(a, b) {
   if (Array.isArray(b)) {
     return false;
   }
-  a = a;
-  b = b;
-  let aSize = 0;
-  for (const key in a) {
-    if (hasOwn(a, key)) {
-      if (!deepEqual(a[key], b[key])) {
-        return false;
-      }
-      aSize++;
-    }
-  }
-  let bSize = 0;
-  for (const key in b) {
-    if (hasOwn(b, key)) {
-      bSize++;
-    }
-  }
-  return aSize === bSize;
-}
-function assertJSONValue(v2) {
-  if (isProd) {
-    return;
-  }
-  switch (typeof v2) {
-    case "boolean":
-    case "number":
-    case "string":
-      return;
-    case "object":
-      if (v2 === null) {
-        return;
-      }
-      if (Array.isArray(v2)) {
-        return assertJSONArray(v2);
-      }
-      return assertObjectIsJSONObject(v2);
-  }
-  throwInvalidType(v2, "JSON value");
-}
-function assertJSONObject(v2) {
-  assertObject(v2);
-  assertObjectIsJSONObject(v2);
-}
-function assertObjectIsJSONObject(v2) {
-  for (const k in v2) {
-    if (hasOwn(v2, k)) {
-      const value = v2[k];
-      if (value !== void 0) {
-        assertJSONValue(value);
-      }
-    }
-  }
-}
-function assertJSONArray(v2) {
-  for (const item of v2) {
-    assertJSONValue(item);
-  }
-}
-function isJSONValue(v2, path2) {
-  switch (typeof v2) {
-    case "boolean":
-    case "number":
-    case "string":
-      return true;
-    case "object":
-      if (v2 === null) {
-        return true;
-      }
-      if (Array.isArray(v2)) {
-        return isJSONArray(v2, path2);
-      }
-      return objectIsJSONObject(v2, path2);
-  }
-  return false;
-}
-function isJSONObject(v2, path2) {
-  if (typeof v2 !== "object" || v2 === null) {
-    return false;
-  }
-  return objectIsJSONObject(v2, path2);
-}
-function objectIsJSONObject(v2, path2) {
-  for (const k in v2) {
-    if (hasOwn(v2, k)) {
-      path2.push(k);
-      const value = v2[k];
-      if (value !== void 0 && !isJSONValue(value, path2)) {
-        return false;
-      }
-      path2.pop();
-    }
-  }
-  return true;
-}
-function isJSONArray(v2, path2) {
-  for (let i = 0; i < v2.length; i++) {
-    path2.push(i);
-    if (!isJSONValue(v2[i], path2)) {
-      return false;
-    }
-    path2.pop();
-  }
-  return true;
-}
-
-// ../shared/src/random-uint64.ts
-function randomUint64() {
-  const high = Math.floor(Math.random() * 4294967295);
-  const low = Math.floor(Math.random() * 4294967295);
-  return BigInt(high) << 32n | BigInt(low);
-}
-
-// ../replicache/src/hash.ts
-var STRING_LENGTH = 22;
-var hashRe = /^[0-9a-v-]+$/;
-var emptyUUID = "0".repeat(STRING_LENGTH);
-var emptyHash = emptyUUID;
-var newRandomHash = makeNewRandomHashFunctionInternal();
-function toStringAndSlice(n, len) {
-  return n.toString(32).slice(-len).padStart(len, "0");
-}
-function makeNewRandomHashFunctionInternal() {
-  let base = "";
-  let i = 0;
-  return () => {
-    if (!base) {
-      base = toStringAndSlice(randomUint64(), 12);
-    }
-    const tail = toStringAndSlice(i++, 10);
-    return base + tail;
-  };
-}
-function isHash(value) {
-  return typeof value === "string" && hashRe.test(value);
-}
-function assertHash(value) {
-  assert2(value, hashSchema);
-}
-var hashSchema = valita_exports.string().assert(isHash, "Invalid hash");
-
-// ../replicache/src/size-of-value.ts
-var SIZE_TAG = 1;
-var SIZE_INT32 = 4;
-var SIZE_SMI = 5;
-var SIZE_DOUBLE = 8;
-function getSizeOfValue(value) {
-  switch (typeof value) {
-    case "string":
-      return SIZE_TAG + SIZE_INT32 + value.length;
-    case "number":
-      if (isSmi(value)) {
-        if (value <= -(2 ** 30) || value >= 2 ** 30 - 1) {
-          return SIZE_TAG + SIZE_SMI;
-        }
-        return SIZE_TAG + SIZE_INT32;
-      }
-      return SIZE_TAG + SIZE_DOUBLE;
-    case "boolean":
-      return SIZE_TAG;
-    case "object":
-      if (value === null) {
-        return SIZE_TAG;
-      }
-      if (Array.isArray(value)) {
-        let sum = 2 * SIZE_TAG + SIZE_INT32;
-        for (const element of value) {
-          sum += getSizeOfValue(element);
-        }
-        return sum;
-      }
-      {
-        const val = value;
-        let sum = 2 * SIZE_TAG + SIZE_INT32;
-        for (const k in val) {
-          if (hasOwn(val, k)) {
-            const propertyValue = val[k];
-            if (propertyValue !== void 0) {
-              sum += getSizeOfValue(k) + getSizeOfValue(propertyValue);
-            }
-          }
-        }
-        return sum;
-      }
-  }
-  throw new Error(`Invalid value. type: ${typeof value}, value: ${value}`);
-}
-function isSmi(value) {
-  return value === (value | 0);
-}
-var entryFixed = 2 * SIZE_TAG + SIZE_INT32 + SIZE_TAG + SIZE_INT32;
-function getSizeOfEntry(key, value) {
-  return entryFixed + getSizeOfValue(key) + getSizeOfValue(value);
-}
-
-// ../replicache/src/btree/node.ts
-import { compareUTF8 } from "compare-utf8";
-
-// ../shared/src/iterables.ts
-function* joinIterables(...iters) {
-  for (const iter of iters) {
-    yield* iter;
-  }
-}
-function* filterIter(iter, p) {
-  let index = 0;
-  for (const t of iter) {
-    if (p(t, index++)) {
-      yield t;
-    }
-  }
-}
-function* mapIter(iter, f) {
-  let index = 0;
-  for (const t of iter) {
-    yield f(t, index++);
-  }
-}
-var IterWrapper = class _IterWrapper {
-  iter;
-  constructor(iter) {
-    this.iter = iter;
-  }
-  [Symbol.iterator]() {
-    return this.iter[Symbol.iterator]();
-  }
-  map(f) {
-    return new _IterWrapper(mapIter(this.iter, f));
-  }
-  filter(p) {
-    return new _IterWrapper(filterIter(this.iter, p));
-  }
-};
-function wrapIterable(iter) {
-  return new IterWrapper(iter);
-}
-function* mergeIterables(iterables, comparator, distinct = false) {
-  const iterators = iterables.map((i) => i[Symbol.iterator]());
-  try {
-    const current = iterators.map((i) => i.next());
-    let lastYielded;
-    while (current.some((c) => !c.done)) {
-      const min = current.reduce(
-        (acc, c, i) => {
-          if (c.done) {
-            return acc;
-          }
-          if (acc === void 0 || comparator(c.value, acc[0]) < 0) {
-            return [c.value, i];
-          }
-          return acc;
-        },
-        void 0
-      );
-      assert(min !== void 0, "min is undefined");
-      current[min[1]] = iterators[min[1]].next();
-      if (lastYielded !== void 0 && distinct && comparator(lastYielded, min[0]) === 0) {
-        continue;
-      }
-      lastYielded = min[0];
-      yield min[0];
-    }
-  } finally {
-    for (const it of iterators) {
-      it.return?.();
-    }
-  }
-}
-
-// ../replicache/src/binary-search.ts
-function binarySearch(high, compare) {
-  let low = 0;
-  while (low < high) {
-    const mid = low + (high - low >> 1);
-    const i = compare(mid);
-    if (i === 0) {
-      return mid;
-    }
-    if (i > 0) {
-      low = mid + 1;
-    } else {
-      high = mid;
-    }
-  }
-  return low;
-}
-
-// ../replicache/src/frozen-json.ts
-var deepFrozenObjects = /* @__PURE__ */ new WeakSet();
-function deepFreeze(v2) {
-  if (isProd) {
-    return v2;
-  }
-  deepFreezeInternal(v2, []);
-  return v2;
-}
-function deepFreezeInternal(v2, seen) {
-  switch (typeof v2) {
-    case "undefined":
-      throw new TypeError("Unexpected value undefined");
-    case "boolean":
-    case "number":
-    case "string":
-      return;
-    case "object": {
-      if (v2 === null) {
-        return;
-      }
-      if (deepFrozenObjects.has(v2)) {
-        return;
-      }
-      deepFrozenObjects.add(v2);
-      if (seen.includes(v2)) {
-        throwInvalidType(v2, "Cyclic JSON object");
-      }
-      seen.push(v2);
-      Object.freeze(v2);
-      if (Array.isArray(v2)) {
-        deepFreezeArray(v2, seen);
-      } else {
-        deepFreezeObject(v2, seen);
-      }
-      seen.pop();
-      return;
-    }
-    default:
-      throwInvalidType(v2, "JSON value");
-  }
-}
-function deepFreezeArray(v2, seen) {
-  for (const item of v2) {
-    deepFreezeInternal(item, seen);
-  }
-}
-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(v2) {
-  if (isProd) {
-    return;
-  }
-  if (!isDeepFrozen(v2, [])) {
-    throw new Error("Expected frozen object");
-  }
-}
-function isDeepFrozen(v2, seen) {
-  switch (typeof v2) {
-    case "boolean":
-    case "number":
-    case "string":
-      return true;
-    case "object":
-      if (v2 === null) {
-        return true;
-      }
-      if (deepFrozenObjects.has(v2)) {
-        return true;
-      }
-      if (!Object.isFrozen(v2)) {
-        return false;
-      }
-      if (seen.includes(v2)) {
-        throwInvalidType(v2, "Cyclic JSON object");
-      }
-      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 v2) {
-          if (hasOwn(v2, k)) {
-            const value = v2[k];
-            if (value !== void 0 && !isDeepFrozen(value, seen)) {
-              seen.pop();
-              return false;
-            }
-          }
-        }
-      }
-      deepFrozenObjects.add(v2);
-      seen.pop();
-      return true;
-    default:
-      throwInvalidType(v2, "JSON value");
-  }
-}
-function deepFreezeAllowUndefined(v2) {
-  if (v2 === void 0) {
-    return void 0;
-  }
-  return deepFreeze(v2);
-}
-
-// ../replicache/src/btree/node.ts
-var NODE_LEVEL = 0;
-var NODE_ENTRIES = 1;
-function makeNodeChunkData(level, entries, formatVersion) {
-  return deepFreeze([
-    level,
-    formatVersion >= V7 ? entries : entries.map((e) => e.slice(0, 2))
-  ]);
-}
-async function findLeaf(key, hash2, source, expectedRootHash) {
-  const node = await source.getNode(hash2);
-  if (expectedRootHash !== source.rootHash) {
-    return findLeaf(key, source.rootHash, source, source.rootHash);
-  }
-  if (isDataNodeImpl(node)) {
-    return node;
-  }
-  const { entries } = node;
-  let i = binarySearch2(key, entries);
-  if (i === entries.length) {
-    i--;
-  }
-  const entry = entries[i];
-  return findLeaf(key, entry[1], source, expectedRootHash);
-}
-function binarySearch2(key, entries) {
-  return binarySearch(
-    entries.length,
-    (i) => compareUTF8(key, entries[i][0])
-  );
-}
-function binarySearchFound(i, entries, key) {
-  return i !== entries.length && entries[i][0] === key;
-}
-function parseBTreeNode(v2, formatVersion, getSizeOfEntry2) {
-  if (isProd && formatVersion >= V7) {
-    return v2;
-  }
-  assertArray(v2);
-  assertDeepFrozen(v2);
-  assert(v2.length >= 2);
-  const [level, entries] = v2;
-  assertNumber(level);
-  assertArray(entries);
-  const f = level > 0 ? assertString : assertJSONValue;
-  if (formatVersion >= V7) {
-    for (const e of entries) {
-      assertEntry(e, f);
-    }
-    return v2;
-  }
-  const newEntries = entries.map((e) => convertNonV7Entry(e, f, getSizeOfEntry2));
-  return [level, newEntries];
-}
-function assertEntry(entry, f) {
-  assertArray(entry);
-  assert(entry.length >= 3);
-  assertString(entry[0]);
-  f(entry[1]);
-  assertNumber(entry[2]);
-}
-function convertNonV7Entry(entry, f, getSizeOfEntry2) {
-  assertArray(entry);
-  assert(entry.length >= 2);
-  assertString(entry[0]);
-  f(entry[1]);
-  const entrySize = getSizeOfEntry2(entry[0], entry[1]);
-  return [entry[0], entry[1], entrySize];
-}
-var NodeImpl = class {
-  entries;
-  hash;
-  isMutable;
-  #childNodeSize = -1;
-  constructor(entries, hash2, isMutable) {
-    this.entries = entries;
-    this.hash = hash2;
-    this.isMutable = isMutable;
-  }
-  maxKey() {
-    return this.entries[this.entries.length - 1][0];
-  }
-  getChildNodeSize(tree) {
-    if (this.#childNodeSize !== -1) {
-      return this.#childNodeSize;
-    }
-    let sum = tree.chunkHeaderSize;
-    for (const entry of this.entries) {
-      sum += entry[2];
-    }
-    return this.#childNodeSize = sum;
-  }
-  _updateNode(tree) {
-    this.#childNodeSize = -1;
-    tree.updateNode(
-      this
-    );
-  }
-};
-function toChunkData(node, formatVersion) {
-  return makeNodeChunkData(node.level, node.entries, formatVersion);
-}
-var DataNodeImpl = class extends NodeImpl {
-  level = 0;
-  set(key, value, entrySize, tree) {
-    let deleteCount;
-    const i = binarySearch2(key, this.entries);
-    if (!binarySearchFound(i, this.entries, key)) {
-      deleteCount = 0;
-    } else {
-      deleteCount = 1;
-    }
-    return Promise.resolve(
-      this.#splice(tree, i, deleteCount, [key, value, entrySize])
-    );
-  }
-  #splice(tree, start, deleteCount, ...items) {
-    if (this.isMutable) {
-      this.entries.splice(start, deleteCount, ...items);
-      this._updateNode(tree);
-      return this;
-    }
-    const entries = readonlySplice(this.entries, start, deleteCount, ...items);
-    return tree.newDataNodeImpl(entries);
-  }
-  del(key, tree) {
-    const i = binarySearch2(key, this.entries);
-    if (!binarySearchFound(i, this.entries, key)) {
-      return Promise.resolve(this);
-    }
-    return Promise.resolve(this.#splice(tree, i, 1));
-  }
-  async *keys(_tree) {
-    for (const entry of this.entries) {
-      yield entry[0];
-    }
-  }
-  async *entriesIter(_tree) {
-    for (const entry of this.entries) {
-      yield entry;
-    }
-  }
-};
-function readonlySplice(array5, start, deleteCount, ...items) {
-  const arr = array5.slice(0, start);
-  for (let i = 0; i < items.length; i++) {
-    arr.push(items[i]);
-  }
-  for (let i = start + deleteCount; i < array5.length; i++) {
-    arr.push(array5[i]);
-  }
-  return arr;
-}
-var InternalNodeImpl = class _InternalNodeImpl extends NodeImpl {
-  level;
-  constructor(entries, hash2, level, isMutable) {
-    super(entries, hash2, isMutable);
-    this.level = level;
-  }
-  async set(key, value, entrySize, tree) {
-    let i = binarySearch2(key, this.entries);
-    if (i === this.entries.length) {
-      i--;
-    }
-    const childHash = this.entries[i][1];
-    const oldChildNode = await tree.getNode(childHash);
-    const childNode = await oldChildNode.set(key, value, entrySize, tree);
-    const childNodeSize = childNode.getChildNodeSize(tree);
-    if (childNodeSize > tree.maxSize || childNodeSize < tree.minSize) {
-      return this.#mergeAndPartition(tree, i, childNode);
-    }
-    const newEntry = createNewInternalEntryForNode(
-      childNode,
-      tree.getEntrySize
-    );
-    return this.#replaceChild(tree, i, newEntry);
-  }
-  /**
-   * This merges the child node entries with previous or next sibling and then
-   * partitions the merged entries.
-   */
-  async #mergeAndPartition(tree, i, childNode) {
-    const level = this.level - 1;
-    const thisEntries = this.entries;
-    let values;
-    let startIndex;
-    let removeCount;
-    if (i > 0) {
-      const hash2 = thisEntries[i - 1][1];
-      const previousSibling = await tree.getNode(hash2);
-      values = joinIterables(
-        previousSibling.entries,
-        childNode.entries
-      );
-      startIndex = i - 1;
-      removeCount = 2;
-    } else if (i < thisEntries.length - 1) {
-      const hash2 = thisEntries[i + 1][1];
-      const nextSibling = await tree.getNode(hash2);
-      values = joinIterables(
-        childNode.entries,
-        nextSibling.entries
-      );
-      startIndex = i;
-      removeCount = 2;
-    } else {
-      values = childNode.entries;
-      startIndex = i;
-      removeCount = 1;
-    }
-    const partitions = partition(
-      values,
-      (value) => value[2],
-      tree.minSize - tree.chunkHeaderSize,
-      tree.maxSize - tree.chunkHeaderSize
-    );
-    const newEntries = [];
-    for (const entries2 of partitions) {
-      const node = tree.newNodeImpl(entries2, level);
-      const newHashEntry = createNewInternalEntryForNode(
-        node,
-        tree.getEntrySize
-      );
-      newEntries.push(newHashEntry);
-    }
-    if (this.isMutable) {
-      this.entries.splice(startIndex, removeCount, ...newEntries);
-      this._updateNode(tree);
-      return this;
-    }
-    const entries = readonlySplice(
-      thisEntries,
-      startIndex,
-      removeCount,
-      ...newEntries
-    );
-    return tree.newInternalNodeImpl(entries, this.level);
-  }
-  #replaceChild(tree, index, newEntry) {
-    if (this.isMutable) {
-      this.entries.splice(index, 1, newEntry);
-      this._updateNode(tree);
-      return this;
-    }
-    const entries = readonlySplice(this.entries, index, 1, newEntry);
-    return tree.newInternalNodeImpl(entries, this.level);
-  }
-  async del(key, tree) {
-    const i = binarySearch2(key, this.entries);
-    if (i === this.entries.length) {
-      return this;
-    }
-    const childHash = this.entries[i][1];
-    const oldChildNode = await tree.getNode(childHash);
-    const oldHash = oldChildNode.hash;
-    const childNode = await oldChildNode.del(key, tree);
-    if (childNode.hash === oldHash) {
-      return this;
-    }
-    if (childNode.entries.length === 0) {
-      const entries = readonlySplice(this.entries, i, 1);
-      return tree.newInternalNodeImpl(entries, this.level);
-    }
-    if (i === 0 && this.entries.length === 1) {
-      return childNode;
-    }
-    if (childNode.getChildNodeSize(tree) > tree.minSize) {
-      const entry = createNewInternalEntryForNode(childNode, tree.getEntrySize);
-      return this.#replaceChild(tree, i, entry);
-    }
-    return this.#mergeAndPartition(tree, i, childNode);
-  }
-  async *keys(tree) {
-    for (const entry of this.entries) {
-      const childNode = await tree.getNode(entry[1]);
-      yield* childNode.keys(tree);
-    }
-  }
-  async *entriesIter(tree) {
-    for (const entry of this.entries) {
-      const childNode = await tree.getNode(entry[1]);
-      yield* childNode.entriesIter(tree);
-    }
-  }
-  getChildren(start, length, tree) {
-    const ps = [];
-    for (let i = start; i < length && i < this.entries.length; i++) {
-      ps.push(tree.getNode(this.entries[i][1]));
-    }
-    return Promise.all(ps);
-  }
-  async getCompositeChildren(start, length, tree) {
-    const { level } = this;
-    if (length === 0) {
-      return new _InternalNodeImpl([], newRandomHash(), level - 1, true);
-    }
-    const output = await this.getChildren(start, start + length, tree);
-    if (level > 1) {
-      const entries2 = [];
-      for (const child of output) {
-        entries2.push(...child.entries);
-      }
-      return new _InternalNodeImpl(entries2, newRandomHash(), level - 1, true);
-    }
-    assert(level === 1);
-    const entries = [];
-    for (const child of output) {
-      entries.push(...child.entries);
-    }
-    return new DataNodeImpl(entries, newRandomHash(), true);
-  }
-};
-function newNodeImpl(entries, hash2, level, isMutable) {
-  if (level === 0) {
-    return new DataNodeImpl(
-      entries,
-      hash2,
-      isMutable
-    );
-  }
-  return new InternalNodeImpl(entries, hash2, level, isMutable);
-}
-function isDataNodeImpl(node) {
-  return node.level === 0;
-}
-function partition(values, getSizeOfEntry2, min, max) {
-  const partitions = [];
-  const sizes = [];
-  let sum = 0;
-  let accum = [];
-  for (const value of values) {
-    const size = getSizeOfEntry2(value);
-    if (size >= max) {
-      if (accum.length > 0) {
-        partitions.push(accum);
-        sizes.push(sum);
-      }
-      partitions.push([value]);
-      sizes.push(size);
-      sum = 0;
-      accum = [];
-    } else if (sum + size >= min) {
-      accum.push(value);
-      partitions.push(accum);
-      sizes.push(sum + size);
-      sum = 0;
-      accum = [];
-    } else {
-      sum += size;
-      accum.push(value);
-    }
-  }
-  if (sum > 0) {
-    if (sizes.length > 0 && sum + sizes[sizes.length - 1] <= max) {
-      partitions[partitions.length - 1].push(...accum);
-    } else {
-      partitions.push(accum);
-    }
-  }
-  return partitions;
-}
-var emptyDataNode = makeNodeChunkData(
-  0,
-  [],
-  Latest
-);
-var emptyDataNodeImpl = new DataNodeImpl([], emptyHash, false);
-function createNewInternalEntryForNode(node, getSizeOfEntry2) {
-  const key = node.maxKey();
-  const value = node.hash;
-  const size = getSizeOfEntry2(key, value);
-  return [key, value, size];
-}
-
-// ../replicache/src/btree/splice.ts
-var SPLICE_UNASSIGNED = -1;
-var SPLICE_AT = 0;
-var SPLICE_REMOVED = 1;
-var SPLICE_ADDED = 2;
-var SPLICE_FROM = 3;
-var KEY = 0;
-var VALUE = 1;
-function* computeSplices(previous, current) {
-  let previousIndex = 0;
-  let currentIndex = 0;
-  let splice;
-  function ensureAssigned(splice2, index) {
-    if (splice2[SPLICE_FROM] === SPLICE_UNASSIGNED) {
-      splice2[SPLICE_FROM] = index;
-    }
-  }
-  function newSplice() {
-    return [previousIndex, 0, 0, SPLICE_UNASSIGNED];
-  }
-  while (previousIndex < previous.length && currentIndex < current.length) {
-    if (previous[previousIndex][KEY] === current[currentIndex][KEY]) {
-      if (deepEqual(
-        // These are really Hash | InternalValue
-        previous[previousIndex][VALUE],
-        current[currentIndex][VALUE]
-      )) {
-        if (splice) {
-          ensureAssigned(splice, 0);
-          yield splice;
-          splice = void 0;
-        }
-      } else {
-        if (!splice) {
-          splice = newSplice();
-        }
-        splice[SPLICE_ADDED]++;
-        splice[SPLICE_REMOVED]++;
-        ensureAssigned(splice, currentIndex);
-      }
-      previousIndex++;
-      currentIndex++;
-    } else if (previous[previousIndex][KEY] < current[currentIndex][KEY]) {
-      if (!splice) {
-        splice = newSplice();
-      }
-      splice[SPLICE_REMOVED]++;
-      previousIndex++;
-    } else {
-      if (!splice) {
-        splice = newSplice();
-      }
-      splice[SPLICE_ADDED]++;
-      ensureAssigned(splice, currentIndex);
-      currentIndex++;
-    }
-  }
-  if (currentIndex < current.length) {
-    if (!splice) {
-      splice = newSplice();
-    }
-    splice[SPLICE_ADDED] += current.length - currentIndex;
-    ensureAssigned(splice, currentIndex);
-  }
-  if (previousIndex < previous.length) {
-    if (!splice) {
-      splice = newSplice();
-    }
-    splice[SPLICE_REMOVED] += previous.length - previousIndex;
-  }
-  if (splice) {
-    ensureAssigned(splice, 0);
-    yield splice;
-  }
-}
-
-// ../replicache/src/btree/read.ts
-var NODE_HEADER_SIZE = 11;
-var BTreeRead = class {
-  _cache = /* @__PURE__ */ new Map();
-  _dagRead;
-  _formatVersion;
-  rootHash;
-  getEntrySize;
-  chunkHeaderSize;
-  constructor(dagRead, formatVersion, root = emptyHash, getEntrySize = getSizeOfEntry, chunkHeaderSize = NODE_HEADER_SIZE) {
-    this._dagRead = dagRead;
-    this._formatVersion = formatVersion;
-    this.rootHash = root;
-    this.getEntrySize = getEntrySize;
-    this.chunkHeaderSize = chunkHeaderSize;
-  }
-  async getNode(hash2) {
-    if (hash2 === emptyHash) {
-      return emptyDataNodeImpl;
-    }
-    const cached = this._cache.get(hash2);
-    if (cached) {
-      return cached;
-    }
-    const chunk = await this._dagRead.mustGetChunk(hash2);
-    const data = parseBTreeNode(
-      chunk.data,
-      this._formatVersion,
-      this.getEntrySize
-    );
-    const impl = newNodeImpl(
-      data[NODE_ENTRIES],
-      hash2,
-      data[NODE_LEVEL],
-      false
-    );
-    this._cache.set(hash2, impl);
-    return impl;
-  }
-  async get(key) {
-    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);
-    const index = binarySearch2(key, leaf.entries);
-    if (!binarySearchFound(index, leaf.entries, key)) {
-      return void 0;
-    }
-    return leaf.entries[index][1];
-  }
-  async has(key) {
-    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);
-    const index = binarySearch2(key, leaf.entries);
-    return binarySearchFound(index, leaf.entries, key);
-  }
-  async isEmpty() {
-    const { rootHash } = this;
-    const node = await this.getNode(this.rootHash);
-    if (this.rootHash !== rootHash) {
-      return this.isEmpty();
-    }
-    return node.entries.length === 0;
-  }
-  // We don't do any encoding of the key in the map, so we have no way of
-  // determining from an entry.key alone whether it is a regular key or an
-  // encoded IndexKey in an index map. Without encoding regular map keys the
-  // caller has to deal with encoding and decoding the keys for the index map.
-  scan(fromKey) {
-    return scanForHash(
-      this.rootHash,
-      () => this.rootHash,
-      this.rootHash,
-      fromKey,
-      async (hash2) => {
-        const cached = await this.getNode(hash2);
-        if (cached) {
-          return [
-            cached.level,
-            cached.isMutable ? cached.entries.slice() : cached.entries
-          ];
-        }
-        const chunk = await this._dagRead.mustGetChunk(hash2);
-        return parseBTreeNode(
-          chunk.data,
-          this._formatVersion,
-          this.getEntrySize
-        );
-      }
-    );
-  }
-  async *keys() {
-    const node = await this.getNode(this.rootHash);
-    yield* node.keys(this);
-  }
-  async *entries() {
-    const node = await this.getNode(this.rootHash);
-    yield* node.entriesIter(this);
-  }
-  [Symbol.asyncIterator]() {
-    return this.entries();
-  }
-  async *diff(last) {
-    const [currentNode, lastNode] = await Promise.all([
-      this.getNode(this.rootHash),
-      last.getNode(last.rootHash)
-    ]);
-    yield* diffNodes(lastNode, currentNode, last, this);
-  }
-};
-async function* diffNodes(last, current, lastTree, currentTree) {
-  if (last.level > current.level) {
-    const lastChild = await last.getCompositeChildren(
-      0,
-      last.entries.length,
-      lastTree
-    );
-    yield* diffNodes(lastChild, current, lastTree, currentTree);
-    return;
-  }
-  if (current.level > last.level) {
-    const currentChild = await current.getCompositeChildren(
-      0,
-      current.entries.length,
-      currentTree
-    );
-    yield* diffNodes(last, currentChild, lastTree, currentTree);
-    return;
-  }
-  if (isDataNodeImpl(last) && isDataNodeImpl(current)) {
-    yield* diffEntries(
-      last.entries,
-      current.entries
-    );
-    return;
-  }
-  const initialSplices = computeSplices(
-    last.entries,
-    current.entries
-  );
-  for (const splice of initialSplices) {
-    const [lastChild, currentChild] = await Promise.all([
-      last.getCompositeChildren(
-        splice[SPLICE_AT],
-        splice[SPLICE_REMOVED],
-        lastTree
-      ),
-      current.getCompositeChildren(
-        splice[SPLICE_FROM],
-        splice[SPLICE_ADDED],
-        currentTree
-      )
-    ]);
-    yield* diffNodes(lastChild, currentChild, lastTree, currentTree);
-  }
-}
-function* diffEntries(lastEntries, currentEntries) {
-  const lastLength = lastEntries.length;
-  const currentLength = currentEntries.length;
-  let i = 0;
-  let j = 0;
-  while (i < lastLength && j < currentLength) {
-    const lastKey = lastEntries[i][0];
-    const currentKey = currentEntries[j][0];
-    if (lastKey === currentKey) {
-      if (!deepEqual(lastEntries[i][1], currentEntries[j][1])) {
-        yield {
-          op: "change",
-          key: lastKey,
-          oldValue: lastEntries[i][1],
-          newValue: currentEntries[j][1]
-        };
-      }
-      i++;
-      j++;
-    } else if (lastKey < currentKey) {
-      yield {
-        op: "del",
-        key: lastKey,
-        oldValue: lastEntries[i][1]
-      };
-      i++;
-    } else {
-      yield {
-        op: "add",
-        key: currentKey,
-        newValue: currentEntries[j][1]
-      };
-      j++;
-    }
-  }
-  for (; i < lastLength; i++) {
-    yield {
-      op: "del",
-      key: lastEntries[i][0],
-      oldValue: lastEntries[i][1]
-    };
-  }
-  for (; j < currentLength; j++) {
-    yield {
-      op: "add",
-      key: currentEntries[j][0],
-      newValue: currentEntries[j][1]
-    };
-  }
-}
-async function* scanForHash(expectedRootHash, getRootHash, hash2, fromKey, readNode) {
-  if (hash2 === emptyHash) {
-    return;
-  }
-  const data = await readNode(hash2);
-  const entries = data[NODE_ENTRIES];
-  let i = 0;
-  if (fromKey) {
-    i = binarySearch2(fromKey, entries);
-  }
-  if (data[NODE_LEVEL] > 0) {
-    for (; i < entries.length; i++) {
-      yield* scanForHash(
-        expectedRootHash,
-        getRootHash,
-        entries[i][1],
-        fromKey,
-        readNode
-      );
-      fromKey = "";
-    }
-  } else {
-    for (; i < entries.length; i++) {
-      const rootHash = getRootHash();
-      if (expectedRootHash !== rootHash) {
-        yield* scanForHash(
-          rootHash,
-          getRootHash,
-          rootHash,
-          entries[i][0],
-          readNode
-        );
-        return;
-      }
-      yield entries[i];
-    }
-  }
-}
-async function allEntriesAsDiff(map, op) {
-  const diff3 = [];
-  const make = op === "add" ? (entry) => ({
-    op: "add",
-    key: entry[0],
-    newValue: entry[1]
-  }) : (entry) => ({
-    op: "del",
-    key: entry[0],
-    oldValue: entry[1]
-  });
-  for await (const entry of map.entries()) {
-    diff3.push(make(entry));
-  }
-  return diff3;
-}
-
-// ../shared/src/string-compare.ts
-function stringCompare(a, b) {
-  if (a === b) {
-    return 0;
-  }
-  if (a < b) {
-    return -1;
-  }
-  return 1;
-}
-
-// ../replicache/src/cookies.ts
-function compareCookies(a, b) {
-  if (a === b) {
-    return 0;
-  }
-  if (a === null) {
-    return -1;
-  }
-  if (b === null) {
-    return 1;
-  }
-  const cva = getCompareValue(a);
-  const cvb = getCompareValue(b);
-  if (typeof cva === "string" || typeof cvb === "string") {
-    return stringCompare(String(cva), String(cvb));
-  }
-  return cva - cvb;
-}
-function getCompareValue(cookie) {
-  if (typeof cookie === "string" || typeof cookie === "number") {
-    return cookie;
-  }
-  return cookie.order;
-}
-function assertCookie(v2) {
-  if (v2 === null || typeof v2 === "string" || typeof v2 === "number") {
-    return;
-  }
-  assertJSONObject(v2);
-  if (typeof v2.order === "string" || typeof v2.order === "number") {
-    return;
-  }
-  throw new Error("Invalid cookie");
-}
-
-// ../replicache/src/dag/chunk.ts
-function asRefs(sortedRefs) {
-  return sortedRefs;
-}
-function toRefs(refs) {
-  if (Array.isArray(refs)) {
-    refs.sort();
-    for (let i = 1; i < refs.length; i++) {
-      assert(refs[i - 1] !== refs[i], "Refs must not have duplicates");
-    }
-    return asRefs(refs);
-  }
-  const refsArray = [...refs];
-  refsArray.sort();
-  return asRefs(refsArray);
-}
-var Chunk = class {
-  hash;
-  data;
-  /**
-   * Meta is an array of refs. If there are no refs we do not write a meta
-   * chunk.
-   */
-  meta;
-  constructor(hash2, data, refs) {
-    assert(
-      !refs.includes(hash2),
-      "Chunk cannot reference itself"
-    );
-    assertDeepFrozen(data);
-    this.hash = hash2;
-    this.data = data;
-    this.meta = refs;
-  }
-};
-function assertRefs(v2) {
-  if (!Array.isArray(v2)) {
-    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]);
-    }
-  }
-}
-function createChunk(data, refs, chunkHasher) {
-  const hash2 = chunkHasher();
-  return new Chunk(hash2, data, refs);
-}
-
-// ../replicache/src/db/meta-type-enum.ts
-var LocalDD31 = 4;
-var SnapshotDD31 = 5;
-
-// ../replicache/src/db/commit.ts
-var DEFAULT_HEAD_NAME = "main";
-function commitIsLocalDD31(commit) {
-  return isLocalMetaDD31(commit.meta);
-}
-function commitIsLocal(commit) {
-  return commitIsLocalDD31(commit);
-}
-function commitIsSnapshot(commit) {
-  return isSnapshotMetaDD31(commit.meta);
-}
-var Commit = class {
-  chunk;
-  constructor(chunk) {
-    this.chunk = chunk;
-  }
-  get meta() {
-    return this.chunk.data.meta;
-  }
-  get valueHash() {
-    return this.chunk.data.valueHash;
-  }
-  getMutationID(clientID, dagRead) {
-    return getMutationID(clientID, dagRead, this.meta);
-  }
-  async getNextMutationID(clientID, dagRead) {
-    return await this.getMutationID(clientID, dagRead) + 1;
-  }
-  get indexes() {
-    return this.chunk.data.indexes;
-  }
-};
-async function getMutationID(clientID, dagRead, meta) {
-  switch (meta.type) {
-    case SnapshotDD31:
-      return meta.lastMutationIDs[clientID] ?? 0;
-    case LocalDD31: {
-      if (meta.clientID === clientID) {
-        return meta.mutationID;
-      }
-      const { basisHash } = meta;
-      const basisCommit = await commitFromHash(basisHash, dagRead);
-      return getMutationID(clientID, dagRead, basisCommit.meta);
-    }
-    default:
-      unreachable(meta);
-  }
-}
-async function localMutations(fromCommitHash, dagRead) {
-  const commits = await commitChain(fromCommitHash, dagRead);
-  return commits.filter((c) => commitIsLocal(c));
-}
-async function localMutationsDD31(fromCommitHash, dagRead) {
-  const commits = await commitChain(fromCommitHash, dagRead);
-  return commits.filter((c) => commitIsLocalDD31(c));
-}
-async function localMutationsGreaterThan(commit, mutationIDLimits, dagRead) {
-  const commits = [];
-  const remainingMutationIDLimits = new Map(Object.entries(mutationIDLimits));
-  while (!commitIsSnapshot(commit) && remainingMutationIDLimits.size > 0) {
-    if (commitIsLocalDD31(commit)) {
-      const { meta } = commit;
-      const mutationIDLowerLimit = remainingMutationIDLimits.get(meta.clientID);
-      if (mutationIDLowerLimit !== void 0) {
-        if (meta.mutationID <= mutationIDLowerLimit) {
-          remainingMutationIDLimits.delete(meta.clientID);
-        } else {
-          commits.push(commit);
-        }
-      }
-    }
-    const { basisHash } = commit.meta;
-    if (basisHash === null) {
-      throw new Error(`Commit ${commit.chunk.hash} has no basis`);
-    }
-    commit = await commitFromHash(basisHash, dagRead);
-  }
-  return commits;
-}
-async function baseSnapshotFromHead(name, dagRead) {
-  const hash2 = await dagRead.getHead(name);
-  assert(hash2, `Missing head ${name}`);
-  return baseSnapshotFromHash(hash2, dagRead);
-}
-async function baseSnapshotHashFromHash(hash2, dagRead) {
-  return (await baseSnapshotFromHash(hash2, dagRead)).chunk.hash;
-}
-async function baseSnapshotFromHash(hash2, dagRead) {
-  const commit = await commitFromHash(hash2, dagRead);
-  return baseSnapshotFromCommit(commit, dagRead);
-}
-async function baseSnapshotFromCommit(commit, dagRead) {
-  while (!commitIsSnapshot(commit)) {
-    const { meta } = commit;
-    if (isLocalMetaDD31(meta)) {
-      commit = await commitFromHash(meta.baseSnapshotHash, dagRead);
-    } else {
-      const { basisHash } = meta;
-      if (basisHash === null) {
-        throw new Error(`Commit ${commit.chunk.hash} has no basis`);
-      }
-      commit = await commitFromHash(basisHash, dagRead);
-    }
-  }
-  return commit;
-}
-function snapshotMetaParts(c, clientID) {
-  const m = c.meta;
-  const lmid = m.lastMutationIDs[clientID] ?? 0;
-  return [lmid, m.cookieJSON];
-}
-function compareCookiesForSnapshots(a, b) {
-  return compareCookies(a.meta.cookieJSON, b.meta.cookieJSON);
-}
-async function commitChain(fromCommitHash, dagRead) {
-  let commit = await commitFromHash(fromCommitHash, dagRead);
-  const commits = [];
-  while (!commitIsSnapshot(commit)) {
-    const { meta } = commit;
-    const { basisHash } = meta;
-    if (basisHash === null) {
-      throw new Error(`Commit ${commit.chunk.hash} has no basis`);
-    }
-    commits.push(commit);
-    commit = await commitFromHash(basisHash, dagRead);
-  }
-  commits.push(commit);
-  return commits;
-}
-async function commitFromHash(hash2, dagRead) {
-  const chunk = await dagRead.mustGetChunk(hash2);
-  return fromChunk(chunk);
-}
-async function commitFromHead(name, dagRead) {
-  const hash2 = await mustGetHeadHash(name, dagRead);
-  return commitFromHash(hash2, dagRead);
-}
-function assertLocalMetaDD31(v2) {
-  assertString(v2.clientID);
-  assertNumber(v2.mutationID);
-  assertString(v2.mutatorName);
-  if (!v2.mutatorName) {
-    throw new Error("Missing mutator name");
-  }
-  assertJSONValue(v2.mutatorArgsJSON);
-  if (v2.originalHash !== null) {
-    assertHash(v2.originalHash);
-  }
-  assertNumber(v2.timestamp);
-}
-function isLocalMetaDD31(meta) {
-  return meta.type === LocalDD31;
-}
-function assertSnapshotMetaDD31(v2) {
-  if (v2.basisHash !== null) {
-    assertHash(v2.basisHash);
-  }
-  assertJSONValue(v2.cookieJSON);
-  assertLastMutationIDs(v2.lastMutationIDs);
-}
-function assertLastMutationIDs(v2) {
-  assertObject(v2);
-  for (const e of Object.values(v2)) {
-    assertNumber(e);
-  }
-}
-function assertSnapshotCommitDD31(c) {
-  assertSnapshotMetaDD31(c.meta);
-}
-function isSnapshotMetaDD31(meta) {
-  return meta.type === SnapshotDD31;
-}
-function assertMeta(v2) {
-  assertObject(v2);
-  assertDeepFrozen(v2);
-  if (v2.basisHash !== null) {
-    assertString(v2.basisHash);
-  }
-  assertNumber(v2.type);
-  switch (v2.type) {
-    case LocalDD31:
-      assertLocalMetaDD31(v2);
-      break;
-    case SnapshotDD31:
-      assertSnapshotMetaDD31(v2);
-      break;
-    default:
-      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(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) {
-  return {
-    name,
-    keyPrefix: indexDefinition.prefix ?? "",
-    jsonPointer: indexDefinition.jsonPointer,
-    allowEmpty: indexDefinition.allowEmpty ?? false
-  };
-}
-function assertIndexRecord(v2) {
-  assertObject(v2);
-  assertDeepFrozen(v2);
-  assertChunkIndexDefinition(v2.definition);
-  assertString(v2.valueHash);
-}
-function assertIndexRecords(v2) {
-  assertArray(v2);
-  assertDeepFrozen(v2);
-  for (const ir of v2) {
-    assertIndexRecord(ir);
-  }
-}
-function newLocalDD31(createChunk2, basisHash, baseSnapshotHash, mutationID, mutatorName, mutatorArgsJSON, originalHash, valueHash, indexes, timestamp, clientID) {
-  const meta = {
-    type: LocalDD31,
-    basisHash,
-    baseSnapshotHash,
-    mutationID,
-    mutatorName,
-    mutatorArgsJSON,
-    originalHash,
-    timestamp,
-    clientID
-  };
-  return commitFromCommitData(
-    createChunk2,
-    makeCommitData(meta, valueHash, indexes)
-  );
-}
-function newSnapshotDD31(createChunk2, basisHash, lastMutationIDs, cookieJSON, valueHash, indexes) {
-  return commitFromCommitData(
-    createChunk2,
-    newSnapshotCommitDataDD31(
-      basisHash,
-      lastMutationIDs,
-      cookieJSON,
-      valueHash,
-      indexes
-    )
-  );
-}
-function newSnapshotCommitDataDD31(basisHash, lastMutationIDs, cookieJSON, valueHash, indexes) {
-  const meta = {
-    type: SnapshotDD31,
-    basisHash,
-    lastMutationIDs,
-    cookieJSON
-  };
-  return makeCommitData(meta, valueHash, indexes);
-}
-function fromChunk(chunk) {
-  validateChunk(chunk);
-  return new Commit(chunk);
-}
-function commitFromCommitData(createChunk2, data) {
-  return new Commit(createChunk2(data, getRefs(data)));
-}
-function getRefs(data) {
-  const refs = /* @__PURE__ */ new Set();
-  refs.add(data.valueHash);
-  const { meta } = data;
-  switch (meta.type) {
-    case LocalDD31:
-      meta.basisHash && refs.add(meta.basisHash);
-      break;
-    case SnapshotDD31:
-      break;
-    default:
-      unreachable(meta);
-  }
-  for (const index of data.indexes) {
-    refs.add(index.valueHash);
-  }
-  return toRefs(refs);
-}
-function makeCommitData(meta, valueHash, indexes) {
-  return deepFreeze({
-    meta,
-    valueHash,
-    indexes
-  });
-}
-function assertCommitData(v2) {
-  if (isProd) {
-    return;
-  }
-  assertObject(v2);
-  assertDeepFrozen(v2);
-  assertMeta(v2.meta);
-  assertString(v2.valueHash);
-  assertIndexRecords(v2.indexes);
-}
-function validateChunk(chunk) {
-  const { data } = chunk;
-  assertCommitData(data);
-  const seen = /* @__PURE__ */ new Set();
-  for (const index of data.indexes) {
-    const { name } = index.definition;
-    if (seen.has(name)) {
-      throw new Error(`Duplicate index ${name}`);
-    }
-    seen.add(name);
-  }
-}
-
-// ../replicache/src/db/index-operation-enum.ts
-var Add = 0;
-var Remove = 1;
-
-// ../replicache/src/db/index.ts
-var IndexRead = class {
-  meta;
-  map;
-  constructor(meta, map) {
-    this.meta = meta;
-    this.map = map;
-  }
-};
-var IndexWrite = class extends IndexRead {
-  // Note: does not update self.meta.valueHash (doesn't need to at this point as flush
-  // is only called during commit.)
-  flush() {
-    return this.map.flush();
-  }
-  clear() {
-    return this.map.clear();
-  }
-};
-async function indexValue(lc, index, op, key, val, jsonPointer, allowEmpty) {
-  try {
-    for (const entry of getIndexKeys(key, val, jsonPointer, allowEmpty)) {
-      switch (op) {
-        case Add:
-          await index.put(entry, val);
-          break;
-        case Remove:
-          await index.del(entry);
-          break;
-      }
-    }
-  } catch (e) {
-    lc.info?.("Not indexing value", val, ":", e);
-  }
-}
-function getIndexKeys(primary, value, jsonPointer, allowEmpty) {
-  const target = evaluateJSONPointer(value, jsonPointer);
-  if (target === void 0) {
-    if (allowEmpty) {
-      return [];
-    }
-    throw new Error(`No value at path: ${jsonPointer}`);
-  }
-  const values = Array.isArray(target) ? target : [target];
-  const indexKeys = [];
-  for (const value2 of values) {
-    if (typeof value2 === "string") {
-      indexKeys.push(encodeIndexKey([value2, primary]));
-    } else {
-      throw new Error("Unsupported target type");
-    }
-  }
-  return indexKeys;
-}
-var KEY_VERSION_0 = "\0";
-var KEY_SEPARATOR = "\0";
-function encodeIndexKey(indexKey) {
-  const secondary = indexKey[0];
-  const primary = indexKey[1];
-  if (secondary.includes("\0")) {
-    throw new Error("Secondary key cannot contain null byte");
-  }
-  return KEY_VERSION_0 + secondary + KEY_SEPARATOR + primary;
-}
-function encodeIndexScanKey(secondary, primary) {
-  const k = encodeIndexKey([secondary, primary || ""]);
-  if (primary === void 0) {
-    return k.slice(0, k.length - 1);
-  }
-  return k;
-}
-function decodeIndexKey(encodedIndexKey) {
-  if (encodedIndexKey[0] !== KEY_VERSION_0) {
-    throw new Error("Invalid version");
-  }
-  const versionLen = KEY_VERSION_0.length;
-  const separatorLen = KEY_SEPARATOR.length;
-  const separatorOffset = encodedIndexKey.indexOf(KEY_SEPARATOR, versionLen);
-  if (separatorOffset === -1) {
-    throw new Error("Invalid formatting");
-  }
-  const secondary = encodedIndexKey.slice(versionLen, separatorOffset);
-  const primary = encodedIndexKey.slice(separatorOffset + separatorLen);
-  return [secondary, primary];
-}
-function evaluateJSONPointer(value, pointer) {
-  function parseIndex(s) {
-    if (s.startsWith("+") || s.startsWith("0") && s.length !== 1) {
-      return void 0;
-    }
-    return parseInt(s, 10);
-  }
-  if (pointer === "") {
-    return value;
-  }
-  if (!pointer.startsWith("/")) {
-    throw new Error(`Invalid JSON pointer: ${pointer}`);
-  }
-  const tokens = pointer.split("/").slice(1).map((x) => x.replace(/~1/g, "/").replace(/~0/g, "~"));
-  let target = value;
-  for (const token of tokens) {
-    let targetOpt;
-    if (Array.isArray(target)) {
-      const i = parseIndex(token);
-      if (i === void 0) {
-        return void 0;
-      }
-      targetOpt = target[i];
-    } else if (target === null) {
-      return void 0;
-    } else if (typeof target === "object") {
-      target = target;
-      targetOpt = target[token];
-    }
-    if (targetOpt === void 0) {
-      return void 0;
-    }
-    target = targetOpt;
-  }
-  return target;
-}
-
-// ../replicache/src/db/read.ts
-var Read = class {
-  #dagRead;
-  map;
-  indexes;
-  constructor(dagRead, map, indexes) {
-    this.#dagRead = dagRead;
-    this.map = map;
-    this.indexes = indexes;
-  }
-  has(key) {
-    return this.map.has(key);
-  }
-  get(key) {
-    return this.map.get(key);
-  }
-  isEmpty() {
-    return this.map.isEmpty();
-  }
-  getMapForIndex(indexName) {
-    const idx = this.indexes.get(indexName);
-    if (idx === void 0) {
-      throw new Error(`Unknown index name: ${indexName}`);
-    }
-    return idx.map;
-  }
-  get closed() {
-    return this.#dagRead.closed;
-  }
-  close() {
-    this.#dagRead.release();
-  }
-};
-function readFromDefaultHead(dagRead, formatVersion) {
-  return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);
-}
-async function readFromHead(name, dagRead, formatVersion) {
-  const commit = await commitFromHead(name, dagRead);
-  return readFromCommit(commit, dagRead, formatVersion);
-}
-async function readFromHash(hash2, dagRead, formatVersion) {
-  const commit = await commitFromHash(hash2, dagRead);
-  return readFromCommit(commit, dagRead, formatVersion);
-}
-function readFromCommit(commit, dagRead, formatVersion) {
-  const indexes = readIndexesForRead(commit, dagRead, formatVersion);
-  const map = new BTreeRead(dagRead, formatVersion, commit.valueHash);
-  return new Read(dagRead, map, indexes);
-}
-function readIndexesForRead(commit, dagRead, formatVersion) {
-  const m = /* @__PURE__ */ new Map();
-  for (const index of commit.indexes) {
-    m.set(
-      index.definition.name,
-      new IndexRead(
-        index,
-        new BTreeRead(dagRead, formatVersion, index.valueHash)
-      )
-    );
-  }
-  return m;
-}
-
-// ../replicache/src/index-defs.ts
-var indexDefinitionSchema = readonlyObject({
-  prefix: valita_exports.string().optional(),
-  jsonPointer: valita_exports.string(),
-  allowEmpty: valita_exports.boolean().optional()
-});
-var indexDefinitionsSchema = readonlyRecord(
-  indexDefinitionSchema
-);
-function indexDefinitionEqual(a, b) {
-  return a.jsonPointer === b.jsonPointer && (a.allowEmpty ?? false) === (b.allowEmpty ?? false) && (a.prefix ?? "") === (b.prefix ?? "");
-}
-function indexDefinitionsEqual(a, b) {
-  if (Object.keys(a).length !== Object.keys(b).length) {
-    return false;
-  }
-  for (const [aKey, aValue] of Object.entries(a)) {
-    const bValue = b[aKey];
-    if (!bValue || !indexDefinitionEqual(aValue, bValue)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// ../replicache/src/persist/client-groups.ts
-var clientGroupSchema = readonlyObject({
-  /**
-   * The hash of the commit in the perdag last persisted to this client group.
-   * Should only be updated by clients assigned to this client group.
-   */
-  headHash: hashSchema,
-  /**
-   * Set of mutator names common to all clients assigned to this client group.
-   */
-  mutatorNames: readonlyArray(valita_exports.string()),
-  /**
-   * Index definitions common to all clients assigned to this client group.
-   */
-  indexes: indexDefinitionsSchema,
-  /**
-   * The highest mutation ID of every client assigned to this client group.
-   * Should only be updated by clients assigned to this client group. Read by
-   * other clients to determine if there are unacknowledged pending mutations
-   * for them to try to recover. This is redundant with information in the
-   * commit graph at `headHash`, but allows other clients to determine if there
-   * are unacknowledged pending mutations without having to load the commit
-   * graph.
-   */
-  mutationIDs: readonlyRecord(valita_exports.number()),
-  /**
-   * The highest lastMutationID received from the server for every client
-   * assigned to this client group.
-   *
-   * Should be updated by the clients assigned to this client group whenever
-   * they persist to this client group. Read by other clients to determine if
-   * there are unacknowledged pending mutations for them to recover and
-   * *updated* by other clients upon successfully recovering pending mutations
-   * to avoid redundant pushes of pending mutations.
-   *
-   * Note: This will be the same as the `lastMutationIDs` of the base snapshot
-   * of the client group's commit graph when written by clients assigned to this
-   * client group.  However, when written by another client recovering mutations
-   * it may be different because the other client does not update the commit
-   * graph.
-   */
-  lastServerAckdMutationIDs: valita_exports.record(valita_exports.number()),
-  /**
-   * If the server deletes this client group it can signal that the client group
-   * was deleted. If that happens we mark this client group as disabled so that
-   * we do not use it again when creating new clients.
-   */
-  disabled: valita_exports.boolean()
-});
-var CLIENT_GROUPS_HEAD_NAME = "client-groups";
-function assertClientGroup(value) {
-  assert2(value, clientGroupSchema);
-}
-function chunkDataToClientGroupMap(chunkData) {
-  assertObject(chunkData);
-  const clientGroups = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(chunkData)) {
-    if (value !== void 0) {
-      assertClientGroup(value);
-      clientGroups.set(key, value);
-    }
-  }
-  return clientGroups;
-}
-function clientGroupMapToChunkData(clientGroups, dagWrite) {
-  const chunkData = {};
-  for (const [clientGroupID, clientGroup] of clientGroups.entries()) {
-    dagWrite.assertValidHash(clientGroup.headHash);
-    chunkData[clientGroupID] = {
-      ...clientGroup,
-      mutatorNames: [...clientGroup.mutatorNames.values()]
-    };
-  }
-  return deepFreeze(chunkData);
-}
-async function getClientGroupsAtHash(hash2, dagRead) {
-  const chunk = await dagRead.getChunk(hash2);
-  return chunkDataToClientGroupMap(chunk?.data);
-}
-async function getClientGroups(dagRead) {
-  const hash2 = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
-  if (!hash2) {
-    return /* @__PURE__ */ new Map();
-  }
-  return getClientGroupsAtHash(hash2, dagRead);
-}
-async function setClientGroups(clientGroups, dagWrite) {
-  const currClientGroups = await getClientGroups(dagWrite);
-  for (const [clientGroupID, clientGroup] of clientGroups) {
-    const currClientGroup = currClientGroups.get(clientGroupID);
-    validateClientGroupUpdate(clientGroup, currClientGroup);
-  }
-  return setValidatedClientGroups(clientGroups, dagWrite);
-}
-async function setClientGroup(clientGroupID, clientGroup, dagWrite) {
-  const currClientGroups = await getClientGroups(dagWrite);
-  const currClientGroup = currClientGroups.get(clientGroupID);
-  validateClientGroupUpdate(clientGroup, currClientGroup);
-  const newClientGroups = new Map(currClientGroups);
-  newClientGroups.set(clientGroupID, clientGroup);
-  return setValidatedClientGroups(newClientGroups, dagWrite);
-}
-function validateClientGroupUpdate(clientGroup, currClientGroup) {
-  const mutatorNamesSet = new Set(clientGroup.mutatorNames);
-  assert(
-    mutatorNamesSet.size === clientGroup.mutatorNames.length,
-    "A client group's mutatorNames must be a set."
-  );
-  if (currClientGroup !== void 0) {
-    assert(
-      indexDefinitionsEqual(currClientGroup.indexes, clientGroup.indexes),
-      "A client group's index definitions must never change."
-    );
-    assert(
-      mutatorNamesEqual(mutatorNamesSet, currClientGroup.mutatorNames),
-      "A client group's mutatorNames must never change."
-    );
-  }
-}
-async function setValidatedClientGroups(clientGroups, dagWrite) {
-  const chunkData = clientGroupMapToChunkData(clientGroups, dagWrite);
-  const refs = /* @__PURE__ */ new Set();
-  for (const clientGroup of clientGroups.values()) {
-    refs.add(clientGroup.headHash);
-  }
-  const chunk = dagWrite.createChunk(chunkData, toRefs(refs));
-  await dagWrite.putChunk(chunk);
-  await dagWrite.setHead(CLIENT_GROUPS_HEAD_NAME, chunk.hash);
-  return clientGroups;
-}
-function mutatorNamesEqual(mutatorNamesSet, mutatorNames) {
-  if (mutatorNames.length !== mutatorNamesSet.size) {
-    return false;
-  }
-  for (const mutatorName of mutatorNames) {
-    if (!mutatorNamesSet.has(mutatorName)) {
-      return false;
-    }
-  }
-  return true;
-}
-async function getClientGroup(id, dagRead) {
-  const clientGroups = await getClientGroups(dagRead);
-  return clientGroups.get(id);
-}
-function clientGroupHasPendingMutations(clientGroup) {
-  for (const [clientID, mutationID] of Object.entries(
-    clientGroup.mutationIDs
-  )) {
-    const lastServerAckdMutationID = clientGroup.lastServerAckdMutationIDs[clientID];
-    if (lastServerAckdMutationID === void 0 && mutationID !== 0 || lastServerAckdMutationID < mutationID) {
-      return true;
-    }
-  }
-  return false;
-}
-async function disableClientGroup(clientGroupID, dagWrite) {
-  const clientGroup = await getClientGroup(clientGroupID, dagWrite);
-  if (!clientGroup) {
-    return;
-  }
-  const disabledClientGroup = {
-    ...clientGroup,
-    disabled: true
-  };
-  await setClientGroup(clientGroupID, disabledClientGroup, dagWrite);
-}
-
-// ../replicache/src/with-transactions.ts
-function withRead(store, fn) {
-  return using(store.read(), fn);
-}
-function withWriteNoImplicitCommit(store, fn) {
-  return using(store.write(), fn);
-}
-function withWrite(store, fn) {
-  return using(store.write(), async (write) => {
-    const result = await fn(write);
-    await write.commit();
-    return result;
-  });
-}
-async function using(x, fn) {
-  const write = await x;
-  try {
-    return await fn(write);
-  } finally {
-    write.release();
-  }
-}
-
-// ../replicache/src/async-iterable-to-array.ts
-async function asyncIterableToArray(it) {
-  const arr = [];
-  for await (const v2 of it) {
-    arr.push(v2);
-  }
-  return arr;
-}
-
-// ../replicache/src/btree/diff.ts
-function diff(oldMap, newMap) {
-  return asyncIterableToArray(newMap.diff(oldMap));
-}
-
-// ../replicache/src/btree/write.ts
-import { Lock } from "@rocicorp/lock";
-var BTreeWrite = class extends BTreeRead {
-  /**
-   * This rw lock is used to ensure we do not mutate the btree in parallel. It
-   * would be a problem if we didn't have the lock in cases like this:
-   *
-   * ```ts
-   * const p1 = tree.put('a', 0);
-   * const p2 = tree.put('b', 1);
-   * await p1;
-   * await p2;
-   * ```
-   *
-   * because both `p1` and `p2` would start from the old root hash but a put
-   * changes the root hash so the two concurrent puts would lead to only one of
-   * them actually working, and it is not deterministic which one would finish
-   * last.
-   */
-  #lock = new Lock();
-  #modified = /* @__PURE__ */ new Map();
-  minSize;
-  maxSize;
-  constructor(dagWrite, formatVersion, root = emptyHash, minSize = 8 * 1024, maxSize = 16 * 1024, getEntrySize = getSizeOfEntry, chunkHeaderSize) {
-    super(dagWrite, formatVersion, root, getEntrySize, chunkHeaderSize);
-    this.minSize = minSize;
-    this.maxSize = maxSize;
-  }
-  #addToModified(node) {
-    assert(node.isMutable);
-    this.#modified.set(node.hash, node);
-    this._cache.set(node.hash, node);
-  }
-  updateNode(node) {
-    assert(node.isMutable);
-    this.#modified.delete(node.hash);
-    node.hash = newRandomHash();
-    this.#addToModified(node);
-  }
-  newInternalNodeImpl(entries, level) {
-    const n = new InternalNodeImpl(entries, newRandomHash(), level, true);
-    this.#addToModified(n);
-    return n;
-  }
-  newDataNodeImpl(entries) {
-    const n = new DataNodeImpl(entries, newRandomHash(), true);
-    this.#addToModified(n);
-    return n;
-  }
-  newNodeImpl(entries, level) {
-    const n = newNodeImpl(entries, newRandomHash(), level, true);
-    this.#addToModified(n);
-    return n;
-  }
-  put(key, value) {
-    return this.#lock.withLock(async () => {
-      const oldRootNode = await this.getNode(this.rootHash);
-      const entrySize = this.getEntrySize(key, value);
-      const rootNode = await oldRootNode.set(key, value, entrySize, this);
-      if (rootNode.getChildNodeSize(this) > this.maxSize) {
-        const headerSize = this.chunkHeaderSize;
-        const partitions = partition(
-          rootNode.entries,
-          (value2) => value2[2],
-          this.minSize - headerSize,
-          this.maxSize - headerSize
-        );
-        const { level } = rootNode;
-        const entries = partitions.map((entries2) => {
-          const node = this.newNodeImpl(entries2, level);
-          return createNewInternalEntryForNode(node, this.getEntrySize);
-        });
-        const newRoot = this.newInternalNodeImpl(entries, level + 1);
-        this.rootHash = newRoot.hash;
-        return;
-      }
-      this.rootHash = rootNode.hash;
-    });
-  }
-  del(key) {
-    return this.#lock.withLock(async () => {
-      const oldRootNode = await this.getNode(this.rootHash);
-      const newRootNode = await oldRootNode.del(key, this);
-      const found = this.rootHash !== newRootNode.hash;
-      if (found) {
-        if (newRootNode.level > 0 && newRootNode.entries.length === 1) {
-          this.rootHash = newRootNode.entries[0][1];
-        } else {
-          this.rootHash = newRootNode.hash;
-        }
-      }
-      return found;
-    });
-  }
-  clear() {
-    return this.#lock.withLock(() => {
-      this.#modified.clear();
-      this.rootHash = emptyHash;
-    });
-  }
-  flush() {
-    return this.#lock.withLock(async () => {
-      const dagWrite = this._dagRead;
-      if (this.rootHash === emptyHash) {
-        const chunk = dagWrite.createChunk(emptyDataNode, []);
-        await dagWrite.putChunk(chunk);
-        return chunk.hash;
-      }
-      const newChunks = [];
-      const newRoot = gatherNewChunks(
-        this.rootHash,
-        newChunks,
-        dagWrite.createChunk,
-        this.#modified,
-        this._formatVersion
-      );
-      await Promise.all(newChunks.map((chunk) => dagWrite.putChunk(chunk)));
-      this.#modified.clear();
-      this.rootHash = newRoot;
-      return newRoot;
-    });
-  }
-};
-function gatherNewChunks(hash2, newChunks, createChunk2, modified, formatVersion) {
-  const node = modified.get(hash2);
-  if (node === void 0) {
-    return hash2;
-  }
-  if (isDataNodeImpl(node)) {
-    const chunk2 = createChunk2(toChunkData(node, formatVersion), []);
-    newChunks.push(chunk2);
-    return chunk2.hash;
-  }
-  const refs = [];
-  const { entries } = node;
-  for (let i = 0; i < entries.length; i++) {
-    const entry = entries[i];
-    const childHash = entry[1];
-    const newChildHash = gatherNewChunks(
-      childHash,
-      newChunks,
-      createChunk2,
-      modified,
-      formatVersion
-    );
-    if (newChildHash !== childHash) {
-      entries[i] = [entry[0], newChildHash, entry[2]];
-    }
-    refs.push(newChildHash);
-  }
-  const chunk = createChunk2(toChunkData(node, formatVersion), toRefs(refs));
-  newChunks.push(chunk);
-  return chunk.hash;
-}
-
-// ../replicache/src/lazy.ts
-function lazy(factory) {
-  let value;
-  return () => {
-    if (value === void 0) {
-      value = factory();
-    }
-    return value;
-  };
-}
-
-// ../replicache/src/sync/diff.ts
-var DiffsMap = class extends Map {
-  set(key, value) {
-    if (value.length === 0) {
-      return this;
-    }
-    return super.set(key, value);
-  }
-};
-async function diff2(oldHash, newHash, read, diffConfig, formatVersion) {
-  const [oldCommit, newCommit] = await Promise.all([
-    commitFromHash(oldHash, read),
-    commitFromHash(newHash, read)
-  ]);
-  return diffCommits(oldCommit, newCommit, read, diffConfig, formatVersion);
-}
-async function diffCommits(oldCommit, newCommit, read, diffConfig, formatVersion) {
-  const diffsMap = new DiffsMap();
-  if (!diffConfig.shouldComputeDiffs()) {
-    return diffsMap;
-  }
-  const oldMap = new BTreeRead(read, formatVersion, oldCommit.valueHash);
-  const newMap = new BTreeRead(read, formatVersion, newCommit.valueHash);
-  const valueDiff = await diff(oldMap, newMap);
-  diffsMap.set("", valueDiff);
-  await addDiffsForIndexes(
-    oldCommit,
-    newCommit,
-    read,
-    diffsMap,
-    diffConfig,
-    formatVersion
-  );
-  return diffsMap;
-}
-async function addDiffsForIndexes(mainCommit, syncCommit, read, diffsMap, diffConfig, formatVersion) {
-  const oldIndexes = readIndexesForRead(mainCommit, read, formatVersion);
-  const newIndexes = readIndexesForRead(syncCommit, read, formatVersion);
-  for (const [oldIndexName, oldIndex] of oldIndexes) {
-    if (!diffConfig.shouldComputeDiffsForIndex(oldIndexName)) {
-      continue;
-    }
-    const newIndex = newIndexes.get(oldIndexName);
-    if (newIndex !== void 0) {
-      assert(newIndex !== oldIndex);
-      const diffs = await diff(oldIndex.map, newIndex.map);
-      newIndexes.delete(oldIndexName);
-      diffsMap.set(oldIndexName, diffs);
-    } else {
-      const diffs = await allEntriesAsDiff(oldIndex.map, "del");
-      diffsMap.set(oldIndexName, diffs);
-    }
-  }
-  for (const [newIndexName, newIndex] of newIndexes) {
-    if (!diffConfig.shouldComputeDiffsForIndex(newIndexName)) {
-      continue;
-    }
-    const diffs = await allEntriesAsDiff(newIndex.map, "add");
-    diffsMap.set(newIndexName, diffs);
-  }
-}
-
-// ../replicache/src/db/write.ts
-var Write = class extends Read {
-  #dagWrite;
-  #basis;
-  #meta;
-  #clientID;
-  #formatVersion;
-  constructor(dagWrite, map, basis, meta, indexes, clientID, formatVersion) {
-    super(dagWrite, map, indexes);
-    this.#dagWrite = dagWrite;
-    this.#basis = basis;
-    this.#meta = meta;
-    this.#clientID = clientID;
-    this.#formatVersion = formatVersion;
-    if (basis === void 0) {
-      assert(meta.basisHash === emptyHash);
-    } else {
-      assert(meta.basisHash === basis.chunk.hash);
-    }
-  }
-  /**
-   * The value needs to be frozen since it is kept in memory and used later for
-   * comparison as well as returned in `get`.
-   */
-  async put(lc, key, value) {
-    const oldVal = lazy(() => this.map.get(key));
-    await updateIndexes(lc, this.indexes, key, oldVal, value);
-    await this.map.put(key, value);
-  }
-  getMutationID() {
-    return getMutationID(this.#clientID, this.#dagWrite, this.#meta);
-  }
-  async del(lc, key) {
-    const oldVal = lazy(() => this.map.get(key));
-    if (oldVal !== void 0) {
-      await updateIndexes(lc, this.indexes, key, oldVal, void 0);
-    }
-    return this.map.del(key);
-  }
-  async clear() {
-    await this.map.clear();
-    const ps = [];
-    for (const idx of this.indexes.values()) {
-      ps.push(idx.clear());
-    }
-    await Promise.all(ps);
-  }
-  async putCommit() {
-    const valueHash = await this.map.flush();
-    const indexRecords = [];
-    for (const index of this.indexes.values()) {
-      const valueHash2 = await index.flush();
-      const indexRecord = {
-        definition: index.meta.definition,
-        valueHash: valueHash2
-      };
-      indexRecords.push(indexRecord);
-    }
-    let commit;
-    const meta = this.#meta;
-    switch (meta.type) {
-      case LocalDD31: {
-        assert(this.#formatVersion >= DD31);
-        const {
-          basisHash,
-          mutationID,
-          mutatorName,
-          mutatorArgsJSON,
-          originalHash,
-          timestamp
-        } = meta;
-        commit = newLocalDD31(
-          this.#dagWrite.createChunk,
-          basisHash,
-          await baseSnapshotHashFromHash(basisHash, this.#dagWrite),
-          mutationID,
-          mutatorName,
-          mutatorArgsJSON,
-          originalHash,
-          valueHash,
-          indexRecords,
-          timestamp,
-          this.#clientID
-        );
-        break;
-      }
-      case SnapshotDD31: {
-        assert(this.#formatVersion > DD31);
-        const { basisHash, lastMutationIDs, cookieJSON } = meta;
-        commit = newSnapshotDD31(
-          this.#dagWrite.createChunk,
-          basisHash,
-          lastMutationIDs,
-          cookieJSON,
-          valueHash,
-          indexRecords
-        );
-        break;
-      }
-    }
-    await this.#dagWrite.putChunk(commit.chunk);
-    return commit;
-  }
-  // Return value is the hash of the new commit.
-  async commit(headName) {
-    const commit = await this.putCommit();
-    const commitHash = commit.chunk.hash;
-    await this.#dagWrite.setHead(headName, commitHash);
-    await this.#dagWrite.commit();
-    return commitHash;
-  }
-  async commitWithDiffs(headName, diffConfig) {
-    const commit = this.putCommit();
-    const diffMap = await this.#generateDiffs(diffConfig);
-    const commitHash = (await commit).chunk.hash;
-    await this.#dagWrite.setHead(headName, commitHash);
-    await this.#dagWrite.commit();
-    return [commitHash, diffMap];
-  }
-  async #generateDiffs(diffConfig) {
-    const diffsMap = new DiffsMap();
-    if (!diffConfig.shouldComputeDiffs()) {
-      return diffsMap;
-    }
-    let valueDiff = [];
-    if (this.#basis) {
-      const basisMap = new BTreeRead(
-        this.#dagWrite,
-        this.#formatVersion,
-        this.#basis.valueHash
-      );
-      valueDiff = await diff(basisMap, this.map);
-    }
-    diffsMap.set("", valueDiff);
-    let basisIndexes;
-    if (this.#basis) {
-      basisIndexes = readIndexesForRead(
-        this.#basis,
-        this.#dagWrite,
-        this.#formatVersion
-      );
-    } else {
-      basisIndexes = /* @__PURE__ */ new Map();
-    }
-    for (const [name, index] of this.indexes) {
-      if (!diffConfig.shouldComputeDiffsForIndex(name)) {
-        continue;
-      }
-      const basisIndex = basisIndexes.get(name);
-      assert(index !== basisIndex);
-      const indexDiffResult = await (basisIndex ? diff(basisIndex.map, index.map) : (
-        // No basis. All keys are new.
-        allEntriesAsDiff(index.map, "add")
-      ));
-      diffsMap.set(name, indexDiffResult);
-    }
-    for (const [name, basisIndex] of basisIndexes) {
-      if (!this.indexes.has(name) && diffConfig.shouldComputeDiffsForIndex(name)) {
-        const indexDiffResult = await allEntriesAsDiff(basisIndex.map, "del");
-        diffsMap.set(name, indexDiffResult);
-      }
-    }
-    return diffsMap;
-  }
-  close() {
-    this.#dagWrite.release();
-  }
-};
-async function newWriteLocal(basisHash, mutatorName, mutatorArgsJSON, originalHash, dagWrite, timestamp, clientID, formatVersion) {
-  const basis = await commitFromHash(basisHash, dagWrite);
-  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,
-    {
-      type: LocalDD31,
-      basisHash,
-      baseSnapshotHash: await baseSnapshotHashFromHash(basisHash, dagWrite),
-      mutatorName,
-      mutatorArgsJSON,
-      mutationID,
-      originalHash,
-      timestamp,
-      clientID
-    },
-    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);
-  return new Write(
-    dagWrite,
-    bTreeWrite,
-    basis,
-    { basisHash, type: SnapshotDD31, lastMutationIDs, cookieJSON },
-    readIndexesForWrite(basis, dagWrite, formatVersion),
-    clientID,
-    formatVersion
-  );
-}
-async function updateIndexes(lc, indexes, key, oldValGetter, newVal) {
-  const ps = [];
-  for (const idx of indexes.values()) {
-    const { keyPrefix } = idx.meta.definition;
-    if (!keyPrefix || key.startsWith(keyPrefix)) {
-      const oldVal = await oldValGetter();
-      if (oldVal !== void 0) {
-        ps.push(
-          indexValue(
-            lc,
-            idx.map,
-            Remove,
-            key,
-            oldVal,
-            idx.meta.definition.jsonPointer,
-            idx.meta.definition.allowEmpty ?? false
-          )
-        );
-      }
-      if (newVal !== void 0) {
-        ps.push(
-          indexValue(
-            lc,
-            idx.map,
-            Add,
-            key,
-            newVal,
-            idx.meta.definition.jsonPointer,
-            idx.meta.definition.allowEmpty ?? false
-          )
-        );
-      }
-    }
-  }
-  await Promise.all(ps);
-}
-function readIndexesForWrite(commit, dagWrite, formatVersion) {
-  const m = /* @__PURE__ */ new Map();
-  for (const index of commit.indexes) {
-    m.set(
-      index.definition.name,
-      new IndexWrite(
-        index,
-        new BTreeWrite(dagWrite, formatVersion, index.valueHash)
-      )
-    );
-  }
-  return m;
-}
-async function createIndexBTree(lc, dagWrite, valueMap, prefix, jsonPointer, allowEmpty, formatVersion) {
-  const indexMap = new BTreeWrite(dagWrite, formatVersion);
-  for await (const entry of valueMap.scan(prefix)) {
-    const key = entry[0];
-    if (!key.startsWith(prefix)) {
-      break;
-    }
-    await indexValue(
-      lc,
-      indexMap,
-      Add,
-      key,
-      entry[1],
-      jsonPointer,
-      allowEmpty
-    );
-  }
-  return indexMap;
-}
-
-// ../replicache/src/sync/ids.ts
-var clientGroupIDSchema = valita_exports.string();
-var clientIDSchema = valita_exports.string();
-
-// ../replicache/src/persist/make-client-id.ts
-function makeClientID() {
-  const length = 18;
-  const high = randomUint64();
-  const low = randomUint64();
-  const combined = high << 64n | low;
-  return combined.toString(32).slice(-length).padStart(length, "0");
-}
-
-// ../replicache/src/persist/clients.ts
-var 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;
-}
-var CLIENTS_HEAD_NAME = "clients";
-var clientSchema = valita_exports.union(clientV5Schema, clientV6Schema);
-function assertClient(value) {
-  assert2(value, clientSchema);
-}
-function assertClientV6(value) {
-  assert2(value, clientV6Schema);
-}
-function chunkDataToClientMap(chunkData) {
-  assertObject(chunkData);
-  const clients = /* @__PURE__ */ new Map();
-  for (const key in chunkData) {
-    if (hasOwn(chunkData, key)) {
-      const value = chunkData[key];
-      if (value !== void 0) {
-        assertClient(value);
-        clients.set(key, value);
-      }
-    }
-  }
-  return clients;
-}
-function clientMapToChunkData(clients, dagWrite) {
-  for (const client of clients.values()) {
-    if (isClientV6(client)) {
-      client.refreshHashes.forEach(dagWrite.assertValidHash);
-      if (client.persistHash) {
-        dagWrite.assertValidHash(client.persistHash);
-      }
-    } else {
-      dagWrite.assertValidHash(client.headHash);
-      if (client.tempRefreshHash) {
-        dagWrite.assertValidHash(client.tempRefreshHash);
+  a = a;
+  b = b;
+  let aSize = 0;
+  for (const key in a) {
+    if (hasOwn(a, key)) {
+      if (!deepEqual(a[key], b[key])) {
+        return false;
       }
+      aSize++;
     }
   }
-  return deepFreeze(Object.fromEntries(clients));
-}
-async function getClients(dagRead) {
-  const hash2 = await dagRead.getHead(CLIENTS_HEAD_NAME);
-  return getClientsAtHash(hash2, dagRead);
-}
-async function getClientsAtHash(hash2, dagRead) {
-  if (!hash2) {
-    return /* @__PURE__ */ new Map();
-  }
-  const chunk = await dagRead.getChunk(hash2);
-  return chunkDataToClientMap(chunk?.data);
-}
-var ClientStateNotFoundError = class extends Error {
-  name = "ClientStateNotFoundError";
-  id;
-  constructor(id) {
-    super(`Client state not found, id: ${id}`);
-    this.id = id;
-  }
-};
-async function assertHasClientState(id, dagRead) {
-  if (!await hasClientState(id, dagRead)) {
-    throw new ClientStateNotFoundError(id);
+  let bSize = 0;
+  for (const key in b) {
+    if (hasOwn(b, key)) {
+      bSize++;
+    }
   }
+  return aSize === bSize;
 }
-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);
+function assertJSONValue(v2) {
+  if (isProd) {
+    return;
   }
-  return client;
-}
-function initClientV6(newClientID, lc, perdag, mutatorNames, indexes, formatVersion, enableClientGroupForking) {
-  return withWrite(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)
-      ]);
-      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);
-      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
-        });
+  switch (typeof v2) {
+    case "boolean":
+    case "number":
+    case "string":
+      return;
+    case "object":
+      if (v2 === null) {
+        return;
       }
-      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()
-        });
+      if (Array.isArray(v2)) {
+        return assertJSONArray(v2);
       }
-    }
-    return setClientsAndClientGroupAndCommit(
-      snapshot.meta.basisHash,
-      snapshot.meta.cookieJSON,
-      snapshot.valueHash,
-      indexRecords
-    );
-  });
+      return assertObjectIsJSONObject(v2);
+  }
+  throwInvalidType(v2, "JSON value");
 }
-function findMatchingOldIndex(oldIndexes, chunkIndexDefinition) {
-  return oldIndexes.find(
-    (index) => chunkIndexDefinitionEqualIgnoreName(index.definition, chunkIndexDefinition)
-  );
+function assertJSONObject(v2) {
+  assertObject(v2);
+  assertObjectIsJSONObject(v2);
 }
-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;
+function assertObjectIsJSONObject(v2) {
+  for (const k in v2) {
+    if (hasOwn(v2, k)) {
+      const value = v2[k];
+      if (value !== void 0) {
+        assertJSONValue(value);
+      }
     }
   }
-  if (bestSnapshot) {
-    return {
-      type: FIND_MATCHING_CLIENT_TYPE_FORK,
-      snapshot: bestSnapshot
-    };
+}
+function assertJSONArray(v2) {
+  for (const item of v2) {
+    assertJSONValue(item);
   }
-  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);
+function isJSONValue(v2, path2) {
+  switch (typeof v2) {
+    case "boolean":
+    case "number":
+    case "string":
+      return true;
+    case "object":
+      if (v2 === null) {
+        return true;
       }
-    } else {
-      refs.add(client.headHash);
-      if (client.tempRefreshHash) {
-        refs.add(client.tempRefreshHash);
+      if (Array.isArray(v2)) {
+        return isJSONArray(v2, path2);
       }
-    }
+      return objectIsJSONObject(v2, path2);
   }
-  return toRefs(refs);
+  return false;
 }
-async function getClientGroupForClient(clientID, read) {
-  const clientGroupID = await getClientGroupIDForClient(clientID, read);
-  if (!clientGroupID) {
-    return void 0;
+function isJSONObject(v2, path2) {
+  if (typeof v2 !== "object" || v2 === null) {
+    return false;
   }
-  return getClientGroup(clientGroupID, read);
-}
-async function getClientGroupIDForClient(clientID, read) {
-  const client = await getClient(clientID, read);
-  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;
+  return objectIsJSONObject(v2, path2);
 }
-
-// ../zero-protocol/src/ast.ts
-import { compareUTF8 as compareUTF82 } from "compare-utf8";
-
-// ../shared/src/arrays.ts
-function defined(arr) {
-  let i = arr.findIndex((x) => x === void 0);
-  if (i < 0) {
-    return arr;
-  }
-  const defined2 = arr.slice(0, i);
-  for (i++; i < arr.length; i++) {
-    const x = arr[i];
-    if (x !== void 0) {
-      defined2.push(x);
+function objectIsJSONObject(v2, path2) {
+  for (const k in v2) {
+    if (hasOwn(v2, k)) {
+      path2.push(k);
+      const value = v2[k];
+      if (value !== void 0 && !isJSONValue(value, path2)) {
+        return false;
+      }
+      path2.pop();
     }
   }
-  return defined2;
+  return true;
 }
-function areEqual(arr1, arr2) {
-  return arr1.length === arr2.length && arr1.every((e, i) => e === arr2[i]);
+function isJSONArray(v2, path2) {
+  for (let i = 0; i < v2.length; i++) {
+    path2.push(i);
+    if (!isJSONValue(v2[i], path2)) {
+      return false;
+    }
+    path2.pop();
+  }
+  return true;
 }
 
 // ../shared/src/json-schema.ts
-import * as valita from "@badrap/valita";
 var path = [];
 var jsonSchema = valita_exports.unknown().chain((v2) => {
   if (isProd) {
@@ -3397,15 +756,15 @@ function cmpCondition(a, b) {
 }
 function compareValuePosition(a, b) {
   if (a.type !== b.type) {
-    return compareUTF82(a.type, b.type);
+    return compareUTF8(a.type, b.type);
   }
   switch (a.type) {
     case "literal":
       assert(b.type === "literal");
-      return compareUTF82(String(a.value), String(b.value));
+      return compareUTF8(String(a.value), String(b.value));
     case "column":
       assert(b.type === "column");
-      return compareUTF82(a.name, b.name);
+      return compareUTF8(a.name, b.name);
     case "static":
       throw new Error(
         "Static parameters should be resolved before normalization"
@@ -3413,7 +772,7 @@ function compareValuePosition(a, b) {
   }
 }
 function cmpRelated(a, b) {
-  return compareUTF82(must(a.subquery.alias), must(b.subquery.alias));
+  return compareUTF8(must(a.subquery.alias), must(b.subquery.alias));
 }
 function flattened(cond) {
   if (cond.type === "simple" || cond.type === "correlatedSubquery") {
@@ -3438,7 +797,7 @@ function flattened(cond) {
 }
 function compareUTF8MaybeNull(a, b) {
   if (a !== null && b !== null) {
-    return compareUTF82(a, b);
+    return compareUTF8(a, b);
   }
   if (b !== null) {
     return -1;
@@ -3449,109 +808,6 @@ function compareUTF8MaybeNull(a, b) {
   return 0;
 }
 
-// ../zero-protocol/src/inspect-down.ts
-var inspectQueryRowSchema = valita_exports.object({
-  clientID: valita_exports.string(),
-  queryID: valita_exports.string(),
-  ast: astSchema,
-  got: valita_exports.boolean(),
-  deleted: valita_exports.boolean(),
-  ttl: valita_exports.number(),
-  inactivatedAt: valita_exports.number().nullable(),
-  rowCount: valita_exports.number()
-});
-var inspectQueriesDownSchema = valita_exports.object({
-  op: valita_exports.literal("queries"),
-  id: valita_exports.string(),
-  value: valita_exports.array(inspectQueryRowSchema)
-});
-var inspectDownBodySchema = valita_exports.union(inspectQueriesDownSchema);
-var inspectDownMessageSchema = valita_exports.tuple([
-  valita_exports.literal("inspect"),
-  inspectDownBodySchema
-]);
-
-// ../shared/src/random-values.ts
-function getNonCryptoRandomValues(array5) {
-  if (array5 === null) {
-    throw new TypeError("array cannot be null");
-  }
-  for (let i = 0; i < array5.length; i++) {
-    array5[i] = Math.floor(Math.random() * 256);
-  }
-  return array5;
-}
-
-// ../zero-client/src/util/nanoid.ts
-function nanoid(size = 21) {
-  const randomBytes = getNonCryptoRandomValues(new Uint8Array(size));
-  return randomBytes.reduce((id, byte) => {
-    byte &= 63;
-    if (byte < 36) {
-      id += byte.toString(36);
-    } else if (byte < 62) {
-      id += (byte - 26).toString(36).toUpperCase();
-    } else if (byte > 62) {
-      id += "-";
-    } else {
-      id += "_";
-    }
-    return id;
-  }, "");
-}
-
-// ../shared/src/hash.ts
-import { xxHash32 } from "js-xxhash";
-var h64 = (s) => hash(s, 2);
-var h128 = (s) => hash(s, 4);
-function hash(str, words) {
-  let hash2 = 0n;
-  for (let i = 0; i < words; i++) {
-    hash2 = (hash2 << 32n) + BigInt(xxHash32(str, i));
-  }
-  return hash2;
-}
-
-// ../zero-protocol/src/primary-key.ts
-var primaryKeySchema = readonly(
-  valita_exports.tuple([valita_exports.string()]).concat(valita_exports.array(valita_exports.string()))
-);
-var primaryKeyValueSchema = valita_exports.union(
-  valita_exports.string(),
-  valita_exports.number(),
-  valita_exports.boolean()
-);
-var primaryKeyValueRecordSchema = readonlyRecord(
-  primaryKeyValueSchema
-);
-
-// ../zero-client/src/client/keys.ts
-var DESIRED_QUERIES_KEY_PREFIX = "d/";
-var GOT_QUERIES_KEY_PREFIX = "g/";
-var ENTITIES_KEY_PREFIX = "e/";
-function toDesiredQueriesKey(clientID, hash2) {
-  return DESIRED_QUERIES_KEY_PREFIX + clientID + "/" + hash2;
-}
-function desiredQueriesPrefixForClient(clientID) {
-  return DESIRED_QUERIES_KEY_PREFIX + clientID + "/";
-}
-function toGotQueriesKey(hash2) {
-  return GOT_QUERIES_KEY_PREFIX + hash2;
-}
-function toPrimaryKeyString(tableName, primaryKey, value) {
-  if (primaryKey.length === 1) {
-    return ENTITIES_KEY_PREFIX + tableName + "/" + parse(value[primaryKey[0]], primaryKeyValueSchema);
-  }
-  const values = primaryKey.map((k) => parse(value[k], primaryKeyValueSchema));
-  const str = JSON.stringify(values);
-  const idSegment = h128(str);
-  return ENTITIES_KEY_PREFIX + tableName + "/" + idSegment;
-}
-function sourceNameFromKey(key) {
-  const slash = key.indexOf("/", ENTITIES_KEY_PREFIX.length);
-  return key.slice(ENTITIES_KEY_PREFIX.length, slash);
-}
-
 // ../zero-schema/src/table-schema.ts
 function isOneHop(r) {
   return r.length === 1;
@@ -3838,6 +1094,77 @@ var Exists = class {
   }
 };
 
+// ../shared/src/iterables.ts
+function* joinIterables(...iters) {
+  for (const iter of iters) {
+    yield* iter;
+  }
+}
+function* filterIter(iter, p) {
+  let index = 0;
+  for (const t of iter) {
+    if (p(t, index++)) {
+      yield t;
+    }
+  }
+}
+function* mapIter(iter, f) {
+  let index = 0;
+  for (const t of iter) {
+    yield f(t, index++);
+  }
+}
+var IterWrapper = class _IterWrapper {
+  iter;
+  constructor(iter) {
+    this.iter = iter;
+  }
+  [Symbol.iterator]() {
+    return this.iter[Symbol.iterator]();
+  }
+  map(f) {
+    return new _IterWrapper(mapIter(this.iter, f));
+  }
+  filter(p) {
+    return new _IterWrapper(filterIter(this.iter, p));
+  }
+};
+function wrapIterable(iter) {
+  return new IterWrapper(iter);
+}
+function* mergeIterables(iterables, comparator, distinct = false) {
+  const iterators = iterables.map((i) => i[Symbol.iterator]());
+  try {
+    const current = iterators.map((i) => i.next());
+    let lastYielded;
+    while (current.some((c) => !c.done)) {
+      const min = current.reduce(
+        (acc, c, i) => {
+          if (c.done) {
+            return acc;
+          }
+          if (acc === void 0 || comparator(c.value, acc[0]) < 0) {
+            return [c.value, i];
+          }
+          return acc;
+        },
+        void 0
+      );
+      assert(min !== void 0, "min is undefined");
+      current[min[1]] = iterators[min[1]].next();
+      if (lastYielded !== void 0 && distinct && comparator(lastYielded, min[0]) === 0) {
+        continue;
+      }
+      lastYielded = min[0];
+      yield min[0];
+    }
+  } finally {
+    for (const it of iterators) {
+      it.return?.();
+    }
+  }
+}
+
 // ../zql/src/ivm/fan-in.ts
 var FanIn = class {
   #inputs;
@@ -5550,10 +2877,12 @@ var ArrayView = class {
   onDestroy;
   #dirty = false;
   #complete = false;
-  constructor(input, format = { singular: false, relationships: {} }, queryComplete = true) {
+  #updateTTL;
+  constructor(input, format, queryComplete, updateTTL) {
     this.#input = input;
     this.#schema = input.getSchema();
     this.#format = format;
+    this.#updateTTL = updateTTL;
     this.#root = { "": format.singular ? void 0 : [] };
     input.setOutput(this);
     if (queryComplete === true) {
@@ -5615,6 +2944,9 @@ var ArrayView = class {
     this.#dirty = false;
     this.#fireListeners();
   }
+  updateTTL(ttl) {
+    this.#updateTTL(ttl);
+  }
 };
 
 // ../zql/src/query/expression.ts
@@ -5757,8 +3089,8 @@ var negateOperatorMap = {
 function negateOperator(op) {
   return must(negateOperatorMap[op]);
 }
-function filterUndefined(array5) {
-  return array5.filter((e) => e !== void 0);
+function filterUndefined(array3) {
+  return array3.filter((e) => e !== void 0);
 }
 function filterTrue(conditions) {
   return conditions.filter((c) => !isAlwaysTrue(c));
@@ -5821,7 +3153,7 @@ function unwrap(c) {
 }
 
 // ../zql/src/query/query-impl.ts
-var astForTestingSymbol = Symbol();
+var astSymbol = Symbol();
 function newQuery(delegate, schema, table) {
   return new QueryImpl(delegate, schema, table, { table }, defaultFormat);
 }
@@ -5850,8 +3182,7 @@ var AbstractQuery = class {
     this.#ast = ast;
     this.format = format;
   }
-  // Not part of Query or QueryInternal interface
-  get [astForTestingSymbol]() {
+  get [astSymbol]() {
     return this.#ast;
   }
   hash() {
@@ -6242,6 +3573,9 @@ var QueryImpl = class extends AbstractQuery {
         queryCompleteResolver.resolve(true);
       }
     });
+    const updateTTL = (newTTL) => {
+      this.#delegate.updateServerQuery(ast, newTTL);
+    };
     const input = buildPipeline(ast, this.#delegate);
     let removeCommitObserver;
     const onDestroy = () => {
@@ -6258,14 +3592,12 @@ var QueryImpl = class extends AbstractQuery {
         (cb) => {
           removeCommitObserver = this.#delegate.onTransactionCommit(cb);
         },
-        queryGot || queryCompleteResolver.promise
+        queryGot || queryCompleteResolver.promise,
+        updateTTL
       )
     );
     return view;
   }
-  updateTTL(ttl) {
-    this.#delegate.updateServerQuery(this._completeAst(), ttl);
-  }
   run() {
     const v2 = this.materialize();
     const ret = v2.data;
@@ -6311,8 +3643,13 @@ function addPrimaryKeysToAst(schema, ast) {
     orderBy: addPrimaryKeys(schema, ast.orderBy)
   };
 }
-function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit, queryComplete) {
-  const v2 = new ArrayView(input, format, queryComplete);
+function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit, queryComplete, updateTTL) {
+  const v2 = new ArrayView(
+    input,
+    format,
+    queryComplete,
+    updateTTL
+  );
   v2.onDestroy = onDestroy;
   onTransactionCommit(() => {
     v2.flush();
@@ -6325,94 +3662,24 @@ function isCompoundKey(field) {
 
 export {
   isProd,
+  hasOwn,
   deepEqual,
   assertJSONValue,
   assertJSONObject,
-  stringCompare,
-  compareCookies,
-  assertCookie,
-  deepFreeze,
-  deepFreezeAllowUndefined,
   parse,
+  assert2 as assert,
   test,
+  readonly,
   readonlyObject,
   readonlyArray,
+  readonlyRecord,
   valita_exports,
-  emptyHash,
-  newRandomHash,
-  assertHash,
-  Chunk,
-  assertRefs,
-  createChunk,
-  ChunkNotFoundError,
-  mustGetChunk,
-  mustGetHeadHash,
-  DD31,
-  V6,
-  V7,
-  Latest,
   joinIterables,
   wrapIterable,
-  getSizeOfValue,
-  DEFAULT_HEAD_NAME,
-  commitIsLocalDD31,
-  localMutations,
-  localMutationsDD31,
-  localMutationsGreaterThan,
-  baseSnapshotFromHead,
-  baseSnapshotFromHash,
-  baseSnapshotFromCommit,
-  snapshotMetaParts,
-  compareCookiesForSnapshots,
-  commitFromHash,
-  commitFromHead,
-  assertLocalMetaDD31,
-  isLocalMetaDD31,
-  assertSnapshotMetaDD31,
-  assertSnapshotCommitDD31,
-  binarySearch,
-  BTreeRead,
-  encodeIndexScanKey,
-  decodeIndexKey,
-  readFromDefaultHead,
-  readFromHash,
-  asyncIterableToArray,
-  diff,
-  DiffsMap,
-  diff2,
-  diffCommits,
-  addDiffsForIndexes,
-  newWriteLocal,
-  newWriteSnapshotDD31,
-  getClientGroups,
-  setClientGroups,
-  setClientGroup,
-  getClientGroup,
-  clientGroupHasPendingMutations,
-  disableClientGroup,
-  withRead,
-  withWriteNoImplicitCommit,
-  withWrite,
-  using,
   jsonSchema,
   jsonObjectSchema,
-  clientGroupIDSchema,
-  clientIDSchema,
-  makeClientID,
-  assertClientV6,
-  getClients,
-  ClientStateNotFoundError,
-  assertHasClientState,
-  hasClientState,
-  getClient,
-  mustGetClient,
-  initClientV6,
-  getClientGroupForClient,
-  getClientGroupIDForClient,
-  setClient,
-  setClients,
-  getNonCryptoRandomValues,
   h64,
+  h128,
   rowSchema,
   toStaticParam,
   astSchema,
@@ -6425,22 +3692,14 @@ export {
   transformFilters,
   assertOrderingIncludesPK,
   ExpressionBuilder,
+  DEFAULT_TTL,
+  parseTTL,
+  compareTTL,
+  normalizeTTL,
   newQuery,
   staticParam,
   SUBQ_PREFIX,
   defaultFormat,
-  AbstractQuery,
-  inspectQueriesDownSchema,
-  inspectDownMessageSchema,
-  primaryKeySchema,
-  primaryKeyValueRecordSchema,
-  nanoid,
-  GOT_QUERIES_KEY_PREFIX,
-  ENTITIES_KEY_PREFIX,
-  toDesiredQueriesKey,
-  desiredQueriesPrefixForClient,
-  toGotQueriesKey,
-  toPrimaryKeyString,
-  sourceNameFromKey
+  AbstractQuery
 };
-//# sourceMappingURL=chunk-JW7AJ755.js.map
+//# sourceMappingURL=chunk-GTRWLUIW.js.map