@ricsam/quickjs-core 0.2.0 → 0.2.2

package/dist/cjs/marshal.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/marshal.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport type { MarshalOptions } from \"./types.cjs\";\n\n/**\n * Check if a value is a QuickJS handle\n */\nexport function isHandle(value: unknown): value is QuickJSHandle {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    \"alive\" in value &&\n    \"dispose\" in value &&\n    typeof (value as QuickJSHandle).dispose === \"function\"\n  );\n}\n\n/**\n * Get the type of a QuickJS handle as a string\n */\nexport function getHandleType(\n  context: QuickJSContext,\n  handle: QuickJSHandle\n): \"undefined\" | \"null\" | \"boolean\" | \"number\" | \"string\" | \"symbol\" | \"object\" | \"function\" {\n  return context.typeof(handle) as \"undefined\" | \"null\" | \"boolean\" | \"number\" | \"string\" | \"symbol\" | \"object\" | \"function\";\n}\n\n/**\n * Marshal a JavaScript value to a QuickJS handle\n *\n * Supports:\n * - Primitives (string, number, boolean, null, undefined, bigint)\n * - Arrays\n * - Plain objects\n * - ArrayBuffer / Uint8Array\n * - Date (converted to Date object in QuickJS)\n * - Functions (wrapped as host functions)\n * - Promises (wrapped with context.newPromise)\n *\n * @example\n * const handle = marshal(context, {\n *   name: \"test\",\n *   values: [1, 2, 3],\n *   callback: (x) => x * 2\n * });\n */\nexport function marshal(\n  context: QuickJSContext,\n  value: unknown,\n  options: MarshalOptions = {}\n): QuickJSHandle {\n  const maxDepth = options.maxDepth ?? 10;\n  const seen = new WeakSet<object>();\n\n  function marshalValue(val: unknown, depth: number): QuickJSHandle {\n    if (depth > maxDepth) {\n      throw new Error(`Maximum marshalling depth of ${maxDepth} exceeded`);\n    }\n\n    // Pass through existing QuickJS handles\n    if (isHandle(val)) {\n      return val;\n    }\n\n    // Try custom marshaller first\n    if (options.custom) {\n      const customResult = options.custom(val, context);\n      if (customResult !== undefined) {\n        return customResult;\n      }\n    }\n\n    // Handle primitives\n    if (val === undefined) {\n      return context.undefined;\n    }\n    if (val === null) {\n      return context.null;\n    }\n    if (typeof val === \"boolean\") {\n      return val ? context.true : context.false;\n    }\n    if (typeof val === \"number\") {\n      return context.newNumber(val);\n    }\n    if (typeof val === \"string\") {\n      return context.newString(val);\n    }\n    if (typeof val === \"bigint\") {\n      return context.newBigInt(val);\n    }\n\n    // Handle symbols (convert to string representation)\n    if (typeof val === \"symbol\") {\n      return context.newString(val.toString());\n    }\n\n    // Handle objects\n    if (typeof val === \"object\") {\n      // Check for circular references\n      if (seen.has(val)) {\n        throw new Error(\"Circular reference detected during marshalling\");\n      }\n      seen.add(val);\n\n      try {\n        // Handle ArrayBuffer\n        if (val instanceof ArrayBuffer) {\n          return context.newArrayBuffer(val);\n        }\n\n        // Handle Uint8Array - create proper Uint8Array in QuickJS (has .length property)\n        if (val instanceof Uint8Array) {\n          const buffer = val.buffer.slice(\n            val.byteOffset,\n            val.byteOffset + val.byteLength\n          );\n          const bufferHandle = context.newArrayBuffer(buffer);\n          context.setProp(context.global, \"__tempMarshalBuffer__\", bufferHandle);\n          bufferHandle.dispose();\n          const result = context.evalCode(\"new Uint8Array(__tempMarshalBuffer__)\");\n          const cleanup = context.evalCode(\"delete globalThis.__tempMarshalBuffer__\");\n          if (cleanup.error) cleanup.error.dispose();\n          else cleanup.value.dispose();\n          if (result.error) {\n            result.error.dispose();\n            // Fallback to ArrayBuffer if Uint8Array creation fails\n            return context.newArrayBuffer(buffer);\n          }\n          return result.value;\n        }\n\n        // Handle other TypedArrays (Int8Array, Float32Array, etc.) - convert to ArrayBuffer\n        if (ArrayBuffer.isView(val)) {\n          const buffer = val.buffer.slice(\n            val.byteOffset,\n            val.byteOffset + val.byteLength\n          );\n          return context.newArrayBuffer(buffer);\n        }\n\n        // Handle Date\n        if (val instanceof Date) {\n          const dateConstructor = context.getProp(context.global, \"Date\");\n          const timestamp = context.newNumber(val.getTime());\n          const result = context.callFunction(\n            dateConstructor,\n            context.undefined,\n            timestamp\n          );\n          dateConstructor.dispose();\n          timestamp.dispose();\n\n          if (result.error) {\n            const error = result.error;\n            result.error.dispose();\n            throw new Error(`Failed to create Date: ${context.dump(error)}`);\n          }\n          return result.value;\n        }\n\n        // Handle Promise\n        if (val instanceof Promise) {\n          const deferred = context.newPromise();\n          val\n            .then((resolved) => {\n              const resolvedHandle = marshalValue(resolved, depth + 1);\n              deferred.resolve(resolvedHandle);\n              resolvedHandle.dispose();\n              context.runtime.executePendingJobs();\n            })\n            .catch((error) => {\n              const errorHandle = marshalValue(\n                error instanceof Error\n                  ? { name: error.name, message: error.message }\n                  : error,\n                depth + 1\n              );\n              deferred.reject(errorHandle);\n              errorHandle.dispose();\n              context.runtime.executePendingJobs();\n            });\n          return deferred.handle;\n        }\n\n        // Handle Array\n        if (Array.isArray(val)) {\n          const arr = context.newArray();\n          for (let i = 0; i < val.length; i++) {\n            const elementHandle = marshalValue(val[i], depth + 1);\n            context.setProp(arr, i, elementHandle);\n            elementHandle.dispose();\n          }\n          return arr;\n        }\n\n        // Handle plain objects\n        const obj = context.newObject();\n        for (const [key, propVal] of Object.entries(val)) {\n          const propHandle = marshalValue(propVal, depth + 1);\n          context.setProp(obj, key, propHandle);\n          propHandle.dispose();\n        }\n        return obj;\n      } finally {\n        seen.delete(val);\n      }\n    }\n\n    // Handle functions\n    if (typeof val === \"function\") {\n      return context.newFunction(val.name || \"anonymous\", (...argHandles) => {\n        const args = argHandles.map((h) => context.dump(h));\n        try {\n          const result = val(...args);\n          if (result instanceof Promise) {\n            const deferred = context.newPromise();\n            result\n              .then((resolved) => {\n                const resolvedHandle = marshalValue(resolved, depth + 1);\n                deferred.resolve(resolvedHandle);\n                resolvedHandle.dispose();\n                context.runtime.executePendingJobs();\n              })\n              .catch((error) => {\n                const errorHandle = marshalValue(\n                  error instanceof Error\n                    ? { name: error.name, message: error.message }\n                    : error,\n                  depth + 1\n                );\n                deferred.reject(errorHandle);\n                errorHandle.dispose();\n                context.runtime.executePendingJobs();\n              });\n            return deferred.handle;\n          }\n          return marshalValue(result, depth + 1);\n        } catch (error) {\n          throw context.newError(\n            error instanceof Error ? error.message : String(error)\n          );\n        }\n      });\n    }\n\n    throw new Error(`Cannot marshal value of type ${typeof val}`);\n  }\n\n  return marshalValue(value, 0);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "92FCF047844230B864756E2164756E21",
+  "names": []
+}

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/quickjs-core",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "commonjs"
 }

