@rocicorp/zero 0.13.2025020303 → 0.13.2025020402

package/out/{chunk-L6HKVJYT.js → chunk-ADFMUREC.js}

@@ -18,7 +18,7 @@ import {
   throwInvalidType,
   unreachable,
   valuesEqual
-} from "./chunk-ZVLXEWWB.js";
+} from "./chunk-Q6D7EOS6.js";
 import {
   __export,
   __reExport
@@ -1957,6 +1957,38 @@ function* joinIterables(...iters) {
     yield* iter;
   }
 }
+function* filterIter(iter, p) {
+  let index = 0;
+  for (const t2 of iter) {
+    if (p(t2, index++)) {
+      yield t2;
+    }
+  }
+}
+function* mapIter(iter, f) {
+  let index = 0;
+  for (const t2 of iter) {
+    yield f(t2, index++);
+  }
+}
+var IterWrapper = class _IterWrapper {
+  iter;
+  constructor(iter) {
+    this.iter = iter;
+  }
+  [Symbol.iterator]() {
+    return this.iter[Symbol.iterator]();
+  }
+  map(f) {
+    return new _IterWrapper(mapIter(this.iter, f));
+  }
+  filter(p) {
+    return new _IterWrapper(filterIter(this.iter, p));
+  }
+};
+function wrapIterable(iter) {
+  return new IterWrapper(iter);
+}
 function* mergeIterables(iterables, comparator2, distinct = false) {
   const iterators = iterables.map((i) => i[Symbol.iterator]());
   try {
@@ -8286,6 +8318,87 @@ function one(...args) {
   }));
 }
 
