@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/errors/base.js

@@ -1,279 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { ExitCode } from './codes.js';
-/**
- * Base error class for all FireForge errors.
- * Provides structured error information with exit codes and user-friendly messages.
- */
-export class FireForgeError extends Error {
-    /**
-     * Creates a new FireForgeError.
-     * @param message - Technical error message for logging
-     * @param cause - The underlying error that caused this error
-     */
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.name = this.constructor.name;
-        if (cause !== undefined) {
-            this.cause = cause;
-        }
-        // Trims the constructor frames off the stack. `engines` pins Node >= 22,
-        // so the V8-only `captureStackTrace` is always present. The former
-        // `typeof === 'function'` guard was an unreachable branch that coverage
-        // could never close.
-        Error.captureStackTrace(this, this.constructor);
-    }
-    /**
-     * User-friendly error message with context and suggested fixes.
-     * Override in subclasses to provide specific guidance.
-     */
-    get userMessage() {
-        return this.message;
-    }
-}
-/**
- * Renders the trailing "To fix this:" block shared by every FireForge error
- * that offers remedies.
- *
- * Numbering is derived from the array rather than written into each string.
- * Several classes vary their advice by context (`FurnaceError` drops the
- * validate step, `ChecksumMismatchError` adds a Developer Edition note), and
- * hand-numbered branches had to renumber every later step by hand, one
- * conditional away from printing "2." twice.
- *
- * @param steps - The remedy lines, in order, without their numbers
- * @returns The block, starting with the blank-line separator
- */
-export function remedies(steps) {
-    return `\n\nTo fix this:\n${steps.map((step, index) => `  ${index + 1}. ${step}`).join('\n')}`;
-}
-/**
- * General error for unexpected failures.
- */
-export class GeneralError extends FireForgeError {
-    code = ExitCode.GENERAL_ERROR;
-}
-/**
- * A `fireforge test` preflight gate that refused before any harness ran.
- *
- * Exists to carry a `note`, not to change behaviour: it keeps
- * {@link ExitCode.GENERAL_ERROR}, so `docs/exit-codes.md` and every CI
- * consumer keying on the exit status are untouched. The note is a stable
- * kebab-case refusal class that the `FIREFORGE-VERDICT:` line reports as an
- * additive `note=` key. Without it every preflight refusal reached an
- * unattended reader as the single token `reason=preflight`, which covers
- * everything from a missing build to a peer's packaging record, so the one
- * line that survives a truncating pipe could not say which gate fired.
- */
-export class PreflightRefusalError extends GeneralError {
-    note;
-    constructor(message, 
-    /** Stable refusal class, e.g. `stale-browser`. */
-    note) {
-        super(message);
-        this.note = note;
-    }
-}
-/**
- * Raised when one of FireForge's own internal invariants did not hold:
- * the failure of a runtime assertion from `src/utils/assert.ts`.
- *
- * Dedicated subclass (rather than raw GeneralError) because an invariant
- * failure is categorically different from every other error the CLI
- * raises: it is a bug in FireForge, not something the operator did or can
- * fix. That difference is worth carrying all the way to the exit status
- * (see {@link ExitCode.INTERNAL_ERROR}) so a CI job can escalate it
- * instead of retrying it, and it is the one error class the CLI boundary
- * prints a stack trace for, since the stack is the report.
- *
- * Assertions exist so that a violated invariant stops the run at the
- * first inconsistency instead of continuing to write. In the mutating
- * paths that means the surrounding rollback journal restores the engine
- * before this reaches the operator. See `docs/lifecycle-invariants.md`.
- */
-export class InternalInvariantError extends FireForgeError {
-    code = ExitCode.INTERNAL_ERROR;
-    get userMessage() {
-        return (`Internal error: ${this.message}\n\n` +
-            'This is a bug in FireForge itself, not a problem with your project — ' +
-            'no configuration change on your side would have prevented it. The ' +
-            'operation stopped at the first inconsistency rather than continuing ' +
-            'to write.\n\n' +
-            'To report this:\n' +
-            '  1. Keep the full output above, including the stack trace.\n' +
-            '  2. Note the command you ran and what the project looked like at the time.\n' +
-            '  3. Open an issue at https://github.com/HominisBrowser/FireForge/issues');
-    }
-}
-/**
- * Raised when a regex/brace-depth fallback parser decides it
- * cannot safely perform its mutation, e.g. because a block it expected
- * to walk never closes, because the inserted result fails a round-trip
- * brace balance check, or because an expected pattern is missing.
- *
- * Dedicated subclass (rather than raw GeneralError) so callers and tests
- * can distinguish "the fallback refused to corrupt this file" from other
- * failure modes, and so {@link withParserFallback} callers can opt into
- * re-throwing fallback refusals instead of silently swallowing them.
- */
-export class ParserFallbackError extends FireForgeError {
-    context;
-    code = ExitCode.GENERAL_ERROR;
-    constructor(message, 
-    /** Filename or logical context where the fallback ran (e.g. `browser-init.js`). */
-    context, cause) {
-        super(message, cause);
-        this.context = context;
-    }
-    get userMessage() {
-        return this.context ? `${this.message} (in ${this.context})` : this.message;
-    }
-}
-/**
- * Error thrown when a command-line argument is invalid.
- */
-export class InvalidArgumentError extends FireForgeError {
-    argument;
-    code = ExitCode.INVALID_ARGUMENT;
-    constructor(message, argument, cause) {
-        super(message, cause);
-        this.argument = argument;
-    }
-    get userMessage() {
-        return this.argument
-            ? `Invalid Argument: ${this.message}\n\nArgument: ${this.argument}`
-            : `Invalid Argument: ${this.message}`;
-    }
-}
-/**
- * Error thrown when a spawned command exceeds its `timeout` option.
- *
- * Every `exec*` helper in `src/utils/process.ts` rejects with this type
- * instead of Node's bare `AbortError: The operation was aborted`, which
- * carries no command name, no elapsed time, and no hint that a timeout
- * (rather than the command) was responsible. See
- * {@link GitIndexingTimeoutError} in errors/git.ts for the git-specific
- * variant.
- */
-export class ExecTimeoutError extends FireForgeError {
-    command;
-    args;
-    timeoutMs;
-    code = ExitCode.GENERAL_ERROR;
-    /** Standard output captured before the deadline fired (empty when the exec path does not capture). */
-    stdout;
-    /** Standard error captured before the deadline fired (empty when the exec path does not capture). */
-    stderr;
-    /** True when either captured stream was cut off at the exec layer's collector cap. */
-    outputTruncated;
-    constructor(
-    /** Executable that was spawned (argv[0]). */
-    command, 
-    /** Arguments the executable was spawned with. */
-    args, 
-    /** Timeout that elapsed, in milliseconds. */
-    timeoutMs, cause, output) {
-        super(`Command timed out after ${Math.round(timeoutMs / 1000)}s: ${[command, ...args].join(' ')}`, cause);
-        this.command = command;
-        this.args = args;
-        this.timeoutMs = timeoutMs;
-        this.stdout = output?.stdout ?? '';
-        this.stderr = output?.stderr ?? '';
-        this.outputTruncated = output?.truncated ?? false;
-    }
-    get userMessage() {
-        return (`${this.message}\n\n` +
-            'The command was killed because it exceeded its time budget, not because it failed on its own. ' +
-            'If the host is just slow or loaded, re-running may succeed.' +
-            this.outputTailForUser());
-    }
-    /**
-     * The last few lines the command printed before it was killed, so an
-     * operator can see what it was doing (a `git add -A` stuck on one path,
-     * a build step that hung) instead of a bare budget number. It prefers
-     * stderr and falls back to stdout when stderr is silent.
-     */
-    outputTailForUser() {
-        const source = this.stderr.trim().length > 0 ? this.stderr : this.stdout;
-        const lines = source
-            .trimEnd()
-            .split(/\r?\n/)
-            .filter((line) => line.length > 0);
-        if (lines.length === 0)
-            return '';
-        const tail = lines.slice(-EXEC_TIMEOUT_TAIL_LINES);
-        const label = this.stderr.trim().length > 0 ? 'stderr' : 'stdout';
-        const omitted = lines.length > tail.length ? ` (last ${tail.length} of ${lines.length} lines)` : '';
-        const truncatedNote = this.outputTruncated ? ' [captured output was truncated]' : '';
-        return `\n\nOutput before the timeout (${label}${omitted})${truncatedNote}:\n${tail.map((line) => `  ${line}`).join('\n')}`;
-    }
-}
-/** How many trailing output lines {@link ExecTimeoutError.userMessage} shows. */
-const EXEC_TIMEOUT_TAIL_LINES = 20;
-/**
- * Error thrown when a file-lock wait times out because another process holds
- * the lock.
- *
- * Dedicated subclass so the CLI boundary renders lock contention as the
- * one-line reason-first/remedy-second refusal it is. As a plain `Error` it
- * is treated by `withErrorHandling` as an internal failure and printed with
- * a five-frame stack: a correct refusal that looks like a crash.
- *
- * Exit code 15, not 1: the run never started. A script that retries on
- * failure wants to re-queue this one, not treat it as a failure of the work
- * it asked for. Every lock in FireForge shares the class and therefore the
- * code, because the fact is the same whichever lock was contended.
- */
-export class LockContentionError extends FireForgeError {
-    code = ExitCode.LOCK_TIMEOUT;
-}
-/**
- * Error thrown when a test run completed but its verdict cannot be trusted,
- * because `engine/` changed (or stopped being probeable) while the harness
- * was running.
- *
- * Dedicated subclass for its exit code alone: as a `GeneralError` this
- * refusal exited 1 beside real test failures' 5, and a summary line reading
- * `FAIL, exit 1` next to `FAIL, exit 5` invites treating them as the same
- * kind of fact. They are opposites (one suite failed, the other's result
- * was discarded) and only a distinct code makes "unknown, re-run"
- * mechanically separable from "red".
- */
-export class InconclusiveVerdictError extends FireForgeError {
-    code = ExitCode.INCONCLUSIVE;
-}
-/**
- * Error thrown when the user interrupts an interactive prompt: Esc or
- * Ctrl+C, i.e. `isCancel(...)`.
- *
- * Not for a prompt the operator answered "no" to: 130 is
- * 128+SIGINT, which claims an interrupt. A declined confirmation is a
- * successful run that chose not to proceed, and exits 0.
- */
-export class CancellationError extends FireForgeError {
-    code = ExitCode.USER_CANCELLED;
-    constructor() {
-        super('cancelled');
-    }
-}
-/**
- * Error thrown when patch resolution fails.
- */
-export class ResolutionError extends FireForgeError {
-    code = ExitCode.RESOLUTION_ERROR;
-}
-/**
- * Sentinel error used to propagate an exit code to the CLI entrypoint
- * without calling process.exit() from shared library code.
- *
- * The user-visible error message has already been logged by the time this
- * is thrown. The entrypoint only needs to read `.exitCode` and terminate.
- */
-export class CommandError extends Error {
-    exitCode;
-    constructor(exitCode) {
-        super(`Command failed with exit code ${exitCode}`);
-        this.exitCode = exitCode;
-        this.name = 'CommandError';
-    }
-}

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

