@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,17 +0,0 @@
-import { FireForgeError } from './base.js';
-/**
- * Error thrown when configuration is missing or invalid.
- */
-export declare class ConfigError extends FireForgeError {
-    readonly field?: string | undefined;
-    readonly code: 2;
-    constructor(message: string, field?: string | undefined, cause?: Error);
-    get userMessage(): string;
-}
-/**
- * Error thrown when fireforge.json is not found.
- */
-export declare class ConfigNotFoundError extends ConfigError {
-    constructor(configPath: string);
-    get userMessage(): string;
-}

package/dist/src/errors/config.js

@@ -1,39 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { FireForgeError, remedies } from './base.js';
-import { ExitCode } from './codes.js';
-/**
- * Error thrown when configuration is missing or invalid.
- */
-export class ConfigError extends FireForgeError {
-    field;
-    code = ExitCode.CONFIG_ERROR;
-    constructor(message, field, cause) {
-        super(message, cause);
-        this.field = field;
-    }
-    get userMessage() {
-        return (`Configuration Error: ${this.message}` +
-            (this.field ? `\n\nField: ${this.field}` : '') +
-            remedies([
-                'Check your fireforge.json file for errors',
-                'Run "fireforge setup" to create a new configuration',
-                'See the documentation for the expected format',
-            ]));
-    }
-}
-/**
- * Error thrown when fireforge.json is not found.
- */
-export class ConfigNotFoundError extends ConfigError {
-    constructor(configPath) {
-        super(`Configuration file not found: ${configPath}`);
-    }
-    get userMessage() {
-        return (`Configuration Error: ${this.message}\n\n` +
-            'This directory does not appear to be a FireForge project.' +
-            remedies([
-                'Navigate to your project root directory',
-                'Run "fireforge setup" to initialize a new project',
-            ]));
-    }
-}

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

@@ -1,66 +0,0 @@
-import type { FirefoxProduct } from '../types/config.js';
-import { FireForgeError } from './base.js';
-/**
- * Error thrown when Firefox source download fails.
- */
-export declare class DownloadError extends FireForgeError {
-    readonly url?: string | undefined;
-    readonly code: 3;
-    constructor(message: string, url?: string | undefined, cause?: Error);
-    get userMessage(): string;
-}
-/**
- * Error thrown when a pinned Firefox source archive checksum does not match.
- */
-export declare class ChecksumMismatchError extends DownloadError {
-    readonly product: FirefoxProduct;
-    readonly expectedSha256: string;
-    readonly actualSha256: string;
-    constructor(product: FirefoxProduct, expectedSha256: string, actualSha256: string, url: string);
-    get userMessage(): string;
-}
-/**
- * Error thrown when the default integrity check cannot obtain Mozilla's
- * published SHA-256 for a freshly downloaded archive (checksum file
- * unreachable, malformed, or not listing the archive) and no operator pin
- * or explicit opt-out allows the download to be trusted on TLS alone.
- */
-export declare class ChecksumUnavailableError extends DownloadError {
-    readonly product: FirefoxProduct;
-    readonly checksumsUrl: string;
-    readonly reason: string;
-    constructor(product: FirefoxProduct, checksumsUrl: string, reason: string, url: string);
-    get userMessage(): string;
-}
-/**
- * Error thrown when extraction of the downloaded archive fails.
- */
-export declare class ExtractionError extends DownloadError {
-    readonly archivePath: string;
-    constructor(archivePath: string, cause?: Error);
-    get userMessage(): string;
-}
-/**
- * Error thrown when the Firefox version is not found on the server.
- */
-export declare class VersionNotFoundError extends DownloadError {
-    readonly version: string;
-    constructor(version: string);
-    get userMessage(): string;
-}
-/**
- * Error thrown when engine directory already exists.
- */
-export declare class EngineExistsError extends DownloadError {
-    readonly enginePath: string;
-    constructor(enginePath: string);
-    get userMessage(): string;
-}
-/**
- * Error thrown when engine/ exists but contains an unborn git repo from a failed download.
- */
-export declare class PartialEngineExistsError extends DownloadError {
-    readonly enginePath: string;
-    constructor(enginePath: string, cause?: Error);
-    get userMessage(): string;
-}

package/dist/src/errors/download.js

