@pgpmjs/core 7.0.0 → 7.2.0

package/bundle/apply.d.ts

@@ -0,0 +1,93 @@
+import { PgConfig } from 'pg-env';
+import { PgpmScriptKind } from '@pgpmjs/ast/module/types';
+import { BundleIssue, MigrationBundle } from '@pgpmjs/bundle';
+import { PgpmMigrateOptions } from '../migrate/client';
+import { DeployResult, VerifyResult } from '../migrate/types';
+/** A script whose SQL references something outside the allowed namespace. */
+export interface NamespaceViolation {
+    change: string;
+    kind: PgpmScriptKind;
+    /** Offending references reported by the caller's validator. */
+    references: string[];
+}
+/**
+ * A validator for transpiled bundles: given a script's SQL, return the
+ * references that fall *outside* the target namespace (empty = clean). Core
+ * stays parser-agnostic; the caller (constructive-db) supplies the AST check.
+ */
+export type ReferenceValidator = (sql: string, ctx: {
+    change: string;
+    kind: PgpmScriptKind;
+}) => string[];
+/** Pre-flight analysis of an apply, computed without touching the database. */
+export interface ApplyBundlePreview {
+    name: string;
+    /** Changes in deploy order. */
+    deployOrder: string[];
+    /** Digest/order/integrity problems from {@link verifyBundle}. */
+    bundleIssues: BundleIssue[];
+    /** References outside the target namespace (only when a validator is given). */
+    namespaceViolations: NamespaceViolation[];
+    /** Reverse deploy order — the revert sequence that fully undoes this apply. */
+    rollbackPlan: string[];
+}
+export interface PreviewBundleApplyOptions {
+    validateReferences?: ReferenceValidator;
+}
+/**
+ * Analyze a bundle apply without executing it: verify artifact integrity, run
+ * the optional namespace-reference validator, and derive the rollback plan.
+ * Pure — no database, no disk.
+ */
+export declare function previewBundleApply(bundle: MigrationBundle, options?: PreviewBundleApplyOptions): ApplyBundlePreview;
+export interface ApplyBundleOptions extends PreviewBundleApplyOptions {
+    /** Target database. */
+    config: PgConfig;
+    /** Analyze only; never touch the database. Default false. */
+    dryRun?: boolean;
+    /** Run `verify` after a successful deploy. Default false. */
+    verify?: boolean;
+    /**
+     * Wall-clock budget for the deploy (+ optional verify). On expiry the result
+     * is flagged `timedOut` and a {@link BundleApplyError} is thrown. The apply
+     * runs in a single transaction (see `useTransaction`), so the database rolls
+     * back rather than being left half-applied.
+     */
+    timeoutMs?: number;
+    /** Apply as one atomic transaction so any failure rolls back. Default true. */
+    useTransaction?: boolean;
+    /** Directory to materialize into (default: a temp dir, removed afterward). */
+    workDir?: string;
+    migrateOptions?: PgpmMigrateOptions;
+    /** Apply even if artifact verification fails. Default false (refuse). */
+    allowUnverified?: boolean;
+}
+/** Explicit outcome of an {@link applyBundle} call. */
+export interface ApplyBundleResult {
+    preview: ApplyBundlePreview;
+    dryRun: boolean;
+    /** True when the deploy actually ran against the database. */
+    executed: boolean;
+    deploy?: DeployResult;
+    verify?: VerifyResult;
+    durationMs: number;
+    timedOut: boolean;
+}
+/** Thrown when an apply is refused pre-flight or exceeds its timeout. */
+export declare class BundleApplyError extends Error {
+    readonly preview: ApplyBundlePreview;
+    readonly timedOut: boolean;
+    constructor(message: string, preview: ApplyBundlePreview, timedOut?: boolean);
+}
+/**
+ * Safely apply a {@link MigrationBundle} to a target database.
+ *
+ * A thin, safety-first wrapper over {@link PgpmMigrate}: it gates on artifact
+ * integrity and (optionally) namespace validation, supports a dry run, applies
+ * atomically in a single transaction, enforces a timeout, and returns an
+ * explicit result including the rollback plan.
+ *
+ * The mechanics (materialize → deploy → verify) reuse existing plumbing;
+ * nothing here re-implements deployment.
+ */
+export declare function applyBundle(bundle: MigrationBundle, options: ApplyBundleOptions): Promise<ApplyBundleResult>;

