@pgpmjs/core 7.1.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

@@ -13,13 +13,15 @@ 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');

package/esm/rebundle/module.js

@@ -1,6 +1,6 @@
 import { copyFileSync, existsSync, mkdirSync, readdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { parsePlanFile } from '../files/plan/parser';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
 import { mergeSqlStatements, packageModule } from '../packaging/package';
 import { generatePlanContent } from '../slice/slice';
 import { assembleChunkSql, rebundlePlan } from './rebundle';

package/esm/rebundle/rebundle.js

@@ -1,9 +1,9 @@
 import { readFileSync } from 'fs';
 import { join } from 'path';
-import { getChanges } from '../files/plan/parser';
+import { getChanges } from '@pgpmjs/ast/files/plan/parser';
 import { resolveWithPlan } from '../resolution/resolve';
 import { buildDependencyGraph, buildPackageDependencies, computeDeployOrder, detectPackageCycle, extractPackageFromPath, } from '../slice/slice';
-import { parsePlanFile } from '../files/plan/parser';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
 /**
  * Derive the boundary key for a change under the given strategy.
  * Consecutive changes sharing a key may be merged into the same chunk.

package/esm/rebundle/workspace.js

@@ -1,7 +1,7 @@
 import { existsSync, readdirSync, readFileSync } from 'fs';
 import { basename, join } from 'path';
 import { DEFAULT_TEMPLATE_REPO, scaffoldTemplate } from '../core/template-scaffold';
-import { parsePlanFile } from '../files/plan/parser';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
 import { mergeSqlStatements } from '../packaging/package';
 import { resolveWithPlan } from '../resolution/resolve';
 import { writeMinimalModule, writeMinimalWorkspace } from '../workspace/minimal';

package/esm/refactor/rename.js

@@ -1,7 +1,10 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmdirSync, statSync, writeFileSync } from 'fs';
 import { dirname, join, relative, sep } from 'path';
-import { parsePlanFileSimple } from '../files/plan/parser';
-import { parsePgpmHeader, renameInHeader, writePgpmScript } from '../files/sql/header';
+import { parsePlanFileSimple } from '@pgpmjs/ast/files/plan/parser';
+import { parsePgpmHeader, renameInHeader, writePgpmScript } from '@pgpmjs/ast/files/sql/header';
+import { renameInPlanContent } from '@pgpmjs/ast/plan-rename';
+// Re-exported from @pgpmjs/ast so existing `@pgpmjs/core` consumers keep importing it here.
+export { renameInPlanContent };
 const SCRIPT_DIRS = ['deploy', 'revert', 'verify'];
 function escapeRe(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -59,31 +62,6 @@ export function validateRenames(moduleDir, renames) {
         targets.add(to);
     }
 }
-/**
- * Rewrite change names in a pgpm.plan's content according to a rename map.
- * Textual and format-preserving: only the change-name token at the start of a
- * change line, plain (same-package) dependency refs inside `[...]`, and tag
- * lines' change field are rewritten; timestamps, planners, comments,
- * cross-package refs, and tag refs are untouched.
- */
-export function renameInPlanContent(content, renames) {
-    const froms = Array.from(renames.keys()).sort((a, b) => b.length - a.length);
-    return content
-        .split('\n')
-        .map(line => {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('%'))
-            return line;
-        let result = line;
-        for (const from of froms) {
-            const to = renames.get(from);
-            const re = new RegExp(`(^|[\\s\\[])${escapeRe(from)}(?=$|[\\s\\]@])`, 'g');
-            result = result.replace(re, `$1${to}`);
-        }
-        return result;
-    })
-        .join('\n');
-}
 /**
  * Atomically rename/move changes within a pgpm module: the coupled 4-way
  * rewrite of (1) deploy/revert/verify script files on disk, (2) the moved

package/esm/resolution/deps.js

@@ -2,8 +2,8 @@ import { readFileSync } from 'fs';
 import { sync as glob } from 'glob';
 import { join, relative } from 'path';
 import { PgpmPackage } from '../core/class/pgpm';
-import { parsePlanFile } from '../files/plan/parser';
-import { scanDeployScript } from '../files/sql/header';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
+import { scanDeployScript } from '@pgpmjs/ast/files/sql/header';
 import { errors } from '@pgpmjs/types';
 /**
  * Core dependency resolution algorithm that handles circular dependency detection

package/esm/resolution/resolve.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'fs';
-import { getChanges, getExtensionName } from '../files';
-import { parsePlanFile } from '../files/plan/parser';
+import { getChanges, getExtensionName } from '@pgpmjs/ast/files';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
 import { resolveDependencies } from './deps';
 import { errors } from '@pgpmjs/types';
 /**

package/esm/slice/slice.js

@@ -1,4 +1,4 @@
-import { parsePlanFile } from '../files/plan/parser';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
 import { minimatch } from 'minimatch';
 /**
  * Build a dependency graph from a parsed plan file