+// ../zero-schema/src/name-mapper.ts
+function clientToServer(tables) {
+  return createMapperFrom("client", tables);
+}
+function serverToClient(tables) {
+  return createMapperFrom("server", tables);
+}
+function createMapperFrom(src, tables) {
+  const mapping = new Map(
+    Object.entries(tables).map(
+      ([tableName, { serverName: serverTableName, columns }]) => {
+        let allColumnsSame = true;
+        const names = {};
+        for (const [name, { serverName }] of Object.entries(columns)) {
+          if (serverName && serverName !== name) {
+            allColumnsSame = false;
+          }
+          if (src === "client") {
+            names[name] = serverName ?? name;
+          } else {
+            names[serverName ?? name] = name;
+          }
+        }
+        return [
+          src === "client" ? tableName : serverTableName ?? tableName,
+          {
+            tableName: src === "client" ? serverTableName ?? tableName : tableName,
+            columns: names,
+            allColumnsSame
+          }
+        ];
+      }
+    )
+  );
+  return new NameMapper(mapping);
+}
+var NameMapper = class {
+  #tables = /* @__PURE__ */ new Map();
+  constructor(tables) {
+    this.#tables = tables;
+  }
+  #getTable(src, ctx) {
+    const table2 = this.#tables.get(src);
+    if (!table2) {
+      throw new Error(
+        `unknown table "${src}" ${!ctx ? "" : `in ${JSON.stringify(ctx)}`}`
+      );
+    }
+    return table2;
+  }
+  tableName(src, context) {
+    return this.#getTable(src, context).tableName;
+  }
+  columnName(table2, src, ctx) {
+    const dst = this.#getTable(table2, ctx).columns[src];
+    if (!dst) {
+      throw new Error(
+        `unknown column "${src}" of "${table2}" table ${!ctx ? "" : `in ${JSON.stringify(ctx)}`}`
+      );
+    }
+    return dst;
+  }
+  row(table2, row) {
+    const dest = this.#getTable(table2);
+    const { allColumnsSame, columns } = dest;
+    if (allColumnsSame) {
+      return row;
+    }
+    const clientRow = {};
+    for (const col in row) {
+      clientRow[columns[col] ?? col] = row[col];
+    }
+    return clientRow;
+  }
+  columns(table2, cols) {
+    const dest = this.#getTable(table2);
+    const { allColumnsSame, columns } = dest;
+    return cols === void 0 || allColumnsSame ? cols : cols.map((col) => columns[col] ?? col);
+  }
+};
+
 // ../zero-schema/src/builder/table-builder.ts
 function table(name) {
   return new TableBuilder({
@@ -8696,77 +8809,23 @@ function normalizeAST(ast) {
   }
   return normalized;
 }
-function toServerAST(ast, tables) {
-  return transformAST(ast, clientToServer(tables));
-}
-function toServerCondition(cond, table2, tables) {
-  return transformWhere(cond, table2, clientToServer(tables));
-}
-function clientToServer(tables) {
-  const mustTable = (table2) => {
-    const t2 = tables[table2];
-    if (!table2) {
-      throw new Error(`invalid table "${table2}"`);
-    }
-    return t2;
-  };
-  return {
-    tableName: (table2) => mustTable(table2).serverName ?? table2,
-    columnName: (table2, col) => {
-      const c = mustTable(table2).columns[col];
-      if (!c) {
-        throw new Error(`invalid column "${col}" in table "${table2}"`);
-      }
-      return c.serverName ?? col;
-    },
+function mapAST(ast, mapper) {
+  return transformAST(ast, {
+    tableName: (table2) => mapper.tableName(table2),
+    columnName: (table2, col) => mapper.columnName(table2, col),
     related: (r) => r,
     where: (w) => w,
     conditions: (c) => c
-  };
-}
-function toClientAST(ast, tables) {
-  return transformAST(ast, serverToClient(tables));
+  });
 }
-function serverToClient(tables) {
-  const tableNames = Object.fromEntries(
-    Object.entries(tables).map(([clientName, { serverName }]) => [
-      serverName ?? clientName,
-      clientName
-    ])
-  );
-  const columnNamesByTable = Object.fromEntries(
-    Object.entries(tables).map(
-      ([clientTable, { serverName: serverTable, columns }]) => {
-        const columnNames = Object.fromEntries(
-          Object.entries(columns).map(([clientName, { serverName }]) => [
-            serverName ?? clientName,
-            clientName
-          ])
-        );
-        return [serverTable ?? clientTable, columnNames];
-      }
-    )
-  );
-  function mustTable(table2, tables2) {
-    const t2 = tables2[table2];
-    if (!table2) {
-      throw new Error(`invalid table "${table2}"`);
-    }
-    return t2;
-  }
-  return {
-    tableName: (table2) => mustTable(table2, tableNames),
-    columnName: (table2, col) => {
-      const name = mustTable(table2, columnNamesByTable)[col];
-      if (!name) {
-        throw new Error(`invalid column "${col}" in table "${table2}"`);
-      }
-      return name;
-    },
+function mapCondition(cond, table2, mapper) {
+  return transformWhere(cond, table2, {
+    tableName: (table3) => mapper.tableName(table3),
+    columnName: (table3, col) => mapper.columnName(table3, col),
     related: (r) => r,
     where: (w) => w,
     conditions: (c) => c
-  };
+  });
 }
 function sortedRelated(related) {
   return related.sort(cmpRelated);
@@ -11424,18 +11483,19 @@ function compilePermissions(schema, authz, expressionBuilders) {
   if (!authz) {
     return void 0;
   }
+  const nameMapper = clientToServer(schema.tables);
   const ret = {};
   for (const [tableName, tableConfig] of Object.entries(authz)) {
     const serverName = schema.tables[tableName].serverName ?? tableName;
     ret[serverName] = {
       row: compileRowConfig(
-        schema,
+        nameMapper,
         tableName,
         tableConfig.row,
         expressionBuilders[tableName]
       ),
       cell: compileCellConfig(
-        schema,
+        nameMapper,
         tableName,
         tableConfig.cell,
         expressionBuilders[tableName]
@@ -11444,66 +11504,93 @@ function compilePermissions(schema, authz, expressionBuilders) {
   }
   return ret;
 }
-function compileRowConfig(schema, tableName, rowRules, expressionBuilder) {
+function compileRowConfig(clientToServer2, tableName, rowRules, expressionBuilder) {
   if (!rowRules) {
     return void 0;
   }
   return {
-    select: compileRules(schema, tableName, rowRules.select, expressionBuilder),
-    insert: compileRules(schema, tableName, rowRules.insert, expressionBuilder),
+    select: compileRules(
+      clientToServer2,
+      tableName,
+      rowRules.select,
+      expressionBuilder
+    ),
+    insert: compileRules(
+      clientToServer2,
+      tableName,
+      rowRules.insert,
+      expressionBuilder
+    ),
     update: {
       preMutation: compileRules(
-        schema,
+        clientToServer2,
         tableName,
         rowRules.update?.preMutation,
         expressionBuilder
       ),
       postMutation: compileRules(
-        schema,
+        clientToServer2,
         tableName,
         rowRules.update?.postMutation,
         expressionBuilder
       )
     },
-    delete: compileRules(schema, tableName, rowRules.delete, expressionBuilder)
+    delete: compileRules(
+      clientToServer2,
+      tableName,
+      rowRules.delete,
+      expressionBuilder
+    )
   };
 }
-function compileRules(schema, tableName, rules, expressionBuilder) {
+function compileRules(clientToServer2, tableName, rules, expressionBuilder) {
   if (!rules) {
     return void 0;
   }
   return rules.map((rule) => {
     const cond = rule(authDataRef, expressionBuilder);
-    return [
-      "allow",
-      toServerCondition(cond, tableName, schema.tables)
-    ];
+    return ["allow", mapCondition(cond, tableName, clientToServer2)];
   });
 }
-function compileCellConfig(schema, tableName, cellRules, expressionBuilder) {
+function compileCellConfig(clientToServer2, tableName, cellRules, expressionBuilder) {
   if (!cellRules) {
     return void 0;
   }
   const ret = {};
   for (const [columnName, rules] of Object.entries(cellRules)) {
     ret[columnName] = {
-      select: compileRules(schema, tableName, rules.select, expressionBuilder),
-      insert: compileRules(schema, tableName, rules.insert, expressionBuilder),
+      select: compileRules(
+        clientToServer2,
+        tableName,
+        rules.select,
+        expressionBuilder
+      ),
+      insert: compileRules(
+        clientToServer2,
+        tableName,
+        rules.insert,
+        expressionBuilder
+      ),
       update: {
         preMutation: compileRules(
-          schema,
+          clientToServer2,
           tableName,
           rules.update?.preMutation,
           expressionBuilder
         ),
         postMutation: compileRules(
-          schema,
+          clientToServer2,
           tableName,
           rules.update?.postMutation,
           expressionBuilder
         )
       },
-      delete: compileRules(schema, tableName, rules.delete, expressionBuilder)
+      delete: compileRules(
+        clientToServer2,
+        tableName,
+        rules.delete,
+        expressionBuilder
+      )
     };
   }
   return ret;
@@ -11887,6 +11974,29 @@ var pushBodySchema = valita_exports.object({
   requestID: valita_exports.string()
 });
 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)
+          };
+      }
+    })
+  };
+}
 
 // ../zero-client/src/util/nanoid.ts
 function nanoid(size = 21) {
@@ -11916,6 +12026,9 @@ var Disconnected = 0;
 var Connecting = 1;
 var Connected = 2;
 
+// ../zql/src/ivm/memory-storage.ts
+import { compareUTF8 as compareUTF84 } from "compare-utf8";
+
 // ../shared/src/btree-set.ts
 var MAX_NODE_SIZE = 32;
 var BTreeSet = class _BTreeSet {
@@ -12403,885 +12516,965 @@ function indexOf(key, keys, failXor, comparator2) {
 var emptyLeaf = new BNode([]);
 emptyLeaf.isShared = true;
 
-// ../zql/src/ivm/constraint.ts
-function constraintMatchesRow(constraint, row) {
-  for (const key in constraint) {
-    if (!valuesEqual(row[key], constraint[key])) {
-      return false;
+// ../zql/src/ivm/memory-storage.ts
+function comparator(a, b) {
+  return compareUTF84(a[0], b[0]);
+}
+var MemoryStorage = class {
+  #data = new BTreeSet(comparator);
+  set(key, value) {
+    this.#data.add([key, value]);
+  }
+  get(key, def) {
+    const r = this.#data.get([key, null]);
+    if (r !== void 0) {
+      return r[1];
     }
+    return def;
   }
-  return true;
-}
-function constraintMatchesPrimaryKey(constraint, primary) {
-  const constraintKeys = Object.keys(constraint);
-  if (constraintKeys.length !== primary.length) {
-    return false;
+  del(key) {
+    this.#data.delete([key, null]);
   }
-  constraintKeys.sort(stringCompare);
-  for (let i = 0; i < constraintKeys.length; i++) {
-    if (constraintKeys[i][0] !== primary[i]) {
-      return false;
+  *scan(options) {
+    for (const entry of this.#data.valuesFrom(
+      options && [options.prefix, null]
+    )) {
+      if (options && !entry[0].startsWith(options.prefix)) {
+        return;
+      }
+      yield entry;
     }
   }
-  return true;
+  cloneData() {
+    return structuredClone(Object.fromEntries(this.#data.values()));
+  }
+};
+
+// ../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);
+  }
+  const values = primaryKey.map((k) => parse(value[k], primaryKeyValueSchema));
+  const str = JSON.stringify(values);
+  const idSegment = h128(str);
+  return ENTITIES_KEY_PREFIX + tableName + "/" + idSegment;
 }
 
-// ../zql/src/ivm/memory-source.ts
-var MemorySource = class {
-  #tableName;
-  #columns;
-  #primaryKey;
-  #primaryIndexSort;
-  #indexes = /* @__PURE__ */ new Map();
-  #connections = [];
-  #overlay;
-  constructor(tableName, columns, primaryKey) {
-    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: new BTreeSet(comparator2),
-      usedBy: /* @__PURE__ */ new Set()
-    });
-    assertOrderingIncludesPK(this.#primaryIndexSort, this.#primaryKey);
+// ../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;
   }
-  // Mainly for tests.
-  getSchemaInfo() {
-    return {
-      tableName: this.#tableName,
-      columns: this.#columns,
-      primaryKey: this.#primaryKey
-    };
+  getSource(name) {
+    return this.#mainSources.getSource(name);
   }
-  #getSchema(connection) {
-    return {
-      tableName: this.#tableName,
-      columns: this.#columns,
-      primaryKey: this.#primaryKey,
-      sort: connection.sort,
-      system: "client",
-      relationships: {},
-      isHidden: false,
-      compareRows: connection.compareRows
-    };
+  addServerQuery(ast, gotCallback) {
+    return this.#addQuery(ast, gotCallback);
   }
-  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
+  createStorage() {
+    return new MemoryStorage();
+  }
+  onTransactionCommit(cb) {
+    this.#commitListeners.add(cb);
+    return () => {
+      this.#commitListeners.delete(cb);
     };
-    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;
   }
-  #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);
-      }
-    }
+  batchViewUpdates(applyViewUpdates) {
+    let result;
+    let viewChangesPerformed = false;
+    this.#batchViewUpdates(() => {
+      result = applyViewUpdates();
+      viewChangesPerformed = true;
+    });
+    assert(
+      viewChangesPerformed,
+      "batchViewUpdates must call applyViewUpdates synchronously."
+    );
+    return result;
   }
-  #getPrimaryIndex() {
-    const index = this.#indexes.get(JSON.stringify(this.#primaryIndexSort));
-    assert(index, "Primary index not found");
-    return index;
+  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();
+      }
+    });
   }
-  #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);
+  #endTransaction() {
+    for (const listener of this.#commitListeners) {
+      listener();
     }
-    const newIndex = { comparator: comparator2, data, usedBy: /* @__PURE__ */ new Set([usedBy]) };
-    this.#indexes.set(key, newIndex);
-    return newIndex;
-  }
-  // 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"]);
-      }
-    }
-    if (this.#primaryKey.length > 1 || !req.constraint || !constraintMatchesPrimaryKey(req.constraint, this.#primaryKey)) {
-      indexSort.push(...requestedSort);
+};
+
+// ../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");
     }
-    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;
+    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;
     }
-    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;
+  };
+  const assertNotInBatch = (tableName, op) => {
+    if (inBatch) {
+      throw new Error(`Cannot call mutate.${tableName}.${op} inside a batch`);
     }
-    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
+  };
+  const mutate = {};
+  for (const [name, tableSchema] of Object.entries(schema.tables)) {
+    mutate[name] = makeEntityCRUDMutate(
+      name,
+      tableSchema.primaryKey,
+      zeroCRUD,
+      assertNotInBatch
     );
-    yield* conn.filters ? generateWithFilter(withConstraint, conn.filters.predicate) : withConstraint;
   }
