capnweb 0.4.0 → 0.6.0

package/dist/index-workers.cjs

@@ -49,6 +49,7 @@ var RpcTarget = workersModule ? workersModule.RpcTarget : class {
 };
 var AsyncFunction = (async function() {
 }).constructor;
+var BUFFER_PROTOTYPE = typeof Buffer !== "undefined" ? Buffer.prototype : void 0;
 function typeForRpc(value) {
   switch (typeof value) {
     case "boolean":
@@ -80,7 +81,18 @@ function typeForRpc(value) {
     case Date.prototype:
       return "date";
     case Uint8Array.prototype:
+    case BUFFER_PROTOTYPE:
       return "bytes";
+    case WritableStream.prototype:
+      return "writable";
+    case ReadableStream.prototype:
+      return "readable";
+    case Headers.prototype:
+      return "headers";
+    case Request.prototype:
+      return "request";
+    case Response.prototype:
+      return "response";
     // TODO: All other structured clone types.
     case RpcStub.prototype:
       return "stub";
@@ -108,7 +120,34 @@ function mapNotLoaded() {
   throw new Error("RPC map() implementation was not loaded.");
 }
 var mapImpl = { applyMap: mapNotLoaded, sendMap: mapNotLoaded };
+function streamNotLoaded() {
+  throw new Error("Stream implementation was not loaded.");
+}
+var streamImpl = {
+  createWritableStreamHook: streamNotLoaded,
+  createWritableStreamFromHook: streamNotLoaded,
+  createReadableStreamHook: streamNotLoaded
+};
 var StubHook = class {
+  // Like call(), but designed for streaming calls (e.g. WritableStream writes). Returns:
+  // - promise: A Promise<void> for the completion of the call.
+  // - size: If the call was remote, the byte size of the serialized message. For local calls,
+  //   undefined is returned, indicating the caller should await the promise to serialize writes
+  //   (no overlapping).
+  stream(path, args) {
+    let hook = this.call(path, args);
+    let pulled = hook.pull();
+    let promise;
+    if (pulled instanceof Promise) {
+      promise = pulled.then((p) => {
+        p.dispose();
+      });
+    } else {
+      pulled.dispose();
+      promise = Promise.resolve();
+    }
+    return { promise };
+  }
 };
 var ErrorStubHook = class extends StubHook {
   constructor(error) {
@@ -333,10 +372,10 @@ async function pullPromise(promise) {
 }
 var RpcPayload = class _RpcPayload {
   // Private constructor; use factory functions above to construct.
-  constructor(value, source, stubs, promises) {
+  constructor(value, source, hooks, promises) {
     this.value = value;
     this.source = source;
-    this.stubs = stubs;
+    this.hooks = hooks;
     this.promises = promises;
   }
   // Create a payload from a value passed as params to an RPC from the app.
@@ -361,13 +400,13 @@ var RpcPayload = class _RpcPayload {
   // stubs is transferred from the inputs to the outputs, hence if the output is disposed, the
   // inputs should not be. (In case of exception, nothing is disposed, though.)
   static fromArray(array) {
-    let stubs = [];
+    let hooks = [];
     let promises = [];
     let resultArray = [];
     for (let payload of array) {
       payload.ensureDeepCopied();
-      for (let stub of payload.stubs) {
-        stubs.push(stub);
+      for (let hook of payload.hooks) {
+        hooks.push(hook);
       }
       for (let promise of payload.promises) {
         if (promise.parent === payload) {
@@ -381,12 +420,12 @@ var RpcPayload = class _RpcPayload {
       }
       resultArray.push(payload.value);
     }
-    return new _RpcPayload(resultArray, "owned", stubs, promises);
+    return new _RpcPayload(resultArray, "owned", hooks, promises);
   }
   // Create a payload from a value parsed off the wire using Evaluator.evaluate().
   //
-  // A payload is constructed with a null value and the given stubs and promises arrays. The value
-  // is expected to be filled in by the evaluator, and the stubs and promises arrays are expected
+  // A payload is constructed with a null value and the given hooks and promises arrays. The value
+  // is expected to be filled in by the evaluator, and the hooks and promises arrays are expected
   // to be extended with stubs found during parsing. (This weird usage model is necessary so that
   // if the root value turns out to be a promise, its `parent` in `promises` can be the payload
   // object itself.)
@@ -394,8 +433,8 @@ var RpcPayload = class _RpcPayload {
   // When done, the payload takes ownership of the final value and all the stubs within. It may
   // modify the value in preparation for delivery, and may deliver the value directly to the app
   // without copying.
-  static forEvaluate(stubs, promises) {
-    return new _RpcPayload(null, "owned", stubs, promises);
+  static forEvaluate(hooks, promises) {
+    return new _RpcPayload(null, "owned", hooks, promises);
   }
   // Deep-copy the given value, including dup()ing all stubs.
   //
@@ -417,8 +456,8 @@ var RpcPayload = class _RpcPayload {
     return result;
   }
   // For `source === "return"` payloads only, this tracks any StubHooks created around RpcTargets
-  // found in the payload at the time that it is serialized (or deep-copied) for return, so that we
-  // can make sure they are not disposed before the pipeline ends.
+  // or WritableStreams found in the payload at the time that it is serialized (or deep-copied) for
+  // return, so that we can make sure they are not disposed before the pipeline ends.
   //
   // This is initialized on first use.
   rpcTargets;
@@ -457,6 +496,64 @@ var RpcPayload = class _RpcPayload {
       throw new Error("owned payload shouldn't contain raw RpcTargets");
     }
   }
+  // Get the StubHook representing the given WritableStream found inside this payload.
+  getHookForWritableStream(stream, parent, dupStubs = true) {
+    if (this.source === "params") {
+      return streamImpl.createWritableStreamHook(stream);
+    } else if (this.source === "return") {
+      let hook = this.rpcTargets?.get(stream);
+      if (hook) {
+        if (dupStubs) {
+          return hook.dup();
+        } else {
+          this.rpcTargets?.delete(stream);
+          return hook;
+        }
+      } else {
+        hook = streamImpl.createWritableStreamHook(stream);
+        if (dupStubs) {
+          if (!this.rpcTargets) {
+            this.rpcTargets = /* @__PURE__ */ new Map();
+          }
+          this.rpcTargets.set(stream, hook);
+          return hook.dup();
+        } else {
+          return hook;
+        }
+      }
+    } else {
+      throw new Error("owned payload shouldn't contain raw WritableStreams");
+    }
+  }
+  // Get the StubHook representing the given ReadableStream found inside this payload.
+  getHookForReadableStream(stream, parent, dupStubs = true) {
+    if (this.source === "params") {
+      return streamImpl.createReadableStreamHook(stream);
+    } else if (this.source === "return") {
+      let hook = this.rpcTargets?.get(stream);
+      if (hook) {
+        if (dupStubs) {
+          return hook.dup();
+        } else {
+          this.rpcTargets?.delete(stream);
+          return hook;
+        }
+      } else {
+        hook = streamImpl.createReadableStreamHook(stream);
+        if (dupStubs) {
+          if (!this.rpcTargets) {
+            this.rpcTargets = /* @__PURE__ */ new Map();
+          }
+          this.rpcTargets.set(stream, hook);
+          return hook.dup();
+        } else {
+          return hook;
+        }
+      }
+    } else {
+      throw new Error("owned payload shouldn't contain raw ReadableStreams");
+    }
+  }
   deepCopy(value, oldParent, property, parent, dupStubs, owner) {
     let kind = typeForRpc(value);
     switch (kind) {
@@ -500,22 +597,21 @@ var RpcPayload = class _RpcPayload {
           this.promises.push({ parent, property, promise });
           return promise;
         } else {
-          let newStub = new RpcStub(hook);
-          this.stubs.push(newStub);
-          return newStub;
+          this.hooks.push(hook);
+          return new RpcStub(hook);
         }
       }
       case "function":
       case "rpc-target": {
         let target = value;
-        let stub;
+        let hook;
         if (owner) {
-          stub = new RpcStub(owner.getHookForRpcTarget(target, oldParent, dupStubs));
+          hook = owner.getHookForRpcTarget(target, oldParent, dupStubs);
         } else {
-          stub = new RpcStub(TargetStubHook.create(target, oldParent));
+          hook = TargetStubHook.create(target, oldParent);
         }
-        this.stubs.push(stub);
-        return stub;
+        this.hooks.push(hook);
+        return new RpcStub(hook);
       }
       case "rpc-thenable": {
         let target = value;
@@ -528,6 +624,44 @@ var RpcPayload = class _RpcPayload {
         this.promises.push({ parent, property, promise });
         return promise;
       }
+      case "writable": {
+        let stream = value;
+        let hook;
+        if (owner) {
+          hook = owner.getHookForWritableStream(stream, oldParent, dupStubs);
+        } else {
+          hook = streamImpl.createWritableStreamHook(stream);
+        }
+        this.hooks.push(hook);
+        return stream;
+      }
+      case "readable": {
+        let stream = value;
+        let hook;
+        if (owner) {
+          hook = owner.getHookForReadableStream(stream, oldParent, dupStubs);
+        } else {
+          hook = streamImpl.createReadableStreamHook(stream);
+        }
+        this.hooks.push(hook);
+        return stream;
+      }
+      case "headers":
+        return new Headers(value);
+      case "request": {
+        let req = value;
+        if (req.body) {
+          this.deepCopy(req.body, req, "body", req, dupStubs, owner);
+        }
+        return new Request(req);
+      }
+      case "response": {
+        let resp = value;
+        if (resp.body) {
+          this.deepCopy(resp.body, resp, "body", resp, dupStubs, owner);
+        }
+        return new Response(resp.body, resp);
+      }
       default:
         throw new Error("unreachable");
     }
@@ -537,12 +671,12 @@ var RpcPayload = class _RpcPayload {
   ensureDeepCopied() {
     if (this.source !== "owned") {
       let dupStubs = this.source === "params";
-      this.stubs = [];
+      this.hooks = [];
       this.promises = [];
       try {
         this.value = this.deepCopy(this.value, void 0, "value", this, dupStubs, this);
       } catch (err) {
-        this.stubs = void 0;
+        this.hooks = void 0;
         this.promises = void 0;
         throw err;
       }
@@ -645,7 +779,7 @@ var RpcPayload = class _RpcPayload {
   }
   dispose() {
     if (this.source === "owned") {
-      this.stubs.forEach((stub) => stub[Symbol.dispose]());
+      this.hooks.forEach((hook) => hook.dispose());
       this.promises.forEach((promise) => promise.promise[Symbol.dispose]());
     } else if (this.source === "return") {
       this.disposeImpl(this.value, void 0);
@@ -654,7 +788,7 @@ var RpcPayload = class _RpcPayload {
       }
     } else ;
     this.source = "owned";
-    this.stubs = [];
+    this.hooks = [];
     this.promises = [];
   }
   // Recursive dispose, called only when `source` is "return".
@@ -707,6 +841,40 @@ var RpcPayload = class _RpcPayload {
       }
       case "rpc-thenable":
         return;
+      case "headers":
+        return;
+      case "request": {
+        let req = value;
+        if (req.body) this.disposeImpl(req.body, req);
+        return;
+      }
+      case "response": {
+        let resp = value;
+        if (resp.body) this.disposeImpl(resp.body, resp);
+        return;
+      }
+      case "writable": {
+        let stream = value;
+        let hook = this.rpcTargets?.get(stream);
+        if (hook) {
+          this.rpcTargets.delete(stream);
+        } else {
+          hook = streamImpl.createWritableStreamHook(stream);
+        }
+        hook.dispose();
+        return;
+      }
+      case "readable": {
+        let stream = value;
+        let hook = this.rpcTargets?.get(stream);
+        if (hook) {
+          this.rpcTargets.delete(stream);
+        } else {
+          hook = streamImpl.createReadableStreamHook(stream);
+        }
+        hook.dispose();
+        return;
+      }
       default:
         return;
     }
@@ -715,9 +883,9 @@ var RpcPayload = class _RpcPayload {
   // *would* be awaited if this payload were to be delivered. See the similarly-named method of
   // StubHook for explanation.
   ignoreUnhandledRejections() {
-    if (this.stubs) {
-      this.stubs.forEach((stub) => {
-        unwrapStubOrParent(stub).ignoreUnhandledRejections();
+    if (this.hooks) {
+      this.hooks.forEach((hook) => {
+        hook.ignoreUnhandledRejections();
       });
       this.promises.forEach(
         (promise) => unwrapStubOrParent(promise.promise).ignoreUnhandledRejections()
@@ -738,6 +906,11 @@ var RpcPayload = class _RpcPayload {
       case "undefined":
       case "function":
       case "rpc-target":
+      case "writable":
+      case "readable":
+      case "headers":
+      case "request":
+      case "response":
         return;
       case "array": {
         let array = value;
@@ -810,11 +983,20 @@ function followPath(value, parent, path, owner) {
         let { hook, pathIfPromise } = unwrapStubAndPath(value);
         return { hook, remainingPath: pathIfPromise ? pathIfPromise.concat(path.slice(i)) : path.slice(i) };
       }
+      case "writable":
+        value = void 0;
+        break;
+      case "readable":
+        value = void 0;
+        break;
       case "primitive":
       case "bigint":
       case "bytes":
       case "date":
       case "error":
+      case "headers":
+      case "request":
+      case "response":
         value = void 0;
         break;
       case "undefined":
@@ -1049,6 +1231,14 @@ var PromiseStubHook = class _PromiseStubHook extends StubHook {
     args.ensureDeepCopied();
     return new _PromiseStubHook(this.promise.then((hook) => hook.call(path, args)));
   }
+  stream(path, args) {
+    args.ensureDeepCopied();
+    let promise = this.promise.then((hook) => {
+      let result = hook.stream(path, args);
+      return result.promise;
+    });
+    return { promise };
+  }
   map(path, captures, instructions) {
     return new _PromiseStubHook(this.promise.then(
       (hook) => hook.map(path, captures, instructions),
@@ -1121,6 +1311,9 @@ var NullExporter = class {
   }
   unexport(ids) {
   }
+  createPipe(readable) {
+    throw new Error("Cannot create pipes without an RPC session.");
+  }
   onSendError(error) {
   }
 };
@@ -1218,12 +1411,86 @@ var Devaluator = class _Devaluator {
         let bytes = value;
         if (bytes.toBase64) {
           return ["bytes", bytes.toBase64({ omitPadding: true })];
+        }
+        let b64;
+        if (typeof Buffer !== "undefined") {
+          let buf = bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+          b64 = buf.toString("base64");
         } else {
-          return [
-            "bytes",
-            btoa(String.fromCharCode.apply(null, bytes).replace(/=*$/, ""))
-          ];
+          let binary = "";
+          for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          b64 = btoa(binary);
+        }
+        return ["bytes", b64.replace(/=+$/, "")];
+      }
+      case "headers":
+        return ["headers", [...value]];
+      case "request": {
+        let req = value;
+        let init = {};
+        if (req.method !== "GET") init.method = req.method;
+        let headers = [...req.headers];
+        if (headers.length > 0) {
+          init.headers = headers;
+        }
+        if (req.body) {
+          init.body = this.devaluateImpl(req.body, req, depth + 1);
+          init.duplex = req.duplex || "half";
+        } else if (req.body === void 0 && !["GET", "HEAD", "OPTIONS", "TRACE", "DELETE"].includes(req.method)) {
+          let bodyPromise = req.arrayBuffer();
+          let readable = new ReadableStream({
+            async start(controller) {
+              try {
+                controller.enqueue(new Uint8Array(await bodyPromise));
+                controller.close();
+              } catch (err) {
+                controller.error(err);
+              }
+            }
+          });
+          let hook = streamImpl.createReadableStreamHook(readable);
+          let importId = this.exporter.createPipe(readable, hook);
+          init.body = ["readable", importId];
+          init.duplex = req.duplex || "half";
         }
+        if (req.cache && req.cache !== "default") init.cache = req.cache;
+        if (req.redirect !== "follow") init.redirect = req.redirect;
+        if (req.integrity) init.integrity = req.integrity;
+        if (req.mode && req.mode !== "cors") init.mode = req.mode;
+        if (req.credentials && req.credentials !== "same-origin") {
+          init.credentials = req.credentials;
+        }
+        if (req.referrer && req.referrer !== "about:client") init.referrer = req.referrer;
+        if (req.referrerPolicy) init.referrerPolicy = req.referrerPolicy;
+        if (req.keepalive) init.keepalive = req.keepalive;
+        let cfReq = req;
+        if (cfReq.cf) init.cf = cfReq.cf;
+        if (cfReq.encodeResponseBody && cfReq.encodeResponseBody !== "automatic") {
+          init.encodeResponseBody = cfReq.encodeResponseBody;
+        }
+        return ["request", req.url, init];
+      }
+      case "response": {
+        let resp = value;
+        let body = this.devaluateImpl(resp.body, resp, depth + 1);
+        let init = {};
+        if (resp.status !== 200) init.status = resp.status;
+        if (resp.statusText) init.statusText = resp.statusText;
+        let headers = [...resp.headers];
+        if (headers.length > 0) {
+          init.headers = headers;
+        }
+        let cfResp = resp;
+        if (cfResp.cf) init.cf = cfResp.cf;
+        if (cfResp.encodeBody && cfResp.encodeBody !== "automatic") {
+          init.encodeBody = cfResp.encodeBody;
+        }
+        if (cfResp.webSocket) {
+          throw new TypeError("Can't serialize a Response containing a webSocket.");
+        }
+        return ["response", body, init];
       }
       case "error": {
         let e = value;
@@ -1279,6 +1546,22 @@ var Devaluator = class _Devaluator {
         let hook = this.source.getHookForRpcTarget(value, parent);
         return this.devaluateHook("promise", hook);
       }
+      case "writable": {
+        if (!this.source) {
+          throw new Error("Can't serialize WritableStream in this context.");
+        }
+        let hook = this.source.getHookForWritableStream(value, parent);
+        return this.devaluateHook("writable", hook);
+      }
+      case "readable": {
+        if (!this.source) {
+          throw new Error("Can't serialize ReadableStream in this context.");
+        }
+        let ws = value;
+        let hook = this.source.getHookForReadableStream(ws, parent);
+        let importId = this.exporter.createPipe(ws, hook);
+        return ["readable", importId];
+      }
       default:
         throw new Error("unreachable");
     }
@@ -1303,16 +1586,27 @@ var NullImporter = class {
   getExport(idx) {
     return void 0;
   }
+  getPipeReadable(exportId) {
+    throw new Error("Cannot retrieve pipe readable without an RPC session.");
+  }
 };
 var NULL_IMPORTER = new NullImporter();
+function fixBrokenRequestBody(request, body) {
+  let promise = new Response(body).arrayBuffer().then((arrayBuffer) => {
+    let bytes = new Uint8Array(arrayBuffer);
+    let result = new Request(request, { body: bytes });
+    return new PayloadStubHook(RpcPayload.fromAppReturn(result));
+  });
+  return new RpcPromise(new PromiseStubHook(promise), []);
+}
 var Evaluator = class _Evaluator {
   constructor(importer) {
     this.importer = importer;
   }
-  stubs = [];
+  hooks = [];
   promises = [];
   evaluate(value) {
-    let payload = RpcPayload.forEvaluate(this.stubs, this.promises);
+    let payload = RpcPayload.forEvaluate(this.hooks, this.promises);
     try {
       payload.value = this.evaluateImpl(value, payload, "value");
       return payload;
@@ -1345,10 +1639,11 @@ var Evaluator = class _Evaluator {
           }
           break;
         case "bytes": {
-          let b64 = Uint8Array;
           if (typeof value[1] == "string") {
-            if (b64.fromBase64) {
-              return b64.fromBase64(value[1]);
+            if (typeof Buffer !== "undefined") {
+              return Buffer.from(value[1], "base64");
+            } else if (Uint8Array.fromBase64) {
+              return Uint8Array.fromBase64(value[1]);
             } else {
               let bs = atob(value[1]);
               let len = bs.length;
@@ -1382,6 +1677,56 @@ var Evaluator = class _Evaluator {
           return -Infinity;
         case "nan":
           return NaN;
+        case "headers":
+          if (value.length === 2 && value[1] instanceof Array) {
+            return new Headers(value[1]);
+          }
+          break;
+        case "request": {
+          if (value.length !== 3 || typeof value[1] !== "string") break;
+          let url = value[1];
+          let init = value[2];
+          if (typeof init !== "object" || init === null) break;
+          if (init.body) {
+            init.body = this.evaluateImpl(init.body, init, "body");
+            if (init.body === null || typeof init.body === "string" || init.body instanceof Uint8Array || init.body instanceof ReadableStream) ; else {
+              throw new TypeError("Request body must be of type ReadableStream.");
+            }
+          }
+          if (init.signal) {
+            init.signal = this.evaluateImpl(init.signal, init, "signal");
+            if (!(init.signal instanceof AbortSignal)) {
+              throw new TypeError("Request siganl must be of type AbortSignal.");
+            }
+          }
+          if (init.headers && !(init.headers instanceof Array)) {
+            throw new TypeError("Request headers must be serialized as an array of pairs.");
+          }
+          let result = new Request(url, init);
+          if (init.body instanceof ReadableStream && result.body === void 0) {
+            let promise = fixBrokenRequestBody(result, init.body);
+            this.promises.push({ promise, parent, property });
+            return promise;
+          } else {
+            return result;
+          }
+        }
+        case "response": {
+          if (value.length !== 3) break;
+          let body = this.evaluateImpl(value[1], parent, property);
+          if (body === null || typeof body === "string" || body instanceof Uint8Array || body instanceof ReadableStream) ; else {
+            throw new TypeError("Response body must be of type ReadableStream.");
+          }
+          let init = value[2];
+          if (typeof init !== "object" || init === null) break;
+          if (init.webSocket) {
+            throw new TypeError("Can't deserialize a Response containing a webSocket.");
+          }
+          if (init.headers && !(init.headers instanceof Array)) {
+            throw new TypeError("Request headers must be serialized as an array of pairs.");
+          }
+          return new Response(body, init);
+        }
         case "import":
         case "pipeline": {
           if (value.length < 2 || value.length > 4) {
@@ -1401,9 +1746,8 @@ var Evaluator = class _Evaluator {
               this.promises.push({ promise, parent, property });
               return promise;
             } else {
-              let stub = new RpcPromise(hook2, []);
-              this.stubs.push(stub);
-              return stub;
+              this.hooks.push(hook2);
+              return new RpcPromise(hook2, []);
             }
           };
           if (value.length == 2) {
@@ -1481,12 +1825,27 @@ var Evaluator = class _Evaluator {
               return promise;
             } else {
               let hook = this.importer.importStub(value[1]);
-              let stub = new RpcStub(hook);
-              this.stubs.push(stub);
-              return stub;
+              this.hooks.push(hook);
+              return new RpcStub(hook);
             }
           }
           break;
+        case "writable":
+          if (typeof value[1] == "number") {
+            let hook = this.importer.importStub(value[1]);
+            let stream = streamImpl.createWritableStreamFromHook(hook);
+            this.hooks.push(hook);
+            return stream;
+          }
+          break;
+        case "readable":
+          if (typeof value[1] == "number") {
+            let stream = this.importer.getPipeReadable(value[1]);
+            let hook = streamImpl.createReadableStreamHook(stream);
+            this.hooks.push(hook);
+            return stream;
+          }
+          break;
       }
       throw new TypeError(`unknown special value: ${JSON.stringify(value)}`);
     } else if (value instanceof Object) {
@@ -1626,6 +1985,14 @@ var RpcImportHook = class _RpcImportHook extends StubHook {
       return entry.session.sendCall(entry.importId, path, args);
     }
   }
+  stream(path, args) {
+    let entry = this.getEntry();
+    if (entry.resolution) {
+      return entry.resolution.stream(path, args);
+    } else {
+      return entry.session.sendStream(entry.importId, path, args);
+    }
+  }
   map(path, captures, instructions) {
     let entry;
     try {
@@ -1798,19 +2165,23 @@ var RpcSessionImpl = class {
           return payload;
         }
       };
+      let autoRelease = exp.autoRelease;
       ++this.pullCount;
       exp.pull = resolve().then(
         (payload) => {
           let value = Devaluator.devaluate(payload.value, void 0, this, payload);
           this.send(["resolve", exportId, value]);
+          if (autoRelease) this.releaseExport(exportId, 1);
         },
         (error) => {
           this.send(["reject", exportId, Devaluator.devaluate(error, void 0, this)]);
+          if (autoRelease) this.releaseExport(exportId, 1);
         }
       ).catch(
         (error) => {
           try {
             this.send(["reject", exportId, Devaluator.devaluate(error, void 0, this)]);
+            if (autoRelease) this.releaseExport(exportId, 1);
           } catch (error2) {
             this.abort(error2);
           }
@@ -1862,9 +2233,35 @@ var RpcSessionImpl = class {
   getExport(idx) {
     return this.exports[idx]?.hook;
   }
+  getPipeReadable(exportId) {
+    let entry = this.exports[exportId];
+    if (!entry || !entry.pipeReadable) {
+      throw new Error(`Export ${exportId} is not a pipe or its readable end was already consumed.`);
+    }
+    let readable = entry.pipeReadable;
+    entry.pipeReadable = void 0;
+    return readable;
+  }
+  createPipe(readable, readableHook) {
+    if (this.abortReason) throw this.abortReason;
+    this.send(["pipe"]);
+    let importId = this.imports.length;
+    let entry = new ImportTableEntry(this, importId, false);
+    this.imports.push(entry);
+    let hook = new RpcImportHook(
+      /*isPromise=*/
+      false,
+      entry
+    );
+    let writable = streamImpl.createWritableStreamFromHook(hook);
+    readable.pipeTo(writable).catch(() => {
+    }).finally(() => readableHook.dispose());
+    return importId;
+  }
+  // Serializes and sends a message. Returns the byte length of the serialized message.
   send(msg) {
     if (this.abortReason !== void 0) {
-      return;
+      return 0;
     }
     let msgText;
     try {
@@ -1877,6 +2274,7 @@ var RpcSessionImpl = class {
       throw err;
     }
     this.transport.send(msgText).catch((err) => this.abort(err, false));
+    return msgText.length;
   }
   sendCall(id, path, args) {
     if (this.abortReason) throw this.abortReason;
@@ -1894,6 +2292,34 @@ var RpcSessionImpl = class {
       entry
     );
   }
+  sendStream(id, path, args) {
+    if (this.abortReason) throw this.abortReason;
+    let value = ["pipeline", id, path];
+    let devalue = Devaluator.devaluate(args.value, void 0, this, args);
+    value.push(devalue[0]);
+    let size = this.send(["stream", value]);
+    let importId = this.imports.length;
+    let entry = new ImportTableEntry(
+      this,
+      importId,
+      /*pulling=*/
+      true
+    );
+    entry.remoteRefcount = 0;
+    entry.localRefcount = 1;
+    this.imports.push(entry);
+    let promise = entry.awaitResolution().then(
+      (p) => {
+        p.dispose();
+        delete this.imports[importId];
+      },
+      (err) => {
+        delete this.imports[importId];
+        throw err;
+      }
+    );
+    return { promise, size };
+  }
   sendMap(id, path, captures, instructions) {
     if (this.abortReason) {
       for (let cap of captures) {
@@ -1981,6 +2407,24 @@ var RpcSessionImpl = class {
               continue;
             }
             break;
+          case "stream": {
+            if (msg.length > 1) {
+              let payload = new Evaluator(this).evaluate(msg[1]);
+              let hook = new PayloadStubHook(payload);
+              hook.ignoreUnhandledRejections();
+              let exportId = this.exports.length;
+              this.exports.push({ hook, refcount: 1, autoRelease: true });
+              this.ensureResolvingExport(exportId);
+              continue;
+            }
+            break;
+          }
+          case "pipe": {
+            let { readable, writable } = new TransformStream();
+            let hook = streamImpl.createWritableStreamHook(writable);
+            this.exports.push({ hook, refcount: 1, pipeReadable: readable });
+            continue;
+          }
           case "pull": {
             let exportId = msg[1];
             if (typeof exportId == "number") {
@@ -2476,6 +2920,9 @@ var MapBuilder = class {
   }
   unexport(ids) {
   }
+  createPipe(readable) {
+    throw new Error("Cannot send ReadableStream inside a mapper function.");
+  }
   onSendError(error) {
   }
 };
@@ -2585,6 +3032,9 @@ var MapApplicator = class {
       return this.variables[idx];
     }
   }
+  getPipeReadable(exportId) {
+    throw new Error("A mapper function cannot use pipe readables.");
+  }
 };
 function applyMapToElement(input, parent, owner, captures, instructions) {
   let inputHook = new PayloadStubHook(RpcPayload.deepCopyFrom(input, parent, owner));
@@ -2625,6 +3075,333 @@ mapImpl.applyMap = (input, parent, owner, captures, instructions) => {
     }
   }
 };
+
+// src/streams.ts
+var WritableStreamStubHook = class _WritableStreamStubHook extends StubHook {
+  state;
+  // undefined when disposed
+  // Creates a new WritableStreamStubHook that is not duplicated from an existing hook.
+  static create(stream) {
+    let writer = stream.getWriter();
+    return new _WritableStreamStubHook({ refcount: 1, writer, closed: false });
+  }
+  constructor(state, dupFrom) {
+    super();
+    this.state = state;
+    if (dupFrom) {
+      ++state.refcount;
+    }
+  }
+  getState() {
+    if (this.state) {
+      return this.state;
+    } else {
+      throw new Error("Attempted to use a WritableStreamStubHook after it was disposed.");
+    }
+  }
+  call(path, args) {
+    try {
+      let state = this.getState();
+      if (path.length !== 1 || typeof path[0] !== "string") {
+        throw new Error("WritableStream stub only supports direct method calls");
+      }
+      const method = path[0];
+      if (method !== "write" && method !== "close" && method !== "abort") {
+        args.dispose();
+        throw new Error(`Unknown WritableStream method: ${method}`);
+      }
+      if (method === "close" || method === "abort") {
+        state.closed = true;
+      }
+      let func = state.writer[method];
+      let promise = args.deliverCall(func, state.writer);
+      return new PromiseStubHook(promise.then((payload) => new PayloadStubHook(payload)));
+    } catch (err) {
+      return new ErrorStubHook(err);
+    }
+  }
+  map(path, captures, instructions) {
+    for (let cap of captures) {
+      cap.dispose();
+    }
+    return new ErrorStubHook(new Error("Cannot use map() on a WritableStream"));
+  }
+  get(path) {
+    return new ErrorStubHook(new Error("Cannot access properties on a WritableStream stub"));
+  }
+  dup() {
+    let state = this.getState();
+    return new _WritableStreamStubHook(state, this);
+  }
+  pull() {
+    return Promise.reject(new Error("Cannot pull a WritableStream stub"));
+  }
+  ignoreUnhandledRejections() {
+  }
+  dispose() {
+    let state = this.state;
+    this.state = void 0;
+    if (state) {
+      if (--state.refcount === 0) {
+        if (!state.closed) {
+          state.writer.abort(new Error("WritableStream RPC stub was disposed without calling close()")).catch(() => {
+          });
+        }
+        state.writer.releaseLock();
+      }
+    }
+  }
+  onBroken(callback) {
+  }
+};
+var INITIAL_WINDOW = 256 * 1024;
+var MAX_WINDOW = 1024 * 1024 * 1024;
+var MIN_WINDOW = 64 * 1024;
+var STARTUP_GROWTH_FACTOR = 2;
+var STEADY_GROWTH_FACTOR = 1.25;
+var DECAY_FACTOR = 0.9;
+var STARTUP_EXIT_ROUNDS = 3;
+var FlowController = class {
+  constructor(now) {
+    this.now = now;
+  }
+  // The current window size in bytes. The sender blocks when bytesInFlight >= window.
+  window = INITIAL_WINDOW;
+  // Total bytes currently in flight (sent but not yet acked).
+  bytesInFlight = 0;
+  // Whether we're still in the startup phase.
+  inStartupPhase = true;
+  // ----- BDP estimation state (private) -----
+  // Total bytes acked so far.
+  delivered = 0;
+  // Time of most recent ack.
+  deliveredTime = 0;
+  // Time when the very first ack was received.
+  firstAckTime = 0;
+  firstAckDelivered = 0;
+  // Global minimum RTT observed (milliseconds).
+  minRtt = Infinity;
+  // For startup exit: count of consecutive RTT rounds where the window didn't meaningfully grow.
+  roundsWithoutIncrease = 0;
+  // Window size at the start of the current round, for startup exit detection.
+  lastRoundWindow = 0;
+  // Time when the current round started.
+  roundStartTime = 0;
+  // Called when a write of `size` bytes is about to be sent. Returns a token that must be
+  // passed to onAck() when the ack arrives, and whether the sender should block (window full).
+  onSend(size) {
+    this.bytesInFlight += size;
+    let token = {
+      sentTime: this.now(),
+      size,
+      deliveredAtSend: this.delivered,
+      deliveredTimeAtSend: this.deliveredTime,
+      windowAtSend: this.window,
+      windowFullAtSend: this.bytesInFlight >= this.window
+    };
+    return { token, shouldBlock: token.windowFullAtSend };
+  }
+  // Called when a previously-sent write fails. Restores bytesInFlight without updating
+  // any BDP estimates.
+  onError(token) {
+    this.bytesInFlight -= token.size;
+  }
+  // Called when an ack is received for a previously-sent write. Updates BDP estimates and
+  // the window. Returns whether a blocked sender should now unblock.
+  onAck(token) {
+    let ackTime = this.now();
+    this.delivered += token.size;
+    this.deliveredTime = ackTime;
+    this.bytesInFlight -= token.size;
+    let rtt = ackTime - token.sentTime;
+    this.minRtt = Math.min(this.minRtt, rtt);
+    if (this.firstAckTime === 0) {
+      this.firstAckTime = ackTime;
+      this.firstAckDelivered = this.delivered;
+    } else {
+      let baseTime;
+      let baseDelivered;
+      if (token.deliveredTimeAtSend === 0) {
+        baseTime = this.firstAckTime;
+        baseDelivered = this.firstAckDelivered;
+      } else {
+        baseTime = token.deliveredTimeAtSend;
+        baseDelivered = token.deliveredAtSend;
+      }
+      let interval = ackTime - baseTime;
+      let bytes = this.delivered - baseDelivered;
+      let bandwidth = bytes / interval;
+      let growthFactor = this.inStartupPhase ? STARTUP_GROWTH_FACTOR : STEADY_GROWTH_FACTOR;
+      let newWindow = bandwidth * this.minRtt * growthFactor;
+      newWindow = Math.min(newWindow, token.windowAtSend * growthFactor);
+      if (token.windowFullAtSend) {
+        newWindow = Math.max(newWindow, token.windowAtSend * DECAY_FACTOR);
+      } else {
+        newWindow = Math.max(newWindow, this.window);
+      }
+      this.window = Math.max(Math.min(newWindow, MAX_WINDOW), MIN_WINDOW);
+      if (this.inStartupPhase && token.sentTime >= this.roundStartTime) {
+        if (this.window > this.lastRoundWindow * STEADY_GROWTH_FACTOR) {
+          this.roundsWithoutIncrease = 0;
+        } else {
+          if (++this.roundsWithoutIncrease >= STARTUP_EXIT_ROUNDS) {
+            this.inStartupPhase = false;
+          }
+        }
+        this.roundStartTime = ackTime;
+        this.lastRoundWindow = this.window;
+      }
+    }
+    return this.bytesInFlight < this.window;
+  }
+};
+function createWritableStreamFromHook(hook) {
+  let pendingError = void 0;
+  let hookDisposed = false;
+  let fc = new FlowController(() => performance.now());
+  let windowResolve;
+  let windowReject;
+  const disposeHook = () => {
+    if (!hookDisposed) {
+      hookDisposed = true;
+      hook.dispose();
+    }
+  };
+  return new WritableStream({
+    write(chunk, controller) {
+      if (pendingError !== void 0) {
+        throw pendingError;
+      }
+      const payload = RpcPayload.fromAppParams([chunk]);
+      const { promise, size } = hook.stream(["write"], payload);
+      if (size === void 0) {
+        return promise.catch((err) => {
+          if (pendingError === void 0) {
+            pendingError = err;
+          }
+          throw err;
+        });
+      } else {
+        let { token, shouldBlock } = fc.onSend(size);
+        promise.then(() => {
+          let hasCapacity = fc.onAck(token);
+          if (hasCapacity && windowResolve) {
+            windowResolve();
+            windowResolve = void 0;
+            windowReject = void 0;
+          }
+        }, (err) => {
+          fc.onError(token);
+          if (pendingError === void 0) {
+            pendingError = err;
+            controller.error(err);
+            disposeHook();
+          }
+          if (windowReject) {
+            windowReject(err);
+            windowResolve = void 0;
+            windowReject = void 0;
+          }
+        });
+        if (shouldBlock) {
+          return new Promise((resolve, reject) => {
+            windowResolve = resolve;
+            windowReject = reject;
+          });
+        }
+      }
+    },
+    async close() {
+      if (pendingError !== void 0) {
+        disposeHook();
+        throw pendingError;
+      }
+      const { promise } = hook.stream(["close"], RpcPayload.fromAppParams([]));
+      try {
+        await promise;
+      } catch (err) {
+        throw pendingError ?? err;
+      } finally {
+        disposeHook();
+      }
+    },
+    abort(reason) {
+      if (pendingError !== void 0) {
+        return;
+      }
+      pendingError = reason ?? new Error("WritableStream was aborted");
+      if (windowReject) {
+        windowReject(pendingError);
+        windowResolve = void 0;
+        windowReject = void 0;
+      }
+      const { promise } = hook.stream(["abort"], RpcPayload.fromAppParams([reason]));
+      promise.then(() => disposeHook(), () => disposeHook());
+    }
+  });
+}
+var ReadableStreamStubHook = class _ReadableStreamStubHook extends StubHook {
+  state;
+  // undefined when disposed
+  // Creates a new ReadableStreamStubHook.
+  static create(stream) {
+    return new _ReadableStreamStubHook({ refcount: 1, stream, canceled: false });
+  }
+  constructor(state, dupFrom) {
+    super();
+    this.state = state;
+    if (dupFrom) {
+      ++state.refcount;
+    }
+  }
+  call(path, args) {
+    args.dispose();
+    return new ErrorStubHook(new Error("Cannot call methods on a ReadableStream stub"));
+  }
+  map(path, captures, instructions) {
+    for (let cap of captures) {
+      cap.dispose();
+    }
+    return new ErrorStubHook(new Error("Cannot use map() on a ReadableStream"));
+  }
+  get(path) {
+    return new ErrorStubHook(new Error("Cannot access properties on a ReadableStream stub"));
+  }
+  dup() {
+    let state = this.state;
+    if (!state) {
+      throw new Error("Attempted to dup a ReadableStreamStubHook after it was disposed.");
+    }
+    return new _ReadableStreamStubHook(state, this);
+  }
+  pull() {
+    return Promise.reject(new Error("Cannot pull a ReadableStream stub"));
+  }
+  ignoreUnhandledRejections() {
+  }
+  dispose() {
+    let state = this.state;
+    this.state = void 0;
+    if (state) {
+      if (--state.refcount === 0) {
+        if (!state.canceled) {
+          state.canceled = true;
+          if (!state.stream.locked) {
+            state.stream.cancel(
+              new Error("ReadableStream RPC stub was disposed without being consumed")
+            ).catch(() => {
+            });
+          }
+        }
+      }
+    }
+  }
+  onBroken(callback) {
+  }
+};
+streamImpl.createWritableStreamHook = WritableStreamStubHook.create;
+streamImpl.createWritableStreamFromHook = createWritableStreamFromHook;
+streamImpl.createReadableStreamHook = ReadableStreamStubHook.create;
 var RpcStub2 = RpcStub;
 var RpcPromise2 = RpcPromise;
 var RpcSession2 = RpcSession;