@hominis/fireforge 0.35.0 → 0.36.0

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

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { Option } from 'commander';
+import { Command, Option } from 'commander';
+import { withEngineSessionLock } from '../../core/engine-session-lock.js';
 import { pickDefined } from '../../utils/options.js';
 import { furnaceApplyCommand } from './apply.js';
 import { furnaceChromeDocCreateCommand } from './chrome-doc.js';
@@ -18,20 +19,12 @@ import { furnaceScanCommand } from './scan.js';
 import { furnaceStatusCommand } from './status.js';
 import { furnaceSyncCommand } from './sync.js';
 import { furnaceValidateCommand } from './validate.js';
-/**
- * Registers Furnace commands for querying component state: status, scan,
- * and action commands like apply, deploy, and create.
- * @param furnace - Parent Furnace command
- * @param context - Shared CLI registration context
- */
-function registerFurnaceInfoCommands(furnace, context) {
+async function runEngineLockedFurnaceCommand(context, command, operation) {
+    const projectRoot = context.getProjectRoot();
+    await withEngineSessionLock(projectRoot, command, () => operation(projectRoot));
+}
+function registerFurnaceApplyCommand(furnace, context) {
     const { getProjectRoot, withErrorHandling } = context;
-    furnace
-        .command('status [name]')
-        .description('Show component status and registration details')
-        .action(withErrorHandling(async (name) => {
-        await furnaceStatusCommand(getProjectRoot(), name);
-    }));
     furnace
         .command('apply [name]')
         .description('Apply components to the engine (optionally a single component)')
@@ -39,8 +32,17 @@ function registerFurnaceInfoCommands(furnace, context) {
         .option('--force', 'Proceed despite baseVersion drift (stale overrides)')
         .option('-w, --watch', 'Watch component directories and re-apply on changes')
         .action(withErrorHandling(async (name, options) => {
-        await furnaceApplyCommand(getProjectRoot(), name, pickDefined(options ?? {}));
+        const parsed = pickDefined(options ?? {});
+        const run = (projectRoot) => furnaceApplyCommand(projectRoot, name, parsed);
+        if (parsed.dryRun === true) {
+            await run(getProjectRoot());
+            return;
+        }
+        await runEngineLockedFurnaceCommand(context, 'furnace apply', run);
     }));
+}
+function registerFurnaceDeployCommand(furnace, context) {
+    const { getProjectRoot, withErrorHandling } = context;
     furnace
         .command('deploy [name]')
         .description('Apply components and validate in one step')
@@ -48,8 +50,48 @@ function registerFurnaceInfoCommands(furnace, context) {
         .option('--force', 'Proceed despite baseVersion drift (stale overrides)')
         .option('--skip-validate', 'Skip the validation step (apply only)')
         .action(withErrorHandling(async (name, options) => {
-        await furnaceDeployCommand(getProjectRoot(), name, pickDefined(options ?? {}));
+        const parsed = pickDefined(options ?? {});
+        const run = (projectRoot) => furnaceDeployCommand(projectRoot, name, parsed);
+        if (parsed.dryRun === true) {
+            await run(getProjectRoot());
+            return;
+        }
+        await runEngineLockedFurnaceCommand(context, 'furnace deploy', run);
+    }));
+}
+function registerFurnaceSyncCommand(furnace, context) {
+    const { getProjectRoot, withErrorHandling } = context;
+    furnace
+        .command('sync')
+        .description('Refresh drifted overrides and re-apply all components (recommended after fireforge download)')
+        .option('--dry-run', 'Show what would change without modifying files (reads may overlap concurrent mutations)')
+        .addOption(new Option('-s, --strategy <strategy>', 'Auto-resolve merge conflicts (ours = keep local, theirs = accept upstream)').choices(['ours', 'theirs']))
+        .action(withErrorHandling(async (options) => {
+        const parsed = pickDefined(options);
+        const run = (projectRoot) => furnaceSyncCommand(projectRoot, parsed);
+        if (parsed.dryRun === true) {
+            await run(getProjectRoot());
+            return;
+        }
+        await runEngineLockedFurnaceCommand(context, 'furnace sync', run);
     }));
+}
+/**
+ * Registers Furnace commands for querying component state: status, scan,
+ * and action commands like apply, deploy, and create.
+ * @param furnace - Parent Furnace command
+ * @param context - Shared CLI registration context
+ */
+function registerFurnaceInfoCommands(furnace, context) {
+    const { getProjectRoot, withErrorHandling } = context;
+    furnace
+        .command('status [name]')
+        .description('Show component status and registration details')
+        .action(withErrorHandling(async (name) => {
+        await furnaceStatusCommand(getProjectRoot(), name);
+    }));
+    registerFurnaceApplyCommand(furnace, context);
+    registerFurnaceDeployCommand(furnace, context);
     furnace
         .command('scan')
         .description('Scan engine for available components. Report-only by default: persist the discovered ' +
@@ -188,14 +230,7 @@ function registerFurnaceModifyCommands(furnace, context) {
         .action(withErrorHandling(async (oldName, newName) => {
         await furnaceRenameCommand(getProjectRoot(), oldName, newName);
     }));
-    furnace
-        .command('sync')
-        .description('Refresh drifted overrides and re-apply all components (recommended after fireforge download)')
-        .option('--dry-run', 'Show what would change without modifying files (reads may overlap concurrent mutations)')
-        .addOption(new Option('-s, --strategy <strategy>', 'Auto-resolve merge conflicts (ours = keep local, theirs = accept upstream)').choices(['ours', 'theirs']))
-        .action(withErrorHandling(async (options) => {
-        await furnaceSyncCommand(getProjectRoot(), pickDefined(options));
-    }));
+    registerFurnaceSyncCommand(furnace, context);
 }
 /** Registers the furnace command on the CLI program. */
 export function registerFurnace(program, context) {
@@ -209,4 +244,3 @@ export function registerFurnace(program, context) {
     registerFurnaceInfoCommands(furnace, context);
     registerFurnaceModifyCommands(furnace, context);
 }
-//# sourceMappingURL=index.js.map

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

@@ -279,4 +279,3 @@ async function scaffoldTokensCss(projectRoot) {
     }
     return { tokensCssPath };
 }
-//# sourceMappingURL=init.js.map

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

@@ -102,4 +102,3 @@ export async function furnaceListCommand(projectRoot, options = {}) {
     note(`Stock: ${stockCount}  Overrides: ${overrideCount}  Custom: ${customCount}  Total: ${total}`, 'Summary');
     outro('List complete');
 }
-//# sourceMappingURL=list.js.map

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

@@ -440,4 +440,3 @@ export async function furnaceBatchOverrideCommand(projectRoot, names, options =
     }
     outro(`Batch override complete: ${succeeded.length} succeeded, ${failed.length} failed`);
 }
-//# sourceMappingURL=override.js.map

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

@@ -5,6 +5,7 @@ import { applyAllComponents } from '../../core/furnace-apply.js';
 import { furnaceConfigExists, loadFurnaceConfig, updateFurnaceState, } from '../../core/furnace-config.js';
 import { runFurnaceMutation } from '../../core/furnace-operation.js';
 import { restoreRollbackJournal } from '../../core/furnace-rollback.js';
+import { countEntriesWithBlockingStepErrors } from '../../core/furnace-step-errors.js';
 import { cleanStories, syncStories } from '../../core/furnace-stories.js';
 import { hasBuildArtifacts, runMach, runMachCapture } from '../../core/mach.js';
 import { FurnaceError } from '../../errors/furnace.js';
@@ -68,7 +69,7 @@ function reportPreviewStagingFailures(stageResult) {
             }
         }
     }
-    const appliedWithStepErrorsCount = stageResult.applied.filter((entry) => (entry.stepErrors?.length ?? 0) > 0).length;
+    const appliedWithStepErrorsCount = countEntriesWithBlockingStepErrors(stageResult.applied);
     const totalFailures = stageResult.errors.length + appliedWithStepErrorsCount;
     throw new FurnaceError(`${totalFailures} component${totalFailures === 1 ? '' : 's'} failed to stage for preview`);
 }
@@ -273,7 +274,7 @@ export async function furnacePreviewCommand(projectRoot, options = {}) {
                 if (previewJournal) {
                     ctx.registerJournal(previewJournal);
                 }
-                const appliedWithStepErrorsCount = stageResult.applied.filter((entry) => (entry.stepErrors?.length ?? 0) > 0).length;
+                const appliedWithStepErrorsCount = countEntriesWithBlockingStepErrors(stageResult.applied);
                 const totalFailures = stageResult.errors.length + appliedWithStepErrorsCount;
                 if (totalFailures > 0) {
                     stageSpinner.error('Failed to stage components');
@@ -362,4 +363,3 @@ export async function furnacePreviewCommand(projectRoot, options = {}) {
     }
     outro('Storybook stopped');
 }
-//# sourceMappingURL=preview.js.map

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

@@ -294,4 +294,3 @@ export async function furnaceRefreshCommand(projectRoot, name, options = {}) {
     }
     outro(dryRun ? 'Dry run complete' : 'Refresh complete');
 }
-//# sourceMappingURL=refresh.js.map

package/dist/src/commands/furnace/remove-state.d.ts

@@ -1,5 +1,20 @@
+import { type RollbackJournal } from '../../core/furnace-rollback.js';
 import type { FurnaceState } from '../../types/furnace.js';
 /**
  * Removes every checksum entry owned by the removed component.
  */
 export declare function dropChecksumsByPrefix(state: FurnaceState, prefix: string): FurnaceState;
+/**
+ * Deletes the files a custom component deployed into its engine targetPath.
+ *
+ * Per-file, never a recursive `removeDir` of the whole directory: nothing
+ * stops two components from sharing a targetPath (or a hand-edited config
+ * from pointing at an upstream-shared directory), and the recursive delete
+ * permanently destroyed the co-located files on success — the rollback
+ * journal only protects the failure path. Deployed files come from the
+ * component's state checksums, falling back to the conventional
+ * `<name>.{mjs,css,ftl}` set when state carries no record (cleared by a
+ * --force download or rebase). The directory itself is removed only when
+ * nothing else lives in it afterwards.
+ */
+export declare function removeDeployedCustomFiles(projectRoot: string, engineDir: string, name: string, targetPath: string, journal: RollbackJournal): Promise<void>;

package/dist/src/commands/furnace/remove-state.js

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { loadFurnaceState } from '../../core/furnace-config.js';
+import { snapshotFile } from '../../core/furnace-rollback.js';
+import { pathExists, removeDir, removeFile } from '../../utils/fs.js';
+import { info } from '../../utils/logger.js';
 /**
  * Removes every checksum entry owned by the removed component.
  */
@@ -11,4 +17,44 @@ export function dropChecksumsByPrefix(state, prefix) {
     }
     return result;
 }
