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

package/src/core/objects/utils.ts

@@ -71,6 +71,9 @@ export const stableId = {
   constraint(schema: string, table: string, constraint: string) {
     return `constraint:${schema}.${table}.${constraint}` as const;
   },
+  index(schema: string, table: string, indexName: string) {
+    return `index:${schema}.${table}.${indexName}` as const;
+  },
   comment(objectStableId: string) {
     return `comment:${objectStableId}` as const;
   },

package/src/core/objects/view/view.model.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import { extractViews, View } from "./view.model.ts";
+
+const baseRow = {
+  schema: "public",
+  row_security: false,
+  force_row_security: false,
+  has_indexes: false,
+  has_rules: false,
+  has_triggers: false,
+  has_subclasses: false,
+  is_populated: true,
+  replica_identity: "d" as const,
+  is_partition: false,
+  options: null,
+  partition_bound: null,
+  owner: "postgres",
+  comment: null,
+  columns: [],
+  privileges: [],
+};
+
+const mockPool = (rows: unknown[]): Pool =>
+  ({ query: async () => ({ rows }) }) as unknown as Pool;
+
+const mockPoolSequence = (...attempts: unknown[][]): Pool => {
+  let i = 0;
+  return {
+    query: async () => ({
+      rows: attempts[Math.min(i++, attempts.length - 1)],
+    }),
+  } as unknown as Pool;
+};
+
+const NO_BACKOFF = { backoffMs: 0 } as const;
+
+describe("extractViews", () => {
+  test("skips rows where pg_get_viewdef returned NULL after exhausting retries", async () => {
+    const views = await extractViews(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"good_view"',
+          definition: "SELECT 1",
+        },
+        { ...baseRow, name: '"orphan_view"', definition: null },
+      ]),
+      NO_BACKOFF,
+    );
+
+    expect(views).toHaveLength(1);
+    expect(views[0]).toBeInstanceOf(View);
+    expect(views[0]?.name).toBe('"good_view"');
+    expect(views[0]?.definition).toBe("SELECT 1");
+  });
+
+  test("does not throw ZodError when the only row has a null definition", async () => {
+    await expect(
+      extractViews(
+        mockPool([{ ...baseRow, name: '"orphan"', definition: null }]),
+        NO_BACKOFF,
+      ),
+    ).resolves.toEqual([]);
+  });
+
+  test("returns all views when every row has a valid definition", async () => {
+    const views = await extractViews(
+      mockPool([
+        { ...baseRow, name: '"a"', definition: "SELECT 1" },
+        { ...baseRow, name: '"b"', definition: "SELECT 2" },
+      ]),
+      NO_BACKOFF,
+    );
+    expect(views.map((v) => v.name)).toEqual(['"a"', '"b"']);
+  });
+
+  test("recovers when pg_get_viewdef is NULL on first attempt but resolved on retry", async () => {
+    const views = await extractViews(
+      mockPoolSequence(
+        [{ ...baseRow, name: '"racy_view"', definition: null }],
+        [{ ...baseRow, name: '"racy_view"', definition: "SELECT 42" }],
+      ),
+      { retries: 2, backoffMs: 0 },
+    );
+    expect(views).toHaveLength(1);
+    expect(views[0]?.name).toBe('"racy_view"');
+    expect(views[0]?.definition).toBe("SELECT 42");
+  });
+});

package/src/core/objects/view/view.model.ts

@@ -11,6 +11,10 @@ import {
   type PrivilegeProps,
   privilegePropsSchema,
 } from "../base.privilege-diff.ts";
+import {
+  type ExtractRetryOptions,
+  extractWithDefinitionRetry,
+} from "../extract-with-retry.ts";
 import { ReplicaIdentitySchema } from "../table/table.model.ts";
 
 const viewPropsSchema = z.object({
@@ -34,6 +38,15 @@ const viewPropsSchema = z.object({
   privileges: z.array(privilegePropsSchema),
 });
 
+// pg_get_viewdef(oid) can return NULL when the underlying view (or its
+// pg_rewrite row) is dropped between catalog scan and resolution, or under
+// transient catalog state during recovery. An unreadable view cannot be
+// diffed, so we accept NULL here and filter the row out at extraction time
+// rather than crashing the whole catalog parse with a ZodError.
+const viewRowSchema = viewPropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
 type ViewPrivilegeProps = PrivilegeProps;
 export type ViewProps = z.infer<typeof viewPropsSchema>;
 
@@ -126,8 +139,16 @@ export class View extends BasePgModel implements TableLikeObject {
   }
 }
 
-export async function extractViews(pool: Pool): Promise<View[]> {
-  const { rows: viewRows } = await pool.query<ViewProps>(sql`
+export async function extractViews(
+  pool: Pool,
+  options?: ExtractRetryOptions,
+): Promise<View[]> {
+  const viewRows = await extractWithDefinitionRetry({
+    label: "views",
+    options,
+    hasNullDefinition: (row) => row.definition === null,
+    query: async () => {
+      const result = await pool.query<ViewProps>(sql`
 with extension_oids as (
   select
     objid
@@ -254,9 +275,11 @@ group by
 order by
   v.schema, v.name
   `);
-  // Validate and parse each row using the Zod schema
-  const validatedRows = viewRows.map((row: unknown) =>
-    viewPropsSchema.parse(row),
+      return result.rows.map((row: unknown) => viewRowSchema.parse(row));
+    },
+  });
+  const validatedRows = viewRows.filter(
+    (row): row is ViewProps => row.definition !== null,
   );
   return validatedRows.map((row: ViewProps) => new View(row));
 }

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/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