@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/re-export.d.ts

@@ -1,8 +0,0 @@
-import type { ReExportOptions } from '../types/commands/index.js';
-/**
- * Runs the re-export command to regenerate existing patches from current engine state.
- * @param projectRoot - Root directory of the project
- * @param patches - Patch identifiers (numbers or filenames)
- * @param options - Re-export options
- */
-export declare function reExportCommand(projectRoot: string, patches: string[], options: ReExportOptions): Promise<void>;

package/dist/src/commands/rebase/abort.d.ts

@@ -1,7 +0,0 @@
-/**
- * Rebase abort flow.
- */
-/**
- * Handles `fireforge rebase --abort`.
- */
-export declare function handleAbort(projectRoot: string, yes?: boolean): Promise<void>;

package/dist/src/commands/rebase/abort.js

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Rebase abort flow.
- */
-import { getProjectPaths } from '../../core/config.js';
-import { clearAppliedFurnaceState } from '../../core/furnace-config.js';
-import { resetChanges } from '../../core/git.js';
-import { clearRebaseSession, getRebaseSessionPath, readRebaseSession, } from '../../core/rebase-session.js';
-import { NoRebaseSessionError } from '../../errors/rebase.js';
-import { intro, outro, spinner, success, warn } from '../../utils/logger.js';
-import { clearPendingResolution } from '../pending-resolution.js';
-import { confirmDirtyEngineReset } from './confirm.js';
-/**
- * Handles `fireforge rebase --abort`.
- */
-export async function handleAbort(projectRoot, yes) {
-    intro('FireForge Rebase — Abort');
-    // Abort is the escape hatch, so it does not require a valid session, only
-    // that one is present. Nothing below reads the session object (the restore
-    // works off `paths.engine` and `resetChanges`), and an
-    // `if (!session) throw` would refuse to run against a corrupt file, which
-    // is the only thing that could have cleared it.
-    const read = await readRebaseSession(projectRoot);
-    if (!read.present)
-        throw new NoRebaseSessionError();
-    if (!read.valid) {
-        warn(`The rebase session at ${getRebaseSessionPath(projectRoot)} is unreadable ` +
-            `(${read.reason}). Aborting anyway: the engine will be restored and the session cleared.`);
-    }
-    const paths = getProjectPaths(projectRoot);
-    if (!(await confirmDirtyEngineReset({
-        engineDir: paths.engine,
-        yes: yes ?? false,
-        nonInteractiveCommand: 'fireforge rebase --abort --yes',
-        argumentName: '--yes',
-        warningMessage: 'The engine directory has uncommitted changes that will be lost.',
-        promptMessage: 'Discard uncommitted changes and abort rebase?',
-        cancelMessage: 'Abort cancelled',
-    }))) {
-        return;
-    }
-    const s = spinner('Restoring engine to pre-rebase state...');
-    // Step 1: git reset. If this fails, the rebase session must stay on disk
-    // so the user can retry the abort: resetChanges is the only irreversible
-    // operation in this handler and everything downstream assumes it ran.
-    try {
-        await resetChanges(paths.engine);
-        s.stop('Engine restored');
-    }
-    catch (error) {
-        s.error('Failed to restore engine');
-        throw error;
-    }
-    // Step 2: clear Furnace state. A failure here is reported on its own
-    // (rather than labelled "Failed to restore engine", which would be
-    // misleading now that reset already succeeded). The rebase session is
-    // still kept on disk so the user can retry the abort and let it
-    // idempotently re-clear furnace state.
-    await clearAppliedFurnaceState(projectRoot);
-    // Step 3: clear pending resolution transactionally.
-    await clearPendingResolution(projectRoot);
-    // Step 4: clear the rebase session last so a failure in any prior step
-    // preserves the session on disk and a retry of --abort can succeed.
-    await clearRebaseSession(projectRoot);
-    success('Rebase aborted and session cleared.');
-    outro('Rebase aborted');
-}

package/dist/src/commands/rebase/confirm.d.ts

