@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/export-staged-registration.js

@@ -1,91 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Lets `export --order` land a new system module whose moz.build line is
- * still unexported working-tree drift in the patch that registers it.
- *
- * Without this the two refusals deadlock: the module's export fails
- * `unregistered-system-module` because no patch body carries its moz.build
- * line yet, and the registering patch cannot be re-exported first because
- * its line names a file no patch creates. The way through is
- * declared intent plus evidence: when the registering patch carries a
- * staged registration for the module and the working tree's moz.build has
- * exactly that line, the export is accepted and the operator is told to
- * re-export the registering patch next. Without the declaration the
- * refusal names the steps, with the exact `patch staged-dependency`
- * command, instead of stopping at "register it".
- *
- * Consumed by export-flow.ts.
- */
-import { basename, dirname, join } from 'node:path';
-import { STAGED_DEPENDENCY_REASON_PLACEHOLDER } from '../core/patch-lint-staged-registration.js';
-import { pathExists, readText } from '../utils/fs.js';
-async function readLines(path) {
-    if (!(await pathExists(path)))
-        return undefined;
-    return (await readText(path)).split('\n').map((line) => line.trim());
-}
-/** The nearest moz.build at or above `modulePath` whose lines name `leaf` quoted. */
-async function findTreeRegistration(engineDir, modulePath) {
-    const leaf = basename(modulePath);
-    let dir = dirname(modulePath);
-    for (;;) {
-        const file = dir === '.' ? 'moz.build' : `${dir}/moz.build`;
-        const line = (await readLines(join(engineDir, file)))?.find((candidate) => candidate.includes(`"${leaf}"`) || candidate.includes(`'${leaf}'`));
-        if (line !== undefined)
-            return { file, line };
-        if (dir === '.' || dir === '')
-            return undefined;
-        const parent = dirname(dir);
-        dir = parent === dir ? '.' : parent;
-    }
-}
-/**
- * Removes `unregistered-system-module` findings for modules the pending
- * export creates when a queue patch declares their registration as a
- * staged dependency and the working tree's moz.build carries that line.
- * For a module whose line is in the tree but undeclared, returns the steps
- * that make it acceptable.
- *
- * @param args - The engine directory (the working tree), the current queue,
- *   the filename the pending export would take, the files it creates, and
- *   the placement projection's error findings
- */
-export async function acceptTreeRegisteredModules(args) {
-    const outcome = { remaining: [], accepted: [], advice: [] };
-    for (const issue of args.projectedIssues) {
-        if (issue.check !== 'unregistered-system-module' || !args.pendingNewFiles.has(issue.file)) {
-            outcome.remaining.push(issue);
-            continue;
-        }
-        const declared = args.baseCtx.entries.flatMap((entry) => (entry.metadata?.stagedDependencies?.registrations ?? [])
-            .filter((registration) => registration.creates === issue.file &&
-            (registration.owner === undefined || registration.owner === args.newFilename))
-            .map((registration) => ({ holder: entry.filename, registration })));
-        let accepted = false;
-        for (const { holder, registration } of declared) {
-            const lines = await readLines(join(args.engineDir, registration.file));
-            if (lines?.includes(registration.line.trim()) !== true)
-                continue;
-            outcome.accepted.push(`${issue.file} is registered by the working tree's ${registration.file} ` +
-                `("${registration.line.trim()}"), which ${holder} declares as a staged registration ` +
-                `but has not exported yet. Re-export ${holder} right after this export to land the ` +
-                `line: fireforge re-export ${holder}`);
-            accepted = true;
-            break;
-        }
-        if (accepted)
-            continue;
-        outcome.remaining.push(issue);
-        const tree = await findTreeRegistration(args.engineDir, issue.file);
-        if (tree === undefined)
-            continue;
-        const owner = args.baseCtx.entries.find((entry) => entry.metadata?.filesAffected.includes(tree.file))?.filename;
-        if (owner === undefined)
-            continue;
-        outcome.advice.push('', `${issue.file} is registered in the working tree's ${tree.file}, but ${owner} has not ` +
-            'exported that line. Land both without untangling the tree:', `  1. fireforge patch staged-dependency ${owner} --add --kind registration --file ${tree.file} ` +
-            `--line "${tree.line.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}" --creates ${issue.file} ` +
-            `--owner ${args.newFilename} ${STAGED_DEPENDENCY_REASON_PLACEHOLDER}`, '  2. re-run this export (a declared registration present in the working tree is accepted)', `  3. fireforge re-export ${owner}`);
-    }
-    return outcome;
-}

