@hominis/fireforge 0.54.0 → 0.60.0

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

@@ -1,400 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
-import { isComponentSourceFile, resolveFtlDir, tagNameToClassName, } from '../../core/furnace-constants.js';
-import { completeJournalRollback, runFurnaceMutation, waitLockMutationOptions, } from '../../core/furnace-operation.js';
-import { CUSTOM_ELEMENT_TAG_PATTERN, CUSTOM_ELEMENT_TAG_RULES, } from '../../core/furnace-registration-validate.js';
-import { createRollbackJournal, recordCreatedDir, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
-import { getStoriesDir } from '../../core/furnace-stories.js';
-import { InvalidArgumentError } from '../../errors/base.js';
-import { FurnaceError } from '../../errors/furnace.js';
-import { toError } from '../../utils/errors.js';
-import { copyFile, ensureDir, pathExists, readText, removeDir, removeFile, writeText, } from '../../utils/fs.js';
-import { info, intro, note, outro, warn } from '../../utils/logger.js';
-import { escapeRegex } from '../../utils/regex.js';
-import { updateBrowserChromeTestContent } from './rename-browser-test.js';
-import { renderRenamePlan } from './rename-dry-run.js';
-import { rekeyStateChecksums, renameComponentFileName, updateConfigForCustomRename, updateConfigForOverrideRename, } from './rename-helpers.js';
-import { loadMarkerComment, updateEngineRegistrations } from './rename-registrations.js';
-import { renameXpcshellTestFiles } from './rename-xpcshell.js';
-import { browserTestFileName } from './test-file-name.js';
-/**
- * Renames test files created by `furnace create --with-tests` in the engine
- * test directory. Best-effort: failures are logged as warnings but do not
- * block the rename.
- */
-async function renameTestFiles(engineDir, projectRoot, oldName, newName, journal) {
-    let forgeConfig;
-    try {
-        forgeConfig = await loadConfig(projectRoot);
-    }
-    catch {
-        return; // Cannot determine test paths without config.
-    }
-    const binaryName = forgeConfig.binaryName;
-    const oldTestFileName = browserTestFileName(oldName, binaryName);
-    const newTestFileName = browserTestFileName(newName, binaryName);
-    const testDir = join(engineDir, 'browser/base/content/test', binaryName);
-    if (!(await pathExists(testDir)))
-        return;
-    // Rename the test JS file
-    const oldTestPath = join(testDir, oldTestFileName);
-    const newTestPath = join(testDir, newTestFileName);
-    if (await pathExists(oldTestPath)) {
-        try {
-            await snapshotFile(journal, oldTestPath);
-            await snapshotFile(journal, newTestPath);
-            const content = await readText(oldTestPath);
-            await writeText(newTestPath, updateBrowserChromeTestContent(content, oldName, newName, binaryName));
-            await removeFile(oldTestPath);
-            info(`Renamed test file: ${oldTestFileName} → ${newTestFileName}`);
-        }
-        catch (error) {
-            warn(`Could not rename test file — ${toError(error).message}. Rename it manually if needed.`);
-        }
-    }
-    // Update browser.toml entry
-    const tomlPath = join(testDir, 'browser.toml');
-    if (await pathExists(tomlPath)) {
-        try {
-            const toml = await readText(tomlPath);
-            if (toml.includes(`["${oldTestFileName}"]`)) {
-                await snapshotFile(journal, tomlPath);
-                const updated = toml.replace(`["${oldTestFileName}"]`, `["${newTestFileName}"]`);
-                await writeText(tomlPath, updated);
-                info(`Updated browser.toml: ${oldTestFileName} → ${newTestFileName}`);
-            }
-        }
-        catch (error) {
-            warn(`Could not update browser.toml — ${toError(error).message}. Update it manually if needed.`);
-        }
-    }
-}
-/**
- * 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.
- *
- * Without it, a rename registers and deploys the new name correctly but
- * leaves `engine/toolkit/content/widgets/<old>/` in place: subsequent
- * `furnace sync` runs cannot clear the stale widget, and packaging pulls 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. Leaving both
- * unhandled produces a `test_<old>.html` that still imports
- * `chrome://global/content/elements/<old>.mjs` and references
- * `customElements.whenDefined("<old>")`, running against a component that
- * no longer exists under that name, and either failing or (if the old
- * component is still deployed) passing 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 snapshotFile(journal, newTestPath);
-            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.
- */
-async function performRenameMutations(args) {
-    const { projectRoot, oldName, newName } = args;
-    const oldClassName = tagNameToClassName(oldName);
-    const newClassName = tagNameToClassName(newName);
-    const mutate = async (ctx) => {
-        const journal = createRollbackJournal();
-        ctx.registerJournal(journal);
-        let newDir = args.newDir;
-        try {
-            const config = await loadFurnaceConfig(projectRoot);
-            const isCustom = oldName in config.custom;
-            const isOverride = oldName in config.overrides;
-            if (!isCustom && !isOverride) {
-                throw new FurnaceError(`Component "${oldName}" not found in furnace.json. Only custom and override components can be renamed.`, oldName);
-            }
-            if (newName in config.custom ||
-                newName in config.overrides ||
-                config.stock.includes(newName)) {
-                throw new FurnaceError(`A component named "${newName}" already exists in furnace.json.`, newName);
-            }
-            const componentType = isCustom ? 'custom' : 'override';
-            const componentDirLabel = isCustom ? 'custom' : 'overrides';
-            const baseDir = isCustom ? args.furnacePaths.customDir : args.furnacePaths.overridesDir;
-            const oldDir = join(baseDir, oldName);
-            newDir = join(baseDir, newName);
-            const oldCustomTargetPath = isCustom ? config.custom[oldName]?.targetPath : undefined;
-            if (!(await pathExists(oldDir))) {
-                throw new FurnaceError(`Component directory not found: components/${componentDirLabel}/${oldName}`, oldName);
-            }
-            if (await pathExists(newDir)) {
-                throw new FurnaceError(`Target directory already exists: components/${componentDirLabel}/${newName}`, newName);
-            }
-            await snapshotDir(journal, oldDir);
-            await snapshotFile(journal, args.furnaceConfigPath);
-            // Journal the state file before step 4 re-keys its checksums, plus
-            // the new dir and every new-name destination below (a snapshot of a
-            // missing path records {existed: false}, so rollback deletes it).
-            // Without these, a failed or SIGINT'd rename stranded the new-name
-            // scaffold and kept re-keyed state for a nonexistent component.
-            await snapshotFile(journal, getFurnacePaths(projectRoot).furnaceState);
-            // 1. Create new directory with renamed files and updated content
-            recordCreatedDir(journal, newDir);
-            await ensureDir(newDir);
-            const entries = await readdir(oldDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isFile())
-                    continue;
-                const oldFileName = entry.name;
-                // Rename only when the filename starts with the component name. The
-                // scaffolding convention for both create and override is
-                // `${name}.ext`. A plain `replace(oldName, newName)` produces wrong
-                // results when the old name occurs more than once (`foo-foo.mjs`
-                // renamed `foo` → `bar` becomes `bar-foo.mjs` instead of
-                // `bar-bar.mjs`) and when the old name appears inside a file that is
-                // not the component scaffold itself. Unrelated files (stray assets,
-                // editor backups) are copied verbatim.
-                const newFileName = renameComponentFileName(oldFileName, oldName, newName);
-                const oldPath = join(oldDir, oldFileName);
-                const newPath = join(newDir, newFileName);
-                await snapshotFile(journal, newPath);
-                if (isComponentSourceFile(oldFileName)) {
-                    let content = await readText(oldPath);
-                    // Use word-boundary-aware patterns so substrings in other
-                    // identifiers (e.g. "moz-panel" inside "moz-panel-group") are
-                    // not replaced.
-                    const tagPattern = new RegExp(`(?<![\\w-])${escapeRegex(oldName)}(?![\\w-])`, 'g');
-                    const classPattern = new RegExp(`\\b${escapeRegex(oldClassName)}\\b`, 'g');
-                    content = content.replace(tagPattern, newName);
-                    content = content.replace(classPattern, newClassName);
-                    await writeText(newPath, content);
-                }
-                else {
-                    await copyFile(oldPath, newPath);
-                }
-            }
-            // 2. Update furnace.json
-            if (isCustom) {
-                updateConfigForCustomRename(config, oldName, newName);
-            }
-            else {
-                updateConfigForOverrideRename(config, oldName, newName);
-            }
-            await writeFurnaceConfig(projectRoot, config);
-            // 3. Update engine registrations (custom components only)
-            const newConfig = config.custom[newName];
-            if (isCustom && newConfig?.register && (await pathExists(args.engineDir))) {
-                await updateEngineRegistrations({
-                    engineDir: args.engineDir,
-                    oldName,
-                    newName,
-                    newDir,
-                    ftlDir: resolveFtlDir(config.ftlBasePath),
-                    componentConfig: newConfig,
-                    markerComment: await loadMarkerComment(projectRoot),
-                    journal,
-                });
-            }
-            // 4. Re-key furnace-state.json checksums from old name to new name
-            await rekeyStateChecksums(args.projectRoot, componentType, oldName, newName);
-            // 5. Remove old directory
-            await removeDir(oldDir);
-            // 6. Clean up stale Storybook story file for the old name (if it exists
-            // from a previous `furnace preview` session). The next preview will
-            // regenerate the story under the new name via `syncStories`.
-            const oldStoryPath = join(getStoriesDir(args.engineDir), 'furnace', `${oldName}.stories.mjs`);
-            if (await pathExists(oldStoryPath)) {
-                await snapshotFile(journal, oldStoryPath);
-                await removeFile(oldStoryPath);
-                info(`Deleted stale story file: ${oldName}.stories.mjs`);
-            }
-            // 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);
-                // The mochikit scaffold and widgets/chrome.toml live in a different
-                // tree than browser.toml-registered browser-chrome tests, so
-                // renameTestFiles does not reach them, leaving
-                // `engine/toolkit/content/tests/widgets/test_<old>.html` and its
-                // `chrome.toml` entry pointing at the old name, which either fails
-                // the test run outright or passes for the wrong component.
-                await renameMochikitTestFiles(args.engineDir, oldName, newName, journal);
-                // xpcshell scaffolds live in yet another tree
-                // (`browser/base/content/test/<binary>-xpcshell/<name>/`). Without
-                // this call, renaming a component scaffolded with
-                // `--with-tests --xpcshell` leaves a directory whose name still
-                // references the pre-rename component, plus a test file whose
-                // underscored name references the old tag.
-                await renameXpcshellTestFiles(args.engineDir, projectRoot, 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 it the old widget stays at
-                // `engine/toolkit/content/widgets/<old>/` alongside the
-                // newly-deployed `<new>/`, with no signal to `status` / `verify`.
-                if (oldCustomTargetPath) {
-                    await removeStaleDeployedComponentDir(args.engineDir, oldCustomTargetPath, journal);
-                }
-            }
-            info(`Renamed ${componentType} component: ${oldName} → ${newName}`);
-        }
-        catch (error) {
-            // Extra best-effort step this site owns: the half-created new
-            // directory is not in the journal, so drop it before the shared
-            // restore puts the old one back.
-            try {
-                if (await pathExists(newDir)) {
-                    await removeDir(newDir);
-                }
-            }
-            catch {
-                // Best effort cleanup
-            }
-            return await completeJournalRollback(ctx, journal, error, {
-                projectRoot,
-                operation: 'rename-rollback',
-                failureMessage: `Failed to rename component "${oldName}" to "${newName}"`,
-                subject: `rename "${oldName}" → "${newName}"`,
-            });
-        }
-    };
-    await runFurnaceMutation(projectRoot, 'rename-rollback', mutate, waitLockMutationOptions(args.waitLockSeconds));
-}
-/**
- * Renames a custom or override component atomically: updates directory name,
- * file names, file contents, furnace.json, and engine registrations.
- */
-export async function furnaceRenameCommand(projectRoot, oldName, newName, options = {}) {
-    intro(options.dryRun ? 'Furnace Rename (dry run)' : 'Furnace Rename');
-    if (!CUSTOM_ELEMENT_TAG_PATTERN.test(oldName)) {
-        throw new InvalidArgumentError(`Invalid source name "${oldName}": ${CUSTOM_ELEMENT_TAG_RULES}`, 'old-name');
-    }
-    if (!CUSTOM_ELEMENT_TAG_PATTERN.test(newName)) {
-        throw new InvalidArgumentError(`Invalid target name "${newName}": ${CUSTOM_ELEMENT_TAG_RULES}`, 'new-name');
-    }
-    if (oldName === newName) {
-        throw new InvalidArgumentError('Source and target names are identical.', 'new-name');
-    }
-    const config = await loadFurnaceConfig(projectRoot);
-    const furnacePaths = getFurnacePaths(projectRoot);
-    const paths = getProjectPaths(projectRoot);
-    const isCustom = oldName in config.custom;
-    const isOverride = oldName in config.overrides;
-    if (!isCustom && !isOverride) {
-        throw new FurnaceError(`Component "${oldName}" not found in furnace.json. Only custom and override components can be renamed.`, oldName);
-    }
-    if (newName in config.custom || newName in config.overrides || config.stock.includes(newName)) {
-        throw new FurnaceError(`A component named "${newName}" already exists in furnace.json.`, newName);
-    }
-    // The furnace-state key is singular (`custom` / `override`, derived
-    // inside performRenameMutations). The on-disk directory label differs.
-    // Custom components live under `components/custom/` (singular) while
-    // overrides live under `components/overrides/` (plural). Appending an
-    // `s` to the state key produces the wrong label `components/customs/`
-    // for custom components and is correct for overrides only by
-    // coincidence. `componentDirLabel` centralises the pick so every
-    // operator-facing string names the directory that actually exists on
-    // disk.
-    const componentDirLabel = isCustom ? 'custom' : 'overrides';
-    const baseDir = isCustom ? furnacePaths.customDir : furnacePaths.overridesDir;
-    const oldDir = join(baseDir, oldName);
-    const newDir = join(baseDir, newName);
-    if (!(await pathExists(oldDir))) {
-        throw new FurnaceError(`Component directory not found: components/${componentDirLabel}/${oldName}`, oldName);
-    }
-    if (await pathExists(newDir)) {
-        throw new FurnaceError(`Target directory already exists: components/${componentDirLabel}/${newName}`, newName);
-    }
-    if (options.dryRun) {
-        note(await renderRenamePlan({
-            config,
-            oldName,
-            newName,
-            oldDir,
-            componentDirLabel,
-            engineDir: paths.engine,
-            markerComment: await loadMarkerComment(projectRoot),
-        }), `${oldName} → ${newName}`);
-        outro('Dry run complete (no files modified)');
-        return;
-    }
-    await performRenameMutations({
-        projectRoot,
-        oldName,
-        newName,
-        newDir,
-        furnaceConfigPath: furnacePaths.furnaceConfig,
-        furnacePaths,
-        engineDir: paths.engine,
-        waitLockSeconds: options.waitLockSeconds,
-    });
-    note(`Component renamed: ${oldName} → ${newName}\n\n` +
-        `Directory: components/${componentDirLabel}/${newName}/\n\n` +
-        'Next steps:\n' +
-        '  1. Review the renamed files for any remaining references\n' +
-        '  2. Run "fireforge furnace validate" to verify\n' +
-        '  3. Run "fireforge furnace apply" to update the engine', newName);
-    outro('Rename complete');
-}

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

