@hominis/fireforge 0.34.2 → 0.36.0

package/dist/src/commands/doctor-external-toolchains.js

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { isAbsolute, resolve } from 'node:path';
+import { pathExists } from '../utils/fs.js';
+import { exec, findExecutable } from '../utils/process.js';
+import { failure, warning } from './doctor-check-core.js';
+async function resolveDeclaredTool(projectRoot, tool) {
+    if (tool.path !== undefined) {
+        const candidate = isAbsolute(tool.path) ? tool.path : resolve(projectRoot, tool.path);
+        return (await pathExists(candidate)) ? candidate : undefined;
+    }
+    if (tool.xcrun === true) {
+        try {
+            const found = await exec('xcrun', ['-find', tool.name], { timeout: 5000 });
+            const line = found.stdout.split(/\r?\n/).find((entry) => entry.trim().length > 0);
+            return found.exitCode === 0 ? line?.trim() : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return findExecutable(tool.name);
+}
+async function runExternalToolchainChecks(ctx) {
+    const toolchains = ctx.config?.externalToolchains;
+    if (!toolchains || toolchains.length === 0)
+        return [];
+    const rows = [];
+    for (const toolchain of toolchains) {
+        for (const tool of toolchain.tools) {
+            const label = `External toolchain: ${toolchain.name}/${tool.name}`;
+            const found = await resolveDeclaredTool(ctx.projectRoot, tool);
+            if (found !== undefined) {
+                rows.push({ name: label, passed: true, severity: 'ok', message: `OK (${found})` });
+                continue;
+            }
+            const required = tool.required !== false;
+            const location = tool.path
+                ? `at ${tool.path}`
+                : tool.xcrun
+                    ? `via xcrun -find ${tool.name}`
+                    : 'on PATH';
+            const message = `${tool.name} was not found ${location}.`;
+            const fix = `Install ${tool.name} or update fireforge.json externalToolchains for ${toolchain.name}.`;
+            rows.push(required ? failure(label, message, fix) : warning(label, message, fix));
+        }
+    }
+    return rows;
+}
+/** Doctor check for opt-in project-declared external asset/toolchain requirements. */
+export const EXTERNAL_TOOLCHAIN_DOCTOR_CHECK = {
+    name: 'External toolchains',
+    dependsOn: ['fireforge.json is valid'],
+    run: runExternalToolchainChecks,
+};

package/dist/src/commands/doctor-furnace-jar.js

@@ -44,4 +44,3 @@ export const furnaceStaleJarRegistrationCheck = {
         }
     },
 };
-//# sourceMappingURL=doctor-furnace-jar.js.map

package/dist/src/commands/doctor-furnace-manifest-sync.js

@@ -194,4 +194,3 @@ export const furnaceManifestSyncCheck = {
             'Nothing to repair (orphans surfaced but all were already recoverable).');
     },
 };
-//# sourceMappingURL=doctor-furnace-manifest-sync.js.map

package/dist/src/commands/doctor-furnace.js

@@ -6,6 +6,7 @@ import { hasCustomEngineDrift, hasOverrideEngineDrift } from '../core/furnace-ap
 import { getFurnacePaths, loadFurnaceConfig, loadFurnaceState, updateFurnaceState, } from '../core/furnace-config.js';
 import { CUSTOM_ELEMENTS_JS, JAR_MN, resolveFtlDir } from '../core/furnace-constants.js';
 import { getFurnaceLockPath, runFurnaceMutation } from '../core/furnace-operation.js';
+import { hasBlockingStepErrors } from '../core/furnace-step-errors.js';
 import { validateAllComponents } from '../core/furnace-validate.js';
 import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
