capnweb 0.10.0 → 0.11.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -76,9 +76,22 @@ function typeForRpc(value) {
76
76
  case Array.prototype: return "array";
77
77
  case Date.prototype: return "date";
78
78
  case Uint8Array.prototype:
79
- case BUFFER_PROTOTYPE: return "bytes";
79
+ case BUFFER_PROTOTYPE:
80
+ case ArrayBuffer.prototype:
81
+ case DataView.prototype:
82
+ case Int8Array.prototype:
83
+ case Uint8ClampedArray.prototype:
84
+ case Int16Array.prototype:
85
+ case Uint16Array.prototype:
86
+ case Int32Array.prototype:
87
+ case Uint32Array.prototype:
88
+ case BigInt64Array.prototype:
89
+ case BigUint64Array.prototype:
90
+ case Float32Array.prototype:
91
+ case Float64Array.prototype: return "bytes";
80
92
  case WritableStream.prototype: return "writable";
81
93
  case ReadableStream.prototype: return "readable";
94
+ case URL.prototype: return "url";
82
95
  case Headers.prototype: return "headers";
83
96
  case Request.prototype: return "request";
84
97
  case Response.prototype: return "response";
@@ -413,6 +426,7 @@ var RpcPayload = class RpcPayload {
413
426
  case "date":
414
427
  case "bytes":
415
428
  case "blob":
429
+ case "url":
416
430
  case "error":
417
431
  case "undefined": return value;
418
432
  case "array": {
@@ -546,6 +560,30 @@ var RpcPayload = class RpcPayload {
546
560
  this.dispose();
547
561
  }
548
562
  }
563
+ async deliverStreamWrite(writer) {
564
+ try {
565
+ let promises = [];
566
+ this.deliverTo(this, "value", promises);
567
+ if (promises.length > 0) await Promise.all(promises);
568
+ let chunk = this.value[0];
569
+ if ((this.hooks.length > 0 || this.promises.length > 0) && chunk instanceof Object) {
570
+ if (!(Symbol.dispose in chunk)) Object.defineProperty(chunk, Symbol.dispose, {
571
+ value: () => this.dispose(),
572
+ writable: true,
573
+ enumerable: false,
574
+ configurable: true
575
+ });
576
+ await writer.write(chunk);
577
+ return RpcPayload.fromAppReturn(void 0);
578
+ }
579
+ await writer.write(chunk);
580
+ this.dispose();
581
+ return RpcPayload.fromAppReturn(void 0);
582
+ } catch (err) {
583
+ this.dispose();
584
+ throw err;
585
+ }
586
+ }
549
587
  async deliverResolve() {
550
588
  try {
551
589
  let promises = [];
@@ -586,6 +624,7 @@ var RpcPayload = class RpcPayload {
586
624
  case "bytes":
587
625
  case "blob":
588
626
  case "date":
627
+ case "url":
589
628
  case "error":
590
629
  case "undefined": return;
591
630
  case "array": {
@@ -668,6 +707,7 @@ var RpcPayload = class RpcPayload {
668
707
  case "rpc-target":
669
708
  case "writable":
670
709
  case "readable":
710
+ case "url":
671
711
  case "headers":
672
712
  case "request":
673
713
  case "response": return;
@@ -737,6 +777,7 @@ function followPath(value, parent, path, owner) {
737
777
  case "blob":
738
778
  case "date":
739
779
  case "error":
780
+ case "url":
740
781
  case "headers":
741
782
  case "request":
742
783
  case "response":
@@ -970,6 +1011,71 @@ const DEFAULT_LIMITS = {
970
1011
  maxDepth: 256,
971
1012
  maxMessageSize: 32 * 1024 * 1024
972
1013
  };
1014
+ const NATIVE_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
1015
+ const BYTE_CONTAINER_TYPE_NAMES = [
1016
+ "ArrayBuffer",
1017
+ "DataView",
1018
+ "Int8Array",
1019
+ "Uint8Array",
1020
+ "Uint8ClampedArray",
1021
+ "Int16Array",
1022
+ "Uint16Array",
1023
+ "Int32Array",
1024
+ "Uint32Array",
1025
+ "BigInt64Array",
1026
+ "BigUint64Array",
1027
+ "Float32Array",
1028
+ "Float64Array"
1029
+ ];
1030
+ function isValidByteContainerName(value) {
1031
+ return BYTE_CONTAINER_TYPE_NAMES.includes(value);
1032
+ }
1033
+ const TYPED_ARRAY_ELEMENT_SIZE = {
1034
+ ArrayBuffer: void 0,
1035
+ DataView: void 0,
1036
+ Int8Array: void 0,
1037
+ Uint8Array: void 0,
1038
+ Uint8ClampedArray: void 0,
1039
+ Int16Array: 2,
1040
+ Uint16Array: 2,
1041
+ Int32Array: 4,
1042
+ Uint32Array: 4,
1043
+ BigInt64Array: 8,
1044
+ BigUint64Array: 8,
1045
+ Float32Array: 4,
1046
+ Float64Array: 8
1047
+ };
1048
+ const BYTE_CONTAINER_PROTOTYPES = {
1049
+ ArrayBuffer: ArrayBuffer.prototype,
1050
+ DataView: DataView.prototype,
1051
+ Int8Array: Int8Array.prototype,
1052
+ Uint8ClampedArray: Uint8ClampedArray.prototype,
1053
+ Int16Array: Int16Array.prototype,
1054
+ Uint16Array: Uint16Array.prototype,
1055
+ Int32Array: Int32Array.prototype,
1056
+ Uint32Array: Uint32Array.prototype,
1057
+ BigInt64Array: BigInt64Array.prototype,
1058
+ BigUint64Array: BigUint64Array.prototype,
1059
+ Float32Array: Float32Array.prototype,
1060
+ Float64Array: Float64Array.prototype
1061
+ };
1062
+ const BYTE_CONTAINER_TYPE_BY_PROTOTYPE = /* @__PURE__ */ new Map();
1063
+ for (let type of Object.keys(BYTE_CONTAINER_PROTOTYPES)) BYTE_CONTAINER_TYPE_BY_PROTOTYPE.set(BYTE_CONTAINER_PROTOTYPES[type], type);
1064
+ function swapByteOrder(bytes, elementSize) {
1065
+ if (elementSize !== 2 && elementSize !== 4 && elementSize !== 8) throw new RangeError(`Unsupported element size: ${elementSize}`);
1066
+ let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
1067
+ for (let offset = 0; offset < bytes.byteLength; offset += elementSize) switch (elementSize) {
1068
+ case 2:
1069
+ view.setUint16(offset, view.getUint16(offset, false), true);
1070
+ break;
1071
+ case 4:
1072
+ view.setUint32(offset, view.getUint32(offset, false), true);
1073
+ break;
1074
+ case 8:
1075
+ view.setBigUint64(offset, view.getBigUint64(offset, false), true);
1076
+ break;
1077
+ }
1078
+ }
973
1079
  var NullExporter = class {
974
1080
  exportStub(stub) {
975
1081
  throw new Error("Cannot serialize RPC stubs without an RPC session.");
@@ -989,7 +1095,8 @@ async function streamToBlob(stream, type) {
989
1095
  let b = await new Response(stream).blob();
990
1096
  return b.type === type ? b : b.slice(0, b.size, type);
991
1097
  }
992
- const ERROR_TYPES = Object.assign(Object.create(null), {
1098
+ const ERROR_TYPES = {
1099
+ __proto__: null,
993
1100
  Error,
994
1101
  EvalError,
995
1102
  RangeError,
@@ -998,7 +1105,7 @@ const ERROR_TYPES = Object.assign(Object.create(null), {
998
1105
  TypeError,
999
1106
  URIError,
1000
1107
  AggregateError
1001
- });
1108
+ };
1002
1109
  var Devaluator = class Devaluator {
1003
1110
  exporter;
1004
1111
  source;
@@ -1060,18 +1167,40 @@ var Devaluator = class Devaluator {
1060
1167
  return ["date", Number.isNaN(time) ? null : time];
1061
1168
  }
1062
1169
  case "bytes": {
1063
- let bytes = value;
1064
- if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return ["bytes", bytes];
1065
- if (bytes.toBase64) return ["bytes", bytes.toBase64({ omitPadding: true })];
1170
+ let alternateTypeName = BYTE_CONTAINER_TYPE_BY_PROTOTYPE.get(Object.getPrototypeOf(value));
1171
+ let bytes;
1172
+ if (alternateTypeName === "ArrayBuffer") bytes = new Uint8Array(value);
1173
+ else if (alternateTypeName === void 0) bytes = value;
1174
+ else {
1175
+ let view = value;
1176
+ bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
1177
+ let elementSize = TYPED_ARRAY_ELEMENT_SIZE[alternateTypeName];
1178
+ if (!NATIVE_LITTLE_ENDIAN && elementSize) {
1179
+ bytes = bytes.slice();
1180
+ swapByteOrder(bytes, elementSize);
1181
+ }
1182
+ }
1183
+ if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return alternateTypeName === void 0 ? ["bytes", bytes] : [
1184
+ "bytes",
1185
+ bytes,
1186
+ alternateTypeName
1187
+ ];
1066
1188
  let b64;
1067
- if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
1189
+ if (bytes.toBase64) b64 = bytes.toBase64({ omitPadding: true });
1190
+ else if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
1068
1191
  else {
1069
1192
  let binary = "";
1070
1193
  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
1071
1194
  b64 = btoa(binary);
1072
1195
  }
1073
- return ["bytes", b64.replace(/=+$/, "")];
1196
+ b64 = b64.replace(/=+$/, "");
1197
+ return alternateTypeName === void 0 ? ["bytes", b64] : [
1198
+ "bytes",
1199
+ b64,
1200
+ alternateTypeName
1201
+ ];
1074
1202
  }
1203
+ case "url": return ["url", value.href];
1075
1204
  case "headers": return ["headers", [...value]];
1076
1205
  case "request": {
1077
1206
  let req = value;
@@ -1323,18 +1452,46 @@ var Evaluator = class Evaluator {
1323
1452
  if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
1324
1453
  if (typeof value[1] == "number") return new Date(value[1]);
1325
1454
  break;
1326
- case "bytes":
1327
- if (value[1] instanceof Uint8Array) return value[1];
1328
- if (typeof value[1] == "string") if (typeof Buffer !== "undefined") return Buffer.from(value[1], "base64");
1329
- else if (Uint8Array.fromBase64) return Uint8Array.fromBase64(value[1]);
1455
+ case "bytes": {
1456
+ let bytes;
1457
+ if (value[1] instanceof Uint8Array) bytes = value[1];
1458
+ else if (typeof value[1] == "string") if (typeof Buffer !== "undefined") bytes = Buffer.from(value[1], "base64");
1459
+ else if (Uint8Array.fromBase64) bytes = Uint8Array.fromBase64(value[1]);
1330
1460
  else {
1331
1461
  let bs = atob(value[1]);
1332
1462
  let len = bs.length;
1333
- let bytes = new Uint8Array(len);
1463
+ bytes = new Uint8Array(len);
1334
1464
  for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
1335
- return bytes;
1336
1465
  }
1337
- break;
1466
+ else break;
1467
+ if (value.length === 2) return bytes;
1468
+ if (typeof value[2] !== "string") throw new TypeError(`Unknown bytes type marker type: ${typeof value[2]}`);
1469
+ if (!isValidByteContainerName(value[2])) {
1470
+ let marker = value[2].slice(0, 64);
1471
+ throw new TypeError(`Unknown bytes type marker: ${marker}`);
1472
+ }
1473
+ let marker = value[2];
1474
+ let elementSize = TYPED_ARRAY_ELEMENT_SIZE[marker];
1475
+ if (elementSize !== void 0 && bytes.byteLength % elementSize !== 0) throw new TypeError(`Invalid byte length ${bytes.byteLength} for ${marker}; expected a multiple of ${elementSize}`);
1476
+ let buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
1477
+ if (!NATIVE_LITTLE_ENDIAN && elementSize !== void 0) swapByteOrder(new Uint8Array(buffer), elementSize);
1478
+ switch (marker) {
1479
+ case "ArrayBuffer": return buffer;
1480
+ case "DataView": return new DataView(buffer);
1481
+ case "Int8Array": return new Int8Array(buffer);
1482
+ case "Uint8Array": return new Uint8Array(buffer);
1483
+ case "Uint8ClampedArray": return new Uint8ClampedArray(buffer);
1484
+ case "Int16Array": return new Int16Array(buffer);
1485
+ case "Uint16Array": return new Uint16Array(buffer);
1486
+ case "Int32Array": return new Int32Array(buffer);
1487
+ case "Uint32Array": return new Uint32Array(buffer);
1488
+ case "BigInt64Array": return new BigInt64Array(buffer);
1489
+ case "BigUint64Array": return new BigUint64Array(buffer);
1490
+ case "Float32Array": return new Float32Array(buffer);
1491
+ case "Float64Array": return new Float64Array(buffer);
1492
+ default:
1493
+ }
1494
+ }
1338
1495
  case "error":
1339
1496
  if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
1340
1497
  let cls = ERROR_TYPES[value[1]] || Error;
@@ -1363,6 +1520,9 @@ var Evaluator = class Evaluator {
1363
1520
  case "inf": return Infinity;
1364
1521
  case "-inf": return -Infinity;
1365
1522
  case "nan": return NaN;
1523
+ case "url":
1524
+ if (value.length === 2 && typeof value[1] === "string") return new URL(value[1]);
1525
+ break;
1366
1526
  case "headers":
1367
1527
  if (value.length === 2 && value[1] instanceof Array) return new Headers(value[1]);
1368
1528
  break;
@@ -1584,10 +1744,6 @@ var ImportTableEntry = class {
1584
1744
  resolution;
1585
1745
  onBrokenRegistrations;
1586
1746
  resolve(resolution) {
1587
- if (this.resolution) {
1588
- resolution.dispose();
1589
- return;
1590
- }
1591
1747
  if (this.localRefcount == 0) {
1592
1748
  resolution.dispose();
1593
1749
  return;
@@ -2187,6 +2343,8 @@ var RpcSession$1 = class {
2187
2343
 
2188
2344
  //#endregion
2189
2345
  //#region src/websocket.ts
2346
+ /** Close-frame reason max UTF-8 bytes: 125 payload - 2-byte status (RFC 6455 section 5.5). */
2347
+ const MAX_CLOSE_REASON_BYTES = 123;
2190
2348
  function newWebSocketRpcSession$1(webSocket, localMain, options) {
2191
2349
  if (typeof webSocket === "string") webSocket = new WebSocket(webSocket);
2192
2350
  return new RpcSession$1(new WebSocketTransport(webSocket), localMain, options).getRemoteMain();
@@ -2281,6 +2439,7 @@ var WebSocketTransport = class {
2281
2439
 
2282
2440
  //#endregion
2283
2441
  //#region src/batch.ts
2442
+ const yieldToMacrotask = typeof setImmediate === "function" ? () => new Promise((resolve) => setImmediate(resolve)) : () => new Promise((resolve) => setTimeout(resolve, 0));
2284
2443
  var BatchClientTransport = class {
2285
2444
  constructor(sendBatch) {
2286
2445
  this.#promise = this.#scheduleBatch(sendBatch);
@@ -2302,7 +2461,7 @@ var BatchClientTransport = class {
2302
2461
  this.#aborted = reason;
2303
2462
  }
2304
2463
  async #scheduleBatch(sendBatch) {
2305
- await new Promise((resolve) => setTimeout(resolve, 0));
2464
+ await yieldToMacrotask();
2306
2465
  if (this.#aborted !== void 0) throw this.#aborted;
2307
2466
  let batch = this.#batchToSend;
2308
2467
  this.#batchToSend = null;
@@ -2712,8 +2871,7 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
2712
2871
  throw new Error(`Unknown WritableStream method: ${method}`);
2713
2872
  }
2714
2873
  if (method === "close" || method === "abort") state.closed = true;
2715
- let func = state.writer[method];
2716
- return new PromiseStubHook(args.deliverCall(func, state.writer).then((payload) => new PayloadStubHook(payload)));
2874
+ return new PromiseStubHook((method === "write" ? args.deliverStreamWrite(state.writer) : args.deliverCall(state.writer[method], state.writer)).then((payload) => new PayloadStubHook(payload)));
2717
2875
  } catch (err) {
2718
2876
  return new ErrorStubHook(err);
2719
2877
  }