@supabase/pg-delta 1.0.0-alpha.21 → 1.0.0-alpha.23

package/src/core/plan/create.ts

@@ -100,7 +100,9 @@ export async function createPlan(
     }
     const resolved = await resolvePool(input, label);
     pools.push(resolved);
-    return extractCatalog(resolved.pool);
+    return extractCatalog(resolved.pool, {
+      extractRetries: options.extractRetries,
+    });
   };
 
   const pools: Array<{ pool: Pool; shouldClose: boolean }> = [];

package/src/core/plan/sql-format/fixtures.ts

@@ -1119,6 +1119,7 @@ const schema = new Schema({
   owner: "admin",
   comment: "application schema",
   privileges: [],
+  security_labels: [],
 });
 
 const extension = new Extension({

package/src/core/plan/types.ts

@@ -165,4 +165,12 @@ export interface CreatePlanOptions {
    * the output must be self-contained and not rely on statement execution order.
    */
   skipDefaultPrivilegeSubtraction?: boolean;
+  /**
+   * Number of retry attempts for catalog extractors when `pg_get_*def()`
+   * returns NULL for at least one row (a transient race with concurrent DDL).
+   * Total attempts is `extractRetries + 1`. When undefined, the value is read
+   * from the `PGDELTA_EXTRACT_RETRIES` environment variable, falling back to
+   * a default of 1 (i.e. the first attempt plus one retry, 2 attempts total).
+   */
+  extractRetries?: number;
 }

package/src/core/{post-diff-cycle-breaking.test.ts → post-diff-normalization.test.ts}

@@ -1,5 +1,8 @@
 import { describe, expect, test } from "bun:test";
 import type { Change } from "./change.types.ts";
+import { CreateIndex } from "./objects/index/changes/index.create.ts";
+import { DropIndex } from "./objects/index/changes/index.drop.ts";
+import { Index, type IndexProps } from "./objects/index/index.model.ts";
 import {
   AlterTableAddConstraint,
   AlterTableChangeOwner,
@@ -14,7 +17,7 @@ import { CreateTable } from "./objects/table/changes/table.create.ts";
 import { DropTable } from "./objects/table/changes/table.drop.ts";
 import { GrantTablePrivileges } from "./objects/table/changes/table.privilege.ts";
 import { Table } from "./objects/table/table.model.ts";
-import { normalizePostDiffCycles } from "./post-diff-cycle-breaking.ts";
+import { normalizePostDiffChanges } from "./post-diff-normalization.ts";
 
 const baseTableProps = {
   schema: "public",
@@ -59,7 +62,7 @@ function integerColumn(name: string, position: number) {
   };
 }
 
-describe("normalizePostDiffCycles", () => {
+describe("normalizePostDiffChanges", () => {
   test("prunes same-table drop-column and drop-constraint ALTERs for replaced tables only", async () => {
     const mainChildren = new Table({
       ...baseTableProps,
@@ -149,7 +152,7 @@ describe("normalizePostDiffCycles", () => {
       preExistingGrant,
     ];
 
-    const normalized = normalizePostDiffCycles({
+    const normalized = normalizePostDiffChanges({
       changes,
       replacedTableIds: new Set([mainChildren.stableId]),
     });
@@ -273,7 +276,7 @@ describe("normalizePostDiffCycles", () => {
       expansionComment,
     ];
 
-    const normalized = normalizePostDiffCycles({
+    const normalized = normalizePostDiffChanges({
       changes,
       replacedTableIds: new Set([branchChildren.stableId]),
     });
@@ -300,4 +303,165 @@ describe("normalizePostDiffCycles", () => {
       ),
     ).toHaveLength(1);
   });
+
+  describe("restoreReplicaIdentityAfterIndexReplace", () => {
+    const baseIndexProps: IndexProps = {
+      schema: "public",
+      table_name: "replicated",
+      name: "tenant_idx",
+      storage_params: [],
+      statistics_target: [],
+      index_type: "btree",
+      tablespace: null,
+      is_unique: true,
+      is_primary: false,
+      is_exclusion: false,
+      nulls_not_distinct: false,
+      immediate: true,
+      is_clustered: false,
+      is_replica_identity: true,
+      key_columns: [],
+      column_collations: [],
+      operator_classes: [],
+      column_options: [],
+      index_expressions: null,
+      partial_predicate: null,
+      table_relkind: "r",
+      is_owned_by_constraint: false,
+      is_partitioned_index: false,
+      is_index_partition: false,
+      parent_index_name: null,
+      definition: "CREATE UNIQUE INDEX tenant_idx ON public.replicated (a)",
+      comment: null,
+      owner: "postgres",
+    };
+
+    function makeBranchTable(replicaIdentityIndex: string | null) {
+      return new Table({
+        ...baseTableProps,
+        name: "replicated",
+        replica_identity: replicaIdentityIndex ? "i" : "d",
+        replica_identity_index: replicaIdentityIndex,
+        columns: [
+          { ...integerColumn("id", 1), not_null: true },
+          integerColumn("a", 2),
+        ],
+      });
+    }
+
+    test("re-emits ALTER TABLE … REPLICA IDENTITY USING INDEX after a DropIndex+CreateIndex pair", () => {
+      const branchTable = makeBranchTable("tenant_idx");
+      const oldIndex = new Index(baseIndexProps);
+      const newIndex = new Index({
+        ...baseIndexProps,
+        definition:
+          "CREATE UNIQUE INDEX tenant_idx ON public.replicated (a, id)",
+      });
+
+      const changes: Change[] = [
+        new DropIndex({ index: oldIndex }),
+        new CreateIndex({ index: newIndex, indexableObject: branchTable }),
+      ];
+
+      const normalized = normalizePostDiffChanges({
+        changes,
+        branchTables: { [branchTable.stableId]: branchTable },
+      });
+
+      expect(normalized.map((c) => c.constructor.name)).toEqual([
+        "DropIndex",
+        "CreateIndex",
+        "AlterTableSetReplicaIdentity",
+      ]);
+
+      const inserted = normalized[2] as AlterTableSetReplicaIdentity;
+      expect(inserted.mode).toBe("i");
+      expect(inserted.indexName).toBe("tenant_idx");
+      expect(inserted.requires).toEqual([
+        "table:public.replicated",
+        "index:public.replicated.tenant_idx",
+      ]);
+    });
+
+    test("does not double-emit when diffTables already produced an AlterTableSetReplicaIdentity for the same table", () => {
+      const branchTable = makeBranchTable("tenant_idx");
+      const oldIndex = new Index(baseIndexProps);
+      const newIndex = new Index({
+        ...baseIndexProps,
+        definition:
+          "CREATE UNIQUE INDEX tenant_idx ON public.replicated (a, id)",
+      });
+
+      const changes: Change[] = [
+        new DropIndex({ index: oldIndex }),
+        new CreateIndex({ index: newIndex, indexableObject: branchTable }),
+        new AlterTableSetReplicaIdentity({
+          table: branchTable,
+          mode: "i",
+          indexName: "tenant_idx",
+        }),
+      ];
+
+      const normalized = normalizePostDiffChanges({
+        changes,
+        branchTables: { [branchTable.stableId]: branchTable },
+      });
+
+      expect(
+        normalized.filter((c) => c instanceof AlterTableSetReplicaIdentity),
+      ).toHaveLength(1);
+    });
+
+    test("ignores DropIndex without a matching CreateIndex (pure drop)", () => {
+      // Pure drop: the user removed the index entirely. The table.diff path is
+      // responsible for emitting the corresponding REPLICA IDENTITY DEFAULT.
+      // The post-diff pass must not synthesize a USING INDEX setter for an
+      // index that no longer exists.
+      const branchTable = makeBranchTable(null);
+      const oldIndex = new Index(baseIndexProps);
+
+      const changes: Change[] = [new DropIndex({ index: oldIndex })];
+
+      const normalized = normalizePostDiffChanges({
+        changes,
+        branchTables: { [branchTable.stableId]: branchTable },
+      });
+
+      expect(
+        normalized.filter((c) => c instanceof AlterTableSetReplicaIdentity),
+      ).toHaveLength(0);
+    });
+
+    test("ignores indexes that are not the table's replica identity", () => {
+      // The table has replica_identity = 'd', so even if some other index is
+      // being replaced, no setter should be injected.
+      const branchTable = makeBranchTable(null);
+      const otherIndex = new Index({
+        ...baseIndexProps,
+        name: "some_other_idx",
+        is_replica_identity: false,
+        definition: "CREATE INDEX some_other_idx ON public.replicated (a)",
+      });
+      const newOtherIndex = new Index({
+        ...baseIndexProps,
+        name: "some_other_idx",
+        is_replica_identity: false,
+        definition: "CREATE INDEX some_other_idx ON public.replicated (a, id)",
+      });
+
+      const changes: Change[] = [
+        new DropIndex({ index: otherIndex }),
+        new CreateIndex({ index: newOtherIndex, indexableObject: branchTable }),
+      ];
+
+      const normalized = normalizePostDiffChanges({
+        changes,
+        branchTables: { [branchTable.stableId]: branchTable },
+      });
+
+      expect(
+        normalized.filter((c) => c instanceof AlterTableSetReplicaIdentity),
+      ).toHaveLength(0);
+    });
+  });
 });

package/src/core/post-diff-normalization.ts

@@ -0,0 +1,260 @@
+import type { Change } from "./change.types.ts";
+import { CreateIndex } from "./objects/index/changes/index.create.ts";
+import { DropIndex } from "./objects/index/changes/index.drop.ts";
+import {
+  AlterTableAddConstraint,
+  AlterTableDropColumn,
+  AlterTableDropConstraint,
+  AlterTableSetReplicaIdentity,
+  AlterTableValidateConstraint,
+} from "./objects/table/changes/table.alter.ts";
+import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.ts";
+import type { Table } from "./objects/table/table.model.ts";
+import { stableId } from "./objects/utils.ts";
+
+function constraintStableId(
+  table: { schema: string; name: string },
+  constraintName: string,
+) {
+  return stableId.constraint(table.schema, table.name, constraintName);
+}
+
+function isSupersededByTableReplacement(
+  change: Change,
+  replacedTableIds: ReadonlySet<string>,
+): boolean {
+  if (
+    !(change instanceof AlterTableDropColumn) &&
+    !(change instanceof AlterTableDropConstraint)
+  ) {
+    return false;
+  }
+  return replacedTableIds.has(change.table.stableId);
+}
+
+/**
+ * Drop earlier duplicates of `AlterTableAddConstraint` /
+ * `AlterTableValidateConstraint` / `CreateCommentOnConstraint` targeting
+ * replaced tables, keeping only the last occurrence of each
+ * `(changeType, table.stableId, constraint.name)`.
+ *
+ * When `expandReplaceDependencies()` promotes a table to a full
+ * `DropTable + CreateTable` pair, it also emits one
+ * `AlterTableAddConstraint` (plus optional `VALIDATE CONSTRAINT` /
+ * `COMMENT ON CONSTRAINT`) per branch constraint. If `diffTables()` already
+ * emitted the same change for a shape flip or a new constraint on that
+ * table, the plan ends up with two identical `ALTER TABLE ... ADD
+ * CONSTRAINT ...` statements and PostgreSQL fails at apply time with
+ * `constraint "..." for relation "..." already exists`. Because
+ * `expandReplaceDependencies()` appends its additions after the original
+ * `diffTables()` output, the last occurrence is the expansion's emission —
+ * keeping it preserves correctness while removing the duplicate.
+ */
+function dropReplacedTableDuplicateConstraintChanges(
+  changes: Change[],
+  replacedTableIds: ReadonlySet<string>,
+): Change[] {
+  if (replacedTableIds.size === 0) return changes;
+
+  const keyFor = (change: Change): string | null => {
+    if (
+      !(change instanceof AlterTableAddConstraint) &&
+      !(change instanceof AlterTableValidateConstraint) &&
+      !(change instanceof CreateCommentOnConstraint)
+    ) {
+      return null;
+    }
+    if (!replacedTableIds.has(change.table.stableId)) return null;
+    const tag =
+      change instanceof AlterTableAddConstraint
+        ? "add"
+        : change instanceof AlterTableValidateConstraint
+          ? "validate"
+          : "comment";
+    return `${tag}:${constraintStableId(change.table, change.constraint.name)}`;
+  };
+
+  const seen = new Set<string>();
+  const reversedKept: Change[] = [];
+  let mutated = false;
+
+  // Walk backwards: the first encounter of each key corresponds to its LAST
+  // occurrence in the original order. `expandReplaceDependencies()` appends
+  // additions after the original changes, so "last wins" keeps the
+  // expansion's emission and drops the earlier diffTables duplicate.
+  for (let i = changes.length - 1; i >= 0; i--) {
+    const change = changes[i] as Change;
+    const key = keyFor(change);
+    if (key !== null) {
+      if (seen.has(key)) {
+        mutated = true;
+        continue;
+      }
+      seen.add(key);
+    }
+    reversedKept.push(change);
+  }
+
+  return mutated ? reversedKept.reverse() : changes;
+}
+
+/**
+ * Re-emit `ALTER TABLE ... REPLICA IDENTITY USING INDEX <idx>` after any
+ * `DropIndex(idx) + CreateIndex(idx)` pair where `idx` is the replica-identity
+ * index of a branch table.
+ *
+ * Background: PostgreSQL silently flips a table's `relreplident` to `'d'`
+ * (DEFAULT) when the index it points to is dropped. `CREATE INDEX` cannot
+ * restore the marker — only `ALTER TABLE ... REPLICA IDENTITY USING INDEX`
+ * can. When both main and branch carry `replica_identity = 'i'` pointing at
+ * the same index name, `diffTables()` emits no replica-identity change of its
+ * own, so the marker would be lost on apply.
+ *
+ * This is a whole-plan interaction: `diffTables()` cannot detect it without
+ * also looking at index changes. Per the "whole-plan interactions belong in
+ * post-diff normalization" rule in the package CLAUDE.md, the restoration
+ * lives here.
+ *
+ * Insertion is idempotent: if `diffTables()` already emitted the same
+ * `AlterTableSetReplicaIdentity` for this table (e.g. when the user is also
+ * switching the replica-identity index name in the same migration), no
+ * duplicate is added.
+ */
+function restoreReplicaIdentityAfterIndexReplace(
+  changes: Change[],
+  branchTables: Record<string, Table>,
+): Change[] {
+  // Build the index-stable-id → owning-table map from branch state. Only
+  // tables in 'i' mode contribute, and only those whose configured index name
+  // is non-null (the extractor returns null for any other mode).
+  const replicaIdentityIndexToTable = new Map<string, Table>();
+  for (const table of Object.values(branchTables)) {
+    if (table.replica_identity !== "i" || !table.replica_identity_index) {
+      continue;
+    }
+    const indexId = stableId.index(
+      table.schema,
+      table.name,
+      table.replica_identity_index,
+    );
+    replicaIdentityIndexToTable.set(indexId, table);
+  }
+  if (replicaIdentityIndexToTable.size === 0) return changes;
+
+  // Find the indexes that are both dropped AND created in this plan. A pure
+  // drop or a pure create is handled by `diffTables()` directly (the table's
+  // replica_identity / replica_identity_index fields will have changed). The
+  // hole is specifically the drop+create pair that recreates the same name.
+  const droppedIndexIds = new Set<string>();
+  const createdIndexIds = new Set<string>();
+  for (const change of changes) {
+    if (change instanceof DropIndex) {
+      droppedIndexIds.add(change.index.stableId);
+    } else if (change instanceof CreateIndex) {
+      createdIndexIds.add(change.index.stableId);
+    }
+  }
+  const replacedIndexIds = new Set<string>();
+  for (const id of droppedIndexIds) {
+    if (createdIndexIds.has(id) && replicaIdentityIndexToTable.has(id)) {
+      replacedIndexIds.add(id);
+    }
+  }
+  if (replacedIndexIds.size === 0) return changes;
+
+  // Skip tables for which `diffTables()` already emitted a replica-identity
+  // setter — re-emitting would produce a redundant ALTER TABLE (harmless on
+  // apply, but noisy in plan output).
+  const tablesWithExistingReplicaIdentitySetter = new Set<string>();
+  for (const change of changes) {
+    if (change instanceof AlterTableSetReplicaIdentity) {
+      tablesWithExistingReplicaIdentitySetter.add(change.table.stableId);
+    }
+  }
+
+  // Insert one `AlterTableSetReplicaIdentity` per replaced index, immediately
+  // after the matching `CreateIndex`. The change's `requires` already names
+  // both the table and the recreated index, so the topo sort orders it
+  // correctly relative to the surrounding DDL.
+  const result: Change[] = [];
+  for (const change of changes) {
+    result.push(change);
+    if (
+      !(change instanceof CreateIndex) ||
+      !replacedIndexIds.has(change.index.stableId)
+    ) {
+      continue;
+    }
+    const table = replicaIdentityIndexToTable.get(change.index.stableId);
+    if (!table) continue;
+    if (tablesWithExistingReplicaIdentitySetter.has(table.stableId)) continue;
+
+    result.push(
+      new AlterTableSetReplicaIdentity({
+        table,
+        mode: "i",
+        indexName: table.replica_identity_index,
+      }),
+    );
+    // Mark as emitted so a second replaced index on the same table — if that
+    // ever arises — doesn't double-emit.
+    tablesWithExistingReplicaIdentitySetter.add(table.stableId);
+  }
+
+  return result;
+}
+
+/**
+ * Apply structural rewrites to the change list that are only obvious once
+ * every object diff has been collected. This pass does NOT prevent dependency
+ * cycles — that responsibility now lives in the sort phase, where
+ * `sortPhaseChanges` invokes `tryBreakCycleByChangeInjection` lazily on cycles
+ * that edge filtering can't break (FK SCC of dropped tables,
+ * AlterPublicationDropTables ↔ AlterTableDropColumn, …).
+ *
+ * Concretely, this pass:
+ *
+ * - Prunes `AlterTableDropColumn(T.*)` / `AlterTableDropConstraint(T.*)`
+ *   changes that are made redundant by an expansion-emitted
+ *   `DropTable(T) + CreateTable(T)` pair. Without this, the apply phase
+ *   would try to drop a column that no longer exists in the freshly
+ *   recreated table.
+ * - Dedupes duplicate `AlterTableAddConstraint` /
+ *   `AlterTableValidateConstraint` / `CreateCommentOnConstraint` changes
+ *   produced when `diffTables()` and `expandReplaceDependencies()` both
+ *   emit the same constraint operation for a replaced table. Last write
+ *   wins so the expansion's emission survives.
+ * - Re-emits `ALTER TABLE ... REPLICA IDENTITY USING INDEX <idx>` after any
+ *   `DropIndex(idx) + CreateIndex(idx)` pair where `idx` is the replica
+ *   identity index of a branch table — Postgres silently clears the marker
+ *   when the underlying index is dropped, and `CREATE INDEX` cannot restore
+ *   it.
+ *
+ * Object-local PostgreSQL semantics (for example owned-sequence cascades)
+ * stay in the corresponding `diff*` function instead of this pass.
+ */
+export function normalizePostDiffChanges({
+  changes,
+  replacedTableIds = new Set<string>(),
+  branchTables = {},
+}: {
+  changes: Change[];
+  replacedTableIds?: ReadonlySet<string>;
+  branchTables?: Record<string, Table>;
+}): Change[] {
+  const restoredChanges = restoreReplicaIdentityAfterIndexReplace(
+    changes,
+    branchTables,
+  );
+
+  const dedupedChanges = dropReplacedTableDuplicateConstraintChanges(
+    restoredChanges,
+    replacedTableIds,
+  );
+
+  if (replacedTableIds.size === 0) return dedupedChanges;
+
+  return dedupedChanges.filter(
+    (change) => !isSupersededByTableReplacement(change, replacedTableIds),
+  );
+}

package/src/core/sort/cycle-breakers.ts

@@ -284,7 +284,7 @@ function tryBreakPublicationColumnCycle(
 
   // Verify the table is NOT itself being dropped. If `DropTable(T)` is in
   // the same phase, the existing structural rewrites in
-  // `post-diff-cycle-breaking.ts` (replace-expansion superseded filter)
+  // `post-diff-normalization.ts` (replace-expansion superseded filter)
   // already prune the redundant `AlterTableDropColumn`, so we should not
   // see this combination here. Be defensive and bail anyway — flipping
   // `omitTableRequirement` when T is being dropped would let the column

package/src/core/sort/utils.ts

@@ -1,4 +1,9 @@
 import type { Change } from "../change.types.ts";
+import {
+  AlterTableAlterColumnDropDefault,
+  AlterTableAlterColumnDropIdentity,
+  AlterTableAlterColumnType,
+} from "../objects/table/changes/table.alter.ts";
 
 /**
  * Execution phases for changes.
@@ -30,6 +35,16 @@ export function isMetadataStableId(stableId: string): boolean {
  * - ALTER operations with scope="privilege" → create_alter_object phase (metadata changes)
  * - ALTER operations that drop actual objects → drop phase (destructive ALTER)
  * - ALTER operations that don't drop objects → create_alter_object phase (non-destructive ALTER)
+ *
+ * Dependency-breaking ALTERs that remove a `pg_depend` edge to another
+ * object that may be dropped in the same plan (for example
+ * `ALTER COLUMN ... DROP DEFAULT` releasing a sequence reference, or
+ * `ALTER COLUMN ... TYPE <built-in>` releasing a user-defined type
+ * reference) are routed to the drop phase. The drop phase sorts in reverse
+ * dependency order using the main catalog, so the catalog edges already
+ * in `pg_depend` order the ALTER before any dependent `DROP TYPE` /
+ * `DROP SEQUENCE` / `DROP FUNCTION` and PostgreSQL no longer rejects the
+ * drop with error 2BP01.
  */
 export function getExecutionPhase(change: Change): Phase {
   // DROP operations always go to drop phase
@@ -60,6 +75,29 @@ export function getExecutionPhase(change: Change): Phase {
       return "drop";
     }
 
+    // Dependency-breaking column ALTERs that release a pg_depend edge.
+    // Routing these to the drop phase lets the existing catalog dependency
+    // edges (column → sequence, column → identity sequence) order them
+    // before the matching DROP statement.
+    if (
+      change instanceof AlterTableAlterColumnDropDefault ||
+      change instanceof AlterTableAlterColumnDropIdentity
+    ) {
+      return "drop";
+    }
+
+    // ALTER COLUMN ... TYPE only safely runs in the drop phase when the
+    // target type is built-in. For user-defined target types we cannot tell
+    // here whether the type is created in the same plan, and the create
+    // happens in create_alter phase, so we keep the alter in that phase to
+    // preserve the create-then-alter ordering.
+    if (
+      change instanceof AlterTableAlterColumnType &&
+      !change.column.is_custom_type
+    ) {
+      return "drop";
+    }
+
     // Non-destructive ALTER (ADD COLUMN, GRANT, etc.) → create_alter phase
     return "create_alter_object";
   }

package/dist/core/post-diff-cycle-breaking.js

@@ -1,100 +0,0 @@
-import { AlterTableAddConstraint, AlterTableDropColumn, AlterTableDropConstraint, AlterTableValidateConstraint, } from "./objects/table/changes/table.alter.js";
-import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.js";
-import { stableId } from "./objects/utils.js";
-function constraintStableId(table, constraintName) {
-    return stableId.constraint(table.schema, table.name, constraintName);
-}
-function isSupersededByTableReplacement(change, replacedTableIds) {
-    if (!(change instanceof AlterTableDropColumn) &&
-        !(change instanceof AlterTableDropConstraint)) {
-        return false;
-    }
-    return replacedTableIds.has(change.table.stableId);
-}
-/**
- * Drop earlier duplicates of `AlterTableAddConstraint` /
- * `AlterTableValidateConstraint` / `CreateCommentOnConstraint` targeting
- * replaced tables, keeping only the last occurrence of each
- * `(changeType, table.stableId, constraint.name)`.
- *
- * When `expandReplaceDependencies()` promotes a table to a full
- * `DropTable + CreateTable` pair, it also emits one
- * `AlterTableAddConstraint` (plus optional `VALIDATE CONSTRAINT` /
- * `COMMENT ON CONSTRAINT`) per branch constraint. If `diffTables()` already
- * emitted the same change for a shape flip or a new constraint on that
- * table, the plan ends up with two identical `ALTER TABLE ... ADD
- * CONSTRAINT ...` statements and PostgreSQL fails at apply time with
- * `constraint "..." for relation "..." already exists`. Because
- * `expandReplaceDependencies()` appends its additions after the original
- * `diffTables()` output, the last occurrence is the expansion's emission —
- * keeping it preserves correctness while removing the duplicate.
- */
-function dropReplacedTableDuplicateConstraintChanges(changes, replacedTableIds) {
-    if (replacedTableIds.size === 0)
-        return changes;
-    const keyFor = (change) => {
-        if (!(change instanceof AlterTableAddConstraint) &&
-            !(change instanceof AlterTableValidateConstraint) &&
-            !(change instanceof CreateCommentOnConstraint)) {
-            return null;
-        }
-        if (!replacedTableIds.has(change.table.stableId))
-            return null;
-        const tag = change instanceof AlterTableAddConstraint
-            ? "add"
-            : change instanceof AlterTableValidateConstraint
-                ? "validate"
-                : "comment";
-        return `${tag}:${constraintStableId(change.table, change.constraint.name)}`;
-    };
-    const seen = new Set();
-    const reversedKept = [];
-    let mutated = false;
-    // Walk backwards: the first encounter of each key corresponds to its LAST
-    // occurrence in the original order. `expandReplaceDependencies()` appends
-    // additions after the original changes, so "last wins" keeps the
-    // expansion's emission and drops the earlier diffTables duplicate.
-    for (let i = changes.length - 1; i >= 0; i--) {
-        const change = changes[i];
-        const key = keyFor(change);
-        if (key !== null) {
-            if (seen.has(key)) {
-                mutated = true;
-                continue;
-            }
-            seen.add(key);
-        }
-        reversedKept.push(change);
-    }
-    return mutated ? reversedKept.reverse() : changes;
-}
-/**
- * Apply structural rewrites to the change list that are only obvious once
- * every object diff has been collected. This pass does NOT prevent dependency
- * cycles — that responsibility now lives in the sort phase, where
- * `sortPhaseChanges` invokes `tryBreakCycleByChangeInjection` lazily on cycles
- * that edge filtering can't break (FK SCC of dropped tables,
- * AlterPublicationDropTables ↔ AlterTableDropColumn, …).
- *
- * Concretely, this pass:
- *
- * - Prunes `AlterTableDropColumn(T.*)` / `AlterTableDropConstraint(T.*)`
- *   changes that are made redundant by an expansion-emitted
- *   `DropTable(T) + CreateTable(T)` pair. Without this, the apply phase
- *   would try to drop a column that no longer exists in the freshly
- *   recreated table.
- * - Dedupes duplicate `AlterTableAddConstraint` /
- *   `AlterTableValidateConstraint` / `CreateCommentOnConstraint` changes
- *   produced when `diffTables()` and `expandReplaceDependencies()` both
- *   emit the same constraint operation for a replaced table. Last write
- *   wins so the expansion's emission survives.
- *
- * Object-local PostgreSQL semantics (for example owned-sequence cascades)
- * stay in the corresponding `diff*` function instead of this pass.
- */
-export function normalizePostDiffCycles({ changes, replacedTableIds = new Set(), }) {
-    const dedupedChanges = dropReplacedTableDuplicateConstraintChanges(changes, replacedTableIds);
-    if (replacedTableIds.size === 0)
-        return dedupedChanges;
-    return dedupedChanges.filter((change) => !isSupersededByTableReplacement(change, replacedTableIds));
-}