@@ -25,7 +26,7 @@ async function runRepairApply(projectRoot) {
     return runFurnaceMutation(projectRoot, 'apply-rollback', (ctx) => applyAllComponents(projectRoot, false, { operationContext: ctx }), { skipPendingRepairCheck: true });
 }
 function countApplyFailures(applyResult) {
-    const appliedWithStepErrors = applyResult.applied.filter((entry) => (entry.stepErrors?.length ?? 0) > 0).length;
+    const appliedWithStepErrors = applyResult.applied.filter((entry) => hasBlockingStepErrors(entry)).length;
     return applyResult.errors.length + appliedWithStepErrors;
 }
 function firstApplyFailure(applyResult) {
@@ -512,4 +513,3 @@ export const FURNACE_DOCTOR_CHECKS = [
     furnaceComponentValidationCheck,
     furnaceManifestSyncCheck,
 ];
-//# sourceMappingURL=doctor-furnace.js.map

package/dist/src/commands/doctor-working-tree.js

@@ -94,4 +94,3 @@ export async function inspectEngineWorkingTree(ctx) {
         : '';
     return warning('Engine working tree', `Engine working tree has ${counts.unmanaged} unmanaged change${counts.unmanaged === 1 ? '' : 's'}.${managedTail}`, 'Use "fireforge status --ownership" to separate patch-backed from unmanaged files, then export, discard, or reset only the unmanaged set.');
 }
-//# sourceMappingURL=doctor-working-tree.js.map

package/dist/src/commands/doctor.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { Command } from 'commander';
 import { configExists, getProjectPaths, loadConfig, loadState, updateState, } from '../core/config.js';
 import { furnaceConfigExists as checkFurnaceConfigExists } from '../core/furnace-config.js';
 import { getCurrentBranch, getHead, isGitRepository, isMissingHeadError } from '../core/git.js';
@@ -12,6 +14,7 @@ import { error, info, intro, outro, success, warn } from '../utils/logger.js';
 import { findExecutable } from '../utils/process.js';
 import { POST_REBASE_AUDIT_CHECK } from './doctor/post-rebase-audit.js';
 import { failure, ok, warning } from './doctor-check-core.js';
+import { EXTERNAL_TOOLCHAIN_DOCTOR_CHECK } from './doctor-external-toolchains.js';
 import { FURNACE_DOCTOR_CHECKS } from './doctor-furnace.js';
 import { inspectEngineWorkingTree } from './doctor-working-tree.js';
 import { collectPatchQueueHealth } from './verify.js';
@@ -173,6 +176,7 @@ const DOCTOR_CHECKS = [
         },
         fix: 'Check fireforge.json for syntax errors or missing fields',
     },
+    EXTERNAL_TOOLCHAIN_DOCTOR_CHECK,
     {
         name: 'Engine directory exists',
         run: (ctx) => {
@@ -476,4 +480,3 @@ export function registerDoctor(program, { getProjectRoot, withErrorHandling }) {
         }
     }));
 }
-//# sourceMappingURL=doctor.js.map

package/dist/src/commands/download.js

@@ -2,14 +2,16 @@
 import { randomUUID } from 'node:crypto';
 import { rename } from 'node:fs/promises';
 import { join } from 'node:path';
-import { getProjectPaths, loadConfig, updateState } from '../core/config.js';
+import { Command } from 'commander';
+import { getProjectPaths, loadConfig, loadState, updateState } from '../core/config.js';
 import { withFileLock } from '../core/file-lock.js';
-import { downloadFirefoxSource, formatBytes } from '../core/firefox.js';
-import { getFurnacePaths, updateFurnaceState } from '../core/furnace-config.js';
+import { downloadFirefoxSource, formatBytes, sweepOrphanedEngineWorkDirs, } from '../core/firefox.js';
+import { clearAppliedFurnaceState } from '../core/furnace-config.js';
 import { getHead, initRepository, isGitRepository, isMissingHeadError, resumeRepository, } from '../core/git.js';
 import { restoreTrackedPath } from '../core/git-file-ops.js';
 import { getDirtyFiles } from '../core/git-status.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
+import { formatMajorVersionHopNotice } from '../core/toolchain-preflight.js';
 import { EngineExistsError, PartialEngineExistsError } from '../errors/download.js';
 import { toError } from '../utils/errors.js';
 import { checkDiskSpace, ensureDir, pathExists, pathExistsStrict, removeDir } from '../utils/fs.js';
@@ -115,15 +117,8 @@ function closeRestoreSpinner(restoreSpinner, result) {
 }
 async function clearStaleFurnaceApplyState(projectRoot) {
     // --force installs a new baseCommit, which invalidates every applied
-    // checksum in furnace-state.json. Preserve pendingRepair: authoring-side
-    // rollback markers describe unresolved component workspace state and
-    // should survive an engine refresh.
-    const furnacePaths = getFurnacePaths(projectRoot);
-    if (await pathExists(furnacePaths.furnaceState)) {
-        await updateFurnaceState(projectRoot, (current) => ({
-            ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
-        }));
-    }
+    // checksum in furnace-state.json.
+    await clearAppliedFurnaceState(projectRoot);
 }
 async function activateReplacementEngine(args) {
     const { engineDir, replacementDir, backupDir } = args;
@@ -196,8 +191,22 @@ async function downloadAndExtractFirefox(args) {
         throw error;
     }
 }