-//# sourceMappingURL=remove-state.js.map
+/**
+ * Deletes the files a custom component deployed into its engine targetPath.
+ *
+ * Per-file, never a recursive `removeDir` of the whole directory: nothing
+ * stops two components from sharing a targetPath (or a hand-edited config
+ * from pointing at an upstream-shared directory), and the recursive delete
+ * permanently destroyed the co-located files on success — the rollback
+ * journal only protects the failure path. Deployed files come from the
+ * component's state checksums, falling back to the conventional
+ * `<name>.{mjs,css,ftl}` set when state carries no record (cleared by a
+ * --force download or rebase). The directory itself is removed only when
+ * nothing else lives in it afterwards.
+ */
+export async function removeDeployedCustomFiles(projectRoot, engineDir, name, targetPath, journal) {
+    const engineTargetDir = join(engineDir, targetPath);
+    if (!(await pathExists(engineTargetDir)))
+        return;
+    const state = await loadFurnaceState(projectRoot);
+    const checksumPrefix = `custom/${name}/`;
+    const recordedFiles = Object.keys(state.appliedChecksums ?? {})
+        .filter((key) => key.startsWith(checksumPrefix))
+        .map((key) => key.slice(checksumPrefix.length));
+    const deployedFiles = recordedFiles.length > 0 ? recordedFiles : [`${name}.mjs`, `${name}.css`, `${name}.ftl`];
+    let deletedCount = 0;
+    for (const file of deployedFiles) {
+        const target = join(engineTargetDir, file);
+        if (await pathExists(target)) {
+            await snapshotFile(journal, target);
+            await removeFile(target);
+            deletedCount++;
+        }
+    }
+    if (deletedCount > 0) {
+        info(`Deleted ${deletedCount} deployed file(s) from engine/${targetPath}/`);
+    }
+    const { readdir } = await import('node:fs/promises');
+    if ((await readdir(engineTargetDir)).length === 0) {
+        await removeDir(engineTargetDir);
+        info(`Removed now-empty engine/${targetPath}/`);
+    }
+}

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

