@pgpmjs/core 7.2.1 → 7.3.0

package/README.md

@@ -22,6 +22,28 @@ pgpm Core is the main package for pgpm, providing tools for database migrations,
 - Reading and writing SQL scripts
 - Resolving dependencies between migrations
 
+## Migration bundles and envelopes
+
+`@pgpmjs/core` is the deployment half of the portable artifact layer defined in
+`@pgpmjs/bundle` (the pure layer: `MigrationBundle` — a content-addressed snapshot of a
+pgpm module — and `BundleEnvelope` — the versioned shipping container wrapping a schema
+bundle plus data/fixtures SQL parts):
+
+- `applyBundle(bundle, { config, dryRun?, verify?, timeoutMs?, validateReferences? })` —
+  safety-first apply of a `MigrationBundle` via `PgpmMigrate`: artifact-integrity and
+  optional namespace gating, dry-run preview, atomic single-transaction deploy,
+  timeout, and an explicit result including the rollback plan.
+- `applyEnvelope(envelope, { config, dryRun?, verifyParts?, transformPartSql?, ... })` —
+  the generic `applyMigrationBundle` primitive: digest-gates the whole envelope
+  (`verifyEnvelope`), applies the schema via `applyBundle`, then replays each data and
+  fixtures part's deploy SQL in manifest order inside one transaction (a failing part
+  rolls back all part data; the schema stays applied). `previewEnvelopeApply` gives the
+  pure pre-flight: envelope issues, part replay order, and a layered rollback plan.
+  `transformPartSql` is the seam for pre-apply rewriting of part SQL (e.g.
+  deterministic ID remap).
+
+See `pgpm/bundle/README.md` and the `pgpm-migration-bundle` skill for the artifact model.
+
 ## Configuration
 
 ### Error Output Configuration

package/bundle/apply-envelope.d.ts

@@ -0,0 +1,101 @@
+import { BundleEnvelope, EnvelopeIssue, EnvelopePartKind } from '@pgpmjs/bundle';
+import { ApplyBundleOptions, ApplyBundlePreview, ApplyBundleResult, PreviewBundleApplyOptions } from './apply';
+/** One data/fixtures part in the envelope's replay order. */
+export interface EnvelopePartRef {
+    kind: Exclude<EnvelopePartKind, 'schema'>;
+    name: string;
+}
+/** Pre-flight analysis of an envelope apply, computed without touching the database. */
+export interface EnvelopeApplyPreview {
+    name: string;
+    version: string;
+    envelopeDigest: string;
+    /** Digest/inventory/tamper problems from `verifyEnvelope`. */
+    envelopeIssues: EnvelopeIssue[];
+    /** The schema bundle's own pre-flight (integrity, namespace, order, rollback). */
+    schema: ApplyBundlePreview;
+    /** Data then fixtures parts, in manifest replay order. */
+    partOrder: EnvelopePartRef[];
+    /**
+     * How to undo this apply: part reverts in reverse replay order (parts
+     * without a revert script are flagged), then the schema rollback plan.
+     */
+    rollbackPlan: {
+        parts: (EnvelopePartRef & {
+            hasRevert: boolean;
+        })[];
+        schema: string[];
+    };
+}
+/**
+ * Analyze an envelope apply without executing it: verify the envelope's
+ * digest chain (including the schema bundle), run the schema pre-flight, and
+ * derive replay order + rollback plan. Pure — no database, no disk.
+ */
+export declare function previewEnvelopeApply(envelope: BundleEnvelope, options?: PreviewBundleApplyOptions): EnvelopeApplyPreview;
+/** Context handed to {@link EnvelopeApplyOptions.transformPartSql}. */
+export interface PartSqlContext {
+    kind: Exclude<EnvelopePartKind, 'schema'>;
+    name: string;
+    script: 'deploy' | 'verify';
+}
+/** Status/rollback metadata for one replayed part. */
+export interface EnvelopePartResult {
+    kind: Exclude<EnvelopePartKind, 'schema'>;
+    name: string;
+    /** True when the part's deploy SQL ran against the database. */
+    executed: boolean;
+    /** Set only when `verifyParts` is enabled and the part has a verify script. */
+    verified?: boolean;
+    durationMs: number;
+}
+export interface EnvelopeApplyOptions extends ApplyBundleOptions {
+    /** Run each part's verify script after its deploy. Default false. */
+    verifyParts?: boolean;
+    /**
+     * Seam for pre-apply rewriting of part SQL (e.g. deterministic ID remap).
+     * Applied to deploy and verify scripts just before execution; identity when
+     * omitted. Never sees schema-bundle SQL.
+     */
+    transformPartSql?: (sql: string, ctx: PartSqlContext) => string;
+}
+/** Explicit outcome of an {@link applyEnvelope} call. */
+export interface EnvelopeApplyResult {
+    preview: EnvelopeApplyPreview;
+    dryRun: boolean;
+    /** True when anything ran against the database. */
+    executed: boolean;
+    /** The schema half's own result (undefined on dry-run). */
+    schema?: ApplyBundleResult;
+    /** Per-part status metadata, in replay order (parts reached so far). */
+    parts: EnvelopePartResult[];
+    durationMs: number;
+    timedOut: boolean;
+}
+/** Thrown when an envelope apply is refused pre-flight or fails mid-replay. */
+export declare class EnvelopeApplyError extends Error {
+    readonly preview: EnvelopeApplyPreview;
+    /** Parts completed before the failure (for status recording). */
+    readonly parts: EnvelopePartResult[];
+    readonly timedOut: boolean;
+    constructor(message: string, preview: EnvelopeApplyPreview, 
+    /** Parts completed before the failure (for status recording). */
+    parts?: EnvelopePartResult[], timedOut?: boolean);
+}
+/**
+ * Apply a {@link BundleEnvelope} into a target database: the generic
+ * `applyMigrationBundle` primitive.
+ *
+ * Order of operations:
+ * 1. Pre-flight: {@link previewEnvelopeApply} — refuse on any envelope digest
+ *    issue unless `allowUnverified` (schema-bundle integrity and namespace
+ *    gating are then enforced again by {@link applyBundle}).
+ * 2. Schema: {@link applyBundle} on `envelope.schema` (atomic transaction,
+ *    timeout, dry-run all handled there).
+ * 3. Parts: replay each data then fixtures part's deploy SQL in manifest
+ *    order, inside a single transaction so a failing part rolls back all part
+ *    data (the schema stays applied; the preview's rollback plan describes the
+ *    full undo). Optional per-part verify. The `transformPartSql` seam runs
+ *    just before execution.
+ */
+export declare function applyEnvelope(envelope: BundleEnvelope, options: EnvelopeApplyOptions): Promise<EnvelopeApplyResult>;

