@supabase/pg-delta 1.0.0-alpha.16 → 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/objects/trigger/trigger.diff.js

@@ -44,6 +44,11 @@ export function diffTriggers(main, branch, branchIndexableObjects) {
         if (mainTrigger.is_partition_clone || branchTrigger.is_partition_clone) {
             continue;
         }
+        // Note: column_numbers is excluded because it contains pg_trigger.tgattr
+        // attnums that differ between databases when physical column layouts
+        // diverge but logical (named) columns match. The definition field
+        // (pg_get_triggerdef) already captures the UPDATE OF column list by name,
+        // so we compare by definition instead.
         const NON_ALTERABLE_FIELDS = [
             "function_schema",
             "function_name",
@@ -53,14 +58,14 @@ export function diffTriggers(main, branch, branchIndexableObjects) {
             "deferrable",
             "initially_deferred",
             "argument_count",
-            "column_numbers",
             "arguments",
             "when_condition",
             "old_table",
             "new_table",
             "owner",
+            "definition", // Compare by definition instead of column_numbers (tgattr)
         ];
-        const shouldReplace = hasNonAlterableChanges(mainTrigger, branchTrigger, NON_ALTERABLE_FIELDS, { column_numbers: deepEqual, arguments: deepEqual });
+        const shouldReplace = hasNonAlterableChanges(mainTrigger, branchTrigger, NON_ALTERABLE_FIELDS, { arguments: deepEqual });
         if (shouldReplace) {
             const tableStableId = stableId.table(branchTrigger.schema, branchTrigger.table_name);
             changes.push(new ReplaceTrigger({

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

@@ -83,7 +83,6 @@ export declare class Trigger extends BasePgModel {
         deferrable: boolean;
         initially_deferred: boolean;
         argument_count: number;
-        column_numbers: number[] | null;
         arguments: string[];
         when_condition: string | null;
         old_table: string | null;
@@ -94,6 +93,7 @@ export declare class Trigger extends BasePgModel {
         parent_table_name: string | null;
         is_on_partitioned_table: boolean;
         owner: string;
+        definition: string;
         comment: string | null;
     };
 }

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

@@ -120,7 +120,10 @@ export class Trigger extends BasePgModel {
             deferrable: this.deferrable,
             initially_deferred: this.initially_deferred,
             argument_count: this.argument_count,
-            column_numbers: this.column_numbers,
+            // column_numbers excluded: contains pg_trigger.tgattr attnums that differ
+            // between databases when physical column layouts diverge but logical
+            // (named) columns match. The definition field (pg_get_triggerdef) captures
+            // the UPDATE OF column list by name, so we compare by definition instead.
             arguments: this.arguments,
             when_condition: this.when_condition,
             old_table: this.old_table,
@@ -131,6 +134,7 @@ export class Trigger extends BasePgModel {
             parent_table_name: this.parent_table_name,
             is_on_partitioned_table: this.is_on_partitioned_table,
             owner: this.owner,
+            definition: this.definition,
             comment: this.comment,
         };
     }

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.16",
+  "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;