@@ -1,42 +0,0 @@
-/**
- * Dirty-engine confirmation/reset flow.
- */
-/** Options for the dirty-engine confirmation prompt. */
-export interface DirtyEngineConfirmationOptions {
-    engineDir: string;
-    yes: boolean;
-    /**
-     * Full remediation command the user should run in non-interactive mode,
-     * e.g. `"fireforge rebase --abort --yes"`. Rendered inline in the
-     * non-interactive error message so the user gets a paste-ready
-     * command instead of a bare flag name.
-     */
-    nonInteractiveCommand: string;
-    /**
-     * Argument identifier attached to the thrown {@link InvalidArgumentError}
-     * (typically the flag name, e.g. `"--yes"`). Separate from
-     * `nonInteractiveCommand` so the error's `argument` field carries the
-     * canonical flag name for structured handling.
-     */
-    argumentName: string;
-    warningMessage: string;
-    promptMessage: string;
-    cancelMessage: string;
-    /**
-     * Precomputed dirtiness. A caller that already measured what would be
-     * lost (and may count more than the working tree, such as commits made
-     * on top of the base) passes it here instead of the `hasChanges` probe.
-     */
-    dirty?: boolean;
-    /**
-     * Replaces the generic "Engine has uncommitted changes" opening of the
-     * non-interactive refusal, so the refusal names what would be lost.
-     */
-    refusalDetail?: string;
-}
-/**
- * Checks if the engine has uncommitted changes and prompts for confirmation.
- * Returns true if safe to proceed, false if the user cancelled.
- * Throws in non-interactive mode without --yes.
- */
-export declare function confirmDirtyEngineReset({ engineDir, yes, nonInteractiveCommand, argumentName, warningMessage, promptMessage, cancelMessage, dirty, refusalDetail, }: DirtyEngineConfirmationOptions): Promise<boolean>;

package/dist/src/commands/rebase/confirm.js

@@ -1,36 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Dirty-engine confirmation/reset flow.
- */
-import { confirm } from '@clack/prompts';
-import { stdioIsInteractive } from '../../core/destructive.js';
-import { hasChanges } from '../../core/git.js';
-import { InvalidArgumentError } from '../../errors/base.js';
-import { cancel, isCancel, warn } from '../../utils/logger.js';
-/**
- * Checks if the engine has uncommitted changes and prompts for confirmation.
- * Returns true if safe to proceed, false if the user cancelled.
- * Throws in non-interactive mode without --yes.
- */
-export async function confirmDirtyEngineReset({ engineDir, yes, nonInteractiveCommand, argumentName, warningMessage, promptMessage, cancelMessage, dirty, refusalDetail, }) {
-    if (yes || !(dirty ?? (await hasChanges(engineDir)))) {
-        return true;
-    }
-    const isInteractive = stdioIsInteractive();
-    if (!isInteractive) {
-        const opening = refusalDetail !== undefined
-            ? `${refusalDetail} Interactive confirmation is not available.`
-            : 'Engine has uncommitted changes and interactive confirmation is not available.';
-        throw new InvalidArgumentError(`${opening} Run: ${nonInteractiveCommand}`, argumentName);
-    }
-    warn(warningMessage);
-    const confirmed = await confirm({
-        message: promptMessage,
-        initialValue: false,
-    });
-    if (isCancel(confirmed) || !confirmed) {
-        cancel(cancelMessage);
-        return false;
-    }
-    return true;
-}

package/dist/src/commands/rebase/conflict-summary.d.ts

@@ -1,12 +0,0 @@
-export interface RebaseConflictSummary {
-    patchFilename: string;
-    failedFiles: string[];
-    category: string;
-    nextCommands: string[];
-}
-/** Builds a concise operator-facing summary for a failed rebase patch. */
-export declare function buildRebaseConflictSummary(args: {
-    patchFilename: string;
-    error?: string;
-    rejectFiles?: string[];
-}): RebaseConflictSummary;

