@hominis/fireforge 0.30.0 → 0.31.0

package/dist/src/commands/furnace/chrome-doc-templates.js

@@ -20,7 +20,7 @@
  * Exposed as a named constant so test code and external checks can
  * reference the exact attribute name without hardcoding the string.
  */
-export const FURNACE_CHROME_DOC_SENTINEL = 'data-furnace-chrome-doc';
+const FURNACE_CHROME_DOC_SENTINEL = 'data-furnace-chrome-doc';
 /**
  * XHTML shell for a top-level chrome document.
  *

package/dist/src/commands/furnace/create-dry-run.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedTestStyle } from './create.js';
+import type { ResolvedTestStyle } from '../../types/furnace.js';
 export interface DryRunPlanInput {
     componentName: string;
     localized: boolean;

package/dist/src/commands/furnace/create.d.ts

@@ -1,6 +1,5 @@
 import type { FurnaceCreateOptions } from '../../types/commands/index.js';
-/** Resolved test-harness selection for a `furnace create` run. */
-export type ResolvedTestStyle = 'mochikit' | 'browser-chrome' | 'xpcshell' | 'none';
+import type { ResolvedTestStyle } from '../../types/furnace.js';
 /**
  * Collapses `--with-tests`, `--xpcshell`, and `--test-style` into the single
  * scaffold dispatch used inside the mutation phase.

package/dist/src/commands/furnace/deploy.js

@@ -1,16 +1,13 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { applyAllComponents, applyCustomComponent, applyOverrideComponent, computeComponentChecksums, prefixChecksums, } from '../../core/furnace-apply.js';
+import { applyAllComponents, computeComponentChecksums, prefixChecksums, } from '../../core/furnace-apply.js';
 import { logApplyResult } from '../../core/furnace-apply-output.js';
 import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, updateFurnaceState, } from '../../core/furnace-config.js';
-import { resolveFtlDir } from '../../core/furnace-constants.js';
-import { resolveFurnaceMarkerComment } from '../../core/furnace-marker.js';
-import { recordFurnaceRollbackFailure, runFurnaceMutation, } from '../../core/furnace-operation.js';
-import { createRollbackJournal, restoreRollbackJournalOrThrow, } from '../../core/furnace-rollback.js';
+import { reportJsconfigPathsSync } from '../../core/furnace-jsconfig.js';
+import { runFurnaceMutation } from '../../core/furnace-operation.js';
 import { findOverrideBaseVersionDrift, formatOverrideBaseVersionDriftError, formatOverrideBaseVersionDriftWarning, } from '../../core/furnace-version-drift.js';
 import { FurnaceError } from '../../errors/furnace.js';
-import { toError } from '../../utils/errors.js';
 import { pathExists } from '../../utils/fs.js';
 import { info, intro, note, outro, spinner, warn } from '../../utils/logger.js';
 import { runDeployValidation } from './validation-output.js';
@@ -116,115 +113,42 @@ async function persistSingleComponentState(projectRoot, appliedEntry, furnacePat
         lastApply: new Date().toISOString(),
     }));
 }
-/**
- * True when an applied-result carries any signal that the deploy did not
- * complete cleanly. Any such signal must trigger the rollback journal and
- * must suppress state persistence, so both call sites read from here.
- *
- * An apply failure on a single-component deploy means one of:
- *   - `result.errors` has an entry (the apply body threw)
- *   - an `applied[].stepErrors` entry is present (a registration step
- *     failed after the copy succeeded)
- *
- * Both are treated identically for atomicity purposes: rollback runs,
- * state stays on the previous checkpoint, and the caller raises a deploy
- * failure so the operator sees the error.
- */
-function namedDeployHasFailures(result) {
-    return result.errors.length > 0 || getStepFailureCount(result) > 0;
-}
-async function restoreNamedDeployRollback(rollbackJournal, name, projectRoot) {
-    if (!rollbackJournal)
-        return;
-    try {
-        await restoreRollbackJournalOrThrow(rollbackJournal, `Furnace deploy failed for "${name}"`);
-    }
-    catch (rollbackError) {
-        if (projectRoot) {
-            await recordFurnaceRollbackFailure(projectRoot, 'deploy-rollback', `component "${name}": ${toError(rollbackError).message}`);
-        }
-        throw rollbackError;
-    }
-}
 /**
  * Applies a single named override or custom component in targeted deploy mode.
  *
- * Atomicity contract: the helper owns a single rollback journal for the
- * deploy. If any apply path fails (thrown error or step error), the journal
- * restores the engine to its pre-deploy state and the returned `result` is
- * still reported as failed to the caller. The caller must consult
- * {@link shouldPersistNamedDeployState} before touching furnace-state.json —
- * partial checksums must never be persisted on top of a rollback.
+ * Delegates to {@link applyAllComponents} with a `componentName` filter so
+ * targeted deploys run the exact same pipeline as deploy-all — including
+ * workspace-deletion detection, engine orphan undeploy, and jar.mn /
+ * customElements.js re-sync. The previous implementation called the
+ * per-component apply helpers directly and never pruned: renaming a helper
+ * file in the workspace left the old deployed file and its stale jar.mn
+ * line in the engine (field report D1).
+ *
+ * `persistState: false` is load-bearing: the batch persist path *replaces*
+ * `appliedChecksums` wholesale with only this run's entries, which for a
+ * named deploy would wipe every other component's state. Named deploy keeps
+ * its per-component state merge ({@link persistSingleComponentState}) and
+ * its atomicity gate ({@link shouldPersistNamedDeployState}) at the call
+ * site. Rollback on failure happens inside `applyAllComponents`; the
+ * journal returned on success is ignored (the deploy keeps its files).
  *
  * @param name - Component name to apply
- * @param engineDir - Firefox engine source directory
- * @param furnacePaths - Resolved Furnace workspace paths
  * @param config - Loaded Furnace configuration
  * @param isDryRun - Whether file writes should be skipped
  * @returns Apply result for the named component, or `stock` for stock-only entries
  */
