@poe-platform/safe-bash 0.1.809 → 0.1.811

package/dist/safe-bash/command-chunks/chunk-72C3TZ2U.js

@@ -0,0 +1,826 @@
+import {
+  PatchPublication,
+  TargetDocuments,
+  TargetOutput,
+  equalTargetLines,
+  targetBytes
+} from "./chunk-WH3TIOTS.js";
+import {
+  unwrapPatch
+} from "./chunk-JKLOBSMP.js";
+import {
+  parsePatch
+} from "./chunk-2VLAXKTS.js";
+import {
+  reversePatch,
+  startIndex
+} from "./chunk-MOZD7RUY.js";
+import {
+  authorizeOutputs,
+  authorizePaths,
+  backupName,
+  candidateStat,
+  ensureParents,
+  pruneDirectories,
+  pruneParents,
+  regular,
+  rejectName,
+  selectTarget
+} from "./chunk-OQNX2OOS.js";
+import {
+  safeTarget
+} from "./chunk-AJEQUVDN.js";
+import {
+  rejectText
+} from "./chunk-JYTESTBS.js";
+
+// packages/safe-bash-command-patch/src/stored-hunks.ts
+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) {
+    return index >= 0 && index < original.length ? { document: original, index } : void 0;
+  } };
+  budget.countLines(source.length);
+  const result = new TargetOutput(documents);
+  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 !== "+");
+      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++;
+      const expected = startIndex(hunk.oldStart, hunk.oldCount) + offset;
+      let found = -1;
+      let misordered = false;
+      let usedFuzz = 0;
+      const context = Math.max(leading, trailing);
+      const matches = async (position, prefixFuzz, suffixFuzz) => {
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          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;
+          const actual = source.at(position + lineIndex);
+          if (actual === void 0) return false;
+          const expectedLine = oldLines[lineIndex].text;
+          if (!await equalTargetLines(actual, expectedLine, budget, ignoreWhitespace)) return false;
+          {
+            const c = budget.checkpoint();
+            if (c) await c;
+          }
+        }
+        if (position < cursor) misordered = true;
+        return true;
+      };
+      let matchedPrefixFuzz = 0;
+      let matchedSuffixFuzz = 0;
+      for (let tolerance = 0; tolerance <= Math.min(fuzz, context); tolerance++) {
+        if (application.rejectAll) break;
+        usedFuzz = tolerance;
+        const prefixFuzz = tolerance + leading - context;
+        const suffixFuzz = tolerance + trailing - context;
+        if (prefixFuzz < 0 && hunk.oldStart <= 1) {
+          if (await matches(0, 0, suffixFuzz)) {
+            found = 0;
+            matchedPrefixFuzz = 0;
+            matchedSuffixFuzz = suffixFuzz;
+          }
+          if (found >= 0) break;
+          continue;
+        }
+        if (suffixFuzz < 0) {
+          const end = source.length - hunk.oldCount;
+          if (await matches(end, Math.max(0, prefixFuzz), 0)) {
+            found = end;
+            matchedPrefixFuzz = Math.max(0, prefixFuzz);
+            matchedSuffixFuzz = 0;
+          }
+          if (found >= 0) break;
+          continue;
+        }
+        const retained = oldLines.length - Math.max(0, prefixFuzz) - suffixFuzz;
+        if (retained === 0) {
+          if (await matches(expected, Math.max(0, prefixFuzz), suffixFuzz)) {
+            found = expected;
+            matchedPrefixFuzz = Math.max(0, prefixFuzz);
+            matchedSuffixFuzz = suffixFuzz;
+            break;
+          }
+          continue;
+        }
+        const maximum = source.length - hunk.oldCount + suffixFuzz;
+        const positiveLimit = maximum - expected;
+        const negativeLimit = Math.min(expected - cursor, expected);
+        const distanceLimit = Math.max(positiveLimit, negativeLimit);
+        const firstDistance = positiveLimit < 0 ? -positiveLimit : negativeLimit < 0 ? negativeLimit : 0;
+        for (let distance = firstDistance; distance <= distanceLimit; distance++) {
+          if (distance <= positiveLimit && await matches(expected + distance, Math.max(0, prefixFuzz), suffixFuzz)) {
+            found = expected + distance;
+            matchedPrefixFuzz = Math.max(0, prefixFuzz);
+            matchedSuffixFuzz = suffixFuzz;
+            break;
+          }
+          if (distance <= negativeLimit && await matches(expected - distance, Math.max(0, prefixFuzz), suffixFuzz)) {
+            found = expected - distance;
+            matchedPrefixFuzz = Math.max(0, prefixFuzz);
+            matchedSuffixFuzz = suffixFuzz;
+            break;
+          }
+        }
+        if (found >= 0) break;
+      }
+      const matched = found;
+      if (matched >= 0) offset = matched - startIndex(hunk.oldStart, hunk.oldCount);
+      if (misordered) found = -1;
+      application.outcomes?.push({
+        hunk,
+        index: hunkIndex + 1,
+        failed: found < 0,
+        misordered: found < 0 && misordered,
+        line: (matched < 0 ? startIndex(hunk.oldStart, hunk.oldCount) : matched) + 1 + outputOffset,
+        outputOffset,
+        offset: matched - startIndex(hunk.oldStart, hunk.oldCount),
+        fuzz: usedFuzz
+      });
+      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 anchored = false;
+        for (let index = 0; index < oldLines.length; index++) {
+          if (await equalTargetLines(oldLines[index].text, local[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);
+        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++;
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+        for (const line of local.slice(0, prefix)) await result.append(line);
+        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);
+        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);
+        } else {
+          await result.append("<<<<<<<\n");
+          for (const line of local.slice(prefix, local.length - suffix)) await result.append(line);
+          if (application.merge === "diff3") {
+            await result.append("|||||||\n");
+            for (const line of base.slice(prefix, base.length - suffix)) await result.append(line);
+          }
+          await result.append("=======\n");
+          for (const line of incoming.slice(prefix, incoming.length - suffix)) await result.append(line);
+          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;
+        outputOffset = result.length - cursor;
+        continue;
+      }
+      if (found < 0) {
+        if (application.partial) continue;
+        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;
+        if (application.ifdef) {
+          await result.append(`#${removed.length ? "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 = [];
+      };
+      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();
+          if (cursor < source.length) await result.append(source.at(cursor++));
+        } else {
+          removed.push(source.at(cursor) ?? line.text);
+          cursor++;
+        }
+      }
+      await flush();
+      outputOffset = result.length - cursor;
+    }
+    while (cursor < source.length) await result.append(source.at(cursor++));
+    return await result.finish();
+  } finally {
+    await result.close();
+  }
+}
+
+// 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";
+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 = [];
+  const select = (format) => {
+    result.format = format;
+  };
+  const versionControl = (parameter) => {
+    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}`);
+  };
+  let literal = false;
+  let backupSelected = false;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    const value = (attached, name) => {
+      const next = attached ?? args[++index];
+      if (next === void 0) throw new ToolError2(`${name} requires an argument`);
+      return next;
+    };
+    if (literal || arg === "-" || !arg.startsWith("-")) operands.push(arg);
+    else if (arg === "--") literal = true;
+    else if (arg === "--dry-run") result.dryRun = true;
+    else if (arg === "--atomic") result.atomic = true;
+    else if (arg === "--quiet" || arg === "--silent") {
+      result.quiet = true;
+      result.verbose = false;
+    } else if (arg === "--force") result.force = true;
+    else if (arg === "--batch") continue;
+    else if (arg === "--binary") continue;
+    else if (arg === "--posix") result.posix = true;
+    else if (arg === "--verbose") {
+      result.verbose = true;
+      result.quiet = false;
+    } else if (arg === "--set-time") result.setTime ??= "local";
+    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}`);
+      result.merge = style;
+    } else if (arg === "--backup") result.alwaysBackup = true;
+    else if (arg === "--forward") result.forward = true;
+    else if (arg === "--no-backup-if-mismatch") {
+      result.backup = false;
+      backupSelected = true;
+    } else if (arg === "--backup-if-mismatch") {
+      result.backup = true;
+      backupSelected = true;
+    } else if (arg === "--reverse") result.reverse = true;
+    else if (arg === "--remove-empty-files") result.removeEmpty = true;
+    else if (arg === "--ignore-whitespace" || arg === "--ignore-white-space") result.ignoreWhitespace = true;
+    else if (arg === "--unified") select("unified");
+    else if (arg === "--context") select("context");
+    else if (arg === "--normal") select("normal");
+    else if (["--strip", "--input", "--fuzz", "--reject-file", "--output", "--directory", "--get", "--suffix", "--prefix", "--basename-prefix", "--version-control", "--ifdef", "--quoting-style", "--reject-format", "--read-only"].includes(arg.split("=")[0])) {
+      const [name] = arg.split("=");
+      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}`);
+        result.quotingStyle = parameter;
+      } else if (name === "--reject-format") {
+        if (parameter !== "unified" && parameter !== "context") throw new ToolError2(`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}`);
+        result.readOnly = parameter;
+      } else if (name === "--strip") result.strip = integer(parameter, "strip count");
+      else if (name === "--fuzz") result.fuzz = integer(parameter, "fuzz");
+      else if (name === "--reject-file") result.reject = parameter;
+      else if (name === "--output") result.output = parameter;
+      else if (name === "--directory") result.directory = parameter;
+      else if (name === "--suffix") result.suffix = parameter;
+      else if (name === "--prefix") result.prefix = parameter;
+      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");
+      } else result.input = parameter;
+    } else if (arg.startsWith("--")) throw new ToolError2(`unsupported option: ${arg}`);
+    else for (let offset = 1; offset < arg.length; offset++) {
+      const flag = arg[offset];
+      if (flag === "R") result.reverse = true;
+      else if (flag === "s") {
+        result.quiet = true;
+        result.verbose = false;
+      } else if (flag === "f") result.force = true;
+      else if (flag === "t") continue;
+      else if (flag === "T") result.setTime ??= "local";
+      else if (flag === "Z") result.setTime = "utc";
+      else if (flag === "b") result.alwaysBackup = true;
+      else if (flag === "N") result.forward = true;
+      else if (flag === "E") result.removeEmpty = true;
+      else if (flag === "l") result.ignoreWhitespace = true;
+      else if (flag === "u") select("unified");
+      else if (flag === "c") select("context");
+      else if (flag === "n") select("normal");
+      else if (["p", "i", "F", "r", "o", "d", "g", "z", "B", "Y", "V", "D"].includes(flag)) {
+        const parameter = value(arg.slice(offset + 1) || void 0, `-${flag}`);
+        if (flag === "D") result.ifdef = parameter;
+        else if (flag === "p") result.strip = integer(parameter, "strip count");
+        else if (flag === "F") result.fuzz = integer(parameter, "fuzz");
+        else if (flag === "r") result.reject = parameter;
+        else if (flag === "o") result.output = parameter;
+        else if (flag === "d") result.directory = parameter;
+        else if (flag === "z") result.suffix = parameter;
+        else if (flag === "B") result.prefix = parameter;
+        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");
+        } else result.input = parameter;
+        break;
+      } else throw new ToolError2(`unsupported option: -${flag}`);
+    }
+  }
+  if (operands.length > 2) throw new ToolError2("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.merge) result.fuzz = 0;
+  if (result.posix && !backupSelected) result.backup = false;
+  return result;
+}
+async function applyContent(sourcePatch, current, exists, options, budget, documents) {
+  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 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);
+  if (!options.force && (declaredCreation && current.size !== 0 || declaredDeletion && !exists)) {
+    patch = reversePatch(patch);
+    reversed = !reversed;
+    autoReversed = true;
+  }
+  if (!creation() && !exists) return void 0;
+  let outcomes = [];
+  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
+  }, 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);
+    await documents.release(probeResult);
+    if (!probe[0]?.failed) {
+      patch = opposite;
+      reversed = !reversed;
+      autoReversed = true;
+      reverseMismatch = true;
+      outcomes = [];
+      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
+      }, documents);
+    }
+  }
+  const deletion = patch.newPath === "/dev/null" || patch.newEpoch && patch.hunks.every((hunk) => hunk.newCount === 0 && hunk.newStart === 0);
+  if (autoReversed && options.forward) {
+    await documents.release(result);
+    return { result: current, outcomes: [], reversed, autoReversed, reverseMismatch, deletion: false, skipped: true };
+  }
+  return { result, outcomes, reversed, autoReversed, reverseMismatch, deletion };
+}
+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);
+  }
+  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);
+  }
+  for (const path of [item.backupPath, item.rejectPath]) {
+    if (path !== void 0) regular(await inspect(budget, path), path);
+  }
+  for (const parent of item.parents) await inspect(budget, parent);
+}
+async function publish(item, budget, rejects, publication, documents) {
+  const context = budget.context;
+  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)}`);
+    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");
+    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);
+  };
+  if (item.backup !== void 0 && item.backupPath !== void 0) await write(item.backupPath, item.backup, false, true, item.backupMode);
+  if (item.remove) {
+    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);
+      await publication.remove(item.path, expected);
+    }
+  } else if (!item.skipWrite) {
+    await write(item.path, item.result, false, true, void 0, item.mtimeMs);
+  }
+  if (item.rejectPath !== void 0 && item.reject !== void 0) {
+    await write(item.rejectPath, item.reject, rejects.has(item.rejectPath), false);
+    rejects.add(item.rejectPath);
+  }
+}
+async function run(context, budget) {
+  const options = flags(context.args);
+  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}`);
+    context = { ...context, cwd };
+    budget = new Budget2(context, Object.fromEntries(Object.entries(budget.limits).filter(([, value]) => Number.isFinite(value))));
+  }
+  let publication = new PatchPublication(context);
+  if (!options.dryRun) {
+    const fs = context.fs;
+    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");
+    }
+    publication = new PatchPublication(context, trusted);
+    await publication.capture(`${context.cwd === "/" ? "" : context.cwd}/.patch-admission`);
+    const confined = trusted ? fs : await host(context, () => fs.confineExtraction([context.cwd], { signal: context.signal }));
+    context = { ...context, fs: new Proxy(fs, {
+      get(target, property) {
+        if (trusted && property === "mkdir") return (path) => publication.mkdir(path);
+        if (property === "rmdir") return (path) => publication.prune(path);
+        const selected = ["mkdir", "rm"].includes(String(property)) ? confined : target;
+        const value = Reflect.get(selected, property, selected);
+        return typeof value === "function" ? value.bind(selected) : value;
+      }
+    }) };
+    budget = new Budget2(context, Object.fromEntries(Object.entries(budget.limits).filter(([, value]) => Number.isFinite(value))));
+  }
+  const documents = new TargetDocuments(budget);
+  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");
+    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.input !== "-") {
+      const stat = await inspect(budget, options.input);
+      if (stat?.type !== "file") throw new ToolError2("patch input must be a regular file");
+    }
+    const input = await budget.read(options.input === "-" ? "-" : resolvePath(context.cwd, options.input));
+    const progress = options.atomic ? void 0 : {};
+    const sections = await parsePatch(await unwrapPatch(input, budget), budget, options.format, explicit, progress);
+    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");
+    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 -");
+    const paths = {
+      strip: options.strip,
+      explicit,
+      reject,
+      posix: options.posix,
+      input: options.input === "-" ? void 0 : resolvePath(context.cwd, options.input)
+    };
+    const preview = /* @__PURE__ */ new Map();
+    const previewParents = /* @__PURE__ */ new Set();
+    const authorized = await authorizePaths(parsed, paths, budget, !options.dryRun || options.atomic ? {
+      reverse: options.atomic && options.reverse,
+      exists: async (path) => preview.has(path) ? preview.get(path) !== void 0 : previewParents.has(path) || await candidateStat(path, budget) !== void 0,
+      advance: async (item) => {
+        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);
+        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);
+        preview.set(path, remove ? void 0 : applied.result);
+        if (!remove) for (let parent = dirname(path); parent !== "/"; parent = dirname(parent)) previewParents.add(parent);
+      }
+    } : void 0);
+    for (const document of preview.values()) if (document) await documents.release(document);
+    preview.clear();
+    const targets = new Set(authorized.flatMap((item) => item.selected === void 0 ? [] : [resolvePath(context.cwd, item.selected)]));
+    if (outputPath !== void 0) await authorizeOutputs([outputPath], targets, paths.input, budget);
+    const staged = /* @__PURE__ */ new Map();
+    const stdoutItems = [];
+    const stagedParents = /* @__PURE__ */ new Set();
+    const touched = /* @__PURE__ */ new Set();
+    const rejects = /* @__PURE__ */ new Set();
+    const backupPaths = /* @__PURE__ */ new Set();
+    const rejectPaths = /* @__PURE__ */ new Set();
+    const parents = /* @__PURE__ */ new Set();
+    const messages = [];
+    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) => {
+      if (!text) return;
+      budget.output(text);
+      if (options.atomic) messages.push(text);
+      else await writeBytes(statusSink, encodeBytes(text), context.signal);
+    };
+    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);
+        await status(`No file to patch.  Skipping patch.
+${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
+`);
+        exitCode = 1;
+        return;
+      }
+      const name = await selectTarget(authorizedPatch, async (path2) => options.atomic && staged.has(path2) ? !staged.get(path2).remove : options.atomic && stagedParents.has(path2) || await candidateStat(path2, budget) !== void 0, budget);
+      const path = resolvePath(context.cwd, name);
+      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}`);
+      targets.add(path);
+      const prior = options.atomic ? staged.get(path) : void 0;
+      const stat = await inspect(budget, path);
+      regular(stat, path);
+      if (stat && options.readOnly !== "ignore") {
+        const capabilities = await host(context, async () => await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities);
+        if (capabilities?.permissions !== false && !(stat.mode & 146)) {
+          const refuse = options.readOnly === "fail";
+          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);
+            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");
+              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 reject2 = await rejectText(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);
+              committed++;
+              publishing = false;
+              rejectPaths.add(rejectPath2);
+            }
+            await status(`${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} ${sourcePatch.hunks.length === 1 ? "hunk" : "hunks"} ignored${rejectPath2 === void 0 ? "" : ` -- saving rejects to file ${destination}`}
+`);
+            exitCode = 1;
+            return;
+          }
+        }
+      }
+      const exists = prior ? !prior.remove : stat !== void 0;
+      const original = prior ? prior.original : stat ? await documents.read(path) : void 0;
+      const current = prior ? prior.remove ? empty : prior.result : original ?? empty;
+      if (options.posix && !exists) {
+        await status(`No file to patch.  Skipping patch.
+${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
+`);
+        exitCode = 1;
+        return;
+      }
+      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);
+        await status(`No file to patch.  Skipping patch ${name}.
+${sourcePatch.hunks.length} out of ${sourcePatch.hunks.length} hunks ignored
+`);
+        exitCode = 1;
+        return;
+      }
+      const { result, outcomes, reversed, autoReversed, reverseMismatch, deletion } = applied;
+      if (applied.skipped) {
+        await status(`Reversed (or previously applied) patch detected!  Skipping patch.
+${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 ToolError2(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);
+      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");
+      }
+      if (backupPath !== void 0) backupPaths.add(backupPath);
+      if (rejectPath !== void 0) rejectPaths.add(rejectPath);
+      const remove = options.ifdef === void 0 && output === void 0 && result.size === 0 && (!options.posix && deletion || options.removeEmpty);
+      const outputPrior = outputPath === void 0 ? void 0 : staged.get(outputPath);
+      const outputOriginal = outputPath === void 0 ? original : outputPrior ? outputPrior.original : await inspect(budget, outputPath) ? await documents.read(outputPath) : void 0;
+      if (outputPath !== void 0) outputContents = await documents.concat(outputContents, result);
+      let mtimeMs;
+      let timeMessage = "";
+      if (options.setTime) {
+        const oldTime = patchTimestamp(reversed ? sourcePatch.newHeader : sourcePatch.oldHeader, options.setTime);
+        const newTime = patchTimestamp(reversed ? sourcePatch.oldHeader : sourcePatch.newHeader, options.setTime);
+        if (newTime !== void 0) {
+          if (!options.force && stat && oldTime !== void 0 && oldTime !== stat.mtimeMs) timeMessage = `Not setting time of file ${name} (time mismatch)
+`;
+          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");
+            mtimeMs = newTime;
+          }
+        }
+      }
+      const item = {
+        path: outputPath ?? path,
+        original: outputOriginal,
+        result: outputPath === void 0 ? result : outputContents,
+        remove,
+        ...outputToStdout ? { skipWrite: true } : {},
+        ...outputPath === void 0 ? {} : { sourcePath: path, ...original === void 0 ? {} : { sourceOriginal: original } },
+        ...backup === void 0 ? prior?.backup === void 0 ? {} : { backup: prior.backup } : { backup },
+        ...backupPath === void 0 ? {} : { backupPath },
+        ...prior?.backupMode !== void 0 ? { backupMode: prior.backupMode } : backup !== void 0 && stat ? { backupMode: stat.mode & 4095 } : {},
+        ...mtimeMs === void 0 ? {} : { mtimeMs },
+        ...rejectPath === void 0 ? {} : { rejectPath, reject: rejected },
+        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})`}
+`;
+      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...
+The text leading up to this was:
+--------------------------
+${headers}--------------------------
+` + message;
+      }
+      if (autoReversed) message += "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 (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 (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);
+      touched.add(path);
+      if (options.atomic) {
+        if (outputToStdout) stdoutItems.push(item);
+        else {
+          staged.set(item.path, item);
+          if (!remove) for (let parent = dirname(path); parent !== "/"; parent = dirname(parent)) stagedParents.add(parent);
+        }
+      } else if (!options.dryRun || outputToStdout) {
+        publishing = true;
+        if (!options.dryRun) await publish(item, budget, rejects, publication, documents);
+        if (outputToStdout) await pipeBytes(result.range(0, result.size), context.stdout, context.signal);
+        committed++;
+        publishing = false;
+        for (const parent of item.parents) parents.add(parent);
+      }
+    };
+    for (const authorizedPatch of options.atomic && options.reverse ? authorized.slice().reverse() : authorized) {
+      activePath = authorizedPatch.selected === void 0 ? void 0 : resolvePath(context.cwd, authorizedPatch.selected);
+      try {
+        await applySection(authorizedPatch);
+      } 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)}`);
+      }
+    }
+    if (options.atomic && (!options.dryRun || outputToStdout)) {
+      const prepared = outputToStdout ? stdoutItems : [...staged.values()].filter((item) => !(item.remove && item.original === void 0));
+      for (const item of prepared) await unchanged(item, budget, documents);
+      for (const item of prepared) {
+        try {
+          if (!options.dryRun) await publish(item, budget, rejects, publication, documents);
+          if (outputToStdout) await pipeBytes(item.result.range(0, item.result.size), context.stdout, context.signal);
+          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)}`);
+        }
+        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);
+    if (progress?.error) throw progress.error;
+    return exitCode;
+  } finally {
+    await documents.close();
+  }
+}
+function patchCommand(options = {}) {
+  return definition("patch", options, run);
+}
+function patchTimestamp(header, zone) {
+  const separator = header?.indexOf("	") ?? -1;
+  if (separator < 0) return void 0;
+  let text = header.slice(separator + 1).trim();
+  const parts = text.split(" ").filter(Boolean);
+  if (zone === "utc" && parts.length === 2) text += " +0000";
+  const time = Date.parse(text);
+  return Number.isFinite(time) ? time : void 0;
+}
+function quotePatchName(name, style = "shell") {
+  const safe = [...name].every((c) => "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_./-".includes(c));
+  if (style === "literal" || safe && !["shell-always", "shell-escape-always", "c", "locale", "clocale"].includes(style)) return name;
+  if (style === "c" || style === "clocale") return JSON.stringify(name);
+  if (style === "locale") return `\u2018${name}\u2019`;
+  if (style === "escape") return JSON.stringify(name).slice(1, -1);
+  return `'${name.replaceAll("'", "'\\''")}'`;
+}
+async function sameTarget(path, right, documents) {
+  const left = await documents.read(path);
+  try {
+    if (left.size !== right.size || left.length !== right.length) return false;
+    for (let index = 0; index < left.length; index++) {
+      if (!await equalTargetLines({ document: left, index }, { document: right, index }, documents.budget)) return false;
+    }
+    return true;
+  } finally {
+    await documents.release(left);
+  }
+}
+
+export {
+  patchCommand
+};