@supabase/pg-delta 1.0.0-alpha.17 → 1.0.0-alpha.18

package/dist/core/expand-replace-dependencies.js

@@ -32,6 +32,25 @@ export function expandReplaceDependencies({ changes, mainCatalog, branchCatalog,
             replaceRoots.add(id);
         }
     }
+    // Procedure stableIds are signature-qualified
+    // (`procedure:schema.name(argtypes)`), so a function whose parameter types
+    // change has different ids in `createdIds` and `droppedIds` and would not
+    // appear in the intersection above. Treat any dropped procedure whose
+    // `(schema, name)` matches a created procedure as a replace root so
+    // dependents referencing the old signature via pg_depend get promoted to
+    // DROP+CREATE.
+    const createdProcedureNames = new Set();
+    for (const id of createdIds) {
+        const key = parseProcedureSchemaName(id);
+        if (key)
+            createdProcedureNames.add(key);
+    }
+    for (const id of droppedIds) {
+        const key = parseProcedureSchemaName(id);
+        if (key && createdProcedureNames.has(key)) {
+            replaceRoots.add(id);
+        }
+    }
     if (replaceRoots.size === 0) {
         return {
             changes,
@@ -149,6 +168,14 @@ function isOwnedSequenceColumnDependency(referencedId, dependentId, mainCatalog,
     return (dependentId ===
         stableId.column(sequence.owned_by_schema, sequence.owned_by_table, sequence.owned_by_column));
 }
+function parseProcedureSchemaName(stableId) {
+    if (!stableId.startsWith("procedure:"))
+        return null;
+    const paren = stableId.indexOf("(");
+    if (paren === -1)
+        return null;
+    return stableId.slice("procedure:".length, paren);
+}
 function normalizeDependentId(dependentId) {
     let id = dependentId;
     while (id.startsWith("comment:")) {

package/dist/core/objects/procedure/procedure.diff.js

@@ -17,8 +17,7 @@ import { GrantProcedurePrivileges, RevokeGrantOptionProcedurePrivileges, RevokeP
 export function diffProcedures(ctx, main, branch) {
     const { created, dropped, altered } = diffObjects(main, branch);
     const changes = [];
-    for (const procedureId of created) {
-        const proc = branch[procedureId];
+    const appendCreateProcedureChanges = (proc) => {
         changes.push(new CreateProcedure({ procedure: proc }));
         // OWNER: If the procedure should be owned by someone other than the current user,
         // emit ALTER FUNCTION/PROCEDURE ... OWNER TO after creation
@@ -53,6 +52,9 @@ export function diffProcedures(ctx, main, branch) {
             Revoke: RevokeProcedurePrivileges,
             RevokeGrantOption: RevokeGrantOptionProcedurePrivileges,
         }, ctx.version));
+    };
+    for (const procedureId of created) {
+        appendCreateProcedureChanges(branch[procedureId]);
     }
     for (const procedureId of dropped) {
         changes.push(new DropProcedure({ procedure: main[procedureId] }));
@@ -60,22 +62,18 @@ export function diffProcedures(ctx, main, branch) {
     for (const procedureId of altered) {
         const mainProcedure = main[procedureId];
         const branchProcedure = branch[procedureId];
-        // Check if non-alterable properties have changed
-        // These require dropping and recreating the procedure
-        const NON_ALTERABLE_FIELDS = [
+        // Fields that are part of the function's identity/signature. PostgreSQL
+        // rejects `CREATE OR REPLACE FUNCTION` for any of these changes with
+        // errors such as:
+        //   - cannot change return type of existing function
+        //   - cannot change name of input parameter "..."
+        //   - cannot change whether a procedure has output parameters
+        //   - cannot remove parameter defaults from existing function
+        // These require `DROP FUNCTION` followed by `CREATE FUNCTION`.
+        const SIGNATURE_BREAKING_FIELDS = [
             "kind",
             "return_type",
             "return_type_schema",
-            "language",
-            // The following properties are alterable in SQL, but our generator may choose
-            // to replace on changes not covered by explicit ALTER actions. Keep them out here
-            // to allow ALTER for those we implement below.
-            // security_definer,
-            // volatility,
-            // parallel_safety,
-            // is_strict,
-            // leakproof,
-            // Returns-set is part of the signature and not alterable
             "returns_set",
             "argument_count",
             "argument_default_count",
@@ -84,20 +82,35 @@ export function diffProcedures(ctx, main, branch) {
             "all_argument_types",
             "argument_modes",
             "argument_defaults",
+        ];
+        // Fields where `CREATE OR REPLACE` is sufficient - body replacement only.
+        // Other fields (security_definer, volatility, parallel_safety, is_strict,
+        // leakproof, config) are alterable via dedicated ALTER actions below.
+        const OR_REPLACEABLE_NON_ALTERABLE_FIELDS = [
+            "language",
             "source_code",
             "binary_path",
             "sql_body",
-            // config is alterable via SET/RESET
         ];
-        const nonAlterablePropsChanged = hasNonAlterableChanges(mainProcedure, branchProcedure, NON_ALTERABLE_FIELDS, {
+        const signatureChanged = hasNonAlterableChanges(mainProcedure, branchProcedure, SIGNATURE_BREAKING_FIELDS, {
             argument_names: deepEqual,
             argument_types: deepEqual,
             all_argument_types: deepEqual,
             argument_modes: deepEqual,
-            config: deepEqual,
         });
-        if (nonAlterablePropsChanged) {
-            // Replace the entire procedure
+        const nonAlterablePropsChanged = signatureChanged ||
+            hasNonAlterableChanges(mainProcedure, branchProcedure, OR_REPLACEABLE_NON_ALTERABLE_FIELDS);
+        if (signatureChanged) {
+            // PostgreSQL cannot change an existing function's signature via
+            // `CREATE OR REPLACE`. Drop the old signature, then recreate.
+            // `expandReplaceDependencies` will cascade the replacement to dependent
+            // objects (views, triggers, column defaults) via pg_depend edges.
+            changes.push(new DropProcedure({ procedure: mainProcedure }));
+            appendCreateProcedureChanges(branchProcedure);
+        }
+        else if (nonAlterablePropsChanged) {
+            // Body-only non-alterable change - `CREATE OR REPLACE` preserves the
+            // function OID and keeps dependent objects attached.
             changes.push(new CreateProcedure({ procedure: branchProcedure, orReplace: true }));
             if (mainProcedure.comment !== branchProcedure.comment) {
                 if (branchProcedure.comment === null) {

package/dist/core/objects/table/table.diff.js

@@ -66,6 +66,7 @@ function createAlterConstraintChange(mainTable, branchTable) {
             mainC.validated !== branchC.validated ||
             mainC.is_local !== branchC.is_local ||
             mainC.no_inherit !== branchC.no_inherit ||
+            mainC.is_temporal !== branchC.is_temporal ||
             JSON.stringify(mainC.key_columns) !==
                 JSON.stringify(branchC.key_columns) ||
             JSON.stringify(mainC.foreign_key_columns) !==

package/dist/core/objects/table/table.model.d.ts

@@ -23,6 +23,7 @@ declare const tableConstraintPropsSchema: z.ZodObject<{
     validated: z.ZodBoolean;
     is_local: z.ZodBoolean;
     no_inherit: z.ZodBoolean;
+    is_temporal: z.ZodBoolean;
     is_partition_clone: z.ZodBoolean;
     parent_constraint_schema: z.ZodNullable<z.ZodString>;
     parent_constraint_name: z.ZodNullable<z.ZodString>;
@@ -125,6 +126,7 @@ declare const tablePropsSchema: z.ZodObject<{
         validated: z.ZodBoolean;
         is_local: z.ZodBoolean;
         no_inherit: z.ZodBoolean;
+        is_temporal: z.ZodBoolean;
         is_partition_clone: z.ZodBoolean;
         parent_constraint_schema: z.ZodNullable<z.ZodString>;
         parent_constraint_name: z.ZodNullable<z.ZodString>;
@@ -239,6 +241,7 @@ export declare class Table extends BasePgModel implements TableLikeObject {
             validated: boolean;
             is_local: boolean;
             no_inherit: boolean;
+            is_temporal: boolean;
             is_partition_clone: boolean;
             parent_constraint_schema: string | null;
             parent_constraint_name: string | null;
@@ -300,6 +303,7 @@ export declare class Table extends BasePgModel implements TableLikeObject {
                 validated: boolean;
                 is_local: boolean;
                 no_inherit: boolean;
+                is_temporal: boolean;
                 is_partition_clone: boolean;
                 parent_constraint_schema: string | null;
                 parent_constraint_name: string | null;

package/dist/core/objects/table/table.model.js

@@ -42,6 +42,7 @@ const tableConstraintPropsSchema = z.object({
     validated: z.boolean(),
     is_local: z.boolean(),
     no_inherit: z.boolean(),
+    is_temporal: z.boolean(),
     is_partition_clone: z.boolean(),
     parent_constraint_schema: z.string().nullable(),
     parent_constraint_name: z.string().nullable(),
@@ -253,6 +254,7 @@ select
           'validated', c.convalidated,
           'is_local', c.conislocal,
           'no_inherit', c.connoinherit,
+          'is_temporal', coalesce((to_jsonb(c)->>'conperiod')::boolean, false),
 
           -- NEW: propagated-to-partition tagging (PG15+)
           'is_partition_clone', (c.conparentid <> 0::oid),

package/dist/core/plan/sql-format/fixtures.js

@@ -294,6 +294,7 @@ const pkConstraint = {
     validated: true,
     is_local: true,
     no_inherit: false,
+    is_temporal: false,
     is_partition_clone: false,
     parent_constraint_schema: null,
     parent_constraint_name: null,
@@ -324,6 +325,7 @@ const uniqueConstraint = {
     validated: true,
     is_local: true,
     no_inherit: false,
+    is_temporal: false,
     is_partition_clone: false,
     parent_constraint_schema: null,
     parent_constraint_name: null,
@@ -353,6 +355,7 @@ const fkConstraint = {
     validated: true,
     is_local: true,
     no_inherit: false,
+    is_temporal: false,
     is_partition_clone: false,
     parent_constraint_schema: null,
     parent_constraint_name: null,
@@ -382,6 +385,7 @@ const checkConstraint = {
     validated: true,
     is_local: true,
     no_inherit: true,
+    is_temporal: false,
     is_partition_clone: false,
     parent_constraint_schema: null,
     parent_constraint_name: null,

package/dist/core/post-diff-cycle-breaking.d.ts

@@ -8,6 +8,13 @@ import type { Change } from "./change.types.ts";
  * - If replace expansion added `DropTable(T)+CreateTable(T)`, targeted
  *   `AlterTableDropColumn(T.*)` / `AlterTableDropConstraint(T.*)` changes are
  *   redundant and create an unbreakable drop-phase cycle, so we elide them.
+ * - When the same `DropTable+CreateTable` pair is present, the expansion
+ *   also emits one `AlterTableAddConstraint` / `AlterTableValidateConstraint`
+ *   / `CreateCommentOnConstraint` per branch constraint, which may collide
+ *   with the same change already emitted by `diffTables()` (for example on a
+ *   shape flip or a new constraint). We dedupe these keeping only the last
+ *   occurrence so the expansion's emission survives and the diffTables
+ *   duplicate is removed.
  * - If two dropped tables reference each other via FK, we insert dedicated
  *   `AlterTableDropConstraint` changes and teach the paired `DropTable`
  *   changes not to claim those FK stable IDs.

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

@@ -1,4 +1,5 @@
-import { AlterTableDropColumn, AlterTableDropConstraint, } from "./objects/table/changes/table.alter.js";
+import { AlterTableAddConstraint, AlterTableDropColumn, AlterTableDropConstraint, AlterTableValidateConstraint, } from "./objects/table/changes/table.alter.js";
+import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.js";
 import { DropTable } from "./objects/table/changes/table.drop.js";
 import { stableId } from "./objects/utils.js";
 function constraintStableId(table, constraintName) {
@@ -33,6 +34,63 @@ function isSupersededByTableReplacement(change, replacedTableIds) {
     }
     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;
+}
 function collectExplicitConstraintDropIds(changes) {
     const explicitConstraintDropIds = new Set();
     for (const change of changes) {
@@ -59,6 +117,13 @@ function hasSameEntries(left, right) {
  * - If replace expansion added `DropTable(T)+CreateTable(T)`, targeted
  *   `AlterTableDropColumn(T.*)` / `AlterTableDropConstraint(T.*)` changes are
  *   redundant and create an unbreakable drop-phase cycle, so we elide them.
+ * - When the same `DropTable+CreateTable` pair is present, the expansion
+ *   also emits one `AlterTableAddConstraint` / `AlterTableValidateConstraint`
+ *   / `CreateCommentOnConstraint` per branch constraint, which may collide
+ *   with the same change already emitted by `diffTables()` (for example on a
+ *   shape flip or a new constraint). We dedupe these keeping only the last
+ *   occurrence so the expansion's emission survives and the diffTables
+ *   duplicate is removed.
  * - If two dropped tables reference each other via FK, we insert dedicated
  *   `AlterTableDropConstraint` changes and teach the paired `DropTable`
  *   changes not to claim those FK stable IDs.
@@ -67,9 +132,10 @@ function hasSameEntries(left, right) {
  * in the corresponding `diff*` function instead of this pass.
  */
 export function normalizePostDiffCycles({ changes, mainCatalog, replacedTableIds = new Set(), }) {
+    const dedupedChanges = dropReplacedTableDuplicateConstraintChanges(changes, replacedTableIds);
     const structurallyNormalizedChanges = replacedTableIds.size === 0
-        ? changes
-        : changes.filter((change) => !isSupersededByTableReplacement(change, replacedTableIds));
+        ? dedupedChanges
+        : dedupedChanges.filter((change) => !isSupersededByTableReplacement(change, replacedTableIds));
     const dropTableChanges = structurallyNormalizedChanges.filter((change) => change instanceof DropTable);
     if (dropTableChanges.length < 2) {
         return structurallyNormalizedChanges;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.17",
+  "version": "1.0.0-alpha.18",
   "description": "PostgreSQL migrations made easy",
   "type": "module",
   "sideEffects": false,

package/src/core/expand-replace-dependencies.test.ts

@@ -3,6 +3,9 @@ import { Catalog, createEmptyCatalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import { expandReplaceDependencies } from "./expand-replace-dependencies.ts";
 import { DefaultPrivilegeState } from "./objects/base.default-privileges.ts";
+import { CreateProcedure } from "./objects/procedure/changes/procedure.create.ts";
+import { DropProcedure } from "./objects/procedure/changes/procedure.drop.ts";
+import { Procedure } from "./objects/procedure/procedure.model.ts";
 import { CreateSequence } from "./objects/sequence/changes/sequence.create.ts";
 import { DropSequence } from "./objects/sequence/changes/sequence.drop.ts";
 import { diffSequences } from "./objects/sequence/sequence.diff.ts";
@@ -22,6 +25,9 @@ import { Table } from "./objects/table/table.model.ts";
 import { CreateEnum } from "./objects/type/enum/changes/enum.create.ts";
 import { DropEnum } from "./objects/type/enum/changes/enum.drop.ts";
 import { Enum } from "./objects/type/enum/enum.model.ts";
+import { CreateView } from "./objects/view/changes/view.create.ts";
+import { DropView } from "./objects/view/changes/view.drop.ts";
+import { View } from "./objects/view/view.model.ts";
 
 function mockChange(overrides: {
   creates?: string[];
@@ -330,6 +336,7 @@ describe("expandReplaceDependencies", () => {
         validated: true,
         is_local: true,
         no_inherit: false,
+        is_temporal: false,
         is_partition_clone: false,
         parent_constraint_schema: null,
         parent_constraint_name: null,
@@ -431,4 +438,115 @@ describe("expandReplaceDependencies", () => {
     expect(expanded.changes).toContain(preExistingGrant);
     expect(expanded.replacedTableIds.has("table:public.parents")).toBe(false);
   });
+
+  test("promotes dependent view when a procedure's parameter types change", async () => {
+    // Procedure stableIds are signature-qualified, so a parameter-type change
+    // produces different stableIds in `createdIds` and `droppedIds`. The
+    // expander must still treat the (schema, name)-matched pair as a replace
+    // root so a dependent view is promoted from `CREATE OR REPLACE VIEW` to
+    // `DROP VIEW` + `CREATE VIEW` (otherwise `DROP FUNCTION` fails with
+    // "cannot drop function because other objects depend on it").
+    const baseline = await createEmptyCatalog(170000, "postgres");
+    const procedureBase = {
+      schema: "public",
+      name: "format_id",
+      kind: "f" as const,
+      return_type: "text",
+      return_type_schema: "pg_catalog",
+      language: "sql",
+      security_definer: false,
+      volatility: "i" as const,
+      parallel_safety: "u" as const,
+      execution_cost: 100,
+      result_rows: 0,
+      is_strict: false,
+      leakproof: false,
+      returns_set: false,
+      argument_count: 1,
+      argument_default_count: 0,
+      argument_names: ["id"],
+      all_argument_types: null,
+      argument_modes: null,
+      argument_defaults: null,
+      source_code: "SELECT 'id:' || id::text",
+      binary_path: null,
+      sql_body: null,
+      config: null,
+      owner: "postgres",
+      comment: null,
+      privileges: [],
+    };
+    const mainProcedure = new Procedure({
+      ...procedureBase,
+      argument_types: ["int4"],
+      definition: "CREATE FUNCTION public.format_id(id integer) ...",
+    });
+    const branchProcedure = new Procedure({
+      ...procedureBase,
+      argument_types: ["int8"],
+      definition: "CREATE FUNCTION public.format_id(id bigint) ...",
+    });
+    const viewBase = {
+      schema: "public",
+      name: "items_formatted",
+      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 mainView = new View({
+      ...viewBase,
+      definition: "SELECT public.format_id(id) FROM public.items",
+    });
+    const branchView = new View({
+      ...viewBase,
+      definition: "SELECT public.format_id(id::bigint) FROM public.items",
+    });
+
+    const changes: Change[] = [
+      new DropProcedure({ procedure: mainProcedure }),
+      new CreateProcedure({ procedure: branchProcedure }),
+      // view.diff emits this because pg_get_viewdef text differs after the
+      // underlying function signature changes.
+      new CreateView({ view: branchView, orReplace: true }),
+    ];
+
+    const mainCatalog = new Catalog({
+      ...baseline,
+      procedures: { [mainProcedure.stableId]: mainProcedure },
+      views: { [mainView.stableId]: mainView },
+      depends: [
+        {
+          dependent_stable_id: mainView.stableId,
+          referenced_stable_id: mainProcedure.stableId,
+          deptype: "n",
+        },
+      ],
+    });
+    const branchCatalog = new Catalog({
+      ...baseline,
+      procedures: { [branchProcedure.stableId]: branchProcedure },
+      views: { [branchView.stableId]: branchView },
+      depends: [],
+    });
+
+    const expanded = expandReplaceDependencies({
+      changes,
+      mainCatalog,
+      branchCatalog,
+    });
+
+    expect(expanded.changes.some((c) => c instanceof DropView)).toBe(true);
+  });
 });

package/src/core/expand-replace-dependencies.ts

@@ -102,6 +102,25 @@ export function expandReplaceDependencies({
     }
   }
 
+  // Procedure stableIds are signature-qualified
+  // (`procedure:schema.name(argtypes)`), so a function whose parameter types
+  // change has different ids in `createdIds` and `droppedIds` and would not
+  // appear in the intersection above. Treat any dropped procedure whose
+  // `(schema, name)` matches a created procedure as a replace root so
+  // dependents referencing the old signature via pg_depend get promoted to
+  // DROP+CREATE.
+  const createdProcedureNames = new Set<string>();
+  for (const id of createdIds) {
+    const key = parseProcedureSchemaName(id);
+    if (key) createdProcedureNames.add(key);
+  }
+  for (const id of droppedIds) {
+    const key = parseProcedureSchemaName(id);
+    if (key && createdProcedureNames.has(key)) {
+      replaceRoots.add(id);
+    }
+  }
+
   if (replaceRoots.size === 0) {
     return {
       changes,
@@ -259,6 +278,13 @@ function isOwnedSequenceColumnDependency(
   );
 }
 
+function parseProcedureSchemaName(stableId: string): string | null {
+  if (!stableId.startsWith("procedure:")) return null;
+  const paren = stableId.indexOf("(");
+  if (paren === -1) return null;
+  return stableId.slice("procedure:".length, paren);
+}
+
 function normalizeDependentId(dependentId: string): string | null {
   let id = dependentId;
 

package/src/core/objects/procedure/procedure.diff.test.ts

@@ -144,12 +144,13 @@ describe.concurrent("procedure.diff", () => {
     expect(changes[0]).toBeInstanceOf(AlterProcedureSetParallel);
   });
 
-  test("create or replace when non-alterable property changes", () => {
+  test("create or replace when body-only non-alterable property changes", () => {
+    // Changing only the language (or source) is OR-REPLACE-safe: no DROP needed.
     const main = new Procedure(base);
     const branch = new Procedure({
       ...base,
-      return_type: "text",
       language: "plpgsql",
+      source_code: "BEGIN RETURN 1; END",
     });
     const changes = diffProcedures(
       testContext,
@@ -158,6 +159,82 @@ describe.concurrent("procedure.diff", () => {
     );
     expect(changes).toHaveLength(1);
     expect(changes[0]).toBeInstanceOf(CreateProcedure);
+    expect((changes[0] as CreateProcedure).orReplace).toBe(true);
+  });
+
+  test("drop + create when return type changes", () => {
+    // `CREATE OR REPLACE FUNCTION` cannot change the return type.
+    const main = new Procedure(base);
+    const branch = new Procedure({ ...base, return_type: "text" });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropProcedure);
+    expect(changes[1]).toBeInstanceOf(CreateProcedure);
+    expect((changes[1] as CreateProcedure).orReplace).toBe(false);
+  });
+
+  test("drop + create when parameter name changes but type is identical", () => {
+    // Same argument_types means same stableId (altered path), but
+    // `CREATE OR REPLACE` rejects changing an IN parameter's name.
+    const main = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_names: ["p"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+    });
+    const branch = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_names: ["renamed"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropProcedure);
+    expect(changes[1]).toBeInstanceOf(CreateProcedure);
+    expect((changes[1] as CreateProcedure).orReplace).toBe(false);
+  });
+
+  test("drop + create when a parameter default is removed", () => {
+    // `CREATE OR REPLACE` rejects removing parameter defaults.
+    const main = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_default_count: 1,
+      argument_names: ["p"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+      argument_defaults: "0",
+    });
+    const branch = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_default_count: 0,
+      argument_names: ["p"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+      argument_defaults: null,
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropProcedure);
+    expect(changes[1]).toBeInstanceOf(CreateProcedure);
+    expect((changes[1] as CreateProcedure).orReplace).toBe(false);
   });
 
   test("create or replace also emits a procedure comment when the comment changes", () => {
@@ -183,4 +260,25 @@ describe.concurrent("procedure.diff", () => {
       changes.some((change) => change instanceof CreateCommentOnProcedure),
     ).toBe(true);
   });
+
+  test("signature change re-emits comment even when comment itself is unchanged", () => {
+    // DROP destroys the old comment, so the new CREATE path must re-emit it.
+    const main = new Procedure({ ...base, comment: "hello" });
+    const branch = new Procedure({
+      ...base,
+      return_type: "text",
+      comment: "hello",
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((change) => change instanceof DropProcedure)).toBe(
+      true,
+    );
+    expect(
+      changes.some((change) => change instanceof CreateCommentOnProcedure),
+    ).toBe(true);
+  });
 });

package/src/core/objects/procedure/procedure.diff.ts

@@ -49,8 +49,7 @@ export function diffProcedures(
 
   const changes: ProcedureChange[] = [];
 
-  for (const procedureId of created) {
-    const proc = branch[procedureId];
+  const appendCreateProcedureChanges = (proc: Procedure) => {
     changes.push(new CreateProcedure({ procedure: proc }));
 
     // OWNER: If the procedure should be owned by someone other than the current user,
@@ -112,6 +111,10 @@ export function diffProcedures(
         ctx.version,
       ) as ProcedureChange[]),
     );
+  };
+
+  for (const procedureId of created) {
+    appendCreateProcedureChanges(branch[procedureId]);
   }
 
   for (const procedureId of dropped) {
@@ -122,22 +125,18 @@ export function diffProcedures(
     const mainProcedure = main[procedureId];
     const branchProcedure = branch[procedureId];
 
-    // Check if non-alterable properties have changed
-    // These require dropping and recreating the procedure
-    const NON_ALTERABLE_FIELDS: Array<keyof Procedure> = [
+    // Fields that are part of the function's identity/signature. PostgreSQL
+    // rejects `CREATE OR REPLACE FUNCTION` for any of these changes with
+    // errors such as:
+    //   - cannot change return type of existing function
+    //   - cannot change name of input parameter "..."
+    //   - cannot change whether a procedure has output parameters
+    //   - cannot remove parameter defaults from existing function
+    // These require `DROP FUNCTION` followed by `CREATE FUNCTION`.
+    const SIGNATURE_BREAKING_FIELDS: Array<keyof Procedure> = [
       "kind",
       "return_type",
       "return_type_schema",
-      "language",
-      // The following properties are alterable in SQL, but our generator may choose
-      // to replace on changes not covered by explicit ALTER actions. Keep them out here
-      // to allow ALTER for those we implement below.
-      // security_definer,
-      // volatility,
-      // parallel_safety,
-      // is_strict,
-      // leakproof,
-      // Returns-set is part of the signature and not alterable
       "returns_set",
       "argument_count",
       "argument_default_count",
@@ -146,26 +145,45 @@ export function diffProcedures(
       "all_argument_types",
       "argument_modes",
       "argument_defaults",
+    ];
+    // Fields where `CREATE OR REPLACE` is sufficient - body replacement only.
+    // Other fields (security_definer, volatility, parallel_safety, is_strict,
+    // leakproof, config) are alterable via dedicated ALTER actions below.
+    const OR_REPLACEABLE_NON_ALTERABLE_FIELDS: Array<keyof Procedure> = [
+      "language",
       "source_code",
       "binary_path",
       "sql_body",
-      // config is alterable via SET/RESET
     ];
-    const nonAlterablePropsChanged = hasNonAlterableChanges(
+    const signatureChanged = hasNonAlterableChanges(
       mainProcedure,
       branchProcedure,
-      NON_ALTERABLE_FIELDS,
+      SIGNATURE_BREAKING_FIELDS,
       {
         argument_names: deepEqual,
         argument_types: deepEqual,
         all_argument_types: deepEqual,
         argument_modes: deepEqual,
-        config: deepEqual,
       },
     );
+    const nonAlterablePropsChanged =
+      signatureChanged ||
+      hasNonAlterableChanges(
+        mainProcedure,
+        branchProcedure,
+        OR_REPLACEABLE_NON_ALTERABLE_FIELDS,
+      );
 
-    if (nonAlterablePropsChanged) {
-      // Replace the entire procedure
+    if (signatureChanged) {
+      // PostgreSQL cannot change an existing function's signature via
+      // `CREATE OR REPLACE`. Drop the old signature, then recreate.
+      // `expandReplaceDependencies` will cascade the replacement to dependent
+      // objects (views, triggers, column defaults) via pg_depend edges.
+      changes.push(new DropProcedure({ procedure: mainProcedure }));
+      appendCreateProcedureChanges(branchProcedure);
+    } else if (nonAlterablePropsChanged) {
+      // Body-only non-alterable change - `CREATE OR REPLACE` preserves the
+      // function OID and keeps dependent objects attached.
       changes.push(
         new CreateProcedure({ procedure: branchProcedure, orReplace: true }),
       );

package/src/core/objects/table/changes/table.alter.test.ts

@@ -766,6 +766,7 @@ describe.concurrent("table", () => {
         validated: true,
         is_local: true,
         no_inherit: false,
+        is_temporal: false,
         is_partition_clone: false,
         parent_constraint_schema: null,
         parent_constraint_name: null,

package/src/core/objects/table/table.diff.test.ts

@@ -112,6 +112,7 @@ describe.concurrent("table.diff", () => {
           validated: false,
           is_local: true,
           no_inherit: false,
+          is_temporal: false,
           is_partition_clone: false,
           parent_constraint_schema: null,
           parent_constraint_name: null,
@@ -328,6 +329,7 @@ describe.concurrent("table.diff", () => {
       validated: false,
       is_local: true,
       no_inherit: false,
+      is_temporal: false,
       is_partition_clone: false,
       parent_constraint_schema: null,
       parent_constraint_name: null,
@@ -453,6 +455,7 @@ describe.concurrent("table.diff", () => {
           validated: true,
           is_local: true,
           no_inherit: false,
+          is_temporal: false,
           is_partition_clone: false,
           parent_constraint_schema: null,
           parent_constraint_name: null,
@@ -531,6 +534,7 @@ describe.concurrent("table.diff", () => {
           validated: true,
           is_local: true,
           no_inherit: false,
+          is_temporal: false,
           is_partition_clone: false,
           parent_constraint_schema: null,
           parent_constraint_name: null,
@@ -606,6 +610,104 @@ describe.concurrent("table.diff", () => {
     );
   });
 
+  test("altered temporal constraint metadata triggers drop+add", () => {
+    const tMain = new Table({
+      ...base,
+      name: "t_temporal",
+      columns: [
+        {
+          name: "room_id",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+        {
+          name: "booking_period",
+          position: 2,
+          data_type: "tstzrange",
+          data_type_str: "tstzrange",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      constraints: [
+        {
+          name: "bookings_pkey",
+          constraint_type: "p",
+          deferrable: false,
+          initially_deferred: false,
+          validated: true,
+          is_local: true,
+          no_inherit: false,
+          is_temporal: false,
+          is_partition_clone: false,
+          parent_constraint_schema: null,
+          parent_constraint_name: null,
+          parent_table_schema: null,
+          parent_table_name: null,
+          key_columns: ["room_id", "booking_period"],
+          foreign_key_columns: null,
+          foreign_key_table: null,
+          foreign_key_schema: null,
+          foreign_key_table_is_partition: null,
+          foreign_key_parent_schema: null,
+          foreign_key_parent_table: null,
+          foreign_key_effective_schema: null,
+          foreign_key_effective_table: null,
+          on_update: null,
+          on_delete: null,
+          match_type: null,
+          check_expression: null,
+          owner: "o1",
+          definition: "PRIMARY KEY (room_id, booking_period)",
+        },
+      ],
+    });
+    const tBranch = new Table({
+      ...tMain,
+      constraints: [
+        {
+          ...tMain.constraints[0],
+          is_temporal: true,
+          definition: "PRIMARY KEY (room_id, booking_period WITHOUT OVERLAPS)",
+        },
+      ],
+    });
+    const changes = diffTables(
+      testContext,
+      { [tMain.stableId]: tMain },
+      { [tBranch.stableId]: tBranch },
+    );
+    expect(changes.some((c) => c instanceof AlterTableDropConstraint)).toBe(
+      true,
+    );
+    expect(changes.some((c) => c instanceof AlterTableAddConstraint)).toBe(
+      true,
+    );
+  });
+
   test("columns added/dropped/altered (type, default, not null)", () => {
     const main = new Table({ ...base, name: "t2", columns: [] });
     const withCol = new Table({

package/src/core/objects/table/table.diff.ts

@@ -130,6 +130,7 @@ function createAlterConstraintChange(mainTable: Table, branchTable: Table) {
       mainC.validated !== branchC.validated ||
       mainC.is_local !== branchC.is_local ||
       mainC.no_inherit !== branchC.no_inherit ||
+      mainC.is_temporal !== branchC.is_temporal ||
       JSON.stringify(mainC.key_columns) !==
         JSON.stringify(branchC.key_columns) ||
       JSON.stringify(mainC.foreign_key_columns) !==

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

@@ -56,6 +56,7 @@ const tableConstraintPropsSchema = z.object({
   validated: z.boolean(),
   is_local: z.boolean(),
   no_inherit: z.boolean(),
+  is_temporal: z.boolean(),
   is_partition_clone: z.boolean(),
   parent_constraint_schema: z.string().nullable(),
   parent_constraint_name: z.string().nullable(),
@@ -284,6 +285,7 @@ select
           'validated', c.convalidated,
           'is_local', c.conislocal,
           'no_inherit', c.connoinherit,
+          'is_temporal', coalesce((to_jsonb(c)->>'conperiod')::boolean, false),
 
           -- NEW: propagated-to-partition tagging (PG15+)
           'is_partition_clone', (c.conparentid <> 0::oid),

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

@@ -578,6 +578,7 @@ const pkConstraint = {
   validated: true,
   is_local: true,
   no_inherit: false,
+  is_temporal: false,
   is_partition_clone: false,
   parent_constraint_schema: null,
   parent_constraint_name: null,
@@ -609,6 +610,7 @@ const uniqueConstraint = {
   validated: true,
   is_local: true,
   no_inherit: false,
+  is_temporal: false,
   is_partition_clone: false,
   parent_constraint_schema: null,
   parent_constraint_name: null,
@@ -639,6 +641,7 @@ const fkConstraint = {
   validated: true,
   is_local: true,
   no_inherit: false,
+  is_temporal: false,
   is_partition_clone: false,
   parent_constraint_schema: null,
   parent_constraint_name: null,
@@ -670,6 +673,7 @@ const checkConstraint = {
   validated: true,
   is_local: true,
   no_inherit: true,
+  is_temporal: false,
   is_partition_clone: false,
   parent_constraint_schema: null,
   parent_constraint_name: null,

package/src/core/post-diff-cycle-breaking.test.ts

@@ -2,12 +2,15 @@ import { describe, expect, test } from "bun:test";
 import { Catalog, createEmptyCatalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import {
+  AlterTableAddConstraint,
   AlterTableChangeOwner,
   AlterTableDropColumn,
   AlterTableDropConstraint,
   AlterTableEnableRowLevelSecurity,
   AlterTableSetReplicaIdentity,
+  AlterTableValidateConstraint,
 } from "./objects/table/changes/table.alter.ts";
+import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.ts";
 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";
@@ -77,6 +80,7 @@ describe("normalizePostDiffCycles", () => {
           validated: true,
           is_local: true,
           no_inherit: false,
+          is_temporal: false,
           is_partition_clone: false,
           parent_constraint_schema: null,
           parent_constraint_name: null,
@@ -117,6 +121,7 @@ describe("normalizePostDiffCycles", () => {
           validated: true,
           is_local: true,
           no_inherit: false,
+          is_temporal: false,
           is_partition_clone: false,
           parent_constraint_schema: null,
           parent_constraint_name: null,
@@ -237,6 +242,7 @@ describe("normalizePostDiffCycles", () => {
         validated: true,
         is_local: true,
         no_inherit: false,
+        is_temporal: false,
         is_partition_clone: false,
         parent_constraint_schema: null,
         parent_constraint_name: null,
@@ -314,4 +320,140 @@ describe("normalizePostDiffCycles", () => {
     expect(normalized).toContain(preExistingReplicaIdentity);
     expect(normalized).toContain(preExistingGrant);
   });
+
+  test("dedupes duplicate constraint Add/Validate/Comment on replaced tables keeping last occurrence", async () => {
+    const baseline = await createEmptyCatalog(170000, "postgres");
+    const branchChildren = new Table({
+      ...baseTableProps,
+      name: "children",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("parent_ref", 2),
+      ],
+    });
+    const otherTable = new Table({
+      ...baseTableProps,
+      name: "other",
+      columns: [{ ...integerColumn("id", 1), not_null: true }],
+    });
+
+    const fkConstraint = {
+      name: "children_parent_ref_fkey",
+      constraint_type: "f" as const,
+      deferrable: false,
+      initially_deferred: false,
+      validated: false,
+      is_local: true,
+      no_inherit: false,
+      is_temporal: true,
+      is_partition_clone: false,
+      parent_constraint_schema: null,
+      parent_constraint_name: null,
+      parent_table_schema: null,
+      parent_table_name: null,
+      key_columns: ["parent_ref"],
+      foreign_key_columns: ["id"],
+      foreign_key_table: "parents",
+      foreign_key_schema: "public",
+      foreign_key_table_is_partition: false,
+      foreign_key_parent_schema: null,
+      foreign_key_parent_table: null,
+      foreign_key_effective_schema: "public",
+      foreign_key_effective_table: "parents",
+      on_update: "a" as const,
+      on_delete: "a" as const,
+      match_type: "s" as const,
+      check_expression: null,
+      owner: "postgres",
+      definition:
+        "FOREIGN KEY (parent_ref, PERIOD valid_period) REFERENCES public.parents(id, PERIOD valid_period)",
+      comment: "fk comment",
+    };
+    const otherConstraint = {
+      ...fkConstraint,
+      name: "other_unique",
+      constraint_type: "u" as const,
+      foreign_key_table: null,
+      foreign_key_schema: null,
+      foreign_key_effective_schema: null,
+      foreign_key_effective_table: null,
+      foreign_key_columns: [],
+      key_columns: ["id"],
+      definition: "UNIQUE (id)",
+    };
+
+    const diffTablesAdd = new AlterTableAddConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const diffTablesValidate = new AlterTableValidateConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const diffTablesComment = new CreateCommentOnConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const expansionAdd = new AlterTableAddConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const expansionValidate = new AlterTableValidateConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const expansionComment = new CreateCommentOnConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const soloOtherTableAdd = new AlterTableAddConstraint({
+      table: otherTable,
+      constraint: otherConstraint,
+    });
+
+    const changes: Change[] = [
+      new DropTable({ table: branchChildren }),
+      new CreateTable({ table: branchChildren }),
+      diffTablesAdd,
+      diffTablesValidate,
+      diffTablesComment,
+      soloOtherTableAdd,
+      expansionAdd,
+      expansionValidate,
+      expansionComment,
+    ];
+
+    const mainCatalog = new Catalog({
+      ...baseline,
+      tables: { [branchChildren.stableId]: branchChildren },
+    });
+
+    const normalized = normalizePostDiffCycles({
+      changes,
+      mainCatalog,
+      replacedTableIds: new Set([branchChildren.stableId]),
+    });
+
+    expect(normalized).not.toContain(diffTablesAdd);
+    expect(normalized).not.toContain(diffTablesValidate);
+    expect(normalized).not.toContain(diffTablesComment);
+    expect(normalized).toContain(expansionAdd);
+    expect(normalized).toContain(expansionValidate);
+    expect(normalized).toContain(expansionComment);
+    expect(normalized).toContain(soloOtherTableAdd);
+
+    expect(
+      normalized.filter((change) => change instanceof AlterTableAddConstraint),
+    ).toHaveLength(2);
+    expect(
+      normalized.filter(
+        (change) => change instanceof AlterTableValidateConstraint,
+      ),
+    ).toHaveLength(1);
+    expect(
+      normalized.filter(
+        (change) => change instanceof CreateCommentOnConstraint,
+      ),
+    ).toHaveLength(1);
+  });
 });

package/src/core/post-diff-cycle-breaking.ts

@@ -1,9 +1,12 @@
 import type { Catalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import {
+  AlterTableAddConstraint,
   AlterTableDropColumn,
   AlterTableDropConstraint,
+  AlterTableValidateConstraint,
 } from "./objects/table/changes/table.alter.ts";
+import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.ts";
 import { DropTable } from "./objects/table/changes/table.drop.ts";
 import { stableId } from "./objects/utils.ts";
 
@@ -52,6 +55,72 @@ function isSupersededByTableReplacement(
   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;
+}
+
 function collectExplicitConstraintDropIds(changes: Change[]) {
   const explicitConstraintDropIds = new Set<string>();
 
@@ -84,6 +153,13 @@ function hasSameEntries(
  * - If replace expansion added `DropTable(T)+CreateTable(T)`, targeted
  *   `AlterTableDropColumn(T.*)` / `AlterTableDropConstraint(T.*)` changes are
  *   redundant and create an unbreakable drop-phase cycle, so we elide them.
+ * - When the same `DropTable+CreateTable` pair is present, the expansion
+ *   also emits one `AlterTableAddConstraint` / `AlterTableValidateConstraint`
+ *   / `CreateCommentOnConstraint` per branch constraint, which may collide
+ *   with the same change already emitted by `diffTables()` (for example on a
+ *   shape flip or a new constraint). We dedupe these keeping only the last
+ *   occurrence so the expansion's emission survives and the diffTables
+ *   duplicate is removed.
  * - If two dropped tables reference each other via FK, we insert dedicated
  *   `AlterTableDropConstraint` changes and teach the paired `DropTable`
  *   changes not to claim those FK stable IDs.
@@ -100,10 +176,15 @@ export function normalizePostDiffCycles({
   mainCatalog: Catalog;
   replacedTableIds?: ReadonlySet<string>;
 }): Change[] {
+  const dedupedChanges = dropReplacedTableDuplicateConstraintChanges(
+    changes,
+    replacedTableIds,
+  );
+
   const structurallyNormalizedChanges =
     replacedTableIds.size === 0
-      ? changes
-      : changes.filter(
+      ? dedupedChanges
+      : dedupedChanges.filter(
           (change) => !isSupersededByTableReplacement(change, replacedTableIds),
         );