@hominis/fireforge 0.19.6 → 0.20.0

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

@@ -2,7 +2,7 @@
 import { join } from 'node:path';
 import { text } from '@clack/prompts';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { createDefaultFurnaceConfig, detectComposesCycles, furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
+import { createDefaultFurnaceConfig, furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
 import { resolveFtlChromeSubPath, tagNameToClassName } from '../../core/furnace-constants.js';
 import { recordFurnaceRollbackFailure, runFurnaceMutation, } from '../../core/furnace-operation.js';
 import { CUSTOM_ELEMENT_TAG_PATTERN, CUSTOM_ELEMENT_TAG_RULES, } from '../../core/furnace-registration-validate.js';
@@ -21,6 +21,7 @@ import { resolveCreateFeatures } from './create-features.js';
 import { scaffoldMochikitTestFiles } from './create-mochikit.js';
 import { assertCustomEntryPersisted } from './create-readback.js';
 import { generateCssContent, generateFtlContent, generateMjsContent } from './create-templates.js';
+import { validateCreateAgainstConfig } from './create-validation.js';
 import { scaffoldXpcshellTestFiles } from './create-xpcshell.js';
 async function loadAuthoringFurnaceConfig(projectRoot) {
     if (await furnaceConfigExists(projectRoot)) {
@@ -41,18 +42,6 @@ function validateTagName(name) {
         return `Name ${CUSTOM_ELEMENT_TAG_RULES}`;
     return undefined;
 }
-/**
- * Checks if a component name conflicts with existing entries in furnace.json.
- */
-function checkNameConflict(config, name) {
-    if (name in config.custom) {
-        return `A custom component named "${name}" already exists in furnace.json`;
-    }
-    if (name in config.overrides) {
-        return `An override component named "${name}" already exists in furnace.json`;
-    }
-    return undefined;
-}
 /**
  * Scaffolds browser mochitest files for a newly created custom component.
  * @param componentName - Custom element tag name
@@ -247,11 +236,16 @@ async function performCreateMutations(args) {
     const testFiles = [];
     let files;
     try {
+        const freshConfig = await loadAuthoringFurnaceConfig(args.projectRoot);
+        validateCreateAgainstConfig(freshConfig, args.componentName, args.allowPrefixMismatch, args.composes);
+        if (await pathExists(args.componentDir)) {
+            throw new FurnaceError(`Directory already exists: components/custom/${args.componentName}`, args.componentName);
+        }
         // Record the componentDir creation entry immediately after registration
         // so signal-driven rollback can clean it up even if writeComponentFiles
         // is interrupted mid-ensureDir.
         recordCreatedDir(journal, args.componentDir);
-        files = await writeComponentFiles(args.componentDir, args.componentName, args.className, args.description, args.localized, args.license, args.ftlChromeSubPath, args.sharedFtl, journal);
+        files = await writeComponentFiles(args.componentDir, args.componentName, args.className, args.description, args.localized, args.license, resolveFtlChromeSubPath(freshConfig.ftlBasePath), args.sharedFtl, journal);
         const customEntry = {
             description: args.description,
             targetPath: `toolkit/content/widgets/${args.componentName}`,
@@ -264,9 +258,9 @@ async function performCreateMutations(args) {
         if (args.sharedFtl) {
             customEntry.sharedFtl = args.sharedFtl;
         }
-        args.config.custom[args.componentName] = customEntry;
+        freshConfig.custom[args.componentName] = customEntry;
         await snapshotFile(journal, args.furnacePaths.furnaceConfig);
-        await writeFurnaceConfig(args.projectRoot, args.config);
+        await writeFurnaceConfig(args.projectRoot, freshConfig);
         await assertCustomEntryPersisted(args.projectRoot, args.componentName);
         if (args.testStyle === 'browser-chrome') {
             const scafFiles = await scaffoldTestFiles(args.componentName, args.license, args.forgeConfig, args.paths, journal);
@@ -310,41 +304,6 @@ async function resolveDescription(isInteractive, options) {
     }
     return description;
 }
-/**
- * Validates the `--compose` targets against registered components and runs
- * cycle detection if the new component is introduced into the graph. Throws
- * on any failure; returns when the graph is clean.
- */
-function validateComposesTargets(config, componentName, composes) {
-    if (!composes || composes.length === 0)
-        return;
-    const known = new Set([
-        ...config.stock,
-        ...Object.keys(config.overrides),
-        ...Object.keys(config.custom),
-    ]);
-    for (const tag of composes) {
-        if (tag === componentName) {
-            throw new FurnaceError(`Component "${componentName}" cannot compose itself.`);
-        }
-        if (!known.has(tag)) {
-            throw new FurnaceError(`Cannot compose unknown component "${tag}". ` +
-                'The referenced component must be registered as stock, override, or custom.');
-        }
-    }
-    // Check for cycles that would be introduced by adding this component.
-    const tempCustom = {
-        ...config.custom,
-        [componentName]: {
-            description: '',
-            targetPath: `toolkit/content/widgets/${componentName}`,
-            register: true,
-            localized: false,
-            composes,
-        },
-    };
-    detectComposesCycles(tempCustom);
-}
 /**
  * Runs the furnace create command to scaffold a new custom component.
  * @param projectRoot - Root directory of the project
@@ -391,39 +350,14 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
     // succeeds so a cancelled create in a fresh project does not strand a new
     // furnace.json behind.
     const config = await loadAuthoringFurnaceConfig(projectRoot);
-    // Check for conflicts
-    const conflict = checkNameConflict(config, componentName);
-    if (conflict) {
-        throw new FurnaceError(conflict, componentName);
-    }
+    const composes = options.compose;
+    validateCreateAgainstConfig(config, componentName, options.allowPrefixMismatch, composes);
     // Check if it already exists in the engine source tree
     if (await pathExists(paths.engine)) {
         if (await isComponentInEngine(paths.engine, componentName)) {
             throw new FurnaceError(`"${componentName}" already exists in the engine source tree. Use "fireforge furnace override" instead.`, componentName);
         }
     }
-    // Refuse if name doesn't match componentPrefix, unless
-    // --allow-prefix-mismatch was explicitly passed.
-    //
-    // Pre-0.16.0 this was a bare `warn()` and the create flow continued,
-    // which produced a class of validation runs where the command reported
-    // success, scaffolded files under components/custom/<name>/, and
-    // registered tests in browser/base/moz.build, but the component
-    // wasn't a good citizen of the fork's convention — subsequent
-    // follow-up commands (list, status, rename) behaved inconsistently.
-    // Refusing up-front leaves the workspace untouched on a bad name and
-    // forces an intentional `--allow-prefix-mismatch` for the rare case
-    // where the mismatch is deliberate.
-    if (config.componentPrefix &&
-        !componentName.startsWith(config.componentPrefix) &&
-        !options.allowPrefixMismatch) {
-        throw new InvalidArgumentError(`Name "${componentName}" does not start with the configured prefix "${config.componentPrefix}". ` +
-            'Use a prefixed name (e.g. "' +
-            config.componentPrefix +
-            componentName +
-            '"), update `componentPrefix` in furnace.json, ' +
-            'or pass --allow-prefix-mismatch to create the component anyway.', 'name');
-    }
     // --- Resolve description ---
     const description = await resolveDescription(isInteractive, options);
     // --- Resolve features ---
@@ -447,10 +381,6 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
     if (await pathExists(componentDir)) {
         throw new FurnaceError(`Directory already exists: components/custom/${componentName}`, componentName);
     }
-    // --- Validate --compose targets BEFORE any writes so a failed validation
-    // does not strand component files behind.
-    const composes = options.compose;
-    validateComposesTargets(config, componentName, composes);
     // --- Normalize and validate --shared-ftl ahead of any writes. Shares the
     // structural rules with furnace-config.ts so the command and the on-disk
     // schema cannot diverge. Pass the resolved `localized` rather than a
@@ -492,10 +422,6 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
     // state via the shared rollback journal. The mutation runs under the
     // furnace-wide lock and is registered with the global SIGINT/SIGTERM
     // rollback pathway.
-    // Derive the FTL chrome sub-path from the configured ftlBasePath so the
-    // generated `.mjs` calls `insertFTLIfNeeded` at a URI that actually matches
-    // the locale jar.mn entry `furnace apply` will write.
-    const ftlChromeSubPath = resolveFtlChromeSubPath(config.ftlBasePath);
     const { files, testFiles } = await runFurnaceMutation(projectRoot, 'create-rollback', (ctx) => performCreateMutations({
         projectRoot,
         componentName,
@@ -507,12 +433,11 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
         sharedFtl,
         componentDir,
         furnacePaths,
-        config,
+        allowPrefixMismatch: options.allowPrefixMismatch,
         forgeConfig,
         paths,
         license,
         testStyle,
-        ftlChromeSubPath,
         operationContext: ctx,
     }));
     note(formatSuccessNote({

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

@@ -213,6 +213,7 @@ export async function furnaceRefreshCommand(projectRoot, name, options = {}) {
     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
@@ -244,7 +245,9 @@ export async function furnaceRefreshCommand(projectRoot, name, options = {}) {
                 }
             }
             catch (error) {
-                warn(`${overrideName}: ${toError(error).message}`);
+                const message = toError(error).message;
+                warn(`${overrideName}: ${message}`);
+                failedOverrides.push({ name: overrideName, message });
             }
         }
     }
@@ -257,12 +260,18 @@ export async function furnaceRefreshCommand(projectRoot, name, options = {}) {
         throw error;
     }
     const summary = `${overrideNames.length} override(s) processed, ${totalSkipped} already up-to-date\n` +
-        `${totalMerged} file(s) merged, ${totalUnchanged} unchanged, ${totalConflicts} conflict(s)`;
+        `${totalMerged} file(s) merged, ${totalUnchanged} unchanged, ${totalConflicts} conflict(s), ` +
+        `${failedOverrides.length} failed`;
     if (conflictComponents.length > 0) {
         warn(`Conflicts in: ${conflictComponents.join(', ')}. ` +
             'Resolve conflict markers, then re-run refresh for those components to update baseVersion.');
     }
     note(summary, dryRun ? 'Dry Run Summary' : 'Refresh Summary');
+    if (failedOverrides.length > 0) {
+        outro(dryRun ? 'Dry run completed with failures' : 'Refresh completed with failures');
+        throw new FurnaceError(`Failed to refresh ${failedOverrides.length} override(s): ` +
+            failedOverrides.map((failure) => `${failure.name}: ${failure.message}`).join('; '));
+    }
     outro(dryRun ? 'Dry run complete' : 'Refresh complete');
 }
 //# sourceMappingURL=refresh.js.map

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

@@ -0,0 +1,5 @@
+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;

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

@@ -0,0 +1,14 @@
+/**
+ * Removes every checksum entry owned by the removed component.
+ */
+export function dropChecksumsByPrefix(state, prefix) {
+    const result = { ...state };
+    if (state.appliedChecksums) {
+        result.appliedChecksums = Object.fromEntries(Object.entries(state.appliedChecksums).filter(([k]) => !k.startsWith(prefix)));
+    }
+    if (state.engineChecksums) {
+        result.engineChecksums = Object.fromEntries(Object.entries(state.engineChecksums).filter(([k]) => !k.startsWith(prefix)));
+    }
+    return result;
+}
+//# sourceMappingURL=remove-state.js.map

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

@@ -16,6 +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';
 /**
  * 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,
@@ -328,15 +329,22 @@ async function cleanupCustomXpcshellTestFiles(name, projectRoot, journal) {
     }
     return { partialFailures };
 }
-function dropChecksumsByPrefix(state, prefix) {
-    const result = { ...state };
-    if (state.appliedChecksums) {
-        result.appliedChecksums = Object.fromEntries(Object.entries(state.appliedChecksums).filter(([k]) => !k.startsWith(prefix)));
-    }
-    if (state.engineChecksums) {
-        result.engineChecksums = Object.fromEntries(Object.entries(state.engineChecksums).filter(([k]) => !k.startsWith(prefix)));
+async function loadFreshRemoveTarget(projectRoot, name, engineDir) {
+    const config = await loadFurnaceConfig(projectRoot);
+    const state = await loadFurnaceState(projectRoot);
+    const type = findComponentType(config, name);
+    if (!type) {
+        throw new FurnaceError(`Component "${name}" not found in furnace.json. Run "fireforge furnace list" to see registered components.`, name);
     }
-    return result;
+    await requireGitEngineForRemove(type, name, engineDir);
+    return { config, ftlDir: resolveFtlDir(config.ftlBasePath), state, type };
+}
+async function cleanupAllCustomTestFiles(name, projectRoot, journal) {
+    const result = await cleanupCustomTestFiles(name, projectRoot, journal);
+    const failures = [...result.partialFailures];
+    failures.push(...(await cleanupCustomXpcshellTestFiles(name, projectRoot, journal)).partialFailures);
+    failures.push(...(await cleanupCustomMochikitTestFiles(name, projectRoot, journal)).partialFailures);
+    return failures;
 }
 /**
  * Confirms the remove operation interactively when TTY is available, or
@@ -380,9 +388,7 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
     const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
     intro('Furnace Remove');
     const config = await loadFurnaceConfig(projectRoot);
-    const state = await loadFurnaceState(projectRoot);
     const furnacePaths = getFurnacePaths(projectRoot);
-    const ftlDir = resolveFtlDir(config.ftlBasePath);
     // Find which section the component belongs to
     const type = findComponentType(config, name);
     if (!type) {
@@ -402,8 +408,9 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
         const journal = createRollbackJournal();
         ctx.registerJournal(journal);
         try {
-            if (type === 'override') {
-                const overrideConfig = config.overrides[name];
+            const { config: freshConfig, ftlDir, state: freshState, type: freshType, } = await loadFreshRemoveTarget(projectRoot, name, paths.engine);
+            if (freshType === 'override') {
+                const overrideConfig = freshConfig.overrides[name];
                 const dir = join(furnacePaths.overridesDir, name);
                 // Restore deployed engine files BEFORE removing the workspace
                 // directory. The restore set is the union of (a) files currently in
@@ -411,7 +418,7 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
                 // — without (b), source-side deletions would orphan engine copies
                 // that this command can never see again.
                 if (overrideConfig?.basePath) {
-                    const previousKeys = Object.keys(extractComponentChecksums(state.appliedChecksums, 'override', name));
+                    const previousKeys = Object.keys(extractComponentChecksums(freshState.appliedChecksums, 'override', name));
                     const { restored, removed } = await restoreOverrideEngineFiles(paths.engine, dir, overrideConfig, previousKeys, ftlDir, journal);
                     if (restored > 0) {
                         info(`Restored ${restored} file${restored === 1 ? '' : 's'} in engine/${overrideConfig.basePath} to Firefox baseline`);
@@ -426,8 +433,8 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
                     info(`Deleted components/overrides/${name}/`);
                 }
             }
-            else if (type === 'custom') {
-                const customConfig = config.custom[name];
+            else if (freshType === 'custom') {
+                const customConfig = freshConfig.custom[name];
                 // Custom-component removal mutates engine files (jar.mn,
                 // customElements.js, deployed widgets, optional .ftl) and the
                 // rollback journal is the only safety net for those edits while
@@ -479,46 +486,24 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
                     await removeCustomFtlJarMnEntry(paths.engine, `${name}.ftl`, ftlDir, customConfig, journal);
                 }
             }
-            let testCleanupFailures = [];
-            if (type === 'custom') {
-                const result = await cleanupCustomTestFiles(name, projectRoot, journal);
-                testCleanupFailures = result.partialFailures;
-                // 2026-04-24 eval Finding 5: also clean up xpcshell scaffolds
-                // generated by `furnace create --with-tests --xpcshell`. The
-                // mochitest cleanup above covers `browser/base/content/test/
-                // <binary>/`, but xpcshell scaffolds live in the sibling
-                // `<binary>-xpcshell/` directory and were orphaned by prior
-                // versions.
-                const xpcshellResult = await cleanupCustomXpcshellTestFiles(name, projectRoot, journal);
-                testCleanupFailures.push(...xpcshellResult.partialFailures);
-                // 2026-04-25 eval Finding 13: mochikit-style scaffolds
-                // (`--test-style mochikit`) live under
-                // `engine/toolkit/content/tests/widgets/` with `chrome.toml`
-                // entries — neither the browser-chrome path nor the xpcshell
-                // path touches them. Without this pass, a `furnace create
-                // --with-tests --test-style mochikit` followed by `furnace
-                // remove` left the test file and its toml entry referencing a
-                // component that no longer exists.
-                const mochikitResult = await cleanupCustomMochikitTestFiles(name, projectRoot, journal);
-                testCleanupFailures.push(...mochikitResult.partialFailures);
-            }
+            const testCleanupFailures = freshType === 'custom' ? await cleanupAllCustomTestFiles(name, projectRoot, journal) : [];
             // Remove entry from furnace.json
-            if (type === 'stock') {
-                config.stock = config.stock.filter((s) => s !== name);
+            if (freshType === 'stock') {
+                freshConfig.stock = freshConfig.stock.filter((s) => s !== name);
             }
-            else if (type === 'override') {
-                config.overrides = Object.fromEntries(Object.entries(config.overrides).filter(([key]) => key !== name));
+            else if (freshType === 'override') {
+                freshConfig.overrides = Object.fromEntries(Object.entries(freshConfig.overrides).filter(([key]) => key !== name));
             }
             else {
-                config.custom = Object.fromEntries(Object.entries(config.custom).filter(([key]) => key !== name));
+                freshConfig.custom = Object.fromEntries(Object.entries(freshConfig.custom).filter(([key]) => key !== name));
             }
             await snapshotFile(journal, furnacePaths.furnaceConfig);
-            await writeFurnaceConfig(projectRoot, config);
+            await writeFurnaceConfig(projectRoot, freshConfig);
             // Drop stale per-file checksums inside the same transactional block.
             // Snapshotting the state file into the rollback journal means the
             // entire remove operation is a single atomic unit.
             await snapshotFile(journal, furnacePaths.furnaceState);
-            await updateFurnaceState(projectRoot, (state) => dropChecksumsByPrefix(state, `${type}/${name}/`));
+            await updateFurnaceState(projectRoot, (state) => dropChecksumsByPrefix(state, `${freshType}/${name}/`));
             // Test-cleanup failures are warn-and-continue by design (test files
             // are secondary artefacts), but the caller deserves a single summary
             // line pointing at the residue so they don't have to re-scan earlier

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

@@ -0,0 +1,13 @@
+import type { FurnaceConfig } from '../../types/furnace.js';
+/**
+ * Applies a component rename to scaffold-owned filenames only.
+ */
+export declare function renameComponentFileName(fileName: string, oldName: string, newName: string): string;
+/**
+ * Re-keys a custom component config entry and same-config compose references.
+ */
+export declare function updateConfigForCustomRename(config: FurnaceConfig, oldName: string, newName: string): void;
+/**
+ * Re-keys an override component config entry.
+ */
+export declare function updateConfigForOverrideRename(config: FurnaceConfig, oldName: string, newName: string): void;

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

@@ -0,0 +1,42 @@
+/**
+ * Applies a component rename to scaffold-owned filenames only.
+ */
+export function renameComponentFileName(fileName, oldName, newName) {
+    if (fileName === oldName)
+        return newName;
+    if (fileName.startsWith(oldName + '.')) {
+        return newName + fileName.slice(oldName.length);
+    }
+    return fileName;
+}
+/**
+ * Re-keys a custom component config entry and same-config compose references.
+ */
+export function updateConfigForCustomRename(config, oldName, newName) {
+    const oldConfig = config.custom[oldName];
+    if (!oldConfig)
+        return;
+    config.custom[newName] = {
+        ...oldConfig,
+        targetPath: oldConfig.targetPath.replace(new RegExp(`(^|/)${oldName}$`), `$1${newName}`),
+    };
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- idiomatic key removal from config record
+    delete config.custom[oldName];
+    for (const customConfig of Object.values(config.custom)) {
+        if (customConfig.composes) {
+            customConfig.composes = customConfig.composes.map((ref) => (ref === oldName ? newName : ref));
+        }
+    }
+}
+/**
+ * Re-keys an override component config entry.
+ */
+export function updateConfigForOverrideRename(config, oldName, newName) {
+    const oldConfig = config.overrides[oldName];
+    if (!oldConfig)
+        return;
+    config.overrides[newName] = { ...oldConfig };
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- idiomatic key removal from config record
+    delete config.overrides[oldName];
+}
+//# sourceMappingURL=rename-helpers.js.map

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

@@ -14,52 +14,12 @@ 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 { 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, '\\$&');
 }
-/**
- * Applies the component rename to a filename. Only replaces the leading
- * component name when it is followed by `.` (extension) or equals the
- * filename exactly; every other filename is returned unchanged so stray
- * assets, editor backups, or files whose name coincidentally contains the
- * old component name in the middle or at the end are not accidentally
- * renamed.
- */
-function renameComponentFileName(fileName, oldName, newName) {
-    if (fileName === oldName)
-        return newName;
-    if (fileName.startsWith(oldName + '.')) {
-        return newName + fileName.slice(oldName.length);
-    }
-    return fileName;
-}
-function updateConfigForCustomRename(config, oldName, newName) {
-    const oldConfig = config.custom[oldName];
-    if (!oldConfig)
-        return;
-    config.custom[newName] = {
-        ...oldConfig,
-        targetPath: oldConfig.targetPath.replace(new RegExp(`(^|/)${oldName}$`), `$1${newName}`),
-    };
-    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- idiomatic key removal from config record
-    delete config.custom[oldName];
-    // Update composes references in other components
-    for (const customConfig of Object.values(config.custom)) {
-        if (customConfig.composes) {
-            customConfig.composes = customConfig.composes.map((ref) => (ref === oldName ? newName : ref));
-        }
-    }
-}
-function updateConfigForOverrideRename(config, oldName, newName) {
-    const oldConfig = config.overrides[oldName];
-    if (!oldConfig)
-        return;
-    config.overrides[newName] = { ...oldConfig };
-    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- idiomatic key removal from config record
-    delete config.overrides[oldName];
-}
 /**
  * Derives the test file name for a component, matching the convention used by
  * `furnace create --with-tests`.
@@ -215,18 +175,37 @@ async function renameMochikitTestFiles(engineDir, oldName, newName, journal) {
  * Performs the transactional rename mutation inside a furnace lock.
  */
 async function performRenameMutations(args) {
-    const { projectRoot, oldName, newName, oldDir, newDir, isCustom, componentType, config } = args;
+    const { projectRoot, oldName, newName } = args;
     const oldClassName = tagNameToClassName(oldName);
     const newClassName = tagNameToClassName(newName);
-    // Capture the pre-rename deployed target path so we know what to
-    // clean up in the engine tree. `updateConfigForCustomRename` rewrites
-    // `targetPath` in-place once the mutation enters phase 2, so we read
-    // it here while it still points at the old name's deployment.
-    const oldCustomTargetPath = isCustom ? config.custom[oldName]?.targetPath : undefined;
     await runFurnaceMutation(projectRoot, 'rename-rollback', async (ctx) => {
         const journal = createRollbackJournal();
         ctx.registerJournal(journal);
+        let newDir = args.newDir;
         try {
+            const config = await loadFurnaceConfig(projectRoot);
+            const isCustom = oldName in config.custom;
+            const isOverride = oldName in config.overrides;
+            if (!isCustom && !isOverride) {
+                throw new FurnaceError(`Component "${oldName}" not found in furnace.json. Only custom and override components can be renamed.`, oldName);
+            }
+            if (newName in config.custom ||
+                newName in config.overrides ||
+                config.stock.includes(newName)) {
+                throw new FurnaceError(`A component named "${newName}" already exists in furnace.json.`, newName);
+            }
+            const componentType = isCustom ? 'custom' : 'override';
+            const componentDirLabel = isCustom ? 'custom' : 'overrides';
+            const baseDir = isCustom ? args.furnacePaths.customDir : args.furnacePaths.overridesDir;
+            const oldDir = join(baseDir, oldName);
+            newDir = join(baseDir, newName);
+            const oldCustomTargetPath = isCustom ? config.custom[oldName]?.targetPath : undefined;
+            if (!(await pathExists(oldDir))) {
+                throw new FurnaceError(`Component directory not found: components/${componentDirLabel}/${oldName}`, oldName);
+            }
+            if (await pathExists(newDir)) {
+                throw new FurnaceError(`Target directory already exists: components/${componentDirLabel}/${newName}`, newName);
+            }
             await snapshotDir(journal, oldDir);
             await snapshotFile(journal, args.furnaceConfigPath);
             // 1. Create new directory with renamed files and updated content
@@ -472,6 +451,7 @@ export async function furnaceRenameCommand(projectRoot, oldName, newName) {
         componentType,
         config,
         furnaceConfigPath: furnacePaths.furnaceConfig,
+        furnacePaths,
         engineDir: paths.engine,
     });
     note(`Component renamed: ${oldName} → ${newName}\n\n` +

package/dist/src/core/config-paths.d.ts

@@ -19,7 +19,7 @@ export declare const SRC_DIR = "src";
 /** Supported top-level fireforge.json keys backed by the current schema. */
 export declare const SUPPORTED_CONFIG_ROOT_KEYS: readonly ["name", "vendor", "appId", "binaryName", "firefox", "build", "license", "wire", "patchLint", "typecheck", "markerComment"];
 /** Supported config paths that can be read or set without --force. */
-export declare const SUPPORTED_CONFIG_PATHS: readonly ["name", "vendor", "appId", "binaryName", "license", "firefox", "firefox.version", "firefox.product", "build", "build.jobs", "wire", "wire.subscriptDir", "patchLint", "patchLint.checkJs", "patchLint.checkJsStrict", "patchLint.checkJsCompilerOptions", "patchLint.checkJsExtraShim", "patchLint.rawColorAllowlist", "patchLint.jsdocClassMethods", "patchLint.testAssertionFloor", "patchLint.chromeScriptJsDoc", "typecheck", "typecheck.projects", "typecheck.extraShim", "markerComment"];
+export declare const SUPPORTED_CONFIG_PATHS: readonly ["name", "vendor", "appId", "binaryName", "license", "firefox", "firefox.version", "firefox.product", "firefox.sha256", "build", "build.jobs", "wire", "wire.subscriptDir", "patchLint", "patchLint.checkJs", "patchLint.checkJsStrict", "patchLint.checkJsCompilerOptions", "patchLint.checkJsExtraShim", "patchLint.rawColorAllowlist", "patchLint.jsdocClassMethods", "patchLint.testAssertionFloor", "patchLint.chromeScriptJsDoc", "typecheck", "typecheck.projects", "typecheck.extraShim", "markerComment"];
 /**
  * Gets all project paths based on a root directory.
  * @param root - Root directory of the project

package/dist/src/core/config-paths.js

@@ -41,6 +41,7 @@ export const SUPPORTED_CONFIG_PATHS = [
     'firefox',
     'firefox.version',
     'firefox.product',
+    'firefox.sha256',
     'build',
     'build.jobs',
     'wire',

package/dist/src/core/config-validate.js

@@ -75,6 +75,10 @@ export function validateConfig(data) {
     if (compatError) {
         throw new ConfigError(compatError);
     }
+    const firefoxSha256 = optionalConfigString(firefoxRec, 'sha256', 'firefox.sha256');
+    if (firefoxSha256 !== undefined && !/^[a-f0-9]{64}$/i.test(firefoxSha256)) {
+        throw new ConfigError('Config field "firefox.sha256" must be a 64-character SHA-256 hex digest');
+    }
     // Optional configs
     const config = {
         name,
@@ -84,6 +88,7 @@ export function validateConfig(data) {
         firefox: {
             version: firefoxVersion,
             product: firefoxProduct,
+            ...(firefoxSha256 !== undefined ? { sha256: firefoxSha256.toLowerCase() } : {}),
         },
     };
     // Build

package/dist/src/core/config.js

@@ -11,7 +11,7 @@
 import { basename } from 'node:path';
 import { ConfigError, ConfigNotFoundError } from '../errors/config.js';
 import { toError } from '../utils/errors.js';
-import { pathExists, readJson, writeJson } from '../utils/fs.js';
+import * as fsUtils from '../utils/fs.js';
 import { getProjectPaths } from './config-paths.js';
 import { validateConfig } from './config-validate.js';
 import { createSiblingLockPath, withFileLock } from './file-lock.js';
@@ -21,6 +21,10 @@ export { CONFIG_FILENAME, FIREFORGE_DIR, getProjectPaths, STATE_FILENAME, SUPPOR
 export { loadState, saveState, updateState } from './config-state.js';
 export { validateConfig } from './config-validate.js';
 // ---- config I/O (stays here because it bridges paths + validation) ----
+async function configPathExists(path) {
+    const fs = fsUtils;
+    return (fs.pathExistsStrict ?? fsUtils.pathExists)(path);
+}
 /**
  * Checks if a fireforge.json exists in the given directory.
  * @param root - Root directory to check
@@ -28,7 +32,7 @@ export { validateConfig } from './config-validate.js';
  */
 export async function configExists(root) {
     const paths = getProjectPaths(root);
-    return pathExists(paths.config);
+    return configPathExists(paths.config);
 }
 /**
  * Loads and validates the fireforge.json configuration.
@@ -38,11 +42,11 @@ export async function configExists(root) {
  */
 export async function loadConfig(root) {
     const paths = getProjectPaths(root);
-    if (!(await pathExists(paths.config))) {
+    if (!(await configPathExists(paths.config))) {
         throw new ConfigNotFoundError(paths.config);
     }
     try {
-        const data = await readJson(paths.config);
+        const data = await fsUtils.readJson(paths.config);
         return validateConfig(data);
     }
     catch (error) {
@@ -70,11 +74,11 @@ export async function loadConfig(root) {
  */
 export async function loadRawConfigDocument(root) {
     const paths = getProjectPaths(root);
-    if (!(await pathExists(paths.config))) {
+    if (!(await configPathExists(paths.config))) {
         throw new ConfigNotFoundError(paths.config);
     }
     try {
-        const data = await readJson(paths.config);
+        const data = await fsUtils.readJson(paths.config);
         if (data === null || typeof data !== 'object' || Array.isArray(data)) {
             throw new ConfigError(`Invalid fireforge.json at ${paths.config}: expected an object`);
         }
@@ -110,7 +114,7 @@ export async function writeConfig(root, config) {
  */
 export async function writeConfigDocument(root, config) {
     const paths = getProjectPaths(root);
-    await writeJson(paths.config, config);
+    await fsUtils.writeJson(paths.config, config);
 }
 /**
  * Runs an operation while holding a sidecar lock on `fireforge.json`.