package/bundle/apply.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleApplyError = void 0;
+exports.previewBundleApply = previewBundleApply;
+exports.applyBundle = applyBundle;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const bundle_1 = require("@pgpmjs/bundle");
+const client_1 = require("../migrate/client");
+/**
+ * Analyze a bundle apply without executing it: verify artifact integrity, run
+ * the optional namespace-reference validator, and derive the rollback plan.
+ * Pure — no database, no disk.
+ */
+function previewBundleApply(bundle, options = {}) {
+    const namespaceViolations = [];
+    if (options.validateReferences) {
+        for (const change of bundle.changes) {
+            for (const script of [change.deploy, change.revert, change.verify]) {
+                if (!script)
+                    continue;
+                const references = options.validateReferences(script.sql, {
+                    change: change.name,
+                    kind: script.kind
+                });
+                if (references.length > 0) {
+                    namespaceViolations.push({ change: change.name, kind: script.kind, references });
+                }
+            }
+        }
+    }
+    return {
+        name: bundle.manifest.name,
+        deployOrder: [...bundle.manifest.deployOrder],
+        bundleIssues: (0, bundle_1.verifyBundle)(bundle),
+        namespaceViolations,
+        rollbackPlan: [...bundle.manifest.deployOrder].reverse()
+    };
+}
+/** Thrown when an apply is refused pre-flight or exceeds its timeout. */
+class BundleApplyError extends Error {
+    preview;
+    timedOut;
+    constructor(message, preview, timedOut = false) {
+        super(message);
+        this.preview = preview;
+        this.timedOut = timedOut;
+        this.name = 'BundleApplyError';
+    }
+}
+exports.BundleApplyError = BundleApplyError;
+const TIMEOUT = Symbol('timeout');
+async function withTimeout(work, ms) {
+    if (!ms)
+        return work;
+    let timer;
+    const timeout = new Promise(resolve => {
+        timer = setTimeout(() => resolve(TIMEOUT), ms);
+    });
+    try {
+        return await Promise.race([work, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Safely apply a {@link MigrationBundle} to a target database.
+ *
+ * A thin, safety-first wrapper over {@link PgpmMigrate}: it gates on artifact
+ * integrity and (optionally) namespace validation, supports a dry run, applies
+ * atomically in a single transaction, enforces a timeout, and returns an
+ * explicit result including the rollback plan.
+ *
+ * The mechanics (materialize → deploy → verify) reuse existing plumbing;
+ * nothing here re-implements deployment.
+ */
+async function applyBundle(bundle, options) {
+    const started = Date.now();
+    const preview = previewBundleApply(bundle, options);
+    if (!options.allowUnverified && preview.bundleIssues.length > 0) {
+        throw new BundleApplyError(`Refusing to apply "${preview.name}": bundle failed integrity verification ` +
+            `(${preview.bundleIssues.length} issue(s): ${preview.bundleIssues.map(i => i.kind).join(', ')})`, preview);
+    }
+    if (preview.namespaceViolations.length > 0) {
+        throw new BundleApplyError(`Refusing to apply "${preview.name}": ${preview.namespaceViolations.length} ` +
+            `reference(s) fall outside the target namespace`, preview);
+    }
+    if (options.dryRun) {
+        return {
+            preview,
+            dryRun: true,
+            executed: false,
+            durationMs: Date.now() - started,
+            timedOut: false
+        };
+    }
+    const ownWorkDir = options.workDir === undefined;
+    const workDir = options.workDir ?? (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'pgpm-apply-'));
+    (0, bundle_1.materializeBundle)(bundle, workDir);
+    const migrate = new client_1.PgpmMigrate(options.config, options.migrateOptions);
+    const useTransaction = options.useTransaction ?? true;
+    try {
+        const run = (async () => {
+            const deploy = await migrate.deploy({ modulePath: workDir, useTransaction });
+            let verify;
+            if (options.verify) {
+                verify = await migrate.verify({ modulePath: workDir });
+            }
+            return { deploy, verify };
+        })();
+        const outcome = await withTimeout(run, options.timeoutMs);
+        if (outcome === TIMEOUT) {
+            throw new BundleApplyError(`Apply of "${preview.name}" exceeded ${options.timeoutMs}ms`, preview, true);
+        }
+        return {
+            preview,
+            dryRun: false,
+            executed: true,
+            deploy: outcome.deploy,
+            verify: outcome.verify,
+            durationMs: Date.now() - started,
+            timedOut: false
+        };
+    }
+    finally {
+        if (ownWorkDir) {
+            try {
+                (0, fs_1.rmSync)(workDir, { recursive: true, force: true });
+            }
+            catch {
+                // best-effort cleanup
+            }
+        }
+    }
+}

package/bundle/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * pgpm migration bundles: the portable, content-addressed artifact layer.
+ *
+ * A {@link MigrationBundle} is a deterministic snapshot of a pgpm module — plan,
+ * control, ordered changes, and per-change/whole-bundle sha256 digests — with an
+ * optional provenance manifest. It is the substrate for the `exportMigrationBundle`
+ * / `applyMigrationBundle` / `transpileMigrationBundle` cloud functions: build one
+ * from a module AST, transport or transform it, verify its digests, then
+ * materialize it back into a deployable module.
+ */
+export * from '@pgpmjs/bundle';
+export * from './apply';

package/bundle/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * pgpm migration bundles: the portable, content-addressed artifact layer.
+ *
+ * A {@link MigrationBundle} is a deterministic snapshot of a pgpm module — plan,
+ * control, ordered changes, and per-change/whole-bundle sha256 digests — with an
+ * optional provenance manifest. It is the substrate for the `exportMigrationBundle`
+ * / `applyMigrationBundle` / `transpileMigrationBundle` cloud functions: build one
+ * from a module AST, transport or transform it, verify its digests, then
+ * materialize it back into a deployable module.
+ */
+// Pure artifact layer moved to @pgpmjs/bundle; re-exported here so existing
+// `@pgpmjs/core` consumers keep importing the whole bundle surface unchanged.
+__exportStar(require("@pgpmjs/bundle"), exports);
+// applyBundle stays in core: it drives PgpmMigrate (the deploy engine).
+__exportStar(require("./apply"), exports);

package/core/class/pgpm.d.ts

@@ -1,7 +1,7 @@
 import { PgpmOptions, PgpmWorkspaceConfig } from '@pgpmjs/types';
 import { PgConfig } from 'pg-env';
-import { ExtensionInfo } from '../../files';
-import { PackageAnalysisResult, RenameOptions } from '../../files/types';
+import { ExtensionInfo } from '@pgpmjs/ast/files';
+import { PackageAnalysisResult, RenameOptions } from '@pgpmjs/ast/files/types';
 import { ModuleMap } from '../../modules/modules';
 export declare enum PackageContext {
     Outside = "outside",

package/core/class/pgpm.js

@@ -49,12 +49,12 @@ const path_1 = __importStar(require("path"));
 const pg_cache_1 = require("pg-cache");
 const yanse_1 = __importDefault(require("yanse"));
 const extensions_1 = require("../../extensions/extensions");
-const files_1 = require("../../files");
-const files_2 = require("../../files");
-const writer_1 = require("../../files/extension/writer");
-const generator_1 = require("../../files/plan/generator");
-const parser_1 = require("../../files/plan/parser");
-const validators_1 = require("../../files/plan/validators");
+const files_1 = require("@pgpmjs/ast/files");
+const files_2 = require("@pgpmjs/ast/files");
+const writer_1 = require("@pgpmjs/ast/files/extension/writer");
+const generator_1 = require("@pgpmjs/ast/files/plan/generator");
+const parser_1 = require("@pgpmjs/ast/files/plan/parser");
+const validators_1 = require("@pgpmjs/ast/files/plan/validators");
 const client_1 = require("../../migrate/client");
 const modules_1 = require("../../modules/modules");
 const package_1 = require("../../packaging/package");

package/esm/bundle/apply.js

@@ -0,0 +1,131 @@
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { materializeBundle, verifyBundle } from '@pgpmjs/bundle';
+import { PgpmMigrate } from '../migrate/client';
+/**
+ * Analyze a bundle apply without executing it: verify artifact integrity, run
+ * the optional namespace-reference validator, and derive the rollback plan.
+ * Pure — no database, no disk.
+ */
+export function previewBundleApply(bundle, options = {}) {
+    const namespaceViolations = [];
+    if (options.validateReferences) {
+        for (const change of bundle.changes) {
+            for (const script of [change.deploy, change.revert, change.verify]) {
+                if (!script)
+                    continue;
+                const references = options.validateReferences(script.sql, {
+                    change: change.name,
+                    kind: script.kind
+                });
+                if (references.length > 0) {
+                    namespaceViolations.push({ change: change.name, kind: script.kind, references });
+                }
+            }
+        }
+    }
+    return {
+        name: bundle.manifest.name,
+        deployOrder: [...bundle.manifest.deployOrder],
+        bundleIssues: verifyBundle(bundle),
+        namespaceViolations,
+        rollbackPlan: [...bundle.manifest.deployOrder].reverse()
+    };
+}
+/** Thrown when an apply is refused pre-flight or exceeds its timeout. */
+export class BundleApplyError extends Error {
+    preview;
+    timedOut;
+    constructor(message, preview, timedOut = false) {
+        super(message);
+        this.preview = preview;
+        this.timedOut = timedOut;
+        this.name = 'BundleApplyError';
+    }
+}
+const TIMEOUT = Symbol('timeout');
+async function withTimeout(work, ms) {
+    if (!ms)
+        return work;
+    let timer;
+    const timeout = new Promise(resolve => {
+        timer = setTimeout(() => resolve(TIMEOUT), ms);
+    });
+    try {
+        return await Promise.race([work, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Safely apply a {@link MigrationBundle} to a target database.
+ *
+ * A thin, safety-first wrapper over {@link PgpmMigrate}: it gates on artifact
+ * integrity and (optionally) namespace validation, supports a dry run, applies
+ * atomically in a single transaction, enforces a timeout, and returns an
+ * explicit result including the rollback plan.
+ *
+ * The mechanics (materialize → deploy → verify) reuse existing plumbing;
+ * nothing here re-implements deployment.
+ */
+export async function applyBundle(bundle, options) {
+    const started = Date.now();
+    const preview = previewBundleApply(bundle, options);
+    if (!options.allowUnverified && preview.bundleIssues.length > 0) {
+        throw new BundleApplyError(`Refusing to apply "${preview.name}": bundle failed integrity verification ` +
+            `(${preview.bundleIssues.length} issue(s): ${preview.bundleIssues.map(i => i.kind).join(', ')})`, preview);
+    }
+    if (preview.namespaceViolations.length > 0) {
+        throw new BundleApplyError(`Refusing to apply "${preview.name}": ${preview.namespaceViolations.length} ` +
+            `reference(s) fall outside the target namespace`, preview);
+    }
+    if (options.dryRun) {
+        return {
+            preview,
+            dryRun: true,
+            executed: false,
+            durationMs: Date.now() - started,
+            timedOut: false
+        };
+    }
+    const ownWorkDir = options.workDir === undefined;
+    const workDir = options.workDir ?? mkdtempSync(join(tmpdir(), 'pgpm-apply-'));
+    materializeBundle(bundle, workDir);
+    const migrate = new PgpmMigrate(options.config, options.migrateOptions);
+    const useTransaction = options.useTransaction ?? true;
+    try {
+        const run = (async () => {
+            const deploy = await migrate.deploy({ modulePath: workDir, useTransaction });
+            let verify;
+            if (options.verify) {
+                verify = await migrate.verify({ modulePath: workDir });
+            }
+            return { deploy, verify };
+        })();
+        const outcome = await withTimeout(run, options.timeoutMs);
+        if (outcome === TIMEOUT) {
+            throw new BundleApplyError(`Apply of "${preview.name}" exceeded ${options.timeoutMs}ms`, preview, true);
+        }
+        return {
+            preview,
+            dryRun: false,
+            executed: true,
+            deploy: outcome.deploy,
+            verify: outcome.verify,
+            durationMs: Date.now() - started,
+            timedOut: false
+        };
+    }
+    finally {
+        if (ownWorkDir) {
+            try {
+                rmSync(workDir, { recursive: true, force: true });
+            }
+            catch {
+                // best-effort cleanup
+            }
+        }
+    }
+}

package/esm/bundle/index.js

@@ -0,0 +1,15 @@
+/**
+ * pgpm migration bundles: the portable, content-addressed artifact layer.
+ *
+ * A {@link MigrationBundle} is a deterministic snapshot of a pgpm module — plan,
+ * control, ordered changes, and per-change/whole-bundle sha256 digests — with an
+ * optional provenance manifest. It is the substrate for the `exportMigrationBundle`
+ * / `applyMigrationBundle` / `transpileMigrationBundle` cloud functions: build one
+ * from a module AST, transport or transform it, verify its digests, then
+ * materialize it back into a deployable module.
+ */
+// Pure artifact layer moved to @pgpmjs/bundle; re-exported here so existing
+// `@pgpmjs/core` consumers keep importing the whole bundle surface unchanged.
+export * from '@pgpmjs/bundle';
+// applyBundle stays in core: it drives PgpmMigrate (the deploy engine).
+export * from './apply';

package/esm/core/class/pgpm.js

@@ -10,12 +10,12 @@ import path, { dirname, resolve } from 'path';
 import { getPgPool } from 'pg-cache';
 import yanse from 'yanse';
 import { getAvailableExtensions } from '../../extensions/extensions';
-import { generatePlan, writePlan, writePlanFile } from '../../files';
-import { getExtensionInfo, getExtensionName, getInstalledExtensions, parseControlFile, writeExtensions } from '../../files';
-import { generateControlFileContent, writeExtensionMakefile } from '../../files/extension/writer';
-import { getNow as getPlanTimestamp } from '../../files/plan/generator';
-import { parsePlanFile } from '../../files/plan/parser';
-import { isValidChangeName, isValidTagName, parseReference } from '../../files/plan/validators';
+import { generatePlan, writePlan, writePlanFile } from '@pgpmjs/ast/files';
+import { getExtensionInfo, getExtensionName, getInstalledExtensions, parseControlFile, writeExtensions } from '@pgpmjs/ast/files';
+import { generateControlFileContent, writeExtensionMakefile } from '@pgpmjs/ast/files/extension/writer';
+import { getNow as getPlanTimestamp } from '@pgpmjs/ast/files/plan/generator';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
+import { isValidChangeName, isValidTagName, parseReference } from '@pgpmjs/ast/files/plan/validators';
 import { PgpmMigrate } from '../../migrate/client';
 import { getExtensionsAndModules, getExtensionsAndModulesChanges, latestChange, latestChangeAndVersion } from '../../modules/modules';
 import { packageModule } from '../../packaging/package';

package/esm/index.js

@@ -1,5 +1,6 @@
 export * from './core/class/pgpm';
 export * from './slice';
+export * from './rebundle';
 export * from './extensions/extensions';
 export * from './modules/modules';
 export * from './packaging/package';
@@ -8,16 +9,19 @@ export * from './resolution/deps';
 export * from './resolution/resolve';
 export * from './workspace/paths';
 export * from './workspace/utils';
+export * from './workspace/minimal';
 export * from './core/template-scaffold';
 export * from './core/boilerplate-types';
 export * from './core/boilerplate-scanner';
-// Export package-files functionality (now integrated into core)
-export * from './files';
+// Re-export the module AST layer (moved to the @pgpmjs/ast leaf package)
+export * from '@pgpmjs/ast/files';
+export * from '@pgpmjs/ast/module';
+export * from './bundle';
 export * from './refactor';
 export { cleanSql } from './migrate/clean';
 export { PgpmMigrate } from './migrate/client';
 export { PgpmInit } from './init/client';
 export * from './roles';
-export { parseAuthor } from './utils/author';
+export { parseAuthor } from '@pgpmjs/ast';
 export { hashFile, hashString } from './migrate/utils/hash';
 export { executeQuery, withTransaction } from './migrate/utils/transaction';

package/esm/migrate/client.js

@@ -3,7 +3,7 @@ import { errors, extractPgErrorFields, formatPgError, formatPgErrorFields } from
 import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { getPgPool } from 'pg-cache';
-import { parsePlanFile, parsePlanFileSimple, readScript } from '../files';
+import { parsePlanFile, parsePlanFileSimple, readScript } from '@pgpmjs/ast/files';
 import { resolveDependencies } from '../resolution/deps';
 import { resolveTagToChangeName } from '../resolution/resolve';
 import { cleanSql } from './clean';

package/esm/migrate/utils/hash.js

@@ -1,7 +1,10 @@
+import { hashString } from '@pgpmjs/ast';
 import { createHash } from 'crypto';
 import { readFile } from 'fs/promises';
 import { parse } from 'pgsql-parser';
 import { cleanTree } from '../../packaging/package';
+// Re-exported from @pgpmjs/ast so existing `@pgpmjs/core` consumers keep importing it here.
+export { hashString };
 /**
  * Generate SHA256 hash of a file's contents
  */
@@ -9,12 +12,6 @@ export async function hashFile(filePath) {
     const content = await readFile(filePath, 'utf-8');
     return createHash('sha256').update(content).digest('hex');
 }
-/**
- * Generate SHA256 hash of a string
- */
-export function hashString(content) {
-    return createHash('sha256').update(content).digest('hex');
-}
 /**
  * Generate SHA256 hash of a SQL file's parsed and cleaned AST
  */

package/esm/modules/modules.js

@@ -1,4 +1,4 @@
-import { getLatestChange } from '../files';
+import { getLatestChange } from '@pgpmjs/ast/files';
 import { errors } from '@pgpmjs/types';
 /**
  * Mapping from control file names (used in extensions list) to npm package names.

package/esm/packaging/package.js

@@ -3,7 +3,7 @@ import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { relative } from 'path';
 import { deparse } from 'pgsql-deparser';
 import { parse } from 'pgsql-parser';
-import { getExtensionName } from '../files';
+import { getExtensionName } from '@pgpmjs/ast/files';
 import { resolve, resolveWithPlan } from '../resolution/resolve';
 import { transformProps } from './transform';
 const log = new Logger('package');
@@ -15,8 +15,8 @@ export const cleanTree = (tree) => {
         location: noop,
     });
 };
-const filterStatements = (stmts, extension) => {
-    if (!extension)
+const filterStatements = (stmts, stripTransactions) => {
+    if (!stripTransactions)
         return stmts;
     return stmts.filter(node => {
         const stmt = node.stmt;
@@ -24,7 +24,39 @@ const filterStatements = (stmts, extension) => {
             !stmt.hasOwnProperty('CreateExtensionStmt');
     });
 };
-export const packageModule = async (packageDir, { usePlan = true, extension = true, pretty = true, functionDelimiter = '$EOFCODE$', outputDiff = false } = {}) => {
+/**
+ * Merge a concatenated SQL string into a single deparsed script.
+ *
+ * Parses the input, optionally strips transaction/extension statements, deparses
+ * with a stable function delimiter, and round-trips the result to detect any AST
+ * drift. This is the shared engine behind `packageModule` (whole-module packaging)
+ * and per-chunk rebundling — both must merge statements identically.
+ */
+export const mergeSqlStatements = async (sql, { stripTransactions = false, echoExtensionName, pretty = true, functionDelimiter = '$EOFCODE$' } = {}) => {
+    if (!sql?.trim()) {
+        return { sql: '' };
+    }
+    const parsed = await parse(sql);
+    parsed.stmts = filterStatements(parsed.stmts, stripTransactions);
+    const topLine = echoExtensionName
+        ? `\\echo Use "CREATE EXTENSION ${echoExtensionName}" to load this file. \\quit\n`
+        : '';
+    const finalSql = await deparse(parsed, { pretty, functionDelimiter });
+    const tree1 = parsed.stmts;
+    const reparsed = await parse(finalSql);
+    const tree2 = filterStatements(reparsed.stmts, stripTransactions);
+    const results = {
+        sql: `${topLine}${finalSql}`,
+    };
+    const diff = JSON.stringify(cleanTree(tree1)) !== JSON.stringify(cleanTree(tree2));
+    if (diff) {
+        results.diff = true;
+        results.tree1 = JSON.stringify(cleanTree(tree1), null, 2);
+        results.tree2 = JSON.stringify(cleanTree(tree2), null, 2);
+    }
+    return results;
+};
+export const packageModule = async (packageDir, { usePlan = true, extension = true, pretty = true, functionDelimiter = '$EOFCODE$' } = {}) => {
     const resolveFn = usePlan ? resolveWithPlan : resolve;
     const sql = resolveFn(packageDir);
     if (!sql?.trim()) {
@@ -33,28 +65,12 @@ export const packageModule = async (packageDir, { usePlan = true, extension = tr
     }
     const extname = getExtensionName(packageDir);
     try {
-        const parsed = await parse(sql);
-        parsed.stmts = filterStatements(parsed.stmts, extension);
-        const topLine = extension
-            ? `\\echo Use "CREATE EXTENSION ${extname}" to load this file. \\quit\n`
-            : '';
-        const finalSql = await deparse(parsed, {
+        return await mergeSqlStatements(sql, {
+            stripTransactions: extension,
+            echoExtensionName: extension ? extname : undefined,
             pretty,
-            functionDelimiter
+            functionDelimiter,
         });
-        const tree1 = parsed.stmts;
-        const reparsed = await parse(finalSql);
-        const tree2 = filterStatements(reparsed.stmts, extension);
-        const results = {
-            sql: `${topLine}${finalSql}`,
-        };
-        const diff = JSON.stringify(cleanTree(tree1)) !== JSON.stringify(cleanTree(tree2));
-        if (diff) {
-            results.diff = true;
-            results.tree1 = JSON.stringify(cleanTree(tree1), null, 2);
-            results.tree2 = JSON.stringify(cleanTree(tree2), null, 2);
-        }
-        return results;
     }
     catch (e) {
         log.error(`❌ Failed to parse SQL for ${packageDir}`);

package/esm/rebundle/index.js

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './rebundle';
+export * from './module';
+export * from './workspace';