@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/commands/furnace/deploy-named.js

@@ -1,107 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Targeted `furnace deploy <name>...`: one or more named components applied
- * under ONE furnace lock hold.
- *
- * Deploying a set of widgets one invocation at a time put every call at the
- * back of the engine-lock queue, so a forty-widget deploy waited forty
- * times. Naming them together waits once. Each named component is still its
- * own atomic unit (applied, then its state persisted, before the next one
- * starts), exactly as a single-name deploy, so a failure or signal midway
- * leaves every earlier component committed and consistent.
- */
-import { applyAllComponents } from '../../core/furnace-apply.js';
-import { getPersistableAppliedEntry, persistSingleComponentState, shouldPersistSingleComponentState, } from '../../core/furnace-state-persist.js';
-import { FurnaceError } from '../../errors/furnace.js';
-import { mergeApplyResults, refreshStaleFragmentIncluders, } from './deploy-fragment-includers.js';
-/**
- * Splits the requested names into deployable and stock entries, refusing
- * the whole invocation before any write when one is unknown. Duplicates
- * are dropped, keeping the first occurrence.
- */
-function partitionDeployNames(names, config) {
-    const deployable = [];
-    const stock = [];
-    for (const name of new Set(names)) {
-        if (name in config.overrides || name in config.custom)
-            deployable.push(name);
-        else if (config.stock.includes(name))
-            stock.push(name);
-        else
-            throw new FurnaceError(`Component "${name}" not found in furnace.json.`, name);
-    }
-    return { deployable, stock };
-}
-/** Folds several includer refreshes into one, without repeating a tag. */
-function mergeIncluderRefreshes(refreshes, named) {
-    // A named component is reported as deployed in its own right, never as
-    // an includer some other named component refreshed on its behalf.
-    const refreshed = [...new Set(refreshes.flatMap((r) => r.refreshed))].filter((tag) => !named.has(tag));
-    return {
-        fragments: [...new Set(refreshes.flatMap((r) => r.fragments))].sort(),
-        refreshed,
-        failed: refreshes.flatMap((r) => r.failed).filter((f) => !named.has(f.tag)),
-        results: refreshes.flatMap((r) => r.results),
-    };
-}
-/**
- * Applies each named override or custom component through the same
- * pipeline as deploy-all (`applyAllComponents` with a `componentName`
- * filter), persisting each one's state right after it applies cleanly.
- * Only then are the other stale includers of the fragments the cleanly
- * applied components include refreshed, so an includer that is itself
- * named is applied once, as a named component.
- *
- * Must run inside one `runFurnaceMutation` so the whole set shares a single
- * lock hold.
- */
-export async function deployNamedComponents(args) {
-    const { projectRoot, names, config, furnacePaths, isDryRun, operationContext } = args;
-    const { deployable, stock } = partitionDeployNames(names, config);
-    if (deployable.length === 0)
-        return { kind: 'stock', stock };
-    const results = [];
-    const clean = [];
-    for (const name of deployable) {
-        const result = await applyAllComponents(projectRoot, isDryRun, {
-            componentName: name,
-            persistState: false,
-            operationContext,
-        });
-        results.push(result);
-        // Each named deploy is atomic: state is persisted only when every apply
-        // step succeeded, and any rollback has already restored the engine.
-        if (shouldPersistSingleComponentState(result, isDryRun)) {
-            await persistSingleComponentState(projectRoot, getPersistableAppliedEntry('Deploy', name, result.applied[0]), furnacePaths);
-            clean.push(name);
-        }
-        else if (isDryRun) {
-            clean.push(name);
-        }
-    }
-    // Other deployed includers of a fragment these components include would
-    // otherwise keep a stale expansion. Only after a clean, persisted apply
-    // (dry-run always previews).
-    const refreshes = [];
-    for (const name of clean) {
-        refreshes.push(await refreshStaleFragmentIncluders({
-            projectRoot,
-            name,
-            config,
-            furnacePaths,
-            isDryRun,
-            operationContext,
-        }));
-    }
-    const includers = mergeIncluderRefreshes(refreshes, new Set(deployable));
-    const [first, ...rest] = results;
-    // `deployable` is non-empty, so `first` is always set.
-    const primary = first;
-    return {
-        kind: 'result',
-        result: mergeApplyResults(primary, [...rest, ...includers.results]),
-        includers,
-        stock,
-        deployed: deployable,
-    };
-}

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