-async function applyNamedComponent(name, engineDir, furnacePaths, config, ftlDir, isDryRun, operationContext, projectRoot, markerComment) {
-    const rollbackJournal = isDryRun ? undefined : createRollbackJournal();
-    if (rollbackJournal && operationContext) {
-        operationContext.registerJournal(rollbackJournal);
-    }
-    const result = {
-        applied: [],
-        skipped: [],
-        errors: [],
-        actions: [],
-    };
-    const overrideConfig = config.overrides[name];
-    const customConfig = config.custom[name];
-    if (overrideConfig) {
-        const componentDir = join(furnacePaths.overridesDir, name);
-        if (!(await pathExists(componentDir))) {
-            throw new FurnaceError(`Component directory not found: components/overrides/${name}`, name);
-        }
-        try {
-            const { affectedPaths: filesAffected, actions } = await applyOverrideComponent(engineDir, name, componentDir, overrideConfig, ftlDir, isDryRun, rollbackJournal);
-            if (isDryRun && actions) {
-                result.actions = actions;
-            }
-            result.applied.push({ name, type: 'override', filesAffected });
-        }
-        catch (error) {
-            result.errors.push({ name, error: toError(error).message });
+async function applyNamedComponent(name, config, isDryRun, projectRoot, operationContext) {
+    if (!(name in config.overrides) && !(name in config.custom)) {
+        if (config.stock.includes(name)) {
+            return 'stock';
         }
-        if (!isDryRun && namedDeployHasFailures(result)) {
-            await restoreNamedDeployRollback(rollbackJournal, name, projectRoot);
-        }
-        return result;
+        throw new FurnaceError(`Component "${name}" not found in furnace.json.`, name);
     }
-    if (customConfig) {
-        const componentDir = join(furnacePaths.customDir, name);
-        if (!(await pathExists(componentDir))) {
-            throw new FurnaceError(`Component directory not found: components/custom/${name}`, name);
-        }
-        try {
-            const { affectedPaths: filesAffected, stepErrors, actions, } = await applyCustomComponent(engineDir, name, componentDir, customConfig, ftlDir, isDryRun, rollbackJournal, markerComment !== undefined ? { markerComment } : {});
-            if (isDryRun && actions) {
-                result.actions = actions;
-            }
-            result.applied.push({
-                name,
-                type: 'custom',
-                filesAffected,
-                ...(stepErrors.length > 0 ? { stepErrors } : {}),
-            });
-        }
-        catch (error) {
-            result.errors.push({ name, error: toError(error).message });
-        }
-        if (!isDryRun && namedDeployHasFailures(result)) {
-            await restoreNamedDeployRollback(rollbackJournal, name, projectRoot);
-        }
-        return result;
-    }
-    if (config.stock.includes(name)) {
-        return 'stock';
-    }
-    throw new FurnaceError(`Component "${name}" not found in furnace.json.`, name);
+    return applyAllComponents(projectRoot, isDryRun, {
+        componentName: name,
+        persistState: false,
+        ...(operationContext ? { operationContext } : {}),
+    });
 }
 /**
  * Prints the deploy summary after apply and validation complete.
@@ -293,7 +217,7 @@ export async function furnaceDeployCommand(projectRoot, name, options = {}) {
         throw new FurnaceError('No furnace.json found. Run "fireforge furnace create" or "fireforge furnace override" to get started.');
     }
     const config = await loadFurnaceConfig(projectRoot);
-    const [furnacePaths, ftlDir] = [getFurnacePaths(projectRoot), resolveFtlDir(config.ftlBasePath)];
+    const furnacePaths = getFurnacePaths(projectRoot);
     const overrideCount = Object.keys(config.overrides).length;
     const customCount = Object.keys(config.custom).length;
     if (overrideCount === 0 && customCount === 0) {
@@ -306,14 +230,6 @@ export async function furnaceDeployCommand(projectRoot, name, options = {}) {
     // the plan before deciding whether to refresh the override or acknowledge
     // the new baseline in furnace.json.
     const forgeConfig = await loadConfig(projectRoot);
-    // 2026-04-26 eval Finding 6: when `markerComment` is unset in
-    // fireforge.json, default it to `binaryName.toUpperCase()` so the
-    // furnace-emitted edits to upstream files satisfy
-    // `lintModificationComments` on the next `lint`/`export` round-trip.
-    // The lint rule keys on the same uppercased binaryName, so the
-    // implicit default is identical to what the rule expects. Threaded
-    // through `applyNamedComponent` below.
-    const resolvedMarkerComment = resolveFurnaceMarkerComment(forgeConfig);
     const driftEntries = findOverrideBaseVersionDrift(config, forgeConfig.firefox.version);
     const force = options.force ?? false;
     const scopedDrift = name ? driftEntries.filter((entry) => entry.name === name) : driftEntries;
@@ -326,7 +242,7 @@ export async function furnaceDeployCommand(projectRoot, name, options = {}) {
     // `furnace deploy` runs only contend on the actual mutation.
     const applyOutcome = await runFurnaceMutation(projectRoot, 'deploy-rollback', async (ctx) => {
         if (name) {
-            const namedApplyResult = await applyNamedComponent(name, paths.engine, furnacePaths, config, ftlDir, isDryRun, ctx, projectRoot, resolvedMarkerComment);
+            const namedApplyResult = await applyNamedComponent(name, config, isDryRun, projectRoot, ctx);
             if (namedApplyResult === 'stock') {
                 return { kind: 'stock' };
             }
@@ -354,6 +270,12 @@ export async function furnaceDeployCommand(projectRoot, name, options = {}) {
     const result = applyOutcome.result;
     applySpinner.stop(isDryRun ? 'Planned actions calculated' : 'Components applied');
     logApplyResult(result, isDryRun);
+    // Keep the consumer jsconfig's chrome-module `paths` in step with the
+    // deployed module set (field report D3). Only after a clean apply —
+    // a rolled-back deploy must not advance the typecheck mapping either.
+    if (result.errors.length === 0 && getStepFailureCount(result) === 0) {
+        await reportJsconfigPathsSync(projectRoot, config, isDryRun);
+    }
     // --- Step 2: Validate (read-only, runs even in dry-run to show what would fail) ---
     if (options.skipValidate) {
         const applyErrors = result.errors.length + getStepFailureCount(result);

package/dist/src/commands/furnace/refresh.js

@@ -158,6 +158,54 @@ async function refreshSingleOverride(projectRoot, name, options = {}) {
     }, { dryRun });
     return { results, currentVersion };
 }
+/**
+ * Refreshes every override sequentially, tallying merged/conflict/
+ * unchanged file counts. Per-override errors are expected (warned and
+ * recorded as failures) and do not abort the batch; only an error that
+ * escapes this function entirely warrants the caller's journal rollback.
+ */
+async function runBatchRefresh(projectRoot, overrideNames, options) {
+    let totalMerged = 0;
+    let totalConflicts = 0;
+    let totalUnchanged = 0;
+    let totalSkipped = 0;
+    const conflictComponents = [];
+    const failedOverrides = [];
+    for (const overrideName of overrideNames) {
+        try {
+            const { results } = await refreshSingleOverride(projectRoot, overrideName, options);
+            if (results.length === 0) {
+                totalSkipped++;
+                continue;
+            }
+            for (const r of results) {
+                if (r.status === 'merged')
+                    totalMerged++;
+                else if (r.status === 'conflict') {
+                    totalConflicts++;
+                    if (!conflictComponents.includes(overrideName)) {
+                        conflictComponents.push(overrideName);
+                    }
+                }
+                else if (r.status === 'unchanged')
+                    totalUnchanged++;
+            }
+        }
+        catch (error) {
+            const message = toError(error).message;
+            warn(`${overrideName}: ${message}`);
+            failedOverrides.push({ name: overrideName, message });
+        }
+    }
+    return {
+        totalMerged,
+        totalConflicts,
+        totalUnchanged,
+        totalSkipped,
+        conflictComponents,
+        failedOverrides,
+    };
+}
 /**
  * Runs the furnace refresh command to merge upstream Firefox changes into
  * an override component using three-way merge.
@@ -208,12 +256,6 @@ export async function furnaceRefreshCommand(projectRoot, name, options = {}) {
         outro('Done');
         return;
     }
-    let totalMerged = 0;
-    let totalConflicts = 0;
-    let totalUnchanged = 0;
-    let totalSkipped = 0;
-    const conflictComponents = [];
-    const failedOverrides = [];
     // Snapshot furnace.json before the batch loop so an unexpected failure
     // (process crash, unhandled error) can be recovered from. Per-component
     // errors caught below are expected and do not trigger a restore — only
@@ -223,33 +265,9 @@ export async function furnaceRefreshCommand(projectRoot, name, options = {}) {
         const furnacePaths = getFurnacePaths(projectRoot);
         await snapshotFile(batchJournal, furnacePaths.furnaceConfig);
     }
+    let tally;
     try {
-        for (const overrideName of overrideNames) {
-            try {
-                const { results } = await refreshSingleOverride(projectRoot, overrideName, options);
-                if (results.length === 0) {
-                    totalSkipped++;
-                    continue;
-                }
-                for (const r of results) {
-                    if (r.status === 'merged')
-                        totalMerged++;
-                    else if (r.status === 'conflict') {
-                        totalConflicts++;
-                        if (!conflictComponents.includes(overrideName)) {
-                            conflictComponents.push(overrideName);
-                        }
-                    }
-                    else if (r.status === 'unchanged')
-                        totalUnchanged++;
-                }
-            }
-            catch (error) {
-                const message = toError(error).message;
-                warn(`${overrideName}: ${message}`);
-                failedOverrides.push({ name: overrideName, message });
-            }
-        }
+        tally = await runBatchRefresh(projectRoot, overrideNames, options);
     }
     catch (error) {
         // Unexpected batch-level failure: restore furnace.json to its
@@ -259,6 +277,8 @@ export async function furnaceRefreshCommand(projectRoot, name, options = {}) {
         }
         throw error;
     }
+    const { totalMerged, totalConflicts, totalUnchanged, totalSkipped } = tally;
+    const { conflictComponents, failedOverrides } = tally;
     const summary = `${overrideNames.length} override(s) processed, ${totalSkipped} already up-to-date\n` +
         `${totalMerged} file(s) merged, ${totalUnchanged} unchanged, ${totalConflicts} conflict(s), ` +
         `${failedOverrides.length} failed`;

package/dist/src/commands/furnace/sync.js

@@ -3,6 +3,7 @@ import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { applyAllComponents } from '../../core/furnace-apply.js';
 import { logApplyResult } from '../../core/furnace-apply-output.js';
 import { furnaceConfigExists, loadFurnaceConfig } from '../../core/furnace-config.js';
+import { reportJsconfigPathsSync } from '../../core/furnace-jsconfig.js';
 import { runFurnaceMutation } from '../../core/furnace-operation.js';
 import { findOverrideBaseVersionDrift, formatOverrideBaseVersionDriftWarning, } from '../../core/furnace-version-drift.js';
 import { FurnaceError } from '../../errors/furnace.js';
@@ -68,6 +69,7 @@ export async function furnaceSyncCommand(projectRoot, options = {}) {
         if (totalFailures > 0) {
             throw new FurnaceError(`${totalFailures} component${totalFailures === 1 ? '' : 's'} failed to apply cleanly`);
         }
+        await reportJsconfigPathsSync(projectRoot, config, false);
         outro(`Sync complete — ${result.applied.length} applied, ${result.skipped.length} skipped`);
     }
     else {

package/dist/src/commands/import.js

@@ -200,6 +200,108 @@ function buildUntilFilenameSet(patches, until) {
     }
     return set;
 }
+/**
+ * Runs the manifest consistency check, scoped to the `--until` subset:
+ * global (manifest-level) issues always block, per-patch issues only
+ * block when the patch is in scope. Throws GeneralError with the repair
+ * hint when anything in scope is broken.
+ */
+async function assertScopedManifestConsistency(patchesDir, untilFilenameSet, until) {
+    const manifestConsistencyIssues = await validatePatchesManifestConsistency(patchesDir);
+    const scopedManifestIssues = until !== undefined
+        ? manifestConsistencyIssues.filter((issue) => 
+        // Global (manifest-level) issues have no specific filename to scope
+        // against — a missing or unparseable patches.json blocks any
+        // import. Per-patch issues only block when the patch is in scope.
+        issue.code === 'manifest-missing' ||
+            issue.code === 'manifest-invalid' ||
+            untilFilenameSet.has(issue.filename))
+        : manifestConsistencyIssues;
+    if (scopedManifestIssues.length > 0) {
+        const issueSummary = scopedManifestIssues.map((issue) => issue.message).join('\n  ');
+        throw new GeneralError('Patch manifest consistency check failed. Repair patches/patches.json before importing.\n' +
+            `  ${issueSummary}\n\n` +
+            'Run "fireforge doctor --repair-patches-manifest" to rebuild the manifest from on-disk patch files.');
+    }
+}
+/**
+ * Prints advisory version-compatibility warnings for every in-scope patch
+ * whose recorded source version differs meaningfully from the configured
+ * Firefox version. Advisory only — never blocks the import.
+ */
+async function warnVersionCompatibility(projectRoot, manifest, untilFilenameSet, until) {
+    if (!manifest)
+        return;
+    const config = await loadConfig(projectRoot);
+    const currentVersion = config.firefox.version;
+    for (const patch of manifest.patches) {
+        // Scope the advisory warnings too: an operator running with --until
+        // doesn't need to see version warnings for patches outside the range.
+        if (until !== undefined && !untilFilenameSet.has(patch.filename))
+            continue;
+        const warning = checkVersionCompatibility(getPatchSourceVersion(patch), currentVersion);
+        if (warning) {
+            warn(`${patch.filename}: ${warning}`);
+        }
+    }
+}
+/**
+ * Patch-integrity gate: surfaces orphaned-modification issues scoped to
+ * the `--until` range and decides whether the import may proceed —
+ * `--force` continues with a warning, non-TTY refuses loudly, and an
+ * interactive operator is prompted. Returns false when the import should
+ * stop (the cancel outro has been printed).
+ */
+async function gateImportIntegrity(paths, untilFilenameSet, until, forceImport) {
+    const allIntegrityIssues = await validatePatchIntegrity(paths.patches, paths.engine);
+    const integrityIssues = until !== undefined
+        ? allIntegrityIssues.filter((issue) => untilFilenameSet.has(issue.filename))
+        : allIntegrityIssues;
+    if (integrityIssues.length > 0) {
+        warn('\nPatch integrity issues detected:');
+        for (const issue of integrityIssues) {
+            warn(`  ${issue.filename}: ${issue.message}`);
+        }
+        info('Run "fireforge doctor" for more details.');
+        if (forceImport) {
+            warn('Continuing because --force was provided. Integrity issues were not resolved.\n');
+        }
+        else if (!process.stdin.isTTY) {
+            throw new GeneralError(`Refusing to import while ${integrityIssues.length} patch integrity issue(s) are unresolved. ` +
+                `Fix the issues reported above (see "fireforge doctor") or re-run with --force to continue anyway.`);
+        }
+        else {
+            const shouldContinue = await confirm({
+                message: 'Patch integrity issues detected. Continuing may fail with cascading errors during patch application. Continue anyway?',
+                initialValue: false,
+            });
+            if (isCancel(shouldContinue) || !shouldContinue) {
+                outro('Import cancelled — fix the integrity issues and re-run');
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Dry-run rendering: lists the in-scope patches (or the bare count when no
+ * manifest exists) and prints the dry-run outro.
+ */
+function renderImportDryRun(manifest, untilFilenameSet, until, patchCount) {
+    if (manifest) {
+        const patches = until !== undefined
+            ? manifest.patches.filter((p) => untilFilenameSet.has(p.filename))
+            : manifest.patches;
+        info(`\n[dry-run] Would apply ${patches.length} patch(es) in order:`);
+        for (const patch of patches) {
+            info(`  ${patch.filename} (${patch.filesAffected.length} file${patch.filesAffected.length === 1 ? '' : 's'})`);
+        }
+    }
+    else {
+        info(`\n[dry-run] Would apply ${patchCount} patch(es)`);
+    }
+    outro('Dry run complete — no changes made');
+}
 /**
  * Runs the import command to apply patches.
  * @param projectRoot - Root directory of the project
@@ -245,37 +347,8 @@ export async function importCommand(projectRoot, options = {}) {
     const untilFilenameSet = buildUntilFilenameSet(manifest?.patches ?? [], options.until);
     const scopedPatchCount = options.until !== undefined ? untilFilenameSet.size : patchCount;
     info(`Found ${scopedPatchCount} patch${scopedPatchCount === 1 ? '' : 'es'} to apply${options.until !== undefined ? ` (up to ${options.until})` : ''}`);
-    const manifestConsistencyIssues = await validatePatchesManifestConsistency(paths.patches);
-    const scopedManifestIssues = options.until !== undefined
-        ? manifestConsistencyIssues.filter((issue) => 
-        // Global (manifest-level) issues have no specific filename to scope
-        // against — a missing or unparseable patches.json blocks any
-        // import. Per-patch issues only block when the patch is in scope.
-        issue.code === 'manifest-missing' ||
-            issue.code === 'manifest-invalid' ||
-            untilFilenameSet.has(issue.filename))
-        : manifestConsistencyIssues;
-    if (scopedManifestIssues.length > 0) {
-        const issueSummary = scopedManifestIssues.map((issue) => issue.message).join('\n  ');
-        throw new GeneralError('Patch manifest consistency check failed. Repair patches/patches.json before importing.\n' +
-            `  ${issueSummary}\n\n` +
-            'Run "fireforge doctor --repair-patches-manifest" to rebuild the manifest from on-disk patch files.');
-    }
-    // Version compatibility warnings (advisory only)
-    if (manifest) {
-        const config = await loadConfig(projectRoot);
-        const currentVersion = config.firefox.version;
-        for (const patch of manifest.patches) {
-            // Scope the advisory warnings too: an operator running with --until
-            // doesn't need to see version warnings for patches outside the range.
-            if (options.until !== undefined && !untilFilenameSet.has(patch.filename))
-                continue;
-            const warning = checkVersionCompatibility(getPatchSourceVersion(patch), currentVersion);
-            if (warning) {
-                warn(`${patch.filename}: ${warning}`);
-            }
-        }
-    }
+    await assertScopedManifestConsistency(paths.patches, untilFilenameSet, options.until);
+    await warnVersionCompatibility(projectRoot, manifest, untilFilenameSet, options.until);
     // Validate patch integrity (detect orphaned modification patches). Warn
     // and prompt the operator to confirm before proceeding — the legacy
     // warn-and-continue behaviour hid the real root cause because import
@@ -286,49 +359,11 @@ export async function importCommand(projectRoot, options = {}) {
     // integrity problems should not block importing an earlier good subset,
     // which is exactly what operators reach for when the tail of the queue
     // is broken and they want to keep working against an earlier checkpoint.
-    const allIntegrityIssues = await validatePatchIntegrity(paths.patches, paths.engine);
-    const integrityIssues = options.until !== undefined
-        ? allIntegrityIssues.filter((issue) => untilFilenameSet.has(issue.filename))
-        : allIntegrityIssues;
-    if (integrityIssues.length > 0) {
-        warn('\nPatch integrity issues detected:');
-        for (const issue of integrityIssues) {
-            warn(`  ${issue.filename}: ${issue.message}`);
-        }
-        info('Run "fireforge doctor" for more details.');
-        if (forceImport) {
-            warn('Continuing because --force was provided. Integrity issues were not resolved.\n');
-        }
-        else if (!process.stdin.isTTY) {
-            throw new GeneralError(`Refusing to import while ${integrityIssues.length} patch integrity issue(s) are unresolved. ` +
-                `Fix the issues reported above (see "fireforge doctor") or re-run with --force to continue anyway.`);
-        }
-        else {
-            const shouldContinue = await confirm({
-                message: 'Patch integrity issues detected. Continuing may fail with cascading errors during patch application. Continue anyway?',
-                initialValue: false,
-            });
-            if (isCancel(shouldContinue) || !shouldContinue) {
-                outro('Import cancelled — fix the integrity issues and re-run');
-                return;
-            }
-        }
-    }
-    // Dry-run: list patches that would be applied and exit
+    const integrityOk = await gateImportIntegrity(paths, untilFilenameSet, options.until, forceImport);
+    if (!integrityOk)
+        return;
     if (isDryRun) {
-        if (manifest) {
-            const patches = options.until !== undefined
-                ? manifest.patches.filter((p) => untilFilenameSet.has(p.filename))
-                : manifest.patches;
-            info(`\n[dry-run] Would apply ${patches.length} patch(es) in order:`);
-            for (const patch of patches) {
-                info(`  ${patch.filename} (${patch.filesAffected.length} file${patch.filesAffected.length === 1 ? '' : 's'})`);
-            }
-        }
-        else {
-            info(`\n[dry-run] Would apply ${patchCount} patch(es)`);
-        }
-        outro('Dry run complete — no changes made');
+        renderImportDryRun(manifest, untilFilenameSet, options.until, patchCount);
         return;
     }
     await checkUncommittedPatchFiles(paths.engine, paths.patches, forceImport);

package/dist/src/commands/lint-per-patch.d.ts

@@ -1,5 +1,5 @@
 import { getProjectPaths } from '../core/config.js';
-import type { LintCommandOptions } from './lint.js';
+import type { LintCommandOptions } from '../types/commands/index.js';
 /**
  * Lints each patch in the queue as its own isolated diff, honouring
  * per-patch `lintIgnore` entries. Cross-patch rules still run once over