@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/preflight-wait.d.ts

@@ -1,22 +0,0 @@
-/** Waits for a busy browser or port without changing or terminating its owner. */
-export declare function waitForPreflight(action: () => Promise<void>, seconds?: number): Promise<void>;
-/**
- * Spends a `--wait-browser`/`--wait-port` budget BEFORE the engine session
- * lock is taken, so a run queued behind a busy browser or port does not
- * hold the lock (and every peer's build, test and re-export behind it)
- * while it does nothing. The caller re-checks once under the lock.
- *
- * Never refuses on its own: when the budget runs out the run still joins
- * the lock queue, and the single check under the lock decides. A peer's
- * test run that holds the lock legitimately keeps its browser alive until
- * it releases, and refusing here would turn that ordinary queue into a
- * refusal the old in-lock wait never produced. Never terminates anything
- * either: nothing is owned before the lock is won. A refusal whose note is
- * in `clearNotes` (a stale browser the run is allowed to reap under the
- * lock) counts as clear.
- *
- * @param action - The preflight probe, which throws `PreflightRefusalError` while busy
- * @param seconds - The wait budget
- * @param clearNotes - Refusal classes that do not need waiting out
- */
-export declare function waitBeforeLock(action: () => Promise<void>, seconds: number | undefined, clearNotes?: readonly string[]): Promise<void>;

package/dist/src/core/preflight-wait.js

@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { PreflightRefusalError } from '../errors/base.js';
-import { info } from '../utils/logger.js';
-import { sleep } from '../utils/sleep.js';
-/** Waits for a busy browser or port without changing or terminating its owner. */
-export async function waitForPreflight(action, seconds) {
-    const deadline = Date.now() + (seconds ?? 0) * 1000;
-    let announced = false;
-    for (;;) {
-        try {
-            await action();
-            return;
-        }
-        catch (error) {
-            if (!(error instanceof PreflightRefusalError) || Date.now() >= deadline)
-                throw error;
-            if (!announced) {
-                info(`Waiting up to ${seconds} seconds: ${error.message}`);
-                announced = true;
-            }
-            await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
-        }
-    }
-}
-/**
- * Spends a `--wait-browser`/`--wait-port` budget BEFORE the engine session
- * lock is taken, so a run queued behind a busy browser or port does not
- * hold the lock (and every peer's build, test and re-export behind it)
- * while it does nothing. The caller re-checks once under the lock.
- *
- * Never refuses on its own: when the budget runs out the run still joins
- * the lock queue, and the single check under the lock decides. A peer's
- * test run that holds the lock legitimately keeps its browser alive until
- * it releases, and refusing here would turn that ordinary queue into a
- * refusal the old in-lock wait never produced. Never terminates anything
- * either: nothing is owned before the lock is won. A refusal whose note is
- * in `clearNotes` (a stale browser the run is allowed to reap under the
- * lock) counts as clear.
- *
- * @param action - The preflight probe, which throws `PreflightRefusalError` while busy
- * @param seconds - The wait budget
- * @param clearNotes - Refusal classes that do not need waiting out
- */
-export async function waitBeforeLock(action, seconds, clearNotes = []) {
-    try {
-        await waitForPreflight(async () => {
-            try {
-                await action();
-            }
-            catch (error) {
-                if (error instanceof PreflightRefusalError && clearNotes.includes(error.note))
-                    return;
-                throw error;
-            }
-        }, seconds);
-    }
-    catch (error) {
-        if (!(error instanceof PreflightRefusalError))
-            throw error;
-        info(`Still busy after the ${seconds ?? 0}-second wait; joining the lock queue and re-checking once under the lock.`);
-    }
-}

package/dist/src/core/process-cpu-time.d.ts

@@ -1,12 +0,0 @@
-/**
- * Reads a process's accumulated CPU seconds.
- *
- * Best-effort: a missing `ps`, an exited process, or an unparseable field
- * yields `undefined`, which callers must render as "unknown" rather than as
- * zero. Reporting a live build as having used no CPU would invert the very
- * diagnosis this exists for.
- *
- * @param pid - Process to inspect
- * @returns Accumulated CPU seconds, or `undefined` when unmeasurable
- */
-export declare function readProcessCpuSeconds(pid: number): Promise<number | undefined>;

