okmodel 0.2.1 → 0.3.0

package/dist/shared/2ssqrv66.js

@@ -0,0 +1,1576 @@
+import {
+  creationOrder2,
+  renameColumn2,
+  renameTable2
+} from "./t616ynfn.js";
+import {
+  quoteIdent,
+  ownedByView,
+  dropObjectSql,
+  createObjectSql,
+  functionSql,
+  viewSql,
+  refreshMaterializedViewSql,
+  alterColumnSql,
+  identitySequence,
+  createTableSql,
+  qualify
+} from "./wekze34d.js";
+import {
+  isExactVersion,
+  compareExtensionVersions,
+  sameExtensionDefinition
+} from "./th14ygv2.js";
+import {
+  isDomain,
+  sameEnumLabels
+} from "./qbxzvwwc.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/dialects/pg/role/sql.ts
+var PRIVILEGE = /^(select|insert|update|delete|execute|usage)$/;
+function privilegeSql(before, after, schema) {
+  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(grantStatement(object, schema, true));
+    if (object.kind === "defaultPrivilege")
+      revoke.push(defaultStatement(object, true));
+  }
+  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(createRoleSql(object));
+        continue;
+      }
+      if (previous.kind !== "role" || previous.owner !== "managed")
+        continue;
+      if (previous.definition.login !== object.definition.login || previous.definition.inherit !== object.definition.inherit) {
+        roles.push(alterRoleSql(object));
+      }
+      continue;
+    }
+    if (previous !== undefined)
+      continue;
+    if (object.kind === "defaultPrivilege")
+      defaults.push(defaultStatement(object, false));
+    if (object.kind === "grant")
+      grant.push(grantStatement(object, schema, false));
+  }
+  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 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/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({
+      sql: `alter extension ${name} set schema ${quoteIdent(after.definition.schema)}`,
+      class: "contract",
+      action: "ddl",
+      lock: "ACCESS EXCLUSIVE",
+      transactional: true
+    });
+  }
+  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({
+    sql: `alter extension ${name} update to ${quoteLiteral(next)}`,
+    class: "expand",
+    action: "ddl",
+    lock: "ACCESS EXCLUSIVE",
+    transactional: true,
+    path: "unverified"
+  });
+  return steps;
+}
+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"]);
+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.startsWith("okm_meta_") || name.startsWith("okm_history_");
+}
+
+// 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/tooling/migrate/values.ts
+function parseReplace(flag) {
+  const eq = flag.indexOf("=");
+  if (eq <= 0) {
+    throw new OkmError2("OKM1541", `--replace ${flag} must be table.column.old=new.`, {
+      fix: {
+        summary: "Pass --replace <table>.<column>.<old>=<new>, or =null on a nullable column."
+      }
+    });
+  }
+  const left = flag.slice(0, eq);
+  const raw = flag.slice(eq + 1);
+  const first = left.indexOf(".");
+  const second = first < 0 ? -1 : left.indexOf(".", first + 1);
+  if (first <= 0 || second <= first + 1 || second === left.length - 1) {
+    throw new OkmError2("OKM1541", `--replace ${flag} must be table.column.old=new.`, {
+      fix: {
+        summary: "Pass --replace <table>.<column>.<old>=<new>, or =null on a nullable column."
+      }
+    });
+  }
+  const table = left.slice(0, first);
+  const column = left.slice(first + 1, second);
+  const from = left.slice(second + 1);
+  return { table, column, from, to: raw === "null" ? null : raw };
+}
+function assertNoChains(replacements) {
+  const removed = new Set(replacements.map((item) => pair(item.table, item.column, item.from)));
+  for (const item of replacements) {
+    if (item.to !== null && removed.has(pair(item.table, item.column, item.to))) {
+      const flag = `--replace ${item.table}.${item.column}.${item.from}=${item.to}`;
+      throw new OkmError2("OKM1541", `${flag} chains through another removed value.`, {
+        fix: { summary: "The replacement must be in the new list. No chains." }
+      });
+    }
+  }
+}
+function pair(table, column, value) {
+  return `${table}\x00${column}\x00${value}`;
+}
+
+// src/tooling/migrate/plan.ts
+var ACCESS = "ACCESS EXCLUSIVE";
+var SHARE = "SHARE";
+var SHARE_UPDATE = "SHARE UPDATE EXCLUSIVE";
+var ROW = "ROW EXCLUSIVE";
+function planMigration(input) {
+  const request = {
+    ...input,
+    before: omitManagedObjects(input.before),
+    after: omitManagedObjects(input.after)
+  };
+  const schema = request.schema ?? "public";
+  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 privileges = privilegeSql(renamed.objects, request.after.objects, schema);
+  const steps = [];
+  steps.push(...renameSteps(request.before, renames, schema));
+  for (const sql of privileges.revoke)
+    steps.push(step(sql, "contract", "ddl", ACCESS));
+  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));
+  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);
+    if (sql === undefined)
+      return;
+    steps.push(step(sql, "contract", "ddl", ACCESS));
+  };
+  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) {
+    const sql = dropObjectSql(object, schema);
+    if (sql === undefined)
+      continue;
+    steps.push(step(sql, "contract", "ddl", ACCESS));
+  }
+  for (const object of extensionDrops) {
+    const sql = dropObjectSql(object, schema);
+    if (sql === undefined)
+      continue;
+    steps.push(step(sql, "contract", "ddl", ACCESS));
+  }
+  steps.push(...extensionAlterSteps(beforeBy, afterBy, dropKeys));
+  for (const change of alters) {
+    for (const sql of alterColumnSql(alignedColumnType(change.before, change.after), change.after, schema)) {
+      steps.push(step(sql, alterClass(sql), "ddl", ACCESS));
+    }
+    const identitySql = identityChangeSql(change.before, change.after, schema);
+    if (identitySql !== undefined)
+      steps.push(step(identitySql, "expand", "ddl", ACCESS));
+  }
+  const createdTables = new Set([...createKeys].map((key) => afterBy.get(key)).filter((object) => object?.kind === "table").map((object) => object.identity.name));
+  const emitted = new Set;
+  for (const sql of privileges.prepare)
+    steps.push(step(sql, "expand", "ddl", ACCESS));
+  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);
+    if (sql === undefined)
+      continue;
+    steps.push(step(sql, "expand", "ddl", ACCESS));
+  }
+  for (const object of creationOrder2(request.after)) {
+    if (object.kind !== "type")
+      continue;
+    const key = identityKey2(object.identity);
+    if (!createKeys.has(key) || emitted.has(key))
+      continue;
+    emitted.add(key);
+    const sql = createObjectSql(object, schema);
+    if (sql === undefined)
+      continue;
+    steps.push(step(sql, "expand", "ddl", ACCESS));
+  }
+  for (const object of creationOrder2(request.after)) {
+    if (object.kind === "type" || 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), "expand", "ddl", ACCESS));
+      continue;
+    }
+    const sql = createObjectSql(object, schema);
+    if (sql === undefined)
+      continue;
+    steps.push(step(sql, "expand", "ddl", object.kind === "index" ? SHARE : ACCESS));
+  }
+  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);
+    steps.push({
+      sql,
+      class: "expand",
+      action: "ddl",
+      lock: ACCESS,
+      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);
+      if (sql === undefined)
+        continue;
+      steps.push(step(sql, "expand", "ddl", ACCESS));
+    }
+  }
+  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);
+    if (sql === undefined)
+      continue;
+    steps.push(step(sql, "expand", "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), "expand", "backfill", ACCESS));
+  }
+  for (const sql of privileges.grant)
+    steps.push(step(sql, "expand", "ddl", ACCESS));
+  steps.push(...contractSwaps(picklists, enums, replacements, schema));
+  return {
+    name: request.name ?? "migration",
+    class: overall(steps),
+    steps
+  };
+}
+function formatPlan(plan) {
+  const lines = [`-- class: ${plan.class}`, `-- name: ${plan.name}`, ""];
+  if (plan.steps.length === 0) {
+    lines.push("-- no steps");
+    lines.push("");
+    return lines.join(`
+`);
+  }
+  for (const item of plan.steps) {
+    lines.push(`-- class: ${item.class}`);
+    lines.push(`-- action: ${item.action}`);
+    lines.push(`-- lock: ${item.lock}`);
+    if (!item.transactional)
+      lines.push("-- transactional: false");
+    if (item.path !== undefined)
+      lines.push(`-- path: ${item.path}`);
+    if (item.behavior === "change")
+      lines.push("-- behavior: change");
+    lines.push(`${item.sql};`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function parsePlan(text) {
+  const lines = text.split(`
+`);
+  let name = "migration";
+  let planClass = "expand";
+  let index = 0;
+  while (index < lines.length && lines[index] !== "") {
+    const line = lines[index] ?? "";
+    if (line.startsWith("-- name: "))
+      name = line.slice("-- name: ".length);
+    if (line.startsWith("-- class: "))
+      planClass = readClass(line.slice("-- class: ".length));
+    index += 1;
+  }
+  const steps = [];
+  while (index < lines.length) {
+    if ((lines[index] ?? "").trim() === "") {
+      index += 1;
+      continue;
+    }
+    if (lines[index] === "-- no steps")
+      break;
+    let stepClass = "expand";
+    let action = "ddl";
+    let lock = "";
+    let transactional = true;
+    let path;
+    let behavior;
+    const sql = [];
+    while (index < lines.length && (lines[index] ?? "") !== "") {
+      const line = lines[index] ?? "";
+      index += 1;
+      if (line.startsWith("-- class: "))
+        stepClass = readClass(line.slice("-- class: ".length));
+      else if (line.startsWith("-- action: "))
+        action = line.endsWith("backfill") ? "backfill" : "ddl";
+      else if (line.startsWith("-- lock: "))
+        lock = line.slice("-- lock: ".length);
+      else if (line === "-- transactional: false")
+        transactional = false;
+      else if (line === "-- path: unverified")
+        path = "unverified";
+      else if (line === "-- behavior: change")
+        behavior = "change";
+      else if (!line.startsWith("--"))
+        sql.push(line);
+    }
+    const statement = sql.join(`
+`).replace(/;\s*$/, "");
+    if (statement.length > 0) {
+      steps.push({
+        sql: statement,
+        class: stepClass,
+        action,
+        lock,
+        transactional,
+        ...path !== undefined ? { path } : {},
+        ...behavior !== undefined ? { behavior } : {}
+      });
+    }
+  }
+  return { name, class: steps.length === 0 ? planClass : overall(steps), steps };
+}
+function readClass(value) {
+  if (value === "contract" || value === "unclassified")
+    return value;
+  return "expand";
+}
+function staleRenames(previous, renames) {
+  if (previous === undefined)
+    return [];
+  const messages = [];
+  for (const rename of renames) {
+    if (rename.kind === "table") {
+      if (!hasTable(previous, rename.from)) {
+        messages.push(`Table renamedFrom ${rename.from} is not in the previous snapshot.`);
+      }
+      continue;
+    }
+    const tableRename = renames.find((item) => item.kind === "table" && item.to === rename.table);
+    const previousTable = tableRename?.kind === "table" ? tableRename.from : rename.table;
+    if (!hasColumn(previous, previousTable, rename.from)) {
+      messages.push(`Column ${rename.table}.${rename.from} renamedFrom is not in the previous snapshot.`);
+    }
+  }
+  return messages;
+}
+function applyRenames(source, renames) {
+  let current = source;
+  const namespace = staticNamespace2("public");
+  for (const rename of renames) {
+    if (rename.kind !== "table")
+      continue;
+    if (!hasTable(current, rename.from))
+      continue;
+    current = renameTable2(current, { namespace, from: rename.from, to: rename.to });
+  }
+  for (const rename of renames) {
+    if (rename.kind !== "column")
+      continue;
+    const parent = { namespace, name: rename.table };
+    if (!hasColumn(current, rename.table, rename.from))
+      continue;
+    current = renameColumn2(current, { parent, from: rename.from, to: rename.to });
+  }
+  return current;
+}
+function renameSteps(source, renames, schema) {
+  const steps = [];
+  const tables = new Map;
+  for (const rename of renames) {
+    if (rename.kind !== "table" || !hasTable(source, rename.from))
+      continue;
+    tables.set(rename.to, rename.from);
+    steps.push(step(`alter table ${qualify(schema, rename.from)} rename to ${quoteIdent(rename.to)}`, "contract", "ddl", ACCESS));
+  }
+  for (const rename of renames) {
+    if (rename.kind !== "column")
+      continue;
+    const previousTable = tables.get(rename.table) ?? rename.table;
+    if (!hasColumn(source, previousTable, rename.from))
+      continue;
+    steps.push(step(`alter table ${qualify(schema, rename.table)} rename column ${quoteIdent(rename.from)} to ${quoteIdent(rename.to)}`, "contract", "ddl", ACCESS));
+  }
+  return steps;
+}
+function pairSameShape(beforeBy, afterBy, dropKeys, createKeys) {
+  const dropped = [...dropKeys].map((key) => beforeBy.get(key)).filter((object) => object !== undefined);
+  const created = [...createKeys].map((key) => afterBy.get(key)).filter((object) => object !== undefined);
+  const pairs = [];
+  const used = new Set;
+  for (const left of dropped) {
+    if (left.kind !== "index" && left.kind !== "constraint")
+      continue;
+    const leftKey = identityKey2(left.identity);
+    const hits = created.filter((right) => {
+      const key = identityKey2(right.identity);
+      return key !== leftKey && !used.has(key) && sameShape(left, right);
+    });
+    const right = hits.length === 1 ? hits[0] : undefined;
+    if (right === undefined)
+      continue;
+    const rivals = dropped.filter((item) => sameShape(item, right));
+    if (rivals.length !== 1)
+      continue;
+    const rightKey = identityKey2(right.identity);
+    used.add(rightKey);
+    dropKeys.delete(identityKey2(left.identity));
+    createKeys.delete(rightKey);
+    if (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)}`, "contract", "ddl", ACCESS);
+  }
+  if (pair.from.kind !== "constraint" || pair.to.kind !== "constraint") {
+    return step("select 1", "unclassified", "ddl", ACCESS);
+  }
+  return step(`alter table ${qualify(schema, pair.from.identity.parent.name)} rename constraint ${quoteIdent(pair.from.identity.name)} to ${quoteIdent(pair.to.identity.name)}`, "contract", "ddl", ACCESS);
+}
+function assertUnambiguous(beforeBy, afterBy) {
+  const dropped = new Map;
+  const added = new Map;
+  for (const [key, object] of beforeBy) {
+    if (afterBy.has(key))
+      continue;
+    const group = groupOf(object);
+    if (group === undefined)
+      continue;
+    const list = dropped.get(group) ?? [];
+    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, "expand", "ddl", ACCESS, false));
+    }
+  }
+  return steps;
+}
+function expandBackfills(picklists, enums, replacements, schema) {
+  return dataSteps(picklists, enums, replacements, schema, "expand");
+}
+function contractSwaps(picklists, enums, replacements, schema) {
+  const steps = [];
+  steps.push(...dataSteps(picklists, enums, replacements, schema, "contract"));
+  for (const change of picklists) {
+    const table = qualify(schema, change.after.identity.parent.name);
+    const name = quoteIdent(change.after.identity.name);
+    steps.push(step(`alter table ${table} drop constraint ${name}`, change.removed.length > 0 ? "contract" : "expand", "ddl", ACCESS));
+    const expression = change.after.definition.expression ?? "true";
+    steps.push(step(`alter table ${table} add constraint ${name} check (${expression}) not valid`, change.removed.length > 0 ? "contract" : "expand", "ddl", ACCESS));
+    steps.push(step(`alter table ${table} validate constraint ${name}`, change.removed.length > 0 ? "contract" : "expand", "ddl", SHARE_UPDATE));
+  }
+  for (const change of enums) {
+    if (change.kind !== "replace")
+      continue;
+    const type = 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}`, "contract", "ddl", ACCESS));
+    steps.push(step(`create type ${type} as enum (${labels})`, "contract", "ddl", ACCESS));
+    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}`, "contract", "ddl", ACCESS));
+    }
+    steps.push(step(`drop type ${qualify(schema, `${change.name}_old`)}`, "contract", "ddl", ACCESS));
+  }
+  return steps;
+}
+function dataSteps(picklists, enums, replacements, schema, phase) {
+  const steps = [];
+  for (const change of picklists) {
+    if (change.removed.length === 0)
+      continue;
+    const table = change.after.identity.parent.name;
+    for (const value of change.removed) {
+      const replacement = findReplacement(replacements, table, change.column, value);
+      if (replacement === undefined)
+        continue;
+      steps.push(step(updateSql(schema, table, change.column, value, replacement.to), phase, "backfill", ROW));
+    }
+  }
+  for (const change of enums) {
+    if (change.kind !== "replace" || change.removed.length === 0)
+      continue;
+    for (const column of change.columns) {
+      if (!column.existed)
+        continue;
+      for (const value of change.removed) {
+        const replacement = findReplacement(replacements, column.table, column.column, value);
+        if (replacement === undefined)
+          continue;
+        steps.push(step(updateSql(schema, column.table, column.column, value, replacement.to, true), phase, "backfill", ROW));
+      }
+    }
+  }
+  return steps;
+}
+function requireReplacements(picklists, enums, replacements) {
+  const missing = [];
+  for (const change of picklists) {
+    for (const value of change.removed) {
+      const table = change.after.identity.parent.name;
+      const found = findReplacement(replacements, table, change.column, value);
+      if (found === undefined) {
+        missing.push(`--replace ${table}.${change.column}.${value}=<new>`);
+        continue;
+      }
+      assertReplacement(found, change.after.definition.expression, change.nullable, parseValues(change.after.definition.expression));
+    }
+  }
+  for (const change of enums) {
+    if (change.kind !== "replace")
+      continue;
+    for (const column of change.columns) {
+      if (!column.existed)
+        continue;
+      for (const value of change.removed) {
+        const found = findReplacement(replacements, column.table, column.column, value);
+        if (found === undefined) {
+          missing.push(`--replace ${column.table}.${column.column}.${value}=<new>`);
+          continue;
+        }
+        assertReplacement(found, undefined, column.nullable, change.labels);
+      }
+    }
+  }
+  if (missing.length > 0) {
+    throw new OkmError2("OKM1541", `Removed values need a replacement: ${missing.join(", ")}.`, {
+      fix: { summary: missing.join(" ") }
+    });
+  }
+}
+function assertReplacement(replacement, expression, nullable, allowed) {
+  if (replacement.to === null) {
+    if (!nullable) {
+      throw new OkmError2("OKM1541", `--replace ${replacement.table}.${replacement.column}.${replacement.from}=null needs a nullable column.`, { fix: { summary: "Pass a value that is in the new list, or make the column nullable." } });
+    }
+    return;
+  }
+  const list = allowed ?? (expression === undefined ? [] : parseValues(expression) ?? []);
+  if (!list.includes(replacement.to)) {
+    const flag = `--replace ${replacement.table}.${replacement.column}.${replacement.from}=${replacement.to}`;
+    throw new OkmError2("OKM1541", `${flag} is not in the new list.`, {
+      fix: { summary: "The replacement must be in the new list. No chains." }
+    });
+  }
+}
+function parseValues(expression) {
+  if (expression === undefined)
+    return;
+  return parseInList(expression)?.values;
+}
+function findReplacement(replacements, table, column, from) {
+  return replacements.find((item) => item.table === table && item.column === column && item.from === from);
+}
+function picklistChanges(beforeBy, afterBy, after) {
+  const changes = [];
+  for (const [key, object] of beforeBy) {
+    if (object.kind !== "constraint" || object.definition.constraintKind !== "check")
+      continue;
+    const next = afterBy.get(key);
+    if (next === undefined || next.kind !== "constraint")
+      continue;
+    const left = parseInList(object.definition.expression ?? "");
+    const right = parseInList(next.definition.expression ?? "");
+    if (left === undefined || right === undefined || left.column !== right.column)
+      continue;
+    const removed = left.values.filter((value) => !right.values.includes(value));
+    const added = right.values.filter((value) => !left.values.includes(value));
+    if (removed.length === 0 && added.length === 0)
+      continue;
+    changes.push({
+      before: object,
+      after: next,
+      column: right.column,
+      removed,
+      added,
+      nullable: columnNullable(after, next.identity.parent.name, right.column)
+    });
+  }
+  return changes;
+}
+function 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`, "expand", "ddl", ACCESS));
+    steps.push(step(`alter domain ${type} validate constraint ${upcoming}`, "expand", "ddl", ACCESS));
+    steps.push(step(`alter domain ${type} drop constraint ${current}`, "contract", "ddl", ACCESS));
+    steps.push(step(`alter domain ${type} rename constraint ${upcoming} to ${current}`, "expand", "ddl", ACCESS));
+  }
+  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);
+  }
+}
+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":
+    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 alterClass(sql) {
+  if (sql.includes("set data type") || sql.includes("set not null"))
+    return "contract";
+  return "expand";
+}
+function overall(steps) {
+  if (steps.some((item) => item.class === "contract"))
+    return "contract";
+  if (steps.some((item) => item.class === "unclassified"))
+    return "unclassified";
+  return "expand";
+}
+function updateSql(schema, table, column, from, to, cast = false) {
+  const value = to === null ? "null" : quoteLiteral(to);
+  const compare = cast ? `${quoteIdent(column)}::text` : quoteIdent(column);
+  return `update ${qualify(schema, table)} set ${quoteIdent(column)} = ${value} where ${compare} = ${quoteLiteral(from)}`;
+}
+function hasTable(source, name) {
+  return source.objects.some((object) => object.kind === "table" && object.identity.name === name);
+}
+function hasColumn(source, table, name) {
+  return source.objects.some((object) => object.kind === "column" && object.identity.parent.name === table && object.identity.name === name);
+}
+function index2(source) {
+  return source.objects.map((object) => ({ key: identityKey2(object.identity), object }));
+}
+function step(sql, classification, action, lock, transactional = true) {
+  return { sql, class: classification, action, lock, transactional };
+}
+function 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 { createdRoleName, changesRole, assertExtensionsAvailable, omitManagedObjects, parseReplace, planMigration, formatPlan, parsePlan, staleRenames };