@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/destructive.js

@@ -1,182 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Shared destructive-operation contract: interactive confirmation, non-TTY
- * refusal, dry-run plumbing, hard-refusal on structural conflicts, and a
- * JSONL audit log.
- *
- * This exists because the repair primitives (`patch delete`, `patch reorder`,
- * `re-export --files`) and the new `export --dry-run`/`export --order` flags
- * all share the same dance: build a change summary, gate it behind a prompt,
- * accept a `--yes` bypass for CI, accept a `--dry-run` no-op, and refuse
- * outright when the change would introduce a structural conflict (e.g. a
- * forward-import that later-patch lint would then block). Without a single
- * helper, every new destructive command would re-implement this and drift.
- */
-import { confirm } from '@clack/prompts';
-import { CancellationError, InvalidArgumentError } from '../errors/base.js';
-import { info, isCancel, warn } from '../utils/logger.js';
-import { appendHistoryLine, historyRecordIdentity } from './history-log-file.js';
-/**
- * Prints the change summary lines at warn-severity so the prompt stands out.
- */
-function printSummary(title, summary) {
-    warn(title);
-    for (const line of summary) {
-        info(`  ${line}`);
-    }
-}
-/**
- * Prints a conflict report at warn-severity. Used by both the refusal path
- * and the dry-run-with-conflicts preview path.
- */
-function printConflicts(conflicts) {
-    warn(`Refused: ${conflicts.reason}`);
-    for (const detail of conflicts.details) {
-        info(`  ${detail}`);
-    }
-}
-/**
- * True when both standard handles are real TTYs, i.e. an interactive prompt
- * can actually be answered.
- *
- * Named for the condition rather than for confirmation specifically: many
- * call sites gate a `text()` / `multiselect()` input prompt or a mode
- * switch, not a destructive confirmation.
- *
- * Node types `isTTY` as `boolean`, but at runtime it is `true | undefined`
- * (absent when the handle is not a TTY). Unusual harnesses (vitest stdio
- * capture, CI spawners, mocked pipes) can also leave it unset on only one
- * handle, so every falsy variant (false, undefined, a null-patched mock)
- * must route to the non-interactive path.
- */
-export function stdioIsInteractive() {
-    const stdinIsTTY = process.stdin.isTTY;
-    const stdoutIsTTY = process.stdout.isTTY;
-    return stdinIsTTY === true && stdoutIsTTY === true;
-}
-/**
- * Up-front non-interactive refusal for a command that will end at
- * {@link confirmDestructive}.
- *
- * `confirmDestructive` already refuses a prompt-less run rather than
- * proceeding silently, but it does so at the end, after the command has
- * built diffs and run projected per-patch lint. On `patch move-files
- * --create` that is minutes of work before a scripted run learns it needed
- * `--yes`, and the failure reads as an obscure late error rather than a
- * usage problem. Calling this at command entry turns it into a usage
- * refusal that names the flag.
- *
- * A `--yes` or `--dry-run` run never prompts, so neither is refused.
- *
- * @param operation - Stable operation id, e.g. `patch-move-files-create`
- * @param options - The run's `--yes` / `--dry-run` state
- * @throws InvalidArgumentError when the run would prompt but cannot
- */
-export function assertConfirmationAvailable(operation, options) {
-    if (options.yes === true || options.dryRun === true)
-        return;
-    if (stdioIsInteractive())
-        return;
-    throw new InvalidArgumentError(`"${operation}" ends in an interactive confirmation, but this run has no TTY to answer it ` +
-        '(stdin/stdout are not both terminals). Re-run with --yes to confirm non-interactively ' +
-        '(required for CI and agent-driven runs), or with --dry-run to preview without ' +
-        'confirming. Refusing up front rather than after the planning and lint work.', '--yes');
-}
-/**
- * Executes the destructive-operation contract: summary → conflict refusal →
- * dry-run / force / prompt / non-TTY refusal.
- *
- * Returns the decision for the caller to act on. Callers must not execute
- * the mutation when the result is `'dry-run'` or `'declined'`, and must call
- * {@link appendHistory} only after the mutation succeeds (never on dry-run
- * or decline).
- *
- * @param input - Operation description, flags, and optional conflict report
- * @returns `'proceed'` to execute, `'dry-run'` to skip execution, or
- *   `'declined'` when the user declined the prompt
- */
-export async function confirmDestructive(input) {
-    const { operation, title, summary, yes, dryRun, unsafeOverride, conflicts } = input;
-    // Dry-run: print everything that would happen (including refusal notice if
-    // the real run would be refused), but never mutate and never prompt.
-    if (dryRun) {
-        printSummary(`[dry-run] ${title}`, summary);
-        if (conflicts) {
-            printConflicts(conflicts);
-            info('  The non-dry-run would be refused. Use --force-unsafe only if you accept the risk.');
-        }
-        return 'dry-run';
-    }
-    // Hard refusal: structural conflicts are only bypassable by --force-unsafe,
-    // never by plain --yes. The distinction exists so that `--yes` can
-    // remain a safe-for-CI bypass of interactive prompts without also being a
-    // lint-override.
-    if (conflicts && !unsafeOverride) {
-        printConflicts(conflicts);
-        throw new InvalidArgumentError(`Refusing to run "${operation}": ${conflicts.reason}. ` +
-            'Fix the underlying issue (usually re-export --files or a different target), ' +
-            'or pass --force-unsafe if you genuinely accept the risk.', `--force-unsafe`);
-    }
-    if (conflicts && unsafeOverride) {
-        printConflicts(conflicts);
-        info('  Proceeding because --force-unsafe was provided.');
-    }
-    // --yes bypasses confirmation but not the non-dry-run execution path.
-    // Still print the summary so the operator (or CI log) has a record of what
-    // happened even when no prompt was shown.
-    if (yes) {
-        printSummary(title, summary);
-        return 'proceed';
-    }
-    // Non-TTY without --yes: refuse with a message pointing at --yes rather
-    // than silently proceeding.
-    if (!stdioIsInteractive()) {
-        printSummary(title, summary);
-        throw new InvalidArgumentError(`Interactive confirmation not available for "${operation}". ` +
-            'Use --yes to run non-interactively (required for CI).', '--yes');
-    }
-    // Interactive path: print the summary first so the user sees the full
-    // picture, then prompt.
-    printSummary(title, summary);
-    const confirmed = await confirm({
-        message: `${title} — proceed?`,
-        initialValue: false,
-    });
-    // An interrupt and a "no" are different outcomes and must not share an
-    // exit code. Esc / Ctrl+C is a real interrupt. 130 is 128+SIGINT and is
-    // what a script needs to tell "the operator aborted" from "the operator
-    // considered it and declined". Answering "no" is a successful run.
-    //
-    // `isCancel` narrows the clack sentinel away, leaving a plain boolean.
-    if (isCancel(confirmed)) {
-        throw new CancellationError();
-    }
-    if (!confirmed) {
-        return 'declined';
-    }
-    return 'proceed';
-}
-/**
- * Appends a single JSONL record to the project's patch history log
- * (`.fireforge/history.jsonl` unless `fireforge.json#history.path` says
- * otherwise; a log found at `patches/.fireforge-history.jsonl` is moved
- * there first).
- *
- * Call order matters: append only after the mutation succeeds, never
- * pre-emptively, so rolled-back failures do not leave ghost entries. The log
- * is append-only and advisory: no code path reads it back. It exists so
- * operators have a post-hoc audit trail when something goes wrong. Every
- * record carries the writing invocation's id (and `FIREFORGE_SESSION_ID`
- * when set), so a session sharing the checkout can pick out its own lines.
- *
- * @param patchesDir - Path to the patches directory
- * @param entry - Serializable history record
- */
-export async function appendHistory(patchesDir, entry) {
-    const record = {
-        ts: new Date().toISOString(),
-        ...historyRecordIdentity(),
-        ...entry,
-    };
-    await appendHistoryLine(patchesDir, JSON.stringify(record));
-}