@@ -1,92 +0,0 @@
-import { FireForgeError } from './base.js';
-import { ExitCode } from './codes.js';
-/**
- * Error thrown when a build operation fails.
- */
-export declare class BuildError extends FireForgeError {
-    readonly command?: string | undefined;
-    readonly code: ExitCode;
-    constructor(message: string, command?: string | undefined, cause?: Error);
-    get userMessage(): string;
-}
-/**
- * A test suite went red: assertions failed, or sharded runs did not all
- * pass. Distinct from its {@link BuildError} parent only in what it tells
- * the operator, and not in its exit code: `docs/exit-codes.md`
- * documents 5 as "a suite that FAILED", and consumers key CI on it.
- *
- * The parent's remedies are all build remedies ("check the build output",
- * "fireforge bootstrap", "delete obj-* directories") and none of them apply
- * to a failing assertion. Worse, the first points at the wrong half of the
- * log, which is exactly the half a `tail` keeps. Ground truth for a test red
- * is the harness's own output, so the remedies here name the failing tests,
- * the `FIREFORGE-VERDICT:` line, and the run log that survives a pipe.
- *
- * `machineErrorCode` derives the `--json` error code from the class
- * name, so this reports as `test-failure` rather than `build`.
- */
-export declare class TestFailureError extends BuildError {
-    /** Rendered TEST-UNEXPECTED blocks, when the verdict carried any. */
-    readonly failureBlocks?: string | undefined;
-    /** The run's complete raw log, when one was opened. */
-    readonly logPath?: string | undefined;
-    constructor(message: string, command?: string, 
-    /** Rendered TEST-UNEXPECTED blocks, when the verdict carried any. */
-    failureBlocks?: string | undefined, 
-    /** The run's complete raw log, when one was opened. */
-    logPath?: string | undefined);
-    get userMessage(): string;
-}
-/**
- * Error thrown when mach is not available.
- */
-export declare class MachNotFoundError extends BuildError {
-    readonly engineDir: string;
-    readonly code: 7;
-    constructor(engineDir: string);
-    get userMessage(): string;
-}
-/**
- * Error thrown when python is not available.
- */
-export declare class PythonNotFoundError extends BuildError {
-    readonly minVersion: string;
-    readonly maxVersion: string;
-    readonly code: 7;
-    constructor(minVersion?: string, maxVersion?: string);
-    get userMessage(): string;
-}
-/**
- * Error thrown when bootstrap fails.
- */
-export declare class BootstrapError extends BuildError {
-    constructor(cause?: Error);
-    get userMessage(): string;
-}
-/**
- * Error thrown when mozconfig generation fails.
- */
-export declare class MozconfigError extends BuildError {
-    get userMessage(): string;
-}
-/**
- * Error thrown when multiple build output directories exist and FireForge cannot
- * safely choose one.
- */
-export declare class AmbiguousBuildArtifactsError extends BuildError {
-    readonly objDirs: string[];
-    /**
-     * Objdir the active mozconfig declared, when one was declared and did
-     * not resolve to exactly one candidate. Reported because a declaration
-     * that names something the scan cannot see is the diagnosis, not noise.
-     */
-    readonly declaredObjDir?: string | undefined;
-    constructor(objDirs: string[], 
-    /**
-     * Objdir the active mozconfig declared, when one was declared and did
-     * not resolve to exactly one candidate. Reported because a declaration
-     * that names something the scan cannot see is the diagnosis, not noise.
-     */
-    declaredObjDir?: string | undefined);
-    get userMessage(): string;
-}