@@ -1,160 +0,0 @@
-import { FireForgeError, remedies } from './base.js';
-import { ExitCode } from './codes.js';
-/**
- * Error thrown when Firefox source download fails.
- */
-export class DownloadError extends FireForgeError {
-    url;
-    code = ExitCode.DOWNLOAD_ERROR;
-    constructor(message, url, cause) {
-        super(message, cause);
-        this.url = url;
-    }
-    get userMessage() {
-        return (`Download Error: ${this.message}` +
-            (this.url ? `\n\nURL: ${this.url}` : '') +
-            remedies([
-                'Check your internet connection',
-                'Verify the Firefox version in fireforge.json is valid',
-                'Try again with "fireforge download --force"',
-            ]));
-    }
-}
-/**
- * Error thrown when a pinned Firefox source archive checksum does not match.
- */
-export class ChecksumMismatchError extends DownloadError {
-    product;
-    expectedSha256;
-    actualSha256;
-    constructor(product, expectedSha256, actualSha256, url) {
-        super(`Downloaded archive SHA-256 mismatch: expected ${expectedSha256}, got ${actualSha256}`, url);
-        this.product = product;
-        this.expectedSha256 = expectedSha256;
-        this.actualSha256 = actualSha256;
-    }
-    get userMessage() {
-        return (`Download Error: Firefox source archive checksum mismatch.\n\n` +
-            `Product: ${this.product}\n` +
-            `URL: ${this.url}\n` +
-            `Expected SHA-256: ${this.expectedSha256}\n` +
-            `Actual SHA-256: ${this.actualSha256}` +
-            remedies([
-                'Verify firefox.product, firefox.version, and firefox.sha256 in fireforge.json',
-                'Compare the pinned hash with Mozilla SHA256SUMMARY for the resolved archive',
-                ...(this.product === 'firefox-devedition'
-                    ? [
-                        'Developer Edition archives should resolve under https://archive.mozilla.org/pub/devedition/releases/',
-                    ]
-                    : []),
-                'Re-run "fireforge download --force" after correcting the source settings',
-            ]));
-    }
-}
-/**
- * Error thrown when the default integrity check cannot obtain Mozilla's
- * published SHA-256 for a freshly downloaded archive (checksum file
- * unreachable, malformed, or not listing the archive) and no operator pin
- * or explicit opt-out allows the download to be trusted on TLS alone.
- */
-export class ChecksumUnavailableError extends DownloadError {
-    product;
-    checksumsUrl;
-    reason;
-    constructor(product, checksumsUrl, reason, url) {
-        super(`Could not verify archive against published SHA256SUMS: ${reason}`, url);
-        this.product = product;
-        this.checksumsUrl = checksumsUrl;
-        this.reason = reason;
-    }
-    get userMessage() {
-        return (`Download Error: Firefox source archive integrity could not be verified.\n\n` +
-            `Product: ${this.product}\n` +
-            `Archive: ${this.url ?? ''}\n` +
-            `Checksums: ${this.checksumsUrl}\n` +
-            `Reason: ${this.reason}\n\n` +
-            'The archive was downloaded but discarded: without the published digest it would be ' +
-            'trusted on TLS alone, and it becomes the git baseline every patch is built on.\n\n' +
-            'To fix this:\n' +
-            '  1. Check connectivity to archive.mozilla.org (a captive portal or proxy may be ' +
-            'answering the SHA256SUMS request) and retry\n' +
-            '  2. Or pin the archive digest: set firefox.sha256 in fireforge.json ' +
-            '(from the release SHA256SUMS, obtained out of band)\n' +
-            '  3. Or, for an offline mirror you trust, set firefox.allowUnverifiedDownload: true ' +
-            'in fireforge.json to accept the download with a warning');
-    }
-}
-/**
- * Error thrown when extraction of the downloaded archive fails.
- */
-export class ExtractionError extends DownloadError {
-    archivePath;
-    constructor(archivePath, cause) {
-        super(`Failed to extract archive: ${archivePath}`, undefined, cause);
-        this.archivePath = archivePath;
-    }
-    get userMessage() {
-        const reason = this.cause instanceof Error ? `Reason: ${this.cause.message}\n\n` : '';
-        return (`Extraction Error: Failed to extract Firefox source archive.\n\n` +
-            `Archive: ${this.archivePath}\n\n` +
-            reason +
-            'To fix this:\n' +
-            '  1. Delete the corrupted archive and try again\n' +
-            '  2. Ensure you have enough disk space\n' +
-            '  3. Verify tar/xz tools are installed');
-    }
-}
-/**
- * Error thrown when the Firefox version is not found on the server.
- */
-export class VersionNotFoundError extends DownloadError {
-    version;
-    constructor(version) {
-        super(`Firefox version ${version} not found on archive.mozilla.org`);
-        this.version = version;
-    }
-    get userMessage() {
-        return (`Download Error: Firefox version "${this.version}" was not found.\n\n` +
-            'To fix this:\n' +
-            '  1. Check the version number in fireforge.json\n' +
-            '  2. Visit https://archive.mozilla.org/pub/firefox/releases/ to see available versions\n' +
-            '  3. Update firefox.version in fireforge.json to a valid version');
-    }
-}
-/**
- * Error thrown when engine directory already exists.
- */
-export class EngineExistsError extends DownloadError {
-    enginePath;
-    constructor(enginePath) {
-        super(`Engine directory already exists: ${enginePath}`);
-        this.enginePath = enginePath;
-    }
-    get userMessage() {
-        return (`Download Error: Firefox source already exists.\n\n` +
-            `Path: ${this.enginePath}\n\n` +
-            'To fix this:\n' +
-            '  1. Use "fireforge download --force" to re-download\n' +
-            '  2. Or manually delete the engine/ directory');
-    }
-}
-/**
- * Error thrown when engine/ exists but contains an unborn git repo from a failed download.
- */
-export class PartialEngineExistsError extends DownloadError {
-    enginePath;
-    constructor(enginePath, cause) {
-        super(`Engine directory contains a partially initialized checkout: ${enginePath}`, undefined, cause);
-        this.enginePath = enginePath;
-    }
-    get userMessage() {
-        const causeMessage = this.cause instanceof Error && this.cause.message ? this.cause.message : undefined;
-        return (`Download Error: Firefox source exists, but the baseline git repository was not fully initialized.\n\n` +
-            `Path: ${this.enginePath}\n\n` +
-            (causeMessage ? `Underlying cause: ${causeMessage}\n\n` : '') +
-            'To fix this:\n' +
-            '  1. Re-run "fireforge download --force" to recreate the baseline repository\n' +
-            '  2. Or manually delete the engine/ directory before downloading again\n' +
-            '  3. Re-run with --verbose for the full underlying error and stack trace');
-    }
-}

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

