@poe-platform/safe-bash 0.1.814 → 0.1.815

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

@@ -1,25 +1,27 @@
 import {
   PatchBodyStore,
+  patchHunk,
+  patchHunks,
   patchLine,
   rejectBytes,
   reverseStoredPatch
-} from "./chunk-3JM7E42I.js";
+} from "./chunk-GPGLTWNR.js";
 import {
   PatchPublication
-} from "./chunk-5BIQWWLB.js";
+} from "./chunk-CFMJXJS5.js";
 import {
   TargetDocuments,
   TargetOutput,
   equalTargetLines,
   targetBytes
-} from "./chunk-CK2WFJZN.js";
+} from "./chunk-KASXIRKD.js";
 import {
   parsePatchWith
-} from "./chunk-SW37YCBW.js";
+} from "./chunk-U3C6IT2C.js";
 import {
   parseUnifiedReader,
   startIndex
-} from "./chunk-VT7UBPAE.js";
+} from "./chunk-YW2VYN4V.js";
 import {
   authorizeOutputs,
   authorizePaths,
@@ -38,7 +40,7 @@ import {
 
 // 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";
@@ -55,7 +57,7 @@ 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;
@@ -169,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,
@@ -204,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");
@@ -217,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;
@@ -285,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 });
@@ -297,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");
@@ -320,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");
     }
@@ -344,12 +387,77 @@ 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, pathOf, pipeBytes, resolvePath, writeBytes } from "../../safe-bash-contracts/index.js";
 import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
@@ -481,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 ? reverseStoredPatch(sourcePatch) : sourcePatch;
-  const emptyOld = () => patch.hunks.every((hunk) => hunk.oldCount === 0 && hunk.oldStart === 0);
-  const creation = () => patch.oldPath === "/dev/null" || emptyOld() && (patch.oldEpoch || !exists);
+  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 = 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 first = await outcomes.at(0);
+  if (!options.merge && !options.force && !autoReversed && (first?.failed || first?.fuzz)) {
     const opposite = reverseStoredPatch(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 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 };
 }
@@ -613,7 +725,8 @@ async function run(context, budget) {
   }
   const documents = new TargetDocuments(budget);
   const bodies = new PatchBodyStore(documents);
-  const messages = new PagedStorage2(budget.context, 16, documents.cache);
+  const outcomeStore = new OutcomeStore(documents);
+  const messages = new PagedStorage3(budget.context, 16, documents.cache);
   try {
     const empty = await documents.load({ async *[Symbol.asyncIterator]() {
     } });
@@ -631,14 +744,14 @@ async function run(context, budget) {
     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 parsePatchWith(await unwrapStoredPatch(input, budget), budget, options.format, explicit, {
-      unified: (cursor) => parseUnifiedReader(cursor, budget, true, () => bodies.begin()),
+      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());
+          return await parseUnifiedReader({ input: new StoredPatchInput(converted), index: 0 }, budget, false, () => bodies.begin(), () => bodies.beginHunks());
         } finally {
           await documents.release(converted);
         }
@@ -665,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);
@@ -746,16 +859,18 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
               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 ? reverseStoredPatch(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 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;
@@ -781,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}.
@@ -798,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)) {
@@ -865,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}.
@@ -875,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
 `);
@@ -928,7 +1049,7 @@ ${headers}--------------------------
     if (progress?.error) throw progress.error;
     return exitCode;
   } finally {
-    await closeDocumentResources2([messages, documents, bodies]);
+    await closeDocumentResources2([messages, documents, bodies, outcomeStore]);
   }
 }
 function patchCommand(options = {}) {

package/dist/safe-bash/command-chunks/{chunk-PIVH35EQ.js → chunk-6CDDKNNA.js}

@@ -94,6 +94,7 @@ async function parseStoredXml(source, context, budget, recover, consume) {
       retainTree: false,
       storeFrames: true,
       fragmentContent: true,
+      compactDeclaration: true,
       ...recover ? { recover } : {},
       ...consume ? { events: (event) => {
         queued.push(event);