@hominis/fireforge 0.32.0 → 0.34.0

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

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Browser-chrome test scaffolding for `furnace create --with-tests`,
+ * including the 0.34.0 `--test-dir` redirect and collision safety
+ * (existing manifests are appended to; head.js and test implementations
+ * are never overwritten). Split out of `create.ts` to keep that command
+ * file within the per-file line budget.
+ */
+import { join } from 'node:path';
+import { recordCreatedDir, snapshotFile, } from '../../core/furnace-rollback.js';
+import { getLicenseHeader } from '../../core/license-headers.js';
+import { registerTestManifest } from '../../core/manifest-register.js';
+import { InvalidArgumentError } from '../../errors/base.js';
+import { toError } from '../../utils/errors.js';
+import { ensureDir, pathExists, readText, writeText } from '../../utils/fs.js';
+import { info, success, warn } from '../../utils/logger.js';
+import { stripEnginePrefix } from '../../utils/paths.js';
+/**
+ * Validates the `--test-dir` option against the resolved test style before
+ * any writes. Mochikit lives in the upstream toolkit/content/tests/widgets
+ * tree, so a redirect makes no sense there.
+ */
+export function resolveValidatedTestDir(rawTestDir, testStyle) {
+    if (rawTestDir === undefined)
+        return undefined;
+    if (testStyle === 'none') {
+        throw new InvalidArgumentError('--test-dir requires --with-tests / --test-style.', 'testDir');
+    }
+    if (testStyle === 'mochikit') {
+        throw new InvalidArgumentError('--test-dir is not supported with --test-style=mochikit (the mochikit harness lives in toolkit/content/tests/widgets).', 'testDir');
+    }
+    return resolveTestDirOverride(rawTestDir);
+}
+/**
+ * Scaffolds browser mochitest files for a newly created custom component.
+ * @param componentName - Custom element tag name
+ * @param license - Project license used for generated headers
+ * @param forgeConfig - Project config fields needed for test naming
+ * @param paths - Resolved project paths used to place test files
+ * @param journal - Optional rollback journal that snapshots files before writes
+ * @returns Relative test filenames created or updated for the component
+ */
+const TEST_SCAFFOLD_ROOT = 'browser/base/content/test/';
+/**
+ * Normalizes and validates a `--test-dir` override: engine-relative,
+ * under `browser/base/content/test/` (so manifest registration keeps
+ * working). Returns the normalized engine-relative directory.
+ */
+export function resolveTestDirOverride(raw) {
+    const normalized = stripEnginePrefix(raw).replace(/\/+$/, '');
+    if (!normalized.startsWith(TEST_SCAFFOLD_ROOT) ||
+        normalized === TEST_SCAFFOLD_ROOT.slice(0, -1)) {
+        throw new InvalidArgumentError(`--test-dir must be an engine-relative directory under ${TEST_SCAFFOLD_ROOT} (got "${raw}").`, 'testDir');
+    }
+    return normalized;
+}
+// Exported for direct unit testing of the --test-dir / collision-safety
+// behaviour (the full create command needs a furnace project fixture).
+/**
+ *
+ */
+export async function scaffoldTestFiles(componentName, license, forgeConfig, paths, journal, testDirOverride) {
+    const strippedName = componentName.startsWith('moz-') ? componentName.slice(4) : componentName;
+    // Avoid double-prefixing: strip binaryName prefix since the default test
+    // dir name already uses it
+    const binaryName = forgeConfig.binaryName;
+    const withoutBinaryPrefix = strippedName.startsWith(binaryName + '-')
+        ? strippedName.slice(binaryName.length + 1)
+        : strippedName;
+    const underscored = withoutBinaryPrefix.replace(/-/g, '_');
+    const testFileName = `browser_${binaryName}_${underscored}.js`;
+    // --test-dir redirects the scaffold (0.34.0 field report: the hardcoded
+    // .../test/<binaryName>/ target collided with a test suite owned by a
+    // different patch). The manifest-registration name is the path below
+    // browser/base/content/test/ (nested manifests are supported).
+    const testDirRel = testDirOverride ?? `${TEST_SCAFFOLD_ROOT}${binaryName}`;
+    const testDirName = testDirRel.slice(TEST_SCAFFOLD_ROOT.length);
+    const testDir = join(paths.engine, testDirRel);
+    if (journal && !(await pathExists(testDir))) {
+        recordCreatedDir(journal, testDir);
+    }
+    await ensureDir(testDir);
+    const jsHeader = getLicenseHeader(license, 'js');
+    const hashHeader = getLicenseHeader(license, 'hash');
+    const testFiles = [];
+    // browser.toml — create if missing, append entry if existing
+    const tomlPath = join(testDir, 'browser.toml');
+    if (await pathExists(tomlPath)) {
+        // Defensive guard: only append if the entry is not already present.
+        // With a fresh journal per create, the same test file name cannot be
+        // appended twice in a single run — but retaining the check protects
+        // against accidental re-entrance or a future refactor that reuses the
+        // helper with a stale test directory.
+        const existingToml = await readText(tomlPath);
+        if (!existingToml.includes(`["${testFileName}"]`)) {
+            if (journal)
+                await snapshotFile(journal, tomlPath);
+            await writeText(tomlPath, existingToml.trimEnd() + `\n\n["${testFileName}"]\n`);
+            info(`Appended ["${testFileName}"] to the existing ${testDirRel}/browser.toml — the manifest ` +
+                'is shared; existing entries and support-files were left untouched.');
+        }
+    }
+    else {
+        if (journal)
+            await snapshotFile(journal, tomlPath);
+        const browserToml = `${hashHeader}
+
+[DEFAULT]
+support-files = ["head.js"]
+
+["${testFileName}"]
+`;
+        await writeText(tomlPath, browserToml);
+    }
+    testFiles.push('browser.toml');
+    // head.js — only create if it doesn't exist (shared across components)
+    const headPath = join(testDir, 'head.js');
+    if (!(await pathExists(headPath))) {
+        if (journal)
+            await snapshotFile(journal, headPath);
+        const headJs = `${jsHeader}
+
+"use strict";
+
+/**
+ * Wait for a custom element to be defined.
+ * @param {string} tag - Custom element tag name
+ * @returns {Promise<CustomElementConstructor>}
+ */
+async function waitForElement(tag) {
+  document.createElement(tag);
+  return customElements.whenDefined(tag);
+}
+`;
+        await writeText(headPath, headJs);
+        testFiles.push('head.js');
+    }
+    // browser_{binaryName}_{stripped}.js
+    const testJs = `${jsHeader}
+
+"use strict";
+
+add_task(async function test_${underscored}_defined() {
+  const ctor = await waitForElement("${componentName}");
+  Assert.ok(ctor, "${componentName} custom element should be defined");
+  Assert.equal(typeof ctor, "function", "Constructor should be a function");
+});
+`;
+    const testFilePath = join(testDir, testFileName);
+    if (await pathExists(testFilePath)) {
+        // Never clobber an existing test implementation (it may be owned by a
+        // different patch). The manifest entry above is idempotent, so the
+        // existing file simply stays authoritative.
+        warn(`${testDirRel}/${testFileName} already exists — keeping the existing file. ` +
+            'Pass --test-dir to scaffold into a different directory if you wanted a fresh test.');
+    }
+    else {
+        if (journal)
+            await snapshotFile(journal, testFilePath);
+        await writeText(testFilePath, testJs);
+        testFiles.push(testFileName);
+    }
+    // Register in moz.build. The registration helper edits browser/base/moz.build,
+    // so snapshot it first when a journal is supplied. The existing warn-and-continue
+    // contract is preserved so a missing/unparseable moz.build never trips rollback.
+    try {
+        const mozBuildPath = join(paths.engine, 'browser/base/moz.build');
+        if (journal)
+            await snapshotFile(journal, mozBuildPath);
+        const registerResult = await registerTestManifest(paths.engine, testDirName);
+        if (!registerResult.skipped) {
+            success(`Registered test manifest in ${registerResult.manifest}`);
+        }
+    }
+    catch (error) {
+        warn(`Could not register test manifest in moz.build — ${toError(error).message}. Register manually with "fireforge register".`);
+    }
+    return testFiles;
+}
+//# sourceMappingURL=create-browser-test.js.map

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

