@poe-platform/safe-bash 0.1.813 → 0.1.815

package/dist/safe-bash/command-chunks/{chunk-PKLJRB7W.js → chunk-44F5TOHZ.js}

@@ -1,14 +1,27 @@
+import {
+  PatchBodyStore,
+  patchHunk,
+  patchHunks,
+  patchLine,
+  rejectBytes,
+  reverseStoredPatch
+} from "./chunk-GPGLTWNR.js";
 import {
   PatchPublication
-} from "./chunk-PK36TVXB.js";
+} from "./chunk-CFMJXJS5.js";
+import {
+  TargetDocuments,
+  TargetOutput,
+  equalTargetLines,
+  targetBytes
+} from "./chunk-KASXIRKD.js";
 import {
-  parsePatch
-} from "./chunk-CTDC4LJT.js";
+  parsePatchWith
+} from "./chunk-U3C6IT2C.js";
 import {
-  parseUnified,
-  reversePatch,
+  parseUnifiedReader,
   startIndex
-} from "./chunk-JORIVUPM.js";
+} from "./chunk-YW2VYN4V.js";
 import {
   authorizeOutputs,
   authorizePaths,
@@ -24,19 +37,10 @@ import {
 import {
   safeTarget
 } from "./chunk-AJEQUVDN.js";
-import {
-  rejectBytes
-} from "./chunk-63EMPQ7Z.js";
-import {
-  TargetDocuments,
-  TargetOutput,
-  equalTargetLines,
-  targetBytes
-} from "./chunk-73NYFNAS.js";
 
 // packages/safe-bash-command-patch/src/patch.ts
 import { closeDocumentResources as closeDocumentResources2 } from "../../safe-bash-diff-engine/document.js";
-import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
 
 // packages/safe-bash-command-patch/src/stored-hunks.ts
 import { closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
@@ -53,18 +57,19 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
     let cursor = 0;
     let offset = 0;
     let outputOffset = 0;
-    for (const [hunkIndex, hunk] of patch.hunks.entries()) {
+    for await (const [hunkIndex, hunk] of patchHunks(patch)) {
       budget.step();
       const oldIndex = indices.allocate((hunk.oldCount + hunk.newCount) * 8), newIndex = oldIndex + hunk.oldCount * 8;
       let oldPosition = oldIndex, newPosition = newIndex;
       const cell = new Uint8Array(8), view = new DataView(cell.buffer);
       for (let index = 0; index < hunk.lines.length; index++) {
         view.setFloat64(0, index, true);
-        if (hunk.lines[index].kind !== "+") {
+        const line = await patchLine(hunk, index);
+        if (line.kind !== "+") {
           await indices.write(oldPosition, cell);
           oldPosition += 8;
         }
-        if (hunk.lines[index].kind !== "-") {
+        if (line.kind !== "-") {
           await indices.write(newPosition, cell);
           newPosition += 8;
         }
@@ -74,12 +79,12 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
       }
       const indexedLine = async (base, index) => {
         const bytes = await indices.read(base + index * 8, 8);
-        return hunk.lines[new DataView(bytes.buffer).getFloat64(0, true)].text;
+        return (await patchLine(hunk, new DataView(bytes.buffer).getFloat64(0, true))).text;
       };
       let leading = 0;
       let trailing = 0;
-      while (leading < hunk.lines.length && hunk.lines[leading].kind === " ") leading++;
-      while (trailing < hunk.lines.length - leading && hunk.lines[hunk.lines.length - trailing - 1].kind === " ") trailing++;
+      while (leading < hunk.lines.length && (await patchLine(hunk, leading)).kind === " ") leading++;
+      while (trailing < hunk.lines.length - leading && (await patchLine(hunk, hunk.lines.length - trailing - 1)).kind === " ") trailing++;
       const expected = startIndex(hunk.oldStart, hunk.oldCount) + offset;
       let found = -1;
       let misordered = false;
@@ -166,7 +171,7 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
       const matched = found;
       if (matched >= 0) offset = matched - startIndex(hunk.oldStart, hunk.oldCount);
       if (misordered) found = -1;
-      application.outcomes?.push({
+      await application.outcomes?.push({
         hunk,
         index: hunkIndex + 1,
         failed: found < 0,
@@ -201,8 +206,8 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
         let identical = localLength === hunk.newCount;
         for (let index = 0; identical && index < localLength; index++) identical = await equalTargetLines(source.at(cursor + index), await indexedLine(newIndex, index), budget);
         if (identical) {
-          const last = application.outcomes?.pop();
-          if (last) application.outcomes.push({ ...last, failed: false, fuzz: 0, offset: position - startIndex(hunk.oldStart, hunk.oldCount) });
+          const last = await application.outcomes?.pop();
+          if (last) await application.outcomes.push({ ...last, failed: false, fuzz: 0, offset: position - startIndex(hunk.oldStart, hunk.oldCount) });
           for (let index = prefix; index < localLength - suffix; index++) await result.append(source.at(cursor + index));
         } else {
           await result.append("<<<<<<<\n");
@@ -214,8 +219,8 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
           await result.append("=======\n");
           for (let index = prefix; index < hunk.newCount - suffix; index++) await result.append(await indexedLine(newIndex, index));
           await result.append(">>>>>>>\n");
-          const last = application.outcomes?.pop();
-          if (last) application.outcomes.push({ ...last, mergeRange: [mergeStart, result.length] });
+          const last = await application.outcomes?.pop();
+          if (last) await application.outcomes.push({ ...last, mergeRange: [mergeStart, result.length] });
         }
         for (let index = localLength - suffix; index < localLength; index++) await result.append(source.at(cursor + index));
         cursor += localLength;
@@ -231,7 +236,7 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
       const flush = async (end) => {
         let removed = 0, added = 0;
         for (let index = changeStart; index < end; index++) {
-          if (hunk.lines[index].kind === "+") added++;
+          if ((await patchLine(hunk, index)).kind === "+") added++;
           else removed++;
           budget.step();
           const pause = budget.checkpoint();
@@ -242,14 +247,14 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
           await result.append(`#${removed ? "ifndef" : "ifdef"} ${application.ifdef}
 `);
           let position = changeCursor;
-          for (let index = changeStart; index < end; index++) if (hunk.lines[index].kind === "-") await result.append(source.at(position++) ?? hunk.lines[index].text);
+          for (let index = changeStart; index < end; index++) if ((await patchLine(hunk, index)).kind === "-") await result.append(source.at(position++) ?? (await patchLine(hunk, index)).text);
           if (removed && added) await result.append("#else\n");
         }
-        for (let index = changeStart; index < end; index++) if (hunk.lines[index].kind === "+") await result.append(hunk.lines[index].text);
+        for (let index = changeStart; index < end; index++) if ((await patchLine(hunk, index)).kind === "+") await result.append((await patchLine(hunk, index)).text);
         if (application.ifdef) await result.append("#endif\n");
       };
       for (let index = matchedPrefixFuzz; index < hunk.lines.length - matchedSuffixFuzz; index++) {
-        const line = hunk.lines[index];
+        const line = await patchLine(hunk, index);
         if (line.kind === " ") {
           await flush(index);
           if (cursor < source.length) await result.append(source.at(cursor++));
@@ -282,10 +287,14 @@ var StoredPatchInput = class {
   length;
   cachedIndex = -1;
   cachedLine = "";
-  async read(index) {
+  async read(index, prefix) {
     if (index < 0 || index >= this.length) return void 0;
-    if (index === this.cachedIndex) return this.cachedLine;
+    if (index === this.cachedIndex) return prefix === void 0 ? this.cachedLine : this.cachedLine.slice(0, prefix);
     const line = await this.document.line(this.start + index);
+    if (prefix !== void 0) {
+      const size = Math.min(prefix, line.end - line.start - (this.crlf ? 2 : 1));
+      return new TextDecoder("utf-8", { ignoreBOM: true }).decode(await this.document.data.read(8 + line.start, size));
+    }
     const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
     let text = "";
     for await (const block of this.document.range(line.start, line.end - (this.crlf ? 2 : 1))) text += decoder.decode(block, { stream: true });
@@ -294,12 +303,49 @@ var StoredPatchInput = class {
     this.cachedLine = text;
     return text;
   }
+  async matches(index, text) {
+    if (index < 0 || index >= this.length) return false;
+    const line = await this.document.line(this.start + index), bytes = new TextEncoder().encode(text);
+    if (line.end - line.start - (this.crlf ? 2 : 1) !== bytes.length) return false;
+    let at = 0;
+    for await (const block of this.document.range(line.start, line.end - (this.crlf ? 2 : 1)))
+      for (const byte of block) if (byte !== bytes[at++]) return false;
+    return true;
+  }
+  async body(index, skip, incomplete) {
+    const line = await this.document.line(this.start + index), document = this.document;
+    const end = line.end - (this.crlf ? 2 : 1), start = Math.min(line.start + skip, end);
+    return { size: end - start + (incomplete ? 0 : 1), terminated: !incomplete, bytes: {
+      async *[Symbol.asyncIterator]() {
+        yield* document.range(start, end);
+        if (!incomplete) yield new Uint8Array([10]);
+      }
+    } };
+  }
   async signature(index) {
     const line = await this.document.line(this.start + index);
     if (line.end - line.start !== (this.crlf ? 5 : 4)) return false;
     const bytes = await this.document.data.read(8 + line.start, 3);
     return bytes[0] === 45 && bytes[1] === 45 && bytes[2] === 32;
   }
+  /** Recognize the unbounded numeric prefix used by mail patch admission. */
+  async normalCommand(index) {
+    const line = await this.document.line(this.start + index);
+    let state = "start";
+    for await (const block of this.document.range(line.start, line.end)) for (const byte of block) {
+      const digit = byte >= 48 && byte <= 57;
+      if (state === "operation") return digit;
+      if (state === "start" || state === "comma") {
+        if (!digit) return false;
+        state = state === "start" ? "first" : "second";
+      } else if (!digit) {
+        if (state === "first" && byte === 44) state = "comma";
+        else if (byte === 97 || byte === 99 || byte === 100) state = "operation";
+        else return false;
+      }
+    }
+    return false;
+  }
 };
 async function unwrapStoredPatch(document, budget) {
   if (document.size && (await document.data.read(8 + document.size - 1, 1))[0] !== 10) throw new ToolError2("patch is truncated: missing final LF");
@@ -317,13 +363,13 @@ async function unwrapStoredPatch(document, budget) {
   }
   const input = new StoredPatchInput(document, crlf);
   let start = 0;
-  if (/^(?:From [0-9a-f]{40,64} |(?:From|Date|Subject|To|Cc|MIME-Version|Content-Type):)/u.test(await input.read(0) ?? "")) {
+  if (/^(?:From [0-9a-f]{40,64} |(?:From|Date|Subject|To|Cc|MIME-Version|Content-Type):)/u.test(await input.read(0, 128) ?? "")) {
     while (start < input.length) {
       budget.step();
       const pause = budget.checkpoint();
       if (pause) await pause;
-      const line = await input.read(start);
-      if (/^(?:--- |\*\*\* |diff |\d+(?:,\d+)?[acd]\d)/u.test(line)) break;
+      const line = await input.read(start, 128);
+      if (/^(?:--- |\*\*\* |diff )/u.test(line) || /^\d/u.test(line) && await input.normalCommand(start)) break;
       if (/^(?:old mode |new mode |new file mode |deleted file mode |rename |copy |similarity index |dissimilarity index |GIT binary patch|Binary files |index |@@|[+\\])/u.test(line)) throw new ToolError2("unsupported or malformed mail patch metadata");
       if (++start > budget.limits.maxLines) throw new ToolError2("mail preamble limit exceeded");
     }
@@ -341,14 +387,79 @@ async function unwrapStoredPatch(document, budget) {
       budget.step();
       const pause2 = budget.checkpoint();
       if (pause2) await pause2;
-      if (/^(?:diff |---|\+\+\+|\*\*\*|@@|index |old mode |new mode |new file mode |deleted file mode |rename |copy |similarity index |dissimilarity index |GIT binary patch|Binary files |[+\\]|\d+(?:,\d+)?[acd]\d)/u.test(await input.read(index))) throw new ToolError2("patch data after mail signature");
+      const line = await input.read(index, 128);
+      if (/^(?:diff |---|\+\+\+|\*\*\*|@@|index |old mode |new mode |new file mode |deleted file mode |rename |copy |similarity index |dissimilarity index |GIT binary patch|Binary files |[+\\])/u.test(line) || /^\d/u.test(line) && await input.normalCommand(index)) throw new ToolError2("patch data after mail signature");
     }
   }
   return new StoredPatchInput(document, crlf, start, end - start);
 }
 
+// packages/safe-bash-command-patch/src/stored-outcomes.ts
+import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+var OutcomeStore = class {
+  records;
+  constructor(documents) {
+    this.records = new PagedStorage2(documents.budget.context, 16, documents.cache);
+  }
+  create(patch) {
+    return new StoredOutcomes(this.records, this.records.allocate(patch.hunks.length * 64), patch);
+  }
+  close() {
+    return this.records.close();
+  }
+};
+var StoredOutcomes = class {
+  constructor(records, start, patch) {
+    this.records = records;
+    this.start = start;
+    this.patch = patch;
+  }
+  records;
+  start;
+  patch;
+  length = 0;
+  async push(outcome) {
+    if (this.length >= this.patch.hunks.length) throw new RangeError("Too many patch outcomes");
+    const bytes = new Uint8Array(64), view = new DataView(bytes.buffer);
+    view.setFloat64(0, outcome.index, true);
+    view.setFloat64(8, outcome.line, true);
+    view.setFloat64(16, outcome.outputOffset, true);
+    view.setFloat64(24, outcome.offset, true);
+    view.setFloat64(32, outcome.fuzz, true);
+    view.setFloat64(40, outcome.mergeRange?.[0] ?? NaN, true);
+    view.setFloat64(48, outcome.mergeRange?.[1] ?? NaN, true);
+    bytes[56] = (outcome.failed ? 1 : 0) | (outcome.misordered ? 2 : 0);
+    await this.records.write(this.start + this.length * 64, bytes);
+    this.length++;
+  }
+  async at(position) {
+    if (!Number.isSafeInteger(position) || position < 0 || position >= this.length) return void 0;
+    const bytes = await this.records.read(this.start + position * 64, 64), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const index = view.getFloat64(0, true), mergeStart = view.getFloat64(40, true);
+    return {
+      hunk: await patchHunk(this.patch, index - 1),
+      index,
+      line: view.getFloat64(8, true),
+      outputOffset: view.getFloat64(16, true),
+      offset: view.getFloat64(24, true),
+      fuzz: view.getFloat64(32, true),
+      failed: !!(bytes[56] & 1),
+      misordered: !!(bytes[56] & 2),
+      ...Number.isNaN(mergeStart) ? {} : { mergeRange: [mergeStart, view.getFloat64(48, true)] }
+    };
+  }
+  async pop() {
+    const outcome = await this.at(this.length - 1);
+    if (outcome) this.length--;
+    return outcome;
+  }
+  async *[Symbol.asyncIterator]() {
+    for (let index = 0; index < this.length; index++) yield await this.at(index);
+  }
+};
+
 // packages/safe-bash-command-patch/src/patch.ts
-import { FsError, dirname, pipeBytes, resolvePath, writeBytes } from "../../safe-bash-contracts/index.js";
+import { FsError, dirname, pathOf, pipeBytes, resolvePath, writeBytes } from "../../safe-bash-contracts/index.js";
 import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
 import { Budget as Budget3, ToolError as ToolError3, definition, host, inspect, integer } from "../../safe-bash-diff-engine/shared.js";
 function flags(args) {
@@ -478,55 +589,59 @@ function flags(args) {
   if (result.posix && !backupSelected) result.backup = false;
   return result;
 }
-async function applyContent(sourcePatch, current, exists, options, budget, documents) {
+async function applyContent(sourcePatch, current, exists, options, budget, documents, outcomeStore) {
   let reversed = options.reverse;
-  let patch = reversed ? reversePatch(sourcePatch) : sourcePatch;
-  const emptyOld = () => patch.hunks.every((hunk) => hunk.oldCount === 0 && hunk.oldStart === 0);
-  const creation = () => patch.oldPath === "/dev/null" || emptyOld() && (patch.oldEpoch || !exists);
+  let patch = reversed ? reverseStoredPatch(sourcePatch) : sourcePatch;
+  const emptySide = async (side, checkStart = true) => {
+    for await (const [, hunk] of patchHunks(patch)) if (hunk[`${side}Count`] !== 0 || checkStart && hunk[`${side}Start`] !== 0) return false;
+    return true;
+  };
+  const creation = async () => patch.oldPath === "/dev/null" || await emptySide("old") && (patch.oldEpoch || !exists);
   let autoReversed = false;
   let reverseMismatch = false;
-  const declaredCreation = patch.oldPath === "/dev/null" || patch.oldEpoch && emptyOld();
-  const declaredDeletion = patch.newPath === "/dev/null" || patch.newEpoch && patch.hunks.every((hunk) => hunk.newCount === 0);
+  const declaredCreation = patch.oldPath === "/dev/null" || patch.oldEpoch && await emptySide("old");
+  const declaredDeletion = patch.newPath === "/dev/null" || patch.newEpoch && await emptySide("new", false);
   if (!options.force && (declaredCreation && current.size !== 0 || declaredDeletion && !exists)) {
-    patch = reversePatch(patch);
+    patch = reverseStoredPatch(patch);
     reversed = !reversed;
     autoReversed = true;
   }
-  if (!creation() && !exists) return void 0;
-  let outcomes = [];
+  if (!await creation() && !exists) return void 0;
+  let outcomes = outcomeStore.create(patch);
   let result = await applyStoredHunks(current, patch, options.fuzz, budget, options.ignoreWhitespace, {
     partial: true,
     outcomes,
     ...options.ifdef === void 0 ? {} : { ifdef: options.ifdef },
     ...options.merge === void 0 ? {} : { merge: options.merge },
-    rejectAll: creation() && current.size !== 0
+    rejectAll: await creation() && current.size !== 0
   }, documents);
-  if (!options.merge && !options.force && !autoReversed && (outcomes[0]?.failed || outcomes[0]?.fuzz)) {
-    const opposite = reversePatch(patch);
-    const probe = [];
-    const reverseFuzz = outcomes[0].failed ? options.fuzz : outcomes[0].fuzz - 1;
-    const probeResult = await applyStoredHunks(current, { ...opposite, hunks: opposite.hunks.slice(0, 1) }, reverseFuzz, budget, options.ignoreWhitespace, { partial: true, outcomes: probe }, documents);
+  const first = await outcomes.at(0);
+  if (!options.merge && !options.force && !autoReversed && (first?.failed || first?.fuzz)) {
+    const opposite = reverseStoredPatch(patch);
+    const probe = outcomeStore.create(opposite);
+    const reverseFuzz = first.failed ? options.fuzz : first.fuzz - 1;
+    const probeResult = await applyStoredHunks(current, { ...opposite, hunks: [await patchHunk(opposite, 0)] }, reverseFuzz, budget, options.ignoreWhitespace, { partial: true, outcomes: probe }, documents);
     await documents.release(probeResult);
-    if (!probe[0]?.failed) {
+    if (!(await probe.at(0))?.failed) {
       patch = opposite;
       reversed = !reversed;
       autoReversed = true;
       reverseMismatch = true;
-      outcomes = [];
+      outcomes = outcomeStore.create(patch);
       await documents.release(result);
       result = await applyStoredHunks(current, patch, options.fuzz, budget, options.ignoreWhitespace, {
         partial: true,
         outcomes,
         ...options.ifdef === void 0 ? {} : { ifdef: options.ifdef },
         ...options.merge === void 0 ? {} : { merge: options.merge },
-        rejectAll: creation() && current.size !== 0
+        rejectAll: await creation() && current.size !== 0
       }, documents);
     }
   }
-  const deletion = patch.newPath === "/dev/null" || patch.newEpoch && patch.hunks.every((hunk) => hunk.newCount === 0 && hunk.newStart === 0);
+  const deletion = patch.newPath === "/dev/null" || patch.newEpoch && await emptySide("new");
   if (autoReversed && options.forward) {
     await documents.release(result);
-    return { result: current, outcomes: [], reversed, autoReversed, reverseMismatch, deletion: false, skipped: true };
+    return { result: current, outcomes: outcomeStore.create(patch), reversed, autoReversed, reverseMismatch, deletion: false, skipped: true };
   }
   return { result, outcomes, reversed, autoReversed, reverseMismatch, deletion };
 }
@@ -609,7 +724,9 @@ async function run(context, budget) {
     budget = new Budget3(context, Object.fromEntries(Object.entries(budget.limits).filter(([, value]) => Number.isFinite(value))));
   }
   const documents = new TargetDocuments(budget);
-  const messages = new PagedStorage2(budget.context, 16, documents.cache);
+  const bodies = new PatchBodyStore(documents);
+  const outcomeStore = new OutcomeStore(documents);
+  const messages = new PagedStorage3(budget.context, 16, documents.cache);
   try {
     const empty = await documents.load({ async *[Symbol.asyncIterator]() {
     } });
@@ -622,20 +739,24 @@ async function run(context, budget) {
       const stat = await inspect(budget, options.input);
       if (stat?.type !== "file") throw new ToolError3("patch input must be a regular file");
     }
-    const inputPath = resolvePath(context.cwd, options.input);
+    const inputPath = pathOf(context, options.input);
     const inputCapabilities = options.input === "-" ? void 0 : await host(context, async () => await context.fs.capabilitiesFor?.(inputPath, { signal: context.signal }) ?? context.fs.capabilities);
     const input = options.input === "-" ? await documents.load(budget.stdinSource()) : inputCapabilities?.retainedRead && context.fs.openReadFile ? await documents.read(inputPath) : context.fs.readStream && inputCapabilities?.streamingRead !== false ? await documents.load(budget.streamSource(inputPath)) : await documents.load(targetBytes(await budget.read(inputPath)));
     const progress = options.atomic ? void 0 : {};
-    const sections = await parsePatch(await unwrapStoredPatch(input, budget), budget, options.format, explicit, progress, async (chunks) => {
-      const converted = await documents.load({ async *[Symbol.asyncIterator]() {
-        for await (const chunk of chunks) yield* targetBytes(chunk);
-      } });
-      try {
-        return await parseUnified(new StoredPatchInput(converted), budget);
-      } finally {
-        await documents.release(converted);
+    const sections = await parsePatchWith(await unwrapStoredPatch(input, budget), budget, options.format, explicit, {
+      unified: (cursor) => parseUnifiedReader(cursor, budget, true, () => bodies.begin(), () => bodies.beginHunks()),
+      converted: async (chunks) => {
+        const converted = await documents.load({ async *[Symbol.asyncIterator]() {
+          for await (const chunk of chunks) yield* targetBytes(chunk);
+        } });
+        try {
+          budget.countLines(converted.length);
+          return await parseUnifiedReader({ input: new StoredPatchInput(converted), index: 0 }, budget, false, () => bodies.begin(), () => bodies.beginHunks());
+        } finally {
+          await documents.release(converted);
+        }
       }
-    });
+    }, progress);
     await documents.release(input);
     const parsed = options.format === "normal" ? sections : sections.filter((patch) => !patch.unlocated);
     if (sections.length && !parsed.length) throw new ToolError3("no identifiable patch; normal input requires a target, Index header, or -n");
@@ -657,7 +778,7 @@ async function run(context, budget) {
         if (outputToStdout) return;
         const path = resolvePath(context.cwd, item.selected);
         const current = preview.has(path) ? preview.get(path) : await inspect(budget, path) ? await documents.read(path) : void 0;
-        const applied = await applyContent(item.patch, current ?? empty, current !== void 0, options, budget, documents);
+        const applied = await applyContent(item.patch, current ?? empty, current !== void 0, options, budget, documents, outcomeStore);
         if (current && current !== applied?.result) await documents.release(current);
         if (!applied) return;
         const remove = options.ifdef === void 0 && applied.result.size === 0 && (!options.posix && applied.deletion || options.removeEmpty);
@@ -737,17 +858,19 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
             if (rejectPath2 !== void 0) {
               await authorizeOutputs([rejectPath2], targets, paths.input, budget);
               if (backupPaths.has(rejectPath2)) throw new ToolError3("reject path aliases another section's backup");
-              const patch = options.reverse ? reversePatch(sourcePatch) : sourcePatch;
-              const outcomes2 = patch.hunks.map((hunk, index) => ({
-                hunk,
-                index: index + 1,
-                failed: true,
-                misordered: false,
-                line: hunk.oldStart,
-                outputOffset: 0,
-                offset: 0,
-                fuzz: 0
-              }));
+              const patch = options.reverse ? reverseStoredPatch(sourcePatch) : sourcePatch;
+              const outcomes2 = { async *[Symbol.asyncIterator]() {
+                for await (const [index, hunk] of patchHunks(patch)) yield {
+                  hunk,
+                  index: index + 1,
+                  failed: true,
+                  misordered: false,
+                  line: hunk.oldStart,
+                  outputOffset: 0,
+                  offset: 0,
+                  fuzz: 0
+                };
+              } };
               const reject2 = await documents.load(rejectBytes(sourcePatch, outcomes2, authorizedPatch.oldName, authorizedPatch.newName, authorizedPatch.indexName, options.reverse, budget, options.rejectFormat));
               const original2 = await documents.read(path);
               publishing = true;
@@ -773,7 +896,7 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
         exitCode = 1;
         return;
       }
-      const applied = await applyContent(sourcePatch, current, exists, options, budget, documents);
+      const applied = await applyContent(sourcePatch, current, exists, options, budget, documents, outcomeStore);
       if (!applied) {
         if (options.atomic) throw new ToolError3(`patch target does not exist: ${path}`, 1);
         await status(`No file to patch.  Skipping patch ${name}.
@@ -790,15 +913,21 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
         exitCode = 1;
         return;
       }
-      const failed = outcomes.filter((outcome) => outcome.failed);
-      const conflict = failed.length > 0 || deletion && result.size !== 0;
-      if (options.atomic && conflict) throw new ToolError3(failed.length ? `hunk ${failed[0].index} does not match ${name}` : `deletion patch leaves content: ${name}`, 1);
+      let failedCount = 0, firstFailed = 0, mismatch = reverseMismatch;
+      for await (const outcome of outcomes) {
+        if (outcome.failed) {
+          if (!failedCount) firstFailed = outcome.index;
+          failedCount++;
+        }
+        mismatch ||= outcome.failed || outcome.offset !== 0 || outcome.fuzz !== 0;
+      }
+      const conflict = failedCount > 0 || deletion && result.size !== 0;
+      if (options.atomic && conflict) throw new ToolError3(failedCount ? `hunk ${firstFailed} does not match ${name}` : `deletion patch leaves content: ${name}`, 1);
       if (conflict) exitCode = 1;
-      const mismatch = reverseMismatch || outcomes.some((outcome) => outcome.failed || outcome.offset !== 0 || outcome.fuzz !== 0);
       const backup = !options.dryRun && !outputToStdout && (options.alwaysBackup || options.backup && mismatch) && !touched.has(path) ? original ?? empty : void 0;
       const backupPath = backup === void 0 ? prior?.backupPath : await backupName(path, budget, options);
       const rejectDestination = rejectName(outputToStdout ? "-" : name, paths);
-      const rejectPath = !options.dryRun && !options.merge && failed.length && rejectDestination !== void 0 ? resolvePath(context.cwd, rejectDestination) : void 0;
+      const rejectPath = !options.dryRun && !options.merge && failedCount && rejectDestination !== void 0 ? resolvePath(context.cwd, rejectDestination) : void 0;
       const rejected = rejectPath === void 0 ? void 0 : await documents.load(rejectBytes(sourcePatch, outcomes, authorizedPatch.oldName, authorizedPatch.newName, authorizedPatch.indexName, reversed, budget, options.rejectFormat));
       await authorizeOutputs([outputPath, backupPath, rejectPath], targets, paths.input, budget);
       if (backupPath !== void 0 && rejectPaths.has(backupPath) || rejectPath !== void 0 && backupPaths.has(rejectPath)) {
@@ -857,7 +986,7 @@ ${headers}--------------------------
       if (!options.quiet) await appendStatus(`${options.dryRun ? "checking" : "patching"} file ${output === void 0 ? displayName : `${quotePatchName(output, options.quotingStyle)} (read from ${displayName})`}
 `);
       if (autoReversed) await appendStatus("Reversed (or previously applied) patch detected!  Assuming -R.\n");
-      for (const outcome of outcomes) {
+      for await (const outcome of outcomes) {
         if (outcome.misordered) await appendStatus("misordered hunks! output would be garbled\n");
         if (options.quiet) continue;
         if (outcome.failed && options.merge) await appendStatus(`Hunk #${outcome.index} NOT MERGED at ${outcome.mergeRange?.[0] ?? outcome.line}-${outcome.mergeRange?.[1] ?? outcome.line}.
@@ -867,7 +996,7 @@ ${headers}--------------------------
         else if (options.verbose || outcome.offset || outcome.fuzz) await appendStatus(`Hunk #${outcome.index} succeeded at ${outcome.line}${outcome.fuzz ? ` with fuzz ${outcome.fuzz}` : ""}${outcome.offset ? ` (offset ${outcome.offset} ${outcome.offset === 1 ? "line" : "lines"})` : ""}.
 `);
       }
-      if (failed.length && !options.merge) await appendStatus(`${failed.length} out of ${outcomes.length} ${outcomes.length === 1 ? "hunk" : "hunks"} FAILED${options.dryRun || rejectPath === void 0 ? "" : ` -- saving rejects to file ${rejectDestination}`}
+      if (failedCount && !options.merge) await appendStatus(`${failedCount} out of ${outcomes.length} ${outcomes.length === 1 ? "hunk" : "hunks"} FAILED${options.dryRun || rejectPath === void 0 ? "" : ` -- saving rejects to file ${rejectDestination}`}
 `);
       if (deletion && result.size !== 0) await appendStatus(`Not deleting file ${name} as content differs from patch
 `);
@@ -920,7 +1049,7 @@ ${headers}--------------------------
     if (progress?.error) throw progress.error;
     return exitCode;
   } finally {
-    await closeDocumentResources2([messages, documents]);
+    await closeDocumentResources2([messages, documents, bodies, outcomeStore]);
   }
 }
 function patchCommand(options = {}) {

package/dist/safe-bash/command-chunks/{chunk-GQ2ZSPZ3.js → chunk-46AMTJPE.js}

@@ -1,33 +1,33 @@
 import {
   collectDocumentRevisions
-} from "./chunk-MPORWUTU.js";
+} from "./chunk-V5XC43BX.js";
 import {
   assertOutsideFields,
   parseFields
-} from "./chunk-ATI464W3.js";
+} from "./chunk-AG2SNMP5.js";
 import {
   openDocumentLocations
-} from "./chunk-UZL7G57V.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   DocumentArchiveEditor
-} from "./chunk-QDVI2YB6.js";
-import {
-  validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-VUWXLH3E.js";
 import {
   pathContains
-} from "./chunk-MTWZEPAR.js";
+} from "./chunk-47IAU25U.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DZH54L3F.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   UnsupportedEditError,
   assertOutsideRevisionRanges,
   containsRevision,
   revisionInfo,
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   closedRecord,
   encodeGeneratedLocation

package/dist/safe-bash/command-chunks/{chunk-MTWZEPAR.js → chunk-47IAU25U.js}

@@ -1,13 +1,13 @@
 import {
   tableRows
-} from "./chunk-ML5R5JML.js";
+} from "./chunk-KY4LCHUF.js";
 import {
   DocumentPackage
 } from "./chunk-5BUL25DF.js";
 import {
   collectShapeCarriers,
   revisionInfo
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   trimXmlWhitespace
 } from "./chunk-ET5SFGRH.js";

package/dist/safe-bash/command-chunks/{chunk-6GI3NTCW.js → chunk-4B2ZUGLT.js}

@@ -1,14 +1,14 @@
 import {
   openDocumentLocations,
   resolveDocxSelection
-} from "./chunk-UZL7G57V.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-DZH54L3F.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   documentPartRole
 } from "./chunk-L4FX5S6P.js";
@@ -25,7 +25,7 @@ import {
   runElementOpen,
   splitNativeTextRunXml,
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   corePropertyKeys,
   customPropertyType,