okmodel 0.8.0 → 0.9.0

package/dist/shared/{f4jy1j7x.js → 2zdxkt7b.js}

@@ -1,7 +1,3 @@
-import {
-  VALIDATION_NOT_IMPORTED2,
-  VALIDATION_NOT_IMPORTED_FIX2
-} from "./n442h54c.js";
 import {
   roleObject,
   grantObject,
@@ -9,12 +5,20 @@ import {
   serializeCatalog2,
   catalogHash2,
   startupCatalog2,
+  startupHash2,
   catalogFileText2,
   parseCatalog2
 } from "./12z7aznj.js";
+import {
+  quoteIdent2
+} from "./fk9vef30.js";
+import {
+  VALIDATION_NOT_IMPORTED2,
+  VALIDATION_NOT_IMPORTED_FIX2
+} from "./n442h54c.js";
 import {
   open2
-} from "./35q0n9tz.js";
+} from "./dd5pmnky.js";
 import {
   sqlStatements,
   transactionControl,
@@ -35,7 +39,7 @@ import {
   assertTargetAlias,
   listTargets,
   selectTarget
-} from "./dpc2r7rb.js";
+} from "./6nae0spm.js";
 import {
   contributedFields
 } from "./n0dgs0pb.js";
@@ -78,6 +82,374 @@ function projectPath(cwd, ...parts) {
   return resolve(cwd, ...parts);
 }
 
