@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/cli.js

@@ -1,380 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { existsSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { Command, Help } from 'commander';
-import { handleParseError, machineErrorCode, wantsMachineOutput } from './cli-usage-error.js';
-import { COMMAND_MANIFEST } from './commands/manifest.js';
-import { runTreeGuardHook } from './core/tree-guard.js';
-import { CancellationError, CommandError, FireForgeError, InternalInvariantError, } from './errors/base.js';
-import { ExitCode } from './errors/codes.js';
-import { ConfigNotFoundError } from './errors/config.js';
-import { getCliVersion } from './utils/build-info.js';
-import { toError } from './utils/errors.js';
-import { cancel, error as logError, isStdoutSealed, isVerbose, setMachineOutputMode, setStdoutSealed, setVerbose, } from './utils/logger.js';
-import { emitMachineError } from './utils/machine-output.js';
-import { ensureWaitLockOptionEverywhere } from './utils/options.js';
-const brokenPipeInstalledKey = Symbol.for('fireforge.cli.brokenPipeHandlerInstalled');
-const brokenPipeListenerKey = Symbol.for('fireforge.cli.brokenPipeHandlerListener');
-function getProcessState() {
-    return process;
-}
-function getBrokenPipeHandler(state) {
-    const existingHandler = state[brokenPipeListenerKey];
-    if (existingHandler) {
-        return existingHandler;
-    }
-    const handler = (error) => {
-        if (error.code === 'EPIPE') {
-            process.exitCode = 0;
-            return;
-        }
-        throw error;
-    };
-    state[brokenPipeListenerKey] = handler;
-    return handler;
-}
-/**
- * Prints an error's `cause` chain under `--verbose`.
- *
- * Nine error classes declare a `cause` and twenty-two throw sites pass one.
- * Without this the underlying git stderr, errno or parse failure never
- * reaches the operator, because a `FireForgeError` renders as its
- * `userMessage` and stops.
- *
- * Goes to stderr via console.error so a `--json` payload on stdout stays
- * intact, matching the InternalInvariantError branch.
- *
- * @param error - The error whose chain to walk
- */
-function printCauseChain(error) {
-    if (!isVerbose())
-        return;
-    let current = error.cause;
-    let depth = 0;
-    // Bounded: a self-referential cause chain must not hang the boundary.
-    while (current !== undefined && current !== null && depth < 8) {
-        const normalized = toError(current);
-        console.error(`Caused by: ${normalized.name}: ${normalized.message}`);
-        if (normalized.stack) {
-            console.error(normalized.stack);
-        }
-        current = normalized.cause;
-        depth += 1;
-    }
-}
-/**
- * Installs a handler for broken-pipe (EPIPE) errors on stdout/stderr.
- * This is a process-level concern: when output is piped to a process that
- * closes early (e.g. `fireforge status | head`), Node emits EPIPE.
- * We treat this as a clean exit.
- */
-export function installBrokenPipeHandler() {
-    const state = getProcessState();
-    if (state[brokenPipeInstalledKey]) {
-        return;
-    }
-    const handleStreamError = getBrokenPipeHandler(state);
-    process.stdout.on('error', handleStreamError);
-    process.stderr.on('error', handleStreamError);
-    state[brokenPipeInstalledKey] = true;
-}
-/**
- * Removes the broken-pipe handler installed for CLI tests.
- *
- * @internal Exported only so tests can reach it. It is not part of the
- * public surface.
- */
-export function resetBrokenPipeHandlerForTests() {
-    const state = getProcessState();
-    const handleStreamError = state[brokenPipeListenerKey];
-    if (handleStreamError) {
-        process.stdout.off('error', handleStreamError);
-        process.stderr.off('error', handleStreamError);
-    }
-    state[brokenPipeInstalledKey] = undefined;
-    state[brokenPipeListenerKey] = undefined;
-}
-/**
- * Maximum number of directory levels to walk when searching for
- * `fireforge.json`. `dirname()` walking is pure string manipulation and
- * cannot cycle (the `parent === current` check already terminates at the
- * root). This cap only bounds the cost on pathologically deep paths.
- */
-const MAX_PROJECT_ROOT_WALK_DEPTH = 50;
-/**
- * Gets the project root directory.
- * Walks up from the current working directory until a fireforge.json is found.
- * Throws a {@link ConfigNotFoundError} (code: CONFIG_ERROR) when no
- * fireforge.json is found within the walk depth limit. The error is
- * user-facing so `withErrorHandling` can print the guidance without
- * the stack dump that a plain `Error` would trigger.
- */
-export function getProjectRoot() {
-    const start = resolve(process.cwd());
-    let current = start;
-    for (let depth = 0; depth < MAX_PROJECT_ROOT_WALK_DEPTH; depth++) {
-        if (existsSync(join(current, 'fireforge.json'))) {
-            return current;
-        }
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    throw new ConfigNotFoundError('fireforge.json');
-}
-/**
- * Wraps a command handler with error handling.
- *
- * Logs the user-visible error message and throws a {@link CommandError}
- * carrying the appropriate exit code. The actual `process.exit()` call
- * lives in the CLI entrypoint (`bin/fireforge.ts`), keeping shared library
- * code free of process-terminating side effects.
- */
-export function withErrorHandling(handler) {
-    return async (...args) => {
-        // Rule 3 of docs/machine-output.md: machine mode engages before any
-        // output. Anything that throws on the way in (most visibly
-        // `getProjectRoot`'s ConfigNotFoundError) would otherwise render a
-        // clack-styled block to stdout and leave a `--json` consumer with
-        // un-parseable output. Reading the flag from argv is blunt but exact: if
-        // the invocation asked for machine output, stdout belongs to the payload
-        // from the first byte.
-        const machineOutput = wantsMachineOutput();
-        if (machineOutput) {
-            setMachineOutputMode(true);
-        }
-        try {
-            await handler(...args);
-        }
-        catch (error) {
-            // Sentinel errors have already been rendered by the command. Passing
-            // them through prevents machine-readable refusal paths from acquiring
-            // an "Unexpected error" banner and stack trace on stderr.
-            if (error instanceof CommandError) {
-                throw error;
-            }
-            const normalizedError = toError(error);
-            const exitCode = error instanceof FireForgeError ? error.code : ExitCode.GENERAL_ERROR;
-            if (error instanceof CancellationError) {
-                cancel('Operation cancelled');
-            }
-            else if (error instanceof InternalInvariantError) {
-                // Invariant failures always include their stack for a bug report.
-                logError(error.userMessage);
-                if (error.stack)
-                    console.error(error.stack);
-            }
-            else if (error instanceof FireForgeError) {
-                logError(error.userMessage);
-                printCauseChain(error);
-            }
-            else {
-                logError(`Unexpected error: ${normalizedError.message}`);
-                if (normalizedError.stack)
-                    console.error(normalizedError.stack);
-            }
-            // One final sink covers every classification. A command that already
-            // sealed stdout owns its payload; appending an envelope would corrupt it.
-            if (machineOutput && !isStdoutSealed()) {
-                emitMachineError(error instanceof FireForgeError ? machineErrorCode(error) : 'unexpected-error', normalizedError.message, exitCode);
-            }
-            throw new CommandError(exitCode);
-        }
-        finally {
-            // Central machine-mode and stdout-seal reset. Commands leave both
-            // engaged while an error propagates (a mid-throw restore would route
-            // the styled error to stdout, corrupting the `--json`/`--raw` payload
-            // stream or displacing the FIREFORGE-VERDICT line). The reset happens
-            // here, after logError has picked its stream, so no state leaks into a
-            // subsequent in-process invocation.
-            setMachineOutputMode(false);
-            setStdoutSealed(false);
-        }
-    };
-}
-/** Human-readable labels for command groups, in display order. */
-const GROUP_LABELS = new Map([
-    ['project', 'Project'],
-    ['engine', 'Engine'],
-    ['workflow', 'Workflow'],
-    ['components', 'Components'],
-    ['diagnostics', 'Diagnostics'],
-]);
-/**
- * Builds a grouped help formatter that replaces Commander's flat command
- * list with sections labelled by manifest group.
- */
-function buildGroupedHelpFormatter(manifest) {
-    const commandGroupMap = new Map();
-    for (const entry of manifest) {
-        commandGroupMap.set(entry.name, entry.group);
-    }
-    return (cmd, helper) => {
-        // For subcommands (e.g. `furnace --help`), fall back to Commander's
-        // default formatting by calling the prototype method directly.
-        if (cmd.parent) {
-            return Help.prototype.formatHelp.call(helper, cmd, helper);
-        }
-        const termWidth = helper.padWidth(cmd, helper);
-        const helpWidth = helper.helpWidth ?? 80;
-        const output = [];
-        // Usage
-        output.push(`Usage: ${helper.commandUsage(cmd)}`, '');
-        // Description
-        const desc = helper.commandDescription(cmd);
-        if (desc) {
-            output.push(desc, '');
-        }
-        // Options
-        const optionLines = helper.visibleOptions(cmd).map((opt) => {
-            const term = helper.optionTerm(opt);
-            const desc = helper.optionDescription(opt);
-            return formatHelpLine(term, desc, termWidth, helpWidth);
-        });
-        // -V/--version is handled in main() before commander parses (a real
-        // root-level `.version()` option would claim `--version` anywhere in
-        // argv under commander's default parsing, breaking subcommand flags
-        // like `source set --version <v>`). Advertise it here so root help
-        // stays truthful.
-        optionLines.unshift(formatHelpLine('-V, --version', 'output the version number', termWidth, helpWidth));
-        if (optionLines.length > 0) {
-            output.push('Options:');
-            output.push(...optionLines);
-            output.push('');
-        }
-        // Grouped commands
-        const visibleCommands = helper.visibleCommands(cmd);
-        const grouped = new Map();
-        const otherLines = [];
-        for (const sub of visibleCommands) {
-            const name = sub.name();
-            const group = commandGroupMap.get(name);
-            const term = helper.subcommandTerm(sub);
-            const desc = helper.subcommandDescription(sub);
-            const line = formatHelpLine(term, desc, termWidth, helpWidth);
-            if (!group) {
-                // Built-in commands (e.g. "help") go to the end
-                otherLines.push(line);
-                continue;
-            }
-            const label = GROUP_LABELS.get(group) ?? group;
-            const lines = grouped.get(label) ?? [];
-            lines.push(line);
-            grouped.set(label, lines);
-        }
-        for (const [, displayLabel] of GROUP_LABELS) {
-            const lines = grouped.get(displayLabel);
-            if (!lines || lines.length === 0)
-                continue;
-            output.push(`${displayLabel}:`);
-            output.push(...lines);
-            output.push('');
-        }
-        if (otherLines.length > 0) {
-            output.push(...otherLines);
-            output.push('');
-        }
-        return output.join('\n');
-    };
-}
-/** Formats a single help line with term and description, wrapping as needed. */
-function formatHelpLine(term, description, termWidth, helpWidth) {
-    const padding = ' '.repeat(termWidth - term.length);
-    const fullLine = `  ${term}${padding}  ${description}`;
-    if (fullLine.length <= helpWidth || !description) {
-        return fullLine;
-    }
-    // Wrap long descriptions
-    const descWidth = helpWidth - termWidth - 4;
-    if (descWidth < 20) {
-        return fullLine;
-    }
-    const words = description.split(' ');
-    const lines = [];
-    let currentLine = '';
-    for (const word of words) {
-        if (currentLine.length + word.length + 1 > descWidth && currentLine.length > 0) {
-            lines.push(currentLine);
-            currentLine = word;
-        }
-        else {
-            currentLine = currentLine.length > 0 ? `${currentLine} ${word}` : word;
-        }
-    }
-    if (currentLine.length > 0) {
-        lines.push(currentLine);
-    }
-    const indent = ' '.repeat(termWidth + 4);
-    const first = lines[0] ?? '';
-    const rest = lines.slice(1).map((l) => `${indent}${l}`);
-    return [`  ${term}${padding}  ${first}`, ...rest].join('\n');
-}
-/**
- * Creates and configures the CLI program.
- */
-export function createProgram() {
-    const program = new Command();
-    program
-        .name('fireforge')
-        // Usage errors must not let commander call process.exit(1) itself: the
-        // documented code is INVALID_ARGUMENT (8) and `--json` owes a refusal
-        // envelope. Installed before any subcommand registers, because
-        // `.command()` copies the override into the child at creation time.
-        .exitOverride()
-        .description('A build tool for customizing Firefox')
-        .option('-v, --verbose', 'Enable debug output')
-        .option('--ignore-corrupt-tree-marker', 'Run even when .fireforge/tree.json exists but cannot be parsed. Without this the tree guard refuses, because an unreadable marker leaves it unknown whether this is a snapshot or the primary tree.')
-        .hook('preAction', (thisCommand) => {
-        const opts = thisCommand.opts();
-        if (opts['verbose']) {
-            setVerbose(true);
-        }
-    })
-        // Verification-tree guard: when the cwd resolves into a tree snapshot,
-        // refuse mutating commands before their action runs. One hook covers
-        // every command regardless of how the cwd got there.
-        .hook('preAction', async (thisCommand, actionCommand) => {
-        await runTreeGuardHook(thisCommand.name(), actionCommand);
-    });
-    const groupedFormatter = buildGroupedHelpFormatter(COMMAND_MANIFEST);
-    program.configureHelp({
-        formatHelp: groupedFormatter,
-    });
-    const ctx = { getProjectRoot, withErrorHandling };
-    for (const entry of COMMAND_MANIFEST) {
-        entry.register(program, ctx);
-    }
-    // Uniform `--wait-lock`: scripted sequences blanket-append the flag, and a
-    // subcommand that rejects it with "unknown option" kills the sequence with
-    // a usage error instead of a lock message. Applied after registration so it
-    // covers every subcommand at every depth. Commands that already declare the
-    // honoring flag keep it untouched.
-    ensureWaitLockOptionEverywhere(program);
-    return program;
-}
-/**
- * Main CLI entry point.
- */
-export async function main() {
-    // Root-level --version/-V handling. This is not a commander `.version()`
-    // option, because under commander's default (non-positional) parsing a
-    // root version option claims `--version` anywhere in argv and hijacks
-    // subcommand flags like `source set --version <v>`. The rule here: when no
-    // subcommand was given, any -V/--version among the root flags prints the
-    // version, so `fireforge --verbose --version` works and
-    // `fireforge source set --version 152` is untouched.
-    const userArgs = process.argv.slice(2);
-    const hasSubcommand = userArgs.some((arg) => !arg.startsWith('-'));
-    if (!hasSubcommand && userArgs.some((arg) => arg === '--version' || arg === '-V')) {
-        process.stdout.write(`${getCliVersion()}\n`);
-        return;
-    }
-    const program = createProgram();
-    try {
-        await program.parseAsync(process.argv);
-    }
-    catch (error) {
-        handleParseError(error, wantsMachineOutput());
-    }
-}

package/dist/src/commands/bootstrap-checks.d.ts

@@ -1,16 +0,0 @@
-import type { DoctorCheck } from '../types/commands/index.js';
-/** Tags representing distinct issues detected in bootstrap output. */
-export type BootstrapIssue = 'sdk-fetch-403' | 'python-traceback' | 'missing-origin-remote';
-/**
- * Scans bootstrap output for known failure patterns and returns structured
- * issue tags. A Python traceback paired with an HTTP 403 is collapsed into
- * a single `sdk-fetch-403` tag since the traceback is just the stack trace
- * from the HTTP error.
- */
-export declare function detectBootstrapIssues(output: string): BootstrapIssue[];
-/**
- * Runs targeted post-bootstrap checks based on the detected issues.
- * Returns doctor-compatible check results so the caller can render them
- * with the standard `reportDoctorResults` display.
- */
-export declare function runPostBootstrapChecks(issues: BootstrapIssue[]): Promise<DoctorCheck[]>;

package/dist/src/commands/bootstrap-checks.js

@@ -1,66 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { execFile } from 'node:child_process';
-import { failure, warning } from './doctor-check-core.js';
-/**
- * Scans bootstrap output for known failure patterns and returns structured
- * issue tags. A Python traceback paired with an HTTP 403 is collapsed into
- * a single `sdk-fetch-403` tag since the traceback is just the stack trace
- * from the HTTP error.
- */
-export function detectBootstrapIssues(output) {
-    const normalized = output.replace(/\r\n/g, '\n');
-    const issues = [];
-    const hasTraceback = /traceback \(most recent call last\):/i.test(normalized);
-    const has403 = /\bhttp(?:\s+error)?\s*403\b/i.test(normalized) || /\b403\b.*forbidden/i.test(normalized);
-    if (has403) {
-        // The traceback is just the stack trace from the HTTP error, so report
-        // it once.
-        issues.push('sdk-fetch-403');
-    }
-    else if (hasTraceback) {
-        issues.push('python-traceback');
-    }
-    if (/no such remote ['"]origin['"]/i.test(normalized) ||
-        /remote ['"]origin['"] does not exist/i.test(normalized) ||
-        /missing git remote ['"]origin['"]/i.test(normalized)) {
-        issues.push('missing-origin-remote');
-    }
-    return issues;
-}
-/** Checks whether `xcrun --show-sdk-path` returns a valid macOS SDK path. */
-async function hasMacOsSdk() {
-    return new Promise((resolve) => {
-        execFile('xcrun', ['--show-sdk-path'], { timeout: 10_000 }, (err, stdout) => {
-            resolve(!err && stdout.trim().length > 0);
-        });
-    });
-}
-/**
- * Runs targeted post-bootstrap checks based on the detected issues.
- * Returns doctor-compatible check results so the caller can render them
- * with the standard `reportDoctorResults` display.
- */
-export async function runPostBootstrapChecks(issues) {
-    const checks = [];
-    for (const issue of issues) {
-        switch (issue) {
-            case 'sdk-fetch-403': {
-                const sdkAvailable = await hasMacOsSdk();
-                if (sdkAvailable) {
-                    checks.push(warning('macOS SDK download', "SDK download from Apple's CDN failed (HTTP 403), but a macOS SDK was found via Xcode. This is safe to ignore."));
-                }
-                else {
-                    checks.push(failure('macOS SDK', 'SDK download failed and no macOS SDK found on your system.', 'Install Xcode Command Line Tools with "xcode-select --install"'));
-                }
-                break;
-            }
-            case 'python-traceback':
-                checks.push(warning('Python traceback', 'Bootstrap emitted a Python traceback. This may indicate a non-critical issue.', 'Review the bootstrap output above for details.'));
-                break;
-            case 'missing-origin-remote':
-                checks.push(failure('Git remote', 'Bootstrap expected an "origin" git remote in the Firefox source checkout.', 'Run "git remote add origin <url>" in the engine directory.'));
-                break;
-        }
-    }
-    return checks;
-}

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

@@ -1,10 +0,0 @@
-import { Command } from 'commander';
-import { ExitCode } from '../errors/codes.js';
-import type { CommandContext } from '../types/cli.js';
-/**
- * Runs the bootstrap command.
- * @param projectRoot - Root directory of the project
- */
-export declare function bootstrapCommand(projectRoot: string): Promise<ExitCode>;
-/** Registers the bootstrap command on the CLI program. */
-export declare function registerBootstrap(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/build-prelock.d.ts

@@ -1,20 +0,0 @@
-/**
- * `fireforge build --wait-browser` spends its budget before the engine
- * session lock, not while holding it.
- *
- * A build queued behind a running objdir browser (a demo batch, an
- * end-to-end harness) that waited inside `withEngineSessionLock` would queue
- * every peer's build, test and re-export behind a run that was doing
- * nothing. The wait happens first, and the in-lock objdir preflight
- * re-checks once (the spent budget is stripped from the options it gets).
- */
-import type { BuildOptions } from '../types/commands/index.js';
-/**
- * Waits for this objdir's browser before the lock when `--wait-browser`
- * was given and there is a launchable bundle to watch.
- *
- * @param projectRoot - Project root
- * @param options - Parsed build options
- * @returns The options the in-lock run should use
- */
-export declare function waitForBuildBrowserBeforeLock(projectRoot: string, options: BuildOptions): Promise<BuildOptions>;

package/dist/src/commands/build-prelock.js

@@ -1,50 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge build --wait-browser` spends its budget before the engine
- * session lock, not while holding it.
- *
- * A build queued behind a running objdir browser (a demo batch, an
- * end-to-end harness) that waited inside `withEngineSessionLock` would queue
- * every peer's build, test and re-export behind a run that was doing
- * nothing. The wait happens first, and the in-lock objdir preflight
- * re-checks once (the spent budget is stripped from the options it gets).
- */
-import { join } from 'node:path';
-import { getProjectPaths, loadConfig } from '../core/config.js';
-import { hasBuildArtifacts, hasRunnableBundle } from '../core/mach.js';
-import { ensureLaunchableBrowserNotRunning } from '../core/marionette-port.js';
-import { waitBeforeLock } from '../core/preflight-wait.js';
-import { pathExists } from '../utils/fs.js';
-import { resolveWaitLockSeconds } from '../utils/options.js';
-/**
- * Waits for this objdir's browser before the lock when `--wait-browser`
- * was given and there is a launchable bundle to watch.
- *
- * @param projectRoot - Project root
- * @param options - Parsed build options
- * @returns The options the in-lock run should use
- */
-export async function waitForBuildBrowserBeforeLock(projectRoot, options) {
-    const { waitBrowser, ...rest } = options;
-    if (waitBrowser === undefined)
-        return options;
-    const paths = getProjectPaths(projectRoot);
-    if (!(await pathExists(paths.engine)))
-        return options;
-    const { objDir } = await hasBuildArtifacts(paths.engine);
-    if (objDir === undefined)
-        return options;
-    let binaryName;
-    try {
-        ({ binaryName } = await loadConfig(projectRoot));
-    }
-    catch {
-        return options;
-    }
-    const bundle = await hasRunnableBundle(paths.engine, binaryName, objDir);
-    const expectedPath = bundle.expectedPath;
-    if (!bundle.runnable || expectedPath === undefined)
-        return options;
-    await waitBeforeLock(() => ensureLaunchableBrowserNotRunning(join(paths.engine, expectedPath)), resolveWaitLockSeconds(waitBrowser));
-    return rest;
-}

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

@@ -1,13 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-import type { BuildOptions } from '../types/commands/index.js';
-/**
- * Runs the build command.
- * @param projectRoot - Root directory of the project
- * @param options - Build options
- * @param underLock - Runs the build under the engine session lock; a
- *   `--wait-browser` budget is spent before it (see build-prelock.ts)
- */
-export declare function buildCommand(projectRoot: string, options: BuildOptions, underLock?: (body: () => Promise<void>) => Promise<void>): Promise<void>;
-/** Registers the build command on the CLI program. */
-export declare function registerBuild(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/check-report.d.ts

@@ -1,41 +0,0 @@
-import type { CheckStepResult } from './check-run.js';
-/**
- * Why a check failed. `step-failures`: at least one step went red.
- * `lock-timeout`: every failing step exited 15, so nothing was judged red,
- * the steps just never got their locks. Re-queue rather than fix.
- * `skipped-steps`: nothing went red, but `check.failOnSkipped` is set and a
- * step had nothing to run.
- */
-export type CheckVerdictReason = 'step-failures' | 'lock-timeout' | 'skipped-steps';
-/** How the verdict treats skipped steps. */
-export interface CheckJudgeOptions {
-    /** `check.failOnSkipped`: a step skipped for want of anything to run fails the check. */
-    failOnSkipped?: boolean | undefined;
-}
-/** The verdict over all steps. */
-export interface CheckVerdict {
-    passed: boolean;
-    reason?: CheckVerdictReason;
-    failed: string[];
-    skipped: string[];
-    steps: number;
-}
-/**
- * Judges the results: any failing step fails the check. Under
- * `failOnSkipped`, so does a step skipped because the project has nothing
- * for it to run; it is then listed in `failed` too.
- */
-export declare function judgeCheck(results: readonly CheckStepResult[], options?: CheckJudgeOptions): CheckVerdict;
-/**
- * The verdict line: `FIREFORGE-VERDICT: PASS steps=<n> skipped=<n>` or
- * `FIREFORGE-VERDICT: FAIL reason=<reason> failed=<a,b> steps=<n> skipped=<n>`,
- * with an additive `skipped-steps=<a,b>` naming the skipped steps when
- * there are any.
- */
-export declare function formatCheckVerdictLine(verdict: CheckVerdict): string;
-/** The per-step table: one aligned row per step, with its detail. */
-export declare function formatCheckTable(results: readonly CheckStepResult[]): string;
-/** Writes the verdict line as the run's last stdout write, and seals stdout. */
-export declare function writeCheckVerdictLine(verdict: CheckVerdict): void;
-/** Writes the `--json` document (schemaVersion 1) and seals stdout. */
-export declare function writeCheckJson(results: readonly CheckStepResult[], verdict: CheckVerdict): void;