@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/command-chunks/chunk-FXELCPFX.js

@@ -0,0 +1,195 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/sync.ts
+init_buffer();
+import { gnuInformationSync } from "../../safe-bash-io-engine/gnu-information.js";
+import { encoder } from "../../safe-bash-io-engine/internal.js";
+var syncDiffDecoder = new TextDecoder("utf-8", { fatal: false });
+function evalSyncPatch(inBytes, opArgs, readFileSync, writeFileSync) {
+  const gnuInfo = gnuInformationSync("patch", opArgs);
+  if (gnuInfo !== void 0) return gnuInfo;
+  if (!readFileSync || !writeFileSync) return void 0;
+  let strip;
+  let quiet = false;
+  let reverse = false;
+  let dryRun = false;
+  let outputPath;
+  let inputPath;
+  let ended = false;
+  const operands = [];
+  for (let i = 0; i < opArgs.length; i++) {
+    const a = opArgs[i];
+    if (ended || !a.startsWith("-") || a === "-") {
+      operands.push(a);
+      continue;
+    }
+    if (a === "--") {
+      ended = true;
+      continue;
+    }
+    if (a === "-s" || a === "--quiet" || a === "--silent") {
+      quiet = true;
+      continue;
+    }
+    if (a === "-R" || a === "--reverse") {
+      reverse = true;
+      continue;
+    }
+    if (a === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (a === "-N" || a === "--forward" || a === "-f" || a === "--force" || a === "-t" || a === "--batch" || a === "-u" || a === "--unified") {
+      continue;
+    }
+    if (a === "-o" || a === "--output") {
+      outputPath = opArgs[++i];
+      if (!outputPath) return void 0;
+      continue;
+    }
+    if (a.startsWith("-o") && a.length > 2) {
+      outputPath = a.slice(2);
+      continue;
+    }
+    if (a.startsWith("--output=")) {
+      outputPath = a.slice(9);
+      if (!outputPath) return void 0;
+      continue;
+    }
+    if (a === "-p" || a === "--strip") {
+      const v = opArgs[++i];
+      if (!v || !/^\d+$/.test(v)) return void 0;
+      strip = Number(v);
+      continue;
+    }
+    if (a.startsWith("-p") && /^\d+$/.test(a.slice(2))) {
+      strip = Number(a.slice(2));
+      continue;
+    }
+    if (a.startsWith("--strip=") && /^\d+$/.test(a.slice(8))) {
+      strip = Number(a.slice(8));
+      continue;
+    }
+    if (a === "-i" || a === "--input") {
+      inputPath = opArgs[++i];
+      if (!inputPath) return void 0;
+      continue;
+    }
+    if (a.startsWith("--input=")) {
+      inputPath = a.slice(8);
+      continue;
+    }
+    return void 0;
+  }
+  if (operands.length > 2) return void 0;
+  const targetArg = operands[0];
+  const patchFileArg = inputPath ?? operands[1];
+  const patchBytes = patchFileArg && patchFileArg !== "-" ? readFileSync(patchFileArg) : inBytes;
+  if (!patchBytes || patchBytes.includes(0)) return void 0;
+  const patchText = syncDiffDecoder.decode(patchBytes);
+  const lines = patchText.split("\n");
+  let headerOld;
+  let headerNew;
+  let idx = 0;
+  while (idx < lines.length && !lines[idx].startsWith("@@ ")) {
+    if (lines[idx].startsWith("--- ")) {
+      headerOld = lines[idx].slice(4).split("	")[0].trim();
+    } else if (lines[idx].startsWith("+++ ")) {
+      headerNew = lines[idx].slice(4).split("	")[0].trim();
+    }
+    idx++;
+  }
+  if (idx >= lines.length) return void 0;
+  let resolvedTarget = targetArg;
+  if (!resolvedTarget) {
+    const hdr = headerNew && headerNew !== "/dev/null" ? headerNew : headerOld;
+    if (!hdr || hdr === "/dev/null") return void 0;
+    if (strip !== void 0) {
+      const parts = hdr.split("/");
+      if (parts.length <= strip) return void 0;
+      resolvedTarget = parts.slice(strip).join("/");
+    } else {
+      resolvedTarget = hdr.split("/").pop() || hdr;
+    }
+  }
+  if (!resolvedTarget) return void 0;
+  const origBytes = readFileSync(resolvedTarget);
+  if (origBytes && origBytes.includes(0)) return void 0;
+  const isNewFile = !origBytes && (reverse ? headerNew === "/dev/null" : headerOld === "/dev/null");
+  if (!origBytes && !isNewFile) return void 0;
+  const origText = origBytes ? syncDiffDecoder.decode(origBytes) : "";
+  let hasTrailingNewline = origText === "" ? true : origText.endsWith("\n");
+  const origLines = origText === "" ? [] : origText.endsWith("\n") ? origText.slice(0, -1).split("\n") : origText.split("\n");
+  const outLines = [];
+  let origPos = 0;
+  let lastHunkOp = " ";
+  while (idx < lines.length) {
+    const line = lines[idx];
+    if (!line.startsWith("@@ ")) {
+      if (line === "") {
+        idx++;
+        continue;
+      }
+      return void 0;
+    }
+    const m = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (!m) return void 0;
+    const startLineNum = Number(reverse ? m[3] : m[1]);
+    const oldStart = startLineNum === 0 ? 0 : startLineNum - 1;
+    if (oldStart < origPos || oldStart > origLines.length) return void 0;
+    while (origPos < oldStart) outLines.push(origLines[origPos++]);
+    idx++;
+    while (idx < lines.length && !lines[idx].startsWith("@@ ")) {
+      const hl = lines[idx];
+      if (hl === "" && idx === lines.length - 1) {
+        idx++;
+        break;
+      }
+      const rawPrefix = hl[0];
+      const prefix = reverse ? rawPrefix === "+" ? "-" : rawPrefix === "-" ? "+" : rawPrefix : rawPrefix;
+      const body = hl.slice(1);
+      if (prefix === " ") {
+        if (origLines[origPos] !== body) return void 0;
+        outLines.push(body);
+        origPos++;
+        lastHunkOp = " ";
+      } else if (prefix === "-") {
+        if (origLines[origPos] !== body) return void 0;
+        origPos++;
+        if (origPos === origLines.length) hasTrailingNewline = true;
+        lastHunkOp = "-";
+      } else if (prefix === "+") {
+        outLines.push(body);
+        if (origPos === origLines.length) hasTrailingNewline = true;
+        lastHunkOp = "+";
+      } else if (hl.startsWith("\\ No newline")) {
+        if (lastHunkOp === "+" || lastHunkOp === " " && origPos === origLines.length) {
+          hasTrailingNewline = false;
+        }
+      } else {
+        return void 0;
+      }
+      idx++;
+    }
+  }
+  while (origPos < origLines.length) outLines.push(origLines[origPos++]);
+  const resultText = outLines.length === 0 ? "" : outLines.join("\n") + (hasTrailingNewline ? "\n" : "");
+  if (outputPath === "-") {
+    return resultText;
+  }
+  const destPath = outputPath ?? resolvedTarget;
+  if (!dryRun && outputPath !== "/dev/null") {
+    if (!writeFileSync(destPath, encoder.encode(resultText), false)) return void 0;
+  }
+  if (quiet) return "";
+  const verb = dryRun ? "checking" : "patching";
+  const label = outputPath !== void 0 ? `${outputPath} (read from ${resolvedTarget})` : resolvedTarget;
+  return `${verb} file ${label}
+`;
+}
+
+export {
+  evalSyncPatch
+};

package/dist/safe-bash/command-chunks/chunk-FXOA7RBK.js

@@ -0,0 +1,42 @@
+import {
+  CurlError
+} from "./chunk-GRBWW4SG.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/form-headers.ts
+init_buffer();
+import { decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+function validatePartHeader(header) {
+  const colon = header.indexOf(":");
+  if (colon <= 0) throw new CurlError(2, "Invalid multipart part header");
+  for (const character of header.slice(0, colon)) {
+    const code = character.charCodeAt(0);
+    if (!(code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || "!#$%&'*+-.^_`|~".includes(character)))
+      throw new CurlError(2, "Invalid multipart part header");
+  }
+  for (const character of header) {
+    const code = character.charCodeAt(0);
+    if (code < 32 && code !== 9 || code === 127)
+      throw new CurlError(2, "Invalid multipart part header");
+  }
+  return header;
+}
+function filePartHeaders(bytes) {
+  const headers = [];
+  for (let line of decodeBytes(encodeBytes(bytes), "utf8").split("\n")) {
+    if (line.endsWith("\r")) line = line.slice(0, -1);
+    if (!line || line.startsWith("#")) continue;
+    if ((line.startsWith(" ") || line.startsWith("	")) && headers.length) {
+      headers[headers.length - 1] += " " + line.trim();
+      validatePartHeader(headers[headers.length - 1]);
+    } else headers.push(validatePartHeader(line));
+  }
+  return headers;
+}
+
+export {
+  validatePartHeader,
+  filePartHeaders
+};

package/dist/safe-bash/command-chunks/{chunk-LPORMIZS.js → chunk-FZTK4MFI.js}

@@ -1,23 +1,23 @@
 import {
   configuredTable
-} from "./chunk-2WRTLCGK.js";
-import {
-  cell,
-  decode,
-  fields,
-  validateScalar,
-  whitespace
-} from "./chunk-NI7MKJPN.js";
+} from "./chunk-LAOM65EE.js";
 import {
   ColumnInputs,
   diagnostics
-} from "./chunk-K543PB3I.js";
+} from "./chunk-G66QUHIZ.js";
 import {
   helpText,
   parse,
   settings,
   usage
 } from "./chunk-AHEQ2THG.js";