package/dist/src/core/diff-hunks.d.ts

@@ -1,73 +0,0 @@
-/**
- * An edit op produced by {@link computeLineDiff}. Indices are 0-based into the
- * source line arrays. `line` holds the verbatim text so callers do not have to
- * keep the input arrays around while rendering.
- */
-export interface LineDiffOp {
-    type: 'equal' | 'delete' | 'insert';
-    oldIndex?: number;
-    newIndex?: number;
-    line: string;
-}
-/**
- * A single line inside a hunk, rendered as one of the three unified-diff
- * markers. Content is the raw line text with no marker prefix so callers can
- * apply their own coloring before the prefix is added.
- */
-export interface HunkLine {
-    marker: ' ' | '-' | '+';
-    content: string;
-}
-/**
- * A unified-diff hunk. Line numbers are 1-based to match `@@ -X,N +Y,M @@`
- * convention.
- */
-export interface DiffHunk {
-    oldStart: number;
-    oldLength: number;
-    newStart: number;
-    newLength: number;
-    lines: HunkLine[];
-}
-/**
- * A pre-split line output ready for the caller to apply color and emit. Kept
- * free of color codes so the same structure can be unit-tested without
- * depending on the logger.
- */
-export interface RenderedDiffLine {
-    kind: 'header' | 'context' | 'removed' | 'added';
-    text: string;
-}
-/**
- * LCS-based line diff. Runs in O(m·n) time and memory using a single flat
- * `Int32Array` for the DP table. Guarded by {@link LCS_LINE_LIMIT} so callers
- * on very large files transparently get the coalesced fallback instead of
- * allocating hundreds of megabytes.
- *
- * Behavior note: the backtrack walks diagonals in a deterministic order, so
- * the same input always produces the same op sequence. This matters for
- * snapshot tests and for UI stability when the user re-runs `furnace diff`.
- */
-export declare function computeLineDiff(oldLines: readonly string[], newLines: readonly string[]): LineDiffOp[];
-/**
- * Groups an op stream into unified-diff hunks with `context` lines of
- * surrounding equal-line context. Adjacent edit runs whose expanded context
- * regions overlap are merged into a single hunk, matching `diff -U N`.
- *
- * Returns an empty array when the two inputs were identical.
- */
-export declare function buildHunks(ops: readonly LineDiffOp[], context: number): DiffHunk[];
-/**
- * Computes a multi-hunk line diff between two strings. This is the public
- * entry point that {@link furnaceDiffCommand} uses. On normal inputs this
- * runs the exact LCS path and returns a proper multi-hunk diff. On inputs
- * that exceed {@link LCS_LINE_LIMIT} it falls back to a single coalesced
- * hunk so the command stays useful instead of OOMing.
- */
-export declare function diffLines(oldText: string, newText: string, context?: number): DiffHunk[];
-/**
- * Renders hunks into a flat list of lines the caller can emit one by one.
- * Kept color-free so unit tests can assert exact output and so the caller
- * can apply its own formatting (e.g. `formatErrorText` / `formatSuccessText`).
- */
-export declare function renderHunks(hunks: readonly DiffHunk[]): RenderedDiffLine[];

