@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.
- package/LICENSE +202 -0
- package/README.md +213 -2
- package/dist/computer-connection.d.ts +259 -0
- package/dist/computer-connection.js +1200 -0
- package/dist/computer-connection.js.map +1 -0
- package/dist/computer-connection.wasm +0 -0
- package/dist/index.cjs +15957 -0
- package/dist/index.cjs.map +1 -0
- package/dist/index.d.cts +5500 -0
- package/dist/index.d.ts +5500 -0
- package/dist/index.js +15880 -0
- package/dist/index.js.map +1 -0
- package/package.json +105 -4
|
@@ -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
|