@drzl/validation-core 3.20.0 → 3.22.1

package/dist/index.js

@@ -5,6 +5,542 @@ import { createRequire } from "module";
 import path from "path";
 import { pathToFileURL } from "url";
 
+// src/checks.ts
+function lengthMeasure(column, check) {
+  if (column.arrayDimensions) return void 0;
+  if (column.shape?.kind === "buffer") return "byteLength";
+  if (column.shape) return void 0;
+  if (column.tsType !== "string") return void 0;
+  return check.unit === "bytes" ? "utf8Bytes" : "codePoints";
+}
+function measureExpression(measure, variable) {
+  switch (measure) {
+    case "codePoints":
+      return `[...${variable}].length`;
+    case "utf8Bytes":
+      return `new TextEncoder().encode(${variable}).length`;
+    case "byteLength":
+      return `${variable}.length`;
+  }
+}
+function lengthCheckLabel(check) {
+  const fn = check.unit === "bytes" ? "octet_length" : "length";
+  const rule = `${fn}(${check.column}) ${check.operator} ${check.value}`;
+  return check.name ? `${check.name}: ${rule}` : rule;
+}
+var COMPARISON = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*(>=|<=|<>|!=|>|<|=)\s*(.+?)\s*$/;
+var IN_LIST = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s+IN\s*\((.+)\)\s*$/i;
+var CARDINALITY_OF = /^\s*(?:cardinality\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)|array_length\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*,\s*1\s*\))\s*(>=|<=|<>|!=|>|<|=)\s*(\d+)\s*$/i;
+var LENGTH_OF = /^\s*(length|char_length|octet_length)\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)\s*(>=|<=|<>|!=|>|<|=)\s*(\d+)\s*$/i;
+var WORD = /[A-Za-z0-9_]/;
+function splitTopLevel(expr, keyword) {
+  const parts = [];
+  let depth = 0;
+  let inString = false;
+  let start = 0;
+  for (let i = 0; i < expr.length; i++) {
+    const c = expr[i];
+    if (inString) {
+      if (c === "'") {
+        if (expr[i + 1] === "'") i++;
+        else inString = false;
+      }
+      continue;
+    }
+    if (c === "'") {
+      inString = true;
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")") depth--;
+    else if (depth === 0 && WORD.test(c)) {
+      if (i > 0 && WORD.test(expr[i - 1])) continue;
+      if (expr.slice(i, i + keyword.length).toUpperCase() !== keyword) continue;
+      const after = expr[i + keyword.length];
+      if (after !== void 0 && WORD.test(after)) continue;
+      parts.push(expr.slice(start, i));
+      i += keyword.length - 1;
+      start = i + 1;
+    }
+  }
+  parts.push(expr.slice(start));
+  return parts;
+}
+function hasLogicalNot(expr) {
+  let inString = false;
+  for (let i = 0; i < expr.length; i++) {
+    const c = expr[i];
+    if (inString) {
+      if (c === "'") {
+        if (expr[i + 1] === "'") i++;
+        else inString = false;
+      }
+      continue;
+    }
+    if (c === "'") {
+      inString = true;
+      continue;
+    }
+    if (c !== "N" && c !== "n") continue;
+    if (i > 0 && WORD.test(expr[i - 1])) continue;
+    if (!/^NOT($|[^A-Za-z0-9_])/i.test(expr.slice(i))) continue;
+    if (/(^|[^A-Za-z0-9_])IS\s+$/i.test(expr.slice(0, i))) continue;
+    return true;
+  }
+  return false;
+}
+var COMBINING = /(?:^|\s)(\|\||[+\-*/%])(?:\s)/;
+function combiningOperator(expr) {
+  let inString = false;
+  let bare = "";
+  for (let i = 0; i < expr.length; i++) {
+    const c = expr[i];
+    if (inString) {
+      if (c === "'") {
+        if (expr[i + 1] === "'") i++;
+        else inString = false;
+      }
+      continue;
+    }
+    if (c === "'") {
+      inString = true;
+      bare += " ";
+      continue;
+    }
+    bare += c;
+  }
+  return COMBINING.exec(bare)?.[1];
+}
+function unwrap(expr) {
+  let e = expr.trim();
+  while (e.startsWith("(") && e.endsWith(")")) {
+    let depth = 0;
+    let inString = false;
+    let wrapsWhole = true;
+    for (let i = 0; i < e.length; i++) {
+      const c = e[i];
+      if (inString) {
+        if (c === "'") {
+          if (e[i + 1] === "'") i++;
+          else inString = false;
+        }
+        continue;
+      }
+      if (c === "'") inString = true;
+      else if (c === "(") depth++;
+      else if (c === ")") {
+        depth--;
+        if (depth === 0 && i < e.length - 1) {
+          wrapsWhole = false;
+          break;
+        }
+      }
+    }
+    if (!wrapsWhole) break;
+    e = e.slice(1, -1).trim();
+  }
+  return e;
+}
+function splitTopLevelCommas(list2) {
+  const parts = [];
+  let depth = 0;
+  let inString = false;
+  let start = 0;
+  for (let i = 0; i < list2.length; i++) {
+    const c = list2[i];
+    if (inString) {
+      if (c === "'") {
+        if (list2[i + 1] === "'") i++;
+        else inString = false;
+      }
+      continue;
+    }
+    if (c === "'") inString = true;
+    else if (c === "(") depth++;
+    else if (c === ")") depth--;
+    else if (c === "," && depth === 0) {
+      parts.push(list2.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(list2.slice(start));
+  return parts;
+}
+var BETWEEN = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s+BETWEEN\s+(.+?)\s+AND\s+(.+?)\s*$/i;
+var IS_NULL = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s+IS\s+(NOT\s+)?NULL\s*$/i;
+var IS_DISTINCT = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s+IS\s+(NOT\s+)?DISTINCT\s+FROM\s+(.+?)\s*$/i;
+var IS_BOOLEAN = /^\s*[A-Za-z_][A-Za-z0-9_]*\s+IS\s+(?:NOT\s+)?(TRUE|FALSE|UNKNOWN)\s*$/i;
+function literal(raw) {
+  const t = raw.trim();
+  if (/^-?\d+(\.\d+)?$/.test(t)) return { value: t, kind: "number" };
+  const m = t.match(/^'((?:[^']|'')*)'$/);
+  if (m) return { value: m[1].replace(/''/g, "'"), kind: "string" };
+  return void 0;
+}
+function columnsOf(parsed) {
+  const out = /* @__PURE__ */ new Set();
+  for (const c of parsed.checks) out.add(c.column);
+  for (const s of parsed.sets ?? []) out.add(s.column);
+  for (const l of parsed.lengths ?? []) out.add(l.column);
+  for (const a of parsed.cardinalities ?? []) out.add(a.column);
+  for (const n of parsed.nulls ?? []) out.add(n.column);
+  for (const r of parsed.rows ?? []) {
+    out.add(r.left);
+    out.add(r.right);
+  }
+  return out;
+}
+function parseDisjunction(branches, name) {
+  const guarded = [];
+  const rest = [];
+  for (const b of branches) {
+    const m = unwrap(b).match(IS_NULL);
+    if (m && !m[2]) guarded.push(m[1]);
+    else rest.push(b);
+  }
+  const reduced = (() => {
+    if (!rest.length)
+      return {
+        ok: false,
+        reason: "every branch of the OR is a null test, which is a rule about the row"
+      };
+    if (rest.length === 1) return parseCheck(rest[0], name);
+    return foldDisjunctionToSet(rest, name);
+  })();
+  if (!reduced.ok || !guarded.length) return reduced;
+  if (reduced.nulls?.length)
+    return {
+      ok: false,
+      reason: "a null test guarded by IS NULL, which is true of every row rather than a narrowing"
+    };
+  const named = columnsOf(reduced);
+  const stray = guarded.filter((g) => !named.has(g));
+  if (stray.length)
+    return {
+      ok: false,
+      reason: `${stray.map((s) => `"${s}"`).join(" and ")} IS NULL guards a predicate that does not name it`
+    };
+  return reduced;
+}
+function foldDisjunctionToSet(branches, name) {
+  let column;
+  let kind;
+  const values = [];
+  for (const branch of branches) {
+    const parsed = parseCheck(branch, name);
+    if (!parsed.ok)
+      return { ok: false, reason: `part of an OR was not understood: ${parsed.reason}` };
+    if (parsed.rows?.length)
+      return {
+        ok: false,
+        reason: "a branch of the OR compares two columns, which is a rule about the row"
+      };
+    if (parsed.lengths?.length || parsed.cardinalities?.length)
+      return {
+        ok: false,
+        reason: "a branch of the OR is a count rather than a value, so the OR states no set"
+      };
+    if (parsed.nulls?.length)
+      return { ok: false, reason: "a branch of the OR is a null test rather than a value" };
+    const set = parsed.sets?.[0];
+    const range = parsed.checks.find((c) => c.operator !== "=");
+    if (range)
+      return {
+        ok: false,
+        reason: `a branch of the OR is a range (${range.column} ${range.operator} ${range.value}) rather than a set of values`
+      };
+    if (parsed.checks.length + (parsed.sets?.length ?? 0) !== 1)
+      return { ok: false, reason: "a branch of the OR states more than one thing" };
+    const here = set ? { column: set.column, kind: set.kind, values: set.values } : {
+      column: parsed.checks[0].column,
+      kind: parsed.checks[0].kind,
+      values: [parsed.checks[0].value]
+    };
+    if (column === void 0) {
+      column = here.column;
+      kind = here.kind;
+    }
+    if (here.column !== column)
+      return {
+        ok: false,
+        reason: `the OR branches constrain different columns (${column}, ${here.column}), so it states a rule about the row rather than about a field`
+      };
+    if (here.kind !== kind)
+      return { ok: false, reason: "the OR branches mix a string and a number" };
+    for (const v of here.values) if (!values.includes(v)) values.push(v);
+  }
+  return {
+    ok: true,
+    checks: [],
+    sets: [{ column, values, kind, name }]
+  };
+}
+function parseCheck(expression, name) {
+  const expr = unwrap((expression ?? "").trim());
+  if (!expr) return { ok: false, reason: "empty expression" };
+  if (expr.includes("?")) return { ok: false, reason: "expression contains an unresolved value" };
+  const branches = splitTopLevel(expr, "OR");
+  if (branches.length > 1) return parseDisjunction(branches, name);
+  if (hasLogicalNot(expr)) return { ok: false, reason: "contains NOT" };
+  const between = expr.match(BETWEEN);
+  if (between) {
+    const lo = literal(between[2]);
+    const hi = literal(between[3]);
+    if (!lo || !hi) return { ok: false, reason: "BETWEEN bounds are not literals" };
+    if (lo.kind !== hi.kind) return { ok: false, reason: "BETWEEN bounds are of mixed types" };
+    return {
+      ok: true,
+      checks: [
+        { column: between[1], operator: ">=", value: lo.value, kind: lo.kind, name },
+        { column: between[1], operator: "<=", value: hi.value, kind: hi.kind, name }
+      ]
+    };
+  }
+  const parts = splitTopLevel(expr, "AND");
+  if (parts.length > 1) {
+    const checks = [];
+    const sets = [];
+    const rows = [];
+    const lengths = [];
+    const cardinalities = [];
+    const nulls = [];
+    for (const part of parts) {
+      const parsed = parseCheck(part, name);
+      if (!parsed.ok)
+        return { ok: false, reason: `part of an AND was not understood: ${parsed.reason}` };
+      checks.push(...parsed.checks);
+      if (parsed.sets) sets.push(...parsed.sets);
+      if (parsed.rows) rows.push(...parsed.rows);
+      if (parsed.lengths) lengths.push(...parsed.lengths);
+      if (parsed.cardinalities) cardinalities.push(...parsed.cardinalities);
+      if (parsed.nulls) nulls.push(...parsed.nulls);
+    }
+    return {
+      ok: true,
+      checks,
+      ...sets.length ? { sets } : {},
+      ...rows.length ? { rows } : {},
+      ...lengths.length ? { lengths } : {},
+      ...cardinalities.length ? { cardinalities } : {},
+      ...nulls.length ? { nulls } : {}
+    };
+  }
+  const isNull = expr.match(IS_NULL);
+  if (isNull) {
+    return {
+      ok: true,
+      checks: [],
+      nulls: [{ column: isNull[1], notNull: !!isNull[2], ...name ? { name } : {} }]
+    };
+  }
+  const isDistinct = expr.match(IS_DISTINCT);
+  if (isDistinct) {
+    const value2 = literal(isDistinct[3]);
+    if (!value2) return { ok: false, reason: "the right side of IS DISTINCT FROM is not a literal" };
+    const column = isDistinct[1];
+    const negated = !!isDistinct[2];
+    return {
+      ok: true,
+      checks: [
+        { column, operator: negated ? "=" : "<>", value: value2.value, kind: value2.kind, name }
+      ],
+      ...negated ? { nulls: [{ column, notNull: true, ...name ? { name } : {} }] } : {}
+    };
+  }
+  if (IS_BOOLEAN.test(expr))
+    return { ok: false, reason: "a boolean IS test, whose literal this version does not read" };
+  const lengthOf = expr.match(LENGTH_OF);
+  if (lengthOf) {
+    const op2 = lengthOf[3] === "!=" ? "<>" : lengthOf[3];
+    const unit = lengthOf[1].toLowerCase() === "octet_length" ? "bytes" : "characters";
+    return {
+      ok: true,
+      checks: [],
+      lengths: [{ column: lengthOf[2], operator: op2, value: lengthOf[4], unit, name }]
+    };
+  }
+  const cardinalityOf = expr.match(CARDINALITY_OF);
+  if (cardinalityOf) {
+    const op2 = cardinalityOf[3] === "!=" ? "<>" : cardinalityOf[3];
+    return {
+      ok: true,
+      checks: [],
+      cardinalities: [
+        {
+          column: cardinalityOf[1] ?? cardinalityOf[2],
+          operator: op2,
+          value: cardinalityOf[4],
+          ...name ? { name } : {}
+        }
+      ]
+    };
+  }
+  const inList = expr.match(IN_LIST);
+  if (inList) {
+    const raw = splitTopLevelCommas(inList[2]);
+    const parsedValues = raw.map((r) => literal(r));
+    if (parsedValues.some((v) => !v)) return { ok: false, reason: "IN list holds a non-literal" };
+    const kinds = new Set(parsedValues.map((v) => v.kind));
+    if (kinds.size > 1) return { ok: false, reason: "IN list mixes types" };
+    if (!parsedValues.length) return { ok: false, reason: "IN list is empty" };
+    return {
+      ok: true,
+      checks: [],
+      sets: [
+        {
+          column: inList[1],
+          values: parsedValues.map((v) => v.value),
+          kind: parsedValues[0].kind,
+          name
+        }
+      ]
+    };
+  }
+  const combining = combiningOperator(expr);
+  const arithmetic = () => ({
+    ok: false,
+    reason: `columns combined with "${combining}", which this version does not evaluate`
+  });
+  const cmp = expr.match(COMPARISON);
+  if (!cmp) {
+    if (combining) return arithmetic();
+    return { ok: false, reason: "not a single comparison this version understands" };
+  }
+  const value = literal(cmp[3]);
+  if (!value) {
+    const right = cmp[3].trim();
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(right)) {
+      const op2 = cmp[2] === "!=" ? "<>" : cmp[2];
+      return { ok: true, checks: [], rows: [{ left: cmp[1], right, operator: op2, name }] };
+    }
+    if (combining) return arithmetic();
+    return { ok: false, reason: "right side is not a literal" };
+  }
+  const op = cmp[2] === "!=" ? "<>" : cmp[2];
+  return {
+    ok: true,
+    checks: [{ column: cmp[1], operator: op, value: value.value, kind: value.kind, name }]
+  };
+}
+function wireNumberLiteral(column, value) {
+  return column.tsType === "bigint" && /^-?\d+$/.test(value) ? `${value}n` : value;
+}
+function describeSet(set) {
+  const shown = set.values.map((v) => set.kind === "string" ? `'${v}'` : v).join(", ");
+  return `${set.name ? `${set.name}: ` : ""}${set.column} IN (${shown})`;
+}
+function comparisonWire(c) {
+  if (c.shape || c.arrayDimensions) return "opaque";
+  if (c.tsType === "number") return "number";
+  if (c.tsType === "bigint") return "bigint";
+  if (c.tsType !== "string") return "opaque";
+  return c.dbType === "NUMERIC" || c.dbType === "BIGINT" ? "numeric-string" : "text";
+}
+function canonicalNumericText(text) {
+  const m = /^([+-]?)(\d*)(?:\.(\d*))?$/.exec(text.trim());
+  if (!m || !m[2] && !m[3]) return void 0;
+  const int = (m[2] ?? "").replace(/^0+/, "");
+  const frac = (m[3] ?? "").replace(/0+$/, "");
+  if (!int && !frac) return "0";
+  return (m[1] === "-" ? "-" : "") + (int || "0") + (frac ? "." + frac : "");
+}
+function canonicalMembers(values) {
+  const out = [];
+  for (const v of values) {
+    const c = canonicalNumericText(v);
+    if (c !== void 0 && !out.includes(c)) out.push(c);
+  }
+  return out;
+}
+var NUMERIC_CANON_NAME = "DrzlNumericCanon";
+var NUMERIC_CANON_SOURCE = `/**
+ * The canonical spelling of the plain decimal text a numeric wire carries, or null for anything
+ * else. The driver spells one value many ways by declared scale ('1', '1.00', '1.0000000000',
+ * measured) and the database compares them as numbers, so equality is decided on this form:
+ * sign normalised, leading integer zeros and trailing fraction zeros stripped, a bare trailing
+ * dot dropped. String arithmetic on purpose: Number() is not usable here, because a numeric
+ * column carries more digits than a double holds and rounding would merge values the database
+ * keeps distinct.
+ */
+const ${NUMERIC_CANON_NAME} = (s: string): string | null => {
+  const m = /^([+-]?)(\\d*)(?:\\.(\\d*))?$/.exec(s.trim());
+  if (!m || (!m[2] && !m[3])) return null;
+  const int = (m[2] ?? '').replace(/^0+/, '');
+  const frac = (m[3] ?? '').replace(/0+$/, '');
+  if (!int && !frac) return '0';
+  return (m[1] === '-' ? '-' : '') + (int || '0') + (frac ? '.' + frac : '');
+};
+`;
+function wireLiteralFit(c, q) {
+  const wire = comparisonWire(c);
+  if (wire === "opaque") return { fit: "keep" };
+  if (wire === "text") {
+    if (q.kind === "string") return { fit: "keep" };
+    return {
+      fit: "unenforced",
+      reason: `"${c.name ?? "?"}" is a text column, and the database compares a number literal against it by coercion rules that differ per dialect, which no exact predicate restates`
+    };
+  }
+  const canon = q.values.map((v) => canonicalNumericText(v));
+  const bad = q.values[canon.findIndex((x) => x === void 0)];
+  if (wire === "numeric-string") {
+    if (bad !== void 0)
+      return {
+        fit: "unenforced",
+        reason: `'${bad}' is not plain decimal text, and the driver spells one numeric value many ways, so no exact comparison can be stated`
+      };
+    if (q.comparison === "range") return { fit: "respell", values: canon };
+    return { fit: "canonical", canon: canonicalMembers(q.values) };
+  }
+  if (q.kind === "number") return { fit: "keep" };
+  if (bad !== void 0)
+    return {
+      fit: "unenforced",
+      reason: `'${bad}' is quoted text on a ${wire} wire, and it is not plain decimal, so the numeric comparison the database performs cannot be restated exactly`
+    };
+  return { fit: "respell", values: canonicalMembers(q.values) };
+}
+function applyWirePolicy(columns, checks, sets) {
+  const byName = new Map(columns.map((c) => [c.name, c]));
+  const outChecks = [];
+  const outSets = [];
+  const unenforced = [];
+  for (const k of checks) {
+    const c = byName.get(k.column);
+    if (!c) {
+      outChecks.push(k);
+      continue;
+    }
+    const fit = wireLiteralFit(c, {
+      kind: k.kind,
+      values: [k.value],
+      comparison: k.operator === "=" || k.operator === "<>" ? "equality" : "range"
+    });
+    if (fit.fit === "unenforced") unenforced.push({ column: k.column, reason: fit.reason, check: k });
+    else if (fit.fit === "respell") outChecks.push({ ...k, kind: "number", value: fit.values[0] });
+    else outChecks.push(k);
+  }
+  for (const s of sets) {
+    const c = byName.get(s.column);
+    if (!c) {
+      outSets.push(s);
+      continue;
+    }
+    const fit = wireLiteralFit(c, { kind: s.kind, values: s.values, comparison: "equality" });
+    if (fit.fit === "unenforced") unenforced.push({ column: s.column, reason: fit.reason, set: s });
+    else if (fit.fit === "respell") outSets.push({ ...s, kind: "number", values: fit.values });
+    else outSets.push(s);
+  }
+  return { checks: outChecks, sets: outSets, unenforced };
+}
+function needsNumericCanon(columns, checks, sets) {
+  return columns.some(
+    (c) => comparisonWire(c) === "numeric-string" && (sets.some((s) => s.column === c.name) || checks.some(
+      (k) => k.column === c.name && (k.operator === "=" || k.operator === "<>")
+    ))
+  );
+}
+
 // src/naming.ts
 var NAME_MODES = ["insert", "update", "select"];
 var DEFAULT_MODE_PREFIX = {
@@ -60,8 +596,14 @@ function schemaName(mode, tsName, affix) {
 function typeName(mode, tsName, affix) {
   return affix.type.prefix[mode] + applyTableCase(tsName, affix.tableCase) + affix.type.suffix[mode];
 }
-var PREFIX_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-var SUFFIX_RE = /^[A-Za-z0-9_$]+$/;
+var ID_START = "A-Za-z_$";
+var ID_PART = "A-Za-z0-9_$";
+var PREFIX_BODY = `[${ID_START}][${ID_PART}]*`;
+var SUFFIX_BODY = `[${ID_PART}]+`;
+var PREFIX_RE = new RegExp(`^${PREFIX_BODY}$`);
+var SUFFIX_RE = new RegExp(`^${SUFFIX_BODY}$`);
+var AFFIX_PREFIX_PATTERN = `^(?:${PREFIX_BODY})?$`;
+var AFFIX_SUFFIX_PATTERN = `^(?:${SUFFIX_BODY})?$`;
 function validateAffix(affix, schemaSuffix) {
   const issues = [];
   if (!affix) return issues;
@@ -152,9 +694,9 @@ function buildBrandPlan(tables, opt) {
   }
   const bySqlName = /* @__PURE__ */ new Map();
   for (const t of byTs.values()) {
-    const list = bySqlName.get(t.name) ?? [];
-    list.push(t);
-    bySqlName.set(t.name, list);
+    const list2 = bySqlName.get(t.name) ?? [];
+    list2.push(t);
+    bySqlName.set(t.name, list2);
   }
   const tokens = /* @__PURE__ */ new Map();
   const cache = /* @__PURE__ */ new Map();
@@ -258,222 +800,528 @@ function buildBrandPlan(tables, opt) {
   };
 }
 
-// src/checks.ts
-var COMPARISON = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*(>=|<=|<>|!=|>|<|=)\s*(.+?)\s*$/;
-var IN_LIST = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s+IN\s*\((.+)\)\s*$/i;
-var CARDINALITY_OF = /^\s*(?:cardinality\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)|array_length\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*,\s*1\s*\))\s*(>=|<=|<>|!=|>|<|=)\s*(\d+)\s*$/i;
-var LENGTH_OF = /^\s*(?:length|char_length)\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)\s*(>=|<=|<>|!=|>|<|=)\s*(\d+)\s*$/i;
-function splitTopLevelAnd(expr) {
-  const parts = [];
-  let depth = 0;
-  let inString = false;
-  let start = 0;
-  for (let i = 0; i < expr.length; i++) {
-    const c = expr[i];
-    if (inString) {
-      if (c === "'") {
-        if (expr[i + 1] === "'") i++;
-        else inString = false;
-      }
-      continue;
-    }
-    if (c === "'") {
-      inString = true;
+// src/constraints.ts
+function labelled(name, text) {
+  return name ? `${name}: ${text}` : text;
+}
+function literalText(value, kind) {
+  return kind === "string" ? `'${value}'` : value;
+}
+function columnCheckText(k) {
+  return labelled(k.name, `${k.column} ${k.operator} ${literalText(k.value, k.kind)}`);
+}
+function setText(k) {
+  return labelled(
+    k.name,
+    `${k.column} IN (${k.values.map((v) => literalText(v, k.kind)).join(", ")})`
+  );
+}
+var lengthText = lengthCheckLabel;
+function cardinalityText(k) {
+  return labelled(k.name, `cardinality(${k.column}) ${k.operator} ${k.value}`);
+}
+function rowText(k) {
+  return labelled(k.name, `${k.left} ${k.operator} ${k.right}`);
+}
+function nullText(k) {
+  return labelled(k.name, `${k.column} IS ${k.notNull ? "NOT NULL" : "NULL"}`);
+}
+function shapeArticle(c) {
+  switch (c.shape?.kind) {
+    case "json":
+      return "a JSON";
+    case "buffer":
+      return "a binary";
+    case "numberVector":
+      return "a vector";
+    case "bitstring":
+      return "a bit-string";
+    case "byteString":
+      return "a byte-string";
+    case "custom":
+      return "a customType";
+    default:
+      return "a structured";
+  }
+}
+function takesScalarChecks(c) {
+  return !c.arrayDimensions && !c.shape;
+}
+function foldsIntoBounds(c, k) {
+  if (c.arrayDimensions || c.shape) return false;
+  if (c.tsType !== "number" && c.tsType !== "bigint") return false;
+  return k.kind === "number" && k.operator !== "=" && k.operator !== "<>";
+}
+function statesCap(c, hasSet) {
+  if (c.shape || hasSet) return false;
+  if (c.enumValues && c.enumValues.length) return false;
+  if (c.tsType !== "string") return false;
+  return !c.format;
+}
+function classifyTableChecks(table) {
+  const byName = new Map(table.columns.map((c) => [c.name, c]));
+  const out = [];
+  for (const k of table.checks ?? []) {
+    const expression = (k.expression ?? "").trim();
+    const parsed = parseCheck(k.expression, k.name);
+    if (!parsed.ok) {
+      out.push({
+        ...k.name ? { name: k.name } : {},
+        expression,
+        parts: [
+          {
+            text: labelled(k.name, expression),
+            columns: [],
+            place: "none",
+            reason: parsed.reason
+          }
+        ]
+      });
       continue;
     }
-    if (c === "(") depth++;
-    else if (c === ")") depth--;
-    else if (depth === 0 && /\s/.test(c)) {
-      const m = /^\s+AND\s+/i.exec(expr.slice(i));
-      if (m) {
-        parts.push(expr.slice(start, i));
-        i += m[0].length - 1;
-        start = i + 1;
+    const parts = [];
+    const place = (column, text, guard, guardReason, extra = {}) => {
+      const c = byName.get(column);
+      if (!c) {
+        parts.push({
+          text,
+          columns: [column],
+          place: "none",
+          reason: `"${column}" is not a column of that table`
+        });
+        return;
       }
-    }
-  }
-  parts.push(expr.slice(start));
-  return parts;
-}
-function unwrap(expr) {
-  let e = expr.trim();
-  while (e.startsWith("(") && e.endsWith(")")) {
-    let depth = 0;
-    let inString = false;
-    let wrapsWhole = true;
-    for (let i = 0; i < e.length; i++) {
-      const c = e[i];
-      if (inString) {
-        if (c === "'") {
-          if (e[i + 1] === "'") i++;
-          else inString = false;
-        }
+      if (!guard(c)) {
+        parts.push({ text, columns: [column], place: "none", reason: guardReason(c) });
+        return;
+      }
+      parts.push({ text, columns: [column], place: "column", ...extra });
+    };
+    const notScalar = (c) => c.arrayDimensions ? `"${c.name}" is an array, and the clause describes a scalar` : `"${c.name}" is a structured column, and the clause describes a scalar`;
+    const literalFit = (column, kind, values, comparison) => {
+      const col = byName.get(column);
+      return col ? wireLiteralFit(col, { kind, values, comparison }) : { fit: "keep" };
+    };
+    for (const c of parsed.checks) {
+      const fit = literalFit(
+        c.column,
+        c.kind,
+        [c.value],
+        c.operator === "=" || c.operator === "<>" ? "equality" : "range"
+      );
+      if (fit.fit === "unenforced") {
+        parts.push({
+          text: columnCheckText(c),
+          columns: [c.column],
+          place: "none",
+          reason: fit.reason
+        });
+        continue;
+      }
+      const shown = fit.fit === "respell" ? { ...c, kind: "number", value: fit.values[0] } : c;
+      const col = byName.get(c.column);
+      place(c.column, columnCheckText(shown), takesScalarChecks, notScalar, {
+        ...col && foldsIntoBounds(col, shown) ? { bound: { column: c.column, operator: shown.operator, value: shown.value } } : {}
+      });
+    }
+    for (const s of parsed.sets ?? []) {
+      const fit = literalFit(s.column, s.kind, s.values, "equality");
+      if (fit.fit === "unenforced") {
+        parts.push({ text: setText(s), columns: [s.column], place: "none", reason: fit.reason });
         continue;
       }
-      if (c === "'") inString = true;
-      else if (c === "(") depth++;
-      else if (c === ")") {
-        depth--;
-        if (depth === 0 && i < e.length - 1) {
-          wrapsWhole = false;
-          break;
-        }
+      const shown = fit.fit === "respell" ? { ...s, kind: "number", values: fit.values } : s;
+      place(s.column, setText(shown), takesScalarChecks, notScalar, {
+        set: { column: s.column, values: shown.values, kind: shown.kind }
+      });
+    }
+    for (const l of parsed.lengths ?? []) {
+      place(
+        l.column,
+        lengthText(l),
+        (c) => lengthMeasure(c, l) !== void 0,
+        (c) => c.arrayDimensions ? `"${c.name}" is an array, so it has no ${l.unit === "bytes" ? "bytes" : "characters"} to count` : c.shape ? `"${c.name}" is ${shapeArticle(c)} column, whose ${l.unit === "bytes" ? "byte" : "character"} count in JavaScript is not the one the database took` : `"${c.name}" is not a string, so it has no ${l.unit === "bytes" ? "bytes" : "characters"} to count`
+      );
+    }
+    for (const a of parsed.cardinalities ?? []) {
+      place(
+        a.column,
+        cardinalityText(a),
+        (c) => !!c.arrayDimensions,
+        (c) => `"${c.name}" is not an array, so it has no elements to count`
+      );
+    }
+    for (const n of parsed.nulls ?? []) {
+      const text = nullText(n);
+      if (!byName.has(n.column)) {
+        parts.push({
+          text,
+          columns: [n.column],
+          place: "none",
+          reason: `"${n.column}" is not a column of that table`
+        });
+        continue;
       }
+      parts.push(
+        n.notNull ? { text, columns: [n.column], place: "column", shape: "notNull" } : {
+          text,
+          columns: [n.column],
+          place: "none",
+          reason: "the column may hold only NULL, which these schemas do not narrow it to"
+        }
+      );
     }
-    if (!wrapsWhole) break;
-    e = e.slice(1, -1).trim();
+    for (const r of parsed.rows ?? []) {
+      const text = rowText(r);
+      const missing = [r.left, r.right].filter((n) => !byName.has(n));
+      parts.push(
+        missing.length ? {
+          text,
+          columns: [r.left, r.right],
+          place: "none",
+          reason: `${missing.map((n) => `"${n}"`).join(" and ")} ${missing.length > 1 ? "are not columns" : "is not a column"} of that table`
+        } : { text, columns: [r.left, r.right], place: "row" }
+      );
+    }
+    out.push({ ...k.name ? { name: k.name } : {}, expression, parts });
   }
-  return e;
+  return out;
 }
-function splitTopLevelCommas(list) {
-  const parts = [];
-  let depth = 0;
-  let inString = false;
-  let start = 0;
-  for (let i = 0; i < list.length; i++) {
-    const c = list[i];
-    if (inString) {
-      if (c === "'") {
-        if (list[i + 1] === "'") i++;
-        else inString = false;
+var list = (cols) => cols.join(", ");
+function foreignKeyRule(fk) {
+  const target = fk.foreignSchema ? `${fk.foreignSchema}.${fk.foreignTable}` : fk.foreignTable;
+  return `FOREIGN KEY (${list(fk.columns)}) REFERENCES ${target} (${list(fk.foreignColumns)})` + (fk.onDelete ? ` ON DELETE ${fk.onDelete}` : "") + (fk.onUpdate ? ` ON UPDATE ${fk.onUpdate}` : "");
+}
+function uniquifier() {
+  const seen = /* @__PURE__ */ new Map();
+  return (id) => {
+    const n = seen.get(id) ?? 0;
+    seen.set(id, n + 1);
+    return n === 0 ? id : `${id}_${n + 1}`;
+  };
+}
+function tableConstraints(table) {
+  const out = [];
+  const id = uniquifier();
+  const named = (key, fallback) => key.name ? { id: id(key.name), name: key.name } : { id: id(fallback) };
+  if (table.primaryKey?.columns.length) {
+    const pk = table.primaryKey;
+    out.push({
+      ...named(pk, `${table.name}_pkey`),
+      kind: "primaryKey",
+      columns: [...pk.columns],
+      rule: `PRIMARY KEY (${list(pk.columns)})`,
+      // No per-row validator can check a key: whether a value is already taken is a fact about
+      // the table. `duplicateFinder` checks the half that needs no database, and even that only
+      // answers whether a batch collides with itself.
+      enforced: false
+    });
+  }
+  for (const u of table.unique ?? []) {
+    if (!u.columns.length) continue;
+    out.push({
+      ...named(u, `${table.name}_${u.columns.join("_")}_key`),
+      kind: "unique",
+      columns: [...u.columns],
+      rule: `UNIQUE (${list(u.columns)})`,
+      enforced: false
+    });
+  }
+  for (const fk of table.foreignKeys ?? []) {
+    if (!fk.columns.length) continue;
+    out.push({
+      ...named(fk, `${table.name}_${fk.columns.join("_")}_fkey`),
+      kind: "foreignKey",
+      columns: [...fk.columns],
+      rule: foreignKeyRule(fk),
+      // The referenced row either exists or it does not, and only the database knows.
+      enforced: false,
+      references: {
+        table: fk.foreignTable,
+        ...fk.foreignSchema ? { schema: fk.foreignSchema } : {},
+        columns: [...fk.foreignColumns],
+        ...fk.onDelete ? { onDelete: fk.onDelete } : {},
+        ...fk.onUpdate ? { onUpdate: fk.onUpdate } : {}
       }
-      continue;
+    });
+  }
+  const classified = classifyTableChecks(table);
+  classified.forEach((k, i) => {
+    const columns = [];
+    for (const p of k.parts) for (const c of p.columns) if (!columns.includes(c)) columns.push(c);
+    const messages = k.parts.filter((p) => p.place !== "none" && !p.bound && !p.set && !p.shape).map((p) => p.text);
+    const bounds = k.parts.filter((p) => p.bound).map((p) => p.bound);
+    const set = k.parts.find((p) => p.set)?.set;
+    const unenforced = k.parts.filter((p) => p.place === "none").map((p) => ({ part: p.text, reason: p.reason ?? "not translated" }));
+    out.push({
+      ...k.name ? { id: id(k.name), name: k.name } : { id: id(`${table.name}_check_${i + 1}`) },
+      kind: "check",
+      columns,
+      rule: `CHECK (${k.expression})`,
+      enforced: k.parts.some((p) => p.place !== "none"),
+      ...unenforced.length ? { unenforced } : {},
+      ...messages.length ? { messages } : {},
+      ...bounds.length ? { bounds } : {},
+      ...set ? { values: set } : {}
+    });
+  });
+  const setColumns = new Set(
+    classified.flatMap((k) => k.parts.filter((p) => p.set).map((p) => p.set.column))
+  );
+  for (const c of table.columns) {
+    if (!statesCap(c, setColumns.has(c.name))) continue;
+    if (c.maxLength !== void 0) {
+      const message = `at most ${c.maxLength} characters`;
+      out.push({
+        id: id(`${table.name}_${c.name}_maxlength`),
+        kind: "maxLength",
+        columns: [c.name],
+        rule: message,
+        enforced: true,
+        messages: [message]
+      });
     }
-    if (c === "'") inString = true;
-    else if (c === "(") depth++;
-    else if (c === ")") depth--;
-    else if (c === "," && depth === 0) {
-      parts.push(list.slice(start, i));
-      start = i + 1;
+    if (c.maxBytes !== void 0) {
+      const message = `at most ${c.maxBytes} bytes`;
+      out.push({
+        id: id(`${table.name}_${c.name}_maxbytes`),
+        kind: "maxBytes",
+        columns: [c.name],
+        rule: message,
+        enforced: true,
+        messages: [message]
+      });
     }
   }
-  parts.push(list.slice(start));
-  return parts;
+  return {
+    table: table.name,
+    ...table.schema ? { schema: table.schema } : {},
+    constraints: out
+  };
 }
-var BETWEEN = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s+BETWEEN\s+(.+?)\s+AND\s+(.+?)\s*$/i;
-function literal(raw) {
-  const t = raw.trim();
-  if (/^-?\d+(\.\d+)?$/.test(t)) return { value: t, kind: "number" };
-  const m = t.match(/^'((?:[^']|'')*)'$/);
-  if (m) return { value: m[1].replace(/''/g, "'"), kind: "string" };
-  return void 0;
+function resolveConstraints(opt) {
+  if (!opt) return void 0;
+  if (opt === true) return { errorMap: true };
+  if (opt.enabled === false) return void 0;
+  return { errorMap: opt.errorMap !== false };
 }
-function parseCheck(expression, name) {
-  const expr = unwrap((expression ?? "").trim());
-  if (!expr) return { ok: false, reason: "empty expression" };
-  if (expr.includes("?")) return { ok: false, reason: "expression contains an unresolved value" };
-  if (/(^|[\s)])OR($|[\s(])/i.test(expr)) return { ok: false, reason: "contains OR" };
-  if (/(^|[\s(])NOT($|[\s(])/i.test(expr)) return { ok: false, reason: "contains NOT" };
-  const between = expr.match(BETWEEN);
-  if (between) {
-    const lo = literal(between[2]);
-    const hi = literal(between[3]);
-    if (!lo || !hi) return { ok: false, reason: "BETWEEN bounds are not literals" };
-    if (lo.kind !== hi.kind) return { ok: false, reason: "BETWEEN bounds are of mixed types" };
-    return {
-      ok: true,
-      checks: [
-        { column: between[1], operator: ">=", value: lo.value, kind: lo.kind, name },
-        { column: between[1], operator: "<=", value: hi.value, kind: hi.kind, name }
-      ]
-    };
+var CONSTRAINTS_MODULE = "constraints.ts";
+var TYPES = `/** What a constraint is. */
+export type DrzlConstraintKind =
+  | 'primaryKey'
+  | 'unique'
+  | 'foreignKey'
+  | 'check'
+  | 'maxLength'
+  | 'maxBytes';
+
+/** One constraint on one table. */
+export interface DrzlConstraint {
+  /** Stable within the table. The SQL constraint name where the declaration has one. */
+  id: string;
+  /** The SQL constraint name, absent where the declaration did not give one. */
+  name?: string;
+  kind: DrzlConstraintKind;
+  /** The columns the constraint is about, in declaration order. */
+  columns: string[];
+  /** The rule as a sentence, for a form with nothing better to show. */
+  rule: string;
+  /** Whether a generated schema can reject a row for this constraint. */
+  enforced: boolean;
+  /** The clauses nothing in these schemas checks, and why. */
+  unenforced?: { part: string; reason: string }[];
+  /** The exact messages the generated schemas attach for this constraint. */
+  messages?: string[];
+  /** Bounds folded into a column's range, which is where the constraint name is lost. */
+  bounds?: { column: string; operator: string; value: string }[];
+  /** A set of literals folded into an enum, which is the other place it is lost. */
+  values?: { column: string; values: string[]; kind: 'number' | 'string' };
+  /** Where a foreign key points. */
+  references?: {
+    table: string;
+    schema?: string;
+    columns: string[];
+    onDelete?: string;
+    onUpdate?: string;
+  };
+}
+
+/** Every constraint on one table. */
+export interface DrzlTableConstraints {
+  /** The SQL table name, which is not the Drizzle export name this is exported under. */
+  table: string;
+  /** The SQL schema, present only when the table names one. */
+  schema?: string;
+  constraints: DrzlConstraint[];
+}`;
+var MATCHER = `/** A validation issue traced back to the constraint that caused it. */
+export interface DrzlConstraintMatch {
+  constraint: DrzlConstraint;
+  /**
+   * The column to put the message on.
+   *
+   * Taken from the issue where the library named one, and from the constraint where it did not.
+   * Valibot reports a row-level check with an empty path, so without the fallback a form would
+   * have a message and nowhere to show it.
+   */
+  column?: string;
+  /**
+   * How the constraint was identified.
+   *
+   * \`message\` is an exact match on a string these schemas wrote, and is the only tier that is
+   * certain. \`bound\` matched the numeric bound the library put on the issue against a bound this
+   * constraint folded, which is what a folded CHECK leaves to match on once its name is gone.
+   * \`column\` is the last resort: the column has exactly one constraint stated in the validator's
+   * own vocabulary, so nothing else on the issue can be wrong about which.
+   */
+  matchedBy: 'message' | 'bound' | 'column';
+}
+
+/**
+ * The column an issue is about, across the path shapes these libraries use.
+ *
+ * zod and ArkType spell a path item as the key itself; valibot spells it as an object carrying
+ * one. The last key is taken rather than the first, so an issue inside an array or a nested
+ * payload names the field rather than the collection holding it.
+ */
+function drzlIssueColumn(issue: any): string | undefined {
+  const path = issue?.path;
+  if (!Array.isArray(path)) return undefined;
+  for (let i = path.length - 1; i >= 0; i--) {
+    const item: any = path[i];
+    if (typeof item === 'string') return item;
+    if (item && typeof item === 'object' && typeof item.key === 'string') return item.key;
   }
-  const parts = splitTopLevelAnd(expr);
-  if (parts.length > 1) {
-    const checks = [];
-    const sets = [];
-    const rows = [];
-    const lengths = [];
-    const cardinalities = [];
-    for (const part of parts) {
-      const parsed = parseCheck(part, name);
-      if (!parsed.ok)
-        return { ok: false, reason: `part of an AND was not understood: ${parsed.reason}` };
-      checks.push(...parsed.checks);
-      if (parsed.sets) sets.push(...parsed.sets);
-      if (parsed.rows) rows.push(...parsed.rows);
-      if (parsed.lengths) lengths.push(...parsed.lengths);
-      if (parsed.cardinalities) cardinalities.push(...parsed.cardinalities);
-    }
-    return {
-      ok: true,
-      checks,
-      ...sets.length ? { sets } : {},
-      ...rows.length ? { rows } : {},
-      ...lengths.length ? { lengths } : {},
-      ...cardinalities.length ? { cardinalities } : {}
-    };
+  return undefined;
+}
+
+/**
+ * The numeric bound an issue reports, as a decimal string, or nothing.
+ *
+ * Measured rather than guessed: zod 4.4.3 puts \`minimum\`/\`maximum\` on a \`too_small\`/\`too_big\`
+ * issue and valibot 1.4.2 puts \`requirement\` on a \`min_value\`/\`max_value\` one. A bigint bound
+ * is read too, since a 64 bit column's range is not representable as a number.
+ */
+function drzlIssueBound(issue: any): string | undefined {
+  for (const key of ['minimum', 'maximum', 'requirement']) {
+    const v = issue?.[key];
+    if (typeof v === 'number' || typeof v === 'bigint') return String(v);
   }
-  const lengthOf = expr.match(LENGTH_OF);
-  if (lengthOf) {
-    const op2 = lengthOf[2] === "!=" ? "<>" : lengthOf[2];
-    return {
-      ok: true,
-      checks: [],
-      lengths: [{ column: lengthOf[1], operator: op2, value: lengthOf[3], name }]
-    };
+  return undefined;
+}
+
+/**
+ * The constraint a validation issue came from, or nothing.
+ *
+ * Three tiers, because a constraint does not always survive into the issue in the same form. Every
+ * constraint stated as a predicate carries a message these schemas wrote, and that is an exact
+ * lookup. A numeric CHECK is deliberately folded into the column's own range instead, so the
+ * failure is worded by the library and the constraint name is nowhere in it; the bound is, and it
+ * is matched on that. A set constraint becomes an enum and leaves neither, so it is resolved by
+ * the column alone, which is safe only because a column can carry one such constraint at most.
+ *
+ * The two folds are kept apart rather than pooled, and that is what stops the third tier
+ * over-claiming. A folded bound always reports its bound, in every library measured, so an issue
+ * on that column carrying **no** bound is not that constraint: it is the field failing to be a
+ * number at all. Pooling them answered \`invalid_type\` on a column with a numeric CHECK with the
+ * CHECK, which is a rule the row did not break.
+ *
+ * Returns nothing rather than a guess, for the same reason. A \`too_small\` reporting the column's
+ * own type bound has no matching constraint and gets no answer.
+ */
+export function constraintForIssue(
+  table: string,
+  issue: unknown
+): DrzlConstraintMatch | undefined {
+  const ledger = constraintsByTable[table];
+  if (!ledger) return undefined;
+  const raw: any = issue;
+  const column = drzlIssueColumn(raw);
+  const message = typeof raw?.message === 'string' ? raw.message : undefined;
+
+  if (message !== undefined) {
+    for (const constraint of ledger.constraints) {
+      if (!constraint.messages || constraint.messages.indexOf(message) < 0) continue;
+      if (column !== undefined && constraint.columns.indexOf(column) < 0) continue;
+      return {
+        constraint,
+        column: column ?? constraint.columns[0],
+        matchedBy: 'message',
+      };
+    }
   }
-  const cardinalityOf = expr.match(CARDINALITY_OF);
-  if (cardinalityOf) {
-    const op2 = cardinalityOf[3] === "!=" ? "<>" : cardinalityOf[3];
-    return {
-      ok: true,
-      checks: [],
-      cardinalities: [
-        {
-          column: cardinalityOf[1] ?? cardinalityOf[2],
-          operator: op2,
-          value: cardinalityOf[4],
-          ...name ? { name } : {}
-        }
-      ]
-    };
+
+  if (column === undefined) return undefined;
+
+  const bound = drzlIssueBound(raw);
+  if (bound !== undefined) {
+    const hit = ledger.constraints.find(
+      (c) => c.bounds && c.bounds.some((b) => b.column === column && b.value === bound)
+    );
+    return hit ? { constraint: hit, column, matchedBy: 'bound' } : undefined;
   }
-  const inList = expr.match(IN_LIST);
-  if (inList) {
-    const raw = splitTopLevelCommas(inList[2]);
-    const parsedValues = raw.map((r) => literal(r));
-    if (parsedValues.some((v) => !v)) return { ok: false, reason: "IN list holds a non-literal" };
-    const kinds = new Set(parsedValues.map((v) => v.kind));
-    if (kinds.size > 1) return { ok: false, reason: "IN list mixes types" };
-    if (!parsedValues.length) return { ok: false, reason: "IN list is empty" };
+
+  const sets = ledger.constraints.filter((c) => c.values && c.values.column === column);
+  return sets.length === 1 ? { constraint: sets[0], column, matchedBy: 'column' } : undefined;
+}`;
+function constName(tsName) {
+  const safe = tsName.replace(/[^A-Za-z0-9_$]/g, "_");
+  return `${/^[0-9]/.test(safe) ? `_${safe}` : safe}Constraints`;
+}
+function renderConstraintsModule(tables, opts = {}) {
+  const entries = tables.map((t) => ({ tsName: t.tsName, facts: tableConstraints(t) }));
+  const consts = entries.map(
+    (e) => `/** Every constraint on \`${e.facts.table}\`. */
+export const ${constName(e.tsName)}: DrzlTableConstraints = ${JSON.stringify(e.facts, null, 2)};`
+  ).join("\n\n");
+  const record = `/** Every table's constraints, keyed by the Drizzle export name its schemas are named after. */
+export const constraintsByTable: Record<string, DrzlTableConstraints> = {
+` + entries.map((e) => `  ${JSON.stringify(e.tsName)}: ${constName(e.tsName)},`).join("\n") + `
+};`;
+  return [
+    "/**",
+    " * Every CHECK, unique constraint, primary and foreign key on each table, as data.",
+    " *",
+    " * Generated beside the schemas rather than derived from them: a validator states what a value",
+    " * must look like and says nothing about which constraint said so, and the two constraints a",
+    " * per-row schema cannot check at all, uniqueness and a foreign key, are not in it in any form.",
+    " */",
+    TYPES,
+    consts,
+    record,
+    ...opts.errorMap ? [MATCHER] : []
+  ].join("\n\n");
+}
+
+// src/emit.ts
+var realFs = null;
+function nodeFs() {
+  return realFs ??= import("fs/promises");
+}
+function fileWriter(sink) {
+  if (!sink) {
     return {
-      ok: true,
-      checks: [],
-      sets: [
-        {
-          column: inList[1],
-          values: parsedValues.map((v) => v.value),
-          kind: parsedValues[0].kind,
-          name
-        }
-      ]
+      async mkdir(dir, options) {
+        return (await nodeFs()).mkdir(dir, options);
+      },
+      async writeFile(file, contents, encoding = "utf8") {
+        return (await nodeFs()).writeFile(file, contents, encoding);
+      }
     };
   }
-  const cmp = expr.match(COMPARISON);
-  if (!cmp) return { ok: false, reason: "not a single comparison this version understands" };
-  const value = literal(cmp[3]);
-  if (!value) {
-    const right = cmp[3].trim();
-    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(right)) {
-      const op2 = cmp[2] === "!=" ? "<>" : cmp[2];
-      return { ok: true, checks: [], rows: [{ left: cmp[1], right, operator: op2, name }] };
-    }
-    return { ok: false, reason: "right side is not a literal" };
-  }
-  const op = cmp[2] === "!=" ? "<>" : cmp[2];
   return {
-    ok: true,
-    checks: [{ column: cmp[1], operator: op, value: value.value, kind: value.kind, name }]
+    async mkdir(dir) {
+      await sink.mkdir(dir);
+      return void 0;
+    },
+    async writeFile(file, contents) {
+      await sink.writeFile(file, contents);
+    }
   };
 }
-function describeSet(set) {
-  const shown = set.values.map((v) => set.kind === "string" ? `'${v}'` : v).join(", ");
-  return `${set.name ? `${set.name}: ` : ""}${set.column} IN (${shown})`;
-}
 
 // src/files.ts
-import nodeFs from "fs";
+import nodeFs2 from "fs";
 import nodePath from "path";
 var IMPORT_EXTENSIONS = ["js", "none", "ts"];
 var DEFAULT_IMPORT_EXTENSION = "js";
@@ -517,10 +1365,10 @@ function isPackageSpecifier(p) {
 }
 function pointsAtDirectory(absPath) {
   try {
-    return nodeFs.statSync(absPath).isDirectory();
+    return nodeFs2.statSync(absPath).isDirectory();
   } catch {
     for (const ext of [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs"]) {
-      if (nodeFs.existsSync(`${absPath}${ext}`)) return false;
+      if (nodeFs2.existsSync(`${absPath}${ext}`)) return false;
     }
     return !/\.[a-z]+$/i.test(nodePath.basename(absPath));
   }
@@ -532,62 +1380,24 @@ function withTsExtension(p) {
 }
 
 // src/meta.ts
-function labelled(name, text) {
-  return name ? `${name}: ${text}` : text;
-}
-function literalText(value, kind) {
-  return kind === "string" ? `'${value}'` : value;
-}
-function columnCheckText(k) {
-  return labelled(k.name, `${k.column} ${k.operator} ${literalText(k.value, k.kind)}`);
-}
-function setText(k) {
-  return labelled(
-    k.name,
-    `${k.column} IN (${k.values.map((v) => literalText(v, k.kind)).join(", ")})`
-  );
-}
-function lengthText(k) {
-  return labelled(k.name, `length(${k.column}) ${k.operator} ${k.value}`);
-}
-function cardinalityText(k) {
-  return labelled(k.name, `cardinality(${k.column}) ${k.operator} ${k.value}`);
-}
-function rowText(k) {
-  return labelled(k.name, `${k.left} ${k.operator} ${k.right}`);
-}
-function takesScalarChecks(c) {
-  return !c.arrayDimensions && !c.shape;
-}
 function classifyChecks(table) {
   const perColumn = /* @__PURE__ */ new Map();
   const rows = [];
   const unenforced = [];
-  const byName = new Map(table.columns.map((c) => [c.name, c]));
-  const add = (column, text, guard) => {
-    const c = byName.get(column);
-    if (!c || !guard(c)) {
-      unenforced.push(text);
-      return;
-    }
-    const list = perColumn.get(column) ?? [];
-    list.push(text);
-    perColumn.set(column, list);
-  };
-  for (const k of table.checks ?? []) {
-    const parsed = parseCheck(k.expression, k.name);
-    if (!parsed.ok) {
-      unenforced.push(labelled(k.name, (k.expression ?? "").trim()));
-      continue;
-    }
-    for (const c of parsed.checks) add(c.column, columnCheckText(c), takesScalarChecks);
-    for (const s of parsed.sets ?? []) add(s.column, setText(s), takesScalarChecks);
-    for (const l of parsed.lengths ?? []) add(l.column, lengthText(l), takesScalarChecks);
-    for (const a of parsed.cardinalities ?? [])
-      add(a.column, cardinalityText(a), (c) => !!c.arrayDimensions);
-    for (const r of parsed.rows ?? []) {
-      if (byName.has(r.left) && byName.has(r.right)) rows.push(rowText(r));
-      else unenforced.push(rowText(r));
+  for (const check of classifyTableChecks(table)) {
+    for (const part of check.parts) {
+      if (part.place === "none") {
+        unenforced.push(part.text);
+        continue;
+      }
+      if (part.place === "row") {
+        rows.push(part.text);
+        continue;
+      }
+      const column = part.columns[0];
+      const list2 = perColumn.get(column) ?? [];
+      list2.push(part.text);
+      perColumn.set(column, list2);
     }
   }
   return { perColumn, rows, unenforced };
@@ -732,7 +1542,13 @@ function nestedNodeColumns(columnsForMode, node) {
 
 // src/duplicates.ts
 function usableKeys(table) {
-  return (table.unique ?? []).filter((k) => k.columns.length > 0);
+  const keys = [];
+  const pk = table.primaryKey;
+  if (pk && pk.columns.length > 0) {
+    keys.push({ name: pk.name ?? `${table.name}_pkey`, columns: pk.columns });
+  }
+  keys.push(...(table.unique ?? []).filter((k) => k.columns.length > 0));
+  return keys;
 }
 function renderDuplicateFinder(table, fnName, rowType) {
   const keys = usableKeys(table);
@@ -742,14 +1558,15 @@ function renderDuplicateFinder(table, fnName, rowType) {
     return `  { name: ${JSON.stringify(name)}, columns: ${JSON.stringify(k.columns)} }${i === keys.length - 1 ? "" : ","}`;
   }).join("\n");
   return `/**
- * Rows in \`rows\` that collide with an earlier row on a unique constraint.
+ * Rows in \`rows\` that collide with an earlier row on the primary key or a unique constraint.
  *
  * Uniqueness is a fact about the table rather than about a row, so no schema can check it. This
  * checks the half that needs no database: whether the batch collides with itself. A batch that
  * passes here can still collide with rows already stored.
  *
  * A constraint is skipped for any row where one of its columns is null or absent, matching SQL,
- * where NULL is not equal to NULL and a unique index therefore permits repeats.
+ * where NULL is not equal to NULL and a unique index therefore permits repeats. Rows that leave
+ * a generated primary key to the database therefore report nothing on it.
  */
 export function ${fnName}(
   rows: readonly ${rowType}[]
@@ -786,7 +1603,48 @@ var COLUMN_FORMATS = {
   // Sign, decimals, exponents, NaN/Infinity, surrounding whitespace, and the underscore digit
   // separators and 0x/0o/0b integer literals Postgres 16 added. Agrees with Postgres on all 43
   // probes, `1_000` and `0xDEAD_beef` through to `1__0`, `_1`, `0x` and `1e+`.
-  numeric: "^\\s*([+-]?(0[xX][0-9a-fA-F](_?[0-9a-fA-F])*|0[oO][0-7](_?[0-7])*|0[bB][01](_?[01])*)|[+-]?(\\d(_?\\d)*(\\.(\\d(_?\\d)*)?)?|\\.\\d(_?\\d)*)([eE][+-]?\\d(_?\\d)*)?|[+-]?(NaN|Infinity))\\s*$"
+  numeric: "^\\s*([+-]?(0[xX][0-9a-fA-F](_?[0-9a-fA-F])*|0[oO][0-7](_?[0-7])*|0[bB][01](_?[01])*)|[+-]?(\\d(_?\\d)*(\\.(\\d(_?\\d)*)?)?|\\.\\d(_?\\d)*)([eE][+-]?\\d(_?\\d)*)?|[+-]?(NaN|Infinity))\\s*$",
+  // What Postgres itself parses into a `bigint`, for a `bigint({ mode: 'string' })` column whose
+  // value goes to the server as text. `int8in` is a pure integer parser: an optional sign against
+  // the digits, decimal or a `0x`/`0o`/`0b` literal, single `_` separators between digits and one
+  // permitted directly after the base prefix, leading zeros, and surrounding whitespace. Measured
+  // against a real Postgres through PGlite over 16160 probes, boundary sweeps and random shapes:
+  // **zero** values the server takes and this refuses.
+  //
+  // Two things it deliberately does not say.
+  //
+  // **The magnitude.** Every one of the 4474 probes this admits and the server refuses is a value
+  // outside the signed 64 bit range, and nothing else: the syntax half is complete. The exact
+  // bound is expressible, since leading zeros and separators make it a per-digit ladder rather
+  // than a digit count, and it was built and verified at 16160/16160 against the server. It is
+  // not shipped, because at 1237 characters and around twenty alternation branches it exhausts
+  // ArkType's type-level instantiation budget: that generator states a format as a regex literal
+  // inside the type expression, and the emitted module then fails to compile with TS2589.
+  // Measured on arktype 2.2.3, this 101-character pattern compiles and the ladder does not, as
+  // `COLUMN_FORMATS.numeric` at 176 characters already does not. Emitting a module that does not
+  // typecheck is a worse failure than the bound it would buy, and the bound is unreachable by any
+  // value the probe pools carry. The ArkType defect is already reported and carved out of the
+  // parity gate's typecheck stage; when it is fixed, the ladder is what goes here.
+  //
+  // **Whitespace exactly.** Postgres pads with C `isspace`, which is the six ASCII characters, and
+  // JS `\s` also admits NBSP and the Unicode spaces. That admits a handful of strings the server
+  // refuses, which is the safe direction, and it is what `numeric` above already does.
+  pgBigint: "^\\s*[+-]?(\\d(_?\\d)*|0[xX]_?[\\da-fA-F](_?[\\da-fA-F])*|0[oO]_?[0-7](_?[0-7])*|0[bB]_?[01](_?[01])*)\\s*$",
+  // The same column on MySQL, which parses it as a *decimal number* and then rounds. Measured
+  // against MySQL 8.4.11: `'12.5'` stores 13, `'1.5'` stores 2, `'.5'` stores 1, `'1e3'` stores
+  // 1000, and `'92233720368547758070e-1'` stores the int64 maximum. It refuses the two spellings
+  // Postgres takes, `'0x1f'` and `'1_000'`, both as "Data truncated". So no single pattern serves
+  // both servers: their union admits `'12.5'` on Postgres, which is one of the fourteen values
+  // that made this a defect, and their intersection turns away values each server really stores.
+  //
+  // Shared by the signed and the unsigned spelling, and this is why neither magnitude nor sign is
+  // stated here: the value the range applies to is the *rounded* one, so the text does not
+  // determine whether it fits. `'9223372036854775807.4'` is stored and `'9223372036854775807.6'`
+  // is refused; on a `bigint unsigned`, `'-0.4'` and `'-1e-1'` are both stored as 0 while `'-0.5'`
+  // is refused. A pattern cannot do that arithmetic, and guessing at it turns away working rows.
+  // Over 3319 probes against each of a signed and an unsigned column: zero values the server takes
+  // and this refuses.
+  mysqlBigint: "^\\s*[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d*)?\\s*$"
 };
 var COERCIBLE_DATE_STRING = "^(?!\\s*[+-])(?!\\s*\\d*\\.?\\d*(?:[eE][+-]?\\d+)?\\s*$)";
 function parsesToADate(expr) {
@@ -801,15 +1659,39 @@ function nonFiniteAccepted(c) {
   if (c.tsType !== "number" || c.shape) return { nan: false, infinity: false };
   return { nan: c.allowsNaN === true, infinity: c.allowsInfinity === true };
 }
+function nonFiniteRefused(c) {
+  if (c.tsType !== "number" || c.shape) return { nan: false, infinity: false };
+  return { nan: c.allowsNaN === false, infinity: c.allowsInfinity === false };
+}
+function notNullByCheck(table) {
+  const out = /* @__PURE__ */ new Set();
+  for (const k of table.checks ?? []) {
+    const parsed = parseCheck(k.expression, k.name);
+    if (!parsed.ok) continue;
+    for (const n of parsed.nulls ?? []) if (n.notNull) out.add(n.column);
+  }
+  return out;
+}
+function withCheckNullability(table, cols) {
+  const notNull = notNullByCheck(table);
+  if (!notNull.size) return cols;
+  return cols.map((c) => c.nullable && notNull.has(c.name) ? { ...c, nullable: false } : c);
+}
 function insertColumns(table) {
-  return table.columns.filter((c) => !isGeneratedColumn(c));
+  return withCheckNullability(
+    table,
+    table.columns.filter((c) => !isGeneratedColumn(c))
+  );
 }
 function updateColumns(table) {
   const pkCols = table.primaryKey?.columns ?? [];
-  return table.columns.filter((c) => !isGeneratedColumn(c) && !pkCols.includes(c.name));
+  return withCheckNullability(
+    table,
+    table.columns.filter((c) => !isGeneratedColumn(c) && !pkCols.includes(c.name))
+  );
 }
 function selectColumns(table) {
-  return table.columns;
+  return withCheckNullability(table, table.columns);
 }
 var reportedEngines = /* @__PURE__ */ new Set();
 var ENGINE_PACKAGE = { prettier: "prettier", biome: "@biomejs/biome" };
@@ -835,11 +1717,30 @@ function nearestExistingDir(from) {
     dir = parent;
   }
 }
+function isProjectInstallPath(manifestPath) {
+  return manifestPath.split(path.sep).includes("node_modules");
+}
+function biomeManifest(startDir) {
+  const anchors = [startDir, process.cwd()];
+  let lastError;
+  for (const anchor of anchors) {
+    let resolved;
+    try {
+      const require_ = createRequire(pathToFileURL(path.join(anchor, "noop.js")));
+      resolved = require_.resolve("@biomejs/biome/package.json");
+    } catch (err) {
+      lastError = err;
+      continue;
+    }
+    if (isProjectInstallPath(resolved)) return resolved;
+    lastError = new Error(
+      `@biomejs/biome resolved to ${resolved}, which is not part of this project's installed dependencies. Add @biomejs/biome to the project to format with it.`
+    );
+  }
+  throw lastError ?? new Error("@biomejs/biome could not be resolved");
+}
 function biomeBinary(startDir) {
-  const require_ = createRequire(pathToFileURL(path.join(startDir, "noop.js")));
-  const manifestPath = require_.resolve("@biomejs/biome/package.json", {
-    paths: [startDir, process.cwd()]
-  });
+  const manifestPath = biomeManifest(startDir);
   const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
   const relative = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.biome;
   if (typeof relative !== "string") {
@@ -907,10 +1808,13 @@ async function formatCode(code, filePath, fmt) {
   return code;
 }
 export {
+  AFFIX_PREFIX_PATTERN,
   AFFIX_PROBE_TABLE,
+  AFFIX_SUFFIX_PATTERN,
   CODEPOINT_LENGTH,
   COERCIBLE_DATE_STRING,
   COLUMN_FORMATS,
+  CONSTRAINTS_MODULE,
   DEFAULT_IMPORT_EXTENSION,
   DEFAULT_MODE_PREFIX,
   DEFAULT_NESTED_DEPTH,
@@ -920,35 +1824,54 @@ export {
   MAX_NESTED_DEPTH,
   NAME_MODES,
   NESTED_PREFIX,
+  NUMERIC_CANON_NAME,
+  NUMERIC_CANON_SOURCE,
   applyTableCase,
+  applyWirePolicy,
   buildBrandPlan,
   buildNestedPlan,
+  canonicalMembers,
+  canonicalNumericText,
+  classifyTableChecks,
   columnMetaFacts,
+  comparisonWire,
   describeSet,
+  fileWriter,
   formatCode,
   importSpecifier,
   insertColumns,
   isGeneratedColumn,
   isIntegerColumn,
+  isProjectInstallPath,
+  lengthCheckLabel,
+  lengthMeasure,
+  measureExpression,
   moduleFileName,
   moduleSpecifier,
+  needsNumericCanon,
   nestedArmNotes,
   nestedNodeColumns,
   nestedSchemaName,
   nestedTypeName,
   nonFiniteAccepted,
+  nonFiniteRefused,
   parseCheck,
   parsesToADate,
   pascalCase,
+  renderConstraintsModule,
   renderDuplicateFinder,
   resolveAffix,
   resolveBranding,
   resolveConfiguredImport,
+  resolveConstraints,
   resolveNestedDepth,
   schemaName,
   selectColumns,
+  tableConstraints,
   tableMetaFacts,
   typeName,
   updateColumns,
-  validateAffix
+  validateAffix,
+  wireLiteralFit,
+  wireNumberLiteral
 };