package/dist/src/commands/rebase/conflict-summary.js

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { extractConflictingFiles } from '../../core/patch-parse.js';
-function normalizeRejectFile(file) {
-    return file.replace(/\.rej$/, '');
-}
-function classifyConflict(files) {
-    if (files.some((file) => file.endsWith('toolkit/content/customElements.js'))) {
-        return 'registration context drift';
-    }
-    if (files.some((file) => file.endsWith('jar.mn') ||
-        file.endsWith('moz.build') ||
-        file.endsWith('browser.toml') ||
-        file.endsWith('browser/moz.configure'))) {
-        return 'manifest context drift';
-    }
-    return 'patch context drift';
-}
-/** Builds a concise operator-facing summary for a failed rebase patch. */
-export function buildRebaseConflictSummary(args) {
-    const failedFiles = [
-        ...new Set([
-            ...extractConflictingFiles(args.error),
-            ...(args.rejectFiles ?? []).map(normalizeRejectFile),
-        ]),
-    ].sort();
-    return {
-        patchFilename: args.patchFilename,
-        failedFiles,
-        category: classifyConflict(failedFiles),
-        nextCommands: [
-            "find engine -name '*.rej'",
-            'edit the affected engine/ files',
-            'fireforge rebase --continue',
-            'fireforge rebase --abort',
-        ],
-    };
-}

package/dist/src/commands/rebase/continue.d.ts

@@ -1,7 +0,0 @@
-/**
- * Rebase --continue flow.
- */
-/**
- * Handles `fireforge rebase --continue`.
- */
-export declare function handleContinue(projectRoot: string, maxFuzz: number, waitLockSeconds?: number): Promise<void>;

package/dist/src/commands/rebase/continue.js

