pi-supernova 0.6.0 → 0.7.0

package/src/contract/read.js

@@ -0,0 +1,220 @@
+import { isString, isObject, isNumber, looksLikePath } from "../shared/decode.js";
+import { sessionJsonArgs, validateJsonRead } from "../fs/json-read.js";
+
+export const SESSION_URI = /^(?:agent|artifact):\/\//i;
+
+const BOOL_KEYS = ["resolve", "complete", "outline", "evidence"];
+
+export function isSessionUri(value) {
+  return isString(value) && SESSION_URI.test(value);
+}
+
+/** Guest call shape → one options object. */
+export function gatherReadArgs(p, a, b) {
+  if (isObject(p) && !Array.isArray(p)) {
+    const args = { ...p, path: p.path ?? p.target ?? p.query };
+
+    if (p.path === undefined && p.target !== undefined) delete args.target;
+
+    return args;
+  }
+
+  return isObject(a) && !Array.isArray(a) ? { path: p, ...a } : { path: p, offset: a, limit: b };
+}
+
+export function assertReadPaths(targetParam) {
+  if (!Array.isArray(targetParam)) return;
+  if (targetParam.length > 64) throw new Error("read accepts at most 64 paths per batch");
+
+  for (const item of targetParam) if (!isString(item) || !item.trim()) throw new Error("read paths must be non-empty strings");
+}
+
+function assertReadFlags(args) {
+  for (const key of BOOL_KEYS) {
+    if (args[key] !== undefined && args[key] !== true && args[key] !== false) throw new Error("read " + key + " must be a boolean");
+  }
+
+  if (args.about !== undefined && !isString(args.about)) throw new Error("read about must be a string");
+  if (args.query !== undefined && !isString(args.query)) throw new Error("read query must be a string");
+}
+
+function assertExclusiveRead(args) {
+  const focusModes = [args.about !== undefined, args.query !== undefined, args.outline === true].filter(Boolean).length;
+
+  if (focusModes > 1 || (args.outline === true && args.evidence === true)) throw new Error("read accepts only one of about, query, outline, or evidence");
+  if (args.resolve === true && args.complete === true) throw new Error("read accepts either resolve or complete, not both");
+  if ((focusModes === 1 || args.evidence === true) && args.complete === true) throw new Error("complete:true requires a raw file read, not a source view");
+}
+
+function autoResolve(args) {
+  if (!isString(args.path) || args.resolve !== undefined || args.complete === true || args.json !== undefined) return args;
+  if (args.about !== undefined || args.query !== undefined || looksLikePath(args.path) || isSessionUri(args.path)) return args;
+
+  return { ...args, resolve: true };
+}
+
+/** Exclusive-mode + JSON + auto-resolve. Same rules for guest and host. */
+export function normalizeRead(params) {
+  if (!isObject(params)) throw new Error("read requires an options object");
+  if (params.path !== undefined && params.target !== undefined && params.path !== params.target) {
+    throw new Error("read accepts either path or target, not both");
+  }
+
+  const args = sessionJsonArgs({ ...params, path: params.path ?? params.target });
+  validateJsonRead(args);
+  assertReadFlags(args);
+  assertExclusiveRead(args);
+  assertReadPaths(args.path);
+
+  return autoResolve(args);
+}
+
+export function needsProbe(params) {
+  if (isSessionUri(params.path)) return false;
+  if (params.evidence === true) return false;
+  if (isString(params.query)) return false;
+  if (params.outline === true) return false;
+
+  return true;
+}
+
+/**
+ * Kind of read after exclusive modes are already validated.
+ * `existing` is the probe result, or null/undefined when needsProbe is false or the path is missing.
+ */
+function classifyExisting(params, existing) {
+  if (existing.directory) {
+    if (params.json !== undefined) throw new Error("JSON read requires a file, not a directory");
+
+    return isString(params.about)
+      ? { kind: "snap", query: params.about, scoped: true, existing }
+      : { kind: "dir", existing };
+  }
+
+  if (params.resolve === true && isString(params.about)) {
+    throw new Error("resolve:true cannot combine with about on a file; use about for a focused outline or resolve for source text");
+  }
+
+  if (isString(params.about) && existing.size > 512 * 1024) return { kind: "focus", existing, about: params.about };
+
+  return { kind: params.resolve ? "open" : "file", existing };
+}
+
+function classifySession(params) {
+  if (params.about !== undefined || params.query !== undefined || params.outline === true || params.evidence === true) {
+    throw new Error("session resources do not support about/query/outline/evidence views");
+  }
+
+  return { kind: "session" };
+}
+
+function classifyEvidence(params, target) {
+  const query = params.about ?? params.query ?? target;
+  const scope = target !== query || looksLikePath(target) ? target : undefined;
+
+  return { kind: "evidence", query, scope };
+}
+
+function classifyBarePath(params, target) {
+  if (params.json === undefined && !looksLikePath(target)) {
+    return { kind: "snap", query: isString(params.about) ? params.about : target, scoped: isString(params.about) };
+  }
+
+  if (params.resolve === true && params.complete !== true) return { kind: "missing" };
+
+  return { kind: "file", existing: null };
+}
+
+export function classifyRead(params, existing) {
+  const target = params.path;
+
+  if (isSessionUri(target)) return classifySession(params);
+  if (params.evidence === true) return classifyEvidence(params, target);
+  if (isString(params.query)) return { kind: "snap", query: params.query, scoped: Boolean(target && target !== params.query) };
+  if (params.outline === true) return { kind: "outline" };
+  if (existing) return classifyExisting(params, existing);
+
+  return classifyBarePath(params, target);
+}
+
+function jsonSelectorNote(args) {
+  return args.json === undefined ? "" : " (" + (Array.isArray(args.json) ? args.json.join(", ") : String(args.json)) + ")";
+}
+
+export const ROUTING_STATUS = "too_large";
+
+const ROUTING_PREFIX = '{"status":"too_large",';
+
+export const ROUTING_KEYS_MAX = 32;
+
+export function isRoutingPayload(value) {
+  return isString(value) && value.startsWith(ROUTING_PREFIX);
+}
+
+function isRoutingObject(parsed) {
+  return isObject(parsed) && parsed.status === ROUTING_STATUS && isString(parsed.path)
+    && isNumber(parsed.chars) && (Array.isArray(parsed.keys) || isNumber(parsed.length));
+}
+
+/** Shape of an over-bound JSON document for in-band routing. Throws when text is not JSON. */
+export function buildJsonRouting(rel, text) {
+  const document = JSON.parse(text);
+  const base = { status: ROUTING_STATUS, path: rel, chars: text.length };
+
+  if (Array.isArray(document)) return { ...base, length: document.length };
+
+  if (isObject(document)) {
+    const keys = Object.keys(document);
+
+    return keys.length > ROUTING_KEYS_MAX
+      ? { ...base, keys: keys.slice(0, ROUTING_KEYS_MAX), keysTruncated: true }
+      : { ...base, keys };
+  }
+
+  return base;
+}
+
+export function routingText(routing) {
+  const text = JSON.stringify(routing);
+
+  if (!isRoutingPayload(text)) throw new Error("routing payload must start with the shared marker");
+
+  return text;
+}
+
+/** Shape of one over-budget selection for in-band routing; value is already parsed. */
+export function buildSelectionRouting(rel, selector, value, chars) {
+  const base = { status: ROUTING_STATUS, path: rel, selector, chars };
+
+  if (Array.isArray(value)) return { ...base, length: value.length };
+
+  if (isObject(value)) {
+    const keys = Object.keys(value);
+
+    return keys.length > ROUTING_KEYS_MAX
+      ? { ...base, keys: keys.slice(0, ROUTING_KEYS_MAX), keysTruncated: true }
+      : { ...base, keys };
+  }
+
+  return base;
+}
+
+function decodeByArgs(args, value) {
+  return (args.resolve || args.json !== undefined || args.outline || args.evidence) && isString(value);
+}
+
+export function decodeReadValue(args, value) {
+  const sniffed = isRoutingPayload(value);
+
+  if (!sniffed && !decodeByArgs(args, value)) return value;
+
+  try {
+    const parsed = JSON.parse(value);
+
+    return sniffed && !isRoutingObject(parsed) ? value : parsed;
+  } catch (error) {
+    if (sniffed && !decodeByArgs(args, value)) return value;
+
+    throw new Error("JSON read failed for " + String(args.path ?? args.target ?? "resource") + jsonSelectorNote(args) + ": " + (error instanceof Error ? error.message : String(error)));
+  }
+}

