okmodel 0.2.1 → 0.4.0

package/dist/shared/5z4q2zda.js

@@ -1,2073 +0,0 @@
-import {
-  creationOrder2,
-  renameColumn2,
-  renameTable2,
-  serializeCatalog2,
-  catalogHash2,
-  parseCatalog2
-} from "./d2whjz4k.js";
-import {
-  VALIDATION_NOT_IMPORTED2,
-  VALIDATION_NOT_IMPORTED_FIX2
-} from "./n442h54c.js";
-import {
-  contributedFields
-} from "./g1b5zzj9.js";
-import {
-  assertValidation,
-  writeWouldValidate
-} from "./3a5ne750.js";
-import {
-  catalog,
-  sameEnumLabels
-} from "./qxa0yb9j.js";
-import {
-  snakeCase,
-  emittedTypeName
-} from "./x9v1qgeb.js";
-import {
-  ColumnBuilder2
-} from "./dd4f8mnx.js";
-import {
-  quoteLiteral
-} from "./xatfg0gn.js";
-import {
-  staticNamespace2,
-  identityKey2,
-  compareText
-} from "./t4tbsy9h.js";
-import {
-  OkmError2
-} from "./52szzakm.js";
-
-// src/dialects/pg/ddl.ts
-function quoteIdent(name) {
-  return `"${name.replaceAll('"', '""')}"`;
-}
-function dropObjectSql(object, schema) {
-  if (object.owner === "ignored")
-    return;
-  switch (object.kind) {
-    case "table":
-      return `drop table ${qualify(schema, object.identity.name)}`;
-    case "column":
-      return `alter table ${qualify(schema, object.identity.parent.name)} drop column ${quoteIdent(object.identity.name)}`;
-    case "index":
-      return `drop index ${qualify(schema, object.identity.name)}`;
-    case "constraint":
-      return `alter table ${qualify(schema, object.identity.parent.name)} drop constraint ${quoteIdent(object.identity.name)}`;
-    case "sequence":
-      return `drop sequence ${qualify(schema, object.identity.name)}`;
-    case "type":
-      return `drop type ${qualify(schema, object.identity.name)}`;
-    default:
-      return;
-  }
-}
-function createObjectSql(object, schema) {
-  switch (object.kind) {
-    case "column":
-      return `alter table ${qualify(schema, object.identity.parent.name)} add column ${columnSql(object)}`;
-    case "index":
-      return createIndexSql(object, schema);
-    case "constraint":
-      return `alter table ${qualify(schema, object.identity.parent.name)} add constraint ${quoteIdent(object.identity.name)} ${constraintBody(object, schema)}`;
-    case "sequence":
-      return createSequenceSql(object, schema);
-    case "type":
-      return createEnumSql(object, schema);
-    case "table":
-      return;
-    default:
-      return;
-  }
-}
-function alterColumnSql(before, after, schema) {
-  const statements = [];
-  const table = qualify(schema, after.identity.parent.name);
-  const name = quoteIdent(after.identity.name);
-  const typeChanged = before.definition.dataType !== after.definition.dataType;
-  const collationChanged = before.definition.collation !== after.definition.collation;
-  if (typeChanged || collationChanged) {
-    const using = typeChanged ? ` using ${name}::${after.definition.dataType}` : "";
-    statements.push(`alter table ${table} alter column ${name} set data type ${after.definition.dataType}${collateSql(after.definition.collation)}${using}`);
-  }
-  if (before.definition.nullable !== after.definition.nullable) {
-    statements.push(`alter table ${table} alter column ${name} ${after.definition.nullable ? "drop not null" : "set not null"}`);
-  }
-  if (before.definition.defaultExpression !== after.definition.defaultExpression) {
-    statements.push(after.definition.defaultExpression === undefined ? `alter table ${table} alter column ${name} drop default` : `alter table ${table} alter column ${name} set default ${after.definition.defaultExpression}`);
-  }
-  return statements;
-}
-function identitySequence(sequence, source) {
-  const key = identityKey2(sequence.identity);
-  return source.objects.some((object) => {
-    if (object.kind !== "column" || object.definition.identity === undefined)
-      return false;
-    return object.dependencies.some((edge) => identityKey2(edge.target) === key);
-  });
-}
-function createTableSql(tableObject, source, schema) {
-  const parent = tableObject.identity.name;
-  const columns = source.objects.filter((object) => object.kind === "column" && object.identity.parent.name === parent);
-  const primary = source.objects.find((object) => object.kind === "constraint" && object.definition.constraintKind === "primaryKey" && object.identity.parent.name === parent);
-  const lines = columns.map((column) => columnSql(column));
-  if (primary !== undefined) {
-    const cols = primary.definition.columns.map((name) => quoteIdent(name)).join(", ");
-    lines.push(`primary key (${cols})`);
-  }
-  const partition = tableObject.definition.partition;
-  const tail = partition === undefined ? "" : ` partition by ${partition.method} (${partition.columns.map((name) => quoteIdent(name)).join(", ")})`;
-  return `create table ${qualify(schema, parent)} (
-  ${lines.join(`,
-  `)}
-)${tail}`;
-}
-function collateSql(collation) {
-  if (collation === undefined)
-    return "";
-  return ` collate ${quoteIdent(collation)}`;
-}
-function createEnumSql(object, schema) {
-  const labels = object.definition.labels.map((label) => quoteLiteral(label)).join(", ");
-  return `create type ${qualify(schema, object.identity.name)} as enum (${labels})`;
-}
-function columnSql(column) {
-  const definition = column.definition;
-  let sql = `${quoteIdent(column.identity.name)} ${definition.dataType}${collateSql(definition.collation)}`;
-  if (definition.identity !== undefined) {
-    sql += definition.identity.always ? " generated always as identity" : " generated by default as identity";
-  } else if (definition.generated !== undefined) {
-    sql += ` generated always as (${definition.generated.expression}) stored`;
-  }
-  if (!definition.nullable)
-    sql += " not null";
-  if (definition.defaultExpression !== undefined)
-    sql += ` default ${definition.defaultExpression}`;
-  return sql;
-}
-function createIndexSql(object, schema) {
-  const unique = object.definition.unique ? "unique " : "";
-  const target = object.definition.expression !== undefined ? `(${object.definition.expression})` : object.definition.columns.map((name) => quoteIdent(name)).join(", ");
-  const where = object.definition.predicate === undefined ? "" : ` where ${object.definition.predicate}`;
-  return `create ${unique}index ${quoteIdent(object.identity.name)} on ${qualify(schema, object.identity.parent.name)} (${target})${where}`;
-}
-function createSequenceSql(object, schema) {
-  const definition = object.definition;
-  const cycle = definition.cycle ? " cycle" : "";
-  return `create sequence ${qualify(schema, object.identity.name)} as ${definition.dataType} start ${definition.start} increment ${definition.increment}${cycle}`;
-}
-function constraintBody(object, schema) {
-  const definition = object.definition;
-  const columns = definition.columns.map((name) => quoteIdent(name)).join(", ");
-  switch (definition.constraintKind) {
-    case "primaryKey":
-      return `primary key (${columns})`;
-    case "unique": {
-      const nulls = definition.nullsNotDistinct ? " nulls not distinct" : "";
-      return `unique${nulls} (${columns})${deferClause(definition)}`;
-    }
-    case "check":
-      return `check (${definition.expression ?? "true"})${deferClause(definition)}`;
-    case "foreignKey": {
-      const references = definition.references;
-      const target = references === undefined ? "" : ` references ${qualify(schema, references.parent.name)} (${references.columns.map((name) => quoteIdent(name)).join(", ")})`;
-      const onDelete = references?.onDelete === undefined ? "" : ` on delete ${references.onDelete}`;
-      const onUpdate = references?.onUpdate === undefined ? "" : ` on update ${references.onUpdate}`;
-      return `foreign key (${columns})${target}${onDelete}${onUpdate}${deferClause(definition)}`;
-    }
-    default:
-      return definition.constraintKind;
-  }
-}
-function deferClause(definition) {
-  if (!definition.deferrable)
-    return "";
-  return ` deferrable initially ${definition.initially}`;
-}
-function qualify(schema, name) {
-  return `${quoteIdent(schema)}.${quoteIdent(name)}`;
-}
-
-// src/tooling/migrate/values.ts
-function parseReplace(flag) {
-  const eq = flag.indexOf("=");
-  if (eq <= 0) {
-    throw new OkmError2("OKM1541", `--replace ${flag} must be table.column.old=new.`, {
-      fix: {
-        summary: "Pass --replace <table>.<column>.<old>=<new>, or =null on a nullable column."
-      }
-    });
-  }
-  const left = flag.slice(0, eq);
-  const raw = flag.slice(eq + 1);
-  const first = left.indexOf(".");
-  const second = first < 0 ? -1 : left.indexOf(".", first + 1);
-  if (first <= 0 || second <= first + 1 || second === left.length - 1) {
-    throw new OkmError2("OKM1541", `--replace ${flag} must be table.column.old=new.`, {
-      fix: {
-        summary: "Pass --replace <table>.<column>.<old>=<new>, or =null on a nullable column."
-      }
-    });
-  }
-  const table = left.slice(0, first);
-  const column = left.slice(first + 1, second);
-  const from = left.slice(second + 1);
-  return { table, column, from, to: raw === "null" ? null : raw };
-}
-function assertNoChains(replacements) {
-  const removed = new Set(replacements.map((item) => pair(item.table, item.column, item.from)));
-  for (const item of replacements) {
-    if (item.to !== null && removed.has(pair(item.table, item.column, item.to))) {
-      const flag = `--replace ${item.table}.${item.column}.${item.from}=${item.to}`;
-      throw new OkmError2("OKM1541", `${flag} chains through another removed value.`, {
-        fix: { summary: "The replacement must be in the new list. No chains." }
-      });
-    }
-  }
-}
-function pair(table, column, value) {
-  return `${table}\x00${column}\x00${value}`;
-}
-
-// src/tooling/migrate/plan.ts
-var ACCESS = "ACCESS EXCLUSIVE";
-var SHARE = "SHARE";
-var SHARE_UPDATE = "SHARE UPDATE EXCLUSIVE";
-var ROW = "ROW EXCLUSIVE";
-function planMigration(request) {
-  const schema = request.schema ?? "public";
-  const renames = request.renames ?? [];
-  const replacements = request.replacements ?? [];
-  assertNoChains(replacements);
-  const renamed = applyRenames(request.before, renames);
-  const beforeList = index(renamed);
-  const afterList = index(request.after);
-  const beforeBy = new Map(beforeList.map((item) => [item.key, item.object]));
-  const afterBy = new Map(afterList.map((item) => [item.key, item.object]));
-  assertUnambiguous(beforeBy, afterBy);
-  const dropKeys = new Set;
-  const createKeys = new Set;
-  const alters = [];
-  for (const item of beforeList) {
-    if (!afterBy.has(item.key))
-      dropKeys.add(item.key);
-  }
-  for (const item of afterList) {
-    if (!beforeBy.has(item.key))
-      createKeys.add(item.key);
-  }
-  for (const item of afterList) {
-    const previous = beforeBy.get(item.key);
-    if (previous === undefined || sameDefinition(previous, item.object))
-      continue;
-    if (previous.kind === "type" && item.object.kind === "type")
-      continue;
-    if (previous.kind === "column" && item.object.kind === "column" && columnAlterable(previous, item.object)) {
-      alters.push({ before: previous, after: item.object });
-      continue;
-    }
-    dropKeys.add(item.key);
-    createKeys.add(item.key);
-  }
-  const keptNames = pairSameShape(beforeBy, afterBy, dropKeys, createKeys);
-  const picklists = picklistChanges(beforeBy, afterBy, request.after);
-  const enums = enumEdits(beforeBy, afterBy, schema);
-  requireReplacements(picklists, enums, replacements);
-  recreateDependents(beforeList, afterList, alters, dropKeys, createKeys, picklists);
-  omitOwnedSequences(createKeys, afterBy, request.after);
-  omitOwnedSequences(dropKeys, beforeBy, renamed);
-  const steps = [];
-  steps.push(...renameSteps(request.before, renames, schema));
-  steps.push(...keptNames.map((item) => renameShapeStep(item, schema)));
-  steps.push(...enumAddSteps(enums));
-  steps.push(...expandBackfills(picklists, enums, replacements, schema));
-  const droppedTables = new Set([...dropKeys].map((key) => beforeBy.get(key)).filter((object) => object?.kind === "table").map((object) => object.identity.name));
-  const deferred = new Set(picklists.map((change) => identityKey2(change.before.identity)));
-  const typeDrops = [];
-  for (const object of [...creationOrder2(renamed)].reverse()) {
-    const key = identityKey2(object.identity);
-    if (!dropKeys.has(key) || deferred.has(key) || covered(object, droppedTables))
-      continue;
-    if (object.kind === "type") {
-      typeDrops.push(object);
-      continue;
-    }
-    const sql = dropObjectSql(object, schema);
-    if (sql === undefined)
-      continue;
-    steps.push(step(sql, "contract", "ddl", ACCESS));
-  }
-  for (const object of typeDrops) {
-    const sql = dropObjectSql(object, schema);
-    if (sql === undefined)
-      continue;
-    steps.push(step(sql, "contract", "ddl", ACCESS));
-  }
-  for (const change of alters) {
-    for (const sql of alterColumnSql(change.before, change.after, schema)) {
-      steps.push(step(sql, alterClass(sql), "ddl", ACCESS));
-    }
-    const identitySql = identityChangeSql(change.before, change.after, schema);
-    if (identitySql !== undefined)
-      steps.push(step(identitySql, "expand", "ddl", ACCESS));
-  }
-  const createdTables = new Set([...createKeys].map((key) => afterBy.get(key)).filter((object) => object?.kind === "table").map((object) => object.identity.name));
-  const emitted = new Set;
-  for (const object of creationOrder2(request.after)) {
-    if (object.kind !== "type")
-      continue;
-    const key = identityKey2(object.identity);
-    if (!createKeys.has(key) || emitted.has(key))
-      continue;
-    emitted.add(key);
-    const sql = createObjectSql(object, schema);
-    if (sql === undefined)
-      continue;
-    steps.push(step(sql, "expand", "ddl", ACCESS));
-  }
-  for (const object of creationOrder2(request.after)) {
-    if (object.kind === "type")
-      continue;
-    const key = identityKey2(object.identity);
-    if (deferred.has(key))
-      continue;
-    const parent = anchoredParent(object);
-    const tableIsNew = parent !== undefined && createdTables.has(parent);
-    if (tableIsNew && folded(object, request.after))
-      continue;
-    const wanted = createKeys.has(key) || tableIsNew && !folded(object, request.after);
-    if (!wanted || emitted.has(key))
-      continue;
-    emitted.add(key);
-    if (object.kind === "table") {
-      steps.push(step(createTableSql(object, request.after, schema), "expand", "ddl", ACCESS));
-      continue;
-    }
-    const sql = createObjectSql(object, schema);
-    if (sql === undefined)
-      continue;
-    steps.push(step(sql, "expand", "ddl", object.kind === "index" ? SHARE : ACCESS));
-  }
-  steps.push(...contractSwaps(picklists, enums, replacements, schema));
-  return {
-    name: request.name ?? "migration",
-    class: overall(steps),
-    steps
-  };
-}
-function formatPlan(plan) {
-  const lines = [`-- class: ${plan.class}`, `-- name: ${plan.name}`, ""];
-  if (plan.steps.length === 0) {
-    lines.push("-- no steps");
-    lines.push("");
-    return lines.join(`
-`);
-  }
-  for (const item of plan.steps) {
-    lines.push(`-- class: ${item.class}`);
-    lines.push(`-- action: ${item.action}`);
-    lines.push(`-- lock: ${item.lock}`);
-    if (!item.transactional)
-      lines.push("-- transactional: false");
-    lines.push(`${item.sql};`);
-    lines.push("");
-  }
-  return lines.join(`
-`);
-}
-function parsePlan(text) {
-  const lines = text.split(`
-`);
-  let name = "migration";
-  let planClass = "expand";
-  let index = 0;
-  while (index < lines.length && lines[index] !== "") {
-    const line = lines[index] ?? "";
-    if (line.startsWith("-- name: "))
-      name = line.slice("-- name: ".length);
-    if (line.startsWith("-- class: "))
-      planClass = readClass(line.slice("-- class: ".length));
-    index += 1;
-  }
-  const steps = [];
-  while (index < lines.length) {
-    if ((lines[index] ?? "").trim() === "") {
-      index += 1;
-      continue;
-    }
-    if (lines[index] === "-- no steps")
-      break;
-    let stepClass = "expand";
-    let action = "ddl";
-    let lock = "";
-    let transactional = true;
-    const sql = [];
-    while (index < lines.length && (lines[index] ?? "") !== "") {
-      const line = lines[index] ?? "";
-      index += 1;
-      if (line.startsWith("-- class: "))
-        stepClass = readClass(line.slice("-- class: ".length));
-      else if (line.startsWith("-- action: "))
-        action = line.endsWith("backfill") ? "backfill" : "ddl";
-      else if (line.startsWith("-- lock: "))
-        lock = line.slice("-- lock: ".length);
-      else if (line === "-- transactional: false")
-        transactional = false;
-      else if (!line.startsWith("--"))
-        sql.push(line);
-    }
-    const statement = sql.join(`
-`).replace(/;\s*$/, "");
-    if (statement.length > 0) {
-      steps.push({ sql: statement, class: stepClass, action, lock, transactional });
-    }
-  }
-  return { name, class: steps.length === 0 ? planClass : overall(steps), steps };
-}
-function readClass(value) {
-  if (value === "contract" || value === "unclassified")
-    return value;
-  return "expand";
-}
-function staleRenames(previous, renames) {
-  if (previous === undefined)
-    return [];
-  const messages = [];
-  for (const rename of renames) {
-    if (rename.kind === "table") {
-      if (!hasTable(previous, rename.from)) {
-        messages.push(`Table renamedFrom ${rename.from} is not in the previous snapshot.`);
-      }
-      continue;
-    }
-    const tableRename = renames.find((item) => item.kind === "table" && item.to === rename.table);
-    const previousTable = tableRename?.kind === "table" ? tableRename.from : rename.table;
-    if (!hasColumn(previous, previousTable, rename.from)) {
-      messages.push(`Column ${rename.table}.${rename.from} renamedFrom is not in the previous snapshot.`);
-    }
-  }
-  return messages;
-}
-function applyRenames(source, renames) {
-  let current = source;
-  const namespace = staticNamespace2("public");
-  for (const rename of renames) {
-    if (rename.kind !== "table")
-      continue;
-    if (!hasTable(current, rename.from))
-      continue;
-    current = renameTable2(current, { namespace, from: rename.from, to: rename.to });
-  }
-  for (const rename of renames) {
-    if (rename.kind !== "column")
-      continue;
-    const parent = { namespace, name: rename.table };
-    if (!hasColumn(current, rename.table, rename.from))
-      continue;
-    current = renameColumn2(current, { parent, from: rename.from, to: rename.to });
-  }
-  return current;
-}
-function renameSteps(source, renames, schema) {
-  const steps = [];
-  const tables = new Map;
-  for (const rename of renames) {
-    if (rename.kind !== "table" || !hasTable(source, rename.from))
-      continue;
-    tables.set(rename.to, rename.from);
-    steps.push(step(`alter table ${qualify2(schema, rename.from)} rename to ${quoteIdent(rename.to)}`, "contract", "ddl", ACCESS));
-  }
-  for (const rename of renames) {
-    if (rename.kind !== "column")
-      continue;
-    const previousTable = tables.get(rename.table) ?? rename.table;
-    if (!hasColumn(source, previousTable, rename.from))
-      continue;
-    steps.push(step(`alter table ${qualify2(schema, rename.table)} rename column ${quoteIdent(rename.from)} to ${quoteIdent(rename.to)}`, "contract", "ddl", ACCESS));
-  }
-  return steps;
-}
-function pairSameShape(beforeBy, afterBy, dropKeys, createKeys) {
-  const dropped = [...dropKeys].map((key) => beforeBy.get(key)).filter((object) => object !== undefined);
-  const created = [...createKeys].map((key) => afterBy.get(key)).filter((object) => object !== undefined);
-  const pairs = [];
-  const used = new Set;
-  for (const left of dropped) {
-    if (left.kind !== "index" && left.kind !== "constraint")
-      continue;
-    const leftKey = identityKey2(left.identity);
-    const hits = created.filter((right) => {
-      const key = identityKey2(right.identity);
-      return key !== leftKey && !used.has(key) && sameShape(left, right);
-    });
-    const right = hits.length === 1 ? hits[0] : undefined;
-    if (right === undefined)
-      continue;
-    const rivals = dropped.filter((item) => sameShape(item, right));
-    if (rivals.length !== 1)
-      continue;
-    const rightKey = identityKey2(right.identity);
-    used.add(rightKey);
-    dropKeys.delete(identityKey2(left.identity));
-    createKeys.delete(rightKey);
-    if (left.identity.name !== right.identity.name)
-      pairs.push({ from: left, to: right });
-  }
-  return pairs;
-}
-function sameShape(left, right) {
-  if (left.kind !== right.kind)
-    return false;
-  if (left.kind !== "index" && left.kind !== "constraint" || right.kind !== "index" && right.kind !== "constraint") {
-    return false;
-  }
-  if (left.identity.parent.name !== right.identity.parent.name)
-    return false;
-  return stable(withoutNameKey(left.definition)) === stable(withoutNameKey(right.definition));
-}
-function withoutNameKey(value) {
-  const copy = { ...value };
-  delete copy.nameKey;
-  return copy;
-}
-function renameShapeStep(pair, schema) {
-  if (pair.from.kind === "index" && pair.to.kind === "index") {
-    return step(`alter index ${qualify2(schema, pair.from.identity.name)} rename to ${quoteIdent(pair.to.identity.name)}`, "contract", "ddl", ACCESS);
-  }
-  if (pair.from.kind !== "constraint" || pair.to.kind !== "constraint") {
-    return step("select 1", "unclassified", "ddl", ACCESS);
-  }
-  return step(`alter table ${qualify2(schema, pair.from.identity.parent.name)} rename constraint ${quoteIdent(pair.from.identity.name)} to ${quoteIdent(pair.to.identity.name)}`, "contract", "ddl", ACCESS);
-}
-function assertUnambiguous(beforeBy, afterBy) {
-  const dropped = new Map;
-  const added = new Map;
-  for (const [key, object] of beforeBy) {
-    if (afterBy.has(key))
-      continue;
-    const group = groupOf(object);
-    if (group === undefined)
-      continue;
-    const list = dropped.get(group) ?? [];
-    list.push(object.identity.name);
-    dropped.set(group, list);
-  }
-  for (const [key, object] of afterBy) {
-    if (beforeBy.has(key))
-      continue;
-    const group = groupOf(object);
-    if (group === undefined)
-      continue;
-    const list = added.get(group) ?? [];
-    list.push(object.identity.name);
-    added.set(group, list);
-  }
-  for (const [group, names] of added) {
-    const gone = dropped.get(group);
-    if (gone === undefined || gone.length === 0 || names.length === 0)
-      continue;
-    const from = gone[0] ?? "";
-    const to = names[0] ?? "";
-    const line = group.startsWith("table:") ? `Add renamedFrom: "${from}" on ${to}.` : `Add .renamedFrom("${from}") on ${to}.`;
-    throw new OkmError2("OKM1530", `Drop ${from} and add ${to} could be a rename. ${line}`, {
-      fix: { summary: line }
-    });
-  }
-}
-function groupOf(object) {
-  if (object.kind === "table")
-    return "table:public";
-  if (object.kind === "column")
-    return `column:${object.identity.parent.name}`;
-  return;
-}
-function recreateDependents(beforeList, afterList, alters, dropKeys, createKeys, picklists) {
-  const changed = new Set(alters.filter((item) => item.before.definition.dataType !== item.after.definition.dataType).map((item) => identityKey2(item.after.identity)));
-  if (changed.size === 0)
-    return;
-  const deferred = new Set(picklists.map((change) => identityKey2(change.before.identity)));
-  const afterBy = new Map(afterList.map((item) => [item.key, item.object]));
-  for (const item of beforeList) {
-    const key = identityKey2(item.object.identity);
-    if (deferred.has(key) || !afterBy.has(key))
-      continue;
-    if (!dependsOnChanged(item.object, changed))
-      continue;
-    dropKeys.add(key);
-    createKeys.add(key);
-  }
-}
-function dependsOnChanged(object, columns) {
-  if (object.kind !== "index" && object.kind !== "constraint")
-    return false;
-  return object.dependencies.some((edge) => columns.has(identityKey2(edge.target)));
-}
-function enumAddSteps(enums) {
-  const steps = [];
-  for (const change of enums) {
-    if (change.kind !== "add")
-      continue;
-    for (const sql of change.statements) {
-      steps.push(step(sql, "expand", "ddl", ACCESS, false));
-    }
-  }
-  return steps;
-}
-function expandBackfills(picklists, enums, replacements, schema) {
-  return dataSteps(picklists, enums, replacements, schema, "expand");
-}
-function contractSwaps(picklists, enums, replacements, schema) {
-  const steps = [];
-  steps.push(...dataSteps(picklists, enums, replacements, schema, "contract"));
-  for (const change of picklists) {
-    const table = qualify2(schema, change.after.identity.parent.name);
-    const name = quoteIdent(change.after.identity.name);
-    steps.push(step(`alter table ${table} drop constraint ${name}`, change.removed.length > 0 ? "contract" : "expand", "ddl", ACCESS));
-    const expression = change.after.definition.expression ?? "true";
-    steps.push(step(`alter table ${table} add constraint ${name} check (${expression}) not valid`, change.removed.length > 0 ? "contract" : "expand", "ddl", ACCESS));
-    steps.push(step(`alter table ${table} validate constraint ${name}`, change.removed.length > 0 ? "contract" : "expand", "ddl", SHARE_UPDATE));
-  }
-  for (const change of enums) {
-    if (change.kind !== "replace")
-      continue;
-    const type = qualify2(schema, change.name);
-    const old = quoteIdent(`${change.name}_old`);
-    const labels = change.labels.map((label) => sqlString(label)).join(", ");
-    steps.push(step(`alter type ${type} rename to ${old}`, "contract", "ddl", ACCESS));
-    steps.push(step(`create type ${type} as enum (${labels})`, "contract", "ddl", ACCESS));
-    for (const column of change.columns) {
-      const table = qualify2(schema, column.table);
-      const name = quoteIdent(column.column);
-      steps.push(step(`alter table ${table} alter column ${name} type ${type} using ${name}::text::${type}`, "contract", "ddl", ACCESS));
-    }
-    steps.push(step(`drop type ${qualify2(schema, `${change.name}_old`)}`, "contract", "ddl", ACCESS));
-  }
-  return steps;
-}
-function dataSteps(picklists, enums, replacements, schema, phase) {
-  const steps = [];
-  for (const change of picklists) {
-    if (change.removed.length === 0)
-      continue;
-    const table = change.after.identity.parent.name;
-    for (const value of change.removed) {
-      const replacement = findReplacement(replacements, table, change.column, value);
-      if (replacement === undefined)
-        continue;
-      steps.push(step(updateSql(schema, table, change.column, value, replacement.to), phase, "backfill", ROW));
-    }
-  }
-  for (const change of enums) {
-    if (change.kind !== "replace" || change.removed.length === 0)
-      continue;
-    for (const column of change.columns) {
-      if (!column.existed)
-        continue;
-      for (const value of change.removed) {
-        const replacement = findReplacement(replacements, column.table, column.column, value);
-        if (replacement === undefined)
-          continue;
-        steps.push(step(updateSql(schema, column.table, column.column, value, replacement.to, true), phase, "backfill", ROW));
-      }
-    }
-  }
-  return steps;
-}
-function requireReplacements(picklists, enums, replacements) {
-  const missing = [];
-  for (const change of picklists) {
-    for (const value of change.removed) {
-      const table = change.after.identity.parent.name;
-      const found = findReplacement(replacements, table, change.column, value);
-      if (found === undefined) {
-        missing.push(`--replace ${table}.${change.column}.${value}=<new>`);
-        continue;
-      }
-      assertReplacement(found, change.after.definition.expression, change.nullable, parseValues(change.after.definition.expression));
-    }
-  }
-  for (const change of enums) {
-    if (change.kind !== "replace")
-      continue;
-    for (const column of change.columns) {
-      if (!column.existed)
-        continue;
-      for (const value of change.removed) {
-        const found = findReplacement(replacements, column.table, column.column, value);
-        if (found === undefined) {
-          missing.push(`--replace ${column.table}.${column.column}.${value}=<new>`);
-          continue;
-        }
-        assertReplacement(found, undefined, column.nullable, change.labels);
-      }
-    }
-  }
-  if (missing.length > 0) {
-    throw new OkmError2("OKM1541", `Removed values need a replacement: ${missing.join(", ")}.`, {
-      fix: { summary: missing.join(" ") }
-    });
-  }
-}
-function assertReplacement(replacement, expression, nullable, allowed) {
-  if (replacement.to === null) {
-    if (!nullable) {
-      throw new OkmError2("OKM1541", `--replace ${replacement.table}.${replacement.column}.${replacement.from}=null needs a nullable column.`, { fix: { summary: "Pass a value that is in the new list, or make the column nullable." } });
-    }
-    return;
-  }
-  const list = allowed ?? (expression === undefined ? [] : parseValues(expression) ?? []);
-  if (!list.includes(replacement.to)) {
-    const flag = `--replace ${replacement.table}.${replacement.column}.${replacement.from}=${replacement.to}`;
-    throw new OkmError2("OKM1541", `${flag} is not in the new list.`, {
-      fix: { summary: "The replacement must be in the new list. No chains." }
-    });
-  }
-}
-function parseValues(expression) {
-  if (expression === undefined)
-    return;
-  return parseInList(expression)?.values;
-}
-function findReplacement(replacements, table, column, from) {
-  return replacements.find((item) => item.table === table && item.column === column && item.from === from);
-}
-function picklistChanges(beforeBy, afterBy, after) {
-  const changes = [];
-  for (const [key, object] of beforeBy) {
-    if (object.kind !== "constraint" || object.definition.constraintKind !== "check")
-      continue;
-    const next = afterBy.get(key);
-    if (next === undefined || next.kind !== "constraint")
-      continue;
-    const left = parseInList(object.definition.expression ?? "");
-    const right = parseInList(next.definition.expression ?? "");
-    if (left === undefined || right === undefined || left.column !== right.column)
-      continue;
-    const removed = left.values.filter((value) => !right.values.includes(value));
-    const added = right.values.filter((value) => !left.values.includes(value));
-    if (removed.length === 0 && added.length === 0)
-      continue;
-    changes.push({
-      before: object,
-      after: next,
-      column: right.column,
-      removed,
-      added,
-      nullable: columnNullable(after, next.identity.parent.name, right.column)
-    });
-  }
-  return changes;
-}
-function enumEdits(beforeBy, afterBy, schema) {
-  const edits = [];
-  for (const [key, next] of afterBy) {
-    if (next.kind !== "type")
-      continue;
-    const previous = beforeBy.get(key);
-    if (previous === undefined || previous.kind !== "type")
-      continue;
-    if (sameEnumLabels(previous.definition.labels, next.definition.labels))
-      continue;
-    const removed = previous.definition.labels.filter((label) => !next.definition.labels.includes(label));
-    const columns = enumColumns(previous.identity.name, beforeBy, afterBy);
-    if (removed.length === 0 && labelSubsequence(previous.definition.labels, next.definition.labels)) {
-      edits.push({
-        kind: "add",
-        name: next.identity.name,
-        statements: addValueStatements(schema, next.identity.name, previous.definition.labels, next.definition.labels)
-      });
-      continue;
-    }
-    edits.push({
-      kind: "replace",
-      name: next.identity.name,
-      labels: next.definition.labels,
-      removed,
-      columns
-    });
-  }
-  return edits;
-}
-function enumColumns(typeName, beforeBy, afterBy) {
-  const columns = [];
-  for (const object of afterBy.values()) {
-    if (object.kind !== "column")
-      continue;
-    if (!usesType(object, typeName))
-      continue;
-    columns.push({
-      table: object.identity.parent.name,
-      column: object.identity.name,
-      nullable: object.definition.nullable,
-      existed: beforeBy.has(identityKey2(object.identity))
-    });
-  }
-  columns.sort((left, right) => {
-    const table = compareText(left.table, right.table);
-    return table === 0 ? compareText(left.column, right.column) : table;
-  });
-  return columns;
-}
-function usesType(object, typeName) {
-  return object.dependencies.some((edge) => edge.target.kind === "type" && edge.target.name === typeName);
-}
-function labelSubsequence(before, after) {
-  let index = 0;
-  for (const label of after) {
-    if (before[index] === label)
-      index += 1;
-  }
-  return index === before.length;
-}
-function addValueStatements(schema, name, before, after) {
-  const present = new Set(before);
-  const statements = [];
-  const type = qualify2(schema, name);
-  for (let index = 0;index < after.length; index += 1) {
-    const label = after[index];
-    if (label === undefined || present.has(label))
-      continue;
-    let beforeNeighbor;
-    for (let cursor = index + 1;cursor < after.length; cursor += 1) {
-      const next = after[cursor];
-      if (next !== undefined && present.has(next)) {
-        beforeNeighbor = next;
-        break;
-      }
-    }
-    let sql = `alter type ${type} add value ${sqlString(label)}`;
-    if (beforeNeighbor !== undefined) {
-      sql += ` before ${sqlString(beforeNeighbor)}`;
-    } else {
-      let afterNeighbor;
-      for (let cursor = index - 1;cursor >= 0; cursor -= 1) {
-        const previous = after[cursor];
-        if (previous !== undefined && present.has(previous)) {
-          afterNeighbor = previous;
-          break;
-        }
-      }
-      if (afterNeighbor !== undefined)
-        sql += ` after ${sqlString(afterNeighbor)}`;
-    }
-    statements.push(sql);
-    present.add(label);
-  }
-  return statements;
-}
-function parseInList(expression) {
-  const match = /^\(\s*([A-Za-z_][A-Za-z0-9_]*)\s+IN\s*\((.*)\)\s*\)$/i.exec(expression.trim());
-  const column = match?.[1];
-  const body = match?.[2];
-  if (column === undefined || body === undefined)
-    return;
-  const values = [];
-  let index = 0;
-  while (index < body.length) {
-    const char = body[index] ?? "";
-    if (char === " " || char === ",") {
-      index += 1;
-      continue;
-    }
-    if (char !== "'")
-      return;
-    let end = index + 1;
-    let value = "";
-    while (end < body.length) {
-      const next = body[end] ?? "";
-      if (next === "'" && body[end + 1] === "'") {
-        value += "'";
-        end += 2;
-        continue;
-      }
-      if (next === "'") {
-        end += 1;
-        break;
-      }
-      value += next;
-      end += 1;
-    }
-    values.push(value);
-    index = end;
-  }
-  return { column, values };
-}
-function columnNullable(source, table, column) {
-  for (const object of source.objects) {
-    if (object.kind === "column" && object.identity.parent.name === table && object.identity.name === column) {
-      return object.definition.nullable;
-    }
-  }
-  return false;
-}
-function columnAlterable(before, after) {
-  return stable(before.definition.generated) === stable(after.definition.generated);
-}
-function identityChangeSql(before, after, schema) {
-  if (stable(before.definition.identity) === stable(after.definition.identity))
-    return;
-  const table = qualify2(schema, after.identity.parent.name);
-  const name = quoteIdent(after.identity.name);
-  const next = after.definition.identity;
-  const previous = before.definition.identity;
-  if (next === undefined)
-    return `alter table ${table} alter column ${name} drop identity`;
-  if (previous === undefined) {
-    const generated = next.always ? "always" : "by default";
-    return `alter table ${table} alter column ${name} add generated ${generated} as identity`;
-  }
-  return `alter table ${table} alter column ${name} set generated ${next.always ? "always" : "by default"}`;
-}
-function omitOwnedSequences(keys, by, source) {
-  for (const key of keys) {
-    const object = by.get(key);
-    if (object?.kind === "sequence" && folded(object, source))
-      keys.delete(key);
-  }
-}
-function sameDefinition(left, right) {
-  return stable(left.definition) === stable(right.definition);
-}
-function covered(object, tables) {
-  if (object.kind === "column" || object.kind === "index" || object.kind === "constraint") {
-    return tables.has(object.identity.parent.name);
-  }
-  if (object.kind === "sequence") {
-    return object.dependencies.some((edge) => edge.target.kind === "table" && tables.has(edge.target.name));
-  }
-  return false;
-}
-function folded(object, source) {
-  if (object.kind === "column")
-    return true;
-  if (object.kind === "constraint" && object.definition.constraintKind === "primaryKey")
-    return true;
-  if (object.kind !== "sequence")
-    return false;
-  if (identitySequence(object, source))
-    return true;
-  const name = object.identity.name;
-  return source.objects.some((column) => {
-    if (column.kind !== "column" || column.definition.identity === undefined)
-      return false;
-    return name === `${column.identity.parent.name}_${column.identity.name}_seq`;
-  });
-}
-function anchoredParent(object) {
-  if (object.kind === "column" || object.kind === "index" || object.kind === "constraint") {
-    return object.identity.parent.name;
-  }
-  return;
-}
-function alterClass(sql) {
-  if (sql.includes("set data type") || sql.includes("set not null"))
-    return "contract";
-  return "expand";
-}
-function overall(steps) {
-  if (steps.some((item) => item.class === "contract"))
-    return "contract";
-  if (steps.some((item) => item.class === "unclassified"))
-    return "unclassified";
-  return "expand";
-}
-function updateSql(schema, table, column, from, to, cast = false) {
-  const value = to === null ? "null" : sqlString(to);
-  const compare = cast ? `${quoteIdent(column)}::text` : quoteIdent(column);
-  return `update ${qualify2(schema, table)} set ${quoteIdent(column)} = ${value} where ${compare} = ${sqlString(from)}`;
-}
-function hasTable(source, name) {
-  return source.objects.some((object) => object.kind === "table" && object.identity.name === name);
-}
-function hasColumn(source, table, name) {
-  return source.objects.some((object) => object.kind === "column" && object.identity.parent.name === table && object.identity.name === name);
-}
-function index(source) {
-  return source.objects.map((object) => ({ key: identityKey2(object.identity), object }));
-}
-function step(sql, classification, action, lock, transactional = true) {
-  return { sql, class: classification, action, lock, transactional };
-}
-function qualify2(schema, name) {
-  return `${quoteIdent(schema)}.${quoteIdent(name)}`;
-}
-function sqlString(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-function stable(value) {
-  return JSON.stringify(order(value));
-}
-function order(value) {
-  if (Array.isArray(value))
-    return value.map((item) => order(item));
-  if (value !== null && typeof value === "object") {
-    const record = value;
-    const next = {};
-    for (const key of Object.keys(record).sort())
-      next[key] = order(record[key]);
-    return next;
-  }
-  return value;
-}
-
-// src/tooling/migrate/policy.ts
-var READ = new Set([
-  "plan",
-  "status",
-  "check",
-  "drift",
-  "verify",
-  "pull",
-  "catalog-export",
-  "inspect"
-]);
-var ALLOWED = new Set(["expand", "reference", "provision"]);
-var FORWARD_ONLY = new Set(["drop", "rollback"]);
-function assertTargetPolicy(target, operation, allowProtected = false) {
-  if (FORWARD_ONLY.has(operation)) {
-    throw new OkmError2("invalid", "There is no down migration.", {
-      fix: { summary: "Recovery is a new forward migration." }
-    });
-  }
-  if (!target.protected || allowProtected)
-    return;
-  if (READ.has(operation) || ALLOWED.has(operation))
-    return;
-  throw new OkmError2("OKM1850", `${operation} is blocked on protected target ${target.name}.`, {
-    kind: "forbidden",
-    fix: {
-      summary: "Run a read-only command or an expand migration, or pass --allow-protected for this invocation."
-    }
-  });
-}
-function assertTargetAlias(targets) {
-  const groups = new Map;
-  for (const target of targets) {
-    const key = `${target.host}
-${target.port}
-${target.database}`;
-    const group = groups.get(key);
-    if (group === undefined)
-      groups.set(key, [target]);
-    else
-      group.push(target);
-  }
-  for (const group of groups.values()) {
-    const protectedTarget = group.find((target) => target.protected);
-    const open = group.find((target) => !target.protected);
-    if (protectedTarget !== undefined && open !== undefined) {
-      throw new OkmError2("OKM1852", `${open.name} and ${protectedTarget.name} resolve to the same database and disagree about protection.`, {
-        fix: {
-          summary: "Give those targets the same protection flag. okm check and okm doctor both report this."
-        }
-      });
-    }
-  }
-}
-function assertDirectConnection(url, allowPooler) {
-  if (allowPooler)
-    return;
-  const endpoint = endpointOf(url);
-  const parsed = new URL(url);
-  const host = endpoint.host;
-  if (host.includes("pooler") || host.includes("pgbouncer") || host.includes("-pooler") || endpoint.port === "6543" || parsed.searchParams.get("pgbouncer") === "true") {
-    throw new OkmError2("invalid", `Refusing pooler host ${host}. Apply needs a direct connection.`, { fix: { summary: "Use a direct connection, or pass --allow-pooler." } });
-  }
-}
-function listTargets(config) {
-  if (config.database !== undefined && config.targets !== undefined) {
-    throw new OkmError2("invalid", "Set database or targets, not both.", {
-      fix: { summary: "database is the one target named default. Use targets for more than one." }
-    });
-  }
-  const entries = [];
-  if (config.database !== undefined)
-    entries.push(["default", config.database]);
-  if (config.targets !== undefined) {
-    for (const name of Object.keys(config.targets).sort()) {
-      const input = config.targets[name];
-      if (input !== undefined)
-        entries.push([name, input]);
-    }
-  }
-  return entries.map(([name, input]) => resolveTarget(name, input));
-}
-function selectTarget(config, name) {
-  const targets = listTargets(config);
-  if (targets.length === 0) {
-    throw new OkmError2("OKM1845", "No target is configured.", {
-      fix: { summary: "Set database or targets in okmodel.config.ts." }
-    });
-  }
-  if (name === undefined) {
-    if (targets.length === 1) {
-      const only = targets[0];
-      if (only !== undefined)
-        return only;
-    }
-    throw new OkmError2("OKM1853", "Several targets are configured and --target was not passed.", {
-      fix: { summary: "Pass --target <name>. The command does not guess." }
-    });
-  }
-  const found = targets.find((target) => target.name === name);
-  if (found === undefined) {
-    throw new OkmError2("OKM1845", `Target ${name} is not configured.`, {
-      fix: { summary: "Pass a name from targets, or database for the target named default." }
-    });
-  }
-  return found;
-}
-function resolveTarget(name, input) {
-  const url = typeof input === "string" ? input : input.url;
-  const protectedTarget = typeof input === "string" ? false : input.protected === true;
-  if (url === undefined || url.length === 0) {
-    throw new OkmError2("OKM1845", `Target ${name} has no url.`, {
-      fix: { summary: "Set the target url. A target is not inferred from the environment." }
-    });
-  }
-  const endpoint = endpointOf(url);
-  return {
-    name,
-    url,
-    protected: protectedTarget,
-    host: endpoint.host,
-    port: endpoint.port,
-    database: endpoint.database
-  };
-}
-function endpointOf(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new OkmError2("OKM1845", "The target URL is not a Postgres URL.", {
-      fix: { summary: "Pass a postgres:// URL for the target." }
-    });
-  }
-  const database = decodeURIComponent(parsed.pathname.replace(/^\//, ""));
-  return {
-    host: parsed.hostname.toLowerCase(),
-    port: parsed.port.length > 0 ? parsed.port : "5432",
-    database
-  };
-}
-
-// src/tooling/migrate/project.ts
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, join } from "node:path";
-import { pathToFileURL } from "node:url";
-
-// src/tooling/errors/registry.ts
-var ERROR_DOCS = [
-  {
-    code: "OKM1012",
-    title: "Trait field conflict",
-    summary: "A trait added a field that the table already declares.",
-    fix: "Rename the table field or drop the trait that introduces it. The error names both."
-  },
-  {
-    code: "OKM1020",
-    title: "Unknown table",
-    summary: "A table, dependency, or catalog object is missing or does not match its identity.",
-    fix: "Use a name that is in the schema. The error lists the accepted names and a nearest-name hint when one is close."
-  },
-  {
-    code: "OKM1021",
-    title: "Foreign key target",
-    summary: "A foreign key is missing its target table or column, or the target is ambiguous.",
-    fix: "Name the referenced table and columns. The error lists the columns that exist on the target."
-  },
-  {
-    code: "OKM1022",
-    title: "Foreign key type",
-    summary: "A foreign key column and the column it references have different types.",
-    fix: "Give both columns the same type. The error names the type that is accepted."
-  },
-  {
-    code: "OKM1023",
-    title: "Duplicate name",
-    summary: "Two catalog objects share an identity, or two tables emit the same type name.",
-    fix: "Rename one of them. Table names and emitted type names must be unique in the schema."
-  },
-  {
-    code: "OKM1024",
-    title: "Table file not in schema",
-    summary: "A table file is not passed to schema().",
-    fix: "Add the file's table to the schema() call that okm check reads."
-  },
-  {
-    code: "OKM1025",
-    title: "Multiple Register",
-    summary: "More than one Register augmentation is in the project.",
-    fix: 'Keep a single declare module "okmodel" that sets schema. Pass an explicit schema type everywhere else.'
-  },
-  {
-    code: "OKM1026",
-    title: "Dependency cycle",
-    summary: "The catalog dependency graph contains a cycle, so objects cannot be ordered.",
-    fix: "Break the cycle. The error is raised while ordering the catalog."
-  },
-  {
-    code: "OKM1027",
-    title: "Unreadable catalog",
-    summary: "The catalog document is malformed or uses a version this build cannot read.",
-    fix: "Regenerate the catalog with this version of okmodel. Do not hand-edit the document."
-  },
-  {
-    code: "OKM1030",
-    title: "Validation in two places",
-    summary: "A field is validated both on the column and somewhere else.",
-    fix: "Keep one validation for the field. The error names the field."
-  },
-  {
-    code: "OKM1040",
-    title: "Preset name collision",
-    summary: "A preset uses the name of a client method or a reserved name, or a table and its traits (or two traits) define the same preset.",
-    fix: "Rename the preset. The error names both sources when two define it. okm upgrade renames a preset when a later release claims its name."
-  },
-  {
-    code: "OKM1051",
-    title: "Archive foreign key",
-    summary: "A foreign key into a table-strategy archivable table uses CASCADE, SET NULL, or SET DEFAULT and is not listed in cascade.",
-    fix: "List the child table, the foreign key, and its action in cascade, or use RESTRICT or NO ACTION."
-  },
-  {
-    code: "OKM1052",
-    title: "Not archivable",
-    summary: "archive or restore was called on a table that is not archivable.",
-    fix: "Call it only on an archivable table. The methods are absent from the types of other tables."
-  },
-  {
-    code: "OKM1060",
-    title: "Invalid column",
-    summary: "A column definition has a bad length, precision, scale, array rank, interval qualifier, or an empty or repeated picklist or enum.",
-    fix: "Use a value the error lists as accepted."
-  },
-  {
-    code: "OKM1061",
-    title: "Reserved option",
-    summary: "The option exists in the types but this version does not implement it.",
-    fix: "Remove the option until the prompt or milestone named in the error adds it."
-  },
-  {
-    code: "OKM1101",
-    title: "Find without limit",
-    summary: "find was called without a limit.",
-    fix: "Pass limit, or call .all(reason) when the full set is intentional."
-  },
-  {
-    code: "OKM1102",
-    title: "Unfiltered write",
-    summary: "update or delete would run with an empty where.",
-    fix: "Pass a filter. undefined in a write filter does not mean every row."
-  },
-  {
-    code: "OKM1104",
-    title: "Upsert target",
-    summary: "onConflict names columns that are not a unique constraint.",
-    fix: "Set on to the columns of a unique constraint or the primary key."
-  },
-  {
-    code: "OKM1105",
-    title: "Include without limit",
-    summary: "A to-many include has no limit.",
-    fix: "Pass limit on the include, or call .all(reason)."
-  },
-  {
-    code: "OKM1110",
-    title: "Engine version",
-    summary: "The feature needs a newer engine than schema({ requires }) allows.",
-    fix: "Raise requires, or stop using the feature. The error names both versions."
-  },
-  {
-    code: "OKM1111",
-    title: "Missing capability",
-    summary: "The call needs a driver capability this driver does not have.",
-    fix: "Use a driver that declares the capability, or drop the call. The error names the flag."
-  },
-  {
-    code: "OKM1120",
-    title: "Unknown field",
-    summary: "A field name in where, select, orderBy, or include is not on the table.",
-    fix: "Use a field from the catalog. The error includes a nearest-name hint when one is close."
-  },
-  {
-    code: "OKM1121",
-    title: "Object as value",
-    summary: "A plain object was passed where a value is required. JSON cannot create an operator.",
-    fix: "Wrap the value with eq. eq is the equality form for json and jsonb."
-  },
-  {
-    code: "OKM1122",
-    title: "Bad identifier",
-    summary: "An identifier is empty, too long, contains NUL or another control character, or is an unquoted reserved word.",
-    fix: "Use a shorter name without control characters. Quote is not accepted here. The error names the rule that failed."
-  },
-  {
-    code: "OKM1123",
-    title: "Hidden field allowlist",
-    summary: "A hidden field was added to a filter or sort allowlist.",
-    fix: "Remove the hidden field from the allowlist. Hidden fields stay out of caller filters and sorts."
-  },
-  {
-    code: "OKM1124",
-    title: "Operator mismatch",
-    summary: "An operator does not apply to the column type.",
-    fix: "Use an operator the error lists for that column type. Text search needs a tsvector column."
-  },
-  {
-    code: "OKM1130",
-    title: "Cursor order",
-    summary: "A cursor was reused with a different orderBy than the one that created it, or is not a cursor page() returned.",
-    fix: "Request the next page with the same orderBy and the exact next value the previous page returned. The cursor encodes that order."
-  },
-  {
-    code: "OKM1190",
-    title: "Safety violation",
-    summary: "A query composition broke a core invariant. violations lists every broken rule in stable order.",
-    fix: "Change the contribution named on the first violation, or pass an explicit escape hatch (unscoped, all, trusted, allow) and record the reason."
-  },
-  {
-    code: "OKM1191",
-    title: "No snapshot plan",
-    summary: "A multi-statement read was requested inside READ COMMITTED and no single-statement plan exists.",
-    fix: "Run the read in REPEATABLE READ or SERIALIZABLE, or shape it so it is one statement."
-  },
-  {
-    code: "OKM1200",
-    title: "Validation failed",
-    summary: "A write or a standalone check failed a validation rule. issues lists each path and message key.",
-    fix: "Fix the fields named in issues. Each issue message is a key, not display text."
-  },
-  {
-    code: "OKM1201",
-    title: "Validation not imported",
-    summary: VALIDATION_NOT_IMPORTED2,
-    fix: VALIDATION_NOT_IMPORTED_FIX2
-  },
-  {
-    code: "OKM1210",
-    title: "Codec rejected a value",
-    summary: "A codec refused a value: not numeric text, not a valid temporal value, or the wrong shape.",
-    fix: "Pass a value the error lists as accepted. A missing Temporal global tells you to assign one to globalThis.Temporal."
-  },
-  {
-    code: "OKM1401",
-    title: "Outcome unknown",
-    summary: "A commit or batch was sent and its result never arrived, so the write may or may not have happened.",
-    fix: "Check whether the write landed, using an idempotency key, before retrying. This error is never retried automatically."
-  },
-  {
-    code: "OKM1510",
-    title: "Unsafe migration",
-    summary: "A migration is not expand-safe and has no reason.",
-    fix: "Split the change into expand and contract, or pass a reason that CI can record."
-  },
-  {
-    code: "OKM1520",
-    title: "Schema drift",
-    summary: "The database has drifted past what an expand migration can repair.",
-    fix: "Inspect the diff and repair the database, or generate a migration that matches the drift."
-  },
-  {
-    code: "OKM1521",
-    title: "Snapshot mismatch",
-    summary: "Provisioning from the snapshot does not match the replayed migration history.",
-    fix: "Regenerate the snapshot from the history. okm migrate check is the command that reports this."
-  },
-  {
-    code: "OKM1522",
-    title: "Apply lock held",
-    summary: "Another apply already holds the target's migration lock.",
-    fix: "Wait for that apply to finish. Do not start a second apply against the same target."
-  },
-  {
-    code: "OKM1530",
-    title: "Ambiguous rename",
-    summary: "A rename could match more than one object.",
-    fix: "Declare the rename explicitly so the plan has one pairing."
-  },
-  {
-    code: "OKM1541",
-    title: "Picklist removal",
-    summary: "A picklist or enum value was removed and the replacement was not given.",
-    fix: "Pass --replace <table>.<column>.<old>=<new>, or =null on a nullable column. The replacement must be in the new list."
-  },
-  {
-    code: "OKM1542",
-    title: "Data statement",
-    summary: "A migration contains a data statement outside backfill().",
-    fix: "Move the statement into backfill(). Data changes are batched and resumable there."
-  },
-  {
-    code: "OKM1601",
-    title: "Stale typed SQL",
-    summary: "A typed SQL signature no longer matches the database.",
-    fix: "Regenerate the typed SQL and commit the new signature."
-  },
-  {
-    code: "OKM1701",
-    title: "Tenant context missing",
-    summary: "A tenant table was used on a client that has no tenant context.",
-    fix: "Open the client with the tenant context before reading or writing that table."
-  },
-  {
-    code: "OKM1702",
-    title: "Unverifiable tenant SQL",
-    summary: "Raw SQL touches a tenant table and the tenant predicate cannot be proved.",
-    fix: "Use the query builder, or mark the fragment trusted with a reason if it is reviewed."
-  },
-  {
-    code: "OKM1704",
-    title: "Tenant key change",
-    summary: "An update tried to change the tenant key.",
-    fix: "Remove the tenant key from the update. Moving a row between tenants is not an update."
-  },
-  {
-    code: "OKM1705",
-    title: "Global references tenant",
-    summary: "A global table references a tenant table.",
-    fix: "Drop the reference, or make the referencing table a tenant table."
-  },
-  {
-    code: "OKM1706",
-    title: "Tenant index",
-    summary: "An index on a tenant table does not lead with the tenant key.",
-    fix: "Put the tenant key first in the index columns."
-  },
-  {
-    code: "OKM1707",
-    title: "RLS role",
-    summary: "connect() was given a role that owns the tables or is a superuser, under the rls strategy.",
-    fix: "Connect as a role that is neither the owner nor a superuser."
-  },
-  {
-    code: "OKM1801",
-    title: "Dialect mismatch",
-    summary: "The schema dialect and the driver dialect are not the same.",
-    fix: "Open the schema with the driver package that matches it."
-  },
-  {
-    code: "OKM1802",
-    title: "Server version",
-    summary: "The connected server does not satisfy schema({ requires }).",
-    fix: "Upgrade the server, or lower requires to a version the server meets."
-  },
-  {
-    code: "OKM1803",
-    title: "Postgres floor",
-    summary: "The connected server is older than PostgreSQL 15, and the schema does not set requires to that older major.",
-    fix: "Upgrade the server to PostgreSQL 15 or newer, or set schema({ requires }) to the older major on purpose."
-  },
-  {
-    code: "OKM1810",
-    title: "Extension not declared",
-    summary: "An extension builder was used but the extension is not declared on the schema.",
-    fix: "Declare the extension next to the schema that uses it."
-  },
-  {
-    code: "OKM1811",
-    title: "Extension unavailable",
-    summary: "A declared extension is not installed on the server.",
-    fix: "Install the extension, or remove the declaration. okm doctor reports this against the connected server."
-  },
-  {
-    code: "OKM1812",
-    title: "Feature version",
-    summary: "A feature needs a newer Postgres or extension version than the one declared or connected.",
-    fix: 'Raise the declared version, or avoid the feature. uuidv7() below 18 can use t.id({ default: "uuidv4" }), defaults.id set to "uuidv4", or a client generator. Core features are never gated on an extension.'
-  },
-  {
-    code: "OKM1813",
-    title: "Extension defined twice",
-    summary: "The same extension definition was registered twice.",
-    fix: "Keep one definition. A second copy fails at build."
-  },
-  {
-    code: "OKM1814",
-    title: "Extension change refused",
-    summary: "The plan would downgrade an extension, move a non-relocatable one, or drop one that still has dependents.",
-    fix: "Drop or move the dependents first. Postgres cannot lower an extension version."
-  },
-  {
-    code: "OKM1820",
-    title: "View tenancy",
-    summary: "A view over tenant tables does not expose the tenant key and is not marked global.",
-    fix: "Expose the tenant key so the predicate can be applied, or declare global(reason)."
-  },
-  {
-    code: "OKM1821",
-    title: "Replace needs recreate",
-    summary: "An incompatible replace would have to recreate dependents. CASCADE is never used.",
-    fix: "Review the dependents the plan lists and recreate them explicitly."
-  },
-  {
-    code: "OKM1822",
-    title: "Concurrent refresh",
-    summary: "REFRESH CONCURRENTLY was declared without a unique index on the materialized view.",
-    fix: "Add a unique index, or refresh without CONCURRENTLY."
-  },
-  {
-    code: "OKM1823",
-    title: "Security definer path",
-    summary: "A SECURITY DEFINER function has no search_path.",
-    fix: "Set search_path on the function to the schemas it is allowed to see."
-  },
-  {
-    code: "OKM1824",
-    title: "Function dependencies",
-    summary: "A plpgsql function has no dependsOn. Postgres does not record dependencies inside the body.",
-    fix: "List dependsOn. LANGUAGE sql with BEGIN ATOMIC is inferred and does not need the list."
-  },
-  {
-    code: "OKM1825",
-    title: "Missing privilege",
-    summary: "The application role lacks a privilege on a managed object.",
-    fix: "Grant the privilege, or change the role. okm doctor reports the object and the privilege."
-  },
-  {
-    code: "OKM1830",
-    title: "Lock outside transaction",
-    summary: "find was called with a row lock outside tx().",
-    fix: "Take the lock inside tx(). Advisory locks are transaction-scoped too."
-  },
-  {
-    code: "OKM1840",
-    title: "Replica not allowed",
-    summary: ".replica() was used on an operation that requires the primary, or inside tx().",
-    fix: "Run the operation on the primary. Writes, batch, locks, and tx() never go to a replica."
-  },
-  {
-    code: "OKM1841",
-    title: "External object differs",
-    summary: "An external object does not match the owner's exported catalog.",
-    fix: "Update the dependency's export, or stop treating the object as external."
-  },
-  {
-    code: "OKM1842",
-    title: "Cross-database foreign key",
-    summary: "A foreign key points at a table in another database.",
-    fix: "Keep the foreign key inside one database. Cross-catalog keys are allowed only there."
-  },
-  {
-    code: "OKM1843",
-    title: "No eligible replica",
-    summary: "A replica was required and none is eligible: unhealthy, behind the session, or none configured.",
-    fix: "Configure a replica or drop .replica(). This call does not read the primary."
-  },
-  {
-    code: "OKM1844",
-    title: "Fallback refused",
-    summary: "An automatic read found no eligible replica and fallback is error.",
-    fix: "Restore a replica, or set fallback to primary if the primary should absorb the read."
-  },
-  {
-    code: "OKM1845",
-    title: "Target unresolved",
-    summary: "The target could not be resolved. The tenant is unknown or the resolver failed.",
-    fix: "Check the tenant id and the resolver. Connection details are not guessed."
-  },
-  {
-    code: "OKM1846",
-    title: "Acquire timeout",
-    summary: "The pool did not hand out a connection within timeouts.acquire.",
-    fix: "Raise timeouts.acquire, or stop holding connections. The wait does not spill into another pool."
-  },
-  {
-    code: "OKM1850",
-    title: "Protected target",
-    summary: "The operation is blocked on a protected target and --allow-protected was not passed.",
-    fix: "Run a read-only command or an expand migration, or pass --allow-protected for this invocation."
-  },
-  {
-    code: "OKM1851",
-    title: "Target not empty",
-    summary: "Provisioning was asked to fill a target that already has objects.",
-    fix: "Provision an empty schema or an empty database. A non-empty target is refused."
-  },
-  {
-    code: "OKM1852",
-    title: "Protection mismatch",
-    summary: "Targets that resolve to the same database disagree about protection, or tenants of one schema-per-tenant database do.",
-    fix: "Give those targets the same protection flag. okm check and okm doctor both report this."
-  },
-  {
-    code: "OKM1853",
-    title: "Target not named",
-    summary: "Several targets are configured and the command was not given --target.",
-    fix: "Pass --target <name>. The command does not guess."
-  }
-];
-var byCode;
-function errorDoc(code) {
-  const index = byCode ?? indexDocs();
-  return index.get(code);
-}
-function indexDocs() {
-  const index = new Map;
-  for (const doc of ERROR_DOCS)
-    index.set(doc.code, doc);
-  byCode = index;
-  return index;
-}
-
-// src/dialects/pg/declarations.ts
-function schemaDeclarations(source) {
-  const renames = [];
-  for (const item of source.tables) {
-    const tableName = sqlTableName(item, source.casing);
-    const renamed = tableRenamedFrom(item);
-    if (renamed !== undefined) {
-      renames.push({ kind: "table", from: renamed, to: tableName });
-    }
-    for (const [field, value] of Object.entries(item.columns)) {
-      if (!(value instanceof ColumnBuilder2))
-        continue;
-      const state = value.state;
-      const columnName = state.sqlName ?? sqlIdentifier(field, source.casing);
-      if (state.renamedFrom !== undefined) {
-        renames.push({
-          kind: "column",
-          table: tableName,
-          from: state.renamedFrom,
-          to: columnName
-        });
-      }
-    }
-  }
-  return { renames };
-}
-function sqlTableName(item, casing) {
-  const options = item.options;
-  return options?.sqlName ?? sqlIdentifier(item.name, casing);
-}
-function tableRenamedFrom(item) {
-  const options = item.options;
-  return options?.renamedFrom;
-}
-function sqlIdentifier(name, casing) {
-  return casing === "snake" ? snakeCase(name) : name;
-}
-
-// src/dialects/pg/emit.ts
-function emitRowTypes(source) {
-  const lines = [
-    "/**",
-    " * Row types emitted from the schema.",
-    ` * Mode: ${source.types}.`,
-    " */",
-    ""
-  ];
-  const rows = [];
-  const inserts = [];
-  const updates = [];
-  for (const item of source.tables) {
-    const name = emittedTypeName(item.name);
-    const key = propertyName(item.name);
-    rows.push(`  readonly ${key}: ${name};`);
-    inserts.push(`  readonly ${key}: ${name}Insert;`);
-    updates.push(`  readonly ${key}: ${name}Update;`);
-    lines.push(`export interface ${name} {`);
-    lines.push(fields(item, "row", source));
-    lines.push("}", "");
-    lines.push(`export interface ${name}Insert {`);
-    lines.push(fields(item, "insert", source));
-    lines.push("}", "");
-    lines.push(`export interface ${name}Update {`);
-    lines.push(fields(item, "update", source));
-    lines.push("}", "");
-  }
-  lines.push("export interface Rows {");
-  lines.push(rows.join(`
-`));
-  lines.push("}", "");
-  lines.push("export interface Inserts {");
-  lines.push(inserts.join(`
-`));
-  lines.push("}", "");
-  lines.push("export interface Updates {");
-  lines.push(updates.join(`
-`));
-  lines.push("}");
-  return `${lines.join(`
-`)}
-`;
-}
-function propertyName(name) {
-  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : JSON.stringify(name);
-}
-function fields(item, kind, source) {
-  const printed = [];
-  const options = item.options;
-  const entries = Object.entries(item.columns);
-  for (const pair of contributedFields(source.traits, options)) {
-    if (!Object.hasOwn(item.columns, pair[0]))
-      entries.push([pair[0], pair[1]]);
-  }
-  if (source.tenancy !== undefined && options?.tenancy?.kind !== "global" && !Object.hasOwn(item.columns, source.tenancy.key)) {
-    entries.push([source.tenancy.key, source.tenancy.column()]);
-  }
-  for (const [field, builder] of entries) {
-    if (!(builder instanceof ColumnBuilder2)) {
-      continue;
-    }
-    const state = builder.state;
-    if (kind === "row") {
-      if (!state.hidden) {
-        printed.push(`  readonly ${field}: ${valueType(state, "required")};`);
-      }
-      continue;
-    }
-    const written = kind === "update" ? updateMode(state) : insertMode(state);
-    if (written === "omit") {
-      continue;
-    }
-    const mode = kind === "update" ? "optional" : written;
-    printed.push(`  readonly ${field}: ${valueType(state, mode)};`);
-  }
-  return printed.join(`
-`);
-}
-function insertMode(state) {
-  if (state.omitWrite || state.generated !== undefined || state.guarded) {
-    return "omit";
-  }
-  if (state.hasDefault || state.nullable) {
-    return "optional";
-  }
-  return "required";
-}
-function updateMode(state) {
-  if (state.omitUpdate || insertMode(state) === "omit")
-    return "omit";
-  return "optional";
-}
-function valueType(state, mode) {
-  let label = scalarLabel(state);
-  if (state.dims > 0) {
-    for (let rank = 0;rank < state.dims; rank += 1) {
-      label = `readonly (${label})[]`;
-    }
-  }
-  if (state.nullable) {
-    label += " | null";
-  }
-  if (mode === "optional") {
-    label += " | undefined";
-  }
-  return label;
-}
-function scalarLabel(state) {
-  if (state.picklist !== undefined) {
-    return state.picklist.values.map((value) => JSON.stringify(value)).join(" | ");
-  }
-  if (state.typeLabel !== undefined) {
-    return state.typeLabel;
-  }
-  const base = baseName(state.baseType);
-  switch (base) {
-    case "smallint":
-    case "integer":
-    case "real":
-    case "double precision":
-      return "number";
-    case "bigint":
-    case "numeric":
-    case "text":
-    case "varchar":
-    case "char":
-    case "citext":
-    case "uuid":
-    case "inet":
-    case "cidr":
-    case "macaddr":
-    case "macaddr8":
-    case "tsvector":
-    case "ltree":
-      return "string";
-    case "boolean":
-      return "boolean";
-    case "bytea":
-      return "Uint8Array";
-    case "json":
-    case "jsonb":
-      return "unknown";
-    case "timestamptz":
-      return "Temporal.Instant";
-    case "timestamp":
-      return "Temporal.PlainDateTime";
-    case "date":
-      return "Temporal.PlainDate";
-    case "time":
-      return "Temporal.PlainTime";
-    case "timetz":
-      return "{ readonly time: Temporal.PlainTime; readonly offset: string }";
-    case "interval":
-      return "Temporal.Duration";
-    case "tstzrange":
-      return rangeLabel("Temporal.Instant");
-    case "daterange":
-      return rangeLabel("Temporal.PlainDate");
-    case "int4range":
-      return rangeLabel("number");
-    case "int8range":
-    case "numrange":
-      return rangeLabel("string");
-    case "point":
-      return "{ readonly x: number; readonly y: number }";
-    case "line":
-      return "{ readonly a: number; readonly b: number; readonly c: number }";
-    default:
-      return "unknown";
-  }
-}
-function rangeLabel(bound) {
-  return `{ readonly empty: true } | { readonly empty: false; readonly lower: ${bound} | null; readonly upper: ${bound} | null; readonly lowerInclusive: boolean; readonly upperInclusive: boolean }`;
-}
-function baseName(dataType) {
-  if (dataType.startsWith("double precision")) {
-    return "double precision";
-  }
-  const space = dataType.indexOf(" ");
-  const head = space === -1 ? dataType : dataType.slice(0, space);
-  const paren = head.indexOf("(");
-  return paren === -1 ? head : head.slice(0, paren);
-}
-
-// src/tooling/migrate/project.ts
-async function buildProject(cwd) {
-  const config = await loadConfig(cwd);
-  const built = await loadSchema(cwd, config.schema);
-  return writeArtifact(cwd, config, built);
-}
-async function generateProject(cwd, name, flags) {
-  const prepared = await prepare(cwd, name, flags);
-  writeArtifact(cwd, prepared.config, prepared.built);
-  if (prepared.plan.steps.length === 0)
-    return;
-  const directory = join(cwd, prepared.config.migrations ?? "migrations");
-  mkdirSync(directory, { recursive: true });
-  const base = `${nextNumber(directory)}_${safeName(name)}`;
-  const sqlPath = join(directory, `${base}.sql`);
-  writeFileSync(sqlPath, formatPlan(prepared.plan));
-  writeFileSync(join(directory, `${base}.catalog.json`), serializeCatalog2(prepared.built.catalog));
-  return sqlPath;
-}
-async function planProject(cwd, name, flags) {
-  const prepared = await prepare(cwd, name, flags);
-  return prepared.plan;
-}
-async function checkProject(cwd) {
-  const opened = await openProject(cwd);
-  assertValidation(opened.built);
-  if (schemaRequestsValidation(opened.built) && !projectImportsValidate(cwd)) {
-    const doc = errorDoc("OKM1201");
-    if (doc === undefined)
-      throw new Error("OKM1201 missing from the error registry.");
-    throw new OkmError2(doc.code, doc.summary, { fix: { summary: doc.fix } });
-  }
-  assertTargetAlias(listTargets(opened.config));
-  if (opened.config.tables !== undefined) {
-    const directory = join(cwd, opened.config.tables);
-    const files = existsSync(directory) ? readdirSync(directory) : [];
-    const source = readFileSync(join(cwd, opened.config.schema), "utf8");
-    const missing = unlistedTableFiles(source, files);
-    if (missing.length > 0) {
-      throw new OkmError2("OKM1024", `Table file not in schema: ${missing.join(", ")}.`, {
-        fix: { summary: "Add the file's table to the schema() call that okm check reads." }
-      });
-    }
-  }
-}
-function unlistedTableFiles(schemaSource, fileNames) {
-  const missing = [];
-  for (const file of fileNames) {
-    if (!file.endsWith(".ts"))
-      continue;
-    const stem = basename(file, ".ts");
-    if (stem.length === 0 || stem.startsWith("."))
-      continue;
-    if (!schemaSource.includes(stem))
-      missing.push(file);
-  }
-  return missing;
-}
-async function projectHead(cwd) {
-  const opened = await openProject(cwd);
-  return { previous: opened.previous, catalog: opened.built.catalog, renames: opened.renames };
-}
-async function prepare(cwd, name, flags) {
-  const opened = await openProject(cwd);
-  const plan = planMigration({
-    before: opened.previous,
-    after: opened.built.catalog,
-    renames: opened.renames,
-    replacements: flags.map((flag) => parseReplace(flag)),
-    name
-  });
-  return { config: opened.config, built: opened.built, plan };
-}
-async function openProject(cwd) {
-  const config = await loadConfig(cwd);
-  const built = await loadSchema(cwd, config.schema);
-  const declarations = schemaDeclarations(built);
-  const previous = readPrevious(join(cwd, config.migrations ?? "migrations"));
-  const stale = staleRenames(previous?.catalog, declarations.renames);
-  if (stale.length > 0) {
-    throw new OkmError2("OKM1020", stale.join(" "), {
-      fix: { summary: "Remove renamedFrom once the migration that used it has been applied." }
-    });
-  }
-  return {
-    config,
-    built,
-    previous: previous?.catalog ?? catalog([]),
-    renames: declarations.renames
-  };
-}
-function writeArtifact(cwd, config, built) {
-  const directory = join(cwd, config.out ?? ".okm");
-  mkdirSync(directory, { recursive: true });
-  const text = serializeCatalog2(built.catalog);
-  writeFileSync(join(directory, "catalog.json"), text);
-  writeFileSync(join(directory, "catalog.hash"), `${catalogHash2(built.catalog)}
-`);
-  writeFileSync(join(directory, "types.d.ts"), `${emitRowTypes(built)}${referenceAugmentation(built)}`);
-  return directory;
-}
-async function loadConfig(cwd) {
-  const path = join(cwd, "okmodel.config.ts");
-  const imported = await import(`${pathToFileURL(path).href}?okm=${Date.now()}`);
-  const record = isRecord(imported) ? imported : {};
-  const config = record.default ?? record.config;
-  if (!isConfig(config)) {
-    throw new OkmError2("invalid", "okmodel.config.ts must default-export defineConfig(...).");
-  }
-  return config;
-}
-async function loadSchema(cwd, spec) {
-  const path = join(cwd, spec);
-  const imported = await import(`${pathToFileURL(path).href}?okm=${Date.now()}`);
-  const record = isRecord(imported) ? imported : {};
-  for (const value of Object.values(record)) {
-    if (!isBuilt(value))
-      continue;
-    value.catalog;
-    return value;
-  }
-  throw new OkmError2("invalid", `${spec} must export a schema().`);
-}
-function readPrevious(directory) {
-  if (!existsSync(directory))
-    return;
-  const catalogs = readdirSync(directory).filter((file) => file.endsWith(".catalog.json")).sort();
-  const latest = catalogs.at(-1);
-  if (latest === undefined)
-    return;
-  const text = readFileSync(join(directory, latest), "utf8");
-  return { catalog: parseCatalog2(text) };
-}
-function referenceAugmentation(source) {
-  const names = source.tables.map((item) => JSON.stringify(item.name));
-  const union = names.length === 0 ? "never" : names.join(" | ");
-  return [
-    'import type { ColumnFlags, ReferenceOptions } from "okmodel/pg";',
-    "",
-    'declare module "okmodel/pg" {',
-    "  interface ColumnBuilder<TValue, TFlags extends ColumnFlags> {",
-    "    references(",
-    `      table: ${union},`,
-    "      options?: ReferenceOptions,",
-    "    ): ColumnBuilder<TValue, TFlags>;",
-    "  }",
-    "}",
-    "",
-    `export type TableName = ${union};`,
-    ""
-  ].join(`
-`);
-}
-function nextNumber(directory) {
-  let max = 0;
-  if (existsSync(directory)) {
-    for (const file of readdirSync(directory)) {
-      const match = /^(\d+)_/.exec(file);
-      const value = match?.[1];
-      if (value !== undefined)
-        max = Math.max(max, Number(value));
-    }
-  }
-  return String(max + 1).padStart(4, "0");
-}
-function safeName(name) {
-  if (!/^[A-Za-z0-9_-]+$/.test(name)) {
-    throw new OkmError2("invalid", `Migration name ${name} must be letters, digits, _ or -.`);
-  }
-  return name;
-}
-function isBuilt(value) {
-  if (!isRecord(value) || !Array.isArray(value.tables))
-    return false;
-  return "catalog" in value;
-}
-function isConfig(value) {
-  return isRecord(value) && typeof value.schema === "string";
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-var SKIP_SCAN = new Set(["node_modules", "dist", "coverage"]);
-function schemaRequestsValidation(built) {
-  const flag = built.validation;
-  for (const item of built.tables) {
-    if (writeWouldValidate(flag, item, {}))
-      return true;
-  }
-  return false;
-}
-function projectImportsValidate(cwd) {
-  return directoryImportsValidate(cwd);
-}
-function directoryImportsValidate(dir) {
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return false;
-  }
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") || SKIP_SCAN.has(entry.name))
-      continue;
-    const path = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (directoryImportsValidate(path))
-        return true;
-      continue;
-    }
-    if (!/\.(?:ts|tsx|mts|cts)$/.test(entry.name))
-      continue;
-    if (runtimeImportsValidate(readFileSync(path, "utf8")))
-      return true;
-  }
-  return false;
-}
-function runtimeImportsValidate(source) {
-  const text = source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
-  const pattern = /["']okmodel\/validate(?:\.js)?["']/g;
-  for (const match of text.matchAll(pattern)) {
-    const index = match.index ?? 0;
-    const lead = text.slice(Math.max(0, index - 240), index);
-    const start = Math.max(lead.lastIndexOf(`
-`), lead.lastIndexOf(";"));
-    const head = lead.slice(start + 1);
-    if (/\bimport\s+type\b/.test(head) || /\bexport\s+type\b/.test(head))
-      continue;
-    if (/\bimport\b/.test(head) || /\bexport\b/.test(head))
-      return true;
-  }
-  return false;
-}
-
-export { quoteIdent, planMigration, formatPlan, parsePlan, assertTargetPolicy, assertDirectConnection, listTargets, selectTarget, buildProject, generateProject, planProject, checkProject, projectHead, loadConfig };