@pgsql/transform 18.1.0 → 18.3.0

package/facts.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A (possibly schema-qualified) object name extracted from a statement.
+ */
+export interface QualifiedName {
+    schema: string | null;
+    name: string;
+}
+/**
+ * Coarse statement classification used for tier/package sorting.
+ */
+export type StatementKind = 'schema' | 'table' | 'view' | 'index' | 'type' | 'function' | 'trigger' | 'policy' | 'grant' | 'rls_enable' | 'fk_constraint' | 'constraint' | 'comment' | 'seed_dml' | 'other';
+/**
+ * AST-derived facts about a single top-level SQL statement.
+ *
+ * Read-only: classification never modifies the statement. Facts are the
+ * substrate for classifier-driven slicing (schema / functionality / security
+ * tiers) — replacing path/name-glob decisions with computed properties like
+ * "this trigger function references billing".
+ */
+export interface StatementFacts {
+    /** Coarse category of the statement. */
+    kind: StatementKind;
+    /** The raw parser node tag (e.g. `CreateStmt`, `CreatePolicyStmt`). */
+    nodeTag: string;
+    /** Objects this statement creates or directly targets. */
+    creates: QualifiedName[];
+    /**
+     * Schema-qualified objects this statement references — tables, functions
+     * and types reached anywhere in the statement, including PL/pgSQL bodies.
+     * Unqualified references are omitted (they resolve via search_path and
+     * carry no cross-schema information).
+     */
+    references: QualifiedName[];
+    /**
+     * The subset of `references` reached only inside a PL/pgSQL body. These
+     * are late-binding: Postgres resolves them at call time, not at CREATE
+     * time, so they do not constrain deploy order (and legitimately form
+     * recursion cycles between functions).
+     */
+    bodyReferences: QualifiedName[];
+    /** Distinct schemas reached by `references`. */
+    referencedSchemas: string[];
+    /** Role names granted to, owning, or bound by this statement. */
+    roles: string[];
+    /** Foreign-key target tables (from column/table FK constraints). */
+    fkTargets: QualifiedName[];
+    /**
+     * Whether the statement is part of the security surface: policies, grants,
+     * RLS enable/force, security labels, ownership.
+     */
+    securityRelevant: boolean;
+    /** For functions: declared with SECURITY DEFINER. */
+    securityDefiner: boolean;
+    /**
+     * For functions: the body executes dynamic SQL (EXECUTE / EXECUTE ... USING
+     * / FOR ... IN EXECUTE). Analogous to `eval` — references inside the
+     * dynamic string are invisible to the AST, so edges from this statement
+     * are incomplete and slicing should treat it conservatively.
+     */
+    dynamicSql: boolean;
+}
+/**
+ * Classify each top-level statement in a SQL script into {@link StatementFacts}.
+ *
+ * Uses the same parser stack as the schema transformer (pgsql AST walk plus
+ * hydrated PL/pgSQL body walk), so references inside function bodies are
+ * included. The input SQL is never modified.
+ */
+export declare function classifyStatements(sql: string): StatementFacts[];

