modal 0.3.0 → 0.3.1

package/dist/index.js

@@ -36665,13 +36665,19 @@ var timeoutMiddleware = async function* timeoutMiddleware2(call, options) {
     }
   }
 };
-var RETRYABLE_GRPC_STATUS_CODES = [
+var retryableGrpcStatusCodes = /* @__PURE__ */ new Set([
   Status.DEADLINE_EXCEEDED,
   Status.UNAVAILABLE,
   Status.CANCELLED,
   Status.INTERNAL,
   Status.UNKNOWN
-];
+]);
+function isRetryableGrpc(error) {
+  if (error instanceof ClientError) {
+    return retryableGrpcStatusCodes.has(error.code);
+  }
+  return false;
+}
 var sleep = (ms, signal) => new Promise((resolve, reject) => {
   if (signal?.aborted) return reject(signal.reason);
   const t = setTimeout(resolve, ms);
@@ -36698,7 +36704,7 @@ var retryMiddleware = async function* retryMiddleware2(call, options) {
     return yield* call.next(call.request, restOptions);
   }
   const retryableCodes = /* @__PURE__ */ new Set([
-    ...RETRYABLE_GRPC_STATUS_CODES,
+    ...retryableGrpcStatusCodes,
     ...additionalStatusCodes
   ]);
   const idempotencyKey = uuidv4();
@@ -36802,81 +36808,112 @@ ${result.exception}`
 
 // src/streams.ts
 function toModalReadStream(stream) {
-  return Object.assign(stream, {
-    async readText() {
-      const reader = stream.getReader();
-      try {
-        const decoder = new TextDecoder("utf-8");
-        const chunks = [];
-        while (true) {
-          const { value, done } = await reader.read();
-          if (value) {
-            if (typeof value === "string") chunks.push(value);
-            else {
-              chunks.push(decoder.decode(value.buffer, { stream: true }));
-            }
-          }
-          if (done) {
-            chunks.push(decoder.decode(void 0, { stream: false }));
-            break;
+  return Object.assign(stream, readMixin);
+}
+function toModalWriteStream(stream) {
+  return Object.assign(stream, writeMixin);
+}
+var readMixin = {
+  async readText() {
+    const reader = this.getReader();
+    try {
+      const decoder = new TextDecoder("utf-8");
+      const chunks = [];
+      while (true) {
+        const { value, done } = await reader.read();
+        if (value) {
+          if (typeof value === "string") chunks.push(value);
+          else {
+            chunks.push(decoder.decode(value.buffer, { stream: true }));
           }
         }
-        return chunks.join("");
-      } finally {
-        reader.releaseLock();
+        if (done) {
+          chunks.push(decoder.decode(void 0, { stream: false }));
+          break;
+        }
       }
-    },
-    async readBytes() {
-      const chunks = [];
-      const reader = stream.getReader();
-      try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (value) {
-            if (typeof value === "string") {
-              chunks.push(new TextEncoder().encode(value));
-            } else {
-              chunks.push(value);
-            }
+      return chunks.join("");
+    } finally {
+      reader.releaseLock();
+    }
+  },
+  async readBytes() {
+    const chunks = [];
+    const reader = this.getReader();
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (value) {
+          if (typeof value === "string") {
+            chunks.push(new TextEncoder().encode(value));
+          } else {
+            chunks.push(value);
           }
-          if (done) break;
         }
-      } finally {
-        reader.releaseLock();
-      }
-      let totalLength = 0;
-      for (const chunk of chunks) {
-        totalLength += chunk.length;
+        if (done) break;
       }
-      const result = new Uint8Array(totalLength);
-      let offset = 0;
-      for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.length;
-      }
-      return result;
+    } finally {
+      reader.releaseLock();
     }
-  });
-}
-function toModalWriteStream(stream) {
-  return Object.assign(stream, {
-    async writeText(text) {
-      const writer = stream.getWriter();
-      try {
-        await writer.write(text);
-      } finally {
-        writer.releaseLock();
+    let totalLength = 0;
+    for (const chunk of chunks) {
+      totalLength += chunk.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+};
+var writeMixin = {
+  async writeText(text) {
+    const writer = this.getWriter();
+    try {
+      await writer.write(text);
+    } finally {
+      writer.releaseLock();
+    }
+  },
+  async writeBytes(bytes) {
+    const writer = this.getWriter();
+    try {
+      await writer.write(bytes);
+    } finally {
+      writer.releaseLock();
+    }
+  }
+};
+function streamConsumingIter(iterable) {
+  const iter = iterable[Symbol.asyncIterator]();
+  return new ReadableStream(
+    {
+      async pull(controller) {
+        const { done, value } = await iter.next();
+        if (value) {
+          controller.enqueue(value);
+        }
+        if (done) {
+          controller.close();
+        }
+      },
+      async cancel() {
+        consumeIterator(iter);
       }
     },
-    async writeBytes(bytes) {
-      const writer = stream.getWriter();
-      try {
-        await writer.write(bytes);
-      } finally {
-        writer.releaseLock();
-      }
-    }
-  });
+    new ByteLengthQueuingStrategy({
+      highWaterMark: 64 * 1024
+      // 64 KiB
+    })
+  );
+}
+async function consumeIterator(iter) {
+  while (true) {
+    const { done } = await iter.next();
+    if (done) break;
+  }
 }
 
 // src/sandbox.ts
@@ -36890,14 +36927,14 @@ var Sandbox2 = class {
     this.sandboxId = sandboxId;
     this.stdin = toModalWriteStream(inputStreamSb(sandboxId));
     this.stdout = toModalReadStream(
-      ReadableStream.from(
+      streamConsumingIter(
         outputStreamSb(sandboxId, 1 /* FILE_DESCRIPTOR_STDOUT */)
-      )
+      ).pipeThrough(new TextDecoderStream())
     );
     this.stderr = toModalReadStream(
-      ReadableStream.from(
+      streamConsumingIter(
         outputStreamSb(sandboxId, 2 /* FILE_DESCRIPTOR_STDERR */)
-      )
+      ).pipeThrough(new TextDecoderStream())
     );
   }
   async exec(command, options) {
@@ -36951,12 +36988,20 @@ var ContainerProcess = class {
     const stderr = options?.stderr ?? "pipe";
     this.#execId = execId;
     this.stdin = toModalWriteStream(inputStreamCp(execId));
-    const stdoutStream = ReadableStream.from(
-      stdout === "pipe" ? outputStreamCp(execId, 1 /* FILE_DESCRIPTOR_STDOUT */) : []
+    let stdoutStream = streamConsumingIter(
+      outputStreamCp(execId, 1 /* FILE_DESCRIPTOR_STDOUT */)
     );
-    const stderrStream = ReadableStream.from(
-      stderr === "pipe" ? outputStreamCp(execId, 2 /* FILE_DESCRIPTOR_STDERR */) : []
+    if (stdout === "ignore") {
+      stdoutStream.cancel();
+      stdoutStream = ReadableStream.from([]);
+    }
+    let stderrStream = streamConsumingIter(
+      outputStreamCp(execId, 2 /* FILE_DESCRIPTOR_STDERR */)
     );
+    if (stderr === "ignore") {
+      stderrStream.cancel();
+      stderrStream = ReadableStream.from([]);
+    }
     if (mode === "text") {
       this.stdout = toModalReadStream(
         stdoutStream.pipeThrough(new TextDecoderStream())
@@ -36985,7 +37030,7 @@ var ContainerProcess = class {
 async function* outputStreamSb(sandboxId, fileDescriptor) {
   let lastIndex = "0-0";
   let completed = false;
-  let retriesRemaining = 10;
+  let retries = 10;
   while (!completed) {
     try {
       const outputIterator = client.sandboxGetLogs({
@@ -36996,25 +37041,22 @@ async function* outputStreamSb(sandboxId, fileDescriptor) {
       });
       for await (const batch of outputIterator) {
         lastIndex = batch.entryId;
-        yield* batch.items.map((item) => item.data);
+        yield* batch.items.map((item) => new TextEncoder().encode(item.data));
         if (batch.eof) {
           completed = true;
           break;
         }
       }
     } catch (error) {
-      if (retriesRemaining > 0) {
-        retriesRemaining--;
-      } else {
-        throw error;
-      }
+      if (isRetryableGrpc(error) && retries > 0) retries--;
+      else throw error;
     }
   }
 }
 async function* outputStreamCp(execId, fileDescriptor) {
   let lastIndex = 0;
   let completed = false;
-  let retriesRemaining = 10;
+  let retries = 10;
   while (!completed) {
     try {
       const outputIterator = client.containerExecGetOutput({
@@ -37033,11 +37075,8 @@ async function* outputStreamCp(execId, fileDescriptor) {
         }
       }
     } catch (error) {
-      if (retriesRemaining > 0) {
-        retriesRemaining--;
-      } else {
-        throw error;
-      }
+      if (isRetryableGrpc(error) && retries > 0) retries--;
+      else throw error;
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modal",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Modal client library for JavaScript",
   "license": "MIT",
   "homepage": "https://modal.com/docs",