@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash-network-engine/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,4 @@
+import { type ByteSink, type CommandContext, type OutputOperation } from "../safe-bash-contracts/index.js";
+import { CurlError } from "./types.js";
+export declare function createDeadlineOutput(context: CommandContext, destination: ByteSink, remaining: number): OutputOperation;
+export declare function deadlineDiagnostic(context: CommandContext, error: CurlError, remaining: number): Promise<void>;

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

@@ -0,0 +1,37 @@
+import {
+  diagnostic
+} from "../safe-bash/command-chunks/chunk-FKKB5X5V.js";
+import {
+  CurlError
+} from "../safe-bash/command-chunks/chunk-IYPAQ7PH.js";
+import {
+  scheduleNetworkDeadline
+} from "../safe-bash/command-chunks/chunk-KWESKQHR.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/aggregate.ts
+init_buffer();
+import { createOutputOperation } from "../safe-bash-contracts/index.js";
+function createDeadlineOutput(context, destination, remaining) {
+  const lifetime = new AbortController();
+  const signal = AbortSignal.any([context.signal, lifetime.signal]);
+  const operation = createOutputOperation({ ...context, signal }, destination);
+  if (operation.signal.aborted) return operation;
+  const cancel = scheduleNetworkDeadline(remaining, () => lifetime.abort(new CurlError(28, "Operation timed out")));
+  operation.registerCleanup(cancel);
+  return operation;
+}
+async function deadlineDiagnostic(context, error, remaining) {
+  const operation = createDeadlineOutput(context, context.stderr, remaining);
+  try {
+    await diagnostic({ ...context, stderr: operation.output, signal: operation.signal }, error);
+  } finally {
+    await operation.close();
+  }
+}
+export {
+  createDeadlineOutput,
+  deadlineDiagnostic
+};

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

@@ -0,0 +1,68 @@
+import { type NetworkLimits } from "./types.js";
+export interface DataArgument {
+    readonly kind: "data" | "raw" | "binary" | "json" | "urlencode" | "form" | "form-string";
+    readonly value: string;
+}
+export interface CurlArguments {
+    caFile?: string;
+    etagSave?: string;
+    etagCompare?: string;
+    etag?: string;
+    query?: DataArgument[];
+    httpVersion?: "1.0" | "1.1";
+    ignoreContentLength?: boolean;
+    agent?: string;
+    referer?: string;
+    autoReferer?: boolean;
+    retryTransport?: boolean;
+    directoryIndex?: string;
+    download?: {
+        spider: boolean;
+        resume: boolean;
+        noClobber: boolean;
+        contentDisposition: boolean;
+    };
+    urls: string[];
+    data: DataArgument[];
+    headers: [string, string | null][];
+    method?: string;
+    range?: string;
+    continueAt?: number | "auto";
+    user?: string;
+    bearer?: string;
+    upload?: string;
+    output?: string;
+    outputs?: {
+        output?: string;
+        remoteName: boolean;
+    }[];
+    outputDirectory?: string;
+    dumpHeader?: string;
+    writeOut?: string;
+    include: boolean;
+    head: boolean;
+    get: boolean;
+    location: boolean;
+    remoteName: boolean;
+    fail: boolean;
+    failWithBody: boolean;
+    silent: boolean;
+    showError: boolean;
+    verbose: boolean;
+    globoff: boolean;
+    help: boolean;
+    version: boolean;
+    compressed?: boolean;
+    raw?: boolean;
+    retries: number;
+    retryDelayMs: number;
+    maxTimeMs: number;
+    connectTimeoutMs?: number;
+    maxRedirects: number;
+    maxFileSize: number;
+}
+export declare const values: Readonly<Record<string, string>>;
+export declare const flags: Readonly<Record<string, string>>;
+export declare const longValues: Set<string>;
+export declare function validateRequestHeader(name: string, value: string): void;
+export declare function parseArguments(args: readonly string[], limits: NetworkLimits): CurlArguments;

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

