@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash-network-engine/form-content-type.d.ts

@@ -0,0 +1,5 @@
+/** Read MIME parameters until curl's next form attribute, retaining header bytes. */
+export declare function formContentType(input: string, start: number, fileList?: boolean): {
+    value: string;
+    end: number;
+};

package/dist/safe-bash-network-engine/form-content-type.js

@@ -0,0 +1,8 @@
+import {
+  formContentType
+} from "../safe-bash/command-chunks/chunk-CKXV2CLD.js";
+import "../safe-bash/command-chunks/chunk-IYPAQ7PH.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  formContentType
+};

package/dist/safe-bash-network-engine/form-headers.d.ts

@@ -0,0 +1,2 @@
+export declare function validatePartHeader(header: string): string;
+export declare function filePartHeaders(bytes: Uint8Array): string[];

package/dist/safe-bash-network-engine/form-headers.js

@@ -0,0 +1,10 @@
+import {
+  filePartHeaders,
+  validatePartHeader
+} from "../safe-bash/command-chunks/chunk-E2LB7FRT.js";
+import "../safe-bash/command-chunks/chunk-IYPAQ7PH.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  filePartHeaders,
+  validatePartHeader
+};

package/dist/safe-bash-network-engine/glob.d.ts

@@ -0,0 +1,7 @@
+import { type NetworkLimits } from "./types.js";
+export interface ExpandedUrl {
+    readonly url: string;
+    readonly captures: readonly string[];
+}
+export declare function expandUrls(urls: readonly string[], globoff: boolean, limits: NetworkLimits): ExpandedUrl[];
+export declare function globFilename(template: string, captures: readonly string[]): string;

package/dist/safe-bash-network-engine/glob.js

