okmodel 0.5.1 → 0.7.0

package/dist/shared/qm7cdtvr.js

@@ -1,912 +0,0 @@
-import {
-  assertOperatorFits,
-  textArray,
-  arrayElementType
-} from "./n7mcc1gk.js";
-import {
-  stack
-} from "./672t5vym.js";
-import {
-  touchFields,
-  fieldSealed,
-  sealingTrait
-} from "./7m88x3e9.js";
-import {
-  runWrite
-} from "./n4jqhpqz.js";
-import {
-  writeWouldValidate
-} from "./9m80mkac.js";
-import {
-  encodeJson
-} from "./gjthds9j.js";
-import {
-  withRowFilters,
-  archiveRules,
-  emitWhere,
-  selectedColumns,
-  rejectKeys,
-  takeObject,
-  projectExpr,
-  decodeRow,
-  indexes,
-  quote,
-  isRecord,
-  effectivePredicate,
-  registerFailFix,
-  fail
-} from "./gbtcc2d7.js";
-import {
-  safetyInstalled,
-  runSafety
-} from "./a5sxz52y.js";
-import {
-  isOperator,
-  operatorName,
-  operatorValue
-} from "./cn0n68ft.js";
-import {
-  OkmError2,
-  throwNamed2
-} from "./52szzakm.js";
-
-// 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 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"];
-var UPDATE_ROW_KEYS = ["id", "set", "where"];
-var NO_ALLOW = new Set;
-async function executeWrite(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);
-}
-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.expect !== undefined ? { checked: "expect" } : {},
-      finish: (results) => finish(results, planned, table)
-    };
-  } catch (error) {
-    throw scrubWrite(host.schema, table, input, error);
-  }
-}
-async function explainWrite(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) {
-    fail("OKM1120", `Table ${tableName} is not in the schema.`);
-  }
-  if (mods.uses !== undefined && op !== "insert") {
-    const { resolve } = await import("./r6nwkxnt.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") {
-    return withRowFilters(scope, mods.archive, () => {
-      noteArchive(table, mods.archive);
-      return planUpdate(schema, table, input, record, mods);
-    });
-  }
-  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 = allowSet(table, options.allow);
-  noteGuarded(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, tenancy?.key);
-  const returning = selectedColumns(table, options.returning);
-  const outputs = outputsOf(returning);
-  const clause = returningClause(returning, undefined);
-  const expect = expectOf(options, mods);
-  const shape = many ? "rows" : "row";
-  if (columns.length === 0) {
-    const text = `insert into ${quote(table.model.sql)} default values${clause}`;
-    return {
-      statements: rows.map(() => ({ text })),
-      outputs,
-      shape,
-      expect,
-      keys: undefined,
-      keyFields: undefined
-    };
-  }
-  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./32zqc1dw.js");
-  const conflict = conflictMod?.readConflict(table, options.onConflict, allow, tenancy?.key);
-  const chunks = chunkRows(rows.map((row) => cellsFor(columns, row)));
-  const statements = [];
-  const keys = [];
-  let offset = 0;
-  for (const chunk of chunks) {
-    const slice = rows.slice(offset, offset + chunk.length);
-    offset += chunk.length;
-    const built = insertHead(table, columns, chunk);
-    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));
-  }
-  return {
-    statements,
-    outputs,
-    shape,
-    expect,
-    keys: conflict?.kind === "return" ? keys : undefined,
-    keyFields: conflict?.kind === "return" ? conflict.columns.map((column) => column.field) : undefined
-  };
-}
-function planUpdate(schema, table, input, options, mods) {
-  const allow = allowSet(table, options.allow);
-  noteGuarded(table, allow, "update");
-  const returning = returningOption(table, options.returning);
-  const outputs = outputsOf(returning);
-  const expect = expectOf(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");
-      return { ...row, where: stack(row.where, mods.presets) };
-    });
-    return {
-      statements: updateList(schema, table, rows, returning),
-      outputs,
-      shape: returning === undefined ? "count" : "rows",
-      expect,
-      keys: undefined,
-      keyFields: 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");
-  if (Object.keys(set).length === 0)
-    fail("OKM1120", "update set is empty.");
-  const sql = new Sql;
-  sql.text("update ");
-  sql.text(quote(table.model.sql));
-  sql.text(" as t set ");
-  emitSet(sql, table, set, "t");
-  emitFilter(schema, table, stack(input.where, mods.presets), sql, "t");
-  sql.text(returningClause(returning, "t"));
-  return {
-    statements: [sql.statement()],
-    outputs,
-    shape: returning === undefined ? "count" : "rows",
-    expect,
-    keys: undefined,
-    keyFields: undefined
-  };
-}
-function planDelete(schema, table, input, options, mods) {
-  if (!isRecord(input))
-    fail("OKM1121", "delete expects { where }.");
-  rejectKeys(input, ["where"], "delete");
-  requireFilter(table, input.where, mods, "delete");
-  const returning = returningOption(table, options.returning);
-  const sql = new Sql;
-  sql.text("delete from ");
-  sql.text(quote(table.model.sql));
-  sql.text(" as t");
-  emitFilter(schema, table, stack(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),
-    keys: undefined,
-    keyFields: undefined
-  };
-}
-function finish(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 = [];
-  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);
-  checkExpect(rows.length, planned.expect, table, "insert");
-  if (planned.shape === "row")
-    return rows[0] ?? null;
-  return rows;
-}
-function orderByKeys(rows, fields, keys) {
-  const found = new Map;
-  for (const row of rows)
-    found.set(fields.map((field) => wireKey(row[field])).join("\x00"), 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 wireKey(value) {
-  if (typeof value === "string")
-    return value;
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  return "";
-}
-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_BUDGET / (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 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)
-    fail("OKM1120", "update set is empty.");
-  const sql = new Sql;
-  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 (const row of rows) {
-      sql.text(" when ");
-      emitBare(schema, table, row.where, sql, "t");
-      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);
-  sql.text(" 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");
-    sql.text(")");
-  }
-  sql.text(returningClause(returning, "t"));
-  return sql.statement();
-}
-function emitSet(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") {
-      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);
-      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;
-    }
-    fail("OKM1121", `Field ${column.field} received an operator. set accepts a value, inc, set, or arr.`);
-  }
-  if (value === null) {
-    sql.text(`null::${column.dataType}`);
-    return;
-  }
-  if (typeof value === "object")
-    takeObject(column, value);
-  sql.param(encodeColumn(column, value), 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.`);
-  const stored = operatorValue(value);
-  if (!isRecord(stored) || !Array.isArray(stored.path)) {
-    fail("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.`);
-  }
-  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) {
-    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.`);
-  }
-  if (!isOperator(value)) {
-    fail("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) {
-    fail("OKM1102", `update on ${table.model.name} needs a where for each row.`);
-  }
-}
-
-class Sql {
-  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))
-    fail("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];
-  }
-  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, tenantKey) {
-  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 || column.field === tenantKey)) {
-      columns.push(column);
-    }
-  }
-  return columns;
-}
-function writeSet(table, value, allow, tenancy) {
-  if (!isRecord(value))
-    fail("OKM1121", "set must be an object of fields.");
-  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];
-  }
-  return set;
-}
-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);
-  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.`);
-}
-function rejectUpdateKeys(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 requireFilter(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.`);
-    }
-    return;
-  }
-  if (!effectivePredicate(where)) {
-    fail("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_BUDGET) {
-      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 returningOption(table, value) {
-  if (value === undefined)
-    return;
-  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 expectOf(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 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.`);
-  }
-  if (column.guardUpdate) {
-    fail("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.`);
-  }
-  fail("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 allowSet(table, value) {
-  if (value === undefined)
-    return NO_ALLOW;
-  if (!Array.isArray(value))
-    fail("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.");
-    }
-    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 noteGuarded(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 {
-  WRITE_PARAM_BUDGET,
-  executeWrite,
-  explainWrite
-};