@poe-platform/safe-bash 0.1.811 → 0.1.813

package/dist/safe-bash/command-chunks/{chunk-72C3TZ2U.js → chunk-PKLJRB7W.js}

@@ -1,20 +1,14 @@
 import {
-  PatchPublication,
-  TargetDocuments,
-  TargetOutput,
-  equalTargetLines,
-  targetBytes
-} from "./chunk-WH3TIOTS.js";
-import {
-  unwrapPatch
-} from "./chunk-JKLOBSMP.js";
+  PatchPublication
+} from "./chunk-PK36TVXB.js";
 import {
   parsePatch
-} from "./chunk-2VLAXKTS.js";
+} from "./chunk-CTDC4LJT.js";
 import {
+  parseUnified,
   reversePatch,
   startIndex
-} from "./chunk-MOZD7RUY.js";
+} from "./chunk-JORIVUPM.js";
 import {
   authorizeOutputs,
   authorizePaths,
@@ -31,10 +25,22 @@ import {
   safeTarget
 } from "./chunk-AJEQUVDN.js";
 import {
-  rejectText
-} from "./chunk-JYTESTBS.js";
+  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";
 
 // packages/safe-bash-command-patch/src/stored-hunks.ts
+import { closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
 import { ToolError } from "../../safe-bash-diff-engine/shared.js";
 async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace = false, application, documents) {
   const source = { length: original.length, at(index) {
@@ -42,13 +48,34 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
   } };
   budget.countLines(source.length);
   const result = new TargetOutput(documents);
+  const indices = new PagedStorage(budget.context, 16, documents.cache);
   try {
     let cursor = 0;
     let offset = 0;
     let outputOffset = 0;
     for (const [hunkIndex, hunk] of patch.hunks.entries()) {
       budget.step();
-      const oldLines = hunk.lines.filter((line) => line.kind !== "+");
+      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 !== "+") {
+          await indices.write(oldPosition, cell);
+          oldPosition += 8;
+        }
+        if (hunk.lines[index].kind !== "-") {
+          await indices.write(newPosition, cell);
+          newPosition += 8;
+        }
+        budget.step();
+        const pause = budget.checkpoint();
+        if (pause) await pause;
+      }
+      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;
+      };
       let leading = 0;
       let trailing = 0;
       while (leading < hunk.lines.length && hunk.lines[leading].kind === " ") leading++;
@@ -65,11 +92,11 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
           if (c) await c;
         }
         if (position < 0 || position > source.length - hunk.oldCount + suffixFuzz) return false;
