okmodel 0.5.1 → 0.7.0

package/dist/shared/1w508jbr.js

@@ -0,0 +1,1611 @@
+import {
+  stack2
+} from "./mss6ctgv.js";
+import {
+  effectivePredicate
+} from "./n816peh1.js";
+import {
+  assertOperatorFits,
+  textArray,
+  arrayElementType
+} from "./zchaghkf.js";
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  writeWouldValidate
+} from "./ze4hxsmy.js";
+import {
+  encodeJson
+} from "./9628a9xt.js";
+import {
+  withRowFilters,
+  archiveRules,
+  emitWhere,
+  selectedColumns,
+  rejectKeys,
+  takeObject,
+  projectExpr,
+  decodeRow,
+  indexes,
+  quote,
+  isRecord,
+  registerFailFix,
+  fail2
+} from "./67txcrcw.js";
+import {
+  safetyInstalled,
+  runSafety
+} from "./a5sxz52y.js";
+import {
+  isOperator,
+  operatorName,
+  operatorValue
+} from "./cn0n68ft.js";
+import {
+  OkmError2,
+  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_BUDGET2 = 2048;
+var REDACTED = "[redacted]";
+function encodeColumn(column, value) {
+  if (!column.hidden && !column.sensitive)
+    return column.encode(value);
+  try {
+    return column.encode(value);
+  } catch (error) {
+    if (error instanceof OkmError2) {
+      throw new OkmError2(error.code, `Field ${column.field} was rejected.`, {
+        kind: error.kind,
+        fix: error.fix
+      });
+    }
+    throw error;
+  }
+}
+async function requireValidationImport(schema, op, tableName, options) {
+  if (op === "delete" || validationRegistered(schema))
+    return;
+  const stored = schema;
+  const source = stored.tables?.find((item) => item.name === tableName);
+  if (source === undefined || !writeWouldValidate(stored.validation, source, options))
+    return;
+  const { refuseMissingValidation } = await import("./83eaefwr.js");
+  refuseMissingValidation();
+}
+function validationRegistered(schema) {
+  const hooks = schema.hooks;
+  if (hooks === undefined)
+    return false;
+  for (const hook of hooks) {
+    if (hook["~v"] === 1)
+      return true;
+  }
+  return false;
+}
+var INSERT_OPTIONS = [
+  "allow",
+  "expect",
+  "onConflict",
+  "returning",
+  "signal",
+  "timeout",
+  "validate"
+];
+var FILTER_OPTIONS = ["allow", "expect", "returning", "signal", "timeout", "validate"];
+var UPDATE_KEYS = ["set", "where", "limit", "lock", "version"];
+var UPDATE_ROW_KEYS = ["id", "set", "where", "version"];
+var NO_ALLOW = new Set;
+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);
+  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 {
+    const planned = await planWrite(host.schema, host.generators, op, table, input, options, mods, scope);
+    return {
+      statements: planned.statements,
+      options: callOptions(options),
+      ...planned.parentGuard === true ? { checked: "parent" } : planned.expect !== undefined ? { checked: "expect" } : {},
+      ...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 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 };
+  } catch (error) {
+    throw scrubWrite(schema, table, input, error);
+  }
+}
+async function planWrite(schema, generators, op, tableName, input, options, mods, scope) {
+  await requireValidationImport(schema, op, tableName, options);
+  const table = indexes(schema).get(tableName);
+  if (table === undefined) {
+    fail2("OKM1120", `Table ${tableName} is not in the schema.`);
+  }
+  if (mods.uses !== undefined && op !== "insert") {
+    const { resolve } = await import("./m7n9h2a5.js");
+    mods = { ...mods, presets: resolve(schema, tableName, mods.uses).wheres };
+  }
+  const record = isRecord(options) ? options : {};
+  rejectKeys(record, op === "insert" ? INSERT_OPTIONS : FILTER_OPTIONS, op);
+  if (op === "insert") {
+    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);
+    });
+  }
+  return withRowFilters(scope, mods.archive, () => {
+    noteArchive(table, mods.archive);
+    return planDelete(schema, table, input, record, mods);
+  });
+}
+async function planInsert(table, input, options, mods, generators, scope, tenancy) {
+  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);
+  fillInsert(table, rows, generators);
+  const columns = writtenColumns(table, rows, allow, tenantKeyList(tenancy));
+  const returning = selectedColumns(table, options.returning);
+  const outputs = outputsOf(returning);
+  const clause = returningClause(returning, undefined);
+  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") {
+    fail2("OKM1120", `onConflict on ${table.model.name} is not available. The insert checks the parent.`);
+  }
+  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 })),
+      outputs,
+      shape,
+      expect,
+      keys: undefined,
+      keyColumns: undefined
+    };
+  }
+  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 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;
+    }
+    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: 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) {
+  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 = expectOf2(options, mods);
+  if (Array.isArray(input)) {
+    const rows = input.map((item) => {
+      const row = updateItem(table, item, allow, schema.tenancy);
+      requireFilter2(table, row.where, mods, "update");
+      pathAssignment(schema.tenancy, table.model.name, row.set, scope);
+      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 {
+        statements: [pathListUpdate(schema, table, rows, scope, returning)],
+        outputs: parentOutputs(returning),
+        shape: returning === undefined ? "count" : "rows",
+        expect,
+        keys: undefined,
+        keyColumns: undefined,
+        parentGuard: true
+      };
+    }
+    return {
+      statements: updateList(schema, table, rows, returning),
+      outputs,
+      shape: returning === undefined ? "count" : "rows",
+      expect,
+      keys: undefined,
+      keyColumns: undefined
+    };
+  }
+  if (!isRecord(input))
+    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)
+    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,
+      keyColumns: undefined,
+      parentGuard: true
+    };
+  }
+  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 ");
+  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"));
+  return {
+    statements: [sql.statement()],
+    outputs,
+    shape: returning === undefined ? "count" : "rows",
+    expect,
+    keys: undefined,
+    keyColumns: undefined
+  };
+}
+function planDelete(schema, table, input, options, mods) {
+  if (!isRecord(input))
+    fail2("OKM1121", "delete expects { where }.");
+  rejectKeys(input, ["where"], "delete");
+  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, 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: expectOf2(options, mods),
+    keys: 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") {
+    let count = 0;
+    for (const result of results)
+      count += result.count;
+    checkExpect(count, planned.expect, table, "write");
+    return { count };
+  }
+  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.`, {
+      fix: { summary: "Insert under a parent that belongs to this tenant." }
+    });
+  }
+  if (planned.shape === "row")
+    return rows[0] ?? null;
+  return rows;
+}
+function finishParent(results, planned, table) {
+  const row = results[0]?.rows[0];
+  const matched = countCell(row?.[0]);
+  const updated = countCell(row?.[1]);
+  if (updated < matched) {
+    throw new OkmError2("OKM1705", `Update on ${table} did not find a parent in this tenant.`, {
+      fix: { summary: "Point the foreign key at a parent in this tenant." }
+    });
+  }
+  if (planned.shape === "count") {
+    checkExpect(updated, planned.expect, table, "write");
+    return { count: updated };
+  }
+  const decoded = [];
+  if (updated > 0) {
+    for (const result of results) {
+      for (const item of result.rows)
+        decoded.push(decodeRow(planned.outputs, item));
+    }
+  }
+  checkExpect(decoded.length, planned.expect, table, "write");
+  if (planned.shape === "row")
+    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;
+  if (typeof value === "bigint")
+    return Number(value);
+  if (typeof value === "string" && value.length > 0)
+    return Number(value);
+  return 0;
+}
+function pathField(tenancy, table, set) {
+  if (tenancy?.isPath?.(table) !== true)
+    return;
+  const field = tenancy.pathOf?.(table)?.[0]?.localField;
+  if (field === undefined || !Object.hasOwn(set, field))
+    return;
+  return field;
+}
+function pathAssignment(tenancy, table, set, scope) {
+  const field = pathField(tenancy, table, set);
+  if (field === undefined)
+    return;
+  const value = set[field];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new OkmError2("OKM1705", `Update on ${table} cannot verify ${field}. Pass the parent id as a string.`, { fix: { summary: "Pass the parent id as a string so the tenant can be checked." } });
+  }
+  if (scope === undefined || "unscoped" in scope) {
+    throw new OkmError2("OKM1705", `Update on ${table} cannot verify ${field} without a tenant.`, {
+      fix: { summary: `Call for({ ... }) so ${field} can be checked.` }
+    });
+  }
+  return field;
+}
+function parentOutputs(returning) {
+  const outputs = outputsOf(returning);
+  if (returning === undefined)
+    return outputs;
+  return {
+    fields: outputs.fields.map((field) => ({ ...field, at: field.at + 2 })),
+    includes: outputs.includes
+  };
+}
+function rowId(alias) {
+  return `${alias}.tableoid, ${alias}.ctid`;
+}
+function pathSetUpdate(schema, table, where, set, scope, returning) {
+  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 ");
+  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 Sql2;
+  sql.text("with matched as (");
+  for (let index = 0;index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === undefined)
+      continue;
+    if (index > 0)
+      sql.text(" union all ");
+    sql.text("select t.ctid as tid, ");
+    sql.text(String(index));
+    sql.text(" as ord from ");
+    sql.text(quote(table.model.sql));
+    sql.text(" as t where ");
+    emitBare(schema, table, row.where, sql, "t");
+  }
+  sql.text("), rejected as (");
+  let rejected = false;
+  for (let index = 0;index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === undefined)
+      continue;
+    if (pathField(schema.tenancy, table.model.name, row.set) === undefined)
+      continue;
+    if (rejected)
+      sql.text(" union all ");
+    rejected = true;
+    sql.text("select ");
+    sql.text(String(index));
+    sql.text(" as ord where exists (select 1 from matched where ord = ");
+    sql.text(String(index));
+    sql.text(")");
+    noteParentNot(schema, table, row.set, scope, sql);
+  }
+  if (!rejected)
+    sql.text("select 0 as ord where false");
+  sql.text("), updated as (");
+  updateSliceBody2(schema, table, rows, sql, true);
+  sql.text(" and not exists (select 1 from rejected)");
+  endParent(sql, returning);
+  return sql.statement();
+}
+function noteParentNot(schema, table, set, scope, sql) {
+  let first = true;
+  schema.tenancy?.noteParent?.(table.model.name, set, {
+    text(value) {
+      if (first) {
+        first = false;
+        sql.text(" and not ");
+        return;
+      }
+      sql.text(value);
+    },
+    param(encoded) {
+      sql.param(encoded, "");
+    },
+    mark() {}
+  }, scope, (field) => table.columns.get(field)?.sql);
+}
+function endParent(sql, returning) {
+  if (returning === undefined || returning.length === 0) {
+    sql.text(" returning 1) select (select count(*)::int from matched), (select count(*)::int from updated)");
+    return;
+  }
+  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 updateSliceBody2(schema, table, rows, sql, wrapWhere = false, hooks) {
+  const fields = [];
+  const seen = new Set;
+  for (const row of rows) {
+    for (const key of Object.keys(row.set)) {
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      const column = table.columns.get(key);
+      if (column !== undefined)
+        fields.push(column);
+    }
+  }
+  if (fields.length === 0)
+    fail2("OKM1120", "update set is empty.");
+  sql.text("update ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t set ");
+  for (let field = 0;field < fields.length; field += 1) {
+    const column = fields[field];
+    if (column === undefined)
+      continue;
+    if (field > 0)
+      sql.text(", ");
+    sql.text(quote(column.sql));
+    sql.text(" = case");
+    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)
+        sql.text(`t.${quote(column.sql)}`);
+      else
+        emitValue(sql, column, value, "t");
+    }
+    sql.text(" else t.");
+    sql.text(quote(column.sql));
+    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];
+    if (row === undefined)
+      continue;
+    if (index > 0)
+      sql.text(" or ");
+    sql.text("(");
+    emitBare(schema, table, row.where, sql, "t");
+    hooks?.afterWhere?.(sql, index);
+    sql.text(")");
+  }
+  if (wrapWhere)
+    sql.text(")");
+}
+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) {
+    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"));
+    if (row !== undefined)
+      ordered.push(row);
+  }
+  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;
+  return String(value);
+}
+function insertHead(table, columns, rows) {
+  const params = [];
+  const lists = [];
+  for (const row of rows) {
+    const slots = [];
+    for (const cell of row) {
+      if (cell.kind === "default") {
+        slots.push("default");
+        continue;
+      }
+      params.push(cell.kind === "null" ? null : cell.wire);
+      slots.push(`$${String(params.length)}::${cell.dataType}`);
+    }
+    lists.push(`(${slots.join(", ")})`);
+  }
+  const names = columns.map((column) => quote(column.sql)).join(", ");
+  return {
+    text: `insert into ${quote(table.model.sql)} (${names}) values ${lists.join(", ")}`,
+    params
+  };
+}
+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_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));
+  }
+  return statements;
+}
+function updateSlice(schema, table, rows, returning) {
+  const sql = new Sql2;
+  updateSliceBody2(schema, table, rows, sql);
+  sql.text(returningClause(returning, "t"));
+  return sql.statement();
+}
+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) {
+    const column = table.columns.get(key);
+    if (column === undefined)
+      continue;
+    if (wrote)
+      sql.text(", ");
+    wrote = true;
+    sql.text(quote(column.sql));
+    sql.text(" = ");
+    emitValue(sql, column, set[key], alias);
+  }
+  wrote = emitTouch(sql, table, wrote);
+}
+function emitTouch(sql, table, wrote) {
+  const touch = touchFields(table.model);
+  if (touch === undefined)
+    return wrote;
+  for (const field of touch) {
+    const column = table.columns.get(field);
+    if (column === undefined)
+      continue;
+    if (wrote)
+      sql.text(", ");
+    wrote = true;
+    sql.text(quote(column.sql));
+    sql.text(" = now()");
+  }
+  return wrote;
+}
+function emitValue(sql, column, value, alias) {
+  if (isOperator(value)) {
+    const name = operatorName(value);
+    if (name === "inc") {
+      emitIncrement(sql, column, value, alias);
+      return;
+    }
+    if (name === "json.set") {
+      emitJsonSet(sql, column, value, alias);
+      return;
+    }
+    if (name === "arr.append" || name === "arr.remove") {
+      emitArrayWrite(sql, column, name, value, alias);
+      return;
+    }
+    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}`);
+    return;
+  }
+  if (typeof value === "object")
+    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))
+    fail2("OKM1121", `json.set on ${column.field} needs a path and a value.`);
+  const stored = operatorValue(value);
+  if (!isRecord(stored) || !Array.isArray(stored.path)) {
+    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")) {
+    fail2("OKM1121", `json.set on ${column.field} needs a list of segments.`);
+  }
+  const encoded = encodeJson(stored.value);
+  const ref = `${alias}.${quote(column.sql)}`;
+  const target = column.dataType === "json" ? `${ref}::jsonb` : ref;
+  sql.text(`jsonb_set(${target}, `);
+  sql.param(textArray(path, `path on ${column.field}`), "text[]");
+  sql.text(", ");
+  sql.param(encoded, "jsonb");
+  sql.text(")");
+  if (column.dataType === "json")
+    sql.text("::json");
+}
+function emitArrayWrite(sql, column, name, value, alias) {
+  assertOperatorFits(column, name);
+  const encode = column.elementEncode;
+  if (encode === undefined) {
+    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)) {
+    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)}, `);
+  sql.param(encode(operatorValue(value)), arrayElementType(column.dataType, column));
+  sql.text(")");
+}
+function emitFilter(schema, table, where, sql, alias) {
+  emitWhere(schema, table, where, sql.sink(), alias, 0);
+}
+function emitBare(schema, table, where, sql, alias) {
+  let dropped = false;
+  const sink = {
+    text(value) {
+      if (!dropped) {
+        dropped = true;
+        if (value === " where " || value === " and ")
+          return;
+      }
+      sql.text(value);
+    },
+    param(encoded) {
+      sql.param(encoded, "");
+    },
+    mark() {}
+  };
+  emitWhere(schema, table, where, sink, alias, 0);
+  if (!dropped) {
+    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 Sql2 {
+  parts = [];
+  params = [];
+  text(value) {
+    this.parts.push(value);
+  }
+  param(wire, dataType) {
+    this.params.push(wire);
+    const slot = `$${String(this.params.length)}`;
+    this.parts.push(dataType.length === 0 ? slot : `${slot}::${dataType}`);
+  }
+  sink() {
+    return {
+      text: (value) => {
+        this.text(value);
+      },
+      param: (encoded) => {
+        this.param(encoded, "");
+      },
+      mark() {}
+    };
+  }
+  statement() {
+    return this.params.length === 0 ? { text: this.parts.join("") } : { text: this.parts.join(""), params: this.params };
+  }
+}
+function insertRow(table, value, allow, tenancy) {
+  if (!isRecord(value))
+    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);
+    if (column === undefined)
+      continue;
+    tenancy?.guard(table.model.name, key, "insert");
+    if (!writable(table, column, allow))
+      refuse(table, column);
+    if (value[key] !== undefined)
+      row[key] = value[key];
+  }
+  refuseHalfMorph(table, row);
+  return row;
+}
+function cellsFor(columns, row) {
+  return columns.map((column) => {
+    if (!Object.hasOwn(row, column.field))
+      return { kind: "default" };
+    const value = row[column.field];
+    if (value === null)
+      return { kind: "null", dataType: column.dataType };
+    if (typeof value === "object")
+      takeObject(column, value);
+    return { kind: "value", wire: encodeColumn(column, value), dataType: column.dataType };
+  });
+}
+function fillInsert(table, rows, generators) {
+  const fills = [];
+  for (const column of table.model.columns) {
+    if (column.fill !== undefined)
+      fills.push(column);
+  }
+  if (fills.length === 0)
+    return;
+  for (const row of rows) {
+    for (const column of fills) {
+      if (Object.hasOwn(row, column.field))
+        continue;
+      const fill = column.fill;
+      if (fill === undefined)
+        continue;
+      row[column.field] = nextFill(fill, generators);
+    }
+  }
+}
+function nextFill(fill, generators) {
+  if (fill.name === "uuidv4" && generators?.uuidv4 !== undefined)
+    return generators.uuidv4();
+  if (fill.name === "uuidv7" && generators?.uuidv7 !== undefined)
+    return generators.uuidv7();
+  if (fill.name === "okid" && generators?.okid !== undefined)
+    return generators.okid();
+  return fill.call();
+}
+function writtenColumns(table, rows, allow, tenantKeys) {
+  const present = new Set;
+  for (const row of rows) {
+    for (const key of Object.keys(row))
+      present.add(key);
+  }
+  const columns = [];
+  for (const column of table.model.columns) {
+    if (present.has(column.field) && (writable(table, column, allow) || column.fill !== undefined || tenantKeys?.includes(column.field) === true)) {
+      columns.push(column);
+    }
+  }
+  return columns;
+}
+function tenantKeyList(tenancy) {
+  if (tenancy === undefined)
+    return;
+  if (tenancy.keys !== undefined && tenancy.keys.length > 0)
+    return tenancy.keys;
+  return [tenancy.key];
+}
+function pathInsert(table, columns, rows, scope, tenancy) {
+  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 `);
+  for (let row = 0;row < rows.length; row += 1) {
+    const cells = rows[row];
+    if (cells === undefined)
+      continue;
+    if (row > 0)
+      sql.text(", ");
+    sql.text("(");
+    for (let index = 0;index < cells.length; index += 1) {
+      const cell = cells[index];
+      if (index > 0)
+        sql.text(", ");
+      if (cell === undefined || cell.kind === "default") {
+        sql.text("default");
+        continue;
+      }
+      sql.param(cell.kind === "null" ? null : cell.wire, cell.dataType);
+    }
+    sql.text(")");
+  }
+  sql.text(`) as v(${names})`);
+  tenancy?.lockPredicate?.({
+    table: table.model.name,
+    fieldSql: (field) => table.columns.get(field)?.sql,
+    encode: table.columns.get(tenancy.key)?.encode,
+    alias: "v",
+    appended: false,
+    scope,
+    sink: sql.sink()
+  });
+  return sql.statement();
+}
+function writeSet2(table, value, allow, tenancy) {
+  if (!isRecord(value))
+    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)
+      continue;
+    const column = table.columns.get(key);
+    if (column === undefined)
+      continue;
+    tenancy?.guard(table.model.name, key, "update");
+    if (column.guardUpdate || !writable(table, column, allow))
+      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))
+    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 };
+  fail2("OKM1102", `update on ${table.model.name} needs id or where for each 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))
+      continue;
+    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 requireFilter2(table, where, mods, op) {
+  if (mods.all !== undefined) {
+    if (mods.all.trim().length === 0) {
+      fail2("OKM1102", `${op} on ${table.model.name} needs a where. .all needs a reason.`);
+    }
+    return;
+  }
+  if (!effectivePredicate(where)) {
+    fail2("OKM1102", `${op} on ${table.model.name} needs a where. Pass a filter, or .all(reason).`);
+  }
+}
+function chunkRows(rows) {
+  const chunks = [];
+  let current = [];
+  let count = 0;
+  for (const row of rows) {
+    let cost = 0;
+    for (const cell of row)
+      if (cell.kind !== "default")
+        cost += 1;
+    if (current.length > 0 && count + cost > WRITE_PARAM_BUDGET2) {
+      chunks.push(current);
+      current = [];
+      count = 0;
+    }
+    current.push(row);
+    count += cost;
+  }
+  if (current.length > 0)
+    chunks.push(current);
+  return chunks;
+}
+function withParams(text, params) {
+  if (params === undefined || params.length === 0)
+    return { text };
+  return { text, params };
+}
+function keyWire(columns, row) {
+  return columns.map((column) => {
+    const value = row[column.field];
+    if (value === undefined || value === null)
+      return null;
+    return encodeColumn(column, value);
+  });
+}
+function returningOption2(table, value) {
+  if (value === undefined)
+    return;
+  if (value === true)
+    return selectedColumns(table, undefined);
+  return selectedColumns(table, value);
+}
+function returningClause(columns, alias) {
+  if (columns === undefined || columns.length === 0)
+    return "";
+  const parts = columns.map((column) => {
+    const sql = alias === undefined ? quote(column.sql) : `${alias}.${quote(column.sql)}`;
+    return projectExpr(sql, column.dataType);
+  });
+  return ` returning ${parts.join(", ")}`;
+}
+function outputsOf(columns) {
+  const list = columns ?? [];
+  return {
+    fields: list.map((column, index) => ({
+      key: column.field,
+      at: index,
+      decode: column.decode
+    })),
+    includes: []
+  };
+}
+function expectOf2(options, mods) {
+  const value = mods.expect ?? options.expect;
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new OkmError2("invalid", "expect must be an integer from 0 up.", { kind: "invalid" });
+  }
+  return value;
+}
+function checkExpect(count, expected, table, op) {
+  if (expected === undefined || count === expected)
+    return;
+  throw new OkmError2("not_found", `${op} on ${table} changed ${String(count)} rows. expect was ${String(expected)}.`, {
+    kind: "not_found",
+    table,
+    fix: { summary: "Change the filter, or pass the count this write produced." }
+  });
+}
+function callOptions(options) {
+  if (!isRecord(options))
+    return;
+  const signal = options.signal;
+  const timeout = options.timeout;
+  const hasSignal = typeof signal === "object" && signal !== null && "aborted" in signal;
+  const hasTimeout = typeof timeout === "number";
+  if (!hasSignal && !hasTimeout)
+    return;
+  return {
+    ...hasSignal ? { signal } : {},
+    ...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)) {
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is set by a trait. Input cannot set it.`);
+  }
+  if (column.guardUpdate) {
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is a primary key. Input cannot change it.`);
+  }
+  if (column.guarded) {
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is guarded. Input cannot set it.`);
+  }
+  fail2("OKM1120", `Field ${table.model.name}.${column.field} cannot be written.`);
+}
+function writable(table, column, allow) {
+  if (fieldSealed(table.model, column.field))
+    return false;
+  if (column.writable)
+    return true;
+  return column.guarded && allow.has(column.field);
+}
+function allowSet2(table, value) {
+  if (value === undefined)
+    return NO_ALLOW;
+  if (!Array.isArray(value))
+    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)) {
+      fail2("OKM1120", "allow must name fields on the table.");
+    }
+    set.add(name);
+  }
+  return set;
+}
+function noteArchive(table, view) {
+  if (!safetyInstalled())
+    return;
+  const rules = archiveRules(table.model, view);
+  if (rules === undefined)
+    return;
+  runSafety(rules, undefined);
+}
+function noteGuarded2(table, allow, op) {
+  if (!safetyInstalled())
+    return;
+  const contributions = [];
+  const hatches = [];
+  const touch = touchFields(table.model);
+  const source = table.model.source;
+  for (const column of table.model.columns) {
+    const traitName = sealingTrait(table.model, column.field);
+    if (traitName !== undefined) {
+      const sets = op === "insert" || touch?.includes(column.field) === true;
+      contributions.push({
+        rule: traitName,
+        contribution: sets ? `${traitName} ${table.model.name}.${column.field} set by ${traitName}` : `${traitName} ${table.model.name}.${column.field} kept`,
+        provenance: "planner",
+        ...source !== undefined ? { source } : {}
+      });
+      continue;
+    }
+    if (!column.guarded)
+      continue;
+    const name = `${table.model.name}.${column.field}`;
+    if (allow.has(column.field)) {
+      contributions.push({
+        rule: "guarded",
+        contribution: `guarded ${name} allowed`,
+        provenance: "allow"
+      });
+      hatches.push({ name: "allow", reason: name });
+    } else {
+      contributions.push({
+        rule: "guarded",
+        contribution: `guarded ${name} absent`,
+        provenance: "planner"
+      });
+    }
+  }
+  if (contributions.length === 0)
+    return;
+  runSafety(contributions, hatches.length === 0 ? undefined : hatches);
+}
+function scrubWrite(schema, tableName, input, error) {
+  if (!(error instanceof OkmError2))
+    return error;
+  const table = indexes(schema).get(tableName);
+  if (table === undefined || table.model.conceal !== true)
+    return error;
+  const secrets = [];
+  const names = new Set;
+  for (const column of table.model.columns) {
+    if (column.hidden || column.sensitive)
+      names.add(column.field);
+  }
+  collectSecrets(input, names, secrets);
+  if (secrets.length === 0)
+    return error;
+  let message = error.message;
+  for (const secret of secrets) {
+    if (secret.length < 4 || !message.includes(secret))
+      continue;
+    message = message.replaceAll(secret, REDACTED);
+  }
+  const issues = error.issues === undefined ? undefined : redactIssues(error.issues, secrets);
+  if (message === error.message && issues === undefined)
+    return error;
+  return new OkmError2(error.code, message, {
+    kind: error.kind,
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...error.columns.length > 0 ? { columns: error.columns } : {},
+    ...error.issues !== undefined ? { issues: issues ?? error.issues } : {},
+    fix: error.fix
+  });
+}
+function redactIssues(issues, secrets) {
+  let changed = false;
+  const next = issues.map((issue) => {
+    let message = issue.message;
+    for (const secret of secrets) {
+      if (secret.length < 4 || !message.includes(secret))
+        continue;
+      message = message.replaceAll(secret, REDACTED);
+      changed = true;
+    }
+    return message === issue.message ? issue : { path: issue.path, message };
+  });
+  return changed ? next : undefined;
+}
+function collectSecrets(value, names, found, key) {
+  if (typeof value === "string") {
+    if (key !== undefined && names.has(key))
+      found.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      collectSecrets(item, names, found);
+    return;
+  }
+  if (!isRecord(value))
+    return;
+  for (const child of Object.keys(value))
+    collectSecrets(value[child], names, found, child);
+}
+
+export { touchFields, fieldSealed, WRITE_PARAM_BUDGET2, executeWrite2, explainWrite2, updateSliceBody2, rejectDuplicateTargets2, emitSet2, Sql2, writeSet2, rejectMixedSets2, readClaim2, rejectUpdateKeys2, requireFilter2, returningOption2, expectOf2, allowSet2, noteGuarded2 };