@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/command-chunks/chunk-5ZMZ573Q.js

@@ -0,0 +1,140 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-find/src/find-format.ts
+init_buffer();
+import { shellValueBytes } from "../../safe-bash-contracts/value.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { output, UsageError } from "../../safe-bash-io-engine/internal.js";
+var controls = { 97: 7, 98: 8, 102: 12, 110: 10, 114: 13, 116: 9, 118: 11, 92: 92 };
+var FindFormatBudget = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  untilYield = 4096;
+  step(count = 1) {
+    this.context.signal.throwIfAborted();
+    this.untilYield -= count;
+    if (this.untilYield > 0) return;
+    this.untilYield = 4096;
+    return yieldTurn(this.context.signal);
+  }
+  async write(bytes) {
+    for (let offset = 0; offset < bytes.length; offset += 4096) {
+      const chunk = bytes.subarray(offset, offset + 4096);
+      {
+        const s = this.step(chunk.length);
+        if (s) await s;
+      }
+      await output(this.context, chunk);
+    }
+  }
+  async text(text) {
+    for (let offset = 0; offset < text.length; ) {
+      let end = Math.min(text.length, offset + 1024);
+      if (end < text.length && text.charCodeAt(end - 1) >= 55296 && text.charCodeAt(end - 1) <= 56319) end--;
+      const part = text.slice(offset, end);
+      await this.write(encodeBytes(part));
+      offset = end;
+    }
+  }
+};
+async function field(entry, code, budget) {
+  if (code === "p") return entry.display;
+  if (code === "P") return entry.relative;
+  if (code === "H") return entry.root;
+  if (code === "s") return String(entry.stat.size);
+  if (code === "d") return String(entry.depth);
+  if (code === "y") return { file: "f", directory: "d", symlink: "l", character: "c" }[entry.stat.type];
+  let end = entry.display.length;
+  while (end > 1 && entry.display[end - 1] === "/") {
+    {
+      const s = budget.step();
+      if (s) await s;
+    }
+    end--;
+  }
+  let slash = end - 1;
+  while (slash >= 0 && entry.display[slash] !== "/") {
+    {
+      const s = budget.step();
+      if (s) await s;
+    }
+    slash--;
+  }
+  const start = code === "f" ? slash + 1 : 0;
+  const finish = code === "f" ? end : slash === 0 ? 1 : slash;
+  if (code === "f" && end === 1 && entry.display[0] === "/") return "/";
+  if (code === "h" && slash < 0) return ".";
+  for (let offset = start; offset < finish; offset += 4096) await budget.step(Math.min(4096, finish - offset));
+  return entry.display.slice(start, finish);
+}
+async function compileFindFormat(value, budget) {
+  const source = shellValueBytes(value);
+  const parts = [];
+  let literal = 0;
+  let index = 0;
+  const flush = () => {
+    if (index > literal) parts.push({ start: literal, end: index });
+  };
+  while (index < source.length) {
+    {
+      const s = budget.step();
+      if (s) await s;
+    }
+    const byte = source[index];
+    if (byte !== 37 && byte !== 92) {
+      index++;
+      continue;
+    }
+    flush();
+    const next = source[++index];
+    if (byte === 37) {
+      if (next === 37) parts.push({ byte: 37 });
+      else if (next !== void 0 && "pfhsdPHy".includes(String.fromCharCode(next))) parts.push({ directive: String.fromCharCode(next) });
+      else throw new UsageError("unsupported printf format directive or modifier");
+      index++;
+    } else {
+      if (next === 99) {
+        literal = source.length;
+        break;
+      }
+      if (next !== void 0 && Object.hasOwn(controls, next)) {
+        parts.push({ byte: controls[next] });
+        index++;
+      } else if (next !== void 0 && next >= 48 && next <= 55) {
+        let value2 = 0;
+        const end = Math.min(source.length, index + 3);
+        while (index < end && source[index] >= 48 && source[index] <= 55) {
+          {
+            const s = budget.step();
+            if (s) await s;
+          }
+          value2 = value2 * 8 + source[index++] - 48;
+        }
+        parts.push({ byte: value2 & 255 });
+      } else throw new UsageError("unsupported printf format escape");
+    }
+    literal = index;
+  }
+  if (literal < source.length && index > literal) parts.push({ start: literal, end: index });
+  return async (entry) => {
+    for (const part of parts) {
+      {
+        const s = budget.step();
+        if (s) await s;
+      }
+      if ("directive" in part) await budget.text(await field(entry, part.directive, budget));
+      else if ("byte" in part) await budget.write(Uint8Array.of(part.byte));
+      else await budget.write(source.subarray(part.start, part.end));
+    }
+  };
+}
+
+export {
+  FindFormatBudget,
+  compileFindFormat
+};

package/dist/safe-bash/command-chunks/{chunk-3NG75MOB.js → chunk-67GQA75T.js}

@@ -2,7 +2,7 @@ import {
   HexdumpError,
   bytes,
   pathText
-} from "./chunk-KKG4BAFZ.js";
+} from "./chunk-DIEPXUM4.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-67QKREJK.js