package/dist/src/errors/build.js

@@ -1,166 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { FireForgeError, remedies } from './base.js';
-import { ExitCode } from './codes.js';
-/**
- * Error thrown when a build operation fails.
- */
-export class BuildError extends FireForgeError {
-    command;
-    code = ExitCode.BUILD_ERROR;
-    constructor(message, command, cause) {
-        super(message, cause);
-        this.command = command;
-    }
-    get userMessage() {
-        return (`Build Error: ${this.message}` +
-            (this.command ? `\n\nCommand: ${this.command}` : '') +
-            remedies([
-                'Check the build output above for specific errors',
-                'Ensure all dependencies are installed with "fireforge bootstrap"',
-                'Try a clean build by deleting obj-* directories',
-            ]));
-    }
-}
-/**
- * A test suite went red: assertions failed, or sharded runs did not all
- * pass. Distinct from its {@link BuildError} parent only in what it tells
- * the operator, and not in its exit code: `docs/exit-codes.md`
- * documents 5 as "a suite that FAILED", and consumers key CI on it.
- *
- * The parent's remedies are all build remedies ("check the build output",
- * "fireforge bootstrap", "delete obj-* directories") and none of them apply
- * to a failing assertion. Worse, the first points at the wrong half of the
- * log, which is exactly the half a `tail` keeps. Ground truth for a test red
- * is the harness's own output, so the remedies here name the failing tests,
- * the `FIREFORGE-VERDICT:` line, and the run log that survives a pipe.
- *
- * `machineErrorCode` derives the `--json` error code from the class
- * name, so this reports as `test-failure` rather than `build`.
- */
-export class TestFailureError extends BuildError {
-    failureBlocks;
-    logPath;
-    constructor(message, command, 
-    /** Rendered TEST-UNEXPECTED blocks, when the verdict carried any. */
-    failureBlocks, 
-    /** The run's complete raw log, when one was opened. */
-    logPath) {
-        super(message, command);
-        this.failureBlocks = failureBlocks;
-        this.logPath = logPath;
-    }
-    get userMessage() {
-        return (`Test Failure: ${this.message}` +
-            (this.command ? `\n\nCommand: ${this.command}` : '') +
-            (this.failureBlocks ? `\n\n${this.failureBlocks}` : '') +
-            remedies([
-                this.failureBlocks
-                    ? 'Fix the failing assertions listed above, then re-run just those test paths'
-                    : 'Find the TEST-UNEXPECTED-FAIL lines in the output above — they name what broke',
-                'Read the "FIREFORGE-VERDICT:" line for the run\'s ground truth (checks, unexpected)',
-                this.logPath !== undefined
-                    ? `The complete raw output is at ${this.logPath} — it survives a piped/tailed terminal`
-                    : 'Re-run without piping the output, so the failure lines are not cut off by "tail"',
-            ]));
-    }
-}
-/**
- * Error thrown when mach is not available.
- */
-export class MachNotFoundError extends BuildError {
-    engineDir;
-    code = ExitCode.MISSING_DEPENDENCY;
-    constructor(engineDir) {
-        super(`mach not found in ${engineDir}`);
-        this.engineDir = engineDir;
-    }
-    get userMessage() {
-        return ('Build Error: Firefox build system (mach) not found.\n\n' +
-            `Expected location: ${this.engineDir}/mach\n\n` +
-            'To fix this:\n' +
-            '  1. Run "fireforge download" to download Firefox source\n' +
-            '  2. Ensure the engine/ directory contains the Firefox source');
-    }
-}
-/**
- * Error thrown when python is not available.
- */
-export class PythonNotFoundError extends BuildError {
-    minVersion;
-    maxVersion;
-    code = ExitCode.MISSING_DEPENDENCY;
-    constructor(minVersion = '3.8', maxVersion = '3.12') {
-        super(`FireForge could not find a Python interpreter supported by Firefox mach (${minVersion}-${maxVersion}).`);
-        this.minVersion = minVersion;
-        this.maxVersion = maxVersion;
-    }
-    get userMessage() {
-        return (`Build Error: Python ${this.minVersion}-${this.maxVersion} is required but not found.\n\n` +
-            'Firefox mach declares the supported Python range in engine/mach, and FireForge could not find any interpreter in that range.\n\n' +
-            'To fix this:\n' +
-            `  1. Install a supported Python version (${this.minVersion}-${this.maxVersion}) from https://python.org/\n` +
-            '  2. Ensure that interpreter is in your PATH (for example as python3.12 or python3)\n' +
-            '  3. Re-run "fireforge doctor" to confirm FireForge can see it');
-    }
-}
-/**
- * Error thrown when bootstrap fails.
- */
-export class BootstrapError extends BuildError {
-    constructor(cause) {
-        super('Bootstrap failed', 'python3 mach bootstrap', cause);
-    }
-    get userMessage() {
-        return ('Build Error: Bootstrap failed.\n\n' +
-            'The Firefox build dependencies could not be installed. This often happens if the Python interpreter selected for mach is missing or misconfigured.\n\n' +
-            'To fix this:\n' +
-            '  1. Check the error output above\n' +
-            '  2. Ensure you have sufficient permissions\n' +
-            '  3. Try running bootstrap manually:\n' +
-            '     cd engine && python3 mach bootstrap');
-    }
-}
-/**
- * Error thrown when mozconfig generation fails.
- */
-export class MozconfigError extends BuildError {
-    get userMessage() {
-        return (`Build Error: ${this.message}\n\n` +
-            'To fix this:\n' +
-            '  1. Check that configs/ directory exists\n' +
-            '  2. Ensure platform-specific mozconfig exists\n' +
-            '  3. Run "fireforge setup" to regenerate configs');
-    }
-}
-/**
- * Error thrown when multiple build output directories exist and FireForge cannot
- * safely choose one.
- */
-export class AmbiguousBuildArtifactsError extends BuildError {
-    objDirs;
-    declaredObjDir;
-    constructor(objDirs, 
-    /**
-     * Objdir the active mozconfig declared, when one was declared and did
-     * not resolve to exactly one candidate. Reported because a declaration
-     * that names something the scan cannot see is the diagnosis, not noise.
-     */
-    declaredObjDir) {
-        super(`Multiple build artifact directories found: ${objDirs.join(', ')}`);
-        this.objDirs = objDirs;
-        this.declaredObjDir = declaredObjDir;
-    }
-    get userMessage() {
-        const declared = this.declaredObjDir !== undefined
-            ? `The mozconfig declares MOZ_OBJDIR=${this.declaredObjDir}, which does not match exactly one of these candidates — so it could not settle the choice.\n\n`
-            : '';
-        return ('Build Error: Multiple build artifact directories were found.\n\n' +
-            `Candidates: ${this.objDirs.join(', ')}\n\n` +
-            declared +
-            'FireForge will not guess which build output to use.\n\n' +
-            'To fix this:\n' +
-            '  1. Remove stale obj-* directories you no longer need\n' +
-            '  2. Keep only the active build output directory, or name it with MOZ_OBJDIR in the mozconfig\n' +
-            '  3. Run the command again');
-    }
-}

