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.
- package/README.md +38 -2
- package/dist/index-bun.cjs +236 -33
- package/dist/index-bun.cjs.map +1 -1
- package/dist/index-bun.d.cts +34 -7
- package/dist/index-bun.d.ts +34 -7
- package/dist/index-bun.js +235 -34
- package/dist/index-bun.js.map +1 -1
- package/dist/index-workers.cjs +236 -33
- package/dist/index-workers.cjs.map +1 -1
- package/dist/index-workers.d.cts +31 -7
- package/dist/index-workers.d.ts +31 -7
- package/dist/index-workers.js +235 -34
- package/dist/index-workers.js.map +1 -1
- package/dist/index.cjs +236 -33
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +31 -7
- package/dist/index.d.ts +31 -7
- package/dist/index.js +235 -34
- package/dist/index.js.map +1 -1
- package/package.json +4 -4
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:
|
|
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 >=
|
|
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
|
|
1023
|
-
|
|
1024
|
-
if (
|
|
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 (
|
|
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
|
-
|
|
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")
|
|
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
|
-
|
|
1272
|
-
if (
|
|
1273
|
-
else if (
|
|
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
|
-
|
|
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
|
-
|
|
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).
|
|
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
|
|
2429
|
+
await yieldToMacrotask();
|
|
2231
2430
|
if (this.#aborted !== void 0) throw this.#aborted;
|
|
2232
2431
|
let batch = this.#batchToSend;
|
|
2233
2432
|
this.#batchToSend = null;
|
|
@@ -2574,6 +2773,9 @@ var MapApplicator = class {
|
|
|
2574
2773
|
getPipeReadable(exportId) {
|
|
2575
2774
|
throw new Error("A mapper function cannot use pipe readables.");
|
|
2576
2775
|
}
|
|
2776
|
+
getLimits() {
|
|
2777
|
+
return DEFAULT_LIMITS;
|
|
2778
|
+
}
|
|
2577
2779
|
};
|
|
2578
2780
|
function applyMapToElement(input, parent, owner, captures, instructions) {
|
|
2579
2781
|
let mapper = new MapApplicator(captures, new PayloadStubHook(RpcPayload.deepCopyFrom(input, parent, owner)));
|
|
@@ -2634,8 +2836,7 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2634
2836
|
throw new Error(`Unknown WritableStream method: ${method}`);
|
|
2635
2837
|
}
|
|
2636
2838
|
if (method === "close" || method === "abort") state.closed = true;
|
|
2637
|
-
|
|
2638
|
-
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)));
|
|
2639
2840
|
} catch (err) {
|
|
2640
2841
|
return new ErrorStubHook(err);
|
|
2641
2842
|
}
|
|
@@ -2912,12 +3113,12 @@ let newMessagePortRpcSession = newMessagePortRpcSession$1;
|
|
|
2912
3113
|
* credentials as parameters and returns the authorized API), then cross-origin requests should
|
|
2913
3114
|
* be safe.
|
|
2914
3115
|
*/
|
|
2915
|
-
async function newWorkersRpcResponse(request, localMain) {
|
|
3116
|
+
async function newWorkersRpcResponse(request, localMain, options) {
|
|
2916
3117
|
if (request.method === "POST") {
|
|
2917
|
-
let response = await newHttpBatchRpcResponse(request, localMain);
|
|
3118
|
+
let response = await newHttpBatchRpcResponse(request, localMain, options);
|
|
2918
3119
|
response.headers.set("Access-Control-Allow-Origin", "*");
|
|
2919
3120
|
return response;
|
|
2920
|
-
} 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);
|
|
2921
3122
|
else return new Response("This endpoint only accepts POST or WebSocket requests.", { status: 400 });
|
|
2922
3123
|
}
|
|
2923
3124
|
|
|
@@ -3038,5 +3239,5 @@ var BunWebSocketTransport = class {
|
|
|
3038
3239
|
let newBunWebSocketRpcSession = newBunWebSocketRpcSession$1;
|
|
3039
3240
|
|
|
3040
3241
|
//#endregion
|
|
3041
|
-
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 };
|
|
3042
3243
|
//# sourceMappingURL=index-bun.js.map
|