@@ -0,0 +1,124 @@
+import {
+  CurlError
+} from "../safe-bash/command-chunks/chunk-IYPAQ7PH.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/glob.ts
+init_buffer();
+import { byteLength } from "../safe-bash-io-engine/byte-encoding.js";
+function decimal(text) {
+  if (!text || ![...text].every((char) => char >= "0" && char <= "9")) throw new CurlError(3, "Malformed URL range");
+  const value = Number(text);
+  if (!Number.isSafeInteger(value)) throw new CurlError(3, "Malformed URL range");
+  return value;
+}
+function range(text, maximum, admit) {
+  const parts = text.split(":");
+  if (parts.length > 2) throw new CurlError(3, "Malformed URL range");
+  const ends = parts[0].split("-");
+  if (ends.length !== 2) throw new CurlError(3, "Malformed URL range");
+  const [left, right] = ends;
+  const character = left.length === 1 && right.length === 1 && (left >= "a" && right <= "z" && right >= "a" || left >= "A" && right <= "Z" && right >= "A");
+  const start = character ? left.charCodeAt(0) : decimal(left);
+  const end = character ? right.charCodeAt(0) : decimal(right);
+  const step = parts[1] === void 0 ? 1 : decimal(parts[1]);
+  if (start > end || step === 0 || step > end - start + 1) throw new CurlError(3, "Malformed URL range");
+  const count = Math.floor((end - start) / step) + 1;
+  if (count > maximum) throw new CurlError(2, "URL count exceeds host limit");
+  const width = !character && left.startsWith("0") ? left.length : 0;
+  admit(count, count * Math.max(width, character ? 1 : String(end).length));
+  return Array.from({ length: count }, (_, index) => character ? String.fromCharCode(start + index * step) : String(start + index * step).padStart(width, "0"));
+}
+function expandUrls(urls, globoff, limits) {
+  const result = [];
+  let bytes = 0;
+  let work = 0;
+  const charge = (size) => {
+    work += size;
+    if (work > limits.maxBufferBytes) throw new CurlError(2, "URL expansion work exceeds host limit");
+  };
+  for (const input of urls) {
+    let expanded = [{ url: "", captures: [] }];
+    const append = (suffix) => {
+      const retained = expanded.reduce((total, item) => total + byteLength(item.url) + byteLength(suffix) + item.captures.reduce((size, value) => size + byteLength(value), 0), bytes);
+      if (retained > limits.maxBufferBytes) throw new CurlError(2, "Expanded URLs exceed host buffer limit");
+      charge(retained - bytes);
+      expanded = expanded.map((item) => ({ ...item, url: item.url + suffix }));
+    };
+    for (let index = 0; index < input.length; ) {
+      const char = input[index];
+      if (globoff) {
+        append(input.slice(index));
+        break;
+      }
+      if (char === "\\" && "{}[]".includes(input[index + 1] ?? " ")) {
+        append(input[index + 1]);
+        index += 2;
+        continue;
+      }
+      if (char !== "{" && char !== "[") {
+        if (char === "}" || char === "]") throw new CurlError(3, "Unmatched URL glob delimiter");
+        let end = index + 1;
+        while (end < input.length && !"{}[]\\".includes(input[end])) end++;
+        append(input.slice(index, end));
+        index = end;
+        continue;
+      }
+      const close = input.indexOf(char === "{" ? "}" : "]", index + 1);
+      if (close < 0) throw new CurlError(3, "Unmatched URL glob delimiter");
+      const content = input.slice(index + 1, close);
+      if (char === "{" && content === "") throw new CurlError(3, "Malformed URL glob");
+      if (char === "[" && content.includes(":") && input.slice(0, index).endsWith("//")) {
+        append(input.slice(index, close + 1));
+        index = close + 1;
+        continue;
+      }
+      if ([...content].some((value) => "{}[]".includes(value))) throw new CurlError(3, "Nested URL globs are unsupported");
+      const maximum = Math.floor((limits.maxUrls - result.length) / expanded.length);
+      const admit = (count, valueBytes) => {
+        const prefixBytes = expanded.reduce((total, item) => total + byteLength(item.url) + item.captures.reduce((size, capture) => size + byteLength(capture), 0), 0);
+        const retained = count * prefixBytes + expanded.length * valueBytes * 2;
+        if (retained + bytes > limits.maxBufferBytes) throw new CurlError(2, "Expanded URLs exceed host buffer limit");
+        charge(retained);
+      };
+      const values = char === "{" ? content.split(",") : range(content, maximum, admit);
+      if (values.length > maximum) throw new CurlError(2, "URL count exceeds host limit");
+      if (char === "{") admit(values.length, values.reduce((total, value) => total + byteLength(value), 0));
+      const next = [];
+      for (const item of expanded) for (const value of values) {
+        next.push({ url: item.url + value, captures: [...item.captures, value] });
+      }
+      expanded = next;
+      index = close + 1;
+    }
+    for (const item of expanded) {
+      bytes += byteLength(item.url) + item.captures.reduce((total, value) => total + byteLength(value), 0);
+      if (bytes > limits.maxBufferBytes) throw new CurlError(2, "Expanded URLs exceed host buffer limit");
+      if (result.length >= limits.maxUrls) throw new CurlError(2, "URL count exceeds host limit");
+      result.push(item);
+    }
+  }
+  return result;
+}
+function globFilename(template, captures) {
+  let output = "";
+  for (let index = 0; index < template.length; ) {
+    if (template[index] !== "#") {
+      output += template[index++];
+      continue;
+    }
+    let end = index + 1;
+    while (end < template.length && template[end] >= "0" && template[end] <= "9") end++;
+    const number = Number(template.slice(index + 1, end));
+    const capture = captures[number - 1];
+    output += capture === void 0 ? template.slice(index, end) : capture;
+    index = end;
+  }
+  return output;
+}
+export {
+  expandUrls,
+  globFilename
+};

package/dist/safe-bash-network-engine/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./authorizer.js";
+export * from "./fetch-transport.js";
+export * from "./types.js";

package/dist/safe-bash-network-engine/index.js

