@drzl/validation-core 3.18.0 → 3.22.0

package/dist/index.js

@@ -6,11 +6,34 @@ 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)\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)\s*(>=|<=|<>|!=|>|<|=)\s*(\d+)\s*$/i;
-function splitTopLevelAnd(expr) {
+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;
@@ -30,18 +53,64 @@ function splitTopLevelAnd(expr) {
     }
     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;
-      }
+    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(")")) {
@@ -72,16 +141,16 @@ function unwrap(expr) {
   }
   return e;
 }
-function splitTopLevelCommas(list) {
+function splitTopLevelCommas(list2) {
   const parts = [];
   let depth = 0;
   let inString = false;
   let start = 0;
-  for (let i = 0; i < list.length; i++) {
-    const c = list[i];
+  for (let i = 0; i < list2.length; i++) {
+    const c = list2[i];
     if (inString) {
       if (c === "'") {
-        if (list[i + 1] === "'") i++;
+        if (list2[i + 1] === "'") i++;
         else inString = false;
       }
       continue;
@@ -90,14 +159,17 @@ function splitTopLevelCommas(list) {
     else if (c === "(") depth++;
     else if (c === ")") depth--;
     else if (c === "," && depth === 0) {
-      parts.push(list.slice(start, i));
+      parts.push(list2.slice(start, i));
       start = i + 1;
     }
   }
-  parts.push(list.slice(start));
+  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" };
@@ -105,12 +177,111 @@ function literal(raw) {
   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" };
-  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 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]);
@@ -125,13 +296,14 @@ function parseCheck(expression, name) {
       ]
     };
   }
-  const parts = splitTopLevelAnd(expr);
+  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)
@@ -141,6 +313,7 @@ function parseCheck(expression, name) {
       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,
@@ -148,16 +321,42 @@ function parseCheck(expression, name) {
       ...sets.length ? { sets } : {},
       ...rows.length ? { rows } : {},
       ...lengths.length ? { lengths } : {},
-      ...cardinalities.length ? { cardinalities } : {}
+      ...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[2] === "!=" ? "<>" : lengthOf[2];
+    const op2 = lengthOf[3] === "!=" ? "<>" : lengthOf[3];
+    const unit = lengthOf[1].toLowerCase() === "octet_length" ? "bytes" : "characters";
     return {
       ok: true,
       checks: [],
-      lengths: [{ column: lengthOf[1], operator: op2, value: lengthOf[3], name }]
+      lengths: [{ column: lengthOf[2], operator: op2, value: lengthOf[4], unit, name }]
     };
   }
   const cardinalityOf = expr.match(CARDINALITY_OF);
@@ -197,8 +396,16 @@ function parseCheck(expression, 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) return { ok: false, reason: "not a single comparison this version understands" };
+  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();
@@ -206,6 +413,7 @@ function parseCheck(expression, name) {
       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];
@@ -214,68 +422,123 @@ function parseCheck(expression, name) {
     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})`;
 }
-
-// src/files.ts
-import nodeFs from "fs";
-import nodePath from "path";
-var IMPORT_EXTENSIONS = ["js", "none", "ts"];
-var DEFAULT_IMPORT_EXTENSION = "js";
-var TS_EXTENSIONS = [
-  { ext: ".mts", js: ".mjs", none: ".mjs" },
-  { ext: ".cts", js: ".cjs", none: ".cjs" },
-  { ext: ".tsx", js: ".js", none: "" },
-  { ext: ".ts", js: ".js", none: "" }
-];
-function moduleFileName(tsName, fileSuffix) {
-  return `${tsName}${fileSuffix}`;
+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 importSpecifier(relativePath, importExtension = DEFAULT_IMPORT_EXTENSION) {
-  for (const { ext, js, none } of TS_EXTENSIONS) {
-    if (!relativePath.endsWith(ext)) continue;
-    const stem = relativePath.slice(0, -ext.length);
-    if (importExtension === "ts") return relativePath;
-    return `${stem}${importExtension === "none" ? none : js}`;
-  }
-  return relativePath;
-}
-function moduleSpecifier(tsName, fileSuffix, importExtension = DEFAULT_IMPORT_EXTENSION) {
-  return importSpecifier(`./${moduleFileName(tsName, fileSuffix)}`, importExtension);
+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 resolveConfiguredImport(configured, outDirAbs, cwd, importExtension = DEFAULT_IMPORT_EXTENSION) {
-  if (isPackageSpecifier(configured)) return configured;
-  const targetAbs = nodePath.isAbsolute(configured) ? configured : nodePath.resolve(configured.startsWith(".") ? outDirAbs : cwd, configured);
-  const withIndex = pointsAtDirectory(targetAbs) ? `${configured}/index` : configured;
-  if (configured.startsWith(".")) {
-    return importSpecifier(withTsExtension(withIndex), importExtension);
+function canonicalMembers(values) {
+  const out = [];
+  for (const v of values) {
+    const c = canonicalNumericText(v);
+    if (c !== void 0 && !out.includes(c)) out.push(c);
   }
-  const resolved = pointsAtDirectory(targetAbs) ? nodePath.join(targetAbs, "index") : targetAbs;
-  const rel = nodePath.relative(outDirAbs, resolved).split(nodePath.sep).join("/");
-  const prefixed = !rel ? "." : rel.startsWith(".") ? rel : `./${rel}`;
-  return importSpecifier(withTsExtension(prefixed), importExtension);
+  return out;
 }
-function isPackageSpecifier(p) {
-  if (p.startsWith(".") || nodePath.isAbsolute(p)) return false;
-  if (p.startsWith("@") || p.includes(":")) return true;
-  return !p.includes("/");
+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 pointsAtDirectory(absPath) {
-  try {
-    return nodeFs.statSync(absPath).isDirectory();
-  } catch {
-    for (const ext of [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs"]) {
-      if (nodeFs.existsSync(`${absPath}${ext}`)) return false;
+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;
     }
-    return !/\.[a-z]+$/i.test(nodePath.basename(absPath));
+    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 withTsExtension(p) {
-  if (/\.(ts|tsx|mts|cts)$/.test(p)) return p;
-  if (/\.(js|mjs|cjs)$/.test(p)) return p.replace(/\.(js|mjs|cjs)$/, ".ts");
-  return `${p}.ts`;
+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
@@ -333,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;
@@ -384,7 +653,808 @@ function validateAffix(affix, schemaSuffix) {
   return issues;
 }
 
+// src/branding.ts
+function resolveBranding(opt) {
+  if (!opt) return void 0;
+  if (opt === true) return { foreignKeys: true, aliases: true };
+  if (opt.enabled === false) return void 0;
+  return { foreignKeys: opt.foreignKeys !== false, aliases: opt.aliases !== false };
+}
+var at = (tsName, column) => `${tsName}\0${column}`;
+function referenceOf(table, columnName) {
+  const col = table.columns.find((c) => c.name === columnName);
+  if (col?.references) return { sqlTable: col.references.table, column: col.references.column };
+  for (const fk of table.foreignKeys ?? []) {
+    const i = fk.columns.indexOf(columnName);
+    if (i === -1) continue;
+    const target = fk.foreignColumns[i];
+    if (target === void 0) continue;
+    return { sqlTable: fk.foreignTable, column: target };
+  }
+  return void 0;
+}
+function isKeyColumn(table, columnName) {
+  return (table.primaryKey?.columns ?? []).includes(columnName);
+}
+function buildBrandPlan(tables, opt) {
+  const resolved = resolveBranding(opt);
+  if (!resolved) return void 0;
+  const notes = [];
+  const byTs = /* @__PURE__ */ new Map();
+  const dupTs = /* @__PURE__ */ new Set();
+  for (const t of tables) {
+    if (byTs.has(t.tsName)) dupTs.add(t.tsName);
+    byTs.set(t.tsName, t);
+  }
+  for (const name of dupTs) {
+    byTs.delete(name);
+    notes.push(
+      `two tables are exported as "${name}", so nothing on either is branded: a brand token is built from the export name and the two would be indistinguishable.`
+    );
+  }
+  const bySqlName = /* @__PURE__ */ new Map();
+  for (const t of byTs.values()) {
+    const list2 = bySqlName.get(t.name) ?? [];
+    list2.push(t);
+    bySqlName.set(t.name, list2);
+  }
+  const tokens = /* @__PURE__ */ new Map();
+  const cache = /* @__PURE__ */ new Map();
+  const resolveToken = (tsName, columnName) => {
+    const start = at(tsName, columnName);
+    if (cache.has(start)) return cache.get(start);
+    const origin = byTs.get(tsName)?.columns.find((c) => c.name === columnName);
+    if (!origin || origin.arrayDimensions) {
+      cache.set(start, void 0);
+      return void 0;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    let curTable = tsName;
+    let curColumn = columnName;
+    let answer;
+    let terminal;
+    for (; ; ) {
+      const key = at(curTable, curColumn);
+      if (seen.has(key)) {
+        notes.push(
+          `${tsName}.${columnName} references a cycle of foreign keys, so it is not branded.`
+        );
+        break;
+      }
+      seen.add(key);
+      const table = byTs.get(curTable);
+      const col = table?.columns.find((c) => c.name === curColumn);
+      if (!table || !col) break;
+      const ref = resolved.foreignKeys ? referenceOf(table, curColumn) : void 0;
+      if (ref) {
+        const candidates = bySqlName.get(ref.sqlTable) ?? [];
+        if (candidates.length !== 1) {
+          notes.push(
+            candidates.length === 0 ? `${tsName}.${columnName} references a table "${ref.sqlTable}" that is not in this analysis, so it is not branded.` : `${tsName}.${columnName} references "${ref.sqlTable}", which names more than one table here, so it is not branded.`
+          );
+          break;
+        }
+        const next = candidates[0];
+        if (!next.columns.some((c) => c.name === ref.column)) {
+          notes.push(
+            `${tsName}.${columnName} references ${next.tsName}.${ref.column}, which is not a column of that table, so it is not branded.`
+          );
+          break;
+        }
+        curTable = next.tsName;
+        curColumn = ref.column;
+        continue;
+      }
+      if (isKeyColumn(table, curColumn)) {
+        answer = `${curTable}.${curColumn}`;
+        terminal = col;
+      }
+      break;
+    }
+    if (answer && terminal && terminal.tsType !== origin.tsType) {
+      notes.push(
+        `${tsName}.${columnName} is a ${origin.tsType} and ${answer} is a ${terminal.tsType}, so it is not branded.`
+      );
+      answer = void 0;
+    }
+    cache.set(start, answer);
+    return answer;
+  };
+  for (const t of byTs.values()) {
+    for (const c of t.columns) {
+      const token = resolveToken(t.tsName, c.name);
+      if (token) tokens.set(at(t.tsName, c.name), token);
+    }
+  }
+  const aliases = /* @__PURE__ */ new Map();
+  if (resolved.aliases) {
+    const claimed = /* @__PURE__ */ new Map();
+    const draft = [];
+    for (const t of byTs.values()) {
+      for (const c of t.columns) {
+        const token = tokens.get(at(t.tsName, c.name));
+        if (token !== `${t.tsName}.${c.name}`) continue;
+        const alias = pascalCase(t.tsName) + pascalCase(c.name);
+        draft.push({ tsName: t.tsName, entry: { alias, column: c.name, token } });
+        claimed.set(alias, [...claimed.get(alias) ?? [], `${t.tsName}.${c.name}`]);
+      }
+    }
+    for (const { tsName, entry } of draft) {
+      const owners = claimed.get(entry.alias) ?? [];
+      if (owners.length > 1) continue;
+      aliases.set(tsName, [...aliases.get(tsName) ?? [], entry]);
+    }
+    for (const [alias, owners] of claimed) {
+      if (owners.length > 1) {
+        notes.push(
+          `${owners.join(" and ")} both name their brand alias "${alias}", so neither is exported. The schemas are unaffected; refer to the type as the select type's property instead.`
+        );
+      }
+    }
+  }
+  return {
+    brandOf: (tsName, columnName) => tokens.get(at(tsName, columnName)),
+    aliasesFor: (tsName) => aliases.get(tsName) ?? [],
+    any: tokens.size > 0,
+    notes
+  };
+}
+
+// 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;
+    }
+    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;
+      }
+      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;
+      }
+      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"
+        }
+      );
+    }
+    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 out;
+}
+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 } : {}
+      }
+    });
+  }
+  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.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]
+      });
+    }
+  }
+  return {
+    table: table.name,
+    ...table.schema ? { schema: table.schema } : {},
+    constraints: out
+  };
+}
+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 };
+}
+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;
+  }
+  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);
+  }
+  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',
+      };
+    }
+  }
+
+  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 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 {
+      async mkdir(dir, options) {
+        return (await nodeFs()).mkdir(dir, options);
+      },
+      async writeFile(file, contents, encoding = "utf8") {
+        return (await nodeFs()).writeFile(file, contents, encoding);
+      }
+    };
+  }
+  return {
+    async mkdir(dir) {
+      await sink.mkdir(dir);
+      return void 0;
+    },
+    async writeFile(file, contents) {
+      await sink.writeFile(file, contents);
+    }
+  };
+}
+
+// src/files.ts
+import nodeFs2 from "fs";
+import nodePath from "path";
+var IMPORT_EXTENSIONS = ["js", "none", "ts"];
+var DEFAULT_IMPORT_EXTENSION = "js";
+var TS_EXTENSIONS = [
+  { ext: ".mts", js: ".mjs", none: ".mjs" },
+  { ext: ".cts", js: ".cjs", none: ".cjs" },
+  { ext: ".tsx", js: ".js", none: "" },
+  { ext: ".ts", js: ".js", none: "" }
+];
+function moduleFileName(tsName, fileSuffix) {
+  return `${tsName}${fileSuffix}`;
+}
+function importSpecifier(relativePath, importExtension = DEFAULT_IMPORT_EXTENSION) {
+  for (const { ext, js, none } of TS_EXTENSIONS) {
+    if (!relativePath.endsWith(ext)) continue;
+    const stem = relativePath.slice(0, -ext.length);
+    if (importExtension === "ts") return relativePath;
+    return `${stem}${importExtension === "none" ? none : js}`;
+  }
+  return relativePath;
+}
+function moduleSpecifier(tsName, fileSuffix, importExtension = DEFAULT_IMPORT_EXTENSION) {
+  return importSpecifier(`./${moduleFileName(tsName, fileSuffix)}`, importExtension);
+}
+function resolveConfiguredImport(configured, outDirAbs, cwd, importExtension = DEFAULT_IMPORT_EXTENSION) {
+  if (isPackageSpecifier(configured)) return configured;
+  const targetAbs = nodePath.isAbsolute(configured) ? configured : nodePath.resolve(configured.startsWith(".") ? outDirAbs : cwd, configured);
+  const withIndex = pointsAtDirectory(targetAbs) ? `${configured}/index` : configured;
+  if (configured.startsWith(".")) {
+    return importSpecifier(withTsExtension(withIndex), importExtension);
+  }
+  const resolved = pointsAtDirectory(targetAbs) ? nodePath.join(targetAbs, "index") : targetAbs;
+  const rel = nodePath.relative(outDirAbs, resolved).split(nodePath.sep).join("/");
+  const prefixed = !rel ? "." : rel.startsWith(".") ? rel : `./${rel}`;
+  return importSpecifier(withTsExtension(prefixed), importExtension);
+}
+function isPackageSpecifier(p) {
+  if (p.startsWith(".") || nodePath.isAbsolute(p)) return false;
+  if (p.startsWith("@") || p.includes(":")) return true;
+  return !p.includes("/");
+}
+function pointsAtDirectory(absPath) {
+  try {
+    return nodeFs2.statSync(absPath).isDirectory();
+  } catch {
+    for (const ext of [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs"]) {
+      if (nodeFs2.existsSync(`${absPath}${ext}`)) return false;
+    }
+    return !/\.[a-z]+$/i.test(nodePath.basename(absPath));
+  }
+}
+function withTsExtension(p) {
+  if (/\.(ts|tsx|mts|cts)$/.test(p)) return p;
+  if (/\.(js|mjs|cjs)$/.test(p)) return p.replace(/\.(js|mjs|cjs)$/, ".ts");
+  return `${p}.ts`;
+}
+
+// src/meta.ts
+function classifyChecks(table) {
+  const perColumn = /* @__PURE__ */ new Map();
+  const rows = [];
+  const unenforced = [];
+  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 };
+}
+function columnDescription(facts) {
+  const parts = [];
+  if (facts.maxLength !== void 0) parts.push(`at most ${facts.maxLength} characters`);
+  if (facts.maxBytes !== void 0) parts.push(`at most ${facts.maxBytes} bytes`);
+  for (const c of facts.checks ?? []) parts.push(`CHECK ${c}`);
+  return parts.length ? parts.join(". ") : void 0;
+}
+function tableDescription(facts) {
+  const parts = [];
+  for (const c of facts.checks ?? []) parts.push(`CHECK ${c}`);
+  if (facts.unenforcedChecks?.length) {
+    parts.push(
+      `not enforced by this schema, the database also checks: ${facts.unenforcedChecks.join("; ")}`
+    );
+  }
+  return parts.length ? parts.join(". ") : void 0;
+}
+function columnMetaFacts(column, table, opts = {}) {
+  const checks = classifyChecks(table).perColumn.get(column.name);
+  const facts = {
+    ...column.sqlType ? { sqlType: column.sqlType } : {},
+    ...column.maxLength !== void 0 ? { maxLength: column.maxLength } : {},
+    ...column.maxBytes !== void 0 ? { maxBytes: column.maxBytes } : {},
+    ...column.hasDefault ? { hasDefault: true } : {},
+    ...column.isGenerated ? { generated: true } : {},
+    ...checks?.length ? { checks } : {}
+  };
+  if (!opts.description) return facts;
+  const description = columnDescription(facts);
+  return description ? { ...facts, description } : facts;
+}
+function tableMetaFacts(table, opts) {
+  const { rows, unenforced } = classifyChecks(table);
+  const pk = table.primaryKey?.columns ?? [];
+  const unique = (table.unique ?? []).map((k) => k.columns).filter((c) => c.length > 0);
+  const facts = {
+    table: table.name,
+    ...table.schema ? { schema: table.schema } : {},
+    ...opts.dialect ? { dialect: opts.dialect } : {},
+    mode: opts.mode,
+    ...pk.length ? { primaryKey: pk } : {},
+    ...unique.length ? { unique } : {},
+    ...table.readOnly ? { readOnly: true } : {},
+    ...rows.length ? { checks: rows } : {},
+    ...unenforced.length ? { unenforcedChecks: unenforced } : {}
+  };
+  if (!opts.description) return facts;
+  const description = tableDescription(facts);
+  return description ? { ...facts, description } : facts;
+}
+
 // src/nested.ts
