@rocicorp/zero 0.13.2025020200 → 0.13.2025020300

package/out/{chunk-5S3K5CU2.js → chunk-2WSNDAJE.js}

@@ -5543,50 +5543,6 @@ function makeClientID() {
 }
 
 // ../replicache/src/persist/clients.ts
-var clientV4Schema = readonlyObject({
-  /**
-   * A UNIX timestamp in milliseconds updated by the client once a minute
-   * while it is active and every time the client persists its state to
-   * the perdag.
-   * Should only be updated by the client represented by this structure.
-   */
-  heartbeatTimestampMs: valita_exports.number(),
-  /**
-   * The hash of the commit in the perdag this client last persisted.
-   * Should only be updated by the client represented by this structure.
-   */
-  headHash: hashSchema,
-  /**
-   * The mutationID of the commit at headHash (mutationID if it is a
-   * local commit, lastMutationID if it is an index change or snapshot commit).
-   * Should only be updated by the client represented by this structure.
-   * Read by other clients to determine if there are unacknowledged pending
-   * mutations for them to push on behalf of the client represented by this
-   * structure.
-   * This is redundant with information in the commit graph at headHash,
-   * but allows other clients to determine if there are unacknowledged pending
-   * mutations without having to load the commit graph at headHash.
-   */
-  mutationID: valita_exports.number(),
-  /**
-   * The highest lastMutationID received from the server for this client.
-   *
-   * Should be updated by the client represented by this structure whenever
-   * it persists its state to the perdag.
-   * Read by other clients to determine if there are unacknowledged pending
-   * mutations for them to push on behalf of the client represented by this
-   * structure, and *updated* by other clients upon successfully pushing
-   * pending mutations to avoid redundant pushes of those mutations.
-   *
-   * Note: This will be the same as the lastMutationID of the base snapshot of
-   * the commit graph at headHash when written by the client represented by this
-   * structure.  However, when written by another client pushing pending
-   * mutations on this client's behalf it will be different.  This is because
-   * the other client does not update the commit graph (it is unsafe to update
-   * another client's commit graph).
-   */
-  lastServerAckdMutationID: valita_exports.number()
-});
 var clientV5Schema = readonlyObject({
   heartbeatTimestampMs: valita_exports.number(),
   headHash: hashSchema,
@@ -5630,15 +5586,8 @@ var clientV6Schema = readonlyObject({
 function isClientV6(client) {
   return client.refreshHashes !== void 0;
 }
-function isClientV5(client) {
-  return client.clientGroupID !== void 0;
-}
 var CLIENTS_HEAD_NAME = "clients";
-var clientSchema = valita_exports.union(
-  clientV4Schema,
-  clientV5Schema,
-  clientV6Schema
-);
+var clientSchema = valita_exports.union(clientV5Schema, clientV6Schema);
 function assertClient(value) {
   assert2(value, clientSchema);
 }
@@ -5668,7 +5617,7 @@ function clientMapToChunkData(clients, dagWrite) {
       }
     } else {
       dagWrite.assertValidHash(client.headHash);
-      if (isClientV5(client) && client.tempRefreshHash) {
+      if (client.tempRefreshHash) {
         dagWrite.assertValidHash(client.tempRefreshHash);
       }
     }
@@ -5882,7 +5831,7 @@ function getRefsForClients(clients) {
       }
     } else {
       refs.add(client.headHash);
-      if (isClientV5(client) && client.tempRefreshHash) {
+      if (client.tempRefreshHash) {
         refs.add(client.tempRefreshHash);
       }
     }
@@ -5898,10 +5847,7 @@ async function getClientGroupForClient(clientID, read) {
 }
 async function getClientGroupIDForClient(clientID, read) {
   const client = await getClient(clientID, read);
-  if (!client || !isClientV5(client)) {
-    return void 0;
-  }
-  return client.clientGroupID;
+  return client?.clientGroupID;
 }
 async function setClient(clientID, client, dagWrite) {
   const clients = await getClients(dagWrite);
@@ -8383,11 +8329,17 @@ function enumeration() {
     customType: null
   });
 }
-var TableBuilder = class {
+var TableBuilder = class _TableBuilder {
   #schema;
   constructor(schema) {
     this.#schema = schema;
   }
+  from(serverName) {
+    return new _TableBuilder({
+      ...this.#schema,
+      serverName
+    });
+  }
   columns(columns) {
     const columnSchemas = Object.fromEntries(
       Object.entries(columns).map(([k, v2]) => [k, v2.schema])
@@ -8416,6 +8368,16 @@ var TableBuilderWithColumns = class _TableBuilderWithColumns {
     if (this.#schema.primaryKey.length === 0) {
       throw new Error(`Table "${this.#schema.name}" is missing a primary key`);
     }
+    const names = /* @__PURE__ */ new Set();
+    for (const [col, { serverName }] of Object.entries(this.#schema.columns)) {
+      const name = serverName ?? col;
+      if (names.has(name)) {
+        throw new Error(
+          `Table "${this.#schema.name}" has multiple columns referencing "${name}"`
+        );
+      }
+      names.add(name);
+    }
     return this.#schema;
   }
 };
@@ -8424,6 +8386,12 @@ var ColumnBuilder = class _ColumnBuilder {
   constructor(schema) {
     this.#schema = schema;
   }
+  from(serverName) {
+    return new _ColumnBuilder({
+      ...this.#schema,
+      serverName
+    });
+  }
   optional() {
     return new _ColumnBuilder({
       ...this.#schema,
@@ -8439,7 +8407,13 @@ var ColumnBuilder = class _ColumnBuilder {
 function createSchema(version3, options) {
   const retTables = {};
   const retRelationships = {};
+  const serverNames = /* @__PURE__ */ new Set();
   options.tables.forEach((table2) => {
+    const { serverName = table2.schema.name } = table2.schema;
+    if (serverNames.has(serverName)) {
+      throw new Error(`Multiple tables reference the name "${serverName}"`);
+    }
+    serverNames.add(serverName);
     if (retTables[table2.schema.name]) {
       throw new Error(
         `Table "${table2.schema.name}" is defined more than once in the schema`
@@ -8604,6 +8578,10 @@ var disjunctionSchema = readonlyObject({
   type: valita_exports.literal("or"),
   conditions: readonlyArray(conditionSchema)
 });
+function mustCompoundKey(field) {
+  assert(Array.isArray(field) && field.length >= 1);
+  return field;
+}
 var compoundKeySchema = readonly(
   valita_exports.tuple([valita_exports.string()]).concat(valita_exports.array(valita_exports.string()))
 );
@@ -8632,42 +8610,162 @@ var astSchema = readonlyObject({
     exclusive: valita_exports.boolean()
   }).optional()
 });
-var normalizeCache = /* @__PURE__ */ new WeakMap();
-function normalizeAST(ast) {
-  const cached = normalizeCache.get(ast);
-  if (cached) {
-    return cached;
-  }
-  const where = flattened(ast.where);
-  const normalized = {
+function transformAST(ast, transform) {
+  const { tableName, columnName } = transform;
+  const colName = (c) => columnName(ast.table, c);
+  const key = (table2, k) => {
+    const serverKey = k.map((col) => columnName(table2, col));
+    return mustCompoundKey(serverKey);
+  };
+  const where = ast.where ? transform.where(ast.where) : void 0;
+  const transformed = {
     schema: ast.schema,
-    table: ast.table,
+    table: tableName(ast.table),
     alias: ast.alias,
-    where: where ? sortedWhere(where) : void 0,
-    related: ast.related ? sortedRelated(
+    where: where ? transformWhere(where, ast.table, transform) : void 0,
+    related: ast.related ? transform.related(
       ast.related.map(
         (r) => ({
-          correlation: r.correlation,
+          correlation: {
+            parentField: key(ast.table, r.correlation.parentField),
+            childField: key(r.subquery.table, r.correlation.childField)
+          },
           hidden: r.hidden,
-          subquery: normalizeAST(r.subquery),
+          subquery: transformAST(r.subquery, transform),
           system: r.system
         })
       )
     ) : void 0,
-    start: ast.start,
+    start: ast.start ? {
+      ...ast.start,
+      row: Object.fromEntries(
+        Object.entries(ast.start.row).map(([col, val]) => [
+          colName(col),
+          val
+        ])
+      )
+    } : void 0,
     limit: ast.limit,
-    orderBy: ast.orderBy
+    orderBy: ast.orderBy?.map(([col, dir]) => [colName(col), dir])
+  };
+  return transformed;
+}
+function transformWhere(where, table2, transform) {
+  const { columnName } = transform;
+  const condValue = (c) => c.type !== "column" ? c : { ...c, name: columnName(table2, c.name) };
+  const key = (table3, k) => {
+    const serverKey = k.map((col) => columnName(table3, col));
+    return mustCompoundKey(serverKey);
+  };
+  if (where.type === "simple") {
+    return { ...where, left: condValue(where.left) };
+  } else if (where.type === "correlatedSubquery") {
+    const { correlation, subquery } = where.related;
+    return {
+      ...where,
+      related: {
+        ...where.related,
+        correlation: {
+          parentField: key(table2, correlation.parentField),
+          childField: key(subquery.table, correlation.childField)
+        },
+        subquery: transformAST(subquery, transform)
+      }
+    };
+  }
+  return {
+    type: where.type,
+    conditions: transform.conditions(
+      where.conditions.map((c) => transformWhere(c, table2, transform))
+    )
   };
-  normalizeCache.set(ast, normalized);
+}
+var normalizeCache = /* @__PURE__ */ new WeakMap();
+var NORMALIZE_TRANSFORM = {
+  tableName: (t2) => t2,
+  columnName: (_, c) => c,
+  related: sortedRelated,
+  where: flattened,
+  conditions: (c) => c.sort(cmpCondition)
+};
+function normalizeAST(ast) {
+  let normalized = normalizeCache.get(ast);
+  if (!normalized) {
+    normalized = transformAST(ast, NORMALIZE_TRANSFORM);
+    normalizeCache.set(ast, normalized);
+  }
   return normalized;
 }
-function sortedWhere(where) {
-  if (where.type === "simple" || where.type === "correlatedSubquery") {
-    return where;
+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;
+    },
+    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 {
-    type: where.type,
-    conditions: where.conditions.map((w) => sortedWhere(w)).sort(cmpCondition)
+    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;
+    },
+    related: (r) => r,
+    where: (w) => w,
+    conditions: (c) => c
   };
 }
 function sortedRelated(related) {
@@ -8725,9 +8823,6 @@ function cmpRelated(a, b) {
   return compareUTF83(must(a.subquery.alias), must(b.subquery.alias));
 }
 function flattened(cond) {
-  if (cond === void 0) {
-    return void 0;
-  }
   if (cond.type === "simple" || cond.type === "correlatedSubquery") {
     return cond;
   }
@@ -11323,69 +11418,92 @@ async function definePermissions(schema, definer) {
     expressionBuilders[name] = new AuthQuery(schema, name).expressionBuilder();
   }
   const config = await definer();
-  return compilePermissions(config, expressionBuilders);
+  return compilePermissions(schema, config, expressionBuilders);
 }
-function compilePermissions(authz, expressionBuilders) {
+function compilePermissions(schema, authz, expressionBuilders) {
   if (!authz) {
     return void 0;
   }
   const ret = {};
   for (const [tableName, tableConfig] of Object.entries(authz)) {
-    ret[tableName] = {
-      row: compileRowConfig(tableConfig.row, expressionBuilders[tableName]),
-      cell: compileCellConfig(tableConfig.cell, expressionBuilders[tableName])
+    const serverName = schema.tables[tableName].serverName ?? tableName;
+    ret[serverName] = {
+      row: compileRowConfig(
+        schema,
+        tableName,
+        tableConfig.row,
+        expressionBuilders[tableName]
+      ),
+      cell: compileCellConfig(
+        schema,
+        tableName,
+        tableConfig.cell,
+        expressionBuilders[tableName]
+      )
     };
   }
   return ret;
 }
-function compileRowConfig(rowRules, expressionBuilder) {
+function compileRowConfig(schema, tableName, rowRules, expressionBuilder) {
   if (!rowRules) {
     return void 0;
   }
   return {
-    select: compileRules(rowRules.select, expressionBuilder),
-    insert: compileRules(rowRules.insert, expressionBuilder),
+    select: compileRules(schema, tableName, rowRules.select, expressionBuilder),
+    insert: compileRules(schema, tableName, rowRules.insert, expressionBuilder),
     update: {
       preMutation: compileRules(
+        schema,
+        tableName,
         rowRules.update?.preMutation,
         expressionBuilder
       ),
       postMutation: compileRules(
+        schema,
+        tableName,
         rowRules.update?.postMutation,
         expressionBuilder
       )
     },
-    delete: compileRules(rowRules.delete, expressionBuilder)
+    delete: compileRules(schema, tableName, rowRules.delete, expressionBuilder)
   };
 }
-function compileRules(rules, expressionBuilder) {
+function compileRules(schema, tableName, rules, expressionBuilder) {
   if (!rules) {
     return void 0;
   }
-  return rules.map(
-    (rule) => [
+  return rules.map((rule) => {
+    const cond = rule(authDataRef, expressionBuilder);
+    return [
       "allow",
-      rule(authDataRef, expressionBuilder)
-    ]
-  );
+      toServerCondition(cond, tableName, schema.tables)
+    ];
+  });
 }
-function compileCellConfig(cellRules, expressionBuilder) {
+function compileCellConfig(schema, tableName, cellRules, expressionBuilder) {
   if (!cellRules) {
     return void 0;
   }
   const ret = {};
   for (const [columnName, rules] of Object.entries(cellRules)) {
     ret[columnName] = {
-      select: compileRules(rules.select, expressionBuilder),
-      insert: compileRules(rules.insert, expressionBuilder),
+      select: compileRules(schema, tableName, rules.select, expressionBuilder),
+      insert: compileRules(schema, tableName, rules.insert, expressionBuilder),
       update: {
-        preMutation: compileRules(rules.update?.preMutation, expressionBuilder),
+        preMutation: compileRules(
+          schema,
+          tableName,
+          rules.update?.preMutation,
+          expressionBuilder
+        ),
         postMutation: compileRules(
+          schema,
+          tableName,
           rules.update?.postMutation,
           expressionBuilder
         )
       },
-      delete: compileRules(rules.delete, expressionBuilder)
+      delete: compileRules(schema, tableName, rules.delete, expressionBuilder)
     };
   }
   return ret;
@@ -13104,6 +13222,44 @@ async function deleteImpl(tx, arg, schema) {
   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);
+  }
+  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);
+  }
+  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:]*\]$/;
@@ -13352,7 +13508,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.13.2025020200";
+var version2 = "0.13.2025020300";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -13653,13 +13809,15 @@ var Success = 1;
 // ../zero-client/src/client/query-manager.ts
 var QueryManager = class {
   #clientID;
+  #tables;
   #send;
   #queries = /* @__PURE__ */ new Map();
   #recentQueriesMaxSize;
   #recentQueries = /* @__PURE__ */ new Set();
   #gotQueries = /* @__PURE__ */ new Set();
-  constructor(clientID, send2, experimentalWatch, recentQueriesMaxSize) {
+  constructor(clientID, tables, send2, experimentalWatch, recentQueriesMaxSize) {
     this.#clientID = clientID;
+    this.#tables = tables;
     this.#recentQueriesMaxSize = recentQueriesMaxSize;
     this.#send = send2;
     experimentalWatch(
@@ -13743,17 +13901,16 @@ var QueryManager = class {
     let entry = this.#queries.get(astHash);
     this.#recentQueries.delete(astHash);
     if (!entry) {
+      const serverAST = toServerAST(normalized, this.#tables);
       entry = {
-        normalized,
+        normalized: serverAST,
         count: 1,
         gotCallbacks: gotCallback === void 0 ? [] : [gotCallback]
       };
       this.#queries.set(astHash, entry);
       this.#send([
         "changeDesiredQueries",
-        {
-          desiredQueriesPatch: [{ op: "put", hash: astHash, ast: normalized }]
-        }
+        { desiredQueriesPatch: [{ op: "put", hash: astHash, ast: serverAST }] }
       ]);
     } else {
       ++entry.count;
@@ -13981,6 +14138,26 @@ 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;
@@ -13994,12 +14171,14 @@ var PokeHandler = class {
   // order poke errors.
   #pokeLock = new Lock4();
   #schema;
+  #clientNames;
   #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.#lc = lc.withContext("PokeHandler");
   }
   handlePokeStart(pokeStart) {
@@ -14077,7 +14256,11 @@ var PokeHandler = class {
       lc.debug?.("got poke lock at", now);
       lc.debug?.("merging", this.#pokeBuffer.length);
       try {
-        const merged = mergePokes(this.#pokeBuffer, this.#schema);
+        const merged = mergePokes(
+          this.#pokeBuffer,
+          this.#schema,
+          this.#clientNames
+        );
         this.#pokeBuffer.length = 0;
         if (merged === void 0) {
           lc.debug?.("frame is empty");
@@ -14106,7 +14289,7 @@ var PokeHandler = class {
     this.#pokeBuffer.length = 0;
   }
 };
-function mergePokes(pokeBuffer, schema) {
+function mergePokes(pokeBuffer, schema, clientNames) {
   if (pokeBuffer.length === 0) {
     return void 0;
   }
@@ -14145,7 +14328,8 @@ function mergePokes(pokeBuffer, schema) {
             ...queriesPatch.map(
               (op) => queryPatchOpToReplicachePatchOp(
                 op,
-                (hash2) => toDesiredQueriesKey(clientID, hash2)
+                (hash2) => toDesiredQueriesKey(clientID, hash2),
+                schema
               )
             )
           );
@@ -14154,14 +14338,14 @@ function mergePokes(pokeBuffer, schema) {
       if (pokePart.gotQueriesPatch) {
         mergedPatch.push(
           ...pokePart.gotQueriesPatch.map(
-            (op) => queryPatchOpToReplicachePatchOp(op, toGotQueriesKey)
+            (op) => queryPatchOpToReplicachePatchOp(op, toGotQueriesKey, schema)
           )
         );
       }
       if (pokePart.rowsPatch) {
         mergedPatch.push(
           ...pokePart.rowsPatch.map(
-            (p) => rowsPatchOpToReplicachePatchOp(p, schema)
+            (p) => rowsPatchOpToReplicachePatchOp(p, schema, clientNames)
           )
         );
       }
@@ -14194,7 +14378,7 @@ function clientsPatchOpToReplicachePatchOp(op) {
       };
   }
 }
-function queryPatchOpToReplicachePatchOp(op, toKey) {
+function queryPatchOpToReplicachePatchOp(op, toKey, schema) {
   switch (op.op) {
     case "clear":
       return op;
@@ -14208,88 +14392,69 @@ function queryPatchOpToReplicachePatchOp(op, toKey) {
       return {
         op: "put",
         key: toKey(op.hash),
-        value: op.ast
+        value: toClientAST(op.ast, schema.tables)
       };
   }
 }
-function rowsPatchOpToReplicachePatchOp(op, schema) {
+function rowsPatchOpToReplicachePatchOp(op, schema, clientNames) {
+  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;
   switch (op.op) {
-    case "clear":
-      return op;
     case "del":
       return {
         op: "del",
         key: toPrimaryKeyString(
-          op.tableName,
-          schema.tables[op.tableName].primaryKey,
-          op.id
+          tableName,
+          schema.tables[tableName].primaryKey,
+          toClientRow(op.id, columns)
         )
       };
     case "put":
       return {
         op: "put",
         key: toPrimaryKeyString(
-          op.tableName,
-          schema.tables[op.tableName].primaryKey,
-          op.value
+          tableName,
+          schema.tables[tableName].primaryKey,
+          toClientRow(op.value, columns)
         ),
-        value: op.value
+        value: toClientRow(op.value, columns)
       };
     case "update":
       return {
         op: "update",
         key: toPrimaryKeyString(
-          op.tableName,
-          schema.tables[op.tableName].primaryKey,
-          op.id
+          tableName,
+          schema.tables[tableName].primaryKey,
+          toClientRow(op.id, columns)
         ),
-        merge: op.merge,
-        constrain: op.constrain
+        merge: op.merge ? toClientRow(op.merge, columns) : void 0,
+        constrain: toClientColumns(op.constrain, columns)
       };
     default:
       throw new Error("to be implemented");
   }
 }
-function rafFallback(callback) {
-  setTimeout(callback, 0);
-}
-
-// ../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);
+function toClientRow(row, names) {
+  if (names === null) {
+    return row;
   }
-  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);
+  const clientRow = {};
+  for (const col in row) {
+    clientRow[names[col] ?? col] = row[col];
   }
-  return mutate;
+  return clientRow;
 }
-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 toClientColumns(columns, names) {
+  return !names || !columns ? columns : columns.map((col) => names[col] ?? col);
+}
+function rafFallback(callback) {
+  setTimeout(callback, 0);
 }
 
 // ../zero-client/src/client/zero.ts
@@ -14543,6 +14708,7 @@ var Zero = class {
     this.mutateBatch = mutateBatch;
     this.#queryManager = new QueryManager(
       rep.clientID,
+      schema.tables,
       (msg) => this.#sendChangeDesiredQueries(msg),
       rep.experimentalWatch.bind(rep),
       maxRecentQueries
@@ -15483,4 +15649,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-5S3K5CU2.js.map
+//# sourceMappingURL=chunk-2WSNDAJE.js.map