@@ -1,14 +0,0 @@
-import type { FurnaceLockWaitable } from '../../types/commands/index.js';
-/** Options for `furnace scan`. */
-export interface FurnaceScanOptions extends FurnaceLockWaitable {
-    /** Search additional Firefox directories beyond the default widgets path. */
-    deep?: boolean;
-    /** Persist every untracked component into furnace.json's stock section. */
-    track?: boolean;
-}
-/**
- * Runs the furnace scan command to discover MozLitElement components.
- * @param projectRoot - Root directory of the project
- * @param options - Scan options
- */
-export declare function furnaceScanCommand(projectRoot: string, options?: FurnaceScanOptions): Promise<void>;

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

@@ -1,192 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { confirm, multiselect, select } from '@clack/prompts';
-import { stdioIsInteractive } from '../../core/destructive.js';
-import { ensureFurnaceConfig, furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
-import { completeJournalRollback, runFurnaceMutation, waitLockMutationOptions, } from '../../core/furnace-operation.js';
-import { assertFurnaceEngineReady } from '../../core/furnace-precondition.js';
-import { createRollbackJournal, snapshotFile } from '../../core/furnace-rollback.js';
-import { DEEP_SCAN_PATHS, scanWidgetsDirectory } from '../../core/furnace-scanner.js';
-import { cancel, info, intro, isCancel, note, outro, spinner, success, } from '../../utils/logger.js';
-import { furnaceOverrideCommand } from './override.js';
-/**
- * Prompts the user to add newly discovered stock components to furnace.json.
- * @param components - Components discovered in the engine scan
- * @param tracked - Existing Furnace tracking map keyed by tag name
- * @param projectRoot - Root directory of the project
- * @param waitLockSeconds - Resolved `--wait-lock` budget for the furnace lock
- */
-async function promptAddComponents(components, tracked, projectRoot, waitLockSeconds) {
-    const untrackedComponents = components.filter((c) => !tracked.has(c.tagName));
-    const shouldAdd = await confirm({ message: 'Add components to furnace.json?' });
-    if (isCancel(shouldAdd) || !shouldAdd) {
-        if (isCancel(shouldAdd)) {
-            cancel('Cancelled');
-        }
-        outro('Scan complete');
-        return;
-    }
-    const selected = await multiselect({
-        message: 'Select components to add as stock',
-        options: untrackedComponents.map((c) => ({
-            value: c.tagName,
-            label: `${c.tagName}${formatComponentFeatures(c)}`,
-        })),
-    });
-    if (isCancel(selected)) {
-        cancel('Cancelled');
-        outro('Scan complete');
-        return;
-    }
-    await persistStockComponents(projectRoot, selected, waitLockSeconds);
-    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, waitLockSeconds !== undefined ? { waitLockSeconds } : {});
-}
-/**
- * Persists discovered component tag names into the `stock` section of
- * furnace.json. Shared by the interactive confirm flow and the
- * non-interactive `--track` flag. Without it, scan prints a full inventory
- * but persists nothing and says 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, waitLockSeconds) {
-    const mutate = async (ctx) => {
-        const journal = createRollbackJournal();
-        ctx.registerJournal(journal);
-        const furnacePaths = getFurnacePaths(projectRoot);
-        await snapshotFile(journal, furnacePaths.furnaceConfig);
-        try {
-            const config = await ensureFurnaceConfig(projectRoot);
-            // 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 = names.filter((s) => !config.stock.includes(s));
-            config.stock.push(...toAdd);
-            await writeFurnaceConfig(projectRoot, config);
-        }
-        catch (error) {
-            return await completeJournalRollback(ctx, journal, error, {
-                projectRoot: projectRoot,
-                operation: 'scan-rollback',
-                failureMessage: 'Failed to update furnace.json during scan',
-                subject: `furnace.json update during scan`,
-            });
-        }
-    };
-    await runFurnaceMutation(projectRoot, 'scan-rollback', mutate, waitLockMutationOptions(waitLockSeconds));
-}
-/**
- * Renders a component's discovered capabilities as a display suffix. Shared
- * by the interactive multiselect labels and the report rows.
- */
-function formatComponentFeatures(component) {
-    const features = [];
-    if (component.hasCSS)
-        features.push('CSS');
-    if (component.hasFTL)
-        features.push('FTL');
-    if (component.isRegistered)
-        features.push('registered');
-    return features.length > 0 ? ` — ${features.join(', ')}` : '';
-}
-/**
- * Runs the furnace scan command to discover MozLitElement components.
- * @param projectRoot - Root directory of the project
- * @param options - Scan options
- */
-export async function furnaceScanCommand(projectRoot, options = {}) {
-    intro(options.deep ? 'Furnace Scan (deep)' : 'Furnace Scan');
-    const { paths } = await assertFurnaceEngineReady(projectRoot);
-    // Load scan paths from config if available, merge with deep paths if requested
-    const extraScanPaths = [];
-    if (await furnaceConfigExists(projectRoot)) {
-        const preConfig = await loadFurnaceConfig(projectRoot);
-        if (preConfig.scanPaths) {
-            extraScanPaths.push(...preConfig.scanPaths);
-        }
-    }
-    if (options.deep) {
-        for (const deepPath of DEEP_SCAN_PATHS) {
-            if (!extraScanPaths.includes(deepPath)) {
-                extraScanPaths.push(deepPath);
-            }
-        }
-    }
-    const s = spinner('Scanning engine for components...');
-    const components = await scanWidgetsDirectory(paths.engine, undefined, extraScanPaths.length > 0 ? extraScanPaths : undefined);
-    s.stop(`Found ${components.length} component${components.length === 1 ? '' : 's'}`);
-    // Build tracking info from furnace.json if it exists
-    const tracked = new Map();
-    if (await furnaceConfigExists(projectRoot)) {
-        const config = await loadFurnaceConfig(projectRoot);
-        for (const name of config.stock) {
-            tracked.set(name, 'stock');
-        }
-        for (const name of Object.keys(config.overrides)) {
-            tracked.set(name, 'override');
-        }
-        for (const name of Object.keys(config.custom)) {
-            tracked.set(name, 'custom');
-        }
-    }
-    // Partition once and reuse across the report and the `--track` path.
-    const untrackedComponentList = components.filter((c) => !tracked.has(c.tagName));
-    const untrackedCount = untrackedComponentList.length;
-    const trackedCount = components.length - untrackedCount;
-    for (const component of components) {
-        const type = tracked.get(component.tagName);
-        info(`${component.tagName}${formatComponentFeatures(component)}${type ? ` [${type}]` : ''}`);
-    }
-    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 = untrackedComponentList.map((c) => c.tagName);
-        await persistStockComponents(projectRoot, untrackedNames, options.waitLockSeconds);
-        success(`Tracked ${untrackedNames.length} component${untrackedNames.length === 1 ? '' : 's'} in the stock section of furnace.json`);
-        outro('Scan complete');
-        return;
-    }
-    const isInteractive = stdioIsInteractive();
-    if (isInteractive && untrackedCount > 0) {
-        await promptAddComponents(components, tracked, projectRoot, options.waitLockSeconds);
-        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');
-}

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

@@ -1,7 +0,0 @@
-/**
- * Runs the furnace status command to show an overview of Furnace state.
- * When a component name is provided, shows detailed registration status.
- * @param projectRoot - Root directory of the project
- * @param name - Optional component name for detailed status
- */
-export declare function furnaceStatusCommand(projectRoot: string, name?: string): Promise<void>;