-        for (let lineIndex = 0; lineIndex < oldLines.length; lineIndex++) {
-          if (lineIndex < prefixFuzz || lineIndex >= oldLines.length - suffixFuzz) continue;
+        for (let lineIndex = 0; lineIndex < hunk.oldCount; lineIndex++) {
+          if (lineIndex < prefixFuzz || lineIndex >= hunk.oldCount - suffixFuzz) continue;
           const actual = source.at(position + lineIndex);
           if (actual === void 0) return false;
-          const expectedLine = oldLines[lineIndex].text;
+          const expectedLine = await indexedLine(oldIndex, lineIndex);
           if (!await equalTargetLines(actual, expectedLine, budget, ignoreWhitespace)) return false;
           {
             const c = budget.checkpoint();
@@ -105,7 +132,7 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
           if (found >= 0) break;
           continue;
         }
-        const retained = oldLines.length - Math.max(0, prefixFuzz) - suffixFuzz;
+        const retained = hunk.oldCount - Math.max(0, prefixFuzz) - suffixFuzz;
         if (retained === 0) {
           if (await matches(expected, Math.max(0, prefixFuzz), suffixFuzz)) {
             found = expected;
@@ -152,48 +179,46 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
       if (found < 0 && application.merge && !misordered) {
         const position = Math.max(cursor, Math.min(source.length, expected));
         while (cursor < position) await result.append(source.at(cursor++));
-        let local = Array.from({ length: Math.min(hunk.oldCount, source.length - cursor) }, (_, index) => source.at(cursor + index));
+        let localLength = Math.min(hunk.oldCount, source.length - cursor);
         let anchored = false;
-        for (let index = 0; index < oldLines.length; index++) {
-          if (await equalTargetLines(oldLines[index].text, local[index] ?? "", budget)) {
+        for (let index = 0; index < hunk.oldCount; index++) {
+          if (await equalTargetLines(await indexedLine(oldIndex, index), index < localLength ? source.at(cursor + index) : "", budget)) {
             anchored = true;
             break;
           }
         }
-        if (!anchored) local = [];
-        const incoming = hunk.lines.filter((line) => line.kind !== "-").map((line) => line.text);
-        const base = oldLines.map((line) => line.text);
+        if (!anchored) localLength = 0;
         let prefix = 0;
         let suffix = 0;
-        while (prefix < Math.min(local.length, incoming.length, base.length) && await equalTargetLines(local[prefix], incoming[prefix], budget) && await equalTargetLines(local[prefix], base[prefix], budget)) prefix++;
-        while (suffix < Math.min(local.length, incoming.length, base.length) - prefix && await equalTargetLines(local[local.length - suffix - 1], incoming[incoming.length - suffix - 1], budget) && await equalTargetLines(local[local.length - suffix - 1], base[base.length - suffix - 1], budget)) suffix++;
+        while (prefix < Math.min(localLength, hunk.newCount, hunk.oldCount) && await equalTargetLines(source.at(cursor + prefix), await indexedLine(newIndex, prefix), budget) && await equalTargetLines(source.at(cursor + prefix), await indexedLine(oldIndex, prefix), budget)) prefix++;
+        while (suffix < Math.min(localLength, hunk.newCount, hunk.oldCount) - prefix && await equalTargetLines(source.at(cursor + localLength - suffix - 1), await indexedLine(newIndex, hunk.newCount - suffix - 1), budget) && await equalTargetLines(source.at(cursor + localLength - suffix - 1), await indexedLine(oldIndex, hunk.oldCount - suffix - 1), budget)) suffix++;
         {
           const c = budget.checkpoint();
           if (c) await c;
         }
-        for (const line of local.slice(0, prefix)) await result.append(line);
+        for (let index = 0; index < prefix; index++) await result.append(source.at(cursor + index));
         const mergeStart = result.length + 1;
-        let identical = local.length === incoming.length;
-        for (let index = 0; identical && index < local.length; index++) identical = await equalTargetLines(local[index], incoming[index], budget);
+        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) });
-          for (const line of local.slice(prefix, local.length - suffix)) await result.append(line);
+          for (let index = prefix; index < localLength - suffix; index++) await result.append(source.at(cursor + index));
         } else {
           await result.append("<<<<<<<\n");
-          for (const line of local.slice(prefix, local.length - suffix)) await result.append(line);
+          for (let index = prefix; index < localLength - suffix; index++) await result.append(source.at(cursor + index));
           if (application.merge === "diff3") {
             await result.append("|||||||\n");
-            for (const line of base.slice(prefix, base.length - suffix)) await result.append(line);
+            for (let index = prefix; index < hunk.oldCount - suffix; index++) await result.append(await indexedLine(oldIndex, index));
           }
           await result.append("=======\n");
-          for (const line of incoming.slice(prefix, incoming.length - suffix)) await result.append(line);
+          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] });
         }
-        for (const line of local.slice(local.length - suffix)) await result.append(line);
-        cursor += local.length;
+        for (let index = localLength - suffix; index < localLength; index++) await result.append(source.at(cursor + index));
+        cursor += localLength;
         outputOffset = result.length - cursor;
         continue;
       }
@@ -202,46 +227,130 @@ async function applyStoredHunks(original, patch, fuzz, budget, ignoreWhitespace
         throw new ToolError(`hunk ${hunkIndex + 1} does not match ${patch.oldPath}`, 1);
       }
       while (cursor < found + matchedPrefixFuzz) await result.append(source.at(cursor++));
