@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/re-export-files.js

@@ -1,307 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { appendHistory, confirmDestructive, } from '../core/destructive.js';
-import { enforceFreshFurnaceSources } from '../core/furnace-stale-export.js';
-import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
-import { listTrackedInHead } from '../core/git-file-ops.js';
-import { extractAffectedFiles } from '../core/patch-apply.js';
-import { updatePatchAndMetadata } from '../core/patch-export.js';
-import { buildPatchQueueContext, formatPatchLintIssue, lintPatchQueue, } from '../core/patch-lint.js';
-import { buildLintIgnoreChecks, mergeLintIgnoreIds } from '../core/patch-lint-ignore.js';
-import { computeProjectedLintRegressions } from '../core/patch-lint-projection.js';
-import { loadPatchesManifest } from '../core/patch-manifest.js';
-import { buildProjectedManifest, enforcePatchPolicy } from '../core/patch-policy.js';
-import { InvalidArgumentError } from '../errors/base.js';
-import { pathExists } from '../utils/fs.js';
-import { info, outro, success, warn } from '../utils/logger.js';
-import { runPatchLint } from './export-shared.js';
-import { projectEntryBody } from './patch/entry-projection.js';
-/**
- * Computes the effective `tier` and `lintIgnore` carrying both the patch's
- * existing values and the CLI flag overrides.
- *
- * Tier resolution: the CLI flag takes precedence. The patch's existing tier
- * is the fallback. Lint-ignore resolution: union of the patch's existing list
- * and the CLI flag values, de-duplicated. An empty result returns `undefined`
- * so the caller can drop the field rather than write an empty array.
- */
-function resolveEffectiveTierAndLintIgnore(target, options) {
-    const flagIgnoreSet = new Set(options.lintIgnore ?? []);
-    const effectiveLintIgnore = mergeLintIgnoreIds(target.lintIgnore, [...flagIgnoreSet]);
-    const effectiveTier = options.tier ?? target.tier;
-    return { effectiveTier, effectiveLintIgnore, flagIgnoreSet };
-}
-/**
- * Projects the cross-patch context (replace the target entry with its
- * shrunken self), runs the patch-queue lint against the projection, and
- * returns a conflict report only for regressions introduced *by* this
- * shrink. Pre-existing cross-patch errors are surfaced as a non-blocking
- * warning so the user does not walk away thinking the queue is clean.
- */
-async function runProjectedCrossPatchLint(patchesDir, targetFilename, projectedDiff, config) {
-    // The config threads `patchLint.forwardRegistration` through, so a forward
-    // jar.mn registration is judged the way `lint --per-patch` judges it.
-    const baseCtx = await buildPatchQueueContext(patchesDir, config);
-    const projection = projectEntryBody(projectedDiff);
-    const projectedEntries = baseCtx.entries.map((entry) => {
-        if (entry.filename !== targetFilename)
-            return entry;
-        return { ...entry, ...projection };
-    });
-    const baselineIssues = lintPatchQueue(baseCtx).filter((i) => i.severity === 'error');
-    const projectedIssues = lintPatchQueue({ ...baseCtx, entries: projectedEntries }).filter((i) => i.severity === 'error');
-    const regressions = computeProjectedLintRegressions(baselineIssues, projectedIssues);
-    if (baselineIssues.length > 0 && regressions.length === 0) {
-        warn(`Note: projected queue still has ${baselineIssues.length} pre-existing ` +
-            `cross-patch error(s) unrelated to this shrink. Run "fireforge verify" to list them.`);
-    }
-    if (regressions.length === 0)
-        return null;
-    return {
-        reason: `projected --files state introduces ${regressions.length} new cross-patch lint error(s)`,
-        details: regressions.map(formatPatchLintIssue),
-    };
-}
-/**
- * Builds the `Partial<PatchMetadata>` payload for the `--files` write,
- * folding in the CLI flag overrides for `tier` and `lintIgnore` only when the
- * operator actually asked for them.
- */
-function buildFilesModeMetadataUpdates(actualProjectedFiles, options, effectiveLintIgnore, flagIgnoreSet) {
-    const updates = {
-        filesAffected: actualProjectedFiles,
-    };
-    if (options.tier !== undefined) {
-        updates.tier = options.tier;
-    }
-    if (effectiveLintIgnore !== undefined && flagIgnoreSet.size > 0) {
-        updates.lintIgnore = effectiveLintIgnore;
-    }
-    return updates;
-}
-async function confirmFilesModeProjection(args) {
-    const { target, retained, removed, added, actualProjectedFiles, deletedFiles, options, conflicts, } = args;
-    const isDryRun = options.dryRun === true;
-    const summary = [
-        `re-export ${target.filename} with --files scope`,
-        `current files (${target.filesAffected.length}): ${target.filesAffected.join(', ') || '(none)'}`,
-        `retained files (${retained.length}): ${retained.join(', ') || '(none)'}`,
-        `projected files (${actualProjectedFiles.length}): ${actualProjectedFiles.join(', ') || '(none)'}`,
-    ];
-    if (removed.length > 0) {
-        summary.push(`removed files (${removed.length}; become unmanaged): ${removed.join(', ')}`);
-    }
-    if (added.length > 0) {
-        summary.push(`newly included files (${added.length}): ${added.join(', ')}`);
-    }
-    if (deletedFiles.length > 0) {
-        summary.push(`deleted on disk (captured as deletions the patch will replay): ${deletedFiles.join(', ')}`);
-    }
-    if (!isDryRun && removed.length > 0 && options.allowShrink !== true) {
-        warn(`Refusing to shrink ${target.filename} without --allow-shrink.`);
-        for (const line of summary) {
-            info(`  ${line}`);
-        }
-        throw new InvalidArgumentError(`Refusing to re-export ${target.filename} with --files because it would remove ${removed.length} existing patch-owned file${removed.length === 1 ? '' : 's'}. Run again with --allow-shrink after reviewing the dry-run output. ` +
-            'If the intent is to move those files into their own patch instead, ' +
-            '"fireforge patch move-files <from> <to> --file <path> --create --order <n>" does the shrink and the new patch in one transaction.', '--allow-shrink');
-    }
-    return confirmDestructive({
-        operation: 're-export-files',
-        title: `Re-export ${target.filename} with --files`,
-        summary,
-        // A captured deletion still needs the confirmation: the patch will now
-        // remove those files wherever it is applied, which is the same class of
-        // consequence as shrinking the scope.
-        yes: removed.length === 0 && deletedFiles.length === 0 ? true : options.yes === true,
-        dryRun: isDryRun,
-        unsafeOverride: options.forceUnsafe === true,
-        conflicts,
-    });
-}
-/**
- * Splits the requested paths into what can be diffed and what is a deletion.
- *
- * A path absent from disk is one of two very different things, and
- * collapsing them is what made a deletion impossible to capture.
- *
- * Tracked in HEAD: a deletion. `git diff HEAD -- <path>` renders it as a
- * proper `deleted file mode` section, so it stays in the diff scope. (The
- * comment this replaces claimed the diff "would fail" on any missing path,
- * which is true only for the never-tracked case.) Dropping these produced
- * the dangerous shape: a re-export that reported success while writing a patch
- * whose own file list claimed a path it did not restore, so a fresh clone
- * would apply it and resurrect exactly what the change meant to remove.
- *
- * Never tracked in HEAD: nothing on disk and nothing to diff against, so
- * there is no hunk to be had. Refused rather than warned about, because the
- * patch cannot express it either way.
- *
- * @param requested - The `--files` scope
- * @param engineDir - Absolute path to the engine checkout
- * @param patchFilename - Target patch, for the refusal message
- * @returns The diffable scope and the subset captured as deletions
- */
-async function classifyRequestedPaths(requested, engineDir, patchFilename) {
-    const absentFiles = [];
-    for (const file of requested) {
-        if (!(await pathExists(join(engineDir, file)))) {
-            absentFiles.push(file);
-        }
-    }
-    const trackedAbsent = await listTrackedInHead(engineDir, absentFiles);
-    const untrackedAbsent = absentFiles.filter((f) => !trackedAbsent.has(f));
-    const deletedFiles = absentFiles.filter((f) => trackedAbsent.has(f));
-    if (untrackedAbsent.length > 0) {
-        throw new InvalidArgumentError(`Refusing to re-export ${patchFilename} with --files because ${untrackedAbsent.length} requested path${untrackedAbsent.length === 1 ? ' is' : 's are'} ` +
-            `neither on disk nor tracked in engine HEAD (${untrackedAbsent.join(', ')}). ` +
-            'There is no content to diff and no deletion to record, so the patch could not ' +
-            'honour the file list it would claim. Remove those paths from --files.', '--files');
-    }
-    for (const file of deletedFiles) {
-        info(`${patchFilename}: capturing deletion of ${file}`);
-    }
-    const untrackedSet = new Set(untrackedAbsent);
-    return { diffableFiles: requested.filter((f) => !untrackedSet.has(f)), deletedFiles };
-}
-/**
- * Handles `re-export --files` end-to-end: computes the projected diff, runs
- * the per-patch and cross-patch lint against a context in which the target
- * patch has been replaced with the projected state, gates on
- * confirmDestructive, and writes atomically.
- *
- * Lives outside reExportSinglePatch because the --files path has strictly
- * different semantics (authoritative file list, destructive shrink
- * confirmation, cross-patch projection lint). Shoehorning it through the
- * generic single-patch helper is what makes the projection lint run against
- * the current (unchanged) queue instead of the projected state.
- */
-export async function reExportFilesInPlace(paths, selectedPatches, options, config) {
-    const target = selectedPatches[0];
-    if (!target) {
-        throw new InvalidArgumentError('--files requires a target patch.', '--files');
-    }
-    const filesOption = options.files;
-    if (filesOption === undefined) {
-        throw new InvalidArgumentError('reExportFilesInPlace called with no --files.', '--files');
-    }
-    const requested = [...new Set(filesOption)].sort();
-    // Stale-furnace-source gate: same refusal as the generic re-export path,
-    // since the projected diff would capture stale deployed copies.
-    await enforceFreshFurnaceSources(paths.root, requested, options.allowStaleFurnace === true, 're-export');
-    const removed = target.filesAffected.filter((f) => !requested.includes(f));
-    const added = requested.filter((f) => !target.filesAffected.includes(f));
-    const retained = target.filesAffected.filter((f) => requested.includes(f));
-    const { diffableFiles, deletedFiles } = await classifyRequestedPaths(requested, paths.engine, target.filename);
-    // Compute the projected diff up front. This is the same diff the real
-    // write would produce, so we get an exact preview through the lint
-    // gate and avoid computing it twice.
-    const projectedDiff = diffableFiles.length > 0 ? await getDiffForFilesAgainstHead(paths.engine, diffableFiles) : '';
-    if (!projectedDiff.trim()) {
-        throw new InvalidArgumentError(`Refusing to re-export ${target.filename} with --files because the projected scope ` +
-            'produces an empty patch. FireForge does not write zero-hunk patch files; ' +
-            `use "fireforge patch delete ${target.filename}" if this patch should be removed entirely.`, '--files');
-    }
-    const actualProjectedFiles = extractAffectedFiles(projectedDiff);
-    const actualProjectedSet = new Set(actualProjectedFiles);
-    // Domain is the full requested list, not the diffable subset. When the
-    // subset was used, any path filtered out upstream was invisible to this
-    // check, which is how a dropped deletion slipped through while the run
-    // reported success. A patch must do what its own file list claims, so an
-    // explicitly named path that produced no hunk is a refusal.
-    const noDiffFiles = requested.filter((file) => !actualProjectedSet.has(file));
-    if (noDiffFiles.length > 0) {
-        throw new InvalidArgumentError(`Refusing to re-export ${target.filename} with --files because ${noDiffFiles.length} requested path${noDiffFiles.length === 1 ? '' : 's'} produced no diff hunks (${noDiffFiles.join(', ')}). ` +
-            'Keeping them in filesAffected would desync patches.json from the patch body. ' +
-            'Remove those paths from --files or modify them before retrying.', '--files');
-    }
-    // Run the per-patch lint against the projected diff, mirroring what
-    // runPatchLint does in the standard re-export path. The target patch's
-    // `lintIgnore` threads through so a shrink of an advisory-noisy-but-
-    // intentional patch (branding bundle, localised-resource pack) does not
-    // have to choose between `--skip-lint` (blunt) and the full rebase path.
-    // `target.tier` threads the explicit branding-threshold opt-in. CLI flags
-    // `--tier` and `--lint-ignore` participate too, with append/union
-    // semantics on the lint-ignore list.
-    const { effectiveTier, effectiveLintIgnore, flagIgnoreSet } = resolveEffectiveTierAndLintIgnore(target, options);
-    const ignoreChecks = buildLintIgnoreChecks(effectiveLintIgnore);
-    const patchQueueCtx = (await pathExists(paths.patches))
-        ? await buildPatchQueueContext(paths.patches)
-        : undefined;
-    await runPatchLint({
-        engineDir: paths.engine,
-        filesAffected: actualProjectedFiles,
-        diffContent: projectedDiff,
-        config,
-        skipLint: options.skipLint,
-        patchQueueCtx,
-        ignoreChecks,
-        patchTier: effectiveTier,
-    });
-    const conflicts = await runProjectedCrossPatchLint(paths.patches, target.filename, projectedDiff, config);
-    const filesUpdates = buildFilesModeMetadataUpdates(actualProjectedFiles, options, effectiveLintIgnore, flagIgnoreSet);
-    const manifest = await loadPatchesManifest(paths.patches);
-    if (manifest) {
-        enforcePatchPolicy({
-            config,
-            manifest: buildProjectedManifest(manifest, manifest.patches.map((entry) => entry.filename === target.filename ? { ...entry, ...filesUpdates } : entry)),
-            command: 're-export --files',
-            forceUnsafe: options.forceUnsafe === true,
-            scope: [target.filename],
-        });
-    }
-    const decision = await confirmFilesModeProjection({
-        target,
-        retained,
-        removed,
-        added,
-        actualProjectedFiles,
-        deletedFiles,
-        options,
-        conflicts,
-    });
-    if (decision === 'declined') {
-        outro('Re-export cancelled');
-        return;
-    }
-    if (decision === 'dry-run') {
-        info(`[dry-run] ${target.filename}: ${actualProjectedFiles.length} file(s) in projected scope`);
-        outro('Dry run complete — no changes made');
-        return;
-    }
-    // Execute the write. At this point the projected diff is guaranteed
-    // non-empty and `actualProjectedFiles` is guaranteed to match the paths the
-    // body really touches, so the manifest cannot drift from the regenerated
-    // patch body. The history append runs inside the same patch directory lock
-    // as the mutation (via the onCommitted hook) so two concurrent re-exports
-    // cannot interleave records and a crash between mutation and append cannot
-    // orphan the audit trail.
-    await updatePatchAndMetadata({
-        patchesDir: paths.patches,
-        filename: target.filename,
-        newContent: projectedDiff,
-        updates: filesUpdates,
-        onCommitted: async () => {
-            await appendHistory(paths.patches, {
-                operation: 're-export-files',
-                args: {
-                    filename: target.filename,
-                    files: actualProjectedFiles,
-                    previousFiles: target.filesAffected,
-                    deletionsCaptured: deletedFiles,
-                },
-                ...(options.yes === true ? { yes: true } : {}),
-                ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
-                result: 'ok',
-            });
-        },
-        policyGate: {
-            config,
-            command: 're-export --files',
-            forceUnsafe: options.forceUnsafe === true,
-            scope: [target.filename],
-        },
-    });
-    success(`Re-exported ${target.filename}`);
-    outro('Re-export complete');
-}

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