package/bundle/apply-envelope.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvelopeApplyError = void 0;
+exports.previewEnvelopeApply = previewEnvelopeApply;
+exports.applyEnvelope = applyEnvelope;
+const pg_cache_1 = require("pg-cache");
+const bundle_1 = require("@pgpmjs/bundle");
+const apply_1 = require("./apply");
+/**
+ * Analyze an envelope apply without executing it: verify the envelope's
+ * digest chain (including the schema bundle), run the schema pre-flight, and
+ * derive replay order + rollback plan. Pure — no database, no disk.
+ */
+function previewEnvelopeApply(envelope, options = {}) {
+    const { issues } = (0, bundle_1.verifyEnvelope)(envelope);
+    const parts = [
+        ...envelope.data.map(part => ({ kind: 'data', name: part.name, part })),
+        ...envelope.fixtures.map(part => ({ kind: 'fixtures', name: part.name, part }))
+    ];
+    const schema = (0, apply_1.previewBundleApply)(envelope.schema, options);
+    return {
+        name: envelope.manifest.name,
+        version: envelope.manifest.version,
+        envelopeDigest: envelope.manifest.digest,
+        envelopeIssues: issues,
+        schema,
+        partOrder: parts.map(({ kind, name }) => ({ kind, name })),
+        rollbackPlan: {
+            parts: [...parts]
+                .reverse()
+                .map(({ kind, name, part }) => ({ kind, name, hasRevert: part.revert !== null })),
+            schema: schema.rollbackPlan
+        }
+    };
+}
+/** Thrown when an envelope apply is refused pre-flight or fails mid-replay. */
+class EnvelopeApplyError extends Error {
+    preview;
+    parts;
+    timedOut;
+    constructor(message, preview, 
+    /** Parts completed before the failure (for status recording). */
+    parts = [], timedOut = false) {
+        super(message);
+        this.preview = preview;
+        this.parts = parts;
+        this.timedOut = timedOut;
+        this.name = 'EnvelopeApplyError';
+    }
+}
+exports.EnvelopeApplyError = EnvelopeApplyError;
+/**
+ * Apply a {@link BundleEnvelope} into a target database: the generic
+ * `applyMigrationBundle` primitive.
+ *
+ * Order of operations:
+ * 1. Pre-flight: {@link previewEnvelopeApply} — refuse on any envelope digest
+ *    issue unless `allowUnverified` (schema-bundle integrity and namespace
+ *    gating are then enforced again by {@link applyBundle}).
+ * 2. Schema: {@link applyBundle} on `envelope.schema` (atomic transaction,
+ *    timeout, dry-run all handled there).
+ * 3. Parts: replay each data then fixtures part's deploy SQL in manifest
+ *    order, inside a single transaction so a failing part rolls back all part
+ *    data (the schema stays applied; the preview's rollback plan describes the
+ *    full undo). Optional per-part verify. The `transformPartSql` seam runs
+ *    just before execution.
+ */
+async function applyEnvelope(envelope, options) {
+    const started = Date.now();
+    const preview = previewEnvelopeApply(envelope, options);
+    if (!options.allowUnverified && preview.envelopeIssues.length > 0) {
+        throw new EnvelopeApplyError(`Refusing to apply envelope "${preview.name}@${preview.version}": failed integrity ` +
+            `verification (${preview.envelopeIssues.length} issue(s): ` +
+            `${preview.envelopeIssues.map(i => i.kind).join(', ')})`, preview);
+    }
+    if (options.dryRun) {
+        return {
+            preview,
+            dryRun: true,
+            executed: false,
+            parts: [],
+            durationMs: Date.now() - started,
+            timedOut: false
+        };
+    }
+    const schema = await (0, apply_1.applyBundle)(envelope.schema, options);
+    const transform = options.transformPartSql ?? ((sql) => sql);
+    const orderedParts = [
+        ...envelope.data.map(part => ({ kind: 'data', name: part.name, part })),
+        ...envelope.fixtures.map(part => ({ kind: 'fixtures', name: part.name, part }))
+    ];
+    const parts = [];
+    if (orderedParts.length > 0) {
+        const pool = (0, pg_cache_1.getPgPool)(options.config);
+        const client = await pool.connect();
+        try {
+            await client.query('BEGIN');
+            for (const { kind, name, part } of orderedParts) {
+                const partStarted = Date.now();
+                try {
+                    await client.query(transform(part.deploy, { kind, name, script: 'deploy' }));
+                    const result = {
+                        kind,
+                        name,
+                        executed: true,
+                        durationMs: Date.now() - partStarted
+                    };
+                    if (options.verifyParts && part.verify !== null) {
+                        await client.query(transform(part.verify, { kind, name, script: 'verify' }));
+                        result.verified = true;
+                    }
+                    parts.push(result);
+                }
+                catch (e) {
+                    await client.query('ROLLBACK');
+                    throw new EnvelopeApplyError(`Part ${kind}/${name} of envelope "${preview.name}@${preview.version}" failed: ` +
+                        `${e instanceof Error ? e.message : String(e)} — all part data rolled back ` +
+                        `(schema remains applied; see preview.rollbackPlan)`, preview, parts);
+                }
+            }
+            await client.query('COMMIT');
+        }
+        finally {
+            client.release();
+        }
+    }
+    return {
+        preview,
+        dryRun: false,
+        executed: true,
+        schema,
+        parts,
+        durationMs: Date.now() - started,
+        timedOut: schema.timedOut
+    };
+}

package/bundle/index.d.ts

@@ -10,3 +10,4 @@
  */
 export * from '@pgpmjs/bundle';
 export * from './apply';
+export * from './apply-envelope';

package/bundle/index.js

@@ -29,3 +29,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("@pgpmjs/bundle"), exports);
 // applyBundle stays in core: it drives PgpmMigrate (the deploy engine).
 __exportStar(require("./apply"), exports);
+// applyEnvelope: schema apply + data/fixtures part replay for a BundleEnvelope.
+__exportStar(require("./apply-envelope"), exports);