+// src/tooling/migrate/export.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+var EXPORT_FORMAT = 1;
+var LOGICAL_FORMAT = 1;
+function snapshotFromCatalog(source, namespace, database) {
+  return {
+    format: EXPORT_FORMAT,
+    logical: { namespace, name: namespace, format: LOGICAL_FORMAT },
+    catalogHash: startupHash2(source),
+    ...database !== undefined ? { database } : {},
+    tables: exportTables(source)
+  };
+}
+function serializeSnapshot(snapshot) {
+  return `${JSON.stringify(snapshot, null, 2)}
+`;
+}
+function parseSnapshot(path, text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw snapshotError(path, "stale", `Catalog snapshot ${path} is not JSON.`);
+  }
+  if (!isSnapshot(parsed)) {
+    throw snapshotError(path, "stale", `Catalog snapshot ${path} is stale: the file format is not ${String(EXPORT_FORMAT)}.`);
+  }
+  return parsed;
+}
+function databaseName(url) {
+  try {
+    const name = decodeURIComponent(new URL(url).pathname.replace(/^\//, ""));
+    return name.length > 0 ? name : undefined;
+  } catch {
+    return;
+  }
+}
+function catalogNamespace(config) {
+  return config.namespace ?? "public";
+}
+function loadSnapshots(cwd, config) {
+  const paths = config.external ?? [];
+  return paths.map((path) => {
+    const file = resolveSnapshot(cwd, path);
+    if (!existsSync(file)) {
+      throw snapshotError(path, "missing", `Catalog snapshot ${path} is missing.`);
+    }
+    return { path, snapshot: parseSnapshot(path, readFileSync(file, "utf8")) };
+  });
+}
+function externalNamespaceMap(snapshots) {
+  const names = new Map;
+  for (const loaded of snapshots) {
+    for (const table of loaded.snapshot.tables)
+      names.set(table.name, table.namespace);
+  }
+  return names;
+}
+function couplingFindings(source) {
+  const findings = [];
+  for (const object of source.objects) {
+    if (object.kind !== "constraint" || object.definition.constraintKind !== "foreignKey")
+      continue;
+    const references = object.definition.references;
+    if (references === undefined)
+      continue;
+    const from = object.identity.parent.namespace;
+    const to = references.parent.namespace;
+    if (from.form !== "static" || to.form !== "static" || from.name === to.name)
+      continue;
+    findings.push({
+      severity: "warning",
+      code: "coupling",
+      place: `${from.name}.${object.identity.parent.name}.${object.definition.columns.join(",")}`,
+      reason: `references ${to.name}.${references.parent.name}.${references.columns.join(",")}`,
+      fix: "Cross-catalog foreign keys are allowed inside one database."
+    });
+  }
+  return findings;
+}
+function assertSnapshots(cwd, config, source) {
+  if ((config.external ?? []).length === 0)
+    return;
+  const snapshots = loadSnapshots(cwd, config);
+  for (const table of externalTables(source)) {
+    const found = findTable(snapshots, table.namespace, table.name);
+    if (found === undefined) {
+      throw snapshotError(table.name, "missing", `External table ${table.namespace}.${table.name} is missing from the catalog snapshots.`);
+    }
+    const differ = columnDifference(table.columns, found.table.columns);
+    if (differ !== undefined) {
+      throw snapshotError(found.path, "stale", `Catalog snapshot ${found.path} is stale: ${table.namespace}.${table.name}.${differ} does not match the export.`);
+    }
+  }
+}
+async function assertLiveExternal(url, source, snapshots) {
+  if (snapshots.length === 0 && externalTables(source).length === 0)
+    return;
+  const postgres = (await import("postgres")).default;
+  const sql = postgres(url, { max: 1, connect_timeout: 5, idle_timeout: 1, onnotice: () => {} });
+  try {
+    const current = await sql`select current_database() as name`;
+    const database = current[0]?.name;
+    if (database !== undefined)
+      assertSameDatabase(source, snapshots, database);
+    for (const table of externalTables(source)) {
+      const found = findTable(snapshots, table.namespace, table.name);
+      if (found === undefined)
+        continue;
+      await assertLiveTable(sql, found.path, found.snapshot, table);
+    }
+  } finally {
+    await sql.end({ timeout: 5 });
+  }
+}
+function renderExport(cwd, config, source, args) {
+  const flags = exportFlags(args);
+  const database = exportDatabase(config);
+  const snapshot = snapshotFromCatalog(source, catalogNamespace(config), database);
+  const text = serializeSnapshot(snapshot);
+  if (flags.out !== undefined) {
+    const path = isAbsolute(flags.out) ? flags.out : join(cwd, flags.out);
+    writeFileSync(path, text);
+  }
+  if (flags.json || flags.out === undefined)
+    return text;
+  return `${flags.out}
+`;
+}
+function exportTables(source) {
+  const tables = [];
+  for (const object of source.objects) {
+    if (object.kind !== "table" || object.owner === "external" || object.owner === "ignored") {
+      continue;
+    }
+    if (object.identity.namespace.form !== "static")
+      continue;
+    const columns = [];
+    for (const column of source.objects) {
+      if (!isColumnOf(column, object.identity.namespace.name, object.identity.name))
+        continue;
+      columns.push({
+        name: column.identity.name,
+        type: column.definition.dataType,
+        nullable: column.definition.nullable
+      });
+    }
+    tables.push({
+      namespace: object.identity.namespace.name,
+      name: object.identity.name,
+      columns
+    });
+  }
+  return tables;
+}
+function isColumnOf(object, namespace, table) {
+  return object.kind === "column" && object.identity.parent.name === table && object.identity.parent.namespace.form === "static" && object.identity.parent.namespace.name === namespace;
+}
+function externalTables(source) {
+  const tables = [];
+  for (const object of source.objects) {
+    if (object.kind !== "table" || object.owner !== "external")
+      continue;
+    if (object.identity.namespace.form !== "static")
+      continue;
+    const columns = [];
+    for (const column of source.objects) {
+      if (!isColumnOf(column, object.identity.namespace.name, object.identity.name))
+        continue;
+      columns.push({
+        name: column.identity.name,
+        type: column.definition.dataType,
+        nullable: column.definition.nullable
+      });
+    }
+    tables.push({ namespace: object.identity.namespace.name, name: object.identity.name, columns });
+  }
+  return tables;
+}
+function findTable(snapshots, namespace, name) {
+  for (const loaded of snapshots) {
+    for (const table of loaded.snapshot.tables) {
+      if (table.name === name && (table.namespace === namespace || namespace === "public")) {
+        return { path: loaded.path, snapshot: loaded.snapshot, table };
+      }
+    }
+  }
+  for (const loaded of snapshots) {
+    for (const table of loaded.snapshot.tables) {
+      if (table.name === name)
+        return { path: loaded.path, snapshot: loaded.snapshot, table };
+    }
+  }
+  return;
+}
+function columnDifference(left, right) {
+  const byName = new Map(right.map((column) => [column.name, column]));
+  for (const column of left) {
+    const other = byName.get(column.name);
+    if (other === undefined)
+      return column.name;
+    if (other.type !== column.type || other.nullable !== column.nullable)
+      return column.name;
+  }
+  for (const column of right) {
+    if (!left.some((item) => item.name === column.name))
+      return column.name;
+  }
+  return;
+}
+function assertSameDatabase(source, snapshots, database) {
+  if (!hasCrossCatalogForeignKey(source))
+    return;
+  for (const loaded of snapshots) {
+    const name = loaded.snapshot.database;
+    if (name !== undefined && name !== database) {
+      throw new OkmError2("OKM1842", `A foreign key references ${loaded.snapshot.logical.namespace} in database ${name}. This database is ${database}.`, {
+        kind: "invalid",
+        fieldReason: "database",
+        fix: {
+          summary: "Keep the foreign key inside one database. Cross-catalog keys are allowed only there."
+        }
+      });
+    }
+  }
+}
+function hasCrossCatalogForeignKey(source) {
+  for (const object of source.objects) {
+    if (object.kind !== "constraint" || object.definition.constraintKind !== "foreignKey")
+      continue;
+    const references = object.definition.references;
+    if (references === undefined)
+      continue;
+    const from = object.identity.parent.namespace;
+    const to = references.parent.namespace;
+    if (from.form === "static" && to.form === "static" && from.name !== to.name)
+      return true;
+  }
+  return false;
+}
+async function assertLiveTable(sql, path, snapshot, table) {
+  const hash = await liveHash(sql, table.namespace);
+  if (hash !== undefined && hash !== snapshot.catalogHash) {
+    throw snapshotError(path, "stale", `Catalog snapshot ${path} is stale: the catalog hash changed.`);
+  }
+  const live = await liveColumns(sql, table.namespace, table.name);
+  if (live === undefined) {
+    throw snapshotError(path, "missing", `External table ${table.namespace}.${table.name} is missing on the database.`);
+  }
+  const differ = columnDifference(snapshotTableColumns(snapshot, table), live);
+  if (differ !== undefined) {
+    throw snapshotError(path, "stale", `Catalog snapshot ${path} is stale: ${table.namespace}.${table.name}.${differ} is missing on the database.`);
+  }
+}
+function snapshotTableColumns(snapshot, table) {
+  for (const item of snapshot.tables) {
+    if (item.name === table.name)
+      return item.columns;
+  }
+  return table.columns;
+}
+async function liveHash(sql, namespace) {
+  const reg = `${quoteIdent2(namespace)}.${quoteIdent2("okm_meta")}`;
+  const present = await sql.unsafe(`select to_regclass('${reg}')::text as reg`);
+  if (present[0]?.reg == null)
+    return;
+  const rows = await sql.unsafe(`select catalog_hash from ${reg} where id = 'head'`);
+  return rows[0]?.catalog_hash;
+}
+async function liveColumns(sql, namespace, table) {
+  const rows = await sql`select a.attname as name, format_type(a.atttypid, a.atttypmod) as type, a.attnotnull as not_null
+    from pg_attribute a
+    join pg_class c on c.oid = a.attrelid
+    join pg_namespace n on n.oid = c.relnamespace
+    where n.nspname = ${namespace} and c.relname = ${table}
+      and a.attnum > 0 and not a.attisdropped
+    order by a.attnum`;
+  if (rows.length === 0) {
+    const exists = await sql`
+      select to_regclass(${`${quoteIdent2(namespace)}.${quoteIdent2(table)}`})::text as reg
+    `;
+    if (exists[0]?.reg == null)
+      return;
+  }
+  return rows.map((row) => ({ name: row.name, type: row.type, nullable: !row.not_null }));
+}
+function resolveSnapshot(cwd, path) {
+  return isAbsolute(path) ? path : projectPath(cwd, path);
+}
+function exportDatabase(config) {
+  const target = config.database;
+  if (typeof target === "string")
+    return databaseName(target);
+  if (target?.url !== undefined)
+    return databaseName(target.url);
+  return;
+}
+function exportFlags(args) {
+  let json = false;
+  let out;
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index] ?? "";
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--out") {
+      const value = args[index + 1];
+      if (value === undefined || value.startsWith("--")) {
+        throw new OkmError2("invalid", "--out needs a file.", {
+          fix: { summary: "Pass --out <file>." }
+        });
+      }
+      out = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--out=")) {
+      out = arg.slice("--out=".length);
+      continue;
+    }
+    throw new OkmError2("invalid", `Unknown flag ${arg}.`, {
+      fix: { summary: "okm catalog export accepts --json and --out <file>." }
+    });
+  }
+  return out === undefined ? { json } : { json, out };
+}
+function snapshotError(path, reason, message) {
+  return new OkmError2("OKM1841", message, {
+    kind: reason === "missing" ? "not_found" : "schema_drift",
+    fieldReason: reason,
+    columns: [path],
+    fix: {
+      summary: reason === "missing" ? "Point external at the file okm catalog export wrote, and apply the owning catalog." : "Run okm catalog export in the owning catalog and update the dependent."
+    }
+  });
+}
+function isSnapshot(value) {
+  if (!isRecord(value) || value.format !== EXPORT_FORMAT)
+    return false;
+  if (typeof value.catalogHash !== "string")
+    return false;
+  if (!isLogical(value.logical))
+    return false;
+  if (value.database !== undefined && typeof value.database !== "string")
+    return false;
+  if (!Array.isArray(value.tables))
+    return false;
+  return value.tables.every(isTable);
+}
+function isLogical(value) {
+  if (!isRecord(value))
+    return false;
+  return typeof value.namespace === "string" && typeof value.name === "string" && value.format === LOGICAL_FORMAT;
+}
+function isTable(value) {
+  if (!isRecord(value) || typeof value.namespace !== "string" || typeof value.name !== "string") {
+    return false;
+  }
+  if (!Array.isArray(value.columns))
+    return false;
+  return value.columns.every((column) => isRecord(column) && typeof column.name === "string" && typeof column.type === "string" && typeof column.nullable === "boolean");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
 // src/tooling/errors/registry.ts
 var ERROR_DOCS = [
   {
@@ -455,7 +827,7 @@ var ERROR_DOCS = [
   {
     code: "OKM1538",
     title: "Type rewrite",
-    summary: "A statement changes a column type in a way that rewrites the table.",
+    summary: "A statement changes a column type in a way that rewrites the table. Binary-coercible changes, varchar widening, varchar to text, and a numeric precision increase at the same scale do not.",
     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."
   },
   {
@@ -536,6 +908,12 @@ var ERROR_DOCS = [
     summary: "A step contains COMMIT, ROLLBACK, or other transaction control, including inside a DO body. A function or procedure body is not this.",
     fix: "Remove the transaction control. okm migrate check replays one transaction and rolls it back. Apply accepts the step only with -- okm-allow OKM1551: reason."
   },
+  {
+    code: "OKM1552",
+    title: "Reprinted declaration",
+    summary: "A domain check or a LANGUAGE sql function body is stored differently from the text in the migration catalog.",
+    fix: "Write the check or the body the way Postgres prints it, or allow OKM1552 with a reason. The warning does not fail apply. A domain whose check differs is still OKM1547."
+  },
   {
     code: "OKM1601",
     title: "Stale typed SQL",
@@ -751,6 +1129,18 @@ var ERROR_DOCS = [
     title: "Pooler session",
     summary: "Two statements on the same connection saw different backend pids. A transaction-mode pooler is in the way.",
     fix: "Use a direct connection, or pass --allow-pooler."
+  },
+  {
+    code: "OKM1855",
+    title: "Pull would overwrite",
+    summary: "okm pull or okm import drizzle found a file it would replace. It writes nothing.",
+    fix: "Pass --out <directory> to write somewhere else, or move the file."
+  },
+  {
+    code: "OKM1856",
+    title: "Drizzle is not installed",
+    summary: "okm import drizzle could not resolve drizzle-orm from the project.",
+    fix: "Install drizzle-orm in the project that owns the schema."
   }
 ];
 var byCode;
@@ -767,25 +1157,25 @@ function indexDocs() {
 }
 
 // src/tooling/migrate/files.ts
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
 function loadMigrations(directory) {
-  if (!existsSync(directory))
+  if (!existsSync2(directory))
     return [];
   const names = readdirSync(directory).filter((file) => file.endsWith(".sql")).sort();
   const migrations = [];
   for (const file of names) {
     const id = file.slice(0, -".sql".length);
-    const catalogPath = join(directory, `${id}.catalog.json`);
-    if (!existsSync(catalogPath)) {
+    const catalogPath = join2(directory, `${id}.catalog.json`);
+    if (!existsSync2(catalogPath)) {
       throw new OkmError2("invalid", `Migration ${id} is missing its catalog snapshot.`, {
         fix: {
           summary: "Generate the migration again so the SQL and the catalog are written together."
         }
       });
     }
-    const plan = readMigrationPlan(join(directory, file));
-    const stored = parseCatalog2(readFileSync(catalogPath, "utf8"));
+    const plan = readMigrationPlan(join2(directory, file));
+    const stored = parseCatalog2(readFileSync2(catalogPath, "utf8"));
     const startup = startupCatalog2(stored);
     const hash = catalogHash2(startup);
     migrations.push(startup === stored ? { id, catalogHash: hash, steps: plan.steps } : { id, catalogHash: hash, legacyHash: catalogHash2(stored), steps: plan.steps });
@@ -793,7 +1183,7 @@ function loadMigrations(directory) {
   return migrations;
 }
 function readMigrationPlan(path) {
-  const text = prepareMigrationText(readFileSync(path, "utf8"), path);
+  const text = prepareMigrationText(readFileSync2(path, "utf8"), path);
   const plan = parsePlan(text);
   assertMigrationSteps(text, plan.steps.length, path);
   return plan;
@@ -806,13 +1196,13 @@ function loadHeadSnapshot(directory) {
   return {
     id: last.id,
     catalogHash: last.catalogHash,
-    catalog: parseCatalog2(readFileSync(join(directory, `${last.id}.catalog.json`), "utf8"))
+    catalog: parseCatalog2(readFileSync2(join2(directory, `${last.id}.catalog.json`), "utf8"))
   };
 }
 
 // src/tooling/migrate/lint.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
 
 // src/tooling/migrate/lint-rules.ts
 var INTEGER_WIDTH = {
@@ -899,7 +1289,7 @@ function rule(code, category, severity, doc, check) {
 function hit(matched, reason) {
   return matched ? [reason] : [];
 }
-function normalized(sql) {
+function normalizedSql(sql) {
   const collapsed = sql.trim().replace(/\s+/g, " ");
   let out = "";
   let quoted = false;
@@ -914,7 +1304,7 @@ function normalized(sql) {
   return out;
 }
 function weakensRls(input) {
-  const text = normalized(input.step.sql);
+  const text = normalizedSql(input.step.sql);
   if (/\bdisable row level security\b/.test(text))
     return ["disables row level security"];
   if (/\bno force row level security\b/.test(text))
@@ -1031,7 +1421,7 @@ function parenthesized(text, open) {
 }
 function policyExpression(input, table, name) {
   const expression = expressionOf(input.after, table, name) ?? expressionOf(input.before, table, name);
-  return expression === undefined ? undefined : normalized(expression);
+  return expression === undefined ? undefined : normalizedSql(expression);
 }
 function expressionOf(source, table, name) {
   for (const object of source.objects) {
@@ -1054,7 +1444,7 @@ function hasPolicy(source, table) {
   return source.objects.some((object) => object.kind === "policy" && object.identity.parent.name === table);
 }
 function dataStatement(step) {
-  const text = normalized(step.sql);
+  const text = normalizedSql(step.sql);
   if (/^(?:do|call)\b/.test(text))
     return ["the body is not analysed"];
   if (step.backfill !== undefined)
@@ -1068,16 +1458,16 @@ function dataStatement(step) {
   return [];
 }
 function matches(step, kind, pattern) {
-  return pattern.test(normalized(step.sql)) || step.kind === kind;
+  return pattern.test(normalizedSql(step.sql)) || step.kind === kind;
 }
 function renamesTable(step) {
-  const text = normalized(step.sql);
+  const text = normalizedSql(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 text = normalizedSql(input.step.sql);
   const dropping = /^drop type\b/.test(text);
   if (!dropping && input.step.kind !== "drop-enum" && input.step.kind !== "drop-domain") {
     return;
@@ -1093,7 +1483,7 @@ function droppedType(input) {
   return "enum";
 }
 function requiredColumn(input) {
-  const text = normalized(input.step.sql);
+  const text = normalizedSql(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;
@@ -1109,7 +1499,7 @@ function requiredColumn(input) {
 function uniqueConstraint(input) {
   if (!tableExists(input))
     return false;
-  const text = normalized(input.step.sql);
+  const text = normalizedSql(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)) {
@@ -1120,16 +1510,16 @@ function uniqueConstraint(input) {
   const name = createdIndexName(text);
   if (name === undefined)
     return false;
-  return input.later.some((step) => usesIndex(normalized(step.sql), name));
+  return input.later.some((step) => usesIndex(normalizedSql(step.sql), name));
 }
 function uniqueIndex(input) {
-  const text = normalized(input.step.sql);
+  const text = normalizedSql(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))) {
+  if (name !== undefined && input.later.some((step) => usesIndex(normalizedSql(step.sql), name))) {
     return false;
   }
   return true;
@@ -1142,7 +1532,7 @@ 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 text = normalizedSql(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;
@@ -1158,21 +1548,21 @@ function unsafeSetNotNull(input) {
 function validatedNotNullCheck(earlier, table, column) {
   const needle = `check (${column} is not null) not valid`;
   for (const step of earlier) {
-    const text = normalized(step.sql);
+    const text = normalizedSql(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}`));
+    const validated = earlier.some((item) => normalizedSql(item.sql).startsWith(`alter table ${table} validate constraint ${name}`));
     if (validated)
       return true;
   }
   return false;
 }
 function blockingIndex(input) {
-  const text = normalized(input.step.sql);
+  const text = normalizedSql(input.step.sql);
   if (!/^create(?: unique)? index\b/.test(text) && input.step.kind !== "create-index")
     return false;
   if (/\bconcurrently\b/.test(text))
@@ -1180,10 +1570,10 @@ function blockingIndex(input) {
   return tableExists(input);
 }
 function checkWithoutNotValid(input) {
-  return addedConstraint(input, "check") && !/\bnot valid\b/.test(normalized(input.step.sql));
+  return addedConstraint(input, "check") && !/\bnot valid\b/.test(normalizedSql(input.step.sql));
 }
 function foreignKeyWithoutNotValid(input) {
-  return addedConstraint(input, "foreign key") && !/\bnot valid\b/.test(normalized(input.step.sql));
+  return addedConstraint(input, "foreign key") && !/\bnot valid\b/.test(normalizedSql(input.step.sql));
 }
 function validatingCheck(input) {
   if (widenValidate(input))
@@ -1193,7 +1583,7 @@ function validatingCheck(input) {
   return checkWithoutNotValid(input);
 }
 function widenValidate(input) {
-  const text = normalized(input.step.sql);
+  const text = normalizedSql(input.step.sql);
   if (!/^alter table\s+\S+\s+validate constraint\b/.test(text))
     return false;
   if (input.step.kind === "widen-check")
@@ -1204,7 +1594,7 @@ function widenValidate(input) {
   return input.earlier.some((step) => {
     if (step.kind !== "widen-check")
       return false;
-    const prior = normalized(step.sql);
+    const prior = normalizedSql(step.sql);
     return prior.includes(`add constraint ${name} `);
   });
 }
@@ -1216,13 +1606,13 @@ function validatingForeignKey(input) {
 function addedConstraint(input, kind) {
   if (!tableExists(input))
     return false;
-  const text = normalized(input.step.sql);
+  const text = normalizedSql(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 text = normalizedSql(input.step.sql);
   const table = /^alter table\s+\S+\s+validate constraint\s+(\S+)/.exec(text);
   if (table !== null) {
     const token = table[1];
@@ -1242,7 +1632,7 @@ function validates(input, kind) {
 }
 var TYPE_CHANGE = /^alter table\s+(\S+)\s+alter column\s+(\S+)\s+(?:set data type|type)\b/;
 function typeChange(input, mode) {
-  const text = normalized(input.step.sql);
+  const text = normalizedSql(input.step.sql);
   const changing = TYPE_CHANGE.test(text) || input.step.kind === "set-column-type";
   if (!changing)
     return [];
@@ -1258,18 +1648,19 @@ function typeChange(input, mode) {
   const shrink = lengthShrink(before, after);
   if (mode === "shrink")
     return shrink ? ["shortens a character length"] : [];
-  if (shrink)
-    return [];
+  if (shrink) {
+    return mode === "rewrite" && tableRewrites(before, after, input) ? ["rewrites the table"] : [];
+  }
   if (mode === "narrow")
     return narrows(before, after) ? ["narrows a type"] : [];
-  if (lengthGrow(before, after))
+  if (lengthGrow(before, after) && mode !== "rewrite")
     return [];
   if (mode === "incompatible")
     return ["changes a column type"];
-  return rewrites(before, after) ? ["rewrites the table"] : [];
+  return tableRewrites(before, after, input) ? ["rewrites the table"] : [];
 }
 function columnTypes(input) {
-  const text = normalized(input.step.sql);
+  const text = normalizedSql(input.step.sql);
   const match = TYPE_CHANGE.exec(text);
   const table = lastName(match?.[1]);
   const column = lastName(match?.[2]);
@@ -1294,13 +1685,115 @@ function lengthGrow(before, after) {
   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))
+function tableRewrites(before, after, input) {
+  if (usingRewrites(input))
+    return true;
+  if (varyingRelaxation(before, after))
+    return false;
+  if (isVarying(before) && after === "text")
     return false;
-  if (isCharacter(before) && after === "text")
+  if (before === "text" && unconstrainedVarying(after))
+    return false;
+  if ((before === "text" || isVarying(before)) && unconstrainedCharacter(after))
+    return false;
+  if (numericRelaxation(before, after))
+    return false;
+  if (binaryPair(before, after))
+    return false;
+  if (domainSkipsRewrite(before, after, input))
     return false;
   return true;
 }
+function statementMayReprint(sql) {
+  const text = normalizedSql(sql);
+  if (/^(?:create|alter) domain\b/.test(text))
+    return true;
+  return /^create(?: or replace)? function\b/.test(text) && /\blanguage sql\b/.test(text);
+}
+function usingRewrites(input) {
+  const text = normalizedSql(input.step.sql);
+  const at = text.search(/\busing\b/);
+  if (at < 0)
+    return false;
+  const column = lastName(TYPE_CHANGE.exec(text)?.[2]);
+  if (column === undefined)
+    return true;
+  const expression = text.slice(at + "using".length).trim().replace(/;$/, "");
+  return !plainCast(expression, column);
+}
+function plainCast(expression, column) {
+  const bare = column.toLowerCase();
+  const quoted = `"${column}"`;
+  return expression.startsWith(`${bare}::`) || expression.startsWith(`${quoted}::`) || expression.startsWith(`cast(${bare} as `) || expression.startsWith(`cast(${quoted} as `);
+}
+function isVarying(type) {
+  return type === "character varying" || type === "varchar" || type.startsWith("character varying(") || type.startsWith("varchar(");
+}
+function unconstrainedVarying(type) {
+  return type === "character varying" || type === "varchar";
+}
+function unconstrainedCharacter(type) {
+  return type === "bpchar" || type === "character";
+}
+function varyingRelaxation(before, after) {
+  const left = charLength(before);
+  if (left?.family === "varying" && unconstrainedVarying(after))
+    return true;
+  const right = charLength(after);
+  return left?.family === "varying" && right?.family === "varying" && right.length > left.length;
+}
+function numericRelaxation(before, after) {
+  const left = numericBounds(before);
+  const right = numericBounds(after);
+  if (left === undefined || right === undefined)
+    return false;
+  if (right.precision === undefined)
+    return left.precision !== undefined;
+  if (left.precision === undefined || left.scale === undefined || right.scale === undefined) {
+    return false;
+  }
+  return right.scale === left.scale && right.precision > left.precision;
+}
+function numericBounds(type) {
+  const match = /^numeric(?:\((\d+)(?:,(\d+))?\))?$/.exec(type);
+  if (match === null)
+    return;
+  if (match[1] === undefined)
+    return { precision: undefined, scale: undefined };
+  return {
+    precision: Number(match[1]),
+    scale: match[2] === undefined ? 0 : Number(match[2])
+  };
+}
+function binaryPair(before, after) {
+  if (before === "integer" && after === "oid")
+    return true;
+  if (before === "oid" && after === "integer")
+    return true;
+  if (before === "cidr" && after === "inet")
+    return true;
+  return before === "xml" && after === "text";
+}
+function domainSkipsRewrite(before, after, input) {
+  const next = domainNamed(input, after);
+  if (next !== undefined && next.check.trim().length === 0 && canonical(next.base) === before) {
+    return true;
+  }
+  const previous = domainNamed(input, before);
+  return previous !== undefined && canonical(previous.base) === after;
+}
+function domainNamed(input, name) {
+  for (const source of [input.after, input.before]) {
+    for (const object of source.objects) {
+      if (object.kind !== "type" || object.identity.name !== name)
+        continue;
+      if (!isDomain(object.definition))
+        continue;
+      return object.definition;
+    }
+  }
+  return;
+}
 function narrows(before, after) {
   const leftInt = INTEGER_WIDTH[before];
   const rightInt = INTEGER_WIDTH[after];
@@ -1325,9 +1818,6 @@ function charLength(type) {
     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)
@@ -1344,7 +1834,7 @@ function tableExists(input) {
   return name !== undefined && input.existingTables.has(name);
 }
 function statementTable(step) {
-  const text = normalized(step.sql);
+  const text = normalizedSql(step.sql);
   const altered = /^(?:alter|drop) table\s+(\S+)/.exec(text);
   if (altered?.[1] !== undefined)
     return lastName(altered[1]);
@@ -1380,6 +1870,134 @@ function isSerial(column) {
   return /nextval\s*\(/i.test(column.definition.defaultExpression ?? "");
 }
 
+// src/tooling/migrate/reprint.ts
+var REPRINT_CODE = "OKM1552";
+function reprintHits(declared, stored, steps) {
+  const hits = [];
+  const silenced = new Set;
+  for (const difference of differences(declared, stored)) {
+    const index = stepIndex(steps, difference.kind, difference.name);
+    if (index === undefined)
+      continue;
+    const step = steps[index];
+    const allow = step?.allows?.find((item) => item.code === REPRINT_CODE);
+    if (allow !== undefined && allow.reason.trim().length > 0) {
+      silenced.add(index);
+      continue;
+    }
+    hits.push({
+      severity: "warning",
+      code: REPRINT_CODE,
+      place: `step ${String(index + 1)}`,
+      reason: difference.reason
+    });
+  }
+  steps.forEach((step, index) => {
+    for (const allow of step.allows ?? []) {
+      if (allow.code !== REPRINT_CODE)
+        continue;
+      const place = `step ${String(index + 1)}`;
+      if (allow.reason.trim().length === 0) {
+        hits.push({
+          severity: "error",
+          code: "OKM1510",
+          place,
+          reason: "override needs a reason"
+        });
+        continue;
+      }
+      if (silenced.has(index))
+        continue;
+      if (hits.some((item) => item.place === place && item.code === REPRINT_CODE))
+        continue;
+      if (!statementMayReprint(step.sql))
+        continue;
+      hits.push({
+        severity: "error",
+        code: "OKM1510",
+        place,
+        reason: `override ${REPRINT_CODE} does not match this statement`
+      });
+    }
+  });
+  return hits;
+}
+function differences(declared, stored) {
+  const found = [];
+  const storedDomains = domainChecks(stored);
+  for (const [name, check] of domainChecks(declared)) {
+    const live = storedDomains.get(name);
+    if (live === undefined || live === check)
+      continue;
+    found.push({
+      kind: "domain",
+      name,
+      reason: `domain ${name} check reprints differently`
+    });
+  }
+  const storedFunctions = sqlBodies(stored);
+  for (const [key, body] of sqlBodies(declared)) {
+    const live = storedFunctions.get(key);
+    if (live === undefined || live.body === body.body)
+      continue;
+    found.push({
+      kind: "function",
+      name: body.name,
+      reason: `function ${body.name} body reprints differently`
+    });
+  }
+  return found;
+}
+function domainChecks(source) {
+  const checks = new Map;
+  for (const object of source.objects) {
+    if (object.kind !== "type" || !isDomain(object.definition))
+      continue;
+    checks.set(object.identity.name, object.definition.check.trim());
+  }
+  return checks;
+}
+function sqlBodies(source) {
+  const bodies = new Map;
+  for (const object of source.objects) {
+    if (object.kind !== "function" || object.definition.language !== "sql")
+      continue;
+    bodies.set(functionKey(object), {
+      name: object.identity.name,
+      body: object.definition.body.trim()
+    });
+  }
+  return bodies;
+}
+function functionKey(object) {
+  const args = object.identity.argTypes.map((typeName) => canonicalTypeName(typeName)).join(",");
+  return `${object.identity.name}(${args})`;
+}
+function stepIndex(steps, kind, name) {
+  let found;
+  steps.forEach((step, index) => {
+    if (mentions(normalizedSql(step.sql), kind, name))
+      found = index;
+  });
+  return found;
+}
+function mentions(text, kind, name) {
+  if (kind === "domain" && !/^(?:create|alter) domain\b/.test(text))
+    return false;
+  if (kind === "function") {
+    if (!/^create(?: or replace)? function\b/.test(text) || !/\blanguage sql\b/.test(text)) {
+      return false;
+    }
+  }
+  const quoted = `"${name}"`;
+  if (text.includes(quoted))
+    return true;
+  return new RegExp(`\\b${escapeRegExp(name.toLowerCase())}\\b`).test(text);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/tooling/migrate/lint.ts
 function lintPlan(plan, before, after) {
   const existingTables = tableNames(before);
@@ -1389,6 +2007,9 @@ function lintPlan(plan, before, after) {
   });
   return findings;
 }
+function lintReprints(declared, stored, steps) {
+  return reprintHits(declared, stored, steps).map((hit) => finding(hit.severity, hit.code, hit.place, hit.reason));
+}
 function lintCatalog(source) {
   const findings = [];
   for (const object of source.objects) {
@@ -1404,15 +2025,15 @@ function lintCatalog(source) {
   return findings;
 }
 function lintMigrationDirectory(directory, pending) {
-  if (!existsSync2(directory))
+  if (!existsSync3(directory))
     return [];
   const names = readdirSync2(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 = readMigrationPlan(join2(directory, file));
-    const after = parseCatalog2(readFileSync2(join2(directory, `${id}.catalog.json`), "utf8"));
+    const plan = readMigrationPlan(join3(directory, file));
+    const after = parseCatalog2(readFileSync3(join3(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}` });
@@ -1462,6 +2083,8 @@ function lintStep(step, number, before, after, existingTables, earlier, later) {
         triggered.add(hit.code);
       }
     }
+    if (statementMayReprint(statement.sql))
+      triggered.add(REPRINT_CODE);
     const place = multi ? `step ${String(number)} statement ${String(index + 1)}` : `step ${String(number)}`;
     perStatement.push({ place, hits });
   });
@@ -1531,8 +2154,16 @@ function columnPlace(column) {
 }
 
 // src/tooling/migrate/project.ts
-import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, join as join3 } from "node:path";
+import {
+  existsSync as existsSync4,
+  mkdirSync,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync4,
+  statSync,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { basename, dirname, join as join4 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/dialects/pg/declarations.ts
@@ -2143,6 +2774,131 @@ function columnNames(target, built, table) {
   return built.flatMap((object) => object.kind === "column" && object.identity.parent.name === table ? [object.identity.name] : []);
 }
 
+// src/tooling/migrate/place.ts
+function placeCatalog(source, namespace, externalNamespaces) {
+  if (namespace === "public" && externalNamespaces.size === 0)
+    return source;
+  const homes = tableHomes(source, namespace, externalNamespaces);
+  let changed = false;
+  const objects = source.objects.map((object) => {
+    const next = relocateObject(object, homes, namespace);
+    if (next !== object)
+      changed = true;
+    return next;
+  });
+  if (!changed)
+    return source;
+  return catalog(objects);
+}
+function tableHomes(source, namespace, externalNamespaces) {
+  const homes = new Map;
+  for (const object of source.objects) {
+    if (object.kind !== "table" && object.kind !== "view" && object.kind !== "materializedView") {
+      continue;
+    }
+    const home = object.owner === "external" ? externalNamespaces.get(object.identity.name) ?? namespace : namespace;
+    homes.set(object.identity.name, home);
+  }
+  return homes;
+}
+function relocateObject(object, homes, namespace) {
+  const dependencies = relocateEdges(object.dependencies, homes, namespace);
+  if (object.kind === "extension") {
+    if (object.definition.schema === "public" && namespace !== "public") {
+      return { ...object, definition: { ...object.definition, schema: namespace }, dependencies };
+    }
+    return dependencies === object.dependencies ? object : { ...object, dependencies };
+  }
+  if (object.kind === "role") {
+    return dependencies === object.dependencies ? object : { ...object, dependencies };
+  }
+  const identity = relocateIdentity(object.identity, homes, namespace);
+  if (object.kind === "constraint") {
+    const references = relocateReferences(object, homes);
+    if (identity === object.identity && references === object.definition.references && dependencies === object.dependencies) {
+      return object;
+    }
+    if (references === undefined || references === object.definition.references) {
+      return { ...object, identity, dependencies };
+    }
+    return {
+      ...object,
+      identity,
+      definition: { ...object.definition, references },
+      dependencies
+    };
+  }
+  if (identity === object.identity && dependencies === object.dependencies)
+    return object;
+  return { ...object, identity, dependencies };
+}
+function relocateReferences(object, homes) {
+  const references = object.definition.references;
+  if (references === undefined)
+    return;
+  const home = homes.get(references.parent.name);
+  if (home === undefined)
+    return references;
+  const parent = moveRef(references.parent, home);
+  if (parent === references.parent)
+    return references;
+  return { ...references, parent };
+}
+function relocateEdges(edges, homes, namespace) {
+  let changed = false;
+  const next = edges.map((edge) => {
+    const target = relocateIdentity(edge.target, homes, namespace);
+    if (target === edge.target)
+      return edge;
+    changed = true;
+    return { target };
+  });
+  return changed ? next : edges;
+}
+function relocateIdentity(identity, homes, namespace) {
+  if (identity.kind === "role" || identity.kind === "extension")
+    return identity;
+  if (identity.kind === "column" || identity.kind === "index" || identity.kind === "constraint" || identity.kind === "trigger" || identity.kind === "policy") {
+    const home = homes.get(identity.parent.name) ?? namespace;
+    const parent = moveRef(identity.parent, home);
+    if (parent === identity.parent)
+      return identity;
+    return { ...identity, parent };
+  }
+  if (identity.kind === "grant") {
+    const home = homes.get(identity.object.name) ?? namespace;
+    const moved = moveNamespace(identity.object.namespace, home);
+    if (moved === identity.object.namespace)
+      return identity;
+    return { ...identity, object: { ...identity.object, namespace: moved } };
+  }
+  if (identity.kind === "defaultPrivilege") {
+    const moved = moveNamespace(identity.namespace, namespace);
+    if (moved === identity.namespace)
+      return identity;
+    return { ...identity, namespace: moved };
+  }
+  if (identity.kind === "table" || identity.kind === "view" || identity.kind === "materializedView" || identity.kind === "sequence" || identity.kind === "type" || identity.kind === "function") {
+    const home = homes.get(identity.name) ?? namespace;
+    const moved = moveNamespace(identity.namespace, home);
+    if (moved === identity.namespace)
+      return identity;
+    return { ...identity, namespace: moved };
+  }
+  return identity;
+}
+function moveRef(ref, namespace) {
+  const moved = moveNamespace(ref.namespace, namespace);
+  if (moved === ref.namespace)
+    return ref;
+  return { ...ref, namespace: moved };
+}
+function moveNamespace(namespace, name) {
+  if (namespace.form !== "static" || namespace.name === name)
+    return namespace;
+  return staticNamespace2(name);
+}
+
 // src/tooling/migrate/estimate.ts
 var LARGE_TABLE_ROWS = 1e6;
 var ESTIMATE_SQL = `
@@ -2336,11 +3092,35 @@ function trimZero(text) {
   return text.endsWith(".0") ? text.slice(0, -2) : text;
 }
 
+// src/tooling/migrate/plan-json.ts
+function planDocument(plan, findings, lockText) {
+  return {
+    name: plan.name,
+    class: plan.class,
+    steps: plan.steps.map((step) => ({
+      class: step.class,
+      lock: lockText === undefined ? step.lock : lockText(step),
+      sql: step.sql
+    })),
+    findings: findings.map((finding) => ({
+      severity: finding.severity,
+      code: finding.code,
+      place: finding.place,
+      reason: finding.reason,
+      fix: finding.fix
+    }))
+  };
+}
+function formatPlanJson(plan, findings, lockText) {
+  return `${JSON.stringify(planDocument(plan, findings, lockText))}
+`;
+}
+
 // 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, withRoles(built, config));
+  return writeArtifact(cwd, config, withRoles(built, config, cwd));
 }
 async function generateProject(cwd, name, flags) {
   const prepared = await prepare(cwd, name, flags);
@@ -2352,17 +3132,20 @@ async function generateProject(cwd, name, flags) {
   const directory = projectPath(cwd, prepared.config.migrations ?? "migrations");
   mkdirSync(directory, { recursive: true });
   const base = `${nextNumber(directory)}_${safeName(name)}`;
-  const sqlPath = join3(directory, `${base}.sql`);
-  writeFileSync(sqlPath, formatPlan(prepared.plan));
-  writeFileSync(join3(directory, `${base}.catalog.json`), serializeCatalog2(prepared.built.catalog));
+  const sqlPath = join4(directory, `${base}.sql`);
+  writeFileSync2(sqlPath, formatPlan(prepared.plan));
+  writeFileSync2(join4(directory, `${base}.catalog.json`), serializeCatalog2(prepared.built.catalog));
   return { path: sqlPath, findings: lintPrepared(prepared) };
 }
 async function planProject(cwd, name, flags, invoke) {
   const prepared = await prepare(cwd, name, flags);
+  const findings = lintPrepared(prepared);
+  const lockText = await planLockText(prepared.config, prepared.plan, invoke);
   return {
     plan: prepared.plan,
-    findings: lintPrepared(prepared),
-    text: await displayPlan(prepared.config, prepared.plan, invoke)
+    findings,
+    text: formatPlan(prepared.plan, lockText),
+    json: formatPlanJson(prepared.plan, findings, lockText)
   };
 }
 async function checkProject(cwd, flags) {
@@ -2378,8 +3161,8 @@ async function checkProject(cwd, flags) {
   assertTargetAlias(targets);
   if (opened.config.tables !== undefined) {
     const directory = projectPath(cwd, opened.config.tables);
-    const files = existsSync3(directory) ? readdirSync3(directory) : [];
-    const source = readFileSync3(projectPath(cwd, opened.config.schema), "utf8");
+    const files = existsSync4(directory) ? readdirSync3(directory) : [];
+    const source = readFileSync4(projectPath(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(", ")}.`, {
@@ -2387,7 +3170,8 @@ async function checkProject(cwd, flags) {
       });
     }
   }
-  const findings = lintOpened(opened);
+  assertSnapshots(cwd, opened.config, opened.built.catalog);
+  const findings = [...lintOpened(opened), ...couplingFindings(opened.built.catalog)];
   if (hasError(findings))
     throw lintRefusal(findings);
   const named = flags?.target;
@@ -2398,8 +3182,9 @@ async function checkProject(cwd, flags) {
   const target = selectTarget(opened.config, named);
   assertTargetPolicy(target, "check", flags?.allowProtected ?? false);
   assertTargetPolicy(target, "drift", flags?.allowProtected ?? false);
-  const { assertAuthorDrift } = await import("./3449rcae.js");
+  const { assertAuthorDrift } = await import("./ckz05z15.js");
   const allowPooler = flags?.allowPooler === true || opened.config.allowPooler === true;
+  await assertLiveExternal(target.url, opened.built.catalog, loadSnapshots(cwd, opened.config));
   await assertAuthorDrift(target.url, opened.built.catalog, opened.config.roles, allowPooler);
   return findings;
 }
@@ -2429,6 +3214,7 @@ async function prepare(cwd, name, flags) {
     renames: opened.renames,
     replacements: flags.map((flag) => parseReplace(flag)),
     name,
+    ...placedSchema(opened.config),
     ...batchSizeField(opened.config.backfill?.batchSize)
   });
   return {
@@ -2442,26 +3228,25 @@ async function prepare(cwd, name, flags) {
 function lintPrepared(prepared) {
   return lintPlan(prepared.plan, prepared.before, prepared.after);
 }
-async function displayPlan(config, plan, invoke) {
-  const offline = formatPlan(plan);
+async function planLockText(config, plan, invoke) {
   const targets = listTargets(config);
   if (targets.length === 0)
-    return offline;
+    return;
   assertTargetAlias(targets);
   const named = invoke?.target;
   if (named === undefined && targets.length !== 1)
-    return offline;
+    return;
   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);
+    estimates = await readRowEstimates(target.url, catalogNamespace(config), names);
   } catch {
-    return offline;
+    return;
   }
   const aliases = renameAliases(plan.steps);
-  return formatPlan(plan, (step) => annotateLock(step, estimates, aliases));
+  return (step) => annotateLock(step, estimates, aliases);
 }
 function lintOpened(opened) {
   const plan = planMigration({
@@ -2469,6 +3254,7 @@ function lintOpened(opened) {
     after: opened.built.catalog,
     renames: opened.renames,
     name: "check",
+    ...placedSchema(opened.config),
     ...batchSizeField(opened.config.backfill?.batchSize)
   });
   return [
@@ -2478,7 +3264,7 @@ function lintOpened(opened) {
 }
 async function openProject(cwd) {
   const config = await loadConfig(cwd);
-  const built = withRoles(await loadSchema(cwd, config.schema), config);
+  const built = await loadBuiltSchema(cwd, config);
   const declarations = schemaDeclarations(built);
   const previous = readPrevious(projectPath(cwd, config.migrations ?? "migrations"));
   const stale = staleRenames(previous?.catalog, declarations.renames);
@@ -2494,15 +3280,22 @@ async function openProject(cwd) {
     renames: declarations.renames
   };
 }
-function withRoles(built, config) {
+function withRoles(built, config, cwd) {
   const marks = ownershipMarks(built);
   const stamped = marks.size === 0 ? built.catalog : stampOwnership(built.catalog, marks);
+  const placed = placeCatalog(stamped, catalogNamespace(config), externalNamespaceMap(loadSnapshots(cwd, config)));
   const roles = config.roles;
-  const catalog = roles === undefined ? stamped : attachRoles(stamped, roles, exposureFor(built, roles));
+  const catalog = roles === undefined ? placed : attachRoles(placed, roles, exposureFor(built, roles));
   if (catalog === built.catalog)
     return built;
   return { ...built, catalog };
 }
+function placedSchema(config) {
+  const namespace = catalogNamespace(config);
+  if (namespace === "public")
+    return;
+  return { schema: namespace };
+}
 function ownershipMarks(built) {
   const marks = new Map;
   const models = built.model;
@@ -2539,9 +3332,9 @@ var GIT_ATTRIBUTES = [
 `);
 function writeGitAttributes(cwd) {
   const path = projectPath(cwd, ".gitattributes");
-  if (existsSync3(path))
+  if (existsSync4(path))
     return;
-  writeFileSync(path, GIT_ATTRIBUTES);
+  writeFileSync2(path, GIT_ATTRIBUTES);
 }
 function typesText(cwd, spec, built) {
   return `${emitRowTypes(built, jsonColumnTypes(readSchemaSource(cwd, spec)))}${referenceAugmentation(built)}`;
@@ -2550,7 +3343,7 @@ function readSchemaSource(cwd, spec) {
   const parts = [];
   const seen = new Set;
   const visit = (file) => {
-    if (seen.has(file) || !existsSync3(file))
+    if (seen.has(file) || !existsSync4(file))
       return;
     let stat;
     try {
@@ -2561,16 +3354,16 @@ function readSchemaSource(cwd, spec) {
     if (!stat.isFile())
       return;
     seen.add(file);
-    const text = readFileSync3(file, "utf8");
+    const text = readFileSync4(file, "utf8");
     parts.push(text);
     for (const match of text.matchAll(/from\s+["'](\.[^"']+)["']/g)) {
       const rel = match[1];
       if (rel === undefined)
         continue;
-      const base = join3(dirname(file), rel);
-      const candidates = [base, `${base}.ts`, `${base}.tsx`, `${base}.mts`, join3(base, "index.ts")];
+      const base = join4(dirname(file), rel);
+      const candidates = [base, `${base}.ts`, `${base}.tsx`, `${base}.mts`, join4(base, "index.ts")];
       for (const candidate of candidates) {
-        if (existsSync3(candidate)) {
+        if (existsSync4(candidate)) {
           visit(candidate);
           break;
         }
@@ -2586,19 +3379,35 @@ function writeArtifact(cwd, config, built) {
   mkdirSync(directory, { recursive: true });
   const startup = startupCatalog2(built.catalog);
   const text = catalogFileText2(serializeCatalog2(startup));
-  writeFileSync(join3(directory, "catalog.json"), text);
-  writeFileSync(join3(directory, "catalog.hash"), `${sha2562(text)}
+  writeFileSync2(join4(directory, "catalog.json"), text);
+  writeFileSync2(join4(directory, "catalog.hash"), `${sha2562(text)}
 `);
-  writeFileSync(join3(directory, "types.d.ts"), typesText(cwd, config.schema, built));
+  writeFileSync2(join4(directory, "types.d.ts"), typesText(cwd, config.schema, built));
+  writeNamespace(directory, catalogNamespace(config));
   return directory;
 }
+function writeNamespace(directory, namespace) {
+  const path = join4(directory, "namespace");
+  if (namespace === "public") {
+    if (existsSync4(path))
+      unlinkSync(path);
+    return;
+  }
+  writeFileSync2(path, `${namespace}
+`);
+}
 async function loadBuiltSchema(cwd, config) {
-  return withRoles(await loadSchema(cwd, config.schema), config);
+  return withRoles(await loadSchema(cwd, config.schema), config, cwd);
+}
+async function exportProject(cwd, args) {
+  const config = await loadConfig(cwd);
+  const built = await loadBuiltSchema(cwd, config);
+  return renderExport(cwd, config, built.catalog, args);
 }
 async function loadConfig(cwd) {
   const path = projectPath(cwd, "okmodel.config.ts");
   const imported = await import(`${pathToFileURL(path).href}?okm=${Date.now()}`);
-  const record = isRecord(imported) ? imported : {};
+  const record = isRecord2(imported) ? imported : {};
   const config = record.default ?? record.config;
   if (!isConfig(config)) {
     throw new OkmError2("invalid", "okmodel.config.ts must default-export defineConfig(...).");
@@ -2608,7 +3417,7 @@ async function loadConfig(cwd) {
 async function loadSchema(cwd, spec) {
   const path = projectPath(cwd, spec);
   const imported = await import(`${pathToFileURL(path).href}?okm=${Date.now()}`);
-  const record = isRecord(imported) ? imported : {};
+  const record = isRecord2(imported) ? imported : {};
   for (const value of Object.values(record)) {
     if (!isBuilt(value))
       continue;
@@ -2618,13 +3427,13 @@ async function loadSchema(cwd, spec) {
   throw new OkmError2("invalid", `${spec} must export a schema().`);
 }
 function readPrevious(directory) {
-  if (!existsSync3(directory))
+  if (!existsSync4(directory))
     return;
   const catalogs = readdirSync3(directory).filter((file) => file.endsWith(".catalog.json")).sort();
   const latest = catalogs.at(-1);
   if (latest === undefined)
     return;
-  const text = readFileSync3(join3(directory, latest), "utf8");
+  const text = readFileSync4(join4(directory, latest), "utf8");
   return { catalog: parseCatalog2(text) };
 }
 function referenceAugmentation(source) {
@@ -2649,7 +3458,7 @@ function referenceAugmentation(source) {
 }
 function nextNumber(directory) {
   let max = 0;
-  if (existsSync3(directory)) {
+  if (existsSync4(directory)) {
     for (const file of readdirSync3(directory)) {
       const match = /^(\d+)_/.exec(file);
       const value = match?.[1];
@@ -2666,14 +3475,14 @@ function safeName(name) {
   return name;
 }
 function isBuilt(value) {
-  if (!isRecord(value) || !Array.isArray(value.tables))
+  if (!isRecord2(value) || !Array.isArray(value.tables))
     return false;
   return "catalog" in value;
 }
 function isConfig(value) {
-  return isRecord(value) && typeof value.schema === "string";
+  return isRecord2(value) && typeof value.schema === "string";
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 var SKIP_SCAN = new Set(["node_modules", "dist", "coverage"]);
@@ -2698,7 +3507,7 @@ function directoryImportsValidate(dir) {
   for (const entry of entries) {
     if (entry.name.startsWith(".") || SKIP_SCAN.has(entry.name))
       continue;
-    const path = join3(dir, entry.name);
+    const path = join4(dir, entry.name);
     if (entry.isDirectory()) {
       if (directoryImportsValidate(path))
         return true;
@@ -2706,7 +3515,7 @@ function directoryImportsValidate(dir) {
     }
     if (!/\.(?:ts|tsx|mts|cts)$/.test(entry.name))
       continue;
-    if (runtimeImportsValidate(readFileSync3(path, "utf8")))
+    if (runtimeImportsValidate(readFileSync4(path, "utf8")))
       return true;
   }
   return false;
@@ -2728,4 +3537,4 @@ function runtimeImportsValidate(source) {
   return false;
 }
 
-export { projectPath, errorDoc, loadMigrations, readMigrationPlan, loadHeadSnapshot, lintMigrationDirectory, formatFindings, hasError, lintRefusal, buildProject, generateProject, planProject, checkProject, projectHead, openProject, loadBuiltSchema, loadConfig, loadSchema };
+export { projectPath, LOGICAL_FORMAT, catalogNamespace, loadSnapshots, assertSnapshots, assertLiveExternal, errorDoc, loadMigrations, readMigrationPlan, loadHeadSnapshot, lintReprints, lintMigrationDirectory, formatFindings, hasError, lintRefusal, buildProject, generateProject, planProject, checkProject, projectHead, openProject, loadBuiltSchema, exportProject, loadConfig, loadSchema };