@poe-platform/safe-bash 0.1.789 → 0.1.790

package/dist/safe-bash/{chunks/chunk-LD76P7AG.js → command-chunks/chunk-AKDMCNX4.js}

@@ -1,9 +1,9 @@
 import {
-  init_platform
-} from "./chunk-Q45QCA4J.js";
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
 
-// packages/safe-bash/src/commands/llm/mime.ts
-init_platform();
+// packages/safe-bash-command-llm/dist/mime.js
+init_buffer();
 import { classify } from "../../safe-bash-command-file/classify.js";
 var extensions = {
   png: "image/png",
@@ -48,35 +48,45 @@ var extensions = {
 };
 function ebmlInteger(bytes, offset, retainMarker = false) {
   const first = bytes[offset];
-  if (!first) return void 0;
+  if (!first)
+    return void 0;
   let marker = 128, width = 1;
   while (!(first & marker)) {
     marker >>= 1;
     width++;
   }
-  if (offset + width > bytes.length) return void 0;
+  if (offset + width > bytes.length)
+    return void 0;
   let value = retainMarker ? first : first & marker - 1;
-  for (let index = 1; index < width; index++) value = value * 256 + bytes[offset + index];
-  if (!Number.isSafeInteger(value) || !retainMarker && value === 2 ** (7 * width) - 1) return void 0;
+  for (let index = 1; index < width; index++)
+    value = value * 256 + bytes[offset + index];
+  if (!Number.isSafeInteger(value) || !retainMarker && value === 2 ** (7 * width) - 1)
+    return void 0;
   return { value, width };
 }
 function ebmlMimeType(bytes) {
   const header = ebmlInteger(bytes, 4);
-  if (!header) return void 0;
+  if (!header)
+    return void 0;
   let offset = 4 + header.width;
   const end = Math.min(bytes.length, offset + header.value, 4096);
   while (offset < end) {
     const identifier = ebmlInteger(bytes, offset, true);
-    if (!identifier) return void 0;
+    if (!identifier)
+      return void 0;
     offset += identifier.width;
     const size = ebmlInteger(bytes, offset);
-    if (!size) return void 0;
+    if (!size)
+      return void 0;
     offset += size.width;
-    if (size.value > end - offset) return void 0;
+    if (size.value > end - offset)
+      return void 0;
     if (identifier.value === 17026) {
       const docType = new TextDecoder().decode(bytes.subarray(offset, offset + size.value)).split("\0", 1)[0];
-      if (docType === "webm") return "video/webm";
-      if (docType === "matroska") return "video/x-matroska";
+      if (docType === "webm")
+        return "video/webm";
+      if (docType === "matroska")
+        return "video/x-matroska";
       return void 0;
     }
     offset += size.value;
@@ -86,53 +96,78 @@ function ebmlMimeType(bytes) {
 function sniffMimeType(path, bytes) {
   const matches = (signature, offset = 0) => bytes.length >= offset + signature.length && signature.every((byte, index) => bytes[offset + index] === byte);
   const ascii = (offset, text) => bytes.length >= offset + text.length && [...text].every((character, index) => bytes[offset + index] === character.charCodeAt(0));
-  if (matches([137, 80, 78, 71, 13, 10, 26, 10])) return "image/png";
-  if (matches([255, 216, 255])) return "image/jpeg";
-  if (ascii(0, "GIF87a") || ascii(0, "GIF89a")) return "image/gif";
+  if (matches([137, 80, 78, 71, 13, 10, 26, 10]))
+    return "image/png";
+  if (matches([255, 216, 255]))
+    return "image/jpeg";
+  if (ascii(0, "GIF87a") || ascii(0, "GIF89a"))
+    return "image/gif";
   if (ascii(0, "RIFF")) {
-    if (ascii(8, "WEBP")) return "image/webp";
-    if (ascii(8, "WAVE")) return "audio/wav";
-    if (ascii(8, "AVI ")) return "video/x-msvideo";
+    if (ascii(8, "WEBP"))
+      return "image/webp";
+    if (ascii(8, "WAVE"))
+      return "audio/wav";
+    if (ascii(8, "AVI "))
+      return "video/x-msvideo";
   }
-  if (ascii(0, "fLaC")) return "audio/flac";
+  if (ascii(0, "fLaC"))
+    return "audio/flac";
   if (ascii(0, "OggS")) {
     const packet = 27 + (bytes[26] ?? 0);
-    if (bytes[26] && bytes[packet] === 128 && ascii(packet + 1, "theora")) return "video/ogg";
+    if (bytes[26] && bytes[packet] === 128 && ascii(packet + 1, "theora"))
+      return "video/ogg";
     return "audio/ogg";
   }
-  if (ascii(0, "ID3") || bytes.length >= 2 && bytes[0] === 255 && (bytes[1] & 224) === 224 && (bytes[1] & 6) !== 0) return "audio/mpeg";
-  if (bytes.length >= 2 && bytes[0] === 255 && (bytes[1] & 246) === 240) return "audio/aac";
-  if (ascii(0, "FORM") && (ascii(8, "AIFF") || ascii(8, "AIFC"))) return "audio/aiff";
+  if (ascii(0, "ID3") || bytes.length >= 2 && bytes[0] === 255 && (bytes[1] & 224) === 224 && (bytes[1] & 6) !== 0)
+    return "audio/mpeg";
+  if (bytes.length >= 2 && bytes[0] === 255 && (bytes[1] & 246) === 240)
+    return "audio/aac";
+  if (ascii(0, "FORM") && (ascii(8, "AIFF") || ascii(8, "AIFC")))
+    return "audio/aiff";
   if (ascii(4, "ftyp")) {
-    if (ascii(8, "avif") || ascii(8, "avis")) return "image/avif";
-    if (ascii(8, "heic") || ascii(8, "heix")) return "image/heic";
-    if (ascii(8, "mif1") || ascii(8, "msf1")) return "image/heif";
-    if (ascii(8, "M4A ") || ascii(8, "M4B ")) return "audio/mp4";
-    if (ascii(8, "qt  ")) return "video/quicktime";
+    if (ascii(8, "avif") || ascii(8, "avis"))
+      return "image/avif";
+    if (ascii(8, "heic") || ascii(8, "heix"))
+      return "image/heic";
+    if (ascii(8, "mif1") || ascii(8, "msf1"))
+      return "image/heif";
+    if (ascii(8, "M4A ") || ascii(8, "M4B "))
+      return "audio/mp4";
+    if (ascii(8, "qt  "))
+      return "video/quicktime";
     return "video/mp4";
   }
   if (matches([26, 69, 223, 163])) {
     const mimeType = ebmlMimeType(bytes);
-    if (mimeType) return mimeType;
+    if (mimeType)
+      return mimeType;
   }
-  if (ascii(0, "%PDF-")) return "application/pdf";
-  if (matches([80, 75, 3, 4]) || matches([80, 75, 5, 6])) return "application/zip";
-  if (matches([31, 139])) return "application/gzip";
-  if (matches([73, 73, 42, 0]) || matches([77, 77, 0, 42])) return "image/tiff";
-  if (ascii(0, "BM")) return "image/bmp";
+  if (ascii(0, "%PDF-"))
+    return "application/pdf";
+  if (matches([80, 75, 3, 4]) || matches([80, 75, 5, 6]))
+    return "application/zip";
+  if (matches([31, 139]))
+    return "application/gzip";
+  if (matches([73, 73, 42, 0]) || matches([77, 77, 0, 42]))
+    return "image/tiff";
+  if (ascii(0, "BM"))
+    return "image/bmp";
   const prefix = bytes.subarray(0, 512);
   const classified = classify(prefix, bytes.length <= prefix.length).mime;
-  if (!["application/octet-stream", "text/plain", "inode/x-empty"].includes(classified)) return classified;
+  if (!["application/octet-stream", "text/plain", "inode/x-empty"].includes(classified))
+    return classified;
   const filename = path.slice(path.lastIndexOf("/") + 1);
   const dot = filename.lastIndexOf(".");
   const extension = dot < 0 ? "" : filename.slice(dot + 1).toLowerCase();
   return Object.hasOwn(extensions, extension) ? extensions[extension] : classified === "inode/x-empty" ? "application/octet-stream" : classified;
 }
 function acceptsMimeType(types, mimeType) {
-  if ([...mimeType].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)) return false;
+  if ([...mimeType].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127))
+    return false;
   const mime = mimeType.split(";", 1)[0].trim().toLowerCase();
   const parts = mime.split("/");
-  if (parts.length !== 2 || parts.some((part) => !part || [...part].some((character) => !(character >= "a" && character <= "z" || character >= "0" && character <= "9" || "!#$%&'+-.^_`|~".includes(character))))) return false;
+  if (parts.length !== 2 || parts.some((part) => !part || [...part].some((character) => !(character >= "a" && character <= "z" || character >= "0" && character <= "9" || "!#$%&'+-.^_`|~".includes(character)))))
+    return false;
   return types.some((type) => {
     const accepted = type.toLowerCase();
     return accepted === mime || accepted.endsWith("/*") && accepted.slice(0, -2) === parts[0];

package/dist/safe-bash/command-chunks/{chunk-6F7QJMJ3.js → chunk-CBDVLMJB.js}

@@ -1,6 +1,6 @@
 import {
   pathOf
-} from "./chunk-UJOO6DKY.js";
+} from "./chunk-6EASC5EC.js";
 import {
   inputRequirements
 } from "./chunk-YAFQG4SC.js";

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

@@ -0,0 +1,169 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/openai-http.js
+init_buffer();
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+function openAiAbortable(pending, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve(pending).then((value) => {
+      signal.removeEventListener("abort", abort);
+      if (signal.aborted)
+        reject(signal.reason);
+      else
+        resolve(value);
+    }, (error) => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.aborted ? signal.reason : error);
+    });
+    if (signal.aborted)
+      abort();
+  });
+}
+async function* openAiBytes(source, signal, limit = Infinity) {
+  signal.throwIfAborted();
+  const iterator = source[Symbol.asyncIterator]();
+  let failed = false, finished = false;
+  let size = 0, windows = 0;
+  try {
+    while (true) {
+      signal.throwIfAborted();
+      const next = await openAiAbortable(iterator.next(), signal);
+      if (next.done) {
+        finished = true;
+        return;
+      }
+      if (!(next.value instanceof Uint8Array))
+        throw new Error("OpenAI returned a non-byte response chunk");
+      size += next.value.byteLength;
+      if (size > limit)
+        throw new RangeError("Provider response byte limit exceeded");
+      if (!next.value.byteLength)
+        yield new Uint8Array(0);
+      for (let offset = 0; offset < next.value.byteLength; offset += 16384) {
+        if (++windows % 64 === 0)
+          await yieldTurn(signal);
+        signal.throwIfAborted();
+        yield Uint8Array.from(next.value.subarray(offset, offset + 16384));
+      }
+    }
+  } catch (error) {
+    failed = true;
+    throw signal.aborted ? signal.reason : error;
+  } finally {
+    if (!finished) {
+      const returned = Promise.resolve().then(() => iterator.return?.());
+      if (signal.aborted)
+        void returned.catch(() => void 0);
+      else
+        await openAiAbortable(returned, signal).catch((error) => {
+          if (!failed)
+            throw error;
+        });
+    }
+  }
+}
+async function openAiJson(response, signal, maxBytes = Infinity) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let text = "", length = 0;
+  for await (const chunk of openAiBytes(response.body, signal, maxBytes)) {
+    length += chunk.byteLength;
+    if (length > maxBytes)
+      throw new Error("OpenAI JSON response exceeds buffer limit");
+    text += decoder.decode(chunk, { stream: true });
+  }
+  text += decoder.decode();
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error("OpenAI returned malformed JSON");
+  }
+  if (!openAiRecord(value))
+    throw new Error("OpenAI returned a non-object JSON response");
+  return value;
+}
+function openAiRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function openAiError(value) {
+  if (typeof value === "string" && value)
+    return value.slice(0, 1024);
+  if (openAiRecord(value) && typeof value.message === "string")
+    return value.message.slice(0, 1024);
+  return void 0;
+}
+async function* openAiResponse(transport, input, maxResponseBytes) {
+  input.signal.throwIfAborted();
+  const cleanups = /* @__PURE__ */ new Map();
+  let closed = false, failed = false;
+  const run = (cleanup) => {
+    cleanup.pending ??= Promise.resolve().then(cleanup.run);
+    return cleanup.pending;
+  };
+  const register = (cleanup, receiver) => {
+    if (cleanups.has(cleanup))
+      return;
+    const entry = { run: () => cleanup.call(receiver) };
+    cleanups.set(cleanup, entry);
+    if (closed)
+      void run(entry).catch(() => void 0);
+  };
+  const close = async () => {
+    closed = true;
+    const results = await Promise.allSettled([...cleanups.values()].map(run));
+    const rejected = results.find((result) => result.status === "rejected");
+    if (rejected?.status === "rejected")
+      throw rejected.reason;
+  };
+  const abort = () => {
+    void close().catch(() => void 0);
+  };
+  input.signal.addEventListener("abort", abort, { once: true });
+  try {
+    const pending = Promise.resolve().then(() => {
+      input.signal.throwIfAborted();
+      return transport({ ...input, registerCleanup: register });
+    }).then((response2) => {
+      register(response2.dispose, response2);
+      return response2;
+    });
+    const response = await openAiAbortable(pending, input.signal);
+    if (!Number.isInteger(response.status) || response.status < 200 || response.status >= 300) {
+      let detail;
+      try {
+        detail = openAiError((await openAiJson(response, input.signal, maxResponseBytes)).error);
+      } catch {
+        input.signal.throwIfAborted();
+      }
+      throw new Error(`OpenAI HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+    }
+    yield response;
+  } catch (error) {
+    failed = true;
+    throw input.signal.aborted ? input.signal.reason : error;
+  } finally {
+    input.signal.removeEventListener("abort", abort);
+    await close().catch((error) => {
+      if (!failed && !input.signal.aborted)
+        throw error;
+    });
+    if (!failed)
+      input.signal.throwIfAborted();
+  }
+}
+
+export {
+  openAiAbortable,
+  openAiBytes,
+  openAiJson,
+  openAiRecord,
+  openAiError,
+  openAiResponse
+};

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

@@ -0,0 +1,145 @@
+import {
+  streamElevenLabs
+} from "./chunk-VNSJKXDU.js";
+import {
+  credential,
+  jsonBody,
+  providerLimits
+} from "./chunk-QTYZAWSB.js";
+import {
+  acceptsMimeType
+} from "./chunk-AKDMCNX4.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/elevenlabs.js
+init_buffer();
+var outputFormats = /* @__PURE__ */ new Map([
+  ["audio/mpeg", "mp3_44100_128"],
+  ["audio/wav", "wav_44100"],
+  ["audio/x-wav", "wav_44100"],
+  ["audio/pcm", "pcm_44100"],
+  ["audio/basic", "ulaw_8000"],
+  ["audio/opus", "opus_48000_128"],
+  ["audio/ogg", "opus_48000_128"]
+]);
+var optionTypes = {
+  tts: /* @__PURE__ */ new Map([
+    ["stability", "number"],
+    ["similarity_boost", "number"],
+    ["style", "number"],
+    ["speed", "number"],
+    ["use_speaker_boost", "boolean"]
+  ]),
+  music: /* @__PURE__ */ new Map([
+    ["music_length_ms", "integer"],
+    ["seed", "integer"],
+    ["force_instrumental", "boolean"],
+    ["respect_sections_durations", "boolean"],
+    ["store_for_inpainting", "boolean"],
+    ["sign_with_c2pa", "boolean"]
+  ])
+};
+function parseOptions(options, endpoint) {
+  return Object.fromEntries(Object.entries(options).map(([key, value]) => {
+    const type = optionTypes[endpoint].get(key);
+    if (!type)
+      return [key, value];
+    if (type === "boolean") {
+      if (typeof value === "boolean")
+        return [key, value];
+      if (value === "true" || value === "false")
+        return [key, value === "true"];
+    } else {
+      const number = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : NaN;
+      if (Number.isFinite(number) && (type !== "integer" || Number.isSafeInteger(number)))
+        return [key, number];
+    }
+    throw new Error(`Invalid ElevenLabs option ${key}: expected ${type}`);
+  }));
+}
+function createElevenLabsProvider(options) {
+  const transport = options.transport;
+  if (typeof transport !== "function")
+    throw new TypeError("Provider transport is required");
+  const apiKey = credential(options.apiKey);
+  const limits = providerLimits(options.limits);
+  const baseUrl = new URL(options.baseUrl ?? "https://api.elevenlabs.io");
+  if (!["https:", "http:"].includes(baseUrl.protocol) || baseUrl.username || baseUrl.password || baseUrl.search || baseUrl.hash) {
+    throw new Error("Invalid ElevenLabs baseUrl: expected an HTTP(S) URL without credentials, query, or fragment");
+  }
+  if (!baseUrl.pathname.endsWith("/"))
+    baseUrl.pathname += "/";
+  const models = options.models.map((model) => Object.freeze({
+    ...model,
+    ...model.aliases === void 0 ? {} : { aliases: Object.freeze([...model.aliases]) },
+    ...model.attachmentTypes === void 0 ? {} : { attachmentTypes: Object.freeze([...model.attachmentTypes]) }
+  }));
+  const byId = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    if (model.endpoint !== "tts" && model.endpoint !== "music")
+      throw new Error(`Invalid ElevenLabs endpoint: ${model.endpoint}`);
+    if (!model.outputType)
+      throw new TypeError("ElevenLabs models require an audio outputType");
+    const mimeType = model.outputType.split(";", 1)[0].trim().toLowerCase();
+    const format = outputFormats.get(mimeType);
+    if (!format || !acceptsMimeType([mimeType], model.outputType) || model.endpoint === "music" && format.startsWith("wav_")) {
+      throw new Error(`Unsupported ElevenLabs outputType for ${model.endpoint}: ${model.outputType}`);
+    }
+    if (model.attachmentTypes?.length)
+      throw new Error(`ElevenLabs model ${model.id} does not accept attachments`);
+    if (!model.id || byId.has(model.id))
+      throw new Error(`Duplicate or empty ElevenLabs model: ${model.id}`);
+    byId.set(model.id, { model, format });
+  }
+  return {
+    name: "elevenlabs",
+    models: Object.freeze(models),
+    async *complete(request) {
+      request.signal.throwIfAborted();
+      const entry = byId.get(request.model);
+      if (!entry)
+        throw new Error(`Unknown model: ${request.model}`);
+      const { model, format } = entry;
+      if (request.attachments.length)
+        throw new Error(`Model ${model.id} does not accept ${request.attachments[0].mimeType} attachments`);
+      if (request.messages?.length || request.schema !== void 0)
+        throw new TypeError("ElevenLabs reference endpoints do not accept messages or schemas");
+      if (request.system !== void 0)
+        throw new TypeError("ElevenLabs reference endpoints do not accept system prompts");
+      const { output_format: requestedFormat, ...requestOptions } = request.options;
+      if (requestedFormat !== void 0 && requestedFormat !== format)
+        throw new TypeError("output_format conflicts with model outputType");
+      let path;
+      let body;
+      if (model.endpoint === "tts") {
+        const { voice_id: suppliedVoice, ...settings } = requestOptions;
+        const voice = suppliedVoice ?? model.defaultVoiceId;
+        if (typeof voice !== "string" || !voice.trim())
+          throw new Error(`ElevenLabs model ${model.id} requires voice_id or a configured defaultVoiceId`);
+        if (voice === "." || voice === "..")
+          throw new Error("Invalid ElevenLabs voice_id: dot segments are not allowed");
+        path = `v1/text-to-speech/${encodeURIComponent(voice)}`;
+        body = { text: request.prompt, model_id: model.id, voice_settings: parseOptions(settings, model.endpoint) };
+      } else {
+        path = "v1/music";
+        body = { ...parseOptions(requestOptions, model.endpoint), prompt: request.prompt, model_id: model.id };
+      }
+      const url = new URL(path, baseUrl);
+      url.searchParams.set("output_format", format);
+      const payload = jsonBody(body, limits.maxRequestBytes);
+      yield* streamElevenLabs(transport, {
+        url: url.href,
+        method: "POST",
+        headers: [["xi-api-key", apiKey], ...payload.headers, ["accept", model.outputType]],
+        body: payload.body,
+        signal: request.signal
+      }, limits.maxResponseBytes);
+    }
+  };
+}
+
+export {
+  createElevenLabsProvider
+};

package/dist/safe-bash/command-chunks/{chunk-5GRLAARV.js → chunk-IOXI5ZAJ.js}

@@ -1,7 +1,7 @@
 import {
   PdfDocument,
   renderPdfPageToPng
-} from "./chunk-ZF3ZVGQC.js";
+} from "./chunk-7JRITHKW.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-XNHSCU6I.js → chunk-MDPIOQUD.js}

@@ -10,8 +10,8 @@ var information = {
   du: { usage: "[OPTION]... [FILE]...", description: "Report virtual file allocation.", options: ["-a, --all", "-s, --summarize", "-c, --total", "-h, --human-readable", "-B, --block-size=SIZE", "-b, --bytes", "--apparent-size", "-d, --max-depth=NUM", "-X, --exclude-from=FILE", "--exclude=PATTERN", "-t, --threshold=SIZE"], versionOnly: true },
   base32: { usage: "[OPTION]... [FILE]", description: "Encode or decode Base32 data.", options: ["-d, --decode", "-i, --ignore-garbage", "-w, --wrap=COLS"] },
   base64: { usage: "[OPTION]... [FILE]", description: "Encode or decode Base64 data.", options: ["-d, --decode", "-i, --ignore-garbage", "-w, --wrap=COLS"] },
-  basename: { usage: "[OPTION]... NAME... [SUFFIX]", description: "Remove directory components and an optional suffix from names.", options: ["-a, --multiple", "-s, --suffix=SUFFIX", "-z, --zero"] },
-  dirname: { usage: "[OPTION]... NAME...", description: "Print the directory component of each name.", options: ["-z, --zero"] },
+  basename: { usage: "[OPTION]... NAME... [SUFFIX]", description: "Remove directory components and an optional suffix from names.", options: ["-a, --multiple", "-s, --suffix=SUFFIX", "-z, --zero"], stopAtOperand: true },
+  dirname: { usage: "[OPTION]... NAME...", description: "Print the directory component of each name.", options: ["-z, --zero"], stopAtOperandInPosix: true },
   chmod: { usage: "[OPTION]... MODE FILE...", description: "Change virtual file permissions, subject to filesystem capabilities.", options: ["-R, --recursive", "-v, --verbose", "-c, --changes", "-f, --silent, --quiet", "--reference=FILE"] },
   cksum: { usage: "[OPTION]... [FILE]...", description: "Compute checksums of files or standard input.", options: ["-a, --algorithm=TYPE", "-b, --binary", "-z, --zero", "--tag", "--untagged", "--raw", "--base64"] },
   comm: { usage: "[OPTION]... FILE1 FILE2", description: "Compare sorted files in the C/POSIX byte locale.", options: ["-1", "-2", "-3", "--output-delimiter=STR", "--check-order", "--nocheck-order"] },
@@ -46,7 +46,7 @@ var information = {
   unexpand: { usage: "[OPTION]... [FILE]...", description: "Convert spaces to tabs.", options: ["-a, --all", "-t, --tabs=LIST", "--first-only"] },
   uniq: { usage: "[OPTION]... [INPUT [OUTPUT]]", description: "Filter adjacent repeated input records.", options: ["-c, --count", "-d, --repeated", "-u, --unique", "-i, --ignore-case", "-f, --skip-fields=NUM", "-s, --skip-chars=NUM", "-w, --check-chars=NUM", "-z, --zero-terminated"] },
   wc: { usage: "[OPTION]... [FILE]...", description: "Count input lines, words, bytes, characters or display width.", options: ["-l, --lines", "-w, --words", "-c, --bytes", "-m, --chars", "-L, --max-line-length"] },
-  pwd: { usage: "[OPTION]...", description: "Print the full filename of the current working directory.", options: ["-L, --logical", "-P, --physical"] },
+  pwd: { usage: "[OPTION]...", description: "Print the full filename of the current working directory.", options: ["-L, --logical", "-P, --physical"], stopAtOperandInPosix: true },
   true: { usage: "[ignored command line arguments]", description: "Exit with a status code indicating success.", options: [] },
   false: { usage: "[ignored command line arguments]", description: "Exit with a status code indicating failure.", options: [], exitCode: 1 },
   echo: { usage: "[SHORT-OPTION]... [STRING]...", description: "Echo the STRING(s) to standard output.", options: ["-n", "-e", "-E"] },
@@ -57,7 +57,7 @@ var checksumInformation = {
   description: "Compute or verify file digests.",
   options: ["-b, --binary", "-c, --check", "-t, --text", "-z, --zero", "--tag", "--quiet", "--status", "--strict", "--warn", "--ignore-missing"]
 };
-function gnuInformationSync(name, args, externalInvocation = false) {
+function gnuInformationSync(name, args, externalInvocation = false, posixlyCorrect = false) {
   if (!args.includes("--help") && !args.includes("--version"))
     return void 0;
   if ((name === "true" || name === "false" || name === "echo" || name === "[" || name === "pwd") && (args.length !== 1 || !externalInvocation))
@@ -91,7 +91,7 @@ This is the safe-bash virtual implementation; filesystem operations require back
 `;
     }
     if (!arg.startsWith("-") || arg === "-") {
-      if (info.stopAtOperand)
+      if (info.stopAtOperand || info.stopAtOperandInPosix && posixlyCorrect)
         break;
       continue;
     }
@@ -162,7 +162,7 @@ This is the safe-bash virtual implementation; filesystem operations require back
       return { exitCode: info.exitCode ?? 0 };
     }
     if (!arg.startsWith("-") || arg === "-") {
-      if (info.stopAtOperand || name === "pwd" && context.env.POSIXLY_CORRECT !== void 0)
+      if (info.stopAtOperand || info.stopAtOperandInPosix && context.env.POSIXLY_CORRECT !== void 0)
         break;
       continue;
     }

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

@@ -0,0 +1,6 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/providers/elevenlabs.js
+init_buffer();

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

@@ -0,0 +1,91 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/providers/shared.js
+init_buffer();
+function providerLimits(input = {}) {
+  const limits = { maxRequestBytes: Infinity, maxResponseBytes: Infinity, maxEventBytes: Infinity, maxPolls: Infinity, pollIntervalMs: 1e3, ...input };
+  for (const [name, value] of Object.entries(limits)) {
+    if (name !== "pollIntervalMs" && value === Infinity)
+      continue;
+    if (!Number.isSafeInteger(value) || value < (name === "maxPolls" || name === "pollIntervalMs" ? 0 : 1))
+      throw new RangeError(`Invalid provider limit: ${name}`);
+  }
+  return Object.freeze(limits);
+}
+function credential(value) {
+  if (typeof value !== "string" || value.length === 0 || [...value].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127))
+    throw new TypeError("Invalid provider apiKey");
+  return value;
+}
+function jsonBody(value, limit) {
+  const text = JSON.stringify(value);
+  if (text.length > limit)
+    throw new RangeError("Provider request byte limit exceeded");
+  const bytes = new TextEncoder().encode(text);
+  if (bytes.length > limit)
+    throw new RangeError("Provider request byte limit exceeded");
+  return { body: (async function* () {
+    yield bytes;
+  })(), headers: [["content-type", "application/json"]] };
+}
+function multipart(options, files, limit) {
+  const encoder = new TextEncoder();
+  const parts = [];
+  const entries = Object.entries(options).map(([name, value]) => {
+    if (![...name].every((char) => "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-".includes(char)))
+      throw new TypeError("Invalid multipart option name");
+    return [name, String(value)];
+  });
+  let size = files.reduce((sum, file) => sum + file.bytes.length, 0);
+  for (const [, value] of entries) {
+    if (value.length > limit)
+      throw new RangeError("Provider request byte limit exceeded");
+    size += encoder.encode(value).length;
+  }
+  if (size > limit)
+    throw new RangeError("Provider request byte limit exceeded");
+  let boundary = "safe-bash-llm-boundary";
+  const contains = (bytes, needle) => {
+    outer: for (let start = 0; start <= bytes.length - needle.length; start++) {
+      for (let index = 0; index < needle.length; index++)
+        if (bytes[start + index] !== needle[index])
+          continue outer;
+      return true;
+    }
+    return false;
+  };
+  while (entries.some(([, value]) => value.includes(boundary)) || files.some((file) => contains(file.bytes, encoder.encode(boundary)))) {
+    boundary += "x";
+  }
+  for (const [name, value] of entries)
+    parts.push(encoder.encode(`--${boundary}\r
+Content-Disposition: form-data; name="${name}"\r
+\r
+${value}\r
+`));
+  for (const [index, file] of files.entries()) {
+    if ([...file.mimeType].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) > 126))
+      throw new TypeError("Invalid attachment MIME type");
+    parts.push(encoder.encode(`--${boundary}\r
+Content-Disposition: form-data; name="${file.field}"; filename="attachment-${index}"\r
+Content-Type: ${file.mimeType}\r
+\r
+`), Uint8Array.from(file.bytes), encoder.encode("\r\n"));
+  }
+  parts.push(encoder.encode(`--${boundary}--\r
+`));
+  if (parts.reduce((sum, part) => sum + part.length, 0) > limit)
+    throw new RangeError("Provider request byte limit exceeded");
+  return { body: (async function* () {
+    yield* parts;
+  })(), headers: [["content-type", `multipart/form-data; boundary=${boundary}`]] };
+}
+
+export {
+  providerLimits,
+  credential,
+  jsonBody,
+  multipart
+};