@rocicorp/zero 0.23.2025082700 → 0.23.2025082901

package/out/{chunk-3I7CRZJP.js → chunk-G442PJSB.js}

@@ -17,6 +17,12 @@ import {
   __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, {
@@ -252,11 +258,307 @@ async function mustGetHeadHash(name, store) {
   return hash2;
 }
 
-// ../replicache/src/format-version-enum.ts
-var DD31 = 5;
-var V6 = 6;
-var V7 = 7;
-var Latest = V7;
+// ../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/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);
+}
+
+// ../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/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);
+}
 
 // ../shared/src/json.ts
 function deepEqual(a, b) {
@@ -398,41 +700,6 @@ function isJSONArray(v2, path2) {
   return true;
 }
 
-// ../shared/src/random-uint64.ts
-function randomUint64() {
-  const high = Math.floor(Math.random() * 4294967295);
-  const low = Math.floor(Math.random() * 4294967295);
-  return BigInt(high) << 32n | BigInt(low);
-}
-
-// ../replicache/src/hash.ts
-var STRING_LENGTH = 22;
-var hashRe = /^[0-9a-v-]+$/;
-var emptyUUID = "0".repeat(STRING_LENGTH);
-var emptyHash = emptyUUID;
-var newRandomHash = makeNewRandomHashFunctionInternal();
-function toStringAndSlice(n, len) {
-  return n.toString(32).slice(-len).padStart(len, "0");
-}
-function makeNewRandomHashFunctionInternal() {
-  let base = "";
-  let i = 0;
-  return () => {
-    if (!base) {
-      base = toStringAndSlice(randomUint64(), 12);
-    }
-    const tail = toStringAndSlice(i++, 10);
-    return base + tail;
-  };
-}
-function isHash(value) {
-  return typeof value === "string" && hashRe.test(value);
-}
-function assertHash(value) {
-  assert2(value, hashSchema);
-}
-var hashSchema = valita_exports.string().assert(isHash, "Invalid hash");
-
 // ../replicache/src/size-of-value.ts
 var SIZE_TAG = 1;
 var SIZE_INT32 = 4;
@@ -1287,76 +1554,25 @@ function compareCookies(a, b) {
   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]);
-    }
+    return stringCompare(String(cva), String(cvb));
   }
+  return cva - cvb;
 }
