@pgpmjs/core 7.0.0 → 7.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/core",
-  "version": "7.0.0",
+  "version": "7.1.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PGPM Package and Migration Tools",
   "main": "index.js",
@@ -64,5 +64,5 @@
     "pgsql-parser": "^18.1.1",
     "yanse": "^0.2.1"
   },
-  "gitHead": "278757de075dcdaf3d7aca114644d64c10e49ba7"
+  "gitHead": "370a4754d9ad8caaa1446ff2337a7fbcd6ea75a5"
 }

package/packaging/package.d.ts

@@ -10,7 +10,29 @@ interface WritePackageOptions extends PackageModuleOptions {
     version: string;
     packageDir: string;
 }
-export declare const packageModule: (packageDir: string, { usePlan, extension, pretty, functionDelimiter, outputDiff }?: PackageModuleOptions) => Promise<{
+export interface MergeSqlOptions {
+    /** Strip `TransactionStmt`/`CreateExtensionStmt` before deparsing (extension mode) */
+    stripTransactions?: boolean;
+    /** Prepend a `\echo ... \quit` extension guard line */
+    echoExtensionName?: string;
+    pretty?: boolean;
+    functionDelimiter?: string;
+}
+/**
+ * Merge a concatenated SQL string into a single deparsed script.
+ *
+ * Parses the input, optionally strips transaction/extension statements, deparses
+ * with a stable function delimiter, and round-trips the result to detect any AST
+ * drift. This is the shared engine behind `packageModule` (whole-module packaging)
+ * and per-chunk rebundling — both must merge statements identically.
+ */
+export declare const mergeSqlStatements: (sql: string, { stripTransactions, echoExtensionName, pretty, functionDelimiter }?: MergeSqlOptions) => Promise<{
+    sql: string;
+    diff?: boolean;
+    tree1?: string;
+    tree2?: string;
+}>;
+export declare const packageModule: (packageDir: string, { usePlan, extension, pretty, functionDelimiter }?: PackageModuleOptions) => Promise<{
     sql: string;
     diff?: boolean;
     tree1?: string;

package/packaging/package.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writePackage = exports.packageModule = exports.cleanTree = void 0;
+exports.writePackage = exports.packageModule = exports.mergeSqlStatements = exports.cleanTree = void 0;
 const logger_1 = require("@pgpmjs/logger");
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -19,8 +19,8 @@ const cleanTree = (tree) => {
     });
 };
 exports.cleanTree = cleanTree;