@@ -1,119 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Rebase --continue flow.
- */
-import { join } from 'node:path';
-import { getProjectPaths } from '../../core/config.js';
-import { getStagedDiffForFiles } from '../../core/git-diff.js';
-import { stageFiles, unstageFiles } from '../../core/git-file-ops.js';
-import { updatePatchAndMetadata } from '../../core/patch-export.js';
-import { loadPatchesManifest } from '../../core/patch-manifest.js';
-import { getRebaseSessionPath, readRebaseSession, saveRebaseSession, } from '../../core/rebase-session.js';
-import { runInSignalCriticalSection } from '../../core/signal-critical.js';
-import { GeneralError } from '../../errors/base.js';
-import { CorruptRebaseSessionError, NoRebaseSessionError, RebaseError, } from '../../errors/rebase.js';
-import { pathExists } from '../../utils/fs.js';
-import { info, intro, success, warn } from '../../utils/logger.js';
-import { clearPendingResolution } from '../pending-resolution.js';
-import { runPatchLoop } from './patch-loop.js';
-/**
- * Handles `fireforge rebase --continue`.
- */
-export async function handleContinue(projectRoot, maxFuzz, waitLockSeconds) {
-    intro('FireForge Rebase — Continue');
-    // A present-but-unreadable session is not "no session in progress":
-    // treating it as one leaves a corrupt file unrecoverable. Name the file
-    // and point at --abort, which can clear it.
-    const read = await readRebaseSession(projectRoot);
-    if (!read.present)
-        throw new NoRebaseSessionError();
-    if (!read.valid) {
-        throw new CorruptRebaseSessionError(getRebaseSessionPath(projectRoot), read.reason);
-    }
-    const session = read.session;
-    const paths = getProjectPaths(projectRoot);
-    // Special case: every patch has already applied but a previous run failed
-    // somewhere in the post-apply work (re-export, version stamping). In that
-    // state currentIndex is past the end of the queue. Jumping straight back
-    // into runPatchLoop replays the no-op apply loop and re-attempts the
-    // post-apply pipeline. Without this branch the user would be stuck: there
-    // is no failed patch to resolve, but the session is still active.
-    if (session.currentIndex >= session.patches.length) {
-        info('All patches already applied; retrying post-apply re-export and version stamping.');
-        await runPatchLoop(projectRoot, session, paths, maxFuzz, waitLockSeconds);
-        return;
-    }
-    // The current patch should be in 'failed' state
-    const currentPatch = session.patches[session.currentIndex];
-    if (!currentPatch || currentPatch.status !== 'failed') {
-        throw new RebaseError('Expected the current patch to be in a failed state. The session may be corrupt.');
-    }
-    info(`Resolving: ${currentPatch.filename}`);
-    // Look up the patch's files from the manifest
-    const manifest = await loadPatchesManifest(paths.patches);
-    if (!manifest)
-        throw new GeneralError('Patches manifest not found.');
-    const meta = manifest.patches.find((p) => p.filename === currentPatch.filename);
-    if (!meta)
-        throw new GeneralError(`Patch ${currentPatch.filename} not found in manifest.`);
-    // Re-export the resolved patch from current engine state
-    const activeFiles = [];
-    for (const f of meta.filesAffected) {
-        if (await pathExists(join(paths.engine, f))) {
-            activeFiles.push(f);
-        }
-    }
-    let staged = false;
-    try {
-        await stageFiles(paths.engine, activeFiles);
-        staged = true;
-        const diffContent = await getStagedDiffForFiles(paths.engine, activeFiles);
-        if (!diffContent.trim()) {
-            warn('No diff generated — the files may not have changed from HEAD.');
-            warn('Either apply your fixes and re-run --continue, or skip this patch (not yet supported).');
-            return;
-        }
-        // Write the patch body and the manifest metadata atomically under the
-        // shared patch-directory lock. A lock-free updatePatch +
-        // updatePatchMetadata sequence can interleave with a concurrent export /
-        // re-export / patch reorder / patch compact and leave the manifest
-        // disagreeing with the freshly-written patch body. Mirrors resolve.ts.
-        await updatePatchAndMetadata({
-            patchesDir: paths.patches,
-            filename: currentPatch.filename,
-            newContent: diffContent,
-            updates: {
-                sourceEsrVersion: session.toVersion,
-                sourceVersion: session.toVersion,
-                ...(session.toProduct !== undefined ? { sourceProduct: session.toProduct } : {}),
-            },
-        });
-    }
-    finally {
-        if (staged) {
-            await unstageFiles(paths.engine, activeFiles);
-        }
-    }
-    // Mark resolved and advance. Wrap in a signal-deferred critical section
-    // so SIGINT / SIGTERM between the session update and the pendingResolution
-    // clear is held until both writes land, matching the guarantee the apply
-    // loop in patch-loop.ts provides.
-    await runInSignalCriticalSection(`rebase-continue:${currentPatch.filename}`, async () => {
-        // The entry is replaced rather than mutated. Flipping `status` in place
-        // would leave the failure's `error` and `conflictingFiles` on a
-        // now-resolved entry and persist that to the session file. The union
-        // type rules that out.
-        session.patches[session.currentIndex] = {
-            filename: currentPatch.filename,
-            status: 'resolved',
-        };
-        session.currentIndex++;
-        await saveRebaseSession(projectRoot, session);
-        // Clear pending resolution transactionally so concurrent state-file
-        // writes to unrelated keys are not clobbered by a stale reload.
-        await clearPendingResolution(projectRoot);
-    });
-    success(`Resolved ${currentPatch.filename}`);
-    // Continue applying remaining patches
-    await runPatchLoop(projectRoot, session, paths, maxFuzz, waitLockSeconds);
-}

package/dist/src/commands/rebase/index.d.ts