@@ -0,0 +1,26 @@
+import {
+  createOriginAuthorizer
+} from "../safe-bash/command-chunks/chunk-KYSPGS33.js";
+import "../safe-bash/command-chunks/chunk-MDH5T4OS.js";
+import {
+  createFetchTransport
+} from "../safe-bash/command-chunks/chunk-JN7WIP6S.js";
+import "../safe-bash/command-chunks/chunk-RVLO4DYT.js";
+import {
+  CurlError,
+  cloudflareWorkerNetworkLimits,
+  defaultNetworkLimits
+} from "../safe-bash/command-chunks/chunk-IYPAQ7PH.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/index.ts
+init_buffer();
+export {
+  CurlError,
+  cloudflareWorkerNetworkLimits,
+  createFetchTransport,
+  createOriginAuthorizer,
+  defaultNetworkLimits
+};

package/dist/safe-bash-network-engine/input.d.ts

@@ -0,0 +1,5 @@
+import { type CommandContext } from "../safe-bash-contracts/index.js";
+import { type CurlArguments } from "./args.js";
+import { type NetworkLimits } from "./types.js";
+/** Resolve explicit config, variable and -H/--header @VFS-file or @- inputs in option order. */
+export declare function parseCurlInput(context: CommandContext, limits: NetworkLimits): Promise<CurlArguments>;

package/dist/safe-bash-network-engine/input.js

