@rocicorp/zero 0.25.0 → 0.26.0-canary.0

package/out/chunk-TJFNGO7E.js

@@ -1,4126 +0,0 @@
-import {
-  assert,
-  assertArray,
-  assertBoolean,
-  assertDeepFrozen,
-  assertNumber,
-  assertObject,
-  assertString,
-  deepFreeze,
-  hasOwn,
-  isProd,
-  throwInvalidType,
-  unreachable
-} from "./chunk-EZM3XBAB.js";
-import {
-  __export,
-  __reExport
-} from "./chunk-424PT5DM.js";
-
-// ../replicache/src/format-version-enum.ts
-var DD31 = 5;
-var V6 = 6;
-var V7 = 7;
-var Latest = V7;
-
-// ../shared/src/valita.ts
-var valita_exports = {};
-__export(valita_exports, {
-  assert: () => assert2,
-  deepPartial: () => deepPartial,
-  instanceOfAbstractType: () => instanceOfAbstractType,
-  is: () => is,
-  literalUnion: () => literalUnion,
-  parse: () => parse,
-  readonly: () => readonly,
-  readonlyArray: () => readonlyArray,
-  readonlyObject: () => readonlyObject,
-  readonlyRecord: () => readonlyRecord,
-  test: () => test,
-  testOptional: () => testOptional
-});
-__reExport(valita_exports, valita_star);
-import * as v from "@badrap/valita";
-import * as valita_star from "@badrap/valita";
-function toDisplay(value) {
-  switch (typeof value) {
-    case "string":
-    case "number":
-    case "boolean":
-      return JSON.stringify(value);
-    case "undefined":
-      return "undefined";
-    case "bigint":
-      return value.toString() + "n";
-    default:
-      if (value === null) {
-        return "null";
-      }
-      if (Array.isArray(value)) {
-        return "array";
-      }
-      return typeof value;
-  }
-}
-function toDisplayAtPath(v2, path2) {
-  if (!path2?.length) {
-    return toDisplay(v2);
-  }
-  let cur = v2;
-  for (const p of path2) {
-    cur = cur[p];
-  }
-  return toDisplay(cur);
-}
-function displayList(word, expected, toDisplay2 = (x) => String(x)) {
-  if (expected.length === 1) {
-    return toDisplay2(expected[0]);
-  }
-  const suffix = `${toDisplay2(
-    expected[expected.length - 2]
-  )} ${word} ${toDisplay2(expected[expected.length - 1])}`;
-  if (expected.length === 2) {
-    return suffix;
-  }
-  return `${expected.slice(0, -2).map(toDisplay2).join(", ")}, ${suffix}`;
-}
-function getMessage(err2, v2, schema, mode) {
-  const firstIssue = err2.issues[0];
-  const { path: path2 } = firstIssue;
-  const atPath = path2?.length ? ` at ${path2.join(".")}` : "";
-  switch (firstIssue.code) {
-    case "invalid_type":
-      return `Expected ${displayList(
-        "or",
-        firstIssue.expected
-      )}${atPath}. Got ${toDisplayAtPath(v2, path2)}`;
-    case "missing_value": {
-      const atPath2 = path2 && path2.length > 1 ? ` at ${path2.slice(0, -1).join(".")}` : "";
-      if (firstIssue.path?.length) {
-        return `Missing property ${firstIssue.path.at(-1)}${atPath2}`;
-      }
-      return `TODO Unknown missing property${atPath2}`;
-    }
-    case "invalid_literal":
-      return `Expected literal value ${displayList(
-        "or",
-        firstIssue.expected,
-        toDisplay
-      )}${atPath} Got ${toDisplayAtPath(v2, path2)}`;
-    case "invalid_length": {
-      return `Expected array with length ${firstIssue.minLength === firstIssue.maxLength ? firstIssue.minLength : `between ${firstIssue.minLength} and ${firstIssue.maxLength}`}${atPath}. Got array with length ${v2.length}`;
-    }
-    case "unrecognized_keys":
-      if (firstIssue.keys.length === 1) {
-        return `Unexpected property ${firstIssue.keys[0]}${atPath}`;
-      }
-      return `Unexpected properties ${displayList(
-        "and",
-        firstIssue.keys
-      )}${atPath}`;
-    case "invalid_union":
-      return schema.name === "union" ? getDeepestUnionParseError(v2, schema, mode ?? "strict") : `Invalid union value${atPath}`;
-    case "custom_error": {
-      const { error } = firstIssue;
-      const message = !error ? "unknown" : typeof error === "string" ? error : error.message ?? "unknown";
-      return `${message}${atPath}. Got ${toDisplayAtPath(v2, path2)}`;
-    }
-  }
-}
-function getDeepestUnionParseError(value, schema, mode) {
-  const failures = [];
-  for (const type of schema.options) {
-    const r = type.try(value, { mode });
-    if (!r.ok) {
-      failures.push({ type, err: r });
-    }
-  }
-  if (failures.length) {
-    failures.sort(pathCmp);
-    if (failures.length === 1 || pathCmp(failures[0], failures[1]) < 0) {
-      return getMessage(failures[0].err, value, failures[0].type, mode);
-    }
-  }
-  try {
-    const str = JSON.stringify(value);
-    return `Invalid union value: ${str}`;
-  } catch {
-    return `Invalid union value`;
-  }
-}
-function pathCmp(a, b) {
-  const aPath = a.err.issues[0].path;
-  const bPath = b.err.issues[0].path;
-  if (aPath.length !== bPath.length) {
-    return bPath.length - aPath.length;
-  }
-  for (let i = 0; i < aPath.length; i++) {
-    if (bPath[i] > aPath[i]) {
-      return -1;
-    }
-    if (bPath[i] < aPath[i]) {
-      return 1;
-    }
-  }
-  return 0;
-}
-function parse(value, schema, mode) {
-  const res = test(value, schema, mode);
-  if (!res.ok) {
-    throw new TypeError(res.error);
-  }
-  return res.value;
-}
-function is(value, schema, mode) {
-  return test(value, schema, mode).ok;
-}
-function assert2(value, schema, mode) {
-  parse(value, schema, mode);
-}
-function test(value, schema, mode) {
-  const res = schema.try(value, mode ? { mode } : void 0);
-  if (!res.ok) {
-    return {
-      ok: false,
-      error: getMessage(res, value, schema, mode)
-    };
-  }
-  return res;
-}
-function testOptional(value, schema, mode) {
-  let flags = 1;
-  if (mode === "passthrough") {
-    flags = 0;
-  } else if (mode === "strip") {
-    flags = 2;
-  }
-  const res = schema.func(value, flags);
-  if (res === void 0) {
-    return { ok: true, value };
-  } else if (res.ok) {
-    return res;
-  }
-  const err2 = new v.ValitaError(res);
-  return { ok: false, error: getMessage(err2, value, schema, mode) };
-}
-function readonly(t) {
-  return t;
-}
-function readonlyObject(t) {
-  return v.object(t);
-}
-function readonlyArray(t) {
-  return v.array(t);
-}
-function readonlyRecord(t) {
-  return v.record(t);
-}
-var AbstractType = Object.getPrototypeOf(
-  Object.getPrototypeOf(v.string().optional())
-).constructor;
-function instanceOfAbstractType(obj) {
-  return obj instanceof AbstractType;
-}
-function deepPartial(s) {
-  const shape = {};
-  for (const [key, type] of Object.entries(s.shape)) {
-    if (type.name === "object") {
-      shape[key] = deepPartial(type).optional();
-    } else {
-      shape[key] = type.optional();
-    }
-  }
-  return v.object(shape);
-}
-function literalUnion(...literals) {
-  return v.union(...literals.map(v.literal));
-}
-
-// ../shared/src/json.ts
-function deepEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (typeof a !== typeof b) {
-    return false;
-  }
-  switch (typeof a) {
-    case "boolean":
-    case "number":
-    case "string":
-      return false;
-  }
-  a = a;
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b)) {
-      return false;
-    }
-    if (a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (a === null || b === null) {
-    return false;
-  }
-  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/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);
-}
-
-// ../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/btree/node.ts
-import { compareUTF8 } from "compare-utf8";
-
-// ../shared/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;
-}
-
-// ../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++);
-  }
-}
-function* once(stream) {
-  const it = stream[Symbol.iterator]();
-  const { value } = it.next();
-  if (value !== void 0) {
-    yield value;
-  }
-  it.return?.();
-}
-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/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(array7, start, deleteCount, ...items) {
-  const arr = array7.slice(0, start);
-  for (let i = 0; i < items.length; i++) {
-    arr.push(items[i]);
-  }
-  for (let i = start + deleteCount; i < array7.length; i++) {
-    arr.push(array7[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/dag/store.ts
-var ChunkNotFoundError = class extends Error {
-  name = "ChunkNotFoundError";
-  hash;
-  constructor(hash2) {
-    super(`Chunk not found ${hash2}`);
-    this.hash = hash2;
-  }
-};
-async function mustGetChunk(store, hash2) {
-  const chunk = await store.getChunk(hash2);
-  if (chunk) {
-    return chunk;
-  }
-  throw new ChunkNotFoundError(hash2);
-}
-async function mustGetHeadHash(name, store) {
-  const hash2 = await store.getHead(name);
-  assert(hash2, `Missing head ${name}`);
-  return hash2;
-}
-
-// ../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/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/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/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);
-      }
-    }
-  }
-  return deepFreeze(Object.fromEntries(clients));
-}
-async function getClients(dagRead) {
-  const hash2 = await dagRead.getHead(CLIENTS_HEAD_NAME);
-  return getClientsAtHash(hash2, dagRead);
-}
-async function getClientsAtHash(hash2, dagRead) {
-  if (!hash2) {
-    return /* @__PURE__ */ new Map();
-  }
-  const chunk = await dagRead.getChunk(hash2);
-  return chunkDataToClientMap(chunk?.data);
-}
-var ClientStateNotFoundError = class extends Error {
-  name = "ClientStateNotFoundError";
-  id;
-  constructor(id) {
-    super(`Client state not found, id: ${id}`);
-    this.id = id;
-  }
-};
-async function assertHasClientState(id, dagRead) {
-  if (!await hasClientState(id, dagRead)) {
-    throw new ClientStateNotFoundError(id);
-  }
-}
-async function hasClientState(id, dagRead) {
-  return !!await getClient(id, dagRead);
-}
-async function getClient(id, dagRead) {
-  const clients = await getClients(dagRead);
-  return clients.get(id);
-}
-async function mustGetClient(id, dagRead) {
-  const client = await getClient(id, dagRead);
-  if (!client) {
-    throw new ClientStateNotFoundError(id);
-  }
-  return client;
-}
-function initClientV6(newClientID, lc, perdag, mutatorNames, indexes, formatVersion, enableClientGroupForking) {
-  return 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 hash2 of client.refreshHashes) {
-        refs.add(hash2);
-      }
-      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;
-}
-
-// ../shared/src/objects.ts
-function mapValues(input, mapper) {
-  return mapEntries(input, (k, v2) => [k, mapper(v2)]);
-}
-function mapEntries(input, mapper) {
-  const output = {};
-  for (const entry of Object.entries(input)) {
-    const mapped = mapper(entry[0], entry[1]);
-    output[mapped[0]] = mapped[1];
-  }
-  return output;
-}
-function mapAllEntries(input, mapper) {
-  const output = {};
-  for (const mapped of mapper(Object.entries(input))) {
-    output[mapped[0]] = mapped[1];
-  }
-  return output;
-}
-
-// ../shared/src/json-schema.ts
-import * as valita from "@badrap/valita";
-var path = [];
-var jsonSchema = valita_exports.unknown().chain((v2) => {
-  if (isProd) {
-    return valita.ok(v2);
-  }
-  const rv = isJSONValue(v2, path) ? valita.ok(v2) : valita.err({
-    message: `Not a JSON value`,
-    path: path.slice()
-  });
-  path.length = 0;
-  return rv;
-});
-var jsonObjectSchema = valita_exports.unknown().chain((v2) => {
-  if (isProd) {
-    return valita.ok(v2);
-  }
-  const rv = isJSONObject(v2, path) ? valita.ok(v2) : valita.err({
-    message: `Not a JSON object`,
-    path: path.slice()
-  });
-  path.length = 0;
-  return rv;
-});
-
-// ../shared/src/tdigest-schema.ts
-var tdigestSchema = valita_exports.tuple([valita_exports.number()]).concat(valita_exports.array(valita_exports.number()));
-
-// ../zero-protocol/src/data.ts
-var valueSchema = valita_exports.union(jsonSchema, valita_exports.undefined());
-var rowSchema = readonlyRecord(valueSchema);
-
-// ../zero-protocol/src/analyze-query-result.ts
-var rowCountsByQuerySchema = valita_exports.record(valita_exports.number());
-var rowCountsBySourceSchema = valita_exports.record(rowCountsByQuerySchema);
-var rowsByQuerySchema = valita_exports.record(valita_exports.array(rowSchema));
-var rowsBySourceSchema = valita_exports.record(rowsByQuerySchema);
-var analyzeQueryResultSchema = valita_exports.object({
-  warnings: valita_exports.array(valita_exports.string()),
-  syncedRows: valita_exports.record(valita_exports.array(rowSchema)).optional(),
-  syncedRowCount: valita_exports.number(),
-  start: valita_exports.number(),
-  /** @deprecated Use start + elapsed instead */
-  end: valita_exports.number(),
-  elapsed: valita_exports.number().optional(),
-  afterPermissions: valita_exports.string().optional(),
-  /** @deprecated Use readRowCountsByQuery */
-  vendedRowCounts: rowCountsBySourceSchema.optional(),
-  /** @deprecated Use readRows */
-  vendedRows: rowsBySourceSchema.optional(),
-  plans: valita_exports.record(valita_exports.array(valita_exports.string())).optional(),
-  readRows: rowsBySourceSchema.optional(),
-  readRowCountsByQuery: rowCountsBySourceSchema.optional(),
-  readRowCount: valita_exports.number().optional()
-});
-
-// ../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);
-    }
-  }
-  return defined2;
-}
-function areEqual(arr1, arr2) {
-  return arr1.length === arr2.length && arr1.every((e, i) => e === arr2[i]);
-}
-
-// ../shared/src/must.ts
-function must(v2, msg) {
-  if (v2 == null) {
-    throw new Error(msg ?? `Unexpected ${v2} value`);
-  }
-  return v2;
-}
-
-// ../zero-protocol/src/ast.ts
-var SUBQ_PREFIX = "zsubq_";
-var selectorSchema = valita_exports.string();
-var toStaticParam = Symbol();
-var planIdSymbol = Symbol("planId");
-var orderingElementSchema = readonly(
-  valita_exports.tuple([selectorSchema, literalUnion("asc", "desc")])
-);
-var orderingSchema = readonlyArray(orderingElementSchema);
-var primitiveSchema = valita_exports.union(
-  valita_exports.string(),
-  valita_exports.number(),
-  valita_exports.boolean(),
-  valita_exports.null()
-);
-var equalityOpsSchema = literalUnion("=", "!=", "IS", "IS NOT");
-var orderOpsSchema = literalUnion("<", ">", "<=", ">=");
-var likeOpsSchema = literalUnion(
-  "LIKE",
-  "NOT LIKE",
-  "ILIKE",
-  "NOT ILIKE"
-);
-var inOpsSchema = literalUnion("IN", "NOT IN");
-var simpleOperatorSchema = valita_exports.union(
-  equalityOpsSchema,
-  orderOpsSchema,
-  likeOpsSchema,
-  inOpsSchema
-);
-var literalReferenceSchema = readonlyObject({
-  type: valita_exports.literal("literal"),
-  value: valita_exports.union(
-    valita_exports.string(),
-    valita_exports.number(),
-    valita_exports.boolean(),
-    valita_exports.null(),
-    readonlyArray(valita_exports.union(valita_exports.string(), valita_exports.number(), valita_exports.boolean()))
-  )
-});
-var columnReferenceSchema = readonlyObject({
-  type: valita_exports.literal("column"),
-  name: valita_exports.string()
-});
-var parameterReferenceSchema = readonlyObject({
-  type: valita_exports.literal("static"),
-  // The "namespace" of the injected parameter.
-  // Write authorization will send the value of a row
-  // prior to the mutation being run (preMutationRow).
-  // Read and write authorization will both send the
-  // current authentication data (authData).
-  anchor: literalUnion("authData", "preMutationRow"),
-  field: valita_exports.union(valita_exports.string(), valita_exports.array(valita_exports.string()))
-});
-var conditionValueSchema = valita_exports.union(
-  literalReferenceSchema,
-  columnReferenceSchema,
-  parameterReferenceSchema
-);
-var simpleConditionSchema = readonlyObject({
-  type: valita_exports.literal("simple"),
-  op: simpleOperatorSchema,
-  left: conditionValueSchema,
-  right: valita_exports.union(parameterReferenceSchema, literalReferenceSchema)
-});
-var correlatedSubqueryConditionOperatorSchema = literalUnion("EXISTS", "NOT EXISTS");
-var correlatedSubqueryConditionSchema = readonlyObject({
-  type: valita_exports.literal("correlatedSubquery"),
-  related: valita_exports.lazy(() => correlatedSubquerySchema),
-  op: correlatedSubqueryConditionOperatorSchema,
-  flip: valita_exports.boolean().optional()
-});
-var conditionSchema = valita_exports.union(
-  simpleConditionSchema,
-  valita_exports.lazy(() => conjunctionSchema),
-  valita_exports.lazy(() => disjunctionSchema),
-  correlatedSubqueryConditionSchema
-);
-var conjunctionSchema = readonlyObject({
-  type: valita_exports.literal("and"),
-  conditions: readonlyArray(conditionSchema)
-});
-var disjunctionSchema = readonlyObject({
-  type: valita_exports.literal("or"),
-  conditions: readonlyArray(conditionSchema)
-});
-function mustCompoundKey(field) {
-  assert(Array.isArray(field) && field.length >= 1);
-  return field;
-}
-var compoundKeySchema = readonly(
-  valita_exports.tuple([valita_exports.string()]).concat(valita_exports.array(valita_exports.string()))
-);
-var correlationSchema = readonlyObject({
-  parentField: compoundKeySchema,
-  childField: compoundKeySchema
-});
-var correlatedSubquerySchemaOmitSubquery = readonlyObject({
-  correlation: correlationSchema,
-  hidden: valita_exports.boolean().optional(),
-  system: literalUnion("permissions", "client", "test").optional()
-});
-var correlatedSubquerySchema = correlatedSubquerySchemaOmitSubquery.extend({
-  subquery: valita_exports.lazy(() => astSchema)
-});
-var astSchema = readonlyObject({
-  schema: valita_exports.string().optional(),
-  table: valita_exports.string(),
-  alias: valita_exports.string().optional(),
-  where: conditionSchema.optional(),
-  related: readonlyArray(correlatedSubquerySchema).optional(),
-  limit: valita_exports.number().optional(),
-  orderBy: orderingSchema.optional(),
-  start: valita_exports.object({
-    row: rowSchema,
-    exclusive: valita_exports.boolean()
-  }).optional()
-});
-function transformAST(ast, transform) {
-  const { tableName, columnName } = transform;
-  const colName = (c) => columnName(ast.table, c);
-  const key = (table, k) => {
-    const serverKey = k.map((col) => columnName(table, col));
-    return mustCompoundKey(serverKey);
-  };
-  const where = ast.where ? transform.where(ast.where) : void 0;
-  const transformed = {
-    schema: ast.schema,
-    table: tableName(ast.table),
-    alias: ast.alias,
-    where: where ? transformWhere(where, ast.table, transform) : void 0,
-    related: ast.related ? transform.related(
-      ast.related.map(
-        (r) => ({
-          correlation: {
-            parentField: key(ast.table, r.correlation.parentField),
-            childField: key(r.subquery.table, r.correlation.childField)
-          },
-          hidden: r.hidden,
-          subquery: transformAST(r.subquery, transform),
-          system: r.system
-        })
-      )
-    ) : void 0,
-    start: ast.start ? {
-      ...ast.start,
-      row: Object.fromEntries(
-        Object.entries(ast.start.row).map(([col, val]) => [
-          colName(col),
-          val
-        ])
-      )
-    } : void 0,
-    limit: ast.limit,
-    orderBy: ast.orderBy?.map(([col, dir]) => [colName(col), dir])
-  };
-  return transformed;
-}
-function transformWhere(where, table, transform) {
-  const { columnName } = transform;
-  const condValue = (c) => c.type !== "column" ? c : { ...c, name: columnName(table, c.name) };
-  const key = (table2, k) => {
-    const serverKey = k.map((col) => columnName(table2, col));
-    return mustCompoundKey(serverKey);
-  };
-  if (where.type === "simple") {
-    return { ...where, left: condValue(where.left) };
-  } else if (where.type === "correlatedSubquery") {
-    const { correlation, subquery } = where.related;
-    return {
-      ...where,
-      related: {
-        ...where.related,
-        correlation: {
-          parentField: key(table, correlation.parentField),
-          childField: key(subquery.table, correlation.childField)
-        },
-        subquery: transformAST(subquery, transform)
-      }
-    };
-  }
-  return {
-    type: where.type,
-    conditions: transform.conditions(
-      where.conditions.map((c) => transformWhere(c, table, transform))
-    )
-  };
-}
-var normalizeCache = /* @__PURE__ */ new WeakMap();
-var NORMALIZE_TRANSFORM = {
-  tableName: (t) => t,
-  columnName: (_, c) => c,
-  related: sortedRelated,
-  where: flattened,
-  conditions: (c) => c.sort(cmpCondition)
-};
-function normalizeAST(ast) {
-  let normalized = normalizeCache.get(ast);
-  if (!normalized) {
-    normalized = transformAST(ast, NORMALIZE_TRANSFORM);
-    normalizeCache.set(ast, normalized);
-  }
-  return normalized;
-}
-function mapAST(ast, mapper) {
-  return transformAST(ast, {
-    tableName: (table) => mapper.tableName(table),
-    columnName: (table, col) => mapper.columnName(table, col),
-    related: (r) => r,
-    where: (w) => w,
-    conditions: (c) => c
-  });
-}
-function mapCondition(cond, table, mapper) {
-  return transformWhere(cond, table, {
-    tableName: (table2) => mapper.tableName(table2),
-    columnName: (table2, col) => mapper.columnName(table2, col),
-    related: (r) => r,
-    where: (w) => w,
-    conditions: (c) => c
-  });
-}
-function sortedRelated(related) {
-  return related.sort(cmpRelated);
-}
-function cmpCondition(a, b) {
-  if (a.type === "simple") {
-    if (b.type !== "simple") {
-      return -1;
-    }
-    return compareValuePosition(a.left, b.left) || compareUTF8MaybeNull(a.op, b.op) || compareValuePosition(a.right, b.right);
-  }
-  if (b.type === "simple") {
-    return 1;
-  }
-  if (a.type === "correlatedSubquery") {
-    if (b.type !== "correlatedSubquery") {
-      return -1;
-    }
-    return cmpRelated(a.related, b.related) || compareUTF8MaybeNull(a.op, b.op);
-  }
-  if (b.type === "correlatedSubquery") {
-    return -1;
-  }
-  const val = compareUTF8MaybeNull(a.type, b.type);
-  if (val !== 0) {
-    return val;
-  }
-  for (let l = 0, r = 0; l < a.conditions.length && r < b.conditions.length; l++, r++) {
-    const val2 = cmpCondition(a.conditions[l], b.conditions[r]);
-    if (val2 !== 0) {
-      return val2;
-    }
-  }
-  return a.conditions.length - b.conditions.length;
-}
-function compareValuePosition(a, b) {
-  if (a.type !== b.type) {
-    return compareUTF82(a.type, b.type);
-  }
-  switch (a.type) {
-    case "literal":
-      assert(b.type === "literal");
-      return compareUTF82(String(a.value), String(b.value));
-    case "column":
-      assert(b.type === "column");
-      return compareUTF82(a.name, b.name);
-    case "static":
-      throw new Error(
-        "Static parameters should be resolved before normalization"
-      );
-  }
-}
-function cmpRelated(a, b) {
-  return compareUTF82(must(a.subquery.alias), must(b.subquery.alias));
-}
-function flattened(cond) {
-  if (cond.type === "simple" || cond.type === "correlatedSubquery") {
-    return cond;
-  }
-  const conditions = defined(
-    cond.conditions.flatMap(
-      (c) => c.type === cond.type ? c.conditions.map((c2) => flattened(c2)) : flattened(c)
-    )
-  );
-  switch (conditions.length) {
-    case 0:
-      return void 0;
-    case 1:
-      return conditions[0];
-    default:
-      return {
-        type: cond.type,
-        conditions
-      };
-  }
-}
-function compareUTF8MaybeNull(a, b) {
-  if (a !== null && b !== null) {
-    return compareUTF82(a, b);
-  }
-  if (b !== null) {
-    return -1;
-  }
-  if (a !== null) {
-    return 1;
-  }
-  return 0;
-}
-
-// ../zero-protocol/src/inspect-down.ts
-var serverMetricsSchema = valita_exports.object({
-  "query-materialization-server": tdigestSchema,
-  "query-update-server": tdigestSchema
-});
-var inspectQueryRowSchema = valita_exports.object({
-  clientID: valita_exports.string(),
-  queryID: valita_exports.string(),
-  // This is the server return AST for custom queries
-  // TODO: Return server generated AST
-  ast: astSchema.nullable(),
-  // not null for custom queries
-  name: valita_exports.string().nullable(),
-  // not null for custom queries
-  args: readonlyArray(jsonSchema).nullable(),
-  got: valita_exports.boolean(),
-  deleted: valita_exports.boolean(),
-  ttl: valita_exports.number(),
-  inactivatedAt: valita_exports.number().nullable(),
-  rowCount: valita_exports.number(),
-  metrics: serverMetricsSchema.nullable().optional()
-});
-var inspectBaseDownSchema = valita_exports.object({
-  id: valita_exports.string()
-});
-var inspectQueriesDownSchema = inspectBaseDownSchema.extend({
-  op: valita_exports.literal("queries"),
-  value: valita_exports.array(inspectQueryRowSchema)
-});
-var inspectMetricsDownSchema = inspectBaseDownSchema.extend({
-  op: valita_exports.literal("metrics"),
-  value: serverMetricsSchema
-});
-var inspectVersionDownSchema = inspectBaseDownSchema.extend({
-  op: valita_exports.literal("version"),
-  value: valita_exports.string()
-});
-var inspectAuthenticatedDownSchema = inspectBaseDownSchema.extend({
-  op: valita_exports.literal("authenticated"),
-  value: valita_exports.boolean()
-});
-var inspectAnalyzeQueryDownSchema = inspectBaseDownSchema.extend({
-  op: valita_exports.literal("analyze-query"),
-  value: analyzeQueryResultSchema
-});
-var inspectErrorDownSchema = inspectBaseDownSchema.extend({
-  op: valita_exports.literal("error"),
-  value: valita_exports.string()
-});
-var inspectDownBodySchema = valita_exports.union(
-  inspectQueriesDownSchema,
-  inspectMetricsDownSchema,
-  inspectVersionDownSchema,
-  inspectAuthenticatedDownSchema,
-  inspectAnalyzeQueryDownSchema,
-  inspectErrorDownSchema
-);
-var inspectDownMessageSchema = valita_exports.tuple([
-  valita_exports.literal("inspect"),
-  inspectDownBodySchema
-]);
-
-// ../shared/src/random-values.ts
-function getNonCryptoRandomValues(array7) {
-  if (array7 === null) {
-    throw new TypeError("array cannot be null");
-  }
-  for (let i = 0; i < array7.length; i++) {
-    array7[i] = Math.floor(Math.random() * 256);
-  }
-  return array7;
-}
-
-// ../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/";
-var MUTATIONS_KEY_PREFIX = "m/";
-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 toMutationResponseKey(mid) {
-  return MUTATIONS_KEY_PREFIX + mid.clientID + "/" + mid.id;
-}
-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-client/src/client/inspector/client-group.ts
-var ClientGroup = class {
-  #delegate;
-  id;
-  constructor(delegate, clientGroupID) {
-    this.#delegate = delegate;
-    this.id = clientGroupID;
-  }
-  async clients() {
-    return (await this.#delegate.lazy).clientGroupClients(
-      this.#delegate,
-      this.id
-    );
-  }
-  async clientsWithQueries() {
-    return (await this.#delegate.lazy).clientGroupClientsWithQueries(
-      this.#delegate,
-      this.id
-    );
-  }
-  async queries() {
-    return (await this.#delegate.lazy).clientGroupQueries(this.#delegate);
-  }
-};
-
-// ../zero-client/src/client/inspector/client.ts
-var Client = class {
-  #delegate;
-  id;
-  clientGroup;
-  constructor(delegate, clientID, clientGroupID) {
-    this.#delegate = delegate;
-    this.id = clientID;
-    this.clientGroup = new ClientGroup(this.#delegate, clientGroupID);
-  }
-  async queries() {
-    return (await this.#delegate.lazy).clientQueries(this.#delegate, this.id);
-  }
-  async map() {
-    return (await this.#delegate.lazy).clientMap(this.#delegate, this.id);
-  }
-  async rows(tableName) {
-    return (await this.#delegate.lazy).clientRows(
-      this.#delegate,
-      this.id,
-      tableName
-    );
-  }
-};
-
-// ../shared/src/centroid.ts
-var Centroid = class {
-  mean;
-  weight;
-  constructor(mean, weight) {
-    this.mean = mean;
-    this.weight = weight;
-  }
-  add(r) {
-    if (r.weight < 0) {
-      throw new Error("centroid weight cannot be less than zero");
-    }
-    if (this.weight !== 0) {
-      this.weight += r.weight;
-      this.mean += r.weight * (r.mean - this.mean) / this.weight;
-    } else {
-      this.weight = r.weight;
-      this.mean = r.mean;
-    }
-  }
-};
-function sortCentroidList(centroids) {
-  centroids.sort((a, b) => a.mean - b.mean);
-}
-
-// ../shared/src/tdigest.ts
-var TDigest = class _TDigest {
-  compression;
-  #maxProcessed;
-  #maxUnprocessed;
-  #processed;
-  #unprocessed;
-  #cumulative;
-  #processedWeight;
-  #unprocessedWeight;
-  #min;
-  #max;
-  constructor(compression = 1e3) {
-    this.compression = compression;
-    this.#maxProcessed = processedSize(0, this.compression);
-    this.#maxUnprocessed = unprocessedSize(0, this.compression);
-    this.reset();
-  }
-  /**
-   * fromJSON creates a TDigest from a JSON-serializable representation.
-   * The data should be an object with compression and centroids array.
-   */
-  static fromJSON(data) {
-    const digest = new _TDigest(data[0]);
-    if (data.length % 2 !== 1) {
-      throw new Error("Invalid centroids array");
-    }
-    for (let i = 1; i < data.length; i += 2) {
-      digest.add(data[i], data[i + 1]);
-    }
-    return digest;
-  }
-  reset() {
-    this.#processed = [];
-    this.#unprocessed = [];
-    this.#cumulative = [];
-    this.#processedWeight = 0;
-    this.#unprocessedWeight = 0;
-    this.#min = Number.MAX_VALUE;
-    this.#max = -Number.MAX_VALUE;
-  }
-  add(mean, weight = 1) {
-    this.addCentroid(new Centroid(mean, weight));
-  }
-  /** AddCentroidList can quickly add multiple centroids. */
-  addCentroidList(centroidList) {
-    for (const c of centroidList) {
-      this.addCentroid(c);
-    }
-  }
-  /**
-   * AddCentroid adds a single centroid.
-   * Weights which are not a number or are <= 0 are ignored, as are NaN means.
-   */
-  addCentroid(c) {
-    if (Number.isNaN(c.mean) || c.weight <= 0 || Number.isNaN(c.weight) || !Number.isFinite(c.weight)) {
-      return;
-    }
-    this.#unprocessed.push(new Centroid(c.mean, c.weight));
-    this.#unprocessedWeight += c.weight;
-    if (this.#processed.length > this.#maxProcessed || this.#unprocessed.length > this.#maxUnprocessed) {
-      this.#process();
-    }
-  }
-  /**
-   *  Merges the supplied digest into this digest. Functionally equivalent to
-   * calling t.AddCentroidList(t2.Centroids(nil)), but avoids making an extra
-   * copy of the CentroidList.
-   **/
-  merge(t2) {
-    t2.#process();
-    this.addCentroidList(t2.#processed);
-  }
-  #process() {
-    if (this.#unprocessed.length > 0 || this.#processed.length > this.#maxProcessed) {
-      this.#unprocessed.push(...this.#processed);
-      sortCentroidList(this.#unprocessed);
-      this.#processed.length = 0;
-      this.#processed.push(this.#unprocessed[0]);
-      this.#processedWeight += this.#unprocessedWeight;
-      this.#unprocessedWeight = 0;
-      let soFar = this.#unprocessed[0].weight;
-      let limit = this.#processedWeight * this.#integratedQ(1);
-      for (let i = 1; i < this.#unprocessed.length; i++) {
-        const centroid = this.#unprocessed[i];
-        const projected = soFar + centroid.weight;
-        if (projected <= limit) {
-          soFar = projected;
-          this.#processed[this.#processed.length - 1].add(centroid);
-        } else {
-          const k1 = this.#integratedLocation(soFar / this.#processedWeight);
-          limit = this.#processedWeight * this.#integratedQ(k1 + 1);
-          soFar += centroid.weight;
-          this.#processed.push(centroid);
-        }
-      }
-      this.#min = Math.min(this.#min, this.#processed[0].mean);
-      this.#max = Math.max(
-        this.#max,
-        this.#processed[this.#processed.length - 1].mean
-      );
-      this.#unprocessed.length = 0;
-    }
-  }
-  /**
-   * Centroids returns a copy of processed centroids.
-   * Useful when aggregating multiple t-digests.
-   *
-   * Centroids are appended to the passed CentroidList; if you're re-using a
-   * buffer, be sure to pass cl[:0].
-   */
-  centroids(cl = []) {
-    this.#process();
-    return cl.concat(this.#processed);
-  }
-  count() {
-    this.#process();
-    return this.#processedWeight;
-  }
-  /**
-   * toJSON returns a JSON-serializable representation of the digest.
-   * This processes the digest and returns an object with compression and centroid data.
-   */
-  toJSON() {
-    this.#process();
-    const data = [this.compression];
-    for (const centroid of this.#processed) {
-      data.push(centroid.mean, centroid.weight);
-    }
-    return data;
-  }
-  #updateCumulative() {
-    if (this.#cumulative.length > 0 && this.#cumulative[this.#cumulative.length - 1] === this.#processedWeight) {
-      return;
-    }
-    const n = this.#processed.length + 1;
-    if (this.#cumulative.length > n) {
-      this.#cumulative.length = n;
-    }
-    let prev = 0;
-    for (let i = 0; i < this.#processed.length; i++) {
-      const centroid = this.#processed[i];
-      const cur = centroid.weight;
-      this.#cumulative[i] = prev + cur / 2;
-      prev += cur;
-    }
-    this.#cumulative[this.#processed.length] = prev;
-  }
-  // Quantile returns the (approximate) quantile of
-  // the distribution. Accepted values for q are between 0 and 1.
-  // Returns NaN if Count is zero or bad inputs.
-  quantile(q) {
-    this.#process();
-    this.#updateCumulative();
-    if (q < 0 || q > 1 || this.#processed.length === 0) {
-      return NaN;
-    }
-    if (this.#processed.length === 1) {
-      return this.#processed[0].mean;
-    }
-    const index = q * this.#processedWeight;
-    if (index <= this.#processed[0].weight / 2) {
-      return this.#min + 2 * index / this.#processed[0].weight * (this.#processed[0].mean - this.#min);
-    }
-    const lower = binarySearch(
-      this.#cumulative.length,
-      (i) => -this.#cumulative[i] + index
-    );
-    if (lower + 1 !== this.#cumulative.length) {
-      const z12 = index - this.#cumulative[lower - 1];
-      const z22 = this.#cumulative[lower] - index;
-      return weightedAverage(
-        this.#processed[lower - 1].mean,
-        z22,
-        this.#processed[lower].mean,
-        z12
-      );
-    }
-    const z1 = index - this.#processedWeight - this.#processed[lower - 1].weight / 2;
-    const z2 = this.#processed[lower - 1].weight / 2 - z1;
-    return weightedAverage(
-      this.#processed[this.#processed.length - 1].mean,
-      z1,
-      this.#max,
-      z2
-    );
-  }
-  /**
-   * CDF returns the cumulative distribution function for a given value x.
-   */
-  cdf(x) {
-    this.#process();
-    this.#updateCumulative();
-    switch (this.#processed.length) {
-      case 0:
-        return 0;
-      case 1: {
-        const width = this.#max - this.#min;
-        if (x <= this.#min) {
-          return 0;
-        }
-        if (x >= this.#max) {
-          return 1;
-        }
-        if (x - this.#min <= width) {
-          return 0.5;
-        }
-        return (x - this.#min) / width;
-      }
-    }
-    if (x <= this.#min) {
-      return 0;
-    }
-    if (x >= this.#max) {
-      return 1;
-    }
-    const m0 = this.#processed[0].mean;
-    if (x <= m0) {
-      if (m0 - this.#min > 0) {
-        return (x - this.#min) / (m0 - this.#min) * this.#processed[0].weight / this.#processedWeight / 2;
-      }
-      return 0;
-    }
-    const mn = this.#processed[this.#processed.length - 1].mean;
-    if (x >= mn) {
-      if (this.#max - mn > 0) {
-        return 1 - (this.#max - x) / (this.#max - mn) * this.#processed[this.#processed.length - 1].weight / this.#processedWeight / 2;
-      }
-      return 1;
-    }
-    const upper = binarySearch(
-      this.#processed.length,
-      // Treat equals as greater than, so we can use the upper index
-      // This is equivalent to:
-      //   i => this.#processed[i].mean > x ? -1 : 1,
-      (i) => x - this.#processed[i].mean || 1
-    );
-    const z1 = x - this.#processed[upper - 1].mean;
-    const z2 = this.#processed[upper].mean - x;
-    return weightedAverage(
-      this.#cumulative[upper - 1],
-      z2,
-      this.#cumulative[upper],
-      z1
-    ) / this.#processedWeight;
-  }
-  #integratedQ(k) {
-    return (Math.sin(
-      Math.min(k, this.compression) * Math.PI / this.compression - Math.PI / 2
-    ) + 1) / 2;
-  }
-  #integratedLocation(q) {
-    return this.compression * (Math.asin(2 * q - 1) + Math.PI / 2) / Math.PI;
-  }
-};
-function weightedAverage(x1, w1, x2, w2) {
-  if (x1 <= x2) {
-    return weightedAverageSorted(x1, w1, x2, w2);
-  }
-  return weightedAverageSorted(x2, w2, x1, w1);
-}
-function weightedAverageSorted(x1, w1, x2, w2) {
-  const x = (x1 * w1 + x2 * w2) / (w1 + w2);
-  return Math.max(x1, Math.min(x, x2));
-}
-function processedSize(size, compression) {
-  if (size === 0) {
-    return Math.ceil(compression) * 2;
-  }
-  return size;
-}
-function unprocessedSize(size, compression) {
-  if (size === 0) {
-    return Math.ceil(compression) * 8;
-  }
-  return size;
-}
-
-// ../zero-client/src/client/inspector/inspector.ts
-var Inspector = class {
-  #delegate;
-  client;
-  clientGroup;
-  constructor(rep, delegate, getSocket) {
-    this.#delegate = {
-      getQueryMetrics: delegate.getQueryMetrics.bind(delegate),
-      getAST: delegate.getAST.bind(delegate),
-      get metrics() {
-        return delegate.metrics;
-      },
-      rep,
-      getSocket,
-      lazy: import("./lazy-inspector-OXIFYSSQ.js")
-    };
-    this.client = new Client(this.#delegate, rep.clientID, rep.clientGroupID);
-    this.clientGroup = this.client.clientGroup;
-  }
-  async metrics() {
-    return (await this.#delegate.lazy).inspectorMetrics(this.#delegate);
-  }
-  async clients() {
-    return (await this.#delegate.lazy).inspectorClients(this.#delegate);
-  }
-  async clientsWithQueries() {
-    return (await this.#delegate.lazy).inspectorClientsWithQueries(
-      this.#delegate
-    );
-  }
-  async serverVersion() {
-    return (await this.#delegate.lazy).serverVersion(this.#delegate);
-  }
-  async analyzeQuery(query, options) {
-    return (await this.#delegate.lazy).analyzeQuery(
-      this.#delegate,
-      query,
-      options
-    );
-  }
-};
-
-// ../zql/src/query/ttl.ts
-var DEFAULT_TTL_MS = 1e3 * 60 * 5;
-var DEFAULT_PRELOAD_TTL_MS = 0;
-var MAX_TTL = "10m";
-var MAX_TTL_MS = 1e3 * 60 * 10;
-var multiplier = {
-  s: 1e3,
-  m: 60 * 1e3,
-  h: 60 * 60 * 1e3,
-  d: 24 * 60 * 60 * 1e3,
-  y: 365 * 24 * 60 * 60 * 1e3
-};
-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;
-    }
-  }
-  return shortest.length < lengthOfNumber ? shortest : ttl;
-}
-function clampTTL(ttl, lc) {
-  const parsedTTL = parseTTL(ttl);
-  if (parsedTTL === -1 || parsedTTL > 10 * 60 * 1e3) {
-    lc?.warn?.(`TTL (${ttl}) is too high, clamping to ${MAX_TTL}`);
-    return parseTTL(MAX_TTL);
-  }
-  return parsedTTL;
-}
-
-export {
-  deepEqual,
-  assertJSONValue,
-  assertJSONObject,
-  stringCompare,
-  compareCookies,
-  assertCookie,
-  DD31,
-  V6,
-  V7,
-  Latest,
-  parse,
-  test,
-  readonly,
-  readonlyObject,
-  readonlyArray,
-  literalUnion,
-  valita_exports,
-  emptyHash,
-  newRandomHash,
-  assertHash,
-  Chunk,
-  assertRefs,
-  createChunk,
-  ChunkNotFoundError,
-  mustGetChunk,
-  mustGetHeadHash,
-  binarySearch,
-  joinIterables,
-  once,
-  wrapIterable,
-  mergeIterables,
-  getSizeOfValue,
-  BTreeRead,
-  DEFAULT_HEAD_NAME,
-  commitIsLocalDD31,
-  localMutations,
-  localMutationsDD31,
-  localMutationsGreaterThan,
-  baseSnapshotFromHead,
-  baseSnapshotFromHash,
-  baseSnapshotFromCommit,
-  snapshotMetaParts,
-  compareCookiesForSnapshots,
-  commitFromHash,
-  commitFromHead,
-  assertLocalMetaDD31,
-  isLocalMetaDD31,
-  assertSnapshotMetaDD31,
-  assertSnapshotCommitDD31,
-  asyncIterableToArray,
-  diff,
-  encodeIndexScanKey,
-  decodeIndexKey,
-  readFromDefaultHead,
-  readFromHash,
-  DiffsMap,
-  diff2,
-  diffCommits,
-  addDiffsForIndexes,
-  newWriteLocal,
-  newWriteSnapshotDD31,
-  clientGroupIDSchema,
-  clientIDSchema,
-  withRead,
-  withWriteNoImplicitCommit,
-  withWrite,
-  using,
-  getClientGroups,
-  setClientGroups,
-  setClientGroup,
-  getClientGroup,
-  clientGroupHasPendingMutations,
-  disableClientGroup,
-  makeClientID,
-  assertClientV6,
-  getClients,
-  ClientStateNotFoundError,
-  assertHasClientState,
-  hasClientState,
-  getClient,
-  mustGetClient,
-  initClientV6,
-  getClientGroupForClient,
-  getClientGroupIDForClient,
-  setClient,
-  setClients,
-  jsonSchema,
-  jsonObjectSchema,
-  areEqual,
-  must,
-  rowSchema,
-  SUBQ_PREFIX,
-  toStaticParam,
-  planIdSymbol,
-  astSchema,
-  normalizeAST,
-  mapAST,
-  mapCondition,
-  h64,
-  mapValues,
-  mapEntries,
-  mapAllEntries,
-  DEFAULT_TTL_MS,
-  DEFAULT_PRELOAD_TTL_MS,
-  compareTTL,
-  normalizeTTL,
-  clampTTL,
-  getNonCryptoRandomValues,
-  inspectQueriesDownSchema,
-  inspectMetricsDownSchema,
-  inspectVersionDownSchema,
-  inspectAuthenticatedDownSchema,
-  inspectAnalyzeQueryDownSchema,
-  inspectDownMessageSchema,
-  primaryKeySchema,
-  primaryKeyValueRecordSchema,
-  nanoid,
-  GOT_QUERIES_KEY_PREFIX,
-  ENTITIES_KEY_PREFIX,
-  MUTATIONS_KEY_PREFIX,
-  toDesiredQueriesKey,
-  desiredQueriesPrefixForClient,
-  toGotQueriesKey,
-  toMutationResponseKey,
-  toPrimaryKeyString,
-  sourceNameFromKey,
-  Client,
-  TDigest,
-  Inspector
-};
-//# sourceMappingURL=chunk-TJFNGO7E.js.map