@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/doctor-furnace.js

@@ -1,514 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { readFile, rm, stat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { applyAllComponents } from '../core/furnace-apply.js';
-import { hasCustomEngineDrift, hasOverrideEngineDrift } from '../core/furnace-apply-helpers.js';
-import { getFurnacePaths, loadFurnaceConfig, loadFurnaceState, updateFurnaceState, } from '../core/furnace-config.js';
-import { CUSTOM_ELEMENTS_JS, JAR_MN, resolveFtlDir, WIDGETS_DIR, } from '../core/furnace-constants.js';
-import { getFurnaceLockPath, runFurnaceMutation } from '../core/furnace-operation.js';
-import { hasBlockingStepErrors } from '../core/furnace-step-errors.js';
-import { validateAllComponents } from '../core/furnace-validate.js';
-import { isProcessAlive, toError } from '../utils/errors.js';
-import { pathExists } from '../utils/fs.js';
-import { failure, ok, warning } from './doctor-check-core.js';
-import { furnaceConfigSyncCheck } from './doctor-furnace-config-sync.js';
-import { furnaceStaleJarRegistrationCheck } from './doctor-furnace-jar.js';
-const ENGINE_REPAIRABLE_OPERATIONS = [
-    'preview-teardown',
-    'apply-rollback',
-    'deploy-rollback',
-    'remove-rollback',
-];
-function isEngineRepairableOperation(operation) {
-    return ENGINE_REPAIRABLE_OPERATIONS.includes(operation);
-}
-async function runRepairApply(projectRoot) {
-    return runFurnaceMutation(projectRoot, 'apply-rollback', (ctx) => applyAllComponents(projectRoot, false, { operationContext: ctx }), { skipPendingRepairCheck: true });
-}
-function countApplyFailures(applyResult) {
-    const appliedWithStepErrors = applyResult.applied.filter((entry) => hasBlockingStepErrors(entry)).length;
-    return applyResult.errors.length + appliedWithStepErrors;
-}
-function firstApplyFailure(applyResult) {
-    return (applyResult.errors[0]?.error ??
-        applyResult.applied
-            .flatMap((entry) => entry.stepErrors ?? [])
-            .map((step) => `${step.step}: ${step.error}`)[0] ??
-        'unknown error');
-}
-async function clearPendingRepairMarker(projectRoot) {
-    await updateFurnaceState(projectRoot, (current) => {
-        const next = { ...current };
-        delete next.pendingRepair;
-        return next;
-    });
-}
-/**
- * Returns the subset of state-file checksum keys whose `type/name` prefix
- * does not match any component in `furnace.json`. Keys are structured as
- * `<type>/<name>/<file>` where type is one of `override`, `custom`, or
- * `stock` and name is the tag name.
- *
- * Stock components are never checksummed by apply, so they never appear
- * in the state file, so any stock-prefixed entry is automatically stale.
- */
-function collectStaleChecksumKeys(appliedChecksums, config) {
-    const stale = [];
-    for (const key of Object.keys(appliedChecksums)) {
-        const segments = key.split('/');
-        if (segments.length < 2) {
-            stale.push(key);
-            continue;
-        }
-        const type = segments[0];
-        const name = segments[1];
-        if (type === undefined || name === undefined) {
-            stale.push(key);
-            continue;
-        }
-        if (type === 'override' && !(name in config.overrides)) {
-            stale.push(key);
-        }
-        else if (type === 'custom' && !(name in config.custom)) {
-            stale.push(key);
-        }
-        else if (type !== 'override' && type !== 'custom') {
-            stale.push(key);
-        }
-    }
-    return stale;
-}
-/**
- * Walks every override and custom component in the furnace config and asks
- * the drift oracles whether the engine still reflects the workspace source.
- * Returns the flat list of drifted component names so the doctor check can
- * decide whether a repair is needed.
- *
- * Components whose workspace directory is missing are treated as drifted:
- * the only consistent recovery is a re-run of apply which will surface the
- * missing-directory error through its own failure path.
- */
-async function collectFurnaceDrift(projectRoot, engineDir, config, ftlDir) {
-    const drifted = [];
-    const furnacePaths = getFurnacePaths(projectRoot);
-    for (const [name, overrideConfig] of Object.entries(config.overrides)) {
-        const componentDir = join(furnacePaths.overridesDir, name);
-        if (!(await pathExists(componentDir))) {
-            drifted.push(name);
-            continue;
-        }
-        try {
-            if (await hasOverrideEngineDrift({ engineDir, componentDir, ftlDir }, overrideConfig)) {
-                drifted.push(name);
-            }
-        }
-        catch {
-            // Drift check throws on unreadable paths. Treat as drift so the
-            // operator is told to run apply rather than swallowing the error.
-            drifted.push(name);
-        }
-    }
-    for (const [name, customConfig] of Object.entries(config.custom)) {
-        const componentDir = join(furnacePaths.customDir, name);
-        if (!(await pathExists(componentDir))) {
-            drifted.push(name);
-            continue;
-        }
-        try {
-            if (await hasCustomEngineDrift({ root: projectRoot, name, componentDir, ftlDir }, customConfig)) {
-                drifted.push(name);
-            }
-        }
-        catch {
-            // A drift probe that cannot complete is reported as drift: the doctor
-            // check must not claim a component is clean when it failed to look.
-            // Mirrors the documented twin above.
-            drifted.push(name);
-        }
-    }
-    return { drifted };
-}
-/**
- * "Furnace configuration" check: load and parse `furnace.json`. Populates
- * `ctx.furnaceConfig` for the downstream furnace checks so they do not
- * re-parse the file.
- */
-const furnaceConfigurationCheck = {
-    name: 'Furnace configuration',
-    // Silently skip when the project is not using furnace. Plenty of
-    // projects are patch-only, and flagging the absence of furnace.json
-    // would make `doctor` warn on every such project.
-    skipIf: (ctx) => !ctx.furnaceConfigExists,
-    run: async (ctx) => {
-        try {
-            ctx.furnaceConfig = await loadFurnaceConfig(ctx.projectRoot);
-            return ok('Furnace configuration');
-        }
-        catch (err) {
-            return failure('Furnace configuration', `furnace.json is invalid: ${toError(err).message}`, 'Fix the errors reported above in furnace.json and re-run "fireforge doctor".');
-        }
-    },
-};
-/**
- * "Furnace state consistency" check: detect checksums keyed by components
- * that are no longer in `furnace.json`. Repair clears the stale entries.
- */
-const furnaceStateConsistencyCheck = {
-    name: 'Furnace state consistency',
-    dependsOn: ['Furnace configuration'],
-    skipIf: (ctx) => !ctx.furnaceConfigExists || !ctx.furnaceConfig,
-    run: async (ctx) => {
-        const config = ctx.furnaceConfig;
-        if (!config) {
-            return [];
-        }
-        const state = await loadFurnaceState(ctx.projectRoot);
-        if (!state.appliedChecksums && !state.engineChecksums) {
-            return ok('Furnace state consistency');
-        }
-        // A "stale" entry is a checksum keyed by a component that is no
-        // longer in furnace.json. These are harmless but misleading: status
-        // and drift oracles read state independently and a stale entry
-        // shows up as a ghost component in their reports.
-        const staleApplied = state.appliedChecksums
-            ? collectStaleChecksumKeys(state.appliedChecksums, config)
-            : [];
-        const staleEngine = state.engineChecksums
-            ? collectStaleChecksumKeys(state.engineChecksums, config)
-            : [];
-        const staleKeys = [...new Set([...staleApplied, ...staleEngine])];
-        if (staleKeys.length === 0) {
-            return ok('Furnace state consistency');
-        }
-        const ghostSet = new Set();
-        for (const key of staleKeys) {
-            // Keys look like "override/<name>/<file>", so the ghost component is
-            // the first two segments joined for display purposes.
-            const segments = key.split('/');
-            if (segments.length >= 2) {
-                ghostSet.add(`${segments[0]}/${segments[1]}`);
-            }
-        }
-        const ghostList = [...ghostSet].sort();
-        const message = `.fireforge/furnace-state.json records ${staleKeys.length} checksum entr${staleKeys.length === 1 ? 'y' : 'ies'} for component${ghostList.length === 1 ? '' : 's'} no longer in furnace.json (${ghostList.join(', ')}).`;
-        if (!ctx.options.repairFurnace) {
-            return warning('Furnace state consistency', message, 'Run "fireforge doctor --repair-furnace" to clear the stale entries.');
-        }
-        try {
-            await updateFurnaceState(ctx.projectRoot, (current) => {
-                const result = { ...current };
-                if (current.appliedChecksums) {
-                    result.appliedChecksums = Object.fromEntries(Object.entries(current.appliedChecksums).filter(([key]) => !staleKeys.includes(key)));
-                }
-                if (current.engineChecksums) {
-                    result.engineChecksums = Object.fromEntries(Object.entries(current.engineChecksums).filter(([key]) => !staleKeys.includes(key)));
-                }
-                return result;
-            });
-            return warning('Furnace state consistency', `Cleared ${staleKeys.length} stale checksum entr${staleKeys.length === 1 ? 'y' : 'ies'} from .fireforge/furnace-state.json (${ghostList.join(', ')}).`);
-        }
-        catch (err) {
-            return failure('Furnace state consistency', `Could not clear stale furnace-state.json entries: ${toError(err).message}`, 'Fix the underlying file I/O issue and retry the doctor command.');
-        }
-    },
-};
-/**
- * "Furnace engine state" check: detect the `pendingRepair` marker set by
- * a failed preview teardown and any on-disk drift between the workspace
- * and the engine. Repair runs `applyAllComponents` to reconcile and
- * clears the marker on success.
- */
-const furnaceEngineStateCheck = {
-    name: 'Furnace engine state',
-    dependsOn: ['Furnace configuration'],
-    // Requires both a furnace project and an engine checkout: the drift
-    // oracles resolve engine paths, so a missing engine dir would throw.
-    skipIf: (ctx) => !ctx.furnaceConfigExists || !ctx.furnaceConfig || !ctx.engineExists,
-    run: async (ctx) => {
-        const config = ctx.furnaceConfig;
-        if (!config) {
-            return [];
-        }
-        const state = await loadFurnaceState(ctx.projectRoot);
-        const pendingRepair = state.pendingRepair;
-        // Drift check: walks every override and custom component and asks
-        // the same oracle apply's skip logic uses. A drifted component means
-        // the engine no longer reflects what the state file claims was
-        // deployed, so an apply is needed to reconcile.
-        const driftReport = await collectFurnaceDrift(ctx.projectRoot, ctx.paths.engine, config, resolveFtlDir(config.ftlBasePath));
-        const driftedNames = driftReport.drifted;
-        if (!pendingRepair && driftedNames.length === 0) {
-            return ok('Furnace engine state');
-        }
-        const pendingMessage = pendingRepair
-            ? `Pending repair marker set by ${pendingRepair.operation} at ${pendingRepair.timestamp}: ${pendingRepair.reason}.`
-            : '';
-        const driftMessage = driftedNames.length > 0
-            ? `Engine is drifted for ${driftedNames.length} component${driftedNames.length === 1 ? '' : 's'} (${driftedNames.join(', ')}).`
-            : '';
-        const message = [pendingMessage, driftMessage].filter(Boolean).join(' ');
-        if (!ctx.options.repairFurnace) {
-            const guidance = pendingRepair && !isEngineRepairableOperation(pendingRepair.operation)
-                ? 'Resolve or remove the partial component authoring changes, then run "fireforge doctor --repair-furnace" to re-validate and clear the repair marker.'
-                : 'Run "fireforge doctor --repair-furnace" to re-run furnace apply and reconcile the engine.';
-            return failure('Furnace engine state', message, guidance);
-        }
-        if (pendingRepair && !isEngineRepairableOperation(pendingRepair.operation)) {
-            try {
-                const validationResults = await validateAllComponents(ctx.projectRoot);
-                const validationIssues = [...validationResults.values()].flat();
-                const validationErrors = validationIssues.filter((issue) => issue.severity === 'error');
-                const validationWarnings = validationIssues.filter((issue) => issue.severity === 'warning').length;
-                if (validationErrors.length > 0) {
-                    const firstError = validationErrors[0];
-                    const firstMessage = firstError
-                        ? `${firstError.component} [${firstError.check}] ${firstError.message}`
-                        : 'unknown validation error';
-                    return failure('Furnace engine state', `Authoring rollback marker from ${pendingRepair.operation} is still unresolved: validation found ${validationErrors.length} error(s) (first: ${firstMessage}).`, 'Inspect furnace.json and the affected component files, finish or remove the partial authoring change, then retry "fireforge doctor --repair-furnace".');
-                }
-                let applyResult = null;
-                if (driftedNames.length > 0) {
-                    applyResult = await runRepairApply(ctx.projectRoot);
-                    const totalFailures = countApplyFailures(applyResult);
-                    if (totalFailures > 0) {
-                        return failure('Furnace engine state', `Repair attempted after ${pendingRepair.operation}, but apply reported ${totalFailures} failure${totalFailures === 1 ? '' : 's'} (first: ${firstApplyFailure(applyResult)}).`, 'Fix the underlying component issue, or remove the partial authoring change, and retry the doctor command.');
-                    }
-                }
-                await clearPendingRepairMarker(ctx.projectRoot);
-                const summary = driftedNames.length > 0 && applyResult
-                    ? `Reconciled engine drift after ${pendingRepair.operation} (${applyResult.applied.length} applied, ${applyResult.skipped.length} skipped) and cleared the repair marker.`
-                    : `Cleared the ${pendingRepair.operation} repair marker after validation passed${validationWarnings > 0 ? ` (${validationWarnings} warning${validationWarnings === 1 ? '' : 's'} remain)` : ''}.`;
-                return warning('Furnace engine state', summary);
-            }
-            catch (err) {
-                return failure('Furnace engine state', `Repair failed: ${toError(err).message}`, 'Inspect the error above, fix the partial authoring state, and retry the doctor command.');
-            }
-        }
-        // Repair path: run apply to reconcile the engine with the workspace
-        // state, then clear the pendingRepair marker on success. We re-run
-        // apply even when only the marker is set. The marker exists
-        // specifically because the last mutation could not clean up, so
-        // re-reconciling end-to-end is the cheapest honest thing to do.
-        try {
-            const applyResult = await runRepairApply(ctx.projectRoot);
-            const totalFailures = countApplyFailures(applyResult);
-            if (totalFailures > 0) {
-                return failure('Furnace engine state', `Repair attempted but apply reported ${totalFailures} failure${totalFailures === 1 ? '' : 's'} (first: ${firstApplyFailure(applyResult)}).`, 'Fix the underlying component issue and retry the doctor command.');
-            }
-            // Apply succeeded, so clear the pendingRepair marker so subsequent
-            // doctor runs stop reporting the issue. updateFurnaceState merges
-            // its return value via `validateFurnaceState` which simply writes
-            // whatever object we return, so dropping the key from the spread
-            // copy is enough to persist the cleared marker.
-            if (pendingRepair) {
-                await clearPendingRepairMarker(ctx.projectRoot);
-            }
-            const summary = driftedNames.length > 0
-                ? `Reconciled ${applyResult.applied.length} component${applyResult.applied.length === 1 ? '' : 's'} (${driftedNames.join(', ')} re-applied).`
-                : `Reconciled via furnace apply (${applyResult.applied.length} applied, ${applyResult.skipped.length} skipped).`;
-            return warning('Furnace engine state', summary);
-        }
-        catch (err) {
-            return failure('Furnace engine state', `Repair failed: ${toError(err).message}`, 'Inspect the error above, fix the underlying issue, and retry the doctor command.');
-        }
-    },
-};
-/**
- * Furnace operations read from a handful of Firefox-internal paths that are
- * hardcoded in `furnace-constants.ts` and `furnace-scanner.ts`. If upstream
- * renames or restructures any of them, furnace will silently fail instead
- * of diagnosing the change. This check verifies each expected path exists
- * so the operator gets a targeted "this path moved" message rather than a
- * confusing downstream error.
- */
-const furnaceEnginePathsCheck = {
-    name: 'Furnace engine paths',
-    dependsOn: ['Furnace configuration'],
-    skipIf: (ctx) => !ctx.furnaceConfigExists || !ctx.furnaceConfig || !ctx.engineExists,
-    run: async (ctx) => {
-        // Forks that replace browser.xhtml with a custom top-level chrome
-        // document enumerate their chrome docs in furnace.json.tokenHostDocuments.
-        // Reuse the same field for the engine-path probe so those forks stop
-        // seeing a permanent "browser.xhtml missing" warning.
-        const hostDocs = ctx.furnaceConfig?.tokenHostDocuments && ctx.furnaceConfig.tokenHostDocuments.length > 0
-            ? ctx.furnaceConfig.tokenHostDocuments
-            : ['browser/base/content/browser.xhtml'];
-        const expectedPaths = [
-            CUSTOM_ELEMENTS_JS,
-            JAR_MN,
-            WIDGETS_DIR,
-            resolveFtlDir(ctx.furnaceConfig?.ftlBasePath),
-            ...hostDocs,
-        ];
-        const missing = [];
-        for (const relative of expectedPaths) {
-            const absolute = join(ctx.paths.engine, relative);
-            if (!(await pathExists(absolute))) {
-                missing.push(relative);
-            }
-        }
-        if (missing.length === 0) {
-            return ok('Furnace engine paths');
-        }
-        return warning('Furnace engine paths', `${missing.length} expected engine path${missing.length === 1 ? '' : 's'} missing: ${missing.join(', ')}. Firefox may have restructured its source tree — furnace operations that depend on these paths will fail.`, 'Re-run "fireforge download" to update the engine. If the paths have genuinely moved, file an issue so Furnace can be updated.');
-    },
-};
-/**
- * Furnace Storybook backend check: verifies that the engine contains the
- * Storybook workspace required by `furnace preview`. Missing Storybook
- * support is a warning rather than a failure, since furnace works fine
- * without preview. Operators should still know upfront rather than
- * discovering it mid-command.
- */
-const furnaceStorybookCheck = {
-    name: 'Furnace Storybook backend',
-    dependsOn: ['Furnace configuration'],
-    skipIf: (ctx) => !ctx.furnaceConfigExists || !ctx.furnaceConfig || !ctx.engineExists,
-    run: async (ctx) => {
-        const storybookRoot = join(ctx.paths.engine, 'browser', 'components', 'storybook');
-        if (await pathExists(storybookRoot)) {
-            return ok('Furnace Storybook backend');
-        }
-        return warning('Furnace Storybook backend', 'browser/components/storybook not found in the engine. "fireforge furnace preview" will not work.', 'Re-run "fireforge download" to get a complete engine checkout. If you do not need Storybook preview, this warning can be ignored.');
-    },
-};
-/**
- * "Furnace component validation" check: runs the full validation suite
- * across all override and custom components. Surfaces structural,
- * accessibility, compatibility, and registration issues that would
- * otherwise go unnoticed until `furnace validate` is run explicitly.
- */
-const furnaceComponentValidationCheck = {
-    name: 'Furnace component validation',
-    dependsOn: ['Furnace configuration'],
-    // Requires a furnace project, a valid config, and an engine checkout.
-    // Skip when there are no override/custom components to validate.
-    skipIf: (ctx) => {
-        if (!ctx.furnaceConfigExists || !ctx.furnaceConfig || !ctx.engineExists)
-            return true;
-        const config = ctx.furnaceConfig;
-        return Object.keys(config.overrides).length === 0 && Object.keys(config.custom).length === 0;
-    },
-    run: async (ctx) => {
-        const config = ctx.furnaceConfig;
-        if (!config) {
-            return [];
-        }
-        try {
-            const results = await validateAllComponents(ctx.projectRoot);
-            const allIssues = [...results.values()].flat();
-            const errors = allIssues.filter((issue) => issue.severity === 'error');
-            const warnings = allIssues.filter((issue) => issue.severity === 'warning');
-            if (errors.length === 0 && warnings.length === 0) {
-                return ok('Furnace component validation');
-            }
-            const summary = `${errors.length} error${errors.length === 1 ? '' : 's'}, ` +
-                `${warnings.length} warning${warnings.length === 1 ? '' : 's'} ` +
-                `across ${results.size} component${results.size === 1 ? '' : 's'}`;
-            if (errors.length > 0) {
-                const first = errors[0];
-                const detail = first
-                    ? ` (first: ${first.component} [${first.check}] ${first.message})`
-                    : '';
-                return failure('Furnace component validation', `${summary}${detail}`, 'Run "fireforge furnace validate" for the full report, then fix the errors.');
-            }
-            return warning('Furnace component validation', summary, 'Run "fireforge furnace validate" for details.');
-        }
-        catch (err) {
-            return failure('Furnace component validation', `Validation failed: ${toError(err).message}`, 'Run "fireforge furnace validate" directly to diagnose.');
-        }
-    },
-};
-/**
- * Reads the owner PID from a furnace lock directory. Returns `null` when
- * the PID file is missing, unreadable, or does not parse as a finite
- * integer. The caller then falls back to an age-only heuristic.
- */
-async function readFurnaceLockPid(lockPath) {
-    try {
-        const pidContent = await readFile(join(lockPath, 'pid'), 'utf-8');
-        const pid = parseInt(pidContent.trim(), 10);
-        return Number.isFinite(pid) ? pid : null;
-    }
-    catch {
-        // No PID file, or it is unreadable/unparseable. The caller falls back to the
-        // age-only staleness heuristic, which is why this is `null` and not a throw.
-        return null;
-    }
-}
-/**
- * "Furnace stale lock" check: detect and (under `--repair-furnace`) remove a
- * `.fireforge/furnace.lock` directory whose owner process is no longer
- * alive.
- *
- * This is the recovery path when the signal-handler sweep
- * (`forceReleaseFurnaceLocksForActiveOperations` in `bin/fireforge.ts`)
- * misses: a SIGKILL'd process that never ran the handler, or a lock
- * directory without a PID file. SIGINT'ing `furnace
- * preview` leaves the lock behind, and the next `fireforge test --build`
- * then times out waiting for it. `doctor --repair-furnace` clears it so the
- * next command runs immediately.
- */
-const furnaceStaleLockCheck = {
-    name: 'Furnace lock',
-    dependsOn: ['Furnace configuration'],
-    skipIf: (ctx) => !ctx.furnaceConfigExists,
-    run: async (ctx) => {
-        const lockPath = getFurnaceLockPath(ctx.projectRoot);
-        if (!(await pathExists(lockPath))) {
-            return ok('Furnace lock');
-        }
-        const pid = await readFurnaceLockPid(lockPath);
-        const lockStat = await stat(lockPath).catch(() => null);
-        const ageMs = lockStat ? Date.now() - lockStat.mtimeMs : undefined;
-        const ageSuffix = ageMs !== undefined ? ` (age: ${Math.round(ageMs / 1000)}s)` : '';
-        // Two signals mark a lock as stale:
-        //   1. PID file says owner is dead → unambiguous, remove immediately.
-        //   2. PID file absent and lock is older than 60s → a lock directory
-        //      written without a PID file (for example created externally)
-        //      falls into this bucket. The age gate avoids false positives on a lock just
-        //      acquired by a concurrent process that has not written its PID yet.
-        //
-        // `isProcessAlive` treats EPERM as alive. Returning false for EPERM
-        // reports a furnace lock held by a live process owned by another uid as
-        // "owner is no longer running", and --repair-furnace then deletes it,
-        // dropping mutual exclusion under a concurrent furnace operation.
-        const ownerDead = pid !== null && !isProcessAlive(pid);
-        const pidMissingAndOld = pid === null && (ageMs ?? 0) > 60_000;
-        const isStale = ownerDead || pidMissingAndOld;
-        if (!isStale) {
-            // Lock is held by a running FireForge process, so nothing to report.
-            return ok('Furnace lock');
-        }
-        const description = ownerDead
-            ? `Stale furnace lock at ${lockPath}: owner PID ${pid} is no longer running${ageSuffix}.`
-            : `Stale furnace lock at ${lockPath}: no PID file and lock directory is older than 60s${ageSuffix}.`;
-        if (!ctx.options.repairFurnace) {
-            return warning('Furnace lock', description, 'Run "fireforge doctor --repair-furnace" to remove the stale lock.');
-        }
-        try {
-            await rm(lockPath, { recursive: true, force: true });
-            return warning('Furnace lock', `Removed stale furnace lock at ${lockPath}${ageSuffix}.`);
-        }
-        catch (err) {
-            return failure('Furnace lock', `Could not remove stale furnace lock at ${lockPath}: ${toError(err).message}`, 'Remove the directory manually (rm -rf .fireforge/furnace.lock) and retry.');
-        }
-    },
-};
-/**
- * The ordered furnace check group. Exported as an array so `doctor.ts`
- * can splice it into the main registry at the right position. The order
- * here matters: `Furnace configuration` must run before the consumers
- * that read `ctx.furnaceConfig`.
- */
-export const FURNACE_DOCTOR_CHECKS = [
-    furnaceConfigurationCheck,
-    furnaceStateConsistencyCheck,
-    furnaceStaleJarRegistrationCheck,
-    furnaceEnginePathsCheck,
-    furnaceStorybookCheck,
-    furnaceStaleLockCheck,
-    furnaceEngineStateCheck,
-    furnaceComponentValidationCheck,
-    furnaceConfigSyncCheck,
-];

package/dist/src/commands/doctor-macos-sdk.d.ts

@@ -1,8 +0,0 @@
-import type { DoctorCheck } from '../types/commands/index.js';
-import type { DoctorCheckDefinition } from './doctor-check-core.js';
-/** The bootstrapped clang mach uses on macOS. */
-export declare function bootstrappedClangPath(): string;
-/** Runs the check for one engine directory. */
-export declare function checkMacosSdkLink(engineDir: string): Promise<DoctorCheck>;
-/** Registry entry for the doctor runner. */
-export declare const MACOS_SDK_LINK_DOCTOR_CHECK: DoctorCheckDefinition;