-const filterStatements = (stmts, extension) => {
-    if (!extension)
+const filterStatements = (stmts, stripTransactions) => {
+    if (!stripTransactions)
         return stmts;
     return stmts.filter(node => {
         const stmt = node.stmt;
@@ -28,7 +28,40 @@ const filterStatements = (stmts, extension) => {
             !stmt.hasOwnProperty('CreateExtensionStmt');
     });
 };
-const packageModule = async (packageDir, { usePlan = true, extension = true, pretty = true, functionDelimiter = '$EOFCODE$', outputDiff = false } = {}) => {
+/**
+ * Merge a concatenated SQL string into a single deparsed script.
+ *
+ * Parses the input, optionally strips transaction/extension statements, deparses
+ * with a stable function delimiter, and round-trips the result to detect any AST
+ * drift. This is the shared engine behind `packageModule` (whole-module packaging)
+ * and per-chunk rebundling — both must merge statements identically.
+ */
+const mergeSqlStatements = async (sql, { stripTransactions = false, echoExtensionName, pretty = true, functionDelimiter = '$EOFCODE$' } = {}) => {
+    if (!sql?.trim()) {
+        return { sql: '' };
+    }
+    const parsed = await (0, pgsql_parser_1.parse)(sql);
+    parsed.stmts = filterStatements(parsed.stmts, stripTransactions);
+    const topLine = echoExtensionName
+        ? `\\echo Use "CREATE EXTENSION ${echoExtensionName}" to load this file. \\quit\n`
+        : '';
+    const finalSql = await (0, pgsql_deparser_1.deparse)(parsed, { pretty, functionDelimiter });
+    const tree1 = parsed.stmts;
+    const reparsed = await (0, pgsql_parser_1.parse)(finalSql);
+    const tree2 = filterStatements(reparsed.stmts, stripTransactions);
+    const results = {
+        sql: `${topLine}${finalSql}`,
+    };
+    const diff = JSON.stringify((0, exports.cleanTree)(tree1)) !== JSON.stringify((0, exports.cleanTree)(tree2));
+    if (diff) {
+        results.diff = true;
+        results.tree1 = JSON.stringify((0, exports.cleanTree)(tree1), null, 2);
+        results.tree2 = JSON.stringify((0, exports.cleanTree)(tree2), null, 2);
+    }
+    return results;
+};
+exports.mergeSqlStatements = mergeSqlStatements;
+const packageModule = async (packageDir, { usePlan = true, extension = true, pretty = true, functionDelimiter = '$EOFCODE$' } = {}) => {
     const resolveFn = usePlan ? resolve_1.resolveWithPlan : resolve_1.resolve;
     const sql = resolveFn(packageDir);
     if (!sql?.trim()) {
@@ -37,28 +70,12 @@ const packageModule = async (packageDir, { usePlan = true, extension = true, pre
     }
     const extname = (0, files_1.getExtensionName)(packageDir);
     try {
-        const parsed = await (0, pgsql_parser_1.parse)(sql);
-        parsed.stmts = filterStatements(parsed.stmts, extension);
-        const topLine = extension
-            ? `\\echo Use "CREATE EXTENSION ${extname}" to load this file. \\quit\n`
-            : '';
-        const finalSql = await (0, pgsql_deparser_1.deparse)(parsed, {
+        return await (0, exports.mergeSqlStatements)(sql, {
+            stripTransactions: extension,
+            echoExtensionName: extension ? extname : undefined,
             pretty,
-            functionDelimiter
+            functionDelimiter,
         });
-        const tree1 = parsed.stmts;
-        const reparsed = await (0, pgsql_parser_1.parse)(finalSql);
-        const tree2 = filterStatements(reparsed.stmts, extension);
-        const results = {
-            sql: `${topLine}${finalSql}`,
-        };
-        const diff = JSON.stringify((0, exports.cleanTree)(tree1)) !== JSON.stringify((0, exports.cleanTree)(tree2));
-        if (diff) {
-            results.diff = true;
-            results.tree1 = JSON.stringify((0, exports.cleanTree)(tree1), null, 2);
-            results.tree2 = JSON.stringify((0, exports.cleanTree)(tree2), null, 2);
-        }
-        return results;
     }
     catch (e) {
         log.error(`❌ Failed to parse SQL for ${packageDir}`);

package/rebundle/index.d.ts

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

package/rebundle/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./rebundle"), exports);
+__exportStar(require("./module"), exports);
+__exportStar(require("./workspace"), exports);

package/rebundle/module.d.ts

@@ -0,0 +1,23 @@
+import { Chunk, RebundleModuleOptions, RebundleModuleResult } from './types';
+export declare const SCRIPT_DIRS: readonly ["deploy", "revert", "verify"];
+export type ScriptDir = (typeof SCRIPT_DIRS)[number];
+/**
+ * Merge one chunk's member scripts (in the correct order per direction) into a
+ * single deparsed, single-transaction migration string. Shared by the
+ * single-module (`rebundleModule`) and workspace (`rebundleWorkspace`) emitters.
+ */
+export declare function mergeChunkScript(sourceDir: string, chunk: Chunk, scriptType: ScriptDir, opts?: {
+    pretty?: boolean;
+    functionDelimiter?: string;
+}): Promise<string>;
+/**
+ * Materialize a rebundled module: merge each chunk's member scripts into a
+ * single deparsed migration (reusing `packageModule`'s merge engine), write the
+ * chunk-quotient plan, and verify the result is byte-identical when packaged.
+ *
+ * Reuses existing plumbing throughout — `rebundlePlan` for the chunk model,
+ * `mergeSqlStatements`/`packageModule` for statement merging and the gate,
+ * `generatePlanContent` for the chunk plan, and the source control/Makefile
+ * verbatim.
+ */
+export declare function rebundleModule(sourceDir: string, options: RebundleModuleOptions): Promise<RebundleModuleResult>;

package/rebundle/module.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCRIPT_DIRS = void 0;
+exports.mergeChunkScript = mergeChunkScript;
+exports.rebundleModule = rebundleModule;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const parser_1 = require("../files/plan/parser");
+const package_1 = require("../packaging/package");
+const slice_1 = require("../slice/slice");
+const rebundle_1 = require("./rebundle");
+exports.SCRIPT_DIRS = ['deploy', 'revert', 'verify'];
+/**
+ * Wrap a merged chunk body in a single transaction. Deploy/revert commit;
+ * verify rolls back (a verify script must leave no trace). The individual
+ * member files' own BEGIN/COMMIT were stripped during the merge, so each
+ * rebundled chunk deploys as exactly one transaction.
+ */
+function wrapTransaction(body, scriptType) {
+    const trimmed = body.trim();
+    const tail = scriptType === 'verify' ? 'ROLLBACK;' : 'COMMIT;';
+    return `BEGIN;\n\n${trimmed}\n\n${tail}\n`;
+}
+/**
+ * Merge one chunk's member scripts (in the correct order per direction) into a
+ * single deparsed, single-transaction migration string. Shared by the
+ * single-module (`rebundleModule`) and workspace (`rebundleWorkspace`) emitters.
+ */
+async function mergeChunkScript(sourceDir, chunk, scriptType, opts = {}) {
+    const merged = await (0, package_1.mergeSqlStatements)((0, rebundle_1.assembleChunkSql)(sourceDir, chunk, scriptType), {
+        stripTransactions: true,
+        pretty: opts.pretty ?? true,
+        functionDelimiter: opts.functionDelimiter ?? '$EOFCODE$',
+    });
+    return wrapTransaction(merged.sql, scriptType);
+}
+/**
+ * Copy any top-level files (control, Makefile, package.json, README, ...) from
+ * the source module, excluding the plan and the per-change script directories
+ * which are regenerated. The rebundled module stays the same extension — same
+ * name, same control `requires` — only its internal change set collapses.
+ */
+function copyModuleMetadata(sourceDir, outputDir) {
+    for (const entry of (0, fs_1.readdirSync)(sourceDir, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            continue;
+        if (entry.name === 'pgpm.plan')
+            continue;
+        (0, fs_1.copyFileSync)((0, path_1.join)(sourceDir, entry.name), (0, path_1.join)(outputDir, entry.name));
+    }
+}
+/**
+ * Materialize a rebundled module: merge each chunk's member scripts into a
+ * single deparsed migration (reusing `packageModule`'s merge engine), write the
+ * chunk-quotient plan, and verify the result is byte-identical when packaged.
+ *
+ * Reuses existing plumbing throughout — `rebundlePlan` for the chunk model,
+ * `mergeSqlStatements`/`packageModule` for statement merging and the gate,
+ * `generatePlanContent` for the chunk plan, and the source control/Makefile
+ * verbatim.
+ */
+async function rebundleModule(sourceDir, options) {
+    const { outputDir, overwrite = false, pretty = true, functionDelimiter = '$EOFCODE$', ...strategy } = options;
+    if ((0, fs_1.existsSync)(outputDir) && (0, fs_1.readdirSync)(outputDir).length > 0 && !overwrite) {
+        throw new Error(`Output directory is not empty: ${outputDir}. Pass overwrite: true to replace.`);
+    }
+    const plan = (0, rebundle_1.rebundlePlan)(sourceDir, strategy);
+    // Tags anchor on the last member of the chunk that sealed at them; remap each
+    // to its chunk name so `deploy --to @tag` still lands on a real change.
+    const parsed = (0, parser_1.parsePlanFile)((0, path_1.join)(sourceDir, 'pgpm.plan'));
+    const sourceTags = parsed.data?.tags ?? [];
+    const memberToChunk = new Map();
+    for (const chunk of plan.chunks) {
+        for (const member of chunk.deploy)
+            memberToChunk.set(member, chunk.name);
+    }
+    const remappedTags = sourceTags.map(tag => ({
+        ...tag,
+        change: memberToChunk.get(tag.change) ?? tag.change,
+    }));
+    (0, fs_1.mkdirSync)(outputDir, { recursive: true });
+    for (const dir of exports.SCRIPT_DIRS)
+        (0, fs_1.mkdirSync)((0, path_1.join)(outputDir, dir), { recursive: true });
+    copyModuleMetadata(sourceDir, outputDir);
+    const written = [];
+    for (const chunk of plan.chunks) {
+        const paths = { chunk: chunk.name };
+        for (const dir of exports.SCRIPT_DIRS) {
+            const merged = await (0, package_1.mergeSqlStatements)((0, rebundle_1.assembleChunkSql)(sourceDir, chunk, dir), {
+                stripTransactions: true,
+                pretty,
+                functionDelimiter,
+            });
+            const rel = (0, path_1.join)(dir, `${chunk.name}.sql`);
+            (0, fs_1.writeFileSync)((0, path_1.join)(outputDir, rel), wrapTransaction(merged.sql, dir));
+            paths[dir] = rel;
+        }
+        written.push(paths);
+    }
+    // Chunk-quotient plan: one change per chunk, deps are earlier chunk names.
+    const planEntries = plan.chunks.map(chunk => ({
+        name: chunk.name,
+        dependencies: chunk.dependencies,
+    }));
+    (0, fs_1.writeFileSync)((0, path_1.join)(outputDir, 'pgpm.plan'), (0, slice_1.generatePlanContent)(plan.project, planEntries, remappedTags));
+    // Byte-identical gate: packaging the source and the rebundled module must
+    // produce the same consolidated extension SQL.
+    const sourcePkg = await (0, package_1.packageModule)(sourceDir, { pretty, functionDelimiter });
+    const outputPkg = await (0, package_1.packageModule)(outputDir, { pretty, functionDelimiter });
+    const invariant = {
+        ok: sourcePkg.sql === outputPkg.sql,
+        sourceDiff: !!sourcePkg.diff,
+        outputDiff: !!outputPkg.diff,
+    };
+    return { ...plan, outputDir, written, invariant };
+}

package/rebundle/rebundle.d.ts

@@ -0,0 +1,26 @@
+import { Chunk, RebundleResult, RebundleStrategy } from './types';
+/**
+ * Compute a rebundle plan for a pgpm module directory.
+ *
+ * Uses the existing plan parser, dependency graph, and package-dependency /
+ * deploy-order primitives from the slicer — chunks are treated exactly like
+ * packages for dependency and ordering purposes. No plan re-parsing or path
+ * logic is reinvented here.
+ */
+export declare function rebundlePlan(moduleDir: string, strategy?: RebundleStrategy): RebundleResult;
+/**
+ * Assemble the merged SQL for one chunk in the given direction by concatenating
+ * its member script files — the same file-concatenation `resolveWithPlan` uses,
+ * just scoped to the chunk. Members are already correctly ordered per direction.
+ */
+export declare function assembleChunkSql(moduleDir: string, chunk: Chunk, scriptType?: 'deploy' | 'revert' | 'verify'): string;
+/**
+ * Byte-identical gate: assembling all chunks in deploy order must reproduce the
+ * module's original resolved output in every direction the engine cares about
+ * (deploy topological, verify in deploy order, revert reversed). This is the
+ * invariant that makes any granularity-dial position safe.
+ */
+export declare function verifyRebundleInvariant(moduleDir: string, result: RebundleResult): {
+    ok: boolean;
+    mismatches: ('deploy' | 'revert' | 'verify')[];
+};

package/rebundle/rebundle.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rebundlePlan = rebundlePlan;
+exports.assembleChunkSql = assembleChunkSql;
+exports.verifyRebundleInvariant = verifyRebundleInvariant;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const parser_1 = require("../files/plan/parser");
+const resolve_1 = require("../resolution/resolve");
+const slice_1 = require("../slice/slice");
+const parser_2 = require("../files/plan/parser");
+/**
+ * Derive the boundary key for a change under the given strategy.
+ * Consecutive changes sharing a key may be merged into the same chunk.
+ */
+function boundaryKey(changeName, strategy) {
+    if (strategy.boundary === 'none')
+        return '';
+    const folderKey = () => (0, slice_1.extractPackageFromPath)(changeName, strategy.depth ?? 1, strategy.prefixToStrip ?? 'schemas');
+    if (strategy.boundary === 'category') {
+        // Classifier/facts-driven seam: the caller decides each change's category;
+        // fall back to the folder key for changes it doesn't classify.
+        const category = strategy.categoryOf?.(changeName);
+        return category ?? folderKey();
+    }
+    return folderKey();
+}
+/**
+ * Assign changes to chunks by walking the source plan in order and greedily
+ * accumulating consecutive changes that share a boundary key, sealing a chunk
+ * when the key changes, the size cap is reached, or a member carries a tag
+ * (tags mark points you can `deploy --to @tag`, so they must stay chunk seams).
+ *
+ * Because chunks are contiguous runs of the plan, member and chunk order both
+ * follow the source, which is what guarantees byte-identical output.
+ */
+function assignChunks(orderedChanges, graph, strategy) {
+    const chunks = [];
+    const seen = new Map();
+    const maxSize = strategy.maxChunkSize && strategy.maxChunkSize > 0 ? strategy.maxChunkSize : Infinity;
+    let current = null;
+    const seal = () => {
+        current = null;
+    };
+    for (const change of orderedChanges) {
+        const key = boundaryKey(change, strategy);
+        const changeHasTag = (graph.tags.get(change)?.length ?? 0) > 0;
+        if (current &&
+            current.key === key &&
+            current.members.length < maxSize) {
+            current.members.push(change);
+        }
+        else {
+            // Deterministic, collision-free chunk name: boundary key (or 'chunk'),
+            // suffixed with an ordinal when the same key splits across size caps.
+            const base = key || 'chunk';
+            const ordinal = (seen.get(base) ?? 0) + 1;
+            seen.set(base, ordinal);
+            const name = ordinal === 1 ? base : `${base}~${ordinal}`;
+            current = { name, members: [change], key };
+            chunks.push(current);
+        }
+        // A member that is a tag anchor seals the chunk after inclusion.
+        if (changeHasTag)
+            seal();
+    }
+    return chunks.map(({ name, members }) => ({ name, members }));
+}
+/**
+ * Compute a rebundle plan for a pgpm module directory.
+ *
+ * Uses the existing plan parser, dependency graph, and package-dependency /
+ * deploy-order primitives from the slicer — chunks are treated exactly like
+ * packages for dependency and ordering purposes. No plan re-parsing or path
+ * logic is reinvented here.
+ */
+function rebundlePlan(moduleDir, strategy = {}) {
+    const planPath = (0, path_1.join)(moduleDir, 'pgpm.plan');
+    const planResult = (0, parser_2.parsePlanFile)(planPath);
+    if (!planResult.data) {
+        const msg = planResult.errors?.map(e => `Line ${e.line}: ${e.message}`).join('\n') || 'Unknown error';
+        throw new Error(`Failed to parse plan file: ${msg}`);
+    }
+    const graph = (0, slice_1.buildDependencyGraph)(planResult.data);
+    const orderedChanges = planResult.data.changes.map(c => c.name);
+    const warnings = [];
+    const rawChunks = assignChunks(orderedChanges, graph, strategy);
+    // Reverse lookup change -> chunk, reusing slice's package-dep machinery.
+    const assignments = new Map();
+    const changeToChunk = new Map();
+    for (const chunk of rawChunks) {
+        assignments.set(chunk.name, new Set(chunk.members));
+        for (const member of chunk.members)
+            changeToChunk.set(member, chunk.name);
+    }
+    const chunkDeps = (0, slice_1.buildPackageDependencies)(graph, assignments);
+    const cycle = (0, slice_1.detectPackageCycle)(chunkDeps);
+    if (cycle) {
+        warnings.push({
+            type: 'cycle_detected',
+            message: `Chunk cycle detected: ${cycle.join(' -> ')}`,
+            suggestedAction: 'Widen the boundary or raise maxChunkSize so cyclic changes share a chunk',
+        });
+    }
+    const deployOrder = (0, slice_1.computeDeployOrder)(chunkDeps);
+    // Because chunks are contiguous runs of the source plan, the greedy creation
+    // order is already a valid deploy order. If the dependency-derived order
+    // disagrees, the boundary split a back-edge — surface it rather than silently
+    // reordering (that would break byte-identical output).
+    const creationOrder = rawChunks.map(c => c.name);
+    const orderMatches = deployOrder.length === creationOrder.length &&
+        deployOrder.every((name, i) => name === creationOrder[i]);
+    if (!orderMatches) {
+        warnings.push({
+            type: 'heavy_cross_deps',
+            message: 'Chunk deploy order differs from source order; a boundary split a dependency edge',
+            suggestedAction: 'Adjust the boundary/maxChunkSize so dependent changes stay contiguous',
+        });
+    }
+    const chunkByName = new Map(rawChunks.map(c => [c.name, c.members]));
+    const chunks = creationOrder.map(name => {
+        const members = chunkByName.get(name);
+        return {
+            name,
+            deploy: members,
+            verify: members,
+            revert: [...members].reverse(),
+            dependencies: [...(chunkDeps.get(name) ?? new Set())].sort(),
+        };
+    });
+    return {
+        chunks,
+        deployOrder: creationOrder,
+        warnings,
+        sourceChanges: planResult.data.changes,
+        project: planResult.data.package,
+    };
+}
+/**
+ * Assemble the merged SQL for one chunk in the given direction by concatenating
+ * its member script files — the same file-concatenation `resolveWithPlan` uses,
+ * just scoped to the chunk. Members are already correctly ordered per direction.
+ */
+function assembleChunkSql(moduleDir, chunk, scriptType = 'deploy') {
+    const members = scriptType === 'revert' ? chunk.revert : scriptType === 'verify' ? chunk.verify : chunk.deploy;
+    const parts = [];
+    for (const change of members) {
+        parts.push((0, fs_1.readFileSync)((0, path_1.join)(moduleDir, scriptType, `${change}.sql`), 'utf-8'));
+    }
+    return parts.join('\n');
+}
+/**
+ * Byte-identical gate: assembling all chunks in deploy order must reproduce the
+ * module's original resolved output in every direction the engine cares about
+ * (deploy topological, verify in deploy order, revert reversed). This is the
+ * invariant that makes any granularity-dial position safe.
+ */
+function verifyRebundleInvariant(moduleDir, result) {
+    const mismatches = [];
+    const assembled = (scriptType) => {
+        const chunks = scriptType === 'revert' ? [...result.chunks].reverse() : result.chunks;
+        return chunks.map(chunk => assembleChunkSql(moduleDir, chunk, scriptType)).join('\n');
+    };
+    // deploy / revert have canonical resolvers; verify concatenates in deploy order.
+    const originalVerify = (0, parser_1.getChanges)((0, path_1.join)(moduleDir, 'pgpm.plan'))
+        .map(change => (0, fs_1.readFileSync)((0, path_1.join)(moduleDir, 'verify', `${change}.sql`), 'utf-8'))
+        .join('\n');
+    if (assembled('deploy') !== (0, resolve_1.resolveWithPlan)(moduleDir, 'deploy'))
+        mismatches.push('deploy');
+    if (assembled('revert') !== (0, resolve_1.resolveWithPlan)(moduleDir, 'revert'))
+        mismatches.push('revert');
+    if (assembled('verify') !== originalVerify)
+        mismatches.push('verify');
+    return { ok: mismatches.length === 0, mismatches };
+}