@@ -1,20 +0,0 @@
-import { FireForgeError } from './base.js';
-/**
- * Error thrown when a furnace component operation fails.
- */
-export declare class FurnaceError extends FireForgeError {
-    readonly component?: string | undefined;
-    readonly code: 9;
-    constructor(message: string, component?: string | undefined, cause?: Error, options?: {
-        /**
-         * Suppresses the "run furnace validate" advice line. Set by callers
-         * whose message already tells the user to run validate, or that are
-         * the validate command. An explicit flag rather than sniffing the
-         * message for `furnace validate`, which drops the advice from any
-         * error that merely mentions the command.
-         */
-        omitValidateAdvice?: boolean;
-    });
-    private readonly omitValidateAdvice;
-    get userMessage(): string;
-}

package/dist/src/errors/furnace.js

@@ -1,28 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { FireForgeError, remedies } from './base.js';
-import { ExitCode } from './codes.js';
-/**
- * Error thrown when a furnace component operation fails.
- */
-export class FurnaceError extends FireForgeError {
-    component;
-    code = ExitCode.FURNACE_ERROR;
-    constructor(message, component, cause, options) {
-        super(message, cause);
-        this.component = component;
-        this.omitValidateAdvice =
-            options?.omitValidateAdvice ?? message.includes('Run "fireforge furnace validate"');
-    }
-    omitValidateAdvice;
-    get userMessage() {
-        const head = this.component
-            ? `Furnace Error (${this.component}): ${this.message}`
-            : `Furnace Error: ${this.message}`;
-        return (head +
-            remedies([
-                'Check the error message above for specifics',
-                ...(this.omitValidateAdvice ? [] : ['Run "fireforge furnace validate" to diagnose issues']),
-                'Use "fireforge doctor --repair-furnace" if state is inconsistent',
-            ]));
-    }
-}

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