@@ -0,0 +1,347 @@
+import {
+  decodeHeaderPath,
+  isEpochHeader
+} from "./chunk-DOKKNRRM.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/unified.ts
+init_buffer();
+import { ToolError, integer } from "../../safe-bash-diff-engine/shared.js";
+import { byteLength } from "../../safe-bash-io-engine/byte-encoding.js";
+function header(line, prefix) {
+  if (!line.startsWith(prefix)) throw new ToolError(`expected ${prefix.trim()} file header`);
+  const path = decodeHeaderPath(line.slice(prefix.length));
+  if (!path || /[\0\r\n]/u.test(path)) throw new ToolError("unsupported or empty patch filename");
+  return path;
+}
+function startIndex(start, count) {
+  return count === 0 ? start : start - 1;
+}
+async function parseUnified(text, budget) {
+  if (text && !text.endsWith("\n")) throw new ToolError("patch is truncated: missing final LF");
+  return parseUnifiedReader({ lines: budget.split(text).map((line) => line.slice(0, -1)), index: 0 }, budget, false);
+}
+async function parseUnifiedSection(cursor, budget) {
+  return parseUnifiedReader(cursor, budget, true);
+}
+async function parseUnifiedReader(cursor, budget, single) {
+  const physical = cursor.lines;
+  const patches = [];
+  let index = cursor.index;
+  let pendingMetadata = false;
+  while (index < physical.length) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    const line = physical[index];
+    if (line === "") {
+      index++;
+      continue;
+    }
+    if (/^diff (?:--git |-[^ ]+ )/u.test(line) || /^index [0-9a-f]+\.\.[0-9a-f]+(?: 100(?:644|755))?$/u.test(line) || /^(?:new file|deleted file) mode 100(?:644|755)$/u.test(line)) {
+      pendingMetadata = true;
+      index++;
+      continue;
+    }
+    const oldPath = header(line, "--- ");
+    const oldHeader = line.slice(4);
+    const oldEpoch = isEpochHeader(line);
+    const newPath = header(physical[++index] ?? "", "+++ ");
+    const newHeader = physical[index].slice(4);
+    const newEpoch = isEpochHeader(physical[index]);
+    index++;
+    budget.file();
+    const hunks = [];
+    let oldEnded = false;
+    let newEnded = false;
+    while (index < physical.length && physical[index].startsWith("@@")) {
+      budget.hunk();
+      const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@( .*)?$/u.exec(physical[index++]);
+      if (!match) throw new ToolError("malformed unified hunk header");
+      const oldStart = integer(match[1], "old start");
+      const oldCount = integer(match[2] ?? "1", "old count");
+      const newStart = integer(match[3], "new start");
+      const newCount = integer(match[4] ?? "1", "new count");
+      for (const value of [oldStart, oldCount, newStart, newCount]) {
+        if (value > budget.limits.maxLines) throw new ToolError("hunk coordinate exceeds line limit");
+      }
+      if (oldCount > 0 && oldStart === 0 || newCount > 0 && newStart === 0 || !oldCount && !newCount) throw new ToolError("invalid zero hunk range");
+      if (oldEnded && oldCount || newEnded && newCount) throw new ToolError("hunk follows an incomplete final line");
+      let oldRead = 0;
+      let newRead = 0;
+      const lines = [];
+      let changed = false;
+      while (oldRead < oldCount || newRead < newCount) {
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+        const body = physical[index++];
+        const kind = body === "" ? " " : body?.[0];
+        if (body === void 0 || kind !== " " && kind !== "+" && kind !== "-") throw new ToolError("truncated or malformed hunk body");
+        if (kind !== "+" && oldEnded || kind !== "-" && newEnded) throw new ToolError("content follows an incomplete final line");
+        if (kind !== "+") oldRead++;
+        if (kind !== "-") newRead++;
+        if (oldRead > oldCount || newRead > newCount) throw new ToolError("hunk line counts do not match header");
+        const entry = { kind, text: `${body.slice(1)}
+` };
+        lines.push(entry);
+        changed ||= kind !== " ";
+        if (physical[index] === "\") {
+          if (entry.text === "\n") throw new ToolError("empty incomplete line is not a valid text line");
+          index++;
+          entry.text = entry.text.slice(0, -1);
+          if (kind !== "+") oldEnded = true;
+          if (kind !== "-") newEnded = true;
+        }
+      }
+      if (!changed) throw new ToolError("hunk has no changes");
+      hunks.push({ oldStart, oldCount, newStart, newCount, lines, section: match[5] ?? "" });
+    }
+    if (!hunks.length) throw new ToolError("file patch has no hunks");
+    patches.push({ oldPath, newPath, oldEpoch, newEpoch, oldHeader, newHeader, hunks });
+    pendingMetadata = false;
+    if (single) break;
+  }
+  if (pendingMetadata) throw new ToolError("metadata without a file patch");
+  cursor.index = index;
+  return patches;
+}
+function reversePatch(patch) {
+  return {
+    ...patch,
+    oldPath: patch.newPath,
+    newPath: patch.oldPath,
+    oldEpoch: patch.newEpoch,
+    newEpoch: patch.oldEpoch,
+    hunks: patch.hunks.map((hunk) => ({
+      ...hunk,
+      oldStart: hunk.newStart,
+      oldCount: hunk.newCount,
+      newStart: hunk.oldStart,
+      newCount: hunk.oldCount,
+      lines: hunk.lines.map((line) => ({ kind: line.kind === "+" ? "-" : line.kind === "-" ? "+" : " ", text: line.text }))
+    }))
+  };
+}
+async function applyHunks(original, patch, fuzz, budget, ignoreWhitespace = false, application = {}) {
+  const source = budget.split(original);
+  const result = [];
+  let resultBytes = 0;
+  const append = (line) => {
+    resultBytes += byteLength(line);
+    if (resultBytes > budget.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+    result.push(line);
+  };
+  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[position + lineIndex];
+        if (actual === void 0) return false;
+        const expectedLine = oldLines[lineIndex].text;
+        if (ignoreWhitespace) budget.step(actual.length + expectedLine.length);
+        if (!budget.equal(
+          ignoreWhitespace ? actual.replace(/[ \t]+(?=\r?\n|$)/gu, "").replace(/[ \t]+/gu, " ") : actual,
+          ignoreWhitespace ? expectedLine.replace(/[ \t]+(?=\r?\n|$)/gu, "").replace(/[ \t]+/gu, " ") : expectedLine
+        )) 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) append(source[cursor++]);
+      let local = source.slice(cursor, cursor + hunk.oldCount);
+      if (!oldLines.some((line, index) => budget.equal(line.text, local[index] ?? ""))) 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) && local[prefix] === incoming[prefix] && local[prefix] === base[prefix]) prefix++;
+      while (suffix < Math.min(local.length, incoming.length, base.length) - prefix && local[local.length - suffix - 1] === incoming[incoming.length - suffix - 1] && local[local.length - suffix - 1] === base[base.length - suffix - 1]) suffix++;
+      budget.step(local.join("").length + incoming.join("").length + base.join("").length);
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+      for (const line of local.slice(0, prefix)) append(line);
+      const mergeStart = result.length + 1;
+      if (local.join("") === incoming.join("")) {
+        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)) append(line);
+      } else {
+        append("<<<<<<<\n");
+        for (const line of local.slice(prefix, local.length - suffix)) append(line);
+        if (application.merge === "diff3") {
+          append("|||||||\n");
+          for (const line of base.slice(prefix, base.length - suffix)) append(line);
+        }
+        append("=======\n");
+        for (const line of incoming.slice(prefix, incoming.length - suffix)) append(line);
+        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)) 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) append(source[cursor++]);
+    let removed = [];
+    let added = [];
+    const flush = () => {
+      if (!removed.length && !added.length) return;
+      if (application.ifdef) {
+        append(`#${removed.length ? "ifndef" : "ifdef"} ${application.ifdef}
+`);
+        for (const text2 of removed) append(text2);
+        if (removed.length && added.length) append("#else\n");
+        for (const text2 of added) append(text2);
+        append("#endif\n");
+      } else for (const text2 of added) append(text2);
+      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 === " ") {
+        flush();
+        if (cursor < source.length) append(source[cursor++]);
+      } else {
+        removed.push(source[cursor] ?? line.text);
+        cursor++;
+      }
+    }
+    flush();
+    outputOffset = result.length - cursor;
+  }
+  while (cursor < source.length) append(source[cursor++]);
+  for (let index = 0; index < result.length - 1; index++) {
+    budget.step();
+    if (!result[index].endsWith("\n")) {
+      if (++resultBytes > budget.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+      result[index] += "\n";
+    }
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+  }
+  const text = result.join("");
+  budget.output(text);
+  return text;
+}
+
+export {
+  startIndex,
+  parseUnified,
+  parseUnifiedSection,
+  reversePatch,
+  applyHunks
+};

package/dist/safe-bash/command-chunks/{chunk-L6SU4S26.js → chunk-6B7WQIKB.js}

@@ -30,12 +30,6 @@ var inProcessRegexWorkers = /* @__PURE__ */ new WeakSet();
 var inProcessRegexProviders = /* @__PURE__ */ new WeakSet();
 var trustedInputRows = /* @__PURE__ */ new WeakSet();
 var reusableBatchRows = /* @__PURE__ */ new WeakSet();
-var reusableTrustedRequest = {
-  id: 0,
-  descriptor: void 0,
-  rows: []
-};
-trustedWorkerRequests.add(reusableTrustedRequest);
 var exprMatchCeilings = Object.freeze({
   maxPatternBytes: Infinity,
   maxSubjectBytes: Infinity,
@@ -291,7 +285,6 @@ export {
   inProcessRegexProviders,
   trustedInputRows,
   reusableBatchRows,
-  reusableTrustedRequest,
   exprMatchCeilings,
   breSearchSymbolWidth,
   ExprMatchError,