okmodel 0.6.0 → 0.7.0

package/dist/shared/{2cg3wnxc.js → 1w508jbr.js}

@@ -1,19 +1,14 @@
+import {
+  stack2
+} from "./mss6ctgv.js";
 import {
   effectivePredicate
-} from "./b3awxn7h.js";
+} from "./n816peh1.js";
 import {
   assertOperatorFits,
   textArray,
   arrayElementType
-} from "./n7mcc1gk.js";
-import {
-  stack
-} from "./672t5vym.js";
-import {
-  touchFields,
-  fieldSealed,
-  sealingTrait
-} from "./7m88x3e9.js";
+} from "./zchaghkf.js";
 import {
   runWrite
 } from "./n4jqhpqz.js";
@@ -36,8 +31,8 @@ import {
   quote,
   isRecord,
   registerFailFix,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   safetyInstalled,
   runSafety
@@ -52,10 +47,54 @@ import {
   throwNamed2
 } from "./52szzakm.js";
 
+// src/runtime/trait-read.ts
+function touchFields(model) {
+  const traits = model.traits;
+  if (traits === undefined)
+    return;
+  const names = [];
+  for (const trait of traits) {
+    const touch = trait.touch;
+    if (touch === undefined)
+      continue;
+    for (const field of touch)
+      names.push(field);
+  }
+  return names.length === 0 ? undefined : names;
+}
+function fieldSealed(model, field) {
+  const traits = model.traits;
+  if (traits === undefined)
+    return false;
+  for (const trait of traits) {
+    const sealed = trait.sealed;
+    if (sealed === undefined)
+      continue;
+    for (const name of sealed)
+      if (name === field)
+        return true;
+  }
+  return false;
+}
+function sealingTrait(model, field) {
+  const traits = model.traits;
+  if (traits === undefined)
+    return;
+  for (const trait of traits) {
+    const sealed = trait.sealed;
+    if (sealed === undefined)
+      continue;
+    for (const name of sealed)
+      if (name === field)
+        return trait.name;
+  }
+  return;
+}
+
 // src/runtime/write.ts
 registerFailFix("OKM1102", "Pass where, or call .all(reason) to match every row.");
 registerFailFix("OKM1190", "Remove the guarded field. Input cannot set it.");
-var WRITE_PARAM_BUDGET = 2048;
+var WRITE_PARAM_BUDGET2 = 2048;
 var REDACTED = "[redacted]";
 function encodeColumn(column, value) {
   if (!column.hidden && !column.sensitive)
@@ -102,17 +141,21 @@ var INSERT_OPTIONS = [
   "validate"
 ];
 var FILTER_OPTIONS = ["allow", "expect", "returning", "signal", "timeout", "validate"];
-var UPDATE_KEYS = ["set", "where"];
-var UPDATE_ROW_KEYS = ["id", "set", "where"];
+var UPDATE_KEYS = ["set", "where", "limit", "lock", "version"];
+var UPDATE_ROW_KEYS = ["id", "set", "where", "version"];
 var NO_ALLOW = new Set;
-async function executeWrite(host, op, table, input, options, mods, scope, plan) {
+async function executeWrite2(host, op, table, input, options, mods, scope, plan) {
   const prepared = await prepareWrite(host, op, table, input, options, mods, scope);
   if (plan !== undefined)
     return prepared;
   if (prepared.statements.length === 0)
     return prepared.finish([]);
   const results = await runWrite(host, prepared.statements, prepared.options);
-  return prepared.finish(results);
+  const more = prepared.follow?.(results);
+  if (more === undefined || more.length === 0)
+    return prepared.finish(results);
+  const extra = await runWrite(host, more, prepared.options);
+  return prepared.finish(results.concat(extra));
 }
 async function prepareWrite(host, op, table, input, options, mods, scope) {
   try {
@@ -121,13 +164,16 @@ async function prepareWrite(host, op, table, input, options, mods, scope) {
       statements: planned.statements,
       options: callOptions(options),
       ...planned.parentGuard === true ? { checked: "parent" } : planned.expect !== undefined ? { checked: "expect" } : {},
-      finish: (results) => finish(results, planned, table)
+      ...planned.recover === undefined ? {} : {
+        follow: (results) => planned.recover?.(decodePlanned(withoutQuiet(results, planned.quiet), planned.outputs)) ?? []
+      },
+      finish: (results) => finish(withoutQuiet(results, planned.quiet), planned, table)
     };
   } catch (error) {
     throw scrubWrite(host.schema, table, input, error);
   }
 }
-async function explainWrite(schema, op, table, input, options, mods, generators, scope) {
+async function explainWrite2(schema, op, table, input, options, mods, generators, scope) {
   try {
     const planned = await planWrite(schema, generators, op, table, input, options, mods, scope);
     return { statements: planned.statements };
@@ -139,10 +185,10 @@ async function planWrite(schema, generators, op, tableName, input, options, mods
   await requireValidationImport(schema, op, tableName, options);
   const table = indexes(schema).get(tableName);
   if (table === undefined) {
-    fail("OKM1120", `Table ${tableName} is not in the schema.`);
+    fail2("OKM1120", `Table ${tableName} is not in the schema.`);
   }
   if (mods.uses !== undefined && op !== "insert") {
-    const { resolve } = await import("./r6nwkxnt.js");
+    const { resolve } = await import("./m7n9h2a5.js");
     mods = { ...mods, presets: resolve(schema, tableName, mods.uses).wheres };
   }
   const record = isRecord(options) ? options : {};
@@ -151,6 +197,14 @@ async function planWrite(schema, generators, op, tableName, input, options, mods
     return planInsert(table, input, record, mods, generators, scope, schema.tenancy);
   }
   if (op === "update") {
+    if (traitNamed(table, "versioned")) {
+      const { planVersioned } = await import("./y6njgyda.js");
+      return withRowFilters(scope, mods.archive, () => {
+        noteArchive(table, mods.archive);
+        const planned = planVersioned(schema, table, input, record, mods);
+        return { ...planned, keys: undefined, keyColumns: undefined };
+      });
+    }
     return withRowFilters(scope, mods.archive, () => {
       noteArchive(table, mods.archive);
       return planUpdate(schema, table, input, record, mods, scope);
@@ -162,8 +216,8 @@ async function planWrite(schema, generators, op, tableName, input, options, mods
   });
 }
 async function planInsert(table, input, options, mods, generators, scope, tenancy) {
-  const allow = allowSet(table, options.allow);
-  noteGuarded(table, allow, "insert");
+  const allow = allowSet2(table, options.allow);
+  noteGuarded2(table, allow, "insert");
   const many = Array.isArray(input);
   const rows = (many ? input : [input]).map((row) => insertRow(table, row, allow, tenancy));
   tenancy?.stamp(table.model.name, rows, scope);
@@ -172,13 +226,14 @@ async function planInsert(table, input, options, mods, generators, scope, tenanc
   const returning = selectedColumns(table, options.returning);
   const outputs = outputsOf(returning);
   const clause = returningClause(returning, undefined);
-  const expect = expectOf(options, mods);
+  const expect = expectOf2(options, mods);
   const shape = many ? "rows" : "row";
   const path = tenancy?.isPath?.(table.model.name) === true;
   if (path && options.onConflict !== undefined && options.onConflict !== "error") {
-    fail("OKM1120", `onConflict on ${table.model.name} is not available. The insert checks the parent.`);
+    fail2("OKM1120", `onConflict on ${table.model.name} is not available. The insert checks the parent.`);
   }
-  if (columns.length === 0) {
+  const sorting = traitNamed(table, "sortable");
+  if (columns.length === 0 && !sorting) {
     const text = `insert into ${quote(table.model.sql)} default values${clause}`;
     return {
       statements: rows.map(() => ({ text })),
@@ -186,51 +241,74 @@ async function planInsert(table, input, options, mods, generators, scope, tenanc
       shape,
       expect,
       keys: undefined,
-      keyFields: undefined
+      keyColumns: undefined
     };
   }
-  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./vmfkhszw.js");
+  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./bg3rym3g.js");
   const conflict = conflictMod?.readConflict(table, options.onConflict, allow, tenantKeyList(tenancy));
+  if (conflict?.kind === "update" && traitNamed(table, "versioned")) {
+    fail2("OKM1120", `onConflict update on ${table.model.name} does not check the version you read.`, "Read the row and update. ignore and return do not change the existing row.");
+  }
+  const sortMod = sorting ? await import("./9y3mmmh1.js") : undefined;
   const chunks = chunkRows(rows.map((row) => cellsFor(columns, row)));
   const statements = [];
+  const quiet = [];
   const keys = [];
   let offset = 0;
   for (const chunk of chunks) {
     const slice = rows.slice(offset, offset + chunk.length);
     offset += chunk.length;
-    const built = path ? pathInsert(table, columns, chunk, scope, tenancy) : insertHead(table, columns, chunk);
+    const head = path || sortMod === undefined ? undefined : sortMod.insertAtEnd(table, columns, slice, traitGroup(table), tenantKeyList(tenancy));
+    const built = head ?? (path ? pathInsert(table, columns, chunk, scope, tenancy) : insertHead(table, columns, chunk));
+    if (head !== undefined) {
+      quiet.push(statements.length);
+      statements.push(head.lock);
+    }
     if (conflict === undefined || conflictMod === undefined) {
       statements.push(withParams(`${built.text}${clause}`, built.params));
       continue;
     }
-    const keyRows = conflict.kind === "return" ? slice.map((row) => keyWire(conflict.columns, row)) : [];
-    for (const row of keyRows)
-      keys.push([...row]);
-    statements.push(conflictMod.finishInsert(built.text, clause, built.params ?? [], conflict, table, returning, keyRows));
+    if (conflict.kind === "return") {
+      for (const row of slice)
+        keys.push(keyWire(conflict.columns, row));
+    }
+    statements.push(conflictMod.finishInsert(built.text, clause, built.params ?? [], conflict, table));
   }
+  const conflictColumns = conflict?.kind === "return" ? conflict.columns : undefined;
   return {
     statements,
     outputs,
     shape,
     expect,
-    keys: conflict?.kind === "return" ? keys : undefined,
-    keyFields: conflict?.kind === "return" ? conflict.columns.map((column) => column.field) : undefined,
-    ...path ? { parent: rows.length } : {}
+    keys: conflictColumns === undefined ? undefined : keys,
+    keyColumns: conflictColumns,
+    ...path ? { parent: rows.length } : {},
+    ...quiet.length > 0 ? { quiet } : {},
+    ...conflictColumns === undefined || conflictMod === undefined ? {} : {
+      recover: (found) => lookupStatements(conflictMod, table, conflictColumns, returning, missingKeys(found, conflictColumns, keys))
+    }
   };
 }
 function planUpdate(schema, table, input, options, mods, scope) {
-  const allow = allowSet(table, options.allow);
-  noteGuarded(table, allow, "update");
-  const returning = returningOption(table, options.returning);
+  if (mentionsVersion(input)) {
+    fail2("OKM1120", `version on ${table.model.name} needs versioned().`, "Add versioned() from okmodel/traits, or remove version.");
+  }
+  const allow = allowSet2(table, options.allow);
+  noteGuarded2(table, allow, "update");
+  const returning = returningOption2(table, options.returning);
   const outputs = outputsOf(returning);
-  const expect = expectOf(options, mods);
+  const expect = expectOf2(options, mods);
   if (Array.isArray(input)) {
     const rows = input.map((item) => {
       const row = updateItem(table, item, allow, schema.tenancy);
-      requireFilter(table, row.where, mods, "update");
+      requireFilter2(table, row.where, mods, "update");
       pathAssignment(schema.tenancy, table.model.name, row.set, scope);
-      return { ...row, where: stack(row.where, mods.presets) };
+      return { ...row, where: stack2(row.where, mods.presets) };
     });
+    rejectDuplicateTargets2(table, rows);
+    rejectMixedSets2(rows);
+    for (const row of rows)
+      refuseTreeCycle(table, row.where, row.set, schema.tenancy?.key);
     const moves = rows.some((row) => pathField(schema.tenancy, table.model.name, row.set) !== undefined);
     if (moves) {
       return {
@@ -239,7 +317,7 @@ function planUpdate(schema, table, input, options, mods, scope) {
         shape: returning === undefined ? "count" : "rows",
         expect,
         keys: undefined,
-        keyFields: undefined,
+        keyColumns: undefined,
         parentGuard: true
       };
     }
@@ -249,33 +327,49 @@ function planUpdate(schema, table, input, options, mods, scope) {
       shape: returning === undefined ? "count" : "rows",
       expect,
       keys: undefined,
-      keyFields: undefined
+      keyColumns: undefined
     };
   }
   if (!isRecord(input))
-    fail("OKM1121", "update expects { where, set } or a list of rows.");
-  rejectUpdateKeys(input, false);
-  const set = writeSet(table, input.set, allow, schema.tenancy);
-  requireFilter(table, input.where, mods, "update");
+    fail2("OKM1121", "update expects { where, set } or a list of rows.");
+  const claim = readClaim2(input);
+  rejectUpdateKeys2(input, false);
+  const set = writeSet2(table, input.set, allow, schema.tenancy);
+  requireFilter2(table, input.where, mods, "update");
   if (Object.keys(set).length === 0)
-    fail("OKM1120", "update set is empty.");
-  const where = stack(input.where, mods.presets);
-  if (pathAssignment(schema.tenancy, table.model.name, set, scope) !== undefined) {
+    fail2("OKM1120", "update set is empty.");
+  refuseTreeCycle(table, input.where, set, schema.tenancy?.key);
+  const where = stack2(input.where, mods.presets);
+  const moved = pathAssignment(schema.tenancy, table.model.name, set, scope);
+  if (moved !== undefined && claim !== undefined) {
+    fail2("OKM1120", `lock: "skip" on ${table.model.name} cannot change ${moved} in the same claim.`, "Claim the row first. Point it at a parent in a later update.");
+  }
+  if (moved !== undefined) {
     return {
       statements: [pathSetUpdate(schema, table, where, set, scope, returning)],
       outputs: parentOutputs(returning),
       shape: returning === undefined ? "count" : "rows",
       expect,
       keys: undefined,
-      keyFields: undefined,
+      keyColumns: undefined,
       parentGuard: true
     };
   }
-  const sql = new Sql;
+  if (claim !== undefined) {
+    return {
+      statements: [emitClaim(schema, table, where, set, claim, returning)],
+      outputs,
+      shape: returning === undefined ? "count" : "rows",
+      expect,
+      keys: undefined,
+      keyColumns: undefined
+    };
+  }
+  const sql = new Sql2;
   sql.text("update ");
   sql.text(quote(table.model.sql));
   sql.text(" as t set ");
-  emitSet(sql, table, set, "t");
+  emitSet2(sql, table, set, "t");
   emitFilter(schema, table, where, sql, "t");
   schema.tenancy?.noteParent?.(table.model.name, set, sql.sink(), scope, (field) => table.columns.get(field)?.sql);
   sql.text(returningClause(returning, "t"));
@@ -285,31 +379,36 @@ function planUpdate(schema, table, input, options, mods, scope) {
     shape: returning === undefined ? "count" : "rows",
     expect,
     keys: undefined,
-    keyFields: undefined
+    keyColumns: undefined
   };
 }
 function planDelete(schema, table, input, options, mods) {
   if (!isRecord(input))
-    fail("OKM1121", "delete expects { where }.");
+    fail2("OKM1121", "delete expects { where }.");
   rejectKeys(input, ["where"], "delete");
-  requireFilter(table, input.where, mods, "delete");
-  const returning = returningOption(table, options.returning);
-  const sql = new Sql;
+  requireFilter2(table, input.where, mods, "delete");
+  if (options.returning === true) {
+    fail2("OKM1120", "delete does not accept returning: true.", "Pass the field names in returning, or omit returning for a count.");
+  }
+  const returning = returningOption2(table, options.returning);
+  const sql = new Sql2;
   sql.text("delete from ");
   sql.text(quote(table.model.sql));
   sql.text(" as t");
-  emitFilter(schema, table, stack(input.where, mods.presets), sql, "t");
+  emitFilter(schema, table, stack2(input.where, mods.presets), sql, "t");
   sql.text(returningClause(returning, "t"));
   return {
     statements: [sql.statement()],
     outputs: outputsOf(returning),
     shape: returning === undefined ? "count" : "rows",
-    expect: expectOf(options, mods),
+    expect: expectOf2(options, mods),
     keys: undefined,
-    keyFields: undefined
+    keyColumns: undefined
   };
 }
 function finish(results, planned, table) {
+  if (planned.versioned !== undefined)
+    return finishVersioned(results, planned, table);
   if (planned.parentGuard === true)
     return finishParent(results, planned, table);
   if (planned.shape === "count") {
@@ -319,12 +418,8 @@ function finish(results, planned, table) {
     checkExpect(count, planned.expect, table, "write");
     return { count };
   }
-  const decoded = [];
-  for (const result of results) {
-    for (const row of result.rows)
-      decoded.push(decodeRow(planned.outputs, row));
-  }
-  const rows = planned.keys === undefined || planned.keyFields === undefined ? decoded : orderByKeys(decoded, planned.keyFields, planned.keys);
+  const decoded = decodePlanned(results, planned.outputs);
+  const rows = planned.keys === undefined || planned.keyColumns === undefined ? decoded : orderByKeys(decoded, planned.keyColumns, planned.keys);
   checkExpect(rows.length, planned.expect, table, "insert");
   if (planned.parent !== undefined && rows.length < planned.parent) {
     throw new OkmError2("OKM1705", `Insert on ${table} did not find a parent in this tenant.`, {
@@ -360,6 +455,36 @@ function finishParent(results, planned, table) {
     return decoded[0] ?? null;
   return decoded;
 }
+function finishVersioned(results, planned, table) {
+  const versioned = planned.versioned;
+  const first = results[0]?.rows[0];
+  if (versioned !== undefined && first !== undefined && countCell(first[0]) > 0) {
+    const fields = versioned.fields.length === 0 ? "the row" : versioned.fields.join(", ");
+    const sent = versioned.sent.join(", ");
+    throw new OkmError2("conflict", `update on ${table} tried to write ${fields} at version ${sent}, and the row changed. Reread the row and retry with the version you read.`, {
+      kind: "conflict",
+      columns: ["version"],
+      fix: { summary: "Reread the row and retry with the version you read." }
+    });
+  }
+  if (planned.shape === "count") {
+    const updated = first === undefined ? 0 : countCell(first[1]);
+    checkExpect(updated, planned.expect, table, "write");
+    return { count: updated };
+  }
+  const decoded = [];
+  for (const result of results) {
+    for (const item of result.rows) {
+      if (countCell(item[1]) === 0)
+        continue;
+      decoded.push(decodeRow(planned.outputs, item));
+    }
+  }
+  checkExpect(decoded.length, planned.expect, table, "write");
+  if (planned.shape === "row")
+    return decoded[0] ?? null;
+  return decoded;
+}
 function countCell(value) {
   if (typeof value === "number")
     return value;
@@ -401,23 +526,30 @@ function parentOutputs(returning) {
     includes: outputs.includes
   };
 }
+function rowId(alias) {
+  return `${alias}.tableoid, ${alias}.ctid`;
+}
 function pathSetUpdate(schema, table, where, set, scope, returning) {
-  const sql = new Sql;
-  sql.text("with matched as (select t.ctid as tid from ");
+  const sql = new Sql2;
+  sql.text("with matched as (select ");
+  sql.text(rowId("t"));
+  sql.text(" from ");
   sql.text(quote(table.model.sql));
   sql.text(" as t");
   emitFilter(schema, table, where, sql, "t");
   sql.text("), updated as (update ");
   sql.text(quote(table.model.sql));
   sql.text(" as t set ");
-  emitSet(sql, table, set, "t");
-  sql.text(" where t.ctid in (select tid from matched)");
+  emitSet2(sql, table, set, "t");
+  sql.text(" where (");
+  sql.text(rowId("t"));
+  sql.text(") in (select tableoid, ctid from matched)");
   schema.tenancy?.noteParent?.(table.model.name, set, sql.sink(), scope, (field) => table.columns.get(field)?.sql);
   endParent(sql, returning);
   return sql.statement();
 }
 function pathListUpdate(schema, table, rows, scope, returning) {
-  const sql = new Sql;
+  const sql = new Sql2;
   sql.text("with matched as (");
   for (let index = 0;index < rows.length; index += 1) {
     const row = rows[index];
@@ -453,7 +585,7 @@ function pathListUpdate(schema, table, rows, scope, returning) {
   if (!rejected)
     sql.text("select 0 as ord where false");
   sql.text("), updated as (");
-  updateSliceBody(schema, table, rows, sql, true);
+  updateSliceBody2(schema, table, rows, sql, true);
   sql.text(" and not exists (select 1 from rejected)");
   endParent(sql, returning);
   return sql.statement();
@@ -483,7 +615,7 @@ function endParent(sql, returning) {
   sql.text(returningClause(returning, "t"));
   sql.text(") select c.matched, c.updated, u.* from (select (select count(*)::int from matched) as matched, (select count(*)::int from updated) as updated) c left join updated u on true");
 }
-function updateSliceBody(schema, table, rows, sql, wrapWhere = false) {
+function updateSliceBody2(schema, table, rows, sql, wrapWhere = false, hooks) {
   const fields = [];
   const seen = new Set;
   for (const row of rows) {
@@ -497,7 +629,7 @@ function updateSliceBody(schema, table, rows, sql, wrapWhere = false) {
     }
   }
   if (fields.length === 0)
-    fail("OKM1120", "update set is empty.");
+    fail2("OKM1120", "update set is empty.");
   sql.text("update ");
   sql.text(quote(table.model.sql));
   sql.text(" as t set ");
@@ -509,9 +641,13 @@ function updateSliceBody(schema, table, rows, sql, wrapWhere = false) {
       sql.text(", ");
     sql.text(quote(column.sql));
     sql.text(" = case");
-    for (const row of rows) {
+    for (let index = 0;index < rows.length; index += 1) {
+      const row = rows[index];
+      if (row === undefined)
+        continue;
       sql.text(" when ");
       emitBare(schema, table, row.where, sql, "t");
+      hooks?.afterWhere?.(sql, index);
       sql.text(" then ");
       const value = row.set[column.field];
       if (value === undefined)
@@ -524,6 +660,7 @@ function updateSliceBody(schema, table, rows, sql, wrapWhere = false) {
     sql.text(" end");
   }
   emitTouch(sql, table, fields.length > 0);
+  hooks?.afterSet?.(sql);
   sql.text(wrapWhere ? " where (" : " where ");
   for (let index = 0;index < rows.length; index += 1) {
     const row = rows[index];
@@ -533,15 +670,132 @@ function updateSliceBody(schema, table, rows, sql, wrapWhere = false) {
       sql.text(" or ");
     sql.text("(");
     emitBare(schema, table, row.where, sql, "t");
+    hooks?.afterWhere?.(sql, index);
     sql.text(")");
   }
   if (wrapWhere)
     sql.text(")");
 }
-function orderByKeys(rows, fields, keys) {
+function decodePlanned(results, outputs) {
+  const decoded = [];
+  for (const result of results) {
+    for (const row of result.rows)
+      decoded.push(decodeRow(outputs, row));
+  }
+  return decoded;
+}
+function withoutQuiet(results, quiet) {
+  if (quiet === undefined || quiet.length === 0)
+    return results;
+  const hidden = new Set(quiet);
+  const kept = [];
+  for (let index = 0;index < results.length; index += 1) {
+    if (hidden.has(index))
+      continue;
+    const result = results[index];
+    if (result !== undefined)
+      kept.push(result);
+  }
+  return kept;
+}
+function lookupStatements(mod, table, columns, returning, keyRows) {
+  if (keyRows.length === 0 || returning.length === 0)
+    return [];
+  const width = Math.max(1, columns.length);
+  const size = Math.max(1, Math.floor(WRITE_PARAM_BUDGET2 / width));
+  const statements = [];
+  for (let index = 0;index < keyRows.length; index += size) {
+    statements.push(mod.lookupExisting(table, columns, returning, keyRows.slice(index, index + size)));
+  }
+  return statements;
+}
+function missingKeys(rows, columns, keys) {
+  const have = new Set(rows.map((row) => rowKey(columns, row)));
+  const missing = [];
+  const seen = new Set;
+  for (const key of keys) {
+    const id = key.map((value) => value ?? "").join("\x00");
+    if (have.has(id) || seen.has(id))
+      continue;
+    seen.add(id);
+    missing.push(key);
+  }
+  return missing;
+}
+function rejectDuplicateTargets2(table, rows) {
+  if (rows.length < 2)
+    return;
+  const seen = new Set;
+  for (const row of rows) {
+    const key = canonical(row.where);
+    if (seen.has(key)) {
+      fail2("OKM1120", `update on ${table.model.name} lists the same target twice.`, "List each row once.");
+    }
+    seen.add(key);
+  }
+}
+var unresolved = 0;
+function canonical(value) {
+  if (isOperator(value))
+    return `op:${operatorName(value)}:${canonical(operatorValue(value))}`;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (value === null)
+    return "null";
+  if (value === undefined)
+    return "undefined";
+  if (typeof value === "bigint")
+    return JSON.stringify(value.toString());
+  if (Array.isArray(value))
+    return `[${value.map((item) => canonical(item)).join(",")}]`;
+  if (isRecord(value)) {
+    if (plainRecord(value)) {
+      const keys = Object.keys(value).sort();
+      return `{${keys.map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+    }
+    return boxed(value);
+  }
+  return fresh();
+}
+function plainRecord(value) {
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function boxed(value) {
+  if (value instanceof Uint8Array)
+    return `bytes:${hexBytes(value)}`;
+  if (value instanceof Date) {
+    const time = value.getTime();
+    if (Number.isNaN(time))
+      return fresh();
+    return `date:${value.toISOString()}`;
+  }
+  const read = value.toString;
+  if (read === Object.prototype.toString)
+    return fresh();
+  const text = read.call(value);
+  if (text.length > 0 && text !== "[object Object]")
+    return `text:${text}`;
+  return fresh();
+}
+function hexBytes(value) {
+  let hex = "";
+  for (const byte of value)
+    hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function fresh() {
+  unresolved += 1;
+  return `~${String(unresolved)}`;
+}
+function orderByKeys(rows, columns, keys) {
   const found = new Map;
-  for (const row of rows)
-    found.set(fields.map((field) => wireKey(row[field])).join("\x00"), row);
+  for (const row of rows) {
+    const id = rowKey(columns, row);
+    if (!found.has(id))
+      found.set(id, row);
+  }
   const ordered = [];
   for (const key of keys) {
     const row = found.get(key.map((value) => value ?? "").join("\x00"));
@@ -550,13 +804,30 @@ function orderByKeys(rows, fields, keys) {
   }
   return ordered;
 }
+function rowKey(columns, row) {
+  let id = "";
+  for (let index = 0;index < columns.length; index += 1) {
+    const column = columns[index];
+    if (column === undefined)
+      continue;
+    if (index > 0)
+      id += "\x00";
+    id += valueKey(column, row[column.field]);
+  }
+  return id;
+}
+function valueKey(column, value) {
+  if (value === undefined || value === null)
+    return "";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return wireKey(value);
+  }
+  return column.encode(value);
+}
 function wireKey(value) {
   if (typeof value === "string")
     return value;
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  return "";
+  return String(value);
 }
 function insertHead(table, columns, rows) {
   const params = [];
@@ -583,7 +854,7 @@ function updateList(schema, table, rows, returning) {
   if (rows.length === 0)
     return [];
   const width = Math.max(1, Object.keys(rows[0]?.set ?? {}).length + 2);
-  const size = Math.max(1, Math.floor(WRITE_PARAM_BUDGET / (width * 2)));
+  const size = Math.max(1, Math.floor(WRITE_PARAM_BUDGET2 / (width * 2)));
   const statements = [];
   for (let index = 0;index < rows.length; index += size) {
     statements.push(updateSlice(schema, table, rows.slice(index, index + size), returning));
@@ -591,12 +862,32 @@ function updateList(schema, table, rows, returning) {
   return statements;
 }
 function updateSlice(schema, table, rows, returning) {
-  const sql = new Sql;
-  updateSliceBody(schema, table, rows, sql);
+  const sql = new Sql2;
+  updateSliceBody2(schema, table, rows, sql);
   sql.text(returningClause(returning, "t"));
   return sql.statement();
 }
-function emitSet(sql, table, set, alias) {
+function emitClaim(schema, table, where, set, limit, returning) {
+  const sql = new Sql2;
+  sql.text("update ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t set ");
+  emitSet2(sql, table, set, "t");
+  sql.text(" where (");
+  sql.text(rowId("t"));
+  sql.text(") in (select ");
+  sql.text(rowId("s"));
+  sql.text(" from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as s");
+  emitFilter(schema, table, where, sql, "s");
+  sql.text(" for update of s skip locked limit ");
+  sql.param(String(limit), "integer");
+  sql.text(")");
+  sql.text(returningClause(returning, "t"));
+  return sql.statement();
+}
+function emitSet2(sql, table, set, alias) {
   const keys = Object.keys(set);
   let wrote = false;
   for (const key of keys) {
@@ -632,12 +923,7 @@ function emitValue(sql, column, value, alias) {
   if (isOperator(value)) {
     const name = operatorName(value);
     if (name === "inc") {
-      const amount = operatorValue(value);
-      if (typeof amount === "object" && amount !== null) {
-        fail("OKM1121", `inc on ${column.field} needs a value.`);
-      }
-      sql.text(`${alias}.${quote(column.sql)} + `);
-      sql.param(encodeColumn(column, amount), column.dataType);
+      emitIncrement(sql, column, value, alias);
       return;
     }
     if (name === "json.set") {
@@ -648,7 +934,7 @@ function emitValue(sql, column, value, alias) {
       emitArrayWrite(sql, column, name, value, alias);
       return;
     }
-    fail("OKM1121", `Field ${column.field} received an operator. set accepts a value, inc, set, or arr.`);
+    fail2("OKM1121", `Field ${column.field} received an operator. set accepts a value, inc, json.set, arr.append, or arr.remove.`);
   }
   if (value === null) {
     sql.text(`null::${column.dataType}`);
@@ -658,17 +944,31 @@ function emitValue(sql, column, value, alias) {
     takeObject(column, value);
   sql.param(encodeColumn(column, value), column.dataType);
 }
+var NUMBER_TYPE = /^(?:smallint|integer|bigint|real|double precision|numeric|decimal)(?:\(\d+(?:,\d+)?\))?$/;
+function emitIncrement(sql, column, value, alias) {
+  if (!NUMBER_TYPE.test(column.dataType)) {
+    fail2("OKM1124", `inc adds to a number. ${column.field} is a ${column.dataType} column.`, "Use inc on an integer, bigint, numeric, or float column.");
+  }
+  if (!isOperator(value))
+    fail2("OKM1121", `inc on ${column.field} needs a number.`);
+  const amount = operatorValue(value);
+  if (typeof amount !== "number" && typeof amount !== "bigint" && typeof amount !== "string") {
+    fail2("OKM1121", `inc on ${column.field} needs a number.`, "Pass the amount to add. null stores null; it is not an amount.");
+  }
+  sql.text(`${alias}.${quote(column.sql)} + `);
+  sql.param(encodeColumn(column, amount), column.dataType);
+}
 function emitJsonSet(sql, column, value, alias) {
   assertOperatorFits(column, "json.set");
   if (!isOperator(value))
-    fail("OKM1121", `json.set on ${column.field} needs a path and a value.`);
+    fail2("OKM1121", `json.set on ${column.field} needs a path and a value.`);
   const stored = operatorValue(value);
   if (!isRecord(stored) || !Array.isArray(stored.path)) {
-    fail("OKM1121", `json.set on ${column.field} needs a path and a value.`);
+    fail2("OKM1121", `json.set on ${column.field} needs a path and a value.`);
   }
   const path = stored.path;
   if (path.length === 0 || path.some((item) => typeof item !== "string")) {
-    fail("OKM1121", `json.set on ${column.field} needs a list of segments.`);
+    fail2("OKM1121", `json.set on ${column.field} needs a list of segments.`);
   }
   const encoded = encodeJson(stored.value);
   const ref = `${alias}.${quote(column.sql)}`;
@@ -685,10 +985,10 @@ function emitArrayWrite(sql, column, name, value, alias) {
   assertOperatorFits(column, name);
   const encode = column.elementEncode;
   if (encode === undefined) {
-    fail("OKM1124", `Operator ${name} does not apply to ${column.dataType} column ${column.field}. Accepted operators: eq, not, lt, lte, gt, gte, between, inList, notIn, inc.`);
+    fail2("OKM1124", `Operator ${name} does not apply to ${column.dataType} column ${column.field}. Accepted operators: eq, not, lt, lte, gt, gte, between, inList, notIn, inc.`);
   }
   if (!isOperator(value)) {
-    fail("OKM1121", `${name} on ${column.field} needs an element.`);
+    fail2("OKM1121", `${name} on ${column.field} needs an element.`);
   }
   const fn = name === "arr.append" ? "array_append" : "array_remove";
   sql.text(`${fn}(${alias}.${quote(column.sql)}, `);
@@ -716,11 +1016,42 @@ function emitBare(schema, table, where, sql, alias) {
   };
   emitWhere(schema, table, where, sink, alias, 0);
   if (!dropped) {
-    fail("OKM1102", `update on ${table.model.name} needs a where for each row.`);
+    fail2("OKM1102", `update on ${table.model.name} needs a where for each row.`);
+  }
+}
+function traitNamed(table, name) {
+  const traits = table.model.traits;
+  if (traits === undefined)
+    return false;
+  for (const trait of traits)
+    if (trait.name === name)
+      return true;
+  return false;
+}
+function traitGroup(table) {
+  const traits = table.model.traits;
+  if (traits === undefined)
+    return;
+  for (const trait of traits) {
+    if (trait.name !== "sortable")
+      continue;
+    const group = trait.group;
+    return typeof group === "string" ? group : undefined;
   }
+  return;
+}
+function mentionsVersion(input) {
+  if (Array.isArray(input)) {
+    for (const item of input) {
+      if (isRecord(item) && Object.hasOwn(item, "version"))
+        return true;
+    }
+    return false;
+  }
+  return isRecord(input) && Object.hasOwn(input, "version");
 }
 
-class Sql {
+class Sql2 {
   parts = [];
   params = [];
   text(value) {
@@ -748,7 +1079,7 @@ class Sql {
 }
 function insertRow(table, value, allow, tenancy) {
   if (!isRecord(value))
-    fail("OKM1121", "insert expects an object or a list of objects.");
+    fail2("OKM1121", "insert expects an object or a list of objects.");
   const row = {};
   for (const key of Object.keys(value)) {
     const column = table.columns.get(key);
@@ -760,6 +1091,7 @@ function insertRow(table, value, allow, tenancy) {
     if (value[key] !== undefined)
       row[key] = value[key];
   }
+  refuseHalfMorph(table, row);
   return row;
 }
 function cellsFor(columns, row) {
@@ -824,7 +1156,7 @@ function tenantKeyList(tenancy) {
   return [tenancy.key];
 }
 function pathInsert(table, columns, rows, scope, tenancy) {
-  const sql = new Sql;
+  const sql = new Sql2;
   const names = columns.map((column) => quote(column.sql)).join(", ");
   const selected = columns.map((column) => `v.${quote(column.sql)}`).join(", ");
   sql.text(`insert into ${quote(table.model.sql)} (${names}) select ${selected} from (values `);
@@ -859,9 +1191,13 @@ function pathInsert(table, columns, rows, scope, tenancy) {
   });
   return sql.statement();
 }
-function writeSet(table, value, allow, tenancy) {
+function writeSet2(table, value, allow, tenancy) {
   if (!isRecord(value))
-    fail("OKM1121", "set must be an object of fields.");
+    fail2("OKM1121", "set must be an object of fields.");
+  const group = traitGroup(table);
+  if (group !== undefined && Object.hasOwn(value, group) && value[group] !== undefined) {
+    fail2("OKM1120", `update on ${table.model.name} cannot change ${group}. It groups position.`, "Move stays in one group.");
+  }
   const set = {};
   for (const key of Object.keys(value)) {
     if (value[key] === undefined)
@@ -874,20 +1210,116 @@ function writeSet(table, value, allow, tenancy) {
       refuse(table, column);
     set[key] = value[key];
   }
+  refuseHalfMorph(table, set);
   return set;
 }
+function refuseTreeCycle(table, where, set, scopeKey) {
+  const own = keyedId(table, where, scopeKey);
+  if (own === undefined)
+    return;
+  for (const relation of table.model.relations) {
+    if (relation.kind !== "many" || relation.through !== undefined || relation.morph !== undefined) {
+      continue;
+    }
+    if (relation.table !== table.model.name)
+      continue;
+    for (const sql of relation.remote) {
+      const column = columnBySql(table, sql);
+      if (column === undefined)
+        continue;
+      const value = set[column.field];
+      if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint") {
+        continue;
+      }
+      if ((typeof value === "string" ? value : value.toString()) !== own)
+        continue;
+      fail2("OKM1120", `update on ${table.model.name}.${column.field} cannot point a tree row at itself.`, "Set the parent to another row. A filter that is not the primary key is not checked.");
+    }
+  }
+}
+function keyedId(table, where, scopeKey) {
+  if (!isRecord(where))
+    return;
+  const primary = table.model.primary;
+  const required = primary.filter((field) => field !== scopeKey);
+  const field = required.length === 1 ? required[0] : undefined;
+  if (field === undefined || !Object.hasOwn(where, field))
+    return;
+  for (const key of Object.keys(where)) {
+    if (!primary.includes(key))
+      return;
+  }
+  const value = where[field];
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint") {
+    return;
+  }
+  return String(value);
+}
+function columnBySql(table, sql) {
+  for (const column of table.model.columns) {
+    if (column.sql === sql)
+      return column;
+  }
+  return;
+}
 function updateItem(table, value, allow, tenancy) {
   if (!isRecord(value))
-    fail("OKM1121", "update expects { where, set } or a list of rows.");
-  rejectUpdateKeys(value, true);
-  const set = writeSet(table, value.set, allow, tenancy);
+    fail2("OKM1121", "update expects { where, set } or a list of rows.");
+  rejectUpdateKeys2(value, true);
+  const set = writeSet2(table, value.set, allow, tenancy);
+  if (Object.keys(set).length === 0)
+    fail2("OKM1120", "update set is empty.");
   if (value.where !== undefined)
     return { where: value.where, set };
   if (value.id !== undefined)
     return { where: { id: value.id }, set };
-  fail("OKM1102", `update on ${table.model.name} needs id or where for each row.`);
+  fail2("OKM1102", `update on ${table.model.name} needs id or where for each row.`);
 }
-function rejectUpdateKeys(input, row) {
+function rejectMixedSets2(rows) {
+  const kind = new Map;
+  for (const row of rows) {
+    for (const key of Object.keys(row.set)) {
+      const value = row.set[key];
+      if (value === undefined)
+        continue;
+      const next = isOperator(value) ? operatorName(value) : "value";
+      const previous = kind.get(key);
+      if (previous === undefined) {
+        kind.set(key, next);
+        continue;
+      }
+      if (previous === next)
+        continue;
+      const left = previous === "value" ? "a value" : previous;
+      const right = next === "value" ? "a value" : next;
+      fail2("OKM1120", `${key} is both ${left} and ${right} in this update.`, `Use one value or one operator for ${key} in every row.`);
+    }
+  }
+}
+function readClaim2(input) {
+  if (Object.hasOwn(input, "wait")) {
+    fail2("OKM1120", 'wait belongs on a read. An update claims rows with lock: "skip".', 'Use lock: "skip" and limit. A read uses wait: "nowait" or "skip" inside tx().');
+  }
+  const lock = input.lock;
+  const limit = input.limit;
+  if (lock === undefined && limit === undefined)
+    return;
+  if (lock === undefined) {
+    fail2("OKM1120", 'limit on an update needs lock: "skip".', 'Pass lock: "skip" to claim up to limit rows, or remove limit.');
+  }
+  if (lock !== "skip") {
+    const shown = typeof lock === "string" ? lock : JSON.stringify(lock) ?? "undefined";
+    fail2("OKM1120", `lock on an update must be "skip". ${shown} is not a claim.`, 'Pass lock: "skip". A read uses lock: "update" or "share", and wait: "nowait" or "skip", inside tx().');
+  }
+  if (limit === undefined) {
+    fail2("OKM1120", 'lock: "skip" needs a limit.', "Pass limit so the claim takes a fixed number of rows.");
+  }
+  if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > 2147483647) {
+    fail2("OKM1121", "limit must be a whole number from 1 to 2147483647.");
+  }
+  return limit;
+}
+function rejectUpdateKeys2(input, row) {
   const accepted = row ? UPDATE_ROW_KEYS : UPDATE_KEYS;
   for (const key of Object.keys(input)) {
     if (accepted.includes(key))
@@ -895,15 +1327,15 @@ function rejectUpdateKeys(input, row) {
     throwNamed2("OKM1120", key, [...accepted, ...FILTER_OPTIONS], `Option ${key} is not accepted by update. Accepted options: ${accepted.join(", ")}. timeout and signal go in the second argument.`);
   }
 }
-function requireFilter(table, where, mods, op) {
+function requireFilter2(table, where, mods, op) {
   if (mods.all !== undefined) {
     if (mods.all.trim().length === 0) {
-      fail("OKM1102", `${op} on ${table.model.name} needs a where. .all needs a reason.`);
+      fail2("OKM1102", `${op} on ${table.model.name} needs a where. .all needs a reason.`);
     }
     return;
   }
   if (!effectivePredicate(where)) {
-    fail("OKM1102", `${op} on ${table.model.name} needs a where. Pass a filter, or .all(reason).`);
+    fail2("OKM1102", `${op} on ${table.model.name} needs a where. Pass a filter, or .all(reason).`);
   }
 }
 function chunkRows(rows) {
@@ -915,7 +1347,7 @@ function chunkRows(rows) {
     for (const cell of row)
       if (cell.kind !== "default")
         cost += 1;
-    if (current.length > 0 && count + cost > WRITE_PARAM_BUDGET) {
+    if (current.length > 0 && count + cost > WRITE_PARAM_BUDGET2) {
       chunks.push(current);
       current = [];
       count = 0;
@@ -940,9 +1372,11 @@ function keyWire(columns, row) {
     return encodeColumn(column, value);
   });
 }
-function returningOption(table, value) {
+function returningOption2(table, value) {
   if (value === undefined)
     return;
+  if (value === true)
+    return selectedColumns(table, undefined);
   return selectedColumns(table, value);
 }
 function returningClause(columns, alias) {
@@ -965,7 +1399,7 @@ function outputsOf(columns) {
     includes: []
   };
 }
-function expectOf(options, mods) {
+function expectOf2(options, mods) {
   const value = mods.expect ?? options.expect;
   if (value === undefined)
     return;
@@ -997,17 +1431,49 @@ function callOptions(options) {
     ...hasTimeout ? { timeout } : {}
   };
 }
+function refuseHalfMorph(table, row) {
+  const relations = table.model.relations;
+  for (let index = 0;index < relations.length; index += 1) {
+    const relation = relations[index];
+    const morph = relation?.morph;
+    if (relation === undefined || morph === undefined || morph.direction !== "to")
+      continue;
+    const typeSet = Object.hasOwn(row, morph.typeField);
+    const idSet = Object.hasOwn(row, morph.idField);
+    const type = typeSet ? row[morph.typeField] : undefined;
+    const id = idSet ? row[morph.idField] : undefined;
+    const typeClear = type === null;
+    const idClear = id === null;
+    if (!typeSet && !idSet)
+      continue;
+    if (typeSet !== idSet || typeClear !== idClear) {
+      fail2("OKM1121", `Set ${table.model.name}.${morph.typeField} and ${morph.idField} together, or clear both. Use morphTo("${morph.name}", type, id).`);
+    }
+    if (typeClear)
+      continue;
+    let accepted = false;
+    const names = [];
+    for (const target of morph.targets) {
+      names.push(target.type);
+      if (target.type === type)
+        accepted = true;
+    }
+    if (!accepted) {
+      fail2("OKM1120", `Relation ${table.model.name}.${relation.name} type ${morph.typeField} is ${typeof type === "string" ? type : typeof type}. Accepted tables: ${names.join(", ")}.`);
+    }
+  }
+}
 function refuse(table, column) {
   if (fieldSealed(table.model, column.field)) {
-    fail("OKM1190", `Field ${table.model.name}.${column.field} is set by a trait. Input cannot set it.`);
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is set by a trait. Input cannot set it.`);
   }
   if (column.guardUpdate) {
-    fail("OKM1190", `Field ${table.model.name}.${column.field} is a primary key. Input cannot change it.`);
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is a primary key. Input cannot change it.`);
   }
   if (column.guarded) {
-    fail("OKM1190", `Field ${table.model.name}.${column.field} is guarded. Input cannot set it.`);
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is guarded. Input cannot set it.`);
   }
-  fail("OKM1120", `Field ${table.model.name}.${column.field} cannot be written.`);
+  fail2("OKM1120", `Field ${table.model.name}.${column.field} cannot be written.`);
 }
 function writable(table, column, allow) {
   if (fieldSealed(table.model, column.field))
@@ -1016,15 +1482,15 @@ function writable(table, column, allow) {
     return true;
   return column.guarded && allow.has(column.field);
 }
-function allowSet(table, value) {
+function allowSet2(table, value) {
   if (value === undefined)
     return NO_ALLOW;
   if (!Array.isArray(value))
-    fail("OKM1120", "allow must be a list of field names.");
+    fail2("OKM1120", "allow must be a list of field names.");
   const set = new Set;
   for (const name of value) {
     if (typeof name !== "string" || !table.columns.has(name)) {
-      fail("OKM1120", "allow must name fields on the table.");
+      fail2("OKM1120", "allow must name fields on the table.");
     }
     set.add(name);
   }
@@ -1038,7 +1504,7 @@ function noteArchive(table, view) {
     return;
   runSafety(rules, undefined);
 }
-function noteGuarded(table, allow, op) {
+function noteGuarded2(table, allow, op) {
   if (!safetyInstalled())
     return;
   const contributions = [];
@@ -1141,8 +1607,5 @@ function collectSecrets(value, names, found, key) {
   for (const child of Object.keys(value))
     collectSecrets(value[child], names, found, child);
 }
-export {
-  WRITE_PARAM_BUDGET,
-  executeWrite,
-  explainWrite
-};
+
+export { touchFields, fieldSealed, WRITE_PARAM_BUDGET2, executeWrite2, explainWrite2, updateSliceBody2, rejectDuplicateTargets2, emitSet2, Sql2, writeSet2, rejectMixedSets2, readClaim2, rejectUpdateKeys2, requireFilter2, returningOption2, expectOf2, allowSet2, noteGuarded2 };