@@ -16,7 +16,7 @@ import { FurnaceError } from '../../errors/furnace.js';
 import { toError } from '../../utils/errors.js';
 import { pathExists, readText, removeDir, removeFile, writeText } from '../../utils/fs.js';
 import { cancel, info, intro, isCancel, outro, warn } from '../../utils/logger.js';
-import { dropChecksumsByPrefix } from './remove-state.js';
+import { dropChecksumsByPrefix, removeDeployedCustomFiles } from './remove-state.js';
 /**
  * Removes an entire TOML section (header + body lines) for a given test file.
  * Matches from `["filename"]` up to the next section header `[` or end-of-file,
@@ -457,14 +457,9 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
                     await removeDir(dir);
                     info(`Deleted components/custom/${name}/`);
                 }
-                // Clean up deployed files in engine
+                // Clean up deployed files in engine (per-file — see helper doc).
                 if (customConfig?.targetPath) {
-                    const engineDir = join(paths.engine, customConfig.targetPath);
-                    if (await pathExists(engineDir)) {
-                        await snapshotDir(journal, engineDir);
-                        await removeDir(engineDir);
-                        info(`Deleted deployed files from engine/${customConfig.targetPath}/`);
-                    }
+                    await removeDeployedCustomFiles(projectRoot, paths.engine, name, customConfig.targetPath, journal);
                 }
                 // Localized components deploy a .ftl outside targetPath into the
                 // shared Fluent tree; apply writes it, so remove must delete it too
@@ -530,4 +525,3 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
     info(`Removed "${name}" from furnace.json`);
     outro('Component removed');
 }
-//# sourceMappingURL=remove.js.map

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

@@ -1,9 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { tagNameToClassName } from '../../core/furnace-constants.js';
-/** Escapes regex metacharacters so a user-supplied name is literal inside a RegExp. */
-function escapeRegex(input) {
-    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
+import { escapeRegex } from '../../utils/regex.js';
 function deriveTestStem(componentName, binaryName) {
     const strippedName = componentName.startsWith('moz-') ? componentName.slice(4) : componentName;
     const withoutBinaryPrefix = strippedName.startsWith(binaryName + '-')
@@ -25,4 +22,3 @@ export function updateBrowserChromeTestContent(content, oldName, newName, binary
         .replace(new RegExp(escapeRegex(oldUnderscored), 'g'), newUnderscored)
         .replace(new RegExp(escapeRegex(oldTestStem), 'g'), newTestStem);
 }
-//# sourceMappingURL=rename-browser-test.js.map

package/dist/src/commands/furnace/rename-helpers.d.ts

@@ -11,3 +11,9 @@ export declare function updateConfigForCustomRename(config: FurnaceConfig, oldNa
  * Re-keys an override component config entry.
  */
 export declare function updateConfigForOverrideRename(config: FurnaceConfig, oldName: string, newName: string): void;
+/**
+ * Re-keys checksum entries in furnace-state.json from the old component name
+ * to the new name so that `doctor` doesn't flag stale entries and the next
+ * `apply` can correctly detect whether the renamed component has changed.
+ */
+export declare function rekeyStateChecksums(projectRoot: string, componentType: string, oldName: string, newName: string): Promise<void>;

package/dist/src/commands/furnace/rename-helpers.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { updateFurnaceState } from '../../core/furnace-config.js';
 /**
  * Applies a component rename to scaffold-owned filenames only.
  */
@@ -39,4 +41,31 @@ export function updateConfigForOverrideRename(config, oldName, newName) {
     // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- idiomatic key removal from config record
     delete config.overrides[oldName];
 }
-//# sourceMappingURL=rename-helpers.js.map
+/**
+ * Re-keys checksum entries in furnace-state.json from the old component name
+ * to the new name so that `doctor` doesn't flag stale entries and the next
+ * `apply` can correctly detect whether the renamed component has changed.
+ */
+export async function rekeyStateChecksums(projectRoot, componentType, oldName, newName) {
+    const oldPrefix = `${componentType}/${oldName}/`;
+    const newPrefix = `${componentType}/${newName}/`;
+    await updateFurnaceState(projectRoot, (state) => {
+        const result = { ...state };
+        for (const field of ['appliedChecksums', 'engineChecksums']) {
+            const checksums = state[field];
+            if (!checksums)
+                continue;
+            const updated = {};
+            for (const [key, value] of Object.entries(checksums)) {
+                if (key.startsWith(oldPrefix)) {
+                    updated[newPrefix + key.slice(oldPrefix.length)] = value;
+                }
+                else {
+                    updated[key] = value;
+                }
+            }
+            result[field] = updated;
+        }
+        return result;
+    });
+}

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

@@ -19,14 +19,11 @@ import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { loadConfig } from '../../core/config.js';
 import { xpcshellTestParentDir } from '../../core/furnace-constants.js';
-import { snapshotFile } from '../../core/furnace-rollback.js';
+import { recordCreatedDir, snapshotFile, } from '../../core/furnace-rollback.js';
 import { toError } from '../../utils/errors.js';
 import { ensureDir, pathExists, readText, removeDir, removeFile, writeText, } from '../../utils/fs.js';
 import { info, warn } from '../../utils/logger.js';
-/** Escapes regex metacharacters so a user-supplied name stays literal. */
-function escapeRegex(input) {
-    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
+import { escapeRegex } from '../../utils/regex.js';
 /**
  * Renames an xpcshell test scaffold in place. Moves the directory,
  * rewrites the test filename, updates the `[test_name]` section header
@@ -64,6 +61,10 @@ export async function renameXpcshellTestFiles(engineDir, projectRoot, oldName, n
     const oldTestFileName = `test_${oldUnderscored}_packaged.js`;
     const newTestFileName = `test_${newUnderscored}_packaged.js`;
     try {
+        // Journal the new scaffold dir + files so rollback (including the
+        // SIGINT path) removes them; only the old-name files were journaled
+        // before, so a failed rename stranded the new-name scaffold.
+        recordCreatedDir(journal, newScaffoldDir);
         await ensureDir(newScaffoldDir);
         const entries = await readdir(oldScaffoldDir, { withFileTypes: true });
         for (const entry of entries) {
@@ -73,6 +74,7 @@ export async function renameXpcshellTestFiles(engineDir, projectRoot, oldName, n
             const renamedFileName = entry.name === oldTestFileName ? newTestFileName : entry.name;
             const newFilePath = join(newScaffoldDir, renamedFileName);
             await snapshotFile(journal, oldFilePath);
+            await snapshotFile(journal, newFilePath);
             const body = await readText(oldFilePath);
             let updated = body;
             if (entry.name === 'xpcshell.toml') {
@@ -94,4 +96,3 @@ export async function renameXpcshellTestFiles(engineDir, projectRoot, oldName, n
         warn(`Could not rename xpcshell scaffold — ${toError(error).message}. Rename the scaffold files manually if needed.`);
     }
 }
-//# sourceMappingURL=rename-xpcshell.js.map

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

@@ -2,25 +2,22 @@
 import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { getFurnacePaths, loadFurnaceConfig, updateFurnaceState, writeFurnaceConfig, } from '../../core/furnace-config.js';
+import { getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
 import { isComponentSourceFile, resolveFtlChromeSubPath, resolveFtlDir, resolveFtlLocaleJarMnPath, tagNameToClassName, } from '../../core/furnace-constants.js';
 import { recordFurnaceRollbackFailure, runFurnaceMutation } from '../../core/furnace-operation.js';
 import { addCustomElementRegistration, addJarMnEntries, addLocaleFtlJarMnEntry, removeCustomElementRegistration, removeJarMnEntries, removeLocaleFtlJarMnEntry, } from '../../core/furnace-registration.js';
 import { CUSTOM_ELEMENT_TAG_PATTERN, CUSTOM_ELEMENT_TAG_RULES, } from '../../core/furnace-registration-validate.js';
-import { createRollbackJournal, restoreRollbackJournalOrThrow, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
+import { createRollbackJournal, recordCreatedDir, restoreRollbackJournalOrThrow, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
 import { getStoriesDir } from '../../core/furnace-stories.js';
 import { InvalidArgumentError } from '../../errors/base.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { toError } from '../../utils/errors.js';
 import { copyFile, ensureDir, pathExists, readText, removeDir, removeFile, writeText, } from '../../utils/fs.js';
 import { info, intro, note, outro, warn } from '../../utils/logger.js';
+import { escapeRegex } from '../../utils/regex.js';
 import { updateBrowserChromeTestContent } from './rename-browser-test.js';
-import { renameComponentFileName, updateConfigForCustomRename, updateConfigForOverrideRename, } from './rename-helpers.js';
+import { rekeyStateChecksums, renameComponentFileName, updateConfigForCustomRename, updateConfigForOverrideRename, } from './rename-helpers.js';
 import { renameXpcshellTestFiles } from './rename-xpcshell.js';
-/** Escapes regex metacharacters so a user-supplied name is literal inside a RegExp. */
-function escapeRegex(input) {
-    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 /**
  * Derives the test file name for a component, matching the convention used by
  * `furnace create --with-tests`.
@@ -58,6 +55,7 @@ async function renameTestFiles(engineDir, projectRoot, oldName, newName, journal
     if (await pathExists(oldTestPath)) {
         try {
             await snapshotFile(journal, oldTestPath);
+            await snapshotFile(journal, newTestPath);
             const content = await readText(oldTestPath);
             await writeText(newTestPath, updateBrowserChromeTestContent(content, oldName, newName, binaryName));
             await removeFile(oldTestPath);
@@ -144,6 +142,7 @@ async function renameMochikitTestFiles(engineDir, oldName, newName, journal) {
                 .replace(new RegExp(`Test the ${escapeRegex(oldName)} `, 'g'), `Test the ${newName} `)
                 .replace(new RegExp(`add_task\\(async function test_${escapeRegex(oldName.replace(/-/g, '_'))}_defined\\(`, 'g'), `add_task(async function test_${newName.replace(/-/g, '_')}_defined(`)
                 .replace(new RegExp(`"${escapeRegex(oldName)} custom element`, 'g'), `"${newName} custom element`);
+            await snapshotFile(journal, newTestPath);
             await writeText(newTestPath, updatedContent);
             await removeFile(oldTestPath);
             info(`Renamed mochikit test: ${oldTestFileName} → ${newTestFileName}`);
@@ -209,7 +208,14 @@ async function performRenameMutations(args) {
             }
             await snapshotDir(journal, oldDir);
             await snapshotFile(journal, args.furnaceConfigPath);
+            // Journal the state file BEFORE step 4 re-keys its checksums, plus
+            // the new dir and every new-name destination below (a snapshot of a
+            // missing path records {existed: false} → rollback DELETES it).
+            // Without these, a failed or SIGINT'd rename stranded the new-name
+            // scaffold and kept re-keyed state for a nonexistent component.
+            await snapshotFile(journal, getFurnacePaths(projectRoot).furnaceState);
             // 1. Create new directory with renamed files and updated content
+            recordCreatedDir(journal, newDir);
             await ensureDir(newDir);
             const entries = await readdir(oldDir, { withFileTypes: true });
             for (const entry of entries) {
@@ -227,6 +233,7 @@ async function performRenameMutations(args) {
                 const newFileName = renameComponentFileName(oldFileName, oldName, newName);
                 const oldPath = join(oldDir, oldFileName);
                 const newPath = join(newDir, newFileName);
+                await snapshotFile(journal, newPath);
                 if (isComponentSourceFile(oldFileName)) {
                     let content = await readText(oldPath);
                     // Use word-boundary-aware patterns so substrings in other
@@ -320,34 +327,6 @@ async function performRenameMutations(args) {
         }
     });
 }
-/**
- * Re-keys checksum entries in furnace-state.json from the old component name
- * to the new name so that `doctor` doesn't flag stale entries and the next
- * `apply` can correctly detect whether the renamed component has changed.
- */
-async function rekeyStateChecksums(projectRoot, componentType, oldName, newName) {
-    const oldPrefix = `${componentType}/${oldName}/`;
-    const newPrefix = `${componentType}/${newName}/`;
-    await updateFurnaceState(projectRoot, (state) => {
-        const result = { ...state };
-        for (const field of ['appliedChecksums', 'engineChecksums']) {
-            const checksums = state[field];
-            if (!checksums)
-                continue;
-            const updated = {};
-            for (const [key, value] of Object.entries(checksums)) {
-                if (key.startsWith(oldPrefix)) {
-                    updated[newPrefix + key.slice(oldPrefix.length)] = value;
-                }
-                else {
-                    updated[key] = value;
-                }
-            }
-            result[field] = updated;
-        }
-        return result;
-    });
-}
 async function updateEngineRegistrations(engineDir, oldName, newName, newDir, ftlDir, isLocalized, journal) {
     const customElementsPath = join(engineDir, 'toolkit/content/customElements.js');
     const jarMnPath = join(engineDir, 'toolkit/content/jar.mn');
@@ -372,6 +351,7 @@ async function updateEngineRegistrations(engineDir, oldName, newName, newDir, ft
     const newFtlPath = join(ftlDirPath, `${newName}.ftl`);
     if (await pathExists(oldFtlPath)) {
         await snapshotFile(journal, oldFtlPath);
+        await snapshotFile(journal, newFtlPath);
         const ftlContent = await readText(oldFtlPath);
         await writeText(newFtlPath, ftlContent);
         await removeFile(oldFtlPath);
@@ -463,4 +443,3 @@ export async function furnaceRenameCommand(projectRoot, oldName, newName) {
         '  3. Run "fireforge furnace apply" to update the engine', newName);
     outro('Rename complete');
 }
-//# sourceMappingURL=rename.js.map

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

@@ -208,4 +208,3 @@ export async function furnaceScanCommand(projectRoot, options = {}) {
     }
     outro('Scan complete');
 }
-//# sourceMappingURL=scan.js.map

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

@@ -199,4 +199,3 @@ export async function furnaceStatusCommand(projectRoot, name) {
     info('Tip: run `fireforge furnace status <name>` for detailed component info, or `fireforge furnace --help` for all subcommands.');
     outro('Status complete');
 }
-//# sourceMappingURL=status.js.map

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

@@ -1,15 +1,56 @@
 // SPDX-License-Identifier: EUPL-1.2
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
 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 { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, } from '../../core/furnace-config.js';
 import { reportJsconfigPathsSync } from '../../core/furnace-jsconfig.js';
 import { runFurnaceMutation } from '../../core/furnace-operation.js';
+import { countEntriesWithBlockingStepErrors } from '../../core/furnace-step-errors.js';
+import { containsMergeConflictMarkers } from '../../core/furnace-validate-structure.js';
 import { findOverrideBaseVersionDrift, formatOverrideBaseVersionDriftWarning, } from '../../core/furnace-version-drift.js';
 import { FurnaceError } from '../../errors/furnace.js';
-import { pathExists } from '../../utils/fs.js';
+import { pathExists, readText } from '../../utils/fs.js';
 import { info, intro, outro, spinner, warn } from '../../utils/logger.js';
 import { furnaceRefreshCommand } from './refresh.js';
+/**
+ * Scans every configured override/custom component workspace for files
+ * carrying unresolved merge conflict markers. Returns the component names
+ * (sorted, unique) that must be resolved before an apply may run.
+ */
+async function findComponentsWithConflictMarkers(furnacePaths, config) {
+    const conflicted = new Set();
+    const componentDirs = [
+        ...Object.keys(config.overrides).map((name) => ({
+            name,
+            dir: join(furnacePaths.overridesDir, name),
+        })),
+        ...Object.keys(config.custom).map((name) => ({
+            name,
+            dir: join(furnacePaths.customDir, name),
+        })),
+    ];
+    for (const { name, dir } of componentDirs) {
+        if (!(await pathExists(dir)))
+            continue;
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            if (!entry.name.endsWith('.mjs') &&
+                !entry.name.endsWith('.css') &&
+                !entry.name.endsWith('.ftl')) {
+                continue;
+            }
+            if (containsMergeConflictMarkers(await readText(join(dir, entry.name)))) {
+                conflicted.add(name);
+                break;
+            }
+        }
+    }
+    return [...conflicted].sort();
+}
 /**
  * Runs the furnace sync command: detects overrides with baseVersion drift,
  * refreshes them (three-way merge), and re-applies all components.
@@ -57,6 +98,38 @@ export async function furnaceSyncCommand(projectRoot, options = {}) {
     else {
         info('All overrides are up-to-date with the current Firefox version.');
     }
+    // Phase 2.5: post-refresh gates. Refresh deliberately leaves conflict
+    // markers in workspace files and does NOT bump baseVersion on conflict —
+    // so before this gate existed, sync would warn about conflicts and then
+    // copy the marker-laden files straight into the engine via Phase 3,
+    // producing a broken build from the one command whose whole purpose is a
+    // safe upgrade. Apply/deploy both enforce a drift gate; sync must not be
+    // the back door around it.
+    if (!options.dryRun) {
+        const refreshedConfig = await loadFurnaceConfig(projectRoot);
+        const furnacePaths = getFurnacePaths(projectRoot);
+        const conflicted = await findComponentsWithConflictMarkers(furnacePaths, refreshedConfig);
+        const remainingDrift = findOverrideBaseVersionDrift(refreshedConfig, forgeConfig.firefox.version);
+        if (conflicted.length > 0 || remainingDrift.length > 0) {
+            if (conflicted.length > 0) {
+                warn(`Unresolved merge conflicts in: ${conflicted.join(', ')}`);
+            }
+            for (const entry of remainingDrift) {
+                warn(formatOverrideBaseVersionDriftWarning(entry));
+            }
+            throw new FurnaceError('Sync stopped before applying: ' +
+                (conflicted.length > 0
+                    ? `${conflicted.length} component(s) contain unresolved merge conflict markers` +
+                        (remainingDrift.length > 0 ? ' and ' : '')
+                    : '') +
+                (remainingDrift.length > 0
+                    ? `${remainingDrift.length} override(s) still have baseVersion drift`
+                    : '') +
+                '. Resolve the conflicts in the component workspace files, re-run ' +
+                '"fireforge furnace refresh <name>" to update baseVersion, then run ' +
+                '"fireforge furnace sync" again. Nothing was applied to the engine.');
+        }
+    }
     // Phase 3: Re-apply all components to the engine
     if (!options.dryRun) {
         info('\nApplying all components to engine...');
@@ -64,7 +137,7 @@ export async function furnaceSyncCommand(projectRoot, options = {}) {
         const result = await runFurnaceMutation(projectRoot, 'apply-rollback', (ctx) => applyAllComponents(projectRoot, false, { operationContext: ctx }), { dryRun: false });
         applySpinner.stop('Components applied');
         logApplyResult(result, false);
-        const appliedWithStepErrorsCount = result.applied.filter((entry) => (entry.stepErrors?.length ?? 0) > 0).length;
+        const appliedWithStepErrorsCount = countEntriesWithBlockingStepErrors(result.applied);
         const totalFailures = result.errors.length + appliedWithStepErrorsCount;
         if (totalFailures > 0) {
             throw new FurnaceError(`${totalFailures} component${totalFailures === 1 ? '' : 's'} failed to apply cleanly`);
@@ -76,4 +149,3 @@ export async function furnaceSyncCommand(projectRoot, options = {}) {
         outro('Dry run complete');
     }
 }
-//# sourceMappingURL=sync.js.map

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

@@ -263,4 +263,3 @@ async function reValidateComponents(projectRoot, config, furnacePaths, component
     }
     return { issues, totalErrors, totalWarnings };
 }
-//# sourceMappingURL=validate.js.map

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

@@ -127,4 +127,3 @@ export async function runDeployValidation(validateSpinner, name, config, furnace
     }
     return { done: false, totalErrors, totalWarnings, componentCount, skippedValidationCount };
 }
-//# sourceMappingURL=validation-output.js.map