@@ -1,9 +0,0 @@
-import type { FurnaceDeployOptions } from '../../types/commands/index.js';
-/**
- * Runs the furnace deploy command: apply components then validate in one step.
- * @param projectRoot - Root directory of the project
- * @param names - Component name(s) to deploy, all under one lock hold
- *   (deploys all when omitted or empty)
- * @param options - Command options
- */
-export declare function furnaceDeployCommand(projectRoot: string, names?: string | readonly string[], options?: FurnaceDeployOptions): Promise<void>;

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

@@ -1,218 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { loadConfig } from '../../core/config.js';
-import { applyAllComponents } from '../../core/furnace-apply.js';
-import { formatSkipBreakdown, logApplyResult } from '../../core/furnace-apply-output.js';
-import { getFurnacePaths } from '../../core/furnace-config.js';
-import { reportJsconfigPathsSync } from '../../core/furnace-jsconfig.js';
-import { runFurnaceMutation, waitLockMutationOptions } from '../../core/furnace-operation.js';
-import { assertFurnaceReady } from '../../core/furnace-precondition.js';
-import { getStepFailureCount } from '../../core/furnace-state-persist.js';
-import { hasBlockingStepErrors } from '../../core/furnace-step-errors.js';
-import { findOverrideBaseVersionDrift, formatOverrideBaseVersionDriftError, formatOverrideBaseVersionDriftWarning, } from '../../core/furnace-version-drift.js';
-import { FurnaceError } from '../../errors/furnace.js';
-import { info, intro, note, notice, outro, spinner, warn } from '../../utils/logger.js';
-import { formatFragmentIncluderNotice } from './deploy-fragment-includers.js';
-import { deployNamedComponents } from './deploy-named.js';
-import { runDeployValidation } from './validation-output.js';
-/**
- * Builds the final deploy failure summary from apply and validation error counts.
- * @param applyErrors - Number of component application failures
- * @param validationErrors - Number of validation failures
- * @param isDryRun - Whether deploy was running in dry-run mode
- * @returns User-facing deploy summary message
- */
-function buildDeployFailureMessage(applyErrors, validationErrors, isDryRun) {
-    const mode = isDryRun ? 'Dry run' : 'Deploy';
-    if (applyErrors > 0 && validationErrors > 0) {
-        return `${mode} completed with ${applyErrors} apply error(s) and ${validationErrors} validation error(s).`;
-    }
-    if (applyErrors > 0) {
-        return `${mode} completed with ${applyErrors} apply error(s).`;
-    }
-    return `${mode} completed with ${validationErrors} validation error(s).`;
-}
-function getFailedComponentNames(result) {
-    const failed = new Set(result.errors.map((entry) => entry.name));
-    for (const applied of result.applied) {
-        if (hasBlockingStepErrors(applied)) {
-            failed.add(applied.name);
-        }
-    }
-    return failed;
-}
-/**
- * Prints the deploy summary after apply and validation complete.
- * @param result - Aggregate apply result
- * @param totalErrors - Total validation errors encountered
- * @param totalWarnings - Total validation warnings encountered
- * @param componentCount - Number of components considered during deploy
- * @param skippedValidationCount - Number of components skipped from validation
- * @param isDryRun - Whether deploy was running in dry-run mode
- */
-function printDeploymentSummary(result, totalErrors, totalWarnings, componentCount, skippedValidationCount, isDryRun) {
-    const appliedCount = result.applied.length;
-    const skippedCount = result.skipped.length;
-    const applyErrors = result.errors.length + getStepFailureCount(result);
-    const stepErrorCount = result.applied.reduce((sum, a) => sum + (a.stepErrors?.length ?? 0), 0);
-    if (isDryRun) {
-        note(`Would apply ${appliedCount} component(s)\n` +
-            `${result.actions?.length ?? 0} planned action(s)\n` +
-            `${applyErrors} apply error(s)\n` +
-            `${totalErrors} validation error(s), ${totalWarnings} validation warning(s) across ${componentCount} validated component(s)\n` +
-            '(validation ran against current source files — no engine files were modified)' +
-            (skippedValidationCount > 0
-                ? `\nSkipped validation for ${skippedValidationCount} component(s) with apply errors`
-                : ''), 'Dry Run Summary');
-    }
-    else {
-        note(`Applied ${appliedCount}, skipped ${skippedCount}${formatSkipBreakdown(result.skipped)}\n` +
-            `${applyErrors} apply error(s)` +
-            (stepErrorCount > 0 ? `, ${stepErrorCount} registration step error(s)` : '') +
-            `\n` +
-            `${totalErrors} validation error(s), ${totalWarnings} validation warning(s) across ${componentCount} validated component(s)` +
-            (skippedValidationCount > 0
-                ? `\nSkipped validation for ${skippedValidationCount} component(s) with apply errors`
-                : ''), 'Deploy Summary');
-    }
-    const totalProblems = applyErrors + totalErrors;
-    if (totalProblems > 0) {
-        throw new FurnaceError(buildDeployFailureMessage(applyErrors, totalErrors, isDryRun));
-    }
-    outro(isDryRun ? 'Dry run complete (no files modified)' : 'Deploy complete');
-}
-function enforceScopedOverrideVersionDriftPreflight(scopedDrift, force) {
-    for (const entry of scopedDrift) {
-        warn(formatOverrideBaseVersionDriftWarning(entry));
-    }
-    if (!force && scopedDrift.length > 0) {
-        throw new FurnaceError(formatOverrideBaseVersionDriftError(scopedDrift));
-    }
-}
-/**
- * Normalises the positional argument: a single name (programmatic callers)
- * or the variadic list commander passes. An empty list means "deploy all".
- */
-function normalizeDeployNames(names) {
-    if (names === undefined)
-        return [];
-    return typeof names === 'string' ? [names] : [...names];
-}
-/**
- * Runs the furnace deploy command: apply components then validate in one step.
- * @param projectRoot - Root directory of the project
- * @param names - Component name(s) to deploy, all under one lock hold
- *   (deploys all when omitted or empty)
- * @param options - Command options
- */
-export async function furnaceDeployCommand(projectRoot, names, options = {}) {
-    const isDryRun = options.dryRun ?? false;
-    const requested = normalizeDeployNames(names);
-    intro(isDryRun ? 'Furnace Deploy (dry run)' : 'Furnace Deploy');
-    const { config } = await assertFurnaceReady(projectRoot);
-    const furnacePaths = getFurnacePaths(projectRoot);
-    const overrideCount = Object.keys(config.overrides).length;
-    const customCount = Object.keys(config.custom).length;
-    if (overrideCount === 0 && customCount === 0) {
-        info('No components to deploy.');
-        outro('Done');
-        return;
-    }
-    // Refuse real mutation when the targeted overrides were created against a
-    // different Firefox version. Dry-run still proceeds so operators can inspect
-    // the plan before deciding whether to refresh the override or acknowledge
-    // the new baseline in furnace.json.
-    const forgeConfig = await loadConfig(projectRoot);
-    const driftEntries = findOverrideBaseVersionDrift(config, forgeConfig.firefox.version);
-    const force = options.force ?? false;
-    const scopedDrift = requested.length > 0
-        ? driftEntries.filter((entry) => requested.includes(entry.name))
-        : driftEntries;
-    enforceScopedOverrideVersionDriftPreflight(scopedDrift, force);
-    // --- Step 1: Apply ---
-    const applySpinner = spinner(isDryRun ? 'Calculating planned actions...' : 'Applying components to engine...');
-    // The apply phase is lock-protected and registered with the global
-    // SIGINT/SIGTERM rollback pathway via runFurnaceMutation. The validation
-    // phase below is read-only and runs outside the lock so two concurrent
-    // `furnace deploy` runs only contend on the actual mutation.
-    const applyOutcome = await runFurnaceMutation(projectRoot, 'deploy-rollback', async (ctx) => {
-        if (requested.length > 0) {
-            return deployNamedComponents({
-                projectRoot,
-                names: requested,
-                config,
-                furnacePaths,
-                isDryRun,
-                operationContext: ctx,
-            });
-        }
-        const allResult = await applyAllComponents(projectRoot, isDryRun, {
-            operationContext: ctx,
-        });
-        return { kind: 'all', result: allResult };
-    }, { dryRun: isDryRun, ...waitLockMutationOptions(options.waitLockSeconds) });
-    const warnStock = () => {
-        for (const stockName of applyOutcome.kind === 'all' ? [] : applyOutcome.stock) {
-            warn(`"${stockName}" is a stock component. Stock components are not applied locally.`);
-        }
-    };
-    if (applyOutcome.kind === 'stock') {
-        applySpinner.stop('Apply skipped');
-        warnStock();
-        outro(isDryRun ? 'Dry run complete (no files modified)' : 'Deploy complete');
-        return;
-    }
-    const result = applyOutcome.result;
-    applySpinner.stop(isDryRun ? 'Planned actions calculated' : 'Components applied');
-    warnStock();
-    logApplyResult(result, isDryRun);
-    if (applyOutcome.kind === 'result') {
-        for (const line of formatFragmentIncluderNotice(applyOutcome.includers, isDryRun)) {
-            notice(line);
-        }
-    }
-    // Keep the consumer jsconfig's chrome-module `paths` in step with the
-    // deployed module set. Only after a clean apply: a rolled-back deploy
-    // must not advance the typecheck mapping either.
-    if (result.errors.length === 0 && getStepFailureCount(result) === 0) {
-        await reportJsconfigPathsSync(projectRoot, config, isDryRun);
-    }
-    // --- Step 2: Validate (read-only, runs even in dry-run to show what would fail) ---
-    if (options.skipValidate) {
-        const applyErrors = result.errors.length + getStepFailureCount(result);
-        if (applyErrors > 0)
-            throw new FurnaceError(buildDeployFailureMessage(applyErrors, 0, isDryRun));
-        outro(isDryRun ? 'Dry run complete (validation skipped)' : 'Deploy complete (validation skipped)');
-        return;
-    }
-    const validateSpinner = spinner(isDryRun ? 'Validating (read-only)...' : 'Validating...');
-    const failedComponents = getFailedComponentNames(result);
-    // A named deploy validates every named component that applied, then the
-    // includers it refreshed. The first clean name leads (the validation
-    // runner skips the whole named branch when its lead failed), and every
-    // failed name is counted as skipped.
-    const deployed = applyOutcome.kind === 'result' ? applyOutcome.deployed : [];
-    const failedNamed = deployed.filter((tag) => failedComponents.has(tag));
-    const lead = deployed.find((tag) => !failedComponents.has(tag)) ?? deployed[0];
-    const validation = await runDeployValidation({
-        validateSpinner,
-        name: lead,
-        config,
-        furnacePaths,
-        failedComponents,
-        isDryRun,
-        projectRoot,
-        dryRunActions: result.actions,
-        alsoValidate: applyOutcome.kind === 'result'
-            ? [...deployed.filter((tag) => tag !== lead), ...applyOutcome.includers.refreshed]
-            : [],
-    });
-    if (validation.done)
-        return;
-    const { totalErrors, totalWarnings, componentCount } = validation;
-    // The runner counts a failed lead itself; failed extras it drops silently.
-    const skippedValidationCount = lead !== undefined && failedComponents.has(lead)
-        ? failedNamed.length
-        : validation.skippedValidationCount + failedNamed.length;
-    // --- Step 3: Summary ---
-    printDeploymentSummary(result, totalErrors, totalWarnings, componentCount, skippedValidationCount, isDryRun);
-}

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

