@hominis/fireforge 0.16.3 → 0.17.0

package/dist/src/commands/export.js

@@ -10,7 +10,7 @@ import { generateBinaryFilePatch, generateFullFilePatch } from '../core/git-diff
 import { isBinaryFile } from '../core/git-file-ops.js';
 import { getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, } from '../core/git-status.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
-import { commitExportedPatch } from '../core/patch-export.js';
+import { commitExportedPatch, findAllPatchesForFiles } from '../core/patch-export.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { ensureDir, pathExists } from '../utils/fs.js';
@@ -19,7 +19,7 @@ import { pickDefined } from '../utils/options.js';
 import { stripEnginePrefix } from '../utils/paths.js';
 import { parsePositiveIntegerFlag, PATCH_CATEGORIES } from '../utils/validation.js';
 import { commitPlacementExport, placementSummary, projectPlacementForLint, renderDryRunPreview, resolvePlacementPlan, } from './export-flow.js';
-import { autoFixLicenseHeaders, confirmSupersedePatches, promptExportPatchMetadata, runPatchLint, } from './export-shared.js';
+import { autoFixLicenseHeaders, confirmSupersedePatches, guardOwnershipOverlap, promptExportPatchMetadata, runPatchLint, } from './export-shared.js';
 async function collectExportFiles(paths, files) {
     const collectedFiles = new Set();
     let fileStatuses;
@@ -286,6 +286,26 @@ export async function exportCommand(projectRoot, files, options) {
         const shouldProceed = await confirmSupersedePatches(paths.patches, filesAffected, options.supersede, isInteractive, s);
         if (!shouldProceed)
             return;
+        // Overlap gate: pre-0.16.0 `export` only caught FULL-coverage
+        // supersedes, so a second export targeting a shared file like
+        // `browser/themes/shared/jar.inc.mn` happily created a queue where
+        // two patches both listed the same file in `filesAffected`. `verify`
+        // then failed immediately on "cross-patch filesAffected conflicts".
+        // `confirmSupersedePatches` might already have confirmed full
+        // supersedes above; pass their filenames through so we do not flag
+        // a file claimed by a patch that is about to be removed.
+        const willSupersede = await findAllPatchesForFiles(paths.patches, filesAffected);
+        const supersedingFilenames = new Set(willSupersede.map((p) => p.filename));
+        const shouldProceedPastOverlap = await guardOwnershipOverlap({
+            patchesDir: paths.patches,
+            filesAffected,
+            supersedingFilenames,
+            allowOverlap: options.allowOverlap === true,
+            isInteractive,
+            s,
+        });
+        if (!shouldProceedPastOverlap)
+            return;
         const { patchFilename, superseded } = await commitExportedPatch({
             patchesDir: paths.patches,
             category: selectedCategory,
@@ -327,6 +347,7 @@ export function registerExport(program, { getProjectRoot, withErrorHandling }) {
         .option('-y, --yes', 'Skip confirmation for placement renumbers (required for non-TTY)')
         .option('--force-unsafe', 'Bypass cross-patch lint refusal on projected placement')
         .option('--exclude-furnace', 'Exclude furnace-managed file paths from the export')
+        .option('--allow-overlap', 'Acknowledge cross-patch ownership overlap (default mode only; the resulting queue fails verify)')
         .action(withErrorHandling(async (paths, options) => {
         const { category, ...rest } = options;
         await exportCommand(getProjectRoot(), paths, {

package/dist/src/commands/furnace/chrome-doc-tests.js

@@ -117,9 +117,16 @@ add_task(async function test_${taskSuffix}_files_packaged() {
     ["browser", "chrome", "browser", "content", "browser", "${name}.xhtml"],
     "${name}.xhtml",
   );
+  // The scoped CSS is registered through jar.inc.mn under
+  // \`content/browser/<name>-chrome.css\` (see \`chromeDocJarIncMnCssEntry\`
+  // in \`src/commands/furnace/chrome-doc-templates.ts\`), so the packaged
+  // file lands under \`chrome/browser/content/browser/\`, not under
+  // \`skin/classic/browser/\`. The 2026-04-21 eval's first
+  // \`fireforge test --build\` against a scaffolded chrome-doc reported
+  // a false failure because the probe was looking at the skin layout.
   probeEither(
-    ["chrome", "browser", "skin", "classic", "browser", "${name}-chrome.css"],
-    ["browser", "chrome", "browser", "skin", "classic", "browser", "${name}-chrome.css"],
+    ["chrome", "browser", "content", "browser", "${name}-chrome.css"],
+    ["browser", "chrome", "browser", "content", "browser", "${name}-chrome.css"],
     "${name}-chrome.css",
   );
 });

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

@@ -0,0 +1,23 @@
+/**
+ * Defensive read-back helper for `furnace create`. Extracted from
+ * `create.ts` so the authoring command stays under the per-file LOC
+ * budget.
+ */
+/**
+ * Asserts that the just-written furnace.json contains the expected
+ * custom component entry. The eval run's finding #9 observed a
+ * scenario where `furnace create --allow-prefix-mismatch` reported
+ * success and wrote the component files, but the subsequent
+ * `furnace status` found `custom: {}` in furnace.json — an invariant
+ * violation with no clear smoking gun in the code path. Local repros
+ * do not trigger it, so the defensive readback is the safest recovery
+ * contract we can offer: if the new entry is not visible on the next
+ * load, throw a `FurnaceError` so the rollback journal restores the
+ * pre-command state and the operator sees the failure instead of a
+ * phantom success.
+ *
+ * @param projectRoot - Root of the FireForge project
+ * @param componentName - Custom-element tag name that must be present
+ *   in `config.custom` after the write. Throws when absent.
+ */
+export declare function assertCustomEntryPersisted(projectRoot: string, componentName: string): Promise<void>;

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

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Defensive read-back helper for `furnace create`. Extracted from
+ * `create.ts` so the authoring command stays under the per-file LOC
+ * budget.
+ */
+import { loadFurnaceConfig } from '../../core/furnace-config.js';
+import { FurnaceError } from '../../errors/furnace.js';
+/**
+ * Asserts that the just-written furnace.json contains the expected
+ * custom component entry. The eval run's finding #9 observed a
+ * scenario where `furnace create --allow-prefix-mismatch` reported
+ * success and wrote the component files, but the subsequent
+ * `furnace status` found `custom: {}` in furnace.json — an invariant
+ * violation with no clear smoking gun in the code path. Local repros
+ * do not trigger it, so the defensive readback is the safest recovery
+ * contract we can offer: if the new entry is not visible on the next
+ * load, throw a `FurnaceError` so the rollback journal restores the
+ * pre-command state and the operator sees the failure instead of a
+ * phantom success.
+ *
+ * @param projectRoot - Root of the FireForge project
+ * @param componentName - Custom-element tag name that must be present
+ *   in `config.custom` after the write. Throws when absent.
+ */
+export async function assertCustomEntryPersisted(projectRoot, componentName) {
+    const persisted = await loadFurnaceConfig(projectRoot);
+    if (!(componentName in persisted.custom)) {
+        throw new FurnaceError(`Wrote furnace.json but "${componentName}" is missing from config.custom on read-back. ` +
+            'This should not happen — please report the issue. As a workaround, ' +
+            're-run the command, or add the entry to furnace.json by hand.', componentName);
+    }
+}
+//# sourceMappingURL=create-readback.js.map

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

@@ -76,6 +76,17 @@ export declare function mochikitTestFileName(name: string): string;
  * depend on the component's shape; operators can extend the test using
  * the same SimpleTest APIs upstream toolkit widgets (moz-button, etc.)
  * rely on.
+ *
+ * The template deliberately omits `SimpleTest.waitForExplicitFinish()`.
+ * `add_task` owns the test lifecycle: when every queued task resolves,
+ * the task harness calls `SimpleTest.finish()` on its own. Combining
+ * `waitForExplicitFinish()` with `add_task` *and* no explicit
+ * `SimpleTest.finish()` inside the task body makes the harness wait
+ * forever, which the 2026-04-21 eval run tripped into as an indefinite
+ * hang on a `fireforge test --headless` against a scaffolded widget
+ * test. Leaving `waitForExplicitFinish()` out matches the convention
+ * upstream toolkit widget tests use (see `test_moz-button.html` and
+ * siblings under `toolkit/content/tests/widgets/`).
  */
 export declare function generateMochikitTestContent(name: string): string;
 /**

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

@@ -227,6 +227,17 @@ export function mochikitTestFileName(name) {
  * depend on the component's shape; operators can extend the test using
  * the same SimpleTest APIs upstream toolkit widgets (moz-button, etc.)
  * rely on.
+ *
+ * The template deliberately omits `SimpleTest.waitForExplicitFinish()`.
+ * `add_task` owns the test lifecycle: when every queued task resolves,
+ * the task harness calls `SimpleTest.finish()` on its own. Combining
+ * `waitForExplicitFinish()` with `add_task` *and* no explicit
+ * `SimpleTest.finish()` inside the task body makes the harness wait
+ * forever, which the 2026-04-21 eval run tripped into as an indefinite
+ * hang on a `fireforge test --headless` against a scaffolded widget
+ * test. Leaving `waitForExplicitFinish()` out matches the convention
+ * upstream toolkit widget tests use (see `test_moz-button.html` and
+ * siblings under `toolkit/content/tests/widgets/`).
  */
 export function generateMochikitTestContent(name) {
     return `<!DOCTYPE html>
@@ -244,8 +255,6 @@ export function generateMochikitTestContent(name) {
     <script type="module">
       import "chrome://global/content/elements/${name}.mjs";
 
-      SimpleTest.waitForExplicitFinish();
-
       add_task(async function test_${name.replace(/-/g, '_')}_defined() {
         const ctor = await customElements.whenDefined("${name}");
         ok(ctor, "${name} custom element should be defined");

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

@@ -19,6 +19,7 @@ import { cancel, intro, isCancel, note, outro, success, warn } from '../../utils
 import { formatDryRunPlan, formatSuccessNote } from './create-dry-run.js';
 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 { scaffoldXpcshellTestFiles } from './create-xpcshell.js';
 async function loadAuthoringFurnaceConfig(projectRoot) {
@@ -266,6 +267,7 @@ async function performCreateMutations(args) {
         args.config.custom[args.componentName] = customEntry;
         await snapshotFile(journal, args.furnacePaths.furnaceConfig);
         await writeFurnaceConfig(args.projectRoot, args.config);
+        await assertCustomEntryPersisted(args.projectRoot, args.componentName);
         if (args.testStyle === 'browser-chrome') {
             const scafFiles = await scaffoldTestFiles(args.componentName, args.license, args.forgeConfig, args.paths, journal);
             testFiles.push(...scafFiles);

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

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { dirname, isAbsolute, join, normalize } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, normalize } from 'node:path';
 import { text } from '@clack/prompts';
 import { getProjectPaths, loadConfig, mutateConfig, writeConfig } from '../../core/config.js';
 import { createDefaultFurnaceConfig, furnaceConfigExists, writeFurnaceConfig, } from '../../core/furnace-config.js';
@@ -11,12 +12,46 @@ import { toError } from '../../utils/errors.js';
 import { ensureDir, pathExists, writeText } from '../../utils/fs.js';
 import { cancel, info, intro, isCancel, note, outro, success, warn } from '../../utils/logger.js';
 /**
- * Validates an FTL base path before writing it to furnace.json. Rejects
- * absolute paths, null bytes, and any normalised segment starting with
- * `..` — the previous `includes('..')` substring check caught the common
- * case but missed `./../../` and absolute paths that are arguably worse.
+ * File extensions that are definitely FTL resources (not locale
+ * directories). A value ending in one of these is almost certainly the
+ * result of the operator pointing at a single FTL file instead of the
+ * locale directory that contains it.
+ *
+ * 2026-04-21 eval: `furnace init --ftl-base-path browser/forgefresh.ftl`
+ * produced a misleading success path — the subsequent
+ * `furnace create --localized` scaffolded an `.mjs` referencing
+ * `insertFTLIfNeeded("<name>.ftl")` while furnace.json had no component
+ * entry, leaving the scaffold orphaned. Switching to a locale directory
+ * (`toolkit/locales/en-US/toolkit/global`) fixed the downstream path.
+ * Rejecting file-shaped values up-front keeps the operator on the
+ * correct path before any partial state is written.
+ */
+const FTL_FILE_EXTENSIONS = new Set(['.ftl', '.properties', '.dtd']);
+function hasFtlFileExtension(value) {
+    const lower = value.toLowerCase();
+    const dotIdx = lower.lastIndexOf('.');
+    const slashIdx = Math.max(lower.lastIndexOf('/'), lower.lastIndexOf('\\'));
+    if (dotIdx <= slashIdx)
+        return false; // No extension in the basename.
+    return FTL_FILE_EXTENSIONS.has(lower.slice(dotIdx));
+}
+/**
+ * Validates an FTL base path before writing it to furnace.json.
+ * Rejects:
+ *  - empty values and null bytes;
+ *  - absolute paths (POSIX or Windows-drive) that escape the engine;
+ *  - `..` segments that escape the engine;
+ *  - file-shaped values ending in `.ftl` / `.properties` / `.dtd`
+ *    (these are locale resources, not directories — the operator
+ *    almost certainly meant to name the parent directory).
+ *
+ * When {@link engineDir} is provided and exists on disk, the resolved
+ * `engine/${value}` path is probed: if it exists but is not a
+ * directory, the same file-shape error fires; if it does not exist yet,
+ * a non-blocking warning is logged (a fresh project that has not
+ * `fireforge download`-ed yet is the legitimate pre-existence case).
  */
-function validateFtlBasePath(value) {
+async function validateFtlBasePath(value, engineDir) {
     if (value.length === 0) {
         throw new FurnaceError('ftlBasePath must not be empty.');
     }
@@ -30,6 +65,40 @@ function validateFtlBasePath(value) {
     if (normalized === '..' || normalized.startsWith('../')) {
         throw new FurnaceError(`ftlBasePath "${value}" must not escape the engine checkout via parent-directory segments.`);
     }
+    if (hasFtlFileExtension(value)) {
+        throw new FurnaceError(`ftlBasePath "${value}" looks like a file (basename "${basename(value)}" ends in .ftl/.properties/.dtd), but FireForge expects a locale directory such as toolkit/locales/en-US/toolkit/global or browser/locales/en-US/browser. Use the parent directory instead.`);
+    }
+    // Shape probe against the real filesystem when we have an engine
+    // directory to anchor against. The probe is best-effort: a missing
+    // engine directory or a not-yet-extracted locale tree is
+    // legitimate (an operator may `furnace init` before `fireforge
+    // download`), so we emit a warning rather than refusing.
+    if (engineDir) {
+        const resolved = join(engineDir, value);
+        try {
+            const info = await stat(resolved);
+            if (!info.isDirectory()) {
+                throw new FurnaceError(`ftlBasePath "${value}" resolves to a non-directory at ${resolved}. FireForge expects a locale directory (for example toolkit/locales/en-US/toolkit/global or browser/locales/en-US/browser).`);
+            }
+        }
+        catch (error) {
+            // FurnaceError (from the `isDirectory()` branch above) is a real
+            // shape failure — re-throw so the operator sees it.
+            if (error instanceof FurnaceError)
+                throw error;
+            // ENOENT is expected on a fresh project before `fireforge
+            // download` has populated engine/; only warn.
+            const code = typeof error === 'object' && error !== null && 'code' in error
+                ? error.code
+                : undefined;
+            if (code === 'ENOENT') {
+                warn(`ftlBasePath "${value}" does not yet exist at ${resolved}. This is fine if you have not run "fireforge download" yet; rerun "fireforge furnace init --force" after the engine is extracted to re-validate.`);
+            }
+            // Any other stat error is also best-effort ignored here — a
+            // permission issue or malformed engine checkout will surface on
+            // the next command that actually reads the FTL tree.
+        }
+    }
 }
 /**
  * Runs the furnace init command to create a default furnace.json with
@@ -42,8 +111,27 @@ export async function furnaceInitCommand(projectRoot, options = {}) {
     if ((await furnaceConfigExists(projectRoot)) && !options.force) {
         throw new FurnaceError('furnace.json already exists. Use --force to overwrite it.');
     }
-    const config = createDefaultFurnaceConfig();
+    const paths = getProjectPaths(projectRoot);
+    // Seed the default furnace config with a tokenPrefix derived from
+    // fireforge.json's binaryName so `token coverage` sees real tokens on
+    // the very first run. The 2026-04-21 eval initialised Furnace, added
+    // tokens, ran coverage, and got `0 tokens / N unknown` — the prefix
+    // default was absent and the scan had nothing to key off. Loading
+    // fireforge.json here is best-effort: a project without one (e.g.
+    // mid-setup) falls through to the prefix-less default, and
+    // `token coverage` emits the existing "no tokenPrefix" warning.
+    let derivedBinaryName;
+    try {
+        const fireForgeConfig = await loadConfig(projectRoot);
+        derivedBinaryName = fireForgeConfig.binaryName;
+    }
+    catch {
+        // Best-effort only: initialising furnace without a fireforge.json is
+        // rare but not forbidden. Skip the prefix default in that case.
+    }
+    const config = createDefaultFurnaceConfig(derivedBinaryName ? { binaryName: derivedBinaryName } : {});
     const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    const engineForValidation = (await pathExists(paths.engine)) ? paths.engine : undefined;
     // Resolve componentPrefix
     if (options.prefix !== undefined) {
         config.componentPrefix = options.prefix;
@@ -66,7 +154,7 @@ export async function furnaceInitCommand(projectRoot, options = {}) {
     }
     // Resolve ftlBasePath
     if (options.ftlBasePath !== undefined) {
-        validateFtlBasePath(options.ftlBasePath);
+        await validateFtlBasePath(options.ftlBasePath, engineForValidation);
         config.ftlBasePath = options.ftlBasePath;
     }
     else if (isInteractive) {
@@ -80,7 +168,7 @@ export async function furnaceInitCommand(projectRoot, options = {}) {
         }
         const ftlValue = ftlResult.trim();
         if (ftlValue) {
-            validateFtlBasePath(ftlValue);
+            await validateFtlBasePath(ftlValue, engineForValidation);
             config.ftlBasePath = ftlValue;
         }
     }

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

@@ -1,4 +1,16 @@
 import type { FurnacePreviewOptions } from '../../types/commands/index.js';
+/**
+ * Builds a targeted Storybook failure message from captured mach output.
+ *
+ * Exported for the test suite: the heuristic has three branches (backend
+ * artifact missing, Storybook dep missing, generic) and regression
+ * testing each is easier when the classifier is addressable directly.
+ *
+ * @param output - Combined stdout and stderr from the Storybook command
+ * @param installRequested - Whether the caller requested a dependency reinstall first
+ * @returns User-facing guidance for the specific failure mode
+ */
+export declare function buildStorybookFailureMessage(output: string, installRequested: boolean): string;
 /**
  * Runs the furnace preview command to start Storybook for component preview.
  * @param projectRoot - Root directory of the project

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

@@ -72,17 +72,49 @@ function reportPreviewStagingFailures(stageResult) {
     const totalFailures = stageResult.errors.length + appliedWithStepErrorsCount;
     throw new FurnaceError(`${totalFailures} component${totalFailures === 1 ? '' : 's'} failed to stage for preview`);
 }
+/**
+ * Filenames emitted by the Firefox build backend (not by Storybook's npm
+ * package set) — their absence means `mach build` has not produced its
+ * post-configure artifacts, which is a different failure mode from a
+ * missing Storybook workspace dependency tree. The eval log for finding
+ * #11 reported `FileNotFoundError: [...] chrome-map.json` *after* a
+ * successful Storybook `npm install`, and the pre-0.16 heuristic
+ * misdiagnosed it as a dep failure and sent the operator back to
+ * `--install`. Pattern list is narrow on purpose so we only surface the
+ * backend-rebuild hint when we are confident.
+ */
+const BACKEND_ARTIFACT_PATTERNS = [
+    /chrome-map\.json/i,
+    /config\.status/i,
+    /obj-[^\s/]+\/dist\/bin\/\.lldbinit/i,
+];
 /**
  * Builds a targeted Storybook failure message from captured mach output.
+ *
+ * Exported for the test suite: the heuristic has three branches (backend
+ * artifact missing, Storybook dep missing, generic) and regression
+ * testing each is easier when the classifier is addressable directly.
+ *
  * @param output - Combined stdout and stderr from the Storybook command
  * @param installRequested - Whether the caller requested a dependency reinstall first
  * @returns User-facing guidance for the specific failure mode
  */
-function buildStorybookFailureMessage(output, installRequested) {
+export function buildStorybookFailureMessage(output, installRequested) {
     const installHint = installRequested
         ? 'Try running "python3 ./mach storybook upgrade" manually in the engine directory.'
         : 'Run "fireforge furnace preview --install" to bootstrap Storybook dependencies, or run "python3 ./mach storybook upgrade" manually in engine/.';
-    if (/(ENOENT|No such file or directory)/i.test(output) && /storybook|backend/i.test(output)) {
+    const hasFileNotFoundSignal = /(ENOENT|No such file or directory|FileNotFoundError)/i.test(output);
+    // Check backend-artifact signal first — a missing chrome-map.json looks
+    // like any other "No such file" error to a naïve regex, but the fix is
+    // to rerun `fireforge build`, not to reinstall Storybook dependencies.
+    if (hasFileNotFoundSignal && BACKEND_ARTIFACT_PATTERNS.some((p) => p.test(output))) {
+        return ('Storybook failed because the Firefox build backend artifacts are missing or stale ' +
+            '(chrome-map.json / config.status / obj-*/dist/bin/.lldbinit). ' +
+            'This is a Firefox-build completeness issue, not a Storybook dependency issue.\n\n' +
+            'Rerun "fireforge build" and let it finish, then retry "fireforge furnace preview". ' +
+            'A full rebuild regenerates the backend artifacts Storybook reads.');
+    }
+    if (hasFileNotFoundSignal && /storybook|backend/i.test(output)) {
         return ('Storybook failed because the Firefox checkout appears to be missing Storybook workspace files or backend dependencies.\n\n' +
             installHint);
     }

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

@@ -122,6 +122,94 @@ async function renameTestFiles(engineDir, projectRoot, oldName, newName, journal
         }
     }
 }
+/**
+ * Removes the deployed custom-widget directory at the old target path so
+ * a subsequent `furnace apply` is the single writer of the new name's
+ * deployment. Best-effort: logs a warning but never blocks the rename.
+ *
+ * 2026-04-21 eval: renaming `ff-chip-row` → `ff-chip-stack` registered
+ * and deployed the new name correctly but left `engine/toolkit/content/
+ * widgets/ff-chip-row/` in place. Subsequent `furnace sync` runs could
+ * not clear the stale widget, and packaging would have pulled in both
+ * copies. The snapshot is taken before the remove so the rollback
+ * journal restores the old directory if any later step in
+ * `performRenameMutations` fails.
+ */
+async function removeStaleDeployedComponentDir(engineDir, oldTargetPath, journal) {
+    const oldDeployed = join(engineDir, oldTargetPath);
+    if (!(await pathExists(oldDeployed)))
+        return;
+    try {
+        await snapshotDir(journal, oldDeployed);
+        await removeDir(oldDeployed);
+        info(`Removed stale deployed widget directory: ${oldTargetPath}`);
+    }
+    catch (error) {
+        warn(`Could not remove stale deployed widget directory at ${oldTargetPath}: ${toError(error).message}. Remove it manually if needed.`);
+    }
+}
+/**
+ * Renames the mochikit test scaffold produced by `furnace create
+ * --with-tests` when the default test style is used. The scaffold lives
+ * at `engine/toolkit/content/tests/widgets/test_<name>.html`, and the
+ * accompanying `chrome.toml` entry names the same file. Neither piece
+ * was handled by the pre-0.16.0 rename, so operators were left with a
+ * `test_<old>.html` file that still imported `chrome://global/content/
+ * elements/<old>.mjs` and referenced `customElements.whenDefined("<old>")`
+ * — the test ran against a component that no longer existed under that
+ * name and either failed or (if the old component was still deployed)
+ * passed for the wrong reason.
+ *
+ * Best-effort: individual failures log a warning. The same journal used
+ * for the rest of the rename snapshots every touched file so a later
+ * failure rolls the pair back together.
+ */
+async function renameMochikitTestFiles(engineDir, oldName, newName, journal) {
+    const testDir = join(engineDir, 'toolkit/content/tests/widgets');
+    if (!(await pathExists(testDir)))
+        return;
+    const oldTestFileName = `test_${oldName}.html`;
+    const newTestFileName = `test_${newName}.html`;
+    const oldTestPath = join(testDir, oldTestFileName);
+    const newTestPath = join(testDir, newTestFileName);
+    if (await pathExists(oldTestPath)) {
+        try {
+            await snapshotFile(journal, oldTestPath);
+            const content = await readText(oldTestPath);
+            const updatedContent = content
+                .replace(new RegExp(`chrome://global/content/elements/${escapeRegex(oldName)}\\.mjs`, 'g'), `chrome://global/content/elements/${newName}.mjs`)
+                .replace(new RegExp(`customElements\\.whenDefined\\("${escapeRegex(oldName)}"\\)`, 'g'), `customElements.whenDefined("${newName}")`)
+                .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 writeText(newTestPath, updatedContent);
+            await removeFile(oldTestPath);
+            info(`Renamed mochikit test: ${oldTestFileName} → ${newTestFileName}`);
+        }
+        catch (error) {
+            warn(`Could not rename mochikit test file — ${toError(error).message}. Rename it manually if needed.`);
+        }
+    }
+    // Update `chrome.toml` entry if present. The file may live in the
+    // same widgets/tests directory as the test file itself; upstream
+    // convention places exactly one `chrome.toml` there for all widget
+    // scaffolds.
+    const chromeTomlPath = join(testDir, 'chrome.toml');
+    if (await pathExists(chromeTomlPath)) {
+        try {
+            const toml = await readText(chromeTomlPath);
+            if (toml.includes(`["${oldTestFileName}"]`)) {
+                await snapshotFile(journal, chromeTomlPath);
+                const updated = toml.replace(`["${oldTestFileName}"]`, `["${newTestFileName}"]`);
+                await writeText(chromeTomlPath, updated);
+                info(`Updated chrome.toml: ${oldTestFileName} → ${newTestFileName}`);
+            }
+        }
+        catch (error) {
+            warn(`Could not update widgets chrome.toml — ${toError(error).message}. Update it manually if needed.`);
+        }
+    }
+}
 /**
  * Performs the transactional rename mutation inside a furnace lock.
  */
@@ -129,6 +217,11 @@ async function performRenameMutations(args) {
     const { projectRoot, oldName, newName, oldDir, newDir, isCustom, componentType, config } = 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);
@@ -197,6 +290,23 @@ async function performRenameMutations(args) {
             // 7. Rename test files created by `furnace create --with-tests` (custom only).
             if (isCustom && (await pathExists(args.engineDir))) {
                 await renameTestFiles(args.engineDir, projectRoot, oldName, newName, journal);
+                // Mochikit scaffold + widgets/chrome.toml live in a different
+                // tree than browser.toml-registered browser-chrome tests, so
+                // renameTestFiles doesn't reach them. 2026-04-21 eval: a rename
+                // left `engine/toolkit/content/tests/widgets/test_<old>.html`
+                // and its `chrome.toml` entry pointing at the old name, which
+                // either failed the test run outright or (worse) passed for the
+                // wrong component.
+                await renameMochikitTestFiles(args.engineDir, oldName, newName, journal);
+                // Clear the stale deployed component directory so the next
+                // `furnace apply` is the single writer of the new name's
+                // deployment. Without this, eval runs showed the old widget
+                // still living at `engine/toolkit/content/widgets/<old>/`
+                // alongside the newly-deployed `engine/toolkit/content/
+                // widgets/<new>/`, with no signal to `status` / `verify`.
+                if (oldCustomTargetPath) {
+                    await removeStaleDeployedComponentDir(args.engineDir, oldCustomTargetPath, journal);
+                }
             }
             info(`Renamed ${componentType} component: ${oldName} → ${newName}`);
         }

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

@@ -196,7 +196,7 @@ export async function furnaceStatusCommand(projectRoot, name) {
             warn('Engine drift detected since last apply (reset/download/manual edit). Run `fireforge furnace apply` to re-deploy.');
         }
     }
-    info('Tip: run `furnace status <name>` for detailed component info, or `furnace --help` for all subcommands.');
+    info('Tip: run `fireforge furnace status <name>` for detailed component info, or `fireforge furnace --help` for all subcommands.');
     outro('Status complete');
 }
 //# sourceMappingURL=status.js.map

package/dist/src/commands/lint.js

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { stat } from 'node:fs/promises';
 import { join } from 'node:path';
+import { isBrandingManagedPath } from '../core/branding.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { getStatusWithCodes, hasChanges, isGitRepository } from '../core/git.js';
 import { getAllDiff, getDiffForFilesAgainstHead } from '../core/git-diff.js';
-import { getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, } from '../core/git-status.js';
+import { getModifiedFiles, getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, } from '../core/git-status.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
 import { buildPatchQueueContext, lintExportedPatch, lintPatchQueue } from '../core/patch-lint.js';
 import { collectDiffFilePaths, tagLintIssues } from '../core/patch-lint-diff-tag.js';
@@ -22,8 +23,19 @@ import { stripEnginePrefix } from '../utils/paths.js';
  * per-function LOC budget as the command grows; the two file-mode and
  * aggregate-mode branches share no state with the post-lint reporting
  * pipeline, so the split is a pure rename rather than a refactor.
+ *
+ * When `binaryName` is provided, the aggregate-mode branch (no
+ * explicit file list) excludes paths under `browser/branding/<binaryName>/`
+ * from the diff. `status` classifies those paths as `branding` —
+ * tool-managed material the operator did not author directly — and
+ * the 2026-04-21 eval (Finding #2) reported that `fireforge lint` on
+ * a fresh project immediately failed `large-patch-lines` /
+ * `large-patch-files` / `missing-license-header` on the generated
+ * branding tree. File-list mode (explicit paths) preserves the
+ * previous behaviour: passing a branding file explicitly still lints
+ * it, so operators who need to audit branding content can do so.
  */
-async function resolveLintDiff(engineDir, files) {
+async function resolveLintDiff(engineDir, files, binaryName) {
     if (files.length > 0) {
         const collectedFiles = new Set();
         let fileStatuses;
@@ -83,6 +95,40 @@ async function resolveLintDiff(engineDir, files) {
         outro('Nothing to lint');
         return null;
     }
+    // Aggregate-mode branding exclusion. A fresh-setup workspace (after
+    // `fireforge setup` + `download` + `bootstrap` + `build`) carries a
+    // large tool-managed branding diff that the operator did not
+    // author; running the default lint against it fires size and
+    // license-header rules on content that was never intended to
+    // survive in the patch queue as-is. The exclusion mirrors the
+    // `branding` bucket in `fireforge status` so the two views stay
+    // consistent.
+    if (binaryName) {
+        const modified = await getModifiedFiles(engineDir);
+        const untracked = await getUntrackedFiles(engineDir);
+        const allPaths = [...new Set([...modified, ...untracked])];
+        const nonBrandingPaths = allPaths.filter((path) => !isBrandingManagedPath(path, binaryName));
+        const excludedCount = allPaths.length - nonBrandingPaths.length;
+        if (excludedCount > 0) {
+            info(`Excluded ${excludedCount} tool-managed branding file${excludedCount === 1 ? '' : 's'} from lint. Pass the path explicitly or use \`fireforge lint <path>\` to include them.`);
+        }
+        if (nonBrandingPaths.length === 0) {
+            info('No non-branding changes to lint.');
+            outro('Nothing to lint');
+            return null;
+        }
+        const diff = await getDiffForFilesAgainstHead(engineDir, nonBrandingPaths.sort());
+        if (!diff.trim()) {
+            info('No diff content to lint.');
+            outro('Nothing to lint');
+            return null;
+        }
+        return diff;
+    }
+    // Fallback path: no binaryName available (e.g. a legacy caller
+    // without a loaded config). Retain the pre-0.16.0 behaviour of
+    // linting the full diff so the lint surface is at least as broad
+    // as before.
     const diff = await getAllDiff(engineDir);
     if (!diff.trim()) {
         info('No diff content to lint.');
@@ -126,10 +172,15 @@ export async function lintCommand(projectRoot, files, options = {}) {
         await lintPerPatch(projectRoot, paths);
         return;
     }
-    const diff = await resolveLintDiff(paths.engine, files);
+    // Load the config before resolving the diff so we can pass
+    // `binaryName` into the aggregate-mode branding exclusion in
+    // `resolveLintDiff`. The config was previously loaded only after
+    // the diff was resolved; hoisting it is cheap and keeps the two
+    // call sites close together.
+    const config = await loadConfig(projectRoot);
+    const diff = await resolveLintDiff(paths.engine, files, config.binaryName);
     if (diff === null)
         return;
-    const config = await loadConfig(projectRoot);
     const filesAffected = extractAffectedFiles(diff);
     // Build patch queue context once so it can be shared between the
     // per-patch ownership resolver and the cross-patch rules.