+/**
+ * Prints the major-version-hop toolchain nudge when this download moved
+ * the engine across a Firefox MAJOR version (152.0b7 → 153.0b8 drill:
+ * the first post-hop build died in `mach configure` on a moved cbindgen
+ * minimum, and nothing in the download output suggested re-running
+ * `fireforge bootstrap`). Quiet on first downloads and same-major
+ * re-downloads.
+ */
+function noteMajorVersionHop(previousVersion, version) {
+    const hopNotice = formatMajorVersionHopNotice(previousVersion, version);
+    if (hopNotice) {
+        info(hopNotice);
+    }
+}
 async function initializeDownloadedEngine(args) {
-    const { projectRoot, patchesDir, version, engineDir, replacementActivated, backupEngineDir } = args;
+    const { projectRoot, patchesDir, version, previousVersion, engineDir, replacementActivated, backupEngineDir, } = args;
     // Finding #17: the git indexing phase of `download` can block for
     // minutes on a ~600 MB Firefox tree. Emit a one-line heads-up banner
     // before the spinner starts so CI logs show the expected duration.
@@ -239,6 +248,7 @@ async function initializeDownloadedEngine(args) {
             baseCommit,
         });
         await noteUnappliedPatches(patchesDir);
+        noteMajorVersionHop(previousVersion, version);
         if (backupEngineDir) {
             await removeDir(backupEngineDir);
         }
@@ -264,9 +274,34 @@ export async function downloadCommand(projectRoot, options) {
     intro('FireForge Download');
     const config = await loadConfig(projectRoot), version = config.firefox.version;
     const paths = getProjectPaths(projectRoot);
+    // Captured BEFORE any state update so the post-download major-hop
+    // notice compares against what was actually on disk until now.
+    const previousVersion = (await loadState(projectRoot)).downloadedVersion;
     info(`Firefox version: ${version}`);
     await checkDiskSpace(projectRoot, 5 * 1024 * 1024 * 1024, warn);
+    // A legitimate holder of this lock runs for 10+ minutes (download +
+    // extract + git indexing). The previous default 30 s timeout failed the
+    // second invocation with "remove the lock directory if it is stale" advice
+    // while the lock was actively held — dangerous guidance mid-extraction.
+    // Wait generously instead: a dead holder is reaped within seconds by the
+    // PID-based stale probe, so a long timeout only ever waits on real work.
+    const downloadLockOptions = {
+        timeoutMs: 30 * 60_000,
+        onTimeoutMessage: 'Timed out waiting for another FireForge download to finish. ' +
+            'If no other `fireforge download` is running, remove .fireforge/download.fireforge.lock and retry.',
+        onStaleLockMessage: (ageMs) => `Removing download lock left behind by a crashed run (${Math.round(ageMs / 1000)}s old).`,
+    };
     await withFileLock(join(paths.fireforgeDir, 'download.fireforge.lock'), async () => {
+        // Reclaim multi-GB partial trees left behind by interrupted runs.
+        // Safe under the download lock: any `.tmp-*`/`.replacement-*` dir
+        // present now is orphaned, since live ones only exist while a
+        // download holds this lock. `.backup-*` dirs are NOT swept — a
+        // backup can hold the previous engine after a failed forced
+        // replacement and is the operator's recovery copy.
+        const sweptDirs = await sweepOrphanedEngineWorkDirs(paths.engine);
+        if (sweptDirs.length > 0) {
+            info(`Removed ${sweptDirs.length} orphaned working director${sweptDirs.length === 1 ? 'y' : 'ies'} from interrupted downloads.`);
+        }
         let installEngineDir = paths.engine;
         let replacementEngineDir;
         let backupEngineDir;
@@ -318,6 +353,7 @@ export async function downloadCommand(projectRoot, options) {
                                     baseCommit,
                                 });
                                 await noteUnappliedPatches(paths.patches);
+                                noteMajorVersionHop(previousVersion, version);
                                 outro(`Firefox ${version} is ready! (resumed from partial init)`);
                                 return;
                             }
@@ -388,11 +424,12 @@ export async function downloadCommand(projectRoot, options) {
             projectRoot,
             patchesDir: paths.patches,
             version,
+            previousVersion,
             engineDir: installEngineDir,
             replacementActivated,
             ...(backupEngineDir !== undefined ? { backupEngineDir } : {}),
         });
