capnweb 0.9.1 → 0.11.0

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":
@@ -964,6 +1005,77 @@ var PromiseStubHook = class PromiseStubHook extends StubHook {
964
1005
 
965
1006
  //#endregion
966
1007
  //#region src/serialize.ts
1008
+ const DEFAULT_MAX_DEPTH = 256;
1009
+ const DEFAULT_LIMITS = {
1010
+ maxBigIntDigits: 16384,
1011
+ maxDepth: 256,
1012
+ maxMessageSize: 32 * 1024 * 1024
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
+ }
967
1079
  var NullExporter = class {
968
1080
  exportStub(stub) {
969
1081
  throw new Error("Cannot serialize RPC stubs without an RPC session.");
@@ -984,6 +1096,7 @@ async function streamToBlob(stream, type) {
984
1096
  return b.type === type ? b : b.slice(0, b.size, type);
985
1097
  }
986
1098
  const ERROR_TYPES = {
1099
+ __proto__: null,
987
1100
  Error,
988
1101
  EvalError,
989
1102
  RangeError,
@@ -1015,7 +1128,7 @@ var Devaluator = class Devaluator {
1015
1128
  }
1016
1129
  exports;
1017
1130
  devaluateImpl(value, parent, depth) {
1018
- if (depth >= 64) throw new Error("Serialization exceeded maximum allowed depth. (Does the message contain cycles?)");
1131
+ if (depth >= 256) throw new Error("Serialization exceeded maximum allowed depth. (Does the message contain cycles?)");
1019
1132
  switch (typeForRpc(value)) {
1020
1133
  case "unsupported": {
1021
1134
  let msg;
@@ -1054,18 +1167,40 @@ var Devaluator = class Devaluator {
1054
1167
  return ["date", Number.isNaN(time) ? null : time];
1055
1168
  }
1056
1169
  case "bytes": {
1057
- let bytes = value;
1058
- if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return ["bytes", bytes];
1059
- 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
+ ];
1060
1188
  let b64;
1061
- 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");
1062
1191
  else {
1063
1192
  let binary = "";
1064
1193
  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
1065
1194
  b64 = btoa(binary);
1066
1195
  }
1067
- return ["bytes", b64.replace(/=+$/, "")];
1196
+ b64 = b64.replace(/=+$/, "");
1197
+ return alternateTypeName === void 0 ? ["bytes", b64] : [
1198
+ "bytes",
1199
+ b64,
1200
+ alternateTypeName
1201
+ ];
1068
1202
  }
1203
+ case "url": return ["url", value.href];
1069
1204
  case "headers": return ["headers", [...value]];
1070
1205
  case "request": {
1071
1206
  let req = value;
@@ -1249,6 +1384,9 @@ var NullImporter = class {
1249
1384
  getPipeReadable(exportId) {
1250
1385
  throw new Error("Cannot retrieve pipe readable without an RPC session.");
1251
1386
  }
1387
+ getLimits() {
1388
+ return DEFAULT_LIMITS;
1389
+ }
1252
1390
  };
1253
1391
  const NULL_IMPORTER = new NullImporter();
1254
1392
  function fixBrokenRequestBody(request, body) {
@@ -1266,16 +1404,21 @@ function streamToBlobPromise(stream, type) {
1266
1404
  var Evaluator = class Evaluator {
1267
1405
  importer;
1268
1406
  encodingLevel;
1407
+ limits;
1269
1408
  constructor(importer, encodingLevel = "string") {
1270
1409
  this.importer = importer;
1271
1410
  this.encodingLevel = encodingLevel;
1411
+ this.limits = importer.getLimits();
1272
1412
  }
1273
1413
  hooks = [];
1274
1414
  promises = [];
1275
1415
  evaluate(value) {
1416
+ return this.evaluateWithDepth(value, 0);
1417
+ }
1418
+ evaluateWithDepth(value, depth) {
1276
1419
  let payload = RpcPayload.forEvaluate(this.hooks, this.promises);
1277
1420
  try {
1278
- payload.value = this.evaluateImpl(value, payload, "value");
1421
+ payload.value = this.evaluateImpl(value, payload, "value", depth);
1279
1422
  return payload;
1280
1423
  } catch (err) {
1281
1424
  payload.dispose();
@@ -1285,35 +1428,70 @@ var Evaluator = class Evaluator {
1285
1428
  evaluateCopy(value) {
1286
1429
  return this.evaluate(structuredClone(value));
1287
1430
  }
1288
- evaluateImpl(value, parent, property) {
1431
+ evaluateImpl(value, parent, property, depth) {
1432
+ let maxDepth = this.limits.maxDepth;
1433
+ if (depth >= maxDepth) throw new TypeError(`Deserialization exceeded maximum allowed message depth of ${maxDepth}.`);
1289
1434
  if (this.encodingLevel === "structuredClonable") {
1290
1435
  if (value instanceof Date || typeof value === "bigint") return value;
1291
1436
  }
1292
1437
  if (value instanceof Array) {
1293
1438
  if (value.length == 1 && value[0] instanceof Array) {
1294
1439
  let result = value[0];
1295
- for (let i = 0; i < result.length; i++) result[i] = this.evaluateImpl(result[i], result, i);
1440
+ for (let i = 0; i < result.length; i++) result[i] = this.evaluateImpl(result[i], result, i, depth + 1);
1296
1441
  return result;
1297
1442
  } else switch (value[0]) {
1298
1443
  case "bigint":
1299
- if (typeof value[1] == "string") return BigInt(value[1]);
1444
+ if (typeof value[1] == "string") {
1445
+ let digits = value[1];
1446
+ let maxBigIntDigits = this.limits.maxBigIntDigits;
1447
+ if (digits.length > maxBigIntDigits) throw new TypeError(`Deserialized bigint exceeds maximum length of ${maxBigIntDigits} digits.`);
1448
+ return BigInt(digits);
1449
+ }
1300
1450
  break;
1301
1451
  case "date":
1302
1452
  if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
1303
1453
  if (typeof value[1] == "number") return new Date(value[1]);
1304
1454
  break;
1305
- case "bytes":
1306
- if (value[1] instanceof Uint8Array) return value[1];
1307
- if (typeof value[1] == "string") if (typeof Buffer !== "undefined") return Buffer.from(value[1], "base64");
1308
- 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]);
1309
1460
  else {
1310
1461
  let bs = atob(value[1]);
1311
1462
  let len = bs.length;
1312
- let bytes = new Uint8Array(len);
1463
+ bytes = new Uint8Array(len);
1313
1464
  for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
1314
- return bytes;
1315
1465
  }
1316
- 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
+ }
1317
1495
  case "error":
1318
1496
  if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
1319
1497
  let cls = ERROR_TYPES[value[1]] || Error;
@@ -1326,7 +1504,11 @@ var Evaluator = class Evaluator {
1326
1504
  let propsObj = props;
1327
1505
  for (let key of Object.keys(propsObj)) {
1328
1506
  if (key === "name" || key === "message" || key === "stack") continue;
1329
- anyResult[key] = this.evaluateImpl(propsObj[key], result, key);
1507
+ if (key in Object.prototype || key === "toJSON") {
1508
+ this.evaluateImpl(propsObj[key], result, key, depth + 1);
1509
+ continue;
1510
+ }
1511
+ anyResult[key] = this.evaluateImpl(propsObj[key], result, key, depth + 1);
1330
1512
  }
1331
1513
  }
1332
1514
  return result;
@@ -1338,6 +1520,9 @@ var Evaluator = class Evaluator {
1338
1520
  case "inf": return Infinity;
1339
1521
  case "-inf": return -Infinity;
1340
1522
  case "nan": return NaN;
1523
+ case "url":
1524
+ if (value.length === 2 && typeof value[1] === "string") return new URL(value[1]);
1525
+ break;
1341
1526
  case "headers":
1342
1527
  if (value.length === 2 && value[1] instanceof Array) return new Headers(value[1]);
1343
1528
  break;
@@ -1347,11 +1532,11 @@ var Evaluator = class Evaluator {
1347
1532
  let init = value[2];
1348
1533
  if (typeof init !== "object" || init === null) break;
1349
1534
  if (init.body) {
1350
- init.body = this.evaluateImpl(init.body, init, "body");
1535
+ init.body = this.evaluateImpl(init.body, init, "body", depth + 1);
1351
1536
  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.");
1352
1537
  }
1353
1538
  if (init.signal) {
1354
- init.signal = this.evaluateImpl(init.signal, init, "signal");
1539
+ init.signal = this.evaluateImpl(init.signal, init, "signal", depth + 1);
1355
1540
  if (!(init.signal instanceof AbortSignal)) throw new TypeError("Request siganl must be of type AbortSignal.");
1356
1541
  }
1357
1542
  if (init.headers && !(init.headers instanceof Array)) throw new TypeError("Request headers must be serialized as an array of pairs.");
@@ -1368,7 +1553,7 @@ var Evaluator = class Evaluator {
1368
1553
  }
1369
1554
  case "response": {
1370
1555
  if (value.length !== 3) break;
1371
- let body = this.evaluateImpl(value[1], parent, property);
1556
+ let body = this.evaluateImpl(value[1], parent, property, depth + 1);
1372
1557
  if (body === null || typeof body === "string" || body instanceof Uint8Array || body instanceof ReadableStream) {} else throw new TypeError("Response body must be of type ReadableStream.");
1373
1558
  let init = value[2];
1374
1559
  if (typeof init !== "object" || init === null) break;
@@ -1379,7 +1564,7 @@ var Evaluator = class Evaluator {
1379
1564
  case "blob": {
1380
1565
  if (value.length !== 3 || typeof value[1] !== "string") break;
1381
1566
  let contentType = value[1];
1382
- let content = this.evaluateImpl(value[2], parent, property);
1567
+ let content = this.evaluateImpl(value[2], parent, property, depth + 1);
1383
1568
  if (!(content instanceof ReadableStream)) throw new TypeError("Blob content must be serialized as a ReadableStream.");
1384
1569
  let promise = streamToBlobPromise(content, contentType);
1385
1570
  this.promises.push({
@@ -1420,7 +1605,7 @@ var Evaluator = class Evaluator {
1420
1605
  if (value.length == 3) return addStub(hook.get(path));
1421
1606
  let args = value[3];
1422
1607
  if (!(args instanceof Array)) break;
1423
- args = new Evaluator(this.importer).evaluate([args]);
1608
+ args = new Evaluator(this.importer).evaluateWithDepth([args], depth);
1424
1609
  return addStub(hook.call(path, args));
1425
1610
  }
1426
1611
  case "remap": {
@@ -1486,9 +1671,9 @@ var Evaluator = class Evaluator {
1486
1671
  } else if (value instanceof Object) {
1487
1672
  let result = value;
1488
1673
  for (let key in result) if (key in Object.prototype || key === "toJSON") {
1489
- this.evaluateImpl(result[key], result, key);
1674
+ this.evaluateImpl(result[key], result, key, depth + 1);
1490
1675
  delete result[key];
1491
- } else result[key] = this.evaluateImpl(result[key], result, key);
1676
+ } else result[key] = this.evaluateImpl(result[key], result, key, depth + 1);
1492
1677
  return result;
1493
1678
  } else return value;
1494
1679
  }
@@ -1711,6 +1896,7 @@ var RpcSessionImpl = class {
1711
1896
  pullCount = 0;
1712
1897
  onBrokenCallbacks = [];
1713
1898
  encodingLevel;
1899
+ limits;
1714
1900
  constructor(transport, mainHook, options) {
1715
1901
  this.transport = transport;
1716
1902
  this.options = options;
@@ -1723,6 +1909,10 @@ var RpcSessionImpl = class {
1723
1909
  }
1724
1910
  }
1725
1911
  this.encodingLevel = level;
1912
+ this.limits = {
1913
+ ...DEFAULT_LIMITS,
1914
+ ...options.limits
1915
+ };
1726
1916
  this.exports.push({
1727
1917
  hook: mainHook,
1728
1918
  refcount: 1
@@ -1865,6 +2055,9 @@ var RpcSessionImpl = class {
1865
2055
  entry.pipeReadable = void 0;
1866
2056
  return readable;
1867
2057
  }
2058
+ getLimits() {
2059
+ return this.limits;
2060
+ }
1868
2061
  createPipe(readable, readableHook) {
1869
2062
  if (this.abortReason) throw this.abortReason;
1870
2063
  this.send(["pipe"]);
@@ -2024,6 +2217,7 @@ var RpcSessionImpl = class {
2024
2217
  } finally {
2025
2218
  if (this.cancelReadLoop === readCanceled.reject) this.cancelReadLoop = void 0;
2026
2219
  }
2220
+ if (this.encodingLevel === "string" && raw.length > this.limits.maxMessageSize) throw new TypeError(`Incoming message exceeds maximum size of ${this.limits.maxMessageSize} UTF-16 code units.`);
2027
2221
  if (this.abortReason) break;
2028
2222
  let msg = this.encodingLevel === "string" ? JSON.parse(raw) : raw;
2029
2223
  if (msg instanceof Array) switch (msg[0]) {
@@ -2098,7 +2292,7 @@ var RpcSessionImpl = class {
2098
2292
  case "abort": {
2099
2293
  let payload = new Evaluator(this, this.encodingLevel).evaluate(msg[1]);
2100
2294
  payload.dispose();
2101
- this.abort(payload, false);
2295
+ this.abort(payload.value, false);
2102
2296
  break;
2103
2297
  }
2104
2298
  }
@@ -2149,6 +2343,8 @@ var RpcSession$1 = class {
2149
2343
 
2150
2344
  //#endregion
2151
2345
  //#region src/websocket.ts
2346
+ /** Close-frame reason max UTF-8 bytes: 125 payload − 2-byte status (RFC 6455 §5.5). */
2347
+ const MAX_CLOSE_REASON_BYTES = 123;
2152
2348
  function newWebSocketRpcSession$1(webSocket, localMain, options) {
2153
2349
  if (typeof webSocket === "string") webSocket = new WebSocket(webSocket);
2154
2350
  return new RpcSession$1(new WebSocketTransport(webSocket), localMain, options).getRemoteMain();
@@ -2224,6 +2420,8 @@ var WebSocketTransport = class {
2224
2420
  let message;
2225
2421
  if (reason instanceof Error) message = reason.message;
2226
2422
  else message = `${reason}`;
2423
+ let reasonBytes = new TextEncoder().encode(message);
2424
+ if (reasonBytes.length > 123) message = new TextDecoder().decode(reasonBytes.subarray(0, 123), { stream: true });
2227
2425
  this.#webSocket.close(3e3, message);
2228
2426
  if (!this.#error) this.#error = reason;
2229
2427
  }
@@ -2241,6 +2439,7 @@ var WebSocketTransport = class {
2241
2439
 
2242
2440
  //#endregion
2243
2441
  //#region src/batch.ts
2442
+ const yieldToMacrotask = typeof setImmediate === "function" ? () => new Promise((resolve) => setImmediate(resolve)) : () => new Promise((resolve) => setTimeout(resolve, 0));
2244
2443
  var BatchClientTransport = class {
2245
2444
  constructor(sendBatch) {
2246
2445
  this.#promise = this.#scheduleBatch(sendBatch);
@@ -2262,7 +2461,7 @@ var BatchClientTransport = class {
2262
2461
  this.#aborted = reason;
2263
2462
  }
2264
2463
  async #scheduleBatch(sendBatch) {
2265
- await new Promise((resolve) => setTimeout(resolve, 0));
2464
+ await yieldToMacrotask();
2266
2465
  if (this.#aborted !== void 0) throw this.#aborted;
2267
2466
  let batch = this.#batchToSend;
2268
2467
  this.#batchToSend = null;
@@ -2609,6 +2808,9 @@ var MapApplicator = class {
2609
2808
  getPipeReadable(exportId) {
2610
2809
  throw new Error("A mapper function cannot use pipe readables.");
2611
2810
  }
2811
+ getLimits() {
2812
+ return DEFAULT_LIMITS;
2813
+ }
2612
2814
  };
2613
2815
  function applyMapToElement(input, parent, owner, captures, instructions) {
2614
2816
  let mapper = new MapApplicator(captures, new PayloadStubHook(RpcPayload.deepCopyFrom(input, parent, owner)));
@@ -2669,8 +2871,7 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
2669
2871
  throw new Error(`Unknown WritableStream method: ${method}`);
2670
2872
  }
2671
2873
  if (method === "close" || method === "abort") state.closed = true;
2672
- let func = state.writer[method];
2673
- 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)));
2674
2875
  } catch (err) {
2675
2876
  return new ErrorStubHook(err);
2676
2877
  }
@@ -2947,16 +3148,18 @@ let newMessagePortRpcSession = newMessagePortRpcSession$1;
2947
3148
  * credentials as parameters and returns the authorized API), then cross-origin requests should
2948
3149
  * be safe.
2949
3150
  */
2950
- async function newWorkersRpcResponse(request, localMain) {
3151
+ async function newWorkersRpcResponse(request, localMain, options) {
2951
3152
  if (request.method === "POST") {
2952
- let response = await newHttpBatchRpcResponse(request, localMain);
3153
+ let response = await newHttpBatchRpcResponse(request, localMain, options);
2953
3154
  response.headers.set("Access-Control-Allow-Origin", "*");
2954
3155
  return response;
2955
- } else if (request.headers.get("Upgrade")?.toLowerCase() === "websocket") return newWorkersWebSocketRpcResponse(request, localMain);
3156
+ } else if (request.headers.get("Upgrade")?.toLowerCase() === "websocket") return newWorkersWebSocketRpcResponse(request, localMain, options);
2956
3157
  else return new Response("This endpoint only accepts POST or WebSocket requests.", { status: 400 });
2957
3158
  }
2958
3159
 
2959
3160
  //#endregion
3161
+ exports.DEFAULT_LIMITS = DEFAULT_LIMITS;
3162
+ exports.DEFAULT_MAX_DEPTH = DEFAULT_MAX_DEPTH;
2960
3163
  exports.RpcPromise = RpcPromise;
2961
3164
  exports.RpcSession = RpcSession;
2962
3165
  exports.RpcStub = RpcStub;