+import {
+  cell,
+  decode,
+  fields,
+  validateScalar,
+  whitespace
+} from "./chunk-MTQH74CF.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-K543PB3I.js → chunk-G66QUHIZ.js}

@@ -7,6 +7,7 @@ import {
 
 // packages/safe-bash-command-column/src/internal.ts
 init_buffer();
+import { subscribeAbort } from "../../safe-bash-contracts/index.js";
 import { bytesFrom, concatBytes, utf8ByteLength } from "../../safe-bash-byte-engine/index.js";
 import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
 import { inheritYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
@@ -36,12 +37,6 @@ var ColumnBudget = class _ColumnBudget extends Budget {
   constructor(context, columnLimits) {
     super(context, readerSettings(columnLimits), _ColumnBudget.outputChunkBytes);
     this.columnLimits = columnLimits;
-    const sig = context.signal;
-    this.pollSignal = typeof sig.addEventListener !== "function" || Object.prototype.hasOwnProperty.call(sig, "aborted");
-    if (sig.aborted) this.aborted = true;
-    else if (!this.pollSignal) sig.addEventListener("abort", () => {
-      this.aborted = true;
-    }, { once: true });
   }
   columnLimits;
   static outputChunkBytes = 8192;
@@ -50,8 +45,6 @@ var ColumnBudget = class _ColumnBudget extends Budget {
   emittedBytes = 0;
   retainedBytes = 0;
   projectedBytes = 0;
-  aborted = false;
-  pollSignal;
   check(value, maximum, label) {
     if (!Number.isSafeInteger(value) || value < 0 || value > maximum) {
       throw new FsError("EFBIG", { message: `column ${label} limit exceeded` });
@@ -70,10 +63,7 @@ var ColumnBudget = class _ColumnBudget extends Budget {
     this.projectedBytes += size;
   }
   work(amount) {
-    if (this.aborted || this.pollSignal && this.context.signal.aborted) {
-      this.aborted = true;
-      this.context.signal.throwIfAborted();
-    }
+    this.context.signal.throwIfAborted();
     this.check(amount, this.columnLimits.maxSteps - this.workUsed, "work");
     this.workUsed += amount;
     this.untilYield -= amount;
@@ -113,40 +103,21 @@ var ColumnBudget = class _ColumnBudget extends Budget {
     }
   }
 };
-var columnSignalWaiters = /* @__PURE__ */ new WeakMap();
-function getColumnSignalWaiters(signal) {
-  let waiters = columnSignalWaiters.get(signal);
-  if (!waiters) {
-    waiters = /* @__PURE__ */ new Set();
-    columnSignalWaiters.set(signal, waiters);
-    signal.addEventListener("abort", () => {
-      const pending = [...waiters];
-      waiters.clear();
-      for (const fn of pending) fn();
-    }, { once: true });
-  }
-  return waiters;
-}
 function cancellable(operation, signal) {
   signal.throwIfAborted();
-  const waiters = getColumnSignalWaiters(signal);
   return new Promise((resolve, reject) => {
-    const onAbort = () => {
-      waiters.delete(onAbort);
-      reject(signal.reason);
-    };
-    waiters.add(onAbort);
+    const unsubscribe = subscribeAbort(signal, () => reject(signal.reason));
     try {
       Promise.resolve(operation()).then((value) => {
-        waiters.delete(onAbort);
+        unsubscribe();
         if (signal.aborted) reject(signal.reason);
         else resolve(value);
       }, (error) => {
-        waiters.delete(onAbort);
+        unsubscribe();
         reject(error);
       });
     } catch (error) {
-      waiters.delete(onAbort);
+      unsubscribe();
       reject(error);
     }
   });

package/dist/safe-bash/command-chunks/chunk-GFQZCKO6.js

@@ -0,0 +1,272 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-diff-engine/src/shared.ts
+init_buffer();
+import {
+  collectBytes,
+  isFsError,
+  readBytes
+} from "../../safe-bash-contracts/index.js";
+import { PublicDiagnostic, publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
+import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
+import { monotonicNow, yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { byteLength, concatBytes, decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { pathOf } from "../../safe-bash-io-engine/internal.js";
+var ToolError = class extends PublicDiagnostic {
+  constructor(message, exitCode = 2) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+  exitCode;
+};
+var Budget = class _Budget {
+  constructor(context, options) {
+    this.context = context;
+    this.limits = {
+      maxInputBytes: options.maxInputBytes ?? Infinity,
+      maxOutputBytes: options.maxOutputBytes ?? Infinity,
+      maxLines: options.maxLines ?? Infinity,
+      maxWork: options.maxWork ?? Infinity,
+      maxMatrixCells: options.maxMatrixCells ?? Infinity,
+      maxFiles: options.maxFiles ?? Infinity,
+      maxHunks: options.maxHunks ?? Infinity,
+      maxExcludePatterns: options.maxExcludePatterns ?? Infinity,
+      maxExcludePatternBytes: options.maxExcludePatternBytes ?? Infinity
+    };
+    for (const [name, value] of Object.entries(options).filter(([name2]) => name2 !== "replace")) {
+      if (value !== void 0 && value !== Infinity && (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)) throw new ToolError(`${name} must be a positive safe integer or Infinity`);
+    }
+  }
+  context;
+  limits;
+  inspected = /* @__PURE__ */ new Map();
+  inputBytes = 0;
+  outputBytes = 0;
+  lines = 0;
+  work = 0;
+  nextYield = 4096;
+  lastCheckpointTime;
+  nextYieldTime = 0;
+  files = 0;
+  hunks = 0;
+  get maxBufferBytes() {
+    return this.limits.maxInputBytes;
+  }
+  get remainingWork() {
+    return this.limits.maxWork - this.work;
+  }
+  get remainingFiles() {
+    return this.limits.maxFiles - this.files;
+  }
+  step(amount = 1) {
+    this.context.signal.throwIfAborted();
+    this.work += amount;
+    if (this.work > this.limits.maxWork) throw new ToolError("work limit exceeded");
+  }
+  checkpoint() {
+    this.context.signal.throwIfAborted();
+    if (this.work >= this.nextYield) {
+      this.nextYield = this.work + 4096;
+      const now = monotonicNow();
+      const previous = this.lastCheckpointTime;
+      this.lastCheckpointTime = now;
+      if (previous === void 0 || now <= previous || now >= this.nextYieldTime) {
+        return yieldTurn(this.context.signal).then(() => {
+          this.lastCheckpointTime = monotonicNow();
+          this.nextYieldTime = this.lastCheckpointTime + 16;
+        });
+      }
+    }
+  }
+  file() {
+    this.step();
+    if (++this.files > this.limits.maxFiles) throw new ToolError("file/entry limit exceeded");
+  }
+  hunk() {
+    this.step();
+    if (++this.hunks > this.limits.maxHunks) throw new ToolError("hunk limit exceeded");
+  }
+  static utf8Decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+  text(bytes) {
+    if (bytes.includes(0)) throw new ToolError("binary input is unsupported (NUL byte)");
+    try {
+      return _Budget.utf8Decoder.decode(bytes);
+    } catch {
+      throw new ToolError("binary input is unsupported (invalid UTF-8)");
+    }
+  }
+  split(text) {
+    const result = [];
+    let start = 0;
+    while (start < text.length) {
+      if (++this.lines > this.limits.maxLines) throw new ToolError("line limit exceeded");
+      const newline = text.indexOf("\n", start);
+      const end = newline < 0 ? text.length : newline + 1;
+      result.push(text.slice(start, end));
+      start = end;
+    }
+    return result;
+  }
+  async read(path, encoding = "utf8") {
+    this.context.signal.throwIfAborted();
+    const remaining = Math.min(this.limits.maxInputBytes, this.context.inputBudget?.maxBytes ?? Infinity) - this.inputBytes;
+    const capabilities = path === "-" ? void 0 : await host(this.context, async () => await this.context.fs.capabilitiesFor?.(path, { signal: this.context.signal }) ?? this.context.fs.capabilities);
+    const streamed = path === "-" || this.context.fs.readStream && capabilities?.streamingRead !== false;
+    const bytes = path === "-" ? await collectBytes(this.chunks(this.context.stdin), { signal: this.context.signal, ...Number.isFinite(remaining) ? { maxBytes: remaining } : {} }) : this.context.fs.readStream && capabilities?.streamingRead !== false ? await collectBytes(this.chunks(this.context.fs.readStream(path, { signal: this.context.signal })), { signal: this.context.signal, ...Number.isFinite(remaining) ? { maxBytes: remaining } : {} }) : await host(this.context, () => this.context.fs.readFile(path, { signal: this.context.signal, ...Number.isFinite(remaining) ? { maxBytes: remaining } : {} }));
+    if (!streamed) {
+      this.input(bytes.byteLength);
+      if (this.inputBytes > this.limits.maxInputBytes) throw new ToolError("input byte limit exceeded");
+    }
+    return encoding === "latin1" ? decodeBytes(encodeBytes(bytes), "latin1") : this.text(bytes);
+  }
+  async readDiff(path, encoding = "utf8") {
+    const { fs, signal } = this.context;
+    const expected = this.inspected.get(path);
+    const verifyAncestors = async () => {
+      const parts = path.split("/").filter(Boolean);
+      let current = "";
+      for (let index = -1; index < parts.length - 1; index++) {
+        if (index >= 0) current += `/${parts[index]}`;
+        const ancestor = current || "/";
+        const wanted = this.inspected.get(ancestor);
+        const actual = await fs.stat(ancestor, { signal });
+        if (!wanted || !sameIdentity(actual, wanted)) throw new ToolError("diff input ancestry changed");
+      }
+    };
+    const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;
+    if (!expected || !sameIdentity(expected, expected) || capabilities.retainedRead !== true || !fs.openReadFile)
+      throw new ToolError("diff input requires identity-checked retained reads");
+    await verifyAncestors();
+    const handle = await fs.openReadFile(path, { signal });
+    try {
+      const stat = await handle.stat({ signal });
+      if (!sameIdentity(stat, expected) || stat.size !== expected.size || stat.revision !== expected.revision)
+        throw new ToolError("diff input changed while opening");
+      await verifyAncestors();
+      const remaining = Math.min(this.limits.maxInputBytes, this.context.inputBudget?.maxBytes ?? Infinity) - this.inputBytes;
+      if (stat.size > remaining) throw new ToolError("input byte limit exceeded");
+      const chunks = [];
+      let position = 0;
+      while (position < stat.size) {
+        this.step();
+        {
+          const c = this.checkpoint();
+          if (c) await c;
+        }
+        const size = Math.min(65536, stat.size - position);
+        const chunk = await handle.read(position, size, { signal });
+        if (!chunk.length || chunk.length > size) throw new ToolError("diff input changed while reading");
+        this.input(chunk.length);
+        chunks.push(new Uint8Array(chunk));
+        position += chunk.length;
+      }
+      const after = await handle.stat({ signal });
+      if (!sameIdentity(after, stat) || after.size !== stat.size || after.revision !== stat.revision)
+        throw new ToolError("diff input changed while reading");
+      const bytes = concatBytes(chunks, position);
+      return encoding === "latin1" ? decodeBytes(bytes, "latin1") : this.text(bytes);
+    } finally {
+      await handle.close();
+    }
+  }
+  async *chunks(source) {
+    for await (const chunk of readBytes(source, this.context.signal)) {
+      this.step();
+      {
+        const c = this.checkpoint();
+        if (c) await c;
+      }
+      this.input(chunk.byteLength);
+      yield chunk;
+    }
+  }
+  input(bytes) {
+    const total = this.inputBytes + bytes;
+    this.context.inputBudget?.check(total);
+    this.inputBytes = total;
+  }
+  output(text, encoding = "utf8") {
+    this.outputBytes += byteLength(text, encoding);
+    if (this.outputBytes > this.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+  }
+  equal(left, right) {
+    this.step(1 + Math.max(left?.length ?? 0, right?.length ?? 0));
+    return left === right;
+  }
+};
+async function host(context, operation) {
+  context.signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(context.signal.reason);
+    context.signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve().then(() => {
+      context.signal.throwIfAborted();
+      return operation();
+    }).then(resolve, reject).finally(() => context.signal.removeEventListener("abort", abort));
+  });
+}
+function sameIdentity(actual, wanted) {
+  return wanted.identityScope !== void 0 && wanted.dev !== void 0 && wanted.ino !== void 0 && actual.identityScope === wanted.identityScope && actual.dev === wanted.dev && actual.ino === wanted.ino && actual.type === wanted.type;
+}
+async function inspect(budget, path, symlinks = "reject") {
+  const context = budget.context;
+  const absolute = pathOf(context, path);
+  const parts = absolute.split("/").filter(Boolean);
+  let current = "";
+  for (let index = -1; index < parts.length; index++) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (index >= 0) current += `/${parts[index]}`;
+    let stat;
+    try {
+      stat = await host(context, () => context.fs.lstat(current || "/", { signal: context.signal }));
+    } catch (error) {
+      if (isFsError(error, "ENOENT")) return void 0;
+      throw error;
+    }
+    if (stat.type === "symlink") {
+      if (symlinks === "reject") throw new ToolError(`symlink paths are unsupported: ${current}`);
+      if (symlinks === "follow" || index < parts.length - 1) stat = await host(context, () => context.fs.stat(current || "/", { signal: context.signal }));
+    }
+    budget.inspected.set(current || "/", stat);
+    if (index < parts.length - 1 && stat.type !== "directory") throw new ToolError(`not a directory: ${current}`);
+    if (index === parts.length - 1) return stat;
+  }
+  return void 0;
+}
+function integer(value, name) {
+  if (!/^\d+$/u.test(value) || !Number.isSafeInteger(Number(value))) throw new ToolError(`invalid ${name}: ${value}`);
+  return Number(value);
+}
+function definition(name, options, run) {
+  return {
+    name,
+    async execute(context) {
+      context.signal.throwIfAborted();
+      try {
+        return { exitCode: await run(context, new Budget(context, options)) };
+      } catch (error) {
+        context.signal.throwIfAborted();
+        const message = publicDiagnosticMessage(error, context.onInternalError);
+        await writeDiagnostic(context.stderr, `${name}: ${message.slice(0, 1e3)}${message.length > 1e3 ? "\u2026" : ""}
+`, context.signal);
+        return { exitCode: error instanceof ToolError ? error.exitCode : 2 };
+      }
+    }
+  };
+}
+
+export {
+  ToolError,
+  Budget,
+  host,
+  sameIdentity,
+  inspect,
+  integer,
+  definition
+};