@@ -40,10 +40,17 @@ export async function scaffoldMochikitTestFiles(componentName, license, paths, j
     const writtenFiles = [];
     const testFileName = mochikitTestFileName(componentName);
     const testFilePath = join(testDir, testFileName);
-    if (journal)
-        await snapshotFile(journal, testFilePath);
-    await writeText(testFilePath, generateMochikitTestContent(componentName));
-    writtenFiles.push(testFileName);
+    if (await pathExists(testFilePath)) {
+        // Never clobber an existing test implementation (0.34.0 collision
+        // safety, matching the browser-chrome and xpcshell scaffolds).
+        warn(`toolkit/content/tests/widgets/${testFileName} already exists — keeping the existing file.`);
+    }
+    else {
+        if (journal)
+            await snapshotFile(journal, testFilePath);
+        await writeText(testFilePath, generateMochikitTestContent(componentName));
+        writtenFiles.push(testFileName);
+    }
     // chrome.toml — append entry if the file already exists, otherwise write
     // a fresh skeleton + entry. Idempotency: if the entry is already present
     // the manifest is left untouched so re-runs don't double-register.

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

@@ -24,4 +24,4 @@ export declare function scaffoldXpcshellTestFiles(componentName: string, license
     binaryName: string;
 }, paths: {
     engine: string;
-}, journal?: RollbackJournal): Promise<string[]>;
+}, journal?: RollbackJournal, testDirOverride?: string): Promise<string[]>;

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