@@ -1,37 +0,0 @@
-import { type ParsedHunk } from '../core/patch-parse.js';
-/** Which hunk mode a re-export runs in, and the diff naming the hunks. */
-export interface HunkSelection {
-    mode: 'include' | 'exclude';
-    diffPath: string;
-    flag: '--hunks-from' | '--exclude-hunks';
-}
-/** The selection a re-export's options ask for, if any. */
-export declare function hunkSelectionOf(options: {
-    hunksFrom?: string;
-    excludeHunks?: string;
-}): HunkSelection | undefined;
-/** Splits a diff into its raw per-file sections, keyed by target path. */
-export declare function splitRawSections(diff: string): Map<string, string>;
-/**
- * Applies `hunks` to `content` by context, forward or reversed. A hunk
- * whose context is not found refuses, naming it.
- */
-export declare function applyHunksByContext(content: string, hunks: readonly ParsedHunk[], reverse: boolean, file: string): string;
-/**
- * Builds the re-export body for a hunk-selected run: named files from the
- * selected hunks, the rest from the old body (`--hunks-from`) or the normal
- * working-tree diff (`--exclude-hunks`).
- *
- * @param args.normalDiff - The diff a plain re-export would write
- * @param args.oldBody - The patch's current body
- * @param args.files - The files the refreshed patch owns
- * @param args.patchFilename - The patch being refreshed
- */
-export declare function buildHunkSelectedDiff(args: {
-    engineDir: string;
-    selection: HunkSelection;
-    patchFilename: string;
-    oldBody: string;
-    normalDiff: string;
-    files: readonly string[];
-}): Promise<string>;

