@hominis/fireforge 0.30.1 → 0.32.0

package/dist/src/commands/export.js

@@ -3,16 +3,15 @@ import { stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { Option } from 'commander';
 import { getProjectPaths, loadConfig } from '../core/config.js';
-import { appendHistory, confirmDestructive } from '../core/destructive.js';
+import { appendHistory } from '../core/destructive.js';
 import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
 import { getStatusWithCodes, isGitRepository } from '../core/git.js';
 import { generateBinaryFilePatch, generateFullFilePatch } from '../core/git-diff.js';
 import { isBinaryFile } from '../core/git-file-ops.js';
 import { getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, } from '../core/git-status.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
-import { commitExportedPatch, findAllPatchesForFiles } from '../core/patch-export.js';
-import { loadPatchesManifest } from '../core/patch-manifest.js';
-import { applyRenameMapToManifest, buildProjectedManifest, enforcePatchPolicy, } from '../core/patch-policy.js';
+import { commitExportedPatch } from '../core/patch-export.js';
+import { buildPatchQueueContext } from '../core/patch-lint.js';
 import { buildPatchSourceMetadata } from '../core/patch-source-metadata.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
@@ -21,9 +20,9 @@ import { info, intro, outro, spinner, verbose, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
 import { stripEnginePrefix } from '../utils/paths.js';
 import { parsePositiveIntegerFlag } from '../utils/validation.js';
-import { commitPlacementExport, placementSummary, projectPlacementForLint, renderDryRunPreview, resolvePlacementPlan, } from './export-flow.js';
-import { assertPlacementPreservesReservedRanges } from './export-placement-policy.js';
-import { autoFixLicenseHeaders, confirmSupersedePatches, guardOwnershipOverlap, promptExportPatchMetadata, runPatchLint, } from './export-shared.js';
+import { commitPlacementExport, renderDryRunPreview } from './export-flow.js';
+import { gatePlacementPlan, patchMetadataExtras } from './export-placement-gate.js';
+import { autoFixLicenseHeaders, promptExportPatchMetadata, runPatchLint, runSupersedeAndOverlapGates, } from './export-shared.js';
 async function collectExportFiles(paths, files) {
     const collectedFiles = new Set();
     let fileStatuses;
@@ -100,20 +99,14 @@ async function generatePatchDiff(engineDir, allFiles) {
     return diffs.join('\n');
 }
 /**
- * Runs the export command to export file changes as a patch.
- * Accepts one or more file/directory paths and bundles them into a single patch.
- * @param projectRoot - Root directory of the project
- * @param files - File or directory paths to export (relative to engine/)
- * @param options - Export options
+ * Validation + diff phase of `exportCommand`: checks flag combinations and
+ * the engine checkout, collects the export file set (honouring
+ * `--exclude-furnace`), generates the diff, auto-fixes license headers,
+ * and prompts for patch metadata. Returns `null` when the operator
+ * cancelled the metadata prompt (the command ends silently, matching the
+ * prompt's own cancel handling).
  */
-// The command body is intentionally linear: validation → diff → placement
-// gate → dry-run/placement/default write. Splitting it further would
-// spread the error-handling (spinner.error, try/catch) across multiple
-// helpers and hurt readability more than it would help.
-// eslint-disable-next-line max-lines-per-function
-export async function exportCommand(projectRoot, files, options) {
-    const isDryRun = options.dryRun === true;
-    intro(isDryRun ? 'FireForge Export (dry run)' : 'FireForge Export');
+async function prepareExport(projectRoot, files, options) {
     // Placement flags are mutually exclusive with each other.
     const placementFlagCount = [
         options.order !== undefined,
@@ -170,7 +163,23 @@ export async function exportCommand(projectRoot, files, options) {
     }
     const metadata = await promptExportPatchMetadata(options, isInteractive, 'export', config);
     if (!metadata)
+        return null;
+    return { paths, placementFlagCount, diff, config, isInteractive, metadata };
+}
+/**
+ * Runs the export command to export file changes as a patch.
+ * Accepts one or more file/directory paths and bundles them into a single patch.
+ * @param projectRoot - Root directory of the project
+ * @param files - File or directory paths to export (relative to engine/)
+ * @param options - Export options
+ */
+export async function exportCommand(projectRoot, files, options) {
+    const isDryRun = options.dryRun === true;
+    intro(isDryRun ? 'FireForge Export (dry run)' : 'FireForge Export');
+    const prepared = await prepareExport(projectRoot, files, options);
+    if (!prepared)
         return;
+    const { paths, placementFlagCount, diff, config, isInteractive, metadata } = prepared;
     const { patchName, selectedCategory, description } = metadata;
     const s = spinner(isDryRun ? 'Planning export...' : 'Exporting patch...');
     try {
@@ -184,76 +193,29 @@ export async function exportCommand(projectRoot, files, options) {
         const exportIgnoreChecks = options.lintIgnore && options.lintIgnore.length > 0
             ? new Set(options.lintIgnore)
             : undefined;
-        await runPatchLint(paths.engine, filesAffected, diff, config, options.skipLint, undefined, exportIgnoreChecks, options.tier);
+        const patchQueueCtx = (await pathExists(paths.patches))
+            ? await buildPatchQueueContext(paths.patches)
+            : undefined;
+        await runPatchLint(paths.engine, filesAffected, diff, config, options.skipLint, patchQueueCtx, exportIgnoreChecks, options.tier);
         // Resolve placement (if any flag was given). Placement is mutually
         // exclusive with supersede — the semantics overlap confusingly.
         let placementPlan = null;
         if (placementFlagCount > 0) {
-            if (options.supersede) {
-                throw new InvalidArgumentError('Placement flags (--order/--before/--after) cannot be combined with --supersede.', 'export placement');
-            }
-            placementPlan = await resolvePlacementPlan(paths.patches, options, selectedCategory, patchName);
-            const currentManifest = await loadPatchesManifest(paths.patches);
-            if (currentManifest !== null) {
-                assertPlacementPreservesReservedRanges(placementPlan, currentManifest.patches, config, selectedCategory);
-            }
-            const conflicts = await projectPlacementForLint(paths.patches, placementPlan, diff);
-            const renamed = currentManifest !== null
-                ? applyRenameMapToManifest(currentManifest, placementPlan.renameMap)
-                : buildProjectedManifest(null, []);
-            enforcePatchPolicy({
+            const gated = await gatePlacementPlan({
+                patchesDir: paths.patches,
+                options,
+                selectedCategory,
+                patchName,
+                description,
+                filesAffected,
+                diff,
                 config,
-                manifest: buildProjectedManifest(renamed, [
-                    ...renamed.patches,
-                    {
-                        filename: placementPlan.newFilename,
-                        order: placementPlan.insertionOrder,
-                        category: selectedCategory,
-                        name: patchName,
-                        description,
-                        createdAt: new Date().toISOString(),
-                        ...buildPatchSourceMetadata(config.firefox),
-                        filesAffected,
-                        ...(options.tier !== undefined ? { tier: options.tier } : {}),
-                        ...(options.lintIgnore !== undefined && options.lintIgnore.length > 0
-                            ? { lintIgnore: options.lintIgnore }
-                            : {}),
-                    },
-                ]),
-                command: 'export',
-                forceUnsafe: options.forceUnsafe === true,
+                isDryRun,
+                s,
             });
-            const summary = placementSummary(placementPlan);
-            const renameCount = placementPlan.renameMap.size;
-            // Route through confirmDestructive when the operation is destructive
-            // enough to warrant a prompt (more than one rename) OR when the user
-            // asked for a dry-run. The dry-run branch must always print the
-            // placement summary — previously, single-rename/no-rename dry-runs
-            // exited silently with no filename or projected layout.
-            if (renameCount > 1 || isDryRun) {
-                s.stop();
-                const decision = await confirmDestructive({
-                    operation: 'export-order',
-                    title: `Export with placement at order ${placementPlan.insertionOrder}`,
-                    summary,
-                    yes: options.yes === true,
-                    dryRun: isDryRun,
-                    unsafeOverride: options.forceUnsafe === true,
-                    conflicts,
-                });
-                if (decision === 'dry-run') {
-                    outro('Dry run complete — no changes made');
-                    return;
-                }
-                if (decision === 'cancelled') {
-                    outro('Export cancelled');
-                    return;
-                }
-            }
-            else if (conflicts && options.forceUnsafe !== true) {
-                s.stop();
-                throw new InvalidArgumentError(`Refusing to run export: ${conflicts.reason}. Pass --force-unsafe to override.`, '--force-unsafe');
-            }
+            if (gated === 'stop')
+                return;
+            placementPlan = gated;
         }
         // Dry-run path: compute the plan and print it, never write.
         if (isDryRun && !placementPlan) {
@@ -267,10 +229,7 @@ export async function exportCommand(projectRoot, files, options) {
                 ...buildPatchSourceMetadata(config.firefox),
                 explicitSupersede: options.supersede === true,
                 allowOverlap: options.allowOverlap === true,
-                ...(options.tier !== undefined ? { tier: options.tier } : {}),
-                ...(options.lintIgnore !== undefined && options.lintIgnore.length > 0
-                    ? { lintIgnore: options.lintIgnore }
-                    : {}),
+                ...patchMetadataExtras(options),
                 config,
                 forceUnsafe: options.forceUnsafe === true,
             });
@@ -291,10 +250,7 @@ export async function exportCommand(projectRoot, files, options) {
                 createdAt: new Date().toISOString(),
                 ...buildPatchSourceMetadata(config.firefox),
                 filesAffected,
-                ...(options.tier !== undefined ? { tier: options.tier } : {}),
-                ...(options.lintIgnore !== undefined && options.lintIgnore.length > 0
-                    ? { lintIgnore: options.lintIgnore }
-                    : {}),
+                ...patchMetadataExtras(options),
             };
             const committedPlan = await commitPlacementExport({
                 patchesDir: paths.patches,
@@ -336,29 +292,15 @@ export async function exportCommand(projectRoot, files, options) {
             return;
         }
         // Default (no dry-run, no placement) path: the pre-existing behavior.
-        // Check how many existing patches would be superseded
-        const shouldProceed = await confirmSupersedePatches(paths.patches, filesAffected, options.supersede, isInteractive, s);
-        if (!shouldProceed)
-            return;
-        // Overlap gate: pre-0.16.0 `export` only caught FULL-coverage
-        // supersedes, so a second export targeting a shared file like
-        // `browser/themes/shared/jar.inc.mn` happily created a queue where
-        // two patches both listed the same file in `filesAffected`. `verify`
-        // then failed immediately on "cross-patch filesAffected conflicts".
-        // `confirmSupersedePatches` might already have confirmed full
-        // supersedes above; pass their filenames through so we do not flag
-        // a file claimed by a patch that is about to be removed.
-        const willSupersede = await findAllPatchesForFiles(paths.patches, filesAffected);
-        const supersedingFilenames = new Set(willSupersede.map((p) => p.filename));
-        const shouldProceedPastOverlap = await guardOwnershipOverlap({
+        const shouldProceedPastGates = await runSupersedeAndOverlapGates({
             patchesDir: paths.patches,
             filesAffected,
-            supersedingFilenames,
+            supersede: options.supersede,
             allowOverlap: options.allowOverlap === true,
             isInteractive,
             s,
         });
-        if (!shouldProceedPastOverlap)
+        if (!shouldProceedPastGates)
             return;
         const { patchFilename, superseded } = await commitExportedPatch({
             patchesDir: paths.patches,
@@ -368,10 +310,7 @@ export async function exportCommand(projectRoot, files, options) {
             diff,
             filesAffected,
             ...buildPatchSourceMetadata(config.firefox),
-            ...(options.tier !== undefined ? { tier: options.tier } : {}),
-            ...(options.lintIgnore !== undefined && options.lintIgnore.length > 0
-                ? { lintIgnore: options.lintIgnore }
-                : {}),
+            ...patchMetadataExtras(options),
             config,
             policyCommand: 'export',
             forceUnsafe: options.forceUnsafe === true,

package/dist/src/commands/furnace/chrome-doc-templates.d.ts

@@ -7,19 +7,6 @@
  * upstream Firefox (browser.xhtml, privatebrowsing/aboutPrivateBrowsing.html,
  * etc.) minus the fork-specific wiring. A fork author fills in the body.
  */
-/**
- * Sentinel attribute emitted on every `furnace chrome-doc create`-scaffolded
- * root element. Platform modules (`DevToolsStartup`, `PageActions`,
- * `SessionStore`, `DownloadsButton`, …) that observe
- * `browser-delayed-startup-finished` and walk INTO the window assume the
- * `browser.xhtml` DOM and throw on anything else. A fork-authored patch
- * to such a module can use `hasAttribute(...)` against this sentinel as
- * a cheap, fork-neutral guard to skip the walk on a custom chrome doc.
- *
- * Exposed as a named constant so test code and external checks can
- * reference the exact attribute name without hardcoding the string.
- */
-export declare const FURNACE_CHROME_DOC_SENTINEL = "data-furnace-chrome-doc";
 /**
  * XHTML shell for a top-level chrome document.
  *

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 {