package/core/class/pgpm.d.ts

@@ -3,6 +3,17 @@ import { PgConfig } from 'pg-env';
 import { ExtensionInfo } from '@pgpmjs/ast/files';
 import { PackageAnalysisResult, RenameOptions } from '@pgpmjs/ast/files/types';
 import { ModuleMap } from '../../modules/modules';
+/**
+ * Options accepted by the {@link PgpmPackage} constructor.
+ */
+export interface PgpmPackageOptions {
+    /**
+     * Directory (relative to the workspace root) where pgpm modules are installed.
+     * Takes precedence over `PGPM_EXTENSIONS_DIR` and the `extensionsDir` config
+     * field. Defaults to `extensions`.
+     */
+    extensionsDir?: string;
+}
 export declare enum PackageContext {
     Outside = "outside",
     Workspace = "workspace-root",
@@ -49,10 +60,21 @@ export declare class PgpmPackage {
     config?: PgpmWorkspaceConfig;
     allowedDirs: string[];
     allowedParentDirs: string[];
+    /**
+     * Directory name (relative to the workspace root) where pgpm modules are installed.
+     * Resolved from the constructor option, `PGPM_EXTENSIONS_DIR`, the `extensionsDir`
+     * config field, then the `extensions` default.
+     */
+    extensionsDir: string;
+    private readonly options;
     private _moduleMap?;
     private _moduleInfo?;
-    constructor(cwd?: string);
+    constructor(cwd?: string, options?: PgpmPackageOptions);
     resetCwd(cwd: string): void;
+    /**
+     * Absolute path of the workspace directory where pgpm modules are installed.
+     */
+    getExtensionsPath(): string;
     private resolveSqitchPath;
     private loadConfigSync;
     private loadAllowedDirs;

package/core/class/pgpm.js

@@ -59,14 +59,11 @@ const client_1 = require("../../migrate/client");
 const modules_1 = require("../../modules/modules");
 const package_1 = require("../../packaging/package");
 const deps_1 = require("../../resolution/deps");
+const fs_2 = require("../../utils/fs");
+const glob_1 = require("../../utils/glob");
 const target_utils_1 = require("../../utils/target-utils");
 const template_scaffold_1 = require("../template-scaffold");
 const logger = new logger_1.Logger('pgpm');
-/**
- * Directory name for workspace extensions.
- * Extensions are installed globally in the workspace's extensions/ directory.
- */
-const EXTENSIONS_DIR = 'extensions';
 function sortObjectByKey(obj) {
     return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
 }
@@ -102,21 +99,37 @@ class PgpmPackage {
     config;
     allowedDirs = [];
     allowedParentDirs = [];
+    /**
+     * Directory name (relative to the workspace root) where pgpm modules are installed.
+     * Resolved from the constructor option, `PGPM_EXTENSIONS_DIR`, the `extensionsDir`
+     * config field, then the `extensions` default.
+     */
+    extensionsDir = types_1.DEFAULT_EXTENSIONS_DIR;
+    options;
     _moduleMap;
     _moduleInfo;
-    constructor(cwd = process.cwd()) {
+    constructor(cwd = process.cwd(), options = {}) {
+        this.options = options;
         this.resetCwd(cwd);
     }
     resetCwd(cwd) {
         this.cwd = cwd;
         this.workspacePath = (0, env_1.resolvePgpmPath)(this.cwd);
         this.modulePath = this.resolveSqitchPath();
+        this.extensionsDir = (0, env_1.getExtensionsDir)(this.options.extensionsDir, this.workspacePath ?? this.cwd);
         if (this.workspacePath) {
             this.config = this.loadConfigSync();
             this.allowedDirs = this.loadAllowedDirs();
             this.allowedParentDirs = this.loadAllowedParentDirs();
         }
     }
+    /**
+     * Absolute path of the workspace directory where pgpm modules are installed.
+     */
+    getExtensionsPath() {
+        this.ensureWorkspace();
+        return path_1.default.join(this.workspacePath, this.extensionsDir);
+    }
     resolveSqitchPath() {
         try {
             return (0, env_1.walkUp)(this.cwd, 'pgpm.plan');
@@ -130,7 +143,7 @@ class PgpmPackage {
     }
     loadAllowedDirs() {
         const globs = this.config?.packages ?? [];
-        const dirs = globs.flatMap(pattern => glob.sync(path_1.default.join(this.workspacePath, pattern)));
+        const dirs = globs.flatMap(pattern => (0, glob_1.globPaths)(this.workspacePath, pattern));
         const resolvedDirs = dirs.map(dir => path_1.default.resolve(dir));
         // Remove duplicates by converting to Set and back to array
         return [...new Set(resolvedDirs.sort((a, b) => a.localeCompare(b)))];
@@ -222,7 +235,7 @@ class PgpmPackage {
         const dirs = this.loadAllowedDirs();
         const results = [];
         for (const dir of dirs) {
-            const proj = new PgpmPackage(dir);
+            const proj = new PgpmPackage(dir, this.options);
             if (proj.isInModule()) {
                 results.push(proj);
             }
@@ -242,9 +255,9 @@ class PgpmPackage {
         // nested workspaces (e.g. test fixtures) out of the module map.
         const packageDirs = [
             ...this.allowedDirs,
-            ...glob.sync(path_1.default.join(this.workspacePath, EXTENSIONS_DIR, '{*,@*/*}'))
+            ...(0, glob_1.globPaths)(this.workspacePath, this.extensionsDir, '{*,@*/*}')
         ];
-        const moduleFiles = [...new Set(packageDirs.flatMap(dir => glob.sync(`${dir}/**/*.control`)))].filter((file) => !/node_modules/.test(file)).sort((a, b) => a.localeCompare(b));
+        const moduleFiles = [...new Set(packageDirs.flatMap(dir => glob.sync((0, glob_1.globPattern)(dir, '**/*.control'))))].filter((file) => !/node_modules/.test(file)).sort((a, b) => a.localeCompare(b));
         // Group files by module name to handle collisions
         const filesByName = new Map();
         moduleFiles.forEach((file) => {
@@ -295,7 +308,7 @@ class PgpmPackage {
             throw types_1.errors.MODULE_NOT_FOUND({ name });
         }
         const modulePath = path_1.default.resolve(this.workspacePath, modules[name].path);
-        return new PgpmPackage(modulePath);
+        return new PgpmPackage(modulePath, this.options);
     }
     // ──────────────── Module-scoped ────────────────
     getModuleInfo() {
@@ -810,7 +823,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
         this.ensureWorkspace();
         const inModule = this.isInModule();
         const originalDir = process.cwd();
-        const skitchExtDir = path_1.default.join(this.workspacePath, EXTENSIONS_DIR);
+        const skitchExtDir = this.getExtensionsPath();
         let pkgJsonPath;
         let pkgData;
         if (inModule) {
@@ -828,27 +841,27 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
             const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'pgpm-install-'));
             try {
                 process.chdir(tempDir);
-                (0, child_process_1.execSync)(`npm install ${pkgstr} --production --prefix ./extensions`, {
+                (0, child_process_1.execSync)(`npm install ${pkgstr} --production --prefix ./${this.extensionsDir}`, {
                     stdio: 'inherit'
                 });
-                const matches = glob.sync('./extensions/**/pgpm.plan');
+                const matches = glob.sync((0, glob_1.globPattern)('.', this.extensionsDir, '**/pgpm.plan'));
                 const installs = matches.map((conf) => {
                     const fullConf = (0, path_1.resolve)(conf);
                     const extDir = (0, path_1.dirname)(fullConf);
-                    const parts = extDir.split('node_modules/');
+                    const parts = (0, glob_1.toPosixPath)(extDir).split('node_modules/');
                     const relativeDir = parts[parts.length - 1];
                     const dstDir = path_1.default.join(skitchExtDir, relativeDir);
                     return { src: extDir, dst: dstDir, pkg: relativeDir };
                 });
                 // Sort deepest paths first so nested node_modules deps are
                 // extracted before their parent directories are moved.
-                installs.sort((a, b) => b.src.split('/').length - a.src.split('/').length);
+                installs.sort((a, b) => (0, glob_1.toPosixPath)(b.src).split('/').length - (0, glob_1.toPosixPath)(a.src).split('/').length);
                 for (const { src, dst, pkg } of installs) {
                     if (fs_1.default.existsSync(dst)) {
                         fs_1.default.rmSync(dst, { recursive: true, force: true });
                     }
                     fs_1.default.mkdirSync(path_1.default.dirname(dst), { recursive: true });
-                    (0, child_process_1.execSync)(`mv "${src}" "${dst}"`);
+                    (0, fs_2.movePath)(src, dst);
                     logger.success(`✔ installed ${pkg}`);
                     const pkgJsonFile = path_1.default.join(dst, 'package.json');
                     if (!fs_1.default.existsSync(pkgJsonFile)) {
@@ -864,8 +877,9 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
                 }
             }
             finally {
-                fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                // chdir out first: Windows locks the process working directory
                 process.chdir(originalDir);
+                fs_1.default.rmSync(tempDir, { recursive: true, force: true });
             }
         }
         if (inModule && pkgData && pkgJsonPath) {
@@ -985,7 +999,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
         }
         const pkgData = JSON.parse(fs_1.default.readFileSync(pkgJsonPath, 'utf-8'));
         const dependencies = pkgData.dependencies || {};
-        const skitchExtDir = path_1.default.join(this.workspacePath, EXTENSIONS_DIR);
+        const skitchExtDir = this.getExtensionsPath();
         const installed = [];
         const installedVersions = {};
         for (const [name, version] of Object.entries(dependencies)) {
@@ -1008,7 +1022,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
      */
     getWorkspaceInstalledModules() {
         this.ensureWorkspace();
-        const extensionsDir = path_1.default.join(this.workspacePath, EXTENSIONS_DIR);
+        const extensionsDir = this.getExtensionsPath();
         if (!fs_1.default.existsSync(extensionsDir)) {
             return [];
         }
@@ -1659,7 +1673,8 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
             if (base !== expected)
                 issues.push({ code: 'control_filename_mismatch', message: `Control filename ${base} != ${expected}`, file: controlPath });
         }
-        return { ok: issues.length === 0, name: info.extname, path: modPath, issues };
+        const reported = issues.map(issue => ({ ...issue, file: (0, glob_1.toPosixPath)(issue.file) }));
+        return { ok: reported.length === 0, name: info.extname, path: (0, glob_1.toPosixPath)(modPath), issues: reported };
     }
     renameModule(newName, opts) {
         this.ensureModule();

package/esm/bundle/apply-envelope.js

@@ -0,0 +1,130 @@
+import { getPgPool } from 'pg-cache';
+import { verifyEnvelope } from '@pgpmjs/bundle';
+import { applyBundle, previewBundleApply } from './apply';
+/**
+ * Analyze an envelope apply without executing it: verify the envelope's
+ * digest chain (including the schema bundle), run the schema pre-flight, and
+ * derive replay order + rollback plan. Pure — no database, no disk.
+ */
+export function previewEnvelopeApply(envelope, options = {}) {
+    const { issues } = verifyEnvelope(envelope);
+    const parts = [
+        ...envelope.data.map(part => ({ kind: 'data', name: part.name, part })),
+        ...envelope.fixtures.map(part => ({ kind: 'fixtures', name: part.name, part }))
+    ];
+    const schema = previewBundleApply(envelope.schema, options);
+    return {
+        name: envelope.manifest.name,
+        version: envelope.manifest.version,
+        envelopeDigest: envelope.manifest.digest,
+        envelopeIssues: issues,
+        schema,
+        partOrder: parts.map(({ kind, name }) => ({ kind, name })),
+        rollbackPlan: {
+            parts: [...parts]
+                .reverse()
+                .map(({ kind, name, part }) => ({ kind, name, hasRevert: part.revert !== null })),
+            schema: schema.rollbackPlan
+        }
+    };
+}
+/** Thrown when an envelope apply is refused pre-flight or fails mid-replay. */
+export class EnvelopeApplyError extends Error {
+    preview;
+    parts;
+    timedOut;
+    constructor(message, preview, 
+    /** Parts completed before the failure (for status recording). */
+    parts = [], timedOut = false) {
+        super(message);
+        this.preview = preview;
+        this.parts = parts;
+        this.timedOut = timedOut;
+        this.name = 'EnvelopeApplyError';
+    }
+}
+/**
+ * Apply a {@link BundleEnvelope} into a target database: the generic
+ * `applyMigrationBundle` primitive.
+ *
+ * Order of operations:
+ * 1. Pre-flight: {@link previewEnvelopeApply} — refuse on any envelope digest
+ *    issue unless `allowUnverified` (schema-bundle integrity and namespace
+ *    gating are then enforced again by {@link applyBundle}).
+ * 2. Schema: {@link applyBundle} on `envelope.schema` (atomic transaction,
+ *    timeout, dry-run all handled there).
+ * 3. Parts: replay each data then fixtures part's deploy SQL in manifest
+ *    order, inside a single transaction so a failing part rolls back all part
+ *    data (the schema stays applied; the preview's rollback plan describes the
+ *    full undo). Optional per-part verify. The `transformPartSql` seam runs
+ *    just before execution.
+ */
+export async function applyEnvelope(envelope, options) {
+    const started = Date.now();
+    const preview = previewEnvelopeApply(envelope, options);
+    if (!options.allowUnverified && preview.envelopeIssues.length > 0) {
+        throw new EnvelopeApplyError(`Refusing to apply envelope "${preview.name}@${preview.version}": failed integrity ` +
+            `verification (${preview.envelopeIssues.length} issue(s): ` +
+            `${preview.envelopeIssues.map(i => i.kind).join(', ')})`, preview);
+    }
+    if (options.dryRun) {
+        return {
+            preview,
+            dryRun: true,
+            executed: false,
+            parts: [],
+            durationMs: Date.now() - started,
+            timedOut: false
+        };
+    }
+    const schema = await applyBundle(envelope.schema, options);
+    const transform = options.transformPartSql ?? ((sql) => sql);
+    const orderedParts = [
+        ...envelope.data.map(part => ({ kind: 'data', name: part.name, part })),
+        ...envelope.fixtures.map(part => ({ kind: 'fixtures', name: part.name, part }))
+    ];
+    const parts = [];
+    if (orderedParts.length > 0) {
+        const pool = getPgPool(options.config);
+        const client = await pool.connect();
+        try {
+            await client.query('BEGIN');
+            for (const { kind, name, part } of orderedParts) {
+                const partStarted = Date.now();
+                try {
+                    await client.query(transform(part.deploy, { kind, name, script: 'deploy' }));
+                    const result = {
+                        kind,
+                        name,
+                        executed: true,
+                        durationMs: Date.now() - partStarted
+                    };
+                    if (options.verifyParts && part.verify !== null) {
+                        await client.query(transform(part.verify, { kind, name, script: 'verify' }));
+                        result.verified = true;
+                    }
+                    parts.push(result);
+                }
+                catch (e) {
+                    await client.query('ROLLBACK');
+                    throw new EnvelopeApplyError(`Part ${kind}/${name} of envelope "${preview.name}@${preview.version}" failed: ` +
+                        `${e instanceof Error ? e.message : String(e)} — all part data rolled back ` +
+                        `(schema remains applied; see preview.rollbackPlan)`, preview, parts);
+                }
+            }
+            await client.query('COMMIT');
+        }
+        finally {
+            client.release();
+        }
+    }
+    return {
+        preview,
+        dryRun: false,
+        executed: true,
+        schema,
+        parts,
+        durationMs: Date.now() - started,
+        timedOut: schema.timedOut
+    };
+}

package/esm/bundle/index.js

@@ -13,3 +13,5 @@
 export * from '@pgpmjs/bundle';
 // applyBundle stays in core: it drives PgpmMigrate (the deploy engine).
 export * from './apply';
+// applyEnvelope: schema apply + data/fixtures part replay for a BundleEnvelope.
+export * from './apply-envelope';

package/esm/core/class/pgpm.js

@@ -1,6 +1,6 @@
-import { loadConfigSyncFromDir, resolvePgpmPath, walkUp } from '@pgpmjs/env';
+import { getExtensionsDir, loadConfigSyncFromDir, resolvePgpmPath, walkUp } from '@pgpmjs/env';
 import { Logger } from '@pgpmjs/logger';
-import { errors } from '@pgpmjs/types';
+import { DEFAULT_EXTENSIONS_DIR, errors } from '@pgpmjs/types';
 import { execSync } from 'child_process';
 import fs from 'fs';
 import * as glob from 'glob';
@@ -20,14 +20,11 @@ import { PgpmMigrate } from '../../migrate/client';
 import { getExtensionsAndModules, getExtensionsAndModulesChanges, latestChange, latestChangeAndVersion } from '../../modules/modules';
 import { packageModule } from '../../packaging/package';
 import { resolveDependencies, resolveExtensionDependencies } from '../../resolution/deps';
+import { movePath } from '../../utils/fs';
+import { globPaths, globPattern, toPosixPath } from '../../utils/glob';
 import { parseTarget } from '../../utils/target-utils';
 import { DEFAULT_TEMPLATE_REPO, DEFAULT_TEMPLATE_TOOL_NAME, DEFAULT_TEMPLATE_TTL_MS, scaffoldTemplate } from '../template-scaffold';
 const logger = new Logger('pgpm');
-/**
- * Directory name for workspace extensions.
- * Extensions are installed globally in the workspace's extensions/ directory.
- */
-const EXTENSIONS_DIR = 'extensions';
 function sortObjectByKey(obj) {
     return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
 }
@@ -63,21 +60,37 @@ export class PgpmPackage {
     config;
     allowedDirs = [];
     allowedParentDirs = [];
+    /**
+     * Directory name (relative to the workspace root) where pgpm modules are installed.
+     * Resolved from the constructor option, `PGPM_EXTENSIONS_DIR`, the `extensionsDir`
+     * config field, then the `extensions` default.
+     */
+    extensionsDir = DEFAULT_EXTENSIONS_DIR;
+    options;
     _moduleMap;
     _moduleInfo;
-    constructor(cwd = process.cwd()) {
+    constructor(cwd = process.cwd(), options = {}) {
+        this.options = options;
         this.resetCwd(cwd);
     }
     resetCwd(cwd) {
         this.cwd = cwd;
         this.workspacePath = resolvePgpmPath(this.cwd);
         this.modulePath = this.resolveSqitchPath();
+        this.extensionsDir = getExtensionsDir(this.options.extensionsDir, this.workspacePath ?? this.cwd);
         if (this.workspacePath) {
             this.config = this.loadConfigSync();
             this.allowedDirs = this.loadAllowedDirs();
             this.allowedParentDirs = this.loadAllowedParentDirs();
         }
     }
+    /**
+     * Absolute path of the workspace directory where pgpm modules are installed.
+     */
+    getExtensionsPath() {
+        this.ensureWorkspace();
+        return path.join(this.workspacePath, this.extensionsDir);
+    }
     resolveSqitchPath() {
         try {
             return walkUp(this.cwd, 'pgpm.plan');
@@ -91,7 +104,7 @@ export class PgpmPackage {
     }
     loadAllowedDirs() {
         const globs = this.config?.packages ?? [];
-        const dirs = globs.flatMap(pattern => glob.sync(path.join(this.workspacePath, pattern)));
+        const dirs = globs.flatMap(pattern => globPaths(this.workspacePath, pattern));
         const resolvedDirs = dirs.map(dir => path.resolve(dir));
         // Remove duplicates by converting to Set and back to array
         return [...new Set(resolvedDirs.sort((a, b) => a.localeCompare(b)))];
@@ -183,7 +196,7 @@ export class PgpmPackage {
         const dirs = this.loadAllowedDirs();
         const results = [];
         for (const dir of dirs) {
-            const proj = new PgpmPackage(dir);
+            const proj = new PgpmPackage(dir, this.options);
             if (proj.isInModule()) {
                 results.push(proj);
             }
@@ -203,9 +216,9 @@ export class PgpmPackage {
         // nested workspaces (e.g. test fixtures) out of the module map.
         const packageDirs = [
             ...this.allowedDirs,
-            ...glob.sync(path.join(this.workspacePath, EXTENSIONS_DIR, '{*,@*/*}'))
+            ...globPaths(this.workspacePath, this.extensionsDir, '{*,@*/*}')
         ];
-        const moduleFiles = [...new Set(packageDirs.flatMap(dir => glob.sync(`${dir}/**/*.control`)))].filter((file) => !/node_modules/.test(file)).sort((a, b) => a.localeCompare(b));
+        const moduleFiles = [...new Set(packageDirs.flatMap(dir => glob.sync(globPattern(dir, '**/*.control'))))].filter((file) => !/node_modules/.test(file)).sort((a, b) => a.localeCompare(b));
         // Group files by module name to handle collisions
         const filesByName = new Map();
         moduleFiles.forEach((file) => {
@@ -256,7 +269,7 @@ export class PgpmPackage {
             throw errors.MODULE_NOT_FOUND({ name });
         }
         const modulePath = path.resolve(this.workspacePath, modules[name].path);
-        return new PgpmPackage(modulePath);
+        return new PgpmPackage(modulePath, this.options);
     }
     // ──────────────── Module-scoped ────────────────
     getModuleInfo() {
@@ -771,7 +784,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
         this.ensureWorkspace();
         const inModule = this.isInModule();
         const originalDir = process.cwd();
-        const skitchExtDir = path.join(this.workspacePath, EXTENSIONS_DIR);
+        const skitchExtDir = this.getExtensionsPath();
         let pkgJsonPath;
         let pkgData;
         if (inModule) {
@@ -789,27 +802,27 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
             const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pgpm-install-'));
             try {
                 process.chdir(tempDir);
-                execSync(`npm install ${pkgstr} --production --prefix ./extensions`, {
+                execSync(`npm install ${pkgstr} --production --prefix ./${this.extensionsDir}`, {
                     stdio: 'inherit'
                 });
-                const matches = glob.sync('./extensions/**/pgpm.plan');
+                const matches = glob.sync(globPattern('.', this.extensionsDir, '**/pgpm.plan'));
                 const installs = matches.map((conf) => {
                     const fullConf = resolve(conf);
                     const extDir = dirname(fullConf);
-                    const parts = extDir.split('node_modules/');
+                    const parts = toPosixPath(extDir).split('node_modules/');
                     const relativeDir = parts[parts.length - 1];
                     const dstDir = path.join(skitchExtDir, relativeDir);
                     return { src: extDir, dst: dstDir, pkg: relativeDir };
                 });
                 // Sort deepest paths first so nested node_modules deps are
                 // extracted before their parent directories are moved.
-                installs.sort((a, b) => b.src.split('/').length - a.src.split('/').length);
+                installs.sort((a, b) => toPosixPath(b.src).split('/').length - toPosixPath(a.src).split('/').length);
                 for (const { src, dst, pkg } of installs) {
                     if (fs.existsSync(dst)) {
                         fs.rmSync(dst, { recursive: true, force: true });
                     }
                     fs.mkdirSync(path.dirname(dst), { recursive: true });
-                    execSync(`mv "${src}" "${dst}"`);
+                    movePath(src, dst);
                     logger.success(`✔ installed ${pkg}`);
                     const pkgJsonFile = path.join(dst, 'package.json');
                     if (!fs.existsSync(pkgJsonFile)) {
@@ -825,8 +838,9 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
                 }
             }
             finally {
-                fs.rmSync(tempDir, { recursive: true, force: true });
+                // chdir out first: Windows locks the process working directory
                 process.chdir(originalDir);
+                fs.rmSync(tempDir, { recursive: true, force: true });
             }
         }
         if (inModule && pkgData && pkgJsonPath) {
@@ -946,7 +960,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
         }
         const pkgData = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
         const dependencies = pkgData.dependencies || {};
-        const skitchExtDir = path.join(this.workspacePath, EXTENSIONS_DIR);
+        const skitchExtDir = this.getExtensionsPath();
         const installed = [];
         const installedVersions = {};
         for (const [name, version] of Object.entries(dependencies)) {
@@ -969,7 +983,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
      */
     getWorkspaceInstalledModules() {
         this.ensureWorkspace();
-        const extensionsDir = path.join(this.workspacePath, EXTENSIONS_DIR);
+        const extensionsDir = this.getExtensionsPath();
         if (!fs.existsSync(extensionsDir)) {
             return [];
         }
@@ -1620,7 +1634,8 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
             if (base !== expected)
                 issues.push({ code: 'control_filename_mismatch', message: `Control filename ${base} != ${expected}`, file: controlPath });
         }
-        return { ok: issues.length === 0, name: info.extname, path: modPath, issues };
+        const reported = issues.map(issue => ({ ...issue, file: toPosixPath(issue.file) }));
+        return { ok: reported.length === 0, name: info.extname, path: toPosixPath(modPath), issues: reported };
     }
     renameModule(newName, opts) {
         this.ensureModule();

package/esm/projects/deploy.js

@@ -23,7 +23,7 @@ export const deployProject = async (opts, name, database, pkg, toChange) => {
         throw errors.MODULE_NOT_FOUND({ name });
     }
     const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
-    const moduleProject = new PgpmPackage(modulePath);
+    const moduleProject = new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
     log.info(`📦 Resolving dependencies for ${name}...`);
     const extensions = moduleProject.getModuleExtensions();
     const pgPool = getPgPool({ ...opts.pg, database });
@@ -42,7 +42,7 @@ export const deployProject = async (opts, name, database, pkg, toChange) => {
                 log.debug(`→ Path: ${modulePath}`);
                 if (mergedOpts.deployment.fast) {
                     // Use fast deployment strategy
-                    const localProject = new PgpmPackage(modulePath);
+                    const localProject = new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
                     const cacheKey = getCacheKey(mergedOpts.pg, extension, database);
                     if (mergedOpts.deployment.cache && deployFastCache[cacheKey]) {
                         log.warn(`⚡ Using cached package for ${extension}.`);

package/esm/projects/revert.js

@@ -14,7 +14,7 @@ export const revertProject = async (opts, name, database, pkg, options) => {
         throw errors.MODULE_NOT_FOUND({ name });
     }
     const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
-    const moduleProject = new PgpmPackage(modulePath);
+    const moduleProject = new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
     log.info(`📦 Resolving dependencies for ${name}...`);
     const extensions = moduleProject.getModuleExtensions();
     const pgPool = getPgPool({

package/esm/projects/verify.js

@@ -14,7 +14,7 @@ export const verifyProject = async (opts, name, database, pkg, options) => {
         throw errors.MODULE_NOT_FOUND({ name });
     }
     const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
-    const moduleProject = new PgpmPackage(modulePath);
+    const moduleProject = new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
     log.info(`📦 Resolving dependencies for ${name}...`);
     const extensions = moduleProject.getModuleExtensions();
     const pgPool = getPgPool({

package/esm/resolution/deps.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'fs';
 import { sync as glob } from 'glob';
 import { join, relative } from 'path';
 import { PgpmPackage } from '../core/class/pgpm';
+import { globPattern, toPosixPath } from '../utils/glob';
 import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
 import { scanDeployScript } from '@pgpmjs/ast/files/sql/header';
 import { errors } from '@pgpmjs/types';
@@ -331,10 +332,10 @@ export const resolveDependencies = (packageDir, extname, options = {}) => {
     const deps = {};
     const tagMappings = {};
     // Process SQL files and build dependency graph
-    const files = glob(`${packageDir}/deploy/**/*.sql`).sort((a, b) => a.localeCompare(b));
+    const files = glob(globPattern(packageDir, 'deploy/**/*.sql')).sort((a, b) => a.localeCompare(b));
     for (const file of files) {
         const data = readFileSync(file, 'utf-8');
-        const key = '/' + relative(packageDir, file);
+        const key = '/' + toPosixPath(relative(packageDir, file));
         deps[key] = [];
         const { requires } = scanDeployScript(data, { key, extname, makeKey });
         for (const dep of requires) {

package/esm/utils/fs.js

@@ -0,0 +1,16 @@
+import fs from 'fs';
+/**
+ * Move a file or directory, falling back to copy + remove across devices.
+ * Replaces shelling out to `mv`, which does not exist on Windows.
+ */
+export const movePath = (src, dst) => {
+    try {
+        fs.renameSync(src, dst);
+    }
+    catch (e) {
+        if (e?.code !== 'EXDEV' && e?.code !== 'EPERM')
+            throw e;
+        fs.cpSync(src, dst, { recursive: true });
+        fs.rmSync(src, { recursive: true, force: true });
+    }
+};

package/esm/utils/glob.js

@@ -0,0 +1,19 @@
+import { sync as globSync } from 'glob';
+import path from 'path';
+/**
+ * Convert a native filesystem path to a posix-style path.
+ * Windows path separators are not valid inside glob patterns.
+ */
+export const toPosixPath = (p) => p.replace(/\\/g, '/');
+/**
+ * Join path segments into a glob pattern.
+ *
+ * `glob` treats `\` as an escape character on every platform, so a Windows
+ * path produced by `path.join` silently matches nothing. Patterns must always
+ * use forward slashes, which Windows accepts as a separator.
+ */
+export const globPattern = (...segments) => toPosixPath(path.join(...segments));
+/**
+ * Cross-platform `glob.sync` over path segments joined into a pattern.
+ */
+export const globPaths = (...segments) => globSync(globPattern(...segments));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/core",
-  "version": "7.2.1",
+  "version": "7.3.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PGPM Package and Migration Tools",
   "main": "index.js",
@@ -20,7 +20,7 @@
     "url": "https://github.com/constructive-io/constructive/issues"
   },
   "scripts": {
-    "copy": "npm run copy:pkg; npm run copy:sql",
+    "copy": "npm run copy:pkg && npm run copy:sql",
     "copy:pkg": "makage assets",
     "copy:sql": "copyfiles -f src/migrate/sql/* dist/migrate/sql && copyfiles -f src/migrate/sql/* dist/esm/migrate/sql",
     "clean": "makage clean",
@@ -48,23 +48,23 @@
     "makage": "^0.3.0"
   },
   "dependencies": {
-    "@pgpmjs/ast": "^0.1.1",
-    "@pgpmjs/bundle": "^0.1.1",
-    "@pgpmjs/env": "^2.28.2",
+    "@pgpmjs/ast": "^0.1.2",
+    "@pgpmjs/bundle": "^0.2.1",
+    "@pgpmjs/env": "^2.29.0",
     "@pgpmjs/logger": "^2.14.0",
-    "@pgpmjs/server-utils": "^3.15.3",
-    "@pgpmjs/types": "^2.35.1",
-    "csv-to-pg": "^4.0.0",
+    "@pgpmjs/server-utils": "^3.15.4",
+    "@pgpmjs/types": "^2.36.0",
+    "csv-to-pg": "^4.0.1",
     "genomic": "^5.6.2",
     "glob": "^13.0.6",
     "minimatch": "^10.2.5",
     "parse-package-name": "^1.0.0",
     "pg": "^8.21.0",
-    "pg-cache": "^3.15.2",
+    "pg-cache": "^3.15.3",
     "pg-env": "^1.18.1",
     "pgsql-deparser": "^18.1.1",
     "pgsql-parser": "^18.1.1",
     "yanse": "^0.2.1"
   },
-  "gitHead": "51c3e15e9d509154d0a8102bb18f6e39cfa4e0c6"
+  "gitHead": "39db6d576bce7bc1de8123849f237b1695779d88"
 }

package/projects/deploy.js

@@ -59,7 +59,7 @@ const deployProject = async (opts, name, database, pkg, toChange) => {
         throw types_1.errors.MODULE_NOT_FOUND({ name });
     }
     const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
-    const moduleProject = new pgpm_1.PgpmPackage(modulePath);
+    const moduleProject = new pgpm_1.PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
     log.info(`📦 Resolving dependencies for ${name}...`);
     const extensions = moduleProject.getModuleExtensions();
     const pgPool = (0, pg_cache_1.getPgPool)({ ...opts.pg, database });
@@ -78,7 +78,7 @@ const deployProject = async (opts, name, database, pkg, toChange) => {
                 log.debug(`→ Path: ${modulePath}`);
                 if (mergedOpts.deployment.fast) {
                     // Use fast deployment strategy
-                    const localProject = new pgpm_1.PgpmPackage(modulePath);
+                    const localProject = new pgpm_1.PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
                     const cacheKey = getCacheKey(mergedOpts.pg, extension, database);
                     if (mergedOpts.deployment.cache && deployFastCache[cacheKey]) {
                         log.warn(`⚡ Using cached package for ${extension}.`);

package/projects/revert.js

@@ -50,7 +50,7 @@ const revertProject = async (opts, name, database, pkg, options) => {
         throw types_1.errors.MODULE_NOT_FOUND({ name });
     }
     const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
-    const moduleProject = new pgpm_1.PgpmPackage(modulePath);
+    const moduleProject = new pgpm_1.PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
     log.info(`📦 Resolving dependencies for ${name}...`);
     const extensions = moduleProject.getModuleExtensions();
     const pgPool = (0, pg_cache_1.getPgPool)({

package/projects/verify.js

@@ -50,7 +50,7 @@ const verifyProject = async (opts, name, database, pkg, options) => {
         throw types_1.errors.MODULE_NOT_FOUND({ name });
     }
     const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
-    const moduleProject = new pgpm_1.PgpmPackage(modulePath);
+    const moduleProject = new pgpm_1.PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
     log.info(`📦 Resolving dependencies for ${name}...`);
     const extensions = moduleProject.getModuleExtensions();
     const pgPool = (0, pg_cache_1.getPgPool)({

package/resolution/deps.js

@@ -5,6 +5,7 @@ const fs_1 = require("fs");
 const glob_1 = require("glob");
 const path_1 = require("path");
 const pgpm_1 = require("../core/class/pgpm");
+const glob_2 = require("../utils/glob");
 const parser_1 = require("@pgpmjs/ast/files/plan/parser");
 const header_1 = require("@pgpmjs/ast/files/sql/header");
 const types_1 = require("@pgpmjs/types");
@@ -335,10 +336,10 @@ const resolveDependencies = (packageDir, extname, options = {}) => {
     const deps = {};
     const tagMappings = {};
     // Process SQL files and build dependency graph
-    const files = (0, glob_1.sync)(`${packageDir}/deploy/**/*.sql`).sort((a, b) => a.localeCompare(b));
+    const files = (0, glob_1.sync)((0, glob_2.globPattern)(packageDir, 'deploy/**/*.sql')).sort((a, b) => a.localeCompare(b));
     for (const file of files) {
         const data = (0, fs_1.readFileSync)(file, 'utf-8');
-        const key = '/' + (0, path_1.relative)(packageDir, file);
+        const key = '/' + (0, glob_2.toPosixPath)((0, path_1.relative)(packageDir, file));
         deps[key] = [];
         const { requires } = (0, header_1.scanDeployScript)(data, { key, extname, makeKey });
         for (const dep of requires) {

package/utils/fs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Move a file or directory, falling back to copy + remove across devices.
+ * Replaces shelling out to `mv`, which does not exist on Windows.
+ */
+export declare const movePath: (src: string, dst: string) => void;

package/utils/fs.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.movePath = void 0;
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Move a file or directory, falling back to copy + remove across devices.
+ * Replaces shelling out to `mv`, which does not exist on Windows.
+ */
+const movePath = (src, dst) => {
+    try {
+        fs_1.default.renameSync(src, dst);
+    }
+    catch (e) {
+        if (e?.code !== 'EXDEV' && e?.code !== 'EPERM')
+            throw e;
+        fs_1.default.cpSync(src, dst, { recursive: true });
+        fs_1.default.rmSync(src, { recursive: true, force: true });
+    }
+};
+exports.movePath = movePath;

package/utils/glob.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Convert a native filesystem path to a posix-style path.
+ * Windows path separators are not valid inside glob patterns.
+ */
+export declare const toPosixPath: (p: string) => string;
+/**
+ * Join path segments into a glob pattern.
+ *
+ * `glob` treats `\` as an escape character on every platform, so a Windows
+ * path produced by `path.join` silently matches nothing. Patterns must always
+ * use forward slashes, which Windows accepts as a separator.
+ */
+export declare const globPattern: (...segments: string[]) => string;
+/**
+ * Cross-platform `glob.sync` over path segments joined into a pattern.
+ */
+export declare const globPaths: (...segments: string[]) => string[];

package/utils/glob.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globPaths = exports.globPattern = exports.toPosixPath = void 0;
+const glob_1 = require("glob");
+const path_1 = __importDefault(require("path"));
+/**
+ * Convert a native filesystem path to a posix-style path.
+ * Windows path separators are not valid inside glob patterns.
+ */
+const toPosixPath = (p) => p.replace(/\\/g, '/');
+exports.toPosixPath = toPosixPath;
+/**
+ * Join path segments into a glob pattern.
+ *
+ * `glob` treats `\` as an escape character on every platform, so a Windows
+ * path produced by `path.join` silently matches nothing. Patterns must always
+ * use forward slashes, which Windows accepts as a separator.
+ */
+const globPattern = (...segments) => (0, exports.toPosixPath)(path_1.default.join(...segments));
+exports.globPattern = globPattern;
+/**
+ * Cross-platform `glob.sync` over path segments joined into a pattern.
+ */
+const globPaths = (...segments) => (0, glob_1.sync)((0, exports.globPattern)(...segments));
+exports.globPaths = globPaths;