capnweb 0.7.0 → 0.8.0

package/README.md

@@ -201,6 +201,7 @@ The following types can be passed over RPC (in arguments or return values), and
 * `Date`
 * `Uint8Array`
 * `Error` and its well-known subclasses
+* `Blob`
 * `ReadableStream` and `WritableStream`, with automatic flow control.
 * `Headers`, `Request`, and `Response` from the Fetch API.
 

package/dist/index-bun.cjs

@@ -70,6 +70,8 @@ function typeForRpc(value) {
       return "request";
     case Response.prototype:
       return "response";
+    case Blob.prototype:
+      return "blob";
     // TODO: All other structured clone types.
     case RpcStub.prototype:
       return "stub";
@@ -540,6 +542,7 @@ var RpcPayload = class _RpcPayload {
       case "bigint":
       case "date":
       case "bytes":
+      case "blob":
       case "error":
       case "undefined":
         return value;
@@ -776,6 +779,7 @@ var RpcPayload = class _RpcPayload {
       case "primitive":
       case "bigint":
       case "bytes":
+      case "blob":
       case "date":
       case "error":
       case "undefined":
@@ -878,6 +882,7 @@ var RpcPayload = class _RpcPayload {
       case "primitive":
       case "bigint":
       case "bytes":
+      case "blob":
       case "date":
       case "error":
       case "undefined":
@@ -969,6 +974,7 @@ function followPath(value, parent, path, owner) {
       case "primitive":
       case "bigint":
       case "bytes":
+      case "blob":
       case "date":
       case "error":
       case "headers":
@@ -1295,6 +1301,10 @@ var NullExporter = class {
   }
 };
 var NULL_EXPORTER = new NullExporter();
+async function streamToBlob(stream, type) {
+  let b = await new Response(stream).blob();
+  return b.type === type ? b : b.slice(0, b.size, type);
+}
 var ERROR_TYPES = {
   Error,
   EvalError,
@@ -1382,8 +1392,10 @@ var Devaluator = class _Devaluator {
       }
       case "bigint":
         return ["bigint", value.toString()];
-      case "date":
-        return ["date", value.getTime()];
+      case "date": {
+        const time = value.getTime();
+        return ["date", Number.isNaN(time) ? null : time];
+      }
       case "bytes": {
         let bytes = value;
         if (bytes.toBase64) {
@@ -1469,14 +1481,52 @@ var Devaluator = class _Devaluator {
         }
         return ["response", body, init];
       }
+      case "blob": {
+        let blob = value;
+        let readable = blob.stream();
+        let hook = streamImpl.createReadableStreamHook(readable);
+        let importId = this.exporter.createPipe(readable, hook);
+        return ["blob", blob.type, ["readable", importId]];
+      }
       case "error": {
         let e = value;
         let rewritten = this.exporter.onSendError(e);
         if (rewritten) {
           e = rewritten;
         }
+        let anyE = e;
+        let props;
+        let captureProp = (key, val) => {
+          let exportsBefore = this.exports?.length ?? 0;
+          try {
+            let encoded = this.devaluateImpl(val, e, depth + 1);
+            if (!props) props = {};
+            props[key] = encoded;
+          } catch (err) {
+            if (this.exports && this.exports.length > exportsBefore) {
+              let tail = this.exports.splice(exportsBefore);
+              try {
+                this.exporter.unexport(tail);
+              } catch (err2) {
+              }
+            }
+          }
+        };
+        for (let key of Object.keys(e)) {
+          if (key === "name" || key === "message" || key === "stack") continue;
+          captureProp(key, anyE[key]);
+        }
+        if ("cause" in e) {
+          captureProp("cause", anyE.cause);
+        }
+        if (e instanceof AggregateError) {
+          captureProp("errors", e.errors);
+        }
         let result = ["error", e.name, e.message];
-        if (rewritten && rewritten.stack) {
+        if (props) {
+          result.push(rewritten && rewritten.stack ? rewritten.stack : null);
+          result.push(props);
+        } else if (rewritten && rewritten.stack) {
           result.push(rewritten.stack);
         }
         return result;
@@ -1576,6 +1626,12 @@ function fixBrokenRequestBody(request, body) {
   });
   return new RpcPromise(new PromiseStubHook(promise), []);
 }
+function streamToBlobPromise(stream, type) {
+  let promise = streamToBlob(stream, type).then((blob) => {
+    return new PayloadStubHook(RpcPayload.fromAppReturn(blob));
+  });
+  return new RpcPromise(new PromiseStubHook(promise), []);
+}
 var Evaluator = class _Evaluator {
   constructor(importer) {
     this.importer = importer;
@@ -1611,6 +1667,9 @@ var Evaluator = class _Evaluator {
           }
           break;
         case "date":
+          if (value[1] === null) {
+            return /* @__PURE__ */ new Date(NaN);
+          }
           if (typeof value[1] == "number") {
             return new Date(value[1]);
           }
@@ -1636,10 +1695,22 @@ var Evaluator = class _Evaluator {
         case "error":
           if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
             let cls = ERROR_TYPES[value[1]] || Error;
-            let result = new cls(value[2]);
+            let result = cls === AggregateError ? new cls([], value[2]) : new cls(value[2]);
             if (typeof value[3] === "string") {
               result.stack = value[3];
             }
+            if (value.length >= 5) {
+              let props = value[4];
+              if (!props || typeof props !== "object" || Array.isArray(props)) {
+                break;
+              }
+              let anyResult = result;
+              let propsObj = props;
+              for (let key of Object.keys(propsObj)) {
+                if (key === "name" || key === "message" || key === "stack") continue;
+                anyResult[key] = this.evaluateImpl(propsObj[key], result, key);
+              }
+            }
             return result;
           }
           break;
@@ -1704,6 +1775,17 @@ var Evaluator = class _Evaluator {
           }
           return new Response(body, init);
         }
+        case "blob": {
+          if (value.length !== 3 || typeof value[1] !== "string") break;
+          let contentType = value[1];
+          let content = this.evaluateImpl(value[2], parent, property);
+          if (!(content instanceof ReadableStream)) {
+            throw new TypeError("Blob content must be serialized as a ReadableStream.");
+          }
+          let promise = streamToBlobPromise(content, contentType);
+          this.promises.push({ promise, parent, property });
+          return promise;
+        }
         case "import":
         case "pipeline": {
           if (value.length < 2 || value.length > 4) {
@@ -2044,12 +2126,7 @@ var RpcSessionImpl = class {
     this.options = options;
     this.exports.push({ hook: mainHook, refcount: 1 });
     this.imports.push(new ImportTableEntry(this, 0, false));
-    let rejectFunc;
-    let abortPromise = new Promise((resolve, reject) => {
-      rejectFunc = reject;
-    });
-    this.cancelReadLoop = rejectFunc;
-    this.readLoop(abortPromise).catch((err) => this.abort(err));
+    this.readLoop().catch((err) => this.abort(err));
   }
   exports = [];
   reverseExports = /* @__PURE__ */ new Map();
@@ -2333,7 +2410,8 @@ var RpcSessionImpl = class {
   }
   abort(error, trySendAbortMessage = true) {
     if (this.abortReason !== void 0) return;
-    this.cancelReadLoop(error);
+    this.cancelReadLoop?.(error);
+    this.cancelReadLoop = void 0;
     if (trySendAbortMessage) {
       try {
         this.transport.send(JSON.stringify(["abort", Devaluator.devaluate(error, void 0, this)])).catch((err) => {
@@ -2369,9 +2447,19 @@ var RpcSessionImpl = class {
       this.exports[i].hook.dispose();
     }
   }
-  async readLoop(abortPromise) {
+  async readLoop() {
     while (!this.abortReason) {
-      let msg = JSON.parse(await Promise.race([this.transport.receive(), abortPromise]));
+      let readCanceled = Promise.withResolvers();
+      this.cancelReadLoop = readCanceled.reject;
+      let msgText;
+      try {
+        msgText = await Promise.race([this.transport.receive(), readCanceled.promise]);
+      } finally {
+        if (this.cancelReadLoop === readCanceled.reject) {
+          this.cancelReadLoop = void 0;
+        }
+      }
+      let msg = JSON.parse(msgText);
       if (this.abortReason) break;
       if (msg instanceof Array) {
         switch (msg[0]) {