package/facts.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyStatements = classifyStatements;
+const traverse_1 = require("@pgsql/traverse");
+const plpgsql_parser_1 = require("plpgsql-parser");
+const SECURITY_TAGS = new Set([
+    'CreatePolicyStmt',
+    'AlterPolicyStmt',
+    'GrantStmt',
+    'GrantRoleStmt',
+    'AlterDefaultPrivilegesStmt',
+    'SecLabelStmt',
+    'AlterOwnerStmt',
+    'CreateRoleStmt',
+    'AlterRoleStmt'
+]);
+const KIND_BY_TAG = {
+    CreateSchemaStmt: 'schema',
+    CreateStmt: 'table',
+    ViewStmt: 'view',
+    IndexStmt: 'index',
+    CompositeTypeStmt: 'type',
+    CreateEnumStmt: 'type',
+    CreateDomainStmt: 'type',
+    CreateRangeStmt: 'type',
+    DefineStmt: 'type',
+    CreateFunctionStmt: 'function',
+    CreateTrigStmt: 'trigger',
+    CreateEventTrigStmt: 'trigger',
+    CreatePolicyStmt: 'policy',
+    AlterPolicyStmt: 'policy',
+    GrantStmt: 'grant',
+    GrantRoleStmt: 'grant',
+    AlterDefaultPrivilegesStmt: 'grant',
+    CommentStmt: 'comment',
+    InsertStmt: 'seed_dml',
+    UpdateStmt: 'seed_dml',
+    DeleteStmt: 'seed_dml'
+};
+function qn(schema, name) {
+    return { schema: schema ?? null, name };
+}
+function nameListToQualified(names) {
+    if (!Array.isArray(names) || names.length === 0)
+        return null;
+    const parts = names
+        .map((n) => n?.String?.sval)
+        .filter((s) => typeof s === 'string');
+    if (parts.length === 0)
+        return null;
+    if (parts.length === 1)
+        return qn(null, parts[0]);
+    return qn(parts[parts.length - 2], parts[parts.length - 1]);
+}
+function isCatalogSchema(schema) {
+    return schema === 'pg_catalog' || schema === 'information_schema';
+}
+function pushRef(refs, ref) {
+    if (!ref || !ref.schema || isCatalogSchema(ref.schema))
+        return;
+    if (refs.some(r => r.schema === ref.schema && r.name === ref.name))
+        return;
+    refs.push(ref);
+}
+function collectRoles(node, roles) {
+    const push = (role) => {
+        if (typeof role === 'string' && role.length > 0 && !roles.includes(role)) {
+            roles.push(role);
+        }
+    };
+    if (Array.isArray(node?.grantees)) {
+        for (const g of node.grantees)
+            push(g?.RoleSpec?.rolename);
+    }
+    if (Array.isArray(node?.roles)) {
+        for (const r of node.roles)
+            push(r?.RoleSpec?.rolename);
+    }
+    push(node?.newowner?.rolename);
+    push(node?.role?.rolename);
+}
+/**
+ * Create a read-only visitor that accumulates references, roles and FK
+ * targets into the provided facts object.
+ */
+function createFactsVisitor(facts, bodyRefs) {
+    const push = (ref) => {
+        pushRef(facts.references, ref);
+        if (bodyRefs)
+            pushRef(bodyRefs, ref);
+    };
+    return {
+        RangeVar: (path) => {
+            const node = path.node;
+            if (node.schemaname) {
+                push(qn(node.schemaname, node.relname));
+            }
+        },
+        FuncCall: (path) => {
+            push(nameListToQualified(path.node.funcname));
+        },
+        TypeName: (path) => {
+            push(nameListToQualified(path.node.names));
+        },
+        ColumnRef: (path) => {
+            // schema.table.column references carry cross-schema information
+            const fields = path.node.fields;
+            if (Array.isArray(fields) && fields.length >= 3) {
+                const parts = fields
+                    .map((f) => f?.String?.sval)
+                    .filter((s) => typeof s === 'string');
+                if (parts.length >= 3) {
+                    push(qn(parts[0], parts[1]));
+                }
+            }
+        },
+        Constraint: (path) => {
+            const node = path.node;
+            if (node.contype === 'CONSTR_FOREIGN' && node.pktable) {
+                const target = qn(node.pktable.schemaname ?? null, node.pktable.relname);
+                if (!facts.fkTargets.some(t => t.schema === target.schema && t.name === target.name)) {
+                    facts.fkTargets.push(target);
+                }
+                if (target.schema)
+                    pushRef(facts.references, target);
+            }
+        }
+    };
+}
+function classifyOne(nodeTag, node) {
+    const facts = {
+        kind: KIND_BY_TAG[nodeTag] ?? 'other',
+        nodeTag,
+        creates: [],
+        references: [],
+        referencedSchemas: [],
+        roles: [],
+        fkTargets: [],
+        bodyReferences: [],
+        securityRelevant: SECURITY_TAGS.has(nodeTag),
+        securityDefiner: false,
+        dynamicSql: false
+    };
+    switch (nodeTag) {
+        case 'CreateSchemaStmt':
+            facts.creates.push(qn(null, node.schemaname));
+            break;
+        case 'CreateStmt':
+        case 'ViewStmt': {
+            const rel = nodeTag === 'ViewStmt' ? node.view : node.relation;
+            if (rel)
+                facts.creates.push(qn(rel.schemaname ?? null, rel.relname));
+            break;
+        }
+        case 'IndexStmt':
+            if (node.relation) {
+                facts.creates.push(qn(node.relation.schemaname ?? null, node.idxname ?? node.relation.relname));
+            }
+            break;
+        case 'CreateFunctionStmt': {
+            const name = nameListToQualified(node.funcname);
+            if (name)
+                facts.creates.push(name);
+            for (const opt of node.options ?? []) {
+                const def = opt?.DefElem;
+                if (def?.defname === 'security' && def?.arg?.Boolean?.boolval === true) {
+                    facts.securityDefiner = true;
+                }
+            }
+            break;
+        }
+        case 'CreateTrigStmt':
+            if (node.relation) {
+                // Trigger names are only unique per table; qualify with the table.
+                facts.creates.push(qn(node.relation.schemaname ?? null, `${node.relation.relname}.${node.trigname}`));
+            }
+            pushRef(facts.references, nameListToQualified(node.funcname));
+            break;
+        case 'CreatePolicyStmt':
+        case 'AlterPolicyStmt':
+            if (node.table) {
+                // Policy names are only unique per table; qualify with the table.
+                facts.creates.push(qn(node.table.schemaname ?? null, `${node.table.relname}.${node.policy_name}`));
+                // The guarded table lives on `node.table`; the generic RangeVar walker
+                // does not descend into it, so capture the reference explicitly.
+                if (node.table.schemaname) {
+                    pushRef(facts.references, qn(node.table.schemaname, node.table.relname));
+                }
+            }
+            break;
+        case 'CreateSeqStmt':
+            if (node.sequence) {
+                facts.creates.push(qn(node.sequence.schemaname ?? null, node.sequence.relname));
+            }
+            break;
+        case 'CompositeTypeStmt':
+            if (node.typevar) {
+                facts.creates.push(qn(node.typevar.schemaname ?? null, node.typevar.relname));
+            }
+            break;
+        case 'CreateEnumStmt':
+        case 'CreateDomainStmt':
+        case 'CreateRangeStmt': {
+            const name = nameListToQualified(node.typeName ?? node.domainname);
+            if (name)
+                facts.creates.push(name);
+            break;
+        }
+        case 'AlterTableStmt': {
+            if (node.relation) {
+                facts.creates.push(qn(node.relation.schemaname ?? null, node.relation.relname));
+            }
+            const cmds = node.cmds ?? [];
+            for (const cmd of cmds) {
+                const subtype = cmd?.AlterTableCmd?.subtype;
+                if (subtype === 'AT_EnableRowSecurity' || subtype === 'AT_ForceRowSecurity' ||
+                    subtype === 'AT_DisableRowSecurity' || subtype === 'AT_NoForceRowSecurity') {
+                    facts.kind = 'rls_enable';
+                    facts.securityRelevant = true;
+                }
+                else if (subtype === 'AT_AddConstraint') {
+                    const contype = cmd?.AlterTableCmd?.def?.Constraint?.contype;
+                    facts.kind = contype === 'CONSTR_FOREIGN' ? 'fk_constraint' : 'constraint';
+                }
+                else if (subtype === 'AT_ChangeOwner') {
+                    facts.securityRelevant = true;
+                    const owner = cmd?.AlterTableCmd?.newowner?.rolename;
+                    if (owner && !facts.roles.includes(owner))
+                        facts.roles.push(owner);
+                }
+            }
+            break;
+        }
+        case 'InsertStmt':
+        case 'UpdateStmt':
+        case 'DeleteStmt':
+            if (node.relation) {
+                facts.creates.push(qn(node.relation.schemaname ?? null, node.relation.relname));
+            }
+            break;
+        default:
+            break;
+    }
+    collectRoles(node, facts.roles);
+    return facts;
+}
+/**
+ * Classify each top-level statement in a SQL script into {@link StatementFacts}.
+ *
+ * Uses the same parser stack as the schema transformer (pgsql AST walk plus
+ * hydrated PL/pgSQL body walk), so references inside function bodies are
+ * included. The input SQL is never modified.
+ */
+function classifyStatements(sql) {
+    const allFacts = [];
+    (0, plpgsql_parser_1.transformSync)(sql, (ctx) => {
+        const stmts = ctx.sql?.stmts ?? [];
+        for (const stmt of stmts) {
+            const stmtNode = stmt?.stmt;
+            const nodeTag = stmtNode ? Object.keys(stmtNode)[0] : 'other';
+            const node = stmtNode?.[nodeTag] ?? {};
+            const facts = classifyOne(nodeTag, node);
+            if (stmtNode) {
+                (0, traverse_1.walk)(stmtNode, createFactsVisitor(facts));
+            }
+            allFacts.push(facts);
+        }
+        for (const fn of ctx.functions ?? []) {
+            const facts = allFacts[fn.stmtIndex];
+            if (!facts || !fn.plpgsql?.hydrated)
+                continue;
+            // Refs already found outside the body (signature types, defaults)
+            // constrain deploy order and are not body-only.
+            const outer = new Set(facts.references.map(r => `${r.schema ?? '?'}.${r.name}`));
+            (0, plpgsql_parser_1.walk)(fn.plpgsql.hydrated, {
+                PLpgSQL_stmt_dynexecute: () => { facts.dynamicSql = true; },
+                PLpgSQL_stmt_dynfors: () => { facts.dynamicSql = true; }
+            }, {
+                walkSqlExpressions: true,
+                sqlVisitor: createFactsVisitor(facts, facts.bodyReferences)
+            });
+            facts.bodyReferences = facts.bodyReferences.filter(r => !outer.has(`${r.schema ?? '?'}.${r.name}`));
+        }
+    }, { hydrate: true });
+    for (const facts of allFacts) {
+        const selfRef = (r) => facts.creates.some(c => c.schema === r.schema && c.name === r.name);
+        facts.references = facts.references.filter(r => !selfRef(r));
+        facts.bodyReferences = facts.bodyReferences.filter(r => !selfRef(r));
+        facts.referencedSchemas = [...new Set(facts.references.map(r => r.schema).filter(Boolean))];
+    }
+    return allFacts;
+}

