@idyl-sh/sdk 0.0.0-stage → 0.1.1

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.
@@ -0,0 +1,1200 @@
1
+ // wasm/pkg/computer_connection.js
2
+ var WorkerClient = class {
3
+ __destroy_into_raw() {
4
+ const ptr = this.__wbg_ptr;
5
+ this.__wbg_ptr = 0;
6
+ WorkerClientFinalization.unregister(this);
7
+ return ptr;
8
+ }
9
+ free() {
10
+ const ptr = this.__destroy_into_raw();
11
+ wasm.__wbg_workerclient_free(ptr, 0);
12
+ }
13
+ /**
14
+ * Drops a session stream.
15
+ * @param {number} computer
16
+ * @param {number} stream
17
+ */
18
+ abort(computer, stream) {
19
+ wasm.workerclient_abort(this.__wbg_ptr, computer, stream);
20
+ }
21
+ /**
22
+ * Ends a Computer connection.
23
+ * @param {number} computer
24
+ */
25
+ closeComputer(computer) {
26
+ wasm.workerclient_closeComputer(this.__wbg_ptr, computer);
27
+ }
28
+ /**
29
+ * Ends a service connection.
30
+ * @param {number} service
31
+ */
32
+ closeService(service) {
33
+ wasm.workerclient_closeService(this.__wbg_ptr, service);
34
+ }
35
+ /**
36
+ * Ends the dock gracefully.
37
+ */
38
+ close() {
39
+ wasm.workerclient_close(this.__wbg_ptr);
40
+ }
41
+ /**
42
+ * Finishes a session stream's write side.
43
+ * @param {number} computer
44
+ * @param {number} stream
45
+ */
46
+ finish(computer, stream) {
47
+ try {
48
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
49
+ wasm.workerclient_finish(retptr, this.__wbg_ptr, computer, stream);
50
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
51
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
52
+ if (r1) {
53
+ throw takeObject(r0);
54
+ }
55
+ } finally {
56
+ wasm.__wbindgen_add_to_stack_pointer(16);
57
+ }
58
+ }
59
+ /**
60
+ * Starts a dock: TLS to `server_name`, which must prove `edge_id`
61
+ * under `edge_roots`, presenting `chain` for `key`, with the admission
62
+ * lease `lease`.
63
+ * @param {WorkerKey} key
64
+ * @param {string} server_name
65
+ * @param {string} edge_id
66
+ * @param {Array<any>} edge_roots
67
+ * @param {Array<any>} chain
68
+ * @param {Uint8Array} lease
69
+ * @param {number} keepalive_ms
70
+ * @param {number} now
71
+ */
72
+ constructor(key, server_name, edge_id, edge_roots, chain, lease, keepalive_ms, now) {
73
+ try {
74
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
75
+ _assertClass(key, WorkerKey);
76
+ const ptr0 = passStringToWasm0(server_name, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
77
+ const len0 = WASM_VECTOR_LEN;
78
+ const ptr1 = passStringToWasm0(edge_id, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
79
+ const len1 = WASM_VECTOR_LEN;
80
+ const ptr2 = passArray8ToWasm0(lease, wasm.__wbindgen_export2);
81
+ const len2 = WASM_VECTOR_LEN;
82
+ wasm.workerclient_new(retptr, key.__wbg_ptr, ptr0, len0, ptr1, len1, addBorrowedObject(edge_roots), addBorrowedObject(chain), ptr2, len2, keepalive_ms, now);
83
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
84
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
85
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
86
+ if (r2) {
87
+ throw takeObject(r1);
88
+ }
89
+ this.__wbg_ptr = r0;
90
+ WorkerClientFinalization.register(this, this.__wbg_ptr, this);
91
+ return this;
92
+ } finally {
93
+ wasm.__wbindgen_add_to_stack_pointer(16);
94
+ heap[stack_pointer++] = void 0;
95
+ heap[stack_pointer++] = void 0;
96
+ }
97
+ }
98
+ /**
99
+ * The earliest time `tick` has work, or `undefined`.
100
+ * @returns {number | undefined}
101
+ */
102
+ nextDeadline() {
103
+ try {
104
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
105
+ wasm.workerclient_nextDeadline(retptr, this.__wbg_ptr);
106
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
107
+ var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
108
+ return r0 === 0 ? void 0 : r2;
109
+ } finally {
110
+ wasm.__wbindgen_add_to_stack_pointer(16);
111
+ }
112
+ }
113
+ /**
114
+ * The next event, or `undefined`.
115
+ * @returns {any}
116
+ */
117
+ nextEvent() {
118
+ const ret = wasm.workerclient_nextEvent(this.__wbg_ptr);
119
+ return takeObject(ret);
120
+ }
121
+ /**
122
+ * Opens a Computer connection on `lane` to the sandbox
123
+ * `host_pod`/`sequence` at Activation `epoch`. The endpoint must prove
124
+ * `computer` of `account` under `trust_domain` at an epoch of at least
125
+ * `min_epoch`, against `roots`.
126
+ * @param {number} lane
127
+ * @param {string} host_pod
128
+ * @param {bigint} sequence
129
+ * @param {bigint} epoch
130
+ * @param {Array<any>} roots
131
+ * @param {Array<any>} chain
132
+ * @param {string} trust_domain
133
+ * @param {string} account
134
+ * @param {string} computer
135
+ * @param {bigint} min_epoch
136
+ * @returns {number}
137
+ */
138
+ openComputer(lane, host_pod, sequence, epoch, roots, chain, trust_domain, account, computer, min_epoch) {
139
+ try {
140
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
141
+ const ptr0 = passStringToWasm0(host_pod, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
142
+ const len0 = WASM_VECTOR_LEN;
143
+ const ptr1 = passStringToWasm0(trust_domain, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
144
+ const len1 = WASM_VECTOR_LEN;
145
+ const ptr2 = passStringToWasm0(account, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
146
+ const len2 = WASM_VECTOR_LEN;
147
+ const ptr3 = passStringToWasm0(computer, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
148
+ const len3 = WASM_VECTOR_LEN;
149
+ wasm.workerclient_openComputer(retptr, this.__wbg_ptr, lane, ptr0, len0, sequence, epoch, addBorrowedObject(roots), addBorrowedObject(chain), ptr1, len1, ptr2, len2, ptr3, len3, min_epoch);
150
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
151
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
152
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
153
+ if (r2) {
154
+ throw takeObject(r1);
155
+ }
156
+ return r0 >>> 0;
157
+ } finally {
158
+ wasm.__wbindgen_add_to_stack_pointer(16);
159
+ heap[stack_pointer++] = void 0;
160
+ heap[stack_pointer++] = void 0;
161
+ }
162
+ }
163
+ /**
164
+ * Asks for a lane to the data dock named `principal`.
165
+ * @param {string} principal
166
+ * @returns {number}
167
+ */
168
+ openLane(principal) {
169
+ try {
170
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
171
+ const ptr0 = passStringToWasm0(principal, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
172
+ const len0 = WASM_VECTOR_LEN;
173
+ wasm.workerclient_openLane(retptr, this.__wbg_ptr, ptr0, len0);
174
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
175
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
176
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
177
+ if (r2) {
178
+ throw takeObject(r1);
179
+ }
180
+ return r0 >>> 0;
181
+ } finally {
182
+ wasm.__wbindgen_add_to_stack_pointer(16);
183
+ }
184
+ }
185
+ /**
186
+ * Asks for a client service lane to the Zone service named exactly
187
+ * `principal`.
188
+ * @param {string} principal
189
+ * @returns {number}
190
+ */
191
+ openServiceLane(principal) {
192
+ try {
193
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
194
+ const ptr0 = passStringToWasm0(principal, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
195
+ const len0 = WASM_VECTOR_LEN;
196
+ wasm.workerclient_openServiceLane(retptr, this.__wbg_ptr, ptr0, len0);
197
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
198
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
199
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
200
+ if (r2) {
201
+ throw takeObject(r1);
202
+ }
203
+ return r0 >>> 0;
204
+ } finally {
205
+ wasm.__wbindgen_add_to_stack_pointer(16);
206
+ }
207
+ }
208
+ /**
209
+ * Opens the one stream of the client service lane `lane`, whose header
210
+ * names the stream profile `profile`, and starts TLS with the service,
211
+ * which must prove exactly `principal` against `roots`.
212
+ * @param {number} lane
213
+ * @param {string} profile
214
+ * @param {Array<any>} roots
215
+ * @param {Array<any>} chain
216
+ * @param {string} principal
217
+ * @returns {number}
218
+ */
219
+ openService(lane, profile, roots, chain, principal) {
220
+ try {
221
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
222
+ const ptr0 = passStringToWasm0(profile, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
223
+ const len0 = WASM_VECTOR_LEN;
224
+ const ptr1 = passStringToWasm0(principal, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
225
+ const len1 = WASM_VECTOR_LEN;
226
+ wasm.workerclient_openService(retptr, this.__wbg_ptr, lane, ptr0, len0, addBorrowedObject(roots), addBorrowedObject(chain), ptr1, len1);
227
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
228
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
229
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
230
+ if (r2) {
231
+ throw takeObject(r1);
232
+ }
233
+ return r0 >>> 0;
234
+ } finally {
235
+ wasm.__wbindgen_add_to_stack_pointer(16);
236
+ heap[stack_pointer++] = void 0;
237
+ heap[stack_pointer++] = void 0;
238
+ }
239
+ }
240
+ /**
241
+ * Opens a session stream.
242
+ * @param {number} computer
243
+ * @returns {number}
244
+ */
245
+ openStream(computer) {
246
+ try {
247
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
248
+ wasm.workerclient_openStream(retptr, this.__wbg_ptr, computer);
249
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
250
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
251
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
252
+ if (r2) {
253
+ throw takeObject(r1);
254
+ }
255
+ return r0 >>> 0;
256
+ } finally {
257
+ wasm.__wbindgen_add_to_stack_pointer(16);
258
+ }
259
+ }
260
+ /**
261
+ * What the endpoint sent on a stream: a `Uint8Array`, `null` for
262
+ * nothing yet, `"end"` for its end, or `"broken"`.
263
+ * @param {number} computer
264
+ * @param {number} stream
265
+ * @returns {any}
266
+ */
267
+ read(computer, stream) {
268
+ const ret = wasm.workerclient_read(this.__wbg_ptr, computer, stream);
269
+ return takeObject(ret);
270
+ }
271
+ /**
272
+ * Takes in bytes the edge sent.
273
+ * @param {Uint8Array} bytes
274
+ * @param {number} now
275
+ */
276
+ receive(bytes, now) {
277
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
278
+ const len0 = WASM_VECTOR_LEN;
279
+ wasm.workerclient_receive(this.__wbg_ptr, ptr0, len0, now);
280
+ }
281
+ /**
282
+ * The plaintext a service connection received since the last read, as
283
+ * one batch, possibly empty; after a batch nothing more is read until
284
+ * `serviceRelease`.
285
+ * @param {number} service
286
+ * @returns {Uint8Array}
287
+ */
288
+ serviceRead(service) {
289
+ const ret = wasm.workerclient_serviceRead(this.__wbg_ptr, service);
290
+ return takeObject(ret);
291
+ }
292
+ /**
293
+ * The page has handled the last batch of a service connection; its
294
+ * stream is read again.
295
+ * @param {number} service
296
+ */
297
+ serviceRelease(service) {
298
+ wasm.workerclient_serviceRelease(this.__wbg_ptr, service);
299
+ }
300
+ /**
301
+ * Queues plaintext for a service connection.
302
+ * @param {number} service
303
+ * @param {Uint8Array} bytes
304
+ */
305
+ serviceWrite(service, bytes) {
306
+ try {
307
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
308
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
309
+ const len0 = WASM_VECTOR_LEN;
310
+ wasm.workerclient_serviceWrite(retptr, this.__wbg_ptr, service, ptr0, len0);
311
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
312
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
313
+ if (r1) {
314
+ throw takeObject(r0);
315
+ }
316
+ } finally {
317
+ wasm.__wbindgen_add_to_stack_pointer(16);
318
+ }
319
+ }
320
+ /**
321
+ * Takes the bytes to send to the edge.
322
+ * @returns {Uint8Array}
323
+ */
324
+ takeOutput() {
325
+ try {
326
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
327
+ wasm.workerclient_takeOutput(retptr, this.__wbg_ptr);
328
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
329
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
330
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
331
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
332
+ return v1;
333
+ } finally {
334
+ wasm.__wbindgen_add_to_stack_pointer(16);
335
+ }
336
+ }
337
+ /**
338
+ * Runs keepalive and deadlines.
339
+ * @param {number} now
340
+ */
341
+ tick(now) {
342
+ wasm.workerclient_tick(this.__wbg_ptr, now);
343
+ }
344
+ /**
345
+ * Queues bytes on a session stream.
346
+ * @param {number} computer
347
+ * @param {number} stream
348
+ * @param {Uint8Array} bytes
349
+ */
350
+ write(computer, stream, bytes) {
351
+ try {
352
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
353
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
354
+ const len0 = WASM_VECTOR_LEN;
355
+ wasm.workerclient_write(retptr, this.__wbg_ptr, computer, stream, ptr0, len0);
356
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
357
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
358
+ if (r1) {
359
+ throw takeObject(r0);
360
+ }
361
+ } finally {
362
+ wasm.__wbindgen_add_to_stack_pointer(16);
363
+ }
364
+ }
365
+ };
366
+ if (Symbol.dispose) WorkerClient.prototype[Symbol.dispose] = WorkerClient.prototype.free;
367
+ var WorkerKey = class {
368
+ __destroy_into_raw() {
369
+ const ptr = this.__wbg_ptr;
370
+ this.__wbg_ptr = 0;
371
+ WorkerKeyFinalization.unregister(this);
372
+ return ptr;
373
+ }
374
+ free() {
375
+ const ptr = this.__destroy_into_raw();
376
+ wasm.__wbg_workerkey_free(ptr, 0);
377
+ }
378
+ /**
379
+ * The PKCS#10 certificate signing request for the key, DER.
380
+ * @returns {Uint8Array}
381
+ */
382
+ certificateRequest() {
383
+ try {
384
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
385
+ wasm.workerkey_certificateRequest(retptr, this.__wbg_ptr);
386
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
387
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
388
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
389
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
390
+ return v1;
391
+ } finally {
392
+ wasm.__wbindgen_add_to_stack_pointer(16);
393
+ }
394
+ }
395
+ /**
396
+ * Generates a key from `crypto.getRandomValues`.
397
+ */
398
+ constructor() {
399
+ try {
400
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
401
+ wasm.workerkey_new(retptr);
402
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
403
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
404
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
405
+ if (r2) {
406
+ throw takeObject(r1);
407
+ }
408
+ this.__wbg_ptr = r0;
409
+ WorkerKeyFinalization.register(this, this.__wbg_ptr, this);
410
+ return this;
411
+ } finally {
412
+ wasm.__wbindgen_add_to_stack_pointer(16);
413
+ }
414
+ }
415
+ /**
416
+ * The raw Ed25519 public key.
417
+ * @returns {Uint8Array}
418
+ */
419
+ publicKey() {
420
+ try {
421
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
422
+ wasm.workerkey_publicKey(retptr, this.__wbg_ptr);
423
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
424
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
425
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
426
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
427
+ return v1;
428
+ } finally {
429
+ wasm.__wbindgen_add_to_stack_pointer(16);
430
+ }
431
+ }
432
+ };
433
+ if (Symbol.dispose) WorkerKey.prototype[Symbol.dispose] = WorkerKey.prototype.free;
434
+ function __wbg_get_imports() {
435
+ const import0 = {
436
+ __proto__: null,
437
+ __wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
438
+ const ret = Error(getStringFromWasm0(arg0, arg1));
439
+ return addHeapObject(ret);
440
+ },
441
+ __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
442
+ const ret = typeof getObject(arg0) === "function";
443
+ return ret;
444
+ },
445
+ __wbg___wbindgen_is_object_3c45d4f2dde4e749: function(arg0) {
446
+ const val = getObject(arg0);
447
+ const ret = typeof val === "object" && val !== null;
448
+ return ret;
449
+ },
450
+ __wbg___wbindgen_is_string_90b56bc79aad6f6c: function(arg0) {
451
+ const ret = typeof getObject(arg0) === "string";
452
+ return ret;
453
+ },
454
+ __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
455
+ const ret = getObject(arg0) === void 0;
456
+ return ret;
457
+ },
458
+ __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
459
+ throw new Error(getStringFromWasm0(arg0, arg1));
460
+ },
461
+ __wbg_call_187d372bd5fdd4aa: function() {
462
+ return handleError(function(arg0, arg1, arg2) {
463
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
464
+ return addHeapObject(ret);
465
+ }, arguments);
466
+ },
467
+ __wbg_crypto_38df2bab126b63dc: function(arg0) {
468
+ const ret = getObject(arg0).crypto;
469
+ return addHeapObject(ret);
470
+ },
471
+ __wbg_getRandomValues_c44a50d8cfdaebeb: function() {
472
+ return handleError(function(arg0, arg1) {
473
+ getObject(arg0).getRandomValues(getObject(arg1));
474
+ }, arguments);
475
+ },
476
+ __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
477
+ const ret = getObject(arg0)[arg1 >>> 0];
478
+ return addHeapObject(ret);
479
+ },
480
+ __wbg_instanceof_Uint8Array_828cef2aaacafc31: function(arg0) {
481
+ let result;
482
+ try {
483
+ result = getObject(arg0) instanceof Uint8Array;
484
+ } catch (_) {
485
+ result = false;
486
+ }
487
+ const ret = result;
488
+ return ret;
489
+ },
490
+ __wbg_length_7f3c00c40364105e: function(arg0) {
491
+ const ret = getObject(arg0).length;
492
+ return ret;
493
+ },
494
+ __wbg_length_d4bdea10311bd9cf: function(arg0) {
495
+ const ret = getObject(arg0).length;
496
+ return ret;
497
+ },
498
+ __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
499
+ const ret = getObject(arg0).msCrypto;
500
+ return addHeapObject(ret);
501
+ },
502
+ __wbg_new_617a8cdb8bb1130e: function() {
503
+ const ret = new Object();
504
+ return addHeapObject(ret);
505
+ },
506
+ __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
507
+ const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
508
+ return addHeapObject(ret);
509
+ },
510
+ __wbg_new_with_length_3da0ad195f6f63ba: function(arg0) {
511
+ const ret = new Uint8Array(arg0 >>> 0);
512
+ return addHeapObject(ret);
513
+ },
514
+ __wbg_node_84ea875411254db1: function(arg0) {
515
+ const ret = getObject(arg0).node;
516
+ return addHeapObject(ret);
517
+ },
518
+ __wbg_now_aa4ccb83129e9e55: function() {
519
+ const ret = Date.now();
520
+ return ret;
521
+ },
522
+ __wbg_now_e7c6795a7f81e10f: function(arg0) {
523
+ const ret = getObject(arg0).now();
524
+ return ret;
525
+ },
526
+ __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
527
+ const ret = getObject(arg0).performance;
528
+ return addHeapObject(ret);
529
+ },
530
+ __wbg_process_44c7a14e11e9f69e: function(arg0) {
531
+ const ret = getObject(arg0).process;
532
+ return addHeapObject(ret);
533
+ },
534
+ __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
535
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
536
+ },
537
+ __wbg_randomFillSync_6c25eac9869eb53c: function() {
538
+ return handleError(function(arg0, arg1) {
539
+ getObject(arg0).randomFillSync(takeObject(arg1));
540
+ }, arguments);
541
+ },
542
+ __wbg_require_b4edbdcf3e2a1ef0: function() {
543
+ return handleError(function() {
544
+ const ret = module.require;
545
+ return addHeapObject(ret);
546
+ }, arguments);
547
+ },
548
+ __wbg_set_145a351398b48c65: function() {
549
+ return handleError(function(arg0, arg1, arg2) {
550
+ const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
551
+ return ret;
552
+ }, arguments);
553
+ },
554
+ __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
555
+ const ret = typeof global === "undefined" ? null : global;
556
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
557
+ },
558
+ __wbg_static_accessor_GLOBAL_THIS_10fb7dc1ae063179: function() {
559
+ const ret = typeof globalThis === "undefined" ? null : globalThis;
560
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
561
+ },
562
+ __wbg_static_accessor_SELF_0b583911f537483a: function() {
563
+ const ret = typeof self === "undefined" ? null : self;
564
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
565
+ },
566
+ __wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {
567
+ const ret = typeof window === "undefined" ? null : window;
568
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
569
+ },
570
+ __wbg_subarray_002b94d5e13d1411: function(arg0, arg1, arg2) {
571
+ const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
572
+ return addHeapObject(ret);
573
+ },
574
+ __wbg_versions_276b2795b1c6a219: function(arg0) {
575
+ const ret = getObject(arg0).versions;
576
+ return addHeapObject(ret);
577
+ },
578
+ __wbindgen_generic_0000000000000001: function(arg0) {
579
+ const ret = arg0;
580
+ return addHeapObject(ret);
581
+ },
582
+ __wbindgen_generic_0000000000000002: function(arg0, arg1) {
583
+ const ret = getArrayU8FromWasm0(arg0, arg1);
584
+ return addHeapObject(ret);
585
+ },
586
+ __wbindgen_generic_0000000000000003: function(arg0, arg1) {
587
+ const ret = getStringFromWasm0(arg0, arg1);
588
+ return addHeapObject(ret);
589
+ },
590
+ __wbindgen_generic_0000000000000004: function(arg0) {
591
+ const ret = BigInt.asUintN(64, arg0);
592
+ return addHeapObject(ret);
593
+ },
594
+ __wbindgen_object_clone_ref: function(arg0) {
595
+ const ret = getObject(arg0);
596
+ return addHeapObject(ret);
597
+ },
598
+ __wbindgen_object_drop_ref: function(arg0) {
599
+ takeObject(arg0);
600
+ }
601
+ };
602
+ return {
603
+ __proto__: null,
604
+ "./computer_connection_bg.js": import0
605
+ };
606
+ }
607
+ var WorkerClientFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
608
+ }, unregister: () => {
609
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_workerclient_free(ptr, 1));
610
+ var WorkerKeyFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
611
+ }, unregister: () => {
612
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_workerkey_free(ptr, 1));
613
+ function addHeapObject(obj) {
614
+ if (heap_next === heap.length) heap.push(heap.length + 1);
615
+ const idx = heap_next;
616
+ heap_next = heap[idx];
617
+ heap[idx] = obj;
618
+ return idx;
619
+ }
620
+ function _assertClass(instance, klass) {
621
+ if (!(instance instanceof klass)) {
622
+ throw new Error(`expected instance of ${klass.name}`);
623
+ }
624
+ }
625
+ function addBorrowedObject(obj) {
626
+ if (stack_pointer == 1) throw new Error("out of js stack");
627
+ heap[--stack_pointer] = obj;
628
+ return stack_pointer;
629
+ }
630
+ function dropObject(idx) {
631
+ if (idx < 1028) return;
632
+ heap[idx] = heap_next;
633
+ heap_next = idx;
634
+ }
635
+ function getArrayU8FromWasm0(ptr, len) {
636
+ ptr = ptr >>> 0;
637
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
638
+ }
639
+ var cachedDataViewMemory0 = null;
640
+ function getDataViewMemory0() {
641
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
642
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
643
+ }
644
+ return cachedDataViewMemory0;
645
+ }
646
+ function getStringFromWasm0(ptr, len) {
647
+ return decodeText(ptr >>> 0, len);
648
+ }
649
+ var cachedUint8ArrayMemory0 = null;
650
+ function getUint8ArrayMemory0() {
651
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
652
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
653
+ }
654
+ return cachedUint8ArrayMemory0;
655
+ }
656
+ function getObject(idx) {
657
+ return heap[idx];
658
+ }
659
+ function handleError(f, args) {
660
+ try {
661
+ return f.apply(this, args);
662
+ } catch (e) {
663
+ wasm.__wbindgen_export(addHeapObject(e));
664
+ }
665
+ }
666
+ var heap = new Array(1024).fill(void 0);
667
+ heap.push(void 0, null, true, false);
668
+ var heap_next = heap.length;
669
+ function isLikeNone(x) {
670
+ return x === void 0 || x === null;
671
+ }
672
+ function passArray8ToWasm0(arg, malloc) {
673
+ const ptr = malloc(arg.length * 1, 1) >>> 0;
674
+ getUint8ArrayMemory0().set(arg, ptr / 1);
675
+ WASM_VECTOR_LEN = arg.length;
676
+ return ptr;
677
+ }
678
+ function passStringToWasm0(arg, malloc, realloc) {
679
+ if (realloc === void 0) {
680
+ const buf = cachedTextEncoder.encode(arg);
681
+ const ptr2 = malloc(buf.length, 1) >>> 0;
682
+ getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
683
+ WASM_VECTOR_LEN = buf.length;
684
+ return ptr2;
685
+ }
686
+ let len = arg.length;
687
+ let ptr = malloc(len, 1) >>> 0;
688
+ const mem = getUint8ArrayMemory0();
689
+ let offset = 0;
690
+ for (; offset < len; offset++) {
691
+ const code = arg.charCodeAt(offset);
692
+ if (code > 127) break;
693
+ mem[ptr + offset] = code;
694
+ }
695
+ if (offset !== len) {
696
+ if (offset !== 0) {
697
+ arg = arg.slice(offset);
698
+ }
699
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
700
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
701
+ const ret = cachedTextEncoder.encodeInto(arg, view);
702
+ offset += ret.written;
703
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
704
+ }
705
+ WASM_VECTOR_LEN = offset;
706
+ return ptr;
707
+ }
708
+ var stack_pointer = 1024;
709
+ function takeObject(idx) {
710
+ const ret = getObject(idx);
711
+ dropObject(idx);
712
+ return ret;
713
+ }
714
+ var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
715
+ cachedTextDecoder.decode();
716
+ var MAX_SAFARI_DECODE_BYTES = 2146435072;
717
+ var numBytesDecoded = 0;
718
+ function decodeText(ptr, len) {
719
+ numBytesDecoded += len;
720
+ if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
721
+ cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
722
+ cachedTextDecoder.decode();
723
+ numBytesDecoded = len;
724
+ }
725
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
726
+ }
727
+ var cachedTextEncoder = new TextEncoder();
728
+ if (!("encodeInto" in cachedTextEncoder)) {
729
+ cachedTextEncoder.encodeInto = function(arg, view) {
730
+ const buf = cachedTextEncoder.encode(arg);
731
+ view.set(buf);
732
+ return {
733
+ read: arg.length,
734
+ written: buf.length
735
+ };
736
+ };
737
+ }
738
+ var WASM_VECTOR_LEN = 0;
739
+ var wasm;
740
+ function __wbg_finalize_init(instance, module2) {
741
+ wasm = instance.exports;
742
+ cachedDataViewMemory0 = null;
743
+ cachedUint8ArrayMemory0 = null;
744
+ return wasm;
745
+ }
746
+ async function __wbg_load(module2, imports) {
747
+ if (typeof Response === "function" && module2 instanceof Response) {
748
+ if (!module2.ok) {
749
+ throw new Error(`failed to fetch Wasm: ${module2.status} ${module2.statusText} fetching '${module2.url}'`);
750
+ }
751
+ if (typeof WebAssembly.instantiateStreaming === "function") {
752
+ try {
753
+ return await WebAssembly.instantiateStreaming(module2, imports);
754
+ } catch (e) {
755
+ const validResponse = expectedResponseType(module2.type);
756
+ if (validResponse && module2.headers.get("Content-Type") !== "application/wasm") {
757
+ console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
758
+ } else {
759
+ throw e;
760
+ }
761
+ }
762
+ }
763
+ const bytes = await module2.arrayBuffer();
764
+ return await WebAssembly.instantiate(bytes, imports);
765
+ } else {
766
+ const instance = await WebAssembly.instantiate(module2, imports);
767
+ if (instance instanceof WebAssembly.Instance) {
768
+ return { instance, module: module2 };
769
+ } else {
770
+ return instance;
771
+ }
772
+ }
773
+ function expectedResponseType(type) {
774
+ switch (type) {
775
+ case "basic":
776
+ case "cors":
777
+ case "default":
778
+ return true;
779
+ }
780
+ return false;
781
+ }
782
+ }
783
+ async function __wbg_init(module_or_path) {
784
+ if (wasm !== void 0) return wasm;
785
+ if (module_or_path !== void 0) {
786
+ if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
787
+ ({ module_or_path } = module_or_path);
788
+ } else {
789
+ console.warn("using deprecated parameters for the initialization function; pass a single object instead");
790
+ }
791
+ }
792
+ if (module_or_path === void 0) {
793
+ module_or_path = new URL("computer_connection_bg.wasm", import.meta.url);
794
+ }
795
+ const imports = __wbg_get_imports();
796
+ if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
797
+ module_or_path = fetch(module_or_path);
798
+ }
799
+ const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
800
+ return __wbg_finalize_init(instance);
801
+ }
802
+
803
+ // src/computer-connection/worker.ts
804
+ var SUBPROTOCOL = "idyl-fallback.1";
805
+ function serveComputerConnections(scope) {
806
+ let key;
807
+ let nextDock = 1;
808
+ const docks = /* @__PURE__ */ new Map();
809
+ const post = (message, transfer = []) => {
810
+ scope.postMessage(message, transfer);
811
+ };
812
+ const turn = (id, dock) => {
813
+ const out = dock.client.takeOutput();
814
+ if (out.length > 0 && dock.socket.readyState === WebSocket.OPEN) {
815
+ dock.socket.send(out);
816
+ }
817
+ for (; ; ) {
818
+ const event = dock.client.nextEvent();
819
+ if (event === void 0) break;
820
+ forward(id, dock, event);
821
+ }
822
+ for (const [computer, streams] of dock.streams) {
823
+ for (const stream of streams) {
824
+ for (; ; ) {
825
+ const read = dock.client.read(computer, stream);
826
+ if (read === null) break;
827
+ if (read instanceof Uint8Array) {
828
+ post({ type: "data", dock: id, computer, stream, bytes: read }, [
829
+ read.buffer
830
+ ]);
831
+ continue;
832
+ }
833
+ streams.delete(stream);
834
+ post({
835
+ type: "stream-ended",
836
+ dock: id,
837
+ computer,
838
+ stream,
839
+ broken: read === "broken"
840
+ });
841
+ break;
842
+ }
843
+ }
844
+ }
845
+ for (const service of dock.services) {
846
+ const read = dock.client.serviceRead(service);
847
+ if (read.length > 0) {
848
+ post({ type: "service-data", dock: id, service, bytes: read }, [
849
+ read.buffer
850
+ ]);
851
+ }
852
+ }
853
+ const more = dock.client.takeOutput();
854
+ if (more.length > 0 && dock.socket.readyState === WebSocket.OPEN) {
855
+ dock.socket.send(more);
856
+ }
857
+ schedule(id, dock);
858
+ };
859
+ const schedule = (id, dock) => {
860
+ if (dock.timer !== void 0) clearTimeout(dock.timer);
861
+ dock.timer = void 0;
862
+ const deadline = dock.client.nextDeadline();
863
+ if (deadline === void 0) return;
864
+ dock.timer = setTimeout(
865
+ () => {
866
+ dock.timer = void 0;
867
+ dock.client.tick(Date.now());
868
+ turn(id, dock);
869
+ },
870
+ Math.max(0, deadline - Date.now())
871
+ );
872
+ };
873
+ const forward = (id, dock, event) => {
874
+ const text = (value) => typeof value === "string" ? value : "";
875
+ const num = (value) => typeof value === "number" ? value : 0;
876
+ switch (event["type"]) {
877
+ case "docked":
878
+ post({
879
+ type: "docked",
880
+ dock: id,
881
+ serviceLaneProfile: text(event["serviceLaneProfile"])
882
+ });
883
+ return;
884
+ case "service-established":
885
+ post({
886
+ type: "service-established",
887
+ dock: id,
888
+ service: num(event["service"])
889
+ });
890
+ return;
891
+ case "service-ended": {
892
+ const service = num(event["service"]);
893
+ const read = dock.client.serviceRead(service);
894
+ if (read.length > 0) {
895
+ post({ type: "service-data", dock: id, service, bytes: read }, [
896
+ read.buffer
897
+ ]);
898
+ }
899
+ dock.services.delete(service);
900
+ dock.client.closeService(service);
901
+ post({
902
+ type: "service-ended",
903
+ dock: id,
904
+ service,
905
+ reason: text(event["reason"])
906
+ });
907
+ return;
908
+ }
909
+ case "drain":
910
+ post({ type: "drain", dock: id, reason: text(event["reason"]) });
911
+ return;
912
+ case "edge-ended": {
913
+ docks.delete(id);
914
+ if (dock.timer !== void 0) clearTimeout(dock.timer);
915
+ const retry = event["retryAfterMs"];
916
+ post({
917
+ type: "dock-ended",
918
+ dock: id,
919
+ reason: text(event["reason"]),
920
+ ...typeof retry === "number" ? { retryAfterMs: retry } : {}
921
+ });
922
+ dock.socket.close(1e3);
923
+ return;
924
+ }
925
+ case "lane-ready":
926
+ post({ type: "lane-ready", dock: id, lane: num(event["lane"]) });
927
+ return;
928
+ case "lane-ended":
929
+ post({
930
+ type: "lane-ended",
931
+ dock: id,
932
+ lane: num(event["lane"]),
933
+ reason: text(event["reason"])
934
+ });
935
+ return;
936
+ case "computer-established":
937
+ post({
938
+ type: "computer-established",
939
+ dock: id,
940
+ computer: num(event["computer"]),
941
+ epoch: String(event["epoch"])
942
+ });
943
+ return;
944
+ case "computer-ended": {
945
+ const computer = num(event["computer"]);
946
+ dock.streams.delete(computer);
947
+ const refusal = event["refusal"];
948
+ post({
949
+ type: "computer-ended",
950
+ dock: id,
951
+ computer,
952
+ reason: text(event["reason"]),
953
+ ...typeof refusal === "number" ? { refusal } : {}
954
+ });
955
+ return;
956
+ }
957
+ default:
958
+ return;
959
+ }
960
+ };
961
+ const openDock = (request) => {
962
+ if (key === void 0) throw new Error("the worker has not started");
963
+ const client = new WorkerClient(
964
+ key,
965
+ request.serverName,
966
+ request.edgeId,
967
+ [...request.edgeRoots],
968
+ [...request.chain],
969
+ request.lease,
970
+ request.keepaliveMs,
971
+ Date.now()
972
+ );
973
+ const socket = new WebSocket(request.url, SUBPROTOCOL);
974
+ socket.binaryType = "arraybuffer";
975
+ const id = nextDock++;
976
+ const dock = {
977
+ client,
978
+ socket,
979
+ streams: /* @__PURE__ */ new Map(),
980
+ services: /* @__PURE__ */ new Set(),
981
+ timer: void 0
982
+ };
983
+ docks.set(id, dock);
984
+ socket.addEventListener("open", () => {
985
+ turn(id, dock);
986
+ });
987
+ socket.addEventListener("message", (event) => {
988
+ if (!(event.data instanceof ArrayBuffer)) {
989
+ socket.close(1003);
990
+ return;
991
+ }
992
+ client.receive(new Uint8Array(event.data), Date.now());
993
+ turn(id, dock);
994
+ });
995
+ socket.addEventListener("close", () => {
996
+ if (dock.timer !== void 0) clearTimeout(dock.timer);
997
+ if (docks.delete(id)) {
998
+ post({ type: "dock-ended", dock: id, reason: "connection closed" });
999
+ }
1000
+ });
1001
+ return id;
1002
+ };
1003
+ const docked = (id) => {
1004
+ const dock = docks.get(id);
1005
+ if (dock === void 0) throw new Error("no such dock");
1006
+ return dock;
1007
+ };
1008
+ const handle = async (request) => {
1009
+ switch (request.type) {
1010
+ case "start": {
1011
+ await __wbg_init({ module_or_path: request.module });
1012
+ key = new WorkerKey();
1013
+ post({
1014
+ type: "key",
1015
+ certificateRequest: key.certificateRequest(),
1016
+ publicKey: key.publicKey()
1017
+ });
1018
+ return void 0;
1019
+ }
1020
+ case "dock":
1021
+ return openDock(request);
1022
+ case "close-dock": {
1023
+ const dock = docked(request.dock);
1024
+ dock.client.close();
1025
+ turn(request.dock, dock);
1026
+ return void 0;
1027
+ }
1028
+ case "open-lane": {
1029
+ const dock = docked(request.dock);
1030
+ const lane = dock.client.openLane(request.principal);
1031
+ turn(request.dock, dock);
1032
+ return lane;
1033
+ }
1034
+ case "open-computer": {
1035
+ const dock = docked(request.dock);
1036
+ const computer = dock.client.openComputer(
1037
+ request.lane,
1038
+ request.hostPod,
1039
+ BigInt(request.sequence),
1040
+ BigInt(request.epoch),
1041
+ [...request.roots],
1042
+ [...request.chain],
1043
+ request.trustDomain,
1044
+ request.account,
1045
+ request.computer,
1046
+ BigInt(request.minEpoch)
1047
+ );
1048
+ dock.streams.set(computer, /* @__PURE__ */ new Set());
1049
+ turn(request.dock, dock);
1050
+ return computer;
1051
+ }
1052
+ case "open-service-lane": {
1053
+ const dock = docked(request.dock);
1054
+ const lane = dock.client.openServiceLane(request.principal);
1055
+ turn(request.dock, dock);
1056
+ return lane;
1057
+ }
1058
+ case "open-service": {
1059
+ const dock = docked(request.dock);
1060
+ const service = dock.client.openService(
1061
+ request.lane,
1062
+ request.profile,
1063
+ [...request.roots],
1064
+ [...request.chain],
1065
+ request.principal
1066
+ );
1067
+ dock.services.add(service);
1068
+ turn(request.dock, dock);
1069
+ return service;
1070
+ }
1071
+ case "service-write": {
1072
+ const dock = docked(request.dock);
1073
+ dock.client.serviceWrite(request.service, request.bytes);
1074
+ turn(request.dock, dock);
1075
+ return void 0;
1076
+ }
1077
+ case "service-release": {
1078
+ const dock = docked(request.dock);
1079
+ dock.client.serviceRelease(request.service);
1080
+ turn(request.dock, dock);
1081
+ return void 0;
1082
+ }
1083
+ case "close-service": {
1084
+ const dock = docked(request.dock);
1085
+ dock.client.closeService(request.service);
1086
+ turn(request.dock, dock);
1087
+ return void 0;
1088
+ }
1089
+ case "close-computer": {
1090
+ const dock = docked(request.dock);
1091
+ dock.client.closeComputer(request.computer);
1092
+ dock.streams.delete(request.computer);
1093
+ turn(request.dock, dock);
1094
+ return void 0;
1095
+ }
1096
+ case "open-stream": {
1097
+ const dock = docked(request.dock);
1098
+ const stream = dock.client.openStream(request.computer);
1099
+ dock.streams.get(request.computer)?.add(stream);
1100
+ return stream;
1101
+ }
1102
+ case "write": {
1103
+ const dock = docked(request.dock);
1104
+ dock.client.write(request.computer, request.stream, request.bytes);
1105
+ turn(request.dock, dock);
1106
+ return void 0;
1107
+ }
1108
+ case "finish": {
1109
+ const dock = docked(request.dock);
1110
+ dock.client.finish(request.computer, request.stream);
1111
+ turn(request.dock, dock);
1112
+ return void 0;
1113
+ }
1114
+ case "abort": {
1115
+ const dock = docked(request.dock);
1116
+ dock.client.abort(request.computer, request.stream);
1117
+ dock.streams.get(request.computer)?.delete(request.stream);
1118
+ turn(request.dock, dock);
1119
+ return void 0;
1120
+ }
1121
+ }
1122
+ };
1123
+ scope.addEventListener("message", (event) => {
1124
+ const request = event.data;
1125
+ handle(request).then(
1126
+ (value) => {
1127
+ post({ type: "reply", ref: request.ref, value });
1128
+ },
1129
+ (error) => {
1130
+ post({
1131
+ type: "reply",
1132
+ ref: request.ref,
1133
+ error: error instanceof Error ? error.message : "request failed"
1134
+ });
1135
+ }
1136
+ );
1137
+ });
1138
+ }
1139
+
1140
+ // src/computer-connection/in-thread.ts
1141
+ var compiled;
1142
+ async function connectInThisThread() {
1143
+ compiled ??= compileConnection().catch((error) => {
1144
+ compiled = void 0;
1145
+ throw error;
1146
+ });
1147
+ const module2 = await compiled;
1148
+ const { page, connection } = messagePorts();
1149
+ serveComputerConnections(connection);
1150
+ return { worker: page, module: module2 };
1151
+ }
1152
+ async function compileConnection() {
1153
+ const location = new URL("./computer-connection.wasm", import.meta.url);
1154
+ if (location.protocol !== "file:") {
1155
+ const response = await fetch(location);
1156
+ if (!response.ok) {
1157
+ throw new TypeError("the Computer connection module cannot be read");
1158
+ }
1159
+ return await WebAssembly.compile(await response.arrayBuffer());
1160
+ }
1161
+ const host = globalThis.process;
1162
+ const fs = host?.getBuiltinModule?.("node:fs");
1163
+ if (fs === void 0) {
1164
+ throw new TypeError("the Computer connection module cannot be read");
1165
+ }
1166
+ return await WebAssembly.compile(fs.readFileSync(location));
1167
+ }
1168
+ function messagePorts() {
1169
+ const toConnection = /* @__PURE__ */ new Set();
1170
+ const toPage = /* @__PURE__ */ new Set();
1171
+ const deliver = (listeners, data) => {
1172
+ queueMicrotask(() => {
1173
+ for (const listener of listeners) {
1174
+ listener({ data });
1175
+ }
1176
+ });
1177
+ };
1178
+ return {
1179
+ page: {
1180
+ postMessage: (message) => {
1181
+ deliver(toConnection, message);
1182
+ },
1183
+ addEventListener: (_type, listener) => {
1184
+ toPage.add(listener);
1185
+ }
1186
+ },
1187
+ connection: {
1188
+ postMessage: (message) => {
1189
+ deliver(toPage, message);
1190
+ },
1191
+ addEventListener: (_type, listener) => {
1192
+ toConnection.add(listener);
1193
+ }
1194
+ }
1195
+ };
1196
+ }
1197
+
1198
+ export { connectInThisThread, serveComputerConnections };
1199
+ //# sourceMappingURL=computer-connection.js.map
1200
+ //# sourceMappingURL=computer-connection.js.map