package/dist/src/errors/codes.d.ts

@@ -1,74 +0,0 @@
-/**
- * Exit codes for fireforge CLI operations.
- * Each code represents a specific category of failure.
- */
-export declare const ExitCode: {
-    /** Operation completed successfully */
-    readonly SUCCESS: 0;
-    /** Unspecified error */
-    readonly GENERAL_ERROR: 1;
-    /** fireforge.json missing or invalid */
-    readonly CONFIG_ERROR: 2;
-    /** Failed to download or extract Firefox source */
-    readonly DOWNLOAD_ERROR: 3;
-    /** Git operation failed */
-    readonly GIT_ERROR: 4;
-    /** mach build failed */
-    readonly BUILD_ERROR: 5;
-    /** Patch application failed */
-    readonly PATCH_ERROR: 6;
-    /** Required tool not found (python3, git, tar) */
-    readonly MISSING_DEPENDENCY: 7;
-    /** Invalid command-line argument */
-    readonly INVALID_ARGUMENT: 8;
-    /** Furnace component management error */
-    readonly FURNACE_ERROR: 9;
-    /** Patch conflict resolution error */
-    readonly RESOLUTION_ERROR: 10;
-    /**
-     * An internal invariant did not hold: a bug in FireForge itself, not a
-     * user or environment failure. Distinct from GENERAL_ERROR because the
-     * two call for opposite responses: a GENERAL_ERROR usually means the
-     * operator must change something (fix a config, free a lock, retry), and
-     * an INTERNAL_ERROR means nothing the operator can change would have
-     * helped and the run should be reported instead. Scripts and CI that
-     * retry on failure want to retry the former and escalate the latter.
-     */
-    readonly INTERNAL_ERROR: 11;
-    /**
-     * `fireforge run --smoke-exit` observed one or more unallowed console
-     * error lines inside the smoke window. Distinct from BUILD_ERROR so CI
-     * can route smoke regressions separately from compile/config failures.
-     */
-    readonly SMOKE_EXIT_FAILURE: 12;
-    /**
-     * `fireforge run --smoke-exit` saw the browser exit with a non-clean
-     * status before the smoke window elapsed. This is a launch-side failure
-     * that did not surface as a console error line (crash before console
-     * wiring, missing profile, etc.).
-     */
-    readonly SMOKE_LAUNCH_FAILURE: 13;
-    /**
-     * A `fireforge test` run produced a harness result that cannot be
-     * trusted: `engine/` moved (or became unprobeable) while the tests ran.
-     * Distinct from BUILD_ERROR because the two are opposites: a 5 is a suite
-     * that failed, a 14 is a suite whose result was thrown away. A consumer should
-     * re-run a 14 (after settling the writers) and must not report it as red.
-     */
-    readonly INCONCLUSIVE: 14;
-    /**
-     * A lock wait expired: the run never started, because another FireForge
-     * process held the lock for the whole budget. Distinct from GENERAL_ERROR
-     * because nothing about the request was wrong. A consumer should re-queue
-     * it, with a larger `--wait-lock` budget, rather than treat it as a
-     * failure of the work it asked for.
-     */
-    readonly LOCK_TIMEOUT: 15;
-    /**
-     * The user cancelled an interactive prompt. 130 = 128 + SIGINT, the
-     * conventional "interrupted by the user" code, so scripts and CI can tell
-     * a deliberate cancellation apart from a real failure (GENERAL_ERROR).
-     */
-    readonly USER_CANCELLED: 130;
-};
-export type ExitCode = (typeof ExitCode)[keyof typeof ExitCode];