package/fixture-closure.d.ts

@@ -0,0 +1,71 @@
+import { CategoryProfile, ChangeCategory } from './categorize';
+import { QualifiedName } from './facts';
+/**
+ * A change plus its deploy SQL. Optional plan `dependencies` (from `pgpm.plan`)
+ * are followed as authoritative prerequisites in addition to AST-derived edges.
+ */
+export interface ClosureInputChange {
+    name: string;
+    sql: string;
+    dependencies?: string[];
+}
+/** Why a change ended up in the closure. */
+export type ClosureReason = 'selected' | 'prerequisite' | 'fixture';
+/**
+ * A change included in the closure, with its category and the reason it was pulled.
+ */
+export interface ClosureChange {
+    name: string;
+    category: ChangeCategory;
+    reason: ClosureReason;
+}
+/**
+ * The fixture closure of a schema slice.
+ *
+ * Everything the selected changes need to actually *work*: schema/functionality
+ * prerequisites they depend on, plus the fixtures that attach to them (policies,
+ * grants, RLS enables, role bindings, seed rows / SPRT-style support changes).
+ * References that nothing in the input produces are surfaced in `unresolved`
+ * rather than silently dropped.
+ */
+export interface FixtureClosure {
+    /** Full closure (selection + prerequisites + fixtures) in input/plan order. */
+    order: string[];
+    /** Per-change detail in the same order as {@link order}. */
+    changes: ClosureChange[];
+    /** Closure members categorized as security/fixtures (attached fixtures). */
+    fixtures: string[];
+    /** Non-selected schema/functionality members pulled in as prerequisites. */
+    prerequisites: string[];
+    /** Roles required across the closure. */
+    roles: string[];
+    /** Requirements no input change produces — explicit, never dropped. */
+    unresolved: {
+        objects: QualifiedName[];
+        schemas: string[];
+        roles: string[];
+    };
+}
+export interface ResolveFixtureClosureOptions {
+    /** Category profile used to label changes (default {@link TIER_PROFILE}). */
+    profile?: CategoryProfile;
+    /**
+     * When false, do not follow AST references from selected changes to their
+     * schema/functionality producers (only pull attached fixtures + plan deps).
+     * Default true.
+     */
+    includePrerequisites?: boolean;
+}
+/**
+ * Resolve the fixture closure of a schema slice.
+ *
+ * Pure and deterministic — no I/O — and runs to a fixpoint in both directions:
+ *   - forward: a selected change pulls in the producers of the objects/schemas/
+ *     roles it references, plus its declared plan dependencies (prerequisites);
+ *   - reverse: any fixture (security/fixtures-tier change) that attaches to an
+ *     object already in the closure is pulled in (attached fixtures), and then
+ *     resolved for its own prerequisites.
+ *
+ * Output order follows the input (plan) order, so it stays deploy-safe.
+ */
+export declare function resolveFixtureClosure(allChanges: ClosureInputChange[], selection: string[], options?: ResolveFixtureClosureOptions): FixtureClosure;

