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-workers.cjs
CHANGED
|
@@ -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:
|
|
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 >=
|
|
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
|
|
1058
|
-
|
|
1059
|
-
if (
|
|
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 (
|
|
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
|
-
|
|
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")
|
|
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
|
-
|
|
1307
|
-
if (
|
|
1308
|
-
else if (
|
|
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
|
-
|
|
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
|
-
|
|
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).
|
|
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
|
|
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
|
-
|
|
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;
|