package/dist/src/core/diff-hunks.js

@@ -1,286 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { assert, expectDefined } from '../utils/assert.js';
-/**
- * Maximum combined LCS table side-length before bailing out of the exact
- * O(m·n) diff and falling back to the simpler single-region coalesce. Chosen
- * so the worst-case Int32Array allocation stays under ~16 MB. Typical
- * Firefox widget files are a few hundred lines, so the fast path handles the
- * everyday case. The fallback keeps the command usable on a very large file.
- */
-const LCS_LINE_LIMIT = 2000;
-/** Splits a string on `\n`, discarding a single trailing empty line from a terminal newline. */
-function splitLines(text) {
-    const lines = text.split('\n');
-    if (lines.length > 0 && lines[lines.length - 1] === '')
-        lines.pop();
-    return lines;
-}
-/**
- * LCS-based line diff. Runs in O(m·n) time and memory using a single flat
- * `Int32Array` for the DP table. Guarded by {@link LCS_LINE_LIMIT} so callers
- * on very large files transparently get the coalesced fallback instead of
- * allocating hundreds of megabytes.
- *
- * Behavior note: the backtrack walks diagonals in a deterministic order, so
- * the same input always produces the same op sequence. This matters for
- * snapshot tests and for UI stability when the user re-runs `furnace diff`.
- */
-export function computeLineDiff(oldLines, newLines) {
-    const m = oldLines.length;
-    const n = newLines.length;
-    // The DP below indexes `dp`, `oldLines`, and `newLines` about 4·m·n times
-    // for a worst-case pair, so its bounds are established once here rather
-    // than re-checked per access. Callers gate on LCS_LINE_LIMIT before
-    // reaching this function. If that gate is ever moved or removed, this is
-    // where the resulting allocation blow-up surfaces as a named failure
-    // instead of an out-of-memory crash.
-    assert(m <= LCS_LINE_LIMIT && n <= LCS_LINE_LIMIT, () => `line diff inputs are within LCS_LINE_LIMIT (got ${m}x${n}, limit ${LCS_LINE_LIMIT})`);
-    const dp = new Int32Array((m + 1) * (n + 1));
-    const stride = n + 1;
-    // Every index into `dp` is `row * stride + column` with row ≤ m and
-    // column ≤ n, which is exactly the extent allocated above.
-    assert(dp.length === (m + 1) * stride, 'DP table is sized to its stride');
-    /* eslint-disable @typescript-eslint/no-non-null-assertion --
-     * The DP fill and backtrack below are the one hot path in this module:
-     * O(m·n) iterations, up to ~4M for a LCS_LINE_LIMIT-sized pair. Every
-     * index is structurally bounded by the loop conditions (`i <= m`,
-     * `j <= n`, `i > 0`, `j > 0`) against the extents asserted immediately
-     * above, so the non-null assertions encode a property already checked
-     * once per call rather than one that is never checked at all. The
-     * rendering loops further down, which run O(ops), use `expectDefined`
-     * instead. This exemption is for the quadratic block only.
-     */
-    for (let i = 1; i <= m; i++) {
-        const oldLine = oldLines[i - 1];
-        const rowOffset = i * stride;
-        const prevRowOffset = (i - 1) * stride;
-        for (let j = 1; j <= n; j++) {
-            if (oldLine === newLines[j - 1]) {
-                dp[rowOffset + j] = dp[prevRowOffset + j - 1] + 1;
-            }
-            else {
-                const up = dp[prevRowOffset + j];
-                const left = dp[rowOffset + j - 1];
-                dp[rowOffset + j] = up >= left ? up : left;
-            }
-        }
-    }
-    const ops = [];
-    let i = m;
-    let j = n;
-    while (i > 0 && j > 0) {
-        if (oldLines[i - 1] === newLines[j - 1]) {
-            ops.push({ type: 'equal', oldIndex: i - 1, newIndex: j - 1, line: oldLines[i - 1] });
-            i--;
-            j--;
-            continue;
-        }
-        const up = dp[(i - 1) * stride + j];
-        const left = dp[i * stride + j - 1];
-        if (up >= left) {
-            ops.push({ type: 'delete', oldIndex: i - 1, line: oldLines[i - 1] });
-            i--;
-        }
-        else {
-            ops.push({ type: 'insert', newIndex: j - 1, line: newLines[j - 1] });
-            j--;
-        }
-    }
-    while (i > 0) {
-        ops.push({ type: 'delete', oldIndex: i - 1, line: oldLines[i - 1] });
-        i--;
-    }
-    while (j > 0) {
-        ops.push({ type: 'insert', newIndex: j - 1, line: newLines[j - 1] });
-        j--;
-    }
-    /* eslint-enable @typescript-eslint/no-non-null-assertion */
-    ops.reverse();
-    return ops;
-}
-/**
- * Groups an op stream into unified-diff hunks with `context` lines of
- * surrounding equal-line context. Adjacent edit runs whose expanded context
- * regions overlap are merged into a single hunk, matching `diff -U N`.
- *
- * Returns an empty array when the two inputs were identical.
- */
-export function buildHunks(ops, context) {
-    const editRanges = [];
-    let i = 0;
-    while (i < ops.length) {
-        if (expectDefined(ops[i], () => `diff op at index ${i}`).type !== 'equal') {
-            const start = i;
-            while (i < ops.length &&
-                expectDefined(ops[i], () => `diff op at index ${i}`).type !== 'equal')
-                i++;
-            editRanges.push({ start, end: i });
-        }
-        else {
-            i++;
-        }
-    }
-    if (editRanges.length === 0)
-        return [];
-    const expanded = [];
-    for (const range of editRanges) {
-        const start = Math.max(0, range.start - context);
-        const end = Math.min(ops.length, range.end + context);
-        const prev = expanded[expanded.length - 1];
-        if (prev && start <= prev.end) {
-            prev.end = Math.max(prev.end, end);
-        }
-        else {
-            expanded.push({ start, end });
-        }
-    }
-    const hunks = [];
-    for (const range of expanded) {
-        let oldLine = 1;
-        let newLine = 1;
-        for (let k = 0; k < range.start; k++) {
-            const op = expectDefined(ops[k], () => `diff op at index ${k}`);
-            if (op.type === 'equal') {
-                oldLine++;
-                newLine++;
-            }
-            else if (op.type === 'delete') {
-                oldLine++;
-            }
-            else {
-                newLine++;
-            }
-        }
-        const hunkLines = [];
-        let oldLength = 0;
-        let newLength = 0;
-        for (let k = range.start; k < range.end; k++) {
-            const op = expectDefined(ops[k], () => `diff op at index ${k}`);
-            if (op.type === 'equal') {
-                hunkLines.push({ marker: ' ', content: op.line });
-                oldLength++;
-                newLength++;
-            }
-            else if (op.type === 'delete') {
-                hunkLines.push({ marker: '-', content: op.line });
-                oldLength++;
-            }
-            else {
-                hunkLines.push({ marker: '+', content: op.line });
-                newLength++;
-            }
-        }
-        hunks.push({
-            oldStart: oldLength === 0 ? oldLine - 1 : oldLine,
-            oldLength,
-            newStart: newLength === 0 ? newLine - 1 : newLine,
-            newLength,
-            lines: hunkLines,
-        });
-    }
-    return hunks;
-}
-/**
- * Fallback for inputs that exceed {@link LCS_LINE_LIMIT}. Reproduces the
- * original single-region coalesce: match the common prefix and suffix, then
- * emit one hunk containing the middle region plus `context` lines on each
- * side. Kept simple on purpose: the fast path handles normal files, and
- * this only keeps the command usable on pathologically large inputs without
- * allocating a huge DP table.
- */
-function coalescedHunk(oldLines, newLines, context) {
-    let firstDiff = 0;
-    while (firstDiff < oldLines.length && firstDiff < newLines.length) {
-        if (oldLines[firstDiff] !== newLines[firstDiff])
-            break;
-        firstDiff++;
-    }
-    let lastOldDiff = oldLines.length - 1;
-    let lastNewDiff = newLines.length - 1;
-    while (lastOldDiff >= firstDiff && lastNewDiff >= firstDiff) {
-        if (oldLines[lastOldDiff] !== newLines[lastNewDiff])
-            break;
-        lastOldDiff--;
-        lastNewDiff--;
-    }
-    if (lastOldDiff < firstDiff && lastNewDiff < firstDiff) {
-        return [];
-    }
-    const contextStart = Math.max(0, firstDiff - context);
-    const contextEndNew = Math.min(newLines.length - 1, lastNewDiff + context);
-    const hunkLines = [];
-    for (let k = contextStart; k < firstDiff; k++) {
-        hunkLines.push({ marker: ' ', content: expectDefined(oldLines[k], () => `old line ${k}`) });
-    }
-    for (let k = firstDiff; k <= lastOldDiff; k++) {
-        hunkLines.push({ marker: '-', content: expectDefined(oldLines[k], () => `old line ${k}`) });
-    }
-    for (let k = firstDiff; k <= lastNewDiff; k++) {
-        hunkLines.push({ marker: '+', content: expectDefined(newLines[k], () => `new line ${k}`) });
-    }
-    // Trailing context comes from the common suffix, which lives at different
-    // indices on each side (lastOldDiff+1… vs lastNewDiff+1…). Mixing the two
-    // coordinate spaces emits wrong context on asymmetric edits and drops the
-    // trailing lines from the @@ header lengths, so the rendered header
-    // disagrees with the body.
-    for (let k = lastNewDiff + 1; k <= contextEndNew; k++) {
-        hunkLines.push({ marker: ' ', content: expectDefined(newLines[k], () => `new line ${k}`) });
-    }
-    const leadingContext = firstDiff - contextStart;
-    // Common-suffix symmetry: oldLen-1-lastOldDiff === newLen-1-lastNewDiff,
-    // so both sides clamp to the same trailing context count.
-    const trailingContext = contextEndNew - lastNewDiff;
-    const oldLength = lastOldDiff - firstDiff + 1 + leadingContext + trailingContext;
-    const newLength = lastNewDiff - firstDiff + 1 + leadingContext + trailingContext;
-    return [
-        {
-            oldStart: contextStart + 1,
-            oldLength,
-            newStart: contextStart + 1,
-            newLength,
-            lines: hunkLines,
-        },
-    ];
-}
-/**
- * Computes a multi-hunk line diff between two strings. This is the public
- * entry point that {@link furnaceDiffCommand} uses. On normal inputs this
- * runs the exact LCS path and returns a proper multi-hunk diff. On inputs
- * that exceed {@link LCS_LINE_LIMIT} it falls back to a single coalesced
- * hunk so the command stays useful instead of OOMing.
- */
-export function diffLines(oldText, newText, context = 3) {
-    const oldLines = splitLines(oldText);
-    const newLines = splitLines(newText);
-    if (oldLines.length > LCS_LINE_LIMIT || newLines.length > LCS_LINE_LIMIT) {
-        return coalescedHunk(oldLines, newLines, context);
-    }
-    const ops = computeLineDiff(oldLines, newLines);
-    return buildHunks(ops, context);
-}
-/**
- * Renders hunks into a flat list of lines the caller can emit one by one.
- * Kept color-free so unit tests can assert exact output and so the caller
- * can apply its own formatting (e.g. `formatErrorText` / `formatSuccessText`).
- */
-export function renderHunks(hunks) {
-    const out = [];
-    for (const hunk of hunks) {
-        out.push({
-            kind: 'header',
-            text: `@@ -${hunk.oldStart},${hunk.oldLength} +${hunk.newStart},${hunk.newLength} @@`,
-        });
-        for (const line of hunk.lines) {
-            if (line.marker === ' ') {
-                out.push({ kind: 'context', text: `  ${line.content}` });
-            }
-            else if (line.marker === '-') {
-                out.push({ kind: 'removed', text: `- ${line.content}` });
-            }
-            else {
-                out.push({ kind: 'added', text: `+ ${line.content}` });
-            }
-        }
-    }
-    return out;
-}