package/dist/src/commands/export.d.ts

@@ -1,13 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-import type { ExportOptions } from '../types/commands/index.js';
-/**
- * Runs the export command to export file changes as a patch.
- * Accepts one or more file/directory paths and bundles them into a single patch.
- * @param projectRoot - Root directory of the project
- * @param files - File or directory paths to export (relative to engine/)
- * @param options - Export options
- */
-export declare function exportCommand(projectRoot: string, files: string[], options: ExportOptions): Promise<void>;
-/** Registers the export command on the CLI program. */
-export declare function registerExport(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/forward-import-remedy.d.ts

@@ -1,31 +0,0 @@
-/**
- * The remedy printed under a forward-import refusal from `re-export`
- * (plain refresh and `--scan` adoption alike): the earliest order the files
- * can take as their own later patch, and the exact `patch staged-dependency
- * --add` commands that declare the edges instead.
- *
- * Both the order number and every flag of the declaration are spelled out,
- * so the operator does not have to work them out from the finding text.
- */
-import type { PatchesManifest, PatchLintIssue } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
-/** Inputs to {@link formatForwardImportRemedy}. */
-export interface ForwardImportRemedyInput {
-    /** What to do after the fix, e.g. "re-running the scan". */
-    reRunHint: string;
-    /** The refusal's findings; only `forward-import` and `forward-registration` ones are read. */
-    issues: readonly PatchLintIssue[];
-    /** Current manifest (null when unavailable: the order is then not named). */
-    manifest: PatchesManifest | null;
-    /** Project config; only `patchPolicy` is read. */
-    config?: Pick<FireForgeConfig, 'patchPolicy'>;
-    /** Category the files would be exported under (the refused patch's). */
-    category?: string;
-}
-/**
- * Renders the remedy lines. Falls back to the generic sentence when the
- * findings carry no structured declarations.
- *
- * @param input - See {@link ForwardImportRemedyInput}
- */
-export declare function formatForwardImportRemedy(input: ForwardImportRemedyInput): string;

package/dist/src/commands/forward-import-remedy.js

@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The remedy printed under a forward-import refusal from `re-export`
- * (plain refresh and `--scan` adoption alike): the earliest order the files
- * can take as their own later patch, and the exact `patch staged-dependency
- * --add` commands that declare the edges instead.
- *
- * Both the order number and every flag of the declaration are spelled out,
- * so the operator does not have to work them out from the finding text.
- */
-import { STAGED_DEPENDENCY_REASON_PLACEHOLDER } from '../core/patch-lint-staged-registration.js';
-import { earliestLegalOrderAfter } from '../core/patch-order-legal.js';
-import { formatPatchOrder } from '../core/patch-parse.js';
-function quoteArg(value) {
-    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
-}
-function declarationCommand(declaration) {
-    const anchor = declaration.kind === 'import'
-        ? `--specifier ${quoteArg(declaration.specifier ?? '')}`
-        : `--kind registration --line ${quoteArg(declaration.line ?? '')}`;
-    return (`fireforge patch staged-dependency ${declaration.patch} --add --file ${declaration.file} ` +
-        `${anchor} --creates ${declaration.creates} --owner ${declaration.owner} ` +
-        STAGED_DEPENDENCY_REASON_PLACEHOLDER);
-}
-/**
- * Renders the remedy lines. Falls back to the generic sentence when the
- * findings carry no structured declarations.
- *
- * @param input - See {@link ForwardImportRemedyInput}
- */
-export function formatForwardImportRemedy(input) {
-    const declarations = input.issues
-        .filter((issue) => issue.check === 'forward-import' || issue.check === 'forward-registration')
-        .flatMap((issue) => issue.stagedDeclarations ?? []);
-    const ownerOrders = declarations
-        .map((declaration) => input.manifest?.patches.find((patch) => patch.filename === declaration.owner)?.order)
-        .filter((order) => order !== undefined);
-    const latestOwner = ownerOrders.length > 0 ? Math.max(...ownerOrders) : undefined;
-    const legalOrder = latestOwner !== undefined && input.manifest !== null && input.category !== undefined
-        ? earliestLegalOrderAfter(input.config ?? {}, input.manifest, input.category, latestOwner)
-        : null;
-    const orderText = legalOrder !== null
-        ? `"fireforge export <files> --order ${formatPatchOrder(legalOrder)}"; ` +
-            `${formatPatchOrder(legalOrder)} is the earliest legal order after the latest creator ` +
-            `(${formatPatchOrder(latestOwner ?? legalOrder)})`
-        : '"fireforge export --order <n>"';
-    const lines = [
-        `Export those files as their own later patch (${orderText}; or ` +
-            '"fireforge patch split --order <n>"), or declare the intentional dependency with ' +
-            `"fireforge patch staged-dependency --add" before ${input.reRunHint}` +
-            (declarations.length > 0 ? ':' : '.'),
-    ];
-    const seen = new Set();
-    for (const declaration of declarations) {
-        const command = declarationCommand(declaration);
-        if (seen.has(command))
-            continue;
-        seen.add(command);
-        lines.push(`  ${command}`);
-    }
-    return lines.join('\n');
-}

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

@@ -1,8 +0,0 @@
-import type { FurnaceApplyOptions } from '../../types/commands/index.js';
-/**
- * Runs the furnace apply command to apply components to the engine.
- * @param projectRoot - Root directory of the project
- * @param name - Optional component name to apply a single component
- * @param options - Apply options
- */
-export declare function furnaceApplyCommand(projectRoot: string, name?: string, options?: FurnaceApplyOptions): Promise<void>;

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

@@ -1,327 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { watch as fsWatch } from 'node:fs';
-import { loadConfig } from '../../core/config.js';
-import { applyAllComponents, computeComponentChecksums } from '../../core/furnace-apply.js';
-import { formatSkipBreakdown, logApplyResult } from '../../core/furnace-apply-output.js';
-import { getFurnacePaths } from '../../core/furnace-config.js';
-import { isComponentSourceFile } from '../../core/furnace-constants.js';
-import { runFurnaceMutation, waitLockMutationOptions } from '../../core/furnace-operation.js';
-import { assertFurnaceReady } from '../../core/furnace-precondition.js';
-import { getPersistableAppliedEntry, persistSingleComponentState, shouldPersistSingleComponentState, } from '../../core/furnace-state-persist.js';
-import { countEntriesWithBlockingStepErrors } from '../../core/furnace-step-errors.js';
-import { findOverrideBaseVersionDrift, formatOverrideBaseVersionDriftError, formatOverrideBaseVersionDriftWarning, } from '../../core/furnace-version-drift.js';
-import { FurnaceError } from '../../errors/furnace.js';
-import { getNodeErrorCode, toError } from '../../utils/errors.js';
-import { pathExists } from '../../utils/fs.js';
-import { info, intro, outro, spinner, warn } from '../../utils/logger.js';
-/** Interval (ms) for the periodic checksum poll that catches events missed by fs.watch. */
-const WATCH_POLL_INTERVAL_MS = 30_000;
-/**
- * Collects a combined checksum snapshot across all watched directories.
- */
-async function snapshotWatchedChecksums(watchDirs) {
-    const combined = new Map();
-    for (const dir of watchDirs) {
-        try {
-            const checksums = await computeComponentChecksums(dir);
-            for (const [file, hash] of Object.entries(checksums)) {
-                combined.set(`${dir}/${file}`, hash);
-            }
-        }
-        catch {
-            // Directory may have been removed between iterations, so ignore.
-        }
-    }
-    return combined;
-}
-function checksumMapsEqual(a, b) {
-    if (a.size !== b.size)
-        return false;
-    for (const [key, value] of a) {
-        if (b.get(key) !== value)
-            return false;
-    }
-    return true;
-}
-/**
- * Builds a watch-loop apply-failure message tailored to the error class so
- * transient filesystem errors (EACCES, ENOSPC, lock timeout) look different
- * from genuine apply-level failures. The previous generic "Apply failed: ..."
- * collapsed all causes into one string and made diagnosis difficult.
- */
-function classifyWatchApplyError(err) {
-    const message = toError(err).message;
-    if (err instanceof FurnaceError) {
-        return `Apply failed: ${message}`;
-    }
-    const code = getNodeErrorCode(err);
-    switch (code) {
-        case 'EACCES':
-        case 'EPERM':
-            return `Apply failed: permission denied — ${message}`;
-        case 'ENOSPC':
-            return `Apply failed: disk full — ${message}`;
-        case 'EBUSY':
-        case 'ETXTBSY':
-            return `Apply failed: file is in use — ${message}`;
-        case 'ENOENT':
-            return `Apply failed: missing file — ${message}`;
-        case 'ETIMEDOUT':
-            return `Apply failed: operation timed out — ${message}`;
-        default:
-            return `Apply failed: ${message}`;
-    }
-}
-async function runWatchLoop(projectRoot) {
-    const furnacePaths = getFurnacePaths(projectRoot);
-    // Both categories are eligible targets. The set is fixed. Only existence
-    // varies over time: a component dir created after watch started (the user
-    // running `furnace create` in another terminal) must be picked up without
-    // restarting watch. A one-shot `pathExists` check at startup captures only
-    // the dirs that existed then, leaving any later creation invisible.
-    const candidateDirs = [furnacePaths.overridesDir, furnacePaths.customDir];
-    const watchDirs = [];
-    const watchers = new Map();
-    if (process.platform === 'linux') {
-        warn('Watch mode uses fs.watch with recursive: true, which may miss changes ' +
-            'in deeply nested directories on Linux. A periodic poll runs every 30s as a fallback.');
-    }
-    let debounceTimer = null;
-    let applyInFlight = false;
-    // Coalesces changes that arrive while an apply is running. Without this
-    // flag, a second edit during an in-flight apply is debounced, the timer
-    // fires while applyInFlight is true, and the change is dropped entirely
-    // because the post-apply checksum snapshot already reflects the edit so
-    // the 30s poll also sees no diff.
-    let pendingChange = false;
-    let retryNeeded = false;
-    let lastChecksums = new Map();
-    let pollTimer = null;
-    const runApplyCycle = async () => {
-        applyInFlight = true;
-        try {
-            info('\nChange detected — re-applying...');
-            const result = await runFurnaceMutation(projectRoot, 'apply-rollback', (ctx) => applyAllComponents(projectRoot, false, { operationContext: ctx }));
-            logApplyResult(result, false);
-            if (result.errors.length > 0 || countEntriesWithBlockingStepErrors(result.applied) > 0) {
-                throw new FurnaceError('Watch apply did not complete; retrying on the next poll.');
-            }
-            const applied = result.applied.length;
-            const skipped = result.skipped.length;
-            info(`Re-applied: ${applied} applied, ${skipped} skipped${formatSkipBreakdown(result.skipped)}`);
-            retryNeeded = false;
-            lastChecksums = await snapshotWatchedChecksums(watchDirs);
-        }
-        catch (err) {
-            retryNeeded = true;
-            warn(classifyWatchApplyError(err));
-        }
-        finally {
-            applyInFlight = false;
-        }
-        // Another change arrived while we were applying, so run again and the
-        // edit is not silently absorbed into the post-apply checksum bump.
-        if (pendingChange) {
-            pendingChange = false;
-            await runApplyCycle();
-        }
-    };
-    const triggerApply = () => {
-        if (applyInFlight) {
-            // An apply is already running. Record the change so runApplyCycle
-            // re-runs after it completes. Do not schedule a new debounce: the
-            // in-flight apply will observe this flag when it finishes.
-            pendingChange = true;
-            return;
-        }
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => {
-            debounceTimer = null;
-            if (applyInFlight) {
-                // Race with a change that started its own apply between the debounce
-                // scheduling and the timer firing. Record the pending change. The
-                // in-flight apply will pick it up.
-                pendingChange = true;
-                return;
-            }
-            void runApplyCycle();
-        }, 300);
-    };
-    const installWatcher = (dir) => {
-        if (watchers.has(dir))
-            return false;
-        try {
-            const watcher = fsWatch(dir, { recursive: true }, (_event, filename) => {
-                if (!filename)
-                    return;
-                if (isComponentSourceFile(filename)) {
-                    triggerApply();
-                }
-            });
-            watcher.on('error', (err) => {
-                warn(`Watcher error on ${dir}: ${err.message}. Periodic poll will continue as fallback.`);
-            });
-            watchers.set(dir, watcher);
-            watchDirs.push(dir);
-            return true;
-        }
-        catch (err) {
-            // Directory vanished between the pathExists check and fs.watch, or
-            // fs.watch otherwise refused. refreshWatchers will retry on the next
-            // poll tick.
-            warn(`Could not start watcher on ${dir}: ${toError(err).message}`);
-            return false;
-        }
-    };
-    // Scans candidate dirs for ones we are not yet watching and installs a
-    // watcher for each that now exists. Returns true when at least one new
-    // watcher was installed so the caller can trigger an apply cycle for
-    // the just-noticed content.
-    const refreshWatchers = async () => {
-        let added = false;
-        for (const dir of candidateDirs) {
-            if (watchers.has(dir))
-                continue;
-            if (await pathExists(dir)) {
-                if (installWatcher(dir)) {
-                    info(`Now watching ${dir}`);
-                    added = true;
-                }
-            }
-        }
-        return added;
-    };
-    // Register signal-driven cleanup before creating watchers so there is no
-    // race window where a SIGINT could arrive after watchers exist but before
-    // cleanup handlers are registered.
-    const cleanup = () => {
-        for (const w of watchers.values())
-            w.close();
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        if (pollTimer)
-            clearInterval(pollTimer);
-    };
-    process.once('SIGINT', cleanup);
-    process.once('SIGTERM', cleanup);
-    await refreshWatchers();
-    lastChecksums = await snapshotWatchedChecksums(watchDirs);
-    if (watchDirs.length === 0) {
-        info('No component directories exist yet — will retry every 30s. Create one with "fireforge furnace override" or "fireforge furnace create" in another terminal to begin watching.');
-    }
-    else {
-        info(`Watching ${watchDirs.length} directory(ies) for changes... (Ctrl+C to stop)`);
-    }
-    // Periodic checksum-based poll that also picks up newly-created component
-    // dirs (fs.watch was not installed for them at startup because they did
-    // not yet exist).
-    pollTimer = setInterval(() => {
-        if (applyInFlight)
-            return;
-        void (async () => {
-            try {
-                const added = await refreshWatchers();
-                if (added) {
-                    lastChecksums = await snapshotWatchedChecksums(watchDirs);
-                    triggerApply();
-                    return;
-                }
-                const current = await snapshotWatchedChecksums(watchDirs);
-                // A failed apply remains dirty even if source checksums did not
-                // change. The polling interval bounds retries without a busy loop.
-                if (retryNeeded || !checksumMapsEqual(current, lastChecksums)) {
-                    triggerApply();
-                }
-            }
-            catch {
-                // Best effort: errors here are transient filesystem issues.
-            }
-        })();
-    }, WATCH_POLL_INTERVAL_MS);
-    // Block until signal. The cleanup function registered above closes all
-    // watchers when SIGINT/SIGTERM arrives. The finally block is a safety net
-    // in case the Promise settles through some other path.
-    try {
-        await new Promise(() => { });
-    }
-    finally {
-        cleanup();
-        process.removeListener('SIGINT', cleanup);
-        process.removeListener('SIGTERM', cleanup);
-    }
-}
-/**
- * Runs the furnace apply command to apply components to the engine.
- * @param projectRoot - Root directory of the project
- * @param name - Optional component name to apply a single component
- * @param options - Apply options
- */
-export async function furnaceApplyCommand(projectRoot, name, options = {}) {
-    intro(name ? `Furnace Apply (${name})` : 'Furnace Apply');
-    const { config } = await assertFurnaceReady(projectRoot);
-    const overrideCount = Object.keys(config.overrides).length;
-    const customCount = Object.keys(config.custom).length;
-    if (overrideCount === 0 && customCount === 0) {
-        info('No components to apply.');
-        outro('Done');
-        return;
-    }
-    // Warn on baseVersion drift before mutating the engine. This is advisory
-    // only: apply continues, because a silent divergence is worse than a
-    // noisy one and the operator is the only authority on whether the
-    // upstream component has actually changed shape.
-    const forgeConfig = await loadConfig(projectRoot);
-    const driftEntries = findOverrideBaseVersionDrift(config, forgeConfig.firefox.version);
-    for (const entry of driftEntries) {
-        warn(formatOverrideBaseVersionDriftWarning(entry));
-    }
-    const dryRun = options.dryRun ?? false;
-    const force = options.force ?? false;
-    if (!force && driftEntries.length > 0) {
-        throw new FurnaceError(formatOverrideBaseVersionDriftError(driftEntries));
-    }
-    const applySpinner = dryRun ? undefined : spinner('Applying components to engine...');
-    const result = await runFurnaceMutation(projectRoot, 'apply-rollback', async (ctx) => {
-        // `persistState: false` for a named apply matters: the batch persist
-        // path replaces `appliedChecksums` wholesale with only this run's
-        // entries, and the batch loops filter to the named component, so
-        // routing a named apply through it persists a state file containing
-        // only that component and wipes every other component's checksums.
-        // Orphan detection and deleted-file undeploy both key on that state,
-        // so the wiped components' stale engine files become invisible to
-        // apply and to `furnace validate`. Named apply merges per-component
-        // state below, exactly like `furnace deploy <name>`.
-        const applyResult = await applyAllComponents(projectRoot, dryRun, {
-            operationContext: ctx,
-            ...(name !== undefined ? { componentName: name, persistState: false } : {}),
-        });
-        if (name !== undefined && shouldPersistSingleComponentState(applyResult, dryRun)) {
-            await persistSingleComponentState(projectRoot, getPersistableAppliedEntry('Apply', name, applyResult.applied[0]), getFurnacePaths(projectRoot));
-        }
-        return applyResult;
-    }, { dryRun, ...waitLockMutationOptions(options.waitLockSeconds) });
-    if (applySpinner) {
-        applySpinner.stop('Components applied');
-    }
-    logApplyResult(result, dryRun);
-    const appliedWithStepErrorsCount = dryRun
-        ? 0
-        : countEntriesWithBlockingStepErrors(result.applied);
-    const totalApplyFailures = result.errors.length + appliedWithStepErrorsCount;
-    if (totalApplyFailures > 0) {
-        throw new FurnaceError(`${totalApplyFailures} component${totalApplyFailures === 1 ? '' : 's'} failed to apply cleanly`);
-    }
-    const appliedCount = result.applied.length;
-    const skippedCount = result.skipped.length;
-    if (dryRun) {
-        outro(`Dry run complete — would apply ${appliedCount}, skip ${skippedCount}`);
-    }
-    else {
-        outro(`Applied ${appliedCount}, skipped ${skippedCount}${formatSkipBreakdown(result.skipped)}`);
-    }
-    // Watch mode: re-apply on file changes in component directories
-    if (options.watch && !dryRun) {
-        await runWatchLoop(projectRoot);
-    }
-}