@@ -1,65 +0,0 @@
-import { FireForgeError } from './base.js';
-import { ExitCode } from './codes.js';
-/**
- * Error thrown when a git operation fails.
- */
-export declare class GitError extends FireForgeError {
-    readonly command?: string | undefined;
-    readonly code: ExitCode;
-    constructor(message: string, command?: string | undefined, cause?: Error);
-    get userMessage(): string;
-}
-/**
- * Error thrown when git is not installed.
- *
- * MISSING_DEPENDENCY, not GIT_ERROR: the fact is "a required tool is
- * absent", the same fact `PythonNotFoundError` and `MachNotFoundError`
- * report, and a consumer should install something rather than inspect a
- * repository.
- */
-export declare class GitNotFoundError extends GitError {
-    readonly code: 7;
-    constructor();
-    get userMessage(): string;
-}
-/**
- * Error thrown when applying a patch fails.
- */
-export declare class PatchApplyError extends GitError {
-    readonly patchPath: string;
-    constructor(patchPath: string, cause?: Error);
-    get userMessage(): string;
-}
-/**
- * Error thrown when a stale git index lock blocks repository initialization.
- */
-export declare class GitIndexLockError extends GitError {
-    readonly lockPath: string;
-    readonly ageMs?: number | undefined;
-    constructor(lockPath: string, ageMs?: number | undefined);
-    get userMessage(): string;
-}
-/**
- * Detects transient git `index.lock` contention: an external git process
- * holding `.git/index.lock` while we stage or diff. Mirrors the message
- * heuristics `core/git.ts` uses when wrapping stale-lock failures during
- * download, but lives here so command modules can consult it without
- * importing (frequently vi.mocked) core git internals.
- */
-export declare function isGitIndexLockConflict(error: unknown): boolean;
-/**
- * Error thrown when `git add` (monolithic or chunked) exceeds the configured
- * timeout while indexing the Firefox source tree.
- *
- * A bare `AbortError: The operation was aborted` after ~15 minutes is
- * indistinguishable from any other AbortError and gives the operator no
- * actionable direction. This typed error carries the elapsed budget and the
- * environment-variable override so the recovery path is self-documenting.
- */
-export declare class GitIndexingTimeoutError extends GitError {
-    readonly phase: 'monolithic' | 'chunked';
-    readonly timeoutMs: number;
-    readonly envVar: string;
-    constructor(phase: 'monolithic' | 'chunked', timeoutMs: number, envVar: string, cause?: Error);
-    get userMessage(): string;
-}

package/dist/src/errors/git.js