package/src/fs/check.js

@@ -118,14 +118,7 @@ function consumeQuoted(text, i, stack) {
   return end < 0 ? { error: "unterminated string", at: i } : { end, prev: "value" };
 }
 
-/** Try to consume a comment, string, template, or regex at i. Returns { end, prev } | { error, at } | null. */
-function consumeLiteral(text, i, stack, prev) {
-  const c = text[i];
-
-  if (c === '"' || c === "'" || c === "`") return consumeQuoted(text, i, stack);
-
-  if (c !== "/") return null;
-
+function consumeSlash(text, i, prev) {
   if (text[i + 1] === "/" || text[i + 1] === "*") {
     const end = skipComment(text, i);
 
@@ -140,6 +133,17 @@ function consumeLiteral(text, i, stack, prev) {
   return end > 0 ? { end, prev: "value" } : null;
 }
 
+/** Try to consume a comment, string, template, or regex at i. Returns { end, prev } | { error, at } | null. */
+function consumeLiteral(text, i, stack, prev) {
+  const c = text[i];
+
+  if (c === '"' || c === "'" || c === "`") return consumeQuoted(text, i, stack);
+
+  if (c !== "/") return null;
+
+  return consumeSlash(text, i, prev);
+}
+
 /** Push/pop a bracket; returns an error, a stop, or null to continue. */
 function bracket(c, i, stack, stopDepth) {
   if (OPEN[c]) {

package/src/fs/diff.js

@@ -1,6 +1,9 @@
 
 import { isString } from "../shared/decode.js";
 
+/** Receipts render at most this many matches; totals still cover every match. */
+export const MAX_DIFF_MATCHES = 32;
+
 export function buildEditDiff(filePath, originalText, oldText, newText) {
   const fileLines = contentLines(originalText);
   const idx = isString(originalText) ? originalText.indexOf(oldText) : -1;
@@ -39,7 +42,8 @@ export function buildEditDiff(filePath, originalText, oldText, newText) {
 }
 
 export function buildMultiEditDiff(filePath, originalText, replacements) {
-  const parts = replacements.map(({ oldText, newText }) =>
+  const rendered = replacements.slice(0, MAX_DIFF_MATCHES);
+  const parts = rendered.map(({ oldText, newText }) =>
     buildEditDiff(filePath, originalText, oldText, newText),
   );
 
@@ -53,15 +57,16 @@ export function buildMultiEditDiff(filePath, originalText, replacements) {
         : { ...line, newLineNum: Math.max(1, line.lineNum + shift) });
     }
 
-    shift += replacements[index].newText.split("\n").length - replacements[index].oldText.split("\n").length;
+    shift += rendered[index].newText.split("\n").length - rendered[index].oldText.split("\n").length;
   }
 
   return {
     path: filePath,
     op: "edit",
-    added: parts.reduce((sum, part) => sum + part.added, 0),
-    removed: parts.reduce((sum, part) => sum + part.removed, 0),
+    added: replacements.reduce((sum, r) => sum + contentLines(r.newText).length, 0),
+    removed: replacements.reduce((sum, r) => sum + contentLines(r.oldText).length, 0),
     lines,
+    omittedMatches: replacements.length - rendered.length,
   };
 }
 
@@ -71,22 +76,28 @@ function classifyPatchLine(line) {
   return PATCH_LINE_KINDS[line[0]] || null;
 }
 
-export function buildPatchDiff(filePath, patchText) {
+export function buildPatchDiff(filePath, patchText, relocations = []) {
   const patchLines = isString(patchText) ? patchText.replace(/\r\n/g, "\n").split("\n") : [];
+  const shiftByHunk = new Map(relocations.map(entry => [entry.hunk, entry.offset]));
   const lines = [];
   let added = 0;
   let removed = 0;
   let oldLineNum = 1;
   let newLineNum = 1;
   let inHunk = false;
+  let hunkIndex = 0;
+  let relocatedBy = 0;
 
   for (const patchLine of patchLines) {
     const headerMatch = (/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?/).exec(patchLine);
 
     if (headerMatch) {
+      // Headers already carry length deltas, so only drift relocates the receipt.
+      hunkIndex += 1;
+      relocatedBy += shiftByHunk.get(hunkIndex) ?? 0;
       // A zero-length range names the line before the insertion/deletion point.
-      oldLineNum = Number(headerMatch[1]) + Number(headerMatch[2] === "0");
-      newLineNum = Number(headerMatch[3]) + Number(headerMatch[4] === "0");
+      oldLineNum = Number(headerMatch[1]) + Number(headerMatch[2] === "0") + relocatedBy;
+      newLineNum = Number(headerMatch[3]) + Number(headerMatch[4] === "0") + relocatedBy;
       inHunk = true;
       continue;
     }

package/src/fs/json-read.js

@@ -2,7 +2,37 @@ import { isString, isObject } from "../shared/decode.js";
 
 export const MAX_JSON_BYTES = 16 * 1024 * 1024;
 
-const SELECTOR_HELP = 'JSON selector supports .field, .nested[0], .items[0:3], .["quoted.key"], or . (whole value); not full jq';
+const SELECTOR_HELP = 'JSON selector supports .field, .nested[0], .items[0:3], .items.length, .["quoted.key"], or . (whole value); not full jq';
+
+function parseIdentStep(rest, first) {
+  const match = (first ? /^([A-Za-z_$][\w$]*)/ : /^\.([A-Za-z_$][\w$]*)/).exec(rest);
+
+  return match ? { step: { key: match[1] }, match } : null;
+}
+
+function parseQuotedStep(rest) {
+  const match = /^\[("(?:[^"\\]|\\.)*")\]/.exec(rest);
+
+  if (!match) return null;
+
+  try { return { step: { key: JSON.parse(match[1]) }, match }; } catch { throw new Error(SELECTOR_HELP); }
+}
+
+function parseIndexBounds(start, end) {
+  if (!Number.isSafeInteger(start) || (end !== undefined && (!Number.isSafeInteger(end) || end < start))) throw new Error(SELECTOR_HELP);
+
+  return end === undefined ? { index: start } : { start, end };
+}
+
+function parseIndexStep(rest) {
+  const match = /^\[(\d+)(?::(\d+))?\]/.exec(rest);
+
+  if (!match) return null;
+  const start = Number(match[1]);
+  const end = match[2] === undefined ? undefined : Number(match[2]);
+
+  return { step: parseIndexBounds(start, end), match };
+}
 
 /** Parse a small, non-evaluating selector language. No dynamic code or prototype lookup. */
 function parseSelector(selector) {
@@ -12,25 +42,46 @@ function parseSelector(selector) {
   let first = true;
 
   while (rest) {
-    let match;
-
-    if ((match = (first ? /^([A-Za-z_$][\w$]*)/ : /^\.([A-Za-z_$][\w$]*)/).exec(rest))) {
-      steps.push({ key: match[1] });
-    } else if ((match = /^\[("(?:[^"\\]|\\.)*")\]/.exec(rest))) {
-      try { steps.push({ key: JSON.parse(match[1]) }); } catch { throw new Error(SELECTOR_HELP); }
-    } else if ((match = /^\[(\d+)(?::(\d+))?\]/.exec(rest))) {
-      const start = Number(match[1]), end = match[2] === undefined ? undefined : Number(match[2]);
-
-      if (!Number.isSafeInteger(start) || (end !== undefined && (!Number.isSafeInteger(end) || end < start))) throw new Error(SELECTOR_HELP);
-      steps.push(end === undefined ? { index: start } : { start, end });
-    } else throw new Error(SELECTOR_HELP);
-    rest = rest.slice(match[0].length);
+    const parsed = parseIdentStep(rest, first) || parseQuotedStep(rest) || parseIndexStep(rest);
+
+    if (!parsed) throw new Error(SELECTOR_HELP);
+    steps.push(parsed.step);
+    rest = rest.slice(parsed.match[0].length);
     first = false;
   }
 
   return steps;
 }
 
+function missingJsonField(value, key) {
+  const keys = isObject(value) ? Object.keys(value) : [];
+  const preview = keys.length ? "; available keys: " + keys.slice(0, 24).map(key => JSON.stringify(key)).join(", ") + (keys.length > 24 ? ", …" : "") : "";
+
+  return new Error("JSON field not found: " + JSON.stringify(key) + preview);
+}
+
+function selectKey(value, key) {
+  if (Array.isArray(value) && key === "length") return value.length;
+
+  if (!isObject(value) || !Object.hasOwn(value, key)) throw missingJsonField(value, key);
+
+  return value[key];
+}
+
+function selectStep(value, step) {
+  if (step.key !== undefined) return selectKey(value, step.key);
+
+  if (!Array.isArray(value)) throw new Error("JSON index requires an array");
+
+  if (step.index !== undefined) {
+    if (step.index >= value.length) throw new Error("JSON index out of range: " + step.index);
+
+    return value[step.index];
+  }
+
+  return value.slice(step.start, step.end);
+}
+
 export function jsonProjector(json) {
   const many = Array.isArray(json);
   const selectors = many ? json : [json === true ? "." : json];
@@ -41,27 +92,7 @@ export function jsonProjector(json) {
   // Yield one selection at a time so the caller can budget it before the next
   // slice allocation. Eagerly mapping 64 large slices can exhaust the host heap.
   return function* (root) {
-    for (const steps of plans) yield steps.reduce((value, step) => {
-      if (step.key !== undefined) {
-        if (!isObject(value) || !Object.hasOwn(value, step.key)) {
-          const keys = isObject(value) ? Object.keys(value) : [];
-          const preview = keys.length ? "; available keys: " + keys.slice(0, 24).map(key => JSON.stringify(key)).join(", ") + (keys.length > 24 ? ", …" : "") : "";
-          throw new Error("JSON field not found: " + JSON.stringify(step.key) + preview);
-        }
-
-        return value[step.key];
-      }
-
-      if (!Array.isArray(value)) throw new Error("JSON index requires an array");
-
-      if (step.index !== undefined) {
-        if (step.index >= value.length) throw new Error("JSON index out of range: " + step.index);
-
-        return value[step.index];
-      }
-
-      return value.slice(step.start, step.end);
-    }, root);
+    for (const steps of plans) yield steps.reduce(selectStep, root);
   };
 }
 

package/src/fs/patch.js

@@ -9,6 +9,36 @@ function parseHunkHeader(line) {
     newStart: Number(match[3]), newLength: match[4] === undefined ? 1 : Number(match[4]), lines: [], noNewline: [] };
 }
 
+function applyNoNewlineMarker(current) {
+  if (!current.lines.length) throw new Error("newline marker requires a preceding hunk line");
+  current.noNewline.push(current.lines.length - 1);
+}
+
+function pushHunkLine(current, line, oldCount, newCount) {
+  if (oldCount === current.oldLength && newCount === current.newLength && /^--- |^\+\+\+ /.test(line)) {
+    throw new Error("apply_patch accepts one file at a time");
+  }
+
+  current.lines.push(line);
+
+  return {
+    oldCount: line[0] !== "+" ? oldCount + 1 : oldCount,
+    newCount: line[0] !== "-" ? newCount + 1 : newCount,
+  };
+}
+
+function consumeHunkLine(current, line, oldCount, newCount) {
+  if (line.startsWith("\")) {
+    applyNoNewlineMarker(current);
+
+    return { oldCount, newCount };
+  }
+
+  if (!/^[+ -]/.test(line)) return { oldCount, newCount };
+
+  return pushHunkLine(current, line, oldCount, newCount);
+}
+
 export function parsePatchHunks(patchText) {
   const hunks = [];
   let current;
@@ -23,19 +53,8 @@ export function parsePatchHunks(patchText) {
       hunks.push(current);
       oldCount = 0;
       newCount = 0;
-    } else if (current && line.startsWith("\")) {
-      if (!current.lines.length) throw new Error("newline marker requires a preceding hunk line");
-      current.noNewline.push(current.lines.length - 1);
-    } else if (current && /^[+ -]/.test(line)) {
-      if (oldCount === current.oldLength && newCount === current.newLength && /^--- |^\+\+\+ /.test(line)) {
-        throw new Error("apply_patch accepts one file at a time");
-      }
-
-      current.lines.push(line);
-
-      if (line[0] !== "+") oldCount++;
-
-      if (line[0] !== "-") newCount++;
+    } else if (current) {
+      ({ oldCount, newCount } = consumeHunkLine(current, line, oldCount, newCount));
     }
   }
 
@@ -59,23 +78,73 @@ function splitFile(text) {
   });
 }
 
-function findHunkMatch(fileLines, expectedOld, nominal) {
+function findHunkMatch(fileLines, expectedOld, nominal, hunk, oldStart) {
   const matchAt = index => index >= 0 && index + expectedOld.length <= fileLines.length
     && expectedOld.every((line, i) => fileLines[index + i].text === line);
 
-  if (matchAt(nominal)) return nominal;
+  if (matchAt(nominal)) return { index: nominal, relocated: 0 };
 
-  if (!expectedOld.length) return -1;
+  if (!expectedOld.length) return { index: -1, relocated: 0 };
 
   const maxDrift = Math.min(Math.max(fileLines.length, 100), 200);
+  const hits = [];
 
   for (let delta = 1; delta <= maxDrift; delta++) {
-    if (matchAt(nominal + delta)) return nominal + delta;
+    if (matchAt(nominal + delta)) hits.push(nominal + delta);
 
-    if (matchAt(nominal - delta)) return nominal - delta;
+    if (matchAt(nominal - delta)) hits.push(nominal - delta);
   }
 
-  return -1;
+  if (hits.length > 1) throw new Error("patch hunk " + hunk + " near line " + oldStart + " matches " + hits.length + " locations; add context lines to disambiguate");
+
+  if (hits.length === 1) return { index: hits[0], relocated: hits[0] - nominal };
+
+  return { index: -1, relocated: 0 };
+}
+
+function hunkLineText(line) {
+  return line.slice(1).replace(/\r$/, "");
+}
+
+function applyHunkLines(hunk, fileLines, matchIndex, ending) {
+  const replacement = [];
+  let oldIndex = matchIndex;
+
+  for (let i = 0; i < hunk.lines.length; i++) {
+    const line = hunk.lines[i];
+
+    if (line[0] === "+") {
+      replacement.push({ text: hunkLineText(line), ending: hunk.noNewline.includes(i) ? "" : ending });
+    } else {
+      const original = fileLines[oldIndex++];
+
+      if (hunk.noNewline.includes(i) && original.ending) throw new Error("patch newline marker does not match the file");
+
+      if (line[0] === " ") replacement.push(original);
+    }
+  }
+
+  return replacement;
+}
+
+function applyOneHunk(hunk, h, fileLines, offsetShift, relocationShift, ending) {
+  const expectedOld = hunk.lines.filter(line => line[0] !== "+").map(hunkLineText);
+  const newCount = hunk.lines.filter(line => line[0] !== "-").length;
+
+  if (expectedOld.length !== hunk.oldLength || newCount !== hunk.newLength) throw new Error("patch hunk " + (h + 1) + " length does not match its header");
+  // The new coordinate also handles BSD diff's -1,0 header at file start.
+  const nominal = hunk.oldLength === 0 ? hunk.newStart - 1 + relocationShift : hunk.oldStart - 1 + offsetShift;
+  const match = findHunkMatch(fileLines, expectedOld, nominal, h + 1, hunk.oldStart);
+
+  if (match.index < 0) throw new Error("patch hunk " + (h + 1) + " rejected at line " + hunk.oldStart + ": context did not match");
+  const replacement = applyHunkLines(hunk, fileLines, match.index, ending);
+  fileLines.splice(match.index, expectedOld.length, ...replacement);
+
+  return {
+    relocationShift: relocationShift + match.relocated,
+    offsetShift: offsetShift + match.relocated + replacement.length - expectedOld.length,
+    relocated: match.relocated,
+  };
 }
 
 export function applyPatchToText(originalText, patchText) {
@@ -83,42 +152,17 @@ export function applyPatchToText(originalText, patchText) {
   const hunks = parsePatchHunks(patchText);
   const fileLines = splitFile(originalText);
   const ending = fileLines.find(line => line.ending)?.ending ?? "\n";
+  const relocations = [];
   let offsetShift = 0;
   let relocationShift = 0;
 
   for (let h = 0; h < hunks.length; h++) {
-    const hunk = hunks[h];
-    const textOf = line => line.slice(1).replace(/\r$/, "");
-    const expectedOld = hunk.lines.filter(line => line[0] !== "+").map(textOf);
-    const newCount = hunk.lines.filter(line => line[0] !== "-").length;
-
-    if (expectedOld.length !== hunk.oldLength || newCount !== hunk.newLength) throw new Error("patch hunk " + (h + 1) + " length does not match its header");
-    // The new coordinate also handles BSD diff's -1,0 header at file start.
-    const nominal = hunk.oldLength === 0 ? hunk.newStart - 1 + relocationShift : hunk.oldStart - 1 + offsetShift;
-    const matchIndex = findHunkMatch(fileLines, expectedOld, nominal);
-
-    if (matchIndex < 0) throw new Error("patch hunk " + (h + 1) + " rejected at line " + hunk.oldStart + ": context did not match");
-    const replacement = [];
-    let oldIndex = matchIndex;
-
-    for (let i = 0; i < hunk.lines.length; i++) {
-      const line = hunk.lines[i];
-
-      if (line[0] === "+") {
-        replacement.push({ text: textOf(line), ending: hunk.noNewline.includes(i) ? "" : ending });
-      } else {
-        const original = fileLines[oldIndex++];
-
-        if (hunk.noNewline.includes(i) && original.ending) throw new Error("patch newline marker does not match the file");
-
-        if (line[0] === " ") replacement.push(original);
-      }
-    }
+    const applied = applyOneHunk(hunks[h], h, fileLines, offsetShift, relocationShift, ending);
+    offsetShift = applied.offsetShift;
+    relocationShift = applied.relocationShift;
 
-    fileLines.splice(matchIndex, expectedOld.length, ...replacement);
-    relocationShift += matchIndex - nominal;
-    offsetShift += matchIndex - nominal + replacement.length - expectedOld.length;
+    if (applied.relocated !== 0) relocations.push({ hunk: h + 1, offset: applied.relocated });
   }
 
-  return { resultText: fileLines.map(line => line.text + line.ending).join(""), hunkCount: hunks.length };
+  return { resultText: fileLines.map(line => line.text + line.ending).join(""), hunkCount: hunks.length, relocations };
 }