+import { qualifiedForeignTable, qualifiedTableName } from "@drzl/analyzer";
 var NESTED_PREFIX = "Nested";
 function nestedSchemaName(mode, tsName, affix) {
   return NESTED_PREFIX + schemaName(mode, tsName, affix);
@@ -412,13 +1482,14 @@ var KINDS_BY_MODE = {
 };
 var KIND_ORDER = { many: 0, manyToMany: 1, one: 2 };
 function omittedColumnsFor(parent, child) {
-  const back = (child.foreignKeys ?? []).filter((fk) => fk.foreignTable === parent.name);
+  const parentName = qualifiedTableName(parent);
+  const back = (child.foreignKeys ?? []).filter((fk) => qualifiedForeignTable(fk) === parentName);
   if (back.length === 1) return { omitted: [...back[0].columns] };
   if (back.length === 0) return { omitted: [] };
   const named = back.map((fk) => fk.columns.join("+")).join(", ");
   return {
     omitted: [],
-    note: `${child.tsName} has ${back.length} foreign keys to ${parent.name} (${named}), so which one this relation uses is not stated. None were omitted: supply them yourself.`
+    note: `${child.tsName} has ${back.length} foreign keys to ${parentName} (${named}), so which one this relation uses is not stated. None were omitted: supply them yourself.`
   };
 }
 function buildNestedPlan(root, tables, relations, mode, depth) {
@@ -427,14 +1498,15 @@ function buildNestedPlan(root, tables, relations, mode, depth) {
 }
 function buildNode(table, omitted, tables, relations, mode, depth) {
   if (depth <= 0) return { table, omitted, arms: [] };
-  const byDbName = new Map(tables.map((t) => [t.name, t]));
+  const byName = new Map(tables.map((t) => [qualifiedTableName(t), t]));
   const allowed = KINDS_BY_MODE[mode];
   const columnNames = new Set(table.columns.map((c) => c.name));
   const taken = /* @__PURE__ */ new Set();
   const arms = [];
-  const candidates = relations.filter((r) => r.from === table.name && allowed.has(r.kind)).sort((a, b) => KIND_ORDER[a.kind] - KIND_ORDER[b.kind]);
+  const self = qualifiedTableName(table);
+  const candidates = relations.filter((r) => r.from === self && allowed.has(r.kind)).sort((a, b) => KIND_ORDER[a.kind] - KIND_ORDER[b.kind]);
   for (const rel of candidates) {
-    const child = byDbName.get(rel.to);
+    const child = byName.get(rel.to);
     if (!child) continue;
     const key = child.tsName;
     if (columnNames.has(key)) continue;
@@ -470,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);
@@ -480,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}[]
@@ -524,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) {
@@ -539,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" };
@@ -573,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") {
@@ -645,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,
@@ -658,31 +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
 };