package/fixture-closure.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFixtureClosure = resolveFixtureClosure;
+const categorize_1 = require("./categorize");
+const facts_1 = require("./facts");
+function objectKey(schema, name) {
+    return `${schema ?? ''}\u0000${name}`;
+}
+function analyze(change, profile) {
+    const facts = (0, facts_1.classifyStatements)(change.sql);
+    const category = profile.categorize(facts, change.name);
+    const creates = [];
+    const createsSchemas = [];
+    const createsRoles = [];
+    const needsObjects = [];
+    const needsSchemas = new Set();
+    const needsRoles = new Set();
+    for (const f of facts) {
+        for (const c of f.creates) {
+            if (f.kind === 'schema')
+                createsSchemas.push(c.name);
+            else {
+                creates.push(c);
+                if (c.schema)
+                    needsSchemas.add(c.schema);
+            }
+        }
+        if (f.nodeTag === 'CreateRoleStmt')
+            createsRoles.push(...f.roles);
+        for (const r of [...f.references, ...f.fkTargets]) {
+            if (r.schema)
+                needsObjects.push(r);
+        }
+        for (const s of f.referencedSchemas)
+            needsSchemas.add(s);
+    }
+    const created = new Set(createsRoles);
+    for (const f of facts) {
+        if (f.nodeTag === 'CreateRoleStmt')
+            continue;
+        for (const role of f.roles)
+            if (!created.has(role))
+                needsRoles.add(role);
+    }
+    for (const s of createsSchemas)
+        needsSchemas.delete(s);
+    return {
+        name: change.name,
+        category,
+        facts,
+        dependencies: change.dependencies ?? [],
+        creates,
+        createsSchemas,
+        createsRoles,
+        needsObjects,
+        needsSchemas: [...needsSchemas],
+        needsRoles: [...needsRoles],
+        isFixture: category === 'security' || category === 'fixtures'
+    };
+}
+/**
+ * Resolve the fixture closure of a schema slice.
+ *
+ * Pure and deterministic — no I/O — and runs to a fixpoint in both directions:
+ *   - forward: a selected change pulls in the producers of the objects/schemas/
+ *     roles it references, plus its declared plan dependencies (prerequisites);
+ *   - reverse: any fixture (security/fixtures-tier change) that attaches to an
+ *     object already in the closure is pulled in (attached fixtures), and then
+ *     resolved for its own prerequisites.
+ *
+ * Output order follows the input (plan) order, so it stays deploy-safe.
+ */
+function resolveFixtureClosure(allChanges, selection, options = {}) {
+    const profile = options.profile ?? categorize_1.TIER_PROFILE;
+    const includePrerequisites = options.includePrerequisites ?? true;
+    const analyses = allChanges.map(c => analyze(c, profile));
+    const byName = new Map(analyses.map(a => [a.name, a]));
+    const producerByObject = new Map();
+    const producerBySchema = new Map();
+    const producerByRole = new Map();
+    for (const a of analyses) {
+        for (const c of a.creates) {
+            const key = objectKey(c.schema, c.name);
+            if (!producerByObject.has(key))
+                producerByObject.set(key, a.name);
+        }
+        for (const s of a.createsSchemas) {
+            if (!producerBySchema.has(s))
+                producerBySchema.set(s, a.name);
+        }
+        for (const r of a.createsRoles) {
+            if (!producerByRole.has(r))
+                producerByRole.set(r, a.name);
+        }
+    }
+    const reason = new Map();
+    for (const name of selection) {
+        if (byName.has(name))
+            reason.set(name, 'selected');
+    }
+    const producedObjectKeys = new Set();
+    const producedSchemas = new Set();
+    const refreshProduced = () => {
+        producedObjectKeys.clear();
+        producedSchemas.clear();
+        for (const name of reason.keys()) {
+            const a = byName.get(name);
+            for (const c of a.creates)
+                producedObjectKeys.add(objectKey(c.schema, c.name));
+            for (const s of a.createsSchemas)
+                producedSchemas.add(s);
+        }
+    };
+    let changed = true;
+    while (changed) {
+        changed = false;
+        // forward: pull producers of what current members need
+        for (const name of [...reason.keys()]) {
+            const a = byName.get(name);
+            const pull = (producer, r) => {
+                if (!producer || reason.has(producer))
+                    return;
+                const pa = byName.get(producer);
+                reason.set(producer, pa.isFixture ? 'fixture' : r);
+                changed = true;
+            };
+            for (const dep of a.dependencies) {
+                pull(byName.has(dep) ? dep : undefined, 'prerequisite');
+            }
+            if (!includePrerequisites)
+                continue;
+            for (const o of a.needsObjects)
+                pull(producerByObject.get(objectKey(o.schema, o.name)), 'prerequisite');
+            for (const s of a.needsSchemas)
+                pull(producerBySchema.get(s), 'prerequisite');
+            for (const role of a.needsRoles)
+                pull(producerByRole.get(role), 'prerequisite');
+        }
+        // reverse: pull attached fixtures that target current members
+        refreshProduced();
+        for (const a of analyses) {
+            if (reason.has(a.name) || !a.isFixture)
+                continue;
+            const objectAttaches = a.needsObjects.some(o => producedObjectKeys.has(objectKey(o.schema, o.name))) ||
+                a.creates.some(c => producedObjectKeys.has(objectKey(c.schema, c.name)));
+            // Schema-scoped fixtures (e.g. ALTER DEFAULT PRIVILEGES IN SCHEMA x) name no
+            // specific object; attach them by schema. Object-scoped fixtures attach only
+            // via their object refs, so a shared schema does not drag in every fixture.
+            const schemaScoped = a.needsObjects.length === 0 && a.creates.length === 0;
+            const schemaAttaches = schemaScoped &&
+                (a.needsSchemas.some(s => producedSchemas.has(s)) ||
+                    a.createsSchemas.some(s => producedSchemas.has(s)));
+            if (objectAttaches || schemaAttaches) {
+                reason.set(a.name, 'fixture');
+                changed = true;
+            }
+        }
+    }
+    const order = analyses.filter(a => reason.has(a.name)).map(a => a.name);
+    const changes = order.map(name => {
+        const a = byName.get(name);
+        return { name, category: a.category, reason: reason.get(name) };
+    });
+    const roles = new Set();
+    const unresolvedObjects = [];
+    const unresolvedObjectKeys = new Set();
+    const unresolvedSchemas = new Set();
+    const unresolvedRoles = new Set();
+    for (const name of order) {
+        const a = byName.get(name);
+        for (const role of a.needsRoles) {
+            roles.add(role);
+            if (!producerByRole.has(role))
+                unresolvedRoles.add(role);
+        }
+        for (const o of a.needsObjects) {
+            const key = objectKey(o.schema, o.name);
+            if (!producerByObject.has(key) && !unresolvedObjectKeys.has(key)) {
+                unresolvedObjectKeys.add(key);
+                unresolvedObjects.push(o);
+            }
+        }
+        for (const s of a.needsSchemas) {
+            if (!producerBySchema.has(s))
+                unresolvedSchemas.add(s);
+        }
+    }
+    return {
+        order,
+        changes,
+        fixtures: changes.filter(c => c.reason === 'fixture').map(c => c.name),
+        prerequisites: changes.filter(c => c.reason === 'prerequisite').map(c => c.name),
+        roles: [...roles],
+        unresolved: {
+            objects: unresolvedObjects,
+            schemas: [...unresolvedSchemas],
+            roles: [...unresolvedRoles]
+        }
+    };
+}