package/dist/src/core/process-cpu-time.js

@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Accumulated-CPU-time probe for a single PID.
- *
- * Exists to answer the one question `kill(pid, 0)` cannot: a lock holder
- * that exists may still be wedged. A downstream fork running five concurrent
- * sessions on one checkout diagnosed exactly this by hand ("a holder at
- * near-zero CPU is hung, not working") after a queue stalled behind a
- * command that had consumed 0.3 s of CPU in eleven minutes.
- *
- * It is reported as evidence, never as a verdict. A legitimately slow holder
- * can also sit at low CPU while blocked on I/O or on a child process, so
- * nothing keys a refusal, a kill, or a lock steal off this number.
- */
-import { exec } from '../utils/process.js';
-import { parsePsDuration } from '../utils/ps-duration.js';
-/**
- * Reads a process's accumulated CPU seconds.
- *
- * Best-effort: a missing `ps`, an exited process, or an unparseable field
- * yields `undefined`, which callers must render as "unknown" rather than as
- * zero. Reporting a live build as having used no CPU would invert the very
- * diagnosis this exists for.
- *
- * @param pid - Process to inspect
- * @returns Accumulated CPU seconds, or `undefined` when unmeasurable
- */
-export async function readProcessCpuSeconds(pid) {
-    if (!Number.isSafeInteger(pid) || pid <= 0)
-        return undefined;
-    try {
-        if (process.platform === 'win32') {
-            const result = await exec('powershell.exe', [
-                '-NoProfile',
-                '-NonInteractive',
-                '-Command',
-                `(Get-Process -Id ${pid} -ErrorAction SilentlyContinue).CPU`,
-            ]);
-            const seconds = Number.parseFloat(result.stdout.trim());
-            return Number.isFinite(seconds) ? seconds : undefined;
-        }
-        const result = await exec('ps', ['-p', String(pid), '-o', 'time=']);
-        const field = result.stdout.split(/\r?\n/).find((line) => line.trim().length > 0);
-        if (field === undefined)
-            return undefined;
-        const seconds = parsePsDuration(field);
-        return Number.isNaN(seconds) ? undefined : seconds;
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/src/core/process-owner.d.ts

@@ -1,9 +0,0 @@
-/** Parent evidence; an unreadable parent is never proof of an orphan. */
-export declare function readProcessOwner(pid: number): Promise<{
-    parentPid: number;
-    owner: string;
-} | undefined>;
-/** Harness arguments alone never prove abandonment: require a dead parent too. */
-export declare function isOrphanedHarness(commandLine: string, parentPid?: number): boolean;
-/** Refreshes the exact command and orphan evidence immediately before signaling. */
-export declare function isStillOrphanedProcess(pid: number, commandLine: string): Promise<boolean>;

package/dist/src/core/process-owner.js

@@ -1,43 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { exec } from '../utils/process.js';
-/** Parent evidence; an unreadable parent is never proof of an orphan. */
-export async function readProcessOwner(pid) {
-    if (process.platform === 'win32')
-        return undefined;
-    try {
-        const result = await exec('ps', ['-p', String(pid), '-o', 'ppid='], { timeout: 5000 });
-        const parentPid = Number(result.stdout.trim());
-        if (result.exitCode !== 0 || !Number.isSafeInteger(parentPid) || parentPid < 1)
-            return undefined;
-        if (parentPid === 1)
-            return { parentPid, owner: 'init/launchd (parent exited)' };
-        const parent = await exec('ps', ['-p', String(parentPid), '-o', 'args='], { timeout: 5000 });
-        if (parent.exitCode !== 0 || !parent.stdout.trim())
-            return undefined;
-        return { parentPid, owner: parent.stdout.trim() };
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Harness arguments alone never prove abandonment: require a dead parent too. */
-export function isOrphanedHarness(commandLine, parentPid) {
-    return (parentPid === 1 &&
-        (/\s-marionette(?:\s|$)/.test(commandLine) ||
-            /\s-profile(?:\s|=)[^\n]*(?:fireforge-|mochitest|rust_mozprofile)/.test(commandLine)));
-}
-/** Refreshes the exact command and orphan evidence immediately before signaling. */
-export async function isStillOrphanedProcess(pid, commandLine) {
-    // Windows ownership has no verified implementation; never infer it from
-    // command-line appearance or enable a destructive PowerShell fallback.
-    if (process.platform === 'win32')
-        return false;
-    try {
-        const result = await exec('ps', ['-p', String(pid), '-o', 'ppid=,args='], { timeout: 5000 });
-        const match = /^\s*(\d+)\s+(.+?)\s*$/.exec(result.stdout);
-        return result.exitCode === 0 && match?.[1] === '1' && match[2] === commandLine;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/src/core/rebase-dry-run.d.ts

@@ -1,48 +0,0 @@
-/** A patch to replay, in queue order. */
-export interface DryRunPatch {
-    filename: string;
-    path: string;
-}
-/** What the real rebase loop would do with one patch. */
-export type DryRunVerdict = {
-    filename: string;
-    outcome: 'clean';
-} | {
-    filename: string;
-    outcome: 'reduced-context';
-    step: number;
-    contextArg: string;
-} | {
-    filename: string;
-    outcome: 'reject';
-    /** Files git named as not applying. Empty when stderr named none. */
-    files: string[];
-    /** git's own explanation, from the exact-context `--check`. */
-    detail: string;
-};
-/** Result of a full queue replay. */
-export interface DryRunReplay {
-    verdicts: DryRunVerdict[];
-    /**
-     * Index of the first reject, or `undefined`. Verdicts after it were
-     * computed without that patch applied, so a reject there may cascade from
-     * the earlier one rather than be a conflict of its own.
-     */
-    firstRejectIndex: number | undefined;
-}
-/**
- * Parses the file names out of `git apply --check` failure output. Git
- * reports a context mismatch as `error: patch failed: <file>:<line>` and
- * `error: <file>: patch does not apply`, and a missing or pre-existing
- * target as `error: <file>: does not exist in index` /
- * `error: <file>: already exists in index`.
- */
-export declare function parseApplyCheckFailures(stderr: string): string[];
-/**
- * Replays `patches` onto the engine's HEAD tree in a private index.
- * @param engineDir - Engine repository root
- * @param patches - Patches in queue order
- * @param maxFuzz - Maximum context-reduction steps, as for the real rebase
- * @returns One verdict per patch
- */
-export declare function replayQueueIndexOnly(engineDir: string, patches: readonly DryRunPatch[], maxFuzz: number): Promise<DryRunReplay>;

package/dist/src/core/rebase-dry-run.js

@@ -1,105 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `rebase --dry-run`: replays the patch queue against the engine's base
- * commit without touching `engine/`.
- *
- * The replay runs on a private index seeded from HEAD (`GIT_INDEX_FILE`
- * plus `git read-tree HEAD`) and applies each patch there with
- * `git apply --cached`, in queue order, so a later patch sees what the
- * earlier ones did, exactly as the real loop's worktree does. Each patch
- * walks the same context-reduction ladder as {@link applyPatchWithFuzz}.
- * The worktree and the real index are never written. The private index is
- * deleted when the replay ends.
- */
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { GitError } from '../errors/git.js';
-import { exec } from '../utils/process.js';
-import { ensureGit } from './git-base.js';
-import { assertValidMaxFuzz, contextReductionSteps } from './patch-apply-fuzz.js';
-/**
- * Parses the file names out of `git apply --check` failure output. Git
- * reports a context mismatch as `error: patch failed: <file>:<line>` and
- * `error: <file>: patch does not apply`, and a missing or pre-existing
- * target as `error: <file>: does not exist in index` /
- * `error: <file>: already exists in index`.
- */
-export function parseApplyCheckFailures(stderr) {
-    const files = new Set();
-    for (const line of stderr.split('\n')) {
-        const failed = /^error: patch failed: (.+):\d+$/.exec(line);
-        if (failed?.[1]) {
-            files.add(failed[1]);
-            continue;
-        }
-        const named = /^error: (.+?): (?:patch does not apply|does not exist in index|already exists in index)$/.exec(line);
-        if (named?.[1])
-            files.add(named[1]);
-    }
-    return [...files];
-}
-/**
- * Replays `patches` onto the engine's HEAD tree in a private index.
- * @param engineDir - Engine repository root
- * @param patches - Patches in queue order
- * @param maxFuzz - Maximum context-reduction steps, as for the real rebase
- * @returns One verdict per patch
- */
-export async function replayQueueIndexOnly(engineDir, patches, maxFuzz) {
-    assertValidMaxFuzz(maxFuzz);
-    await ensureGit();
-    const scratch = await mkdtemp(join(tmpdir(), 'fireforge-rebase-dry-run-'));
-    const env = { GIT_INDEX_FILE: join(scratch, 'index') };
-    try {
-        const seeded = await exec('git', ['read-tree', 'HEAD'], { cwd: engineDir, env });
-        if (seeded.exitCode !== 0) {
-            throw new GitError(seeded.stderr.trim() || 'Could not seed a private index from HEAD', 'read-tree HEAD');
-        }
-        const ladder = contextReductionSteps(maxFuzz);
-        const verdicts = [];
-        let firstRejectIndex;
-        for (const patch of patches) {
-            let verdict;
-            let exactFailure = '';
-            for (const [step, contextArgs] of ladder.entries()) {
-                const check = await exec('git', ['apply', '--cached', '--check', ...contextArgs, '--', patch.path], { cwd: engineDir, env });
-                if (check.exitCode !== 0) {
-                    if (step === 0)
-                        exactFailure = check.stderr;
-                    continue;
-                }
-                const apply = await exec('git', ['apply', '--cached', ...contextArgs, '--', patch.path], {
-                    cwd: engineDir,
-                    env,
-                });
-                if (apply.exitCode !== 0)
-                    continue;
-                verdict =
-                    step === 0
-                        ? { filename: patch.filename, outcome: 'clean' }
-                        : {
-                            filename: patch.filename,
-                            outcome: 'reduced-context',
-                            step,
-                            contextArg: contextArgs[0] ?? '',
-                        };
-                break;
-            }
-            if (verdict === undefined) {
-                verdict = {
-                    filename: patch.filename,
-                    outcome: 'reject',
-                    files: parseApplyCheckFailures(exactFailure),
-                    detail: exactFailure.trim(),
-                };
-                firstRejectIndex ??= verdicts.length;
-            }
-            verdicts.push(verdict);
-        }
-        return { verdicts, firstRejectIndex };
-    }
-    finally {
-        await rm(scratch, { recursive: true, force: true });
-    }
-}

package/dist/src/core/rebase-from-version.d.ts

@@ -1,46 +0,0 @@
-/**
- * Resolves the "from" side of a `fireforge rebase` source move.
- *
- * The rebase target is the working `firefox.version` pin, which
- * `fireforge source set` has already moved. The tree the queue was last
- * applied to is the previous pin: the `firefox` block of `fireforge.json`
- * as committed in the project repository. Patch `sourceVersion` stamps are
- * a poor stand-in: patches untouched since an older hop keep their older
- * stamp, so the oldest stamp can trail the real previous tree by several
- * releases. The stamps are only the fallback, for a project that is not a
- * git checkout or whose committed pin already equals the target.
- */
-import type { FirefoxProduct } from '../types/config.js';
-/** A `firefox.version` / `firefox.product` pair. */
-export interface FirefoxPin {
-    version: string;
-    product?: FirefoxProduct;
-}
-/** Where the rebase's "from" label came from. */
-export interface RebaseFromVersion extends FirefoxPin {
-    /** `committed-pin`: the project's committed `fireforge.json`; `patch-stamps`: the oldest stamp. */
-    origin: 'committed-pin' | 'patch-stamps';
-}
-/** Tally of the queue's `sourceVersion` stamps, oldest first. */
-export interface PatchStampSpread {
-    versions: string[];
-    counts: Map<string, number>;
-}
-/**
- * Reads the `firefox` pin from `fireforge.json` as committed at the project
- * repository's HEAD. `HEAD:./fireforge.json` resolves relative to the
- * project root, so a project nested inside a larger repository works too.
- * Returns `undefined` when there is no repository, no commit, no committed
- * config, or no valid pin in it.
- */
-export declare function readCommittedFirefoxPin(projectRoot: string): Promise<FirefoxPin | undefined>;
-/** Counts the queue's stamps and orders them semantically (a lexical sort put 153.10.0esr before 153.2.0esr). */
-export declare function tallyPatchStamps(stamps: readonly string[]): PatchStampSpread;
-/** `"317 at 153.0esr, 5 at 153.3.0esr"`. */
-export declare function formatPatchStampSpread(spread: PatchStampSpread): string;
-/**
- * Picks the rebase's "from": the committed pin when it differs from the
- * target, otherwise the oldest patch stamp (`oldestStampProduct` is that
- * stamp's recorded product, when any patch carries one).
- */
-export declare function resolveRebaseFromVersion(target: string, committed: FirefoxPin | undefined, spread: PatchStampSpread, oldestStampProduct: FirefoxProduct | undefined): RebaseFromVersion;

package/dist/src/core/rebase-from-version.js

@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Resolves the "from" side of a `fireforge rebase` source move.
- *
- * The rebase target is the working `firefox.version` pin, which
- * `fireforge source set` has already moved. The tree the queue was last
- * applied to is the previous pin: the `firefox` block of `fireforge.json`
- * as committed in the project repository. Patch `sourceVersion` stamps are
- * a poor stand-in: patches untouched since an older hop keep their older
- * stamp, so the oldest stamp can trail the real previous tree by several
- * releases. The stamps are only the fallback, for a project that is not a
- * git checkout or whose committed pin already equals the target.
- */
-import { exec } from '../utils/process.js';
-import { compareFirefoxVersions, isObject, isValidFirefoxProduct, isValidFirefoxVersion, } from '../utils/validation.js';
-/**
- * Reads the `firefox` pin from `fireforge.json` as committed at the project
- * repository's HEAD. `HEAD:./fireforge.json` resolves relative to the
- * project root, so a project nested inside a larger repository works too.
- * Returns `undefined` when there is no repository, no commit, no committed
- * config, or no valid pin in it.
- */
-export async function readCommittedFirefoxPin(projectRoot) {
-    const result = await exec('git', ['show', 'HEAD:./fireforge.json'], { cwd: projectRoot }).catch(() => undefined);
-    if (result?.exitCode !== 0)
-        return undefined;
-    let parsed;
-    try {
-        parsed = JSON.parse(result.stdout);
-    }
-    catch {
-        return undefined;
-    }
-    const firefox = isObject(parsed) ? parsed['firefox'] : undefined;
-    if (!isObject(firefox))
-        return undefined;
-    const version = firefox['version'];
-    if (typeof version !== 'string' || !isValidFirefoxVersion(version))
-        return undefined;
-    const product = firefox['product'];
-    return typeof product === 'string' && isValidFirefoxProduct(product)
-        ? { version, product }
-        : { version };
-}
-/** Counts the queue's stamps and orders them semantically (a lexical sort put 153.10.0esr before 153.2.0esr). */
-export function tallyPatchStamps(stamps) {
-    const counts = new Map();
-    for (const stamp of stamps)
-        counts.set(stamp, (counts.get(stamp) ?? 0) + 1);
-    return { versions: [...counts.keys()].sort(compareFirefoxVersions), counts };
-}
-/** `"317 at 153.0esr, 5 at 153.3.0esr"`. */
-export function formatPatchStampSpread(spread) {
-    return spread.versions.map((v) => `${spread.counts.get(v)} at ${v}`).join(', ');
-}
-/**
- * Picks the rebase's "from": the committed pin when it differs from the
- * target, otherwise the oldest patch stamp (`oldestStampProduct` is that
- * stamp's recorded product, when any patch carries one).
- */
-export function resolveRebaseFromVersion(target, committed, spread, oldestStampProduct) {
-    if (committed !== undefined && committed.version !== target) {
-        return { ...committed, origin: 'committed-pin' };
-    }
-    const oldest = spread.versions[0] ?? target;
-    return {
-        version: oldest,
-        ...(oldestStampProduct !== undefined ? { product: oldestStampProduct } : {}),
-        origin: 'patch-stamps',
-    };
-}

package/dist/src/core/rebase-session.d.ts

@@ -1,100 +0,0 @@
-/**
- * Rebase session persistence for multi-patch Firefox source upgrades.
- * Session state is stored at `.fireforge/rebase-session.json` and
- * survives across CLI invocations so the user can fix conflicts and
- * resume with `fireforge rebase --continue`.
- */
-import type { FirefoxProduct } from '../types/config.js';
-export type RebasePatchStatus = 'pending' | 'applied-clean' | 'applied-fuzz' | 'failed' | 'resolved' | 'skipped';
-/**
- * One patch's outcome in a rebase session.
- *
- * A discriminated union on `status`, so a payload can only be present on the
- * status it belongs to. A flat-optionals shape makes
- * `{ status: 'resolved', error, conflictingFiles }` representable, and
- * `rebase --continue` will write it, flipping the status without clearing
- * the failure payload, then persisting that to the session file.
- *
- * The on-disk validator (`isValidPatchEntry`) is not tightened to
- * match, on purpose. The session file carries no schema version, so a stricter
- * validator would reject an older file mid-rebase, where the only remedies
- * discard the operator's in-progress conflict resolution. Instead
- * {@link normalizeEntry} drops payload that does not belong to the status on
- * read, so an older file loads and is corrected rather than refused.
- */
-export type RebasePatchEntry = {
-    filename: string;
-} & ({
-    status: 'pending' | 'applied-clean' | 'skipped' | 'resolved';
-} | {
-    status: 'applied-fuzz';
-    fuzzFactor: number;
-} | {
-    status: 'failed';
-    error?: string;
-    conflictingFiles?: string[];
-});
-export interface RebaseSession {
-    /** ISO timestamp when the rebase started. */
-    startedAt: string;
-    /** Source product being rebased FROM. */
-    fromProduct?: FirefoxProduct;
-    /** Source product being rebased TO. */
-    toProduct?: FirefoxProduct;
-    /** Source version being rebased FROM. */
-    fromVersion: string;
-    /** Source version being rebased TO. */
-    toVersion: string;
-    /** Commit hash recorded before the rebase started (for --abort). */
-    preRebaseCommit: string;
-    /** Ordered list of all patches and their status. */
-    patches: RebasePatchEntry[];
-    /** Index of the next patch to process (resume point). */
-    currentIndex: number;
-}
-/** Absolute path of the session file, for messages that must name it. */
-export declare function getRebaseSessionPath(projectRoot: string): string;
-/**
- * Outcome of reading the session file, following the {@link LockOwner}
- * discriminated-union form rather than collapsing three states into `null`.
- *
- * Distinguishing `present: false` from `present: true, valid: false` is
- * important. Collapsing both to `null` while reporting liveness from
- * `pathExists` alone wedges the operator in a closed cycle: `rebase` says
- * "already in progress, use --continue or --abort", and both of those say
- * "no rebase session in progress", with no CLI path deleting the file and no
- * message naming it.
- */
-export type RebaseSessionRead = {
-    present: false;
-} | {
-    present: true;
-    valid: true;
-    session: RebaseSession;
-} | {
-    present: true;
-    valid: false;
-    reason: string;
-};
-/**
- * Reads the session file, reporting absent, valid, and corrupt as three
- * distinct outcomes. Never throws for a malformed file: `readJson` calls
- * `JSON.parse` with no guard of its own, so an interrupted write would
- * otherwise surface a raw `SyntaxError` out of `--continue`/`--abort`.
- *
- * A single read determines liveness and validity: only ENOENT/ENOTDIR from
- * that read mean `absent`. A pathExists pre-probe both races deletion (a
- * file removed between probe and read misreports an absent session as
- * corrupt) and swallows EACCES (an unreadable `.fireforge/` misreports a
- * session as absent). It is the same failure `readTreeMarker` avoids for
- * tree markers.
- */
-export declare function readRebaseSession(projectRoot: string): Promise<RebaseSessionRead>;
-/**
- * Persists a rebase session atomically.
- */
-export declare function saveRebaseSession(projectRoot: string, session: RebaseSession): Promise<void>;
-/**
- * Removes the rebase session file.
- */
-export declare function clearRebaseSession(projectRoot: string): Promise<void>;