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

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

@@ -1,6 +1,7 @@
 import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
+import { securityLabelPropsSchema, } from "../security-label.types.js";
 const membershipInfoSchema = z.object({
     member: z.string(),
     grantor: z.string(),
@@ -29,6 +30,7 @@ const rolePropsSchema = z.object({
     comment: z.string().nullable(),
     members: z.array(membershipInfoSchema),
     default_privileges: z.array(defaultPrivilegeSchema),
+    security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
 });
 export class Role extends BasePgModel {
     name;
@@ -44,6 +46,7 @@ export class Role extends BasePgModel {
     comment;
     members;
     default_privileges;
+    security_labels;
     constructor(props) {
         super();
         // Identity fields
@@ -61,6 +64,7 @@ export class Role extends BasePgModel {
         this.comment = props.comment;
         this.members = deduplicateMembers(props.members);
         this.default_privileges = props.default_privileges;
+        this.security_labels = props.security_labels ?? [];
     }
     get stableId() {
         return `role:${this.name}`;
@@ -106,6 +110,7 @@ export class Role extends BasePgModel {
             comment: this.comment,
             members: sortedMembers,
             default_privileges: sortedDefaultPrivs,
+            security_labels: this.security_labels,
         };
     }
 }
@@ -200,6 +205,18 @@ export async function extractRoles(pool) {
             r.rolbypassrls  AS can_bypass_rls,
             r.rolconfig     AS config,
             obj_description(r.oid, 'pg_authid') AS comment,
+            COALESCE(
+              (
+                SELECT json_agg(
+                  json_build_object('provider', sl.provider, 'label', sl.label)
+                  ORDER BY sl.provider
+                )
+                FROM pg_catalog.pg_shseclabel sl
+                WHERE sl.objoid = r.oid
+                  AND sl.classoid = 'pg_authid'::regclass
+              ),
+              '[]'::json
+            ) AS security_labels,
             COALESCE(rm.members, '[]') AS members,
             COALESCE(
               (
@@ -322,6 +339,18 @@ export async function extractRoles(pool) {
             r.rolbypassrls   AS can_bypass_rls,
             r.rolconfig      AS config,
             obj_description(r.oid, 'pg_authid') AS comment,
+            COALESCE(
+              (
+                SELECT json_agg(
+                  json_build_object('provider', sl.provider, 'label', sl.label)
+                  ORDER BY sl.provider
+                )
+                FROM pg_catalog.pg_shseclabel sl
+                WHERE sl.objoid = r.oid
+                  AND sl.classoid = 'pg_authid'::regclass
+              ),
+              '[]'::json
+            ) AS security_labels,
             COALESCE(rm.members, '[]') AS members,
             COALESCE(
               (

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

@@ -1,6 +1,7 @@
 import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
+import { type ExtractRetryOptions } from "../extract-with-retry.ts";
 declare const RuleEnabledStateSchema: z.ZodEnum<{
     O: "O";
     D: "D";
@@ -68,5 +69,5 @@ export declare class Rule extends BasePgModel {
     };
     get relationStableId(): string;
 }
-export declare function extractRules(pool: Pool): Promise<Rule[]>;
+export declare function extractRules(pool: Pool, options?: ExtractRetryOptions): Promise<Rule[]>;
 export {};

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

@@ -1,6 +1,7 @@
 import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
+import { extractWithDefinitionRetry, } from "../extract-with-retry.js";
 import { stableId } from "../utils.js";
 const RuleEventSchema = z.enum(["SELECT", "INSERT", "UPDATE", "DELETE"]);
 const RuleEnabledStateSchema = z.enum(["O", "D", "R", "A"]);
@@ -24,6 +25,14 @@ const rulePropsSchema = z.object({
     comment: z.string().nullable(),
     columns: z.array(z.string()),
 });
+// pg_get_ruledef(oid, pretty) can return NULL when the rule (its pg_rewrite
+// row) is dropped between catalog scan and resolution, or under transient
+// catalog state. An unreadable rule 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 ruleRowSchema = rulePropsSchema.extend({
+    definition: z.string().nullable(),
+});
 export class Rule extends BasePgModel {
     schema;
     name;
@@ -82,8 +91,13 @@ export class Rule extends BasePgModel {
         }
     }
 }
-export async function extractRules(pool) {
-    const { rows: ruleRows } = await pool.query(sql `
+export async function extractRules(pool, options) {
+    const ruleRows = await extractWithDefinitionRetry({
+        label: "rules",
+        options,
+        hasNullDefinition: (row) => row.definition === null,
+        query: async () => {
+            const result = await pool.query(sql `
       WITH extension_rule_oids AS (
         SELECT
           objid
@@ -149,6 +163,9 @@ export async function extractRules(pool) {
       ORDER BY
         1, 3, 2
   `);
-    const validatedRows = ruleRows.map((row) => rulePropsSchema.parse(row));
+            return result.rows.map((row) => ruleRowSchema.parse(row));
+        },
+    });
+    const validatedRows = ruleRows.filter((row) => row.definition !== null);
     return validatedRows.map((row) => new Rule(row));
 }

package/dist/core/objects/schema/changes/schema.base.d.ts

@@ -2,7 +2,7 @@ import { BaseChange } from "../../base.change.ts";
 import type { Schema } from "../schema.model.ts";
 declare abstract class BaseSchemaChange extends BaseChange {
     abstract readonly schema: Schema;
-    abstract readonly scope: "object" | "comment" | "privilege";
+    abstract readonly scope: "object" | "comment" | "privilege" | "security_label";
     readonly objectType: "schema";
 }
 export declare abstract class CreateSchemaChange extends BaseSchemaChange {

package/dist/core/objects/schema/changes/schema.security-label.d.ts

@@ -0,0 +1,28 @@
+import type { SecurityLabelProps } from "../../security-label.types.ts";
+import type { Schema } from "../schema.model.ts";
+import { CreateSchemaChange, DropSchemaChange } from "./schema.base.ts";
+export type SecurityLabelSchema = CreateSecurityLabelOnSchema | DropSecurityLabelOnSchema;
+export declare class CreateSecurityLabelOnSchema extends CreateSchemaChange {
+    readonly schema: Schema;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        schema: Schema;
+        securityLabel: SecurityLabelProps;
+    });
+    get creates(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): `schema:${string}`[];
+    serialize(): string;
+}
+export declare class DropSecurityLabelOnSchema extends DropSchemaChange {
+    readonly schema: Schema;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        schema: Schema;
+        securityLabel: SecurityLabelProps;
+    });
+    get drops(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): (`schema:${string}` | `securityLabel:${string}::provider:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/schema/changes/schema.security-label.js

@@ -0,0 +1,61 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateSchemaChange, DropSchemaChange } from "./schema.base.js";
+export class CreateSecurityLabelOnSchema extends CreateSchemaChange {
+    schema;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+        this.securityLabel = props.securityLabel;
+    }
+    get creates() {
+        return [
+            stableId.securityLabel(this.schema.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [this.schema.stableId];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON SCHEMA",
+            this.schema.name,
+            "IS",
+            quoteLiteral(this.securityLabel.label),
+        ].join(" ");
+    }
+}
+export class DropSecurityLabelOnSchema extends DropSchemaChange {
+    schema;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+        this.securityLabel = props.securityLabel;
+    }
+    get drops() {
+        return [
+            stableId.securityLabel(this.schema.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [
+            stableId.securityLabel(this.schema.stableId, this.securityLabel.provider),
+            this.schema.stableId,
+        ];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON SCHEMA",
+            this.schema.name,
+            "IS NULL",
+        ].join(" ");
+    }
+}

package/dist/core/objects/schema/changes/schema.types.d.ts

@@ -3,5 +3,6 @@ import type { CommentSchema } from "./schema.comment.ts";
 import type { CreateSchema } from "./schema.create.ts";
 import type { DropSchema } from "./schema.drop.ts";
 import type { SchemaPrivilege } from "./schema.privilege.ts";
+import type { SecurityLabelSchema } from "./schema.security-label.ts";
 /** Union of all schema-related change variants (`objectType: "schema"`). @category Change Types */
-export type SchemaChange = AlterSchema | CommentSchema | CreateSchema | DropSchema | SchemaPrivilege;
+export type SchemaChange = AlterSchema | CommentSchema | CreateSchema | DropSchema | SchemaPrivilege | SecurityLabelSchema;

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

@@ -1,10 +1,12 @@
 import { diffObjects } from "../base.diff.js";
 import { diffPrivileges, emitObjectPrivilegeChanges, } from "../base.privilege-diff.js";
+import { diffSecurityLabels } from "../security-label.types.js";
 import { AlterSchemaChangeOwner } from "./changes/schema.alter.js";
 import { CreateCommentOnSchema, DropCommentOnSchema, } from "./changes/schema.comment.js";
 import { CreateSchema } from "./changes/schema.create.js";
 import { DropSchema } from "./changes/schema.drop.js";
 import { GrantSchemaPrivileges, RevokeGrantOptionSchemaPrivileges, RevokeSchemaPrivileges, } from "./changes/schema.privilege.js";
+import { CreateSecurityLabelOnSchema, DropSecurityLabelOnSchema, } from "./changes/schema.security-label.js";
 /**
  * Diff two sets of schemas from main and branch catalogs.
  *
@@ -22,6 +24,12 @@ export function diffSchemas(ctx, main, branch) {
         if (sc.comment !== null) {
             changes.push(new CreateCommentOnSchema({ schema: sc }));
         }
+        for (const label of sc.security_labels) {
+            changes.push(new CreateSecurityLabelOnSchema({
+                schema: sc,
+                securityLabel: label,
+            }));
+        }
         // PRIVILEGES: For created objects, compare against default privileges state
         // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
         // so objects are created with the default privileges state in effect.
@@ -43,7 +51,14 @@ export function diffSchemas(ctx, main, branch) {
         }, ctx.version));
     }
     for (const schemaId of dropped) {
-        changes.push(new DropSchema({ schema: main[schemaId] }));
+        const mainSchema = main[schemaId];
+        for (const label of mainSchema.security_labels) {
+            changes.push(new DropSecurityLabelOnSchema({
+                schema: mainSchema,
+                securityLabel: label,
+            }));
+        }
+        changes.push(new DropSchema({ schema: mainSchema }));
     }
     for (const schemaId of altered) {
         const mainSchema = main[schemaId];
@@ -64,6 +79,14 @@ export function diffSchemas(ctx, main, branch) {
                 changes.push(new CreateCommentOnSchema({ schema: branchSchema }));
             }
         }
+        // SECURITY LABELS
+        changes.push(...diffSecurityLabels(mainSchema.security_labels, branchSchema.security_labels, (securityLabel) => new CreateSecurityLabelOnSchema({
+            schema: branchSchema,
+            securityLabel,
+        }), (securityLabel) => new DropSecurityLabelOnSchema({
+            schema: mainSchema,
+            securityLabel,
+        })));
         // PRIVILEGES
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use branch owner as the reference.

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

@@ -2,6 +2,7 @@ import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
+import { type SecurityLabelProps } from "../security-label.types.ts";
 /**
  * All properties exposed by CREATE SCHEMA statement are included in diff output.
  * https://www.postgresql.org/docs/current/sql-createschema.html
@@ -19,6 +20,10 @@ declare const schemaPropsSchema: z.ZodObject<{
         grantable: z.ZodBoolean;
         columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
     }, z.z.core.$strip>>;
+    security_labels: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        label: z.ZodString;
+    }, z.z.core.$strip>>>>;
 }, z.z.core.$strip>;
 type SchemaPrivilegeProps = PrivilegeProps;
 export type SchemaProps = z.infer<typeof schemaPropsSchema>;
@@ -27,6 +32,7 @@ export declare class Schema extends BasePgModel {
     readonly owner: SchemaProps["owner"];
     readonly comment: SchemaProps["comment"];
     readonly privileges: SchemaPrivilegeProps[];
+    readonly security_labels: SecurityLabelProps[];
     constructor(props: SchemaProps);
     get stableId(): `schema:${string}`;
     get identityFields(): {
@@ -41,6 +47,10 @@ export declare class Schema extends BasePgModel {
             grantable: boolean;
             columns?: string[] | null | undefined;
         }[];
+        security_labels: {
+            provider: string;
+            label: string;
+        }[];
     };
 }
 export declare function extractSchemas(pool: Pool): Promise<Schema[]>;

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

@@ -2,6 +2,7 @@ import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
+import { securityLabelPropsSchema, } from "../security-label.types.js";
 /**
  * All properties exposed by CREATE SCHEMA statement are included in diff output.
  * https://www.postgresql.org/docs/current/sql-createschema.html
@@ -14,12 +15,14 @@ const schemaPropsSchema = z.object({
     owner: z.string(),
     comment: z.string().nullable(),
     privileges: z.array(privilegePropsSchema),
+    security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
 });
 export class Schema extends BasePgModel {
     name;
     owner;
     comment;
     privileges;
+    security_labels;
     constructor(props) {
         super();
         // Identity fields
@@ -28,6 +31,7 @@ export class Schema extends BasePgModel {
         this.owner = props.owner;
         this.comment = props.comment;
         this.privileges = props.privileges;
+        this.security_labels = props.security_labels ?? [];
     }
     get stableId() {
         return `schema:${this.name}`;
@@ -42,6 +46,7 @@ export class Schema extends BasePgModel {
             owner: this.owner,
             comment: this.comment,
             privileges: this.privileges,
+            security_labels: this.security_labels,
         };
     }
 }
@@ -72,7 +77,19 @@ export async function extractSchemas(pool) {
           )
           from lateral aclexplode(COALESCE(nspacl, acldefault('n', nspowner))) as x(grantor, grantee, privilege_type, is_grantable)
         ), '[]'
-      ) as privileges
+      ) as privileges,
+      coalesce(
+        (
+          select json_agg(
+            json_build_object('provider', sl.provider, 'label', sl.label)
+            order by sl.provider
+          )
+          from pg_catalog.pg_seclabel sl
+          where sl.objoid = pg_namespace.oid
+            and sl.classoid = 'pg_namespace'::regclass
+            and sl.objsubid = 0
+        ), '[]'
+      ) as security_labels
     from
       pg_catalog.pg_namespace
       left outer join extension_oids e on e.objid = oid

package/dist/core/objects/security-label.types.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const securityLabelPropsSchema: z.ZodObject<{
+    provider: z.ZodString;
+    label: z.ZodString;
+}, z.core.$strip>;
+export type SecurityLabelProps = z.infer<typeof securityLabelPropsSchema>;
+export declare function normalizeSecurityLabels(labels: readonly SecurityLabelProps[]): SecurityLabelProps[];
+/**
+ * Pure helper: compares two arrays of security labels keyed by provider and
+ * returns a deterministic list of create/drop changes.
+ *
+ * - Labels present only on `branch` → emit create (via makeCreate).
+ * - Labels present only on `main` → emit drop (via makeDrop).
+ * - Labels with differing `label` under the same provider → emit create
+ *   (PostgreSQL's SECURITY LABEL … IS '…' overwrites, so no separate alter).
+ * - Unchanged labels → nothing.
+ *
+ * Output order: by provider ascending.
+ */
+export declare function diffSecurityLabels<C>(main: readonly SecurityLabelProps[], branch: readonly SecurityLabelProps[], makeCreate: (props: SecurityLabelProps) => C, makeDrop: (props: SecurityLabelProps) => C): C[];

package/dist/core/objects/security-label.types.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export const securityLabelPropsSchema = z.object({
+    provider: z.string(),
+    label: z.string(),
+});
+export function normalizeSecurityLabels(labels) {
+    return [...labels].sort((a, b) => a.provider.localeCompare(b.provider));
+}
+/**
+ * Pure helper: compares two arrays of security labels keyed by provider and
+ * returns a deterministic list of create/drop changes.
+ *
+ * - Labels present only on `branch` → emit create (via makeCreate).
+ * - Labels present only on `main` → emit drop (via makeDrop).
+ * - Labels with differing `label` under the same provider → emit create
+ *   (PostgreSQL's SECURITY LABEL … IS '…' overwrites, so no separate alter).
+ * - Unchanged labels → nothing.
+ *
+ * Output order: by provider ascending.
+ */
+export function diffSecurityLabels(main, branch, makeCreate, makeDrop) {
+    const mainByProvider = new Map(main.map((l) => [l.provider, l.label]));
+    const branchByProvider = new Map(branch.map((l) => [l.provider, l.label]));
+    const providers = new Set([
+        ...mainByProvider.keys(),
+        ...branchByProvider.keys(),
+    ]);
+    const sortedProviders = [...providers].sort();
+    const out = [];
+    for (const provider of sortedProviders) {
+        const mainLabel = mainByProvider.get(provider);
+        const branchLabel = branchByProvider.get(provider);
+        if (mainLabel === undefined && branchLabel !== undefined) {
+            out.push(makeCreate({ provider, label: branchLabel }));
+        }
+        else if (mainLabel !== undefined && branchLabel === undefined) {
+            out.push(makeDrop({ provider, label: mainLabel }));
+        }
+        else if (mainLabel !== undefined &&
+            branchLabel !== undefined &&
+            mainLabel !== branchLabel) {
+            out.push(makeCreate({ provider, label: branchLabel }));
+        }
+    }
+    return out;
+}

package/dist/core/objects/sequence/changes/sequence.base.d.ts

@@ -2,7 +2,7 @@ import { BaseChange } from "../../base.change.ts";
 import type { Sequence } from "../sequence.model.ts";
 declare abstract class BaseSequenceChange extends BaseChange {
     abstract readonly sequence: Sequence;
-    abstract readonly scope: "object" | "comment" | "privilege";
+    abstract readonly scope: "object" | "comment" | "privilege" | "security_label";
     readonly objectType: "sequence";
 }
 export declare abstract class CreateSequenceChange extends BaseSequenceChange {

package/dist/core/objects/sequence/changes/sequence.security-label.d.ts

@@ -0,0 +1,28 @@
+import type { SecurityLabelProps } from "../../security-label.types.ts";
+import type { Sequence } from "../sequence.model.ts";
+import { CreateSequenceChange, DropSequenceChange } from "./sequence.base.ts";
+export type SecurityLabelSequence = CreateSecurityLabelOnSequence | DropSecurityLabelOnSequence;
+export declare class CreateSecurityLabelOnSequence extends CreateSequenceChange {
+    readonly sequence: Sequence;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        sequence: Sequence;
+        securityLabel: SecurityLabelProps;
+    });
+    get creates(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): `sequence:${string}`[];
+    serialize(): string;
+}
+export declare class DropSecurityLabelOnSequence extends DropSequenceChange {
+    readonly sequence: Sequence;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        sequence: Sequence;
+        securityLabel: SecurityLabelProps;
+    });
+    get drops(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): (`securityLabel:${string}::provider:${string}` | `sequence:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/sequence/changes/sequence.security-label.js

@@ -0,0 +1,61 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateSequenceChange, DropSequenceChange } from "./sequence.base.js";
+export class CreateSecurityLabelOnSequence extends CreateSequenceChange {
+    sequence;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.sequence = props.sequence;
+        this.securityLabel = props.securityLabel;
+    }
+    get creates() {
+        return [
+            stableId.securityLabel(this.sequence.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [this.sequence.stableId];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON SEQUENCE",
+            `${this.sequence.schema}.${this.sequence.name}`,
+            "IS",
+            quoteLiteral(this.securityLabel.label),
+        ].join(" ");
+    }
+}
+export class DropSecurityLabelOnSequence extends DropSequenceChange {
+    sequence;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.sequence = props.sequence;
+        this.securityLabel = props.securityLabel;
+    }
+    get drops() {
+        return [
+            stableId.securityLabel(this.sequence.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [
+            stableId.securityLabel(this.sequence.stableId, this.securityLabel.provider),
+            this.sequence.stableId,
+        ];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON SEQUENCE",
+            `${this.sequence.schema}.${this.sequence.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

package/dist/core/objects/sequence/changes/sequence.types.d.ts

@@ -3,5 +3,6 @@ import type { CommentSequence } from "./sequence.comment.ts";
 import type { CreateSequence } from "./sequence.create.ts";
 import type { DropSequence } from "./sequence.drop.ts";
 import type { SequencePrivilege } from "./sequence.privilege.ts";
+import type { SecurityLabelSequence } from "./sequence.security-label.ts";
 /** Union of all sequence-related change variants (`objectType: "sequence"`). @category Change Types */
-export type SequenceChange = AlterSequence | CommentSequence | CreateSequence | DropSequence | SequencePrivilege;
+export type SequenceChange = AlterSequence | CommentSequence | CreateSequence | DropSequence | SequencePrivilege | SecurityLabelSequence;

package/dist/core/objects/sequence/sequence.diff.d.ts

@@ -11,7 +11,8 @@ type SequenceOrColumnSetDefaultChange = AlterTableAlterColumnSetDefault | Sequen
  * @param main - The sequences in the main catalog.
  * @param branch - The sequences in the branch catalog.
  * @param branchTables - The tables in the branch catalog (used to check if owning tables are being dropped).
+ * @param mainTables - The tables in the main catalog (used to detect when a same-name sequence will be cascade-dropped because its main-side owning table is going away).
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffSequences(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Sequence>, branch: Record<string, Sequence>, branchTables?: Record<string, Table>): SequenceOrColumnSetDefaultChange[];
+export declare function diffSequences(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Sequence>, branch: Record<string, Sequence>, branchTables?: Record<string, Table>, mainTables?: Record<string, Table>): SequenceOrColumnSetDefaultChange[];
 export {};