@rocicorp/zero 0.19.2025040901 → 0.19.2025041102

package/out/chunk-J3DNXL5V.js

@@ -0,0 +1,2843 @@
+import {
+  assert as assert2,
+  assertJSONObject,
+  assertJSONValue,
+  astSchema,
+  deepEqual,
+  h128,
+  hasOwn,
+  isProd,
+  joinIterables,
+  parse,
+  readonly,
+  readonlyArray,
+  readonlyObject,
+  readonlyRecord,
+  valita_exports
+} from "./chunk-GTRWLUIW.js";
+import {
+  assert,
+  assertArray,
+  assertBoolean,
+  assertNumber,
+  assertObject,
+  assertString,
+  throwInvalidType,
+  unreachable
+} from "./chunk-SKR5JO2A.js";
+
+// ../replicache/src/dag/store.ts
+var ChunkNotFoundError = class extends Error {
+  name = "ChunkNotFoundError";
+  hash;
+  constructor(hash) {
+    super(`Chunk not found ${hash}`);
+    this.hash = hash;
+  }
+};
+async function mustGetChunk(store, hash) {
+  const chunk = await store.getChunk(hash);
+  if (chunk) {
+    return chunk;
+  }
+  throw new ChunkNotFoundError(hash);
+}
+async function mustGetHeadHash(name, store) {
+  const hash = await store.getHead(name);
+  assert(hash, `Missing head ${name}`);
+  return hash;
+}
+
+// ../replicache/src/format-version-enum.ts
+var DD31 = 5;
+var V6 = 6;
+var V7 = 7;
+var Latest = V7;
+
+// ../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";
+
+// ../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(v) {
+  if (isProd) {
+    return v;
+  }
+  deepFreezeInternal(v, []);
+  return v;
+}
+function deepFreezeInternal(v, seen) {
+  switch (typeof v) {
+    case "undefined":
+      throw new TypeError("Unexpected value undefined");
+    case "boolean":
+    case "number":
+    case "string":
+      return;
+    case "object": {
+      if (v === null) {
+        return;
+      }
+      if (deepFrozenObjects.has(v)) {
+        return;
+      }
+      deepFrozenObjects.add(v);
+      if (seen.includes(v)) {
+        throwInvalidType(v, "Cyclic JSON object");
+      }
+      seen.push(v);
+      Object.freeze(v);
+      if (Array.isArray(v)) {
+        deepFreezeArray(v, seen);
+      } else {
+        deepFreezeObject(v, seen);
+      }
+      seen.pop();
+      return;
+    }
+    default:
+      throwInvalidType(v, "JSON value");
+  }
+}
+function deepFreezeArray(v, seen) {
+  for (const item of v) {
+    deepFreezeInternal(item, seen);
+  }
+}
+function deepFreezeObject(v, seen) {
+  for (const k in v) {
+    if (hasOwn(v, k)) {
+      const value = v[k];
+      if (value !== void 0) {
+        deepFreezeInternal(value, seen);
+      }
+    }
+  }
+}
+function assertDeepFrozen(v) {
+  if (isProd) {
+    return;
+  }
+  if (!isDeepFrozen(v, [])) {
+    throw new Error("Expected frozen object");
+  }
+}
+function isDeepFrozen(v, seen) {
+  switch (typeof v) {
+    case "boolean":
+    case "number":
+    case "string":
+      return true;
+    case "object":
+      if (v === null) {
+        return true;
+      }
+      if (deepFrozenObjects.has(v)) {
+        return true;
+      }
+      if (!Object.isFrozen(v)) {
+        return false;
+      }
+      if (seen.includes(v)) {
+        throwInvalidType(v, "Cyclic JSON object");
+      }
+      seen.push(v);
+      if (Array.isArray(v)) {
+        for (const item of v) {
+          if (!isDeepFrozen(item, seen)) {
+            seen.pop();
+            return false;
+          }
+        }
+      } else {
+        for (const k in v) {
+          if (hasOwn(v, k)) {
+            const value = v[k];
+            if (value !== void 0 && !isDeepFrozen(value, seen)) {
+              seen.pop();
+              return false;
+            }
+          }
+        }
+      }
+      deepFrozenObjects.add(v);
+      seen.pop();
+      return true;
+    default:
+      throwInvalidType(v, "JSON value");
+  }
+}
+function deepFreezeAllowUndefined(v) {
+  if (v === void 0) {
+    return void 0;
+  }
+  return deepFreeze(v);
+}
+
+// ../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, hash, source, expectedRootHash) {
+  const node = await source.getNode(hash);
+  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(v, formatVersion, getSizeOfEntry2) {
+  if (isProd && formatVersion >= V7) {
+    return v;
+  }
+  assertArray(v);
+  assertDeepFrozen(v);
+  assert(v.length >= 2);
+  const [level, entries] = v;
+  assertNumber(level);
+  assertArray(entries);
+  const f = level > 0 ? assertString : assertJSONValue;
+  if (formatVersion >= V7) {
+    for (const e of entries) {
+      assertEntry(e, f);
+    }
+    return v;
+  }
+  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, hash, isMutable) {
+    this.entries = entries;
+    this.hash = hash;
+    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(array3, start, deleteCount, ...items) {
+  const arr = array3.slice(0, start);
+  for (let i = 0; i < items.length; i++) {
+    arr.push(items[i]);
+  }
+  for (let i = start + deleteCount; i < array3.length; i++) {
+    arr.push(array3[i]);
+  }
+  return arr;
+}
+var InternalNodeImpl = class _InternalNodeImpl extends NodeImpl {
+  level;
+  constructor(entries, hash, level, isMutable) {
+    super(entries, hash, 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 hash = thisEntries[i - 1][1];
+      const previousSibling = await tree.getNode(hash);
+      values = joinIterables(
+        previousSibling.entries,
+        childNode.entries
+      );
+      startIndex = i - 1;
+      removeCount = 2;
+    } else if (i < thisEntries.length - 1) {
+      const hash = thisEntries[i + 1][1];
+      const nextSibling = await tree.getNode(hash);
+      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, hash, level, isMutable) {
+  if (level === 0) {
+    return new DataNodeImpl(
+      entries,
+      hash,
+      isMutable
+    );
+  }
+  return new InternalNodeImpl(entries, hash, 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(hash) {
+    if (hash === emptyHash) {
+      return emptyDataNodeImpl;
+    }
+    const cached = this._cache.get(hash);
+    if (cached) {
+      return cached;
+    }
+    const chunk = await this._dagRead.mustGetChunk(hash);
+    const data = parseBTreeNode(
+      chunk.data,
+      this._formatVersion,
+      this.getEntrySize
+    );
+    const impl = newNodeImpl(
+      data[NODE_ENTRIES],
+      hash,
+      data[NODE_LEVEL],
+      false
+    );
+    this._cache.set(hash, 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 (hash) => {
+        const cached = await this.getNode(hash);
+        if (cached) {
+          return [
+            cached.level,
+            cached.isMutable ? cached.entries.slice() : cached.entries
+          ];
+        }
+        const chunk = await this._dagRead.mustGetChunk(hash);
+        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, hash, fromKey, readNode) {
+  if (hash === emptyHash) {
+    return;
+  }
+  const data = await readNode(hash);
+  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(v) {
+  if (v === null || typeof v === "string" || typeof v === "number") {
+    return;
+  }
+  assertJSONObject(v);
+  if (typeof v.order === "string" || typeof v.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(hash, data, refs) {
+    assert(
+      !refs.includes(hash),
+      "Chunk cannot reference itself"
+    );
+    assertDeepFrozen(data);
+    this.hash = hash;
+    this.data = data;
+    this.meta = refs;
+  }
+};
+function assertRefs(v) {
+  if (!Array.isArray(v)) {
+    throw new Error("Refs must be an array");
+  }
+  if (v.length > 0) {
+    assertString(v[0]);
+    for (let i = 1; i < v.length; i++) {
+      assertString(v[i]);
+    }
+  }
+}
+function createChunk(data, refs, chunkHasher) {
+  const hash = chunkHasher();
+  return new Chunk(hash, 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 hash = await dagRead.getHead(name);
+  assert(hash, `Missing head ${name}`);
+  return baseSnapshotFromHash(hash, dagRead);
+}
+async function baseSnapshotHashFromHash(hash, dagRead) {
+  return (await baseSnapshotFromHash(hash, dagRead)).chunk.hash;
+}
+async function baseSnapshotFromHash(hash, dagRead) {
+  const commit = await commitFromHash(hash, 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(hash, dagRead) {
+  const chunk = await dagRead.mustGetChunk(hash);
+  return fromChunk(chunk);
+}
+async function commitFromHead(name, dagRead) {
+  const hash = await mustGetHeadHash(name, dagRead);
+  return commitFromHash(hash, dagRead);
+}
+function assertLocalMetaDD31(v) {
+  assertString(v.clientID);
+  assertNumber(v.mutationID);
+  assertString(v.mutatorName);
+  if (!v.mutatorName) {
+    throw new Error("Missing mutator name");
+  }
+  assertJSONValue(v.mutatorArgsJSON);
+  if (v.originalHash !== null) {
+    assertHash(v.originalHash);
+  }
+  assertNumber(v.timestamp);
+}
+function isLocalMetaDD31(meta) {
+  return meta.type === LocalDD31;
+}
+function assertSnapshotMetaDD31(v) {
+  if (v.basisHash !== null) {
+    assertHash(v.basisHash);
+  }
+  assertJSONValue(v.cookieJSON);
+  assertLastMutationIDs(v.lastMutationIDs);
+}
+function assertLastMutationIDs(v) {
+  assertObject(v);
+  for (const e of Object.values(v)) {
+    assertNumber(e);
+  }
+}
+function assertSnapshotCommitDD31(c) {
+  assertSnapshotMetaDD31(c.meta);
+}
+function isSnapshotMetaDD31(meta) {
+  return meta.type === SnapshotDD31;
+}
+function assertMeta(v) {
+  assertObject(v);
+  assertDeepFrozen(v);
+  if (v.basisHash !== null) {
+    assertString(v.basisHash);
+  }
+  assertNumber(v.type);
+  switch (v.type) {
+    case LocalDD31:
+      assertLocalMetaDD31(v);
+      break;
+    case SnapshotDD31:
+      assertSnapshotMetaDD31(v);
+      break;
+    default:
+      throw new Error(`Invalid enum value ${v.type}`);
+  }
+}
+function chunkIndexDefinitionEqualIgnoreName(a, b) {
+  return a.jsonPointer === b.jsonPointer && (a.allowEmpty ?? false) === (b.allowEmpty ?? false) && a.keyPrefix === b.keyPrefix;
+}
+function assertChunkIndexDefinition(v) {
+  assertObject(v);
+  assertDeepFrozen(v);
+  assertString(v.name);
+  assertString(v.keyPrefix);
+  assertString(v.jsonPointer);
+  if (v.allowEmpty !== void 0) {
+    assertBoolean(v.allowEmpty);
+  }
+}
+function toChunkIndexDefinition(name, indexDefinition) {
+  return {
+    name,
+    keyPrefix: indexDefinition.prefix ?? "",
+    jsonPointer: indexDefinition.jsonPointer,
+    allowEmpty: indexDefinition.allowEmpty ?? false
+  };
+}
+function assertIndexRecord(v) {
+  assertObject(v);
+  assertDeepFrozen(v);
+  assertChunkIndexDefinition(v.definition);
+  assertString(v.valueHash);
+}
+function assertIndexRecords(v) {
+  assertArray(v);
+  assertDeepFrozen(v);
+  for (const ir of v) {
+    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(v) {
+  if (isProd) {
+    return;
+  }
+  assertObject(v);
+  assertDeepFrozen(v);
+  assertMeta(v.meta);
+  assertString(v.valueHash);
+  assertIndexRecords(v.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(hash, dagRead, formatVersion) {
+  const commit = await commitFromHash(hash, 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(hash, dagRead) {
+  const chunk = await dagRead.getChunk(hash);
+  return chunkDataToClientGroupMap(chunk?.data);
+}
+async function getClientGroups(dagRead) {
+  const hash = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
+  if (!hash) {
+    return /* @__PURE__ */ new Map();
+  }
+  return getClientGroupsAtHash(hash, 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 v of it) {
+    arr.push(v);
+  }
+  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(hash, newChunks, createChunk2, modified, formatVersion) {
+  const node = modified.get(hash);
+  if (node === void 0) {
+    return hash;
+  }
+  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);
+      }
+    }
+  }
+  return deepFreeze(Object.fromEntries(clients));
+}
+async function getClients(dagRead) {
+  const hash = await dagRead.getHead(CLIENTS_HEAD_NAME);
+  return getClientsAtHash(hash, dagRead);
+}
+async function getClientsAtHash(hash, dagRead) {
+  if (!hash) {
+    return /* @__PURE__ */ new Map();
+  }
+  const chunk = await dagRead.getChunk(hash);
+  return chunkDataToClientMap(chunk?.data);
+}
+var ClientStateNotFoundError = class extends Error {
+  name = "ClientStateNotFoundError";
+  id;
+  constructor(id) {
+    super(`Client state not found, id: ${id}`);
+    this.id = id;
+  }
+};
+async function assertHasClientState(id, dagRead) {
+  if (!await hasClientState(id, dagRead)) {
+    throw new ClientStateNotFoundError(id);
+  }
+}
+async function hasClientState(id, dagRead) {
+  return !!await getClient(id, dagRead);
+}
+async function getClient(id, dagRead) {
+  const clients = await getClients(dagRead);
+  return clients.get(id);
+}
+async function mustGetClient(id, dagRead) {
+  const client = await getClient(id, dagRead);
+  if (!client) {
+    throw new ClientStateNotFoundError(id);
+  }
+  return client;
+}
+function initClientV6(newClientID, lc, perdag, mutatorNames, indexes, formatVersion, enableClientGroupForking) {
+  return 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
+        });
+      }
+      return setClientsAndClientGroupAndCommit(
+        null,
+        null,
+        emptyBTreeChunk.hash,
+        indexRecords2
+      );
+    }
+    assert(res.type === FIND_MATCHING_CLIENT_TYPE_FORK);
+    const { snapshot } = res;
+    const indexRecords = [];
+    const { valueHash, indexes: oldIndexes } = snapshot;
+    const map = new BTreeRead(dagWrite, formatVersion, valueHash);
+    for (const [name, indexDefinition] of Object.entries(indexes)) {
+      const { prefix = "", jsonPointer, allowEmpty = false } = indexDefinition;
+      const chunkIndexDefinition = {
+        name,
+        keyPrefix: prefix,
+        jsonPointer,
+        allowEmpty
+      };
+      const oldIndex = findMatchingOldIndex(oldIndexes, chunkIndexDefinition);
+      if (oldIndex) {
+        indexRecords.push({
+          definition: chunkIndexDefinition,
+          valueHash: oldIndex.valueHash
+        });
+      } else {
+        const indexBTree = await createIndexBTree(
+          lc,
+          dagWrite,
+          map,
+          prefix,
+          jsonPointer,
+          allowEmpty,
+          formatVersion
+        );
+        indexRecords.push({
+          definition: chunkIndexDefinition,
+          valueHash: await indexBTree.flush()
+        });
+      }
+    }
+    return setClientsAndClientGroupAndCommit(
+      snapshot.meta.basisHash,
+      snapshot.meta.cookieJSON,
+      snapshot.valueHash,
+      indexRecords
+    );
+  });
+}
+function findMatchingOldIndex(oldIndexes, chunkIndexDefinition) {
+  return oldIndexes.find(
+    (index) => chunkIndexDefinitionEqualIgnoreName(index.definition, chunkIndexDefinition)
+  );
+}
+var FIND_MATCHING_CLIENT_TYPE_NEW = 0;
+var FIND_MATCHING_CLIENT_TYPE_FORK = 1;
+var FIND_MATCHING_CLIENT_TYPE_HEAD = 2;
+async function findMatchingClient(dagRead, mutatorNames, indexes) {
+  let newestCookie;
+  let bestSnapshot;
+  const mutatorNamesSet = new Set(mutatorNames);
+  const clientGroups = await getClientGroups(dagRead);
+  for (const [clientGroupID, clientGroup] of clientGroups) {
+    if (!clientGroup.disabled && mutatorNamesEqual(mutatorNamesSet, clientGroup.mutatorNames) && indexDefinitionsEqual(indexes, clientGroup.indexes)) {
+      return {
+        type: FIND_MATCHING_CLIENT_TYPE_HEAD,
+        clientGroupID,
+        headHash: clientGroup.headHash
+      };
+    }
+    const clientGroupSnapshotCommit = await baseSnapshotFromHash(
+      clientGroup.headHash,
+      dagRead
+    );
+    assertSnapshotCommitDD31(clientGroupSnapshotCommit);
+    const { cookieJSON } = clientGroupSnapshotCommit.meta;
+    if (newestCookie === void 0 || compareCookies(cookieJSON, newestCookie) > 0) {
+      newestCookie = cookieJSON;
+      bestSnapshot = clientGroupSnapshotCommit;
+    }
+  }
+  if (bestSnapshot) {
+    return {
+      type: FIND_MATCHING_CLIENT_TYPE_FORK,
+      snapshot: bestSnapshot
+    };
+  }
+  return { type: FIND_MATCHING_CLIENT_TYPE_NEW };
+}
+function getRefsForClients(clients) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const client of clients.values()) {
+    if (isClientV6(client)) {
+      for (const hash of client.refreshHashes) {
+        refs.add(hash);
+      }
+      if (client.persistHash) {
+        refs.add(client.persistHash);
+      }
+    } else {
+      refs.add(client.headHash);
+      if (client.tempRefreshHash) {
+        refs.add(client.tempRefreshHash);
+      }
+    }
+  }
+  return toRefs(refs);
+}
+async function getClientGroupForClient(clientID, read) {
+  const clientGroupID = await getClientGroupIDForClient(clientID, read);
+  if (!clientGroupID) {
+    return void 0;
+  }
+  return getClientGroup(clientGroupID, read);
+}
+async function getClientGroupIDForClient(clientID, read) {
+  const client = await getClient(clientID, read);
+  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;
+}
+
+// ../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(array3) {
+  if (array3 === null) {
+    throw new TypeError("array cannot be null");
+  }
+  for (let i = 0; i < array3.length; i++) {
+    array3[i] = Math.floor(Math.random() * 256);
+  }
+  return array3;
+}
+
+// ../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;
+  }, "");
+}
+
+// ../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, hash) {
+  return DESIRED_QUERIES_KEY_PREFIX + clientID + "/" + hash;
+}
+function desiredQueriesPrefixForClient(clientID) {
+  return DESIRED_QUERIES_KEY_PREFIX + clientID + "/";
+}
+function toGotQueriesKey(hash) {
+  return GOT_QUERIES_KEY_PREFIX + hash;
+}
+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);
+}
+
+export {
+  stringCompare,
+  compareCookies,
+  assertCookie,
+  deepFreeze,
+  deepFreezeAllowUndefined,
+  emptyHash,
+  newRandomHash,
+  assertHash,
+  Chunk,
+  assertRefs,
+  createChunk,
+  ChunkNotFoundError,
+  mustGetChunk,
+  mustGetHeadHash,
+  DD31,
+  V6,
+  V7,
+  Latest,
+  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,
+  clientGroupIDSchema,
+  clientIDSchema,
+  makeClientID,
+  assertClientV6,
+  getClients,
+  ClientStateNotFoundError,
+  assertHasClientState,
+  hasClientState,
+  getClient,
+  mustGetClient,
+  initClientV6,
+  getClientGroupForClient,
+  getClientGroupIDForClient,
+  setClient,
+  setClients,
+  getNonCryptoRandomValues,
+  inspectQueriesDownSchema,
+  inspectDownMessageSchema,
+  primaryKeySchema,
+  primaryKeyValueRecordSchema,
+  nanoid,
+  GOT_QUERIES_KEY_PREFIX,
+  ENTITIES_KEY_PREFIX,
+  toDesiredQueriesKey,
+  desiredQueriesPrefixForClient,
+  toGotQueriesKey,
+  toPrimaryKeyString,
+  sourceNameFromKey
+};
+//# sourceMappingURL=chunk-J3DNXL5V.js.map