@@ -1,22 +0,0 @@
-/**
- * `fireforge rebase`: semi-automated Firefox source version upgrade.
- *
- * Orchestrates the full patch-rebase workflow:
- *   1. Reset engine to baseline
- *   2. Apply each patch with escalating context reduction (git apply -C<n>)
- *   3. Pause on failures for manual resolution
- *   4. Re-export successfully applied patches with the new version stamp
- *
- * Supports `--continue` (resume after manual fix) and `--abort` (cancel).
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-import type { RebaseOptions } from '../../types/commands/index.js';
-/**
- * Runs the rebase command to orchestrate a Firefox source version upgrade.
- * @param projectRoot - Root directory of the project
- * @param options - Rebase options
- */
-export declare function rebaseCommand(projectRoot: string, options?: RebaseOptions): Promise<void>;
-/** Registers the rebase command on the CLI program. */
-export declare function registerRebase(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/rebase/index.js

@@ -1,209 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge rebase`: semi-automated Firefox source version upgrade.
- *
- * Orchestrates the full patch-rebase workflow:
- *   1. Reset engine to baseline
- *   2. Apply each patch with escalating context reduction (git apply -C<n>)
- *   3. Pause on failures for manual resolution
- *   4. Re-export successfully applied patches with the new version stamp
- *
- * Supports `--continue` (resume after manual fix) and `--abort` (cancel).
- */
-import { Command } from 'commander';
-import { getProjectPaths, loadConfig, loadState } from '../../core/config.js';
-import { assertEngineGitReady } from '../../core/engine-precondition.js';
-import { clearAppliedFurnaceState } from '../../core/furnace-config.js';
-import { getHead, resetChanges } from '../../core/git.js';
-import { discoverPatches } from '../../core/patch-files.js';
-import { loadPatchesManifest } from '../../core/patch-manifest.js';
-import { getPatchSourceVersion } from '../../core/patch-source-metadata.js';
-import { replayQueueIndexOnly } from '../../core/rebase-dry-run.js';
-import { formatPatchStampSpread, readCommittedFirefoxPin, resolveRebaseFromVersion, tallyPatchStamps, } from '../../core/rebase-from-version.js';
-import { getRebaseSessionPath, readRebaseSession, saveRebaseSession, } from '../../core/rebase-session.js';
-import { GeneralError } from '../../errors/base.js';
-import { CorruptRebaseSessionError, RebaseDryRunRejectError, RebaseSessionExistsError, } from '../../errors/rebase.js';
-import { info, intro, outro, spinner, warn } from '../../utils/logger.js';
-import { addWaitLockOption, commanderArgParser, pickDefined, resolveWaitLockSeconds, } from '../../utils/options.js';
-import { parsePositiveIntegerFlag } from '../../utils/validation.js';
-import { handleAbort } from './abort.js';
-import { confirmDirtyEngineReset } from './confirm.js';
-import { handleContinue } from './continue.js';
-import { runPatchLoop } from './patch-loop.js';
-// ── Fresh start ──
-async function handleFreshStart(projectRoot, options) {
-    const isDryRun = options.dryRun === true;
-    const maxFuzz = options.maxFuzz ?? 3;
-    intro(isDryRun ? 'FireForge Rebase (dry run)' : 'FireForge Rebase');
-    // One read decides liveness and validity: a pathExists pre-probe here left
-    // a window where the file vanished between probe and read, reporting
-    // "already in progress" with no session on disk.
-    const existing = await readRebaseSession(projectRoot);
-    if (existing.present) {
-        // A corrupt session must not be reported as "already in progress": that
-        // message tells the operator to run --continue or --abort, and both of
-        // those then report "no rebase session in progress".
-        if (!existing.valid) {
-            throw new CorruptRebaseSessionError(getRebaseSessionPath(projectRoot), existing.reason);
-        }
-        throw new RebaseSessionExistsError();
-    }
-    const paths = getProjectPaths(projectRoot);
-    // Keeps the rebase-specific tail on the unborn-HEAD remediation. Skipping
-    // this check in --dry-run leaves the real run to fail on
-    // `git rev-parse HEAD`.
-    await assertEngineGitReady(paths.engine, { unbornHeadSuffix: ', then retry the rebase.' });
-    const config = await loadConfig(projectRoot);
-    const currentVersion = config.firefox.version;
-    const manifest = await loadPatchesManifest(paths.patches);
-    if (!manifest || manifest.patches.length === 0) {
-        throw new GeneralError('No patches found in manifest. Nothing to rebase.');
-    }
-    // The queue can carry several stamps: patches re-exported since the last
-    // hop are stamped newer than untouched ones. "Nothing to rebase" is a fact
-    // about the stamps; the "from" label is the previous pin (the committed
-    // `firefox.version`), with the oldest stamp only as the fallback.
-    const spread = tallyPatchStamps(manifest.patches.map((p) => getPatchSourceVersion(p)));
-    const oldestStamp = spread.versions[0] ?? currentVersion;
-    const from = resolveRebaseFromVersion(currentVersion, await readCommittedFirefoxPin(projectRoot), spread, manifest.patches.find((p) => getPatchSourceVersion(p) === oldestStamp)?.sourceProduct);
-    const fromVersion = from.version;
-    const fromProduct = from.product ?? config.firefox.product;
-    if (spread.versions.length === 1 && oldestStamp === currentVersion) {
-        info('All patches already match the current Firefox version. Nothing to rebase.');
-        outro('Rebase not needed');
-        return;
-    }
-    info(`Rebasing patches: ${fromVersion} → ${currentVersion}`);
-    if (from.origin === 'patch-stamps') {
-        info('From-version is the oldest patch stamp: no committed fireforge.json pin precedes the target.');
-    }
-    if (from.origin === 'committed-pin' || spread.versions.length > 1) {
-        info(`Patch stamps: ${formatPatchStampSpread(spread)}`);
-    }
-    // The rebase replays onto whatever engine/ holds. The pin is the target,
-    // so an engine still on another version means the download step has not
-    // run yet and every verdict below would be against the wrong tree.
-    const engineVersion = (await loadState(projectRoot)).downloadedVersion;
-    if (engineVersion !== undefined && engineVersion !== currentVersion) {
-        warn(`engine/ holds ${engineVersion}, not the pinned target ${currentVersion}. ` +
-            'Run "fireforge download --force" first, or the rebase applies onto the old source.');
-    }
-    info(`Found ${manifest.patches.length} patch(es)`);
-    info(`Max context-reduction steps (fuzz-like): ${maxFuzz}`);
-    if (isDryRun) {
-        const patches = await discoverPatches(paths.patches);
-        const replaySpinner = spinner(`Replaying ${patches.length} patch(es) on a private index...`);
-        let replay;
-        try {
-            replay = await replayQueueIndexOnly(paths.engine, patches, maxFuzz);
-            replaySpinner.stop('Replay finished; engine/ untouched');
-        }
-        catch (error) {
-            replaySpinner.error('Replay failed');
-            throw error;
-        }
-        reportDryRunReplay(replay);
-        return;
-    }
-    if (!(await confirmDirtyEngineReset({
-        engineDir: paths.engine,
-        yes: options.yes ?? false,
-        nonInteractiveCommand: 'fireforge rebase --yes',
-        argumentName: '--yes',
-        warningMessage: 'The engine directory has uncommitted changes that will be lost by the rebase.',
-        promptMessage: 'Discard uncommitted changes and start rebase?',
-        cancelMessage: 'Rebase cancelled',
-    }))) {
-        return;
-    }
-    // Record pre-rebase commit for --abort
-    const preRebaseCommit = await getHead(paths.engine);
-    // Reset engine to baseline
-    const resetSpinner = spinner('Resetting engine to baseline...');
-    await resetChanges(paths.engine);
-    resetSpinner.stop('Engine reset to baseline');
-    // Clear Furnace state: the engine no longer contains deployed components.
-    await clearAppliedFurnaceState(projectRoot);
-    // Create rebase session
-    const allPatches = await discoverPatches(paths.patches);
-    const session = {
-        startedAt: new Date().toISOString(),
-        fromProduct,
-        toProduct: config.firefox.product,
-        fromVersion,
-        toVersion: currentVersion,
-        preRebaseCommit,
-        patches: allPatches.map((p) => ({
-            filename: p.filename,
-            status: 'pending',
-        })),
-        currentIndex: 0,
-    };
-    await saveRebaseSession(projectRoot, session);
-    // Run the patch loop
-    await runPatchLoop(projectRoot, session, paths, maxFuzz, resolveWaitLockSeconds(options.waitLock));
-}
-/**
- * Prints one line per patch and a tally, then fails the run when any patch
- * rejects: a dry run that exits 0 must mean the real rebase would apply the
- * whole queue.
- */
-function reportDryRunReplay(replay) {
-    let reduced = 0;
-    const rejected = [];
-    for (const [index, verdict] of replay.verdicts.entries()) {
-        const cascade = replay.firstRejectIndex !== undefined && index > replay.firstRejectIndex
-            ? ' (after an earlier reject; may cascade from it)'
-            : '';
-        switch (verdict.outcome) {
-            case 'clean':
-                info(`  clean            ${verdict.filename}`);
-                break;
-            case 'reduced-context':
-                reduced += 1;
-                info(`  reduced context  ${verdict.filename} (step ${verdict.step}, ${verdict.contextArg})`);
-                break;
-            case 'reject': {
-                rejected.push(verdict.filename);
-                const files = verdict.files.length > 0 ? verdict.files.join(', ') : 'see git output';
-                warn(`  reject           ${verdict.filename}: ${files}${cascade}`);
-                break;
-            }
-        }
-    }
-    const clean = replay.verdicts.length - reduced - rejected.length;
-    info(`[dry-run] ${replay.verdicts.length} patch(es): ${clean} clean, ${reduced} with reduced context, ${rejected.length} rejected.`);
-    if (rejected.length > 0) {
-        throw new RebaseDryRunRejectError(rejected);
-    }
-    outro('Dry run complete: every patch applies');
-}
-// ── Public API ──
-/**
- * Runs the rebase command to orchestrate a Firefox source version upgrade.
- * @param projectRoot - Root directory of the project
- * @param options - Rebase options
- */
-export async function rebaseCommand(projectRoot, options = {}) {
-    if (options.abort) {
-        return handleAbort(projectRoot, options.yes);
-    }
-    if (options.continue) {
-        return handleContinue(projectRoot, options.maxFuzz ?? 3, resolveWaitLockSeconds(options.waitLock));
-    }
-    return handleFreshStart(projectRoot, options);
-}
-/** Registers the rebase command on the CLI program. */
-export function registerRebase(program, { getProjectRoot, withErrorHandling }) {
-    const command = program
-        .command('rebase')
-        .description('Semi-automated Firefox source version upgrade — apply patches with drift tolerance and re-export')
-        .option('--continue', 'Resume after manually resolving a failed patch')
-        .option('--abort', 'Cancel the rebase and restore engine to pre-rebase state')
-        .option('--dry-run', 'Replay the queue onto the engine base commit in a private index and report each patch as clean, reduced-context or reject (exit 6 on any reject); engine/ is not touched')
-        .option('--max-fuzz <n>', 'Maximum context-reduction steps for git apply -C<n> (fuzz-like drift tolerance; default: 3)', commanderArgParser((v) => parsePositiveIntegerFlag('--max-fuzz', v)))
-        .option('-y, --yes', 'Skip dirty-tree confirmation prompt');
-    addWaitLockOption(command).action(withErrorHandling(async (options) => {
-        await rebaseCommand(getProjectRoot(), pickDefined(options));
-    }));
-}

package/dist/src/commands/rebase/patch-loop.d.ts

@@ -1,15 +0,0 @@
-/**
- * Patch application loop and re-export flow.
- */
-import type { RebaseSession } from '../../core/rebase-session.js';
-import type { ProjectPaths } from '../../types/config.js';
-/**
- * Runs the patch application loop, re-exports applied patches, and stamps versions.
- *
- * @param projectRoot - Project root directory
- * @param session - The active rebase session, mutated and persisted as it runs
- * @param paths - Resolved project paths
- * @param maxFuzz - Maximum context-reduction steps for `git apply -C<n>`
- * @param waitLockSeconds - `--wait-lock` budget for the patch-directory lock
- */
-export declare function runPatchLoop(projectRoot: string, session: RebaseSession, paths: ProjectPaths, maxFuzz: number, waitLockSeconds?: number): Promise<void>;