-function createChunk(data, refs, chunkHasher) {
-  const hash2 = chunkHasher();
-  return new Chunk(hash2, data, refs);
+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/db/meta-type-enum.ts
@@ -1730,359 +1946,143 @@ function getIndexKeys(primary, value, jsonPointer, allowEmpty) {
   const values = Array.isArray(target) ? target : [target];
   const indexKeys = [];
   for (const value2 of values) {
-    if (typeof value2 === "string") {
-      indexKeys.push(encodeIndexKey([value2, primary]));
-    } else {
-      throw new Error("Unsupported target type");
-    }
-  }
-  return indexKeys;
-}
-var KEY_VERSION_0 = "\0";
-var KEY_SEPARATOR = "\0";
-function encodeIndexKey(indexKey) {
-  const secondary = indexKey[0];
-  const primary = indexKey[1];
-  if (secondary.includes("\0")) {
-    throw new Error("Secondary key cannot contain null byte");
-  }
-  return KEY_VERSION_0 + secondary + KEY_SEPARATOR + primary;
-}
-function encodeIndexScanKey(secondary, primary) {
-  const k = encodeIndexKey([secondary, primary || ""]);
-  if (primary === void 0) {
-    return k.slice(0, k.length - 1);
-  }
-  return k;
-}
-function decodeIndexKey(encodedIndexKey) {
-  if (encodedIndexKey[0] !== KEY_VERSION_0) {
-    throw new Error("Invalid version");
-  }
-  const versionLen = KEY_VERSION_0.length;
-  const separatorLen = KEY_SEPARATOR.length;
-  const separatorOffset = encodedIndexKey.indexOf(KEY_SEPARATOR, versionLen);
-  if (separatorOffset === -1) {
-    throw new Error("Invalid formatting");
-  }
-  const secondary = encodedIndexKey.slice(versionLen, separatorOffset);
-  const primary = encodedIndexKey.slice(separatorOffset + separatorLen);
-  return [secondary, primary];
-}
-function evaluateJSONPointer(value, pointer) {
-  function parseIndex(s) {
-    if (s.startsWith("+") || s.startsWith("0") && s.length !== 1) {
-      return void 0;
-    }
-    return parseInt(s, 10);
-  }
-  if (pointer === "") {
-    return value;
-  }
-  if (!pointer.startsWith("/")) {
-    throw new Error(`Invalid JSON pointer: ${pointer}`);
-  }
-  const tokens = pointer.split("/").slice(1).map((x) => x.replace(/~1/g, "/").replace(/~0/g, "~"));
-  let target = value;
-  for (const token of tokens) {
-    let targetOpt;
-    if (Array.isArray(target)) {
-      const i = parseIndex(token);
-      if (i === void 0) {
-        return void 0;
-      }
-      targetOpt = target[i];
-    } else if (target === null) {
-      return void 0;
-    } else if (typeof target === "object") {
-      target = target;
-      targetOpt = target[token];
-    }
-    if (targetOpt === void 0) {
-      return void 0;
-    }
-    target = targetOpt;
-  }
-  return target;
-}
-
-// ../replicache/src/db/read.ts
-var Read = class {
-  #dagRead;
-  map;
-  indexes;
-  constructor(dagRead, map, indexes) {
-    this.#dagRead = dagRead;
-    this.map = map;
-    this.indexes = indexes;
-  }
-  has(key) {
-    return this.map.has(key);
-  }
-  get(key) {
-    return this.map.get(key);
-  }
-  isEmpty() {
-    return this.map.isEmpty();
-  }
-  getMapForIndex(indexName) {
-    const idx = this.indexes.get(indexName);
-    if (idx === void 0) {
-      throw new Error(`Unknown index name: ${indexName}`);
-    }
-    return idx.map;
-  }
-  get closed() {
-    return this.#dagRead.closed;
-  }
-  close() {
-    this.#dagRead.release();
-  }
-};
-function readFromDefaultHead(dagRead, formatVersion) {
-  return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);
-}
-async function readFromHead(name, dagRead, formatVersion) {
-  const commit = await commitFromHead(name, dagRead);
-  return readFromCommit(commit, dagRead, formatVersion);
-}
-async function readFromHash(hash2, dagRead, formatVersion) {
-  const commit = await commitFromHash(hash2, dagRead);
-  return readFromCommit(commit, dagRead, formatVersion);
-}
-function readFromCommit(commit, dagRead, formatVersion) {
-  const indexes = readIndexesForRead(commit, dagRead, formatVersion);
-  const map = new BTreeRead(dagRead, formatVersion, commit.valueHash);
-  return new Read(dagRead, map, indexes);
-}
-function readIndexesForRead(commit, dagRead, formatVersion) {
-  const m = /* @__PURE__ */ new Map();
-  for (const index of commit.indexes) {
-    m.set(
-      index.definition.name,
-      new IndexRead(
-        index,
-        new BTreeRead(dagRead, formatVersion, index.valueHash)
-      )
-    );
-  }
-  return m;
-}
-
-// ../replicache/src/index-defs.ts
-var indexDefinitionSchema = readonlyObject({
-  prefix: valita_exports.string().optional(),
-  jsonPointer: valita_exports.string(),
-  allowEmpty: valita_exports.boolean().optional()
-});
-var indexDefinitionsSchema = readonlyRecord(
-  indexDefinitionSchema
-);
-function indexDefinitionEqual(a, b) {
-  return a.jsonPointer === b.jsonPointer && (a.allowEmpty ?? false) === (b.allowEmpty ?? false) && (a.prefix ?? "") === (b.prefix ?? "");
-}
-function indexDefinitionsEqual(a, b) {
-  if (Object.keys(a).length !== Object.keys(b).length) {
-    return false;
-  }
-  for (const [aKey, aValue] of Object.entries(a)) {
-    const bValue = b[aKey];
-    if (!bValue || !indexDefinitionEqual(aValue, bValue)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// ../replicache/src/persist/client-groups.ts
-var clientGroupSchema = readonlyObject({
-  /**
-   * The hash of the commit in the perdag last persisted to this client group.
-   * Should only be updated by clients assigned to this client group.
-   */
-  headHash: hashSchema,
-  /**
-   * Set of mutator names common to all clients assigned to this client group.
-   */
-  mutatorNames: readonlyArray(valita_exports.string()),
-  /**
-   * Index definitions common to all clients assigned to this client group.
-   */
-  indexes: indexDefinitionsSchema,
-  /**
-   * The highest mutation ID of every client assigned to this client group.
-   * Should only be updated by clients assigned to this client group. Read by
-   * other clients to determine if there are unacknowledged pending mutations
-   * for them to try to recover. This is redundant with information in the
-   * commit graph at `headHash`, but allows other clients to determine if there
-   * are unacknowledged pending mutations without having to load the commit
-   * graph.
-   */
-  mutationIDs: readonlyRecord(valita_exports.number()),
-  /**
-   * The highest lastMutationID received from the server for every client
-   * assigned to this client group.
-   *
-   * Should be updated by the clients assigned to this client group whenever
-   * they persist to this client group. Read by other clients to determine if
-   * there are unacknowledged pending mutations for them to recover and
-   * *updated* by other clients upon successfully recovering pending mutations
-   * to avoid redundant pushes of pending mutations.
-   *
-   * Note: This will be the same as the `lastMutationIDs` of the base snapshot
-   * of the client group's commit graph when written by clients assigned to this
-   * client group.  However, when written by another client recovering mutations
-   * it may be different because the other client does not update the commit
-   * graph.
-   */
-  lastServerAckdMutationIDs: valita_exports.record(valita_exports.number()),
-  /**
-   * If the server deletes this client group it can signal that the client group
-   * was deleted. If that happens we mark this client group as disabled so that
-   * we do not use it again when creating new clients.
-   */
-  disabled: valita_exports.boolean()
-});
-var CLIENT_GROUPS_HEAD_NAME = "client-groups";
-function assertClientGroup(value) {
-  assert2(value, clientGroupSchema);
-}
-function chunkDataToClientGroupMap(chunkData) {
-  assertObject(chunkData);
-  const clientGroups = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(chunkData)) {
-    if (value !== void 0) {
-      assertClientGroup(value);
-      clientGroups.set(key, value);
-    }
-  }
-  return clientGroups;
-}
-function clientGroupMapToChunkData(clientGroups, dagWrite) {
-  const chunkData = {};
-  for (const [clientGroupID, clientGroup] of clientGroups.entries()) {
-    dagWrite.assertValidHash(clientGroup.headHash);
-    chunkData[clientGroupID] = {
-      ...clientGroup,
-      mutatorNames: [...clientGroup.mutatorNames.values()]
-    };
+    if (typeof value2 === "string") {
+      indexKeys.push(encodeIndexKey([value2, primary]));
+    } else {
+      throw new Error("Unsupported target type");
+    }
   }
-  return deepFreeze(chunkData);
-}
-async function getClientGroupsAtHash(hash2, dagRead) {
-  const chunk = await dagRead.getChunk(hash2);
-  return chunkDataToClientGroupMap(chunk?.data);
+  return indexKeys;
 }
-async function getClientGroups(dagRead) {
-  const hash2 = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
-  if (!hash2) {
-    return /* @__PURE__ */ new Map();
+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 getClientGroupsAtHash(hash2, dagRead);
+  return KEY_VERSION_0 + secondary + KEY_SEPARATOR + primary;
 }
-async function setClientGroups(clientGroups, dagWrite) {
-  const currClientGroups = await getClientGroups(dagWrite);
-  for (const [clientGroupID, clientGroup] of clientGroups) {
-    const currClientGroup = currClientGroups.get(clientGroupID);
-    validateClientGroupUpdate(clientGroup, currClientGroup);
+function encodeIndexScanKey(secondary, primary) {
+  const k = encodeIndexKey([secondary, primary || ""]);
+  if (primary === void 0) {
+    return k.slice(0, k.length - 1);
   }
-  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);
+  return k;
 }
-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."
-    );
+function decodeIndexKey(encodedIndexKey) {
+  if (encodedIndexKey[0] !== KEY_VERSION_0) {
+    throw new Error("Invalid version");
   }
-}
-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 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 chunk = dagWrite.createChunk(chunkData, toRefs(refs));
-  await dagWrite.putChunk(chunk);
-  await dagWrite.setHead(CLIENT_GROUPS_HEAD_NAME, chunk.hash);
-  return clientGroups;
+  const secondary = encodedIndexKey.slice(versionLen, separatorOffset);
+  const primary = encodedIndexKey.slice(separatorOffset + separatorLen);
+  return [secondary, primary];
 }
-function mutatorNamesEqual(mutatorNamesSet, mutatorNames) {
-  if (mutatorNames.length !== mutatorNamesSet.size) {
-    return false;
+function evaluateJSONPointer(value, pointer) {
+  function parseIndex(s) {
+    if (s.startsWith("+") || s.startsWith("0") && s.length !== 1) {
+      return void 0;
+    }
+    return parseInt(s, 10);
   }
-  for (const mutatorName of mutatorNames) {
-    if (!mutatorNamesSet.has(mutatorName)) {
-      return false;
+  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 true;
-}
-async function getClientGroup(id, dagRead) {
-  const clientGroups = await getClientGroups(dagRead);
-  return clientGroups.get(id);
+  return target;
 }
-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;
+
+// ../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;
   }
-  return false;
-}
-async function disableClientGroup(clientGroupID, dagWrite) {
-  const clientGroup = await getClientGroup(clientGroupID, dagWrite);
-  if (!clientGroup) {
-    return;
+  get closed() {
+    return this.#dagRead.closed;
   }
-  const disabledClientGroup = {
-    ...clientGroup,
-    disabled: true
-  };
-  await setClientGroup(clientGroupID, disabledClientGroup, dagWrite);
+  close() {
+    this.#dagRead.release();
+  }
+};
+function readFromDefaultHead(dagRead, formatVersion) {
+  return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);
 }
-
-// ../replicache/src/with-transactions.ts
-function withRead(store, fn) {
-  return using(store.read(), fn);
+async function readFromHead(name, dagRead, formatVersion) {
+  const commit = await commitFromHead(name, dagRead);
+  return readFromCommit(commit, dagRead, formatVersion);
 }
-function withWriteNoImplicitCommit(store, fn) {
-  return using(store.write(), fn);
+async function readFromHash(hash2, dagRead, formatVersion) {
+  const commit = await commitFromHash(hash2, dagRead);
+  return readFromCommit(commit, dagRead, formatVersion);
 }
-function withWrite(store, fn) {
-  return using(store.write(), async (write) => {
-    const result = await fn(write);
-    await write.commit();
-    return result;
-  });
+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);
 }
-async function using(x, fn) {
-  const write = await x;
-  try {
-    return await fn(write);
-  } finally {
-    write.release();
+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/async-iterable-to-array.ts
@@ -6525,6 +6525,12 @@ function assertNoNotExists(condition) {
 }
 
 // ../zql/src/query/query-impl.ts
+function materialize(query, delegate, factoryOrOptions, maybeOptions) {
+  if (typeof factoryOrOptions === "function") {
+    return query[delegateSymbol](delegate).materialize(factoryOrOptions, maybeOptions?.ttl);
+  }
+  return query[delegateSymbol](delegate).materialize(factoryOrOptions?.ttl);
+}
 var astSymbol = Symbol();
 function newQuery(delegate, schema, table) {
   return new QueryImpl(
@@ -7186,6 +7192,10 @@ export {
   stringCompare,
   compareCookies,
   assertCookie,
+  DD31,
+  V6,
+  V7,
+  Latest,
   parse,
   test,
   readonly,
@@ -7202,14 +7212,22 @@ export {
   ChunkNotFoundError,
   mustGetChunk,
   mustGetHeadHash,
-  DD31,
-  V6,
-  V7,
-  Latest,
+  withRead,
+  withWriteNoImplicitCommit,
+  withWrite,
+  using,
+  getClientGroups,
+  setClientGroups,
+  setClientGroup,
+  getClientGroup,
+  clientGroupHasPendingMutations,
+  disableClientGroup,
+  binarySearch,
   joinIterables,
   once,
   wrapIterable,
   getSizeOfValue,
+  BTreeRead,
   DEFAULT_HEAD_NAME,
   commitIsLocalDD31,
   localMutations,
@@ -7226,32 +7244,18 @@ export {
   isLocalMetaDD31,
   assertSnapshotMetaDD31,
   assertSnapshotCommitDD31,
-  binarySearch,
-  BTreeRead,
+  asyncIterableToArray,
+  diff,
   encodeIndexScanKey,
   decodeIndexKey,
   readFromDefaultHead,
   readFromHash,
-  asyncIterableToArray,
-  diff,
   DiffsMap,
   diff2,
   diffCommits,
   addDiffsForIndexes,
   newWriteLocal,
   newWriteSnapshotDD31,
-  getClientGroups,
-  setClientGroups,
-  setClientGroup,
-  getClientGroup,
-  clientGroupHasPendingMutations,
-  disableClientGroup,
-  withRead,
-  withWriteNoImplicitCommit,
-  withWrite,
-  using,
-  jsonSchema,
-  jsonObjectSchema,
   clientGroupIDSchema,
   clientIDSchema,
   makeClientID,
@@ -7267,7 +7271,8 @@ export {
   getClientGroupIDForClient,
   setClient,
   setClients,
-  getNonCryptoRandomValues,
+  jsonSchema,
+  jsonObjectSchema,
   must,
   rowSchema,
   toStaticParam,
@@ -7297,12 +7302,14 @@ export {
   compareTTL,
   normalizeTTL,
   clampTTL,
+  materialize,
   newQuery,
   staticParam,
   SUBQ_PREFIX,
   defaultFormat,
   newQuerySymbol,
   AbstractQuery,
+  getNonCryptoRandomValues,
   inspectQueriesDownSchema,
   inspectMetricsDownSchema,
   inspectVersionDownSchema,
@@ -7321,4 +7328,4 @@ export {
   sourceNameFromKey,
   TDigest
 };
-//# sourceMappingURL=chunk-3I7CRZJP.js.map
+//# sourceMappingURL=chunk-G442PJSB.js.map