package/dist/src/commands/furnace/authoring-config.d.ts

@@ -1,13 +0,0 @@
-import type { FurnaceConfig } from '../../types/index.js';
-/**
- * Loads `furnace.json` for an authoring command, defaulting to an empty
- * configuration when the project has none yet.
- *
- * `furnace create` and `furnace override` both need this: they are the two
- * commands that may run before any furnace configuration exists, and both must
- * treat "no file" as "nothing registered yet" rather than an error. They had a
- * byte-identical private copy each.
- * @param projectRoot - Project root to load from.
- * @returns The parsed configuration, or a fresh default.
- */
-export declare function loadAuthoringFurnaceConfig(projectRoot: string): Promise<FurnaceConfig>;

package/dist/src/commands/furnace/authoring-config.js

@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { createDefaultFurnaceConfig, furnaceConfigExists, loadFurnaceConfig, } from '../../core/furnace-config.js';
-/**
- * Loads `furnace.json` for an authoring command, defaulting to an empty
- * configuration when the project has none yet.
- *
- * `furnace create` and `furnace override` both need this: they are the two
- * commands that may run before any furnace configuration exists, and both must
- * treat "no file" as "nothing registered yet" rather than an error. They had a
- * byte-identical private copy each.
- * @param projectRoot - Project root to load from.
- * @returns The parsed configuration, or a fresh default.
- */
-export async function loadAuthoringFurnaceConfig(projectRoot) {
-    if (await furnaceConfigExists(projectRoot)) {
-        return loadFurnaceConfig(projectRoot);
-    }
-    return createDefaultFurnaceConfig();
-}

package/dist/src/commands/furnace/chrome-doc-remove.d.ts

@@ -1,14 +0,0 @@
-/**
- * `fireforge furnace chrome-doc remove <name>` removes the files and
- * registrations created by `furnace chrome-doc create`.
- */
-import type { FurnaceLockWaitable } from '../../types/commands/index.js';
-/** Options for `furnace chrome-doc remove`. */
-export interface FurnaceChromeDocRemoveOptions extends FurnaceLockWaitable {
-    /** Skip confirmation. Required for real non-interactive removal. */
-    yes?: boolean;
-    /** Print the removal plan without writing files. */
-    dryRun?: boolean;
-}
-/** Runs `furnace chrome-doc remove <name>`. */
-export declare function furnaceChromeDocRemoveCommand(projectRoot: string, name: string, options?: FurnaceChromeDocRemoveOptions): Promise<void>;