@rocicorp/zero 0.13.2025020500 → 0.13.2025020700

package/out/{chunk-H3C7QNPL.js → chunk-FVVIM6TT.js}

@@ -3789,6 +3789,10 @@ 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);
@@ -4995,10 +4999,30 @@ var CookieMismatch = 2;
 
 // ../replicache/src/sync/patch.ts
 async function apply(lc, dbWrite, patch) {
+  const ret = [];
+  function pushChangeOrAdd(key, oldValue, newValue) {
+    if (oldValue === void 0) {
+      ret.push({
+        op: "add",
+        key,
+        newValue
+      });
+    } else {
+      ret.push({
+        op: "change",
+        key,
+        oldValue,
+        newValue
+      });
+    }
+  }
   for (const p of patch) {
     switch (p.op) {
       case "put": {
-        await dbWrite.put(lc, p.key, deepFreeze(p.value));
+        const existing = await dbWrite.get(p.key);
+        const frozen = deepFreeze(p.value);
+        pushChangeOrAdd(p.key, existing, frozen);
+        await dbWrite.put(lc, p.key, frozen);
         break;
       }
       case "update": {
@@ -5018,17 +5042,33 @@ async function apply(lc, dbWrite, patch) {
         if (p.merge) {
           addToEntries(p.merge);
         }
-        await dbWrite.put(lc, p.key, deepFreeze(Object.fromEntries(entries)));
+        const frozen = deepFreeze(Object.fromEntries(entries));
+        pushChangeOrAdd(p.key, existing, frozen);
+        await dbWrite.put(lc, p.key, frozen);
         break;
       }
-      case "del":
+      case "del": {
+        const existing = await dbWrite.get(p.key);
+        if (existing === void 0) {
+          continue;
+        }
         await dbWrite.del(lc, p.key);
+        ret.push({
+          op: "del",
+          key: p.key,
+          oldValue: existing
+        });
         break;
+      }
       case "clear":
         await dbWrite.clear();
+        ret.push({
+          op: "clear"
+        });
         break;
     }
   }
+  return ret;
 }
 
 // ../replicache/src/sync/pull-error.ts
@@ -5195,10 +5235,11 @@ function handlePullResponseV1(lc, store, expectedBaseCookie, response, clientID,
       clientID,
       formatVersion
     );
-    await apply(lc, dbWrite, response.patch);
+    const diffs = await apply(lc, dbWrite, response.patch);
     return {
       type: Applied,
-      syncHead: await dbWrite.commit(SYNC_HEAD_NAME)
+      syncHead: await dbWrite.commit(SYNC_HEAD_NAME),
+      diffs
     };
   });
 }
@@ -7285,6 +7326,7 @@ var ReplicacheImpl = class {
     void this.#open(
       indexes,
       enableClientGroupForking,
+      enableMutationRecovery,
       clientMaxAgeMs,
       profileIDResolver.resolve,
       clientGroupIDResolver.resolve,
@@ -7292,7 +7334,7 @@ var ReplicacheImpl = class {
       onClientsDeleted
     );
   }
-  async #open(indexes, enableClientGroupForking, clientMaxAgeMs, profileIDResolver, resolveClientGroupID, resolveReady, onClientsDeleted) {
+  async #open(indexes, enableClientGroupForking, enableMutationRecovery, clientMaxAgeMs, profileIDResolver, resolveClientGroupID, resolveReady, onClientsDeleted) {
     const { clientID } = this;
     await closingInstances.get(this.name);
     await this.#idbDatabases.getProfileID().then(profileIDResolver);