@@ -0,0 +1,19 @@
+import {
+  flags,
+  longValues,
+  parseArguments,
+  validateRequestHeader,
+  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 "../safe-bash/command-chunks/chunk-IYPAQ7PH.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  flags,
+  longValues,
+  parseArguments,
+  validateRequestHeader,
+  values
+};

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

@@ -0,0 +1,6 @@
+import type { NetworkAuthorizer } from "./types.js";
+export type OriginAllowlist = "*" | readonly string[];
+export interface OriginAuthorizerOptions {
+    readonly denyPrivateNetworks?: boolean;
+}
+export declare function createOriginAuthorizer(allowlist?: OriginAllowlist, options?: OriginAuthorizerOptions): NetworkAuthorizer;

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

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

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

@@ -0,0 +1,9 @@
+import { type ByteSource, type CommandContext } from "../safe-bash-contracts/index.js";
+import type { CurlArguments } from "./args.js";
+import { type NetworkLimits } from "./types.js";
+export interface RequestBody {
+    readonly contentType?: string;
+    open(signal: AbortSignal): ByteSource;
+}
+export declare function createBody(context: CommandContext, args: CurlArguments, limits: NetworkLimits): RequestBody | undefined;
+export declare function queryData(body: RequestBody, signal: AbortSignal, limits: NetworkLimits): Promise<string>;

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

