@hominis/fireforge 0.35.0 → 0.36.0

package/dist/src/commands/download.js

@@ -2,10 +2,11 @@
 import { randomUUID } from 'node:crypto';
 import { rename } from 'node:fs/promises';
 import { join } from 'node:path';
+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';
@@ -116,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;
@@ -285,7 +279,29 @@ export async function downloadCommand(projectRoot, options) {
     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;
@@ -413,7 +429,7 @@ export async function downloadCommand(projectRoot, options) {
             replacementActivated,
             ...(backupEngineDir !== undefined ? { backupEngineDir } : {}),
         });
-    });
+    }, downloadLockOptions);
 }
 /** Registers the download command on the CLI program. */
 export function registerDownload(program, { getProjectRoot, withErrorHandling }) {
@@ -425,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

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

@@ -1,11 +1,12 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { applyAllComponents, computeComponentChecksums, prefixChecksums, } from '../../core/furnace-apply.js';
+import { applyAllComponents } from '../../core/furnace-apply.js';
 import { logApplyResult } from '../../core/furnace-apply-output.js';
-import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, updateFurnaceState, } from '../../core/furnace-config.js';
+import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, } from '../../core/furnace-config.js';
 import { reportJsconfigPathsSync } from '../../core/furnace-jsconfig.js';
 import { runFurnaceMutation } from '../../core/furnace-operation.js';
+import { getPersistableAppliedEntry, getStepFailureCount, persistSingleComponentState, shouldPersistSingleComponentState, } from '../../core/furnace-state-persist.js';
+import { hasBlockingStepErrors } 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';
@@ -28,91 +29,15 @@ function buildDeployFailureMessage(applyErrors, validationErrors, isDryRun) {
     }
     return `${mode} completed with ${validationErrors} validation error(s).`;
 }
-function getStepFailureCount(result) {
-    return result.applied.filter((entry) => (entry.stepErrors?.length ?? 0) > 0).length;
-}
 function getFailedComponentNames(result) {
     const failed = new Set(result.errors.map((entry) => entry.name));
     for (const applied of result.applied) {
-        if ((applied.stepErrors?.length ?? 0) > 0) {
+        if (hasBlockingStepErrors(applied)) {
             failed.add(applied.name);
         }
     }
     return failed;
 }
-function getPersistableAppliedEntry(name, appliedEntry) {
-    if (!appliedEntry) {
-        throw new FurnaceError(`Deploy for "${name}" finished without producing an applied component entry; ` +
-            `furnace state was not modified. Run "fireforge doctor --repair-furnace" to ` +
-            `reconcile state, then retry the deploy. If this persists, file a bug with the ` +
-            `output of "fireforge doctor".`);
-    }
-    if (appliedEntry.type !== 'override' && appliedEntry.type !== 'custom') {
-        throw new FurnaceError(`Deploy for "${name}" returned an unsupported component type "${appliedEntry.type}"; ` +
-            `furnace state was not modified. Run "fireforge doctor --repair-furnace" to reconcile, ` +
-            `then verify the component with "fireforge furnace validate" before retrying.`);
-    }
-    // Guard against future refactors that might reorder or misroute the
-    // applied[] array: named deploy persists state under a single component
-    // name, so the first applied entry MUST be that component. Persisting a
-    // different component's checksums here would cause the next status/apply
-    // run to mis-report health for both components involved.
-    if (name !== undefined && appliedEntry.name !== name) {
-        throw new FurnaceError(`Deploy for "${name}" returned an applied entry for a different component ` +
-            `("${appliedEntry.name}"); refusing to persist mismatched state. ` +
-            `Run "fireforge doctor --repair-furnace" to reconcile, then retry the deploy.`);
-    }
-    return {
-        name: appliedEntry.name,
-        type: appliedEntry.type,
-    };
-}
-/**
- * Decides whether a single-component deploy completed cleanly enough to
- * persist its checksums into furnace-state.json.
- *
- * Named deploy is atomic: if any apply step fails, the rollback journal
- * restores the engine to its pre-deploy state and this helper returns
- * `false` so state is not touched. The conditions must stay in lock-step
- * with the rollback-trigger in `applyNamedComponent` — both now read from
- * this helper so a future refactor cannot drift them apart and accidentally
- * persist partial state.
- */
-function shouldPersistNamedDeployState(result, isDryRun) {
-    if (isDryRun)
-        return false;
-    if (result.errors.length > 0)
-        return false;
-    if (getStepFailureCount(result) > 0)
-        return false;
-    return result.applied.length > 0;
-}
-/**
- * Persists checksum state for a successfully applied named component.
- * @param projectRoot - Root directory of the project
- * @param appliedEntry - Applied component descriptor from deploy
- * @param furnacePaths - Resolved Furnace workspace paths
- */
-async function persistSingleComponentState(projectRoot, appliedEntry, furnacePaths) {
-    const componentDir = appliedEntry.type === 'override'
-        ? join(furnacePaths.overridesDir, appliedEntry.name)
-        : join(furnacePaths.customDir, appliedEntry.name);
-    const checksums = await computeComponentChecksums(componentDir);
-    const prefixed = prefixChecksums(checksums, appliedEntry.type, appliedEntry.name);
-    const componentPrefix = `${appliedEntry.type}/${appliedEntry.name}/`;
-    await updateFurnaceState(projectRoot, (current) => ({
-        ...current,
-        appliedChecksums: {
-            ...Object.fromEntries(Object.entries(current.appliedChecksums ?? {}).filter(([key]) => !key.startsWith(componentPrefix))),
-            ...prefixed,
-        },
-        engineChecksums: {
-            ...Object.fromEntries(Object.entries(current.engineChecksums ?? {}).filter(([key]) => !key.startsWith(componentPrefix))),
-            ...prefixed,
-        },
-        lastApply: new Date().toISOString(),
-    }));
-}
 /**
  * Applies a single named override or custom component in targeted deploy mode.
  *
@@ -251,8 +176,8 @@ export async function furnaceDeployCommand(projectRoot, name, options = {}) {
             // already restored the engine to its pre-deploy state, so persisting
             // partial checksums here would mis-report the next status/apply run
             // against a workspace that was never actually deployed.
-            if (shouldPersistNamedDeployState(namedApplyResult, isDryRun)) {
-                await persistSingleComponentState(projectRoot, getPersistableAppliedEntry(name, namedApplyResult.applied[0]), furnacePaths);
+            if (shouldPersistSingleComponentState(namedApplyResult, isDryRun)) {
+                await persistSingleComponentState(projectRoot, getPersistableAppliedEntry('Deploy', name, namedApplyResult.applied[0]), furnacePaths);
             }
             return { kind: 'result', result: namedApplyResult };
         }
@@ -293,4 +218,3 @@ export async function furnaceDeployCommand(projectRoot, name, options = {}) {
     // --- Step 3: Summary ---
     printDeploymentSummary(result, totalErrors, totalWarnings, componentCount, skippedValidationCount, isDryRun);
 }
-//# sourceMappingURL=deploy.js.map

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

@@ -207,4 +207,3 @@ export async function furnaceDiffCommand(projectRoot, name) {
     }
     outro('Diff complete');
 }
-//# sourceMappingURL=diff.js.map