-  #cleanup(req, connection) {
-    return this.#fetch(req, connection);
-  }
-  push(change) {
-    for (const _ of this.genPush(change)) {
-    }
-  }
-  *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);
+  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] });
     }
-    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;
-      }
+  };
+}
+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;
     }
-    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);
+  };
+}
+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 "remove": {
-          const removed = data2.delete(change.row);
-          assert(removed);
+        case "upsert":
+          await upsertImpl(tx, op, schema);
           break;
-        }
-        case "edit": {
-          const removed = data2.delete(change.oldRow);
-          assert(removed);
-          data2.add(change.row);
+        case "update":
+          await updateImpl(tx, op, schema);
+          break;
+        case "delete":
+          await deleteImpl(tx, op, schema);
           break;
-        }
-        default:
-          unreachable(change);
       }
     }
-  }
-};
-function* generateWithConstraint(it, constraint) {
-  for (const node of it) {
-    if (constraint && !constraintMatchesRow(constraint, node.row)) {
-      break;
-    }
-    yield node;
-  }
+  };
 }
-function* generateWithFilter(it, filter) {
-  for (const node of it) {
-    if (filter(node.row)) {
-      yield node;
+function defaultOptionalFieldsToNull(schema, value) {
+  let rv = value;
+  for (const name in schema.columns) {
+    if (rv[name] === void 0) {
+      rv = { ...rv, [name]: null };
     }
   }
+  return rv;
 }
-function* generateWithStart(nodes, start, compare) {
-  if (!start) {
-    yield* nodes;
-    return;
+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
+    );
+    await tx.set(key, val);
   }
-  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;
+}
+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;
+  }
+  const update = arg.value;
+  const next = { ...prev };
+  for (const k in update) {
+    if (update[k] !== void 0) {
+      next[k] = update[k];
     }
   }
+  await tx.set(key, next);
 }