@@ -0,0 +1,374 @@
+import {
+  formContentType
+} from "../safe-bash/command-chunks/chunk-CKXV2CLD.js";
+import {
+  filePartHeaders,
+  validatePartHeader
+} from "../safe-bash/command-chunks/chunk-E2LB7FRT.js";
+import {
+  randomBytes
+} from "../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,
+  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/body.ts
+init_buffer();
+import { readBytes } from "../safe-bash-contracts/index.js";
+import { posixPath as posix } from "../safe-bash-contracts/path.js";
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
+import { decodeBytes, encodeBytes } from "../safe-bash-io-engine/byte-encoding.js";
+import { pathOf } from "../safe-bash-io-engine/internal.js";
+function multipartBoundary() {
+  let boundary = "virtual-bash-";
+  for (const byte of randomBytes(18)) boundary += byte.toString(16).padStart(2, "0");
+  return boundary;
+}
+function percent(bytes) {
+  let output = "";
+  for (const byte of bytes) output += byte >= 65 && byte <= 90 || byte >= 97 && byte <= 122 || byte >= 48 && byte <= 57 || [45, 46, 95, 126].includes(byte) ? String.fromCharCode(byte) : byte === 32 ? "+" : `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+  return encode(output);
+}
+function dataPart(argument) {
+  const value = argument.value;
+  if (argument.kind === "urlencode") {
+    const equals = value.indexOf("=");
+    if (equals >= 0) return [{ bytes: encode(equals ? `${value.slice(0, equals)}=` : "") }, { bytes: encode(value.slice(equals + 1)), urlencode: true }];
+    const at = value.indexOf("@");
+    if (at >= 0) return [{ prefix: encode(at ? `${value.slice(0, at)}=` : ""), file: value.slice(at + 1), urlencode: true }];
+    return [{ bytes: encode(value), urlencode: true }];
+  }
+  if (argument.kind !== "raw" && value.startsWith("@")) return [{ file: value.slice(1), strip: argument.kind === "data" }];
+  return [{ bytes: encode(value) }];
+}
+function quoted(value) {
+  if (/[\r\n\0]/.test(value)) throw new CurlError(2, "Invalid multipart field metadata");
+  return value.replace(/["\\]/g, "\\$&");
+}
+function formWord(input, start, file) {
+  const delimiter = (character) => character === ";" || file && character === ",";
+  if (input[start] === '"') {
+    let value = "";
+    for (let index = start + 1; index < input.length; index++) {
+      const character = input[index];
+      if (character === '"') {
+        let end2 = index + 1;
+        while (end2 < input.length && !delimiter(input[end2])) end2++;
+        return { value, end: end2 };
+      }
+      if (character === "\\" && (input[index + 1] === "\\" || input[index + 1] === '"')) {
+        value += input[++index];
+      } else value += character;
+    }
+  }
+  let end = start;
+  while (end < input.length && !delimiter(input[end])) end++;
+  return { value: input.slice(start, end), end };
+}
+var multipartContentTypes = /* @__PURE__ */ new Map([
+  ["gif", "image/gif"],
+  ["jpg", "image/jpeg"],
+  ["jpeg", "image/jpeg"],
+  ["png", "image/png"],
+  ["svg", "image/svg+xml"],
+  ["txt", "text/plain"],
+  ["html", "text/html"],
+  ["htm", "text/html"],
+  ["pdf", "application/pdf"],
+  ["xml", "application/xml"]
+]);
+function filenameContentType(filename) {
+  const basename = posix.basename(filename);
+  const dot = basename.lastIndexOf(".");
+  return dot < 0 ? void 0 : multipartContentTypes.get(basename.slice(dot + 1).toLowerCase());
+}
+function multipart(argument, boundary) {
+  const equals = argument.value.indexOf("=");
+  if (equals < 0) throw new CurlError(2, "Multipart form requires name=value");
+  const name = quoted(argument.value.slice(0, equals));
+  const input = argument.value.slice(equals + 1);
+  const upload = argument.kind === "form" && input.startsWith("@");
+  const isFile = argument.kind === "form" && (upload || input.startsWith("<"));
+  const entries = [];
+  let start = isFile ? 1 : 0;
+  do {
+    const word = argument.kind === "form" ? formWord(input, start, isFile) : { value: input, end: input.length };
+    const entry = { value: word.value };
+    if (isFile) {
+      if (!word.value) throw new CurlError(2, "Empty multipart file operand");
+      entry.file = word.value;
+      if (upload) entry.filename = posix.basename(word.value);
+    }
+    let end = word.end;
+    while (end < input.length && input[end] !== ",") {
+      const attributeStart = end + 1;
+      if (input.startsWith("type=", attributeStart)) {
+        const attribute = formContentType(input, attributeStart + 5, upload);
+        entry.type = attribute.value;
+        end = attribute.end;
+      } else if (input.startsWith("filename=", attributeStart)) {
+        const attribute = formWord(input, attributeStart + 9, upload);
+        entry.filename = attribute.value;
+        end = attribute.end;
+      } else if (input.startsWith("headers=", attributeStart)) {
+        const file = input[attributeStart + 8] === "@";
+        const attribute = formWord(input, attributeStart + 8 + (file ? 1 : 0), upload);
+        if (!attribute.value) throw new CurlError(2, "Empty multipart header operand");
+        (entry.headers ??= []).push({ value: file ? attribute.value : validatePartHeader(attribute.value), file });
+        end = attribute.end;
+      } else if (input.startsWith("encoder=", attributeStart)) {
+        const attribute = formWord(input, attributeStart + 8, upload);
+        entry.encoder = attribute.value.toLowerCase();
+        end = attribute.end;
+        if (!["binary", "8bit", "7bit", "base64", "quoted-printable"].includes(entry.encoder))
+          throw new CurlError(2, "Unsupported multipart transfer encoder");
+      } else throw new CurlError(2, "Unsupported multipart form attribute");
+    }
+    entries.push(entry);
+    if (end === input.length) break;
+    if (!upload) throw new CurlError(2, "Unsupported multipart file list");
+    start = end + 1;
+  } while (start <= input.length);
+  const mixed = entries.length > 1;
+  const childBoundary = mixed ? multipartBoundary() : boundary;
+  const disposition = `form-data${name ? `; name="${name}"` : ""}`;
+  const parts = [];
+  if (mixed) parts.push({ bytes: encode(`--${boundary}\r
+Content-Disposition: ${disposition}\r
+Content-Type: multipart/mixed; boundary=${childBoundary}\r
+\r
+`) });
+  for (const entry of entries) {
+    let preamble = `--${childBoundary}\r
+Content-Disposition: ${mixed ? "attachment" : disposition}`;
+    if (entry.filename !== void 0) preamble += `; filename="${quoted(entry.filename)}"`;
+    preamble += "\r\n";
+    if (entry.type || entry.filename !== void 0) {
+      const inferred = entry.filename === void 0 ? void 0 : filenameContentType(entry.filename) ?? (entry.file === void 0 ? void 0 : filenameContentType(entry.file));
+      preamble += `Content-Type: ${entry.type ?? inferred ?? "application/octet-stream"}\r
+`;
+    }
+    if (entry.encoder) preamble += `Content-Transfer-Encoding: ${entry.encoder}\r
+`;
+    const encoding = entry.encoder === void 0 ? {} : { encoder: entry.encoder };
+    parts.push({ bytes: encode(preamble), headers: entry.headers ?? [] }, entry.file !== void 0 ? { file: entry.file, ...encoding } : { bytes: encode(entry.value), ...encoding }, { bytes: encode("\r\n") });
+  }
+  if (mixed) parts.push({ bytes: encode(`--${childBoundary}--\r
+\r
+`) });
+  return parts;
+}
+async function* transfer(source, encoder, signal) {
+  if (!encoder || encoder === "binary" || encoder === "8bit") {
+    yield* source;
+    return;
+  }
+  let pending = [];
+  let column = 0;
+  let output = "";
+  const quotedByte = (byte, next, after) => {
+    if (byte === 13 && next === 10) {
+      output += "\r\n";
+      column = 0;
+      return 2;
+    }
+    const trailing = next === void 0 || next === 13 && after === 10;
+    const literal = byte >= 33 && byte <= 126 && byte !== 61 || (byte === 32 || byte === 9) && !trailing;
+    const token = literal ? String.fromCharCode(byte) : `=${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+    if (column + token.length > 75) {
+      output += "=\r\n";
+      column = 0;
+    }
+    output += token;
+    column += token.length;
+    return 1;
+  };
+  for await (const raw of source) {
+    for (let offset = 0; offset < raw.length; offset += 16 * 1024) {
+      signal.throwIfAborted();
+      const chunk = raw.subarray(offset, offset + 16 * 1024);
+      if (encoder === "7bit") {
+        if (chunk.some((byte) => byte > 127)) throw new CurlError(26, "Non-ASCII byte in 7bit multipart data");
+        yield chunk;
+        continue;
+      }
+      pending.push(...chunk);
+      let consumed = 0;
+      if (encoder === "base64") {
+        while (pending.length - consumed >= 57) {
+          if (column) output += "\r\n";
+          output += decodeBytes(encodeBytes(pending.slice(consumed, consumed + 57)), "base64");
+          consumed += 57;
+          column = 76;
+        }
+      } else {
+        while (pending.length - consumed >= 3)
+          consumed += quotedByte(pending[consumed], pending[consumed + 1], pending[consumed + 2]);
+      }
+      pending = pending.slice(consumed);
+      if (output) {
+        yield encode(output);
+        output = "";
+      }
+      await yieldTurn(signal);
+    }
+  }
+  signal.throwIfAborted();
+  if (encoder === "base64" && pending.length) {
+    if (column) output += "\r\n";
+    output += decodeBytes(encodeBytes(pending), "base64");
+  } else if (encoder === "quoted-printable") {
+    for (let i = 0; i < pending.length; )
+      i += quotedByte(pending[i], pending[i + 1], pending[i + 2]);
+  }
+  if (output) yield encode(output);
+}
+function createBody(context, args, limits) {
+  if (!args.data.length && args.upload === void 0) return void 0;
+  const parts = [];
+  let contentType;
+  const form = args.data.some((part) => part.kind.startsWith("form"));
+  if (form) {
+    const boundary = multipartBoundary();
+    contentType = `multipart/form-data; boundary=${boundary}`;
+    for (const argument of args.data) parts.push(...multipart(argument, boundary));
+    parts.push({ bytes: encode(`--${boundary}--\r
+`) });
+  } else if (args.upload !== void 0) parts.push({ file: args.upload });
+  else {
+    const json = args.data[0]?.kind === "json";
+    contentType = json ? "application/json" : "application/x-www-form-urlencoded";
+    args.data.forEach((argument, index) => {
+      if (index && !json) parts.push({ bytes: encode("&"), separator: true });
+      parts.push(...dataPart(argument));
+    });
+  }
+  const hasStdin = parts.some((part) => part.file === "-");
+  let opened = false;
+  let replayComplete = false;
+  let replayable = true;
+  let cachedBytes = 0;
+  let cache = [];
+  let stdinUsed = false;
+  const source = async function* (part, signal) {
+    if (part.bytes !== void 0) {
+      if (!part.headers) {
+        yield part.bytes;
+        return;
+      }
+      const headers = [];
+      let headerBytes = 0;
+      for (const header of part.headers) {
+        signal.throwIfAborted();
+        if (header.file) {
+          const bytes = await collectNetworkBytes(source({ file: header.value }, signal), {
+            signal,
+            maxBytes: Math.min(limits.maxBufferBytes, limits.maxUploadBytes) - headerBytes
+          });
+          headerBytes += bytes.length;
+          headers.push(...filePartHeaders(bytes));
+        } else {
+          headerBytes += encode(header.value).length;
+          if (headerBytes > Math.min(limits.maxBufferBytes, limits.maxUploadBytes))
+            throw new CurlError(63, "Multipart headers exceed host byte limit");
+          headers.push(header.value);
+        }
+      }
+      const overridden = new Set(headers.map((header) => header.slice(0, header.indexOf(":")).toLowerCase()));
+      const defaults = decodeBytes(encodeBytes(part.bytes), "utf8").split("\r\n");
+      const preamble = defaults.filter((line, index) => index === 0 || line && !overridden.has(line.slice(0, line.indexOf(":")).toLowerCase()));
+      yield encode([...preamble, ...headers, "", ""].join("\r\n"));
+      return;
+    }
+    if (part.file === "-") {
+      if (!stdinUsed) {
+        stdinUsed = true;
+        yield* readBytes(context.stdin, signal);
+      }
+      return;
+    }
+    try {
+      const path = pathOf(context, part.file);
+      const capabilities = await context.fs.capabilitiesFor?.(path, { signal }) ?? context.fs.capabilities;
+      signal.throwIfAborted();
+      if (context.fs.readStream && capabilities.streamingRead !== false) yield* readBytes(context.fs.readStream(path, { signal }), signal);
+      else yield await context.fs.readFile(path, { signal, ...Number.isFinite(Math.min(limits.maxBufferBytes, limits.maxUploadBytes)) ? { maxBytes: Math.min(limits.maxBufferBytes, limits.maxUploadBytes) } : {} });
+    } catch (error) {
+      signal.throwIfAborted();
+      if (error instanceof CurlError) throw error;
+      throw new CurlError(26, "Failed to read virtual upload file");
+    }
+  };
+  return {
+    ...contentType === void 0 ? {} : { contentType },
+    open(signal) {
+      return (async function* () {
+        if (hasStdin && opened) {
+          if (!replayComplete || !replayable) throw new CurlError(65, "Cannot replay stdin upload within the host buffer limit");
+          for (const chunk of cache) {
+            signal.throwIfAborted();
+            yield chunk.slice();
+          }
+          return;
+        }
+        opened = true;
+        let count = 0;
+        let chunks = 0;
+        for (const part of parts) {
+          if (part.separator && count === 0) continue;
+          let prefix = part.prefix;
+          for await (const raw of transfer(source(part, signal), part.encoder, signal)) {
+            if (++chunks % 256 === 0) await yieldTurn(signal);
+            for (let offset = 0; offset < raw.length; offset += 16 * 1024) {
+              signal.throwIfAborted();
+              let chunk = raw.subarray(offset, offset + 16 * 1024);
+              if (part.strip) chunk = chunk.filter((byte) => byte !== 0 && byte !== 10 && byte !== 13);
+              if (part.urlencode) chunk = percent(chunk);
+              count += chunk.length + (prefix?.length ?? 0);
+              if (count > limits.maxUploadBytes) throw new CurlError(63, "Upload exceeds host byte limit");
+              if (prefix?.length) {
+                const prefixed = new Uint8Array(prefix.length + chunk.length);
+                prefixed.set(prefix);
+                prefixed.set(chunk, prefix.length);
+                chunk = prefixed;
+                prefix = void 0;
+              }
+              if (hasStdin && replayable) {
+                cachedBytes += chunk.length;
+                if (cachedBytes > limits.maxBufferBytes) {
+                  replayable = false;
+                  cache = [];
+                } else cache.push(new Uint8Array(chunk));
+              }
+              if (chunk.length) yield chunk;
+            }
+          }
+        }
+        replayComplete = true;
+      })();
+    }
+  };
+}
+async function queryData(body, signal, limits) {
+  try {
+    return decodeBytes(encodeBytes(await collectNetworkBytes(body.open(signal), { signal, maxBytes: limits.maxBufferBytes })), "utf8");
+  } catch (error) {
+    signal.throwIfAborted();
+    if (error instanceof CurlError) throw error;
+    throw new CurlError(63, "Query data exceeds host buffer limit");
+  }
+}
+export {
+  createBody,
+  queryData
+};

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

