capnweb 0.0.0-2a02db9 → 0.0.0-2b292e4

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.
@@ -172,6 +172,9 @@ declare class RpcPayload {
172
172
  private deliverTo;
173
173
  private static deliverRpcPromiseTo;
174
174
  deliverCall(func: Function, thisArg: object | undefined): Promise<RpcPayload>;
175
+ deliverStreamWrite(writer: {
176
+ write(chunk: unknown): Promise<void>;
177
+ }): Promise<RpcPayload>;
175
178
  deliverResolve(): Promise<unknown>;
176
179
  dispose(): void;
177
180
  private disposeImpl;
@@ -172,6 +172,9 @@ declare class RpcPayload {
172
172
  private deliverTo;
173
173
  private static deliverRpcPromiseTo;
174
174
  deliverCall(func: Function, thisArg: object | undefined): Promise<RpcPayload>;
175
+ deliverStreamWrite(writer: {
176
+ write(chunk: unknown): Promise<void>;
177
+ }): Promise<RpcPayload>;
175
178
  deliverResolve(): Promise<unknown>;
176
179
  dispose(): void;
177
180
  private disposeImpl;
package/dist/index-bun.js CHANGED
@@ -41,7 +41,19 @@ function typeForRpc(value) {
41
41
  case Array.prototype: return "array";
42
42
  case Date.prototype: return "date";
43
43
  case Uint8Array.prototype:
44
- case BUFFER_PROTOTYPE: return "bytes";
44
+ case BUFFER_PROTOTYPE:
45
+ case ArrayBuffer.prototype:
46
+ case DataView.prototype:
47
+ case Int8Array.prototype:
48
+ case Uint8ClampedArray.prototype:
49
+ case Int16Array.prototype:
50
+ case Uint16Array.prototype:
51
+ case Int32Array.prototype:
52
+ case Uint32Array.prototype:
53
+ case BigInt64Array.prototype:
54
+ case BigUint64Array.prototype:
55
+ case Float32Array.prototype:
56
+ case Float64Array.prototype: return "bytes";
45
57
  case WritableStream.prototype: return "writable";
46
58
  case ReadableStream.prototype: return "readable";
47
59
  case Headers.prototype: return "headers";
@@ -511,6 +523,30 @@ var RpcPayload = class RpcPayload {
511
523
  this.dispose();
512
524
  }
513
525
  }
526
+ async deliverStreamWrite(writer) {
527
+ try {
528
+ let promises = [];
529
+ this.deliverTo(this, "value", promises);
530
+ if (promises.length > 0) await Promise.all(promises);
531
+ let chunk = this.value[0];
532
+ if ((this.hooks.length > 0 || this.promises.length > 0) && chunk instanceof Object) {
533
+ if (!(Symbol.dispose in chunk)) Object.defineProperty(chunk, Symbol.dispose, {
534
+ value: () => this.dispose(),
535
+ writable: true,
536
+ enumerable: false,
537
+ configurable: true
538
+ });
539
+ await writer.write(chunk);
540
+ return RpcPayload.fromAppReturn(void 0);
541
+ }
542
+ await writer.write(chunk);
543
+ this.dispose();
544
+ return RpcPayload.fromAppReturn(void 0);
545
+ } catch (err) {
546
+ this.dispose();
547
+ throw err;
548
+ }
549
+ }
514
550
  async deliverResolve() {
515
551
  try {
516
552
  let promises = [];
@@ -935,6 +971,71 @@ const DEFAULT_LIMITS = {
935
971
  maxDepth: 256,
936
972
  maxMessageSize: 32 * 1024 * 1024
937
973
  };
974
+ const NATIVE_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
975
+ const BYTE_CONTAINER_TYPE_NAMES = [
976
+ "ArrayBuffer",
977
+ "DataView",
978
+ "Int8Array",
979
+ "Uint8Array",
980
+ "Uint8ClampedArray",
981
+ "Int16Array",
982
+ "Uint16Array",
983
+ "Int32Array",
984
+ "Uint32Array",
985
+ "BigInt64Array",
986
+ "BigUint64Array",
987
+ "Float32Array",
988
+ "Float64Array"
989
+ ];
990
+ function isValidByteContainerName(value) {
991
+ return BYTE_CONTAINER_TYPE_NAMES.includes(value);
992
+ }
993
+ const TYPED_ARRAY_ELEMENT_SIZE = {
994
+ ArrayBuffer: void 0,
995
+ DataView: void 0,
996
+ Int8Array: void 0,
997
+ Uint8Array: void 0,
998
+ Uint8ClampedArray: void 0,
999
+ Int16Array: 2,
1000
+ Uint16Array: 2,
1001
+ Int32Array: 4,
1002
+ Uint32Array: 4,
1003
+ BigInt64Array: 8,
1004
+ BigUint64Array: 8,
1005
+ Float32Array: 4,
1006
+ Float64Array: 8
1007
+ };
1008
+ const BYTE_CONTAINER_PROTOTYPES = {
1009
+ ArrayBuffer: ArrayBuffer.prototype,
1010
+ DataView: DataView.prototype,
1011
+ Int8Array: Int8Array.prototype,
1012
+ Uint8ClampedArray: Uint8ClampedArray.prototype,
1013
+ Int16Array: Int16Array.prototype,
1014
+ Uint16Array: Uint16Array.prototype,
1015
+ Int32Array: Int32Array.prototype,
1016
+ Uint32Array: Uint32Array.prototype,
1017
+ BigInt64Array: BigInt64Array.prototype,
1018
+ BigUint64Array: BigUint64Array.prototype,
1019
+ Float32Array: Float32Array.prototype,
1020
+ Float64Array: Float64Array.prototype
1021
+ };
1022
+ const BYTE_CONTAINER_TYPE_BY_PROTOTYPE = /* @__PURE__ */ new Map();
1023
+ for (let type of Object.keys(BYTE_CONTAINER_PROTOTYPES)) BYTE_CONTAINER_TYPE_BY_PROTOTYPE.set(BYTE_CONTAINER_PROTOTYPES[type], type);
1024
+ function swapByteOrder(bytes, elementSize) {
1025
+ if (elementSize !== 2 && elementSize !== 4 && elementSize !== 8) throw new RangeError(`Unsupported element size: ${elementSize}`);
1026
+ let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
1027
+ for (let offset = 0; offset < bytes.byteLength; offset += elementSize) switch (elementSize) {
1028
+ case 2:
1029
+ view.setUint16(offset, view.getUint16(offset, false), true);
1030
+ break;
1031
+ case 4:
1032
+ view.setUint32(offset, view.getUint32(offset, false), true);
1033
+ break;
1034
+ case 8:
1035
+ view.setBigUint64(offset, view.getBigUint64(offset, false), true);
1036
+ break;
1037
+ }
1038
+ }
938
1039
  var NullExporter = class {
939
1040
  exportStub(stub) {
940
1041
  throw new Error("Cannot serialize RPC stubs without an RPC session.");
@@ -1026,17 +1127,38 @@ var Devaluator = class Devaluator {
1026
1127
  return ["date", Number.isNaN(time) ? null : time];
1027
1128
  }
1028
1129
  case "bytes": {
1029
- let bytes = value;
1030
- if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return ["bytes", bytes];
1031
- if (bytes.toBase64) return ["bytes", bytes.toBase64({ omitPadding: true })];
1130
+ let alternateTypeName = BYTE_CONTAINER_TYPE_BY_PROTOTYPE.get(Object.getPrototypeOf(value));
1131
+ let bytes;
1132
+ if (alternateTypeName === "ArrayBuffer") bytes = new Uint8Array(value);
1133
+ else if (alternateTypeName === void 0) bytes = value;
1134
+ else {
1135
+ let view = value;
1136
+ bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
1137
+ let elementSize = TYPED_ARRAY_ELEMENT_SIZE[alternateTypeName];
1138
+ if (!NATIVE_LITTLE_ENDIAN && elementSize) {
1139
+ bytes = bytes.slice();
1140
+ swapByteOrder(bytes, elementSize);
1141
+ }
1142
+ }
1143
+ if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return alternateTypeName === void 0 ? ["bytes", bytes] : [
1144
+ "bytes",
1145
+ bytes,
1146
+ alternateTypeName
1147
+ ];
1032
1148
  let b64;
1033
- if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
1149
+ if (bytes.toBase64) b64 = bytes.toBase64({ omitPadding: true });
1150
+ else if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
1034
1151
  else {
1035
1152
  let binary = "";
1036
1153
  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
1037
1154
  b64 = btoa(binary);
1038
1155
  }
1039
- return ["bytes", b64.replace(/=+$/, "")];
1156
+ b64 = b64.replace(/=+$/, "");
1157
+ return alternateTypeName === void 0 ? ["bytes", b64] : [
1158
+ "bytes",
1159
+ b64,
1160
+ alternateTypeName
1161
+ ];
1040
1162
  }
1041
1163
  case "headers": return ["headers", [...value]];
1042
1164
  case "request": {
@@ -1289,18 +1411,46 @@ var Evaluator = class Evaluator {
1289
1411
  if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
1290
1412
  if (typeof value[1] == "number") return new Date(value[1]);
1291
1413
  break;
1292
- case "bytes":
1293
- if (value[1] instanceof Uint8Array) return value[1];
1294
- if (typeof value[1] == "string") if (typeof Buffer !== "undefined") return Buffer.from(value[1], "base64");
1295
- else if (Uint8Array.fromBase64) return Uint8Array.fromBase64(value[1]);
1414
+ case "bytes": {
1415
+ let bytes;
1416
+ if (value[1] instanceof Uint8Array) bytes = value[1];
1417
+ else if (typeof value[1] == "string") if (typeof Buffer !== "undefined") bytes = Buffer.from(value[1], "base64");
1418
+ else if (Uint8Array.fromBase64) bytes = Uint8Array.fromBase64(value[1]);
1296
1419
  else {
1297
1420
  let bs = atob(value[1]);
1298
1421
  let len = bs.length;
1299
- let bytes = new Uint8Array(len);
1422
+ bytes = new Uint8Array(len);
1300
1423
  for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
1301
- return bytes;
1302
1424
  }
1303
- break;
1425
+ else break;
1426
+ if (value.length === 2) return bytes;
1427
+ if (typeof value[2] !== "string") throw new TypeError(`Unknown bytes type marker type: ${typeof value[2]}`);
1428
+ if (!isValidByteContainerName(value[2])) {
1429
+ let marker = value[2].slice(0, 64);
1430
+ throw new TypeError(`Unknown bytes type marker: ${marker}`);
1431
+ }
1432
+ let marker = value[2];
1433
+ let elementSize = TYPED_ARRAY_ELEMENT_SIZE[marker];
1434
+ if (elementSize !== void 0 && bytes.byteLength % elementSize !== 0) throw new TypeError(`Invalid byte length ${bytes.byteLength} for ${marker}; expected a multiple of ${elementSize}`);
1435
+ let buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
1436
+ if (!NATIVE_LITTLE_ENDIAN && elementSize !== void 0) swapByteOrder(new Uint8Array(buffer), elementSize);
1437
+ switch (marker) {
1438
+ case "ArrayBuffer": return buffer;
1439
+ case "DataView": return new DataView(buffer);
1440
+ case "Int8Array": return new Int8Array(buffer);
1441
+ case "Uint8Array": return new Uint8Array(buffer);
1442
+ case "Uint8ClampedArray": return new Uint8ClampedArray(buffer);
1443
+ case "Int16Array": return new Int16Array(buffer);
1444
+ case "Uint16Array": return new Uint16Array(buffer);
1445
+ case "Int32Array": return new Int32Array(buffer);
1446
+ case "Uint32Array": return new Uint32Array(buffer);
1447
+ case "BigInt64Array": return new BigInt64Array(buffer);
1448
+ case "BigUint64Array": return new BigUint64Array(buffer);
1449
+ case "Float32Array": return new Float32Array(buffer);
1450
+ case "Float64Array": return new Float64Array(buffer);
1451
+ default:
1452
+ }
1453
+ }
1304
1454
  case "error":
1305
1455
  if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
1306
1456
  let cls = ERROR_TYPES[value[1]] || Error;
@@ -2245,6 +2395,7 @@ var WebSocketTransport = class {
2245
2395
 
2246
2396
  //#endregion
2247
2397
  //#region src/batch.ts
2398
+ const yieldToMacrotask = typeof setImmediate === "function" ? () => new Promise((resolve) => setImmediate(resolve)) : () => new Promise((resolve) => setTimeout(resolve, 0));
2248
2399
  var BatchClientTransport = class {
2249
2400
  constructor(sendBatch) {
2250
2401
  this.#promise = this.#scheduleBatch(sendBatch);
@@ -2266,7 +2417,7 @@ var BatchClientTransport = class {
2266
2417
  this.#aborted = reason;
2267
2418
  }
2268
2419
  async #scheduleBatch(sendBatch) {
2269
- await new Promise((resolve) => setTimeout(resolve, 0));
2420
+ await yieldToMacrotask();
2270
2421
  if (this.#aborted !== void 0) throw this.#aborted;
2271
2422
  let batch = this.#batchToSend;
2272
2423
  this.#batchToSend = null;
@@ -2676,8 +2827,7 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
2676
2827
  throw new Error(`Unknown WritableStream method: ${method}`);
2677
2828
  }
2678
2829
  if (method === "close" || method === "abort") state.closed = true;
2679
- let func = state.writer[method];
2680
- return new PromiseStubHook(args.deliverCall(func, state.writer).then((payload) => new PayloadStubHook(payload)));
2830
+ return new PromiseStubHook((method === "write" ? args.deliverStreamWrite(state.writer) : args.deliverCall(state.writer[method], state.writer)).then((payload) => new PayloadStubHook(payload)));
2681
2831
  } catch (err) {
2682
2832
  return new ErrorStubHook(err);
2683
2833
  }