-function* generateWithOverlay(startAt, rows, constraint, overlay, compare, filterPredicate) {
-  const overlays = computeOverlays(
-    startAt,
-    constraint,
-    overlay,
-    compare,
-    filterPredicate
+async function deleteImpl(tx, arg, schema) {
+  const key = toPrimaryKeyString(
+    arg.tableName,
+    schema.tables[arg.tableName].primaryKey,
+    arg.value
   );
-  yield* generateWithOverlayInner(rows, overlays, compare);
+  await tx.del(key);
 }
-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);
+
+// ../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
+      )
+    );
   }
-  if (constraint) {
-    overlays = overlaysForConstraint(overlays, constraint);
+  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 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);
   }
-  if (filterPredicate) {
-    overlays = overlaysForFilterPredicate(overlays, filterPredicate);
+  return rv;
+}
+function makeSchemaCRUD(schema, tx) {
+  const mutate = {};
+  for (const [name] of Object.entries(schema.tables)) {
+    mutate[name] = makeTableCRUD(schema, name, tx);
   }
-  return overlays;
+  return mutate;
 }
-function overlaysForStartAt({ add, remove }, startAt, compare) {
-  const undefinedIfBeforeStartAt = (row) => row === void 0 || compare(row, startAt) < 0 ? void 0 : row;
+function makeTableCRUD(schema, tableName, tx) {
+  const table2 = must(schema.tables[tableName]);
+  const { primaryKey } = table2;
   return {
-    add: undefinedIfBeforeStartAt(add),
-    remove: undefinedIfBeforeStartAt(remove)
+    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 overlaysForConstraint({ add, remove }, constraint) {
-  const undefinedIfDoesntMatchConstraint = (row) => row === void 0 || !constraintMatchesRow(constraint, row) ? void 0 : row;
-  return {
-    add: undefinedIfDoesntMatchConstraint(add),
-    remove: undefinedIfDoesntMatchConstraint(remove)
-  };
+
+// ../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);
 }
-function overlaysForFilterPredicate({ add, remove }, filterPredicate) {
-  const undefinedIfDoesntMatchFilter = (row) => row === void 0 || !filterPredicate(row) ? void 0 : row;
-  return {
-    add: undefinedIfDoesntMatchFilter(add),
-    remove: undefinedIfDoesntMatchFilter(remove)
-  };
+
+// ../zero-client/src/client/http-string.ts
+function toWSString(url) {
+  return "ws" + url.slice(4);
 }
-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 appendPath(url, toAppend) {
+  return url + (url.endsWith("/") ? toAppend.substring(1) : toAppend);
+}
+
+// ../zql/src/ivm/constraint.ts
+function constraintMatchesRow(constraint, row) {
+  for (const key in constraint) {
+    if (!valuesEqual(row[key], constraint[key])) {
+      return false;
     }
-    if (!removeOverlaySkipped && overlays.remove) {
-      const cmp2 = compare(overlays.remove, row);
-      if (cmp2 === 0) {
-        removeOverlaySkipped = true;
+  }
+  return true;
+}
+function constraintMatchesPrimaryKey(constraint, primary) {
+  const constraintKeys = Object.keys(constraint);
+  if (constraintKeys.length !== primary.length) {
+    return false;
+  }
+  constraintKeys.sort(stringCompare);
+  for (let i = 0; i < constraintKeys.length; i++) {
+    if (constraintKeys[i][0] !== primary[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// ../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
+    };
+  }
+  fork() {
+    const primaryIndex = this.#getPrimaryIndex();
+    return new _MemorySource(
+      this.#tableName,
+      this.#columns,
+      this.#primaryKey,
+      primaryIndex.data.clone()
+    );
+  }
+  #getSchema(connection) {
+    return {
+      tableName: this.#tableName,
+      columns: this.#columns,
+      primaryKey: this.#primaryKey,
+      sort: connection.sort,
+      system: "client",
+      relationships: {},
+      isHidden: false,
+      compareRows: connection.compareRows
+    };
+  }
+  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;
+  }
+  #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);
+      }
     }
-    yield { row, relationships: {} };
   }
-  if (!addOverlayYielded && overlays.add) {
-    yield { row: overlays.add, relationships: {} };
+  #getPrimaryIndex() {
+    const index = this.#indexes.get(JSON.stringify(this.#primaryIndexSort));
+    assert(index, "Primary index not found");
+    return index;
   }
-}
-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;
-      }
+  #getOrCreateIndex(sort, usedBy) {
+    const key = JSON.stringify(sort);
+    const index = this.#indexes.get(key);
+    if (index) {
+      index.usedBy.add(usedBy);
+      return index;
     }
-    return 0;
-  };
-}
-function compareBounds(a, b) {
-  if (a === b) {
-    return 0;
-  }
-  if (a === minValue) {
-    return -1;
-  }
-  if (b === minValue) {
-    return 1;
-  }
-  if (a === maxValue) {
-    return 1;
-  }
-  if (b === maxValue) {
-    return -1;
-  }
-  return compareValues(a, b);
-}
-function* generateRows(data, scanStart, reverse) {
-  yield* data[reverse ? "valuesFromReversed" : "valuesFrom"](
-    scanStart
-  );
-}
-
-// ../zql/src/ivm/memory-storage.ts
-import { compareUTF8 as compareUTF84 } from "compare-utf8";
-function comparator(a, b) {
-  return compareUTF84(a[0], b[0]);
-}
-var MemoryStorage = class {
-  #data = new BTreeSet(comparator);
-  set(key, value) {
-    this.#data.add([key, value]);
-  }
-  get(key, def) {
-    const r = this.#data.get([key, null]);
-    if (r !== void 0) {
-      return r[1];
+    const comparator2 = makeBoundComparator(sort);
+    const data = new BTreeSet(comparator2);
+    for (const row of this.#getPrimaryIndex().data) {
+      data.add(row);
     }
-    return def;
+    const newIndex = { comparator: comparator2, data, usedBy: /* @__PURE__ */ new Set([usedBy]) };
+    this.#indexes.set(key, newIndex);
+    return newIndex;
   }
-  del(key) {
-    this.#data.delete([key, null]);
+  // For unit testing that we correctly clean up indexes.
+  getIndexKeys() {
+    return [...this.#indexes.keys()];
   }
-  *scan(options) {
-    for (const entry of this.#data.valuesFrom(
-      options && [options.prefix, null]
-    )) {
-      if (options && !entry[0].startsWith(options.prefix)) {
-        return;
+  *#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"]);
       }
-      yield entry;
     }
-  }
-  cloneData() {
-    return structuredClone(Object.fromEntries(this.#data.values()));
-  }
-};
-
-// ../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);
-  }
-  const values = primaryKey.map((k) => parse(value[k], primaryKeyValueSchema));
-  const str = JSON.stringify(values);
-  const idSegment = h128(str);
-  return ENTITIES_KEY_PREFIX + tableName + "/" + idSegment;
-}
-
-// ../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.
-  #sources = /* @__PURE__ */ new Map();
-  #tables;
-  #addQuery;
-  #batchViewUpdates;
-  #commitListeners = /* @__PURE__ */ new Set();
-  staticQueryParameters = void 0;
-  constructor(tables, addQuery, batchViewUpdates) {
-    this.#tables = tables;
-    this.#addQuery = addQuery;
-    this.#batchViewUpdates = batchViewUpdates;
-  }
-  getSource(name) {
-    if (this.#sources.has(name)) {
-      return this.#sources.get(name);
+    if (this.#primaryKey.length > 1 || !req.constraint || !constraintMatchesPrimaryKey(req.constraint, this.#primaryKey)) {
+      indexSort.push(...requestedSort);
     }
-    const schema = this.#tables[name];
-    const source = schema ? new MemorySource(name, schema.columns, schema.primaryKey) : void 0;
-    this.#sources.set(name, source);
-    return source;
-  }
-  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) {
-    try {
-      this.batchViewUpdates(() => {
-        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);
+    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;
           }
         }
-      });
-    } finally {
-      this.#endTransaction();
+      }
+    } else {
+      scanStart = startAt;
+    }
+    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
+    );
+    yield* conn.filters ? generateWithFilter(withConstraint, conn.filters.predicate) : withConstraint;
+  }
+  #cleanup(req, connection) {
+    return this.#fetch(req, connection);
+  }
+  push(change) {
+    for (const _ of this.genPush(change)) {
     }
   }