-    });
+    }, downloadLockOptions);
 }
 /** Registers the download command on the CLI program. */
 export function registerDownload(program, { getProjectRoot, withErrorHandling }) {
@@ -404,4 +441,3 @@ export function registerDownload(program, { getProjectRoot, withErrorHandling })
         await downloadCommand(getProjectRoot(), pickDefined(options));
     }));
 }
-//# sourceMappingURL=download.js.map

package/dist/src/commands/export-all.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { Command } from 'commander';
 import { isBrandingManagedPath } from '../core/branding.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { collectFurnaceManagedPrefixes, furnaceConfigExists, loadFurnaceConfig, } from '../core/furnace-config.js';
@@ -228,8 +230,9 @@ export async function exportAllCommand(projectRoot, options = {}) {
     await checkDanglingFurnaceRegistrations(projectRoot, diff, furnaceExcluded);
     // Check for non-interactive mode
     const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
-    // Auto-fix missing license headers on new files (interactive only)
-    const headersAdded = await autoFixLicenseHeaders(paths.engine, diff, config, isInteractive);
+    // Auto-fix missing license headers on new files (interactive only;
+    // report-only under --dry-run so the preview never mutates engine/)
+    const headersAdded = await autoFixLicenseHeaders(paths.engine, diff, config, isInteractive, isDryRun);
     if (headersAdded) {
         diff = await getAllDiff(paths.engine);
     }
@@ -335,4 +338,3 @@ export function registerExportAll(program, { getProjectRoot, withErrorHandling }
         });
     }));
 }
-//# sourceMappingURL=export-all.js.map

package/dist/src/commands/export-flow.js

@@ -8,10 +8,12 @@
  * testable without dragging the whole command harness along for the ride.
  */
 import { join } from 'node:path';
-import { findAllPatchesForFilesWithDetails, planExport, sanitizeName, } from '../core/patch-export.js';
+import {} from '../core/destructive.js';
+import { normalizePatchArtifact } from '../core/patch-artifact-normalize.js';
+import { findAllPatchesForFilesWithDetails, patchNameSlug, planExport, } from '../core/patch-export.js';
 import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, detectNewFilesInDiff, lintPatchQueue, } from '../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../core/patch-lock.js';
-import { addPatchToManifest, loadPatchesManifest, renumberPatchesInManifest, resolvePatchIdentifier, savePatchesManifest, } from '../core/patch-manifest.js';
+import { addPatchToManifest, loadPatchesManifest, loadPatchesManifestForWrite, renumberPatchesInManifest, resolvePatchIdentifier, savePatchesManifest, } from '../core/patch-manifest.js';
 import { applyRenameMapToManifest, buildProjectedManifest, enforcePatchPolicy, } from '../core/patch-policy.js';
 import { extractNewFileContentFromDiff } from '../core/patch-transform.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
