@poe-platform/safe-bash 0.1.809 → 0.1.810

package/dist/safe-bash/command-chunks/{chunk-WFDG3N5R.js → chunk-ECDEPKKW.js}

@@ -5,7 +5,7 @@ import {
   chunkBytes,
   stagingLimit,
   transform
-} from "./chunk-NVBUC644.js";
+} from "./chunk-HKGNBH7Z.js";
 import {
   formats
 } from "./chunk-5AQAWIYK.js";

package/dist/safe-bash/command-chunks/{chunk-OQCJGUI6.js → chunk-HARUYHH7.js}

@@ -61,7 +61,7 @@ async function parse(text, work) {
     } };
   } }, work);
 }
-async function parseRecords(lines, work) {
+async function parseRecords(lines, work, collections) {
   if (!lines.length || (await lines.get(0)).prefix !== "*** Begin Patch" || (await lines.get(lines.length - 1)).prefix !== "*** End Patch") throw new PatchError("expected Begin Patch and End Patch envelope", 2);
   const files = [];
   let index = 1;
@@ -87,8 +87,8 @@ async function parseRecords(lines, work) {
       destinationLabel = await (await lines.get(index++)).read(13);
       destination = await targetPath(destinationLabel, work);
     }
-    const added = [];
-    const hunks = [];
+    const added = collections?.texts() ?? [];
+    const hunks = collections?.hunks() ?? [];
     let current;
     let finished = false;
     while (index < lines.length - 1) {
@@ -97,7 +97,7 @@ async function parseRecords(lines, work) {
       if (line.prefix.startsWith("*** Add File: ") || line.prefix.startsWith("*** Delete File: ") || line.prefix.startsWith("*** Update File: ")) break;
       if (kind === "add") {
         if (!line.prefix.startsWith("+")) throw new PatchError(`invalid Add body at patch line ${index + 1}`, 2);
-        added.push(line.slice(1));
+        await added.push(line.slice(1));
       } else if (kind === "delete") throw new PatchError("Delete cannot have a body", 2);
       else if (finished) throw new PatchError("EOF must terminate the file's last hunk", 2);
       else if (line.prefix === "@@" || line.prefix.startsWith("@@ ")) {
@@ -106,10 +106,10 @@ async function parseRecords(lines, work) {
           if (!named || current.anchors.length === 0) throw new PatchError("empty update hunk", 2);
         } else {
           work.count("maxHunks", 1);
-          current = { anchors: [], lines: [], eof: false };
-          hunks.push(current);
+          if (current) await hunks.push(current);
+          current = { anchors: collections?.texts() ?? [], lines: collections?.lines() ?? [], eof: false };
         }
-        if (named) current.anchors.push(line.slice(3));
+        if (named) await current.anchors.push(line.slice(3));
       } else if (line.prefix === "*** End of File") {
         if (!current?.lines.length) throw new PatchError("EOF requires a nonempty hunk", 2);
         current.eof = true;
@@ -119,13 +119,13 @@ async function parseRecords(lines, work) {
         if (prefix !== " " && prefix !== "+" && prefix !== "-") throw new PatchError(`invalid hunk line ${index + 1}`, 2);
         if (!current) {
           work.count("maxHunks", 1);
-          current = { anchors: [], lines: [], eof: false };
-          hunks.push(current);
+          current = { anchors: collections?.texts() ?? [], lines: collections?.lines() ?? [], eof: false };
         }
-        current.lines.push({ kind: prefix, text: line.slice(1) });
+        await current.lines.push({ kind: prefix, text: line.slice(1) });
       }
       index++;
     }
+    if (current) await hunks.push(current);
     if (kind === "update" && (hunks.length === 0 ? destination === void 0 : !current?.lines.length)) throw new PatchError("Update requires a nonempty hunk", 2);
     files.push({ kind, path, label, added, hunks, ...destination === void 0 ? {} : { destination, destinationLabel } });
   }

package/dist/safe-bash/command-chunks/{chunk-NVBUC644.js → chunk-HKGNBH7Z.js}

@@ -1,9 +1,9 @@
 import {
   zstdDecode
-} from "./chunk-KELMIFVV.js";
+} from "./chunk-TI52LKLL.js";
 import {
   boundedCodec
-} from "./chunk-JW3KIZU6.js";
+} from "./chunk-RUXY7GN5.js";
 import {
   gunzipMembers
 } from "./chunk-52DDLGBS.js";

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

@@ -0,0 +1,12 @@
+// packages/safe-bash-command-ffprobe/src/options.ts
+function resolveFfprobeLimits(options) {
+  const limits = { maxInputBytes: 32 * 1024 * 1024, maxOutputBytes: 1024 * 1024, ...options };
+  for (const value of [limits.maxInputBytes, limits.maxOutputBytes]) {
+    if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError("Invalid ffprobe limit");
+  }
+  return limits;
+}
+
+export {
+  resolveFfprobeLimits
+};

package/dist/safe-bash/command-chunks/{chunk-4557HE3J.js → chunk-PMWW7KSB.js}

@@ -20,9 +20,83 @@ import {
 import { readFileStream } from "../../safe-bash-contracts/filesystem.js";
 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 { inheritYieldCheckpoint, yieldTurn as yieldTurn2 } 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";
+
+// packages/safe-bash-network-engine/src/replay.ts
+import { FsError } from "../../safe-bash-contracts/index.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+function verify(actual, expected) {
+  const identity = expected.opaqueIdentity !== void 0 ? actual.opaqueIdentity === expected.opaqueIdentity : expected.dev !== void 0 && expected.ino !== void 0 && actual.dev === expected.dev && actual.ino === expected.ino;
+  if (!identity || expected.identityScope === void 0 || actual.identityScope !== expected.identityScope || actual.type !== "file" || actual.size !== expected.size || actual.revision !== expected.revision || actual.opaqueVersion !== expected.opaqueVersion || actual.mtimeMs !== expected.mtimeMs || actual.ctimeMs !== expected.ctimeMs)
+    throw new FsError("EBUSY", { message: "Upload replay storage changed" });
+}
+async function createReplay(fs, directory, signal) {
+  const parent = await fs.stat(directory, { signal });
+  const caps = await fs.capabilitiesFor?.(directory, { signal }) ?? fs.capabilities;
+  if (!caps.retainedStagingCleanup || !caps.retainedStagingWrite || !caps.retainedRead || !fs.createStagedFile || !fs.openReadFile)
+    throw new FsError("ENOTSUP", { message: "Upload replay requires retained caller storage" });
+  const name = Array.from(randomBytes(18), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  const stage = await fs.createStagedFile(`${directory === "/" ? "" : directory}/.curl-replay-${name}`, "upload", { type: "file", data: new Uint8Array() }, { parent, mode: 384, retainCleanup: true, signal });
+  const { writer, cleanup } = stage;
+  if (!writer || !cleanup) {
+    try {
+      await cleanup?.remove();
+    } finally {
+      await cleanup?.close();
+    }
+    throw new FsError("EIO", { message: "Missing retained upload handles" });
+  }
+  let size = 0;
+  let sealed;
+  let reader;
+  let closing;
+  return {
+    async write(bytes) {
+      for (let offset = 0; offset < bytes.length; offset += 16384) {
+        const chunk = bytes.slice(offset, offset + 16384);
+        await writer.write(chunk, { signal });
+        size += chunk.length;
+      }
+    },
+    async *read(replaySignal) {
+      replaySignal.throwIfAborted();
+      sealed ??= await writer.finish({ signal: replaySignal });
+      if (sealed.size !== size) throw new FsError("EIO", { message: "Incomplete upload replay storage" });
+      reader ??= await fs.openReadFile(stage.file.path, { signal: replaySignal });
+      verify(await reader.stat({ signal: replaySignal }), sealed);
+      let chunks = 0;
+      for (let position = 0; position < size; ) {
+        if (++chunks % 256 === 0) await yieldTurn(replaySignal);
+        replaySignal.throwIfAborted();
+        verify(await reader.stat({ signal: replaySignal }), sealed);
+        const count = Math.min(16384, size - position);
+        const bytes = await reader.read(position, count, { signal: replaySignal });
+        if (!bytes.length || bytes.length > count) throw new FsError("EIO", { message: "Invalid upload replay read" });
+        verify(await reader.stat({ signal: replaySignal }), sealed);
+        position += bytes.length;
+        yield bytes.slice();
+      }
+    },
+    close() {
+      closing ??= (async () => {
+        try {
+          await reader?.close();
+        } finally {
+          try {
+            await cleanup.remove();
+          } finally {
+            await cleanup.close();
+          }
+        }
+      })();
+      return closing;
+    }
+  };
+}
+
+// packages/safe-bash-network-engine/src/body.ts
 function multipartBoundary() {
   let boundary = "virtual-bash-";
   for (const byte of randomBytes(18)) boundary += byte.toString(16).padStart(2, "0");
@@ -214,7 +288,7 @@ async function* transfer(source, encoder, signal) {
         yield encode(output);
         output = "";
       }
-      await yieldTurn(signal);
+      await yieldTurn2(signal);
     }
   }
   signal.throwIfAborted();
@@ -251,8 +325,12 @@ function createBody(context, args, limits) {
   let opened = false;
   let replayComplete = false;
   let replayable = true;
-  let cachedBytes = 0;
-  let cache = [];
+  let replay;
+  let active = false;
+  let activeIterator;
+  const lifetime = new AbortController();
+  let closing;
+  let closed = false;
   let stdinUsed = false;
   const source = async function* (part, signal) {
     if (part.bytes !== void 0) {
@@ -303,51 +381,90 @@ function createBody(context, args, limits) {
   };
   return {
     ...contentType === void 0 ? {} : { contentType },
+    close() {
+      closed = true;
+      lifetime.abort();
+      closing ??= (async () => {
+        try {
+          await activeIterator?.return(void 0);
+        } finally {
+          await replay?.close();
+        }
+      })();
+      return closing;
+    },
     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();
+      const combined = AbortSignal.any([signal, lifetime.signal]);
+      inheritYieldCheckpoint(signal, combined);
+      signal = combined;
+      async function* generate() {
+        signal.throwIfAborted();
+        if (closed || active) throw new CurlError(65, "Upload body is closed or in use");
+        active = true;
+        activeIterator = iterator;
+        try {
+          if (hasStdin && opened) {
+            if (!replayComplete || !replayable || !replay) throw new CurlError(65, "Cannot replay stdin upload from caller storage");
+            try {
+              yield* replay.read(signal);
+            } catch {
+              replayable = false;
+              signal.throwIfAborted();
+              throw new CurlError(65, "Failed reading stdin replay storage");
+            }
+            return;
           }
-          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) {
+          opened = true;
+          if (hasStdin) {
+            try {
+              replay = await createReplay(context.fs, context.cwd, signal);
+            } catch {
               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));
+              replayable = false;
+            }
+          }
+          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 yieldTurn2(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) {
+                  try {
+                    await replay.write(chunk);
+                  } catch {
+                    signal.throwIfAborted();
+                    replayable = false;
+                    await replay.close();
+                  }
+                }
+                if (chunk.length) yield chunk;
               }
-              if (chunk.length) yield chunk;
             }
           }
+          replayComplete = true;
+        } finally {
+          active = false;
+          activeIterator = void 0;
         }
-        replayComplete = true;
-      })();
+      }
+      const iterator = generate();
+      return iterator;
     }
   };
 }