@@ -1,140 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { FireForgeError, remedies } from './base.js';
-import { ExitCode } from './codes.js';
-/**
- * Error thrown when a git operation fails.
- */
-export class GitError extends FireForgeError {
-    command;
-    code = ExitCode.GIT_ERROR;
-    constructor(message, command, cause) {
-        super(message, cause);
-        this.command = command;
-    }
-    get userMessage() {
-        return (`Git Error: ${this.message}` +
-            (this.command ? `\n\nCommand: git ${this.command}` : '') +
-            remedies([
-                'Ensure git is installed and in your PATH',
-                'Check if the repository is in a valid state',
-                'Try running "fireforge reset" to start fresh',
-            ]));
-    }
-}
-/**
- * Error thrown when git is not installed.
- *
- * MISSING_DEPENDENCY, not GIT_ERROR: the fact is "a required tool is
- * absent", the same fact `PythonNotFoundError` and `MachNotFoundError`
- * report, and a consumer should install something rather than inspect a
- * repository.
- */
-export class GitNotFoundError extends GitError {
-    code = ExitCode.MISSING_DEPENDENCY;
-    constructor() {
-        super('Git is not installed or not found in PATH');
-    }
-    get userMessage() {
-        return ('Git Error: Git is not installed or not found in PATH.\n\n' +
-            'To fix this:\n' +
-            '  1. Install git from https://git-scm.com/\n' +
-            '  2. Ensure git is in your system PATH\n' +
-            '  3. Restart your terminal and try again');
-    }
-}
-/**
- * Error thrown when applying a patch fails.
- */
-export class PatchApplyError extends GitError {
-    patchPath;
-    constructor(patchPath, cause) {
-        super(`Failed to apply patch: ${patchPath}`, 'apply', cause);
-        this.patchPath = patchPath;
-    }
-    get userMessage() {
-        return (`Git Error: Failed to apply patch.\n\n` +
-            `Patch: ${this.patchPath}\n\n` +
-            'This usually means the patch conflicts with existing changes.' +
-            remedies([
-                'Check if the Firefox version matches the patch',
-                'Use "fireforge reset" to start with clean source',
-                'Update the patch to match the current Firefox version',
-            ]));
-    }
-}
-/**
- * Error thrown when a stale git index lock blocks repository initialization.
- */
-export class GitIndexLockError extends GitError {
-    lockPath;
-    ageMs;
-    constructor(lockPath, ageMs) {
-        super(`Git index is locked: ${lockPath}`, 'add -A');
-        this.lockPath = lockPath;
-        this.ageMs = ageMs;
-    }
-    get userMessage() {
-        const ageDescription = this.ageMs === undefined
-            ? ''
-            : `\nApproximate lock age: ${Math.max(1, Math.round(this.ageMs / 60000))} minute(s)\n`;
-        return ('Git Error: Firefox source indexing is blocked by an existing git index lock.\n\n' +
-            `Lock file: ${this.lockPath}${ageDescription}\n` +
-            'This usually means a previous git or FireForge process was interrupted while indexing the engine tree.\n\n' +
-            'To fix this:\n' +
-            '  1. Make sure no other git process is still running inside engine/\n' +
-            `  2. Remove "${this.lockPath}" if it is stale\n` +
-            '  3. Re-run "fireforge download --force"');
-    }
-}
-/**
- * Detects transient git `index.lock` contention: an external git process
- * holding `.git/index.lock` while we stage or diff. Mirrors the message
- * heuristics `core/git.ts` uses when wrapping stale-lock failures during
- * download, but lives here so command modules can consult it without
- * importing (frequently vi.mocked) core git internals.
- */
-export function isGitIndexLockConflict(error) {
-    if (error instanceof GitIndexLockError) {
-        return true;
-    }
-    if (!(error instanceof GitError)) {
-        return false;
-    }
-    return (/index\.lock/i.test(error.message) &&
-        /(unable to create|another git process seems to be running|file exists|locked)/i.test(error.message));
-}
-/**
- * Error thrown when `git add` (monolithic or chunked) exceeds the configured
- * timeout while indexing the Firefox source tree.
- *
- * A bare `AbortError: The operation was aborted` after ~15 minutes is
- * indistinguishable from any other AbortError and gives the operator no
- * actionable direction. This typed error carries the elapsed budget and the
- * environment-variable override so the recovery path is self-documenting.
- */
-export class GitIndexingTimeoutError extends GitError {
-    phase;
-    timeoutMs;
-    envVar;
-    constructor(phase, timeoutMs, envVar, cause) {
-        super(`Git ${phase} indexing exceeded the ${Math.round(timeoutMs / 1000)}s timeout`, 'add -A', cause);
-        this.phase = phase;
-        this.timeoutMs = timeoutMs;
-        this.envVar = envVar;
-    }
-    get userMessage() {
-        const minutes = Math.max(1, Math.round(this.timeoutMs / 60_000));
-        const phaseDescription = this.phase === 'monolithic'
-            ? 'the monolithic `git add -A` pass'
-            : 'one of the chunked `git add -- <dir>` passes';
-        return (`Git Error: ${phaseDescription} exceeded the ${minutes}-minute timeout while indexing the Firefox source tree.\n\n` +
-            'Common triggers:\n' +
-            '  - Slow or loaded disk (an external volume, encrypted filesystem, or heavily-used SSD under load).\n' +
-            '  - A Firefox source tree that has grown beyond what the default timeout accommodates.\n' +
-            '  - A background process (antivirus, backup, indexing) holding the working directory.\n\n' +
-            'To recover:\n' +
-            `  1. Extend the timeout via the ${this.envVar} environment variable (milliseconds; e.g. "export ${this.envVar}=1800000" for 30 minutes).\n` +
-            '  2. Re-run "fireforge download --force" — the resume path resumes from the partial initialisation, so the repeat pass is not wasted work.\n' +
-            '  3. If the problem persists, check disk throughput and free space; Firefox source indexing on a cold SSD typically completes in 1–3 minutes.');
-    }
-}

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

