okmodel 0.0.0 → 0.1.0

package/dist/shared/kynx7vbm.js

@@ -0,0 +1,1490 @@
+import {
+  creationOrder2,
+  renameColumn2,
+  renameTable2,
+  serializeCatalog2,
+  catalogHash2,
+  parseCatalog2
+} from "./y9m15dfv.js";
+import {
+  quoteLiteral,
+  ColumnBuilder2,
+  snakeCase,
+  emittedTypeName
+} from "./gk7cs7sp.js";
+import {
+  catalog,
+  sameEnumLabels
+} from "./g5fhqmwe.js";
+import {
+  staticNamespace2,
+  identityKey2,
+  compareText
+} from "./j5cn2963.js";
+import {
+  OkmError2
+} from "./ycwz42az.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);
+  if (before.definition.dataType !== after.definition.dataType) {
+    statements.push(`alter table ${table} alter column ${name} set data type ${after.definition.dataType} using ${name}::${after.definition.dataType}`);
+  }
+  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 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}`;
+  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);
+  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 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.identity) === stable(after.definition.identity) && stable(before.definition.generated) === stable(after.definition.generated);
+}
+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" && identitySequence(object, source))
+    return true;
+  return false;
+}
+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/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"));
+    lines.push("}", "");
+    lines.push(`export interface ${name}Insert {`);
+    lines.push(fields(item, "insert"));
+    lines.push("}", "");
+    lines.push(`export interface ${name}Update {`);
+    lines.push(fields(item, "update"));
+    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) {
+  const printed = [];
+  for (const [field, builder] of Object.entries(item.columns)) {
+    if (!(builder instanceof ColumnBuilder2)) {
+      continue;
+    }
+    const state = builder.state;
+    const written = insertMode(state);
+    if (kind === "row") {
+      if (!state.hidden) {
+        printed.push(`  readonly ${field}: ${valueType(state, "required")};`);
+      }
+      continue;
+    }
+    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 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);
+  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;
+}
+
+export { quoteIdent, planMigration, formatPlan, parsePlan, assertTargetPolicy, assertDirectConnection, listTargets, selectTarget, buildProject, generateProject, planProject, checkProject, projectHead, loadConfig };