pgpm 5.21.2 → 5.23.0

package/commands/deploy.js

@@ -127,7 +127,8 @@ exports.default = async (argv, prompter, _options) => {
     if (createdb) {
         if (capabilities.createdb) {
             log.info(`Creating database ${database}...`);
-            (0, child_process_1.execSync)(`createdb ${database}`, {
+            const [cmd, ...prefixArgs] = (0, pg_env_1.getPgClientCommand)('createdb');
+            (0, child_process_1.execFileSync)(cmd, [...prefixArgs, database], {
                 env: (0, pg_env_1.getSpawnEnvWithPg)(pgEnv)
             });
         }

package/commands/diff.js

@@ -37,7 +37,6 @@ const core_1 = require("@pgpmjs/core");
 const diff_1 = require("@pgpmjs/diff");
 const logger_1 = require("@pgpmjs/logger");
 const transform_1 = require("@pgpmjs/transform");
-const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const inquirerer_1 = require("inquirerer");
 const os = __importStar(require("os"));
@@ -61,6 +60,8 @@ Diff Command:
 Sides:
   <A> / <B> may each be:
     - a pgpm module directory (flattened in plan order)
+    - a pgpm workspace directory (every local module, in dependency order,
+      with package-qualified change names)
     - a raw .sql file
     - a live database: a postgres:// connection string, or db:<name>
       (uses PG* env for host/port/user; schema is read via pg_dump)
@@ -82,6 +83,16 @@ Options:
                            file (deparsed in plan order); - writes to stdout
   --emit-bundle <file>     Also project the delta to a content-addressed
                            .bundle.tar.gz archive
+  --ledger <db>            Read a database's pgpm_migrate ledger (db:<name> or a
+                           connection string) as the deployment cursor for side
+                           B, and report which of B's plan entries that database
+                           already has (identical / drifted / pending / orphaned
+                           / out-of-order). Combines with --emit-ledger.
+  --emit-ledger <file>     Write an idempotent pgpm_migrate backfill script that
+                           records B's already-satisfied changes without
+                           executing them. Satisfaction is semantic (identity-
+                           keyed against side A), so regenerated or reordered
+                           plans still classify as satisfied.
   --pkg <name>             Emitted migration package name (default: diff-migration)
   --granularity <level>    Granularity for emitted changes: atomic | object |
                            consolidated (default: object)
@@ -102,55 +113,22 @@ Examples:
   pgpm diff ./v1-module ./v2-module
   pgpm diff ./v1-module ./schema-v2.sql --json
   pgpm diff db:app_v1 db:app_v2 --emit-migration ./out --verify
+  pgpm diff db:prod ./workspace-v2 --ledger db:prod --emit-ledger ./backfill.sql \
+           --emit-migration ./out --pkg upgrade
 `;
 const NAMING_STYLES = ['directory', 'flat'];
-/** pg_dump a side's schema: `db:<name>` uses PG* env; DSNs pass through. */
-const dumpDatabase = async (spec) => {
-    const args = ['--schema-only', '--no-owner'];
-    let env = process.env;
-    if (spec.startsWith('db:')) {
-        const config = (0, pg_env_1.getPgEnvOptions)({ database: spec.slice(3) });
-        env = (0, pg_env_1.getSpawnEnvWithPg)(config);
+/** A plan-bearing on-disk side (workspace or module directory). */
+const isPlanSide = (spec, cwd) => {
+    if ((0, core_1.isDatabaseSpec)(spec))
+        return false;
+    try {
+        const kind = (0, diff_1.resolveDiffSideKind)(path.resolve(cwd, spec));
+        return kind === 'workspace' || kind === 'module';
     }
-    else {
-        args.push('--dbname', spec);
+    catch {
+        return false;
     }
-    return new Promise((resolve, reject) => {
-        const child = (0, child_process_1.spawn)('pg_dump', args, { env, stdio: ['ignore', 'pipe', 'pipe'] });
-        let out = '';
-        let err = '';
-        child.stdout.on('data', chunk => { out += chunk; });
-        child.stderr.on('data', chunk => { err += chunk; });
-        child.on('error', (e) => {
-            if (e.code === 'ENOENT') {
-                reject(new Error('pg_dump not found; ensure PostgreSQL client tools are installed and in PATH'));
-                return;
-            }
-            reject(e);
-        });
-        child.on('close', code => {
-            if (code === 0)
-                resolve(out);
-            else
-                reject(new Error(`pg_dump exited with code ${code}: ${err.trim()}`));
-        });
-    });
 };
-/** Resolve one side spec into diff input changes. */
-const loadSide = async (spec, cwd) => {
-    if (resolveDiffSideKindSafe(spec) === 'database') {
-        const label = spec.startsWith('db:') ? spec.slice(3) : spec;
-        return {
-            kind: 'database',
-            label,
-            changes: (0, diff_1.sqlToDiffChanges)(await dumpDatabase(spec), label),
-            warnings: []
-        };
-    }
-    return (0, diff_1.loadDiffSideFromDisk)(path.resolve(cwd, spec));
-};
-/** `resolveDiffSideKind` without throwing on relative on-disk paths. */
-const resolveDiffSideKindSafe = (spec) => /^postgres(ql)?:\/\//.test(spec) || spec.startsWith('db:') ? 'database' : 'disk';
 /** Apply one diff side into a scratch database (module deploy or raw SQL). */
 const applySide = async (config, side, spec, cwd) => {
     if (side.kind === 'module') {
@@ -189,6 +167,29 @@ const runVerify = async (sideA, sideB, specA, specB, migrationDir, cwd) => {
         return (0, scratch_db_1.catalogDifferences)(cfgMigrated, cfgTarget, transform_1.withoutColumnOrder);
     });
 };
+const printLedgerSummary = (report, ledgerSpec) => {
+    const counts = new Map();
+    for (const entry of report.classification.entries) {
+        counts.set(entry.status, (counts.get(entry.status) ?? 0) + 1);
+    }
+    const parts = [...counts.entries()].map(([status, n]) => `${n} ${status}`);
+    console.log(`Ledger (${ledgerSpec}): ${parts.join(', ') || 'empty plan'}.`);
+    if (report.classification.orphaned.length) {
+        console.log(`  Orphaned ledger entries (${report.classification.orphaned.length}):`);
+        for (const row of report.classification.orphaned) {
+            console.log(`    ${row.package}:${row.changeName}`);
+        }
+    }
+    if (report.classification.outOfOrder.length) {
+        console.log(`  Deployed out of plan order: ${report.classification.outOfOrder.join(', ')}`);
+    }
+    if (report.backfilled.length) {
+        console.log(`  Satisfied but unrecorded (backfillable): ${report.backfilled.length}`);
+    }
+    if (report.unprovable.length) {
+        console.log(`  Not provably satisfied (inert/partial; will deploy normally): ${report.unprovable.join(', ')}`);
+    }
+};
 const printSummary = (result, labelA, labelB) => {
     if (result.identical) {
         console.log(`No differences: ${labelA} and ${labelB} describe the same objects.`);
@@ -224,7 +225,7 @@ exports.default = async (argv, prompter, _options) => {
     const { first: specB, newArgv: restArgv } = (0, inquirerer_1.extractFirst)(newArgv);
     argv = restArgv;
     if (!specA || !specB) {
-        await (0, inquirerer_1.cliExitWithError)('pgpm diff requires two sides: pgpm diff <A> <B> (module dir, .sql file, db:<name>, or connection string).');
+        await (0, inquirerer_1.cliExitWithError)('pgpm diff requires two sides: pgpm diff <A> <B> (module dir, workspace dir, .sql file, db:<name>, or connection string).');
     }
     const granularityRaw = argv.granularity ?? 'object';
     if (!(0, transform_1.isExportGranularity)(granularityRaw)) {
@@ -262,6 +263,17 @@ exports.default = async (argv, prompter, _options) => {
         : undefined;
     const sqlToStdout = emitSql === module_projections_1.STDOUT_TARGET;
     const pkgName = argv.pkg || 'diff-migration';
+    const ledgerSpec = typeof argv.ledger === 'string' && argv.ledger ? argv.ledger : undefined;
+    const emitLedgerRaw = argv['emit-ledger'] ?? argv.emitLedger;
+    const emitLedgerTarget = typeof emitLedgerRaw === 'string' && emitLedgerRaw
+        ? path.resolve(cwd, emitLedgerRaw)
+        : undefined;
+    if (emitLedgerTarget && !ledgerSpec) {
+        await (0, inquirerer_1.cliExitWithError)('--emit-ledger requires --ledger <db> (the database whose pgpm_migrate ledger is backfilled).');
+    }
+    if (ledgerSpec && !isPlanSide(specB, cwd)) {
+        await (0, inquirerer_1.cliExitWithError)('--ledger requires side B to be a pgpm workspace or module directory (it needs a plan to classify).');
+    }
     if (appendModuleDir && (emitModuleDir || emitSql || emitBundle || verify)) {
         await (0, inquirerer_1.cliExitWithError)('--append-module is standalone; it cannot be combined with --emit-migration/--emit-module/--emit-sql/--emit-bundle/--verify.');
     }
@@ -269,8 +281,8 @@ exports.default = async (argv, prompter, _options) => {
     let sideA;
     let sideB;
     try {
-        sideA = await loadSide(specA, cwd);
-        sideB = await loadSide(specB, cwd);
+        sideA = await (0, core_1.loadDiffSide)(specA, cwd);
+        sideB = await (0, core_1.loadDiffSide)(specB, cwd);
     }
     catch (err) {
         await (0, inquirerer_1.cliExitWithError)(err instanceof Error ? err.message : String(err));
@@ -282,6 +294,27 @@ exports.default = async (argv, prompter, _options) => {
         ...sideB.warnings.map(w => `${sideB.label}: ${w}`),
         ...result.warnings
     ];
+    let ledgerReport;
+    if (ledgerSpec) {
+        ledgerReport = await (0, core_1.buildLedgerReport)({
+            config: (0, core_1.resolveDatabaseSpec)(ledgerSpec),
+            spec: specB,
+            cwd,
+            changes: sideB.changes,
+            diff: result
+        });
+        if (emitLedgerTarget) {
+            if (ledgerReport.backfillSql) {
+                fs.mkdirSync(path.dirname(emitLedgerTarget), { recursive: true });
+                fs.writeFileSync(emitLedgerTarget, ledgerReport.backfillSql);
+                if (!sqlToStdout && !json)
+                    log.success(`wrote ledger backfill (${ledgerReport.backfilled.length} change(s)) to ${emitLedgerTarget}`);
+            }
+            else if (!sqlToStdout && !json) {
+                log.info('no ledger backfill to emit (nothing satisfied-but-unrecorded).');
+            }
+        }
+    }
     if (json) {
         console.log(JSON.stringify({
             identical: result.identical,
@@ -293,15 +326,30 @@ exports.default = async (argv, prompter, _options) => {
                 revert: c.revert,
                 verify: c.verify
             })),
-            warnings
+            warnings,
+            ...(ledgerReport
+                ? {
+                    ledger: {
+                        entries: ledgerReport.classification.entries,
+                        orphaned: ledgerReport.classification.orphaned,
+                        outOfOrder: ledgerReport.classification.outOfOrder,
+                        coverage: ledgerReport.coverage,
+                        backfilled: ledgerReport.backfilled,
+                        unprovable: ledgerReport.unprovable
+                    }
+                }
+                : {})
         }, null, 2));
     }
     else {
         for (const warning of warnings)
             console.warn(`diff: ${warning}`);
         // Keep stdout clean when the SQL projection is piped there.
-        if (!sqlToStdout)
+        if (!sqlToStdout) {
             printSummary(result, sideA.label, sideB.label);
+            if (ledgerReport)
+                printLedgerSummary(ledgerReport, ledgerSpec);
+        }
     }
     if (appendModuleDir) {
         const rows = (0, diff_1.deltaChangesToRows)(result.changes);

package/commands/dump.js

@@ -3,9 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@pgpmjs/core");
 const logger_1 = require("@pgpmjs/logger");
 const quotes_1 = require("@pgsql/quotes");
-const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const pg_cache_1 = require("pg-cache");
@@ -37,28 +37,6 @@ function nowStamp() {
     const pad = (n) => String(n).padStart(2, '0');
     return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
 }
-async function runPgDump(args, env) {
-    await new Promise((resolve, reject) => {
-        const child = (0, child_process_1.spawn)('pg_dump', args, {
-            env,
-            stdio: 'inherit',
-            shell: false
-        });
-        child.on('error', (err) => {
-            if (err.code === 'ENOENT') {
-                log.error('pg_dump not found; ensure PostgreSQL client tools are installed and in PATH');
-            }
-            reject(err);
-        });
-        child.on('close', (code) => {
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            reject(new Error(`pg_dump exited with code ${code ?? 1}`));
-        });
-    });
-}
 async function resolveDatabaseId(dbname, databaseIdRaw) {
     const pool = (0, pg_cache_1.getPgPool)((0, pg_env_1.getPgEnvOptions)({ database: dbname }));
     const res = await pool.query(`select id, name from metaschema_public.database order by name`);
@@ -145,16 +123,13 @@ exports.default = async (argv, prompter, _options) => {
         log.info(`database id ${databaseIdInfo.id}`);
     }
     const pgEnv = (0, pg_env_1.getPgEnvOptions)({ database: dbname });
-    const spawnEnv = (0, pg_env_1.getSpawnEnvWithPg)(pgEnv);
-    const args = [
-        '--format=plain',
-        '--no-owner',
-        '--no-privileges',
-        '--file',
-        outPath,
-        dbname
-    ];
-    await runPgDump(args, spawnEnv);
+    await (0, core_1.pgDump)({
+        config: pgEnv,
+        format: 'plain',
+        noOwner: true,
+        noPrivileges: true,
+        file: outPath
+    });
     if (databaseIdInfo) {
         const pruneSql = await buildPruneSql(dbname, databaseIdInfo.id);
         // Use writeFileSync with 'a' flag for explicit append as requested

package/commands/import.js

@@ -33,9 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@pgpmjs/core");
 const import_1 = require("@pgpmjs/import");
 const logger_1 = require("@pgpmjs/logger");
 const transform_1 = require("@pgpmjs/transform");
+const fs_1 = require("fs");
 const inquirerer_1 = require("inquirerer");
 const path = __importStar(require("path"));
 const emit_package_1 = require("../utils/emit-package");
@@ -88,6 +90,12 @@ Options:
   --emit-bundle <file>     Also project the imported module into a
                           content-addressed .bundle.tar.gz. Same single-package
                           requirement as --emit-sql.
+  --baseline              After writing each package, also write a
+                          <pkg>/baseline.sql: an idempotent, log-only
+                          pgpm_migrate backfill recording every generated
+                          change as already deployed. Adopts the source
+                          database — apply the script (after 'pgpm migrate
+                          init'), then 'pgpm deploy' runs only real changes.
   --cwd <directory>       Working directory (default: current directory)
   --dry-run               Print the resulting plan/paths without writing
 
@@ -100,6 +108,7 @@ Examples:
   pgpm import ./sql-files --pkg my-app --out ./packages --with-data
   pgpm import dump.sql --pkg my-app --partition partition.json
   pgpm import dump.sql --pkg my-app --emit-sql my-app.sql
+  pgpm import dump.sql --pkg my-app --baseline
 `;
 const NAMING_STYLES = ['directory', 'flat'];
 exports.default = async (argv, prompter, _options) => {
@@ -147,9 +156,13 @@ exports.default = async (argv, prompter, _options) => {
     const emit = (0, module_projections_1.parseEmitProjectionTargets)(argv, cwd);
     const emitRequested = (0, module_projections_1.hasEmitProjection)(emit);
     const sqlToStdout = emit.emitSql === module_projections_1.STDOUT_TARGET;
+    const baseline = Boolean(argv.baseline);
     if (emitRequested && dryRun) {
         await (0, inquirerer_1.cliExitWithError)('--emit-sql/--emit-bundle cannot be combined with --dry-run.');
     }
+    if (baseline && dryRun) {
+        await (0, inquirerer_1.cliExitWithError)('--baseline cannot be combined with --dry-run.');
+    }
     let source;
     try {
         source = (0, import_1.loadDumpSource)(path.resolve(cwd, input));
@@ -213,9 +226,11 @@ exports.default = async (argv, prompter, _options) => {
             }
         }
         let firstDir;
+        const writtenDirs = [];
         for (const pkg of packages) {
             const dir = (0, emit_package_1.writePackage)(outBase, pkg);
             firstDir ??= dir;
+            writtenDirs.push(dir);
             if (!sqlToStdout) {
                 log.success(`wrote ${pkg.rows.length} changes to ${dir}`);
             }
@@ -223,6 +238,14 @@ exports.default = async (argv, prompter, _options) => {
         if (emitRequested && firstDir) {
             await (0, module_projections_1.projectModule)(firstDir, emit, sqlToStdout ? undefined : msg => log.success(msg));
         }
+        if (baseline) {
+            for (const dir of writtenDirs) {
+                const { entries, backfillSql } = await (0, core_1.buildBaselineBackfill)(dir);
+                const baselinePath = path.join(dir, 'baseline.sql');
+                (0, fs_1.writeFileSync)(baselinePath, backfillSql);
+                log.success(`wrote baseline backfill for ${entries.length} change(s) to ${baselinePath}`);
+            }
+        }
     }
     const { summary } = result;
     if (!sqlToStdout) {

package/commands/migrate/baseline.d.ts

@@ -0,0 +1,4 @@
+import { CLIOptions, Inquirerer, ParsedArgs } from 'inquirerer';
+export declare const baselineUsageText = "\nMigrate Baseline Command:\n\n  pgpm migrate baseline [<workspace|module>] [OPTIONS]\n\n  Record a plan's changes as already deployed WITHOUT executing any DDL, so a\n  database that already carries the schema (imported from a dump, restored, or\n  otherwise adopted from outside pgpm) is brought to the plan's head in the\n  pgpm_migrate ledger. A subsequent 'pgpm deploy' then runs only genuinely new\n  changes.\n\n  Each change is recorded through the same pgpm_migrate.deploy procedure a real\n  deploy uses, with log-only mode (empty script, p_log_only => TRUE), in plan\n  order.\n\nOptions:\n  --help, -h              Show this help message\n  --emit-ledger <file|->  Write the log-only backfill SQL instead of applying\n                          it (- for stdout). Offline; no database is touched.\n                          The target must already have the pgpm_migrate schema\n                          (run 'pgpm migrate init' first).\n  --database <name>       Database to apply the baseline to (skips the prompt)\n  -y, --yes               Skip the confirmation prompt when applying\n  --no-tx                 Apply without wrapping each module in a transaction\n  --cwd <directory>       Working directory (default: current directory)\n\nExamples:\n  pgpm migrate baseline ./my-app --emit-ledger baseline.sql\n  pgpm migrate baseline --database mydb\n  pgpm migrate baseline ./ws --emit-ledger -\n";
+declare const _default: (argv: Partial<ParsedArgs>, prompter: Inquirerer, _options: CLIOptions) => Promise<Partial<ParsedArgs>>;
+export default _default;

package/commands/migrate/baseline.js

@@ -0,0 +1,141 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baselineUsageText = void 0;
+const core_1 = require("@pgpmjs/core");
+const diff_1 = require("@pgpmjs/diff");
+const logger_1 = require("@pgpmjs/logger");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const pg_env_1 = require("pg-env");
+const database_1 = require("../../utils/database");
+const log = new logger_1.Logger('migrate-baseline');
+const STDOUT_TARGET = '-';
+exports.baselineUsageText = `
+Migrate Baseline Command:
+
+  pgpm migrate baseline [<workspace|module>] [OPTIONS]
+
+  Record a plan's changes as already deployed WITHOUT executing any DDL, so a
+  database that already carries the schema (imported from a dump, restored, or
+  otherwise adopted from outside pgpm) is brought to the plan's head in the
+  pgpm_migrate ledger. A subsequent 'pgpm deploy' then runs only genuinely new
+  changes.
+
+  Each change is recorded through the same pgpm_migrate.deploy procedure a real
+  deploy uses, with log-only mode (empty script, p_log_only => TRUE), in plan
+  order.
+
+Options:
+  --help, -h              Show this help message
+  --emit-ledger <file|->  Write the log-only backfill SQL instead of applying
+                          it (- for stdout). Offline; no database is touched.
+                          The target must already have the pgpm_migrate schema
+                          (run 'pgpm migrate init' first).
+  --database <name>       Database to apply the baseline to (skips the prompt)
+  -y, --yes               Skip the confirmation prompt when applying
+  --no-tx                 Apply without wrapping each module in a transaction
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  pgpm migrate baseline ./my-app --emit-ledger baseline.sql
+  pgpm migrate baseline --database mydb
+  pgpm migrate baseline ./ws --emit-ledger -
+`;
+exports.default = async (argv, prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(exports.baselineUsageText);
+        process.exit(0);
+    }
+    const cwd = argv.cwd || process.cwd();
+    const spec = argv._?.filter(Boolean)[0] ?? cwd;
+    const modules = await (0, core_1.loadPlanSideModules)(spec, cwd);
+    const entries = await (0, core_1.baselineBackfillEntries)(modules);
+    if (entries.length === 0) {
+        log.warn('No plan changes with deploy scripts found; nothing to baseline.');
+        return argv;
+    }
+    const emitTarget = argv['emit-ledger'] ?? argv.emitLedger;
+    // Offline emit: write the log-only backfill SQL, touch no database.
+    if (typeof emitTarget === 'string' && emitTarget) {
+        const sql = (0, diff_1.emitLedgerBackfill)(entries);
+        if (emitTarget === STDOUT_TARGET) {
+            process.stdout.write(sql);
+        }
+        else {
+            const outPath = path.resolve(cwd, emitTarget);
+            (0, fs_1.writeFileSync)(outPath, sql);
+            log.success(`Wrote baseline backfill for ${entries.length} change(s) to ${outPath}`);
+        }
+        return argv;
+    }
+    // Apply: record every change log-only against the target database.
+    const database = await (0, database_1.getTargetDatabase)(argv, prompter, {
+        message: 'Select database to baseline'
+    });
+    const { yes } = await prompter.prompt(argv, [
+        {
+            name: 'yes',
+            type: 'confirm',
+            message: `Record ${entries.length} change(s) as deployed (log-only) in "${database}"?`,
+            required: true
+        }
+    ]);
+    if (!yes) {
+        log.info('Operation cancelled.');
+        return argv;
+    }
+    const config = (0, pg_env_1.getPgEnvOptions)({ database });
+    const useTransaction = argv.tx !== false;
+    const client = new core_1.PgpmMigrate(config);
+    try {
+        let recorded = 0;
+        let skipped = 0;
+        for (const mod of modules) {
+            const result = await client.deploy({
+                modulePath: mod.modulePath,
+                logOnly: true,
+                useTransaction
+            });
+            recorded += result.deployed.length;
+            skipped += result.skipped.length;
+        }
+        log.success(`Baseline complete in "${database}": ${recorded} change(s) recorded, ${skipped} already present.`);
+    }
+    finally {
+        await client.close();
+    }
+    return argv;
+};

package/commands/migrate.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const inquirerer_1 = require("inquirerer");
+const baseline_1 = __importDefault(require("./migrate/baseline"));
 const deps_1 = __importDefault(require("./migrate/deps"));
 // Migrate subcommands
 const init_1 = __importDefault(require("./migrate/init"));
@@ -13,7 +14,8 @@ const subcommandMap = {
     init: init_1.default,
     status: status_1.default,
     list: list_1.default,
-    deps: deps_1.default
+    deps: deps_1.default,
+    baseline: baseline_1.default
 };
 const migrateUsageText = `
 Migrate Commands:
@@ -22,6 +24,7 @@ Migrate Commands:
   pgpm migrate status    Show current migration status
   pgpm migrate list      List all changes (deployed and pending)
   pgpm migrate deps      Show change dependencies
+  pgpm migrate baseline  Record a plan as already deployed (log-only), adopting an existing database
 
 Options:
   --help, -h     Show this help message
@@ -63,7 +66,8 @@ function getSubcommandDescription(cmd) {
         init: 'Initialize migration tracking in database',
         status: 'Show current migration status',
         list: 'List all changes (deployed and pending)',
-        deps: 'Show change dependencies'
+        deps: 'Show change dependencies',
+        baseline: 'Record a plan as already deployed (log-only), adopting an existing database'
     };
     return descriptions[cmd] || '';
 }

package/esm/commands/deploy.js

@@ -1,8 +1,8 @@
 import { PgpmPackage } from '@pgpmjs/core';
 import { getEnvOptions } from '@pgpmjs/env';
 import { Logger } from '@pgpmjs/logger';
-import { execSync } from 'child_process';
-import { getPgEnvOptions, getSpawnEnvWithPg, } from 'pg-env';
+import { execFileSync } from 'child_process';
+import { getPgClientCommand, getPgEnvOptions, getSpawnEnvWithPg, } from 'pg-env';
 import { getActiveEngine, getTargetDatabase, resolvePackageAlias } from '../utils';
 import { selectPackage } from '../utils/module-utils';
 const deployUsageText = `
@@ -125,7 +125,8 @@ export default async (argv, prompter, _options) => {
     if (createdb) {
         if (capabilities.createdb) {
             log.info(`Creating database ${database}...`);
-            execSync(`createdb ${database}`, {
+            const [cmd, ...prefixArgs] = getPgClientCommand('createdb');
+            execFileSync(cmd, [...prefixArgs, database], {
                 env: getSpawnEnvWithPg(pgEnv)
             });
         }

package/esm/commands/diff.js

@@ -1,14 +1,13 @@
-import { PgpmMigrate } from '@pgpmjs/core';
-import { deltaChangesToRows, loadDiffSideFromDisk, sqlToDiffChanges } from '@pgpmjs/diff';
+import { buildLedgerReport, isDatabaseSpec, loadDiffSide, PgpmMigrate, resolveDatabaseSpec } from '@pgpmjs/core';
+import { deltaChangesToRows, resolveDiffSideKind } from '@pgpmjs/diff';
 import { Logger } from '@pgpmjs/logger';
 import { appendModule, CHANGE_GRANULARITIES, diffChangeSets, EXPORT_GRANULARITIES, isChangeGranularity, isExportGranularity, loadModule, withoutColumnOrder, writeModule } from '@pgpmjs/transform';
-import { spawn } from 'child_process';
 import * as fs from 'fs';
 import { cliExitWithError, extractFirst } from 'inquirerer';
 import * as os from 'os';
 import * as path from 'path';
 import { getPgPool } from 'pg-cache';
-import { getPgEnvOptions, getSpawnEnvWithPg } from 'pg-env';
+import { getPgEnvOptions } from 'pg-env';
 import { emitModuleBundle, emitModuleSql, STDOUT_TARGET } from '../utils/module-projections';
 import { catalogDifferences, withScratchDatabases } from '../utils/scratch-db';
 const log = new Logger('diff');
@@ -26,6 +25,8 @@ Diff Command:
 Sides:
   <A> / <B> may each be:
     - a pgpm module directory (flattened in plan order)
+    - a pgpm workspace directory (every local module, in dependency order,
+      with package-qualified change names)
     - a raw .sql file
     - a live database: a postgres:// connection string, or db:<name>
       (uses PG* env for host/port/user; schema is read via pg_dump)
@@ -47,6 +48,16 @@ Options:
                            file (deparsed in plan order); - writes to stdout
   --emit-bundle <file>     Also project the delta to a content-addressed
                            .bundle.tar.gz archive
+  --ledger <db>            Read a database's pgpm_migrate ledger (db:<name> or a
+                           connection string) as the deployment cursor for side
+                           B, and report which of B's plan entries that database
+                           already has (identical / drifted / pending / orphaned
+                           / out-of-order). Combines with --emit-ledger.
+  --emit-ledger <file>     Write an idempotent pgpm_migrate backfill script that
+                           records B's already-satisfied changes without
+                           executing them. Satisfaction is semantic (identity-
+                           keyed against side A), so regenerated or reordered
+                           plans still classify as satisfied.
   --pkg <name>             Emitted migration package name (default: diff-migration)
   --granularity <level>    Granularity for emitted changes: atomic | object |
                            consolidated (default: object)
@@ -67,55 +78,22 @@ Examples:
   pgpm diff ./v1-module ./v2-module
   pgpm diff ./v1-module ./schema-v2.sql --json
   pgpm diff db:app_v1 db:app_v2 --emit-migration ./out --verify
+  pgpm diff db:prod ./workspace-v2 --ledger db:prod --emit-ledger ./backfill.sql \
+           --emit-migration ./out --pkg upgrade
 `;
 const NAMING_STYLES = ['directory', 'flat'];
-/** pg_dump a side's schema: `db:<name>` uses PG* env; DSNs pass through. */
-const dumpDatabase = async (spec) => {
-    const args = ['--schema-only', '--no-owner'];
-    let env = process.env;
-    if (spec.startsWith('db:')) {
-        const config = getPgEnvOptions({ database: spec.slice(3) });
-        env = getSpawnEnvWithPg(config);
-    }
-    else {
-        args.push('--dbname', spec);
+/** A plan-bearing on-disk side (workspace or module directory). */
+const isPlanSide = (spec, cwd) => {
+    if (isDatabaseSpec(spec))
+        return false;
+    try {
+        const kind = resolveDiffSideKind(path.resolve(cwd, spec));
+        return kind === 'workspace' || kind === 'module';
     }
-    return new Promise((resolve, reject) => {
-        const child = spawn('pg_dump', args, { env, stdio: ['ignore', 'pipe', 'pipe'] });
-        let out = '';
-        let err = '';
-        child.stdout.on('data', chunk => { out += chunk; });
-        child.stderr.on('data', chunk => { err += chunk; });
-        child.on('error', (e) => {
-            if (e.code === 'ENOENT') {
-                reject(new Error('pg_dump not found; ensure PostgreSQL client tools are installed and in PATH'));
-                return;
-            }
-            reject(e);
-        });
-        child.on('close', code => {
-            if (code === 0)
-                resolve(out);
-            else
-                reject(new Error(`pg_dump exited with code ${code}: ${err.trim()}`));
-        });
-    });
-};
-/** Resolve one side spec into diff input changes. */
-const loadSide = async (spec, cwd) => {
-    if (resolveDiffSideKindSafe(spec) === 'database') {
-        const label = spec.startsWith('db:') ? spec.slice(3) : spec;
-        return {
-            kind: 'database',
-            label,
-            changes: sqlToDiffChanges(await dumpDatabase(spec), label),
-            warnings: []
-        };
+    catch {
+        return false;
     }
-    return loadDiffSideFromDisk(path.resolve(cwd, spec));
 };
-/** `resolveDiffSideKind` without throwing on relative on-disk paths. */
-const resolveDiffSideKindSafe = (spec) => /^postgres(ql)?:\/\//.test(spec) || spec.startsWith('db:') ? 'database' : 'disk';
 /** Apply one diff side into a scratch database (module deploy or raw SQL). */
 const applySide = async (config, side, spec, cwd) => {
     if (side.kind === 'module') {
@@ -154,6 +132,29 @@ const runVerify = async (sideA, sideB, specA, specB, migrationDir, cwd) => {
         return catalogDifferences(cfgMigrated, cfgTarget, withoutColumnOrder);
     });
 };
+const printLedgerSummary = (report, ledgerSpec) => {
+    const counts = new Map();
+    for (const entry of report.classification.entries) {
+        counts.set(entry.status, (counts.get(entry.status) ?? 0) + 1);
+    }
+    const parts = [...counts.entries()].map(([status, n]) => `${n} ${status}`);
+    console.log(`Ledger (${ledgerSpec}): ${parts.join(', ') || 'empty plan'}.`);
+    if (report.classification.orphaned.length) {
+        console.log(`  Orphaned ledger entries (${report.classification.orphaned.length}):`);
+        for (const row of report.classification.orphaned) {
+            console.log(`    ${row.package}:${row.changeName}`);
+        }
+    }
+    if (report.classification.outOfOrder.length) {
+        console.log(`  Deployed out of plan order: ${report.classification.outOfOrder.join(', ')}`);
+    }
+    if (report.backfilled.length) {
+        console.log(`  Satisfied but unrecorded (backfillable): ${report.backfilled.length}`);
+    }
+    if (report.unprovable.length) {
+        console.log(`  Not provably satisfied (inert/partial; will deploy normally): ${report.unprovable.join(', ')}`);
+    }
+};
 const printSummary = (result, labelA, labelB) => {
     if (result.identical) {
         console.log(`No differences: ${labelA} and ${labelB} describe the same objects.`);
@@ -189,7 +190,7 @@ export default async (argv, prompter, _options) => {
     const { first: specB, newArgv: restArgv } = extractFirst(newArgv);
     argv = restArgv;
     if (!specA || !specB) {
-        await cliExitWithError('pgpm diff requires two sides: pgpm diff <A> <B> (module dir, .sql file, db:<name>, or connection string).');
+        await cliExitWithError('pgpm diff requires two sides: pgpm diff <A> <B> (module dir, workspace dir, .sql file, db:<name>, or connection string).');
     }
     const granularityRaw = argv.granularity ?? 'object';
     if (!isExportGranularity(granularityRaw)) {
@@ -227,6 +228,17 @@ export default async (argv, prompter, _options) => {
         : undefined;
     const sqlToStdout = emitSql === STDOUT_TARGET;
     const pkgName = argv.pkg || 'diff-migration';
+    const ledgerSpec = typeof argv.ledger === 'string' && argv.ledger ? argv.ledger : undefined;
+    const emitLedgerRaw = argv['emit-ledger'] ?? argv.emitLedger;
+    const emitLedgerTarget = typeof emitLedgerRaw === 'string' && emitLedgerRaw
+        ? path.resolve(cwd, emitLedgerRaw)
+        : undefined;
+    if (emitLedgerTarget && !ledgerSpec) {
+        await cliExitWithError('--emit-ledger requires --ledger <db> (the database whose pgpm_migrate ledger is backfilled).');
+    }
+    if (ledgerSpec && !isPlanSide(specB, cwd)) {
+        await cliExitWithError('--ledger requires side B to be a pgpm workspace or module directory (it needs a plan to classify).');
+    }
     if (appendModuleDir && (emitModuleDir || emitSql || emitBundle || verify)) {
         await cliExitWithError('--append-module is standalone; it cannot be combined with --emit-migration/--emit-module/--emit-sql/--emit-bundle/--verify.');
     }
@@ -234,8 +246,8 @@ export default async (argv, prompter, _options) => {
     let sideA;
     let sideB;
     try {
-        sideA = await loadSide(specA, cwd);
-        sideB = await loadSide(specB, cwd);
+        sideA = await loadDiffSide(specA, cwd);
+        sideB = await loadDiffSide(specB, cwd);
     }
     catch (err) {
         await cliExitWithError(err instanceof Error ? err.message : String(err));
@@ -247,6 +259,27 @@ export default async (argv, prompter, _options) => {
         ...sideB.warnings.map(w => `${sideB.label}: ${w}`),
         ...result.warnings
     ];
+    let ledgerReport;
+    if (ledgerSpec) {
+        ledgerReport = await buildLedgerReport({
+            config: resolveDatabaseSpec(ledgerSpec),
+            spec: specB,
+            cwd,
+            changes: sideB.changes,
+            diff: result
+        });
+        if (emitLedgerTarget) {
+            if (ledgerReport.backfillSql) {
+                fs.mkdirSync(path.dirname(emitLedgerTarget), { recursive: true });
+                fs.writeFileSync(emitLedgerTarget, ledgerReport.backfillSql);
+                if (!sqlToStdout && !json)
+                    log.success(`wrote ledger backfill (${ledgerReport.backfilled.length} change(s)) to ${emitLedgerTarget}`);
+            }
+            else if (!sqlToStdout && !json) {
+                log.info('no ledger backfill to emit (nothing satisfied-but-unrecorded).');
+            }
+        }
+    }
     if (json) {
         console.log(JSON.stringify({
             identical: result.identical,
@@ -258,15 +291,30 @@ export default async (argv, prompter, _options) => {
                 revert: c.revert,
                 verify: c.verify
             })),
-            warnings
+            warnings,
+            ...(ledgerReport
+                ? {
+                    ledger: {
+                        entries: ledgerReport.classification.entries,
+                        orphaned: ledgerReport.classification.orphaned,
+                        outOfOrder: ledgerReport.classification.outOfOrder,
+                        coverage: ledgerReport.coverage,
+                        backfilled: ledgerReport.backfilled,
+                        unprovable: ledgerReport.unprovable
+                    }
+                }
+                : {})
         }, null, 2));
     }
     else {
         for (const warning of warnings)
             console.warn(`diff: ${warning}`);
         // Keep stdout clean when the SQL projection is piped there.
-        if (!sqlToStdout)
+        if (!sqlToStdout) {
             printSummary(result, sideA.label, sideB.label);
+            if (ledgerReport)
+                printLedgerSummary(ledgerReport, ledgerSpec);
+        }
     }
     if (appendModuleDir) {
         const rows = deltaChangesToRows(result.changes);

package/esm/commands/dump.js

@@ -1,10 +1,10 @@
+import { pgDump } from '@pgpmjs/core';
 import { Logger } from '@pgpmjs/logger';
 import { QuoteUtils } from '@pgsql/quotes';
-import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import { getPgPool } from 'pg-cache';
-import { getPgEnvOptions, getSpawnEnvWithPg } from 'pg-env';
+import { getPgEnvOptions } from 'pg-env';
 import { getTargetDatabase } from '../utils';
 const log = new Logger('dump');
 const dumpUsageText = `
@@ -32,28 +32,6 @@ function nowStamp() {
     const pad = (n) => String(n).padStart(2, '0');
     return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
 }
-async function runPgDump(args, env) {
-    await new Promise((resolve, reject) => {
-        const child = spawn('pg_dump', args, {
-            env,
-            stdio: 'inherit',
-            shell: false
-        });
-        child.on('error', (err) => {
-            if (err.code === 'ENOENT') {
-                log.error('pg_dump not found; ensure PostgreSQL client tools are installed and in PATH');
-            }
-            reject(err);
-        });
-        child.on('close', (code) => {
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            reject(new Error(`pg_dump exited with code ${code ?? 1}`));
-        });
-    });
-}
 async function resolveDatabaseId(dbname, databaseIdRaw) {
     const pool = getPgPool(getPgEnvOptions({ database: dbname }));
     const res = await pool.query(`select id, name from metaschema_public.database order by name`);
@@ -140,16 +118,13 @@ export default async (argv, prompter, _options) => {
         log.info(`database id ${databaseIdInfo.id}`);
     }
     const pgEnv = getPgEnvOptions({ database: dbname });
-    const spawnEnv = getSpawnEnvWithPg(pgEnv);
-    const args = [
-        '--format=plain',
-        '--no-owner',
-        '--no-privileges',
-        '--file',
-        outPath,
-        dbname
-    ];
-    await runPgDump(args, spawnEnv);
+    await pgDump({
+        config: pgEnv,
+        format: 'plain',
+        noOwner: true,
+        noPrivileges: true,
+        file: outPath
+    });
     if (databaseIdInfo) {
         const pruneSql = await buildPruneSql(dbname, databaseIdInfo.id);
         // Use writeFileSync with 'a' flag for explicit append as requested

package/esm/commands/import.js

@@ -1,6 +1,8 @@
+import { buildBaselineBackfill } from '@pgpmjs/core';
 import { dumpCompatibilityWarnings, importDumpRows, linkTextualDeps, loadDumpSource } from '@pgpmjs/import';
 import { Logger } from '@pgpmjs/logger';
 import { CHANGE_GRANULARITIES, EXPORT_GRANULARITIES, isChangeGranularity, isExportGranularity, parsePartitionConfig, PartitionCycleError, partitionExportRows } from '@pgpmjs/transform';
+import { writeFileSync } from 'fs';
 import { cliExitWithError } from 'inquirerer';
 import * as path from 'path';
 import { checkOverwrite, writePackage } from '../utils/emit-package';
@@ -53,6 +55,12 @@ Options:
   --emit-bundle <file>     Also project the imported module into a
                           content-addressed .bundle.tar.gz. Same single-package
                           requirement as --emit-sql.
+  --baseline              After writing each package, also write a
+                          <pkg>/baseline.sql: an idempotent, log-only
+                          pgpm_migrate backfill recording every generated
+                          change as already deployed. Adopts the source
+                          database — apply the script (after 'pgpm migrate
+                          init'), then 'pgpm deploy' runs only real changes.
   --cwd <directory>       Working directory (default: current directory)
   --dry-run               Print the resulting plan/paths without writing
 
@@ -65,6 +73,7 @@ Examples:
   pgpm import ./sql-files --pkg my-app --out ./packages --with-data
   pgpm import dump.sql --pkg my-app --partition partition.json
   pgpm import dump.sql --pkg my-app --emit-sql my-app.sql
+  pgpm import dump.sql --pkg my-app --baseline
 `;
 const NAMING_STYLES = ['directory', 'flat'];
 export default async (argv, prompter, _options) => {
@@ -112,9 +121,13 @@ export default async (argv, prompter, _options) => {
     const emit = parseEmitProjectionTargets(argv, cwd);
     const emitRequested = hasEmitProjection(emit);
     const sqlToStdout = emit.emitSql === STDOUT_TARGET;
+    const baseline = Boolean(argv.baseline);
     if (emitRequested && dryRun) {
         await cliExitWithError('--emit-sql/--emit-bundle cannot be combined with --dry-run.');
     }
+    if (baseline && dryRun) {
+        await cliExitWithError('--baseline cannot be combined with --dry-run.');
+    }
     let source;
     try {
         source = loadDumpSource(path.resolve(cwd, input));
@@ -178,9 +191,11 @@ export default async (argv, prompter, _options) => {
             }
         }
         let firstDir;
+        const writtenDirs = [];
         for (const pkg of packages) {
             const dir = writePackage(outBase, pkg);
             firstDir ??= dir;
+            writtenDirs.push(dir);
             if (!sqlToStdout) {
                 log.success(`wrote ${pkg.rows.length} changes to ${dir}`);
             }
@@ -188,6 +203,14 @@ export default async (argv, prompter, _options) => {
         if (emitRequested && firstDir) {
             await projectModule(firstDir, emit, sqlToStdout ? undefined : msg => log.success(msg));
         }
+        if (baseline) {
+            for (const dir of writtenDirs) {
+                const { entries, backfillSql } = await buildBaselineBackfill(dir);
+                const baselinePath = path.join(dir, 'baseline.sql');
+                writeFileSync(baselinePath, backfillSql);
+                log.success(`wrote baseline backfill for ${entries.length} change(s) to ${baselinePath}`);
+            }
+        }
     }
     const { summary } = result;
     if (!sqlToStdout) {

package/esm/commands/migrate/baseline.js

@@ -0,0 +1,105 @@
+import { baselineBackfillEntries, loadPlanSideModules, PgpmMigrate } from '@pgpmjs/core';
+import { emitLedgerBackfill } from '@pgpmjs/diff';
+import { Logger } from '@pgpmjs/logger';
+import { writeFileSync } from 'fs';
+import * as path from 'path';
+import { getPgEnvOptions } from 'pg-env';
+import { getTargetDatabase } from '../../utils/database';
+const log = new Logger('migrate-baseline');
+const STDOUT_TARGET = '-';
+export const baselineUsageText = `
+Migrate Baseline Command:
+
+  pgpm migrate baseline [<workspace|module>] [OPTIONS]
+
+  Record a plan's changes as already deployed WITHOUT executing any DDL, so a
+  database that already carries the schema (imported from a dump, restored, or
+  otherwise adopted from outside pgpm) is brought to the plan's head in the
+  pgpm_migrate ledger. A subsequent 'pgpm deploy' then runs only genuinely new
+  changes.
+
+  Each change is recorded through the same pgpm_migrate.deploy procedure a real
+  deploy uses, with log-only mode (empty script, p_log_only => TRUE), in plan
+  order.
+
+Options:
+  --help, -h              Show this help message
+  --emit-ledger <file|->  Write the log-only backfill SQL instead of applying
+                          it (- for stdout). Offline; no database is touched.
+                          The target must already have the pgpm_migrate schema
+                          (run 'pgpm migrate init' first).
+  --database <name>       Database to apply the baseline to (skips the prompt)
+  -y, --yes               Skip the confirmation prompt when applying
+  --no-tx                 Apply without wrapping each module in a transaction
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  pgpm migrate baseline ./my-app --emit-ledger baseline.sql
+  pgpm migrate baseline --database mydb
+  pgpm migrate baseline ./ws --emit-ledger -
+`;
+export default async (argv, prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(baselineUsageText);
+        process.exit(0);
+    }
+    const cwd = argv.cwd || process.cwd();
+    const spec = argv._?.filter(Boolean)[0] ?? cwd;
+    const modules = await loadPlanSideModules(spec, cwd);
+    const entries = await baselineBackfillEntries(modules);
+    if (entries.length === 0) {
+        log.warn('No plan changes with deploy scripts found; nothing to baseline.');
+        return argv;
+    }
+    const emitTarget = argv['emit-ledger'] ?? argv.emitLedger;
+    // Offline emit: write the log-only backfill SQL, touch no database.
+    if (typeof emitTarget === 'string' && emitTarget) {
+        const sql = emitLedgerBackfill(entries);
+        if (emitTarget === STDOUT_TARGET) {
+            process.stdout.write(sql);
+        }
+        else {
+            const outPath = path.resolve(cwd, emitTarget);
+            writeFileSync(outPath, sql);
+            log.success(`Wrote baseline backfill for ${entries.length} change(s) to ${outPath}`);
+        }
+        return argv;
+    }
+    // Apply: record every change log-only against the target database.
+    const database = await getTargetDatabase(argv, prompter, {
+        message: 'Select database to baseline'
+    });
+    const { yes } = await prompter.prompt(argv, [
+        {
+            name: 'yes',
+            type: 'confirm',
+            message: `Record ${entries.length} change(s) as deployed (log-only) in "${database}"?`,
+            required: true
+        }
+    ]);
+    if (!yes) {
+        log.info('Operation cancelled.');
+        return argv;
+    }
+    const config = getPgEnvOptions({ database });
+    const useTransaction = argv.tx !== false;
+    const client = new PgpmMigrate(config);
+    try {
+        let recorded = 0;
+        let skipped = 0;
+        for (const mod of modules) {
+            const result = await client.deploy({
+                modulePath: mod.modulePath,
+                logOnly: true,
+                useTransaction
+            });
+            recorded += result.deployed.length;
+            skipped += result.skipped.length;
+        }
+        log.success(`Baseline complete in "${database}": ${recorded} change(s) recorded, ${skipped} already present.`);
+    }
+    finally {
+        await client.close();
+    }
+    return argv;
+};

package/esm/commands/migrate.js

@@ -1,4 +1,5 @@
 import { extractFirst } from 'inquirerer';
+import baseline from './migrate/baseline';
 import deps from './migrate/deps';
 // Migrate subcommands
 import init from './migrate/init';
@@ -8,7 +9,8 @@ const subcommandMap = {
     init,
     status,
     list,
-    deps
+    deps,
+    baseline
 };
 const migrateUsageText = `
 Migrate Commands:
@@ -17,6 +19,7 @@ Migrate Commands:
   pgpm migrate status    Show current migration status
   pgpm migrate list      List all changes (deployed and pending)
   pgpm migrate deps      Show change dependencies
+  pgpm migrate baseline  Record a plan as already deployed (log-only), adopting an existing database
 
 Options:
   --help, -h     Show this help message
@@ -58,7 +61,8 @@ function getSubcommandDescription(cmd) {
         init: 'Initialize migration tracking in database',
         status: 'Show current migration status',
         list: 'List all changes (deployed and pending)',
-        deps: 'Show change dependencies'
+        deps: 'Show change dependencies',
+        baseline: 'Record a plan as already deployed (log-only), adopting an existing database'
     };
     return descriptions[cmd] || '';
 }

package/esm/utils/doctor.js

@@ -1,5 +1,6 @@
 import { spawn } from 'child_process';
 import { readFileSync } from 'fs';
+import { getPgClientCommand } from 'pg-env';
 export const runCommand = (command, args) => {
     return new Promise((resolve) => {
         const child = spawn(command, args, { stdio: 'pipe' });
@@ -183,7 +184,8 @@ export function parsePsqlMajor(versionOutput) {
     return Number.isNaN(major) ? null : major;
 }
 export async function checkPsql(info, exec = runCommand) {
-    const result = await exec('psql', ['--version']);
+    const [cmd, ...prefixArgs] = getPgClientCommand('psql');
+    const result = await exec(cmd, [...prefixArgs, '--version']);
     if (result.code !== 0) {
         return {
             name: 'psql',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgpm",
-  "version": "5.21.2",
+  "version": "5.23.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PostgreSQL Package Manager - Database migration and package management CLI",
   "main": "index.js",
@@ -46,24 +46,24 @@
   },
   "dependencies": {
     "@inquirerer/utils": "^3.3.9",
-    "@pgpmjs/core": "^7.21.4",
-    "@pgpmjs/diff": "^0.1.2",
-    "@pgpmjs/env": "^2.40.3",
-    "@pgpmjs/export": "^1.15.3",
-    "@pgpmjs/import": "^0.2.0",
-    "@pgpmjs/logger": "^2.23.3",
-    "@pgpmjs/slice": "^0.13.9",
-    "@pgpmjs/transform": "^0.20.0",
-    "@pgpmjs/types": "^2.49.3",
-    "@pgsql/quotes": "^18.2.0",
+    "@pgpmjs/core": "^7.23.0",
+    "@pgpmjs/diff": "^0.3.0",
+    "@pgpmjs/env": "^2.41.1",
+    "@pgpmjs/export": "^1.16.1",
+    "@pgpmjs/import": "^0.3.1",
+    "@pgpmjs/logger": "^2.24.0",
+    "@pgpmjs/slice": "^0.14.1",
+    "@pgpmjs/transform": "^0.22.0",
+    "@pgpmjs/types": "^2.50.1",
+    "@pgsql/quotes": "^18.2.1",
     "appstash": "^0.7.0",
     "find-and-require-package-json": "^0.9.1",
     "genomic": "^5.6.2",
     "inquirerer": "^4.9.1",
     "js-yaml": "^4.1.0",
-    "pg-cache": "^3.24.3",
-    "pg-env": "^1.27.2",
-    "pgsql-deparser": "^18.3.1",
+    "pg-cache": "^3.25.1",
+    "pg-env": "^1.29.0",
+    "pgsql-deparser": "^18.3.3",
     "semver": "^7.8.1",
     "shelljs": "^0.10.0",
     "yanse": "^0.2.1"
@@ -80,5 +80,5 @@
     "pg",
     "pgsql"
   ],
-  "gitHead": "247e48d25b13524d992f00c1b2dc063884d1deb1"
+  "gitHead": "6da0705f8aa49d62dc2defb8b135b71674611483"
 }

package/utils/doctor.js

@@ -16,6 +16,7 @@ exports.checkNode = checkNode;
 exports.summarizeChecks = summarizeChecks;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
+const pg_env_1 = require("pg-env");
 const runCommand = (command, args) => {
     return new Promise((resolve) => {
         const child = (0, child_process_1.spawn)(command, args, { stdio: 'pipe' });
@@ -200,7 +201,8 @@ function parsePsqlMajor(versionOutput) {
     return Number.isNaN(major) ? null : major;
 }
 async function checkPsql(info, exec = exports.runCommand) {
-    const result = await exec('psql', ['--version']);
+    const [cmd, ...prefixArgs] = (0, pg_env_1.getPgClientCommand)('psql');
+    const result = await exec(cmd, [...prefixArgs, '--version']);
     if (result.code !== 0) {
         return {
             name: 'psql',