@@ -8,7 +8,7 @@ import { join } from 'node:path';
 import { xpcshellTestParentDir } from '../../core/furnace-constants.js';
 import { recordCreatedDir, snapshotFile, } from '../../core/furnace-rollback.js';
 import { getLicenseHeader } from '../../core/license-headers.js';
-import { ensureDir, pathExists, writeText } from '../../utils/fs.js';
+import { ensureDir, pathExists, readText, writeText } from '../../utils/fs.js';
 import { warn } from '../../utils/logger.js';
 import { generateXpcshellManifestContent, generateXpcshellTestContent, xpcshellTestFileName, } from './create-templates.js';
 /**
@@ -26,10 +26,13 @@ import { generateXpcshellManifestContent, generateXpcshellTestContent, xpcshellT
  * deliberate choice about which moz.build should own it, and an
  * auto-insertion that guessed wrong would be worse than a note.
  */
-export async function scaffoldXpcshellTestFiles(componentName, license, forgeConfig, paths, journal) {
+export async function scaffoldXpcshellTestFiles(componentName, license, forgeConfig, paths, journal, testDirOverride) {
     const parentRelDir = xpcshellTestParentDir(forgeConfig.binaryName);
     const parentDirName = parentRelDir.split('/').slice(-1)[0] ?? `${forgeConfig.binaryName}-xpcshell`;
-    const testDir = join(paths.engine, parentRelDir, componentName);
+    // --test-dir names the FINAL directory (no per-component segment is
+    // appended) so the operator controls the exact scaffold target.
+    const testDirRel = testDirOverride ?? `${parentRelDir}/${componentName}`;
+    const testDir = join(paths.engine, testDirRel);
     if (journal && !(await pathExists(testDir))) {
         recordCreatedDir(journal, testDir);
     }
@@ -39,16 +42,39 @@ export async function scaffoldXpcshellTestFiles(componentName, license, forgeCon
     const testFiles = [];
     const testFileName = xpcshellTestFileName(componentName);
     const testFilePath = join(testDir, testFileName);
-    if (journal)
-        await snapshotFile(journal, testFilePath);
-    await writeText(testFilePath, generateXpcshellTestContent(componentName, jsHeader));
-    testFiles.push(testFileName);
+    if (await pathExists(testFilePath)) {
+        // Never clobber an existing test implementation (0.34.0 field report:
+        // the scaffold overwrote files owned by a different patch).
+        warn(`${testDirRel}/${testFileName} already exists — keeping the existing file.`);
+    }
+    else {
+        if (journal)
+            await snapshotFile(journal, testFilePath);
+        await writeText(testFilePath, generateXpcshellTestContent(componentName, jsHeader));
+        testFiles.push(testFileName);
+    }
+    // xpcshell.toml — append the test entry to an existing manifest instead
+    // of scaffolding over it; write a fresh one only when absent.
     const manifestPath = join(testDir, 'xpcshell.toml');
-    if (journal)
-        await snapshotFile(journal, manifestPath);
-    await writeText(manifestPath, generateXpcshellManifestContent(componentName, hashHeader));
-    testFiles.push('xpcshell.toml');
-    warn(`xpcshell scaffold written under browser/base/content/test/${parentDirName}/${componentName}/. ` +
+    if (await pathExists(manifestPath)) {
+        const existing = await readText(manifestPath);
+        if (!existing.includes(`["${testFileName}"]`)) {
+            if (journal)
+                await snapshotFile(journal, manifestPath);
+            await writeText(manifestPath, existing.trimEnd() + `\n\n["${testFileName}"]\n`);
+            warn(`Appended ["${testFileName}"] to the existing ${testDirRel}/xpcshell.toml — the manifest is shared; existing entries were left untouched.`);
+        }
+    }
+    else {
+        if (journal)
+            await snapshotFile(journal, manifestPath);
+        await writeText(manifestPath, generateXpcshellManifestContent(componentName, hashHeader));
+        testFiles.push('xpcshell.toml');
+    }
+    warn(`xpcshell scaffold written under ${testDirRel}/ ` +
+        '(default: browser/base/content/test/' +
+        parentDirName +
+        '/<component>/). ' +
         'Add the directory to XPCSHELL_TESTS_MANIFESTS in the nearest moz.build to run it via "fireforge test".');
     return testFiles;
 }

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

@@ -9,13 +9,13 @@ import { CUSTOM_ELEMENT_TAG_PATTERN, CUSTOM_ELEMENT_TAG_RULES, } from '../../cor
 import { createRollbackJournal, recordCreatedDir, restoreRollbackJournalOrThrow, snapshotFile, } from '../../core/furnace-rollback.js';
 import { isComponentInEngine, scanWidgetsDirectory } from '../../core/furnace-scanner.js';
 import { DEFAULT_LICENSE, getLicenseHeader } from '../../core/license-headers.js';
-import { registerTestManifest } from '../../core/manifest-register.js';
 import { validateSharedFtl } from '../../core/shared-ftl.js';
 import { InvalidArgumentError } from '../../errors/base.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { toError } from '../../utils/errors.js';
-import { ensureDir, pathExists, readText, writeText } from '../../utils/fs.js';
-import { cancel, intro, isCancel, note, outro, success, warn } from '../../utils/logger.js';
+import { ensureDir, pathExists, writeText } from '../../utils/fs.js';
+import { cancel, intro, isCancel, note, outro } from '../../utils/logger.js';
+import { resolveValidatedTestDir, scaffoldTestFiles } from './create-browser-test.js';
 import { formatDryRunPlan, formatSuccessNote } from './create-dry-run.js';
 import { resolveCreateFeatures } from './create-features.js';
 import { scaffoldMochikitTestFiles } from './create-mochikit.js';
@@ -62,115 +62,6 @@ function validateTagName(name) {
         return `Name ${CUSTOM_ELEMENT_TAG_RULES}`;
     return undefined;
 }
-/**
- * Scaffolds browser mochitest files for a newly created custom component.
- * @param componentName - Custom element tag name
- * @param license - Project license used for generated headers
- * @param forgeConfig - Project config fields needed for test naming
- * @param paths - Resolved project paths used to place test files
- * @param journal - Optional rollback journal that snapshots files before writes
- * @returns Relative test filenames created or updated for the component
- */
-async function scaffoldTestFiles(componentName, license, forgeConfig, paths, journal) {
-    const strippedName = componentName.startsWith('moz-') ? componentName.slice(4) : componentName;
-    // Avoid double-prefixing: strip binaryName prefix since testDirName already uses it
-    const testDirName = forgeConfig.binaryName;
-    const withoutBinaryPrefix = strippedName.startsWith(testDirName + '-')
-        ? strippedName.slice(testDirName.length + 1)
-        : strippedName;
-    const underscored = withoutBinaryPrefix.replace(/-/g, '_');
-    const testFileName = `browser_${testDirName}_${underscored}.js`;
-    const testDir = join(paths.engine, 'browser/base/content/test', testDirName);
-    if (journal && !(await pathExists(testDir))) {
-        recordCreatedDir(journal, testDir);
-    }
-    await ensureDir(testDir);
-    const jsHeader = getLicenseHeader(license, 'js');
-    const hashHeader = getLicenseHeader(license, 'hash');
-    const testFiles = [];
-    // browser.toml — create if missing, append entry if existing
-    const tomlPath = join(testDir, 'browser.toml');
-    if (await pathExists(tomlPath)) {
-        // Defensive guard: only append if the entry is not already present.
-        // With a fresh journal per create, the same test file name cannot be
-        // appended twice in a single run — but retaining the check protects
-        // against accidental re-entrance or a future refactor that reuses the
-        // helper with a stale test directory.
-        const existingToml = await readText(tomlPath);
-        if (!existingToml.includes(`["${testFileName}"]`)) {
-            if (journal)
-                await snapshotFile(journal, tomlPath);
-            await writeText(tomlPath, existingToml.trimEnd() + `\n\n["${testFileName}"]\n`);
-        }
-    }
-    else {
-        if (journal)
-            await snapshotFile(journal, tomlPath);
-        const browserToml = `${hashHeader}
-
-[DEFAULT]
-support-files = ["head.js"]
-
-["${testFileName}"]
-`;
-        await writeText(tomlPath, browserToml);
-    }
-    testFiles.push('browser.toml');
-    // head.js — only create if it doesn't exist (shared across components)
-    const headPath = join(testDir, 'head.js');
-    if (!(await pathExists(headPath))) {
-        if (journal)
-            await snapshotFile(journal, headPath);
-        const headJs = `${jsHeader}
-
-"use strict";
-
-/**
- * Wait for a custom element to be defined.
- * @param {string} tag - Custom element tag name
- * @returns {Promise<CustomElementConstructor>}
- */
-async function waitForElement(tag) {
-  document.createElement(tag);
-  return customElements.whenDefined(tag);
-}
-`;
-        await writeText(headPath, headJs);
-        testFiles.push('head.js');
-    }
-    // browser_{binaryName}_{stripped}.js
-    const testJs = `${jsHeader}
-
-"use strict";
-
-add_task(async function test_${underscored}_defined() {
-  const ctor = await waitForElement("${componentName}");
-  Assert.ok(ctor, "${componentName} custom element should be defined");
-  Assert.equal(typeof ctor, "function", "Constructor should be a function");
-});
-`;
-    const testFilePath = join(testDir, testFileName);
-    if (journal)
-        await snapshotFile(journal, testFilePath);
-    await writeText(testFilePath, testJs);
-    testFiles.push(testFileName);
-    // Register in moz.build. The registration helper edits browser/base/moz.build,
-    // so snapshot it first when a journal is supplied. The existing warn-and-continue
-    // contract is preserved so a missing/unparseable moz.build never trips rollback.
-    try {
-        const mozBuildPath = join(paths.engine, 'browser/base/moz.build');
-        if (journal)
-            await snapshotFile(journal, mozBuildPath);
-        const registerResult = await registerTestManifest(paths.engine, testDirName);
-        if (!registerResult.skipped) {
-            success(`Registered test manifest in ${registerResult.manifest}`);
-        }
-    }
-    catch (error) {
-        warn(`Could not register test manifest in moz.build — ${toError(error).message}. Register manually with "fireforge register".`);
-    }
-    return testFiles;
-}
 /**
  * Writes the scaffolded component source files to disk.
  * @param componentDir - Destination component directory
@@ -295,11 +186,11 @@ async function performCreateMutations(args) {
         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);
+            const scafFiles = await scaffoldTestFiles(args.componentName, args.license, args.forgeConfig, args.paths, journal, args.testDir);
             testFiles.push(...scafFiles);
         }
         else if (args.testStyle === 'xpcshell') {
-            const xpcshellFiles = await scaffoldXpcshellTestFiles(args.componentName, args.license, args.forgeConfig, args.paths, journal);
+            const xpcshellFiles = await scaffoldXpcshellTestFiles(args.componentName, args.license, args.forgeConfig, args.paths, journal, args.testDir);
             testFiles.push(...xpcshellFiles);
         }
         else if (args.testStyle === 'mochikit') {
@@ -409,6 +300,7 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
     // incompatible combinations up-front so a bad flag set never strands a
     // partial mutation behind.
     const testStyle = resolveTestStyle(options);
+    const testDir = resolveValidatedTestDir(options.testDir, testStyle);
     if (testStyle !== 'none' && !(await pathExists(paths.engine))) {
         throw new FurnaceError('Engine directory not found. Run "fireforge download" first to use --with-tests, --xpcshell, or --test-style.', componentName);
     }
@@ -477,6 +369,7 @@ export async function furnaceCreateCommand(projectRoot, name, options = {}) {
         paths,
         license,
         testStyle,
+        testDir,
         operationContext: ctx,
     }));
     note(formatSuccessNote({

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

@@ -52,8 +52,11 @@ function registerFurnaceInfoCommands(furnace, context) {
     }));
     furnace
         .command('scan')
-        .description('Scan engine for available components')
+        .description('Scan engine for available components. Report-only by default: persist the discovered ' +
+        'inventory into the stock section of furnace.json with --track (or the interactive ' +
+        'prompt); deploy/validate consume the inventory from there.')
         .option('--deep', 'Search additional Firefox directories beyond the default widgets path')
+        .option('--track', 'Persist every discovered untracked component into the stock section of furnace.json (non-interactive)')
         .action(withErrorHandling(async (options) => {
         await furnaceScanCommand(getProjectRoot(), pickDefined(options));
     }));
@@ -80,6 +83,7 @@ function registerFurnaceInfoCommands(furnace, context) {
         }
         return value;
     })
+        .option('--test-dir <dir>', 'Redirect the --with-tests scaffold to this engine-relative directory under browser/base/content/test/ (browser-chrome and xpcshell styles) instead of the default <binaryName>-derived directory; existing manifests are appended to, never overwritten')
         .option('--compose <tags>', 'Record stock tags composed internally (metadata only, comma-separated)', (val) => val.split(',').map((s) => s.trim()))
         .option('--shared-ftl <path>', 'Participate in an existing feature-scoped .ftl at this path (e.g. "browser/mybrowser-dock.ftl"); skips the per-component .ftl scaffold (implies --localized)')
         .option('--dry-run', 'Show the planned file set and furnace.json changes without writing')
@@ -98,6 +102,7 @@ function registerChromeDocCommands(furnace, context) {
         .command('create <name>')
         .description('Scaffold a new top-level chrome document')
         .option('--no-titlebar', 'Frameless overlay-style document (omits titlebar-buttonbox)')
+        .option('--browser-window', 'Emit the browser.xhtml-like main-window skeleton (<html id="main-window"> with windowtype/chromehidden/persist root attributes platform C++ reads before scripts run) for the document configured as the fork\'s main browser window; implies the titlebar markup')
         .option('--with-tests', 'Scaffold an xpcshell packaging-verification test that probes XCurProcD/chrome/browser/... directly (bypasses the xpcshell chrome:// URI limitation).')
         .option('--dry-run', 'Show the chrome-doc scaffold plan without writing')
         .action(withErrorHandling(async (name, options) => {

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

@@ -5,4 +5,5 @@
  */
 export declare function furnaceScanCommand(projectRoot: string, options?: {
     deep?: boolean;
+    track?: boolean;
 }): Promise<void>;

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

@@ -45,12 +45,41 @@ async function promptAddComponents(components, tracked, projectRoot) {
         outro('Scan complete');
         return;
     }
-    // Wrap the furnace.json mutation in the standard furnace lifecycle so the
-    // write goes through the furnace-wide lock and is visible to the global
-    // SIGINT/SIGTERM rollback pathway. The journal snapshots furnace.json
-    // *before* `ensureFurnaceConfig` runs, so a failed run after the file is
-    // auto-created cleans up after itself instead of leaving an unwanted
-    // default config behind.
+    await persistStockComponents(projectRoot, selected);
+    const addedNames = selected;
+    success(`Added ${addedNames.length} component${addedNames.length === 1 ? '' : 's'} to furnace.json`);
+    // Offer to immediately override one of the just-added stock components.
+    const shouldOverride = await confirm({
+        message: 'Override any of the newly added components?',
+    });
+    if (isCancel(shouldOverride) || !shouldOverride) {
+        return;
+    }
+    const overrideTarget = await select({
+        message: 'Select a component to override',
+        options: addedNames.map((name) => ({ value: name, label: name })),
+    });
+    if (isCancel(overrideTarget)) {
+        cancel('Cancelled');
+        return;
+    }
+    await furnaceOverrideCommand(projectRoot, overrideTarget);
+}
+/**
+ * Persists discovered component tag names into the `stock` section of
+ * furnace.json. Shared by the interactive confirm flow and the
+ * non-interactive `--track` flag (0.34.0 field report: scan printed a full
+ * inventory but persisted nothing and said nothing about where the
+ * inventory goes).
+ *
+ * Wraps the furnace.json mutation in the standard furnace lifecycle so the
+ * write goes through the furnace-wide lock and is visible to the global
+ * SIGINT/SIGTERM rollback pathway. The journal snapshots furnace.json
+ * *before* `ensureFurnaceConfig` runs, so a failed run after the file is
+ * auto-created cleans up after itself instead of leaving an unwanted
+ * default config behind.
+ */
+async function persistStockComponents(projectRoot, names) {
     await runFurnaceMutation(projectRoot, 'scan-rollback', async (ctx) => {
         const journal = createRollbackJournal();
         ctx.registerJournal(journal);
@@ -58,15 +87,14 @@ async function promptAddComponents(components, tracked, projectRoot) {
         await snapshotFile(journal, furnacePaths.furnaceConfig);
         try {
             const config = await ensureFurnaceConfig(projectRoot);
-            // Defensive: `selected` is already filtered to exclude components
-            // currently in config.stock (see untrackedComponents above). This
+            // Defensive: callers already filter to untracked components. This
             // re-filter catches the edge case where the config on disk changed
             // between the scan's read and the write (concurrent scan / manual
             // edit). Without it a duplicate scan would introduce duplicate
             // entries into stock; writeFurnaceConfig's validator would then
             // reject the write, but the error would be less actionable than
             // silently de-duplicating here.
-            const toAdd = selected.filter((s) => !config.stock.includes(s));
+            const toAdd = names.filter((s) => !config.stock.includes(s));
             config.stock.push(...toAdd);
             await writeFurnaceConfig(projectRoot, config);
         }
@@ -81,24 +109,6 @@ async function promptAddComponents(components, tracked, projectRoot) {
             throw error;
         }
     });
-    const addedNames = selected;
-    success(`Added ${addedNames.length} component${addedNames.length === 1 ? '' : 's'} to furnace.json`);
-    // Offer to immediately override one of the just-added stock components.
-    const shouldOverride = await confirm({
-        message: 'Override any of the newly added components?',
-    });
-    if (isCancel(shouldOverride) || !shouldOverride) {
-        return;
-    }
-    const overrideTarget = await select({
-        message: 'Select a component to override',
-        options: addedNames.map((name) => ({ value: name, label: name })),
-    });
-    if (isCancel(overrideTarget)) {
-        cancel('Cancelled');
-        return;
-    }
-    await furnaceOverrideCommand(projectRoot, overrideTarget);
 }
 /**
  * Runs the furnace scan command to discover MozLitElement components.
@@ -171,11 +181,31 @@ export async function furnaceScanCommand(projectRoot, options = {}) {
     }
     const untrackedCount = components.length - trackedCount;
     note(`Total: ${components.length}  Tracked: ${trackedCount}  Untracked: ${untrackedCount}`, 'Summary');
+    // --track: persist the discovered untracked inventory into the `stock`
+    // section without prompting (works non-interactively). Without it, scan
+    // stays report-only; the interactive confirm flow below is the other
+    // persistence path.
+    if (options.track) {
+        if (untrackedCount === 0) {
+            info('Nothing to track: every discovered component is already in furnace.json.');
+            outro('Scan complete');
+            return;
+        }
+        const untrackedNames = components.filter((c) => !tracked.has(c.tagName)).map((c) => c.tagName);
+        await persistStockComponents(projectRoot, untrackedNames);
+        success(`Tracked ${untrackedNames.length} component${untrackedNames.length === 1 ? '' : 's'} in the stock section of furnace.json`);
+        outro('Scan complete');
+        return;
+    }
     const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
     if (isInteractive && untrackedCount > 0) {
         await promptAddComponents(components, tracked, projectRoot);
         return;
     }
+    if (untrackedCount > 0) {
+        info('Scan is report-only: re-run with --track to persist the untracked components into the ' +
+            'stock section of furnace.json (deploy/validate consume them from there).');
+    }
     outro('Scan complete');
 }
 //# sourceMappingURL=scan.js.map

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

@@ -3,7 +3,7 @@ import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { getProjectPaths } from '../../core/config.js';
 import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, } from '../../core/furnace-config.js';
-import { addCustomElementRegistration, addJarMnEntries } from '../../core/furnace-registration.js';
+import { addCustomElementRegistration, addJarMnEntries, pruneStaleJarMnEntries, } from '../../core/furnace-registration.js';
 import { validateAllComponents, validateComponent } from '../../core/furnace-validate.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { pathExists } from '../../utils/fs.js';
@@ -14,6 +14,7 @@ const FIXABLE_CHECKS = new Set([
     'missing-jar-mn-mjs',
     'missing-jar-mn-css',
     'wrong-registration-pattern',
+    'stale-jar-registration',
 ]);
 /**
  * Auto-fixes registration issues that have deterministic solutions.
@@ -40,6 +41,21 @@ async function autoFixIssues(projectRoot, issues) {
             jarMnFixesByComponent.set(issue.component, existing);
         }
     }
+    // Prune stale jar.mn registrations (lines pointing at removed/renamed
+    // component files — 0.34.0 field report: these broke packaging while
+    // validate --fix reported success without touching them).
+    if (issues.some((issue) => issue.check === 'stale-jar-registration')) {
+        try {
+            const pruned = await pruneStaleJarMnEntries(engineDir, furnacePaths.customDir, Object.keys(config.custom));
+            fixed += pruned.length;
+            for (const entry of pruned) {
+                info(`Fixed: pruned stale jar.mn line for ${entry.tagName}/${entry.fileName}`);
+            }
+        }
+        catch (err) {
+            warn(`Could not prune stale jar.mn lines: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     // Fix jar.mn entries
     for (const [componentName, files] of jarMnFixesByComponent) {
         try {