okmodel 0.3.0 → 0.4.0

package/dist/shared/{5nmdenb6.js → q6zsyh31.js}

@@ -9,13 +9,20 @@ import {
   serializeCatalog2,
   catalogHash2,
   parseCatalog2
-} from "./t616ynfn.js";
+} from "./8jb4ymh2.js";
 import {
+  open2
+} from "./wqem4jed.js";
+import {
+  canonicalTypeName,
+  batchSizeField,
+  aboutBatchCount,
   parseReplace,
   planMigration,
   formatPlan,
+  parsePlan,
   staleRenames
-} from "./2ssqrv66.js";
+} from "./n5y9zyj1.js";
 import {
   contributedFields
 } from "./n0dgs0pb.js";
@@ -24,12 +31,13 @@ import {
   writeWouldValidate
 } from "./9m80mkac.js";
 import {
-  catalog
-} from "./jkc6ws1p.js";
+  catalog,
+  isDomain
+} from "./g7ez901n.js";
 import {
   snakeCase,
   emittedTypeName
-} from "./6w5j844a.js";
+} from "./jsd07prz.js";
 import {
   ColumnBuilder2
 } from "./c9z5g0fm.js";
@@ -243,8 +251,62 @@ var ERROR_DOCS = [
   {
     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."
+    summary: "A migration has an unresolved lint error, or an override with an empty reason or a code the statement did not trigger.",
+    fix: "Put `-- okm-allow OKM15xx: reason` on the line above the statement. The code must be one that statement triggered, and the reason must not be empty."
+  },
+  {
+    code: "OKM1511",
+    title: "Drop table",
+    summary: "A statement drops a table. The rows and anything that reads them are gone.",
+    fix: "Stop reading the table in an expand migration, then drop it in a later contract. Or allow OKM1511 with a reason."
+  },
+  {
+    code: "OKM1512",
+    title: "Drop column",
+    summary: "A statement drops a column. Stored values and the code that reads them are gone.",
+    fix: "Stop reading the column in an expand migration, then drop it in a later contract. Or allow OKM1512 with a reason."
+  },
+  {
+    code: "OKM1513",
+    title: "Drop enum",
+    summary: "A statement drops an enum that columns or code may still depend on.",
+    fix: "Move every column off the enum first. Or allow OKM1513 with a reason."
+  },
+  {
+    code: "OKM1514",
+    title: "Drop domain",
+    summary: "A statement drops a domain that columns or code may still depend on.",
+    fix: "Move every column off the domain first. Or allow OKM1514 with a reason."
+  },
+  {
+    code: "OKM1515",
+    title: "Drop function",
+    summary: "A statement drops a function that queries or triggers may still call.",
+    fix: "Remove the callers in an expand migration, then drop the function. Or allow OKM1515 with a reason."
+  },
+  {
+    code: "OKM1516",
+    title: "Drop view",
+    summary: "A statement drops a view that queries may still read.",
+    fix: "Stop reading the view in an expand migration, then drop it. Or allow OKM1516 with a reason."
+  },
+  {
+    code: "OKM1517",
+    title: "Drop extension",
+    summary: "A statement drops an extension. A dependent still in the catalog is refused before this finding.",
+    fix: "Confirm nothing outside the catalog uses the extension. Or allow OKM1517 with a reason."
+  },
+  {
+    code: "OKM1518",
+    title: "Drop materialized view",
+    summary: "A statement drops a materialized view and the rows it stores.",
+    fix: "Stop reading the view in an expand migration, then drop it. Or allow OKM1518 with a reason."
+  },
+  {
+    code: "OKM1519",
+    title: "Rename column",
+    summary: "A statement renames a column. Existing queries still use the old name.",
+    fix: "Add the new column, backfill, and switch readers before dropping the old name. Or allow OKM1519 with a reason."
   },
   {
     code: "OKM1520",
@@ -256,7 +318,7 @@ var ERROR_DOCS = [
     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."
+    fix: "Regenerate the snapshot from the history. okm migrate check --provision is the command that reports this."
   },
   {
     code: "OKM1522",
@@ -264,12 +326,114 @@ var ERROR_DOCS = [
     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: "OKM1523",
+    title: "Rename table",
+    summary: "A statement renames a table. Existing queries still use the old name.",
+    fix: "Create the new table, backfill, and switch readers before dropping the old name. Or allow OKM1523 with a reason."
+  },
+  {
+    code: "OKM1524",
+    title: "Column type change",
+    summary: "A statement changes a column type. Existing readers and writers may not accept the new type.",
+    fix: "Add a new column, backfill, and switch readers before dropping the old one. Or allow OKM1524 with a reason."
+  },
+  {
+    code: "OKM1525",
+    title: "Required column",
+    summary: "A statement adds a NOT NULL column with no default to a table that already has rows.",
+    fix: "Add the column nullable, backfill, then set it NOT NULL. Or allow OKM1525 with a reason."
+  },
+  {
+    code: "OKM1526",
+    title: "Drop default",
+    summary: "A statement removes a column default. Writers that omitted the column will fail.",
+    fix: "Update writers to send the column, then drop the default. Or allow OKM1526 with a reason."
+  },
+  {
+    code: "OKM1527",
+    title: "Shrink length",
+    summary: "A statement shortens a character length. Values longer than the new limit no longer fit.",
+    fix: "Shorten the stored values first, or keep the old length. Or allow OKM1527 with a reason."
+  },
+  {
+    code: "OKM1528",
+    title: "Unique constraint",
+    summary: "A statement adds a unique or primary-key constraint on a table that already has rows.",
+    fix: "Deduplicate the rows first. Or allow OKM1528 with a reason."
+  },
+  {
+    code: "OKM1529",
+    title: "Unique index",
+    summary: "A statement creates a unique index on a table that already has rows.",
+    fix: "Deduplicate the rows first. Or allow OKM1529 with a reason."
+  },
   {
     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: "OKM1531",
+    title: "Validating check",
+    summary: "A statement adds or validates a check against rows already stored.",
+    fix: "Add the check NOT VALID, repair the rows, then validate it. Or allow OKM1531 with a reason."
+  },
+  {
+    code: "OKM1532",
+    title: "Validating foreign key",
+    summary: "A statement adds or validates a foreign key against rows already stored.",
+    fix: "Add the foreign key NOT VALID, repair the rows, then validate it. Or allow OKM1532 with a reason."
+  },
+  {
+    code: "OKM1533",
+    title: "Narrowing type",
+    summary: "A statement narrows a numeric or integer type. Values outside the new range no longer fit.",
+    fix: "Rewrite the values into the new range first. Or allow OKM1533 with a reason."
+  },
+  {
+    code: "OKM1534",
+    title: "Index locks",
+    summary: "A statement creates an index on an existing table without CONCURRENTLY.",
+    fix: "Create the index with CREATE INDEX CONCURRENTLY, outside a transaction. The planner does this on an existing table."
+  },
+  {
+    code: "OKM1535",
+    title: "Check without NOT VALID",
+    summary: "A statement adds a check on an existing table without NOT VALID.",
+    fix: "Add the check NOT VALID, then validate it in its own step. The planner does this on an existing table."
+  },
+  {
+    code: "OKM1536",
+    title: "Foreign key without NOT VALID",
+    summary: "A statement adds a foreign key on an existing table without NOT VALID.",
+    fix: "Add the foreign key NOT VALID, then validate it in its own step. The planner does this on an existing table."
+  },
+  {
+    code: "OKM1537",
+    title: "Set not null",
+    summary: "A statement sets NOT NULL on a column that already exists.",
+    fix: "Add CHECK (column IS NOT NULL) NOT VALID, validate it, then SET NOT NULL and drop the check. The planner does this on an existing column."
+  },
+  {
+    code: "OKM1538",
+    title: "Type rewrite",
+    summary: "A statement changes a column type in a way that rewrites the table.",
+    fix: "There is no safe form for a rewriting type change in this version. A column swap is expand and contract work for a later step. OKM1524 already requires a reason for the type change."
+  },
+  {
+    code: "OKM1539",
+    title: "Timestamp without time zone",
+    summary: "A column is timestamp without time zone. The instant depends on the session time zone.",
+    fix: "Use timestamptz."
+  },
+  {
+    code: "OKM1540",
+    title: "varchar length",
+    summary: "A column is varchar(n). text stores the same values without a length limit in the type.",
+    fix: "Use text, and check the length in the application when one is required."
+  },
   {
     code: "OKM1541",
     title: "Picklist removal",
@@ -282,6 +446,48 @@ var ERROR_DOCS = [
     summary: "A migration contains a data statement outside backfill().",
     fix: "Move the statement into backfill(). Data changes are batched and resumable there."
   },
+  {
+    code: "OKM1543",
+    title: "serial column",
+    summary: "A column uses serial or a nextval default. Identity is the form this repo generates.",
+    fix: "Use an identity column generated always."
+  },
+  {
+    code: "OKM1544",
+    title: "json column",
+    summary: "A column is json. jsonb is available and stores the same documents in binary.",
+    fix: "Use jsonb."
+  },
+  {
+    code: "OKM1545",
+    title: "Identity not always",
+    summary: "An identity column is generated by default. The repo default is generated always.",
+    fix: "Declare the identity as generated always."
+  },
+  {
+    code: "OKM1546",
+    title: "Backfill key",
+    summary: "A backfill step targets a table that has no primary key.",
+    fix: "Add a primary key. A backfill walks that key and does not scan the table."
+  },
+  {
+    code: "OKM1547",
+    title: "History differs",
+    summary: "Replaying a migration does not match its stored catalog, or the file was generated from a different parent than the previous migration.",
+    fix: "Regenerate the migration from the previous catalog so the SQL and the stored catalog describe the same schema."
+  },
+  {
+    code: "OKM1548",
+    title: "Previous catalog",
+    summary: "An expand migration drops or changes a table, column, constraint, or type the previous catalog relies on.",
+    fix: "Keep every table, column, constraint, and type the previous catalog relies on, or classify the migration as contract."
+  },
+  {
+    code: "OKM1549",
+    title: "Stale head",
+    summary: "The last migration's catalog does not match the schema.",
+    fix: "Run okm generate."
+  },
   {
     code: "OKM1601",
     title: "Stale typed SQL",
@@ -494,6 +700,532 @@ function indexDocs() {
   return index;
 }
 
+// src/tooling/migrate/lint.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/tooling/migrate/lint-rules.ts
+var INTEGER_WIDTH = {
+  smallint: 2,
+  integer: 4,
+  bigint: 8
+};
+var FLOAT_WIDTH = {
+  real: 4,
+  "double precision": 8
+};
+var STEP_RULES = [
+  rule("OKM1511", "destructive", "error", "Dropping a table destroys its rows.", (input) => hit(matches(input.step, "drop-table", /^drop table\b/), "drops a table")),
+  rule("OKM1512", "destructive", "error", "Dropping a column destroys its values.", (input) => hit(matches(input.step, "drop-column", /^alter table\s+\S+\s+drop column\b/), "drops a column")),
+  rule("OKM1513", "destructive", "error", "Dropping an enum can break columns that use it.", (input) => hit(droppedType(input) === "enum", "drops an enum")),
+  rule("OKM1514", "destructive", "error", "Dropping a domain can break columns that use it.", (input) => hit(droppedType(input) === "domain", "drops a domain")),
+  rule("OKM1515", "destructive", "error", "Dropping a function can break its callers.", (input) => hit(matches(input.step, "drop-function", /^drop function\b/), "drops a function")),
+  rule("OKM1516", "destructive", "error", "Dropping a view can break queries that read it.", (input) => hit(matches(input.step, "drop-view", /^drop view\b/), "drops a view")),
+  rule("OKM1517", "destructive", "error", "Dropping an extension removes it even when the catalog has no dependent.", (input) => hit(matches(input.step, "drop-extension", /^drop extension\b/), "drops an extension")),
+  rule("OKM1518", "destructive", "error", "Dropping a materialized view destroys the rows it stores.", (input) => hit(matches(input.step, "drop-matview", /^drop materialized view\b/), "drops a materialized view")),
+  rule("OKM1519", "backward-incompatible", "error", "Renaming a column breaks queries that still use the old name.", (input) => hit(matches(input.step, "rename-column", /^alter table\s+\S+\s+rename column\b/), "renames a column")),
+  rule("OKM1523", "backward-incompatible", "error", "Renaming a table breaks queries that still use the old name.", (input) => hit(renamesTable(input.step), "renames a table")),
+  rule("OKM1524", "backward-incompatible", "error", "Changing a column type can break readers and writers.", (input) => typeChange(input, "incompatible")),
+  rule("OKM1525", "backward-incompatible", "error", "Adding NOT NULL without a default fails when the table already has rows.", (input) => hit(requiredColumn(input), "adds NOT NULL without a default")),
+  rule("OKM1526", "backward-incompatible", "error", "Removing a default breaks writers that omit the column.", (input) => hit(matches(input.step, "drop-default", /^alter table\s+\S+\s+alter column\s+\S+\s+drop default\b/), "removes a default")),
+  rule("OKM1527", "backward-incompatible", "error", "Shortening a character length rejects values that used to fit.", (input) => typeChange(input, "shrink")),
+  rule("OKM1528", "data-dependent", "error", "A new unique or primary key on an existing table fails when rows collide.", (input) => hit(uniqueConstraint(input), "builds a unique or primary key")),
+  rule("OKM1529", "data-dependent", "error", "A new unique index on an existing table fails when rows collide.", (input) => hit(uniqueIndex(input), "creates a unique index")),
+  rule("OKM1531", "data-dependent", "error", "A check that validates existing rows fails when a row does not pass.", (input) => hit(validatingCheck(input), "validates a check")),
+  rule("OKM1532", "data-dependent", "error", "A foreign key that validates existing rows fails when a row has no target.", (input) => hit(validatingForeignKey(input), "validates a foreign key")),
+  rule("OKM1533", "data-dependent", "error", "Narrowing an integer, float, or numeric type rejects values outside the new range.", (input) => typeChange(input, "narrow")),
+  rule("OKM1534", "locking", "error", "Creating an index on an existing table without CONCURRENTLY locks writes.", (input) => hit(blockingIndex(input), "creates an index without CONCURRENTLY")),
+  rule("OKM1535", "locking", "error", "Adding a check without NOT VALID locks the table while it scans.", (input) => hit(checkWithoutNotValid(input), "adds a check without NOT VALID")),
+  rule("OKM1536", "locking", "error", "Adding a foreign key without NOT VALID locks the table while it scans.", (input) => hit(foreignKeyWithoutNotValid(input), "adds a foreign key without NOT VALID")),
+  rule("OKM1537", "locking", "error", "SET NOT NULL locks the table while it scans for nulls.", (input) => hit(unsafeSetNotNull(input), "sets NOT NULL")),
+  rule("OKM1538", "locking", "warning", "A type change that rewrites the table locks it for the rewrite.", (input) => typeChange(input, "rewrite")),
+  rule("OKM1542", "data-dependent", "error", "A data statement outside backfill() is not a migration step.", (input) => hit(dataStatement(input.step), "changes rows outside backfill()"))
+];
+var COLUMN_RULES = [
+  {
+    code: "OKM1539",
+    category: "type-preference",
+    severity: "warning",
+    doc: "timestamp without time zone depends on the session time zone; use timestamptz.",
+    check: (column) => /^timestamp(?:\(\d+\))? without time zone$/.test(canonical(column.definition.dataType)) ? "is timestamp without time zone" : undefined
+  },
+  {
+    code: "OKM1540",
+    category: "type-preference",
+    severity: "warning",
+    doc: "varchar(n) can be text; a length check belongs in the application.",
+    check: (column) => /^character varying\(\d+\)$/.test(canonical(column.definition.dataType)) ? "is varchar(n)" : undefined
+  },
+  {
+    code: "OKM1543",
+    category: "type-preference",
+    severity: "warning",
+    doc: "serial and nextval defaults should be identity generated always.",
+    check: (column) => isSerial(column) ? "uses serial or nextval" : undefined
+  },
+  {
+    code: "OKM1544",
+    category: "type-preference",
+    severity: "warning",
+    doc: "json should be jsonb, which is available on every supported Postgres.",
+    check: (column) => canonical(column.definition.dataType) === "json" ? "is json" : undefined
+  },
+  {
+    code: "OKM1545",
+    category: "type-preference",
+    severity: "warning",
+    doc: "An identity that is not generated always differs from the repo default.",
+    check: (column) => column.definition.identity?.always === false ? "is generated by default" : undefined
+  }
+];
+function rule(code, category, severity, doc, check) {
+  return { code, category, severity, doc, check };
+}
+function hit(matched, reason) {
+  return matched ? [reason] : [];
+}
+function normalized(sql) {
+  const collapsed = sql.trim().replace(/\s+/g, " ");
+  let out = "";
+  let quoted = false;
+  for (const char of collapsed) {
+    if (char === '"') {
+      quoted = !quoted;
+      out += char;
+      continue;
+    }
+    out += quoted ? char : char.toLowerCase();
+  }
+  return out;
+}
+function dataStatement(step) {
+  if (step.backfill !== undefined)
+    return false;
+  const text = normalized(step.sql);
+  if (/^(?:insert|update|delete|merge|truncate)\b/.test(text))
+    return true;
+  return /^with\b/.test(text) && /\b(?:insert|update|delete|merge)\b/.test(text);
+}
+function matches(step, kind, pattern) {
+  return pattern.test(normalized(step.sql)) || step.kind === kind;
+}
+function renamesTable(step) {
+  const text = normalized(step.sql);
+  if (/^alter table\s+\S+\s+rename to\b/.test(text))
+    return true;
+  return step.kind === "rename-table" && !/^alter table\s+\S+\s+rename (column|constraint)\b/.test(text);
+}
+function droppedType(input) {
+  const text = normalized(input.step.sql);
+  const dropping = /^drop type\b/.test(text);
+  if (!dropping && input.step.kind !== "drop-enum" && input.step.kind !== "drop-domain") {
+    return;
+  }
+  if (input.step.kind === "drop-domain")
+    return "domain";
+  if (input.step.kind === "drop-enum")
+    return "enum";
+  const name = lastName(/^drop type\s+(\S+)/.exec(text)?.[1]);
+  const found = input.before.objects.find((object) => object.kind === "type" && object.identity.name === name);
+  if (found !== undefined && isDomain(found.definition))
+    return "domain";
+  return "enum";
+}
+function requiredColumn(input) {
+  const text = normalized(input.step.sql);
+  const adding = /^alter table\s+\S+\s+add column\b/.test(text) || input.step.kind === "add-column-required";
+  if (!adding)
+    return false;
+  if (input.step.kind === "add-column")
+    return false;
+  if (!tableExists(input))
+    return false;
+  if (input.step.kind === "add-column-required")
+    return true;
+  const body = text.replace(/^alter table\s+\S+\s+add column\s+/, "");
+  return /\bnot null\b/.test(body) && !/\bdefault\b/.test(body) && !/\bgenerated\b/.test(body);
+}
+function uniqueConstraint(input) {
+  if (!tableExists(input))
+    return false;
+  const text = normalized(input.step.sql);
+  if (/\busing index\b/.test(text))
+    return false;
+  if (/^alter table\s+\S+\s+add constraint\b/.test(text) && /\b(unique|primary key)\b/.test(text)) {
+    return true;
+  }
+  if (!/^create unique index\b/.test(text))
+    return false;
+  const name = createdIndexName(text);
+  if (name === undefined)
+    return false;
+  return input.later.some((step) => usesIndex(normalized(step.sql), name));
+}
+function uniqueIndex(input) {
+  const text = normalized(input.step.sql);
+  if (!/^create unique index\b/.test(text))
+    return false;
+  if (!tableExists(input))
+    return false;
+  const name = createdIndexName(text);
+  if (name !== undefined && input.later.some((step) => usesIndex(normalized(step.sql), name))) {
+    return false;
+  }
+  return true;
+}
+function createdIndexName(text) {
+  const match = /^create unique index (?:concurrently )?(?:"([^"]+)"|([a-z_][\w$]*))/.exec(text);
+  return match?.[1] ?? match?.[2];
+}
+function usesIndex(text, name) {
+  return text.includes(`using index "${name}"`) || text.includes(`using index ${name}`);
+}
+function unsafeSetNotNull(input) {
+  const text = normalized(input.step.sql);
+  const match = /^alter table\s+(\S+)\s+alter column\s+(\S+)\s+set not null\b/.exec(text);
+  if (match === null && input.step.kind !== "set-not-null")
+    return false;
+  if (!tableExists(input))
+    return false;
+  const table = match?.[1];
+  const column = match?.[2];
+  if (table !== undefined && column !== undefined && validatedNotNullCheck(input.earlier, table, column)) {
+    return false;
+  }
+  return true;
+}
+function validatedNotNullCheck(earlier, table, column) {
+  const needle = `check (${column} is not null) not valid`;
+  for (const step of earlier) {
+    const text = normalized(step.sql);
+    if (!text.startsWith(`alter table ${table} `) || !text.includes(needle))
+      continue;
+    const added = /^alter table\s+\S+\s+add constraint\s+(\S+)\s+check\b/.exec(text);
+    const name = added?.[1];
+    if (name === undefined)
+      continue;
+    const validated = earlier.some((item) => normalized(item.sql).startsWith(`alter table ${table} validate constraint ${name}`));
+    if (validated)
+      return true;
+  }
+  return false;
+}
+function blockingIndex(input) {
+  const text = normalized(input.step.sql);
+  if (!/^create(?: unique)? index\b/.test(text) && input.step.kind !== "create-index")
+    return false;
+  if (/\bconcurrently\b/.test(text))
+    return false;
+  return tableExists(input);
+}
+function checkWithoutNotValid(input) {
+  return addedConstraint(input, "check") && !/\bnot valid\b/.test(normalized(input.step.sql));
+}
+function foreignKeyWithoutNotValid(input) {
+  return addedConstraint(input, "foreign key") && !/\bnot valid\b/.test(normalized(input.step.sql));
+}
+function validatingCheck(input) {
+  if (widenValidate(input))
+    return false;
+  if (validates(input, "check"))
+    return true;
+  return checkWithoutNotValid(input);
+}
+function widenValidate(input) {
+  const text = normalized(input.step.sql);
+  if (!/^alter table\s+\S+\s+validate constraint\b/.test(text))
+    return false;
+  if (input.step.kind === "widen-check")
+    return true;
+  const name = /^alter table\s+\S+\s+validate constraint\s+(\S+)/.exec(text)?.[1];
+  if (name === undefined)
+    return false;
+  return input.earlier.some((step) => {
+    if (step.kind !== "widen-check")
+      return false;
+    const prior = normalized(step.sql);
+    return prior.includes(`add constraint ${name} `);
+  });
+}
+function validatingForeignKey(input) {
+  if (validates(input, "foreignKey"))
+    return true;
+  return foreignKeyWithoutNotValid(input);
+}
+function addedConstraint(input, kind) {
+  if (!tableExists(input))
+    return false;
+  const text = normalized(input.step.sql);
+  if (!/^alter table\s+\S+\s+add constraint\b/.test(text))
+    return false;
+  return new RegExp(`\\b${kind}\\b`).test(text);
+}
+function validates(input, kind) {
+  const text = normalized(input.step.sql);
+  const table = /^alter table\s+\S+\s+validate constraint\s+(\S+)/.exec(text);
+  if (table !== null) {
+    const token = table[1];
+    if (token === undefined)
+      return kind === "check";
+    const name = lastName(token);
+    if (name === undefined)
+      return kind === "check";
+    const constraint = findConstraint(input.after, name);
+    if (constraint === undefined)
+      return kind === "check";
+    return constraint.definition.constraintKind === kind;
+  }
+  if (kind === "check" && /^alter domain\s+\S+\s+validate constraint\b/.test(text))
+    return true;
+  return false;
+}
+function typeChange(input, mode) {
+  const text = normalized(input.step.sql);
+  const changing = /^alter table\s+\S+\s+alter column\s+\S+\s+set data type\b/.test(text) || input.step.kind === "set-column-type";
+  if (!changing)
+    return [];
+  const compared = columnTypes(input);
+  if (compared === undefined) {
+    if (mode === "incompatible" || mode === "rewrite")
+      return ["changes a column type"];
+    return [];
+  }
+  const { before, after } = compared;
+  if (before === after)
+    return [];
+  const shrink = lengthShrink(before, after);
+  if (mode === "shrink")
+    return shrink ? ["shortens a character length"] : [];
+  if (shrink)
+    return [];
+  if (mode === "narrow")
+    return narrows(before, after) ? ["narrows a type"] : [];
+  if (lengthGrow(before, after))
+    return [];
+  if (mode === "incompatible")
+    return ["changes a column type"];
+  return rewrites(before, after) ? ["rewrites the table"] : [];
+}
+function columnTypes(input) {
+  const text = normalized(input.step.sql);
+  const match = /^alter table\s+(\S+)\s+alter column\s+(\S+)\s+set data type\b/.exec(text);
+  const table = lastName(match?.[1]);
+  const column = lastName(match?.[2]);
+  if (table === undefined || column === undefined)
+    return;
+  const previous = findColumn(input.before, table, column);
+  const next = findColumn(input.after, table, column);
+  if (previous === undefined || next === undefined)
+    return;
+  return {
+    before: canonical(previous.definition.dataType),
+    after: canonical(next.definition.dataType)
+  };
+}
+function lengthShrink(before, after) {
+  const left = charLength(before);
+  const right = charLength(after);
+  return left !== undefined && right !== undefined && left.family === right.family && right.length < left.length;
+}
+function lengthGrow(before, after) {
+  const left = charLength(before);
+  const right = charLength(after);
+  return left !== undefined && right !== undefined && left.family === right.family && right.length > left.length;
+}
+function rewrites(before, after) {
+  if (lengthShrink(before, after) || lengthGrow(before, after))
+    return false;
+  if (isCharacter(before) && after === "text")
+    return false;
+  return true;
+}
+function narrows(before, after) {
+  const leftInt = INTEGER_WIDTH[before];
+  const rightInt = INTEGER_WIDTH[after];
+  if (leftInt !== undefined && rightInt !== undefined)
+    return rightInt < leftInt;
+  const leftFloat = FLOAT_WIDTH[before];
+  const rightFloat = FLOAT_WIDTH[after];
+  if (leftFloat !== undefined && rightFloat !== undefined)
+    return rightFloat < leftFloat;
+  const left = numericSpec(before);
+  const right = numericSpec(after);
+  if (left === undefined || right === undefined)
+    return false;
+  return right.precision < left.precision || right.scale < left.scale;
+}
+function charLength(type) {
+  const varying = /^character varying\((\d+)\)$/.exec(type);
+  if (varying?.[1] !== undefined)
+    return { family: "varying", length: Number(varying[1]) };
+  const fixed = /^character\((\d+)\)$/.exec(type);
+  if (fixed?.[1] !== undefined)
+    return { family: "fixed", length: Number(fixed[1]) };
+  return;
+}
+function isCharacter(type) {
+  return type === "text" || charLength(type) !== undefined;
+}
+function numericSpec(type) {
+  const match = /^numeric(?:\((\d+)(?:,(\d+))?\))?$/.exec(type);
+  if (match === null)
+    return;
+  if (match[1] === undefined)
+    return { precision: 1000, scale: 0 };
+  return {
+    precision: Number(match[1]),
+    scale: match[2] === undefined ? 0 : Number(match[2])
+  };
+}
+function tableExists(input) {
+  const name = statementTable(input.step);
+  return name !== undefined && input.existingTables.has(name);
+}
+function statementTable(step) {
+  const text = normalized(step.sql);
+  const altered = /^(?:alter|drop) table\s+(\S+)/.exec(text);
+  if (altered?.[1] !== undefined)
+    return lastName(altered[1]);
+  const index = /^create(?: unique)? index(?: concurrently)?\s+\S+\s+on\s+(\S+)/.exec(text);
+  return lastName(index?.[1]);
+}
+function lastName(token) {
+  if (token === undefined)
+    return;
+  const parts = [...token.matchAll(/"(?:[^"]|"")*"|[A-Za-z_][\w$]*/g)];
+  const last = parts.at(-1)?.[0];
+  if (last === undefined)
+    return;
+  if (last.startsWith('"'))
+    return last.slice(1, -1).replaceAll('""', '"');
+  return last;
+}
+function findColumn(source, table, name) {
+  return source.objects.find((object) => object.kind === "column" && object.identity.parent.name === table && object.identity.name === name);
+}
+function findConstraint(source, name) {
+  return source.objects.find((object) => object.kind === "constraint" && object.identity.name === name);
+}
+function canonical(typeName) {
+  return canonicalTypeName(typeName);
+}
+function isSerial(column) {
+  const typeName = column.definition.dataType.toLowerCase();
+  if (typeName === "serial" || typeName === "smallserial" || typeName === "bigserial")
+    return true;
+  if (column.definition.identity !== undefined)
+    return false;
+  return /nextval\s*\(/i.test(column.definition.defaultExpression ?? "");
+}
+
+// src/tooling/migrate/lint.ts
+function lintPlan(plan, before, after) {
+  const existingTables = tableNames(before);
+  const findings = [];
+  plan.steps.forEach((step, index) => {
+    findings.push(...lintStep(step, index + 1, before, after, existingTables, plan.steps.slice(0, index), plan.steps.slice(index + 1)));
+  });
+  return findings;
+}
+function lintCatalog(source) {
+  const findings = [];
+  for (const object of source.objects) {
+    if (object.kind !== "column")
+      continue;
+    for (const rule of COLUMN_RULES) {
+      const reason = rule.check(object);
+      if (reason === undefined)
+        continue;
+      findings.push(finding(rule.severity, rule.code, columnPlace(object), reason));
+    }
+  }
+  return findings;
+}
+function lintMigrationDirectory(directory, pending) {
+  if (!existsSync(directory))
+    return [];
+  const names = readdirSync(directory).filter((file) => file.endsWith(".sql")).sort();
+  let before = catalog([]);
+  const findings = [];
+  for (const file of names) {
+    const id = file.slice(0, -".sql".length);
+    const plan = parsePlan(readFileSync(join(directory, file), "utf8"));
+    const after = parseCatalog2(readFileSync(join(directory, `${id}.catalog.json`), "utf8"));
+    if (pending === undefined || pending.has(id)) {
+      for (const item of lintPlan(plan, before, after)) {
+        findings.push({ ...item, place: `${id} ${item.place}` });
+      }
+    }
+    before = after;
+  }
+  return findings;
+}
+function formatFindings(findings) {
+  if (findings.length === 0)
+    return "";
+  return `${findings.map(formatFinding).join(`
+`)}
+`;
+}
+function hasError(findings) {
+  return findings.some((item) => item.severity === "error");
+}
+function lintRefusal(findings) {
+  const doc = errorDoc("OKM1510");
+  return new OkmError2("OKM1510", formatFindings(findings).trim(), {
+    fix: { summary: doc?.fix ?? "Allow the finding with a reason, or change the statement." }
+  });
+}
+function lintStep(step, number, before, after, existingTables, earlier, later) {
+  const hits = [];
+  for (const rule of STEP_RULES) {
+    for (const reason of rule.check({ step, before, after, existingTables, earlier, later })) {
+      hits.push({ code: rule.code, severity: rule.severity, reason });
+    }
+  }
+  const triggered = new Set(hits.map((item) => item.code));
+  const silenced = new Set;
+  const findings = [];
+  const place = `step ${String(number)}`;
+  for (const allow of step.allows ?? []) {
+    if (allow.reason.trim().length === 0 || allow.code.length === 0) {
+      findings.push(finding("error", "OKM1510", place, "override needs a reason"));
+      continue;
+    }
+    if (!triggered.has(allow.code)) {
+      findings.push(finding("error", "OKM1510", place, `override ${allow.code} does not match this statement`));
+      continue;
+    }
+    silenced.add(allow.code);
+  }
+  for (const hit of hits) {
+    if (silenced.has(hit.code))
+      continue;
+    findings.push(finding(hit.severity, hit.code, place, hit.reason));
+  }
+  return findings;
+}
+function finding(severity, code, place, reason) {
+  const doc = errorDoc(code);
+  if (doc === undefined)
+    throw new Error(`${code} missing from the error registry.`);
+  return { severity, code, place, reason, fix: doc.fix };
+}
+function formatFinding(item) {
+  return `${item.severity} ${item.code} ${item.place}: ${item.reason} -- fix: ${item.fix}`;
+}
+function tableNames(source) {
+  const names = new Set;
+  for (const object of source.objects) {
+    if (object.kind === "table")
+      names.add(object.identity.name);
+  }
+  return names;
+}
+function columnPlace(column) {
+  return `${column.identity.parent.name}.${column.identity.name}`;
+}
+
 // src/tooling/migrate/policy.ts
 var READ = new Set([
   "plan",
@@ -637,8 +1369,8 @@ function endpointOf(url) {
 }
 
 // src/tooling/migrate/project.ts
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { basename, join as join2 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/dialects/pg/declarations.ts
@@ -978,6 +1710,181 @@ function objectIdentity(object) {
   return object.identity;
 }
 
+// src/tooling/migrate/estimate.ts
+var LARGE_TABLE_ROWS = 1e6;
+var ESTIMATE_SQL = `
+  select c.relname, c.reltuples::float8::text
+  from pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+  where n.nspname = $1
+    and c.relname = any(string_to_array($2, E'\\x1f'))
+    and c.relkind in ('r', 'p', 'f', 'm')
+`;
+async function readRowEstimates(url, schema, tables) {
+  const pool = open2({ url, max: 1 });
+  try {
+    const connection = await pool.reserve?.();
+    if (connection === undefined) {
+      throw new Error("The target connection cannot start a transaction.");
+    }
+    let began = false;
+    try {
+      await connection.execute("begin read only");
+      began = true;
+      await connection.execute("set local statement_timeout = '5s'");
+      const map = new Map;
+      const unique = [...new Set(tables)];
+      if (unique.length > 0) {
+        const result = await connection.execute(ESTIMATE_SQL, [schema, unique.join("\x1F")]);
+        for (const row of result.rows) {
+          const name = row[0];
+          if (name === null || name === undefined)
+            continue;
+          map.set(name, classify(row[1] ?? null));
+        }
+      }
+      await connection.execute("commit");
+      began = false;
+      return map;
+    } catch (error) {
+      if (began)
+        await connection.execute("rollback").catch(() => {
+          return;
+        });
+      throw error;
+    } finally {
+      await connection.release();
+    }
+  } finally {
+    await pool.close();
+  }
+}
+function annotateLock(step, estimates) {
+  const pieces = lockPieces(step);
+  const text = withBatches(step, pieces.map((piece) => {
+    if (piece.table === undefined)
+      return piece.mode;
+    return `${piece.mode} on ${piece.table}, ${estimatePhrase(estimates.get(piece.table))}`;
+  }).join("; "), estimates);
+  if (step.safeRewrite === true)
+    return `${text}; safe rewrite applied`;
+  if (exclusiveOverLarge(pieces, estimates)) {
+    return `${text}; note: more than ${String(LARGE_TABLE_ROWS)} estimated rows`;
+  }
+  return text;
+}
+function aboutRows(count) {
+  const rounded = Math.max(0, Math.round(count));
+  if (rounded < 1000)
+    return `about ${String(rounded)} rows`;
+  const units = [
+    [1e9, "B"],
+    [1e6, "M"],
+    [1000, "K"]
+  ];
+  for (const [unit, suffix] of units) {
+    if (rounded < unit)
+      continue;
+    const scaled = rounded / unit;
+    const digits = scaled >= 10 || Number.isInteger(scaled) ? 0 : 1;
+    const text = trimZero(scaled.toFixed(digits));
+    return `about ${text}${suffix} rows`;
+  }
+  return `about ${String(rounded)} rows`;
+}
+function withBatches(step, text, estimates) {
+  const batch = step.backfill?.batch;
+  if (batch === undefined)
+    return text;
+  const name = step.tables?.[0];
+  const estimate = name === undefined ? undefined : estimates.get(name);
+  if (estimate === undefined || estimate.kind !== "rows")
+    return text;
+  return `${text}, about ${String(aboutBatchCount(estimate.reltuples, batch))} batches`;
+}
+function classify(raw) {
+  if (raw === null)
+    return { kind: "unknown" };
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0)
+    return { kind: "unknown" };
+  return { kind: "rows", reltuples: value };
+}
+function estimatePhrase(estimate) {
+  if (estimate === undefined)
+    return "new table";
+  if (estimate.kind === "unknown")
+    return "rows unknown (table not analyzed)";
+  return aboutRows(estimate.reltuples);
+}
+function lockPieces(step) {
+  const segments = step.lock.split("; ").map((part) => part.trim()).filter((part) => part.length > 0);
+  const named = new Map;
+  for (const segment of segments) {
+    const table = lockTable(segment);
+    if (table !== undefined)
+      named.set(table, stripLockTable(segment));
+  }
+  const primary = segments[0] ?? step.lock;
+  const primaryTable = lockTable(primary);
+  const primaryMode = primaryTable === undefined ? primary : stripLockTable(primary);
+  const pieces = [];
+  const seen = new Set;
+  if (primaryTable === undefined) {
+    const lead = (step.tables ?? []).filter((name) => !named.has(name));
+    if (lead.length === 0 && named.size === 0)
+      pieces.push({ mode: step.lock, table: undefined });
+    for (const table of lead) {
+      seen.add(table);
+      pieces.push({ mode: primaryMode, table });
+    }
+  }
+  for (const segment of segments) {
+    const table = lockTable(segment);
+    if (table === undefined) {
+      if (primaryTable !== undefined || pieces.length === 0) {
+        pieces.push({ mode: segment, table: undefined });
+      }
+      continue;
+    }
+    if (seen.has(table))
+      continue;
+    seen.add(table);
+    pieces.push({ mode: stripLockTable(segment), table });
+  }
+  for (const table of step.tables ?? []) {
+    if (seen.has(table))
+      continue;
+    pieces.push({ mode: primaryMode, table });
+  }
+  return pieces;
+}
+function exclusiveOverLarge(pieces, estimates) {
+  for (const piece of pieces) {
+    if (piece.mode !== "ACCESS EXCLUSIVE" || piece.table === undefined)
+      continue;
+    const estimate = estimates.get(piece.table);
+    if (estimate === undefined || estimate.kind !== "rows")
+      continue;
+    if (estimate.reltuples > LARGE_TABLE_ROWS)
+      return true;
+  }
+  return false;
+}
+function lockTable(segment) {
+  const match = /\bon\s+"((?:[^"]|"")*)"\."((?:[^"]|"")*)"/.exec(segment);
+  const name = match?.[2];
+  if (name === undefined)
+    return;
+  return name.replaceAll('""', '"');
+}
+function stripLockTable(segment) {
+  return segment.replace(/\s+on\s+"((?:[^"]|"")*)"\."((?:[^"]|"")*)"/, "").trim();
+}
+function trimZero(text) {
+  return text.endsWith(".0") ? text.slice(0, -2) : text;
+}
+
 // src/tooling/migrate/project.ts
 async function buildProject(cwd) {
   const config = await loadConfig(cwd);
@@ -989,17 +1896,21 @@ async function generateProject(cwd, name, flags) {
   writeArtifact(cwd, prepared.config, prepared.built);
   if (prepared.plan.steps.length === 0)
     return;
-  const directory = join(cwd, prepared.config.migrations ?? "migrations");
+  const directory = join2(cwd, prepared.config.migrations ?? "migrations");
   mkdirSync(directory, { recursive: true });
   const base = `${nextNumber(directory)}_${safeName(name)}`;
-  const sqlPath = join(directory, `${base}.sql`);
+  const sqlPath = join2(directory, `${base}.sql`);
   writeFileSync(sqlPath, formatPlan(prepared.plan));
-  writeFileSync(join(directory, `${base}.catalog.json`), serializeCatalog2(prepared.built.catalog));
-  return sqlPath;
+  writeFileSync(join2(directory, `${base}.catalog.json`), serializeCatalog2(prepared.built.catalog));
+  return { path: sqlPath, findings: lintPrepared(prepared) };
 }
-async function planProject(cwd, name, flags) {
+async function planProject(cwd, name, flags, invoke) {
   const prepared = await prepare(cwd, name, flags);
-  return prepared.plan;
+  return {
+    plan: prepared.plan,
+    findings: lintPrepared(prepared),
+    text: await displayPlan(prepared.config, prepared.plan, invoke)
+  };
 }
 async function checkProject(cwd, flags) {
   const opened = await openProject(cwd);
@@ -1013,9 +1924,9 @@ async function checkProject(cwd, flags) {
   const targets = listTargets(opened.config);
   assertTargetAlias(targets);
   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 directory = join2(cwd, opened.config.tables);
+    const files = existsSync2(directory) ? readdirSync2(directory) : [];
+    const source = readFileSync2(join2(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(", ")}.`, {
@@ -1023,14 +1934,20 @@ async function checkProject(cwd, flags) {
       });
     }
   }
+  const findings = lintOpened(opened);
+  if (hasError(findings))
+    throw lintRefusal(findings);
   const named = flags?.target;
   if (targets.length === 0)
-    return;
+    return findings;
   if (targets.length > 1 && named === undefined)
-    return;
+    return findings;
   const target = selectTarget(opened.config, named);
-  const { assertAuthorDrift } = await import("./49ypnfwt.js");
+  assertTargetPolicy(target, "check", flags?.allowProtected ?? false);
+  assertTargetPolicy(target, "drift", flags?.allowProtected ?? false);
+  const { assertAuthorDrift } = await import("./hqjsxnz7.js");
   await assertAuthorDrift(target.url, opened.built.catalog, opened.config.roles);
+  return findings;
 }
 function unlistedTableFiles(schemaSource, fileNames) {
   const missing = [];
@@ -1056,15 +1973,58 @@ async function prepare(cwd, name, flags) {
     after: opened.built.catalog,
     renames: opened.renames,
     replacements: flags.map((flag) => parseReplace(flag)),
-    name
+    name,
+    ...batchSizeField(opened.config.backfill?.batchSize)
+  });
+  return {
+    config: opened.config,
+    built: opened.built,
+    plan,
+    before: opened.previous,
+    after: opened.built.catalog
+  };
+}
+function lintPrepared(prepared) {
+  return lintPlan(prepared.plan, prepared.before, prepared.after);
+}
+async function displayPlan(config, plan, invoke) {
+  const offline = formatPlan(plan);
+  const targets = listTargets(config);
+  if (targets.length === 0)
+    return offline;
+  assertTargetAlias(targets);
+  const named = invoke?.target;
+  if (named === undefined && targets.length !== 1)
+    return offline;
+  const target = selectTarget(config, named);
+  assertTargetPolicy(target, "plan", invoke?.allowProtected ?? false);
+  let estimates;
+  try {
+    const names = plan.steps.flatMap((step) => step.tables ?? []);
+    estimates = await readRowEstimates(target.url, "public", names);
+  } catch {
+    return offline;
+  }
+  return formatPlan(plan, (step) => annotateLock(step, estimates));
+}
+function lintOpened(opened) {
+  const plan = planMigration({
+    before: opened.previous,
+    after: opened.built.catalog,
+    renames: opened.renames,
+    name: "check",
+    ...batchSizeField(opened.config.backfill?.batchSize)
   });
-  return { config: opened.config, built: opened.built, plan };
+  return [
+    ...lintPlan(plan, opened.previous, opened.built.catalog),
+    ...lintCatalog(opened.built.catalog)
+  ];
 }
 async function openProject(cwd) {
   const config = await loadConfig(cwd);
   const built = withRoles(await loadSchema(cwd, config.schema), config);
   const declarations = schemaDeclarations(built);
-  const previous = readPrevious(join(cwd, config.migrations ?? "migrations"));
+  const previous = readPrevious(join2(cwd, config.migrations ?? "migrations"));
   const stale = staleRenames(previous?.catalog, declarations.renames);
   if (stale.length > 0) {
     throw new OkmError2("OKM1020", stale.join(" "), {
@@ -1084,17 +2044,20 @@ function withRoles(built, config) {
   return { ...built, catalog: attachRoles(built.catalog, config.roles) };
 }
 function writeArtifact(cwd, config, built) {
-  const directory = join(cwd, config.out ?? ".okm");
+  const directory = join2(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(join2(directory, "catalog.json"), text);
+  writeFileSync(join2(directory, "catalog.hash"), `${catalogHash2(built.catalog)}
 `);
-  writeFileSync(join(directory, "types.d.ts"), `${emitRowTypes(built)}${referenceAugmentation(built)}`);
+  writeFileSync(join2(directory, "types.d.ts"), `${emitRowTypes(built)}${referenceAugmentation(built)}`);
   return directory;
 }
+async function loadBuiltSchema(cwd, config) {
+  return withRoles(await loadSchema(cwd, config.schema), config);
+}
 async function loadConfig(cwd) {
-  const path = join(cwd, "okmodel.config.ts");
+  const path = join2(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;
@@ -1104,7 +2067,7 @@ async function loadConfig(cwd) {
   return config;
 }
 async function loadSchema(cwd, spec) {
-  const path = join(cwd, spec);
+  const path = join2(cwd, spec);
   const imported = await import(`${pathToFileURL(path).href}?okm=${Date.now()}`);
   const record = isRecord(imported) ? imported : {};
   for (const value of Object.values(record)) {
@@ -1116,13 +2079,13 @@ async function loadSchema(cwd, spec) {
   throw new OkmError2("invalid", `${spec} must export a schema().`);
 }
 function readPrevious(directory) {
-  if (!existsSync(directory))
+  if (!existsSync2(directory))
     return;
-  const catalogs = readdirSync(directory).filter((file) => file.endsWith(".catalog.json")).sort();
+  const catalogs = readdirSync2(directory).filter((file) => file.endsWith(".catalog.json")).sort();
   const latest = catalogs.at(-1);
   if (latest === undefined)
     return;
-  const text = readFileSync(join(directory, latest), "utf8");
+  const text = readFileSync2(join2(directory, latest), "utf8");
   return { catalog: parseCatalog2(text) };
 }
 function referenceAugmentation(source) {
@@ -1147,8 +2110,8 @@ function referenceAugmentation(source) {
 }
 function nextNumber(directory) {
   let max = 0;
-  if (existsSync(directory)) {
-    for (const file of readdirSync(directory)) {
+  if (existsSync2(directory)) {
+    for (const file of readdirSync2(directory)) {
       const match = /^(\d+)_/.exec(file);
       const value = match?.[1];
       if (value !== undefined)
@@ -1189,14 +2152,14 @@ function projectImportsValidate(cwd) {
 function directoryImportsValidate(dir) {
   let entries;
   try {
-    entries = readdirSync(dir, { withFileTypes: true });
+    entries = readdirSync2(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);
+    const path = join2(dir, entry.name);
     if (entry.isDirectory()) {
       if (directoryImportsValidate(path))
         return true;
@@ -1204,7 +2167,7 @@ function directoryImportsValidate(dir) {
     }
     if (!/\.(?:ts|tsx|mts|cts)$/.test(entry.name))
       continue;
-    if (runtimeImportsValidate(readFileSync(path, "utf8")))
+    if (runtimeImportsValidate(readFileSync2(path, "utf8")))
       return true;
   }
   return false;
@@ -1226,4 +2189,4 @@ function runtimeImportsValidate(source) {
   return false;
 }
 
-export { errorDoc, assertTargetPolicy, assertDirectConnection, listTargets, selectTarget, buildProject, generateProject, planProject, checkProject, projectHead, openProject, loadConfig };
+export { errorDoc, lintMigrationDirectory, formatFindings, hasError, lintRefusal, assertTargetPolicy, assertDirectConnection, listTargets, selectTarget, buildProject, generateProject, planProject, checkProject, projectHead, openProject, loadBuiltSchema, loadConfig, loadSchema };