@@ -0,0 +1,255 @@
+import {
+  flags,
+  longValues,
+  parseArguments,
+  values
+} from "../safe-bash/command-chunks/chunk-5LSGEIZY.js";
+import "../safe-bash/command-chunks/chunk-5XY4DTNG.js";
+import "../safe-bash/command-chunks/chunk-JN7WIP6S.js";
+import "../safe-bash/command-chunks/chunk-RVLO4DYT.js";
+import {
+  collectNetworkBytes,
+  withSignal
+} from "../safe-bash/command-chunks/chunk-FKKB5X5V.js";
+import {
+  CurlError
+} from "../safe-bash/command-chunks/chunk-IYPAQ7PH.js";
+import "../safe-bash/command-chunks/chunk-KWESKQHR.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/input.ts
+init_buffer();
+import { byteLength, decodeBytes, encodeBytes } from "../safe-bash-io-engine/byte-encoding.js";
+import { pathOf } from "../safe-bash-io-engine/internal.js";
+function whitespace(character) {
+  return " 	\r\n\v\f".includes(character);
+}
+function configArguments(text) {
+  const args = [];
+  for (const line of text.split("\n")) {
+    let offset = 0;
+    while (offset < line.length && whitespace(line[offset])) offset++;
+    if (offset === line.length || line[offset] === "#") continue;
+    const start = offset;
+    const dashed = line[offset] === "-";
+    while (offset < line.length && !whitespace(line[offset]) && (dashed || !"=:".includes(line[offset]))) offset++;
+    const option = line.slice(start, offset);
+    args.push(dashed ? option : `--${option}`);
+    while (offset < line.length && whitespace(line[offset])) offset++;
+    if (!dashed && "=:".includes(line[offset] ?? "\0")) offset++;
+    while (offset < line.length && whitespace(line[offset])) offset++;
+    if (offset === line.length) continue;
+    let value = "";
+    if (line[offset] === '"') {
+      offset++;
+      let closed = false;
+      while (offset < line.length) {
+        let character = line[offset++];
+        if (character === '"') {
+          closed = true;
+          break;
+        }
+        if (character === "\\" && offset < line.length) {
+          character = line[offset++];
+          character = { n: "\n", r: "\r", t: "	", v: "\v" }[character] ?? character;
+        }
+        value += character;
+      }
+      if (!closed) throw new CurlError(2, "Unterminated config string");
+      if (line.slice(offset).trim()) throw new CurlError(2, "Unexpected config string suffix");
+    } else value = line.slice(offset).trimEnd();
+    args.push(value);
+  }
+  return args;
+}
+function variableName(name) {
+  return name.length > 0 && [...name].every((character) => "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_".includes(character));
+}
+async function parseCurlInput(context, limits) {
+  const variables = /* @__PURE__ */ new Map();
+  const output = [];
+  let inputBytes = 0;
+  let outputBytes = 0;
+  let optionCount = 0;
+  const admit = (value) => {
+    inputBytes += byteLength(value);
+    if (inputBytes > limits.maxBufferBytes) throw new CurlError(2, "Curl input exceeds host buffer limit");
+    return value;
+  };
+  const append = (value) => {
+    outputBytes += byteLength(value);
+    if (outputBytes > limits.maxBufferBytes) throw new CurlError(2, "Expanded arguments exceed host buffer limit");
+    output.push(value);
+  };
+  const read = async (file) => {
+    try {
+      const maxBytes = limits.maxBufferBytes - inputBytes;
+      const bytes = file === "-" ? await collectNetworkBytes(context.stdin, { signal: context.signal, maxBytes }) : await withSignal(() => context.fs.readFile(pathOf(context, file), { signal: context.signal, ...Number.isFinite(maxBytes) ? { maxBytes } : {} }), context.signal);
+      context.signal.throwIfAborted();
+      inputBytes += bytes.length;
+      if (inputBytes > limits.maxBufferBytes) throw new CurlError(2, "Curl input exceeds host buffer limit");
+      return encodeBytes(bytes);
+    } catch (error) {
+      context.signal.throwIfAborted();
+      if (error instanceof CurlError) throw error;
+      throw new CurlError(26, "Failed to read virtual curl input");
+    }
+  };
+  const expand = (value) => {
+    let result = "";
+    let size = 0;
+    let offset = 0;
+    const appendPiece = (piece) => {
+      size += byteLength(piece);
+      if (size > limits.maxBufferBytes) throw new CurlError(2, "Variable expansion exceeds host buffer limit");
+      result += piece;
+    };
+    while (offset < value.length) {
+      const start = value.indexOf("{{", offset);
+      if (start < 0) {
+        appendPiece(value.slice(offset));
+        break;
+      }
+      appendPiece(value.slice(offset, start));
+      const end = value.indexOf("}}", start + 2);
+      if (end < 0) {
+        appendPiece(value.slice(start));
+        break;
+      }
+      const [name, ...functions] = value.slice(start + 2, end).split(":");
+      if (!variableName(name)) throw new CurlError(2, "Invalid expansion variable");
+      let bytes = variables.get(name) ?? new Uint8Array(0);
+      for (const functionName of functions) {
+        const requireSpace = (length) => {
+          if (length > limits.maxBufferBytes) throw new CurlError(2, "Variable transformation exceeds host buffer limit");
+        };
+        switch (functionName) {
+          case "trim": {
+            let start2 = 0, end2 = bytes.length;
+            while (start2 < end2 && whitespace(String.fromCharCode(bytes[start2]))) start2++;
+            while (end2 > start2 && whitespace(String.fromCharCode(bytes[end2 - 1]))) end2--;
+            bytes = bytes.subarray(start2, end2);
+            break;
+          }
+          case "json": {
+            requireSpace(bytes.length * 6);
+            bytes = encodeBytes(JSON.stringify(new TextDecoder("utf-8", { fatal: true }).decode(bytes)).slice(1, -1));
+            break;
+          }
+          case "url": {
+            requireSpace(bytes.length * 3);
+            let encoded = "";
+            for (const byte of bytes) {
+              const character = String.fromCharCode(byte);
+              encoded += "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~".includes(character) ? character : `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+            }
+            bytes = encodeBytes(encoded);
+            break;
+          }
+          case "b64":
+            requireSpace(Math.ceil(bytes.length / 3) * 4);
+            bytes = encodeBytes(decodeBytes(bytes, "base64"));
+            break;
+          default:
+            throw new CurlError(2, "Unsupported variable expansion function");
+        }
+      }
+      let replacement;
+      try {
+        replacement = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+      } catch {
+        throw new CurlError(2, "Binary variable requires url or b64 expansion");
+      }
+      if (replacement.includes("\0")) throw new CurlError(2, "Variable expansion contains NUL");
+      appendPiece(replacement);
+      offset = end + 2;
+    }
+    return result;
+  };
+  const define = async (value) => {
+    const fromEnv = value.startsWith("%");
+    const spec = fromEnv ? value.slice(1) : value;
+    let delimiter = spec.indexOf("=");
+    const at = spec.indexOf("@");
+    if (delimiter < 0 || at >= 0 && at < delimiter) delimiter = at;
+    const name = delimiter < 0 ? spec : spec.slice(0, delimiter);
+    if (!variableName(name)) throw new CurlError(2, "Invalid variable name");
+    let content = fromEnv && context.env[name] !== void 0 ? encodeBytes(admit(context.env[name])) : void 0;
+    if (content === void 0) {
+      if (delimiter < 0) {
+        if (fromEnv) throw new CurlError(2, "Required environment variable is unset");
+        content = new Uint8Array(0);
+      } else content = spec[delimiter] === "@" ? await read(spec.slice(delimiter + 1)) : encodeBytes(admit(spec.slice(delimiter + 1)));
+    }
+    variables.set(name, content);
+  };
+  let ended = false;
+  const visit = async (args, depth) => {
+    if (depth > 16) throw new CurlError(2, "Config nesting exceeds host limit");
+    for (let index = 0; index < args.length; index++) {
+      context.signal.throwIfAborted();
+      if (++optionCount > limits.maxBufferBytes) throw new CurlError(2, "Curl option count exceeds host limit");
+      const argument = args[index];
+      if (ended || argument === "-" || !argument.startsWith("-")) {
+        append(argument);
+        continue;
+      }
+      if (argument === "--") {
+        ended = true;
+        append(argument);
+        continue;
+      }
+      const apply = async (name, attached) => {
+        const expanded = name.startsWith("expand-");
+        const base = expanded ? name.slice(7) : name;
+        const takesValue = longValues.has(base) || base === "config" || base === "variable";
+        if (expanded && !longValues.has(base)) throw new CurlError(2, "Unsupported expand option");
+        if (!takesValue) {
+          if (attached !== void 0) throw new CurlError(2, "Unexpected option argument");
+          append(`--${name}`);
+          return;
+        }
+        const value = attached ?? args[++index];
+        if (value === void 0) throw new CurlError(2, "Option requires an argument");
+        const resolved = expanded ? expand(value) : value;
+        if (base === "config") await visit(configArguments(decodeBytes(await read(resolved), "utf8")), depth + 1);
+        else if (base === "variable") await define(resolved);
+        else if (base === "header" && resolved.startsWith("@")) {
+          const text = decodeBytes(await read(resolved.slice(1)), "utf8");
+          for (const raw of text.split("\n")) {
+            context.signal.throwIfAborted();
+            const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+            if (!line || line.startsWith("#")) continue;
+            append("--header");
+            append(line);
+          }
+        } else {
+          append(`--${base}`);
+          append(resolved);
+        }
+      };
+      if (argument.startsWith("--")) {
+        const equals = argument.indexOf("=");
+        await apply(argument.slice(2, equals < 0 ? void 0 : equals), equals < 0 ? void 0 : argument.slice(equals + 1));
+      } else {
+        for (let offset = 1; offset < argument.length; offset++) {
+          const short = argument[offset];
+          const name = short === "K" ? "config" : values[short];
+          if (name) {
+            await apply(name, argument.slice(offset + 1) || void 0);
+            break;
+          }
+          if (!flags[short]) throw new CurlError(2, "Unsupported curl option");
+          await apply(flags[short]);
+        }
+      }
+    }
+  };
+  await visit(context.args, 0);
+  return parseArguments(output, limits);
+}
+export {
+  parseCurlInput
+};

package/dist/safe-bash-network-engine/output.d.ts

@@ -0,0 +1,6 @@
+import { type ByteSource, type CommandContext } from "../safe-bash-contracts/index.js";
+import { type HttpResponse } from "./types.js";
+export declare function responseHeaders(response: HttpResponse, maxBytes: number): Uint8Array;
+export declare function writeOutput(context: CommandContext, path: string | undefined, source: ByteSource, signal: AbortSignal, append?: boolean, preserveEmpty?: boolean): Promise<void>;
+export declare function dumpHeaders(context: CommandContext, path: string, bytes: Uint8Array, append: boolean, signal: AbortSignal): Promise<void>;
+export declare function writeOutFormat(format: string, values: Readonly<Record<string, string>>, maxBytes: number): Uint8Array;

package/dist/safe-bash-network-engine/output.js

@@ -0,0 +1,132 @@
+import {
+  encode
+} from "../safe-bash/command-chunks/chunk-FKKB5X5V.js";
+import {
+  CurlError
+} from "../safe-bash/command-chunks/chunk-IYPAQ7PH.js";
+import "../safe-bash/command-chunks/chunk-KWESKQHR.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/output.ts
+init_buffer();
+import { FsError, readBytes, writeBytes } from "../safe-bash-contracts/index.js";
+import { openFileOutput } from "../safe-bash-contracts/filesystem-output.js";
+import { outputFailure } from "../safe-bash-contracts/io.js";
+import { byteLength, encodeBytes } from "../safe-bash-io-engine/byte-encoding.js";
+import { pathOf } from "../safe-bash-io-engine/internal.js";
+function responseHeaders(response, maxBytes) {
+  if (!Number.isInteger(response.status) || response.status < 100 || response.status > 599 || /[\r\n]/.test(response.statusText)) {
+    throw new CurlError(56, "Invalid HTTP response status");
+  }
+  const version = response.httpVersion ?? "1.1";
+  if (!/^\d(?:\.\d)?$/.test(version)) throw new CurlError(56, "Invalid HTTP response version");
+  let text = `HTTP/${version} ${response.status} ${response.statusText}\r
+`;
+  for (const [name, value] of response.headers) {
+    if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name) || /[\r\n\0]/.test(value)) throw new CurlError(56, "Invalid HTTP response header");
+    text += `${name}: ${value}\r
+`;
+    if (byteLength(text, "latin1") > maxBytes) throw new CurlError(63, "Response headers exceed host byte limit");
+  }
+  return new Uint8Array(encodeBytes(`${text}\r
+`, "latin1"));
+}
+async function writeOutput(context, path, source, signal, append = false, preserveEmpty = false) {
+  if (path === void 0 || path === "-") {
+    try {
+      for await (const chunk of readBytes(source, signal)) {
+        try {
+          await writeBytes(context.stdout, chunk, signal);
+        } catch {
+          signal.throwIfAborted();
+          throw new CurlError(23, "Failed writing output");
+        }
+      }
+    } catch (error) {
+      await context.stdout[outputFailure]?.(error);
+      throw error;
+    }
+    return;
+  }
+  try {
+    let target = preserveEmpty ? void 0 : await openFileOutput({ ...context, signal, outputBudget: "independent" }, pathOf(context, path), append ? "a" : "w");
+    try {
+      for await (const chunk of readBytes(source, target?.signal ?? signal)) {
+        if (preserveEmpty && chunk.length === 0) continue;
+        target ??= await openFileOutput({ ...context, signal, outputBudget: "independent" }, pathOf(context, path), append ? "a" : "w");
+        await target.sink.write(chunk);
+      }
+      await target?.finish();
+    } catch (error) {
+      await target?.abort(error);
+      throw error;
+    }
+  } catch (error) {
+    signal.throwIfAborted();
+    if (error instanceof CurlError) throw error;
+    throw new CurlError(23, error instanceof FsError ? `Failed writing virtual output file: ${error.message}` : "Failed writing virtual output file");
+  }
+}
+async function dumpHeaders(context, path, bytes, append, signal) {
+  try {
+    if (path === "-") await writeBytes(context.stdout, bytes, signal);
+    else {
+      const target = await openFileOutput({ ...context, signal, outputBudget: "independent" }, pathOf(context, path), append ? "a" : "w");
+      try {
+        await target.sink.write(bytes);
+        await target.finish();
+      } catch (error) {
+        await target.abort(error);
+        throw error;
+      }
+    }
+  } catch {
+    signal.throwIfAborted();
+    throw new CurlError(23, "Failed writing response headers");
+  }
+}
+function writeOutFormat(format, values, maxBytes) {
+  let result = "";
+  let bytes = 0;
+  const sizes = /* @__PURE__ */ new Map();
+  const append = (text) => {
+    let size = sizes.get(text);
+    if (size === void 0) {
+      size = byteLength(text);
+      sizes.set(text, size);
+    }
+    if (size > maxBytes - bytes) throw new CurlError(63, "Write-out exceeds host buffer limit");
+    bytes += size;
+    result += text;
+  };
+  for (let index = 0; index < format.length; index++) {
+    const character = format[index];
+    if (character === "\\") {
+      const next = format[++index];
+      append(next === "n" ? "\n" : next === "r" ? "\r" : next === "t" ? "	" : next === void 0 ? "\\" : `\\${next}`);
+    } else if (character === "%" && format[index + 1] === "%") {
+      append("%");
+      index++;
+    } else if (character === "%" && format[index + 1] === "{") {
+      const end = format.indexOf("}", index + 2);
+      if (end < 0) throw new CurlError(2, "Invalid write-out format");
+      const name = format.slice(index + 2, end);
+      if (!Object.hasOwn(values, name)) throw new CurlError(2, "Unsupported write-out variable");
+      append(values[name]);
+      index = end;
+    } else {
+      const start = index;
+      while (index + 1 < format.length && format[index + 1] !== "%" && format[index + 1] !== "\\") index++;
+      append(format.slice(start, index + 1));
+    }
+  }
+  return encode(result);
+}
+export {
+  dumpHeaders,
+  responseHeaders,
+  writeOutFormat,
+  writeOutput
+};

package/dist/safe-bash-network-engine/platform-portable.d.ts

@@ -0,0 +1,5 @@
+export declare const requiresFiniteUrlLimits = false;
+export declare function randomBytes(length: number): Uint8Array;
+export declare function validateHeaderName(name: string): void;
+export declare function validateHeaderValue(_name: string, value: string): void;
+export { createFetchTransport as createDefaultHttpTransport } from "./fetch-transport.js";

package/dist/safe-bash-network-engine/platform-portable.js

@@ -0,0 +1,19 @@
+import {
+  randomBytes,
+  requiresFiniteUrlLimits,
+  validateHeaderName,
+  validateHeaderValue
+} from "../safe-bash/command-chunks/chunk-5XY4DTNG.js";
+import {
+  createFetchTransport
+} from "../safe-bash/command-chunks/chunk-JN7WIP6S.js";
+import "../safe-bash/command-chunks/chunk-RVLO4DYT.js";
+import "../safe-bash/command-chunks/chunk-IYPAQ7PH.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  createFetchTransport as createDefaultHttpTransport,
+  randomBytes,
+  requiresFiniteUrlLimits,
+  validateHeaderName,
+  validateHeaderValue
+};

package/dist/safe-bash-network-engine/private-address.d.ts

@@ -0,0 +1 @@
+export declare function privateHostname(input: string): boolean;

package/dist/safe-bash-network-engine/private-address.js

@@ -0,0 +1,7 @@
+import {
+  privateHostname
+} from "../safe-bash/command-chunks/chunk-MDH5T4OS.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  privateHostname
+};

package/dist/safe-bash-network-engine/shared.d.ts

@@ -0,0 +1,14 @@
+import { type ByteSource, type CommandContext } from "../safe-bash-contracts/index.js";
+import { CurlError, type HttpHeaders, type NetworkLimits } from "./types.js";
+export declare const encode: (text: string) => Uint8Array;
+export declare function limitsFor(overrides?: Partial<NetworkLimits>): NetworkLimits;
+export declare function withSignal<Value>(operation: () => PromiseLike<Value> | Value, signal: AbortSignal): Promise<Value>;
+export declare function delay(milliseconds: number, signal: AbortSignal): Promise<void>;
+export declare function header(headers: HttpHeaders, name: string): string | undefined;
+export declare function networkError(error: unknown): CurlError;
+export declare function diagnostic(context: CommandContext, error: CurlError): Promise<void>;
+/** Buffered operands use a quota only when the host supplies one. */
+export declare function collectNetworkBytes(source: ByteSource, options: {
+    signal: AbortSignal;
+    maxBytes: number;
+}): Promise<Uint8Array>;