@@ -1,11 +0,0 @@
-/**
- * Runs the furnace diff command.
- *
- * For overrides: shows changes vs the Firefox original at baseCommit.
- * For custom components: shows workspace vs engine-deployed copy.
- * When no name is provided, diffs all override and custom components.
- *
- * @param projectRoot - Root directory of the project
- * @param name - Optional component name to diff (diffs all when omitted)
- */
-export declare function furnaceDiffCommand(projectRoot: string, name?: string): Promise<void>;

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

@@ -1,238 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { getProjectPaths, loadState } from '../../core/config.js';
-import { diffLines, renderHunks } from '../../core/diff-hunks.js';
-import { getOverrideEngineTargetPath } from '../../core/furnace-apply-helpers.js';
-import { normalizeForChecksum } from '../../core/furnace-checksum-utils.js';
-import { composeComponentSource } from '../../core/furnace-composed-source.js';
-import { getFurnacePaths, loadFurnaceConfig } from '../../core/furnace-config.js';
-import { isComponentSourceFile, resolveFtlDir } from '../../core/furnace-constants.js';
-import { getFileContentAtRef } from '../../core/git-file-ops.js';
-import { FurnaceError } from '../../errors/furnace.js';
-import { toError } from '../../utils/errors.js';
-import { pathExists, readText } from '../../utils/fs.js';
-import { formatErrorText, formatSuccessText, info, intro, outro } from '../../utils/logger.js';
-import { normalizePathSlashes } from '../../utils/paths.js';
-/**
- * Renders a multi-hunk unified diff between the two strings and returns a
- * flat list of display-ready lines. Each line has already had its marker
- * prefix and color applied by this function. The caller just emits them.
- *
- * Pure delegation to the `diff-hunks` module, kept here as a thin wrapper
- * so the command file does not need to care about the hunk data shape.
- */
-function formatUnifiedDiff(original, modified) {
-    const hunks = diffLines(original, modified, 3);
-    return renderHunks(hunks).map((line) => {
-        switch (line.kind) {
-            case 'removed':
-                return formatErrorText(line.text);
-            case 'added':
-                return formatSuccessText(line.text);
-            default:
-                return line.text;
-        }
-    });
-}
-/**
- * Diffs an override component against its Firefox baseline at baseCommit.
- */
-async function diffOverride(name, projectRoot, config) {
-    const overrideConfig = config.overrides[name];
-    if (!overrideConfig) {
-        throw new FurnaceError(`Override "${name}" not found in furnace.json.`, name);
-    }
-    const paths = getProjectPaths(projectRoot);
-    const furnacePaths = getFurnacePaths(projectRoot);
-    const ftlDir = resolveFtlDir(config.ftlBasePath);
-    const overrideDir = join(furnacePaths.overridesDir, name);
-    if (!(await pathExists(overrideDir))) {
-        throw new FurnaceError(`Override directory not found: components/overrides/${name}`, name);
-    }
-    // Prefer the per-override baseCommit (survives download --force). Fall back
-    // to the project-wide value for overrides created before this field existed.
-    const state = await loadState(projectRoot);
-    const baseCommit = overrideConfig.baseCommit ?? state.baseCommit;
-    if (!baseCommit) {
-        throw new FurnaceError(`Cannot diff "${name}": baseCommit not recorded for this override. ` +
-            `Run "fireforge furnace refresh --reset-base ${name}" to stamp the current engine HEAD as the baseline, ` +
-            `or re-run "fireforge download" to re-establish a project-wide baseline.`, name);
-    }
-    const entries = await readdir(overrideDir, { withFileTypes: true });
-    let hasDifferences = false;
-    for (const entry of entries) {
-        if (!entry.isFile())
-            continue;
-        if (!isComponentSourceFile(entry.name))
-            continue;
-        // git show takes a repo-relative path. paths.engine is the repo root.
-        // The slice leaves the host's separators behind, and `git show <ref>:<path>`
-        // only understands forward slashes. On Windows the unnormalized form makes
-        // every baseline read miss, so every overridden file is reported as a new
-        // file and `furnace diff` shows nothing.
-        const enginePath = normalizePathSlashes(getOverrideEngineTargetPath(paths.engine, overrideConfig, entry.name, ftlDir).slice(paths.engine.length + 1));
-        const modifiedPath = join(overrideDir, entry.name);
-        const baselineDisplayPath = enginePath;
-        let originalContent;
-        try {
-            originalContent = await getFileContentAtRef(paths.engine, enginePath, baseCommit);
-        }
-        catch (error) {
-            throw new FurnaceError(`Cannot read baseline for "${entry.name}" at commit ${baseCommit.slice(0, 8)}: ` +
-                `${toError(error).message}. ` +
-                `The commit may no longer exist in the engine history (e.g. after a re-download). ` +
-                `Run "fireforge furnace refresh --reset-base ${name}" to establish a new baseline.`, name);
-        }
-        if (originalContent === null) {
-            info(`${entry.name}: original not found in engine (new file)`);
-            hasDifferences = true;
-            continue;
-        }
-        const modifiedContent = await readText(modifiedPath);
-        if (originalContent === modifiedContent) {
-            continue;
-        }
-        hasDifferences = true;
-        info(`--- ${baselineDisplayPath}`);
-        info(`+++ components/overrides/${name}/${entry.name}`);
-        for (const line of formatUnifiedDiff(originalContent, modifiedContent)) {
-            info(line);
-        }
-        info('');
-    }
-    if (!hasDifferences) {
-        info('No modifications found');
-    }
-}
-/**
- * Diffs a custom component's workspace files against the engine-deployed
- * copy. Shows what would change (or has changed) on the next
- * `furnace apply`.
- *
- * The workspace side is the Furnace-composed source: a stylesheet with
- * `@fireforge-include` directives is compared in its fragment-expanded
- * form, exactly as apply deploys it. Comparing the raw source instead
- * reported every freshly deployed fragment includer as a large difference
- * (the inlined fragment bodies and end markers), so the diff could not show
- * whether a deploy would change anything. Line endings and a BOM are
- * ignored, as apply's own drift check ignores them.
- *
- * `.ftl` files deploy to `engine/<ftlDir>/<name>.ftl` via
- * `applyCustomFtlFile`, not to `customConfig.targetPath`, so the
- * deployment-target lookup has to branch on extension. Without the branch, a
- * component's localization file always reports "not yet deployed to engine
- * (new file)" after a successful apply, because diff looks for it under the
- * component's `targetPath` while apply wrote it into the locale tree.
- */
-async function diffCustom(name, projectRoot, config) {
-    const customConfig = config.custom[name];
-    if (!customConfig) {
-        throw new FurnaceError(`Custom component "${name}" not found in furnace.json.`, name);
-    }
-    const paths = getProjectPaths(projectRoot);
-    const furnacePaths = getFurnacePaths(projectRoot);
-    const ftlDir = resolveFtlDir(config.ftlBasePath);
-    const customDir = join(furnacePaths.customDir, name);
-    if (!(await pathExists(customDir))) {
-        throw new FurnaceError(`Custom component directory not found: components/custom/${name}`, name);
-    }
-    const engineDir = join(paths.engine, customConfig.targetPath);
-    const entries = await readdir(customDir, { withFileTypes: true });
-    let hasDifferences = false;
-    for (const entry of entries) {
-        if (!entry.isFile())
-            continue;
-        if (!isComponentSourceFile(entry.name))
-            continue;
-        const workspacePath = join(customDir, entry.name);
-        const rawWorkspace = await readText(workspacePath);
-        let workspaceContent = rawWorkspace;
-        let composedNote = '';
-        try {
-            workspaceContent = await composeComponentSource(rawWorkspace, entry.name, furnacePaths.sharedDir);
-            if (workspaceContent !== rawWorkspace)
-                composedNote = ' (composed: fragments expanded)';
-        }
-        catch (error) {
-            // A missing fragment: no composed form exists, so show the raw
-            // source and say why; `furnace validate` reports the fragment itself.
-            composedNote = ` (raw: ${toError(error).message})`;
-        }
-        // `.ftl` files deploy to the locale tree, not the component's
-        // targetPath. Mirror `applyCustomFtlFile`'s target computation so the
-        // diff header and the existence probe name the same path apply
-        // writes to. Any change here must stay in lock-step with
-        // `src/core/furnace-apply-ftl.ts`.
-        const isFtl = entry.name.endsWith('.ftl');
-        const deployedPath = isFtl
-            ? join(paths.engine, ftlDir, entry.name)
-            : join(engineDir, entry.name);
-        const deployedDisplayPath = isFtl
-            ? `engine/${ftlDir}/${entry.name}`
-            : `engine/${customConfig.targetPath}/${entry.name}`;
-        if (!(await pathExists(deployedPath))) {
-            info(`${entry.name}: not yet deployed to engine (new file)`);
-            hasDifferences = true;
-            continue;
-        }
-        const deployedContent = normalizeForChecksum(await readText(deployedPath));
-        workspaceContent = normalizeForChecksum(workspaceContent);
-        if (workspaceContent === deployedContent) {
-            continue;
-        }
-        hasDifferences = true;
-        info(`--- ${deployedDisplayPath}`);
-        info(`+++ components/custom/${name}/${entry.name}${composedNote}`);
-        for (const line of formatUnifiedDiff(deployedContent, workspaceContent)) {
-            info(line);
-        }
-        info('');
-    }
-    if (!hasDifferences) {
-        info('No differences between workspace and engine');
-    }
-}
-/**
- * Runs the furnace diff command.
- *
- * For overrides: shows changes vs the Firefox original at baseCommit.
- * For custom components: shows workspace vs engine-deployed copy.
- * When no name is provided, diffs all override and custom components.
- *
- * @param projectRoot - Root directory of the project
- * @param name - Optional component name to diff (diffs all when omitted)
- */
-export async function furnaceDiffCommand(projectRoot, name) {
-    intro('Furnace Diff');
-    const config = await loadFurnaceConfig(projectRoot);
-    if (name) {
-        if (name in config.overrides) {
-            await diffOverride(name, projectRoot, config);
-        }
-        else if (name in config.custom) {
-            await diffCustom(name, projectRoot, config);
-        }
-        else {
-            throw new FurnaceError(`"${name}" is not found in furnace.json. Run "fireforge furnace list" to see registered components.`, name);
-        }
-    }
-    else {
-        const overrideNames = Object.keys(config.overrides);
-        const customNames = Object.keys(config.custom);
-        if (overrideNames.length === 0 && customNames.length === 0) {
-            info('No components to diff.');
-            outro('Diff complete');
-            return;
-        }
-        for (const overrideName of overrideNames) {
-            info(`\n── ${overrideName} (override) ──`);
-            await diffOverride(overrideName, projectRoot, config);
-        }
-        for (const customName of customNames) {
-            info(`\n── ${customName} (custom) ──`);
-            await diffCustom(customName, projectRoot, config);
-        }
-    }
-    outro('Diff complete');
-}

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-/** Registers the furnace command on the CLI program. */
-export declare function registerFurnace(program: Command, context: CommandContext): void;