@poe-platform/safe-bash 0.1.788 → 0.1.790

package/dist/safe-bash/command-chunks/{chunk-IJ3FXP4Q.js → chunk-A3ZX6SCY.js}

@@ -1,6 +1,6 @@
 import {
   builtInDirectContextExecutors
-} from "./chunk-WYJTWJZ5.js";
+} from "./chunk-G3G6W5ZE.js";
 import {
   concatShellValues,
   shellValueBytes,

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-KSIGF4AG.js → chunk-BK4CMEE6.js}

@@ -6,7 +6,7 @@ import {
   addAbortSignalWaiter,
   isManagedAbortSignal,
   removeAbortSignalWaiter
-} from "./chunk-D7TADAYG.js";
+} from "./chunk-64LG3EVJ.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

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

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

package/dist/safe-bash/command-chunks/{chunk-XGMWWUHV.js → chunk-CZ5DAK4K.js}

@@ -5,7 +5,7 @@ import {
   outputFailure,
   removeManagedAbortWaiter,
   writeBytes
-} from "./chunk-4QX6XCDD.js";
+} from "./chunk-4RNIZ3RT.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-Z57TV6TC.js → chunk-EZ2DTOLI.js}

@@ -1,7 +1,9 @@
 import {
-  CsvkitBlocked,
   PythonException
-} from "./chunk-2LP3VMPA.js";
+} from "./chunk-PGEYORBZ.js";
+import {
+  CsvkitBlocked
+} from "./chunk-WFDW4XXD.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-ADCGH6A7.js → chunk-FH3D75FC.js}

@@ -1,6 +1,6 @@
 import {
   createCodec
-} from "./chunk-DEH3CMGL.js";
+} from "./chunk-QJ3ONEBI.js";
 import {
   CompressedDataError
 } from "./chunk-Z6SFT6OC.js";

package/dist/safe-bash/command-chunks/{chunk-WYJTWJZ5.js → chunk-G3G6W5ZE.js}

@@ -1,7 +1,7 @@
 import {
   addAbortSignalWaiter,
   removeAbortSignalWaiter
-} from "./chunk-D7TADAYG.js";
+} from "./chunk-64LG3EVJ.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-3HDIDEUJ.js → chunk-GF54KE2M.js}

@@ -5,7 +5,7 @@ import {
   chunkBytes,
   stagingLimit,
   transform
-} from "./chunk-PFBJR2PY.js";
+} from "./chunk-2KRKKW5S.js";
 import {
   formats
 } from "./chunk-KHGQDFQ7.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-Z7TYZG3A.js → chunk-IHHTTQX6.js}

@@ -1,11 +1,13 @@
 import {
   decodeFrames,
   utf8Codec
-} from "./chunk-Z57TV6TC.js";
+} from "./chunk-EZ2DTOLI.js";
 import {
-  CsvkitBlocked,
   PythonException
-} from "./chunk-2LP3VMPA.js";
+} from "./chunk-PGEYORBZ.js";
+import {
+  CsvkitBlocked
+} from "./chunk-WFDW4XXD.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

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-INDIFLBW.js → chunk-JTAGNROA.js}

@@ -911,6 +911,7 @@ function createFoldEngine(options, locale, configuration = {}, signal) {
 
 // packages/safe-bash-command-fold/dist/command.js
 init_buffer();
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
 import { commandRuntimeIdentity, getCommandArguments } from "../../safe-bash-contracts/command.js";
 import { FsError } from "../../safe-bash-contracts/errors.js";
 import { readBytes, writeBytes } from "../../safe-bash-contracts/io.js";
@@ -1109,6 +1110,8 @@ async function executeFold(context, configuration, invocation) {
 `);
     };
     for (const file of options.files.length ? options.files : ["-"]) {
+      await yieldTurn(signal);
+      signal.throwIfAborted();
       signal.throwIfAborted();
       let source;
       let ownedInput = 0;
@@ -1191,6 +1194,7 @@ async function executeFold(context, configuration, invocation) {
           if (!length)
             await deliver(engine.push(next.value));
           for (let offset = 0; offset < length; offset += 4096) {
+            await yieldTurn(signal);
             signal.throwIfAborted();
             const unit = new Uint8Array(byteBuffer.call(next.value), byteOffset.call(next.value) + offset, Math.min(4096, length - offset));
             const engIn = engine.inputBytes?.() ?? engine.accounting().inputBytes;