-  #endTransaction() {
-    for (const listener of this.#commitListeners) {
-      listener();
+  *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);
+      }
     }
   }
 };
-
-// ../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* generateWithConstraint(it, constraint) {
+  for (const node of it) {
+    if (constraint && !constraintMatchesRow(constraint, node.row)) {
+      break;
     }
-    inBatch = true;
-    try {
-      const ops = [];
-      const m = {};
-      for (const name of Object.keys(schema.tables)) {
-        m[name] = makeBatchCRUDMutate(name, schema, ops);
+    yield node;
+  }
+}
+function* generateWithFilter(it, filter) {
+  for (const node of it) {
+    if (filter(node.row)) {
+      yield node;
+    }
+  }
+}
+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;
+        }
       }
-      const rv = await body(m);
-      await zeroCRUD({ ops });
-      return rv;
-    } finally {
-      inBatch = false;
     }
-  };
-  const assertNotInBatch = (tableName, op) => {
-    if (inBatch) {
-      throw new Error(`Cannot call mutate.${tableName}.${op} inside a batch`);
+    if (started) {
+      yield node;
     }
-  };
-  const mutate = {};
-  for (const [name, tableSchema] of Object.entries(schema.tables)) {
-    mutate[name] = makeEntityCRUDMutate(
-      name,
-      tableSchema.primaryKey,
-      zeroCRUD,
-      assertNotInBatch
-    );
   }
-  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] });
-    }
-  };
+function* generateWithOverlay(startAt, rows, constraint, overlay, compare, filterPredicate) {
+  const overlays = computeOverlays(
+    startAt,
+    constraint,
+    overlay,
+    compare,
+    filterPredicate
+  );
+  yield* generateWithOverlayInner(rows, overlays, compare);
 }