package/index.d.ts

@@ -1,28 +1,14 @@
-import { Node as PG13Node } from './13/types';
-import { Node as PG14Node } from './14/types';
-import { Node as PG15Node } from './15/types';
-import { Node as PG16Node } from './16/types';
-import { Node as PG17Node } from './17/types';
-import { Node as PG18Node } from './18/types';
-import * as PG13Types from './13/types';
-import * as PG14Types from './14/types';
-import * as PG15Types from './15/types';
-import * as PG16Types from './16/types';
-import * as PG17Types from './17/types';
-import * as PG18Types from './18/types';
-export { ASTTransformer } from './multi-version-transformer';
-export { V13ToV14Transformer } from './transformers/v13-to-v14';
-export { V14ToV15Transformer } from './transformers/v14-to-v15';
-export { V15ToV16Transformer } from './transformers/v15-to-v16';
-export { V16ToV17Transformer } from './transformers/v16-to-v17';
-export { V17ToV18Transformer } from './transformers/v17-to-v18';
-export { PG13ToPG17Transformer } from './transformers-direct/v13-to-v17';
-export { PG14ToPG17Transformer } from './transformers-direct/v14-to-v17';
-export { PG15ToPG17Transformer } from './transformers-direct/v15-to-v17';
-export { PG16ToPG17Transformer } from './transformers-direct/v16-to-v17';
-export { PG13ToPG18Transformer } from './transformers-direct/v13-to-v18';
-export { PG14ToPG18Transformer } from './transformers-direct/v14-to-v18';
-export { PG15ToPG18Transformer } from './transformers-direct/v15-to-v18';
-export { PG16ToPG18Transformer } from './transformers-direct/v16-to-v18';
-export { PG17ToPG18Transformer } from './transformers-direct/v17-to-v18';
-export { PG13Node, PG14Node, PG15Node, PG16Node, PG17Node, PG18Node, PG13Types, PG14Types, PG15Types, PG16Types, PG17Types, PG18Types };
+export type { CategoryProfile, ChangeCategory, } from './categorize';
+export { buildCategoryOf, categorizeChange, TIER_PROFILE, } from './categorize';
+export type { QualifiedName, StatementFacts, StatementKind, } from './facts';
+export { classifyStatements } from './facts';
+export type { ClosureChange, ClosureInputChange, ClosureReason, FixtureClosure, ResolveFixtureClosureOptions, } from './fixture-closure';
+export { resolveFixtureClosure } from './fixture-closure';
+export type { ObjectInventory, QualifyResult, QualifyRoutes, QualifyTargetSelector, QualifyUnqualifiedOptions, } from './qualify';
+export { collectCreatedObjects, createQualifyVisitor, mergeInventories, qualifyUnqualified, } from './qualify';
+export type { CapturedAsts } from './round-trip';
+export { captureAstsFromSql, captureTransformAsts, firstDifference, normalizeParseTree, validateRoundTrip, } from './round-trip';
+export type { NormalizeTreeOptions } from './round-trip-core';
+export { CLEAN_TREE_VOLATILE_KEYS, cleanTree, normalizeTree, trimDefElemBody, } from './round-trip-core';
+export type { SchemaTransformPass, SchemaTransformResult, TransformSqlOptions, } from './transform';
+export { createPlpgsqlVisitor, createSqlVisitor, escapeRegexp, extractPgpmHeader, shouldTransformSchema, transformComments, transformJsonStringValues, transformNameList, transformPlpgsqlTypeAst, transformPlpgsqlTypeString, transformRelation, transformSchemaName, transformSql, transformSqlStatement, transformVerifyCalls, validateNoUntransformedSchemas, walkPlpgsqlForSchemas, } from './transform';