@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,283 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { Command, Option } from 'commander';
-import { withEngineSessionLock } from '../../core/engine-session-lock.js';
-import { addWaitLockOption, pickDefined, resolveWaitLockSeconds, } from '../../utils/options.js';
-import { furnaceApplyCommand } from './apply.js';
-import { furnaceChromeDocCreateCommand } from './chrome-doc.js';
-import { furnaceChromeDocRemoveCommand } from './chrome-doc-remove.js';
-import { furnaceCreateCommand } from './create.js';
-import { furnaceDeployCommand } from './deploy.js';
-import { furnaceDiffCommand } from './diff.js';
-import { furnaceInitCommand } from './init.js';
-import { furnaceListCommand } from './list.js';
-import { furnaceBatchOverrideCommand, furnaceOverrideCommand } from './override.js';
-import { furnacePreviewCommand } from './preview.js';
-import { furnaceRefreshCommand } from './refresh.js';
-import { furnaceRemoveCommand } from './remove.js';
-import { furnaceRenameCommand } from './rename.js';
-import { furnaceScanCommand } from './scan.js';
-import { furnaceStatusCommand } from './status.js';
-import { furnaceSyncCommand } from './sync.js';
-import { furnaceValidateCommand } from './validate.js';
-import { parseMaxWarnings } from './validate-report.js';
-/**
- * Splits the raw `--wait-lock` value off a furnace leaf's parsed options and
- * resolves it into `waitLockSeconds` (flag, else `FIREFORGE_WAIT_LOCK`, else
- * undefined) for the furnace lock `runFurnaceMutation` takes. Used by the
- * leaves that take only Furnace's lock, so the flag is honoured there rather
- * than accepted and ignored.
- */
-function withFurnaceLockBudget(options) {
-    const { waitLock, ...rest } = options;
-    return pickDefined({ ...rest, waitLockSeconds: resolveWaitLockSeconds(waitLock) });
-}
-async function runEngineLockedFurnaceCommand(context, command, operation, waitLockSeconds) {
-    const projectRoot = context.getProjectRoot();
-    await withEngineSessionLock(projectRoot, command, () => operation(projectRoot), {
-        waitLockSeconds,
-    });
-}
-function registerFurnaceApplyCommand(furnace, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const apply = furnace
-        .command('apply [name]')
-        .description('Apply components to the engine (optionally a single component)')
-        .option('--dry-run', 'Show what would be changed without writing (reads may overlap concurrent mutations)')
-        .option('--force', 'Proceed despite baseVersion drift (stale overrides)')
-        .option('-w, --watch', 'Watch component directories and re-apply on changes');
-    addWaitLockOption(apply).action(withErrorHandling(async (name, options) => {
-        const { waitLock, ...rest } = options ?? {};
-        // Resolved once and used twice: the engine session lock below, and
-        // the furnace lock the mutation takes inside it. Resolving twice
-        // would be the same value today and a drift risk tomorrow.
-        const waitLockSeconds = resolveWaitLockSeconds(waitLock);
-        const parsed = pickDefined({ ...rest, waitLockSeconds });
-        const run = (projectRoot) => furnaceApplyCommand(projectRoot, name, parsed);
-        if (parsed.dryRun === true) {
-            await run(getProjectRoot());
-            return;
-        }
-        await runEngineLockedFurnaceCommand(context, 'furnace apply', run, waitLockSeconds);
-    }));
-}
-function registerFurnaceDeployCommand(furnace, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const deploy = furnace
-        .command('deploy [names...]')
-        .description('Apply components and validate in one step (name several to deploy them under one lock hold)')
-        .option('--dry-run', 'Show what would be changed without writing (reads may overlap concurrent mutations)')
-        .option('--force', 'Proceed despite baseVersion drift (stale overrides)')
-        .option('--skip-validate', 'Skip the validation step (apply only)')
-        .option('--owner <patch>', 'The patch being exported: refuse the whole deploy, before any write, when it would overwrite a deployed file another patch owns')
-        .addHelpText('after', [
-        '',
-        'Deploy registers every .mjs and .css file in a custom component directory in',
-        'toolkit/content/jar.mn, including extra modules beside the main one (e.g.',
-        'components/custom/<tag>/<tag>-rows.mjs). Add the file to the directory and run',
-        '`fireforge furnace deploy <tag>` instead of writing the jar.mn line by hand; a line',
-        'that already exists anywhere in jar.mn is kept and never duplicated.',
-    ].join('\n'));
-    addWaitLockOption(deploy).action(withErrorHandling(async (names, options) => {
-        const { waitLock, ...rest } = options ?? {};
-        const waitLockSeconds = resolveWaitLockSeconds(waitLock);
-        const parsed = pickDefined({ ...rest, waitLockSeconds });
-        const run = (projectRoot) => furnaceDeployCommand(projectRoot, names, parsed);
-        if (parsed.dryRun === true) {
-            await run(getProjectRoot());
-            return;
-        }
-        await runEngineLockedFurnaceCommand(context, 'furnace deploy', run, waitLockSeconds);
-    }));
-}
-function registerFurnaceSyncCommand(furnace, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const sync = furnace
-        .command('sync')
-        .description('Refresh drifted overrides and re-apply all components (recommended after fireforge download)')
-        .option('--dry-run', 'Show what would change without modifying files (reads may overlap concurrent mutations)')
-        .addOption(new Option('-s, --strategy <strategy>', 'Auto-resolve merge conflicts (ours = keep local, theirs = accept upstream)').choices(['ours', 'theirs']));
-    addWaitLockOption(sync).action(withErrorHandling(async (options) => {
-        const { waitLock, ...rest } = options;
-        const waitLockSeconds = resolveWaitLockSeconds(waitLock);
-        const parsed = pickDefined({ ...rest, waitLockSeconds });
-        const run = (projectRoot) => furnaceSyncCommand(projectRoot, parsed);
-        if (parsed.dryRun === true) {
-            await run(getProjectRoot());
-            return;
-        }
-        await runEngineLockedFurnaceCommand(context, 'furnace sync', run, waitLockSeconds);
-    }));
-}
-/**
- * Registers Furnace commands for querying component state: status, scan,
- * and action commands like apply, deploy, and create.
- * @param furnace - Parent Furnace command
- * @param context - Shared CLI registration context
- */
-function registerFurnaceInfoCommands(furnace, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    furnace
-        .command('status [name]')
-        .description('Show component status and registration details')
-        .action(withErrorHandling(async (name) => {
-        await furnaceStatusCommand(getProjectRoot(), name);
-    }));
-    registerFurnaceApplyCommand(furnace, context);
-    registerFurnaceDeployCommand(furnace, context);
-    const scan = furnace
-        .command('scan')
-        .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)');
-    addWaitLockOption(scan).action(withErrorHandling(async (options) => {
-        await furnaceScanCommand(getProjectRoot(), withFurnaceLockBudget(options));
-    }));
-    furnace
-        .command('init')
-        .description('Initialize furnace.json with project settings')
-        .option('-p, --prefix <prefix>', 'Component prefix (e.g. "moz-", "ff-")')
-        .option('--ftl-base-path <path>', 'Fluent l10n base path')
-        .option('--force', 'Overwrite existing furnace.json')
-        .action(withErrorHandling(async (options) => {
-        await furnaceInitCommand(getProjectRoot(), options);
-    }));
-    const create = furnace
-        .command('create [name]')
-        .description('Create a new custom component')
-        .option('-d, --description <desc>', 'Component description')
-        .option('--localized', 'Include Fluent l10n support')
-        .option('--no-register', 'Skip customElements.js registration')
-        .option('--with-tests', 'Scaffold a test harness (defaults to browser-chrome; use --test-style=mochikit for tabbrowser-less chrome — may be flaky on macOS)')
-        .option('--xpcshell', 'Scaffold an xpcshell test harness (for storage-layer code on forks without tabbrowser); equivalent to --test-style=xpcshell. Note: xpcshell resolves chrome://global/* URIs but not chrome://browser/* — use --test-style=browser-chrome for browser-chrome-dependent tests.')
-        .option('--test-style <style>', 'Override the harness written by --with-tests: browser-chrome (default, needs tabbrowser), mochikit (toolkit/widgets, non-tabbrowser chrome), or xpcshell (headless)', (value) => {
-        if (value !== 'mochikit' && value !== 'browser-chrome' && value !== 'xpcshell') {
-            throw new Error(`--test-style must be one of: mochikit, browser-chrome, xpcshell. Got: "${value}".`);
-        }
-        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')
-        .option('--allow-prefix-mismatch', 'Create the component even when its name does not start with the configured `componentPrefix` in furnace.json. Without this flag the command refuses to write anything on a prefix mismatch.');
-    addWaitLockOption(create).action(withErrorHandling(async (name, options) => {
-        await furnaceCreateCommand(getProjectRoot(), name, withFurnaceLockBudget(options));
-    }));
-    registerChromeDocCommands(furnace, context);
-}
-function registerChromeDocCommands(furnace, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const chromeDoc = furnace
-        .command('chrome-doc')
-        .description('Scaffold top-level chrome documents (xhtml + js + css + ftl + jar.mn)');
-    const chromeDocCreate = chromeDoc
-        .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');
-    addWaitLockOption(chromeDocCreate).action(withErrorHandling(async (name, options) => {
-        await furnaceChromeDocCreateCommand(getProjectRoot(), name, withFurnaceLockBudget(options));
-    }));
-    const chromeDocRemove = chromeDoc
-        .command('remove <name>')
-        .description('Remove a scaffolded top-level chrome document')
-        .option('-y, --yes', 'Skip confirmation')
-        .option('--dry-run', 'Show the chrome-doc removal plan without writing');
-    addWaitLockOption(chromeDocRemove).action(withErrorHandling(async (name, options) => {
-        await furnaceChromeDocRemoveCommand(getProjectRoot(), name, withFurnaceLockBudget(options));
-    }));
-}
-/**
- * Registers Furnace commands for authoring, inspection, and maintenance:
- * override, list, remove, preview, validate, diff, refresh, and rename.
- * @param furnace - Parent Furnace command
- * @param context - Shared CLI registration context
- */
-function registerFurnaceModifyCommands(furnace, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const override = furnace
-        .command('override [names...]')
-        .description('Fork one or more existing components for modification')
-        .addOption(new Option('-t, --type <type>', 'Override type').choices(['css-only', 'full']))
-        .option('-d, --description <desc>', 'Description');
-    addWaitLockOption(override).action(withErrorHandling(async (names, rawOptions) => {
-        const options = withFurnaceLockBudget(rawOptions);
-        if (names.length <= 1) {
-            await furnaceOverrideCommand(getProjectRoot(), names[0], options);
-        }
-        else {
-            await furnaceBatchOverrideCommand(getProjectRoot(), names, options);
-        }
-    }));
-    furnace
-        .command('list')
-        .description('List all registered components')
-        .option('-v, --verbose', 'Show per-component health indicators (clean/modified/not applied)')
-        .action(withErrorHandling(async (options) => {
-        await furnaceListCommand(getProjectRoot(), options);
-    }));
-    const remove = furnace
-        .command('remove <name>')
-        .description('Remove a component from the workspace')
-        .option('-y, --yes', 'Skip confirmation');
-    addWaitLockOption(remove).action(withErrorHandling(async (name, options) => {
-        await furnaceRemoveCommand(getProjectRoot(), name, withFurnaceLockBudget(options));
-    }));
-    const preview = furnace
-        .command('preview')
-        .description('Start component preview (Storybook)')
-        .option('--install', 'Force reinstall Storybook dependencies');
-    addWaitLockOption(preview).action(withErrorHandling(async (options) => {
-        await furnacePreviewCommand(getProjectRoot(), withFurnaceLockBudget(options));
-    }));
-    furnace
-        .command('validate [name]')
-        .description('Run accessibility and compatibility checks')
-        .option('--fix', 'Auto-fix registration issues (missing jar.mn entries, customElements.js)')
-        .option('--json', 'Write the result as one JSON document (findings, excepted findings, stale exceptions, verdict) to stdout')
-        .option('--max-warnings <n>', 'Fail when more than <n> warnings remain after furnace.json validationExceptions (0 for a warning-clean gate)')
-        .action(withErrorHandling(async (name, options) => {
-        const { maxWarnings, ...rest } = options ?? {};
-        await furnaceValidateCommand(getProjectRoot(), name, pickDefined({ ...rest, maxWarnings: parseMaxWarnings(maxWarnings) }));
-    }));
-    furnace
-        .command('diff [name]')
-        .description('Show changes vs baseline (overrides: vs Firefox original, custom: vs engine). Shows all components when name is omitted.')
-        .action(withErrorHandling(async (name) => {
-        await furnaceDiffCommand(getProjectRoot(), name);
-    }));
-    const refresh = furnace
-        .command('refresh [name]')
-        .description('Merge upstream Firefox changes into overrides (three-way merge)')
-        .option('--dry-run', 'Show what would change without modifying files')
-        .option('-a, --all', 'Refresh all overrides in a single batch')
-        .addOption(new Option('-s, --strategy <strategy>', 'Auto-resolve conflicts (ours = keep local, theirs = accept upstream)').choices(['ours', 'theirs']))
-        .option('--reset-base', 'Reset baseline to current engine HEAD (skips three-way merge, recovers from missing baseCommit)');
-    addWaitLockOption(refresh).action(withErrorHandling(async (name, options) => {
-        await furnaceRefreshCommand(getProjectRoot(), name, withFurnaceLockBudget(options));
-    }));
-    const rename = furnace
-        .command('rename <old-name> <new-name>')
-        .description('Rename a component (updates files, config, and registrations)')
-        .option('--dry-run', 'Show the planned file moves, furnace.json change and engine registration edits without writing');
-    addWaitLockOption(rename).action(withErrorHandling(async (oldName, newName, options) => {
-        await furnaceRenameCommand(getProjectRoot(), oldName, newName, withFurnaceLockBudget(options));
-    }));
-    registerFurnaceSyncCommand(furnace, context);
-}
-/** Registers the furnace command on the CLI program. */
-export function registerFurnace(program, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const furnace = program
-        .command('furnace')
-        .description('Component management — create, override, apply, deploy, diff, validate, sync (run furnace --help for all subcommands)')
-        .action(withErrorHandling(async () => {
-        await furnaceStatusCommand(getProjectRoot());
-    }));
-    registerFurnaceInfoCommands(furnace, context);
-    registerFurnaceModifyCommands(furnace, context);
-}

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

@@ -1,11 +0,0 @@
-/**
- * Runs the furnace init command to create a default furnace.json with
- * user-specified settings.
- * @param projectRoot - Root directory of the project
- * @param options - Init options
- */
-export declare function furnaceInitCommand(projectRoot: string, options?: {
-    prefix?: string;
-    ftlBasePath?: string;
-    force?: boolean;
-}): Promise<void>;

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

@@ -1,287 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { stat } from 'node:fs/promises';
-import { basename, dirname, isAbsolute, join, posix } from 'node:path';
-import { text } from '@clack/prompts';
-import { getProjectPaths, loadConfig, loadRawConfigDocument, mutateConfig, validateConfig, withConfigFileLock, writeConfigDocument, } from '../../core/config.js';
-import { stdioIsInteractive } from '../../core/destructive.js';
-import { createDefaultFurnaceConfig, furnaceConfigExists, writeFurnaceConfig, } from '../../core/furnace-config.js';
-import { DEFAULT_LICENSE } from '../../core/license-headers.js';
-import { registerSharedCSS } from '../../core/register-shared-css.js';
-import { getTokensCssPath } from '../../core/token-manager.js';
-import { generateDefaultTokensCss } from '../../core/token-scaffold.js';
-import { FurnaceError } from '../../errors/furnace.js';
-import { getNodeErrorCode, 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';
-import { normalizePathSlashes } from '../../utils/paths.js';
-/**
- * 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.
- *
- * `furnace init --ftl-base-path browser/<name>.ftl` otherwise produces a
- * misleading success path: the subsequent `furnace create --localized`
- * scaffolds an `.mjs` referencing `insertFTLIfNeeded("<name>.ftl")` while
- * furnace.json has no component entry, leaving the scaffold orphaned.
- * 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, so 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).
- */
-async function validateFtlBasePath(value, engineDir) {
-    if (value.length === 0) {
-        throw new FurnaceError('ftlBasePath must not be empty.');
-    }
-    if (value.includes('\0')) {
-        throw new FurnaceError('ftlBasePath must not contain null bytes.');
-    }
-    if (isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value)) {
-        throw new FurnaceError(`ftlBasePath "${value}" must be a relative path inside the engine checkout, not absolute.`);
-    }
-    // Normalize with the POSIX rules regardless of host: `normalize` on Windows
-    // emits backslashes, so a `../`-prefix test against the platform `normalize`
-    // silently passes every traversal attempt there.
-    const normalized = posix.normalize(normalizePathSlashes(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 stats = await stat(resolved);
-            if (!stats.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, so re-throw and let the operator see it.
-            if (error instanceof FurnaceError)
-                throw error;
-            // ENOENT is expected on a fresh project before `fireforge
-            // download` has populated engine/. Only warn.
-            const code = getNodeErrorCode(error);
-            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 ignored here as best-effort: 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
- * user-specified settings.
- * @param projectRoot - Root directory of the project
- * @param options - Init options
- */
-export async function furnaceInitCommand(projectRoot, options = {}) {
-    intro('Furnace Init');
-    if ((await furnaceConfigExists(projectRoot)) && !options.force) {
-        throw new FurnaceError('furnace.json already exists. Use --force to overwrite it.');
-    }
-    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. Without the prefix default, a fresh init → token add →
-    // coverage sequence reports `0 tokens / N unknown` because the scan has
-    // nothing to key off. Loading fireforge.json here is best-effort: a
-    // project without one (mid-setup) falls through to the prefix-less
-    // default, and `token coverage` emits its 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 = stdioIsInteractive();
-    const engineForValidation = (await pathExists(paths.engine)) ? paths.engine : undefined;
-    // Resolve componentPrefix
-    if (options.prefix !== undefined) {
-        config.componentPrefix = options.prefix;
-    }
-    else if (isInteractive) {
-        const prefixResult = await text({
-            message: 'Component prefix (e.g. "moz-", "ff-")',
-            initialValue: config.componentPrefix,
-            validate: (value) => {
-                if (!value)
-                    return 'Prefix is required';
-                return undefined;
-            },
-        });
-        if (isCancel(prefixResult)) {
-            cancel('Init cancelled');
-            return;
-        }
-        config.componentPrefix = prefixResult;
-    }
-    // Resolve ftlBasePath
-    if (options.ftlBasePath !== undefined) {
-        await validateFtlBasePath(options.ftlBasePath, engineForValidation);
-        config.ftlBasePath = options.ftlBasePath;
-    }
-    else if (isInteractive) {
-        const ftlResult = await text({
-            message: 'Fluent l10n base path (leave empty for default)',
-            placeholder: 'toolkit/locales/en-US/toolkit/global',
-        });
-        if (isCancel(ftlResult)) {
-            cancel('Init cancelled');
-            return;
-        }
-        const ftlValue = ftlResult.trim();
-        if (ftlValue) {
-            await validateFtlBasePath(ftlValue, engineForValidation);
-            config.ftlBasePath = ftlValue;
-        }
-    }
-    await writeFurnaceConfig(projectRoot, config);
-    success('Created furnace.json');
-    const scaffoldResult = await scaffoldTokensCss(projectRoot);
-    const lines = [`Component prefix: ${config.componentPrefix}`];
-    if (config.ftlBasePath) {
-        lines.push(`FTL base path: ${config.ftlBasePath}`);
-    }
-    if (scaffoldResult.tokensCssPath) {
-        lines.push(`Tokens CSS:       ${scaffoldResult.tokensCssPath}`);
-    }
-    note(lines.join('\n'), 'Configuration');
-    info('Next steps:\n' +
-        '  fireforge furnace scan         — discover engine components\n' +
-        '  fireforge furnace create       — create a new custom component\n' +
-        '  fireforge furnace override     — fork an existing component\n' +
-        '  fireforge token add            — define a token in the scaffolded tokens CSS\n' +
-        '  fireforge export <tokens.css>  — capture the tokens CSS + its registration in a patch');
-    outro('Init complete');
-}
-/**
- * Scaffolds the default tokens CSS file under the engine and registers
- * its path in `fireforge.json`'s `patchLint.rawColorAllowlist`. Both
- * operations are skipped silently when the engine directory does not
- * yet exist (a fresh project that hasn't `fireforge download`ed yet).
- * The scaffold is re-driven on the next `furnace init --force`.
- *
- * Returns the scaffolded path when the file was actually created, so
- * the init command can surface it in the summary note.
- */
-async function scaffoldTokensCss(projectRoot) {
-    const paths = getProjectPaths(projectRoot);
-    if (!(await pathExists(paths.engine))) {
-        info('Skipping tokens CSS scaffold: engine/ not found. Run "fireforge download" followed by "fireforge furnace init --force" to scaffold it.');
-        return {};
-    }
-    let forgeConfig;
-    try {
-        forgeConfig = await loadConfig(projectRoot);
-    }
-    catch (error) {
-        warn(`Skipping tokens CSS scaffold: fireforge.json could not be loaded (${toError(error).message}). Re-run "fireforge furnace init --force" after fixing the config.`);
-        return {};
-    }
-    const tokensCssPath = getTokensCssPath(forgeConfig.binaryName);
-    const tokensCssAbsPath = join(paths.engine, tokensCssPath);
-    if (!(await pathExists(tokensCssAbsPath))) {
-        try {
-            await ensureDir(dirname(tokensCssAbsPath));
-            await writeText(tokensCssAbsPath, generateDefaultTokensCss(forgeConfig.binaryName, forgeConfig.license ?? DEFAULT_LICENSE));
-            success(`Scaffolded tokens CSS at engine/${tokensCssPath}`);
-        }
-        catch (error) {
-            warn(`Could not scaffold tokens CSS at engine/${tokensCssPath}: ${toError(error).message}. Create the file manually before running "fireforge token add".`);
-            return {};
-        }
-    }
-    else {
-        info(`Tokens CSS already present at engine/${tokensCssPath}; leaving it untouched.`);
-    }
-    // Registering the tokens file in `patchLint.rawColorAllowlist` is the
-    // complement to the scaffold itself: the file exists specifically to carry
-    // raw color literals, and without the allowlist entry the first
-    // `fireforge lint` after a `token add` fails on raw-color-value issues for
-    // tokens the operator just created. The add is idempotent, so re-running
-    // `furnace init --force` does not duplicate the entry.
-    // The edit seeds from the raw document under the config lock, like
-    // `fireforge config`: a validated round-trip would drop keys written with
-    // `config --force`, and an unlocked one could lose a concurrent write.
-    try {
-        const existingAllowlist = forgeConfig.patchLint?.rawColorAllowlist ?? [];
-        if (!existingAllowlist.includes(tokensCssPath)) {
-            await withConfigFileLock(projectRoot, async () => {
-                const raw = await loadRawConfigDocument(projectRoot);
-                const current = validateConfig(raw).patchLint?.rawColorAllowlist ?? [];
-                if (current.includes(tokensCssPath))
-                    return;
-                const updated = mutateConfig(raw, 'patchLint.rawColorAllowlist', [...current, tokensCssPath], true);
-                validateConfig(updated);
-                await writeConfigDocument(projectRoot, updated);
-            });
-            info(`Added ${tokensCssPath} to patchLint.rawColorAllowlist`);
-        }
-    }
-    catch (error) {
-        warn(`Could not register tokens CSS in patchLint.rawColorAllowlist: ${toError(error).message}. ` +
-            `Add "${tokensCssPath}" manually under patchLint.rawColorAllowlist in fireforge.json if lint flags its contents.`);
-    }
-    // Register the tokens CSS in browser/themes/shared/jar.inc.mn so the file
-    // is owned end-to-end by tooling. Scaffolding and allowlisting it without
-    // registering leaves the very next `fireforge status` correctly flagging
-    // it as unmanaged + unregistered while `furnace deploy --dry-run` reports
-    // nothing to deploy, a documented init command turning a clean project
-    // unclean. The CSS lives at the canonical
-    // `browser/themes/shared/<binaryName>-tokens.css` path the shared-CSS rule
-    // already targets, so it gets the same
-    // `skin/classic/browser/<name>.css (../shared/<name>.css)` entry as any
-    // other shared CSS. It is idempotent: `furnace init --force` against a
-    // registered tree is a no-op.
-    try {
-        const fileBase = `${forgeConfig.binaryName}-tokens.css`;
-        const result = await registerSharedCSS(paths.engine, fileBase, undefined, false);
-        if (!result.skipped) {
-            info(`Registered ${fileBase} in browser/themes/shared/jar.inc.mn`);
-        }
-    }
-    catch (error) {
-        warn(`Could not register tokens CSS in browser/themes/shared/jar.inc.mn: ${toError(error).message}. ` +
-            `Run "fireforge register browser/themes/shared/${forgeConfig.binaryName}-tokens.css" once jar.inc.mn is reachable.`);
-    }
-    return { tokensCssPath };
-}

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

@@ -1,8 +0,0 @@
-/**
- * Runs the furnace list command to display all registered components.
- * @param projectRoot - Root directory of the project
- * @param options - List options
- */
-export declare function furnaceListCommand(projectRoot: string, options?: {
-    verbose?: boolean;
-}): Promise<void>;