@@ -22,7 +24,7 @@ import { assertPlacementPreservesReservedRanges } from './export-placement-polic
 import { findPartialOwnershipOverlap } from './export-shared.js';
 function buildFilenameForPlacement(category, name, order, width) {
     const padded = String(order).padStart(Math.max(3, width), '0');
-    return `${padded}-${category}-${sanitizeName(name)}.patch`;
+    return `${padded}-${category}-${patchNameSlug(name, category)}.patch`;
 }
 function prefixWidthForPatches(manifestPatches, requestedOrder) {
     return manifestPatches.reduce((width, patch) => {
@@ -113,7 +115,9 @@ export function computeExactPlacementPlan(manifestPatches, newPatchCategory, new
  * Resolves a placement plan from CLI flags against the current manifest.
  */
 export async function resolvePlacementPlan(patchesDir, options, category, name) {
-    const manifest = await loadPatchesManifest(patchesDir);
+    // ForWrite: placement planning feeds a manifest rewrite; a corrupt
+    // manifest read as empty would allocate colliding orders.
+    const manifest = await loadPatchesManifestForWrite(patchesDir);
     const existingPatches = manifest?.patches ?? [];
     let targetOrder;
     if (options.order !== undefined) {
@@ -232,7 +236,7 @@ export async function commitPlacementExport(input) {
                 're-run the export with an explicit file list that leaves those files with their owner — ' +
                 'do NOT bypass with --force-unsafe. Pass --force-unsafe only for a reviewed placement conflict.', '--force-unsafe');
         }
-        const originalManifest = await loadPatchesManifest(input.patchesDir);
+        const originalManifest = await loadPatchesManifestForWrite(input.patchesDir);
         if (originalManifest !== null) {
             assertPlacementPreservesReservedRanges(currentPlan, originalManifest.patches, input.config, input.category);
         }
@@ -269,7 +273,9 @@ export async function commitPlacementExport(input) {
                 await renumberPatchesInManifest(input.patchesDir, currentPlan.renameMap);
                 renumberApplied = true;
             }
-            await writeText(patchPath, input.diff);
+            // Normalize identically to commitExportedPatch — the two export
+            // paths must produce one artifact contract for the same diff.
+            await writeText(patchPath, normalizePatchArtifact(input.diff));
             await addPatchToManifest(input.patchesDir, {
                 ...input.metadata,
                 filename: currentPlan.newFilename,
@@ -414,4 +420,3 @@ export async function renderDryRunPreview(input) {
         info('[dry-run] No cross-patch ownership overlap detected.');
     }
 }
-//# sourceMappingURL=export-flow.js.map

package/dist/src/commands/export-placement-gate.js

@@ -105,4 +105,3 @@ export async function gatePlacementPlan(args) {
     }
     return placementPlan;
 }
-//# sourceMappingURL=export-placement-gate.js.map

package/dist/src/commands/export-placement-policy.js

@@ -51,4 +51,3 @@ export function assertPlacementPreservesReservedRanges(plan, manifestPatches, co
             suggestionText, 'export placement');
     }
 }
-//# sourceMappingURL=export-placement-policy.js.map

package/dist/src/commands/export-shared.d.ts

@@ -56,9 +56,13 @@ export declare function confirmSupersedePatches(patchesDir: string, filesAffecte
  * @param diffContent - Current unified diff
  * @param config - Project configuration
  * @param isInteractive - Whether interactive prompts are available
+ * @param dryRun - When true, only REPORT missing headers, never prompt or
+ *   write. Dry-run must stay read-only: before this flag existed, an
+ *   interactive `export --dry-run` prompted (default Yes) and wrote license
+ *   headers into engine/ files, then closed with "no changes made".
  * @returns true if files were modified on disk (caller must regenerate diff)
  */
-export declare function autoFixLicenseHeaders(engineDir: string, diffContent: string, config: FireForgeConfig, isInteractive: boolean): Promise<boolean>;
+export declare function autoFixLicenseHeaders(engineDir: string, diffContent: string, config: FireForgeConfig, isInteractive: boolean, dryRun?: boolean): Promise<boolean>;
 /**
  * Maps every file in `filesAffected` to the existing patches that already
  * claim ownership of it, excluding the caller's own patch (when `newFilename`

package/dist/src/commands/export-shared.js

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
 import { confirm, select, text } from '@clack/prompts';
-import { addLicenseHeaderToFile, getLicenseHeader } from '../core/license-headers.js';
+import { addLicenseHeaderToFile } from '../core/license-headers.js';
 import { findAllPatchesForFiles } from '../core/patch-export.js';
-import { commentStyleForFile, detectNewFilesInDiff, lintExportedPatch, resolvePatchSizeTier, } from '../core/patch-lint.js';
+import { commentStyleForFile, detectNewFilesInDiff, isAcceptableNewFileHeader, lintExportedPatch, resolvePatchSizeTier, } from '../core/patch-lint.js';
 import { resolvePatchOwnedSysMjs } from '../core/patch-lint-ownership.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { getPatchPolicyCategories, isCategoryAllowedByConfig } from '../core/patch-policy.js';
@@ -206,9 +206,13 @@ export async function confirmSupersedePatches(patchesDir, filesAffected, superse
  * @param diffContent - Current unified diff
  * @param config - Project configuration
  * @param isInteractive - Whether interactive prompts are available
+ * @param dryRun - When true, only REPORT missing headers, never prompt or
+ *   write. Dry-run must stay read-only: before this flag existed, an
+ *   interactive `export --dry-run` prompted (default Yes) and wrote license
+ *   headers into engine/ files, then closed with "no changes made".
  * @returns true if files were modified on disk (caller must regenerate diff)
  */
-export async function autoFixLicenseHeaders(engineDir, diffContent, config, isInteractive) {
+export async function autoFixLicenseHeaders(engineDir, diffContent, config, isInteractive, dryRun = false) {
     const license = config.license ?? 'MPL-2.0';
     const newFiles = detectNewFilesInDiff(diffContent);
     if (newFiles.size === 0)
@@ -222,13 +226,22 @@ export async function autoFixLicenseHeaders(engineDir, diffContent, config, isIn
         if (!(await pathExists(filePath)))
             continue;
         const content = await readText(filePath);
-        const expectedHeader = getLicenseHeader(license, style);
-        if (!content.startsWith(expectedHeader)) {
+        // Same acceptance policy as the missing-license-header rule: offering
+        // to "fix" a file the lint already accepts (e.g. a verbatim upstream
+        // MPL block header on a derived JS/CSS file) would stack a second
+        // header on top of a legitimate one.
+        if (!isAcceptableNewFileHeader(file, content, style, license)) {
             filesToFix.push(file);
         }
     }
     if (filesToFix.length === 0)
         return false;
+    if (dryRun) {
+        const fileList = filesToFix.map((f) => `  - ${f}`).join('\n');
+        info(`[dry-run] ${filesToFix.length} new file(s) missing the ${license} license header ` +
+            `(a real export would offer to add them):\n${fileList}`);
+        return false;
+    }
     if (!isInteractive)
         return false;
     const fileList = filesToFix.map((f) => `  - ${f}`).join('\n');
@@ -360,4 +373,3 @@ export async function runSupersedeAndOverlapGates(args) {
         s,
     });
 }
-//# sourceMappingURL=export-shared.js.map

package/dist/src/commands/export.js

@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { Option } from 'commander';
+import { Command, Option } from 'commander';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { appendHistory } from '../core/destructive.js';
+import { withEngineSessionLock } from '../core/engine-session-lock.js';
 import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
 import { getStatusWithCodes, isGitRepository } from '../core/git.js';
 import { generateBinaryFilePatch, generateFullFilePatch } from '../core/git-diff.js';
@@ -18,7 +19,7 @@ import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { ensureDir, pathExists } from '../utils/fs.js';
 import { info, intro, outro, spinner, verbose, warn } from '../utils/logger.js';
-import { pickDefined } from '../utils/options.js';
+import { commanderArgParser, pickDefined } from '../utils/options.js';
 import { stripEnginePrefix } from '../utils/paths.js';
 import { parsePositiveIntegerFlag } from '../utils/validation.js';
 import { commitPlacementExport, renderDryRunPreview } from './export-flow.js';
@@ -209,12 +210,16 @@ async function prepareExport(projectRoot, files, options) {
         }
         throw new GeneralError('The specified paths have no diff content to export.');
     }
-    // Ensure patches directory exists
-    await ensureDir(paths.patches);
+    // Ensure patches directory exists. Skip during a dry-run so the command
+    // is purely read-only (matching export-all's dry-run contract).
+    if (!options.dryRun) {
+        await ensureDir(paths.patches);
+    }
     const config = await loadConfig(projectRoot);
     const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
-    // Auto-fix missing license headers on new files (interactive only)
-    const headersAdded = await autoFixLicenseHeaders(paths.engine, diff, config, isInteractive);
+    // Auto-fix missing license headers on new files (interactive only;
+    // report-only under --dry-run so the preview never mutates engine/)
+    const headersAdded = await autoFixLicenseHeaders(paths.engine, diff, config, isInteractive, options.dryRun ?? false);
     if (headersAdded) {
         diff = await generatePatchDiff(paths.engine, allFiles);
     }
@@ -398,7 +403,7 @@ export function registerExport(program, { getProjectRoot, withErrorHandling }) {
         .option('--supersede', 'Allow superseding multiple existing patches')
         .option('--skip-lint', 'Skip patch lint checks (downgrade errors to warnings)')
         .option('--dry-run', 'Print the export plan (including supersede preview) without writing')
-        .addOption(new Option('--order <N>', 'Place the new patch at this exact unused order without renumbering existing patches').argParser((v) => parsePositiveIntegerFlag('--order', v)))
+        .addOption(new Option('--order <N>', 'Place the new patch at this exact unused order without renumbering existing patches').argParser(commanderArgParser((v) => parsePositiveIntegerFlag('--order', v))))
         .option('--before <anchor>', 'Place the new patch immediately before <anchor>')
         .option('--after <anchor>', 'Place the new patch immediately after <anchor>')
         .option('-y, --yes', 'Skip confirmation for placement renumbers (required for non-TTY)')
@@ -409,12 +414,12 @@ export function registerExport(program, { getProjectRoot, withErrorHandling }) {
         .option('--lint-ignore <check-id>', 'Suppress a lint check on this patch (writes to PatchMetadata.lintIgnore; repeatable)', (value, prev) => [...prev, value], [])
         .action(withErrorHandling(async (paths, options) => {
         const { category, tier, lintIgnore, ...rest } = options;
-        await exportCommand(getProjectRoot(), paths, {
+        const projectRoot = getProjectRoot();
+        await withEngineSessionLock(projectRoot, 'export', () => exportCommand(projectRoot, paths, {
             ...pickDefined(rest),
             ...(category !== undefined ? { category } : {}),
             ...(tier !== undefined ? { tier: tier } : {}),
             ...(lintIgnore !== undefined && lintIgnore.length > 0 ? { lintIgnore } : {}),
-        });
+        }));
     }));
 }
-//# sourceMappingURL=export.js.map

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

@@ -6,6 +6,8 @@ import { logApplyResult } from '../../core/furnace-apply-output.js';
 import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, } from '../../core/furnace-config.js';
 import { isComponentSourceFile } from '../../core/furnace-constants.js';
 import { runFurnaceMutation } from '../../core/furnace-operation.js';
+import { getPersistableAppliedEntry, persistSingleComponentState, shouldPersistSingleComponentState, } from '../../core/furnace-state-persist.js';
+import { countEntriesWithBlockingStepErrors } from '../../core/furnace-step-errors.js';
 import { findOverrideBaseVersionDrift, formatOverrideBaseVersionDriftError, formatOverrideBaseVersionDriftWarning, } from '../../core/furnace-version-drift.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { pathExists } from '../../utils/fs.js';
@@ -282,17 +284,32 @@ export async function furnaceApplyCommand(projectRoot, name, options = {}) {
         throw new FurnaceError(formatOverrideBaseVersionDriftError(driftEntries));
     }
     const applySpinner = dryRun ? undefined : spinner('Applying components to engine...');
-    const result = await runFurnaceMutation(projectRoot, 'apply-rollback', (ctx) => applyAllComponents(projectRoot, dryRun, {
-        operationContext: ctx,
-        ...(name !== undefined ? { componentName: name } : {}),
-    }), { dryRun });
+    const result = await runFurnaceMutation(projectRoot, 'apply-rollback', async (ctx) => {
+        // `persistState: false` for a NAMED apply is load-bearing: the batch
+        // persist path replaces `appliedChecksums` wholesale with only this
+        // run's entries, and the batch loops filter to the named component —
+        // so routing a named apply through it persisted a state file
+        // containing ONLY that component, wiping every other component's
+        // checksums. Orphan detection and deleted-file undeploy both key on
+        // that state, so the wiped components' stale engine files became
+        // invisible to apply AND to `furnace validate`. Named apply merges
+        // per-component state below, exactly like `furnace deploy <name>`.
+        const applyResult = await applyAllComponents(projectRoot, dryRun, {
+            operationContext: ctx,
+            ...(name !== undefined ? { componentName: name, persistState: false } : {}),
+        });
+        if (name !== undefined && shouldPersistSingleComponentState(applyResult, dryRun)) {
+            await persistSingleComponentState(projectRoot, getPersistableAppliedEntry('Apply', name, applyResult.applied[0]), getFurnacePaths(projectRoot));
+        }
+        return applyResult;
+    }, { dryRun });
     if (applySpinner) {
         applySpinner.stop('Components applied');
     }
     logApplyResult(result, dryRun);
     const appliedWithStepErrorsCount = dryRun
         ? 0
-        : result.applied.filter((entry) => (entry.stepErrors?.length ?? 0) > 0).length;
+        : countEntriesWithBlockingStepErrors(result.applied);
     const totalApplyFailures = result.errors.length + appliedWithStepErrorsCount;
     if (totalApplyFailures > 0) {
         throw new FurnaceError(`${totalApplyFailures} component${totalApplyFailures === 1 ? '' : 's'} failed to apply cleanly`);
@@ -310,4 +327,3 @@ export async function furnaceApplyCommand(projectRoot, name, options = {}) {
         await runWatchLoop(projectRoot);
     }
 }
-//# sourceMappingURL=apply.js.map

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

@@ -139,4 +139,3 @@ export async function furnaceChromeDocRemoveCommand(projectRoot, name, options =
     }
     outro('Chrome document removed');
 }
-//# sourceMappingURL=chrome-doc-remove.js.map

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

@@ -329,4 +329,3 @@ export function localeJarMnEntryForChromeDoc(name) {
 export function localesFtlWildcardCapturesScaffoldedName(jarMnContents) {
     return /\(%browser\/(?:\*\*\/)?\*\.ftl\)/.test(jarMnContents);
 }
-//# sourceMappingURL=chrome-doc-templates.js.map

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

@@ -149,4 +149,3 @@ firefox-appdir = "browser"
 ["${chromeDocPackagingTestFileName(name)}"]
 `;
 }
-//# sourceMappingURL=chrome-doc-tests.js.map

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

@@ -359,4 +359,3 @@ export async function furnaceChromeDocCreateCommand(projectRoot, name, options =
     ].join('\n'), name);
     outro('Chrome document created');
 }
-//# sourceMappingURL=chrome-doc.js.map

package/dist/src/commands/furnace/create-browser-test.js

@@ -177,4 +177,3 @@ add_task(async function test_${underscored}_defined() {
     }
     return testFiles;
 }
-//# sourceMappingURL=create-browser-test.js.map

package/dist/src/commands/furnace/create-dry-run.js

@@ -103,4 +103,3 @@ export function formatDryRunPlan(args) {
     }
     return plan;
 }
-//# sourceMappingURL=create-dry-run.js.map

package/dist/src/commands/furnace/create-features.js

@@ -53,4 +53,3 @@ export async function resolveCreateFeatures(isInteractive, options) {
     }
     return { localized, register };
 }
-//# sourceMappingURL=create-features.js.map

package/dist/src/commands/furnace/create-mochikit.js

@@ -74,4 +74,3 @@ export async function scaffoldMochikitTestFiles(componentName, license, paths, j
         'Ensure `toolkit/content/tests/widgets/chrome.toml` is reachable from an existing test-harness registration (upstream TEST_HARNESS_FILES entries handle this by default).');
     return writtenFiles;
 }
-//# sourceMappingURL=create-mochikit.js.map

package/dist/src/commands/furnace/create-readback.js

@@ -31,4 +31,3 @@ export async function assertCustomEntryPersisted(projectRoot, componentName) {
             're-run the command, or add the entry to furnace.json by hand.', componentName);
     }
 }
-//# sourceMappingURL=create-readback.js.map

package/dist/src/commands/furnace/create-templates.js

@@ -293,4 +293,3 @@ export function generateMochikitChromeTomlSkeleton(header) {
 
 `;
 }
-//# sourceMappingURL=create-templates.js.map

package/dist/src/commands/furnace/create-validation.js

@@ -57,4 +57,3 @@ export function validateCreateAgainstConfig(config, componentName, allowPrefixMi
     }
     validateComposesTargets(config, componentName, composes, stockAdditions);
 }
-//# sourceMappingURL=create-validation.js.map

package/dist/src/commands/furnace/create-xpcshell.js

@@ -78,4 +78,3 @@ export async function scaffoldXpcshellTestFiles(componentName, license, forgeCon
         'Add the directory to XPCSHELL_TESTS_MANIFESTS in the nearest moz.build to run it via "fireforge test".');
     return testFiles;
 }
-//# sourceMappingURL=create-xpcshell.js.map

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

@@ -381,4 +381,3 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
     }), componentName);
     outro('Component created');
 }
-//# sourceMappingURL=create.js.map