okmodel 0.2.1 → 0.4.0

package/dist/shared/n5y9zyj1.js

@@ -0,0 +1,2431 @@
+import {
+  creationOrder2,
+  renameColumn2,
+  renameTable2
+} from "./8jb4ymh2.js";
+import {
+  quoteIdent,
+  ownedByView,
+  dropObjectSql,
+  createObjectSql,
+  functionSql,
+  viewSql,
+  refreshMaterializedViewSql,
+  alterColumnSql,
+  identitySequence,
+  createTableSql,
+  qualify
+} from "./41kv2xdm.js";
+import {
+  isExactVersion,
+  compareExtensionVersions,
+  sameExtensionDefinition
+} from "./8ktwd3rh.js";
+import {
+  isDomain,
+  sameEnumLabels
+} from "./g7ez901n.js";
+import {
+  quoteLiteral
+} from "./94ez8kzh.js";
+import {
+  staticNamespace2,
+  identityKey2,
+  identityLabel2,
+  compareText
+} from "./t4tbsy9h.js";
+import {
+  fitIdentifier2
+} from "./nfzc5z0w.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/type-name.ts
+function canonicalTypeName(typeName) {
+  const suffix = arraySuffix(typeName);
+  const scalar = suffix.length === 0 ? typeName : typeName.slice(0, -suffix.length);
+  return canonicalScalar(scalar) + suffix;
+}
+function arraySuffix(typeName) {
+  let end = typeName.length;
+  let suffix = "";
+  while (end >= 2 && typeName.endsWith("[]", end)) {
+    suffix = `[]${suffix}`;
+    end -= 2;
+  }
+  return suffix;
+}
+function canonicalScalar(typeName) {
+  const varying = /^(?:varchar|character varying)(\(\d+\))$/.exec(typeName);
+  if (varying !== null)
+    return `character varying${varying[1] ?? ""}`;
+  const fixed = /^(?:char|character)(\(\d+\))$/.exec(typeName);
+  if (fixed !== null)
+    return `character${fixed[1] ?? ""}`;
+  const timed = /^(timestamp with time zone|timestamp without time zone|time with time zone|time without time zone|timestamptz|timestamp|timetz|time)(\(\d+\))?$/.exec(typeName);
+  if (timed !== null)
+    return canonicalTime(timed[1] ?? "", timed[2] ?? "");
+  const numeric = /^(?:decimal|numeric)(\(\d+(?:,\d+)?\))?$/.exec(typeName);
+  if (numeric !== null)
+    return `numeric${numeric[1] ?? ""}`;
+  switch (typeName) {
+    case "int":
+    case "int4":
+    case "integer":
+      return "integer";
+    case "int8":
+    case "bigint":
+      return "bigint";
+    case "int2":
+    case "smallint":
+      return "smallint";
+    case "bool":
+    case "boolean":
+      return "boolean";
+    case "float8":
+    case "double precision":
+      return "double precision";
+    case "float4":
+    case "real":
+      return "real";
+    default:
+      return typeName;
+  }
+}
+function canonicalTime(name, precision) {
+  if (name === "timestamptz" || name === "timestamp with time zone") {
+    return `timestamp${precision} with time zone`;
+  }
+  if (name === "timestamp" || name === "timestamp without time zone") {
+    return `timestamp${precision} without time zone`;
+  }
+  if (name === "timetz" || name === "time with time zone") {
+    return `time${precision} with time zone`;
+  }
+  return `time${precision} without time zone`;
+}
+
+// src/dialects/pg/role/sql.ts
+var PRIVILEGE = /^(select|insert|update|delete|execute|usage)$/;
+function privilegeSql(before, after, schema, recreated = new Set) {
+  const beforeBy = index(before);
+  const afterBy = index(after);
+  const revoke = [];
+  const roles = [];
+  const defaults = [];
+  const grant = [];
+  for (const [key, object] of beforeBy) {
+    if (afterBy.has(key))
+      continue;
+    if (object.kind === "grant") {
+      revoke.push({ sql: grantStatement(object, schema, true), kind: "revoke" });
+    }
+    if (object.kind === "defaultPrivilege") {
+      revoke.push({ sql: defaultStatement(object, true), kind: "revoke-default" });
+    }
+  }
+  for (const [key, object] of afterBy) {
+    const previous = beforeBy.get(key);
+    if (object.kind === "role") {
+      if (object.owner !== "managed")
+        continue;
+      if (previous === undefined) {
+        roles.push({ sql: createRoleSql(object), kind: "create-role" });
+        continue;
+      }
+      if (previous.kind !== "role" || previous.owner !== "managed")
+        continue;
+      if (previous.definition.login !== object.definition.login || previous.definition.inherit !== object.definition.inherit) {
+        roles.push({ sql: alterRoleSql(object), kind: "alter-role" });
+      }
+      continue;
+    }
+    if (object.kind === "grant") {
+      const target = grantTargetKey(object.identity.object);
+      if (previous !== undefined && (target === undefined || !recreated.has(target)))
+        continue;
+      grant.push({ sql: grantStatement(object, schema, false), kind: "grant" });
+      continue;
+    }
+    if (previous !== undefined)
+      continue;
+    if (object.kind === "defaultPrivilege") {
+      defaults.push({ sql: defaultStatement(object, false), kind: "grant-default" });
+    }
+  }
+  return { revoke, prepare: [...roles, ...defaults], grant };
+}
+function createdRoleName(sql) {
+  const match = /^\s*create\s+role\s+(?:"([^"]+)"|([A-Za-z_][\w$]*))/i.exec(sql);
+  const quoted = match?.[1];
+  if (quoted !== undefined)
+    return quoted.replaceAll('""', '"');
+  return match?.[2];
+}
+function changesRole(sql) {
+  return /^\s*(create|alter)\s+role\b/i.test(sql);
+}
+function index(objects) {
+  const by = new Map;
+  for (const object of objects) {
+    if (object.kind !== "role" && object.kind !== "grant" && object.kind !== "defaultPrivilege") {
+      continue;
+    }
+    by.set(identityKey2(object.identity), object);
+  }
+  return by;
+}
+function createRoleSql(object) {
+  return `create role ${quoteIdent(object.identity.name)} with nosuperuser nocreatedb nocreaterole ${inherit(object)} ${login(object)}`;
+}
+function alterRoleSql(object) {
+  return `alter role ${quoteIdent(object.identity.name)} with ${inherit(object)} ${login(object)}`;
+}
+function login(object) {
+  return object.definition.login ? "login" : "nologin";
+}
+function inherit(object) {
+  return object.definition.inherit ? "inherit" : "noinherit";
+}
+function grantStatement(object, schema, revoke) {
+  const privilege = object.identity.privilege.toLowerCase();
+  assertPrivilege(privilege);
+  const verb = revoke ? "revoke" : "grant";
+  const direction = revoke ? "from" : "to";
+  return `${verb} ${privilege} on ${grantTarget(object.identity.object, schema)} ${direction} ${quoteIdent(object.identity.role)}`;
+}
+function defaultStatement(object, revoke) {
+  const privilege = object.identity.privilege.toLowerCase();
+  assertPrivilege(privilege);
+  const verb = revoke ? "revoke" : "grant";
+  const direction = revoke ? "from" : "to";
+  const namespace = object.identity.namespace.form === "static" ? object.identity.namespace.name : "public";
+  return `alter default privileges for role ${quoteIdent(object.identity.forRole)} in schema ${quoteIdent(namespace)} ${verb} ${privilege} on ${objectKindSql(object.identity.objectKind)} ${direction} ${quoteIdent(object.identity.grantee)}`;
+}
+function grantTargetKey(object) {
+  if (object.kind === "table" || object.kind === "view" || object.kind === "materializedView" || object.kind === "sequence") {
+    return identityKey2({ kind: object.kind, namespace: object.namespace, name: object.name });
+  }
+  if (object.kind !== "function")
+    return;
+  const open = object.name.lastIndexOf("(");
+  if (open < 0 || !object.name.endsWith(")"))
+    return;
+  const name = object.name.slice(0, open);
+  const args = object.name.slice(open + 1, -1);
+  return identityKey2({
+    kind: "function",
+    namespace: object.namespace,
+    name,
+    argTypes: args.length === 0 ? [] : args.split(",")
+  });
+}
+function grantTarget(object, schema) {
+  const name = object.namespace.form === "static" ? object.namespace.name : schema;
+  if (object.kind === "sequence")
+    return `sequence ${qualify(name, object.name)}`;
+  if (object.kind === "function")
+    return functionTarget(object.name, name);
+  if (object.kind === "namespace")
+    return `schema ${quoteIdent(object.name)}`;
+  return `table ${qualify(name, object.name)}`;
+}
+function functionTarget(name, schema) {
+  const open = name.lastIndexOf("(");
+  if (open < 0 || !name.endsWith(")"))
+    return `function ${qualify(schema, name)}()`;
+  const fn = name.slice(0, open);
+  const args = name.slice(open + 1, -1);
+  return `function ${qualify(schema, fn)}(${args})`;
+}
+function objectKindSql(kind) {
+  if (kind === "function")
+    return "functions";
+  if (kind === "sequence")
+    return "sequences";
+  return "tables";
+}
+function assertPrivilege(privilege) {
+  if (!PRIVILEGE.test(privilege)) {
+    throw new OkmError2("invalid", `Privilege ${privilege} is not emitted.`, {
+      fix: {
+        summary: "Grants in this version are select, insert, update, delete, execute, and usage."
+      }
+    });
+  }
+}
+
+// src/tooling/migrate/backfill.ts
+var DEFAULT_BACKFILL_BATCH_SIZE = 1000;
+var DEFAULT_BACKFILL_PAUSE_MS = 0;
+var DEFAULT_BACKFILL_STATEMENT_TIMEOUT_MS = 30000;
+var HEADER = /^-- backfill table=(\S+) key=(\S+) batch=(\d+)$/;
+var CAST_TYPE = /^[A-Za-z_][\w$ ]*(?:\([^)]*\))?(?:\[\])*$/;
+function batchSizeField(batchSize) {
+  return batchSize === undefined ? {} : { batchSize };
+}
+function resolveBatchSize(requested) {
+  const batch = requested ?? DEFAULT_BACKFILL_BATCH_SIZE;
+  if (!Number.isInteger(batch) || batch < 1) {
+    throw new OkmError2("invalid", "backfill.batchSize must be an integer of at least 1.", {
+      fix: {
+        summary: "Set defineConfig({ backfill: { batchSize } }) to a positive integer."
+      }
+    });
+  }
+  return batch;
+}
+function formatBackfillHeader(spec) {
+  return `-- backfill table=${spec.table} key=${spec.key.join(",")} batch=${String(spec.batch)}`;
+}
+function parseBackfillHeader(line) {
+  if (!line.startsWith("-- backfill "))
+    return;
+  const match = HEADER.exec(line);
+  const table = match?.[1];
+  const keyText = match?.[2];
+  const batchText = match?.[3];
+  const key = keyText === undefined ? [] : splitKey(keyText);
+  const batch = batchText === undefined ? Number.NaN : Number(batchText);
+  if (table === undefined || key.length === 0 || !Number.isInteger(batch) || batch < 1) {
+    throw new OkmError2("invalid", "A backfill header needs table=<table> key=<col> batch=<n>.", {
+      fix: {
+        summary: "Write -- backfill table=<table> key=<col[,col]> batch=<n> with a batch of at least 1."
+      }
+    });
+  }
+  return { table, key, batch };
+}
+function primaryKeyColumns(catalogs, table) {
+  for (const source of catalogs) {
+    const columns = keyOn(source, table);
+    if (columns !== undefined)
+      return columns;
+  }
+  throw new OkmError2("OKM1546", `Table ${table} has no primary key, so it cannot be backfilled.`, {
+    fix: {
+      summary: "Add a primary key. A backfill walks that key and does not scan the table."
+    }
+  });
+}
+function keyRangePredicate(columns) {
+  for (const column of columns)
+    assertCastType(column.dataType);
+  const lower = compareKey(columns, "$1", ">");
+  const upper = compareKey(columns, "$2", "<=");
+  return `($1::text is null or ${lower}) and ($2::text is null or ${upper})`;
+}
+function aboutBatchCount(rows, batch) {
+  if (!Number.isFinite(rows) || batch < 1)
+    return 0;
+  const rounded = Math.max(0, Math.round(rows));
+  if (rounded === 0)
+    return 0;
+  return Math.ceil(rounded / batch);
+}
+function keyOn(source, table) {
+  const constraint = source.objects.find((object) => object.kind === "constraint" && object.definition.constraintKind === "primaryKey" && object.identity.parent.name === table);
+  if (constraint === undefined || constraint.kind !== "constraint")
+    return;
+  const columns = [];
+  for (const name of constraint.definition.columns) {
+    const column = source.objects.find((object) => object.kind === "column" && object.identity.parent.name === table && object.identity.name === name);
+    if (column === undefined || column.kind !== "column") {
+      throw new OkmError2("OKM1546", `Table ${table} primary key column ${name} is not in the catalog.`, { fix: { summary: "Keep the primary key columns on the table." } });
+    }
+    columns.push({ quoted: quoteIdent(name), dataType: column.definition.dataType });
+  }
+  if (columns.length === 0)
+    return;
+  return columns;
+}
+function boundaryQuery(table, columns) {
+  for (const column of columns)
+    checkedCast(column.dataType);
+  const order = columns.map((column) => column.quoted).join(", ");
+  const first = columns[0];
+  const projected = columns.length === 1 && first !== undefined ? `${first.quoted}::text` : `jsonb_build_array(${columns.map((column) => `${column.quoted}::text`).join(", ")})::text`;
+  const lower = `($1::text is null or ${compareKey(columns, "$1", ">")})`;
+  return `select ${projected} as okm_key from ${table} where ${lower} order by ${order} offset $2::bigint limit 1`;
+}
+function checkedCast(dataType) {
+  assertCastType(dataType);
+  return dataType;
+}
+function compareKey(columns, param, operator) {
+  const first = columns[0];
+  if (first === undefined)
+    return "false";
+  if (columns.length === 1) {
+    return `${first.quoted} ${operator} ${param}::${first.dataType}`;
+  }
+  const left = columns.map((column) => column.quoted).join(", ");
+  const right = columns.map((column, index) => `((${param}::jsonb)->>${String(index)})::${column.dataType}`).join(", ");
+  return `(${left}) ${operator} (${right})`;
+}
+function assertCastType(dataType) {
+  if (CAST_TYPE.test(dataType))
+    return;
+  throw new OkmError2("OKM1546", `Primary key type ${dataType} cannot be used as a backfill bound.`, {
+    fix: {
+      summary: "Use an orderable scalar key. A backfill casts each bound to the key type."
+    }
+  });
+}
+function splitKey(text) {
+  const names = [];
+  let index = 0;
+  while (index < text.length) {
+    if (text[index] === '"') {
+      let value = "";
+      index += 1;
+      let closed = false;
+      while (index < text.length) {
+        const char = text[index];
+        if (char === '"' && text[index + 1] === '"') {
+          value += '"';
+          index += 2;
+          continue;
+        }
+        if (char === '"') {
+          index += 1;
+          closed = true;
+          break;
+        }
+        value += char ?? "";
+        index += 1;
+      }
+      if (!closed)
+        return [];
+      names.push(quoteIdent(value));
+      if (text[index] === ",")
+        index += 1;
+      continue;
+    }
+    const comma = text.indexOf(",", index);
+    const end = comma === -1 ? text.length : comma;
+    const raw = text.slice(index, end);
+    if (raw.length === 0)
+      return [];
+    names.push(quoteIdent(raw));
+    index = comma === -1 ? text.length : comma + 1;
+  }
+  return names;
+}
+
+// src/tooling/migrate/classify.ts
+var STEP_CLASS = {
+  "create-table": "expand",
+  "drop-table": "contract",
+  "add-column": "expand",
+  "add-column-required": "contract",
+  "drop-column": "contract",
+  "set-column-type": "contract",
+  "set-not-null": "contract",
+  "drop-not-null": "expand",
+  "set-default": "expand",
+  "drop-default": "contract",
+  "add-identity": "expand",
+  "drop-identity": "contract",
+  "set-identity-always": "contract",
+  "set-identity-by-default": "expand",
+  "add-constraint": "expand",
+  "validate-constraint": "expand",
+  "drop-constraint": "contract",
+  "drop-not-null-check": "expand",
+  "rename-constraint": "contract",
+  "widen-check": "expand",
+  "narrow-check": "contract",
+  "create-index": "expand",
+  "drop-index": "contract",
+  "rename-index": "contract",
+  "create-sequence": "expand",
+  "drop-sequence": "contract",
+  "create-enum": "expand",
+  "recreate-enum": "contract",
+  "add-enum-value": "expand",
+  "rename-enum": "contract",
+  "drop-enum": "contract",
+  "set-enum-column": "contract",
+  "create-domain": "expand",
+  "drop-domain": "contract",
+  "add-domain-check": "expand",
+  "validate-domain-check": "expand",
+  "drop-domain-check": "contract",
+  "rename-domain-check": "expand",
+  "create-extension": "expand",
+  "drop-extension": "contract",
+  "update-extension": "expand",
+  "move-extension": "contract",
+  "create-function": "expand",
+  "drop-function": "contract",
+  "replace-function": "expand",
+  "create-trigger": "expand",
+  "drop-trigger": "contract",
+  "create-view": "expand",
+  "drop-view": "contract",
+  "replace-view": "expand",
+  "create-matview": "expand",
+  "drop-matview": "contract",
+  "refresh-matview": "expand",
+  "create-role": "expand",
+  "alter-role": "contract",
+  grant: "expand",
+  revoke: "contract",
+  "grant-default": "expand",
+  "revoke-default": "contract",
+  "rename-table": "contract",
+  "rename-column": "contract",
+  "rename-sequence": "contract",
+  "backfill-expand": "expand",
+  "backfill-contract": "contract",
+  "raw-sql": "unclassified"
+};
+var STEP_KINDS = Object.keys(STEP_CLASS);
+function classOf(kind) {
+  return STEP_CLASS[kind];
+}
+function strictestClass(classes) {
+  if (classes.includes("contract"))
+    return "contract";
+  if (classes.includes("unclassified"))
+    return "unclassified";
+  return "expand";
+}
+function isStepKind(value) {
+  return Object.hasOwn(STEP_CLASS, value);
+}
+
+// src/tooling/migrate/extensions.ts
+var CREATE_EXTENSION = /^\s*create\s+extension\s+(?:"([^"]+)"|([A-Za-z_][\w$]*))/i;
+var UPDATE_EXTENSION = /^\s*alter\s+extension\s+(?:"([^"]+)"|([A-Za-z_][\w$]*))\s+update\s+to\s+'([^']*)'/i;
+function extensionAlterSteps(beforeBy, afterBy, dropKeys) {
+  refuseDrops(beforeBy, afterBy, dropKeys);
+  const steps = [];
+  for (const after of afterBy.values()) {
+    if (after.kind !== "extension")
+      continue;
+    const before = beforeBy.get(identityKey2(after.identity));
+    if (before === undefined || before.kind !== "extension")
+      continue;
+    if (sameExtensionDefinition(before, after))
+      continue;
+    steps.push(...alterExtension(before, after));
+  }
+  return steps;
+}
+async function assertExtensionsAvailable(connection, migrations) {
+  const creates = new Set;
+  const updates = [];
+  for (const migration of migrations) {
+    for (const step of migration.steps) {
+      const created = CREATE_EXTENSION.exec(step.sql);
+      const name = created?.[1] ?? created?.[2];
+      if (name !== undefined)
+        creates.add(name.replaceAll('""', '"'));
+      const updated = UPDATE_EXTENSION.exec(step.sql);
+      const updateName = updated?.[1] ?? updated?.[2];
+      const version = updated?.[3];
+      if (updateName !== undefined && version !== undefined) {
+        updates.push({ name: updateName.replaceAll('""', '"'), version });
+      }
+    }
+  }
+  if (creates.size === 0 && updates.length === 0)
+    return;
+  const names = [...creates, ...updates.map((item) => item.name)];
+  const available = await availableExtensions(connection, names);
+  for (const name of creates) {
+    if (!available.has(name)) {
+      throw new OkmError2("OKM1811", `Extension ${name} is not available on the server. Nothing was changed.`, { fix: { summary: "Install the extension, or remove the declaration." } });
+    }
+  }
+  for (const update of updates) {
+    if (!available.has(update.name)) {
+      throw new OkmError2("OKM1811", `Extension ${update.name} is not available on the server. Nothing was changed.`, { fix: { summary: "Install the extension, or remove the declaration." } });
+    }
+    const installed = await installedVersion(connection, update.name);
+    if (installed === undefined) {
+      throw new OkmError2("OKM1811", `Extension ${update.name} is not installed, so it cannot be updated. Nothing was changed.`, { fix: { summary: "Create the extension before updating it." } });
+    }
+    const path = await updatePath(connection, update.name, installed, update.version);
+    if (!path) {
+      throw new OkmError2("OKM1814", `Extension ${update.name} has no update path from ${installed} to ${update.version}. Nothing was changed.`, {
+        fix: {
+          summary: "Drop or move the dependents first. Postgres cannot lower an extension version."
+        }
+      });
+    }
+  }
+}
+function refuseDrops(beforeBy, afterBy, dropKeys) {
+  for (const key of dropKeys) {
+    const object = beforeBy.get(key);
+    if (object?.kind !== "extension")
+      continue;
+    for (const after of afterBy.values()) {
+      const used = after.dependencies.some((edge) => edge.target.kind === "extension" && edge.target.name === object.identity.name);
+      if (!used)
+        continue;
+      throw new OkmError2("OKM1814", `Extension ${object.identity.name} still has dependents. Nothing was dropped.`, {
+        fix: {
+          summary: "Drop or move the dependents first. Postgres cannot lower an extension version."
+        }
+      });
+    }
+  }
+}
+function alterExtension(before, after) {
+  const steps = [];
+  const name = quoteIdent(after.identity.name);
+  if (before.definition.schema !== after.definition.schema) {
+    if (!after.definition.relocatable) {
+      throw new OkmError2("OKM1814", `Extension ${after.identity.name} is not relocatable, so it cannot move to ${after.definition.schema}.`, {
+        fix: {
+          summary: "Drop or move the dependents first. Postgres cannot lower an extension version."
+        }
+      });
+    }
+    steps.push(extensionStep(`alter extension ${name} set schema ${quoteIdent(after.definition.schema)}`, "move-extension"));
+  }
+  const previous = before.definition.version;
+  const next = after.definition.version;
+  if (!isExactVersion(previous) || !isExactVersion(next) || previous === next)
+    return steps;
+  if (compareExtensionVersions(next, previous) < 0) {
+    throw new OkmError2("OKM1814", `Extension ${after.identity.name} cannot move from ${previous} to ${next}. Postgres cannot lower an extension version.`, {
+      fix: {
+        summary: "Drop or move the dependents first. Postgres cannot lower an extension version."
+      }
+    });
+  }
+  steps.push(extensionStep(`alter extension ${name} update to ${quoteLiteral(next)}`, "update-extension", {
+    path: "unverified"
+  }));
+  return steps;
+}
+function extensionStep(sql, kind, extra) {
+  const classification = classOf(kind);
+  if (classification === "unclassified") {
+    throw new OkmError2("invalid", `Extension step ${kind} has no class.`, {
+      fix: { summary: "Classify the extension step as expand or contract." }
+    });
+  }
+  return {
+    sql,
+    kind,
+    class: classification,
+    action: "ddl",
+    lock: "ACCESS EXCLUSIVE",
+    transactional: true,
+    ...extra?.path !== undefined ? { path: extra.path } : {}
+  };
+}
+async function availableExtensions(connection, names) {
+  const listed = await connection.execute(`select name from pg_available_extensions where name in (${names.map((_, index) => `$${String(index + 1)}`).join(", ")})`, names);
+  const found = new Set;
+  for (const row of listed.rows) {
+    const name = row[0];
+    if (typeof name === "string")
+      found.add(name);
+  }
+  return found;
+}
+async function installedVersion(connection, name) {
+  const result = await connection.execute("select extversion from pg_extension where extname = $1", [name]);
+  const version = result.rows[0]?.[0];
+  return typeof version === "string" ? version : undefined;
+}
+async function updatePath(connection, name, source, target) {
+  const result = await connection.execute("select path from pg_extension_update_paths($1) where source = $2 and target = $3", [name, source, target]);
+  const path = result.rows[0]?.[0];
+  return typeof path === "string" && path.length > 0;
+}
+
+// src/tooling/migrate/managed.ts
+var MANAGED_TABLES = new Set(["okm_meta", "okm_history", "okm_backfill"]);
+function omitManagedObjects(source) {
+  let dropped = false;
+  const objects = [];
+  for (const object of source.objects) {
+    if (ownedByMigration(object)) {
+      dropped = true;
+      continue;
+    }
+    objects.push(object);
+  }
+  if (!dropped)
+    return source;
+  return { version: source.version, objects };
+}
+function ownedByMigration(object) {
+  switch (object.kind) {
+    case "table":
+    case "view":
+    case "materializedView":
+      return MANAGED_TABLES.has(object.identity.name);
+    case "column":
+    case "index":
+    case "constraint":
+    case "trigger":
+      return MANAGED_TABLES.has(object.identity.parent.name);
+    case "sequence":
+      return managedSequence(object.identity.name);
+    case "grant": {
+      const target = object.identity.object;
+      if (target.kind === "namespace")
+        return false;
+      if (target.kind === "sequence" || target.kind === "function") {
+        return managedSequence(target.name);
+      }
+      return MANAGED_TABLES.has(target.name);
+    }
+    default:
+      return false;
+  }
+}
+function managedSequence(name) {
+  return name === "okm_meta" || name === "okm_history" || name === "okm_backfill" || name.startsWith("okm_meta_") || name.startsWith("okm_history_") || name.startsWith("okm_backfill_");
+}
+
+// src/tooling/migrate/safe.ts
+var ACCESS = "ACCESS EXCLUSIVE";
+var SHARE_UPDATE = "SHARE UPDATE EXCLUSIVE";
+var ROW = "ROW EXCLUSIVE";
+var VOLATILE_BUILTIN = new Set([
+  "clock_timestamp",
+  "gen_random_uuid",
+  "nextval",
+  "random",
+  "random_normal",
+  "setval",
+  "timeofday",
+  "uuidv7"
+]);
+var STABLE_BUILTIN = new Set([
+  "current_catalog",
+  "current_date",
+  "current_role",
+  "current_schema",
+  "current_time",
+  "current_timestamp",
+  "current_user",
+  "localtime",
+  "localtimestamp",
+  "now",
+  "session_user",
+  "statement_timestamp",
+  "transaction_timestamp"
+]);
+function stepsForExistingTable(object, schema, catalogs, batchSize) {
+  if (object.kind === "index")
+    return [concurrentIndexStep(object, schema)];
+  if (object.kind === "constraint")
+    return constraintSteps(object, schema);
+  if (object.kind === "column" && volatileDefault(object.definition.defaultExpression, catalogs)) {
+    return volatileColumnSteps(object, schema, catalogs, batchSize);
+  }
+  return;
+}
+function notNullSteps(column, schema, setKind, catalogs) {
+  const tableName = column.identity.parent.name;
+  const columnName = column.identity.name;
+  const table = qualify(schema, tableName);
+  const quotedColumn = quoteIdent(columnName);
+  const constraint = quoteIdent(notNullConstraintName(tableName, columnName, catalogs));
+  return [
+    {
+      sql: `alter table ${table} add constraint ${constraint} check (${quotedColumn} is not null) not valid`,
+      kind: "add-constraint",
+      action: "ddl",
+      lock: ACCESS,
+      transactional: true
+    },
+    {
+      sql: `alter table ${table} validate constraint ${constraint}`,
+      kind: "validate-constraint",
+      action: "ddl",
+      lock: SHARE_UPDATE,
+      transactional: true
+    },
+    {
+      sql: `alter table ${table} alter column ${quotedColumn} set not null`,
+      kind: setKind,
+      action: "ddl",
+      lock: ACCESS,
+      transactional: true
+    },
+    {
+      sql: `alter table ${table} drop constraint ${constraint}`,
+      kind: "drop-not-null-check",
+      action: "ddl",
+      lock: ACCESS,
+      transactional: true
+    }
+  ];
+}
+function concurrentIndexSql(sql) {
+  const unique = "create unique index ";
+  const plain = "create index ";
+  if (sql.startsWith(unique))
+    return `create unique index concurrently ${sql.slice(unique.length)}`;
+  if (sql.startsWith(plain))
+    return `create index concurrently ${sql.slice(plain.length)}`;
+  return sql;
+}
+function concurrentDropIndexSql(sql) {
+  const prefix = "drop index ";
+  if (!sql.startsWith(prefix))
+    return sql;
+  return `drop index concurrently ${sql.slice(prefix.length)}`;
+}
+function volatileDefault(expression, catalogs) {
+  if (expression === undefined)
+    return false;
+  const known = catalogVolatility(catalogs);
+  for (const name of functionCalls(expression)) {
+    const lower = name.toLowerCase();
+    if (VOLATILE_BUILTIN.has(lower))
+      return true;
+    if (STABLE_BUILTIN.has(lower))
+      continue;
+    if (known.get(lower) === "volatile")
+      return true;
+  }
+  return false;
+}
+function concurrentIndexStep(object, schema) {
+  const plain = createObjectSql(object, schema) ?? "";
+  return {
+    sql: concurrentIndexSql(plain),
+    kind: "create-index",
+    action: "ddl",
+    lock: SHARE_UPDATE,
+    transactional: false
+  };
+}
+function constraintSteps(object, schema) {
+  const kind = object.definition.constraintKind;
+  if (kind === "unique" || kind === "primaryKey")
+    return usingIndexSteps(object, schema);
+  return notValidSteps(object, schema);
+}
+function notValidSteps(object, schema) {
+  const plain = createObjectSql(object, schema);
+  if (plain === undefined)
+    return [];
+  const table = qualify(schema, object.identity.parent.name);
+  const name = quoteIdent(object.identity.name);
+  const referenced = object.definition.references;
+  const referencedLock = referenced === undefined ? undefined : qualify(schema, referenced.parent.name);
+  return [
+    {
+      sql: `${plain} not valid`,
+      kind: "add-constraint",
+      action: "ddl",
+      lock: referencedLock === undefined ? ACCESS : `${ACCESS}; SHARE ROW EXCLUSIVE on ${referencedLock}`,
+      transactional: true
+    },
+    {
+      sql: `alter table ${table} validate constraint ${name}`,
+      kind: "validate-constraint",
+      action: "ddl",
+      lock: referencedLock === undefined ? SHARE_UPDATE : `${SHARE_UPDATE}; ROW SHARE on ${referencedLock}`,
+      transactional: true
+    }
+  ];
+}
+function usingIndexSteps(object, schema) {
+  const table = qualify(schema, object.identity.parent.name);
+  const name = quoteIdent(object.identity.name);
+  const columns = object.definition.columns.map((column) => quoteIdent(column)).join(", ");
+  const nulls = object.definition.nullsNotDistinct ? " nulls not distinct" : "";
+  const verb = object.definition.constraintKind === "primaryKey" ? "primary key" : "unique";
+  const defer = object.definition.deferrable ? ` deferrable initially ${object.definition.initially}` : "";
+  return [
+    {
+      sql: `create unique index concurrently ${name} on ${table} (${columns})${nulls}`,
+      kind: "create-index",
+      action: "ddl",
+      lock: SHARE_UPDATE,
+      transactional: false
+    },
+    {
+      sql: `alter table ${table} add constraint ${name} ${verb} using index ${name}${defer}`,
+      kind: "add-constraint",
+      action: "ddl",
+      lock: ACCESS,
+      transactional: true
+    }
+  ];
+}
+function volatileColumnSteps(column, schema, catalogs, batchSize) {
+  const tableName = column.identity.parent.name;
+  const table = qualify(schema, tableName);
+  const name = quoteIdent(column.identity.name);
+  const collate = column.definition.collation === undefined ? "" : ` collate ${quoteIdent(column.definition.collation)}`;
+  const expression = column.definition.defaultExpression ?? "";
+  const key = primaryKeyColumns(catalogs, tableName);
+  const backfill = {
+    table,
+    key: key.map((item) => item.quoted),
+    batch: batchSize
+  };
+  const steps = [
+    {
+      sql: `alter table ${table} add column ${name} ${column.definition.dataType}${collate}`,
+      kind: "add-column",
+      action: "ddl",
+      lock: ACCESS,
+      transactional: true
+    },
+    {
+      sql: `alter table ${table} alter column ${name} set default ${expression}`,
+      kind: "set-default",
+      action: "ddl",
+      lock: ACCESS,
+      transactional: true
+    },
+    {
+      sql: `update ${table} set ${name} = ${expression} where ${name} is null and ${keyRangePredicate(key)}`,
+      kind: "backfill-expand",
+      action: "backfill",
+      lock: ROW,
+      transactional: false,
+      backfill
+    }
+  ];
+  if (!column.definition.nullable) {
+    steps.push(...notNullSteps(column, schema, "add-column", catalogs));
+  }
+  return steps;
+}
+function notNullConstraintName(table, column, catalogs) {
+  const taken = new Set;
+  for (const source of catalogs) {
+    for (const object of source.objects) {
+      if (object.kind === "constraint" || object.kind === "index")
+        taken.add(object.identity.name);
+    }
+  }
+  const base = fitIdentifier2(`${table}_${column}_notnull`);
+  if (!taken.has(base))
+    return base;
+  return fitIdentifier2(`${table}_${column}_notnull_okm`);
+}
+function catalogVolatility(catalogs) {
+  const map = new Map;
+  for (const source of catalogs) {
+    for (const object of source.objects) {
+      if (object.kind !== "function")
+        continue;
+      const name = object.identity.name.toLowerCase();
+      const next = object.definition.volatility;
+      const current = map.get(name);
+      if (current === "volatile" || next === "volatile")
+        map.set(name, "volatile");
+      else if (current === undefined)
+        map.set(name, next);
+    }
+  }
+  return map;
+}
+function functionCalls(expression) {
+  const names = [];
+  let index = 0;
+  while (index < expression.length) {
+    const char = expression[index];
+    if (char === "'") {
+      index += 1;
+      while (index < expression.length) {
+        if (expression[index] === "'" && expression[index + 1] === "'") {
+          index += 2;
+          continue;
+        }
+        if (expression[index] === "'") {
+          index += 1;
+          break;
+        }
+        index += 1;
+      }
+      continue;
+    }
+    if (char !== undefined && /[A-Za-z_]/.test(char)) {
+      const start = index;
+      index += 1;
+      while (index < expression.length && /[\w$]/.test(expression[index] ?? ""))
+        index += 1;
+      let name = expression.slice(start, index);
+      if (expression[index] === ".") {
+        index += 1;
+        const qualifier = index;
+        while (index < expression.length && /[\w$]/.test(expression[index] ?? ""))
+          index += 1;
+        name = expression.slice(qualifier, index);
+      }
+      while (expression[index] === " ")
+        index += 1;
+      if (expression[index] === "(")
+        names.push(name);
+      continue;
+    }
+    index += 1;
+  }
+  return names;
+}
+
+// src/tooling/migrate/values.ts
+function parseReplace(flag) {
+  const eq = flag.indexOf("=");
+  if (eq <= 0) {
+    throw new OkmError2("OKM1541", `--replace ${flag} must be table.column.old=new.`, {
+      fix: {
+        summary: "Pass --replace <table>.<column>.<old>=<new>, or =null on a nullable column."
+      }
+    });
+  }
+  const left = flag.slice(0, eq);
+  const raw = flag.slice(eq + 1);
+  const first = left.indexOf(".");
+  const second = first < 0 ? -1 : left.indexOf(".", first + 1);
+  if (first <= 0 || second <= first + 1 || second === left.length - 1) {
+    throw new OkmError2("OKM1541", `--replace ${flag} must be table.column.old=new.`, {
+      fix: {
+        summary: "Pass --replace <table>.<column>.<old>=<new>, or =null on a nullable column."
+      }
+    });
+  }
+  const table = left.slice(0, first);
+  const column = left.slice(first + 1, second);
+  const from = left.slice(second + 1);
+  return { table, column, from, to: raw === "null" ? null : raw };
+}
+function assertNoChains(replacements) {
+  const removed = new Set(replacements.map((item) => pair(item.table, item.column, item.from)));
+  for (const item of replacements) {
+    if (item.to !== null && removed.has(pair(item.table, item.column, item.to))) {
+      const flag = `--replace ${item.table}.${item.column}.${item.from}=${item.to}`;
+      throw new OkmError2("OKM1541", `${flag} chains through another removed value.`, {
+        fix: { summary: "The replacement must be in the new list. No chains." }
+      });
+    }
+  }
+}
+function pair(table, column, value) {
+  return `${table}\x00${column}\x00${value}`;
+}
+
+// src/tooling/migrate/plan.ts
+var ACCESS2 = "ACCESS EXCLUSIVE";
+var SHARE = "SHARE";
+var SHARE_UPDATE2 = "SHARE UPDATE EXCLUSIVE";
+var ROW2 = "ROW EXCLUSIVE";
+function planMigration(input) {
+  const request = {
+    ...input,
+    before: omitManagedObjects(input.before),
+    after: omitManagedObjects(input.after)
+  };
+  const schema = request.schema ?? "public";
+  const batchSize = resolveBatchSize(request.batchSize);
+  const renames = request.renames ?? [];
+  const replacements = request.replacements ?? [];
+  assertNoChains(replacements);
+  const renamed = applyRenames(request.before, renames);
+  const beforeList = index2(renamed);
+  const afterList = index2(request.after);
+  const beforeBy = new Map(beforeList.map((item) => [item.key, item.object]));
+  const afterBy = new Map(afterList.map((item) => [item.key, item.object]));
+  assertUnambiguous(beforeBy, afterBy);
+  const dropKeys = new Set;
+  const createKeys = new Set;
+  const replaces = [];
+  const alters = [];
+  for (const item of beforeList) {
+    if (!afterBy.has(item.key)) {
+      if (item.object.kind === "role")
+        continue;
+      dropKeys.add(item.key);
+    }
+  }
+  for (const item of afterList) {
+    if (!beforeBy.has(item.key))
+      createKeys.add(item.key);
+  }
+  for (const item of afterList) {
+    const previous = beforeBy.get(item.key);
+    if (previous === undefined || sameDefinition(previous, item.object))
+      continue;
+    if (previous.kind === "extension" && item.object.kind === "extension")
+      continue;
+    if (previous.kind === "role" && item.object.kind === "role")
+      continue;
+    if (previous.kind === "function" && item.object.kind === "function" && canonicalTypeName(previous.definition.returns) === canonicalTypeName(item.object.definition.returns)) {
+      replaces.push({ kind: "function", before: previous, after: item.object });
+      continue;
+    }
+    if (previous.kind === "view" && item.object.kind === "view") {
+      if (columnsAppended(previous.definition.columns, item.object.definition.columns)) {
+        replaces.push({ kind: "view", before: previous, after: item.object });
+        continue;
+      }
+    }
+    if (previous.kind === "type" && item.object.kind === "type") {
+      refuseDomainBaseChange(previous, item.object);
+      continue;
+    }
+    if (previous.kind === "column" && item.object.kind === "column" && columnAlterable(previous, item.object)) {
+      alters.push({ before: previous, after: item.object });
+      continue;
+    }
+    dropKeys.add(item.key);
+    createKeys.add(item.key);
+  }
+  const keptNames = pairSameShape(beforeBy, afterBy, dropKeys, createKeys);
+  const picklists = picklistChanges(beforeBy, afterBy, request.after);
+  const enums = enumEdits(beforeBy, afterBy, schema);
+  requireReplacements(picklists, enums, replacements);
+  recreateDependents(beforeList, afterList, alters, dropKeys, createKeys, picklists);
+  recreateRoutineDependents(afterList, dropKeys, createKeys);
+  recreateViewDependents(afterList, dropKeys, createKeys);
+  refuseRoutineDrops(beforeBy, afterBy, dropKeys);
+  omitOwnedSequences(createKeys, afterBy, request.after);
+  omitOwnedSequences(dropKeys, beforeBy, renamed);
+  const recreated = new Set;
+  for (const key of createKeys) {
+    if (dropKeys.has(key))
+      recreated.add(key);
+  }
+  const privileges = privilegeSql(renamed.objects, request.after.objects, schema, recreated);
+  const steps = [];
+  steps.push(...renameSteps(request.before, renames, schema));
+  for (const item of privileges.revoke)
+    steps.push(step(item.sql, item.kind, "ddl", ACCESS2));
+  steps.push(...keptNames.map((item) => renameShapeStep(item, schema)));
+  steps.push(...enumAddSteps(enums));
+  steps.push(...domainCheckSteps(beforeBy, afterBy, schema));
+  steps.push(...expandBackfills(picklists, enums, replacements, schema, [renamed, request.after], batchSize));
+  const droppedTables = new Set([...dropKeys].map((key) => beforeBy.get(key)).filter((object) => object?.kind === "table").map((object) => object.identity.name));
+  const deferred = new Set(picklists.map((change) => identityKey2(change.before.identity)));
+  const typeDrops = [];
+  const extensionDrops = [];
+  const reverse = [...creationOrder2(renamed)].reverse();
+  const emitDrop = (object) => {
+    const key = identityKey2(object.identity);
+    if (!dropKeys.has(key) || deferred.has(key) || covered(object, droppedTables))
+      return;
+    const sql = dropObjectSql(object, schema);
+    const kind = dropKind(object);
+    if (sql === undefined || kind === undefined)
+      return;
+    if (object.kind === "index" && hasTable(renamed, object.identity.parent.name)) {
+      steps.push({
+        ...step(concurrentDropIndexSql(sql), "drop-index", "ddl", SHARE_UPDATE2, false, [
+          object.identity.parent.name
+        ]),
+        safeRewrite: true
+      });
+      return;
+    }
+    steps.push(step(sql, kind, "ddl", ACCESS2));
+  };
+  for (const object of reverse)
+    if (object.kind === "trigger")
+      emitDrop(object);
+  for (const object of reverse)
+    if (object.kind === "function")
+      emitDrop(object);
+  for (const object of reverse)
+    if (ownedByView(object))
+      emitDrop(object);
+  for (const object of reverse) {
+    if (object.kind === "view" || object.kind === "materializedView")
+      emitDrop(object);
+  }
+  for (const object of reverse) {
+    if (object.kind === "trigger" || object.kind === "function" || object.kind === "view" || object.kind === "materializedView" || ownedByView(object)) {
+      continue;
+    }
+    const key = identityKey2(object.identity);
+    if (!dropKeys.has(key) || deferred.has(key) || covered(object, droppedTables))
+      continue;
+    if (object.kind === "type") {
+      typeDrops.push(object);
+      continue;
+    }
+    if (object.kind === "extension") {
+      extensionDrops.push(object);
+      continue;
+    }
+    emitDrop(object);
+  }
+  for (const object of typeDrops)
+    pushDrop(steps, object, schema);
+  for (const object of extensionDrops)
+    pushDrop(steps, object, schema);
+  steps.push(...extensionAlterSteps(beforeBy, afterBy, dropKeys));
+  for (const change of alters) {
+    const aligned = alignedColumnType(change.before, change.after);
+    const statements = alterColumnSql(aligned, change.after, schema);
+    const kinds = columnAlterKinds(aligned, change.after);
+    for (let index = 0;index < statements.length; index += 1) {
+      const sql = statements[index];
+      const kind = kinds[index];
+      if (sql === undefined || kind === undefined)
+        continue;
+      if (kind === "set-not-null") {
+        pushSafe(steps, notNullSteps(change.after, schema, "set-not-null", [renamed, request.after]));
+        continue;
+      }
+      steps.push(step(sql, kind, "ddl", ACCESS2));
+    }
+    const identitySql = identityChangeSql(change.before, change.after, schema);
+    const identity = identityKind(change.before, change.after);
+    if (identitySql !== undefined && identity !== undefined) {
+      steps.push(step(identitySql, identity, "ddl", ACCESS2));
+    }
+  }
+  const createdTables = new Set([...createKeys].map((key) => afterBy.get(key)).filter((object) => object?.kind === "table").map((object) => object.identity.name));
+  const emitted = new Set;
+  for (const item of privileges.prepare)
+    steps.push(step(item.sql, item.kind, "ddl", ACCESS2));
+  for (const object of creationOrder2(request.after)) {
+    if (object.kind !== "extension")
+      continue;
+    const key = identityKey2(object.identity);
+    if (!createKeys.has(key) || emitted.has(key))
+      continue;
+    emitted.add(key);
+    const sql = createObjectSql(object, schema);
+    const kind = createKind(object, false);
+    if (sql === undefined || kind === undefined)
+      continue;
+    steps.push(step(sql, kind, "ddl", ACCESS2));
+  }
+  for (const object of creationOrder2(request.after)) {
+    if (object.kind !== "type")
+      continue;
+    const key = identityKey2(object.identity);
+    if (!createKeys.has(key) || emitted.has(key))
+      continue;
+    emitted.add(key);
+    const sql = createObjectSql(object, schema);
+    const kind = createKind(object, false);
+    if (sql === undefined || kind === undefined)
+      continue;
+    steps.push(step(sql, kind, "ddl", ACCESS2));
+  }
+  for (const object of creationOrder2(request.after)) {
+    if (object.kind === "type" || object.kind === "extension" || object.kind === "function" || object.kind === "trigger" || object.kind === "view" || object.kind === "materializedView" || ownedByView(object)) {
+      continue;
+    }
+    const key = identityKey2(object.identity);
+    if (deferred.has(key))
+      continue;
+    const parent = anchoredParent(object);
+    const tableIsNew = parent !== undefined && createdTables.has(parent);
+    if (tableIsNew && folded(object, request.after))
+      continue;
+    const wanted = createKeys.has(key) || tableIsNew && !folded(object, request.after);
+    if (!wanted || emitted.has(key))
+      continue;
+    emitted.add(key);
+    if (object.kind === "table") {
+      steps.push(step(createTableSql(object, request.after, schema), "create-table", "ddl", ACCESS2));
+      continue;
+    }
+    const sql = createObjectSql(object, schema);
+    const kind = createKind(object, tableIsNew);
+    if (sql === undefined || kind === undefined)
+      continue;
+    if (!tableIsNew && parent !== undefined && hasTable(renamed, parent)) {
+      const safe = stepsForExistingTable(object, schema, [renamed, request.after], batchSize);
+      if (safe !== undefined) {
+        pushSafe(steps, safe);
+        continue;
+      }
+    }
+    steps.push(step(sql, kind, "ddl", object.kind === "index" ? SHARE : ACCESS2));
+  }
+  for (const change of replaces) {
+    if (sameDefinition(change.before, change.after))
+      continue;
+    const key = identityKey2(change.after.identity);
+    if (dropKeys.has(key) && createKeys.has(key))
+      continue;
+    const sql = change.kind === "function" ? functionSql(change.after, schema, true) : viewSql(change.after, schema, true);
+    const kind = change.kind === "function" ? "replace-function" : "replace-view";
+    steps.push({
+      sql,
+      kind,
+      class: classOf(kind),
+      action: "ddl",
+      lock: ACCESS2,
+      transactional: true,
+      behavior: "change"
+    });
+  }
+  for (const kind of ["function", "trigger", "view", "materializedView"]) {
+    for (const object of creationOrder2(request.after)) {
+      if (object.kind !== kind)
+        continue;
+      const key = identityKey2(object.identity);
+      if (!createKeys.has(key) || emitted.has(key))
+        continue;
+      emitted.add(key);
+      const sql = createObjectSql(object, schema);
+      const created = createKind(object, false);
+      if (sql === undefined || created === undefined)
+        continue;
+      steps.push(step(sql, created, "ddl", ACCESS2));
+    }
+  }
+  for (const object of creationOrder2(request.after)) {
+    if (!ownedByView(object))
+      continue;
+    const key = identityKey2(object.identity);
+    if (!createKeys.has(key) || emitted.has(key))
+      continue;
+    emitted.add(key);
+    const sql = createObjectSql(object, schema);
+    const kind = createKind(object, false);
+    if (sql === undefined || kind === undefined)
+      continue;
+    steps.push(step(sql, kind, "ddl", SHARE));
+  }
+  for (const object of creationOrder2(request.after)) {
+    if (object.kind !== "materializedView")
+      continue;
+    const key = identityKey2(object.identity);
+    if (!createKeys.has(key))
+      continue;
+    assertConcurrentRefresh(object, request.after);
+    steps.push(step(refreshMaterializedViewSql(object, schema, false), "refresh-matview", "backfill", ACCESS2));
+  }
+  for (const item of privileges.grant)
+    steps.push(step(item.sql, item.kind, "ddl", ACCESS2));
+  steps.push(...contractSwaps(picklists, enums, replacements, schema, [renamed, request.after], batchSize));
+  return {
+    name: request.name ?? "migration",
+    class: overall(steps),
+    steps
+  };
+}
+function formatPlan(plan, lockText) {
+  const lines = [`-- class: ${plan.class}`, `-- name: ${plan.name}`, ""];
+  if (plan.steps.length === 0) {
+    lines.push("-- no steps");
+    lines.push("");
+    return lines.join(`
+`);
+  }
+  for (const item of plan.steps) {
+    lines.push(`-- class: ${item.class}`);
+    if (item.kind !== undefined)
+      lines.push(`-- kind: ${item.kind}`);
+    lines.push(`-- action: ${item.action}`);
+    lines.push(`-- lock: ${lockText === undefined ? item.lock : lockText(item)}`);
+    if (item.backfill !== undefined)
+      lines.push(formatBackfillHeader(item.backfill));
+    if (!item.transactional)
+      lines.push("-- transactional: false");
+    if (item.path !== undefined)
+      lines.push(`-- path: ${item.path}`);
+    if (item.behavior === "change")
+      lines.push("-- behavior: change");
+    for (const allow of item.allows ?? []) {
+      lines.push(`-- okm-allow ${allow.code}: ${allow.reason}`);
+    }
+    lines.push(`${item.sql};`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function parsePlan(text) {
+  const lines = text.split(`
+`);
+  let name = "migration";
+  let planClass = "expand";
+  let index = 0;
+  while (index < lines.length && lines[index] !== "") {
+    const line = lines[index] ?? "";
+    if (line.startsWith("-- name: "))
+      name = line.slice("-- name: ".length);
+    if (line.startsWith("-- class: "))
+      planClass = readClass(line.slice("-- class: ".length));
+    index += 1;
+  }
+  const steps = [];
+  while (index < lines.length) {
+    if ((lines[index] ?? "").trim() === "") {
+      index += 1;
+      continue;
+    }
+    if (lines[index] === "-- no steps")
+      break;
+    let stepClass = "expand";
+    let sawClass = false;
+    let stepKind;
+    let action = "ddl";
+    let lock = "";
+    let transactional = true;
+    let backfill;
+    let path;
+    let behavior;
+    const allows = [];
+    const sql = [];
+    while (index < lines.length && (lines[index] ?? "") !== "") {
+      const line = lines[index] ?? "";
+      index += 1;
+      if (line.startsWith("-- class: ")) {
+        stepClass = readClass(line.slice("-- class: ".length));
+        sawClass = true;
+      } else if (line.startsWith("-- kind: ")) {
+        const kind = line.slice("-- kind: ".length);
+        if (isStepKind(kind))
+          stepKind = kind;
+      } else if (line.startsWith("-- action: "))
+        action = line.endsWith("backfill") ? "backfill" : "ddl";
+      else if (line.startsWith("-- lock: "))
+        lock = line.slice("-- lock: ".length);
+      else if (line.startsWith("-- backfill "))
+        backfill = parseBackfillHeader(line);
+      else if (line === "-- transactional: false")
+        transactional = false;
+      else if (line === "-- path: unverified")
+        path = "unverified";
+      else if (line === "-- behavior: change")
+        behavior = "change";
+      else if (line.startsWith("-- okm-allow"))
+        allows.push(readAllow(line));
+      else if (!line.startsWith("--"))
+        sql.push(line);
+    }
+    const statement = sql.join(`
+`).replace(/;\s*$/, "");
+    if (statement.length > 0) {
+      const kind = sawClass ? stepKind : "raw-sql";
+      const classification = sawClass ? stepClass : "unclassified";
+      steps.push({
+        sql: statement,
+        class: classification,
+        ...kind !== undefined ? { kind } : {},
+        action,
+        lock,
+        transactional,
+        ...backfill !== undefined ? { backfill } : {},
+        ...path !== undefined ? { path } : {},
+        ...behavior !== undefined ? { behavior } : {},
+        ...allows.length > 0 ? { allows } : {}
+      });
+    }
+  }
+  return { name, class: steps.length === 0 ? planClass : overall(steps), steps };
+}
+var ALLOW = /^-- okm-allow\s+(OKM\d+)\s*(?::\s*(.*))?$/;
+function readAllow(line) {
+  const match = ALLOW.exec(line);
+  if (match === null)
+    return { code: "", reason: "" };
+  return { code: match[1] ?? "", reason: (match[2] ?? "").trim() };
+}
+function readClass(value) {
+  if (value === "contract" || value === "unclassified")
+    return value;
+  return "expand";
+}
+function staleRenames(previous, renames) {
+  if (previous === undefined)
+    return [];
+  const messages = [];
+  for (const rename of renames) {
+    if (rename.kind === "table") {
+      if (!hasTable(previous, rename.from)) {
+        messages.push(`Table renamedFrom ${rename.from} is not in the previous snapshot.`);
+      }
+      continue;
+    }
+    const tableRename = renames.find((item) => item.kind === "table" && item.to === rename.table);
+    const previousTable = tableRename?.kind === "table" ? tableRename.from : rename.table;
+    if (!hasColumn(previous, previousTable, rename.from)) {
+      messages.push(`Column ${rename.table}.${rename.from} renamedFrom is not in the previous snapshot.`);
+    }
+  }
+  return messages;
+}
+function applyRenames(source, renames) {
+  let current = source;
+  const namespace = staticNamespace2("public");
+  for (const rename of renames) {
+    if (rename.kind !== "table")
+      continue;
+    if (!hasTable(current, rename.from))
+      continue;
+    current = renameTable2(current, { namespace, from: rename.from, to: rename.to });
+  }
+  for (const rename of renames) {
+    if (rename.kind !== "column")
+      continue;
+    const parent = { namespace, name: rename.table };
+    if (!hasColumn(current, rename.table, rename.from))
+      continue;
+    current = renameColumn2(current, { parent, from: rename.from, to: rename.to });
+  }
+  return current;
+}
+function renameSteps(source, renames, schema) {
+  const steps = [];
+  const tables = new Map;
+  for (const rename of renames) {
+    if (rename.kind !== "table" || !hasTable(source, rename.from))
+      continue;
+    tables.set(rename.to, rename.from);
+    steps.push(step(`alter table ${qualify(schema, rename.from)} rename to ${quoteIdent(rename.to)}`, "rename-table", "ddl", ACCESS2));
+    steps.push(...sequenceRenames(source, rename, schema));
+  }
+  for (const rename of renames) {
+    if (rename.kind !== "column")
+      continue;
+    const previousTable = tables.get(rename.table) ?? rename.table;
+    if (!hasColumn(source, previousTable, rename.from))
+      continue;
+    steps.push(step(`alter table ${qualify(schema, rename.table)} rename column ${quoteIdent(rename.from)} to ${quoteIdent(rename.to)}`, "rename-column", "ddl", ACCESS2));
+  }
+  return steps;
+}
+function sequenceRenames(source, rename, schema) {
+  const steps = [];
+  for (const object of source.objects) {
+    if (object.kind !== "column" || object.definition.identity === undefined)
+      continue;
+    if (object.identity.parent.name !== rename.from)
+      continue;
+    const fromName = fitIdentifier2(`${rename.from}_${object.identity.name}_seq`);
+    const toName = fitIdentifier2(`${rename.to}_${object.identity.name}_seq`);
+    if (fromName === toName)
+      continue;
+    const owned = source.objects.some((item) => item.kind === "sequence" && item.identity.name === fromName);
+    if (!owned)
+      continue;
+    steps.push(step(`alter sequence ${qualify(schema, fromName)} rename to ${quoteIdent(toName)}`, "rename-sequence", "ddl", ACCESS2));
+  }
+  return steps;
+}
+function pairSameShape(beforeBy, afterBy, dropKeys, createKeys) {
+  const dropped = [...dropKeys].map((key) => beforeBy.get(key)).filter((object) => object !== undefined);
+  const created = [...createKeys].map((key) => afterBy.get(key)).filter((object) => object !== undefined);
+  const pairs = [];
+  const used = new Set;
+  for (const left of dropped) {
+    if (left.kind !== "index" && left.kind !== "constraint")
+      continue;
+    const leftKey = identityKey2(left.identity);
+    const hits = created.filter((right) => {
+      const key = identityKey2(right.identity);
+      return key !== leftKey && !used.has(key) && sameShape(left, right);
+    });
+    const right = hits.length === 1 ? hits[0] : undefined;
+    if (right === undefined)
+      continue;
+    const rivals = dropped.filter((item) => sameShape(item, right));
+    if (rivals.length !== 1)
+      continue;
+    const rightKey = identityKey2(right.identity);
+    used.add(rightKey);
+    dropKeys.delete(identityKey2(left.identity));
+    createKeys.delete(rightKey);
+    if (anchoredName(left) !== anchoredName(right))
+      pairs.push({ from: left, to: right });
+  }
+  return pairs;
+}
+function sameShape(left, right) {
+  if (left.kind !== right.kind)
+    return false;
+  if (left.kind !== "index" && left.kind !== "constraint" || right.kind !== "index" && right.kind !== "constraint") {
+    return false;
+  }
+  if (left.identity.parent.name !== right.identity.parent.name)
+    return false;
+  return stable(withoutNameKey(left.definition)) === stable(withoutNameKey(right.definition));
+}
+function withoutNameKey(value) {
+  const copy = { ...value };
+  delete copy.nameKey;
+  return copy;
+}
+function renameShapeStep(pair, schema) {
+  if (pair.from.kind === "index" && pair.to.kind === "index") {
+    return step(`alter index ${qualify(schema, pair.from.identity.name)} rename to ${quoteIdent(pair.to.identity.name)}`, "rename-index", "ddl", ACCESS2);
+  }
+  if (pair.from.kind !== "constraint" || pair.to.kind !== "constraint") {
+    throw new OkmError2("invalid", "A same-shape rename is an index or a constraint.", {
+      fix: { summary: "The planner only renames an index or a constraint in place." }
+    });
+  }
+  return step(`alter table ${qualify(schema, pair.from.identity.parent.name)} rename constraint ${quoteIdent(pair.from.identity.name)} to ${quoteIdent(pair.to.identity.name)}`, "rename-constraint", "ddl", ACCESS2);
+}
+function assertUnambiguous(beforeBy, afterBy) {
+  const dropped = new Map;
+  const added = new Map;
+  for (const [key, object] of beforeBy) {
+    if (afterBy.has(key))
+      continue;
+    const group = groupOf(object);
+    if (group === undefined)
+      continue;
+    const list = dropped.get(group) ?? [];
+    const name = anchoredName(object);
+    if (name === undefined)
+      continue;
+    list.push(name);
+    dropped.set(group, list);
+  }
+  for (const [key, object] of afterBy) {
+    if (beforeBy.has(key))
+      continue;
+    const group = groupOf(object);
+    if (group === undefined)
+      continue;
+    const list = added.get(group) ?? [];
+    const name = anchoredName(object);
+    if (name === undefined)
+      continue;
+    list.push(name);
+    added.set(group, list);
+  }
+  for (const [group, names] of added) {
+    const gone = dropped.get(group);
+    if (gone === undefined || gone.length === 0 || names.length === 0)
+      continue;
+    const from = gone[0] ?? "";
+    const to = names[0] ?? "";
+    const line = group.startsWith("table:") ? `Add renamedFrom: "${from}" on ${to}.` : `Add .renamedFrom("${from}") on ${to}.`;
+    throw new OkmError2("OKM1530", `Drop ${from} and add ${to} could be a rename. ${line}`, {
+      fix: { summary: line }
+    });
+  }
+}
+function anchoredName(object) {
+  switch (object.kind) {
+    case "grant":
+    case "defaultPrivilege":
+      return;
+    default:
+      return object.identity.name;
+  }
+}
+function groupOf(object) {
+  if (object.kind === "table")
+    return "table:public";
+  if (object.kind === "column")
+    return `column:${object.identity.parent.name}`;
+  return;
+}
+function recreateDependents(beforeList, afterList, alters, dropKeys, createKeys, picklists) {
+  const changed = new Set(alters.filter((item) => canonicalTypeName(item.before.definition.dataType) !== canonicalTypeName(item.after.definition.dataType)).map((item) => identityKey2(item.after.identity)));
+  if (changed.size === 0)
+    return;
+  const deferred = new Set(picklists.map((change) => identityKey2(change.before.identity)));
+  const afterBy = new Map(afterList.map((item) => [item.key, item.object]));
+  for (const item of beforeList) {
+    const key = identityKey2(item.object.identity);
+    if (deferred.has(key) || !afterBy.has(key))
+      continue;
+    if (!dependsOnChanged(item.object, changed))
+      continue;
+    dropKeys.add(key);
+    createKeys.add(key);
+  }
+}
+function recreateRoutineDependents(afterList, dropKeys, createKeys) {
+  const recreated = new Set;
+  for (const item of afterList) {
+    if (!dropKeys.has(item.key) || !createKeys.has(item.key))
+      continue;
+    if (item.object.kind === "function" || item.object.kind === "column" || item.object.kind === "table") {
+      recreated.add(item.key);
+    }
+  }
+  if (recreated.size === 0)
+    return;
+  for (const item of afterList) {
+    if (item.object.kind !== "trigger" && item.object.kind !== "function")
+      continue;
+    const hit = item.object.dependencies.some((edge) => recreated.has(identityKey2(edge.target)));
+    if (!hit)
+      continue;
+    dropKeys.add(item.key);
+    createKeys.add(item.key);
+  }
+}
+function refuseRoutineDrops(beforeBy, afterBy, dropKeys) {
+  for (const after of afterBy.values()) {
+    const key = identityKey2(after.identity);
+    if (dropKeys.has(key))
+      continue;
+    if (after.kind !== "trigger" && after.kind !== "function" && after.kind !== "view" && after.kind !== "materializedView") {
+      continue;
+    }
+    for (const edge of after.dependencies) {
+      const targetKey = identityKey2(edge.target);
+      if (!dropKeys.has(targetKey))
+        continue;
+      const target = beforeBy.get(targetKey);
+      if (target === undefined)
+        continue;
+      if (target.kind !== "function" && target.kind !== "table" && target.kind !== "column" && target.kind !== "view" && target.kind !== "materializedView") {
+        continue;
+      }
+      throw new OkmError2("OKM1821", `${identityLabel2(after.identity)} depends on ${identityLabel2(target.identity)}, which this plan drops. CASCADE is never used.`, { fix: { summary: "Review the dependents the plan lists and recreate them explicitly." } });
+    }
+  }
+}
+function dependsOnChanged(object, columns) {
+  if (object.kind !== "index" && object.kind !== "constraint" && object.kind !== "view" && object.kind !== "materializedView") {
+    return false;
+  }
+  return object.dependencies.some((edge) => columns.has(identityKey2(edge.target)));
+}
+function recreateViewDependents(afterList, dropKeys, createKeys) {
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const item of afterList) {
+      if (dropKeys.has(item.key) && createKeys.has(item.key))
+        continue;
+      const kind = item.object.kind;
+      if (kind !== "view" && kind !== "materializedView" && kind !== "index")
+        continue;
+      const hit = item.object.dependencies.some((edge) => {
+        const key = identityKey2(edge.target);
+        return dropKeys.has(key) && createKeys.has(key);
+      });
+      if (!hit)
+        continue;
+      dropKeys.add(item.key);
+      createKeys.add(item.key);
+      changed = true;
+    }
+  }
+}
+function columnsAppended(before, after) {
+  if (after.length < before.length)
+    return false;
+  for (let index = 0;index < before.length; index += 1) {
+    const left = before[index];
+    const right = after[index];
+    if (left === undefined || right === undefined)
+      return false;
+    if (left.name !== right.name || canonicalTypeName(left.dataType) !== canonicalTypeName(right.dataType)) {
+      return false;
+    }
+  }
+  return true;
+}
+function assertConcurrentRefresh(object, source) {
+  if (object.definition.refresh !== "concurrently")
+    return;
+  const unique = source.objects.some((item) => item.kind === "index" && item.definition.unique && item.identity.parent.name === object.identity.name);
+  if (unique)
+    return;
+  throw new OkmError2("OKM1822", `Materialized view ${object.identity.name} refreshes concurrently and has no unique index.`, { fix: { summary: "Add a unique index, or refresh without CONCURRENTLY." } });
+}
+function enumAddSteps(enums) {
+  const steps = [];
+  for (const change of enums) {
+    if (change.kind !== "add")
+      continue;
+    for (const sql of change.statements) {
+      steps.push(step(sql, "add-enum-value", "ddl", ACCESS2, false));
+    }
+  }
+  return steps;
+}
+function expandBackfills(picklists, enums, replacements, schema, catalogs, batchSize) {
+  return dataSteps(picklists, enums, replacements, schema, catalogs, batchSize, "expand");
+}
+function contractSwaps(picklists, enums, replacements, schema, catalogs, batchSize) {
+  const steps = [];
+  steps.push(...dataSteps(picklists, enums, replacements, schema, catalogs, batchSize, "contract"));
+  for (const change of picklists) {
+    const table = qualify(schema, change.after.identity.parent.name);
+    const name = quoteIdent(change.after.identity.name);
+    const kind = change.removed.length > 0 ? "narrow-check" : "widen-check";
+    steps.push(step(`alter table ${table} drop constraint ${name}`, kind, "ddl", ACCESS2));
+    const expression = change.after.definition.expression ?? "true";
+    steps.push(step(`alter table ${table} add constraint ${name} check (${expression}) not valid`, kind, "ddl", ACCESS2));
+    steps.push(step(`alter table ${table} validate constraint ${name}`, kind, "ddl", SHARE_UPDATE2));
+  }
+  for (const change of enums) {
+    if (change.kind !== "replace")
+      continue;
+    const type = qualify(schema, change.name);
+    const old = quoteIdent(`${change.name}_old`);
+    const labels = change.labels.map((label) => quoteLiteral(label)).join(", ");
+    steps.push(step(`alter type ${type} rename to ${old}`, "rename-enum", "ddl", ACCESS2));
+    steps.push(step(`create type ${type} as enum (${labels})`, "recreate-enum", "ddl", ACCESS2));
+    for (const column of change.columns) {
+      const table = qualify(schema, column.table);
+      const name = quoteIdent(column.column);
+      steps.push(step(`alter table ${table} alter column ${name} type ${type} using ${name}::text::${type}`, "set-enum-column", "ddl", ACCESS2));
+    }
+    steps.push(step(`drop type ${qualify(schema, `${change.name}_old`)}`, "drop-enum", "ddl", ACCESS2));
+  }
+  return steps;
+}
+function dataSteps(picklists, enums, replacements, schema, catalogs, batchSize, phase) {
+  const steps = [];
+  const kind = phase === "expand" ? "backfill-expand" : "backfill-contract";
+  for (const change of picklists) {
+    if (change.removed.length === 0)
+      continue;
+    const table = change.after.identity.parent.name;
+    for (const value of change.removed) {
+      const replacement = findReplacement(replacements, table, change.column, value);
+      if (replacement === undefined)
+        continue;
+      steps.push(backfillStep(updateSql(schema, table, change.column, value, replacement.to, catalogs, batchSize), kind));
+    }
+  }
+  for (const change of enums) {
+    if (change.kind !== "replace" || change.removed.length === 0)
+      continue;
+    for (const column of change.columns) {
+      if (!column.existed)
+        continue;
+      for (const value of change.removed) {
+        const replacement = findReplacement(replacements, column.table, column.column, value);
+        if (replacement === undefined)
+          continue;
+        steps.push(backfillStep(updateSql(schema, column.table, column.column, value, replacement.to, catalogs, batchSize, true), kind));
+      }
+    }
+  }
+  return steps;
+}
+function requireReplacements(picklists, enums, replacements) {
+  const missing = [];
+  for (const change of picklists) {
+    for (const value of change.removed) {
+      const table = change.after.identity.parent.name;
+      const found = findReplacement(replacements, table, change.column, value);
+      if (found === undefined) {
+        missing.push(`--replace ${table}.${change.column}.${value}=<new>`);
+        continue;
+      }
+      assertReplacement(found, change.after.definition.expression, change.nullable, parseValues(change.after.definition.expression));
+    }
+  }
+  for (const change of enums) {
+    if (change.kind !== "replace")
+      continue;
+    for (const column of change.columns) {
+      if (!column.existed)
+        continue;
+      for (const value of change.removed) {
+        const found = findReplacement(replacements, column.table, column.column, value);
+        if (found === undefined) {
+          missing.push(`--replace ${column.table}.${column.column}.${value}=<new>`);
+          continue;
+        }
+        assertReplacement(found, undefined, column.nullable, change.labels);
+      }
+    }
+  }
+  if (missing.length > 0) {
+    throw new OkmError2("OKM1541", `Removed values need a replacement: ${missing.join(", ")}.`, {
+      fix: { summary: missing.join(" ") }
+    });
+  }
+}
+function assertReplacement(replacement, expression, nullable, allowed) {
+  if (replacement.to === null) {
+    if (!nullable) {
+      throw new OkmError2("OKM1541", `--replace ${replacement.table}.${replacement.column}.${replacement.from}=null needs a nullable column.`, { fix: { summary: "Pass a value that is in the new list, or make the column nullable." } });
+    }
+    return;
+  }
+  const list = allowed ?? (expression === undefined ? [] : parseValues(expression) ?? []);
+  if (!list.includes(replacement.to)) {
+    const flag = `--replace ${replacement.table}.${replacement.column}.${replacement.from}=${replacement.to}`;
+    throw new OkmError2("OKM1541", `${flag} is not in the new list.`, {
+      fix: { summary: "The replacement must be in the new list. No chains." }
+    });
+  }
+}
+function parseValues(expression) {
+  if (expression === undefined)
+    return;
+  return parseInList(expression)?.values;
+}
+function findReplacement(replacements, table, column, from) {
+  return replacements.find((item) => item.table === table && item.column === column && item.from === from);
+}
+function picklistChanges(beforeBy, afterBy, after) {
+  const changes = [];
+  for (const [key, object] of beforeBy) {
+    if (object.kind !== "constraint" || object.definition.constraintKind !== "check")
+      continue;
+    const next = afterBy.get(key);
+    if (next === undefined || next.kind !== "constraint")
+      continue;
+    const left = parseInList(object.definition.expression ?? "");
+    const right = parseInList(next.definition.expression ?? "");
+    if (left === undefined || right === undefined || left.column !== right.column)
+      continue;
+    const removed = left.values.filter((value) => !right.values.includes(value));
+    const added = right.values.filter((value) => !left.values.includes(value));
+    if (removed.length === 0 && added.length === 0)
+      continue;
+    changes.push({
+      before: object,
+      after: next,
+      column: right.column,
+      removed,
+      added,
+      nullable: columnNullable(after, next.identity.parent.name, right.column)
+    });
+  }
+  return changes;
+}
+function refuseDomainBaseChange(before, after) {
+  if (before.kind !== "type" || after.kind !== "type")
+    return;
+  if (!isDomain(before.definition) || !isDomain(after.definition))
+    return;
+  if (before.definition.base === after.definition.base)
+    return;
+  throw new OkmError2("OKM1020", `Domain ${after.identity.name} cannot change its base type from ${before.definition.base} to ${after.definition.base}. The base type of a domain stays as it was created.`, {
+    fix: {
+      summary: "Keep the base type. Add a new domain when the column needs another type."
+    }
+  });
+}
+function domainCheckSteps(beforeBy, afterBy, schema) {
+  const steps = [];
+  for (const [key, next] of afterBy) {
+    if (next.kind !== "type" || !isDomain(next.definition))
+      continue;
+    const previous = beforeBy.get(key);
+    if (previous === undefined || previous.kind !== "type" || !isDomain(previous.definition)) {
+      continue;
+    }
+    if (previous.definition.check === next.definition.check)
+      continue;
+    const name = next.identity.name;
+    const type = qualify(schema, name);
+    const current = quoteIdent(fitIdentifier2(`${name}_check`));
+    const upcoming = quoteIdent(fitIdentifier2(`${name}_check_next`));
+    const expression = next.definition.check;
+    steps.push(step(`alter domain ${type} add constraint ${upcoming} check (${expression}) not valid`, "add-domain-check", "ddl", ACCESS2));
+    steps.push(step(`alter domain ${type} validate constraint ${upcoming}`, "validate-domain-check", "ddl", ACCESS2));
+    steps.push(step(`alter domain ${type} drop constraint ${current}`, "drop-domain-check", "ddl", ACCESS2));
+    steps.push(step(`alter domain ${type} rename constraint ${upcoming} to ${current}`, "rename-domain-check", "ddl", ACCESS2));
+  }
+  return steps;
+}
+function enumEdits(beforeBy, afterBy, schema) {
+  const edits = [];
+  for (const [key, next] of afterBy) {
+    if (next.kind !== "type" || isDomain(next.definition))
+      continue;
+    const previous = beforeBy.get(key);
+    if (previous === undefined || previous.kind !== "type" || isDomain(previous.definition)) {
+      continue;
+    }
+    const beforeLabels = previous.definition.labels;
+    const afterLabels = next.definition.labels;
+    if (sameEnumLabels(beforeLabels, afterLabels))
+      continue;
+    const removed = beforeLabels.filter((label) => !afterLabels.includes(label));
+    const columns = enumColumns(previous.identity.name, beforeBy, afterBy);
+    if (removed.length === 0 && labelSubsequence(beforeLabels, afterLabels)) {
+      edits.push({
+        kind: "add",
+        name: next.identity.name,
+        statements: addValueStatements(schema, next.identity.name, beforeLabels, afterLabels)
+      });
+      continue;
+    }
+    edits.push({
+      kind: "replace",
+      name: next.identity.name,
+      labels: afterLabels,
+      removed,
+      columns
+    });
+  }
+  return edits;
+}
+function enumColumns(typeName, beforeBy, afterBy) {
+  const columns = [];
+  for (const object of afterBy.values()) {
+    if (object.kind !== "column")
+      continue;
+    if (!usesType(object, typeName))
+      continue;
+    columns.push({
+      table: object.identity.parent.name,
+      column: object.identity.name,
+      nullable: object.definition.nullable,
+      existed: beforeBy.has(identityKey2(object.identity))
+    });
+  }
+  columns.sort((left, right) => {
+    const table = compareText(left.table, right.table);
+    return table === 0 ? compareText(left.column, right.column) : table;
+  });
+  return columns;
+}
+function usesType(object, typeName) {
+  return object.dependencies.some((edge) => edge.target.kind === "type" && edge.target.name === typeName);
+}
+function labelSubsequence(before, after) {
+  let index = 0;
+  for (const label of after) {
+    if (before[index] === label)
+      index += 1;
+  }
+  return index === before.length;
+}
+function addValueStatements(schema, name, before, after) {
+  const present = new Set(before);
+  const statements = [];
+  const type = qualify(schema, name);
+  for (let index = 0;index < after.length; index += 1) {
+    const label = after[index];
+    if (label === undefined || present.has(label))
+      continue;
+    let beforeNeighbor;
+    for (let cursor = index + 1;cursor < after.length; cursor += 1) {
+      const next = after[cursor];
+      if (next !== undefined && present.has(next)) {
+        beforeNeighbor = next;
+        break;
+      }
+    }
+    let sql = `alter type ${type} add value ${quoteLiteral(label)}`;
+    if (beforeNeighbor !== undefined) {
+      sql += ` before ${quoteLiteral(beforeNeighbor)}`;
+    } else {
+      let afterNeighbor;
+      for (let cursor = index - 1;cursor >= 0; cursor -= 1) {
+        const previous = after[cursor];
+        if (previous !== undefined && present.has(previous)) {
+          afterNeighbor = previous;
+          break;
+        }
+      }
+      if (afterNeighbor !== undefined)
+        sql += ` after ${quoteLiteral(afterNeighbor)}`;
+    }
+    statements.push(sql);
+    present.add(label);
+  }
+  return statements;
+}
+function parseInList(expression) {
+  const match = /^\(\s*([A-Za-z_][A-Za-z0-9_]*)\s+IN\s*\((.*)\)\s*\)$/i.exec(expression.trim());
+  const column = match?.[1];
+  const body = match?.[2];
+  if (column === undefined || body === undefined)
+    return;
+  const values = [];
+  let index = 0;
+  while (index < body.length) {
+    const char = body[index] ?? "";
+    if (char === " " || char === ",") {
+      index += 1;
+      continue;
+    }
+    if (char !== "'")
+      return;
+    let end = index + 1;
+    let value = "";
+    while (end < body.length) {
+      const next = body[end] ?? "";
+      if (next === "'" && body[end + 1] === "'") {
+        value += "'";
+        end += 2;
+        continue;
+      }
+      if (next === "'") {
+        end += 1;
+        break;
+      }
+      value += next;
+      end += 1;
+    }
+    values.push(value);
+    index = end;
+  }
+  return { column, values };
+}
+function columnNullable(source, table, column) {
+  for (const object of source.objects) {
+    if (object.kind === "column" && object.identity.parent.name === table && object.identity.name === column) {
+      return object.definition.nullable;
+    }
+  }
+  return false;
+}
+function columnAlterable(before, after) {
+  return stable(before.definition.generated) === stable(after.definition.generated);
+}
+function identityChangeSql(before, after, schema) {
+  if (stable(before.definition.identity) === stable(after.definition.identity))
+    return;
+  const table = qualify(schema, after.identity.parent.name);
+  const name = quoteIdent(after.identity.name);
+  const next = after.definition.identity;
+  const previous = before.definition.identity;
+  if (next === undefined)
+    return `alter table ${table} alter column ${name} drop identity`;
+  if (previous === undefined) {
+    const generated = next.always ? "always" : "by default";
+    return `alter table ${table} alter column ${name} add generated ${generated} as identity`;
+  }
+  return `alter table ${table} alter column ${name} set generated ${next.always ? "always" : "by default"}`;
+}
+function omitOwnedSequences(keys, by, source) {
+  for (const key of keys) {
+    const object = by.get(key);
+    if (object?.kind === "sequence" && folded(object, source))
+      keys.delete(key);
+  }
+}
+var TRAILING_CAST = /^(.*)::((?:timestamp|time)(?:\(\d+\))? (?:with|without) time zone|character varying(?:\(\d+\))?|[A-Za-z_][\w$]*(?:\([^)]*\))?)$/;
+function canonicalDefault(expression, dataType) {
+  if (expression === undefined)
+    return {};
+  const match = TRAILING_CAST.exec(expression.trim());
+  const body = match?.[1]?.trim();
+  const cast = match?.[2];
+  if (body === undefined || body.length === 0 || cast === undefined)
+    return { defaultExpression: expression };
+  if (!defaultCastMatches(cast, dataType))
+    return { defaultExpression: expression };
+  return { defaultExpression: body };
+}
+function defaultCastMatches(cast, dataType) {
+  if (canonicalTypeName(cast) === canonicalTypeName(dataType))
+    return true;
+  const castBase = reprintedDefaultBase(cast);
+  const columnBase = reprintedDefaultBase(dataType);
+  return castBase !== undefined && castBase === columnBase;
+}
+function reprintedDefaultBase(typeName) {
+  const raw = typeName.trim();
+  if (/^(?:bpchar|character|char)(?:\(\d+\))?$/.test(raw))
+    return "character";
+  const canonical = canonicalTypeName(raw);
+  if (/^character varying(?:\(\d+\))?$/.test(canonical))
+    return "character varying";
+  if (/^character(?:\(\d+\))?$/.test(canonical))
+    return "character";
+  const time = /^(timestamp|time)(?:\(\d+\))? (with time zone|without time zone)$/.exec(canonical);
+  if (time !== null)
+    return `${time[1] ?? ""} ${time[2] ?? ""}`;
+  return;
+}
+function sameDefinition(left, right) {
+  if (left.kind === "materializedView" && right.kind === "materializedView") {
+    return stable(canonicalColumns(left.definition.columns)) === stable(canonicalColumns(right.definition.columns)) && left.definition.query === right.definition.query;
+  }
+  return stable(forComparison(left)) === stable(forComparison(right));
+}
+function forComparison(object) {
+  switch (object.kind) {
+    case "column":
+      return {
+        ...object.definition,
+        dataType: canonicalTypeName(object.definition.dataType),
+        ...canonicalDefault(object.definition.defaultExpression, object.definition.dataType)
+      };
+    case "sequence":
+      return { ...object.definition, dataType: canonicalTypeName(object.definition.dataType) };
+    case "view":
+      return { ...object.definition, columns: canonicalColumns(object.definition.columns) };
+    case "function":
+      return {
+        ...object.definition,
+        returns: canonicalTypeName(object.definition.returns),
+        arguments: object.definition.arguments.map((argument) => ({
+          ...argument,
+          type: canonicalTypeName(argument.type)
+        }))
+      };
+    case "trigger":
+      return {
+        ...object.definition,
+        calls: {
+          ...object.definition.calls,
+          argTypes: object.definition.calls.argTypes.map((typeName) => canonicalTypeName(typeName))
+        }
+      };
+    case "type":
+      if (!isDomain(object.definition))
+        return object.definition;
+      return { ...object.definition, base: canonicalTypeName(object.definition.base) };
+    default:
+      return object.definition;
+  }
+}
+function canonicalColumns(columns) {
+  return columns.map((column) => ({ ...column, dataType: canonicalTypeName(column.dataType) }));
+}
+function alignedColumnType(before, after) {
+  if (canonicalTypeName(before.definition.dataType) !== canonicalTypeName(after.definition.dataType)) {
+    return before;
+  }
+  if (before.definition.dataType === after.definition.dataType)
+    return before;
+  return { ...before, definition: { ...before.definition, dataType: after.definition.dataType } };
+}
+function covered(object, tables) {
+  if (object.kind === "column" || object.kind === "index" || object.kind === "constraint") {
+    return tables.has(object.identity.parent.name);
+  }
+  if (object.kind === "sequence") {
+    return object.dependencies.some((edge) => edge.target.kind === "table" && tables.has(edge.target.name));
+  }
+  return false;
+}
+function folded(object, source) {
+  if (object.kind === "column")
+    return true;
+  if (object.kind === "constraint" && object.definition.constraintKind === "primaryKey")
+    return true;
+  if (object.kind !== "sequence")
+    return false;
+  if (identitySequence(object, source))
+    return true;
+  const name = object.identity.name;
+  return source.objects.some((column) => {
+    if (column.kind !== "column" || column.definition.identity === undefined)
+      return false;
+    return name === `${column.identity.parent.name}_${column.identity.name}_seq`;
+  });
+}
+function anchoredParent(object) {
+  if (object.kind === "column" || object.kind === "index" || object.kind === "constraint") {
+    return object.identity.parent.name;
+  }
+  return;
+}
+function overall(steps) {
+  return strictestClass(steps.map((item) => item.class));
+}
+function updateSql(schema, table, column, from, to, catalogs, batchSize, cast = false) {
+  const key = primaryKeyColumns(catalogs, table);
+  const qualified = qualify(schema, table);
+  const value = to === null ? "null" : quoteLiteral(to);
+  const compare = cast ? `${quoteIdent(column)}::text` : quoteIdent(column);
+  const where = `${compare} = ${quoteLiteral(from)}`;
+  const backfill = {
+    table: qualified,
+    key: key.map((item) => item.quoted),
+    batch: batchSize
+  };
+  return {
+    sql: `update ${qualified} set ${quoteIdent(column)} = ${value} where ${where} and ${keyRangePredicate(key)}`,
+    backfill
+  };
+}
+function backfillStep(planned, kind) {
+  return {
+    ...step(planned.sql, kind, "backfill", ROW2, false),
+    backfill: planned.backfill
+  };
+}
+function hasTable(source, name) {
+  return source.objects.some((object) => object.kind === "table" && object.identity.name === name);
+}
+function hasColumn(source, table, name) {
+  return source.objects.some((object) => object.kind === "column" && object.identity.parent.name === table && object.identity.name === name);
+}
+function index2(source) {
+  return source.objects.map((object) => ({ key: identityKey2(object.identity), object }));
+}
+function step(sql, kind, action, lock, transactional = true, extraTables) {
+  const tables = touchedTables(sql, lock, extraTables);
+  return {
+    sql,
+    kind,
+    class: classOf(kind),
+    action,
+    lock,
+    transactional,
+    ...tables.length > 0 ? { tables } : {}
+  };
+}
+function pushSafe(steps, safe) {
+  for (const item of safe) {
+    steps.push({
+      ...step(item.sql, item.kind, item.action, item.lock, item.transactional),
+      safeRewrite: true,
+      ...item.backfill !== undefined ? { backfill: item.backfill } : {}
+    });
+  }
+}
+var TABLE_PREFIX = /\b(?:create|alter|drop)\s+table(?:\s+if\s+exists)?\s+|\bupdate\s+|\binsert\s+into\s+|\breferences\s+|\bon\s+table\s+|\bon\s+/gi;
+function touchedTables(sql, lock, extra) {
+  const names = [];
+  const text = `${sql}
+${lock}`;
+  TABLE_PREFIX.lastIndex = 0;
+  for (let match = TABLE_PREFIX.exec(text);match !== null; match = TABLE_PREFIX.exec(text)) {
+    const found = readQualified(text, match.index + match[0].length);
+    if (found !== undefined)
+      pushTable(names, found.name);
+  }
+  for (const name of extra ?? [])
+    pushTable(names, name);
+  return names;
+}
+function pushTable(names, name) {
+  if (!names.includes(name))
+    names.push(name);
+}
+function readQualified(text, start) {
+  const schema = readIdent(text, start);
+  if (schema === undefined)
+    return;
+  if (text[schema.end] !== "." || text[schema.end + 1] !== '"')
+    return;
+  const name = readIdent(text, schema.end + 1);
+  if (name === undefined || text[name.end] === ".")
+    return;
+  return name;
+}
+function readIdent(text, start) {
+  if (text[start] !== '"')
+    return;
+  let value = "";
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === '"') {
+      if (text[index + 1] === '"') {
+        value += '"';
+        index += 2;
+        continue;
+      }
+      return { name: value, end: index + 1 };
+    }
+    value += char ?? "";
+    index += 1;
+  }
+  return;
+}
+function pushDrop(steps, object, schema) {
+  const sql = dropObjectSql(object, schema);
+  const kind = dropKind(object);
+  if (sql === undefined || kind === undefined)
+    return;
+  steps.push(step(sql, kind, "ddl", ACCESS2));
+}
+function createKind(object, tableIsNew) {
+  switch (object.kind) {
+    case "table":
+      return "create-table";
+    case "column":
+      return requiredColumn(object) && !tableIsNew ? "add-column-required" : "add-column";
+    case "index":
+      return "create-index";
+    case "constraint":
+      return "add-constraint";
+    case "sequence":
+      return "create-sequence";
+    case "type":
+      return isDomain(object.definition) ? "create-domain" : "create-enum";
+    case "extension":
+      return "create-extension";
+    case "function":
+      return "create-function";
+    case "trigger":
+      return "create-trigger";
+    case "view":
+      return "create-view";
+    case "materializedView":
+      return "create-matview";
+    default:
+      return;
+  }
+}
+function dropKind(object) {
+  switch (object.kind) {
+    case "table":
+      return "drop-table";
+    case "column":
+      return "drop-column";
+    case "index":
+      return "drop-index";
+    case "constraint":
+      return "drop-constraint";
+    case "sequence":
+      return "drop-sequence";
+    case "type":
+      return isDomain(object.definition) ? "drop-domain" : "drop-enum";
+    case "extension":
+      return "drop-extension";
+    case "function":
+      return "drop-function";
+    case "trigger":
+      return "drop-trigger";
+    case "view":
+      return "drop-view";
+    case "materializedView":
+      return "drop-matview";
+    default:
+      return;
+  }
+}
+function requiredColumn(column) {
+  const definition = column.definition;
+  return !definition.nullable && definition.defaultExpression === undefined && definition.identity === undefined && definition.generated === undefined;
+}
+function columnAlterKinds(before, after) {
+  const kinds = [];
+  if (before.definition.dataType !== after.definition.dataType || before.definition.collation !== after.definition.collation) {
+    kinds.push("set-column-type");
+  }
+  if (before.definition.nullable !== after.definition.nullable) {
+    kinds.push(after.definition.nullable ? "drop-not-null" : "set-not-null");
+  }
+  if (before.definition.defaultExpression !== after.definition.defaultExpression) {
+    kinds.push(after.definition.defaultExpression === undefined ? "drop-default" : "set-default");
+  }
+  return kinds;
+}
+function identityKind(before, after) {
+  if (stable(before.definition.identity) === stable(after.definition.identity))
+    return;
+  const next = after.definition.identity;
+  const previous = before.definition.identity;
+  if (next === undefined)
+    return "drop-identity";
+  if (previous === undefined)
+    return "add-identity";
+  return next.always ? "set-identity-always" : "set-identity-by-default";
+}
+function stable(value) {
+  return JSON.stringify(order(value));
+}
+function order(value) {
+  if (Array.isArray(value))
+    return value.map((item) => order(item));
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    const next = {};
+    for (const key of Object.keys(record).sort())
+      next[key] = order(record[key]);
+    return next;
+  }
+  return value;
+}
+
+export { canonicalTypeName, createdRoleName, changesRole, DEFAULT_BACKFILL_PAUSE_MS, DEFAULT_BACKFILL_STATEMENT_TIMEOUT_MS, batchSizeField, aboutBatchCount, boundaryQuery, checkedCast, classOf, strictestClass, assertExtensionsAvailable, omitManagedObjects, parseReplace, planMigration, formatPlan, parsePlan, staleRenames };