package/dist/src/commands/re-export-hunks.js

@@ -1,264 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `re-export --hunks-from <diff>` and `--exclude-hunks <diff>`: export a
- * file by hunk rather than as a whole.
- *
- * Re-export captures a file's working-tree content against engine HEAD, so
- * on a shared engine a peer's unexported line in the same manifest or chrome
- * document landed in the exporting patch, and the only way out was for the
- * peer to park its hunk by hand. These two modes build the file's new
- * content from the hunks a session names:
- *
- *  - `--hunks-from`: the patch's current body for the file (HEAD with the
- *    old section applied) plus only the named hunks. Files the diff does
- *    not name keep their old section.
- *  - `--exclude-hunks`: the working tree minus the named hunks. Files the
- *    diff does not name export as usual.
- *
- * Hunks are placed by their context, searched outward from the line their
- * header names, so a diff taken before a peer's edit above it still applies.
- * The synthetic content is diffed against HEAD by git itself, on a
- * throwaway index, so the section is byte-for-byte what a plain re-export
- * would write for that content.
- */
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { git } from '../core/git-base.js';
-import { getFileContentAtRef, listTrackedInHead } from '../core/git-file-ops.js';
-import { mintDisposableGitIndex } from '../core/git-readonly-index.js';
-import { parseDiffGitHeader, parseDiffSections, withGitHeaders, } from '../core/patch-parse.js';
-import { applyPatchTextToContent } from '../core/patch-transform.js';
-import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-import { PatchError } from '../errors/patch.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { normalizeEngineRelativeInput } from './re-export-scan.js';
-/** The selection a re-export's options ask for, if any. */
-export function hunkSelectionOf(options) {
-    if (options.hunksFrom !== undefined) {
-        return { mode: 'include', diffPath: options.hunksFrom, flag: '--hunks-from' };
-    }
-    if (options.excludeHunks !== undefined) {
-        return { mode: 'exclude', diffPath: options.excludeHunks, flag: '--exclude-hunks' };
-    }
-    return undefined;
-}
-/** Splits a diff into its raw per-file sections, keyed by target path. */
-export function splitRawSections(diff) {
-    const sections = new Map();
-    let path;
-    let lines = [];
-    const flush = () => {
-        if (path !== undefined)
-            sections.set(path, `${lines.join('\n')}\n`);
-    };
-    for (const line of diff.split('\n')) {
-        const header = parseDiffGitHeader(line);
-        if (header) {
-            flush();
-            path = header.targetPath;
-            lines = [line];
-        }
-        else if (path !== undefined) {
-            lines.push(line);
-        }
-    }
-    flush();
-    for (const [key, text] of sections)
-        sections.set(key, text.replace(/\n+$/, '\n'));
-    return sections;
-}
-/** The old and new line blocks a hunk replaces, swapped when reversed. */
-function hunkBlocks(hunk, reverse) {
-    const oldLines = [];
-    const newLines = [];
-    for (const line of hunk.lines) {
-        const marker = line[0];
-        const text = line.slice(1);
-        if (marker === ' ' || marker === '-')
-            oldLines.push(text);
-        if (marker === ' ' || marker === '+')
-            newLines.push(text);
-    }
-    return reverse ? { from: newLines, to: oldLines } : { from: oldLines, to: newLines };
-}
-function matchesAt(lines, block, at) {
-    if (at < 0 || at + block.length > lines.length)
-        return false;
-    return block.every((line, index) => lines[at + index] === line);
-}
-/** The match of `block` nearest `expected`, at or after `floor`. */
-function findBlock(lines, block, expected, floor) {
-    for (let distance = 0; distance <= lines.length; distance++) {
-        for (const at of distance === 0 ? [expected] : [expected - distance, expected + distance]) {
-            if (at >= floor && matchesAt(lines, block, at))
-                return at;
-        }
-    }
-    return undefined;
-}
-/**
- * Applies `hunks` to `content` by context, forward or reversed. A hunk
- * whose context is not found refuses, naming it.
- */
-export function applyHunksByContext(content, hunks, reverse, file) {
-    const endsWithNewline = content.endsWith('\n') || content === '';
-    const lines = content === '' ? [] : content.replace(/\n$/, '').split('\n');
-    let offset = 0;
-    let floor = 0;
-    for (const hunk of hunks) {
-        const { from, to } = hunkBlocks(hunk, reverse);
-        const start = (reverse ? hunk.newStart : hunk.oldStart) - (from.length === 0 ? 0 : 1);
-        const expected = Math.max(0, start + offset);
-        const at = from.length === 0 ? expected : findBlock(lines, from, expected, floor);
-        if (at === undefined) {
-            throw new PatchError(`The hunk @@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@ ` +
-                `does not ${reverse ? 'match the working tree' : 'apply to the patch body'} of ${file}: ` +
-                `its ${reverse ? 'new' : 'old'}-side lines were not found.`);
-        }
-        lines.splice(at, from.length, ...to);
-        offset += to.length - from.length + (at - expected);
-        floor = at + to.length;
-    }
-    if (lines.length === 0)
-        return '';
-    return `${lines.join('\n')}${endsWithNewline ? '\n' : ''}`;
-}
-/**
- * Diffs `content` for `file` against engine HEAD the way a re-export would,
- * on a throwaway index so the shared one never moves.
- */
-async function diffContentAgainstHead(engineDir, file, content, tracked) {
-    const index = await mintDisposableGitIndex(engineDir);
-    if (index === undefined) {
-        throw new GeneralError(`Cannot build a private git index in ${engineDir} to diff the hunk-selected ${file}.`);
-    }
-    const scratch = await mkdtemp(join(tmpdir(), 'fireforge-hunks-'));
-    try {
-        const temp = join(scratch, 'content');
-        await writeFile(temp, content);
-        const blob = (await git(['hash-object', '-w', '--path', file, '--', temp], engineDir)).trim();
-        const mode = tracked
-            ? ((await git(['ls-tree', 'HEAD', '--', file], engineDir)).split(/\s/)[0] ?? '100644')
-            : '100644';
-        await git(['update-index', '--add', '--cacheinfo', `${mode},${blob},${file}`], engineDir, {
-            env: index.env,
-        });
-        return await git(['diff', '--binary', '--cached', 'HEAD', '--', file], engineDir, {
-            env: index.env,
-        });
-    }
-    finally {
-        await rm(scratch, { recursive: true, force: true });
-        await index.dispose();
-    }
-}
-/** Engine-relative form of a diff path, or undefined when it cannot be one. */
-function asEnginePath(path, flag) {
-    try {
-        return normalizeEngineRelativeInput(path, flag);
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * The owned file a section names. A section whose sides name different
- * paths (`diff -u <(fireforge patch body …) engine/<file>`, or a
- * `git diff --no-index` against a copy) is keyed on the side that is a file
- * the patch owns. One whose sides both name owned files is a rename, and
- * refused; one whose sides name none is keyed on its new side.
- */
-function sectionFile(section, ownedSet, flag) {
-    const target = normalizeEngineRelativeInput(section.targetPath, flag);
-    if (section.sourcePath === section.targetPath)
-        return target;
-    const owned = [target, asEnginePath(section.sourcePath, flag)].filter((path) => path !== undefined && ownedSet.has(path));
-    if (owned.length > 1) {
-        throw new InvalidArgumentError(`${flag}: the section ${section.sourcePath} -> ${section.targetPath} is a rename; only text hunks of one file can be selected.`, flag);
-    }
-    return owned[0] ?? target;
-}
-/**
- * Reads and checks the hunk diff: text sections for files the patch owns.
- * A plain unified diff (`diff -u`, no `diff --git` lines) is accepted.
- */
-async function readSelection(selection, owned, patch) {
-    if (!(await pathExists(selection.diffPath))) {
-        throw new InvalidArgumentError(`${selection.flag} ${selection.diffPath} does not exist.`, selection.flag);
-    }
-    const sections = parseDiffSections(withGitHeaders(await readText(selection.diffPath)));
-    if (sections.length === 0) {
-        throw new InvalidArgumentError(`${selection.flag} ${selection.diffPath} holds no diff section (a "diff --git" header ` +
-            'or a "---"/"+++" pair).', selection.flag);
-    }
-    const ownedSet = new Set(owned);
-    const byFile = new Map();
-    for (const section of sections) {
-        if (section.isBinary) {
-            throw new InvalidArgumentError(`${selection.flag}: the section for ${section.targetPath} is binary; only text hunks can be selected.`, selection.flag);
-        }
-        const file = sectionFile(section, ownedSet, selection.flag);
-        if (!ownedSet.has(file)) {
-            throw new InvalidArgumentError(`${selection.flag}: ${file} is not a file this patch owns.`, selection.flag);
-        }
-        if (section.isNewFile && patch.created.has(file)) {
-            throw new InvalidArgumentError(`${selection.flag}: the section for ${file} creates it from /dev/null, but ` +
-                `${patch.filename} already creates ${file}, so the section's hunk is the whole file ` +
-                'rather than the lines changed since the patch body. Diff against the file as the ' +
-                'patch leaves it instead: ' +
-                `diff -u <(fireforge patch body ${patch.filename} ${file}) engine/${file}`, selection.flag);
-        }
-        byFile.set(file, section);
-    }
-    return byFile;
-}
-/**
- * Builds the re-export body for a hunk-selected run: named files from the
- * selected hunks, the rest from the old body (`--hunks-from`) or the normal
- * working-tree diff (`--exclude-hunks`).
- *
- * @param args.normalDiff - The diff a plain re-export would write
- * @param args.oldBody - The patch's current body
- * @param args.files - The files the refreshed patch owns
- * @param args.patchFilename - The patch being refreshed
- */
-export async function buildHunkSelectedDiff(args) {
-    const { engineDir, selection, oldBody, normalDiff, files } = args;
-    const created = new Set(parseDiffSections(oldBody)
-        .filter((section) => section.isNewFile)
-        .map((section) => section.targetPath));
-    const named = await readSelection(selection, files, {
-        filename: args.patchFilename,
-        created,
-    });
-    const tracked = await listTrackedInHead(engineDir, [...named.keys()]);
-    const fallback = splitRawSections(selection.mode === 'include' ? oldBody : normalDiff);
-    const out = [];
-    for (const file of [...files].sort()) {
-        const section = named.get(file);
-        if (section === undefined) {
-            const raw = fallback.get(file);
-            if (raw !== undefined)
-                out.push(raw);
-            continue;
-        }
-        const head = tracked.has(file) ? await getFileContentAtRef(engineDir, file) : null;
-        let content;
-        if (selection.mode === 'include') {
-            const base = applyPatchTextToContent(head, oldBody, file);
-            content = applyHunksByContext(base, section.hunks, false, file);
-        }
-        else {
-            const worktree = join(engineDir, file);
-            const current = (await pathExists(worktree)) ? await readText(worktree) : '';
-            content = applyHunksByContext(current, section.hunks, true, file);
-        }
-        if (head !== null && content === head)
-            continue;
-        const diff = await diffContentAgainstHead(engineDir, file, content, tracked.has(file));
-        if (diff.trim())
-            out.push(diff.endsWith('\n') ? diff : `${diff}\n`);
-    }
-    return out.join('');
-}