-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
+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
       };
-      ops.push(op);
-      return promiseVoid;
-    },
-    update: (value) => {
-      const op = {
-        op: "update",
-        tableName,
-        primaryKey,
-        value
+      break;
+    case "remove":
+      overlays = {
+        add: void 0,
+        remove: overlay.change.row
       };
-      ops.push(op);
-      return promiseVoid;
-    },
-    delete: (id) => {
-      const op = {
-        op: "delete",
-        tableName,
-        primaryKey,
-        value: id
+      break;
+    case "edit":
+      overlays = {
+        add: overlay.change.row,
+        remove: overlay.change.oldRow
       };
-      ops.push(op);
-      return promiseVoid;
-    }
+      break;
+  }
+  if (startAt) {
+    overlays = overlaysForStartAt(overlays, startAt, compare);
+  }
+  if (constraint) {
+    overlays = overlaysForConstraint(overlays, constraint);
+  }
+  if (filterPredicate) {
+    overlays = overlaysForFilterPredicate(overlays, filterPredicate);
+  }
+  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)
   };
 }
-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;
-      }
-    }
+function overlaysForConstraint({ add, remove }, constraint) {
+  const undefinedIfDoesntMatchConstraint = (row) => row === void 0 || !constraintMatchesRow(constraint, row) ? void 0 : row;
+  return {
+    add: undefinedIfDoesntMatchConstraint(add),
+    remove: undefinedIfDoesntMatchConstraint(remove)
   };
 }
-function defaultOptionalFieldsToNull(schema, value) {
-  let rv = value;
-  for (const name in schema.columns) {
-    if (rv[name] === void 0) {
-      rv = { ...rv, [name]: null };
+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 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
-    );
-    await tx.set(key, val);
+  if (!addOverlayYielded && overlays.add) {
+    yield { row: overlays.add, relationships: {} };
   }
 }
-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);
+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 0;
+  };
 }