-      let removed = [];
-      let added = [];
-      const flush = async () => {
-        if (!removed.length && !added.length) return;
+      let changeStart = matchedPrefixFuzz, changeCursor = cursor;
+      const flush = async (end) => {
+        let removed = 0, added = 0;
+        for (let index = changeStart; index < end; index++) {
+          if (hunk.lines[index].kind === "+") added++;
+          else removed++;
+          budget.step();
+          const pause = budget.checkpoint();
+          if (pause) await pause;
+        }
+        if (!removed && !added) return;
         if (application.ifdef) {
-          await result.append(`#${removed.length ? "ifndef" : "ifdef"} ${application.ifdef}
+          await result.append(`#${removed ? "ifndef" : "ifdef"} ${application.ifdef}
 `);
-          for (const text of removed) await result.append(text);
-          if (removed.length && added.length) await result.append("#else\n");
-          for (const text of added) await result.append(text);
-          await result.append("#endif\n");
-        } else for (const text of added) await result.append(text);
-        removed = [];
-        added = [];
+          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);
+          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);
+        if (application.ifdef) await result.append("#endif\n");
       };
-      for (const line of hunk.lines.slice(matchedPrefixFuzz, hunk.lines.length - matchedSuffixFuzz)) {
-        if (line.kind === "+") added.push(line.text);
-        else if (line.kind === " ") {
-          await flush();
+      for (let index = matchedPrefixFuzz; index < hunk.lines.length - matchedSuffixFuzz; index++) {
+        const line = hunk.lines[index];
+        if (line.kind === " ") {
+          await flush(index);
           if (cursor < source.length) await result.append(source.at(cursor++));
-        } else {
-          removed.push(source.at(cursor) ?? line.text);
-          cursor++;
-        }
+          changeStart = index + 1;
+          changeCursor = cursor;
+        } else if (line.kind === "-") cursor++;
       }
-      await flush();
+      await flush(hunk.lines.length - matchedSuffixFuzz);
       outputOffset = result.length - cursor;
     }
     while (cursor < source.length) await result.append(source.at(cursor++));
     return await result.finish();
   } finally {
-    await result.close();
+    await closeDocumentResources([result, indices]);
+  }
+}
+
+// packages/safe-bash-command-patch/src/stored-input.ts
+import { ToolError as ToolError2 } from "../../safe-bash-diff-engine/shared.js";
+var StoredPatchInput = class {
+  constructor(document, crlf = false, start = 0, length = document.length - start) {
+    this.document = document;
+    this.crlf = crlf;
+    this.start = start;
+    this.length = length;
+  }
+  document;
+  crlf;
+  start;
+  length;
+  cachedIndex = -1;
+  cachedLine = "";
+  async read(index) {
+    if (index < 0 || index >= this.length) return void 0;
+    if (index === this.cachedIndex) return this.cachedLine;
+    const line = await this.document.line(this.start + index);
+    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 });
+    text += decoder.decode();
+    this.cachedIndex = index;
+    this.cachedLine = text;
+    return text;
+  }
+  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;
+  }
+};
+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");
+  let crlf = true;
+  for (let index = 0; index < document.length; index++) {
+    const line = await document.line(index);
+    budget.step(line.end - line.start);
+    const pause = budget.checkpoint();
+    if (pause) await pause;
+    if (line.end - line.start < 2 || (await document.data.read(8 + line.end - 2, 1))[0] !== 13) {
+      crlf = false;
+      break;
+    }
+    if (index + 1 > budget.limits.maxLines) throw new ToolError2("transport line limit exceeded");
+  }
+  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) ?? "")) {
+    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;
+      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");
+    }
+    if (start === input.length) throw new ToolError2("mail preamble without patch");
+  }
+  let end = input.length;
+  for (let index = start + 1; index < input.length; index++) {
+    budget.step();
+    const pause = budget.checkpoint();
+    if (pause) await pause;
+    if (!await input.signature(index)) continue;
+    end = index;
+    if (input.length - index > budget.limits.maxLines) throw new ToolError2("mail signature limit exceeded");
+    for (index++; index < input.length; index++) {
+      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");
+    }
   }
+  return new StoredPatchInput(document, crlf, start, end - start);
 }
 
 // packages/safe-bash-command-patch/src/patch.ts
 import { FsError, dirname, pipeBytes, resolvePath, writeBytes } from "../../safe-bash-contracts/index.js";
 import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
-import { Budget as Budget2, ToolError as ToolError2, definition, host, inspect, integer } from "../../safe-bash-diff-engine/shared.js";
-import { encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { Budget as Budget3, ToolError as ToolError3, definition, host, inspect, integer } from "../../safe-bash-diff-engine/shared.js";
 function flags(args) {
   const result = { input: "-", reverse: false, dryRun: false, atomic: false, quiet: false, force: false, backup: true, fuzz: 2, ignoreWhitespace: false, removeEmpty: false };
   const operands = [];
@@ -252,7 +361,7 @@ function flags(args) {
     if (["simple", "never"].includes(parameter)) result.versionControl = "simple";
     else if (["numbered", "t"].includes(parameter)) result.versionControl = "numbered";
     else if (["existing", "nil"].includes(parameter)) result.versionControl = "existing";
-    else throw new ToolError2(`invalid version control: ${parameter}`);
+    else throw new ToolError3(`invalid version control: ${parameter}`);
   };
   let literal = false;
   let backupSelected = false;
@@ -260,7 +369,7 @@ function flags(args) {
     const arg = args[index];
     const value = (attached, name) => {
       const next = attached ?? args[++index];
-      if (next === void 0) throw new ToolError2(`${name} requires an argument`);
+      if (next === void 0) throw new ToolError3(`${name} requires an argument`);
       return next;
     };
     if (literal || arg === "-" || !arg.startsWith("-")) operands.push(arg);
@@ -281,7 +390,7 @@ function flags(args) {
     else if (arg === "--set-utc") result.setTime = "utc";
     else if (arg === "--merge" || arg.startsWith("--merge=")) {
       const style = arg.includes("=") ? arg.slice(arg.indexOf("=") + 1) : "merge";
-      if (style !== "merge" && style !== "diff3") throw new ToolError2(`invalid merge style: ${style}`);
+      if (style !== "merge" && style !== "diff3") throw new ToolError3(`invalid merge style: ${style}`);
       result.merge = style;
     } else if (arg === "--backup") result.alwaysBackup = true;
     else if (arg === "--forward") result.forward = true;
@@ -302,13 +411,13 @@ function flags(args) {
       const parameter = value(arg.includes("=") ? arg.slice(arg.indexOf("=") + 1) : void 0, name);
       if (name === "--ifdef") result.ifdef = parameter;
       else if (name === "--quoting-style") {
-        if (!["literal", "shell", "shell-always", "shell-escape", "shell-escape-always", "c", "escape", "locale", "clocale"].includes(parameter)) throw new ToolError2(`invalid quoting style: ${parameter}`);
+        if (!["literal", "shell", "shell-always", "shell-escape", "shell-escape-always", "c", "escape", "locale", "clocale"].includes(parameter)) throw new ToolError3(`invalid quoting style: ${parameter}`);
         result.quotingStyle = parameter;
       } else if (name === "--reject-format") {
-        if (parameter !== "unified" && parameter !== "context") throw new ToolError2(`invalid reject format: ${parameter}`);
+        if (parameter !== "unified" && parameter !== "context") throw new ToolError3(`invalid reject format: ${parameter}`);
         result.rejectFormat = parameter;
       } else if (name === "--read-only") {
-        if (!["ignore", "warn", "fail"].includes(parameter)) throw new ToolError2(`invalid read-only behavior: ${parameter}`);
+        if (!["ignore", "warn", "fail"].includes(parameter)) throw new ToolError3(`invalid read-only behavior: ${parameter}`);
         result.readOnly = parameter;
       } else if (name === "--strip") result.strip = integer(parameter, "strip count");
       else if (name === "--fuzz") result.fuzz = integer(parameter, "fuzz");
@@ -320,9 +429,9 @@ function flags(args) {
       else if (name === "--basename-prefix") result.basenamePrefix = parameter;
       else if (name === "--version-control") versionControl(parameter);
       else if (name === "--get") {
-        if (parameter !== "0") throw new ToolError2("version-control acquisition is unsupported; use --get=0");
+        if (parameter !== "0") throw new ToolError3("version-control acquisition is unsupported; use --get=0");
       } else result.input = parameter;
-    } else if (arg.startsWith("--")) throw new ToolError2(`unsupported option: ${arg}`);
+    } else if (arg.startsWith("--")) throw new ToolError3(`unsupported option: ${arg}`);
     else for (let offset = 1; offset < arg.length; offset++) {
       const flag = arg[offset];
       if (flag === "R") result.reverse = true;
@@ -353,18 +462,18 @@ function flags(args) {
         else if (flag === "Y") result.basenamePrefix = parameter;
         else if (flag === "V") versionControl(parameter);
         else if (flag === "g") {
-          if (parameter !== "0") throw new ToolError2("version-control acquisition is unsupported; use -g0");
+          if (parameter !== "0") throw new ToolError3("version-control acquisition is unsupported; use -g0");
         } else result.input = parameter;
         break;
-      } else throw new ToolError2(`unsupported option: -${flag}`);
+      } else throw new ToolError3(`unsupported option: -${flag}`);
     }
   }
-  if (operands.length > 2) throw new ToolError2("expected at most a target file and a patch input file");
+  if (operands.length > 2) throw new ToolError3("expected at most a target file and a patch input file");
   if (operands.length) result.target = operands[0];
   if (operands.length === 2) result.input = operands[1];
-  if (!result.input || result.input.includes("\0")) throw new ToolError2("invalid patch input path");
-  for (const path of [result.output, result.directory]) if (path !== void 0 && (!path || path.includes("\0"))) throw new ToolError2("invalid patch option path");
-  if (result.ifdef !== void 0 && (!result.ifdef || [...result.ifdef].some((c) => !"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_".includes(c)))) throw new ToolError2("invalid ifdef symbol");
+  if (!result.input || result.input.includes("\0")) throw new ToolError3("invalid patch input path");
+  for (const path of [result.output, result.directory]) if (path !== void 0 && (!path || path.includes("\0"))) throw new ToolError3("invalid patch option path");
+  if (result.ifdef !== void 0 && (!result.ifdef || [...result.ifdef].some((c) => !"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_".includes(c)))) throw new ToolError3("invalid ifdef symbol");
   if (result.merge) result.fuzz = 0;
   if (result.posix && !backupSelected) result.backup = false;
   return result;
@@ -425,12 +534,12 @@ async function unchanged(item, budget, documents) {
   if (item.sourcePath !== void 0) {
     const source = await inspect(budget, item.sourcePath);
     regular(source, item.sourcePath);
-    if (source === void 0 !== (item.sourceOriginal === void 0) || source && !await sameTarget(item.sourcePath, item.sourceOriginal, documents)) throw new ToolError2(`target changed during preflight: ${item.sourcePath}`, 1);
+    if (source === void 0 !== (item.sourceOriginal === void 0) || source && !await sameTarget(item.sourcePath, item.sourceOriginal, documents)) throw new ToolError3(`target changed during preflight: ${item.sourcePath}`, 1);
   }
   const stat = await inspect(budget, item.path);
   regular(stat, item.path);
   if (stat === void 0 !== (item.original === void 0) || item.original !== void 0 && !await sameTarget(item.path, item.original, documents)) {
-    throw new ToolError2(`target changed during preflight: ${item.path}`, 1);
+    throw new ToolError3(`target changed during preflight: ${item.path}`, 1);
   }
   for (const path of [item.backupPath, item.rejectPath]) {
     if (path !== void 0) regular(await inspect(budget, path), path);
@@ -442,13 +551,12 @@ async function publish(item, budget, rejects, publication, documents) {
   await unchanged(item, budget, documents);
   const write = async (path, text, append = false, createParents = true, mode, mtimeMs) => {
     if (createParents) await ensureParents(path, budget);
-    else if ((await inspect(budget, dirname(path)))?.type !== "directory") throw new ToolError2(`reject parent does not exist: ${dirname(path)}`);
+    else if ((await inspect(budget, dirname(path)))?.type !== "directory") throw new ToolError3(`reject parent does not exist: ${dirname(path)}`);
     const stat = await inspect(budget, path);
     regular(stat, path);
     const capabilities = await host(context, async () => await context.fs.capabilitiesFor?.(path, { signal: context.signal, create: true }) ?? context.fs.capabilities);
-    if (capabilities?.atomicStagingAncestry !== true && !(publication.trusted && capabilities?.trustedOwnedStaging === true)) throw new ToolError2("filesystem does not support race-safe patch publication");
+    if (capabilities?.atomicStagingAncestry !== true && !(publication.trusted && capabilities?.trustedOwnedStaging === true)) throw new ToolError3("filesystem does not support race-safe patch publication");
     const publicationMode = capabilities?.permissions === false ? void 0 : mode ?? (stat ? stat.mode & 4095 : void 0);
-    if (typeof text === "string") text = await documents.load(targetBytes(text));
     if (append && stat) text = await documents.concat(await documents.read(path), text);
     await publication.write(path, text.range(0, text.size), stat, publicationMode, mtimeMs);
   };
@@ -457,7 +565,7 @@ async function publish(item, budget, rejects, publication, documents) {
     if (item.original !== void 0) {
       const expected = await inspect(budget, item.path);
       regular(expected, item.path);
-      if (!expected) throw new ToolError2(`target changed during publication: ${item.path}`, 1);
+      if (!expected) throw new ToolError3(`target changed during publication: ${item.path}`, 1);
       await publication.remove(item.path, expected);
     }
   } else if (!item.skipWrite) {
@@ -473,9 +581,9 @@ async function run(context, budget) {
   const outputToStdout = options.output === "-";
   if (options.directory !== void 0) {
     const cwd = resolvePath(context.cwd, options.directory);
-    if ((await inspect(budget, cwd))?.type !== "directory") throw new ToolError2(`not a directory: ${options.directory}`);
+    if ((await inspect(budget, cwd))?.type !== "directory") throw new ToolError3(`not a directory: ${options.directory}`);
     context = { ...context, cwd };
-    budget = new Budget2(context, Object.fromEntries(Object.entries(budget.limits).filter(([, value]) => Number.isFinite(value))));
+    budget = new Budget3(context, Object.fromEntries(Object.entries(budget.limits).filter(([, value]) => Number.isFinite(value))));
   }
   let publication = new PatchPublication(context);
   if (!options.dryRun) {
@@ -483,8 +591,8 @@ async function run(context, budget) {
     const capabilities = await host(context, async () => await fs.capabilitiesFor?.(context.cwd, { signal: context.signal }) ?? fs.capabilities);
     if (capabilities.readOnly === true) throw new FsError("EROFS", { syscall: "patch", path: context.cwd });
     const trusted = capabilities.atomicStagingAncestry !== true && capabilities.trustedOwnedStaging === true;
-    if ((trusted ? !fs.prepareDirectory || !fs.removeFileConditional : !fs.confineExtraction || capabilities.atomicStagingAncestry !== true) || !fs.createStagedFile || !fs.publishStagedFile || !fs.removeStagedFile) {
-      throw new ToolError2("filesystem does not support race-safe patch publication");
+    if ((trusted ? !fs.prepareDirectory || !fs.removeFileConditional || !fs.writeFileConditional : !fs.confineExtraction || capabilities.atomicStagingAncestry !== true) || !fs.createStagedFile || !fs.publishStagedFile || !fs.removeStagedFile) {
+      throw new ToolError3("filesystem does not support race-safe patch publication");
     }
     publication = new PatchPublication(context, trusted);
     await publication.capture(`${context.cwd === "/" ? "" : context.cwd}/.patch-admission`);
@@ -498,28 +606,41 @@ async function run(context, budget) {
         return typeof value === "function" ? value.bind(selected) : value;
       }
     }) };
-    budget = new Budget2(context, Object.fromEntries(Object.entries(budget.limits).filter(([, value]) => Number.isFinite(value))));
+    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);
   try {
     const empty = await documents.load({ async *[Symbol.asyncIterator]() {
     } });
     const output = options.output === void 0 ? void 0 : safeTarget(options.output, 0, true);
-    if (options.output !== void 0 && output === void 0) throw new ToolError2("/dev/null is not an output file");
+    if (options.output !== void 0 && output === void 0) throw new ToolError3("/dev/null is not an output file");
     const outputPath = output === void 0 || outputToStdout ? void 0 : resolvePath(context.cwd, output);
     const explicit = options.target === void 0 ? void 0 : safeTarget(options.target, 0, true);
-    if (options.target !== void 0 && explicit === void 0) throw new ToolError2("/dev/null is not an explicit target");
+    if (options.target !== void 0 && explicit === void 0) throw new ToolError3("/dev/null is not an explicit target");
     if (options.input !== "-") {
       const stat = await inspect(budget, options.input);
-      if (stat?.type !== "file") throw new ToolError2("patch input must be a regular file");
+      if (stat?.type !== "file") throw new ToolError3("patch input must be a regular file");
     }
-    const input = await budget.read(options.input === "-" ? "-" : resolvePath(context.cwd, options.input));
+    const inputPath = resolvePath(context.cwd, 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 unwrapPatch(input, budget), budget, options.format, explicit, progress);
+    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);
+      }
+    });
+    await documents.release(input);
     const parsed = options.format === "normal" ? sections : sections.filter((patch) => !patch.unlocated);
-    if (sections.length && !parsed.length) throw new ToolError2("no identifiable patch; normal input requires a target, Index header, or -n");
+    if (sections.length && !parsed.length) throw new ToolError3("no identifiable patch; normal input requires a target, Index header, or -n");
     const reject = options.reject === void 0 || options.reject === "-" ? options.reject : safeTarget(options.reject, 0, true);
-    if (options.reject !== void 0 && reject === void 0) throw new ToolError2("/dev/null is not a reject file; use -r -");
+    if (options.reject !== void 0 && reject === void 0) throw new ToolError3("/dev/null is not a reject file; use -r -");
     const paths = {
       strip: options.strip,
       explicit,
@@ -556,23 +677,37 @@ async function run(context, budget) {
     const backupPaths = /* @__PURE__ */ new Set();
     const rejectPaths = /* @__PURE__ */ new Set();
     const parents = /* @__PURE__ */ new Set();
-    const messages = [];
+    let messageSize = 0, messagePosition = 0;
     let exitCode = 0;
     let committed = 0;
     let publishing = false;
     let activePath;
     let outputContents = empty;
     const statusSink = outputToStdout ? context.stderr : context.stdout;
-    const status = async (text) => {
+    const appendStatus = async (text) => {
       if (!text) return;
       budget.output(text);
-      if (options.atomic) messages.push(text);
-      else await writeBytes(statusSink, encodeBytes(text), context.signal);
+      for await (const bytes of targetBytes(text)) {
+        await messages.append(bytes);
+        messageSize += bytes.length;
+      }
+    };
+    const flushStatus = async (final = false) => {
+      if (options.atomic && !final) return;
+      while (messagePosition < messageSize) {
+        const bytes = await messages.read(8 + messagePosition, Math.min(16384, messageSize - messagePosition));
+        await writeBytes(statusSink, bytes, context.signal);
+        messagePosition += bytes.length;
+      }
+    };
+    const status = async (text) => {
+      await appendStatus(text);
+      await flushStatus();
     };
     const applySection = async (authorizedPatch) => {
       const sourcePatch = authorizedPatch.patch;
       if (sourcePatch.unlocated) {
-        if (options.atomic) throw new ToolError2("no file to patch; provide a target or Index header", 1);
+        if (options.atomic) throw new ToolError3("no file to patch; provide a target or Index header", 1);
         await status(`No file to patch.  Skipping patch.
 ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
 `);
@@ -584,7 +719,7 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
       activePath = path;
       const pruning = pruneParents(name, context.cwd).filter((parent) => parent !== context.cwd);
       if (!options.dryRun) await publication.capture(path, pruning);
-      if (path === paths.input || backupPaths.has(path) || rejectPaths.has(path)) throw new ToolError2(`patch target aliases input or an earlier output: ${path}`);
+      if (path === paths.input || backupPaths.has(path) || rejectPaths.has(path)) throw new ToolError3(`patch target aliases input or an earlier output: ${path}`);
       targets.add(path);
       const prior = options.atomic ? staged.get(path) : void 0;
       const stat = await inspect(budget, path);
@@ -596,12 +731,12 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
           await status(`File ${name} is read-only; ${refuse ? "refusing to patch" : "trying to patch anyway"}
 `);
           if (refuse) {
-            if (options.atomic) throw new ToolError2(`read-only target: ${name}`, 1);
+            if (options.atomic) throw new ToolError3(`read-only target: ${name}`, 1);
             const destination = rejectName(outputToStdout ? "-" : name, paths);
             const rejectPath2 = options.dryRun || destination === void 0 ? void 0 : resolvePath(context.cwd, destination);
             if (rejectPath2 !== void 0) {
               await authorizeOutputs([rejectPath2], targets, paths.input, budget);
-              if (backupPaths.has(rejectPath2)) throw new ToolError2("reject path aliases another section's backup");
+              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,
@@ -613,7 +748,7 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
                 offset: 0,
                 fuzz: 0
               }));
-              const reject2 = await rejectText(sourcePatch, outcomes2, authorizedPatch.oldName, authorizedPatch.newName, authorizedPatch.indexName, options.reverse, budget, options.rejectFormat);
+              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;
               await publish({ path, original: original2, result: original2, remove: false, skipWrite: true, rejectPath: rejectPath2, reject: reject2, parents: [] }, budget, rejects, publication, documents);
@@ -640,7 +775,7 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
       }
       const applied = await applyContent(sourcePatch, current, exists, options, budget, documents);
       if (!applied) {
-        if (options.atomic) throw new ToolError2(`patch target does not exist: ${path}`, 1);
+        if (options.atomic) throw new ToolError3(`patch target does not exist: ${path}`, 1);
         await status(`No file to patch.  Skipping patch ${name}.
 ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
 `);
@@ -657,17 +792,17 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
       }
       const failed = outcomes.filter((outcome) => outcome.failed);
       const conflict = failed.length > 0 || deletion && result.size !== 0;
-      if (options.atomic && conflict) throw new ToolError2(failed.length ? `hunk ${failed[0].index} does not match ${name}` : `deletion patch leaves content: ${name}`, 1);
+      if (options.atomic && conflict) throw new ToolError3(failed.length ? `hunk ${failed[0].index} 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 rejected = rejectPath === void 0 ? void 0 : await rejectText(sourcePatch, outcomes, authorizedPatch.oldName, authorizedPatch.newName, authorizedPatch.indexName, reversed, budget, options.rejectFormat);
+      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)) {
-        throw new ToolError2("reject path aliases another section's backup");
+        throw new ToolError3("reject path aliases another section's backup");
       }
       if (backupPath !== void 0) backupPaths.add(backupPath);
       if (rejectPath !== void 0) rejectPaths.add(rejectPath);
@@ -686,7 +821,7 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
           else if (!options.force && mismatch) timeMessage = `Not setting time of file ${name} (contents mismatch)
 `;
           else {
-            if (!options.dryRun && !context.fs.utimes) throw new ToolError2("filesystem does not support setting timestamps");
+            if (!options.dryRun && !context.fs.utimes) throw new ToolError3("filesystem does not support setting timestamps");
             mtimeMs = newTime;
           }
         }
@@ -706,38 +841,38 @@ ${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
         parents: remove ? pruning : []
       };
       const displayName = quotePatchName(name, options.quotingStyle);
-      let message = options.quiet ? "" : `${options.dryRun ? "checking" : "patching"} file ${output === void 0 ? displayName : `${quotePatchName(output, options.quotingStyle)} (read from ${displayName})`}
-`;
+      budget.outputLength(result.size);
+      if (backup !== void 0) budget.outputLength(backup.size);
       if (options.verbose) {
         const format = sourcePatch.format ?? "unified";
         const headers = sourcePatch.oldHeader === void 0 ? "" : `|${format === "context" ? "***" : "---"} ${sourcePatch.oldHeader}
 |${format === "context" ? "---" : "+++"} ${sourcePatch.newHeader}
 `;
-        message = `Hmm...  Looks like a ${format} diff to me...
+        await appendStatus(`Hmm...  Looks like a ${format} diff to me...
 The text leading up to this was:
 --------------------------
 ${headers}--------------------------
-` + message;
+`);
       }