@@ -358,6 +475,8 @@ async function queryData(body, signal, limits) {
     signal.throwIfAborted();
     if (error instanceof CurlError) throw error;
     throw new CurlError(63, "Query data exceeds host buffer limit");
+  } finally {
+    await body.close();
   }
 }
 

package/dist/safe-bash/command-chunks/{chunk-JW3KIZU6.js → chunk-RUXY7GN5.js}

@@ -1,6 +1,6 @@
 import {
   createCodec
-} from "./chunk-EMMSXKEJ.js";
+} from "./chunk-4Q4R3VZU.js";
 import {
   CompressedDataError
 } from "./chunk-V7IP2PFT.js";

package/dist/safe-bash/command-chunks/{chunk-KELMIFVV.js → chunk-TI52LKLL.js}

@@ -1,6 +1,6 @@
 import {
   boundedCodec
-} from "./chunk-JW3KIZU6.js";
+} from "./chunk-RUXY7GN5.js";
 import {
   gunzipMember
 } from "./chunk-52DDLGBS.js";

package/dist/safe-bash/command-chunks/{chunk-JJQ72P3V.js → chunk-VCML4T5D.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-7WIC7SFR.js";
 import {
   mediaCommands
-} from "./chunk-45FI2IPY.js";
+} from "./chunk-WQ6ABTJU.js";
 
 // packages/safe-bash-command-media/src/remote.ts
 import { readBytes } from "@poe-platform/safe-fs/core";

package/dist/safe-bash/command-chunks/{chunk-5HGEXQVD.js → chunk-WC2OCF4H.js}

@@ -1,6 +1,6 @@
 import {
   Presentation
-} from "./chunk-NB7JO7FE.js";
+} from "./chunk-YTFWPJ3F.js";
 import {
   SlidePlaceholder
 } from "./chunk-YUVH6CE4.js";