@@ -0,0 +1,2 @@
+/** Long deadlines are rearmed rather than truncated by the host timer range. */
+export declare function scheduleNetworkDeadline(milliseconds: number, expire: () => void): () => void;

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

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

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

@@ -0,0 +1,2 @@
+import { type ByteSource } from "../safe-bash-contracts/index.js";
+export declare function decodeContent(source: ByteSource, encoding: string, signal: AbortSignal, maxBytes: number): ByteSource;

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

@@ -0,0 +1,81 @@
+import {
+  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/decode.ts
+init_buffer();
+import { readBytes } from "../safe-bash-contracts/index.js";
+var maxEncodingLayers = 4;
+async function* decodeContent(source, encoding, signal, maxBytes) {
+  let layers = 1;
+  for (const character of encoding) {
+    if (character === "," && ++layers > maxEncodingLayers) throw new CurlError(61, "Too many content encoding layers");
+  }
+  const formats = encoding.split(",").map((value) => value.trim().toLowerCase()).filter((value) => value !== "identity");
+  if (formats.some((value) => value !== "gzip" && value !== "deflate")) throw new CurlError(61, "Unsupported content encoding");
+  if (!formats.length) {
+    yield* source;
+    return;
+  }
+  const iterator = readBytes(source, signal)[Symbol.asyncIterator]();
+  let inputError;
+  let inputFailed = false;
+  let stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        const next = await iterator.next();
+        if (next.done) controller.close();
+        else controller.enqueue(new Uint8Array(next.value));
+      } catch (error) {
+        inputFailed = true;
+        inputError = error;
+        controller.error(error);
+      }
+    },
+    async cancel() {
+      await iterator.return?.(void 0);
+    }
+  }, { highWaterMark: 0 });
+  let budgetError;
+  for (const format of formats.reverse()) {
+    let decodedBytes = 0;
+    stream = stream.pipeThrough(new DecompressionStream(format)).pipeThrough(new TransformStream({
+      transform(chunk, controller) {
+        signal.throwIfAborted();
+        decodedBytes += chunk.byteLength;
+        if (decodedBytes > maxBytes) {
+          budgetError = new CurlError(63, "Decoded response exceeds download byte limit");
+          throw budgetError;
+        }
+        controller.enqueue(chunk);
+      }
+    }));
+  }
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const next = await withSignal(() => reader.read(), signal);
+      if (next.done) return;
+      yield next.value;
+    }
+  } catch {
+    signal.throwIfAborted();
+    if (inputFailed) throw inputError;
+    if (budgetError) throw budgetError;
+    throw new CurlError(61, "Invalid compressed response body");
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    await iterator.return(void 0).catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+export {
+  decodeContent
+};

package/dist/safe-bash-network-engine/fetch-transport.d.ts

@@ -0,0 +1,7 @@
+import { type HttpTransport } from "./types.js";
+export interface FetchTransportOptions {
+    readonly fetch?: typeof globalThis.fetch;
+    /** Set false only for a host Fetch implementation that preserves encoded body bytes. */
+    readonly contentDecoded?: boolean;
+}
+export declare function createFetchTransport(options?: FetchTransportOptions): HttpTransport;

package/dist/safe-bash-network-engine/fetch-transport.js

@@ -0,0 +1,9 @@
+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
+};