@@ -7342,6 +7384,7 @@ var ReplicacheImpl = class {
       COLLECT_IDB_INTERVAL,
       INITIAL_COLLECT_IDB_DELAY,
       2 * clientMaxAgeMs,
+      enableMutationRecovery,
       onClientsDeleted,
       this.#lc,
       signal
@@ -7719,7 +7762,7 @@ var ReplicacheImpl = class {
    *
    * @experimental This method is under development and its semantics will change.
    */
-  async poke(poke) {
+  async poke(poke, pullApplied) {
     await this.#ready;
     const { clientID } = this;
     const requestID = newRequestID(clientID);
@@ -7743,6 +7786,7 @@ var ReplicacheImpl = class {
     );
     switch (result.type) {
       case Applied:
+        await pullApplied(this.memdag, result.syncHead, result.diffs);
         await this.maybeEndPull(result.syncHead, requestID);
         break;
       case CookieMismatch:
@@ -8164,7 +8208,7 @@ function getKVStoreProvider(lc, kvStore) {
 // ../replicache/src/persist/collect-idb-databases.ts
 var COLLECT_IDB_INTERVAL = 12 * 60 * 60 * 1e3;
 var INITIAL_COLLECT_IDB_DELAY = 5 * 60 * 1e3;
-function initCollectIDBDatabases(idbDatabasesStore, kvDropStore, collectInterval, initialCollectDelay, maxAge, onClientsDeleted, lc, signal) {
+function initCollectIDBDatabases(idbDatabasesStore, kvDropStore, collectInterval, initialCollectDelay, maxAge, enableMutationRecovery, onClientsDeleted, lc, signal) {
   let initial = true;
   initBgIntervalProcess(
     "CollectIDBDatabases",
@@ -8174,6 +8218,7 @@ function initCollectIDBDatabases(idbDatabasesStore, kvDropStore, collectInterval
         Date.now(),
         maxAge,
         kvDropStore,
+        enableMutationRecovery,
         onClientsDeleted
       );
     },
@@ -8188,14 +8233,20 @@ function initCollectIDBDatabases(idbDatabasesStore, kvDropStore, collectInterval
     signal
   );
 }
-async function collectIDBDatabases(idbDatabasesStore, now, maxAge, kvDropStore, onClientsDeleted, newDagStore = defaultNewDagStore) {
+async function collectIDBDatabases(idbDatabasesStore, now, maxAge, kvDropStore, enableMutationRecovery, onClientsDeleted, newDagStore = defaultNewDagStore) {
   const databases = await idbDatabasesStore.getDatabases();
   const dbs = Object.values(databases);
   const collectResults = await Promise.all(
     dbs.map(
       async (db) => [
         db.name,
-        await gatherDatabaseInfoForCollect(db, now, maxAge, newDagStore)
+        await gatherDatabaseInfoForCollect(
+          db,
+          now,
+          maxAge,
+          enableMutationRecovery,
+          newDagStore
+        )
       ]
     )
   );
@@ -8245,7 +8296,7 @@ function defaultNewDagStore(name) {
   const perKvStore = new IDBStore(name);
   return new StoreImpl(perKvStore, newRandomHash, assertHash);
 }
-function gatherDatabaseInfoForCollect(db, now, maxAge, newDagStore) {
+function gatherDatabaseInfoForCollect(db, now, maxAge, enableMutationRecovery, newDagStore) {
   if (db.replicacheFormatVersion > Latest) {
     return [false];
   }
@@ -8256,7 +8307,10 @@ function gatherDatabaseInfoForCollect(db, now, maxAge, newDagStore) {
   assert(
     db.replicacheFormatVersion === DD31 || db.replicacheFormatVersion === V6 || db.replicacheFormatVersion === V7
   );
-  return gatherPendingMutationsInClientGroups(newDagStore(db.name));
+  return canDatabaseBeCollectedAndGetDeletedClientIDs(
+    enableMutationRecovery,
+    newDagStore(db.name)
+  );
 }
 async function dropDatabase(dbName, opts) {
   const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {
@@ -8280,12 +8334,14 @@ async function dropAllDatabases(opts) {
   const result = await dropDatabases(store, dbNames, kvStoreProvider.drop);
   return result;
 }
-function gatherPendingMutationsInClientGroups(perdag) {
+function canDatabaseBeCollectedAndGetDeletedClientIDs(enableMutationRecovery, perdag) {
   return withRead(perdag, async (read) => {
-    const clientGroups = await getClientGroups(read);
-    for (const clientGroup of clientGroups.values()) {
-      if (clientGroupHasPendingMutations(clientGroup)) {
-        return [false];
+    if (enableMutationRecovery) {
+      const clientGroups = await getClientGroups(read);
+      for (const clientGroup of clientGroups.values()) {
+        if (clientGroupHasPendingMutations(clientGroup)) {
+          return [false];
+        }
       }
     }
     const clients = await getClients(read);
@@ -11976,25 +12032,16 @@ var pushBodySchema = valita_exports.object({
 var pushMessageSchema = valita_exports.tuple([valita_exports.literal("push"), pushBodySchema]);
 function mapCRUD(arg, map) {
   return {
-    ops: arg.ops.map(({ op, tableName, primaryKey, value }) => {
-      switch (op) {
-        case "delete": {
-          return {
-            op,
-            tableName: map.tableName(tableName),
-            primaryKey: map.columns(tableName, primaryKey),
-            value: map.row(tableName, value)
-          };
-        }
-        default:
-          return {
-            op,
-            tableName: map.tableName(tableName),
-            primaryKey: map.columns(tableName, primaryKey),
-            value: map.row(tableName, value)
-          };
-      }
-    })
+    ops: arg.ops.map(
+      ({ op, tableName, primaryKey, value }) => ({
+        op,
+        tableName: map.tableName(tableName),
+        primaryKey: map.columns(tableName, primaryKey),
+        value: map.row(tableName, value)
+        // The cast is necessary because ts objects to the `value` field
+        // for "delete" ops being different.
+      })
+    )
   };
 }
 
@@ -12550,931 +12597,1061 @@ var MemoryStorage = class {
   }
 };
 
-// ../zero-client/src/client/keys.ts
-var CLIENTS_KEY_PREFIX = "c/";
-var DESIRED_QUERIES_KEY_PREFIX = "d/";
-var GOT_QUERIES_KEY_PREFIX = "g/";
-var ENTITIES_KEY_PREFIX = "e/";
-function toClientsKey(clientID) {
-  return CLIENTS_KEY_PREFIX + clientID;
-}
-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;
+// ../zql/src/ivm/constraint.ts
+function constraintMatchesRow(constraint, row) {
+  for (const key in constraint) {
+    if (!valuesEqual(row[key], constraint[key])) {
+      return false;
+    }
+  }
+  return true;
 }
-function toPrimaryKeyString(tableName, primaryKey, value) {
-  if (primaryKey.length === 1) {
-    return ENTITIES_KEY_PREFIX + tableName + "/" + parse(value[primaryKey[0]], primaryKeyValueSchema);
+function constraintMatchesPrimaryKey(constraint, primary) {
+  const constraintKeys = Object.keys(constraint);
+  if (constraintKeys.length !== primary.length) {
+    return false;
   }
-  const values = primaryKey.map((k) => parse(value[k], primaryKeyValueSchema));
-  const str = JSON.stringify(values);
-  const idSegment = h128(str);
-  return ENTITIES_KEY_PREFIX + tableName + "/" + idSegment;
+  constraintKeys.sort(stringCompare);
+  for (let i = 0; i < constraintKeys.length; i++) {
+    if (constraintKeys[i][0] !== primary[i]) {
+      return false;
+    }
+  }
+  return true;
 }
 
-// ../zero-client/src/client/context.ts
-var ZeroContext = class {
-  // It is a bummer to have to maintain separate MemorySources here and copy the
-  // data in from the Replicache db. But we want the data to be accessible via
-  // pipelines *synchronously* and the core Replicache infra is all async. So
-  // that needs to be fixed.
-  #mainSources;
-  #addQuery;
-  #batchViewUpdates;
-  #commitListeners = /* @__PURE__ */ new Set();
-  staticQueryParameters = void 0;
-  constructor(mainSources, addQuery, batchViewUpdates) {
-    this.#mainSources = mainSources;
-    this.#addQuery = addQuery;
-    this.#batchViewUpdates = batchViewUpdates;
-  }
-  getSource(name) {
-    return this.#mainSources.getSource(name);
+// ../zql/src/ivm/memory-source.ts
+var MemorySource = class _MemorySource {
+  #tableName;
+  #columns;
+  #primaryKey;
+  #primaryIndexSort;
+  #indexes = /* @__PURE__ */ new Map();
+  #connections = [];
+  #overlay;
+  constructor(tableName, columns, primaryKey, primaryIndexData) {
+    this.#tableName = tableName;
+    this.#columns = columns;
+    this.#primaryKey = primaryKey;
+    this.#primaryIndexSort = primaryKey.map((k) => [k, "asc"]);
+    const comparator2 = makeBoundComparator(this.#primaryIndexSort);
+    this.#indexes.set(JSON.stringify(this.#primaryIndexSort), {
+      comparator: comparator2,
+      data: primaryIndexData ?? new BTreeSet(comparator2),
+      usedBy: /* @__PURE__ */ new Set()
+    });
+    assertOrderingIncludesPK(this.#primaryIndexSort, this.#primaryKey);
   }
-  addServerQuery(ast, gotCallback) {
-    return this.#addQuery(ast, gotCallback);
+  // Mainly for tests.
+  getSchemaInfo() {
+    return {
+      tableName: this.#tableName,
+      columns: this.#columns,
+      primaryKey: this.#primaryKey
+    };
   }
-  createStorage() {
-    return new MemoryStorage();
+  fork() {
+    const primaryIndex = this.#getPrimaryIndex();
+    return new _MemorySource(
+      this.#tableName,
+      this.#columns,
+      this.#primaryKey,
+      primaryIndex.data.clone()
+    );
   }
-  onTransactionCommit(cb) {
-    this.#commitListeners.add(cb);
-    return () => {
-      this.#commitListeners.delete(cb);
+  #getSchema(connection) {
+    return {
+      tableName: this.#tableName,
+      columns: this.#columns,
+      primaryKey: this.#primaryKey,
+      sort: connection.sort,
+      system: "client",
+      relationships: {},
+      isHidden: false,
+      compareRows: connection.compareRows
     };
   }
-  batchViewUpdates(applyViewUpdates) {
-    let result;
-    let viewChangesPerformed = false;
-    this.#batchViewUpdates(() => {
-      result = applyViewUpdates();
-      viewChangesPerformed = true;
-    });
-    assert(
-      viewChangesPerformed,
-      "batchViewUpdates must call applyViewUpdates synchronously."
-    );
-    return result;
+  connect(sort, filters) {
+    const transformedFilters = transformFilters(filters);
+    const input = {
+      getSchema: () => schema,
+      fetch: (req) => this.#fetch(req, connection),
+      cleanup: (req) => this.#cleanup(req, connection),
+      setOutput: (output) => {
+        connection.output = output;
+      },
+      destroy: () => {
+        this.#disconnect(input);
+      },
+      fullyAppliedFilters: !transformedFilters.conditionsRemoved
+    };
+    const connection = {
+      input,
+      output: void 0,
+      sort,
+      compareRows: makeComparator(sort),
+      filters: transformedFilters.filters ? {
+        condition: transformedFilters.filters,
+        predicate: createPredicate(transformedFilters.filters)
+      } : void 0
+    };
+    const schema = this.#getSchema(connection);
+    assertOrderingIncludesPK(sort, this.#primaryKey);
+    this.#connections.push(connection);
+    return input;
   }
-  processChanges(changes) {
-    this.batchViewUpdates(() => {
-      try {
-        for (const diff2 of changes) {
-          const { key } = diff2;
-          assert(key.startsWith(ENTITIES_KEY_PREFIX));
-          const slash = key.indexOf("/", ENTITIES_KEY_PREFIX.length);
-          const name = key.slice(ENTITIES_KEY_PREFIX.length, slash);
-          const source = this.getSource(name);
-          if (!source) {
-            continue;
-          }
-          switch (diff2.op) {
-            case "del":
-              assert(typeof diff2.oldValue === "object");
-              source.push({
-                type: "remove",
-                row: diff2.oldValue
-              });
-              break;
-            case "add":
-              assert(typeof diff2.newValue === "object");
-              source.push({
-                type: "add",
-                row: diff2.newValue
-              });
-              break;
-            case "change":
-              assert(typeof diff2.newValue === "object");
-              assert(typeof diff2.oldValue === "object");
-              source.push({
-                type: "edit",
-                row: diff2.newValue,
-                oldRow: diff2.oldValue
-              });
-              break;
-            default:
-              unreachable(diff2);
-          }
-        }
-      } finally {
-        this.#endTransaction();
+  #disconnect(input) {
+    const idx = this.#connections.findIndex((c) => c.input === input);
+    assert(idx !== -1, "Connection not found");
+    const connection = this.#connections[idx];
+    this.#connections.splice(idx, 1);
+    const primaryIndexKey = JSON.stringify(this.#primaryIndexSort);
+    for (const [key, index] of this.#indexes) {
+      if (key === primaryIndexKey) {
+        continue;
+      }
+      index.usedBy.delete(connection);
+      if (index.usedBy.size === 0) {
+        this.#indexes.delete(key);
       }
-    });
-  }
-  #endTransaction() {
-    for (const listener of this.#commitListeners) {
-      listener();
     }
   }
-};
-
-// ../zero-client/src/client/crud.ts
-function makeCRUDMutate(schema, repMutate) {
-  const { [CRUD_MUTATION_NAME]: zeroCRUD } = repMutate;
-  let inBatch = false;
-  const mutateBatch = async (body) => {
-    if (inBatch) {
-      throw new Error("Cannot call mutate inside a batch");
-    }
-    inBatch = true;
-    try {
-      const ops = [];
-      const m = {};
-      for (const name of Object.keys(schema.tables)) {
-        m[name] = makeBatchCRUDMutate(name, schema, ops);
-      }
-      const rv = await body(m);
-      await zeroCRUD({ ops });
-      return rv;
-    } finally {
-      inBatch = false;
+  #getPrimaryIndex() {
+    const index = this.#indexes.get(JSON.stringify(this.#primaryIndexSort));
+    assert(index, "Primary index not found");
+    return index;
+  }
+  #getOrCreateIndex(sort, usedBy) {
+    const key = JSON.stringify(sort);
+    const index = this.#indexes.get(key);
+    if (index) {
+      index.usedBy.add(usedBy);
+      return index;
     }
-  };
-  const assertNotInBatch = (tableName, op) => {
-    if (inBatch) {
-      throw new Error(`Cannot call mutate.${tableName}.${op} inside a batch`);
+    const comparator2 = makeBoundComparator(sort);
+    const data = new BTreeSet(comparator2);
+    for (const row of this.#getPrimaryIndex().data) {
+      data.add(row);
     }
-  };
-  const mutate = {};
-  for (const [name, tableSchema] of Object.entries(schema.tables)) {
-    mutate[name] = makeEntityCRUDMutate(
-      name,
-      tableSchema.primaryKey,
-      zeroCRUD,
-      assertNotInBatch
-    );
+    const newIndex = { comparator: comparator2, data, usedBy: /* @__PURE__ */ new Set([usedBy]) };
+    this.#indexes.set(key, newIndex);
+    return newIndex;
   }
-  return {
-    mutate,
-    mutateBatch
-  };
-}
-function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch) {
-  return {
-    insert: (value) => {
-      assertNotInBatch(tableName, "insert");
-      const op = {
-        op: "insert",
-        tableName,
-        primaryKey,
-        value
-      };
-      return zeroCRUD({ ops: [op] });
-    },
-    upsert: (value) => {
-      assertNotInBatch(tableName, "upsert");
-      const op = {
-        op: "upsert",
-        tableName,
-        primaryKey,
-        value
-      };
-      return zeroCRUD({ ops: [op] });
-    },
-    update: (value) => {
-      assertNotInBatch(tableName, "update");
-      const op = {
-        op: "update",
-        tableName,
-        primaryKey,
-        value
-      };
-      return zeroCRUD({ ops: [op] });
-    },
-    delete: (id) => {
-      assertNotInBatch(tableName, "delete");
-      const op = {
-        op: "delete",
-        tableName,
-        primaryKey,
-        value: id
-      };
-      return zeroCRUD({ ops: [op] });
+  // For unit testing that we correctly clean up indexes.
+  getIndexKeys() {
+    return [...this.#indexes.keys()];
+  }
+  *#fetch(req, from) {
+    let overlay;
+    const callingConnectionNum = this.#connections.indexOf(from);
+    assert(callingConnectionNum !== -1, "Output not found");
+    const conn = this.#connections[callingConnectionNum];
+    const { sort: requestedSort } = conn;
+    const indexSort = [];
+    if (req.constraint) {
+      for (const key of Object.keys(req.constraint)) {
+        indexSort.push([key, "asc"]);
+      }
     }
-  };
-}
-function makeBatchCRUDMutate(tableName, schema, ops) {
-  const { primaryKey } = schema.tables[tableName];
-  return {
-    insert: (value) => {
-      const op = {
-        op: "insert",
-        tableName,
-        primaryKey,
-        value
-      };
-      ops.push(op);
-      return promiseVoid;
-    },
-    upsert: (value) => {
-      const op = {
-        op: "upsert",
-        tableName,
-        primaryKey,
-        value
-      };
-      ops.push(op);
-      return promiseVoid;
-    },
-    update: (value) => {
-      const op = {
-        op: "update",
-        tableName,
-        primaryKey,
-        value
-      };
-      ops.push(op);
-      return promiseVoid;
-    },
-    delete: (id) => {
-      const op = {
-        op: "delete",
-        tableName,
-        primaryKey,
-        value: id
-      };
-      ops.push(op);
-      return promiseVoid;
+    if (this.#primaryKey.length > 1 || !req.constraint || !constraintMatchesPrimaryKey(req.constraint, this.#primaryKey)) {
+      indexSort.push(...requestedSort);
     }
-  };
-}
-function makeCRUDMutator(schema) {
-  return async function zeroCRUDMutator(tx, crudArg) {
-    for (const op of crudArg.ops) {
-      switch (op.op) {
-        case "insert":
-          await insertImpl(tx, op, schema);
-          break;
-        case "upsert":
-          await upsertImpl(tx, op, schema);
-          break;
-        case "update":
-          await updateImpl(tx, op, schema);
-          break;
-        case "delete":
-          await deleteImpl(tx, op, schema);
-          break;
+    const index = this.#getOrCreateIndex(indexSort, from);
+    const { data, comparator: compare } = index;
+    const comparator2 = (r1, r2) => compare(r1, r2) * (req.reverse ? -1 : 1);
+    if (this.#overlay) {
+      if (callingConnectionNum <= this.#overlay.outputIndex) {
+        overlay = this.#overlay;
       }
     }
-  };
-}
-function defaultOptionalFieldsToNull(schema, value) {
-  let rv = value;
-  for (const name in schema.columns) {
-    if (rv[name] === void 0) {
-      rv = { ...rv, [name]: null };
+    const startAt = req.start?.row;
+    let scanStart;
+    if (req.constraint) {
+      scanStart = {};
+      for (const [key, dir] of indexSort) {
+        if (hasOwn(req.constraint, key)) {
+          scanStart[key] = req.constraint[key];
+        } else {
+          if (req.reverse) {
+            scanStart[key] = dir === "asc" ? maxValue : minValue;
+          } else {
+            scanStart[key] = dir === "asc" ? minValue : maxValue;
+          }
+        }
+      }
+    } else {
+      scanStart = startAt;
     }
-  }
-  return rv;
-}
-async function insertImpl(tx, arg, schema) {
-  const key = toPrimaryKeyString(
-    arg.tableName,
-    schema.tables[arg.tableName].primaryKey,
-    arg.value
-  );
-  if (!await tx.has(key)) {
-    const val = defaultOptionalFieldsToNull(
-      schema.tables[arg.tableName],
-      arg.value
+    const withOverlay = generateWithOverlay(
+      startAt,
+      generateRows(data, scanStart, req.reverse),
+      req.constraint,
+      overlay,
+      comparator2,
+      conn.filters?.predicate
     );
-    await tx.set(key, val);
+    const withConstraint = generateWithConstraint(
+      generateWithStart(withOverlay, req.start, comparator2),
+      req.constraint
+    );
+    yield* conn.filters ? generateWithFilter(withConstraint, conn.filters.predicate) : withConstraint;
   }
-}
-async function upsertImpl(tx, arg, schema) {
-  const key = toPrimaryKeyString(
-    arg.tableName,
-    schema.tables[arg.tableName].primaryKey,
-    arg.value
-  );
-  const val = defaultOptionalFieldsToNull(
-    schema.tables[arg.tableName],
-    arg.value
-  );
-  await tx.set(key, val);
-}
-async function updateImpl(tx, arg, schema) {
-  const key = toPrimaryKeyString(
-    arg.tableName,
-    schema.tables[arg.tableName].primaryKey,
-    arg.value
-  );
-  const prev = await tx.get(key);
-  if (prev === void 0) {
-    return;
+  #cleanup(req, connection) {
+    return this.#fetch(req, connection);
   }
-  const update = arg.value;
-  const next = { ...prev };
-  for (const k in update) {
-    if (update[k] !== void 0) {
-      next[k] = update[k];
+  push(change) {
+    for (const _ of this.genPush(change)) {
     }
   }
-  await tx.set(key, next);
-}
-async function deleteImpl(tx, arg, schema) {
-  const key = toPrimaryKeyString(
-    arg.tableName,
-    schema.tables[arg.tableName].primaryKey,
-    arg.value
-  );
-  await tx.del(key);
-}
-
-// ../zero-client/src/client/custom.ts
-var TransactionImpl = class {
-  constructor(repTx, schema, ivmSourceRepo) {
-    must(repTx.reason === "initial" || repTx.reason === "rebase");
-    this.clientID = repTx.clientID;
-    this.mutationID = repTx.mutationID;
-    this.reason = repTx.reason === "initial" ? "optimistic" : "rebase";
-    this.mutate = makeSchemaCRUD(schema, repTx);
-    this.query = makeSchemaQuery(
-      schema,
-      this.reason === "optimistic" ? ivmSourceRepo.main : (
-        // TODO: we don't initialize the sync branch yet.
-        // to fix in the next PR.
-        ivmSourceRepo.main
-      )
-    );
+  *genPush(change) {
+    const primaryIndex = this.#getPrimaryIndex();
+    const { data } = primaryIndex;
+    switch (change.type) {
+      case "add":
+        assert(
+          !data.has(change.row),
+          () => `Row already exists ${JSON.stringify(change)}`
+        );
+        break;
+      case "remove":
+        assert(
+          data.has(change.row),
+          () => `Row not found ${JSON.stringify(change)}`
+        );
+        break;
+      case "edit":
+        assert(
+          data.has(change.oldRow),
+          () => `Row not found ${JSON.stringify(change)}`
+        );
+        break;
+      default:
+        unreachable(change);
+    }
+    const outputChange = change.type === "edit" ? {
+      type: change.type,
+      oldNode: {
+        row: change.oldRow,
+        relationships: {}
+      },
+      node: {
+        row: change.row,
+        relationships: {}
+      }
+    } : {
+      type: change.type,
+      node: {
+        row: change.row,
+        relationships: {}
+      }
+    };
+    for (const [
+      outputIndex,
+      { output, filters }
+    ] of this.#connections.entries()) {
+      if (output) {
+        this.#overlay = { outputIndex, change };
+        filterPush(outputChange, output, filters?.predicate);
+        yield;
+      }
+    }
+    this.#overlay = void 0;
+    for (const { data: data2 } of this.#indexes.values()) {
+      switch (change.type) {
+        case "add": {
+          const added = data2.add(change.row);
+          assert(added);
+          break;
+        }
+        case "remove": {
+          const removed = data2.delete(change.row);
+          assert(removed);
+          break;
+        }
+        case "edit": {
+          const removed = data2.delete(change.oldRow);
+          assert(removed);
+          data2.add(change.row);
+          break;
+        }
+        default:
+          unreachable(change);
+      }
+    }
   }
-  clientID;
-  mutationID;
-  reason;
-  mutate;
-  query;
 };
-function makeReplicacheMutator(mutator, schema, ivmSourceRepo) {
-  return (repTx, args) => {
-    const tx = new TransactionImpl(repTx, schema, ivmSourceRepo);
-    return mutator(tx, args);
-  };
+function* generateWithConstraint(it, constraint) {
+  for (const node of it) {
+    if (constraint && !constraintMatchesRow(constraint, node.row)) {
+      break;
+    }
+    yield node;
+  }
 }
-function makeSchemaQuery(schema, ivmBranch) {
-  const rv = {};
-  const context = new ZeroContext(
-    ivmBranch,
-    () => () => {
-    },
-    (applyViewUpdates) => applyViewUpdates()
-  );
-  for (const name of Object.keys(schema.tables)) {
-    rv[name] = newQuery(context, schema, name);
+function* generateWithFilter(it, filter) {
+  for (const node of it) {
+    if (filter(node.row)) {
+      yield node;
+    }
   }
-  return rv;
 }
-function makeSchemaCRUD(schema, tx) {
-  const mutate = {};
-  for (const [name] of Object.entries(schema.tables)) {
-    mutate[name] = makeTableCRUD(schema, name, tx);
+function* generateWithStart(nodes, start, compare) {
+  if (!start) {
+    yield* nodes;
+    return;
+  }
+  let started = false;
+  for (const node of nodes) {
+    if (!started) {
+      if (start.basis === "at") {
+        if (compare(node.row, start.row) >= 0) {
+          started = true;
+        }
+      } else if (start.basis === "after") {
+        if (compare(node.row, start.row) > 0) {
+          started = true;
+        }
+      }
+    }
+    if (started) {
+      yield node;
+    }
   }
-  return mutate;
 }
-function makeTableCRUD(schema, tableName, tx) {
-  const table2 = must(schema.tables[tableName]);
-  const { primaryKey } = table2;
-  return {
-    insert: (value) => insertImpl(tx, { op: "insert", tableName, primaryKey, value }, schema),
-    upsert: (value) => upsertImpl(tx, { op: "upsert", tableName, primaryKey, value }, schema),
-    update: (value) => updateImpl(tx, { op: "update", tableName, primaryKey, value }, schema),
-    delete: (id) => deleteImpl(tx, { op: "delete", tableName, primaryKey, value: id }, schema)
-  };
+function* generateWithOverlay(startAt, rows, constraint, overlay, compare, filterPredicate) {
+  const overlays = computeOverlays(
+    startAt,
+    constraint,
+    overlay,
+    compare,
+    filterPredicate
+  );
+  yield* generateWithOverlayInner(rows, overlays, compare);
 }
-
-// ../zero-client/src/client/enable-analytics.ts
-var IPV4_ADDRESS_REGEX = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-var IPV6_ADDRESS_HOSTNAME_REGEX = /^\[[a-fA-F0-9:]*:[a-fA-F0-9:]*\]$/;
-var IP_ADDRESS_HOSTNAME_REGEX = new RegExp(
-  `(${IPV4_ADDRESS_REGEX.source}|${IPV6_ADDRESS_HOSTNAME_REGEX.source})`
-);
-function shouldEnableAnalytics(server, enableAnalytics = true) {
-  if (!enableAnalytics) {
-    return false;
+function computeOverlays(startAt, constraint, overlay, compare, filterPredicate) {
+  let overlays = {
+    add: void 0,
+    remove: void 0
+  };
+  switch (overlay?.change.type) {
+    case "add":
+      overlays = {
+        add: overlay.change.row,
+        remove: void 0
+      };
+      break;
+    case "remove":
+      overlays = {
+        add: void 0,
+        remove: overlay.change.row
+      };
+      break;
+    case "edit":
+      overlays = {
+        add: overlay.change.row,
+        remove: overlay.change.oldRow
+      };
+      break;
   }
-  const serverURL = server === null ? null : new URL(server);
-  const socketHostname = serverURL?.hostname;
-  return server !== null && socketHostname !== void 0 && socketHostname !== "localhost" && !IP_ADDRESS_HOSTNAME_REGEX.test(socketHostname);
+  if (startAt) {
+    overlays = overlaysForStartAt(overlays, startAt, compare);
+  }
+  if (constraint) {
+    overlays = overlaysForConstraint(overlays, constraint);
+  }
+  if (filterPredicate) {
+    overlays = overlaysForFilterPredicate(overlays, filterPredicate);
+  }
+  return overlays;
 }
-
-// ../zero-client/src/client/http-string.ts
-function toWSString(url) {
-  return "ws" + url.slice(4);
+function overlaysForStartAt({ add, remove }, startAt, compare) {
+  const undefinedIfBeforeStartAt = (row) => row === void 0 || compare(row, startAt) < 0 ? void 0 : row;
+  return {
+    add: undefinedIfBeforeStartAt(add),
+    remove: undefinedIfBeforeStartAt(remove)
+  };
 }
-function appendPath(url, toAppend) {
-  return url + (url.endsWith("/") ? toAppend.substring(1) : toAppend);
+function overlaysForConstraint({ add, remove }, constraint) {
+  const undefinedIfDoesntMatchConstraint = (row) => row === void 0 || !constraintMatchesRow(constraint, row) ? void 0 : row;
+  return {
+    add: undefinedIfDoesntMatchConstraint(add),
+    remove: undefinedIfDoesntMatchConstraint(remove)
+  };
 }
-
-// ../zql/src/ivm/constraint.ts
-function constraintMatchesRow(constraint, row) {
-  for (const key in constraint) {
-    if (!valuesEqual(row[key], constraint[key])) {
-      return false;
+function overlaysForFilterPredicate({ add, remove }, filterPredicate) {
+  const undefinedIfDoesntMatchFilter = (row) => row === void 0 || !filterPredicate(row) ? void 0 : row;
+  return {
+    add: undefinedIfDoesntMatchFilter(add),
+    remove: undefinedIfDoesntMatchFilter(remove)
+  };
+}
+function* generateWithOverlayInner(rowIterator, overlays, compare) {
+  let addOverlayYielded = false;
+  let removeOverlaySkipped = false;
+  for (const row of rowIterator) {
+    if (!addOverlayYielded && overlays.add) {
+      const cmp2 = compare(overlays.add, row);
+      if (cmp2 < 0) {
+        addOverlayYielded = true;
+        yield { row: overlays.add, relationships: {} };
+      }
+    }
+    if (!removeOverlaySkipped && overlays.remove) {
+      const cmp2 = compare(overlays.remove, row);
+      if (cmp2 === 0) {
+        removeOverlaySkipped = true;
+        continue;
+      }
     }
+    yield { row, relationships: {} };
   }
-  return true;
-}
-function constraintMatchesPrimaryKey(constraint, primary) {
-  const constraintKeys = Object.keys(constraint);
-  if (constraintKeys.length !== primary.length) {
-    return false;
+  if (!addOverlayYielded && overlays.add) {
+    yield { row: overlays.add, relationships: {} };
   }
-  constraintKeys.sort(stringCompare);
-  for (let i = 0; i < constraintKeys.length; i++) {
-    if (constraintKeys[i][0] !== primary[i]) {
-      return false;
+}
+var minValue = Symbol("min-value");
+var maxValue = Symbol("max-value");
+function makeBoundComparator(sort) {
+  return (a, b) => {
+    for (const entry of sort) {
+      const key = entry[0];
+      const cmp2 = compareBounds(a[key], b[key]);
+      if (cmp2 !== 0) {
+        return entry[1] === "asc" ? cmp2 : -cmp2;
+      }
     }
-  }
-  return true;
+    return 0;
+  };
 }
-
-// ../zql/src/ivm/memory-source.ts
-var MemorySource = class _MemorySource {
-  #tableName;
-  #columns;
-  #primaryKey;
-  #primaryIndexSort;
-  #indexes = /* @__PURE__ */ new Map();
-  #connections = [];
-  #overlay;
-  constructor(tableName, columns, primaryKey, primaryIndexData) {
-    this.#tableName = tableName;
-    this.#columns = columns;
-    this.#primaryKey = primaryKey;
-    this.#primaryIndexSort = primaryKey.map((k) => [k, "asc"]);
-    const comparator2 = makeBoundComparator(this.#primaryIndexSort);
-    this.#indexes.set(JSON.stringify(this.#primaryIndexSort), {
-      comparator: comparator2,
-      data: primaryIndexData ?? new BTreeSet(comparator2),
-      usedBy: /* @__PURE__ */ new Set()
-    });
-    assertOrderingIncludesPK(this.#primaryIndexSort, this.#primaryKey);
-  }
-  // Mainly for tests.
-  getSchemaInfo() {
-    return {
-      tableName: this.#tableName,
-      columns: this.#columns,
-      primaryKey: this.#primaryKey
-    };
+function compareBounds(a, b) {
+  if (a === b) {
+    return 0;
   }
-  fork() {
-    const primaryIndex = this.#getPrimaryIndex();
-    return new _MemorySource(
-      this.#tableName,
-      this.#columns,
-      this.#primaryKey,
-      primaryIndex.data.clone()
-    );
+  if (a === minValue) {
+    return -1;
   }
-  #getSchema(connection) {
-    return {
-      tableName: this.#tableName,
-      columns: this.#columns,
-      primaryKey: this.#primaryKey,
-      sort: connection.sort,
-      system: "client",
-      relationships: {},
-      isHidden: false,
-      compareRows: connection.compareRows
-    };
+  if (b === minValue) {
+    return 1;
   }
-  connect(sort, filters) {
-    const transformedFilters = transformFilters(filters);
-    const input = {
-      getSchema: () => schema,
-      fetch: (req) => this.#fetch(req, connection),
-      cleanup: (req) => this.#cleanup(req, connection),
-      setOutput: (output) => {
-        connection.output = output;
-      },
-      destroy: () => {
-        this.#disconnect(input);
-      },
-      fullyAppliedFilters: !transformedFilters.conditionsRemoved
-    };
-    const connection = {
-      input,
-      output: void 0,
-      sort,
-      compareRows: makeComparator(sort),
-      filters: transformedFilters.filters ? {
-        condition: transformedFilters.filters,
-        predicate: createPredicate(transformedFilters.filters)
-      } : void 0
-    };
-    const schema = this.#getSchema(connection);
-    assertOrderingIncludesPK(sort, this.#primaryKey);
-    this.#connections.push(connection);
-    return input;
+  if (a === maxValue) {
+    return 1;
   }
-  #disconnect(input) {
-    const idx = this.#connections.findIndex((c) => c.input === input);
-    assert(idx !== -1, "Connection not found");
-    const connection = this.#connections[idx];
-    this.#connections.splice(idx, 1);
-    const primaryIndexKey = JSON.stringify(this.#primaryIndexSort);
-    for (const [key, index] of this.#indexes) {
-      if (key === primaryIndexKey) {
-        continue;
-      }
-      index.usedBy.delete(connection);
-      if (index.usedBy.size === 0) {
-        this.#indexes.delete(key);
-      }
-    }
+  if (b === maxValue) {
+    return -1;
   }
-  #getPrimaryIndex() {
-    const index = this.#indexes.get(JSON.stringify(this.#primaryIndexSort));
-    assert(index, "Primary index not found");
-    return index;
+  return compareValues(a, b);
+}
+function* generateRows(data, scanStart, reverse) {
+  yield* data[reverse ? "valuesFromReversed" : "valuesFrom"](
+    scanStart
+  );
+}
+
+// ../zero-client/src/client/keys.ts
+var CLIENTS_KEY_PREFIX = "c/";
+var DESIRED_QUERIES_KEY_PREFIX = "d/";
+var GOT_QUERIES_KEY_PREFIX = "g/";
+var ENTITIES_KEY_PREFIX = "e/";
+function toClientsKey(clientID) {
+  return CLIENTS_KEY_PREFIX + clientID;
+}
+function toDesiredQueriesKey(clientID, hash2) {
+  return DESIRED_QUERIES_KEY_PREFIX + clientID + "/" + hash2;
+}
+function desiredQueriesPrefixForClient(clientID) {
+  return DESIRED_QUERIES_KEY_PREFIX + clientID + "/";
+}
+function toGotQueriesKey(hash2) {
+  return GOT_QUERIES_KEY_PREFIX + hash2;
+}
+function toPrimaryKeyString(tableName, primaryKey, value) {
+  if (primaryKey.length === 1) {
+    return ENTITIES_KEY_PREFIX + tableName + "/" + parse(value[primaryKey[0]], primaryKeyValueSchema);
   }
-  #getOrCreateIndex(sort, usedBy) {
-    const key = JSON.stringify(sort);
-    const index = this.#indexes.get(key);
-    if (index) {
-      index.usedBy.add(usedBy);
-      return index;
-    }
-    const comparator2 = makeBoundComparator(sort);
-    const data = new BTreeSet(comparator2);
-    for (const row of this.#getPrimaryIndex().data) {
-      data.add(row);
-    }
-    const newIndex = { comparator: comparator2, data, usedBy: /* @__PURE__ */ new Set([usedBy]) };
-    this.#indexes.set(key, newIndex);
-    return newIndex;
+  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/ivm-source-repo.ts
+var IVMSourceRepo = class {
+  #main;
+  #tables;
+  /**
+   * Sync is lazily created when the first response from the server is received.
+   */
+  #sync;
+  /**
+   * Rebase is created when the sync head is advanced and points to a fork
+   * of the sync head. This is used to rebase optimistic mutations.
+   */
+  #rebase;
+  constructor(tables) {
+    this.#main = new IVMSourceBranch(tables);
+    this.#tables = tables;
   }
-  // For unit testing that we correctly clean up indexes.
-  getIndexKeys() {
-    return [...this.#indexes.keys()];
+  get main() {
+    return this.#main;
   }
-  *#fetch(req, from) {
-    let overlay;
-    const callingConnectionNum = this.#connections.indexOf(from);
-    assert(callingConnectionNum !== -1, "Output not found");
-    const conn = this.#connections[callingConnectionNum];
-    const { sort: requestedSort } = conn;
-    const indexSort = [];
-    if (req.constraint) {
-      for (const key of Object.keys(req.constraint)) {
-        indexSort.push([key, "asc"]);
-      }
-    }
-    if (this.#primaryKey.length > 1 || !req.constraint || !constraintMatchesPrimaryKey(req.constraint, this.#primaryKey)) {
-      indexSort.push(...requestedSort);
-    }
-    const index = this.#getOrCreateIndex(indexSort, from);
-    const { data, comparator: compare } = index;
-    const comparator2 = (r1, r2) => compare(r1, r2) * (req.reverse ? -1 : 1);
-    if (this.#overlay) {
-      if (callingConnectionNum <= this.#overlay.outputIndex) {
-        overlay = this.#overlay;
-      }
-    }
-    const startAt = req.start?.row;
-    let scanStart;
-    if (req.constraint) {
-      scanStart = {};
-      for (const [key, dir] of indexSort) {
-        if (hasOwn(req.constraint, key)) {
-          scanStart[key] = req.constraint[key];
-        } else {
-          if (req.reverse) {
-            scanStart[key] = dir === "asc" ? maxValue : minValue;
-          } else {
-            scanStart[key] = dir === "asc" ? minValue : maxValue;
+  /**
+   * Used for reads in `zero.TransactionImpl`.
+   * Writes in `zero.TransactionImpl` also get applied to the rebase branch.
+   *
+   * The rebase branch is always forked off of the sync branch when a rebase begins.
+   */
+  get rebase() {
+    return must(this.#rebase, "rebase branch does not exist!");
+  }
+  advanceSyncHead = async (store, syncHeadHash, patches) => {
+    if (this.#sync === void 0) {
+      await withRead(store, async (dagRead) => {
+        const syncSources = new IVMSourceBranch(this.#tables);
+        const read = await readFromHash(
+          syncHeadHash,
+          dagRead,
+          Latest
+        );
+        for await (const entry of read.map.scan(ENTITIES_KEY_PREFIX)) {
+          if (!entry[0].startsWith(ENTITIES_KEY_PREFIX)) {
+            break;
           }
+          const name = sourceNameFromKey(entry[0]);
+          const source = must(syncSources.getSource(name));
+          source.push({
+            type: "add",
+            row: entry[1]
+          });
         }
-      }
+        this.#sync = syncSources;
+      });
     } else {
-      scanStart = startAt;
+      for (const patch of patches) {
+        if (patch.op === "clear") {
+          this.#sync.clear();
+          continue;
+        }
+        const { key } = patch;
+        if (!key.startsWith(ENTITIES_KEY_PREFIX)) {
+          continue;
+        }
+        const name = sourceNameFromKey(key);
+        const source = must(this.#sync.getSource(name));
+        switch (patch.op) {
+          case "del":
+            source.push({
+              type: "remove",
+              row: patch.oldValue
+            });
+            break;
+          case "add":
+            source.push({
+              type: "add",
+              row: patch.newValue
+            });
+            break;
+          case "change":
+            source.push({
+              type: "edit",
+              row: patch.newValue,
+              oldRow: patch.oldValue
+            });
+            break;
+        }
+      }
     }
-    const withOverlay = generateWithOverlay(
-      startAt,
-      generateRows(data, scanStart, req.reverse),
-      req.constraint,
-      overlay,
-      comparator2,
-      conn.filters?.predicate
-    );
-    const withConstraint = generateWithConstraint(
-      generateWithStart(withOverlay, req.start, comparator2),
-      req.constraint
+    this.#rebase = must(this.#sync).fork();
+  };
+};
+var IVMSourceBranch = class _IVMSourceBranch {
+  #sources;
+  #tables;
+  constructor(tables, sources = /* @__PURE__ */ new Map()) {
+    this.#tables = tables;
+    this.#sources = sources;
+  }
+  getSource(name) {
+    if (this.#sources.has(name)) {
+      return this.#sources.get(name);
+    }
+    const schema = this.#tables[name];
+    const source = schema ? new MemorySource(name, schema.columns, schema.primaryKey) : void 0;
+    this.#sources.set(name, source);
+    return source;
+  }
+  clear() {
+    this.#sources.clear();
+  }
+  /**
+   * Creates a new IVMSourceBranch that is a copy of the current one.
+   * This is a cheap operation since the b-trees are shared until a write is performed
+   * and then only the modified nodes are copied.
+   *
+   * This is used when:
+   * 1. We need to rebase a change. We fork the `sync` branch and run the mutations against the fork.
+   * 2. We need to create `main` at startup.
+   * 3. We need to create a new `sync` head because we got a new server snapshot.
+   *    The old `sync` head is forked and the new server snapshot is applied to the fork.
+   */
+  fork() {
+    return new _IVMSourceBranch(
+      this.#tables,
+      new Map(
+        wrapIterable(this.#sources.entries()).map(([name, source]) => [
+          name,
+          source?.fork()
+        ])
+      )
     );
-    yield* conn.filters ? generateWithFilter(withConstraint, conn.filters.predicate) : withConstraint;
   }
-  #cleanup(req, connection) {
-    return this.#fetch(req, connection);
+};
+
+// ../zero-client/src/client/context.ts
+var ZeroContext = class {
+  // It is a bummer to have to maintain separate MemorySources here and copy the
+  // data in from the Replicache db. But we want the data to be accessible via
+  // pipelines *synchronously* and the core Replicache infra is all async. So
+  // that needs to be fixed.
+  #mainSources;
+  #addQuery;
+  #batchViewUpdates;
+  #commitListeners = /* @__PURE__ */ new Set();
+  staticQueryParameters = void 0;
+  constructor(mainSources, addQuery, batchViewUpdates) {
+    this.#mainSources = mainSources;
+    this.#addQuery = addQuery;
+    this.#batchViewUpdates = batchViewUpdates;
   }
-  push(change) {
-    for (const _ of this.genPush(change)) {
-    }
+  getSource(name) {
+    return this.#mainSources.getSource(name);
   }
-  *genPush(change) {
-    const primaryIndex = this.#getPrimaryIndex();
-    const { data } = primaryIndex;
-    switch (change.type) {
-      case "add":
-        assert(
-          !data.has(change.row),
-          () => `Row already exists ${JSON.stringify(change)}`
-        );
-        break;
-      case "remove":
-        assert(
-          data.has(change.row),
-          () => `Row not found ${JSON.stringify(change)}`
-        );
-        break;
-      case "edit":
-        assert(
-          data.has(change.oldRow),
-          () => `Row not found ${JSON.stringify(change)}`
-        );
-        break;
-      default:
-        unreachable(change);
-    }
-    const outputChange = change.type === "edit" ? {
-      type: change.type,
-      oldNode: {
-        row: change.oldRow,
-        relationships: {}
-      },
-      node: {
-        row: change.row,
-        relationships: {}
-      }
-    } : {
-      type: change.type,
-      node: {
-        row: change.row,
-        relationships: {}
-      }
-    };
-    for (const [
-      outputIndex,
-      { output, filters }
-    ] of this.#connections.entries()) {
-      if (output) {
-        this.#overlay = { outputIndex, change };
-        filterPush(outputChange, output, filters?.predicate);
-        yield;
-      }
-    }
-    this.#overlay = void 0;
-    for (const { data: data2 } of this.#indexes.values()) {
-      switch (change.type) {
-        case "add": {
-          const added = data2.add(change.row);
-          assert(added);
-          break;
-        }
-        case "remove": {
-          const removed = data2.delete(change.row);
-          assert(removed);
-          break;
-        }
-        case "edit": {
-          const removed = data2.delete(change.oldRow);
-          assert(removed);
-          data2.add(change.row);
-          break;
+  addServerQuery(ast, gotCallback) {
+    return this.#addQuery(ast, gotCallback);
+  }
+  createStorage() {
+    return new MemoryStorage();
+  }
+  onTransactionCommit(cb) {
+    this.#commitListeners.add(cb);
+    return () => {
+      this.#commitListeners.delete(cb);
+    };
+  }
+  batchViewUpdates(applyViewUpdates) {
+    let result;
+    let viewChangesPerformed = false;
+    this.#batchViewUpdates(() => {
+      result = applyViewUpdates();
+      viewChangesPerformed = true;
+    });
+    assert(
+      viewChangesPerformed,
+      "batchViewUpdates must call applyViewUpdates synchronously."
+    );
+    return result;
+  }
+  processChanges(changes) {
+    this.batchViewUpdates(() => {
+      try {
+        for (const diff2 of changes) {
+          const { key } = diff2;
+          assert(key.startsWith(ENTITIES_KEY_PREFIX));
+          const name = sourceNameFromKey(key);
+          const source = this.getSource(name);
+          if (!source) {
+            continue;
+          }
+          switch (diff2.op) {
+            case "del":
+              assert(typeof diff2.oldValue === "object");
+              source.push({
+                type: "remove",
+                row: diff2.oldValue
+              });
+              break;
+            case "add":
+              assert(typeof diff2.newValue === "object");
+              source.push({
+                type: "add",
+                row: diff2.newValue
+              });
+              break;
+            case "change":
+              assert(typeof diff2.newValue === "object");
+              assert(typeof diff2.oldValue === "object");
+              source.push({
+                type: "edit",
+                row: diff2.newValue,
+                oldRow: diff2.oldValue
+              });
+              break;
+            default:
+              unreachable(diff2);
+          }
         }
-        default:
-          unreachable(change);
+      } finally {
+        this.#endTransaction();
       }
-    }
+    });
   }
-};
-function* generateWithConstraint(it, constraint) {
-  for (const node of it) {
-    if (constraint && !constraintMatchesRow(constraint, node.row)) {
-      break;
+  #endTransaction() {
+    for (const listener of this.#commitListeners) {
+      listener();
     }
-    yield node;
   }
-}
-function* generateWithFilter(it, filter) {
-  for (const node of it) {
-    if (filter(node.row)) {
-      yield node;
+};
+
+// ../zero-client/src/client/crud.ts
+function makeCRUDMutate(schema, repMutate) {
+  const { [CRUD_MUTATION_NAME]: zeroCRUD } = repMutate;
+  let inBatch = false;
+  const mutateBatch = async (body) => {
+    if (inBatch) {
+      throw new Error("Cannot call mutate inside a batch");
     }
-  }
-}
-function* generateWithStart(nodes, start, compare) {
-  if (!start) {
-    yield* nodes;
-    return;
-  }
-  let started = false;
-  for (const node of nodes) {
-    if (!started) {
-      if (start.basis === "at") {
-        if (compare(node.row, start.row) >= 0) {
-          started = true;
-        }
-      } else if (start.basis === "after") {
-        if (compare(node.row, start.row) > 0) {
-          started = true;
-        }
+    inBatch = true;
+    try {
+      const ops = [];
+      const m = {};
+      for (const name of Object.keys(schema.tables)) {
+        m[name] = makeBatchCRUDMutate(name, schema, ops);
       }
+      const rv = await body(m);
+      await zeroCRUD({ ops });
+      return rv;
+    } finally {
+      inBatch = false;
     }
-    if (started) {
-      yield node;
+  };
+  const assertNotInBatch = (tableName, op) => {
+    if (inBatch) {
+      throw new Error(`Cannot call mutate.${tableName}.${op} inside a batch`);
     }
-  }
-}
-function* generateWithOverlay(startAt, rows, constraint, overlay, compare, filterPredicate) {
-  const overlays = computeOverlays(
-    startAt,
-    constraint,
-    overlay,
-    compare,
-    filterPredicate
-  );
-  yield* generateWithOverlayInner(rows, overlays, compare);
-}
-function computeOverlays(startAt, constraint, overlay, compare, filterPredicate) {
-  let overlays = {
-    add: void 0,
-    remove: void 0
   };
-  switch (overlay?.change.type) {
-    case "add":
-      overlays = {
-        add: overlay.change.row,
-        remove: void 0
-      };
-      break;
-    case "remove":
-      overlays = {
-        add: void 0,
-        remove: overlay.change.row
-      };
-      break;
-    case "edit":
-      overlays = {
-        add: overlay.change.row,
-        remove: overlay.change.oldRow
-      };
-      break;
-  }
-  if (startAt) {
-    overlays = overlaysForStartAt(overlays, startAt, compare);
-  }
-  if (constraint) {
-    overlays = overlaysForConstraint(overlays, constraint);
-  }
-  if (filterPredicate) {
-    overlays = overlaysForFilterPredicate(overlays, filterPredicate);
+  const mutate = {};
+  for (const [name, tableSchema] of Object.entries(schema.tables)) {
+    mutate[name] = makeEntityCRUDMutate(
+      name,
+      tableSchema.primaryKey,
+      zeroCRUD,
+      assertNotInBatch
+    );
   }
-  return overlays;
-}
-function overlaysForStartAt({ add, remove }, startAt, compare) {
-  const undefinedIfBeforeStartAt = (row) => row === void 0 || compare(row, startAt) < 0 ? void 0 : row;
   return {
-    add: undefinedIfBeforeStartAt(add),
-    remove: undefinedIfBeforeStartAt(remove)
+    mutate,
+    mutateBatch
   };
 }
-function overlaysForConstraint({ add, remove }, constraint) {
-  const undefinedIfDoesntMatchConstraint = (row) => row === void 0 || !constraintMatchesRow(constraint, row) ? void 0 : row;
+function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch) {
   return {
-    add: undefinedIfDoesntMatchConstraint(add),
-    remove: undefinedIfDoesntMatchConstraint(remove)
+    insert: (value) => {
+      assertNotInBatch(tableName, "insert");
+      const op = {
+        op: "insert",
+        tableName,
+        primaryKey,
+        value
+      };
+      return zeroCRUD({ ops: [op] });
+    },
+    upsert: (value) => {
+      assertNotInBatch(tableName, "upsert");
+      const op = {
+        op: "upsert",
+        tableName,
+        primaryKey,
+        value
+      };
+      return zeroCRUD({ ops: [op] });
+    },
+    update: (value) => {
+      assertNotInBatch(tableName, "update");
+      const op = {
+        op: "update",
+        tableName,
+        primaryKey,
+        value
+      };
+      return zeroCRUD({ ops: [op] });
+    },
+    delete: (id) => {
+      assertNotInBatch(tableName, "delete");
+      const op = {
+        op: "delete",
+        tableName,
+        primaryKey,
+        value: id
+      };
+      return zeroCRUD({ ops: [op] });
+    }
   };
 }
-function overlaysForFilterPredicate({ add, remove }, filterPredicate) {
-  const undefinedIfDoesntMatchFilter = (row) => row === void 0 || !filterPredicate(row) ? void 0 : row;
+function makeBatchCRUDMutate(tableName, schema, ops) {
+  const { primaryKey } = schema.tables[tableName];
   return {
-    add: undefinedIfDoesntMatchFilter(add),
-    remove: undefinedIfDoesntMatchFilter(remove)
+    insert: (value) => {
+      const op = {
+        op: "insert",
+        tableName,
+        primaryKey,
+        value
+      };
+      ops.push(op);
+      return promiseVoid;
+    },
+    upsert: (value) => {
+      const op = {
+        op: "upsert",
+        tableName,
+        primaryKey,
+        value
+      };
+      ops.push(op);
+      return promiseVoid;
+    },
+    update: (value) => {
+      const op = {
+        op: "update",
+        tableName,
+        primaryKey,
+        value
+      };
+      ops.push(op);
+      return promiseVoid;
+    },
+    delete: (id) => {
+      const op = {
+        op: "delete",
+        tableName,
+        primaryKey,
+        value: id
+      };
+      ops.push(op);
+      return promiseVoid;
+    }
   };
 }
-function* generateWithOverlayInner(rowIterator, overlays, compare) {
-  let addOverlayYielded = false;
-  let removeOverlaySkipped = false;
-  for (const row of rowIterator) {
-    if (!addOverlayYielded && overlays.add) {
-      const cmp2 = compare(overlays.add, row);
-      if (cmp2 < 0) {
-        addOverlayYielded = true;
-        yield { row: overlays.add, relationships: {} };
+function makeCRUDMutator(schema) {
+  return async function zeroCRUDMutator(tx, crudArg) {
+    for (const op of crudArg.ops) {
+      switch (op.op) {
+        case "insert":
+          await insertImpl(tx, op, schema, void 0);
+          break;
+        case "upsert":
+          await upsertImpl(tx, op, schema, void 0);
+          break;
+        case "update":
+          await updateImpl(tx, op, schema, void 0);
+          break;
+        case "delete":
+          await deleteImpl(tx, op, schema, void 0);
+          break;
       }
     }
-    if (!removeOverlaySkipped && overlays.remove) {
-      const cmp2 = compare(overlays.remove, row);
-      if (cmp2 === 0) {
-        removeOverlaySkipped = true;
-        continue;
-      }
+  };
+}
+function defaultOptionalFieldsToNull(schema, value) {
+  let rv = value;
+  for (const name in schema.columns) {
+    if (rv[name] === void 0) {
+      rv = { ...rv, [name]: null };
     }
-    yield { row, relationships: {} };
-  }
-  if (!addOverlayYielded && overlays.add) {
-    yield { row: overlays.add, relationships: {} };
   }
+  return rv;
 }
-var minValue = Symbol("min-value");
-var maxValue = Symbol("max-value");
-function makeBoundComparator(sort) {
-  return (a, b) => {
-    for (const entry of sort) {
-      const key = entry[0];
-      const cmp2 = compareBounds(a[key], b[key]);
-      if (cmp2 !== 0) {
-        return entry[1] === "asc" ? cmp2 : -cmp2;
-      }
+async function insertImpl(tx, arg, schema, ivmBranch) {
+  const key = toPrimaryKeyString(
+    arg.tableName,
+    schema.tables[arg.tableName].primaryKey,
+    arg.value
+  );
+  if (!await tx.has(key)) {
+    const val = defaultOptionalFieldsToNull(
+      schema.tables[arg.tableName],
+      arg.value
+    );
+    await tx.set(key, val);
+    if (ivmBranch) {
+      must(ivmBranch.getSource(arg.tableName)).push({
+        type: "add",
+        row: arg.value
+      });
     }
-    return 0;
-  };
-}
-function compareBounds(a, b) {
-  if (a === b) {
-    return 0;
   }
-  if (a === minValue) {
-    return -1;
+}
+async function upsertImpl(tx, arg, schema, ivmBranch) {
+  const key = toPrimaryKeyString(
+    arg.tableName,
+    schema.tables[arg.tableName].primaryKey,
+    arg.value
+  );
+  const val = defaultOptionalFieldsToNull(
+    schema.tables[arg.tableName],
+    arg.value
+  );
+  await tx.set(key, val);
+  if (ivmBranch) {
+    must(ivmBranch.getSource(arg.tableName)).push({
+      type: "add",
+      row: arg.value
+    });
   }
-  if (b === minValue) {
-    return 1;
+}
+async function updateImpl(tx, arg, schema, ivmBranch) {
+  const key = toPrimaryKeyString(
+    arg.tableName,
+    schema.tables[arg.tableName].primaryKey,
+    arg.value
+  );
+  const prev = await tx.get(key);
+  if (prev === void 0) {
+    return;
   }
-  if (a === maxValue) {
-    return 1;
+  const update = arg.value;
+  const next = { ...prev };
+  for (const k in update) {
+    if (update[k] !== void 0) {
+      next[k] = update[k];
+    }
   }
-  if (b === maxValue) {
-    return -1;
+  await tx.set(key, next);
+  if (ivmBranch) {
+    must(ivmBranch.getSource(arg.tableName)).push({
+      type: "edit",
+      oldRow: prev,
+      row: next
+    });
   }
-  return compareValues(a, b);
 }
-function* generateRows(data, scanStart, reverse) {
-  yield* data[reverse ? "valuesFromReversed" : "valuesFrom"](
-    scanStart
+async function deleteImpl(tx, arg, schema, ivmBranch) {
+  const key = toPrimaryKeyString(
+    arg.tableName,
+    schema.tables[arg.tableName].primaryKey,
+    arg.value
   );
-}
-
-// ../zero-client/src/client/ivm-source-repo.ts
-var IVMSourceRepo = class {
-  #main;
-  #tables;
-  sync;
-  constructor(tables) {
-    this.#main = new IVMSourceBranch(tables);
-    this.#tables = tables;
+  const prev = await tx.get(key);
+  if (prev === void 0) {
+    return;
   }
-  get main() {
-    return this.#main;
+  await tx.del(key);
+  if (ivmBranch) {
+    must(ivmBranch.getSource(arg.tableName)).push({
+      type: "remove",
+      row: prev
+    });
   }
-  /**
-   * Creates a new empty branch.
-   */
-  newBranch() {
-    return new IVMSourceBranch(this.#tables);
+}
+
+// ../zero-client/src/client/custom.ts
+var TransactionImpl = class {
+  constructor(repTx, schema, ivmSourceRepo) {
+    must(repTx.reason === "initial" || repTx.reason === "rebase");
+    this.clientID = repTx.clientID;
+    this.mutationID = repTx.mutationID;
+    this.reason = repTx.reason === "initial" ? "optimistic" : "rebase";
+    this.mutate = makeSchemaCRUD(
+      schema,
+      repTx,
+      // Mutators do not write to the main IVM sources during optimistic mutations
+      // so we pass undefined here.
+      // ExperimentalWatch handles updating main.
+      this.reason === "optimistic" ? void 0 : ivmSourceRepo.rebase
+    );
+    this.query = makeSchemaQuery(
+      schema,
+      this.reason === "optimistic" ? ivmSourceRepo.main : ivmSourceRepo.rebase
+    );
   }
+  clientID;
+  mutationID;
+  reason;
+  mutate;
+  query;
 };
-var IVMSourceBranch = class _IVMSourceBranch {
-  #sources;
-  #tables;
-  constructor(tables, sources = /* @__PURE__ */ new Map()) {
-    this.#tables = tables;
-    this.#sources = sources;
+function makeReplicacheMutator(mutator, schema, ivmSourceRepo) {
+  return (repTx, args) => {
+    const tx = new TransactionImpl(repTx, schema, ivmSourceRepo);
+    return mutator(tx, args);
+  };
+}
+function makeSchemaQuery(schema, ivmBranch) {
+  const rv = {};
+  const context = new ZeroContext(
+    ivmBranch,
+    () => () => {
+    },
+    (applyViewUpdates) => applyViewUpdates()
+  );
+  for (const name of Object.keys(schema.tables)) {
+    rv[name] = newQuery(context, schema, name);
   }
-  getSource(name) {
-    if (this.#sources.has(name)) {
-      return this.#sources.get(name);
-    }
-    const schema = this.#tables[name];
-    const source = schema ? new MemorySource(name, schema.columns, schema.primaryKey) : void 0;
-    this.#sources.set(name, source);
-    return source;
+  return rv;
+}
+function makeSchemaCRUD(schema, tx, ivmBranch) {
+  const mutate = {};
+  for (const [name] of Object.entries(schema.tables)) {
+    mutate[name] = makeTableCRUD(schema, name, tx, ivmBranch);
   }
-  /**
-   * Creates a new IVMSourceBranch that is a copy of the current one.
-   *
-   * This is used when:
-   * 1. We need to rebase a change. We fork the `sync` branch and run the mutations against the fork.
-   * 2. We need to create `main` at startup.
-   * 3. We need to create a new `sync` head because we got a new server snapshot.
-   *    The old `sync` head is forked and the new server snapshot is applied to the fork.
-   */
-  fork() {
-    return new _IVMSourceBranch(
-      this.#tables,
-      new Map(
-        wrapIterable(this.#sources.entries()).map(([name, source]) => [
-          name,
-          source?.fork()
-        ])
-      )
-    );
+  return mutate;
+}
+function makeTableCRUD(schema, tableName, tx, ivmBranch) {
+  const table2 = must(schema.tables[tableName]);
+  const { primaryKey } = table2;
+  return {
+    insert: (value) => insertImpl(
+      tx,
+      { op: "insert", tableName, primaryKey, value },
+      schema,
+      ivmBranch
+    ),
+    upsert: (value) => upsertImpl(
+      tx,
+      { op: "upsert", tableName, primaryKey, value },
+      schema,
+      ivmBranch
+    ),
+    update: (value) => updateImpl(
+      tx,
+      { op: "update", tableName, primaryKey, value },
+      schema,
+      ivmBranch
+    ),
+    delete: (id) => deleteImpl(
+      tx,
+      { op: "delete", tableName, primaryKey, value: id },
+      schema,
+      ivmBranch
+    )
+  };
+}
+
+// ../zero-client/src/client/enable-analytics.ts
+var IPV4_ADDRESS_REGEX = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+var IPV6_ADDRESS_HOSTNAME_REGEX = /^\[[a-fA-F0-9:]*:[a-fA-F0-9:]*\]$/;
+var IP_ADDRESS_HOSTNAME_REGEX = new RegExp(
+  `(${IPV4_ADDRESS_REGEX.source}|${IPV6_ADDRESS_HOSTNAME_REGEX.source})`
+);
+function shouldEnableAnalytics(server, enableAnalytics = true) {
+  if (!enableAnalytics) {
+    return false;
   }
-};
+  const serverURL = server === null ? null : new URL(server);
+  const socketHostname = serverURL?.hostname;
+  return server !== null && socketHostname !== void 0 && socketHostname !== "localhost" && !IP_ADDRESS_HOSTNAME_REGEX.test(socketHostname);
+}
+
+// ../zero-client/src/client/http-string.ts
+function toWSString(url) {
+  return "ws" + url.slice(4);
+}
+function appendPath(url, toAppend) {
+  return url + (url.endsWith("/") ? toAppend.substring(1) : toAppend);
+}
 
 // ../zero-client/src/client/log-options.ts
 import {
@@ -13701,7 +13878,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.13.2025020500";
+var version2 = "0.13.2025020700";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14900,7 +15077,7 @@ var Zero = class {
     });
     this.#metrics.tags.push(`version:${this.version}`);
     this.#pokeHandler = new PokeHandler(
-      (poke) => this.#rep.poke(poke),
+      (poke) => this.#rep.poke(poke, this.#ivmSources.advanceSyncHead),
       () => this.#onPokeError(),
       rep.clientID,
       schema,
@@ -15813,4 +15990,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-H3C7QNPL.js.map
+//# sourceMappingURL=chunk-FVVIM6TT.js.map