package/dist/src/errors/codes.js

@@ -1,74 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Exit codes for fireforge CLI operations.
- * Each code represents a specific category of failure.
- */
-export const ExitCode = {
-    /** Operation completed successfully */
-    SUCCESS: 0,
-    /** Unspecified error */
-    GENERAL_ERROR: 1,
-    /** fireforge.json missing or invalid */
-    CONFIG_ERROR: 2,
-    /** Failed to download or extract Firefox source */
-    DOWNLOAD_ERROR: 3,
-    /** Git operation failed */
-    GIT_ERROR: 4,
-    /** mach build failed */
-    BUILD_ERROR: 5,
-    /** Patch application failed */
-    PATCH_ERROR: 6,
-    /** Required tool not found (python3, git, tar) */
-    MISSING_DEPENDENCY: 7,
-    /** Invalid command-line argument */
-    INVALID_ARGUMENT: 8,
-    /** Furnace component management error */
-    FURNACE_ERROR: 9,
-    /** Patch conflict resolution error */
-    RESOLUTION_ERROR: 10,
-    /**
-     * An internal invariant did not hold: a bug in FireForge itself, not a
-     * user or environment failure. Distinct from GENERAL_ERROR because the
-     * two call for opposite responses: a GENERAL_ERROR usually means the
-     * operator must change something (fix a config, free a lock, retry), and
-     * an INTERNAL_ERROR means nothing the operator can change would have
-     * helped and the run should be reported instead. Scripts and CI that
-     * retry on failure want to retry the former and escalate the latter.
-     */
-    INTERNAL_ERROR: 11,
-    /**
-     * `fireforge run --smoke-exit` observed one or more unallowed console
-     * error lines inside the smoke window. Distinct from BUILD_ERROR so CI
-     * can route smoke regressions separately from compile/config failures.
-     */
-    SMOKE_EXIT_FAILURE: 12,
-    /**
-     * `fireforge run --smoke-exit` saw the browser exit with a non-clean
-     * status before the smoke window elapsed. This is a launch-side failure
-     * that did not surface as a console error line (crash before console
-     * wiring, missing profile, etc.).
-     */
-    SMOKE_LAUNCH_FAILURE: 13,
-    /**
-     * A `fireforge test` run produced a harness result that cannot be
-     * trusted: `engine/` moved (or became unprobeable) while the tests ran.
-     * Distinct from BUILD_ERROR because the two are opposites: a 5 is a suite
-     * that failed, a 14 is a suite whose result was thrown away. A consumer should
-     * re-run a 14 (after settling the writers) and must not report it as red.
-     */
-    INCONCLUSIVE: 14,
-    /**
-     * A lock wait expired: the run never started, because another FireForge
-     * process held the lock for the whole budget. Distinct from GENERAL_ERROR
-     * because nothing about the request was wrong. A consumer should re-queue
-     * it, with a larger `--wait-lock` budget, rather than treat it as a
-     * failure of the work it asked for.
-     */
-    LOCK_TIMEOUT: 15,
-    /**
-     * The user cancelled an interactive prompt. 130 = 128 + SIGINT, the
-     * conventional "interrupted by the user" code, so scripts and CI can tell
-     * a deliberate cancellation apart from a real failure (GENERAL_ERROR).
-     */
-    USER_CANCELLED: 130,
-};