-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;
+function compareBounds(a, b) {
+  if (a === b) {
+    return 0;
   }
-  const update = arg.value;
-  const next = { ...prev };
-  for (const k in update) {
-    if (update[k] !== void 0) {
-      next[k] = update[k];
-    }
+  if (a === minValue) {
+    return -1;
   }
-  await tx.set(key, next);
+  if (b === minValue) {
+    return 1;
+  }
+  if (a === maxValue) {
+    return 1;
+  }
+  if (b === maxValue) {
+    return -1;
+  }
+  return compareValues(a, b);
 }
-async function deleteImpl(tx, arg, schema) {
-  const key = toPrimaryKeyString(
-    arg.tableName,
-    schema.tables[arg.tableName].primaryKey,
-    arg.value
+function* generateRows(data, scanStart, reverse) {
+  yield* data[reverse ? "valuesFromReversed" : "valuesFrom"](
+    scanStart
   );
-  await tx.del(key);
 }
 
-// ../zero-client/src/client/custom.ts
-var TransactionImpl = class {
-  constructor(repTx, schema) {
-    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);
+// ../zero-client/src/client/ivm-source-repo.ts
+var IVMSourceRepo = class {
+  #main;
+  #tables;
+  sync;
+  constructor(tables) {
+    this.#main = new IVMSourceBranch(tables);
+    this.#tables = tables;
+  }
+  get main() {
+    return this.#main;
+  }
+  /**
+   * Creates a new empty branch.
+   */
+  newBranch() {
+    return new IVMSourceBranch(this.#tables);
   }
-  clientID;
-  mutationID;
-  reason;
-  mutate;
 };
-function makeReplicacheMutator(mutator, schema) {
-  return (repTx, args) => {
-    const tx = new TransactionImpl(repTx, schema);
-    return mutator(tx, args);
-  };
-}
-function makeSchemaCRUD(schema, tx) {
-  const mutate = {};
-  for (const [name] of Object.entries(schema.tables)) {
-    mutate[name] = makeTableCRUD(schema, name, tx);
+var IVMSourceBranch = class _IVMSourceBranch {
+  #sources;
+  #tables;
+  constructor(tables, sources = /* @__PURE__ */ new Map()) {
+    this.#tables = tables;
+    this.#sources = sources;
   }
-  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)
-  };
-}
-
-// ../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;
+  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;
   }
-  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);
-}
+  /**
+   * 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()
+        ])
+      )
+    );
+  }
+};
 
 // ../zero-client/src/client/log-options.ts
 import {
@@ -13508,7 +13701,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.13.2025020303";
+var version2 = "0.13.2025020402";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -13809,7 +14002,7 @@ var Success = 1;
 // ../zero-client/src/client/query-manager.ts
 var QueryManager = class {
   #clientID;
-  #tables;
+  #clientToServer;
   #send;
   #queries = /* @__PURE__ */ new Map();
   #recentQueriesMaxSize;
@@ -13817,7 +14010,7 @@ var QueryManager = class {
   #gotQueries = /* @__PURE__ */ new Set();
   constructor(clientID, tables, send2, experimentalWatch, recentQueriesMaxSize) {
     this.#clientID = clientID;
-    this.#tables = tables;
+    this.#clientToServer = clientToServer(tables);
     this.#recentQueriesMaxSize = recentQueriesMaxSize;
     this.#send = send2;
     experimentalWatch(
@@ -13901,7 +14094,7 @@ var QueryManager = class {
     let entry = this.#queries.get(astHash);
     this.#recentQueries.delete(astHash);
     if (!entry) {
-      const serverAST = toServerAST(normalized, this.#tables);
+      const serverAST = mapAST(normalized, this.#clientToServer);
       entry = {
         normalized: serverAST,
         count: 1,
@@ -14138,26 +14331,6 @@ function getServer(server) {
 
 // ../zero-client/src/client/zero-poke-handler.ts
 import { Lock as Lock4 } from "@rocicorp/lock";
-function makeClientNames(schema) {
-  return new Map(
-    Object.entries(schema.tables).map(
-      ([tableName, { serverName: serverTableName, columns }]) => {
-        let allSame = true;
-        const names = {};
-        for (const [name, { serverName }] of Object.entries(columns)) {
-          if (serverName && serverName !== name) {
-            allSame = false;
-          }
-          names[serverName ?? name] = name;
-        }
-        return [
-          serverTableName ?? tableName,
-          { tableName, columns: allSame ? null : names }
-        ];
-      }
-    )
-  );
-}
 var PokeHandler = class {
   #replicachePoke;
   #onPokeError;
@@ -14171,14 +14344,14 @@ var PokeHandler = class {
   // order poke errors.
   #pokeLock = new Lock4();
   #schema;
-  #clientNames;
+  #serverToClient;
   #raf = getBrowserGlobalMethod("requestAnimationFrame") ?? rafFallback;
   constructor(replicachePoke, onPokeError, clientID, schema, lc) {
     this.#replicachePoke = replicachePoke;
     this.#onPokeError = onPokeError;
     this.#clientID = clientID;
     this.#schema = schema;
-    this.#clientNames = makeClientNames(schema);
+    this.#serverToClient = serverToClient(schema.tables);
     this.#lc = lc.withContext("PokeHandler");
   }
   handlePokeStart(pokeStart) {
@@ -14259,7 +14432,7 @@ var PokeHandler = class {
         const merged = mergePokes(
           this.#pokeBuffer,
           this.#schema,
-          this.#clientNames
+          this.#serverToClient
         );
         this.#pokeBuffer.length = 0;
         if (merged === void 0) {
@@ -14289,7 +14462,7 @@ var PokeHandler = class {
     this.#pokeBuffer.length = 0;
   }
 };
-function mergePokes(pokeBuffer, schema, clientNames) {
+function mergePokes(pokeBuffer, schema, serverToClient2) {
   if (pokeBuffer.length === 0) {
     return void 0;
   }
@@ -14329,7 +14502,7 @@ function mergePokes(pokeBuffer, schema, clientNames) {
               (op) => queryPatchOpToReplicachePatchOp(
                 op,
                 (hash2) => toDesiredQueriesKey(clientID, hash2),
-                schema
+                serverToClient2
               )
             )
           );
@@ -14338,14 +14511,18 @@ function mergePokes(pokeBuffer, schema, clientNames) {
       if (pokePart.gotQueriesPatch) {
         mergedPatch.push(
           ...pokePart.gotQueriesPatch.map(
-            (op) => queryPatchOpToReplicachePatchOp(op, toGotQueriesKey, schema)
+            (op) => queryPatchOpToReplicachePatchOp(
+              op,
+              toGotQueriesKey,
+              serverToClient2
+            )
           )
         );
       }
       if (pokePart.rowsPatch) {
         mergedPatch.push(
           ...pokePart.rowsPatch.map(
-            (p) => rowsPatchOpToReplicachePatchOp(p, schema, clientNames)
+            (p) => rowsPatchOpToReplicachePatchOp(p, schema, serverToClient2)
           )
         );
       }
@@ -14378,7 +14555,7 @@ function clientsPatchOpToReplicachePatchOp(op) {
       };
   }
 }
-function queryPatchOpToReplicachePatchOp(op, toKey, schema) {
+function queryPatchOpToReplicachePatchOp(op, toKey, serverToClient2) {
   switch (op.op) {
     case "clear":
       return op;
@@ -14392,19 +14569,15 @@ function queryPatchOpToReplicachePatchOp(op, toKey, schema) {
       return {
         op: "put",
         key: toKey(op.hash),
-        value: toClientAST(op.ast, schema.tables)
+        value: mapAST(op.ast, serverToClient2)
       };
   }
 }
-function rowsPatchOpToReplicachePatchOp(op, schema, clientNames) {
+function rowsPatchOpToReplicachePatchOp(op, schema, serverToClient2) {
   if (op.op === "clear") {
     return op;
   }
-  const names = clientNames.get(op.tableName);
-  if (!names) {
-    throw new Error(`unknown table name in ${JSON.stringify(op)}`);
-  }
-  const { tableName, columns } = names;
+  const tableName = serverToClient2.tableName(op.tableName, op);
   switch (op.op) {
     case "del":
       return {
@@ -14412,7 +14585,7 @@ function rowsPatchOpToReplicachePatchOp(op, schema, clientNames) {
         key: toPrimaryKeyString(
           tableName,
           schema.tables[tableName].primaryKey,
-          toClientRow(op.id, columns)
+          serverToClient2.row(op.tableName, op.id)
         )
       };
     case "put":
@@ -14421,9 +14594,9 @@ function rowsPatchOpToReplicachePatchOp(op, schema, clientNames) {
         key: toPrimaryKeyString(
           tableName,
           schema.tables[tableName].primaryKey,
-          toClientRow(op.value, columns)
+          serverToClient2.row(op.tableName, op.value)
         ),
-        value: toClientRow(op.value, columns)
+        value: serverToClient2.row(op.tableName, op.value)
       };
     case "update":
       return {
@@ -14431,28 +14604,15 @@ function rowsPatchOpToReplicachePatchOp(op, schema, clientNames) {
         key: toPrimaryKeyString(
           tableName,
           schema.tables[tableName].primaryKey,
-          toClientRow(op.id, columns)
+          serverToClient2.row(op.tableName, op.id)
         ),
-        merge: op.merge ? toClientRow(op.merge, columns) : void 0,
-        constrain: toClientColumns(op.constrain, columns)
+        merge: op.merge ? serverToClient2.row(op.tableName, op.merge) : void 0,
+        constrain: serverToClient2.columns(op.tableName, op.constrain)
       };
     default:
       throw new Error("to be implemented");
   }
 }
-function toClientRow(row, names) {
-  if (names === null) {
-    return row;
-  }
-  const clientRow = {};
-  for (const col in row) {
-    clientRow[names[col] ?? col] = row[col];
-  }
-  return clientRow;
-}
-function toClientColumns(columns, names) {
-  return !names || !columns ? columns : columns.map((col) => names[col] ?? col);
-}
 function rafFallback(callback) {
   setTimeout(callback, 0);
 }
@@ -14511,6 +14671,8 @@ var Zero = class {
   #enableAnalytics;
   #pokeHandler;
   #queryManager;
+  #ivmSources;
+  #clientToServer;
   /**
    * The queries we sent when inside the sec-protocol header when establishing a connection.
    * More queries could be registered while we're waiting for the 'connected' message
@@ -14625,13 +14787,14 @@ var Zero = class {
     const replicacheMutators = {
       [CRUD_MUTATION_NAME]: makeCRUDMutator(schema)
     };
+    this.#ivmSources = new IVMSourceRepo(schema.tables);
     for (const [namespace, mutatorsForNamespace] of Object.entries(
       options.mutators ?? {}
     )) {
       for (const [name, mutator] of Object.entries(
         mutatorsForNamespace
       )) {
-        replicacheMutators[customMutatorKey(namespace, name)] = makeReplicacheMutator(mutator, schema);
+        replicacheMutators[customMutatorKey(namespace, name)] = makeReplicacheMutator(mutator, schema, this.#ivmSources);
       }
     }
     this.storageKey = storageKey ?? "";
@@ -14713,8 +14876,9 @@ var Zero = class {
       rep.experimentalWatch.bind(rep),
       maxRecentQueries
     );
+    this.#clientToServer = clientToServer(schema.tables);
     this.#zeroContext = new ZeroContext(
-      schema.tables,
+      this.#ivmSources.main,
       (ast, gotCallback) => this.#queryManager.add(ast, gotCallback),
       batchViewUpdates
     );
@@ -15250,7 +15414,7 @@ var Zero = class {
         id: m.id,
         clientID: m.clientID,
         name: m.name,
-        args: [m.args]
+        args: [mapCRUD(m.args, this.#clientToServer)]
       } : {
         type: Custom,
         timestamp,
@@ -15649,4 +15813,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-L6HKVJYT.js.map
+//# sourceMappingURL=chunk-ADFMUREC.js.map