package/dist/cjs/readable-stream.cjs

@@ -0,0 +1,588 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/core/src/streams/readable-stream.ts
+var exports_readable_stream = {};
+__export(exports_readable_stream, {
+  createReadableStreamDefaultReaderClass: () => createReadableStreamDefaultReaderClass,
+  createReadableStreamClass: () => createReadableStreamClass,
+  createReadableStream: () => createReadableStream,
+  consumeReadableStream: () => consumeReadableStream
+});
+module.exports = __toCommonJS(exports_readable_stream);
+var import_class_builder = require("../class-builder.cjs");
+var import_marshal = require("../marshal.cjs");
+var import_unmarshal = require("../unmarshal.cjs");
+function createReadableStreamDefaultReaderClass(context, stateMap) {
+  return import_class_builder.defineClass(context, stateMap, {
+    name: "ReadableStreamDefaultReader",
+    construct: () => {
+      let resolveClosedPromise;
+      let rejectClosedPromise;
+      const state = {
+        stream: null,
+        closed: false,
+        closedPromiseResolvers: {
+          resolve: () => resolveClosedPromise?.(),
+          reject: (e) => rejectClosedPromise?.(e)
+        },
+        readRequests: []
+      };
+      Object.defineProperty(state, "_closedPromise", {
+        value: undefined,
+        writable: true,
+        enumerable: false
+      });
+      Object.defineProperty(state, "getClosedPromise", {
+        value: function() {
+          if (!this._closedPromise) {
+            this._closedPromise = new Promise((resolve, reject) => {
+              resolveClosedPromise = resolve;
+              rejectClosedPromise = reject;
+            });
+          }
+          return this._closedPromise;
+        },
+        enumerable: false
+      });
+      return state;
+    },
+    properties: {
+      closed: {
+        get() {
+          return this.getClosedPromise();
+        }
+      }
+    },
+    methods: {
+      read() {
+        if (!this.stream) {
+          return Promise.reject(new TypeError("Reader has no stream"));
+        }
+        if (this.stream.locked === false) {
+          return Promise.reject(new TypeError("Stream is not locked"));
+        }
+        return new Promise((resolve, reject) => {
+          if (this.stream.queue.length > 0) {
+            const chunk = this.stream.queue.shift();
+            resolve({ value: chunk, done: false });
+            return;
+          }
+          if (this.stream.closed || this.stream.closeRequested) {
+            resolve({ value: undefined, done: true });
+            this.closedPromiseResolvers.resolve();
+            return;
+          }
+          if (this.stream.errored) {
+            reject(this.stream.errorValue);
+            return;
+          }
+          this.readRequests.push({ resolve, reject });
+          if (this.stream.source?.pull && this.stream.started) {
+            try {
+              const pullResult = this.stream.source.pull(this.stream.controller);
+              if (pullResult instanceof Promise) {
+                pullResult.catch((e) => {
+                  this.stream.errored = true;
+                  this.stream.errorValue = e;
+                  this.readRequests.forEach((req) => req.reject(e));
+                  this.readRequests = [];
+                });
+              }
+            } catch (e) {
+              this.stream.errored = true;
+              this.stream.errorValue = e;
+              reject(e);
+            }
+          }
+        });
+      },
+      cancel(reason) {
+        if (!this.stream) {
+          return Promise.reject(new TypeError("Reader has no stream"));
+        }
+        return new Promise((resolve, reject) => {
+          try {
+            if (this.stream.source?.cancel) {
+              const result = this.stream.source.cancel(reason);
+              if (result instanceof Promise) {
+                result.then(resolve).catch(reject);
+                return;
+              }
+            }
+            this.stream.closed = true;
+            this.closedPromiseResolvers.resolve();
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+      },
+      releaseLock() {
+        if (!this.stream) {
+          return;
+        }
+        this.stream.locked = false;
+        this.stream.reader = null;
+      }
+    }
+  });
+}
+function createReadableStreamClass(context, stateMap, readerClass) {
+  const classHandle = import_class_builder.defineClass(context, stateMap, {
+    name: "ReadableStream",
+    construct: (args) => {
+      const underlyingSource = args[0];
+      const state = {
+        locked: false,
+        controller: null,
+        reader: null,
+        queue: [],
+        closeRequested: false,
+        closed: false,
+        errored: false,
+        errorValue: undefined,
+        pullPromise: null,
+        started: false,
+        source: underlyingSource
+      };
+      state.controller = {
+        enqueue(chunk) {
+          if (state.closeRequested || state.closed) {
+            throw new TypeError("Stream is closed");
+          }
+          state.queue.push(chunk);
+          if (state.reader && state.reader.readRequests.length > 0) {
+            const request = state.reader.readRequests.shift();
+            const value = state.queue.shift();
+            request.resolve({ value, done: false });
+          }
+        },
+        close() {
+          if (state.closeRequested || state.closed) {
+            return;
+          }
+          state.closeRequested = true;
+          if (state.queue.length === 0) {
+            state.closed = true;
+            if (state.reader) {
+              state.reader.closedPromiseResolvers.resolve();
+              state.reader.readRequests.forEach((req) => {
+                req.resolve({ value: undefined, done: true });
+              });
+              state.reader.readRequests = [];
+            }
+          }
+        },
+        error(e) {
+          if (state.errored || state.closed) {
+            return;
+          }
+          state.errored = true;
+          state.errorValue = e;
+          if (state.reader) {
+            state.reader.closedPromiseResolvers.reject(e);
+            state.reader.readRequests.forEach((req) => req.reject(e));
+            state.reader.readRequests = [];
+          }
+        },
+        get desiredSize() {
+          if (state.errored)
+            return null;
+          if (state.closeRequested)
+            return 0;
+          return 1 - state.queue.length;
+        }
+      };
+      if (underlyingSource?.start) {
+        try {
+          const startResult = underlyingSource.start(state.controller);
+          if (startResult instanceof Promise) {
+            startResult.then(() => {
+              state.started = true;
+            }).catch((e) => {
+              state.errored = true;
+              state.errorValue = e;
+            });
+          } else {
+            state.started = true;
+          }
+        } catch (e) {
+          state.errored = true;
+          state.errorValue = e;
+        }
+      } else {
+        state.started = true;
+      }
+      return state;
+    },
+    properties: {
+      locked: {
+        get() {
+          return this.locked;
+        }
+      }
+    },
+    methods: {
+      __linkReader__(readerObj) {
+        if (this.locked) {
+          throw new TypeError("ReadableStream is locked");
+        }
+        this.locked = true;
+        const readerId = readerObj.__instanceId__;
+        const readerState = import_class_builder.getInstanceStateById(readerId);
+        if (!readerState) {
+          throw new Error("Reader instance state not found");
+        }
+        readerState.stream = this;
+        this.reader = readerState;
+      },
+      cancel(reason) {
+        if (this.locked) {
+          return Promise.reject(new TypeError("Cannot cancel a locked stream"));
+        }
+        return new Promise((resolve, reject) => {
+          try {
+            if (this.source?.cancel) {
+              const result = this.source.cancel(reason);
+              if (result instanceof Promise) {
+                result.then(resolve).catch(reject);
+                return;
+              }
+            }
+            this.closed = true;
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+      }
+    }
+  });
+  const prototypeHandle = context.getProp(classHandle, "prototype");
+  const getReaderCode = `(function() {
+    // Create a reader instance
+    const reader = new ReadableStreamDefaultReader();
+    // Link it to this stream's internal state
+    this.__linkReader__(reader);
+    return reader;
+  })`;
+  const getReaderResult = context.evalCode(getReaderCode);
+  if (!getReaderResult.error) {
+    context.setProp(prototypeHandle, "getReader", getReaderResult.value);
+    getReaderResult.value.dispose();
+  } else {
+    getReaderResult.error.dispose();
+  }
+  const pipeToCode = `(async function(destination, options = {}) {
+    if (this.locked) throw new TypeError("ReadableStream is locked");
+    if (destination.locked) throw new TypeError("WritableStream is locked");
+
+    const reader = this.getReader();
+    const writer = destination.getWriter();
+
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        await writer.write(value);
+      }
+      if (!options.preventClose) await writer.close();
+    } catch (error) {
+      if (!options.preventAbort) await writer.abort(error);
+      if (!options.preventCancel) await reader.cancel(error);
+      throw error;
+    } finally {
+      reader.releaseLock();
+      writer.releaseLock();
+    }
+  })`;
+  const pipeToResult = context.evalCode(pipeToCode);
+  if (!pipeToResult.error) {
+    context.setProp(prototypeHandle, "pipeTo", pipeToResult.value);
+    pipeToResult.value.dispose();
+  } else {
+    pipeToResult.error.dispose();
+  }
+  const pipeThroughCode = `(function(transform, options = {}) {
+    if (this.locked) throw new TypeError("ReadableStream is locked");
+    if (transform.writable.locked) throw new TypeError("WritableStream is locked");
+
+    // Start piping in background
+    this.pipeTo(transform.writable, {
+      preventClose: options.preventClose,
+      preventAbort: options.preventAbort,
+      preventCancel: options.preventCancel,
+      signal: options.signal
+    }).catch(() => {}); // Errors handled internally
+
+    return transform.readable;
+  })`;
+  const pipeThroughResult = context.evalCode(pipeThroughCode);
+  if (!pipeThroughResult.error) {
+    context.setProp(prototypeHandle, "pipeThrough", pipeThroughResult.value);
+    pipeThroughResult.value.dispose();
+  } else {
+    pipeThroughResult.error.dispose();
+  }
+  const teeCode = `(function() {
+    if (this.locked) throw new TypeError("ReadableStream is locked");
+
+    const reader = this.getReader();
+    let reading = false;
+    let readAgain = false;
+    let canceled1 = false, canceled2 = false;
+    let reason1, reason2;
+    let branch1Controller, branch2Controller;
+
+    function pullAlgorithm() {
+      if (reading) {
+        readAgain = true;
+        return Promise.resolve();
+      }
+      reading = true;
+
+      return reader.read().then(({ value, done }) => {
+        reading = false;
+        if (done) {
+          if (!canceled1 && branch1Controller) branch1Controller.close();
+          if (!canceled2 && branch2Controller) branch2Controller.close();
+          return;
+        }
+        if (!canceled1 && branch1Controller) branch1Controller.enqueue(value);
+        if (!canceled2 && branch2Controller) branch2Controller.enqueue(value);
+        if (readAgain) {
+          readAgain = false;
+          return pullAlgorithm();
+        }
+      });
+    }
+
+    const branch1 = new ReadableStream({
+      start(controller) { branch1Controller = controller; },
+      pull: pullAlgorithm,
+      cancel(reason) {
+        canceled1 = true;
+        reason1 = reason;
+        if (canceled2) reader.cancel(reason1);
+      }
+    });
+
+    const branch2 = new ReadableStream({
+      start(controller) { branch2Controller = controller; },
+      pull: pullAlgorithm,
+      cancel(reason) {
+        canceled2 = true;
+        reason2 = reason;
+        if (canceled1) reader.cancel(reason2);
+      }
+    });
+
+    return [branch1, branch2];
+  })`;
+  const teeResult = context.evalCode(teeCode);
+  if (!teeResult.error) {
+    context.setProp(prototypeHandle, "tee", teeResult.value);
+    teeResult.value.dispose();
+  } else {
+    teeResult.error.dispose();
+  }
+  prototypeHandle.dispose();
+  return classHandle;
+}
+function createReadableStream(context, stateMap, source) {
+  const sourceObj = context.newObject();
+  if (source.start) {
+    const startFn = context.newFunction("start", (controllerHandle) => {
+      const controller = {
+        enqueue: (chunk) => {
+          const enqueueFn = context.getProp(controllerHandle, "enqueue");
+          const chunkHandle = import_marshal.marshal(context, chunk);
+          context.callFunction(enqueueFn, controllerHandle, chunkHandle);
+          chunkHandle.dispose();
+          enqueueFn.dispose();
+        },
+        close: () => {
+          const closeFn = context.getProp(controllerHandle, "close");
+          context.callFunction(closeFn, controllerHandle);
+          closeFn.dispose();
+        },
+        error: (e) => {
+          const errorFn = context.getProp(controllerHandle, "error");
+          const errorHandle = import_marshal.marshal(context, e);
+          context.callFunction(errorFn, controllerHandle, errorHandle);
+          errorHandle.dispose();
+          errorFn.dispose();
+        }
+      };
+      const result2 = source.start(controller);
+      if (result2 instanceof Promise) {
+        const deferred = context.newPromise();
+        result2.then(() => {
+          deferred.resolve(context.undefined);
+          context.runtime.executePendingJobs();
+        }).catch((e) => {
+          deferred.reject(import_marshal.marshal(context, e));
+          context.runtime.executePendingJobs();
+        });
+        return deferred.handle;
+      }
+      return context.undefined;
+    });
+    context.setProp(sourceObj, "start", startFn);
+    startFn.dispose();
+  }
+  if (source.pull) {
+    const pullFn = context.newFunction("pull", (controllerHandle) => {
+      const controller = {
+        enqueue: (chunk) => {
+          const enqueueFn = context.getProp(controllerHandle, "enqueue");
+          const chunkHandle = import_marshal.marshal(context, chunk);
+          context.callFunction(enqueueFn, controllerHandle, chunkHandle);
+          chunkHandle.dispose();
+          enqueueFn.dispose();
+        },
+        close: () => {
+          const closeFn = context.getProp(controllerHandle, "close");
+          context.callFunction(closeFn, controllerHandle);
+          closeFn.dispose();
+        },
+        error: (e) => {
+          const errorFn = context.getProp(controllerHandle, "error");
+          const errorHandle = import_marshal.marshal(context, e);
+          context.callFunction(errorFn, controllerHandle, errorHandle);
+          errorHandle.dispose();
+          errorFn.dispose();
+        }
+      };
+      const result2 = source.pull(controller);
+      if (result2 instanceof Promise) {
+        const deferred = context.newPromise();
+        result2.then(() => {
+          deferred.resolve(context.undefined);
+          context.runtime.executePendingJobs();
+        }).catch((e) => {
+          deferred.reject(import_marshal.marshal(context, e));
+          context.runtime.executePendingJobs();
+        });
+        return deferred.handle;
+      }
+      return context.undefined;
+    });
+    context.setProp(sourceObj, "pull", pullFn);
+    pullFn.dispose();
+  }
+  if (source.cancel) {
+    const cancelFn = context.newFunction("cancel", (reasonHandle) => {
+      const reason = import_unmarshal.unmarshal(context, reasonHandle);
+      const result2 = source.cancel(reason);
+      if (result2 instanceof Promise) {
+        const deferred = context.newPromise();
+        result2.then(() => {
+          deferred.resolve(context.undefined);
+          context.runtime.executePendingJobs();
+        }).catch((e) => {
+          deferred.reject(import_marshal.marshal(context, e));
+          context.runtime.executePendingJobs();
+        });
+        return deferred.handle;
+      }
+      return context.undefined;
+    });
+    context.setProp(sourceObj, "cancel", cancelFn);
+    cancelFn.dispose();
+  }
+  context.setProp(context.global, "__tempReadableStreamSource__", sourceObj);
+  sourceObj.dispose();
+  const result = context.evalCode(`
+    (function() {
+      const stream = new ReadableStream(__tempReadableStreamSource__);
+      stream.__source__ = __tempReadableStreamSource__;
+      return stream;
+    })()
+  `);
+  const cleanupResult = context.evalCode("delete __tempReadableStreamSource__");
+  if (cleanupResult.error)
+    cleanupResult.error.dispose();
+  else
+    cleanupResult.value.dispose();
+  if (result.error) {
+    const msgHandle = context.getProp(result.error, "message");
+    const errorMsg = context.dump(msgHandle);
+    msgHandle.dispose();
+    result.error.dispose();
+    throw new Error(`Failed to create ReadableStream: ${errorMsg}`);
+  }
+  return result.value;
+}
+async function* consumeReadableStream(context, stateMap, streamHandle) {
+  const getReaderFn = context.getProp(streamHandle, "getReader");
+  const readerResult = context.callFunction(getReaderFn, streamHandle);
+  getReaderFn.dispose();
+  if (readerResult.error) {
+    const error = context.dump(readerResult.error);
+    readerResult.error.dispose();
+    throw new Error(`Failed to get reader: ${error}`);
+  }
+  const reader = readerResult.value;
+  try {
+    while (true) {
+      const readFn = context.getProp(reader, "read");
+      const readResult = context.callFunction(readFn, reader);
+      readFn.dispose();
+      if (readResult.error) {
+        const error = context.dump(readResult.error);
+        readResult.error.dispose();
+        throw new Error(`Read failed: ${error}`);
+      }
+      const resolved = await context.resolvePromise(readResult.value);
+      readResult.value.dispose();
+      context.runtime.executePendingJobs();
+      if (resolved.error) {
+        const error = context.dump(resolved.error);
+        resolved.error.dispose();
+        throw new Error(`Read failed: ${error}`);
+      }
+      const result = import_unmarshal.unmarshal(context, resolved.value);
+      resolved.value.dispose();
+      if (result.done) {
+        break;
+      }
+      yield result.value;
+    }
+  } finally {
+    const releaseLockFn = context.getProp(reader, "releaseLock");
+    context.callFunction(releaseLockFn, reader);
+    releaseLockFn.dispose();
+    reader.dispose();
+  }
+}
+})
+
+//# debugId=824583274BA2456864756E2164756E21