@hominis/fireforge 0.19.5 → 0.20.0

package/dist/src/commands/furnace/create-validation.d.ts

@@ -0,0 +1,6 @@
+import type { FurnaceCreateOptions } from '../../types/commands/index.js';
+import type { FurnaceConfig } from '../../types/furnace.js';
+/**
+ * Validates a proposed custom component against the current furnace config.
+ */
+export declare function validateCreateAgainstConfig(config: FurnaceConfig, componentName: string, allowPrefixMismatch: FurnaceCreateOptions['allowPrefixMismatch'], composes: string[] | undefined): void;

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

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { detectComposesCycles } from '../../core/furnace-config.js';
+import { InvalidArgumentError } from '../../errors/base.js';
+import { FurnaceError } from '../../errors/furnace.js';
+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;
+}
+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.');
+        }
+    }
+    detectComposesCycles({
+        ...config.custom,
+        [componentName]: {
+            description: '',
+            targetPath: `toolkit/content/widgets/${componentName}`,
+            register: true,
+            localized: false,
+            composes,
+        },
+    });
+}
+/**
+ * Validates a proposed custom component against the current furnace config.
+ */
+export function validateCreateAgainstConfig(config, componentName, allowPrefixMismatch, composes) {
+    const conflict = checkNameConflict(config, componentName);
+    if (conflict) {
+        throw new FurnaceError(conflict, componentName);
+    }
+    if (config.componentPrefix &&
+        !componentName.startsWith(config.componentPrefix) &&
+        !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');
+    }
+    validateComposesTargets(config, componentName, composes);
+}
+//# sourceMappingURL=create-validation.js.map

package/dist/src/commands/furnace/create.d.ts

@@ -5,14 +5,14 @@ export type ResolvedTestStyle = 'mochikit' | 'browser-chrome' | 'xpcshell' | 'no
  * Collapses `--with-tests`, `--xpcshell`, and `--test-style` into the single
  * scaffold dispatch used inside the mutation phase.
  *
- * Backwards-compat invariants:
+ * Invariants:
  * - `--xpcshell` alone is equivalent to `--test-style=xpcshell`.
- * - `--with-tests` alone (no `--test-style`) now defaults to `mochikit`
- *   (previously it defaulted to browser-chrome; the dogfooding pass
- *   flagged browser-chrome as unrunnable against non-tabbrowser chrome).
- *   Operators who need the old behavior can pass
- *   `--with-tests --test-style=browser-chrome`.
- * - `--xpcshell --with-tests` is rejected as ambiguous.
+ * - `--with-tests` alone (no `--test-style`) defaults to `browser-chrome`
+ *   (multi-process mochitest; reliable on macOS for interactive chrome).
+ *   Forks whose chrome document has no `tabbrowser` should pass
+ *   `--test-style=mochikit` explicitly.
+ * - When both `--xpcshell` and `--with-tests` are set, `--xpcshell` wins
+ *   (resolved style is `xpcshell` only).
  * @throws InvalidArgumentError when flags conflict.
  */
 export declare function resolveTestStyle(options: FurnaceCreateOptions): ResolvedTestStyle;

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
@@ -204,14 +193,14 @@ async function writeComponentFiles(componentDir, componentName, className, descr
  * Collapses `--with-tests`, `--xpcshell`, and `--test-style` into the single
  * scaffold dispatch used inside the mutation phase.
  *
- * Backwards-compat invariants:
+ * Invariants:
  * - `--xpcshell` alone is equivalent to `--test-style=xpcshell`.
- * - `--with-tests` alone (no `--test-style`) now defaults to `mochikit`
- *   (previously it defaulted to browser-chrome; the dogfooding pass
- *   flagged browser-chrome as unrunnable against non-tabbrowser chrome).
- *   Operators who need the old behavior can pass
- *   `--with-tests --test-style=browser-chrome`.
- * - `--xpcshell --with-tests` is rejected as ambiguous.
+ * - `--with-tests` alone (no `--test-style`) defaults to `browser-chrome`
+ *   (multi-process mochitest; reliable on macOS for interactive chrome).
+ *   Forks whose chrome document has no `tabbrowser` should pass
+ *   `--test-style=mochikit` explicitly.
+ * - When both `--xpcshell` and `--with-tests` are set, `--xpcshell` wins
+ *   (resolved style is `xpcshell` only).
  * @throws InvalidArgumentError when flags conflict.
  */
 export function resolveTestStyle(options) {
@@ -226,7 +215,7 @@ export function resolveTestStyle(options) {
     if (xpcshellFlag)
         return 'xpcshell';
     if (withTests)
-        return 'mochikit';
+        return 'browser-chrome';
     return 'none';
 }
 /**
@@ -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/index.js

@@ -71,9 +71,9 @@ function registerFurnaceInfoCommands(furnace, context) {
         .option('-d, --description <desc>', 'Component description')
         .option('--localized', 'Include Fluent l10n support')
         .option('--no-register', 'Skip customElements.js registration')
-        .option('--with-tests', 'Scaffold a test harness (defaults to MochiKit; see --test-style)')
+        .option('--with-tests', 'Scaffold a test harness (defaults to browser-chrome; use --test-style=mochikit for tabbrowser-less chrome — may be flaky on macOS)')
         .option('--xpcshell', 'Scaffold an xpcshell test harness (for storage-layer code on forks without tabbrowser); equivalent to --test-style=xpcshell. Note: xpcshell resolves chrome://global/* URIs but not chrome://browser/* — use --test-style=browser-chrome for browser-chrome-dependent tests.')
-        .option('--test-style <style>', "Override the harness written by --with-tests: mochikit (default, runs against non-tabbrowser chrome), browser-chrome (today's scaffold, needs tabbrowser), or xpcshell (headless)", (value) => {
+        .option('--test-style <style>', 'Override the harness written by --with-tests: browser-chrome (default, needs tabbrowser), mochikit (toolkit/widgets, non-tabbrowser chrome), or xpcshell (headless)', (value) => {
         if (value !== 'mochikit' && value !== 'browser-chrome' && value !== 'xpcshell') {
             throw new Error(`--test-style must be one of: mochikit, browser-chrome, xpcshell. Got: "${value}".`);
         }

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