@@ -1,27 +0,0 @@
-import { FireForgeError } from './base.js';
-/**
- * Error thrown when `patches.json` exists but cannot be parsed or validated.
- *
- * This must be a hard error on every mutating path. Collapsing "corrupt"
- * into "absent" (a `loadPatchesManifest` that returns null for both) makes
- * the next `fireforge export` rebuild the manifest containing only the new
- * patch, silently destroying every other patch's metadata (tiers,
- * descriptions, lintIgnore, staged dependencies). A failed export's rollback
- * then deletes `patches.json` outright, because the "before" state looked
- * absent.
- */
-export declare class PatchManifestCorruptError extends FireForgeError {
-    readonly manifestPath: string;
-    readonly code: 6;
-    constructor(manifestPath: string, cause?: Error);
-    get userMessage(): string;
-}
-/**
- * Error thrown when patch operations fail.
- */
-export declare class PatchError extends FireForgeError {
-    readonly patchName?: string | undefined;
-    readonly code: 6;
-    constructor(message: string, patchName?: string | undefined, cause?: Error);
-    get userMessage(): string;
-}

package/dist/src/errors/patch.js

@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { FireForgeError, remedies } from './base.js';
-import { ExitCode } from './codes.js';
-/**
- * Error thrown when `patches.json` exists but cannot be parsed or validated.
- *
- * This must be a hard error on every mutating path. Collapsing "corrupt"
- * into "absent" (a `loadPatchesManifest` that returns null for both) makes
- * the next `fireforge export` rebuild the manifest containing only the new
- * patch, silently destroying every other patch's metadata (tiers,
- * descriptions, lintIgnore, staged dependencies). A failed export's rollback
- * then deletes `patches.json` outright, because the "before" state looked
- * absent.
- */
-export class PatchManifestCorruptError extends FireForgeError {
-    manifestPath;
-    code = ExitCode.PATCH_ERROR;
-    constructor(manifestPath, cause) {
-        super(`patches.json exists but could not be parsed: ${cause?.message ?? 'unknown parse error'}`, cause);
-        this.manifestPath = manifestPath;
-    }
-    get userMessage() {
-        return (`Patch Manifest Error: ${this.message}\n\n` +
-            `Manifest: ${this.manifestPath}\n\n` +
-            'FireForge refuses to modify the patch queue while patches.json is unreadable — ' +
-            'rewriting it now would silently discard the metadata of every patch it lists.\n\n' +
-            'To fix this:\n' +
-            '  1. Open patches.json and repair the syntax error (a recent hand-edit is the usual cause)\n' +
-            '  2. Or restore patches.json from version control\n' +
-            '  3. Then re-run the command');
-    }
-}
-/**
- * Error thrown when patch operations fail.
- */
-export class PatchError extends FireForgeError {
-    patchName;
-    code = ExitCode.PATCH_ERROR;
-    constructor(message, patchName, cause) {
-        super(message, cause);
-        this.patchName = patchName;
-    }
-    get userMessage() {
-        return (`Patch Error: ${this.message}` +
-            (this.patchName ? `\n\nPatch: ${this.patchName}` : '') +
-            remedies([
-                'Check if the patch is compatible with the Firefox version',
-                'Use "fireforge reset" to start with clean source',
-                'Update the patch for the current Firefox version',
-            ]));
-    }
-}

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

@@ -1,42 +0,0 @@
-import { FireForgeError } from './base.js';
-/**
- * Base error for rebase operations.
- */
-export declare class RebaseError extends FireForgeError {
-    readonly code: 6;
-    get userMessage(): string;
-}
-/**
- * Thrown when starting a rebase while an existing session is in progress.
- */
-export declare class RebaseSessionExistsError extends RebaseError {
-    constructor();
-}
-/**
- * Thrown when --continue or --abort is used without an active session.
- */
-export declare class NoRebaseSessionError extends RebaseError {
-    constructor();
-}
-/**
- * Thrown when the session file exists but cannot be used.
- *
- * Without an error of its own, this case is reported as
- * {@link NoRebaseSessionError} by `--continue`/`--abort` while `rebase`
- * reports {@link RebaseSessionExistsError}, a closed cycle in which each
- * command points at the other two. The message names the file so an operator
- * always has a way out, and `--abort` clears a corrupt session rather than
- * refusing to run against one.
- */
-export declare class CorruptRebaseSessionError extends RebaseError {
-    constructor(sessionPath: string, reason: string);
-}
-/**
- * Thrown by `rebase --dry-run` when the replay rejects at least one patch.
- * A dry run that exited 0 regardless would read as "the rebase is ready".
- */
-export declare class RebaseDryRunRejectError extends RebaseError {
-    readonly rejected: readonly string[];
-    constructor(rejected: readonly string[]);
-    get userMessage(): string;
-}