-      if (autoReversed) message += "Reversed (or previously applied) patch detected!  Assuming -R.\n";
+      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) {
-        if (outcome.misordered) message += "misordered hunks! output would be garbled\n";
+        if (outcome.misordered) await appendStatus("misordered hunks! output would be garbled\n");
         if (options.quiet) continue;
-        if (outcome.failed && options.merge) message += `Hunk #${outcome.index} NOT MERGED at ${outcome.mergeRange?.[0] ?? outcome.line}-${outcome.mergeRange?.[1] ?? outcome.line}.
-`;
-        else if (outcome.failed) message += `Hunk #${outcome.index} FAILED at ${outcome.line}.
-`;
-        else if (options.verbose || outcome.offset || outcome.fuzz) message += `Hunk #${outcome.index} succeeded at ${outcome.line}${outcome.fuzz ? ` with fuzz ${outcome.fuzz}` : ""}${outcome.offset ? ` (offset ${outcome.offset} ${outcome.offset === 1 ? "line" : "lines"})` : ""}.
-`;
+        if (outcome.failed && options.merge) await appendStatus(`Hunk #${outcome.index} NOT MERGED at ${outcome.mergeRange?.[0] ?? outcome.line}-${outcome.mergeRange?.[1] ?? outcome.line}.
+`);
+        else if (outcome.failed) await appendStatus(`Hunk #${outcome.index} FAILED at ${outcome.line}.
+`);
+        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) message += `${failed.length} 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) message += `Not deleting file ${name} as content differs from patch
-`;
-      message += timeMessage;
-      budget.outputLength(result.size);
-      if (backup !== void 0) budget.outputLength(backup.size);
-      await status(message);
+      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 (deletion && result.size !== 0) await appendStatus(`Not deleting file ${name} as content differs from patch
+`);
+      await appendStatus(timeMessage);
+      await flushStatus();
       touched.add(path);
       if (options.atomic) {
         if (outputToStdout) stdoutItems.push(item);
@@ -761,7 +896,7 @@ ${headers}--------------------------
       } catch (error) {
         context.signal.throwIfAborted();
         if (committed === 0 && !publishing) throw error;
-        throw new ToolError2(`commit stopped; ${committed}/${authorized.length} files committed; failing operation may have side effects; path ${activePath}: ${publicDiagnosticMessage(error, budget.context.onInternalError)}`);
+        throw new ToolError3(`commit stopped; ${committed}/${authorized.length} files committed; failing operation may have side effects; path ${activePath}: ${publicDiagnosticMessage(error, budget.context.onInternalError)}`);
       }
     }
     if (options.atomic && (!options.dryRun || outputToStdout)) {
@@ -774,18 +909,18 @@ ${headers}--------------------------
           committed++;
         } catch (error) {
           context.signal.throwIfAborted();
-          throw new ToolError2(`commit stopped; ${committed}/${prepared.length} files committed; failing operation may have side effects; path ${item.path}: ${publicDiagnosticMessage(error, budget.context.onInternalError)}`);
+          throw new ToolError3(`commit stopped; ${committed}/${prepared.length} files committed; failing operation may have side effects; path ${item.path}: ${publicDiagnosticMessage(error, budget.context.onInternalError)}`);
         }
         for (const parent of item.parents) parents.add(parent);
       }
     }
     if (!options.dryRun) await pruneDirectories(parents, budget);
     if (options.verbose) await status("done\n");
-    if (options.atomic && (!options.quiet || messages.length)) await writeBytes(statusSink, encodeBytes(messages.join("")), context.signal);
+    await flushStatus(true);
     if (progress?.error) throw progress.error;
     return exitCode;
   } finally {
-    await documents.close();
+    await closeDocumentResources2([messages, documents]);
   }
 }
 function patchCommand(options = {}) {