@hominis/fireforge 0.49.2 → 0.51.0

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

@@ -9,7 +9,7 @@
  * (`re-export-adjacent.ts`) warns about unmanaged neighbour files but is
  * structurally blind to drift inside owned files. This module compares
  * the old body against the refreshed body per file and reports the
- * payload lines that are about to enter the body. Under
+ * payload lines that are about to enter or leave the body. Under
  * `--refuse-foreign-drift` the patch is skipped and the run exits
  * non-zero, mirroring `--refuse-adjacent-unmanaged`.
  *
@@ -74,8 +74,15 @@ function multisetExcess(next, previous) {
     }
     return excess;
 }
-function summarizeForeignHunks(payload, foreignAdded, foreignRemoved) {
+/**
+ * Summarizes the hunks of `payload` that carry the budgeted `+`/`-` lines.
+ * `describe` renders the per-hunk counts, so the old body's dropped lines
+ * read in the same engine-edit direction as the new body's absorbed ones.
+ */
+function summarizeForeignHunks(payload, foreignAdded, foreignRemoved, describe) {
     const summaries = [];
+    if (payload === undefined)
+        return summaries;
     const addedBudget = new Map(foreignAdded);
     const removedBudget = new Map(foreignRemoved);
     for (const section of payload.sections) {
@@ -101,7 +108,7 @@ function summarizeForeignHunks(payload, foreignAdded, foreignRemoved) {
                 }
             }
             if (added > 0 || removed > 0) {
-                summaries.push(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@ (+${added}/-${removed})`);
+                summaries.push(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@ ${describe(added, removed)}`);
             }
         }
     }
@@ -113,47 +120,71 @@ function countExcess(excess) {
         total += count;
     return total;
 }
