capnweb 0.0.0-5bf633f → 0.0.0-5da3786

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.
package/dist/index-bun.js CHANGED
@@ -41,9 +41,22 @@ 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";
59
+ case URL.prototype: return "url";
47
60
  case Headers.prototype: return "headers";
48
61
  case Request.prototype: return "request";
49
62
  case Response.prototype: return "response";
@@ -378,6 +391,7 @@ var RpcPayload = class RpcPayload {
378
391
  case "date":
379
392
  case "bytes":
380
393
  case "blob":
394
+ case "url":
381
395
  case "error":
382
396
  case "undefined": return value;
383
397
  case "array": {
@@ -511,6 +525,30 @@ var RpcPayload = class RpcPayload {
511
525
  this.dispose();
512
526
  }
513
527
  }
528
+ async deliverStreamWrite(writer) {
529
+ try {
530
+ let promises = [];
531
+ this.deliverTo(this, "value", promises);
532
+ if (promises.length > 0) await Promise.all(promises);
533
+ let chunk = this.value[0];
534
+ if ((this.hooks.length > 0 || this.promises.length > 0) && chunk instanceof Object) {
535
+ if (!(Symbol.dispose in chunk)) Object.defineProperty(chunk, Symbol.dispose, {
536
+ value: () => this.dispose(),
537
+ writable: true,
538
+ enumerable: false,
539
+ configurable: true
540
+ });
541
+ await writer.write(chunk);
542
+ return RpcPayload.fromAppReturn(void 0);
543
+ }
544
+ await writer.write(chunk);
545
+ this.dispose();
546
+ return RpcPayload.fromAppReturn(void 0);
547
+ } catch (err) {
548
+ this.dispose();
549
+ throw err;
550
+ }
551
+ }
514
552
  async deliverResolve() {
515
553
  try {
516
554
  let promises = [];
@@ -551,6 +589,7 @@ var RpcPayload = class RpcPayload {
551
589
  case "bytes":
552
590
  case "blob":
553
591
  case "date":
592
+ case "url":
554
593
  case "error":
555
594
  case "undefined": return;
556
595
  case "array": {
@@ -633,6 +672,7 @@ var RpcPayload = class RpcPayload {
633
672
  case "rpc-target":
634
673
  case "writable":
635
674
  case "readable":
675
+ case "url":
636
676
  case "headers":
637
677
  case "request":
638
678
  case "response": return;
@@ -702,6 +742,7 @@ function followPath(value, parent, path, owner) {
702
742
  case "blob":
703
743
  case "date":
704
744
  case "error":
745
+ case "url":
705
746
  case "headers":
706
747
  case "request":
707
748
  case "response":
@@ -929,6 +970,77 @@ var PromiseStubHook = class PromiseStubHook extends StubHook {
929
970
 
930
971
  //#endregion
931
972
  //#region src/serialize.ts
973
+ const DEFAULT_MAX_DEPTH = 256;
974
+ const DEFAULT_LIMITS = {
975
+ maxBigIntDigits: 16384,
976
+ maxDepth: 256,
977
+ maxMessageSize: 32 * 1024 * 1024
978
+ };
979
+ const NATIVE_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
980
+ const BYTE_CONTAINER_TYPE_NAMES = [
981
+ "ArrayBuffer",
982
+ "DataView",
983
+ "Int8Array",
984
+ "Uint8Array",
985
+ "Uint8ClampedArray",
986
+ "Int16Array",
987
+ "Uint16Array",
988
+ "Int32Array",
989
+ "Uint32Array",
990
+ "BigInt64Array",
991
+ "BigUint64Array",
992
+ "Float32Array",
993
+ "Float64Array"
994
+ ];
995
+ function isValidByteContainerName(value) {
996
+ return BYTE_CONTAINER_TYPE_NAMES.includes(value);
997
+ }
998
+ const TYPED_ARRAY_ELEMENT_SIZE = {
999
+ ArrayBuffer: void 0,
1000
+ DataView: void 0,
1001
+ Int8Array: void 0,
1002
+ Uint8Array: void 0,
1003
+ Uint8ClampedArray: void 0,
1004
+ Int16Array: 2,
1005
+ Uint16Array: 2,
1006
+ Int32Array: 4,
1007
+ Uint32Array: 4,
1008
+ BigInt64Array: 8,
1009
+ BigUint64Array: 8,
1010
+ Float32Array: 4,
1011
+ Float64Array: 8
1012
+ };
1013
+ const BYTE_CONTAINER_PROTOTYPES = {
1014
+ ArrayBuffer: ArrayBuffer.prototype,
1015
+ DataView: DataView.prototype,
1016
+ Int8Array: Int8Array.prototype,
1017
+ Uint8ClampedArray: Uint8ClampedArray.prototype,
1018
+ Int16Array: Int16Array.prototype,
1019
+ Uint16Array: Uint16Array.prototype,
1020
+ Int32Array: Int32Array.prototype,
1021
+ Uint32Array: Uint32Array.prototype,
1022
+ BigInt64Array: BigInt64Array.prototype,
1023
+ BigUint64Array: BigUint64Array.prototype,
1024
+ Float32Array: Float32Array.prototype,
1025
+ Float64Array: Float64Array.prototype
1026
+ };
1027
+ const BYTE_CONTAINER_TYPE_BY_PROTOTYPE = /* @__PURE__ */ new Map();
1028
+ for (let type of Object.keys(BYTE_CONTAINER_PROTOTYPES)) BYTE_CONTAINER_TYPE_BY_PROTOTYPE.set(BYTE_CONTAINER_PROTOTYPES[type], type);
1029
+ function swapByteOrder(bytes, elementSize) {
1030
+ if (elementSize !== 2 && elementSize !== 4 && elementSize !== 8) throw new RangeError(`Unsupported element size: ${elementSize}`);
1031
+ let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
1032
+ for (let offset = 0; offset < bytes.byteLength; offset += elementSize) switch (elementSize) {
1033
+ case 2:
1034
+ view.setUint16(offset, view.getUint16(offset, false), true);
1035
+ break;
1036
+ case 4:
1037
+ view.setUint32(offset, view.getUint32(offset, false), true);
1038
+ break;
1039
+ case 8:
1040
+ view.setBigUint64(offset, view.getBigUint64(offset, false), true);
1041
+ break;
1042
+ }
1043
+ }
932
1044
  var NullExporter = class {
933
1045
  exportStub(stub) {
934
1046
  throw new Error("Cannot serialize RPC stubs without an RPC session.");
@@ -949,6 +1061,7 @@ async function streamToBlob(stream, type) {
949
1061
  return b.type === type ? b : b.slice(0, b.size, type);
950
1062
  }
951
1063
  const ERROR_TYPES = {
1064
+ __proto__: null,
952
1065
  Error,
953
1066
  EvalError,
954
1067
  RangeError,
@@ -980,7 +1093,7 @@ var Devaluator = class Devaluator {
980
1093
  }
981
1094
  exports;
982
1095
  devaluateImpl(value, parent, depth) {
983
- if (depth >= 64) throw new Error("Serialization exceeded maximum allowed depth. (Does the message contain cycles?)");
1096
+ if (depth >= 256) throw new Error("Serialization exceeded maximum allowed depth. (Does the message contain cycles?)");
984
1097
  switch (typeForRpc(value)) {
985
1098
  case "unsupported": {
986
1099
  let msg;
@@ -1019,18 +1132,40 @@ var Devaluator = class Devaluator {
1019
1132
  return ["date", Number.isNaN(time) ? null : time];
1020
1133
  }
1021
1134
  case "bytes": {
1022
- let bytes = value;
1023
- if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return ["bytes", bytes];
1024
- if (bytes.toBase64) return ["bytes", bytes.toBase64({ omitPadding: true })];
1135
+ let alternateTypeName = BYTE_CONTAINER_TYPE_BY_PROTOTYPE.get(Object.getPrototypeOf(value));
1136
+ let bytes;
1137
+ if (alternateTypeName === "ArrayBuffer") bytes = new Uint8Array(value);
1138
+ else if (alternateTypeName === void 0) bytes = value;
1139
+ else {
1140
+ let view = value;
1141
+ bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
1142
+ let elementSize = TYPED_ARRAY_ELEMENT_SIZE[alternateTypeName];
1143
+ if (!NATIVE_LITTLE_ENDIAN && elementSize) {
1144
+ bytes = bytes.slice();
1145
+ swapByteOrder(bytes, elementSize);
1146
+ }
1147
+ }
1148
+ if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return alternateTypeName === void 0 ? ["bytes", bytes] : [
1149
+ "bytes",
1150
+ bytes,
1151
+ alternateTypeName
1152
+ ];
1025
1153
  let b64;
1026
- if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
1154
+ if (bytes.toBase64) b64 = bytes.toBase64({ omitPadding: true });
1155
+ else if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
1027
1156
  else {
1028
1157
  let binary = "";
1029
1158
  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
1030
1159
  b64 = btoa(binary);
1031
1160
  }
1032
- return ["bytes", b64.replace(/=+$/, "")];
1161
+ b64 = b64.replace(/=+$/, "");
1162
+ return alternateTypeName === void 0 ? ["bytes", b64] : [
1163
+ "bytes",
1164
+ b64,
1165
+ alternateTypeName
1166
+ ];
1033
1167
  }
1168
+ case "url": return ["url", value.href];
1034
1169
  case "headers": return ["headers", [...value]];
1035
1170
  case "request": {
1036
1171
  let req = value;
@@ -1214,6 +1349,9 @@ var NullImporter = class {
1214
1349
  getPipeReadable(exportId) {
1215
1350
  throw new Error("Cannot retrieve pipe readable without an RPC session.");
1216
1351
  }
1352
+ getLimits() {
1353
+ return DEFAULT_LIMITS;
1354
+ }
1217
1355
  };
1218
1356
  const NULL_IMPORTER = new NullImporter();
1219
1357
  function fixBrokenRequestBody(request, body) {
@@ -1231,16 +1369,21 @@ function streamToBlobPromise(stream, type) {
1231
1369
  var Evaluator = class Evaluator {
1232
1370
  importer;
1233
1371
  encodingLevel;
1372
+ limits;
1234
1373
  constructor(importer, encodingLevel = "string") {
1235
1374
  this.importer = importer;
1236
1375
  this.encodingLevel = encodingLevel;
1376
+ this.limits = importer.getLimits();
1237
1377
  }
1238
1378
  hooks = [];
1239
1379
  promises = [];
1240
1380
  evaluate(value) {
1381
+ return this.evaluateWithDepth(value, 0);
1382
+ }
1383
+ evaluateWithDepth(value, depth) {
1241
1384
  let payload = RpcPayload.forEvaluate(this.hooks, this.promises);
1242
1385
  try {
1243
- payload.value = this.evaluateImpl(value, payload, "value");
1386
+ payload.value = this.evaluateImpl(value, payload, "value", depth);
1244
1387
  return payload;
1245
1388
  } catch (err) {
1246
1389
  payload.dispose();
@@ -1250,35 +1393,70 @@ var Evaluator = class Evaluator {
1250
1393
  evaluateCopy(value) {
1251
1394
  return this.evaluate(structuredClone(value));
1252
1395
  }
1253
- evaluateImpl(value, parent, property) {
1396
+ evaluateImpl(value, parent, property, depth) {
1397
+ let maxDepth = this.limits.maxDepth;
1398
+ if (depth >= maxDepth) throw new TypeError(`Deserialization exceeded maximum allowed message depth of ${maxDepth}.`);
1254
1399
  if (this.encodingLevel === "structuredClonable") {
1255
1400
  if (value instanceof Date || typeof value === "bigint") return value;
1256
1401
  }
1257
1402
  if (value instanceof Array) {
1258
1403
  if (value.length == 1 && value[0] instanceof Array) {
1259
1404
  let result = value[0];
1260
- for (let i = 0; i < result.length; i++) result[i] = this.evaluateImpl(result[i], result, i);
1405
+ for (let i = 0; i < result.length; i++) result[i] = this.evaluateImpl(result[i], result, i, depth + 1);
1261
1406
  return result;
1262
1407
  } else switch (value[0]) {
1263
1408
  case "bigint":
1264
- if (typeof value[1] == "string") return BigInt(value[1]);
1409
+ if (typeof value[1] == "string") {
1410
+ let digits = value[1];
1411
+ let maxBigIntDigits = this.limits.maxBigIntDigits;
1412
+ if (digits.length > maxBigIntDigits) throw new TypeError(`Deserialized bigint exceeds maximum length of ${maxBigIntDigits} digits.`);
1413
+ return BigInt(digits);
1414
+ }
1265
1415
  break;
1266
1416
  case "date":
1267
1417
  if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
1268
1418
  if (typeof value[1] == "number") return new Date(value[1]);
1269
1419
  break;
1270
- case "bytes":
1271
- if (value[1] instanceof Uint8Array) return value[1];
1272
- if (typeof value[1] == "string") if (typeof Buffer !== "undefined") return Buffer.from(value[1], "base64");
1273
- else if (Uint8Array.fromBase64) return Uint8Array.fromBase64(value[1]);
1420
+ case "bytes": {
1421
+ let bytes;
1422
+ if (value[1] instanceof Uint8Array) bytes = value[1];
1423
+ else if (typeof value[1] == "string") if (typeof Buffer !== "undefined") bytes = Buffer.from(value[1], "base64");
1424
+ else if (Uint8Array.fromBase64) bytes = Uint8Array.fromBase64(value[1]);
1274
1425
  else {
1275
1426
  let bs = atob(value[1]);
1276
1427
  let len = bs.length;
1277
- let bytes = new Uint8Array(len);
1428
+ bytes = new Uint8Array(len);
1278
1429
  for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
1279
- return bytes;
1280
1430
  }
1281
- break;
1431
+ else break;
1432
+ if (value.length === 2) return bytes;
1433
+ if (typeof value[2] !== "string") throw new TypeError(`Unknown bytes type marker type: ${typeof value[2]}`);
1434
+ if (!isValidByteContainerName(value[2])) {
1435
+ let marker = value[2].slice(0, 64);
1436
+ throw new TypeError(`Unknown bytes type marker: ${marker}`);
1437
+ }
1438
+ let marker = value[2];
1439
+ let elementSize = TYPED_ARRAY_ELEMENT_SIZE[marker];
1440
+ if (elementSize !== void 0 && bytes.byteLength % elementSize !== 0) throw new TypeError(`Invalid byte length ${bytes.byteLength} for ${marker}; expected a multiple of ${elementSize}`);
1441
+ let buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
1442
+ if (!NATIVE_LITTLE_ENDIAN && elementSize !== void 0) swapByteOrder(new Uint8Array(buffer), elementSize);
1443
+ switch (marker) {
1444
+ case "ArrayBuffer": return buffer;
1445
+ case "DataView": return new DataView(buffer);
1446
+ case "Int8Array": return new Int8Array(buffer);
1447
+ case "Uint8Array": return new Uint8Array(buffer);
1448
+ case "Uint8ClampedArray": return new Uint8ClampedArray(buffer);
1449
+ case "Int16Array": return new Int16Array(buffer);
1450
+ case "Uint16Array": return new Uint16Array(buffer);
1451
+ case "Int32Array": return new Int32Array(buffer);
1452
+ case "Uint32Array": return new Uint32Array(buffer);
1453
+ case "BigInt64Array": return new BigInt64Array(buffer);
1454
+ case "BigUint64Array": return new BigUint64Array(buffer);
1455
+ case "Float32Array": return new Float32Array(buffer);
1456
+ case "Float64Array": return new Float64Array(buffer);
1457
+ default:
1458
+ }
1459
+ }
1282
1460
  case "error":
1283
1461
  if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
1284
1462
  let cls = ERROR_TYPES[value[1]] || Error;
@@ -1291,7 +1469,11 @@ var Evaluator = class Evaluator {
1291
1469
  let propsObj = props;
1292
1470
  for (let key of Object.keys(propsObj)) {
1293
1471
  if (key === "name" || key === "message" || key === "stack") continue;
1294
- anyResult[key] = this.evaluateImpl(propsObj[key], result, key);
1472
+ if (key in Object.prototype || key === "toJSON") {
1473
+ this.evaluateImpl(propsObj[key], result, key, depth + 1);
1474
+ continue;
1475
+ }
1476
+ anyResult[key] = this.evaluateImpl(propsObj[key], result, key, depth + 1);
1295
1477
  }
1296
1478
  }
1297
1479
  return result;
@@ -1303,6 +1485,9 @@ var Evaluator = class Evaluator {
1303
1485
  case "inf": return Infinity;
1304
1486
  case "-inf": return -Infinity;
1305
1487
  case "nan": return NaN;
1488
+ case "url":
1489
+ if (value.length === 2 && typeof value[1] === "string") return new URL(value[1]);
1490
+ break;
1306
1491
  case "headers":
1307
1492
  if (value.length === 2 && value[1] instanceof Array) return new Headers(value[1]);
1308
1493
  break;
@@ -1312,11 +1497,11 @@ var Evaluator = class Evaluator {
1312
1497
  let init = value[2];
1313
1498
  if (typeof init !== "object" || init === null) break;
1314
1499
  if (init.body) {
1315
- init.body = this.evaluateImpl(init.body, init, "body");
1500
+ init.body = this.evaluateImpl(init.body, init, "body", depth + 1);
1316
1501
  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.");
1317
1502
  }
1318
1503
  if (init.signal) {
1319
- init.signal = this.evaluateImpl(init.signal, init, "signal");
1504
+ init.signal = this.evaluateImpl(init.signal, init, "signal", depth + 1);
1320
1505
  if (!(init.signal instanceof AbortSignal)) throw new TypeError("Request siganl must be of type AbortSignal.");
1321
1506
  }
1322
1507
  if (init.headers && !(init.headers instanceof Array)) throw new TypeError("Request headers must be serialized as an array of pairs.");
@@ -1333,7 +1518,7 @@ var Evaluator = class Evaluator {
1333
1518
  }
1334
1519
  case "response": {
1335
1520
  if (value.length !== 3) break;
1336
- let body = this.evaluateImpl(value[1], parent, property);
1521
+ let body = this.evaluateImpl(value[1], parent, property, depth + 1);
1337
1522
  if (body === null || typeof body === "string" || body instanceof Uint8Array || body instanceof ReadableStream) {} else throw new TypeError("Response body must be of type ReadableStream.");
1338
1523
  let init = value[2];
1339
1524
  if (typeof init !== "object" || init === null) break;
@@ -1344,7 +1529,7 @@ var Evaluator = class Evaluator {
1344
1529
  case "blob": {
1345
1530
  if (value.length !== 3 || typeof value[1] !== "string") break;
1346
1531
  let contentType = value[1];
1347
- let content = this.evaluateImpl(value[2], parent, property);
1532
+ let content = this.evaluateImpl(value[2], parent, property, depth + 1);
1348
1533
  if (!(content instanceof ReadableStream)) throw new TypeError("Blob content must be serialized as a ReadableStream.");
1349
1534
  let promise = streamToBlobPromise(content, contentType);
1350
1535
  this.promises.push({
@@ -1385,7 +1570,7 @@ var Evaluator = class Evaluator {
1385
1570
  if (value.length == 3) return addStub(hook.get(path));
1386
1571
  let args = value[3];
1387
1572
  if (!(args instanceof Array)) break;
1388
- args = new Evaluator(this.importer).evaluate([args]);
1573
+ args = new Evaluator(this.importer).evaluateWithDepth([args], depth);
1389
1574
  return addStub(hook.call(path, args));
1390
1575
  }
1391
1576
  case "remap": {
@@ -1451,9 +1636,9 @@ var Evaluator = class Evaluator {
1451
1636
  } else if (value instanceof Object) {
1452
1637
  let result = value;
1453
1638
  for (let key in result) if (key in Object.prototype || key === "toJSON") {
1454
- this.evaluateImpl(result[key], result, key);
1639
+ this.evaluateImpl(result[key], result, key, depth + 1);
1455
1640
  delete result[key];
1456
- } else result[key] = this.evaluateImpl(result[key], result, key);
1641
+ } else result[key] = this.evaluateImpl(result[key], result, key, depth + 1);
1457
1642
  return result;
1458
1643
  } else return value;
1459
1644
  }
@@ -1676,6 +1861,7 @@ var RpcSessionImpl = class {
1676
1861
  pullCount = 0;
1677
1862
  onBrokenCallbacks = [];
1678
1863
  encodingLevel;
1864
+ limits;
1679
1865
  constructor(transport, mainHook, options) {
1680
1866
  this.transport = transport;
1681
1867
  this.options = options;
@@ -1688,6 +1874,10 @@ var RpcSessionImpl = class {
1688
1874
  }
1689
1875
  }
1690
1876
  this.encodingLevel = level;
1877
+ this.limits = {
1878
+ ...DEFAULT_LIMITS,
1879
+ ...options.limits
1880
+ };
1691
1881
  this.exports.push({
1692
1882
  hook: mainHook,
1693
1883
  refcount: 1
@@ -1830,6 +2020,9 @@ var RpcSessionImpl = class {
1830
2020
  entry.pipeReadable = void 0;
1831
2021
  return readable;
1832
2022
  }
2023
+ getLimits() {
2024
+ return this.limits;
2025
+ }
1833
2026
  createPipe(readable, readableHook) {
1834
2027
  if (this.abortReason) throw this.abortReason;
1835
2028
  this.send(["pipe"]);
@@ -1989,6 +2182,7 @@ var RpcSessionImpl = class {
1989
2182
  } finally {
1990
2183
  if (this.cancelReadLoop === readCanceled.reject) this.cancelReadLoop = void 0;
1991
2184
  }
2185
+ 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.`);
1992
2186
  if (this.abortReason) break;
1993
2187
  let msg = this.encodingLevel === "string" ? JSON.parse(raw) : raw;
1994
2188
  if (msg instanceof Array) switch (msg[0]) {
@@ -2063,7 +2257,7 @@ var RpcSessionImpl = class {
2063
2257
  case "abort": {
2064
2258
  let payload = new Evaluator(this, this.encodingLevel).evaluate(msg[1]);
2065
2259
  payload.dispose();
2066
- this.abort(payload, false);
2260
+ this.abort(payload.value, false);
2067
2261
  break;
2068
2262
  }
2069
2263
  }
@@ -2114,6 +2308,8 @@ var RpcSession$1 = class {
2114
2308
 
2115
2309
  //#endregion
2116
2310
  //#region src/websocket.ts
2311
+ /** Close-frame reason max UTF-8 bytes: 125 payload − 2-byte status (RFC 6455 §5.5). */
2312
+ const MAX_CLOSE_REASON_BYTES = 123;
2117
2313
  function newWebSocketRpcSession$1(webSocket, localMain, options) {
2118
2314
  if (typeof webSocket === "string") webSocket = new WebSocket(webSocket);
2119
2315
  return new RpcSession$1(new WebSocketTransport(webSocket), localMain, options).getRemoteMain();
@@ -2189,6 +2385,8 @@ var WebSocketTransport = class {
2189
2385
  let message;
2190
2386
  if (reason instanceof Error) message = reason.message;
2191
2387
  else message = `${reason}`;
2388
+ let reasonBytes = new TextEncoder().encode(message);
2389
+ if (reasonBytes.length > 123) message = new TextDecoder().decode(reasonBytes.subarray(0, 123), { stream: true });
2192
2390
  this.#webSocket.close(3e3, message);
2193
2391
  if (!this.#error) this.#error = reason;
2194
2392
  }
@@ -2206,6 +2404,7 @@ var WebSocketTransport = class {
2206
2404
 
2207
2405
  //#endregion
2208
2406
  //#region src/batch.ts
2407
+ const yieldToMacrotask = typeof setImmediate === "function" ? () => new Promise((resolve) => setImmediate(resolve)) : () => new Promise((resolve) => setTimeout(resolve, 0));
2209
2408
  var BatchClientTransport = class {
2210
2409
  constructor(sendBatch) {
2211
2410
  this.#promise = this.#scheduleBatch(sendBatch);
@@ -2227,7 +2426,7 @@ var BatchClientTransport = class {
2227
2426
  this.#aborted = reason;
2228
2427
  }
2229
2428
  async #scheduleBatch(sendBatch) {
2230
- await new Promise((resolve) => setTimeout(resolve, 0));
2429
+ await yieldToMacrotask();
2231
2430
  if (this.#aborted !== void 0) throw this.#aborted;
2232
2431
  let batch = this.#batchToSend;
2233
2432
  this.#batchToSend = null;
@@ -2305,7 +2504,11 @@ async function newHttpBatchRpcResponse(request, localMain, options) {
2305
2504
  * @param options Optional RPC session options. You can also pass headers to set on the response.
2306
2505
  */
2307
2506
  async function nodeHttpBatchRpcResponse(request, response, localMain, options) {
2308
- if (request.method !== "POST") response.writeHead(405, "This endpoint only accepts POST requests.");
2507
+ if (request.method !== "POST") {
2508
+ response.writeHead(405, "This endpoint only accepts POST requests.", options?.headers);
2509
+ response.end();
2510
+ return;
2511
+ }
2309
2512
  let body = await new Promise((resolve, reject) => {
2310
2513
  let chunks = [];
2311
2514
  request.on("data", (chunk) => {
@@ -2570,6 +2773,9 @@ var MapApplicator = class {
2570
2773
  getPipeReadable(exportId) {
2571
2774
  throw new Error("A mapper function cannot use pipe readables.");
2572
2775
  }
2776
+ getLimits() {
2777
+ return DEFAULT_LIMITS;
2778
+ }
2573
2779
  };
2574
2780
  function applyMapToElement(input, parent, owner, captures, instructions) {
2575
2781
  let mapper = new MapApplicator(captures, new PayloadStubHook(RpcPayload.deepCopyFrom(input, parent, owner)));
@@ -2630,8 +2836,7 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
2630
2836
  throw new Error(`Unknown WritableStream method: ${method}`);
2631
2837
  }
2632
2838
  if (method === "close" || method === "abort") state.closed = true;
2633
- let func = state.writer[method];
2634
- return new PromiseStubHook(args.deliverCall(func, state.writer).then((payload) => new PayloadStubHook(payload)));
2839
+ return new PromiseStubHook((method === "write" ? args.deliverStreamWrite(state.writer) : args.deliverCall(state.writer[method], state.writer)).then((payload) => new PayloadStubHook(payload)));
2635
2840
  } catch (err) {
2636
2841
  return new ErrorStubHook(err);
2637
2842
  }
@@ -2908,12 +3113,12 @@ let newMessagePortRpcSession = newMessagePortRpcSession$1;
2908
3113
  * credentials as parameters and returns the authorized API), then cross-origin requests should
2909
3114
  * be safe.
2910
3115
  */
2911
- async function newWorkersRpcResponse(request, localMain) {
3116
+ async function newWorkersRpcResponse(request, localMain, options) {
2912
3117
  if (request.method === "POST") {
2913
- let response = await newHttpBatchRpcResponse(request, localMain);
3118
+ let response = await newHttpBatchRpcResponse(request, localMain, options);
2914
3119
  response.headers.set("Access-Control-Allow-Origin", "*");
2915
3120
  return response;
2916
- } else if (request.headers.get("Upgrade")?.toLowerCase() === "websocket") return newWorkersWebSocketRpcResponse(request, localMain);
3121
+ } else if (request.headers.get("Upgrade")?.toLowerCase() === "websocket") return newWorkersWebSocketRpcResponse(request, localMain, options);
2917
3122
  else return new Response("This endpoint only accepts POST or WebSocket requests.", { status: 400 });
2918
3123
  }
2919
3124
 
@@ -3034,5 +3239,5 @@ var BunWebSocketTransport = class {
3034
3239
  let newBunWebSocketRpcSession = newBunWebSocketRpcSession$1;
3035
3240
 
3036
3241
  //#endregion
3037
- export { BunWebSocketTransport, RpcPromise, RpcSession, RpcStub, RpcTarget, WebSocketTransport, deserialize, newBunWebSocketRpcHandler, newBunWebSocketRpcSession, newHttpBatchRpcResponse, newHttpBatchRpcSession, newMessagePortRpcSession, newWebSocketRpcSession, newWorkersRpcResponse, newWorkersWebSocketRpcResponse, nodeHttpBatchRpcResponse, serialize };
3242
+ export { BunWebSocketTransport, DEFAULT_LIMITS, DEFAULT_MAX_DEPTH, RpcPromise, RpcSession, RpcStub, RpcTarget, WebSocketTransport, deserialize, newBunWebSocketRpcHandler, newBunWebSocketRpcSession, newHttpBatchRpcResponse, newHttpBatchRpcSession, newMessagePortRpcSession, newWebSocketRpcSession, newWorkersRpcResponse, newWorkersWebSocketRpcResponse, nodeHttpBatchRpcResponse, serialize };
3038
3243
  //# sourceMappingURL=index-bun.js.map