package/dist/src/core/discard-baseline.d.ts

@@ -1,60 +0,0 @@
-/**
- * Patch-aware restore planning for `fireforge discard`.
- *
- * The engine convention is: HEAD = pristine upstream Firefox, and the
- * applied patch queue lives as uncommitted worktree changes on top of it
- * (`git apply` without `--index` → patch-edited tracked files are unstaged
- * modifications, patch-created files are untracked). A purely git-mechanical
- * discard (restore to HEAD, delete untracked files) therefore reverts
- * patch-backed files past their owning patch and deletes patch-created files
- * outright.
- *
- * This module classifies each status entry against the patch manifest's
- * ownership claims and plans the correct restore target: the patch-applied
- * baseline (HEAD content folded through every affecting patch in order) for
- * claimed files, and the plain git mechanics for unmanaged ones.
- */
-import type { GitStatusEntry } from './git-base.js';
-/** How one status entry's canonical path will be restored. */
-export type DiscardKind = 'unmanaged' | 'patch-backed' | 'patch-created' | 'patch-deleted';
-/** Restore plan for one git status entry. */
-export interface DiscardBaselinePlan {
-    entry: GitStatusEntry;
-    kind: DiscardKind;
-    /** Claiming patch filenames for `entry.file` ∪ `entry.originalPath`. */
-    owners: string[];
-    /** True when more than one patch claims the path (ownership conflict). */
-    conflicted: boolean;
-    /** Baseline content for `entry.file` (null = absent at baseline). Unset for 'unmanaged'. */
-    expectedContent?: string | null;
-    /** Rename/copy only: baseline content for `originalPath` when that side is claimed. */
-    expectedOriginalContent?: string | null;
-}
-/** Builds an all-unmanaged plan set, the `--to-upstream` shape. */
-export declare function planUpstreamDiscards(entries: readonly GitStatusEntry[]): DiscardBaselinePlan[];
-/**
- * Plans the restore target for each status entry. Entries claimed by the
- * patch manifest restore to the patch-applied baseline. Unclaimed entries
- * keep the plain git mechanics. A missing patches dir or empty manifest
- * degrades every plan to `unmanaged`.
- *
- * A corrupt manifest or an unreconstructible patch baseline refuses with a
- * GeneralError naming `--to-upstream`. Silently falling back to pristine
- * HEAD is the data-loss path this module exists to close.
- */
-export declare function planDiscardBaselines(patchesDir: string, engineDir: string, entries: readonly GitStatusEntry[]): Promise<DiscardBaselinePlan[]>;
-/**
- * Applies one restore plan. Patch-claimed paths end up exactly as `import`
- * leaves them: patched content as an unstaged worktree state (tracked files
- * read ` M`, created files `??`), nothing staged. Unmanaged plans delegate
- * to the plain git {@link discardStatusEntry} mechanics.
- */
-export declare function applyDiscardBaseline(engineDir: string, plan: DiscardBaselinePlan): Promise<void>;
-/** One-line annotation for dry-run listings and confirmation summaries. */
-export declare function describeDiscardBaseline(plan: DiscardBaselinePlan): string;
-/** Single-file outro naming the baseline that was restored. */
-export declare function describeDiscardOutcome(plan: DiscardBaselinePlan, toUpstream: boolean): string;
-/** Batch outro summarising how many files restored to which baseline. */
-export declare function summarizeDiscardBaselines(plans: readonly DiscardBaselinePlan[], succeeded: number): string;
-/** Warn text for a multi-owner (conflicted) restore. */
-export declare function describeConflictWarning(plan: DiscardBaselinePlan): string;