+const EMPTY_PAYLOAD_LINES = new Map();
 /**
  * Pure comparison: per owned file, which `+`/`-` payload lines the
- * refreshed body carries that the old body did not. Files not in
- * `previousFilesAffected` are skipped, since those are intentional
- * adoptions (`--scan`) rather than drift.
+ * refreshed body carries that the old body did not, and which the old body
+ * carried that the refreshed one dropped. Both directions are drift: a
+ * concurrent session deleting a line the patch added changes the patch as
+ * surely as one adding a line, and a belt that only saw absorbed lines let
+ * such a deletion through silently. Files not in `previousFilesAffected`
+ * are skipped, since those are intentional adoptions (`--scan`) or
+ * retirements (`--expect-removed`) rather than drift.
  */
 export function computeForeignDrift(oldBody, newBody, previousFilesAffected) {
     const owned = new Set(previousFilesAffected);
     const oldByFile = collectPayloadByFile(oldBody);
     const newByFile = collectPayloadByFile(newBody);
     const drift = [];
-    for (const [file, next] of newByFile) {
+    // New-body order first, then files only the old body carried.
+    const files = new Set([...newByFile.keys(), ...oldByFile.keys()]);
+    for (const file of files) {
         if (!owned.has(file))
             continue;
+        const next = newByFile.get(file);
         const previous = oldByFile.get(file);
-        if (next.isBinary || previous?.isBinary === true) {
-            const binaryChanged = next.binaryNewHash === undefined ||
-                previous?.binaryNewHash === undefined ||
-                !(next.binaryNewHash.startsWith(previous.binaryNewHash) ||
-                    previous.binaryNewHash.startsWith(next.binaryNewHash));
-            if (binaryChanged) {
-                drift.push({ file, addedLines: 0, removedLines: 0, hunkSummaries: [], binaryChanged });
+        if (next?.isBinary === true || previous?.isBinary === true) {
+            if (binaryContentChanged(next, previous)) {
+                drift.push({
+                    file,
+                    addedLines: 0,
+                    removedLines: 0,
+                    hunkSummaries: [],
+                    binaryChanged: true,
+                });
             }
             continue;
         }
-        const foreignAdded = multisetExcess(next.added, previous?.added ?? new Map());
-        const foreignRemoved = multisetExcess(next.removed, previous?.removed ?? new Map());
-        const addedLines = countExcess(foreignAdded);
-        const removedLines = countExcess(foreignRemoved);
+        const absorbedAdded = multisetExcess(next?.added ?? EMPTY_PAYLOAD_LINES, previous?.added ?? EMPTY_PAYLOAD_LINES);
+        const absorbedRemoved = multisetExcess(next?.removed ?? EMPTY_PAYLOAD_LINES, previous?.removed ?? EMPTY_PAYLOAD_LINES);
+        const droppedAdded = multisetExcess(previous?.added ?? EMPTY_PAYLOAD_LINES, next?.added ?? EMPTY_PAYLOAD_LINES);
+        const droppedRemoved = multisetExcess(previous?.removed ?? EMPTY_PAYLOAD_LINES, next?.removed ?? EMPTY_PAYLOAD_LINES);
+        const addedLines = countExcess(absorbedAdded) + countExcess(droppedRemoved);
+        const removedLines = countExcess(absorbedRemoved) + countExcess(droppedAdded);
         if (addedLines === 0 && removedLines === 0)
             continue;
         drift.push({
             file,
             addedLines,
             removedLines,
-            hunkSummaries: summarizeForeignHunks(next, foreignAdded, foreignRemoved).slice(0, MAX_HUNK_SUMMARIES_PER_FILE),
+            hunkSummaries: [
+                ...summarizeForeignHunks(next, absorbedAdded, absorbedRemoved, (plus, minus) => `(+${plus}/-${minus})`),
+                // A dropped `+` line is one the engine lost; a dropped `-` line is an
+                // upstream line the engine has back.
+                ...summarizeForeignHunks(previous, droppedAdded, droppedRemoved, (plus, minus) => `in the old body, dropped (+${minus}/-${plus})`),
+            ].slice(0, MAX_HUNK_SUMMARIES_PER_FILE),
             binaryChanged: false,
         });
     }
     return drift;
 }
+/** True when a binary section appeared, vanished, or its new-side blob hash moved. */
+function binaryContentChanged(next, previous) {
+    if (next?.binaryNewHash === undefined || previous?.binaryNewHash === undefined)
+        return true;
+    return !(next.binaryNewHash.startsWith(previous.binaryNewHash) ||
+        previous.binaryNewHash.startsWith(next.binaryNewHash));
+}
 /**
  * Reads the old body, prints the always-on drift preview (including under
  * dry-run and `--scan`), and, when `ctx.refuseForeignDrift` is set,
@@ -161,6 +192,10 @@ export function computeForeignDrift(oldBody, newBody, previousFilesAffected) {
  */
 export async function reportForeignDrift(args) {
     const { patch, patchesDir, engineDir, newDiffContent, ctx } = args;
+    for (const file of args.adoptedFiles ?? []) {
+        if (ctx.expectedDriftFiles.has(file))
+            ctx.expectedSeen.add(file);
+    }
     const oldPath = join(patchesDir, patch.filename);
     let oldBody;
     try {
@@ -172,7 +207,7 @@ export async function reportForeignDrift(args) {
     catch (error) {
         return refuseUnreadableBaseline(ctx, patch.filename, `old body unreadable (${toError(error).message})`);
     }
-    const drift = computeForeignDrift(oldBody, newDiffContent, patch.filesAffected);
+    const drift = computeForeignDrift(oldBody, newDiffContent, args.ownedFiles ?? patch.filesAffected);
     ctx.evaluationRuns += 1;
     if (drift.length === 0)
         return false;
@@ -184,7 +219,7 @@ export async function reportForeignDrift(args) {
     const recentlyEdited = await findFilesEditedSinceLastExport(engineDir, oldPath, drift.map((d) => d.file));
     const totalLines = drift.reduce((sum, d) => sum + d.addedLines + d.removedLines, 0);
     const lineNoun = totalLines === 1 ? 'line' : 'lines';
-    warn(`${patch.filename}: refreshed body absorbs ${totalLines} ${lineNoun} not present in the old patch body (${drift.length} file(s)):`);
+    warn(`${patch.filename}: refreshed body changes ${totalLines} ${lineNoun} against the old patch body (${drift.length} file(s)):`);
     for (const entry of drift.slice(0, MAX_FILES_REPORTED)) {
         const expectedTag = ctx.expectedDriftFiles.has(entry.file) ? ' (expected via --expect)' : '';
         const authorshipTag = recentlyEdited.has(entry.file)
@@ -194,7 +229,7 @@ export async function reportForeignDrift(args) {
             info(`  ${entry.file}: binary content changed${expectedTag}${authorshipTag}`);
             continue;
         }
-        info(`  ${entry.file}: +${entry.addedLines}/-${entry.removedLines} newly captured line(s)${expectedTag}${authorshipTag}`);
+        info(`  ${entry.file}: +${entry.addedLines} added / -${entry.removedLines} removed line(s)${expectedTag}${authorshipTag}`);
         for (const summary of entry.hunkSummaries) {
             info(`    ${summary}`);
         }
@@ -274,31 +309,24 @@ function refuseUnreadableBaseline(ctx, patchFilename, detail) {
 /**
  * States, verbatim in the notice, what the `--expect` whitelist is compared
  * against and when. This notice is the only feedback an operator gets that
- * the drift belt looked at the files they named, and a downstream report
- * showed the previous copy actively misleading: it warned "showed no drift"
- * over an edit that was captured correctly, and none of the causes it named
- * held, so the operator's only recourse was `grep -c` on the written body.
- *
- * The measurement, stated exactly:
+ * the drift belt looked at the files they named, so it has to describe the
+ * measurement exactly:
  *
  *  - Compared: for each file already in the patch's `filesAffected`, the
  *    `+`/`-` payload lines the refreshed body carries that the old patch
- *    body did not (`computeForeignDrift`). It is a content comparison, and
- *    it is one-directional: excess in the new body only.
+ *    body did not, and the ones the old body carried that the refreshed body
+ *    dropped (`computeForeignDrift`). It is a content comparison in both
+ *    directions, so a deletion-only edit is drift too.
  *  - When: per patch, on the body about to be written, before the write.
  *    Never against post-write state.
  *
- * The one-directional half is what the earlier copy hid, and it is the
- * cause the report's first shape actually hit: deleting a line from an
- * engine file makes the refreshed body drop that file's `+` line. Nothing
- * is absorbed, so there is no drift to see. The belt exists to catch a
- * concurrent session's edits being silently swallowed into a body, not
- * every difference between two bodies. Stating that is the fix. Widening
- * the comparison would turn every ordinary line removal into a refusal.
+ * An earlier copy compared one direction only, so a correctly captured
+ * deletion read as an `--expect` that matched nothing, and a peer's
+ * deletion in a file outside `--expect` passed the belt silently.
  */
 const EXPECT_MEASUREMENT_NOTE = '--expect is evaluated against CONTENT, before the write: for each file already in the ' +
-    "patch's filesAffected, the payload lines the refreshed body carries that the old patch " +
-    'body did not. It never looks at post-write state.';
+    "patch's filesAffected, the payload lines the refreshed body adds or drops against the old " +
+    'patch body. It never looks at post-write state.';
 /**
  * Names `--expect` paths that never drifted this run. A typo'd
  * `--expect` path silently degrades the flag back to refusing the slice it
@@ -318,17 +346,13 @@ export function warnUnseenExpectedDrift(driftCtx) {
         `${unseen.join(', ')}.\n` +
         `${EXPECT_MEASUREMENT_NOTE}\n` +
         'Causes, in rough order of likelihood:\n' +
-        '  1. Your edit only REMOVED lines from the body (you deleted a line from the engine ' +
-        'file). The comparison is one-directional — it reports lines ABSORBED into the body — ' +
-        'so a correctly captured deletion is not drift and never will be. Confirm the capture ' +
-        'with "grep -c" on the written patch body.\n' +
-        "  2. A typo in the path, or a path not in the patch's filesAffected (files adopted " +
-        'this run via --scan/--scan-file are excluded from the comparison by design).\n' +
-        '  3. Adoption already captured it: a "re-export <p> --scan --scan-file <f>" run also ' +
+        "  1. A typo in the path, or a path in none of the selected patches' filesAffected and " +
+        'not adopted by this run.\n' +
+        '  2. Adoption already captured it: a "re-export <p> --scan --scan-file <f>" run also ' +
         "captures that patch's other drifted files, so a scan-less re-export afterwards " +
-        'legitimately sees nothing left to absorb. Informational — a chain that treats this ' +
+        'legitimately sees nothing left to change. Informational — a chain that treats this ' +
         'warning as an error will false-red on it.\n' +
-        '  4. The slice was already captured by an earlier export in this session.\n' +
-        '  5. The engine content already matches the patch body — a concurrent session may have ' +
+        '  3. The slice was already captured by an earlier export in this session.\n' +
+        '  4. The engine content already matches the patch body — a concurrent session may have ' +
         'exported the same change, so the drift converged before this run looked.');
 }

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

@@ -7,6 +7,7 @@ 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';
@@ -25,10 +26,8 @@ import { projectEntryBody } from './patch/entry-projection.js';
  * so the caller can drop the field rather than write an empty array.
  */
 function resolveEffectiveTierAndLintIgnore(target, options) {
-    const existingIgnoreSet = new Set(target.lintIgnore ?? []);
     const flagIgnoreSet = new Set(options.lintIgnore ?? []);
-    const mergedIgnoreSet = new Set([...existingIgnoreSet, ...flagIgnoreSet]);
-    const effectiveLintIgnore = mergedIgnoreSet.size > 0 ? [...mergedIgnoreSet] : undefined;
+    const effectiveLintIgnore = mergeLintIgnoreIds(target.lintIgnore, [...flagIgnoreSet]);
     const effectiveTier = options.tier ?? target.tier;
     return { effectiveTier, effectiveLintIgnore, flagIgnoreSet };
 }
@@ -39,8 +38,10 @@ function resolveEffectiveTierAndLintIgnore(target, options) {
  * 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) {
-    const baseCtx = await buildPatchQueueContext(patchesDir);
+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)
@@ -48,7 +49,7 @@ async function runProjectedCrossPatchLint(patchesDir, targetFilename, projectedD
         return { ...entry, ...projection };
     });
     const baselineIssues = lintPatchQueue(baseCtx).filter((i) => i.severity === 'error');
-    const projectedIssues = lintPatchQueue({ entries: projectedEntries }).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 ` +
@@ -223,7 +224,7 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
     // `--tier` and `--lint-ignore` participate too, with append/union
     // semantics on the lint-ignore list.
     const { effectiveTier, effectiveLintIgnore, flagIgnoreSet } = resolveEffectiveTierAndLintIgnore(target, options);
-    const ignoreChecks = effectiveLintIgnore ? new Set(effectiveLintIgnore) : undefined;
+    const ignoreChecks = buildLintIgnoreChecks(effectiveLintIgnore);
     const patchQueueCtx = (await pathExists(paths.patches))
         ? await buildPatchQueueContext(paths.patches)
         : undefined;
@@ -237,7 +238,7 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
         ignoreChecks,
         patchTier: effectiveTier,
     });
-    const conflicts = await runProjectedCrossPatchLint(paths.patches, target.filename, projectedDiff);
+    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) {
@@ -246,6 +247,7 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
             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({
@@ -297,6 +299,7 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
             config,
             command: 're-export --files',
             forceUnsafe: options.forceUnsafe === true,
+            scope: [target.filename],
         },
     });
     success(`Re-exported ${target.filename}`);

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

@@ -0,0 +1,35 @@
+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
+ */
+export declare function buildHunkSelectedDiff(args: {
+    engineDir: string;
+    selection: HunkSelection;
+    oldBody: string;
+    normalDiff: string;
+    files: readonly string[];
+}): Promise<string>;

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

@@ -0,0 +1,220 @@
+// 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, } 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();
+    }
+}
+/** Reads and checks the hunk diff: text sections for files the patch owns. */
+async function readSelection(selection, owned) {
+    if (!(await pathExists(selection.diffPath))) {
+        throw new InvalidArgumentError(`${selection.flag} ${selection.diffPath} does not exist.`, selection.flag);
+    }
+    const sections = parseDiffSections(await readText(selection.diffPath));
+    if (sections.length === 0) {
+        throw new InvalidArgumentError(`${selection.flag} ${selection.diffPath} holds no "diff --git" section.`, selection.flag);
+    }
+    const ownedSet = new Set(owned);
+    const byFile = new Map();
+    for (const section of sections) {
+        const file = normalizeEngineRelativeInput(section.targetPath, selection.flag);
+        if (section.isBinary || section.sourcePath !== section.targetPath) {
+            throw new InvalidArgumentError(`${selection.flag}: the section for ${file} is binary or a rename; only text hunks can be selected.`, selection.flag);
+        }
+        if (!ownedSet.has(file)) {
+            throw new InvalidArgumentError(`${selection.flag}: ${file} is not a file this patch owns.`, 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
+ */
+export async function buildHunkSelectedDiff(args) {
+    const { engineDir, selection, oldBody, normalDiff, files } = args;
+    const named = await readSelection(selection, files);
+    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('');
+}

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

@@ -21,6 +21,7 @@
  */
 import { type PatchQueueContext } from '../core/patch-lint.js';
 import { type PerPatchLintCacheFile } from '../core/patch-lint-cache.js';
+import { type LintIgnoreChecks } from '../core/patch-lint-ignore.js';
 import type { PatchLintIssue, PatchMetadata } from '../types/commands/index.js';
 import type { FireForgeConfig, ProjectPaths } from '../types/config.js';
 import { type PerRunCheckJs } from './lint-per-run-checkjs.js';
@@ -92,7 +93,7 @@ export declare function lintReExportedPatch(args: {
     existingFiles: string[];
     diffContent: string;
     skipLint?: boolean;
-    ignoreChecks?: ReadonlySet<string>;
+    ignoreChecks?: LintIgnoreChecks;
     patchTier?: 'branding';
 }): Promise<ReExportLintResult | null>;
 /**