capnweb 0.11.1 → 0.13.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 +112 -738
- package/dist/index-bun.cjs +370 -141
- package/dist/index-bun.cjs.map +1 -1
- package/dist/index-bun.d.cts +101 -32
- package/dist/index-bun.d.ts +101 -32
- package/dist/index-bun.js +370 -140
- package/dist/index-bun.js.map +1 -1
- package/dist/index-workers.cjs +371 -141
- package/dist/index-workers.cjs.map +1 -1
- package/dist/index-workers.d.cts +96 -30
- package/dist/index-workers.d.ts +96 -30
- package/dist/index-workers.js +370 -140
- package/dist/index-workers.js.map +1 -1
- package/dist/index.cjs +370 -141
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +96 -30
- package/dist/index.d.ts +96 -30
- package/dist/index.js +370 -140
- package/dist/index.js.map +1 -1
- package/package.json +22 -19
package/dist/index-bun.cjs
CHANGED
|
@@ -1,5 +1,4 @@
|
|
|
1
1
|
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
|
2
|
-
|
|
3
2
|
//#region src/symbols.ts
|
|
4
3
|
let WORKERS_MODULE_SYMBOL = Symbol("workers-module");
|
|
5
4
|
|
|
@@ -42,6 +41,9 @@ function typeForRpc(value) {
|
|
|
42
41
|
case AsyncFunction.prototype: return "function";
|
|
43
42
|
case Array.prototype: return "array";
|
|
44
43
|
case Date.prototype: return "date";
|
|
44
|
+
case RegExp.prototype: return "regexp";
|
|
45
|
+
case Set.prototype: return "set";
|
|
46
|
+
case Map.prototype: return "map";
|
|
45
47
|
case Uint8Array.prototype:
|
|
46
48
|
case BUFFER_PROTOTYPE:
|
|
47
49
|
case ArrayBuffer.prototype:
|
|
@@ -92,7 +94,14 @@ let streamImpl = {
|
|
|
92
94
|
};
|
|
93
95
|
var StubHook = class {
|
|
94
96
|
stream(path, args) {
|
|
95
|
-
let
|
|
97
|
+
let hook = this.call(path, args);
|
|
98
|
+
let pulled;
|
|
99
|
+
try {
|
|
100
|
+
pulled = hook.pull();
|
|
101
|
+
} catch (err) {
|
|
102
|
+
hook.dispose();
|
|
103
|
+
throw err;
|
|
104
|
+
}
|
|
96
105
|
let promise;
|
|
97
106
|
if (pulled instanceof Promise) promise = pulled.then((p) => {
|
|
98
107
|
p.dispose();
|
|
@@ -111,9 +120,11 @@ var ErrorStubHook = class extends StubHook {
|
|
|
111
120
|
this.error = error;
|
|
112
121
|
}
|
|
113
122
|
call(path, args) {
|
|
123
|
+
args.dispose();
|
|
114
124
|
return this;
|
|
115
125
|
}
|
|
116
126
|
map(path, captures, instructions) {
|
|
127
|
+
for (let cap of captures) cap.dispose();
|
|
117
128
|
return this;
|
|
118
129
|
}
|
|
119
130
|
get(path) {
|
|
@@ -237,7 +248,25 @@ var RpcStub$1 = class RpcStub$1 extends RpcTarget$1 {
|
|
|
237
248
|
};
|
|
238
249
|
var RpcPromise$1 = class extends RpcStub$1 {
|
|
239
250
|
constructor(hook, pathIfPromise) {
|
|
240
|
-
super(hook, pathIfPromise);
|
|
251
|
+
if (hook instanceof StubHook) super(hook, pathIfPromise ?? []);
|
|
252
|
+
else {
|
|
253
|
+
if (pathIfPromise !== void 0) throw new TypeError("RpcPromise constructor expected one argument, received two.");
|
|
254
|
+
let kind = typeForRpc(hook);
|
|
255
|
+
if (kind === "rpc-promise") {
|
|
256
|
+
let raw = unwrapStubAndPath(hook);
|
|
257
|
+
if (raw.pathIfPromise.length > 0) super(raw.hook, raw.pathIfPromise);
|
|
258
|
+
else {
|
|
259
|
+
let adopted = raw.hook;
|
|
260
|
+
raw.hook = DISPOSED_HOOK;
|
|
261
|
+
super(adopted, []);
|
|
262
|
+
}
|
|
263
|
+
} else if (kind === "rpc-thenable") super(TargetStubHook.create(hook, void 0), []);
|
|
264
|
+
else {
|
|
265
|
+
let promiseHook = new PromiseStubHook(Promise.resolve(hook).then((value) => new PayloadStubHook(RpcPayload.fromAppReturn(value))));
|
|
266
|
+
promiseHook.ignoreUnhandledRejections();
|
|
267
|
+
super(promiseHook, []);
|
|
268
|
+
}
|
|
269
|
+
}
|
|
241
270
|
}
|
|
242
271
|
then(onfulfilled, onrejected) {
|
|
243
272
|
return pullPromise(this).then(...arguments);
|
|
@@ -278,6 +307,9 @@ async function pullPromise(promise) {
|
|
|
278
307
|
if (pathIfPromise.length > 0) hook = hook.get(pathIfPromise);
|
|
279
308
|
return (await hook.pull()).deliverResolve();
|
|
280
309
|
}
|
|
310
|
+
function mapKeyToPropertyName(key) {
|
|
311
|
+
return typeof key === "string" || typeof key === "number" ? key : { mapKey: key };
|
|
312
|
+
}
|
|
281
313
|
var RpcPayload = class RpcPayload {
|
|
282
314
|
value;
|
|
283
315
|
source;
|
|
@@ -332,12 +364,13 @@ var RpcPayload = class RpcPayload {
|
|
|
332
364
|
return TargetStubHook.create(target, parent);
|
|
333
365
|
} else if (this.source === "return") {
|
|
334
366
|
let hook = this.rpcTargets?.get(target);
|
|
335
|
-
if (hook)
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
367
|
+
if (hook) {
|
|
368
|
+
if (dupStubs) return hook.dup();
|
|
369
|
+
else {
|
|
370
|
+
this.rpcTargets?.delete(target);
|
|
371
|
+
return hook;
|
|
372
|
+
}
|
|
373
|
+
} else {
|
|
341
374
|
hook = TargetStubHook.create(target, parent);
|
|
342
375
|
if (dupStubs) {
|
|
343
376
|
if (!this.rpcTargets) this.rpcTargets = /* @__PURE__ */ new Map();
|
|
@@ -351,12 +384,13 @@ var RpcPayload = class RpcPayload {
|
|
|
351
384
|
if (this.source === "params") return streamImpl.createWritableStreamHook(stream);
|
|
352
385
|
else if (this.source === "return") {
|
|
353
386
|
let hook = this.rpcTargets?.get(stream);
|
|
354
|
-
if (hook)
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
387
|
+
if (hook) {
|
|
388
|
+
if (dupStubs) return hook.dup();
|
|
389
|
+
else {
|
|
390
|
+
this.rpcTargets?.delete(stream);
|
|
391
|
+
return hook;
|
|
392
|
+
}
|
|
393
|
+
} else {
|
|
360
394
|
hook = streamImpl.createWritableStreamHook(stream);
|
|
361
395
|
if (dupStubs) {
|
|
362
396
|
if (!this.rpcTargets) this.rpcTargets = /* @__PURE__ */ new Map();
|
|
@@ -370,12 +404,13 @@ var RpcPayload = class RpcPayload {
|
|
|
370
404
|
if (this.source === "params") return streamImpl.createReadableStreamHook(stream);
|
|
371
405
|
else if (this.source === "return") {
|
|
372
406
|
let hook = this.rpcTargets?.get(stream);
|
|
373
|
-
if (hook)
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
407
|
+
if (hook) {
|
|
408
|
+
if (dupStubs) return hook.dup();
|
|
409
|
+
else {
|
|
410
|
+
this.rpcTargets?.delete(stream);
|
|
411
|
+
return hook;
|
|
412
|
+
}
|
|
413
|
+
} else {
|
|
379
414
|
hook = streamImpl.createReadableStreamHook(stream);
|
|
380
415
|
if (dupStubs) {
|
|
381
416
|
if (!this.rpcTargets) this.rpcTargets = /* @__PURE__ */ new Map();
|
|
@@ -383,7 +418,7 @@ var RpcPayload = class RpcPayload {
|
|
|
383
418
|
return hook.dup();
|
|
384
419
|
} else return hook;
|
|
385
420
|
}
|
|
386
|
-
} else
|
|
421
|
+
} else return streamImpl.createReadableStreamHook(stream);
|
|
387
422
|
}
|
|
388
423
|
deepCopy(value, oldParent, property, parent, dupStubs, owner) {
|
|
389
424
|
switch (typeForRpc(value)) {
|
|
@@ -394,6 +429,7 @@ var RpcPayload = class RpcPayload {
|
|
|
394
429
|
case "bytes":
|
|
395
430
|
case "blob":
|
|
396
431
|
case "url":
|
|
432
|
+
case "regexp":
|
|
397
433
|
case "error":
|
|
398
434
|
case "undefined": return value;
|
|
399
435
|
case "array": {
|
|
@@ -403,6 +439,35 @@ var RpcPayload = class RpcPayload {
|
|
|
403
439
|
for (let i = 0; i < len; i++) result[i] = this.deepCopy(array[i], array, i, result, dupStubs, owner);
|
|
404
440
|
return result;
|
|
405
441
|
}
|
|
442
|
+
case "set": {
|
|
443
|
+
let set = value;
|
|
444
|
+
let elements = [...set];
|
|
445
|
+
for (let val of elements) {
|
|
446
|
+
let kind = typeForRpc(val);
|
|
447
|
+
if (kind === "rpc-promise" || kind === "rpc-thenable") throw new TypeError("Cannot pass a promise as an element of a Set. Await the value before adding it to the Set.");
|
|
448
|
+
}
|
|
449
|
+
let result = /* @__PURE__ */ new Set();
|
|
450
|
+
let index = 0;
|
|
451
|
+
for (let val of elements) {
|
|
452
|
+
let copy = this.deepCopy(val, set, index++, result, dupStubs, owner);
|
|
453
|
+
result.add(copy);
|
|
454
|
+
}
|
|
455
|
+
return result;
|
|
456
|
+
}
|
|
457
|
+
case "map": {
|
|
458
|
+
let map = value;
|
|
459
|
+
let entries = [...map];
|
|
460
|
+
for (let [key] of entries) {
|
|
461
|
+
let kind = typeForRpc(key);
|
|
462
|
+
if (kind === "rpc-promise" || kind === "rpc-thenable") throw new TypeError("Cannot pass a promise as a key of a Map. Await the value before using it as a key.");
|
|
463
|
+
}
|
|
464
|
+
let result = /* @__PURE__ */ new Map();
|
|
465
|
+
for (let [key, val] of entries) {
|
|
466
|
+
let keyCopy = this.deepCopy(key, map, -1, result, dupStubs, owner);
|
|
467
|
+
result.set(keyCopy, this.deepCopy(val, map, mapKeyToPropertyName(keyCopy), result, dupStubs, owner));
|
|
468
|
+
}
|
|
469
|
+
return result;
|
|
470
|
+
}
|
|
406
471
|
case "object": {
|
|
407
472
|
let result = {};
|
|
408
473
|
let object = value;
|
|
@@ -460,8 +525,10 @@ var RpcPayload = class RpcPayload {
|
|
|
460
525
|
case "readable": {
|
|
461
526
|
let stream = value;
|
|
462
527
|
let hook;
|
|
463
|
-
if (owner)
|
|
464
|
-
|
|
528
|
+
if (owner) {
|
|
529
|
+
if (owner.source === "owned") throw new Error("Can't copy a ReadableStream.");
|
|
530
|
+
hook = owner.getHookForReadableStream(stream, oldParent, dupStubs);
|
|
531
|
+
} else hook = streamImpl.createReadableStreamHook(stream);
|
|
465
532
|
this.hooks.push(hook);
|
|
466
533
|
return stream;
|
|
467
534
|
}
|
|
@@ -487,6 +554,10 @@ var RpcPayload = class RpcPayload {
|
|
|
487
554
|
try {
|
|
488
555
|
this.value = this.deepCopy(this.value, void 0, "value", this, dupStubs, this);
|
|
489
556
|
} catch (err) {
|
|
557
|
+
if (dupStubs) {
|
|
558
|
+
this.hooks.forEach((hook) => hook.dispose());
|
|
559
|
+
this.promises.forEach((promise) => promise.promise[Symbol.dispose]());
|
|
560
|
+
}
|
|
490
561
|
this.hooks = void 0;
|
|
491
562
|
this.promises = void 0;
|
|
492
563
|
throw err;
|
|
@@ -500,7 +571,8 @@ var RpcPayload = class RpcPayload {
|
|
|
500
571
|
this.ensureDeepCopied();
|
|
501
572
|
if (this.value instanceof RpcPromise$1) RpcPayload.deliverRpcPromiseTo(this.value, parent, property, promises);
|
|
502
573
|
else {
|
|
503
|
-
parent
|
|
574
|
+
if (parent instanceof Map) parent.set(typeof property === "object" ? property.mapKey : property, this.value);
|
|
575
|
+
else parent[property] = this.value;
|
|
504
576
|
for (let record of this.promises) RpcPayload.deliverRpcPromiseTo(record.promise, record.parent, record.property, promises);
|
|
505
577
|
}
|
|
506
578
|
}
|
|
@@ -592,6 +664,7 @@ var RpcPayload = class RpcPayload {
|
|
|
592
664
|
case "blob":
|
|
593
665
|
case "date":
|
|
594
666
|
case "url":
|
|
667
|
+
case "regexp":
|
|
595
668
|
case "error":
|
|
596
669
|
case "undefined": return;
|
|
597
670
|
case "array": {
|
|
@@ -600,6 +673,19 @@ var RpcPayload = class RpcPayload {
|
|
|
600
673
|
for (let i = 0; i < len; i++) this.disposeImpl(array[i], array);
|
|
601
674
|
return;
|
|
602
675
|
}
|
|
676
|
+
case "set": {
|
|
677
|
+
let set = value;
|
|
678
|
+
for (let element of set) this.disposeImpl(element, set);
|
|
679
|
+
return;
|
|
680
|
+
}
|
|
681
|
+
case "map": {
|
|
682
|
+
let map = value;
|
|
683
|
+
for (let [key, val] of map) {
|
|
684
|
+
this.disposeImpl(key, map);
|
|
685
|
+
this.disposeImpl(val, map);
|
|
686
|
+
}
|
|
687
|
+
return;
|
|
688
|
+
}
|
|
603
689
|
case "object": {
|
|
604
690
|
let object = value;
|
|
605
691
|
for (let i in object) this.disposeImpl(object[i], object);
|
|
@@ -675,6 +761,7 @@ var RpcPayload = class RpcPayload {
|
|
|
675
761
|
case "writable":
|
|
676
762
|
case "readable":
|
|
677
763
|
case "url":
|
|
764
|
+
case "regexp":
|
|
678
765
|
case "headers":
|
|
679
766
|
case "request":
|
|
680
767
|
case "response": return;
|
|
@@ -684,6 +771,19 @@ var RpcPayload = class RpcPayload {
|
|
|
684
771
|
for (let i = 0; i < len; i++) this.ignoreUnhandledRejectionsImpl(array[i]);
|
|
685
772
|
return;
|
|
686
773
|
}
|
|
774
|
+
case "set": {
|
|
775
|
+
let set = value;
|
|
776
|
+
for (let element of set) this.ignoreUnhandledRejectionsImpl(element);
|
|
777
|
+
return;
|
|
778
|
+
}
|
|
779
|
+
case "map": {
|
|
780
|
+
let map = value;
|
|
781
|
+
for (let [key, val] of map) {
|
|
782
|
+
this.ignoreUnhandledRejectionsImpl(key);
|
|
783
|
+
this.ignoreUnhandledRejectionsImpl(val);
|
|
784
|
+
}
|
|
785
|
+
return;
|
|
786
|
+
}
|
|
687
787
|
case "object": {
|
|
688
788
|
let object = value;
|
|
689
789
|
for (let i in object) this.ignoreUnhandledRejectionsImpl(object[i]);
|
|
@@ -743,8 +843,11 @@ function followPath(value, parent, path, owner) {
|
|
|
743
843
|
case "bytes":
|
|
744
844
|
case "blob":
|
|
745
845
|
case "date":
|
|
846
|
+
case "set":
|
|
847
|
+
case "map":
|
|
746
848
|
case "error":
|
|
747
849
|
case "url":
|
|
850
|
+
case "regexp":
|
|
748
851
|
case "headers":
|
|
749
852
|
case "request":
|
|
750
853
|
case "response":
|
|
@@ -777,17 +880,23 @@ function followPath(value, parent, path, owner) {
|
|
|
777
880
|
}
|
|
778
881
|
var ValueStubHook = class extends StubHook {
|
|
779
882
|
call(path, args) {
|
|
883
|
+
let followResult;
|
|
780
884
|
try {
|
|
781
885
|
let { value, owner } = this.getValue();
|
|
782
|
-
|
|
783
|
-
if (followResult.hook) return followResult.hook.call(followResult.remainingPath, args);
|
|
784
|
-
if (typeof followResult.value != "function") throw new TypeError(`'${path.join(".")}' is not a function.`);
|
|
785
|
-
return new PromiseStubHook(args.deliverCall(followResult.value, followResult.parent).then((payload) => {
|
|
786
|
-
return new PayloadStubHook(payload);
|
|
787
|
-
}));
|
|
886
|
+
followResult = followPath(value, void 0, path, owner);
|
|
788
887
|
} catch (err) {
|
|
888
|
+
args.dispose();
|
|
789
889
|
return new ErrorStubHook(err);
|
|
790
890
|
}
|
|
891
|
+
if (followResult.hook) return followResult.hook.call(followResult.remainingPath, args);
|
|
892
|
+
if (typeof followResult.value != "function") {
|
|
893
|
+
args.dispose();
|
|
894
|
+
return new ErrorStubHook(/* @__PURE__ */ new TypeError(`'${path.join(".")}' is not a function.`));
|
|
895
|
+
}
|
|
896
|
+
let promise = args.deliverCall(followResult.value, followResult.parent);
|
|
897
|
+
return new PromiseStubHook(promise.then((payload) => {
|
|
898
|
+
return new PayloadStubHook(payload);
|
|
899
|
+
}));
|
|
791
900
|
}
|
|
792
901
|
map(path, captures, instructions) {
|
|
793
902
|
try {
|
|
@@ -808,7 +917,10 @@ var ValueStubHook = class extends StubHook {
|
|
|
808
917
|
get(path) {
|
|
809
918
|
try {
|
|
810
919
|
let { value, owner } = this.getValue();
|
|
811
|
-
if (path.length === 0 && owner === null)
|
|
920
|
+
if (path.length === 0 && owner === null) {
|
|
921
|
+
if (value instanceof Object && "then" in value) return this.dup();
|
|
922
|
+
throw new Error("Can't dup an RpcTarget stub as a promise.");
|
|
923
|
+
}
|
|
812
924
|
let followResult = followPath(value, void 0, path, owner);
|
|
813
925
|
if (followResult.hook) return followResult.hook.get(followResult.remainingPath);
|
|
814
926
|
return new PayloadStubHook(RpcPayload.deepCopyFrom(followResult.value, followResult.parent, followResult.owner));
|
|
@@ -911,7 +1023,10 @@ var TargetStubHook = class TargetStubHook extends ValueStubHook {
|
|
|
911
1023
|
this.target = void 0;
|
|
912
1024
|
}
|
|
913
1025
|
}
|
|
914
|
-
onBroken(callback) {
|
|
1026
|
+
onBroken(callback) {
|
|
1027
|
+
let target = this.target;
|
|
1028
|
+
if (target && "then" in target) Promise.resolve(target).then(() => {}, callback);
|
|
1029
|
+
}
|
|
915
1030
|
};
|
|
916
1031
|
var PromiseStubHook = class PromiseStubHook extends StubHook {
|
|
917
1032
|
promise;
|
|
@@ -925,12 +1040,16 @@ var PromiseStubHook = class PromiseStubHook extends StubHook {
|
|
|
925
1040
|
}
|
|
926
1041
|
call(path, args) {
|
|
927
1042
|
args.ensureDeepCopied();
|
|
928
|
-
return new PromiseStubHook(this.promise.then((hook) => hook.call(path, args))
|
|
1043
|
+
return new PromiseStubHook(this.promise.then((hook) => hook.call(path, args), (err) => {
|
|
1044
|
+
args.dispose();
|
|
1045
|
+
throw err;
|
|
1046
|
+
}));
|
|
929
1047
|
}
|
|
930
1048
|
stream(path, args) {
|
|
931
1049
|
args.ensureDeepCopied();
|
|
932
|
-
return { promise: this.promise.then((hook) => {
|
|
933
|
-
|
|
1050
|
+
return { promise: this.promise.then((hook) => hook.stream(path, args).promise, (err) => {
|
|
1051
|
+
args.dispose();
|
|
1052
|
+
throw err;
|
|
934
1053
|
}) };
|
|
935
1054
|
}
|
|
936
1055
|
map(path, captures, instructions) {
|
|
@@ -957,10 +1076,7 @@ var PromiseStubHook = class PromiseStubHook extends StubHook {
|
|
|
957
1076
|
}, (err) => {});
|
|
958
1077
|
}
|
|
959
1078
|
dispose() {
|
|
960
|
-
|
|
961
|
-
else this.promise.then((hook) => {
|
|
962
|
-
hook.dispose();
|
|
963
|
-
}, (err) => {});
|
|
1079
|
+
this.promise.then((hook) => hook.dispose(), () => {});
|
|
964
1080
|
}
|
|
965
1081
|
onBroken(callback) {
|
|
966
1082
|
if (this.resolution) this.resolution.onBroken(callback);
|
|
@@ -976,7 +1092,7 @@ const DEFAULT_MAX_DEPTH = 256;
|
|
|
976
1092
|
const DEFAULT_LIMITS = {
|
|
977
1093
|
maxBigIntDigits: 16384,
|
|
978
1094
|
maxDepth: 256,
|
|
979
|
-
maxMessageSize:
|
|
1095
|
+
maxMessageSize: 33554432
|
|
980
1096
|
};
|
|
981
1097
|
const NATIVE_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
|
|
982
1098
|
const BYTE_CONTAINER_TYPE_NAMES = [
|
|
@@ -1038,9 +1154,7 @@ function swapByteOrder(bytes, elementSize) {
|
|
|
1038
1154
|
case 4:
|
|
1039
1155
|
view.setUint32(offset, view.getUint32(offset, false), true);
|
|
1040
1156
|
break;
|
|
1041
|
-
case 8:
|
|
1042
|
-
view.setBigUint64(offset, view.getBigUint64(offset, false), true);
|
|
1043
|
-
break;
|
|
1157
|
+
case 8: view.setBigUint64(offset, view.getBigUint64(offset, false), true);
|
|
1044
1158
|
}
|
|
1045
1159
|
}
|
|
1046
1160
|
var NullExporter = class {
|
|
@@ -1125,6 +1239,30 @@ var Devaluator = class Devaluator {
|
|
|
1125
1239
|
for (let i = 0; i < len; i++) result[i] = this.devaluateImpl(array[i], array, depth + 1);
|
|
1126
1240
|
return [result];
|
|
1127
1241
|
}
|
|
1242
|
+
case "set": {
|
|
1243
|
+
let set = value;
|
|
1244
|
+
let setElements = [...set];
|
|
1245
|
+
let elements = [];
|
|
1246
|
+
for (let element of setElements) switch (typeForRpc(element)) {
|
|
1247
|
+
case "blob": throw new TypeError("Cannot serialize a Blob as an element of a Set.");
|
|
1248
|
+
case "rpc-promise":
|
|
1249
|
+
case "rpc-thenable": throw new TypeError("Cannot serialize a promise as an element of a Set. Await the value before adding it to the Set.");
|
|
1250
|
+
}
|
|
1251
|
+
for (let element of setElements) elements.push(this.devaluateImpl(element, set, depth + 1));
|
|
1252
|
+
return ["set", elements];
|
|
1253
|
+
}
|
|
1254
|
+
case "map": {
|
|
1255
|
+
let map = value;
|
|
1256
|
+
let mapEntries = [...map];
|
|
1257
|
+
let entries = [];
|
|
1258
|
+
for (let [key] of mapEntries) switch (typeForRpc(key)) {
|
|
1259
|
+
case "blob": throw new TypeError("Cannot serialize a Blob as a key of a Map.");
|
|
1260
|
+
case "rpc-promise":
|
|
1261
|
+
case "rpc-thenable": throw new TypeError("Cannot serialize a promise as a key of a Map. Await the value before using it as a key.");
|
|
1262
|
+
}
|
|
1263
|
+
for (let [key, val] of mapEntries) entries.push([this.devaluateImpl(key, map, depth + 1), this.devaluateImpl(val, map, depth + 1)]);
|
|
1264
|
+
return ["map", entries];
|
|
1265
|
+
}
|
|
1128
1266
|
case "bigint":
|
|
1129
1267
|
if (this.encodingLevel === "structuredClonable") return value;
|
|
1130
1268
|
return ["bigint", value.toString()];
|
|
@@ -1133,6 +1271,15 @@ var Devaluator = class Devaluator {
|
|
|
1133
1271
|
const time = value.getTime();
|
|
1134
1272
|
return ["date", Number.isNaN(time) ? null : time];
|
|
1135
1273
|
}
|
|
1274
|
+
case "regexp": {
|
|
1275
|
+
if (this.encodingLevel === "structuredClonable") return value;
|
|
1276
|
+
let re = value;
|
|
1277
|
+
return re.flags ? [
|
|
1278
|
+
"regexp",
|
|
1279
|
+
re.source,
|
|
1280
|
+
re.flags
|
|
1281
|
+
] : ["regexp", re.source];
|
|
1282
|
+
}
|
|
1136
1283
|
case "bytes": {
|
|
1137
1284
|
let alternateTypeName = BYTE_CONTAINER_TYPE_BY_PROTOTYPE.get(Object.getPrototypeOf(value));
|
|
1138
1285
|
let bytes;
|
|
@@ -1147,11 +1294,14 @@ var Devaluator = class Devaluator {
|
|
|
1147
1294
|
swapByteOrder(bytes, elementSize);
|
|
1148
1295
|
}
|
|
1149
1296
|
}
|
|
1150
|
-
if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes")
|
|
1151
|
-
|
|
1152
|
-
bytes,
|
|
1153
|
-
|
|
1154
|
-
|
|
1297
|
+
if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") {
|
|
1298
|
+
if (bytes.byteLength !== bytes.buffer.byteLength) bytes = new Uint8Array(bytes);
|
|
1299
|
+
return alternateTypeName === void 0 ? ["bytes", bytes] : [
|
|
1300
|
+
"bytes",
|
|
1301
|
+
bytes,
|
|
1302
|
+
alternateTypeName
|
|
1303
|
+
];
|
|
1304
|
+
}
|
|
1155
1305
|
let b64;
|
|
1156
1306
|
if (bytes.toBase64) b64 = bytes.toBase64({ omitPadding: true });
|
|
1157
1307
|
else if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
|
|
@@ -1290,13 +1440,16 @@ var Devaluator = class Devaluator {
|
|
|
1290
1440
|
if (!this.source) throw new Error("Can't serialize RPC stubs in this context.");
|
|
1291
1441
|
let { hook, pathIfPromise } = unwrapStubAndPath(value);
|
|
1292
1442
|
let importId = this.exporter.getImport(hook);
|
|
1293
|
-
if (importId !== void 0)
|
|
1294
|
-
|
|
1295
|
-
|
|
1296
|
-
|
|
1297
|
-
|
|
1298
|
-
|
|
1299
|
-
|
|
1443
|
+
if (importId !== void 0) {
|
|
1444
|
+
if (pathIfPromise) {
|
|
1445
|
+
if (pathIfPromise.length > 0) return [
|
|
1446
|
+
"pipeline",
|
|
1447
|
+
importId,
|
|
1448
|
+
pathIfPromise
|
|
1449
|
+
];
|
|
1450
|
+
else return ["pipeline", importId];
|
|
1451
|
+
} else return ["import", importId];
|
|
1452
|
+
}
|
|
1300
1453
|
if (pathIfPromise) hook = hook.get(pathIfPromise);
|
|
1301
1454
|
else hook = hook.dup();
|
|
1302
1455
|
return this.devaluateHook(pathIfPromise ? "promise" : "export", hook);
|
|
@@ -1357,16 +1510,18 @@ var NullImporter = class {
|
|
|
1357
1510
|
};
|
|
1358
1511
|
const NULL_IMPORTER = new NullImporter();
|
|
1359
1512
|
function fixBrokenRequestBody(request, body) {
|
|
1360
|
-
|
|
1513
|
+
let promise = new Response(body).arrayBuffer().then((arrayBuffer) => {
|
|
1361
1514
|
let bytes = new Uint8Array(arrayBuffer);
|
|
1362
1515
|
let result = new Request(request, { body: bytes });
|
|
1363
1516
|
return new PayloadStubHook(RpcPayload.fromAppReturn(result));
|
|
1364
|
-
})
|
|
1517
|
+
});
|
|
1518
|
+
return new RpcPromise$1(new PromiseStubHook(promise), []);
|
|
1365
1519
|
}
|
|
1366
1520
|
function streamToBlobPromise(stream, type) {
|
|
1367
|
-
|
|
1521
|
+
let promise = streamToBlob(stream, type).then((blob) => {
|
|
1368
1522
|
return new PayloadStubHook(RpcPayload.fromAppReturn(blob));
|
|
1369
|
-
})
|
|
1523
|
+
});
|
|
1524
|
+
return new RpcPromise$1(new PromiseStubHook(promise), []);
|
|
1370
1525
|
}
|
|
1371
1526
|
var Evaluator = class Evaluator {
|
|
1372
1527
|
importer;
|
|
@@ -1399,7 +1554,7 @@ var Evaluator = class Evaluator {
|
|
|
1399
1554
|
let maxDepth = this.limits.maxDepth;
|
|
1400
1555
|
if (depth >= maxDepth) throw new TypeError(`Deserialization exceeded maximum allowed message depth of ${maxDepth}.`);
|
|
1401
1556
|
if (this.encodingLevel === "structuredClonable") {
|
|
1402
|
-
if (value instanceof Date || typeof value === "bigint") return value;
|
|
1557
|
+
if (value instanceof Date || value instanceof RegExp || typeof value === "bigint") return value;
|
|
1403
1558
|
}
|
|
1404
1559
|
if (value instanceof Array) {
|
|
1405
1560
|
if (value.length == 1 && value[0] instanceof Array) {
|
|
@@ -1419,18 +1574,48 @@ var Evaluator = class Evaluator {
|
|
|
1419
1574
|
if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
|
|
1420
1575
|
if (typeof value[1] == "number") return new Date(value[1]);
|
|
1421
1576
|
break;
|
|
1577
|
+
case "regexp":
|
|
1578
|
+
if (typeof value[1] === "string" && (value.length === 2 || value.length === 3 && typeof value[2] === "string")) return new RegExp(value[1], value[2]);
|
|
1579
|
+
break;
|
|
1580
|
+
case "set":
|
|
1581
|
+
if (value.length === 2 && value[1] instanceof Array) {
|
|
1582
|
+
let elements = value[1];
|
|
1583
|
+
let set = /* @__PURE__ */ new Set();
|
|
1584
|
+
for (let i = 0; i < elements.length; i++) {
|
|
1585
|
+
let copy = this.evaluateImpl(elements[i], set, i, depth + 1);
|
|
1586
|
+
if (copy instanceof RpcPromise$1) throw new TypeError("Cannot deserialize a promise as an element of a Set.");
|
|
1587
|
+
set.add(copy);
|
|
1588
|
+
}
|
|
1589
|
+
return set;
|
|
1590
|
+
}
|
|
1591
|
+
break;
|
|
1592
|
+
case "map":
|
|
1593
|
+
if (value.length === 2 && value[1] instanceof Array) {
|
|
1594
|
+
let entries = value[1];
|
|
1595
|
+
let map = /* @__PURE__ */ new Map();
|
|
1596
|
+
for (let i = 0; i < entries.length; i++) {
|
|
1597
|
+
let entry = entries[i];
|
|
1598
|
+
if (!(entry instanceof Array) || entry.length !== 2) throw new TypeError("Map entries must be serialized as key/value pairs.");
|
|
1599
|
+
let key = this.evaluateImpl(entry[0], map, i, depth + 1);
|
|
1600
|
+
if (key instanceof RpcPromise$1) throw new TypeError("Cannot deserialize a promise as a key of a Map.");
|
|
1601
|
+
map.set(key, this.evaluateImpl(entry[1], map, mapKeyToPropertyName(key), depth + 1));
|
|
1602
|
+
}
|
|
1603
|
+
return map;
|
|
1604
|
+
}
|
|
1605
|
+
break;
|
|
1422
1606
|
case "bytes": {
|
|
1423
1607
|
let bytes;
|
|
1424
1608
|
if (value[1] instanceof Uint8Array) bytes = value[1];
|
|
1425
|
-
else if (typeof value[1] == "string")
|
|
1426
|
-
|
|
1427
|
-
|
|
1428
|
-
|
|
1429
|
-
|
|
1430
|
-
|
|
1431
|
-
|
|
1432
|
-
|
|
1433
|
-
|
|
1609
|
+
else if (typeof value[1] == "string") {
|
|
1610
|
+
if (typeof Buffer !== "undefined") bytes = Buffer.from(value[1], "base64");
|
|
1611
|
+
else if (Uint8Array.fromBase64) bytes = Uint8Array.fromBase64(value[1]);
|
|
1612
|
+
else {
|
|
1613
|
+
let bs = atob(value[1]);
|
|
1614
|
+
let len = bs.length;
|
|
1615
|
+
bytes = new Uint8Array(len);
|
|
1616
|
+
for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
|
|
1617
|
+
}
|
|
1618
|
+
} else break;
|
|
1434
1619
|
if (value.length === 2) return bytes;
|
|
1435
1620
|
if (typeof value[2] !== "string") throw new TypeError(`Unknown bytes type marker type: ${typeof value[2]}`);
|
|
1436
1621
|
if (!isValidByteContainerName(value[2])) {
|
|
@@ -1456,7 +1641,6 @@ var Evaluator = class Evaluator {
|
|
|
1456
1641
|
case "BigUint64Array": return new BigUint64Array(buffer);
|
|
1457
1642
|
case "Float32Array": return new Float32Array(buffer);
|
|
1458
1643
|
case "Float64Array": return new Float64Array(buffer);
|
|
1459
|
-
default:
|
|
1460
1644
|
}
|
|
1461
1645
|
}
|
|
1462
1646
|
case "error":
|
|
@@ -1559,11 +1743,13 @@ var Evaluator = class Evaluator {
|
|
|
1559
1743
|
return promise;
|
|
1560
1744
|
} else {
|
|
1561
1745
|
this.hooks.push(hook);
|
|
1562
|
-
return new
|
|
1746
|
+
return new RpcStub$1(hook);
|
|
1563
1747
|
}
|
|
1564
1748
|
};
|
|
1565
|
-
if (value.length == 2)
|
|
1566
|
-
|
|
1749
|
+
if (value.length == 2) {
|
|
1750
|
+
if (isPromise) return addStub(hook.get([]));
|
|
1751
|
+
else return addStub(hook.dup());
|
|
1752
|
+
}
|
|
1567
1753
|
let path = value[2];
|
|
1568
1754
|
if (!(path instanceof Array)) break;
|
|
1569
1755
|
if (!path.every((part) => {
|
|
@@ -1593,7 +1779,8 @@ var Evaluator = class Evaluator {
|
|
|
1593
1779
|
}
|
|
1594
1780
|
});
|
|
1595
1781
|
let instructions = value[4];
|
|
1596
|
-
let
|
|
1782
|
+
let resultHook = hook.map(path, captures, instructions);
|
|
1783
|
+
let promise = new RpcPromise$1(resultHook, []);
|
|
1597
1784
|
this.promises.push({
|
|
1598
1785
|
promise,
|
|
1599
1786
|
parent,
|
|
@@ -1603,18 +1790,21 @@ var Evaluator = class Evaluator {
|
|
|
1603
1790
|
}
|
|
1604
1791
|
case "export":
|
|
1605
1792
|
case "promise":
|
|
1606
|
-
if (typeof value[1] == "number")
|
|
1607
|
-
|
|
1608
|
-
|
|
1609
|
-
|
|
1610
|
-
|
|
1611
|
-
|
|
1612
|
-
|
|
1613
|
-
|
|
1614
|
-
|
|
1615
|
-
|
|
1616
|
-
|
|
1617
|
-
|
|
1793
|
+
if (typeof value[1] == "number") {
|
|
1794
|
+
if (value[0] == "promise") {
|
|
1795
|
+
let hook = this.importer.importPromise(value[1]);
|
|
1796
|
+
let promise = new RpcPromise$1(hook, []);
|
|
1797
|
+
this.promises.push({
|
|
1798
|
+
parent,
|
|
1799
|
+
property,
|
|
1800
|
+
promise
|
|
1801
|
+
});
|
|
1802
|
+
return promise;
|
|
1803
|
+
} else {
|
|
1804
|
+
let hook = this.importer.importStub(value[1]);
|
|
1805
|
+
this.hooks.push(hook);
|
|
1806
|
+
return new RpcStub$1(hook);
|
|
1807
|
+
}
|
|
1618
1808
|
}
|
|
1619
1809
|
break;
|
|
1620
1810
|
case "writable":
|
|
@@ -1625,14 +1815,12 @@ var Evaluator = class Evaluator {
|
|
|
1625
1815
|
return stream;
|
|
1626
1816
|
}
|
|
1627
1817
|
break;
|
|
1628
|
-
case "readable":
|
|
1629
|
-
|
|
1630
|
-
|
|
1631
|
-
|
|
1632
|
-
|
|
1633
|
-
|
|
1634
|
-
}
|
|
1635
|
-
break;
|
|
1818
|
+
case "readable": if (typeof value[1] == "number") {
|
|
1819
|
+
let stream = this.importer.getPipeReadable(value[1]);
|
|
1820
|
+
let hook = streamImpl.createReadableStreamHook(stream);
|
|
1821
|
+
this.hooks.push(hook);
|
|
1822
|
+
return stream;
|
|
1823
|
+
}
|
|
1636
1824
|
}
|
|
1637
1825
|
throw new TypeError(`unknown special value: ${JSON.stringify(value)}`);
|
|
1638
1826
|
} else if (value instanceof Object) {
|
|
@@ -1677,6 +1865,7 @@ function estimateEncodedSize(value, seen, depth = 0) {
|
|
|
1677
1865
|
if (value instanceof ArrayBuffer) return ESTIMATED_BINARY_OVERHEAD + value.byteLength;
|
|
1678
1866
|
if (typeof Blob !== "undefined" && value instanceof Blob) return ESTIMATED_BINARY_OVERHEAD + value.size;
|
|
1679
1867
|
if (value instanceof Date) return 16;
|
|
1868
|
+
if (value instanceof RegExp) return ESTIMATED_OBJECT_OVERHEAD + estimateStringSize(value.source) + estimateStringSize(value.flags);
|
|
1680
1869
|
seen ??= /* @__PURE__ */ new WeakSet();
|
|
1681
1870
|
if (seen.has(value)) return ESTIMATED_ENTRY_OVERHEAD;
|
|
1682
1871
|
seen.add(value);
|
|
@@ -1700,10 +1889,11 @@ function estimateEncodedSize(value, seen, depth = 0) {
|
|
|
1700
1889
|
var ImportTableEntry = class {
|
|
1701
1890
|
session;
|
|
1702
1891
|
importId;
|
|
1892
|
+
pulling;
|
|
1703
1893
|
constructor(session, importId, pulling) {
|
|
1704
1894
|
this.session = session;
|
|
1705
1895
|
this.importId = importId;
|
|
1706
|
-
|
|
1896
|
+
this.pulling = pulling;
|
|
1707
1897
|
}
|
|
1708
1898
|
localRefcount = 0;
|
|
1709
1899
|
remoteRefcount = 1;
|
|
@@ -1734,7 +1924,7 @@ var ImportTableEntry = class {
|
|
|
1734
1924
|
}
|
|
1735
1925
|
async awaitResolution() {
|
|
1736
1926
|
if (!this.activePull) {
|
|
1737
|
-
this.session.sendPull(this.importId);
|
|
1927
|
+
if (!this.pulling) this.session.sendPull(this.importId);
|
|
1738
1928
|
this.activePull = Promise.withResolvers();
|
|
1739
1929
|
}
|
|
1740
1930
|
await this.activePull.promise;
|
|
@@ -1789,24 +1979,28 @@ var RpcImportHook = class RpcImportHook extends StubHook {
|
|
|
1789
1979
|
if (this.entry) return this.entry;
|
|
1790
1980
|
else throw new Error("This RpcImportHook was already disposed.");
|
|
1791
1981
|
}
|
|
1982
|
+
getEntryTakingOwnership(disposeOwned) {
|
|
1983
|
+
try {
|
|
1984
|
+
return this.getEntry();
|
|
1985
|
+
} catch (err) {
|
|
1986
|
+
disposeOwned();
|
|
1987
|
+
throw err;
|
|
1988
|
+
}
|
|
1989
|
+
}
|
|
1792
1990
|
call(path, args) {
|
|
1793
|
-
let entry = this.
|
|
1991
|
+
let entry = this.getEntryTakingOwnership(() => args.dispose());
|
|
1794
1992
|
if (entry.resolution) return entry.resolution.call(path, args);
|
|
1795
1993
|
else return entry.session.sendCall(entry.importId, path, args);
|
|
1796
1994
|
}
|
|
1797
1995
|
stream(path, args) {
|
|
1798
|
-
let entry = this.
|
|
1996
|
+
let entry = this.getEntryTakingOwnership(() => args.dispose());
|
|
1799
1997
|
if (entry.resolution) return entry.resolution.stream(path, args);
|
|
1800
1998
|
else return entry.session.sendStream(entry.importId, path, args);
|
|
1801
1999
|
}
|
|
1802
2000
|
map(path, captures, instructions) {
|
|
1803
|
-
let entry
|
|
1804
|
-
try {
|
|
1805
|
-
entry = this.getEntry();
|
|
1806
|
-
} catch (err) {
|
|
2001
|
+
let entry = this.getEntryTakingOwnership(() => {
|
|
1807
2002
|
for (let cap of captures) cap.dispose();
|
|
1808
|
-
|
|
1809
|
-
}
|
|
2003
|
+
});
|
|
1810
2004
|
if (entry.resolution) return entry.resolution.map(path, captures, instructions);
|
|
1811
2005
|
else return entry.session.sendMap(entry.importId, path, captures, instructions);
|
|
1812
2006
|
}
|
|
@@ -1960,6 +2154,7 @@ var RpcSessionImpl = class {
|
|
|
1960
2154
|
let autoRelease = exp.autoRelease;
|
|
1961
2155
|
++this.pullCount;
|
|
1962
2156
|
exp.pull = resolve().then((payload) => {
|
|
2157
|
+
if (this.exports[exportId] !== exp) return;
|
|
1963
2158
|
let value = Devaluator.devaluate(payload.value, void 0, this, payload, this.encodingLevel);
|
|
1964
2159
|
this.send([
|
|
1965
2160
|
"resolve",
|
|
@@ -1968,6 +2163,7 @@ var RpcSessionImpl = class {
|
|
|
1968
2163
|
]);
|
|
1969
2164
|
if (autoRelease) this.releaseExport(exportId, 1);
|
|
1970
2165
|
}, (error) => {
|
|
2166
|
+
if (this.exports[exportId] !== exp) return;
|
|
1971
2167
|
this.send([
|
|
1972
2168
|
"reject",
|
|
1973
2169
|
exportId,
|
|
@@ -1993,7 +2189,7 @@ var RpcSessionImpl = class {
|
|
|
1993
2189
|
}
|
|
1994
2190
|
}
|
|
1995
2191
|
getImport(hook) {
|
|
1996
|
-
if (hook instanceof RpcImportHook && hook.entry && hook.entry.session === this) return hook.entry.importId;
|
|
2192
|
+
if (hook instanceof RpcImportHook && hook.entry && hook.entry.session === this && !hook.entry.resolution) return hook.entry.importId;
|
|
1997
2193
|
else return;
|
|
1998
2194
|
}
|
|
1999
2195
|
importStub(idx) {
|
|
@@ -2067,32 +2263,52 @@ var RpcSessionImpl = class {
|
|
|
2067
2263
|
}
|
|
2068
2264
|
}
|
|
2069
2265
|
sendCall(id, path, args) {
|
|
2070
|
-
if (this.abortReason)
|
|
2266
|
+
if (this.abortReason) {
|
|
2267
|
+
args?.dispose();
|
|
2268
|
+
throw this.abortReason;
|
|
2269
|
+
}
|
|
2071
2270
|
let value = [
|
|
2072
2271
|
"pipeline",
|
|
2073
2272
|
id,
|
|
2074
2273
|
path
|
|
2075
2274
|
];
|
|
2076
2275
|
if (args) {
|
|
2077
|
-
let devalue
|
|
2276
|
+
let devalue;
|
|
2277
|
+
try {
|
|
2278
|
+
devalue = Devaluator.devaluate(args.value, void 0, this, args, this.encodingLevel);
|
|
2279
|
+
} catch (err) {
|
|
2280
|
+
args.dispose();
|
|
2281
|
+
throw err;
|
|
2282
|
+
}
|
|
2078
2283
|
value.push(devalue[0]);
|
|
2079
2284
|
}
|
|
2080
2285
|
this.send(["push", value]);
|
|
2286
|
+
args?.dispose();
|
|
2081
2287
|
let entry = new ImportTableEntry(this, this.imports.length, false);
|
|
2082
2288
|
this.imports.push(entry);
|
|
2083
2289
|
return new RpcImportHook(true, entry);
|
|
2084
2290
|
}
|
|
2085
2291
|
sendStream(id, path, args) {
|
|
2086
|
-
if (this.abortReason)
|
|
2292
|
+
if (this.abortReason) {
|
|
2293
|
+
args.dispose();
|
|
2294
|
+
throw this.abortReason;
|
|
2295
|
+
}
|
|
2087
2296
|
let value = [
|
|
2088
2297
|
"pipeline",
|
|
2089
2298
|
id,
|
|
2090
2299
|
path
|
|
2091
2300
|
];
|
|
2092
|
-
let devalue
|
|
2301
|
+
let devalue;
|
|
2302
|
+
try {
|
|
2303
|
+
devalue = Devaluator.devaluate(args.value, void 0, this, args, this.encodingLevel);
|
|
2304
|
+
} catch (err) {
|
|
2305
|
+
args.dispose();
|
|
2306
|
+
throw err;
|
|
2307
|
+
}
|
|
2093
2308
|
value.push(devalue[0]);
|
|
2094
2309
|
let msg = ["stream", value];
|
|
2095
2310
|
let size = this.send(msg);
|
|
2311
|
+
args.dispose();
|
|
2096
2312
|
if (size === void 0) size = estimateEncodedSize(msg);
|
|
2097
2313
|
let importId = this.imports.length;
|
|
2098
2314
|
let entry = new ImportTableEntry(this, importId, true);
|
|
@@ -2190,7 +2406,8 @@ var RpcSessionImpl = class {
|
|
|
2190
2406
|
if (msg instanceof Array) switch (msg[0]) {
|
|
2191
2407
|
case "push":
|
|
2192
2408
|
if (msg.length > 1) {
|
|
2193
|
-
let
|
|
2409
|
+
let payload = new Evaluator(this, this.encodingLevel).evaluate(msg[1]);
|
|
2410
|
+
let hook = new PayloadStubHook(payload);
|
|
2194
2411
|
hook.ignoreUnhandledRejections();
|
|
2195
2412
|
this.exports.push({
|
|
2196
2413
|
hook,
|
|
@@ -2201,7 +2418,8 @@ var RpcSessionImpl = class {
|
|
|
2201
2418
|
break;
|
|
2202
2419
|
case "stream":
|
|
2203
2420
|
if (msg.length > 1) {
|
|
2204
|
-
let
|
|
2421
|
+
let payload = new Evaluator(this, this.encodingLevel).evaluate(msg[1]);
|
|
2422
|
+
let hook = new PayloadStubHook(payload);
|
|
2205
2423
|
hook.ignoreUnhandledRejections();
|
|
2206
2424
|
let exportId = this.exports.length;
|
|
2207
2425
|
this.exports.push({
|
|
@@ -2236,13 +2454,14 @@ var RpcSessionImpl = class {
|
|
|
2236
2454
|
let importId = msg[1];
|
|
2237
2455
|
if (typeof importId == "number" && msg.length > 2) {
|
|
2238
2456
|
let imp = this.imports[importId];
|
|
2239
|
-
if (imp)
|
|
2240
|
-
|
|
2241
|
-
|
|
2242
|
-
|
|
2243
|
-
|
|
2244
|
-
|
|
2245
|
-
|
|
2457
|
+
if (imp) {
|
|
2458
|
+
if (msg[0] == "resolve") imp.resolve(new PayloadStubHook(new Evaluator(this, this.encodingLevel).evaluate(msg[2])));
|
|
2459
|
+
else {
|
|
2460
|
+
let payload = new Evaluator(this, this.encodingLevel).evaluate(msg[2]);
|
|
2461
|
+
payload.dispose();
|
|
2462
|
+
imp.resolve(new ErrorStubHook(payload.value));
|
|
2463
|
+
}
|
|
2464
|
+
} else if (msg[0] == "resolve") new Evaluator(this, this.encodingLevel).evaluate(msg[2]).dispose();
|
|
2246
2465
|
continue;
|
|
2247
2466
|
}
|
|
2248
2467
|
break;
|
|
@@ -2314,7 +2533,8 @@ var RpcSession$1 = class {
|
|
|
2314
2533
|
const MAX_CLOSE_REASON_BYTES = 123;
|
|
2315
2534
|
function newWebSocketRpcSession$1(webSocket, localMain, options) {
|
|
2316
2535
|
if (typeof webSocket === "string") webSocket = new WebSocket(webSocket);
|
|
2317
|
-
|
|
2536
|
+
let transport = new WebSocketTransport(webSocket);
|
|
2537
|
+
return new RpcSession$1(transport, localMain, options).getRemoteMain();
|
|
2318
2538
|
}
|
|
2319
2539
|
/**
|
|
2320
2540
|
* For use in Cloudflare Workers: Construct an HTTP response that starts a WebSocket RPC session
|
|
@@ -2351,12 +2571,13 @@ var WebSocketTransport = class {
|
|
|
2351
2571
|
});
|
|
2352
2572
|
}
|
|
2353
2573
|
webSocket.addEventListener("message", (event) => {
|
|
2354
|
-
if (this.#error) {} else if (typeof event.data === "string" || event.data instanceof ArrayBuffer)
|
|
2355
|
-
this.#receiveResolver
|
|
2356
|
-
|
|
2357
|
-
|
|
2358
|
-
|
|
2359
|
-
|
|
2574
|
+
if (this.#error) {} else if (typeof event.data === "string" || event.data instanceof ArrayBuffer) {
|
|
2575
|
+
if (this.#receiveResolver) {
|
|
2576
|
+
this.#receiveResolver(event.data);
|
|
2577
|
+
this.#receiveResolver = void 0;
|
|
2578
|
+
this.#receiveRejecter = void 0;
|
|
2579
|
+
} else this.#receiveQueue.push(event.data);
|
|
2580
|
+
} else this.#receivedError(/* @__PURE__ */ new TypeError("Received unexpected message type from WebSocket."));
|
|
2360
2581
|
});
|
|
2361
2582
|
webSocket.addEventListener("close", (event) => {
|
|
2362
2583
|
this.#receivedError(/* @__PURE__ */ new Error(`Peer closed WebSocket: ${event.code} ${event.reason}`));
|
|
@@ -2448,7 +2669,8 @@ function newHttpBatchRpcSession$1(urlOrRequest, options) {
|
|
|
2448
2669
|
let body = await response.text();
|
|
2449
2670
|
return body == "" ? [] : body.split("\n");
|
|
2450
2671
|
};
|
|
2451
|
-
|
|
2672
|
+
let transport = new BatchClientTransport(sendBatch);
|
|
2673
|
+
return new RpcSession$1(transport, void 0, options).getRemoteMain();
|
|
2452
2674
|
}
|
|
2453
2675
|
var BatchServerTransport = class {
|
|
2454
2676
|
constructor(batch) {
|
|
@@ -2491,7 +2713,8 @@ var BatchServerTransport = class {
|
|
|
2491
2713
|
async function newHttpBatchRpcResponse(request, localMain, options) {
|
|
2492
2714
|
if (request.method !== "POST") return new Response("This endpoint only accepts POST requests.", { status: 405 });
|
|
2493
2715
|
let body = await request.text();
|
|
2494
|
-
let
|
|
2716
|
+
let batch = body === "" ? [] : body.split("\n");
|
|
2717
|
+
let transport = new BatchServerTransport(batch);
|
|
2495
2718
|
let rpc = new RpcSession$1(transport, localMain, options);
|
|
2496
2719
|
await transport.whenAllReceived();
|
|
2497
2720
|
await rpc.drain();
|
|
@@ -2521,7 +2744,8 @@ async function nodeHttpBatchRpcResponse(request, response, localMain, options) {
|
|
|
2521
2744
|
});
|
|
2522
2745
|
request.on("error", reject);
|
|
2523
2746
|
});
|
|
2524
|
-
let
|
|
2747
|
+
let batch = body === "" ? [] : body.split("\n");
|
|
2748
|
+
let transport = new BatchServerTransport(batch);
|
|
2525
2749
|
let rpc = new RpcSession$1(transport, localMain, options);
|
|
2526
2750
|
await transport.whenAllReceived();
|
|
2527
2751
|
await rpc.drain();
|
|
@@ -2532,7 +2756,8 @@ async function nodeHttpBatchRpcResponse(request, response, localMain, options) {
|
|
|
2532
2756
|
//#endregion
|
|
2533
2757
|
//#region src/messageport.ts
|
|
2534
2758
|
function newMessagePortRpcSession$1(port, localMain, options) {
|
|
2535
|
-
|
|
2759
|
+
let transport = new MessagePortTransport(port);
|
|
2760
|
+
return new RpcSession$1(transport, localMain, options).getRemoteMain();
|
|
2536
2761
|
}
|
|
2537
2762
|
var MessagePortTransport = class {
|
|
2538
2763
|
encodingLevel = "structuredClonable";
|
|
@@ -2720,9 +2945,11 @@ var MapVariableHook = class extends StubHook {
|
|
|
2720
2945
|
else throwMapperBuilderUseError();
|
|
2721
2946
|
}
|
|
2722
2947
|
call(path, args) {
|
|
2948
|
+
args.dispose();
|
|
2723
2949
|
throwMapperBuilderUseError();
|
|
2724
2950
|
}
|
|
2725
2951
|
map(path, captures, instructions) {
|
|
2952
|
+
for (let cap of captures) cap.dispose();
|
|
2726
2953
|
throwMapperBuilderUseError();
|
|
2727
2954
|
}
|
|
2728
2955
|
pull() {
|
|
@@ -2780,7 +3007,8 @@ var MapApplicator = class {
|
|
|
2780
3007
|
}
|
|
2781
3008
|
};
|
|
2782
3009
|
function applyMapToElement(input, parent, owner, captures, instructions) {
|
|
2783
|
-
let
|
|
3010
|
+
let inputHook = new PayloadStubHook(RpcPayload.deepCopyFrom(input, parent, owner));
|
|
3011
|
+
let mapper = new MapApplicator(captures, inputHook);
|
|
2784
3012
|
try {
|
|
2785
3013
|
return mapper.apply(instructions);
|
|
2786
3014
|
} finally {
|
|
@@ -2813,9 +3041,10 @@ mapImpl.applyMap = (input, parent, owner, captures, instructions) => {
|
|
|
2813
3041
|
var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
2814
3042
|
state;
|
|
2815
3043
|
static create(stream) {
|
|
3044
|
+
let writer = stream.getWriter();
|
|
2816
3045
|
return new WritableStreamStubHook({
|
|
2817
3046
|
refcount: 1,
|
|
2818
|
-
writer
|
|
3047
|
+
writer,
|
|
2819
3048
|
closed: false
|
|
2820
3049
|
});
|
|
2821
3050
|
}
|
|
@@ -2833,13 +3062,12 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2833
3062
|
let state = this.getState();
|
|
2834
3063
|
if (path.length !== 1 || typeof path[0] !== "string") throw new Error("WritableStream stub only supports direct method calls");
|
|
2835
3064
|
const method = path[0];
|
|
2836
|
-
if (method !== "write" && method !== "close" && method !== "abort") {
|
|
2837
|
-
args.dispose();
|
|
2838
|
-
throw new Error(`Unknown WritableStream method: ${method}`);
|
|
2839
|
-
}
|
|
3065
|
+
if (method !== "write" && method !== "close" && method !== "abort") throw new Error(`Unknown WritableStream method: ${method}`);
|
|
2840
3066
|
if (method === "close" || method === "abort") state.closed = true;
|
|
2841
|
-
|
|
3067
|
+
let promise = method === "write" ? args.deliverStreamWrite(state.writer) : args.deliverCall(state.writer[method], state.writer);
|
|
3068
|
+
return new PromiseStubHook(promise.then((payload) => new PayloadStubHook(payload)));
|
|
2842
3069
|
} catch (err) {
|
|
3070
|
+
args.dispose();
|
|
2843
3071
|
return new ErrorStubHook(err);
|
|
2844
3072
|
}
|
|
2845
3073
|
}
|
|
@@ -2851,7 +3079,8 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2851
3079
|
return new ErrorStubHook(/* @__PURE__ */ new Error("Cannot access properties on a WritableStream stub"));
|
|
2852
3080
|
}
|
|
2853
3081
|
dup() {
|
|
2854
|
-
|
|
3082
|
+
let state = this.getState();
|
|
3083
|
+
return new WritableStreamStubHook(state, this);
|
|
2855
3084
|
}
|
|
2856
3085
|
pull() {
|
|
2857
3086
|
return Promise.reject(/* @__PURE__ */ new Error("Cannot pull a WritableStream stub"));
|
|
@@ -2869,9 +3098,9 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2869
3098
|
}
|
|
2870
3099
|
onBroken(callback) {}
|
|
2871
3100
|
};
|
|
2872
|
-
const INITIAL_WINDOW =
|
|
2873
|
-
const MAX_WINDOW =
|
|
2874
|
-
const MIN_WINDOW =
|
|
3101
|
+
const INITIAL_WINDOW = 262144;
|
|
3102
|
+
const MAX_WINDOW = 1073741824;
|
|
3103
|
+
const MIN_WINDOW = 65536;
|
|
2875
3104
|
const STARTUP_GROWTH_FACTOR = 2;
|
|
2876
3105
|
const STEADY_GROWTH_FACTOR = 1.25;
|
|
2877
3106
|
const DECAY_FACTOR = .9;
|