@hominis/fireforge 0.34.2 → 0.36.0

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

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