@almadar/kernel 18.0.0 → 19.0.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.
@@ -0,0 +1,3214 @@
1
+ /* @ts-self-types="./orbital_wasm.d.ts" */
2
+
3
+ /**
4
+ * The encrypted credential store for a host whose rows answer asynchronously: the host lists its rows and `load`s them,
5
+ * runs an operation, then applies `takeWrites()` to its medium in order. See `credentials::VaultApi`.
6
+ */
7
+ export class CredentialVault {
8
+ __destroy_into_raw() {
9
+ const ptr = this.__wbg_ptr;
10
+ this.__wbg_ptr = 0;
11
+ CredentialVaultFinalization.unregister(this);
12
+ return ptr;
13
+ }
14
+ free() {
15
+ const ptr = this.__destroy_into_raw();
16
+ wasm.__wbg_credentialvault_free(ptr, 0);
17
+ }
18
+ /**
19
+ * @param {number} ticket
20
+ * @returns {boolean}
21
+ */
22
+ connectAbandon(ticket) {
23
+ const ret = wasm.credentialvault_connectAbandon(this.__wbg_ptr, ticket);
24
+ if (ret[2]) {
25
+ throw takeFromExternrefTable0(ret[1]);
26
+ }
27
+ return ret[0] !== 0;
28
+ }
29
+ /**
30
+ * @param {string} grant_json
31
+ * @returns {string}
32
+ */
33
+ connectBegin(grant_json) {
34
+ let deferred3_0;
35
+ let deferred3_1;
36
+ try {
37
+ const ptr0 = passStringToWasm0(grant_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
38
+ const len0 = WASM_VECTOR_LEN;
39
+ const ret = wasm.credentialvault_connectBegin(this.__wbg_ptr, ptr0, len0);
40
+ var ptr2 = ret[0];
41
+ var len2 = ret[1];
42
+ if (ret[3]) {
43
+ ptr2 = 0; len2 = 0;
44
+ throw takeFromExternrefTable0(ret[2]);
45
+ }
46
+ deferred3_0 = ptr2;
47
+ deferred3_1 = len2;
48
+ return getStringFromWasm0(ptr2, len2);
49
+ } finally {
50
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
51
+ }
52
+ }
53
+ /**
54
+ * @param {number} ticket
55
+ * @param {number} status
56
+ * @param {string} body
57
+ * @returns {string}
58
+ */
59
+ connectFinish(ticket, status, body) {
60
+ let deferred3_0;
61
+ let deferred3_1;
62
+ try {
63
+ const ptr0 = passStringToWasm0(body, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
64
+ const len0 = WASM_VECTOR_LEN;
65
+ const ret = wasm.credentialvault_connectFinish(this.__wbg_ptr, ticket, status, ptr0, len0);
66
+ var ptr2 = ret[0];
67
+ var len2 = ret[1];
68
+ if (ret[3]) {
69
+ ptr2 = 0; len2 = 0;
70
+ throw takeFromExternrefTable0(ret[2]);
71
+ }
72
+ deferred3_0 = ptr2;
73
+ deferred3_1 = len2;
74
+ return getStringFromWasm0(ptr2, len2);
75
+ } finally {
76
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
77
+ }
78
+ }
79
+ /**
80
+ * @returns {boolean}
81
+ */
82
+ get enabled() {
83
+ const ret = wasm.credentialvault_enabled(this.__wbg_ptr);
84
+ return ret !== 0;
85
+ }
86
+ /**
87
+ * @param {string | null} [principal]
88
+ * @returns {string}
89
+ */
90
+ entries(principal) {
91
+ let deferred3_0;
92
+ let deferred3_1;
93
+ try {
94
+ var ptr0 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
95
+ var len0 = WASM_VECTOR_LEN;
96
+ const ret = wasm.credentialvault_entries(this.__wbg_ptr, ptr0, len0);
97
+ var ptr2 = ret[0];
98
+ var len2 = ret[1];
99
+ if (ret[3]) {
100
+ ptr2 = 0; len2 = 0;
101
+ throw takeFromExternrefTable0(ret[2]);
102
+ }
103
+ deferred3_0 = ptr2;
104
+ deferred3_1 = len2;
105
+ return getStringFromWasm0(ptr2, len2);
106
+ } finally {
107
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
108
+ }
109
+ }
110
+ /**
111
+ * @param {string} name
112
+ * @param {string | null} [principal]
113
+ * @returns {string | undefined}
114
+ */
115
+ label(name, principal) {
116
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
117
+ const len0 = WASM_VECTOR_LEN;
118
+ var ptr1 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
119
+ var len1 = WASM_VECTOR_LEN;
120
+ const ret = wasm.credentialvault_label(this.__wbg_ptr, ptr0, len0, ptr1, len1);
121
+ if (ret[3]) {
122
+ throw takeFromExternrefTable0(ret[2]);
123
+ }
124
+ let v3;
125
+ if (ret[0] !== 0) {
126
+ v3 = getStringFromWasm0(ret[0], ret[1]).slice();
127
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
128
+ }
129
+ return v3;
130
+ }
131
+ /**
132
+ * @returns {string}
133
+ */
134
+ listing() {
135
+ let deferred2_0;
136
+ let deferred2_1;
137
+ try {
138
+ const ret = wasm.credentialvault_listing(this.__wbg_ptr);
139
+ var ptr1 = ret[0];
140
+ var len1 = ret[1];
141
+ if (ret[3]) {
142
+ ptr1 = 0; len1 = 0;
143
+ throw takeFromExternrefTable0(ret[2]);
144
+ }
145
+ deferred2_0 = ptr1;
146
+ deferred2_1 = len1;
147
+ return getStringFromWasm0(ptr1, len1);
148
+ } finally {
149
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
150
+ }
151
+ }
152
+ /**
153
+ * @param {string} rows_json
154
+ * @returns {number}
155
+ */
156
+ load(rows_json) {
157
+ const ptr0 = passStringToWasm0(rows_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
158
+ const len0 = WASM_VECTOR_LEN;
159
+ const ret = wasm.credentialvault_load(this.__wbg_ptr, ptr0, len0);
160
+ if (ret[2]) {
161
+ throw takeFromExternrefTable0(ret[1]);
162
+ }
163
+ return ret[0] >>> 0;
164
+ }
165
+ /**
166
+ * @param {string | null} [master_key]
167
+ * @param {string | null} [previous_key]
168
+ */
169
+ constructor(master_key, previous_key) {
170
+ var ptr0 = isLikeNone(master_key) ? 0 : passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
171
+ var len0 = WASM_VECTOR_LEN;
172
+ var ptr1 = isLikeNone(previous_key) ? 0 : passStringToWasm0(previous_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
173
+ var len1 = WASM_VECTOR_LEN;
174
+ const ret = wasm.credentialvault_new(ptr0, len0, ptr1, len1);
175
+ if (ret[2]) {
176
+ throw takeFromExternrefTable0(ret[1]);
177
+ }
178
+ this.__wbg_ptr = ret[0];
179
+ CredentialVaultFinalization.register(this, this.__wbg_ptr, this);
180
+ return this;
181
+ }
182
+ /**
183
+ * @param {string} name
184
+ * @param {string} value
185
+ * @param {string | null} [principal]
186
+ * @param {string | null} [label]
187
+ * @returns {string}
188
+ */
189
+ persist(name, value, principal, label) {
190
+ let deferred6_0;
191
+ let deferred6_1;
192
+ try {
193
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
194
+ const len0 = WASM_VECTOR_LEN;
195
+ const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
196
+ const len1 = WASM_VECTOR_LEN;
197
+ var ptr2 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
198
+ var len2 = WASM_VECTOR_LEN;
199
+ var ptr3 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
200
+ var len3 = WASM_VECTOR_LEN;
201
+ const ret = wasm.credentialvault_persist(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
202
+ var ptr5 = ret[0];
203
+ var len5 = ret[1];
204
+ if (ret[3]) {
205
+ ptr5 = 0; len5 = 0;
206
+ throw takeFromExternrefTable0(ret[2]);
207
+ }
208
+ deferred6_0 = ptr5;
209
+ deferred6_1 = len5;
210
+ return getStringFromWasm0(ptr5, len5);
211
+ } finally {
212
+ wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
213
+ }
214
+ }
215
+ /**
216
+ * @param {string} name
217
+ * @param {string | null} [principal]
218
+ * @returns {string}
219
+ */
220
+ refreshBegin(name, principal) {
221
+ let deferred4_0;
222
+ let deferred4_1;
223
+ try {
224
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
225
+ const len0 = WASM_VECTOR_LEN;
226
+ var ptr1 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
227
+ var len1 = WASM_VECTOR_LEN;
228
+ const ret = wasm.credentialvault_refreshBegin(this.__wbg_ptr, ptr0, len0, ptr1, len1);
229
+ var ptr3 = ret[0];
230
+ var len3 = ret[1];
231
+ if (ret[3]) {
232
+ ptr3 = 0; len3 = 0;
233
+ throw takeFromExternrefTable0(ret[2]);
234
+ }
235
+ deferred4_0 = ptr3;
236
+ deferred4_1 = len3;
237
+ return getStringFromWasm0(ptr3, len3);
238
+ } finally {
239
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
240
+ }
241
+ }
242
+ /**
243
+ * @param {string} name
244
+ * @param {string | null} [principal]
245
+ * @returns {boolean}
246
+ */
247
+ remove(name, principal) {
248
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
249
+ const len0 = WASM_VECTOR_LEN;
250
+ var ptr1 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
251
+ var len1 = WASM_VECTOR_LEN;
252
+ const ret = wasm.credentialvault_remove(this.__wbg_ptr, ptr0, len0, ptr1, len1);
253
+ if (ret[2]) {
254
+ throw takeFromExternrefTable0(ret[1]);
255
+ }
256
+ return ret[0] !== 0;
257
+ }
258
+ /**
259
+ * @param {string} name
260
+ * @param {string} value
261
+ * @param {string | null} [principal]
262
+ * @returns {string}
263
+ */
264
+ replace(name, value, principal) {
265
+ let deferred5_0;
266
+ let deferred5_1;
267
+ try {
268
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
269
+ const len0 = WASM_VECTOR_LEN;
270
+ const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
271
+ const len1 = WASM_VECTOR_LEN;
272
+ var ptr2 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
273
+ var len2 = WASM_VECTOR_LEN;
274
+ const ret = wasm.credentialvault_replace(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
275
+ var ptr4 = ret[0];
276
+ var len4 = ret[1];
277
+ if (ret[3]) {
278
+ ptr4 = 0; len4 = 0;
279
+ throw takeFromExternrefTable0(ret[2]);
280
+ }
281
+ deferred5_0 = ptr4;
282
+ deferred5_1 = len4;
283
+ return getStringFromWasm0(ptr4, len4);
284
+ } finally {
285
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
286
+ }
287
+ }
288
+ /**
289
+ * @param {string} name
290
+ * @param {string | null} [principal]
291
+ * @returns {string | undefined}
292
+ */
293
+ resolve(name, principal) {
294
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
295
+ const len0 = WASM_VECTOR_LEN;
296
+ var ptr1 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
297
+ var len1 = WASM_VECTOR_LEN;
298
+ const ret = wasm.credentialvault_resolve(this.__wbg_ptr, ptr0, len0, ptr1, len1);
299
+ if (ret[3]) {
300
+ throw takeFromExternrefTable0(ret[2]);
301
+ }
302
+ let v3;
303
+ if (ret[0] !== 0) {
304
+ v3 = getStringFromWasm0(ret[0], ret[1]).slice();
305
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
306
+ }
307
+ return v3;
308
+ }
309
+ /**
310
+ * @returns {string}
311
+ */
312
+ rotate() {
313
+ let deferred2_0;
314
+ let deferred2_1;
315
+ try {
316
+ const ret = wasm.credentialvault_rotate(this.__wbg_ptr);
317
+ var ptr1 = ret[0];
318
+ var len1 = ret[1];
319
+ if (ret[3]) {
320
+ ptr1 = 0; len1 = 0;
321
+ throw takeFromExternrefTable0(ret[2]);
322
+ }
323
+ deferred2_0 = ptr1;
324
+ deferred2_1 = len1;
325
+ return getStringFromWasm0(ptr1, len1);
326
+ } finally {
327
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
328
+ }
329
+ }
330
+ /**
331
+ * @param {string} service
332
+ * @param {string} name
333
+ * @param {string} value
334
+ * @param {string | null} [principal]
335
+ * @param {string | null} [label]
336
+ * @returns {string}
337
+ */
338
+ set(service, name, value, principal, label) {
339
+ let deferred7_0;
340
+ let deferred7_1;
341
+ try {
342
+ const ptr0 = passStringToWasm0(service, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
343
+ const len0 = WASM_VECTOR_LEN;
344
+ const ptr1 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
345
+ const len1 = WASM_VECTOR_LEN;
346
+ const ptr2 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
347
+ const len2 = WASM_VECTOR_LEN;
348
+ var ptr3 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
349
+ var len3 = WASM_VECTOR_LEN;
350
+ var ptr4 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
351
+ var len4 = WASM_VECTOR_LEN;
352
+ const ret = wasm.credentialvault_set(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
353
+ var ptr6 = ret[0];
354
+ var len6 = ret[1];
355
+ if (ret[3]) {
356
+ ptr6 = 0; len6 = 0;
357
+ throw takeFromExternrefTable0(ret[2]);
358
+ }
359
+ deferred7_0 = ptr6;
360
+ deferred7_1 = len6;
361
+ return getStringFromWasm0(ptr6, len6);
362
+ } finally {
363
+ wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
364
+ }
365
+ }
366
+ /**
367
+ * @returns {string}
368
+ */
369
+ snapshotEnv() {
370
+ let deferred2_0;
371
+ let deferred2_1;
372
+ try {
373
+ const ret = wasm.credentialvault_snapshotEnv(this.__wbg_ptr);
374
+ var ptr1 = ret[0];
375
+ var len1 = ret[1];
376
+ if (ret[3]) {
377
+ ptr1 = 0; len1 = 0;
378
+ throw takeFromExternrefTable0(ret[2]);
379
+ }
380
+ deferred2_0 = ptr1;
381
+ deferred2_1 = len1;
382
+ return getStringFromWasm0(ptr1, len1);
383
+ } finally {
384
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
385
+ }
386
+ }
387
+ /**
388
+ * @returns {string}
389
+ */
390
+ takeWrites() {
391
+ let deferred2_0;
392
+ let deferred2_1;
393
+ try {
394
+ const ret = wasm.credentialvault_takeWrites(this.__wbg_ptr);
395
+ var ptr1 = ret[0];
396
+ var len1 = ret[1];
397
+ if (ret[3]) {
398
+ ptr1 = 0; len1 = 0;
399
+ throw takeFromExternrefTable0(ret[2]);
400
+ }
401
+ deferred2_0 = ptr1;
402
+ deferred2_1 = len1;
403
+ return getStringFromWasm0(ptr1, len1);
404
+ } finally {
405
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
406
+ }
407
+ }
408
+ }
409
+ if (Symbol.dispose) CredentialVault.prototype[Symbol.dispose] = CredentialVault.prototype.free;
410
+
411
+ export class Kernel {
412
+ __destroy_into_raw() {
413
+ const ptr = this.__wbg_ptr;
414
+ this.__wbg_ptr = 0;
415
+ KernelFinalization.unregister(this);
416
+ return ptr;
417
+ }
418
+ free() {
419
+ const ptr = this.__destroy_into_raw();
420
+ wasm.__wbg_kernel_free(ptr, 0);
421
+ }
422
+ /**
423
+ * @param {string} response_json
424
+ * @param {string | null} [already_delivered_json]
425
+ * @param {string | null} [base_json]
426
+ * @returns {string}
427
+ */
428
+ applyServerResponse(response_json, already_delivered_json, base_json) {
429
+ let deferred5_0;
430
+ let deferred5_1;
431
+ try {
432
+ const ptr0 = passStringToWasm0(response_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
433
+ const len0 = WASM_VECTOR_LEN;
434
+ var ptr1 = isLikeNone(already_delivered_json) ? 0 : passStringToWasm0(already_delivered_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
435
+ var len1 = WASM_VECTOR_LEN;
436
+ var ptr2 = isLikeNone(base_json) ? 0 : passStringToWasm0(base_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
437
+ var len2 = WASM_VECTOR_LEN;
438
+ const ret = wasm.kernel_applyServerResponse(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
439
+ var ptr4 = ret[0];
440
+ var len4 = ret[1];
441
+ if (ret[3]) {
442
+ ptr4 = 0; len4 = 0;
443
+ throw takeFromExternrefTable0(ret[2]);
444
+ }
445
+ deferred5_0 = ptr4;
446
+ deferred5_1 = len4;
447
+ return getStringFromWasm0(ptr4, len4);
448
+ } finally {
449
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
450
+ }
451
+ }
452
+ /**
453
+ * @param {string} side
454
+ * @returns {string}
455
+ */
456
+ bootMounts(side) {
457
+ let deferred3_0;
458
+ let deferred3_1;
459
+ try {
460
+ const ptr0 = passStringToWasm0(side, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
461
+ const len0 = WASM_VECTOR_LEN;
462
+ const ret = wasm.kernel_bootMounts(this.__wbg_ptr, ptr0, len0);
463
+ var ptr2 = ret[0];
464
+ var len2 = ret[1];
465
+ if (ret[3]) {
466
+ ptr2 = 0; len2 = 0;
467
+ throw takeFromExternrefTable0(ret[2]);
468
+ }
469
+ deferred3_0 = ptr2;
470
+ deferred3_1 = len2;
471
+ return getStringFromWasm0(ptr2, len2);
472
+ } finally {
473
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
474
+ }
475
+ }
476
+ /**
477
+ * @param {string} query_json
478
+ * @returns {string}
479
+ */
480
+ contractQuery(query_json) {
481
+ let deferred3_0;
482
+ let deferred3_1;
483
+ try {
484
+ const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
485
+ const len0 = WASM_VECTOR_LEN;
486
+ const ret = wasm.kernel_contractQuery(this.__wbg_ptr, ptr0, len0);
487
+ var ptr2 = ret[0];
488
+ var len2 = ret[1];
489
+ if (ret[3]) {
490
+ ptr2 = 0; len2 = 0;
491
+ throw takeFromExternrefTable0(ret[2]);
492
+ }
493
+ deferred3_0 = ptr2;
494
+ deferred3_1 = len2;
495
+ return getStringFromWasm0(ptr2, len2);
496
+ } finally {
497
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
498
+ }
499
+ }
500
+ /**
501
+ * @param {number} flight
502
+ * @param {string} emitted_json
503
+ * @returns {string}
504
+ */
505
+ deliverEmitToListeners(flight, emitted_json) {
506
+ let deferred3_0;
507
+ let deferred3_1;
508
+ try {
509
+ const ptr0 = passStringToWasm0(emitted_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
510
+ const len0 = WASM_VECTOR_LEN;
511
+ const ret = wasm.kernel_deliverEmitToListeners(this.__wbg_ptr, flight, ptr0, len0);
512
+ var ptr2 = ret[0];
513
+ var len2 = ret[1];
514
+ if (ret[3]) {
515
+ ptr2 = 0; len2 = 0;
516
+ throw takeFromExternrefTable0(ret[2]);
517
+ }
518
+ deferred3_0 = ptr2;
519
+ deferred3_1 = len2;
520
+ return getStringFromWasm0(ptr2, len2);
521
+ } finally {
522
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
523
+ }
524
+ }
525
+ /**
526
+ * @param {number} flight
527
+ * @param {string} emitted_json
528
+ * @returns {string}
529
+ */
530
+ deliverOriginEmit(flight, emitted_json) {
531
+ let deferred3_0;
532
+ let deferred3_1;
533
+ try {
534
+ const ptr0 = passStringToWasm0(emitted_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
535
+ const len0 = WASM_VECTOR_LEN;
536
+ const ret = wasm.kernel_deliverOriginEmit(this.__wbg_ptr, flight, ptr0, len0);
537
+ var ptr2 = ret[0];
538
+ var len2 = ret[1];
539
+ if (ret[3]) {
540
+ ptr2 = 0; len2 = 0;
541
+ throw takeFromExternrefTable0(ret[2]);
542
+ }
543
+ deferred3_0 = ptr2;
544
+ deferred3_1 = len2;
545
+ return getStringFromWasm0(ptr2, len2);
546
+ } finally {
547
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
548
+ }
549
+ }
550
+ /**
551
+ * @param {string} trait_name
552
+ * @param {string | null | undefined} entity_id
553
+ * @param {string} event
554
+ * @param {string | null} [payload_json]
555
+ * @returns {string}
556
+ */
557
+ dispatch(trait_name, entity_id, event, payload_json) {
558
+ let deferred6_0;
559
+ let deferred6_1;
560
+ try {
561
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
562
+ const len0 = WASM_VECTOR_LEN;
563
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
564
+ var len1 = WASM_VECTOR_LEN;
565
+ const ptr2 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
566
+ const len2 = WASM_VECTOR_LEN;
567
+ var ptr3 = isLikeNone(payload_json) ? 0 : passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
568
+ var len3 = WASM_VECTOR_LEN;
569
+ const ret = wasm.kernel_dispatch(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
570
+ var ptr5 = ret[0];
571
+ var len5 = ret[1];
572
+ if (ret[3]) {
573
+ ptr5 = 0; len5 = 0;
574
+ throw takeFromExternrefTable0(ret[2]);
575
+ }
576
+ deferred6_0 = ptr5;
577
+ deferred6_1 = len5;
578
+ return getStringFromWasm0(ptr5, len5);
579
+ } finally {
580
+ wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
581
+ }
582
+ }
583
+ /**
584
+ * The kernel's dispatch mode for a registered trait, as JSON text.
585
+ * @param {string} trait_name
586
+ * @returns {string}
587
+ */
588
+ dispatchMode(trait_name) {
589
+ let deferred3_0;
590
+ let deferred3_1;
591
+ try {
592
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
593
+ const len0 = WASM_VECTOR_LEN;
594
+ const ret = wasm.kernel_dispatchMode(this.__wbg_ptr, ptr0, len0);
595
+ var ptr2 = ret[0];
596
+ var len2 = ret[1];
597
+ if (ret[3]) {
598
+ ptr2 = 0; len2 = 0;
599
+ throw takeFromExternrefTable0(ret[2]);
600
+ }
601
+ deferred3_0 = ptr2;
602
+ deferred3_1 = len2;
603
+ return getStringFromWasm0(ptr2, len2);
604
+ } finally {
605
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
606
+ }
607
+ }
608
+ /**
609
+ * @param {string} seeds_json
610
+ * @param {string | null} [entity_id]
611
+ * @param {string | null} [payload_json]
612
+ * @returns {string}
613
+ */
614
+ dispatchMount(seeds_json, entity_id, payload_json) {
615
+ let deferred5_0;
616
+ let deferred5_1;
617
+ try {
618
+ const ptr0 = passStringToWasm0(seeds_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
619
+ const len0 = WASM_VECTOR_LEN;
620
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
621
+ var len1 = WASM_VECTOR_LEN;
622
+ var ptr2 = isLikeNone(payload_json) ? 0 : passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
623
+ var len2 = WASM_VECTOR_LEN;
624
+ const ret = wasm.kernel_dispatchMount(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
625
+ var ptr4 = ret[0];
626
+ var len4 = ret[1];
627
+ if (ret[3]) {
628
+ ptr4 = 0; len4 = 0;
629
+ throw takeFromExternrefTable0(ret[2]);
630
+ }
631
+ deferred5_0 = ptr4;
632
+ deferred5_1 = len4;
633
+ return getStringFromWasm0(ptr4, len4);
634
+ } finally {
635
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
636
+ }
637
+ }
638
+ /**
639
+ * @param {number} flight
640
+ * @returns {boolean}
641
+ */
642
+ endFlight(flight) {
643
+ const ret = wasm.kernel_endFlight(this.__wbg_ptr, flight);
644
+ return ret !== 0;
645
+ }
646
+ /**
647
+ * @param {string | null | undefined} route_path
648
+ * @param {string} mount_key
649
+ * @param {string} traits_json
650
+ * @returns {string}
651
+ */
652
+ enter(route_path, mount_key, traits_json) {
653
+ let deferred5_0;
654
+ let deferred5_1;
655
+ try {
656
+ var ptr0 = isLikeNone(route_path) ? 0 : passStringToWasm0(route_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
657
+ var len0 = WASM_VECTOR_LEN;
658
+ const ptr1 = passStringToWasm0(mount_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
659
+ const len1 = WASM_VECTOR_LEN;
660
+ const ptr2 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
661
+ const len2 = WASM_VECTOR_LEN;
662
+ const ret = wasm.kernel_enter(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
663
+ var ptr4 = ret[0];
664
+ var len4 = ret[1];
665
+ if (ret[3]) {
666
+ ptr4 = 0; len4 = 0;
667
+ throw takeFromExternrefTable0(ret[2]);
668
+ }
669
+ deferred5_0 = ptr4;
670
+ deferred5_1 = len4;
671
+ return getStringFromWasm0(ptr4, len4);
672
+ } finally {
673
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
674
+ }
675
+ }
676
+ /**
677
+ * `undefined` when the leg carried no rows to fold against.
678
+ * @param {string | null | undefined} carried_json
679
+ * @param {string} seeded_json
680
+ * @param {string | null} [entity_id]
681
+ * @returns {string | undefined}
682
+ */
683
+ foldBase(carried_json, seeded_json, entity_id) {
684
+ var ptr0 = isLikeNone(carried_json) ? 0 : passStringToWasm0(carried_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
685
+ var len0 = WASM_VECTOR_LEN;
686
+ const ptr1 = passStringToWasm0(seeded_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
687
+ const len1 = WASM_VECTOR_LEN;
688
+ var ptr2 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
689
+ var len2 = WASM_VECTOR_LEN;
690
+ const ret = wasm.kernel_foldBase(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
691
+ if (ret[3]) {
692
+ throw takeFromExternrefTable0(ret[2]);
693
+ }
694
+ let v4;
695
+ if (ret[0] !== 0) {
696
+ v4 = getStringFromWasm0(ret[0], ret[1]).slice();
697
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
698
+ }
699
+ return v4;
700
+ }
701
+ /**
702
+ * @param {number} flight
703
+ * @param {string} response_json
704
+ * @param {string | null} [already_delivered_json]
705
+ * @param {string | null} [base_json]
706
+ * @returns {string}
707
+ */
708
+ foldInOrder(flight, response_json, already_delivered_json, base_json) {
709
+ let deferred5_0;
710
+ let deferred5_1;
711
+ try {
712
+ const ptr0 = passStringToWasm0(response_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
713
+ const len0 = WASM_VECTOR_LEN;
714
+ var ptr1 = isLikeNone(already_delivered_json) ? 0 : passStringToWasm0(already_delivered_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
715
+ var len1 = WASM_VECTOR_LEN;
716
+ var ptr2 = isLikeNone(base_json) ? 0 : passStringToWasm0(base_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
717
+ var len2 = WASM_VECTOR_LEN;
718
+ const ret = wasm.kernel_foldInOrder(this.__wbg_ptr, flight, ptr0, len0, ptr1, len1, ptr2, len2);
719
+ var ptr4 = ret[0];
720
+ var len4 = ret[1];
721
+ if (ret[3]) {
722
+ ptr4 = 0; len4 = 0;
723
+ throw takeFromExternrefTable0(ret[2]);
724
+ }
725
+ deferred5_0 = ptr4;
726
+ deferred5_1 = len4;
727
+ return getStringFromWasm0(ptr4, len4);
728
+ } finally {
729
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
730
+ }
731
+ }
732
+ /**
733
+ * `undefined` when no tick is due this frame.
734
+ * @param {number} now_ms
735
+ * @returns {string | undefined}
736
+ */
737
+ frame(now_ms) {
738
+ const ret = wasm.kernel_frame(this.__wbg_ptr, now_ms);
739
+ if (ret[3]) {
740
+ throw takeFromExternrefTable0(ret[2]);
741
+ }
742
+ let v1;
743
+ if (ret[0] !== 0) {
744
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
745
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
746
+ }
747
+ return v1;
748
+ }
749
+ framePause() {
750
+ wasm.kernel_framePause(this.__wbg_ptr);
751
+ }
752
+ frameResume() {
753
+ wasm.kernel_frameResume(this.__wbg_ptr);
754
+ }
755
+ /**
756
+ * @param {number} since
757
+ * @returns {string}
758
+ */
759
+ framesSince(since) {
760
+ let deferred2_0;
761
+ let deferred2_1;
762
+ try {
763
+ const ret = wasm.kernel_framesSince(this.__wbg_ptr, since);
764
+ var ptr1 = ret[0];
765
+ var len1 = ret[1];
766
+ if (ret[3]) {
767
+ ptr1 = 0; len1 = 0;
768
+ throw takeFromExternrefTable0(ret[2]);
769
+ }
770
+ deferred2_0 = ptr1;
771
+ deferred2_1 = len1;
772
+ return getStringFromWasm0(ptr1, len1);
773
+ } finally {
774
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
775
+ }
776
+ }
777
+ /**
778
+ * @param {string} trait_name
779
+ * @param {string | null} [entity_id]
780
+ * @returns {string}
781
+ */
782
+ getState(trait_name, entity_id) {
783
+ let deferred3_0;
784
+ let deferred3_1;
785
+ try {
786
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
787
+ const len0 = WASM_VECTOR_LEN;
788
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
789
+ var len1 = WASM_VECTOR_LEN;
790
+ const ret = wasm.kernel_getState(this.__wbg_ptr, ptr0, len0, ptr1, len1);
791
+ deferred3_0 = ret[0];
792
+ deferred3_1 = ret[1];
793
+ return getStringFromWasm0(ret[0], ret[1]);
794
+ } finally {
795
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
796
+ }
797
+ }
798
+ /**
799
+ * @returns {string}
800
+ */
801
+ lastError() {
802
+ let deferred1_0;
803
+ let deferred1_1;
804
+ try {
805
+ const ret = wasm.kernel_lastError(this.__wbg_ptr);
806
+ deferred1_0 = ret[0];
807
+ deferred1_1 = ret[1];
808
+ return getStringFromWasm0(ret[0], ret[1]);
809
+ } finally {
810
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
811
+ }
812
+ }
813
+ /**
814
+ * @returns {string}
815
+ */
816
+ leave() {
817
+ let deferred2_0;
818
+ let deferred2_1;
819
+ try {
820
+ const ret = wasm.kernel_leave(this.__wbg_ptr);
821
+ var ptr1 = ret[0];
822
+ var len1 = ret[1];
823
+ if (ret[3]) {
824
+ ptr1 = 0; len1 = 0;
825
+ throw takeFromExternrefTable0(ret[2]);
826
+ }
827
+ deferred2_0 = ptr1;
828
+ deferred2_1 = len1;
829
+ return getStringFromWasm0(ptr1, len1);
830
+ } finally {
831
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
832
+ }
833
+ }
834
+ /**
835
+ * @param {string} traits_json
836
+ */
837
+ mount(traits_json) {
838
+ const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
839
+ const len0 = WASM_VECTOR_LEN;
840
+ const ret = wasm.kernel_mount(this.__wbg_ptr, ptr0, len0);
841
+ if (ret[1]) {
842
+ throw takeFromExternrefTable0(ret[0]);
843
+ }
844
+ }
845
+ /**
846
+ * @param {string} resolved_schema_json
847
+ * @param {string} client_id
848
+ */
849
+ constructor(resolved_schema_json, client_id) {
850
+ const ptr0 = passStringToWasm0(resolved_schema_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
851
+ const len0 = WASM_VECTOR_LEN;
852
+ const ptr1 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
853
+ const len1 = WASM_VECTOR_LEN;
854
+ const ret = wasm.kernel_new(ptr0, len0, ptr1, len1);
855
+ if (ret[2]) {
856
+ throw takeFromExternrefTable0(ret[1]);
857
+ }
858
+ this.__wbg_ptr = ret[0];
859
+ KernelFinalization.register(this, this.__wbg_ptr, this);
860
+ return this;
861
+ }
862
+ /**
863
+ * @returns {string | undefined}
864
+ */
865
+ nextFold() {
866
+ const ret = wasm.kernel_nextFold(this.__wbg_ptr);
867
+ if (ret[3]) {
868
+ throw takeFromExternrefTable0(ret[2]);
869
+ }
870
+ let v1;
871
+ if (ret[0] !== 0) {
872
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
873
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
874
+ }
875
+ return v1;
876
+ }
877
+ /**
878
+ * @returns {number}
879
+ */
880
+ openFlight() {
881
+ const ret = wasm.kernel_openFlight(this.__wbg_ptr);
882
+ return ret;
883
+ }
884
+ /**
885
+ * @param {string | null} [page]
886
+ * @param {string | null} [route]
887
+ * @returns {string}
888
+ */
889
+ pageCircuit(page, route) {
890
+ let deferred4_0;
891
+ let deferred4_1;
892
+ try {
893
+ var ptr0 = isLikeNone(page) ? 0 : passStringToWasm0(page, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
894
+ var len0 = WASM_VECTOR_LEN;
895
+ var ptr1 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
896
+ var len1 = WASM_VECTOR_LEN;
897
+ const ret = wasm.kernel_pageCircuit(this.__wbg_ptr, ptr0, len0, ptr1, len1);
898
+ var ptr3 = ret[0];
899
+ var len3 = ret[1];
900
+ if (ret[3]) {
901
+ ptr3 = 0; len3 = 0;
902
+ throw takeFromExternrefTable0(ret[2]);
903
+ }
904
+ deferred4_0 = ptr3;
905
+ deferred4_1 = len3;
906
+ return getStringFromWasm0(ptr3, len3);
907
+ } finally {
908
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
909
+ }
910
+ }
911
+ /**
912
+ * @param {string} traits_json
913
+ * @returns {string}
914
+ */
915
+ remount(traits_json) {
916
+ let deferred3_0;
917
+ let deferred3_1;
918
+ try {
919
+ const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
920
+ const len0 = WASM_VECTOR_LEN;
921
+ const ret = wasm.kernel_remount(this.__wbg_ptr, ptr0, len0);
922
+ var ptr2 = ret[0];
923
+ var len2 = ret[1];
924
+ if (ret[3]) {
925
+ ptr2 = 0; len2 = 0;
926
+ throw takeFromExternrefTable0(ret[2]);
927
+ }
928
+ deferred3_0 = ptr2;
929
+ deferred3_1 = len2;
930
+ return getStringFromWasm0(ptr2, len2);
931
+ } finally {
932
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
933
+ }
934
+ }
935
+ /**
936
+ * @param {string} seeds_json
937
+ * @param {string | null} [entity_id]
938
+ * @returns {string}
939
+ */
940
+ reseedLeg(seeds_json, entity_id) {
941
+ let deferred4_0;
942
+ let deferred4_1;
943
+ try {
944
+ const ptr0 = passStringToWasm0(seeds_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
945
+ const len0 = WASM_VECTOR_LEN;
946
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
947
+ var len1 = WASM_VECTOR_LEN;
948
+ const ret = wasm.kernel_reseedLeg(this.__wbg_ptr, ptr0, len0, ptr1, len1);
949
+ var ptr3 = ret[0];
950
+ var len3 = ret[1];
951
+ if (ret[3]) {
952
+ ptr3 = 0; len3 = 0;
953
+ throw takeFromExternrefTable0(ret[2]);
954
+ }
955
+ deferred4_0 = ptr3;
956
+ deferred4_1 = len3;
957
+ return getStringFromWasm0(ptr3, len3);
958
+ } finally {
959
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
960
+ }
961
+ }
962
+ /**
963
+ * A row-set reference resolved against this kernel's rows for its current user (`{ rows, total }`).
964
+ * @param {string} ref_json
965
+ * @returns {string}
966
+ */
967
+ resolveRows(ref_json) {
968
+ let deferred3_0;
969
+ let deferred3_1;
970
+ try {
971
+ const ptr0 = passStringToWasm0(ref_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
972
+ const len0 = WASM_VECTOR_LEN;
973
+ const ret = wasm.kernel_resolveRows(this.__wbg_ptr, ptr0, len0);
974
+ var ptr2 = ret[0];
975
+ var len2 = ret[1];
976
+ if (ret[3]) {
977
+ ptr2 = 0; len2 = 0;
978
+ throw takeFromExternrefTable0(ret[2]);
979
+ }
980
+ deferred3_0 = ptr2;
981
+ deferred3_1 = len2;
982
+ return getStringFromWasm0(ptr2, len2);
983
+ } finally {
984
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
985
+ }
986
+ }
987
+ /**
988
+ * @param {string} trait_name
989
+ * @param {string | null | undefined} entity_id
990
+ * @param {string} snapshot_json
991
+ * @returns {string}
992
+ */
993
+ restore(trait_name, entity_id, snapshot_json) {
994
+ let deferred5_0;
995
+ let deferred5_1;
996
+ try {
997
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
998
+ const len0 = WASM_VECTOR_LEN;
999
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1000
+ var len1 = WASM_VECTOR_LEN;
1001
+ const ptr2 = passStringToWasm0(snapshot_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1002
+ const len2 = WASM_VECTOR_LEN;
1003
+ const ret = wasm.kernel_restore(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1004
+ var ptr4 = ret[0];
1005
+ var len4 = ret[1];
1006
+ if (ret[3]) {
1007
+ ptr4 = 0; len4 = 0;
1008
+ throw takeFromExternrefTable0(ret[2]);
1009
+ }
1010
+ deferred5_0 = ptr4;
1011
+ deferred5_1 = len4;
1012
+ return getStringFromWasm0(ptr4, len4);
1013
+ } finally {
1014
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
1015
+ }
1016
+ }
1017
+ /**
1018
+ * @param {string} route_path
1019
+ * @returns {string}
1020
+ */
1021
+ routeMounts(route_path) {
1022
+ let deferred3_0;
1023
+ let deferred3_1;
1024
+ try {
1025
+ const ptr0 = passStringToWasm0(route_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1026
+ const len0 = WASM_VECTOR_LEN;
1027
+ const ret = wasm.kernel_routeMounts(this.__wbg_ptr, ptr0, len0);
1028
+ var ptr2 = ret[0];
1029
+ var len2 = ret[1];
1030
+ if (ret[3]) {
1031
+ ptr2 = 0; len2 = 0;
1032
+ throw takeFromExternrefTable0(ret[2]);
1033
+ }
1034
+ deferred3_0 = ptr2;
1035
+ deferred3_1 = len2;
1036
+ return getStringFromWasm0(ptr2, len2);
1037
+ } finally {
1038
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1039
+ }
1040
+ }
1041
+ /**
1042
+ * @param {string} entity_type
1043
+ * @param {string} rows_json
1044
+ */
1045
+ seed(entity_type, rows_json) {
1046
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1047
+ const len0 = WASM_VECTOR_LEN;
1048
+ const ptr1 = passStringToWasm0(rows_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1049
+ const len1 = WASM_VECTOR_LEN;
1050
+ const ret = wasm.kernel_seed(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1051
+ if (ret[1]) {
1052
+ throw takeFromExternrefTable0(ret[0]);
1053
+ }
1054
+ }
1055
+ /**
1056
+ * The theme key bound to this client's session (`theme/set`, mirrored from the server's frames), or `undefined`.
1057
+ * @returns {string | undefined}
1058
+ */
1059
+ sessionTheme() {
1060
+ const ret = wasm.kernel_sessionTheme(this.__wbg_ptr);
1061
+ let v1;
1062
+ if (ret[0] !== 0) {
1063
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
1064
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1065
+ }
1066
+ return v1;
1067
+ }
1068
+ /**
1069
+ * Carry each tick's `effectResults` on the frame response, for a verifier. Off by default (P-015).
1070
+ * @param {boolean} carry
1071
+ */
1072
+ setFrameEffectResults(carry) {
1073
+ wasm.kernel_setFrameEffectResults(this.__wbg_ptr, carry);
1074
+ }
1075
+ /**
1076
+ * The host runs the listeners of every emit it marks `dispatched` (the JS runtime, `orbital-server`).
1077
+ * @param {boolean} fans_out
1078
+ */
1079
+ setHostFansOut(fans_out) {
1080
+ wasm.kernel_setHostFansOut(this.__wbg_ptr, fans_out);
1081
+ }
1082
+ /**
1083
+ * @param {string} locales_json
1084
+ * @param {string} catalogs_json
1085
+ */
1086
+ setMessages(locales_json, catalogs_json) {
1087
+ const ptr0 = passStringToWasm0(locales_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1088
+ const len0 = WASM_VECTOR_LEN;
1089
+ const ptr1 = passStringToWasm0(catalogs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1090
+ const len1 = WASM_VECTOR_LEN;
1091
+ const ret = wasm.kernel_setMessages(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1092
+ if (ret[1]) {
1093
+ throw takeFromExternrefTable0(ret[0]);
1094
+ }
1095
+ }
1096
+ /**
1097
+ * Carry each hop's `@entity` before and after it on the dispatch's transitions (`observed`), for a verifier
1098
+ * judging `@ensures`. Off by default (EXEC-STEP-10).
1099
+ * @param {boolean} record
1100
+ */
1101
+ setRecordEntityAfter(record) {
1102
+ wasm.kernel_setRecordEntityAfter(this.__wbg_ptr, record);
1103
+ }
1104
+ /**
1105
+ * @param {string} mode
1106
+ */
1107
+ setThemeMode(mode) {
1108
+ const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1109
+ const len0 = WASM_VECTOR_LEN;
1110
+ const ret = wasm.kernel_setThemeMode(this.__wbg_ptr, ptr0, len0);
1111
+ if (ret[1]) {
1112
+ throw takeFromExternrefTable0(ret[0]);
1113
+ }
1114
+ }
1115
+ /**
1116
+ * The host's report of whether a trait's rendered output is on screen; gates its `[visible]` ticks.
1117
+ * @param {string} trait_name
1118
+ * @param {boolean} on_screen
1119
+ */
1120
+ setTraitOnScreen(trait_name, on_screen) {
1121
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1122
+ const len0 = WASM_VECTOR_LEN;
1123
+ wasm.kernel_setTraitOnScreen(this.__wbg_ptr, ptr0, len0, on_screen);
1124
+ }
1125
+ /**
1126
+ * @returns {string}
1127
+ */
1128
+ snapshot() {
1129
+ let deferred2_0;
1130
+ let deferred2_1;
1131
+ try {
1132
+ const ret = wasm.kernel_snapshot(this.__wbg_ptr);
1133
+ var ptr1 = ret[0];
1134
+ var len1 = ret[1];
1135
+ if (ret[3]) {
1136
+ ptr1 = 0; len1 = 0;
1137
+ throw takeFromExternrefTable0(ret[2]);
1138
+ }
1139
+ deferred2_0 = ptr1;
1140
+ deferred2_1 = len1;
1141
+ return getStringFromWasm0(ptr1, len1);
1142
+ } finally {
1143
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1144
+ }
1145
+ }
1146
+ /**
1147
+ * @param {string} leg_json
1148
+ * @returns {string}
1149
+ */
1150
+ statefulLeg(leg_json) {
1151
+ let deferred3_0;
1152
+ let deferred3_1;
1153
+ try {
1154
+ const ptr0 = passStringToWasm0(leg_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1155
+ const len0 = WASM_VECTOR_LEN;
1156
+ const ret = wasm.kernel_statefulLeg(this.__wbg_ptr, ptr0, len0);
1157
+ var ptr2 = ret[0];
1158
+ var len2 = ret[1];
1159
+ if (ret[3]) {
1160
+ ptr2 = 0; len2 = 0;
1161
+ throw takeFromExternrefTable0(ret[2]);
1162
+ }
1163
+ deferred3_0 = ptr2;
1164
+ deferred3_1 = len2;
1165
+ return getStringFromWasm0(ptr2, len2);
1166
+ } finally {
1167
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1168
+ }
1169
+ }
1170
+ /**
1171
+ * @param {string} trait_name
1172
+ * @param {string} tick_name
1173
+ * @param {string | null} [entity_id]
1174
+ * @returns {string}
1175
+ */
1176
+ tick(trait_name, tick_name, entity_id) {
1177
+ let deferred5_0;
1178
+ let deferred5_1;
1179
+ try {
1180
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1181
+ const len0 = WASM_VECTOR_LEN;
1182
+ const ptr1 = passStringToWasm0(tick_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1183
+ const len1 = WASM_VECTOR_LEN;
1184
+ var ptr2 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1185
+ var len2 = WASM_VECTOR_LEN;
1186
+ const ret = wasm.kernel_tick(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1187
+ var ptr4 = ret[0];
1188
+ var len4 = ret[1];
1189
+ if (ret[3]) {
1190
+ ptr4 = 0; len4 = 0;
1191
+ throw takeFromExternrefTable0(ret[2]);
1192
+ }
1193
+ deferred5_0 = ptr4;
1194
+ deferred5_1 = len4;
1195
+ return getStringFromWasm0(ptr4, len4);
1196
+ } finally {
1197
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
1198
+ }
1199
+ }
1200
+ /**
1201
+ * @returns {number}
1202
+ */
1203
+ tickCount() {
1204
+ const ret = wasm.kernel_tickCount(this.__wbg_ptr);
1205
+ return ret >>> 0;
1206
+ }
1207
+ /**
1208
+ * The config the kernel binds as `@config` for a registered trait, as JSON text.
1209
+ * @param {string} trait_name
1210
+ * @returns {string}
1211
+ */
1212
+ traitConfig(trait_name) {
1213
+ let deferred3_0;
1214
+ let deferred3_1;
1215
+ try {
1216
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1217
+ const len0 = WASM_VECTOR_LEN;
1218
+ const ret = wasm.kernel_traitConfig(this.__wbg_ptr, ptr0, len0);
1219
+ var ptr2 = ret[0];
1220
+ var len2 = ret[1];
1221
+ if (ret[3]) {
1222
+ ptr2 = 0; len2 = 0;
1223
+ throw takeFromExternrefTable0(ret[2]);
1224
+ }
1225
+ deferred3_0 = ptr2;
1226
+ deferred3_1 = len2;
1227
+ return getStringFromWasm0(ptr2, len2);
1228
+ } finally {
1229
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1230
+ }
1231
+ }
1232
+ /**
1233
+ * @param {string} traits_json
1234
+ * @returns {string}
1235
+ */
1236
+ unmount(traits_json) {
1237
+ let deferred3_0;
1238
+ let deferred3_1;
1239
+ try {
1240
+ const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1241
+ const len0 = WASM_VECTOR_LEN;
1242
+ const ret = wasm.kernel_unmount(this.__wbg_ptr, ptr0, len0);
1243
+ var ptr2 = ret[0];
1244
+ var len2 = ret[1];
1245
+ if (ret[3]) {
1246
+ ptr2 = 0; len2 = 0;
1247
+ throw takeFromExternrefTable0(ret[2]);
1248
+ }
1249
+ deferred3_0 = ptr2;
1250
+ deferred3_1 = len2;
1251
+ return getStringFromWasm0(ptr2, len2);
1252
+ } finally {
1253
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1254
+ }
1255
+ }
1256
+ }
1257
+ if (Symbol.dispose) Kernel.prototype[Symbol.dispose] = Kernel.prototype.free;
1258
+
1259
+ export class MemoryStore {
1260
+ __destroy_into_raw() {
1261
+ const ptr = this.__wbg_ptr;
1262
+ this.__wbg_ptr = 0;
1263
+ MemoryStoreFinalization.unregister(this);
1264
+ return ptr;
1265
+ }
1266
+ free() {
1267
+ const ptr = this.__destroy_into_raw();
1268
+ wasm.__wbg_memorystore_free(ptr, 0);
1269
+ }
1270
+ /**
1271
+ * @param {string} entity_type
1272
+ * @param {string} collection
1273
+ */
1274
+ bindCollection(entity_type, collection) {
1275
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1276
+ const len0 = WASM_VECTOR_LEN;
1277
+ const ptr1 = passStringToWasm0(collection, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1278
+ const len1 = WASM_VECTOR_LEN;
1279
+ wasm.memorystore_bindCollection(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1280
+ }
1281
+ clear() {
1282
+ wasm.memorystore_clear(this.__wbg_ptr);
1283
+ }
1284
+ /**
1285
+ * @param {string} entity_type
1286
+ * @param {string} data_json
1287
+ * @returns {string}
1288
+ */
1289
+ create(entity_type, data_json) {
1290
+ let deferred4_0;
1291
+ let deferred4_1;
1292
+ try {
1293
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1294
+ const len0 = WASM_VECTOR_LEN;
1295
+ const ptr1 = passStringToWasm0(data_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1296
+ const len1 = WASM_VECTOR_LEN;
1297
+ const ret = wasm.memorystore_create(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1298
+ var ptr3 = ret[0];
1299
+ var len3 = ret[1];
1300
+ if (ret[3]) {
1301
+ ptr3 = 0; len3 = 0;
1302
+ throw takeFromExternrefTable0(ret[2]);
1303
+ }
1304
+ deferred4_0 = ptr3;
1305
+ deferred4_1 = len3;
1306
+ return getStringFromWasm0(ptr3, len3);
1307
+ } finally {
1308
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1309
+ }
1310
+ }
1311
+ /**
1312
+ * @param {string} entity_type
1313
+ * @param {string} id
1314
+ */
1315
+ delete(entity_type, id) {
1316
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1317
+ const len0 = WASM_VECTOR_LEN;
1318
+ const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1319
+ const len1 = WASM_VECTOR_LEN;
1320
+ const ret = wasm.memorystore_delete(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1321
+ if (ret[1]) {
1322
+ throw takeFromExternrefTable0(ret[0]);
1323
+ }
1324
+ }
1325
+ /**
1326
+ * @param {string} entity_type
1327
+ * @param {string} id
1328
+ * @returns {string}
1329
+ */
1330
+ getById(entity_type, id) {
1331
+ let deferred4_0;
1332
+ let deferred4_1;
1333
+ try {
1334
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1335
+ const len0 = WASM_VECTOR_LEN;
1336
+ const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1337
+ const len1 = WASM_VECTOR_LEN;
1338
+ const ret = wasm.memorystore_getById(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1339
+ var ptr3 = ret[0];
1340
+ var len3 = ret[1];
1341
+ if (ret[3]) {
1342
+ ptr3 = 0; len3 = 0;
1343
+ throw takeFromExternrefTable0(ret[2]);
1344
+ }
1345
+ deferred4_0 = ptr3;
1346
+ deferred4_1 = len3;
1347
+ return getStringFromWasm0(ptr3, len3);
1348
+ } finally {
1349
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1350
+ }
1351
+ }
1352
+ /**
1353
+ * @param {string} entity_type
1354
+ * @returns {string}
1355
+ */
1356
+ list(entity_type) {
1357
+ let deferred3_0;
1358
+ let deferred3_1;
1359
+ try {
1360
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1361
+ const len0 = WASM_VECTOR_LEN;
1362
+ const ret = wasm.memorystore_list(this.__wbg_ptr, ptr0, len0);
1363
+ var ptr2 = ret[0];
1364
+ var len2 = ret[1];
1365
+ if (ret[3]) {
1366
+ ptr2 = 0; len2 = 0;
1367
+ throw takeFromExternrefTable0(ret[2]);
1368
+ }
1369
+ deferred3_0 = ptr2;
1370
+ deferred3_1 = len2;
1371
+ return getStringFromWasm0(ptr2, len2);
1372
+ } finally {
1373
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1374
+ }
1375
+ }
1376
+ constructor() {
1377
+ const ret = wasm.memorystore_new();
1378
+ this.__wbg_ptr = ret;
1379
+ MemoryStoreFinalization.register(this, this.__wbg_ptr, this);
1380
+ return this;
1381
+ }
1382
+ /**
1383
+ * @returns {string}
1384
+ */
1385
+ queryCapabilities() {
1386
+ let deferred2_0;
1387
+ let deferred2_1;
1388
+ try {
1389
+ const ret = wasm.memorystore_queryCapabilities(this.__wbg_ptr);
1390
+ var ptr1 = ret[0];
1391
+ var len1 = ret[1];
1392
+ if (ret[3]) {
1393
+ ptr1 = 0; len1 = 0;
1394
+ throw takeFromExternrefTable0(ret[2]);
1395
+ }
1396
+ deferred2_0 = ptr1;
1397
+ deferred2_1 = len1;
1398
+ return getStringFromWasm0(ptr1, len1);
1399
+ } finally {
1400
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1401
+ }
1402
+ }
1403
+ /**
1404
+ * @param {string} entity_type
1405
+ * @param {string} query_json
1406
+ * @returns {string}
1407
+ */
1408
+ queryIds(entity_type, query_json) {
1409
+ let deferred4_0;
1410
+ let deferred4_1;
1411
+ try {
1412
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1413
+ const len0 = WASM_VECTOR_LEN;
1414
+ const ptr1 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1415
+ const len1 = WASM_VECTOR_LEN;
1416
+ const ret = wasm.memorystore_queryIds(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1417
+ var ptr3 = ret[0];
1418
+ var len3 = ret[1];
1419
+ if (ret[3]) {
1420
+ ptr3 = 0; len3 = 0;
1421
+ throw takeFromExternrefTable0(ret[2]);
1422
+ }
1423
+ deferred4_0 = ptr3;
1424
+ deferred4_1 = len3;
1425
+ return getStringFromWasm0(ptr3, len3);
1426
+ } finally {
1427
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1428
+ }
1429
+ }
1430
+ /**
1431
+ * @param {string} entity_type
1432
+ * @param {string} query_json
1433
+ * @returns {string}
1434
+ */
1435
+ queryPage(entity_type, query_json) {
1436
+ let deferred4_0;
1437
+ let deferred4_1;
1438
+ try {
1439
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1440
+ const len0 = WASM_VECTOR_LEN;
1441
+ const ptr1 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1442
+ const len1 = WASM_VECTOR_LEN;
1443
+ const ret = wasm.memorystore_queryPage(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1444
+ var ptr3 = ret[0];
1445
+ var len3 = ret[1];
1446
+ if (ret[3]) {
1447
+ ptr3 = 0; len3 = 0;
1448
+ throw takeFromExternrefTable0(ret[2]);
1449
+ }
1450
+ deferred4_0 = ptr3;
1451
+ deferred4_1 = len3;
1452
+ return getStringFromWasm0(ptr3, len3);
1453
+ } finally {
1454
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1455
+ }
1456
+ }
1457
+ /**
1458
+ * @returns {string}
1459
+ */
1460
+ snapshot() {
1461
+ let deferred2_0;
1462
+ let deferred2_1;
1463
+ try {
1464
+ const ret = wasm.memorystore_snapshot(this.__wbg_ptr);
1465
+ var ptr1 = ret[0];
1466
+ var len1 = ret[1];
1467
+ if (ret[3]) {
1468
+ ptr1 = 0; len1 = 0;
1469
+ throw takeFromExternrefTable0(ret[2]);
1470
+ }
1471
+ deferred2_0 = ptr1;
1472
+ deferred2_1 = len1;
1473
+ return getStringFromWasm0(ptr1, len1);
1474
+ } finally {
1475
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1476
+ }
1477
+ }
1478
+ /**
1479
+ * @param {string} entity_type
1480
+ * @param {string} id
1481
+ * @param {string} data_json
1482
+ * @returns {string}
1483
+ */
1484
+ update(entity_type, id, data_json) {
1485
+ let deferred5_0;
1486
+ let deferred5_1;
1487
+ try {
1488
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1489
+ const len0 = WASM_VECTOR_LEN;
1490
+ const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1491
+ const len1 = WASM_VECTOR_LEN;
1492
+ const ptr2 = passStringToWasm0(data_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1493
+ const len2 = WASM_VECTOR_LEN;
1494
+ const ret = wasm.memorystore_update(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1495
+ var ptr4 = ret[0];
1496
+ var len4 = ret[1];
1497
+ if (ret[3]) {
1498
+ ptr4 = 0; len4 = 0;
1499
+ throw takeFromExternrefTable0(ret[2]);
1500
+ }
1501
+ deferred5_0 = ptr4;
1502
+ deferred5_1 = len4;
1503
+ return getStringFromWasm0(ptr4, len4);
1504
+ } finally {
1505
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
1506
+ }
1507
+ }
1508
+ /**
1509
+ * @param {string} batch_json
1510
+ * @returns {string}
1511
+ */
1512
+ writeBatch(batch_json) {
1513
+ let deferred3_0;
1514
+ let deferred3_1;
1515
+ try {
1516
+ const ptr0 = passStringToWasm0(batch_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1517
+ const len0 = WASM_VECTOR_LEN;
1518
+ const ret = wasm.memorystore_writeBatch(this.__wbg_ptr, ptr0, len0);
1519
+ var ptr2 = ret[0];
1520
+ var len2 = ret[1];
1521
+ if (ret[3]) {
1522
+ ptr2 = 0; len2 = 0;
1523
+ throw takeFromExternrefTable0(ret[2]);
1524
+ }
1525
+ deferred3_0 = ptr2;
1526
+ deferred3_1 = len2;
1527
+ return getStringFromWasm0(ptr2, len2);
1528
+ } finally {
1529
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1530
+ }
1531
+ }
1532
+ /**
1533
+ * @returns {string}
1534
+ */
1535
+ writeCapabilities() {
1536
+ let deferred2_0;
1537
+ let deferred2_1;
1538
+ try {
1539
+ const ret = wasm.memorystore_writeCapabilities(this.__wbg_ptr);
1540
+ var ptr1 = ret[0];
1541
+ var len1 = ret[1];
1542
+ if (ret[3]) {
1543
+ ptr1 = 0; len1 = 0;
1544
+ throw takeFromExternrefTable0(ret[2]);
1545
+ }
1546
+ deferred2_0 = ptr1;
1547
+ deferred2_1 = len1;
1548
+ return getStringFromWasm0(ptr1, len1);
1549
+ } finally {
1550
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1551
+ }
1552
+ }
1553
+ /**
1554
+ * @param {string} op_json
1555
+ * @returns {string}
1556
+ */
1557
+ writeWhere(op_json) {
1558
+ let deferred3_0;
1559
+ let deferred3_1;
1560
+ try {
1561
+ const ptr0 = passStringToWasm0(op_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1562
+ const len0 = WASM_VECTOR_LEN;
1563
+ const ret = wasm.memorystore_writeWhere(this.__wbg_ptr, ptr0, len0);
1564
+ var ptr2 = ret[0];
1565
+ var len2 = ret[1];
1566
+ if (ret[3]) {
1567
+ ptr2 = 0; len2 = 0;
1568
+ throw takeFromExternrefTable0(ret[2]);
1569
+ }
1570
+ deferred3_0 = ptr2;
1571
+ deferred3_1 = len2;
1572
+ return getStringFromWasm0(ptr2, len2);
1573
+ } finally {
1574
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1575
+ }
1576
+ }
1577
+ }
1578
+ if (Symbol.dispose) MemoryStore.prototype[Symbol.dispose] = MemoryStore.prototype.free;
1579
+
1580
+ /**
1581
+ * The server role: `start` a request, answer the I/O it asks for, `resume` the flight until it is done.
1582
+ */
1583
+ export class Server {
1584
+ static __wrap(ptr) {
1585
+ const obj = Object.create(Server.prototype);
1586
+ obj.__wbg_ptr = ptr;
1587
+ ServerFinalization.register(obj, obj.__wbg_ptr, obj);
1588
+ return obj;
1589
+ }
1590
+ __destroy_into_raw() {
1591
+ const ptr = this.__wbg_ptr;
1592
+ this.__wbg_ptr = 0;
1593
+ ServerFinalization.unregister(this);
1594
+ return ptr;
1595
+ }
1596
+ free() {
1597
+ const ptr = this.__destroy_into_raw();
1598
+ wasm.__wbg_server_free(ptr, 0);
1599
+ }
1600
+ /**
1601
+ * @param {number} flight
1602
+ * @returns {boolean}
1603
+ */
1604
+ abandon(flight) {
1605
+ const ret = wasm.server_abandon(this.__wbg_ptr, flight);
1606
+ if (ret[2]) {
1607
+ throw takeFromExternrefTable0(ret[1]);
1608
+ }
1609
+ return ret[0] !== 0;
1610
+ }
1611
+ /**
1612
+ * @param {string} side
1613
+ * @returns {string}
1614
+ */
1615
+ bootMounts(side) {
1616
+ let deferred3_0;
1617
+ let deferred3_1;
1618
+ try {
1619
+ const ptr0 = passStringToWasm0(side, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1620
+ const len0 = WASM_VECTOR_LEN;
1621
+ const ret = wasm.server_bootMounts(this.__wbg_ptr, ptr0, len0);
1622
+ var ptr2 = ret[0];
1623
+ var len2 = ret[1];
1624
+ if (ret[3]) {
1625
+ ptr2 = 0; len2 = 0;
1626
+ throw takeFromExternrefTable0(ret[2]);
1627
+ }
1628
+ deferred3_0 = ptr2;
1629
+ deferred3_1 = len2;
1630
+ return getStringFromWasm0(ptr2, len2);
1631
+ } finally {
1632
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1633
+ }
1634
+ }
1635
+ /**
1636
+ * @param {number} id
1637
+ * @returns {boolean}
1638
+ */
1639
+ closeSessionStream(id) {
1640
+ const ret = wasm.server_closeSessionStream(this.__wbg_ptr, id);
1641
+ if (ret[2]) {
1642
+ throw takeFromExternrefTable0(ret[1]);
1643
+ }
1644
+ return ret[0] !== 0;
1645
+ }
1646
+ /**
1647
+ * One question about the registered program (a `ContractQuery` as JSON): its answer as JSON.
1648
+ * @param {string} query_json
1649
+ * @returns {string}
1650
+ */
1651
+ contractQuery(query_json) {
1652
+ let deferred3_0;
1653
+ let deferred3_1;
1654
+ try {
1655
+ const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1656
+ const len0 = WASM_VECTOR_LEN;
1657
+ const ret = wasm.server_contractQuery(this.__wbg_ptr, ptr0, len0);
1658
+ var ptr2 = ret[0];
1659
+ var len2 = ret[1];
1660
+ if (ret[3]) {
1661
+ ptr2 = 0; len2 = 0;
1662
+ throw takeFromExternrefTable0(ret[2]);
1663
+ }
1664
+ deferred3_0 = ptr2;
1665
+ deferred3_1 = len2;
1666
+ return getStringFromWasm0(ptr2, len2);
1667
+ } finally {
1668
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1669
+ }
1670
+ }
1671
+ /**
1672
+ * @returns {boolean}
1673
+ */
1674
+ declaresTicks() {
1675
+ const ret = wasm.server_declaresTicks(this.__wbg_ptr);
1676
+ return ret !== 0;
1677
+ }
1678
+ /**
1679
+ * @returns {string}
1680
+ */
1681
+ dispatchStream() {
1682
+ let deferred2_0;
1683
+ let deferred2_1;
1684
+ try {
1685
+ const ret = wasm.server_dispatchStream(this.__wbg_ptr);
1686
+ var ptr1 = ret[0];
1687
+ var len1 = ret[1];
1688
+ if (ret[3]) {
1689
+ ptr1 = 0; len1 = 0;
1690
+ throw takeFromExternrefTable0(ret[2]);
1691
+ }
1692
+ deferred2_0 = ptr1;
1693
+ deferred2_1 = len1;
1694
+ return getStringFromWasm0(ptr1, len1);
1695
+ } finally {
1696
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1697
+ }
1698
+ }
1699
+ /**
1700
+ * @param {string} url
1701
+ * @returns {boolean}
1702
+ */
1703
+ egressAllows(url) {
1704
+ const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1705
+ const len0 = WASM_VECTOR_LEN;
1706
+ const ret = wasm.server_egressAllows(this.__wbg_ptr, ptr0, len0);
1707
+ return ret !== 0;
1708
+ }
1709
+ /**
1710
+ * @returns {string}
1711
+ */
1712
+ flushTickRelay() {
1713
+ let deferred2_0;
1714
+ let deferred2_1;
1715
+ try {
1716
+ const ret = wasm.server_flushTickRelay(this.__wbg_ptr);
1717
+ var ptr1 = ret[0];
1718
+ var len1 = ret[1];
1719
+ if (ret[3]) {
1720
+ ptr1 = 0; len1 = 0;
1721
+ throw takeFromExternrefTable0(ret[2]);
1722
+ }
1723
+ deferred2_0 = ptr1;
1724
+ deferred2_1 = len1;
1725
+ return getStringFromWasm0(ptr1, len1);
1726
+ } finally {
1727
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1728
+ }
1729
+ }
1730
+ /**
1731
+ * A server holding this one's registered program and none of its session: what a stateless host serves
1732
+ * each request from, instead of registering the program again.
1733
+ * @returns {Server}
1734
+ */
1735
+ fork() {
1736
+ const ret = wasm.server_fork(this.__wbg_ptr);
1737
+ if (ret[2]) {
1738
+ throw takeFromExternrefTable0(ret[1]);
1739
+ }
1740
+ return Server.__wrap(ret[0]);
1741
+ }
1742
+ /**
1743
+ * @param {string} program_json
1744
+ * @returns {Server}
1745
+ */
1746
+ forkProgram(program_json) {
1747
+ const ptr0 = passStringToWasm0(program_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1748
+ const len0 = WASM_VECTOR_LEN;
1749
+ const ret = wasm.server_forkProgram(this.__wbg_ptr, ptr0, len0);
1750
+ if (ret[2]) {
1751
+ throw takeFromExternrefTable0(ret[1]);
1752
+ }
1753
+ return Server.__wrap(ret[0]);
1754
+ }
1755
+ /**
1756
+ * @param {string} trait_name
1757
+ * @param {string | null} [entity_id]
1758
+ * @returns {string}
1759
+ */
1760
+ getState(trait_name, entity_id) {
1761
+ let deferred3_0;
1762
+ let deferred3_1;
1763
+ try {
1764
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1765
+ const len0 = WASM_VECTOR_LEN;
1766
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1767
+ var len1 = WASM_VECTOR_LEN;
1768
+ const ret = wasm.server_getState(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1769
+ deferred3_0 = ret[0];
1770
+ deferred3_1 = ret[1];
1771
+ return getStringFromWasm0(ret[0], ret[1]);
1772
+ } finally {
1773
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1774
+ }
1775
+ }
1776
+ /**
1777
+ * @param {number} flight
1778
+ * @returns {boolean}
1779
+ */
1780
+ holdsLane(flight) {
1781
+ const ret = wasm.server_holdsLane(this.__wbg_ptr, flight);
1782
+ if (ret[2]) {
1783
+ throw takeFromExternrefTable0(ret[1]);
1784
+ }
1785
+ return ret[0] !== 0;
1786
+ }
1787
+ /**
1788
+ * @returns {number}
1789
+ */
1790
+ inFlight() {
1791
+ const ret = wasm.server_inFlight(this.__wbg_ptr);
1792
+ return ret >>> 0;
1793
+ }
1794
+ /**
1795
+ * @returns {string}
1796
+ */
1797
+ lastError() {
1798
+ let deferred1_0;
1799
+ let deferred1_1;
1800
+ try {
1801
+ const ret = wasm.server_lastError(this.__wbg_ptr);
1802
+ deferred1_0 = ret[0];
1803
+ deferred1_1 = ret[1];
1804
+ return getStringFromWasm0(ret[0], ret[1]);
1805
+ } finally {
1806
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1807
+ }
1808
+ }
1809
+ /**
1810
+ * @param {string} item_json
1811
+ * @param {string | null} [client_id]
1812
+ * @returns {boolean}
1813
+ */
1814
+ liveItemDelivered(item_json, client_id) {
1815
+ const ptr0 = passStringToWasm0(item_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1816
+ const len0 = WASM_VECTOR_LEN;
1817
+ var ptr1 = isLikeNone(client_id) ? 0 : passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1818
+ var len1 = WASM_VECTOR_LEN;
1819
+ const ret = wasm.server_liveItemDelivered(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1820
+ if (ret[2]) {
1821
+ throw takeFromExternrefTable0(ret[1]);
1822
+ }
1823
+ return ret[0] !== 0;
1824
+ }
1825
+ /**
1826
+ * @param {string} traits_json
1827
+ */
1828
+ mount(traits_json) {
1829
+ const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1830
+ const len0 = WASM_VECTOR_LEN;
1831
+ const ret = wasm.server_mount(this.__wbg_ptr, ptr0, len0);
1832
+ if (ret[1]) {
1833
+ throw takeFromExternrefTable0(ret[0]);
1834
+ }
1835
+ }
1836
+ /**
1837
+ * @param {string} client
1838
+ * @param {string} orbital
1839
+ * @param {string} traits_json
1840
+ */
1841
+ mountClient(client, orbital, traits_json) {
1842
+ const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1843
+ const len0 = WASM_VECTOR_LEN;
1844
+ const ptr1 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1845
+ const len1 = WASM_VECTOR_LEN;
1846
+ const ptr2 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1847
+ const len2 = WASM_VECTOR_LEN;
1848
+ const ret = wasm.server_mountClient(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1849
+ if (ret[1]) {
1850
+ throw takeFromExternrefTable0(ret[0]);
1851
+ }
1852
+ }
1853
+ /**
1854
+ * @param {string} resolved_schema_json
1855
+ */
1856
+ constructor(resolved_schema_json) {
1857
+ const ptr0 = passStringToWasm0(resolved_schema_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1858
+ const len0 = WASM_VECTOR_LEN;
1859
+ const ret = wasm.server_new(ptr0, len0);
1860
+ if (ret[2]) {
1861
+ throw takeFromExternrefTable0(ret[1]);
1862
+ }
1863
+ this.__wbg_ptr = ret[0];
1864
+ ServerFinalization.register(this, this.__wbg_ptr, this);
1865
+ return this;
1866
+ }
1867
+ /**
1868
+ * The oldest queued request, started now the lane is free (`NextWire` JSON), or `null`.
1869
+ * @returns {string}
1870
+ */
1871
+ next() {
1872
+ let deferred2_0;
1873
+ let deferred2_1;
1874
+ try {
1875
+ const ret = wasm.server_next(this.__wbg_ptr);
1876
+ var ptr1 = ret[0];
1877
+ var len1 = ret[1];
1878
+ if (ret[3]) {
1879
+ ptr1 = 0; len1 = 0;
1880
+ throw takeFromExternrefTable0(ret[2]);
1881
+ }
1882
+ deferred2_0 = ptr1;
1883
+ deferred2_1 = len1;
1884
+ return getStringFromWasm0(ptr1, len1);
1885
+ } finally {
1886
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1887
+ }
1888
+ }
1889
+ /**
1890
+ * A live stream of `client`'s session opened (EXEC-DIST-9); the id closes it.
1891
+ * @param {string} client
1892
+ * @returns {number}
1893
+ */
1894
+ openSessionStream(client) {
1895
+ const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1896
+ const len0 = WASM_VECTOR_LEN;
1897
+ const ret = wasm.server_openSessionStream(this.__wbg_ptr, ptr0, len0);
1898
+ return ret;
1899
+ }
1900
+ /**
1901
+ * @param {string} requirement_json
1902
+ * @param {string | null} [orbital]
1903
+ * @returns {boolean}
1904
+ */
1905
+ osAllows(requirement_json, orbital) {
1906
+ const ptr0 = passStringToWasm0(requirement_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1907
+ const len0 = WASM_VECTOR_LEN;
1908
+ var ptr1 = isLikeNone(orbital) ? 0 : passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1909
+ var len1 = WASM_VECTOR_LEN;
1910
+ const ret = wasm.server_osAllows(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1911
+ if (ret[2]) {
1912
+ throw takeFromExternrefTable0(ret[1]);
1913
+ }
1914
+ return ret[0] !== 0;
1915
+ }
1916
+ /**
1917
+ * @param {string} op
1918
+ * @param {string} args_json
1919
+ * @returns {string}
1920
+ */
1921
+ osResolveArgs(op, args_json) {
1922
+ let deferred4_0;
1923
+ let deferred4_1;
1924
+ try {
1925
+ const ptr0 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1926
+ const len0 = WASM_VECTOR_LEN;
1927
+ const ptr1 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1928
+ const len1 = WASM_VECTOR_LEN;
1929
+ const ret = wasm.server_osResolveArgs(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1930
+ var ptr3 = ret[0];
1931
+ var len3 = ret[1];
1932
+ if (ret[3]) {
1933
+ ptr3 = 0; len3 = 0;
1934
+ throw takeFromExternrefTable0(ret[2]);
1935
+ }
1936
+ deferred4_0 = ptr3;
1937
+ deferred4_1 = len3;
1938
+ return getStringFromWasm0(ptr3, len3);
1939
+ } finally {
1940
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1941
+ }
1942
+ }
1943
+ /**
1944
+ * @param {string | null} [page]
1945
+ * @param {string | null} [route]
1946
+ * @returns {string}
1947
+ */
1948
+ pageCircuit(page, route) {
1949
+ let deferred4_0;
1950
+ let deferred4_1;
1951
+ try {
1952
+ var ptr0 = isLikeNone(page) ? 0 : passStringToWasm0(page, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1953
+ var len0 = WASM_VECTOR_LEN;
1954
+ var ptr1 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1955
+ var len1 = WASM_VECTOR_LEN;
1956
+ const ret = wasm.server_pageCircuit(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1957
+ var ptr3 = ret[0];
1958
+ var len3 = ret[1];
1959
+ if (ret[3]) {
1960
+ ptr3 = 0; len3 = 0;
1961
+ throw takeFromExternrefTable0(ret[2]);
1962
+ }
1963
+ deferred4_0 = ptr3;
1964
+ deferred4_1 = len3;
1965
+ return getStringFromWasm0(ptr3, len3);
1966
+ } finally {
1967
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1968
+ }
1969
+ }
1970
+ /**
1971
+ * @param {string} orbital
1972
+ * @param {string} request_json
1973
+ * @returns {string}
1974
+ */
1975
+ relayTick(orbital, request_json) {
1976
+ let deferred4_0;
1977
+ let deferred4_1;
1978
+ try {
1979
+ const ptr0 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1980
+ const len0 = WASM_VECTOR_LEN;
1981
+ const ptr1 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1982
+ const len1 = WASM_VECTOR_LEN;
1983
+ const ret = wasm.server_relayTick(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1984
+ var ptr3 = ret[0];
1985
+ var len3 = ret[1];
1986
+ if (ret[3]) {
1987
+ ptr3 = 0; len3 = 0;
1988
+ throw takeFromExternrefTable0(ret[2]);
1989
+ }
1990
+ deferred4_0 = ptr3;
1991
+ deferred4_1 = len3;
1992
+ return getStringFromWasm0(ptr3, len3);
1993
+ } finally {
1994
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1995
+ }
1996
+ }
1997
+ /**
1998
+ * @param {string} client
1999
+ */
2000
+ releaseClient(client) {
2001
+ const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2002
+ const len0 = WASM_VECTOR_LEN;
2003
+ wasm.server_releaseClient(this.__wbg_ptr, ptr0, len0);
2004
+ }
2005
+ /**
2006
+ * @param {string} traits_json
2007
+ */
2008
+ remount(traits_json) {
2009
+ const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2010
+ const len0 = WASM_VECTOR_LEN;
2011
+ const ret = wasm.server_remount(this.__wbg_ptr, ptr0, len0);
2012
+ if (ret[1]) {
2013
+ throw takeFromExternrefTable0(ret[0]);
2014
+ }
2015
+ }
2016
+ /**
2017
+ * @param {string} ref_json
2018
+ * @param {string | null} [client_id]
2019
+ * @returns {string}
2020
+ */
2021
+ resolveRows(ref_json, client_id) {
2022
+ let deferred4_0;
2023
+ let deferred4_1;
2024
+ try {
2025
+ const ptr0 = passStringToWasm0(ref_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2026
+ const len0 = WASM_VECTOR_LEN;
2027
+ var ptr1 = isLikeNone(client_id) ? 0 : passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2028
+ var len1 = WASM_VECTOR_LEN;
2029
+ const ret = wasm.server_resolveRows(this.__wbg_ptr, ptr0, len0, ptr1, len1);
2030
+ var ptr3 = ret[0];
2031
+ var len3 = ret[1];
2032
+ if (ret[3]) {
2033
+ ptr3 = 0; len3 = 0;
2034
+ throw takeFromExternrefTable0(ret[2]);
2035
+ }
2036
+ deferred4_0 = ptr3;
2037
+ deferred4_1 = len3;
2038
+ return getStringFromWasm0(ptr3, len3);
2039
+ } finally {
2040
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2041
+ }
2042
+ }
2043
+ /**
2044
+ * @param {number} flight
2045
+ * @param {string} replies_json
2046
+ * @returns {string}
2047
+ */
2048
+ resume(flight, replies_json) {
2049
+ let deferred3_0;
2050
+ let deferred3_1;
2051
+ try {
2052
+ const ptr0 = passStringToWasm0(replies_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2053
+ const len0 = WASM_VECTOR_LEN;
2054
+ const ret = wasm.server_resume(this.__wbg_ptr, flight, ptr0, len0);
2055
+ var ptr2 = ret[0];
2056
+ var len2 = ret[1];
2057
+ if (ret[3]) {
2058
+ ptr2 = 0; len2 = 0;
2059
+ throw takeFromExternrefTable0(ret[2]);
2060
+ }
2061
+ deferred3_0 = ptr2;
2062
+ deferred3_1 = len2;
2063
+ return getStringFromWasm0(ptr2, len2);
2064
+ } finally {
2065
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2066
+ }
2067
+ }
2068
+ /**
2069
+ * @param {number} flight
2070
+ * @param {string} replies_json
2071
+ * @returns {string}
2072
+ */
2073
+ resumeResolve(flight, replies_json) {
2074
+ let deferred3_0;
2075
+ let deferred3_1;
2076
+ try {
2077
+ const ptr0 = passStringToWasm0(replies_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2078
+ const len0 = WASM_VECTOR_LEN;
2079
+ const ret = wasm.server_resumeResolve(this.__wbg_ptr, flight, ptr0, len0);
2080
+ var ptr2 = ret[0];
2081
+ var len2 = ret[1];
2082
+ if (ret[3]) {
2083
+ ptr2 = 0; len2 = 0;
2084
+ throw takeFromExternrefTable0(ret[2]);
2085
+ }
2086
+ deferred3_0 = ptr2;
2087
+ deferred3_1 = len2;
2088
+ return getStringFromWasm0(ptr2, len2);
2089
+ } finally {
2090
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2091
+ }
2092
+ }
2093
+ /**
2094
+ * @param {string} route_path
2095
+ * @returns {string}
2096
+ */
2097
+ routeMounts(route_path) {
2098
+ let deferred3_0;
2099
+ let deferred3_1;
2100
+ try {
2101
+ const ptr0 = passStringToWasm0(route_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2102
+ const len0 = WASM_VECTOR_LEN;
2103
+ const ret = wasm.server_routeMounts(this.__wbg_ptr, ptr0, len0);
2104
+ var ptr2 = ret[0];
2105
+ var len2 = ret[1];
2106
+ if (ret[3]) {
2107
+ ptr2 = 0; len2 = 0;
2108
+ throw takeFromExternrefTable0(ret[2]);
2109
+ }
2110
+ deferred3_0 = ptr2;
2111
+ deferred3_1 = len2;
2112
+ return getStringFromWasm0(ptr2, len2);
2113
+ } finally {
2114
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2115
+ }
2116
+ }
2117
+ /**
2118
+ * @param {string} entity_type
2119
+ * @param {string} query_json
2120
+ * @param {string} write_json
2121
+ */
2122
+ setCapabilities(entity_type, query_json, write_json) {
2123
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2124
+ const len0 = WASM_VECTOR_LEN;
2125
+ const ptr1 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2126
+ const len1 = WASM_VECTOR_LEN;
2127
+ const ptr2 = passStringToWasm0(write_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2128
+ const len2 = WASM_VECTOR_LEN;
2129
+ const ret = wasm.server_setCapabilities(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
2130
+ if (ret[1]) {
2131
+ throw takeFromExternrefTable0(ret[0]);
2132
+ }
2133
+ }
2134
+ /**
2135
+ * @param {string} program_json
2136
+ */
2137
+ setManagedProgram(program_json) {
2138
+ const ptr0 = passStringToWasm0(program_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2139
+ const len0 = WASM_VECTOR_LEN;
2140
+ const ret = wasm.server_setManagedProgram(this.__wbg_ptr, ptr0, len0);
2141
+ if (ret[1]) {
2142
+ throw takeFromExternrefTable0(ret[0]);
2143
+ }
2144
+ }
2145
+ /**
2146
+ * @param {string} locales_json
2147
+ * @param {string} catalogs_json
2148
+ */
2149
+ setMessages(locales_json, catalogs_json) {
2150
+ const ptr0 = passStringToWasm0(locales_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2151
+ const len0 = WASM_VECTOR_LEN;
2152
+ const ptr1 = passStringToWasm0(catalogs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2153
+ const len1 = WASM_VECTOR_LEN;
2154
+ const ret = wasm.server_setMessages(this.__wbg_ptr, ptr0, len0, ptr1, len1);
2155
+ if (ret[1]) {
2156
+ throw takeFromExternrefTable0(ret[0]);
2157
+ }
2158
+ }
2159
+ /**
2160
+ * @param {string} anchors_json
2161
+ * @returns {string}
2162
+ */
2163
+ setOsAnchors(anchors_json) {
2164
+ let deferred3_0;
2165
+ let deferred3_1;
2166
+ try {
2167
+ const ptr0 = passStringToWasm0(anchors_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2168
+ const len0 = WASM_VECTOR_LEN;
2169
+ const ret = wasm.server_setOsAnchors(this.__wbg_ptr, ptr0, len0);
2170
+ var ptr2 = ret[0];
2171
+ var len2 = ret[1];
2172
+ if (ret[3]) {
2173
+ ptr2 = 0; len2 = 0;
2174
+ throw takeFromExternrefTable0(ret[2]);
2175
+ }
2176
+ deferred3_0 = ptr2;
2177
+ deferred3_1 = len2;
2178
+ return getStringFromWasm0(ptr2, len2);
2179
+ } finally {
2180
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2181
+ }
2182
+ }
2183
+ /**
2184
+ * @param {boolean} stateful
2185
+ */
2186
+ setStateful(stateful) {
2187
+ wasm.server_setStateful(this.__wbg_ptr, stateful);
2188
+ }
2189
+ /**
2190
+ * @param {number} interval_ms
2191
+ */
2192
+ setTickRelayInterval(interval_ms) {
2193
+ wasm.server_setTickRelayInterval(this.__wbg_ptr, interval_ms);
2194
+ }
2195
+ /**
2196
+ * @param {string} orbital
2197
+ * @param {string} request_json
2198
+ * @returns {string}
2199
+ */
2200
+ start(orbital, request_json) {
2201
+ let deferred4_0;
2202
+ let deferred4_1;
2203
+ try {
2204
+ const ptr0 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2205
+ const len0 = WASM_VECTOR_LEN;
2206
+ const ptr1 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2207
+ const len1 = WASM_VECTOR_LEN;
2208
+ const ret = wasm.server_start(this.__wbg_ptr, ptr0, len0, ptr1, len1);
2209
+ var ptr3 = ret[0];
2210
+ var len3 = ret[1];
2211
+ if (ret[3]) {
2212
+ ptr3 = 0; len3 = 0;
2213
+ throw takeFromExternrefTable0(ret[2]);
2214
+ }
2215
+ deferred4_0 = ptr3;
2216
+ deferred4_1 = len3;
2217
+ return getStringFromWasm0(ptr3, len3);
2218
+ } finally {
2219
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2220
+ }
2221
+ }
2222
+ /**
2223
+ * @param {number} now_ms
2224
+ * @returns {string}
2225
+ */
2226
+ tickPass(now_ms) {
2227
+ let deferred2_0;
2228
+ let deferred2_1;
2229
+ try {
2230
+ const ret = wasm.server_tickPass(this.__wbg_ptr, now_ms);
2231
+ var ptr1 = ret[0];
2232
+ var len1 = ret[1];
2233
+ if (ret[3]) {
2234
+ ptr1 = 0; len1 = 0;
2235
+ throw takeFromExternrefTable0(ret[2]);
2236
+ }
2237
+ deferred2_0 = ptr1;
2238
+ deferred2_1 = len1;
2239
+ return getStringFromWasm0(ptr1, len1);
2240
+ } finally {
2241
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
2242
+ }
2243
+ }
2244
+ tickPause() {
2245
+ wasm.server_tickPause(this.__wbg_ptr);
2246
+ }
2247
+ /**
2248
+ * @returns {boolean}
2249
+ */
2250
+ tickPaused() {
2251
+ const ret = wasm.server_tickPaused(this.__wbg_ptr);
2252
+ return ret !== 0;
2253
+ }
2254
+ tickResume() {
2255
+ wasm.server_tickResume(this.__wbg_ptr);
2256
+ }
2257
+ /**
2258
+ * Feed a deferred raw `os/` outcome into the TLS operation the kernel parked under `key`: `null` when `key` parks
2259
+ * none, `{ ask: { op, args } }` for the next raw ask the host must answer, or `{ done: Settled }`.
2260
+ * @param {string} key
2261
+ * @param {string} outcome_json
2262
+ * @returns {string}
2263
+ */
2264
+ tlsComplete(key, outcome_json) {
2265
+ let deferred4_0;
2266
+ let deferred4_1;
2267
+ try {
2268
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2269
+ const len0 = WASM_VECTOR_LEN;
2270
+ const ptr1 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2271
+ const len1 = WASM_VECTOR_LEN;
2272
+ const ret = wasm.server_tlsComplete(this.__wbg_ptr, ptr0, len0, ptr1, len1);
2273
+ var ptr3 = ret[0];
2274
+ var len3 = ret[1];
2275
+ if (ret[3]) {
2276
+ ptr3 = 0; len3 = 0;
2277
+ throw takeFromExternrefTable0(ret[2]);
2278
+ }
2279
+ deferred4_0 = ptr3;
2280
+ deferred4_1 = len3;
2281
+ return getStringFromWasm0(ptr3, len3);
2282
+ } finally {
2283
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2284
+ }
2285
+ }
2286
+ /**
2287
+ * @param {string} client
2288
+ * @param {string} orbital
2289
+ * @param {string} traits_json
2290
+ */
2291
+ unmountClient(client, orbital, traits_json) {
2292
+ const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2293
+ const len0 = WASM_VECTOR_LEN;
2294
+ const ptr1 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2295
+ const len1 = WASM_VECTOR_LEN;
2296
+ const ptr2 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2297
+ const len2 = WASM_VECTOR_LEN;
2298
+ const ret = wasm.server_unmountClient(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
2299
+ if (ret[1]) {
2300
+ throw takeFromExternrefTable0(ret[0]);
2301
+ }
2302
+ }
2303
+ }
2304
+ if (Symbol.dispose) Server.prototype[Symbol.dispose] = Server.prototype.free;
2305
+
2306
+ /**
2307
+ * Whether a row may be created, updated or deleted under a directive (`MutationVerdictWire` as JSON).
2308
+ * @param {string} operation
2309
+ * @param {string} bindings_json
2310
+ * @param {string} row_json
2311
+ * @param {string} policy_json
2312
+ * @param {string} entity_type
2313
+ * @returns {string}
2314
+ */
2315
+ export function checkMutationAccess(operation, bindings_json, row_json, policy_json, entity_type) {
2316
+ let deferred7_0;
2317
+ let deferred7_1;
2318
+ try {
2319
+ const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2320
+ const len0 = WASM_VECTOR_LEN;
2321
+ const ptr1 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2322
+ const len1 = WASM_VECTOR_LEN;
2323
+ const ptr2 = passStringToWasm0(row_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2324
+ const len2 = WASM_VECTOR_LEN;
2325
+ const ptr3 = passStringToWasm0(policy_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2326
+ const len3 = WASM_VECTOR_LEN;
2327
+ const ptr4 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2328
+ const len4 = WASM_VECTOR_LEN;
2329
+ const ret = wasm.checkMutationAccess(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
2330
+ var ptr6 = ret[0];
2331
+ var len6 = ret[1];
2332
+ if (ret[3]) {
2333
+ ptr6 = 0; len6 = 0;
2334
+ throw takeFromExternrefTable0(ret[2]);
2335
+ }
2336
+ deferred7_0 = ptr6;
2337
+ deferred7_1 = len6;
2338
+ return getStringFromWasm0(ptr6, len6);
2339
+ } finally {
2340
+ wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
2341
+ }
2342
+ }
2343
+
2344
+ /**
2345
+ * One `ContractQuery` (as JSON) answered for a host with no registered program, as JSON.
2346
+ * @param {string} query_json
2347
+ * @returns {string}
2348
+ */
2349
+ export function contractQueryWithoutProgram(query_json) {
2350
+ let deferred3_0;
2351
+ let deferred3_1;
2352
+ try {
2353
+ const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2354
+ const len0 = WASM_VECTOR_LEN;
2355
+ const ret = wasm.contractQueryWithoutProgram(ptr0, len0);
2356
+ var ptr2 = ret[0];
2357
+ var len2 = ret[1];
2358
+ if (ret[3]) {
2359
+ ptr2 = 0; len2 = 0;
2360
+ throw takeFromExternrefTable0(ret[2]);
2361
+ }
2362
+ deferred3_0 = ptr2;
2363
+ deferred3_1 = len2;
2364
+ return getStringFromWasm0(ptr2, len2);
2365
+ } finally {
2366
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2367
+ }
2368
+ }
2369
+
2370
+ /**
2371
+ * Every guard of a render against a context in one crossing (`GuardOutcomeWire[]` as JSON).
2372
+ * @param {string} context_json
2373
+ * @param {string} guards_json
2374
+ * @returns {string}
2375
+ */
2376
+ export function evaluateGuards(context_json, guards_json) {
2377
+ let deferred4_0;
2378
+ let deferred4_1;
2379
+ try {
2380
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2381
+ const len0 = WASM_VECTOR_LEN;
2382
+ const ptr1 = passStringToWasm0(guards_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2383
+ const len1 = WASM_VECTOR_LEN;
2384
+ const ret = wasm.evaluateGuards(ptr0, len0, ptr1, len1);
2385
+ var ptr3 = ret[0];
2386
+ var len3 = ret[1];
2387
+ if (ret[3]) {
2388
+ ptr3 = 0; len3 = 0;
2389
+ throw takeFromExternrefTable0(ret[2]);
2390
+ }
2391
+ deferred4_0 = ptr3;
2392
+ deferred4_1 = len3;
2393
+ return getStringFromWasm0(ptr3, len3);
2394
+ } finally {
2395
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2396
+ }
2397
+ }
2398
+
2399
+ /**
2400
+ * Evaluate `expressionsJson` (`SExpr[]`) against `contextJson` (`EvalContextWire`) in one crossing:
2401
+ * `EvalOutcomeWire[]` as JSON, in order.
2402
+ * @param {string} context_json
2403
+ * @param {string} expressions_json
2404
+ * @returns {string}
2405
+ */
2406
+ export function evaluateMany(context_json, expressions_json) {
2407
+ let deferred4_0;
2408
+ let deferred4_1;
2409
+ try {
2410
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2411
+ const len0 = WASM_VECTOR_LEN;
2412
+ const ptr1 = passStringToWasm0(expressions_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2413
+ const len1 = WASM_VECTOR_LEN;
2414
+ const ret = wasm.evaluateMany(ptr0, len0, ptr1, len1);
2415
+ var ptr3 = ret[0];
2416
+ var len3 = ret[1];
2417
+ if (ret[3]) {
2418
+ ptr3 = 0; len3 = 0;
2419
+ throw takeFromExternrefTable0(ret[2]);
2420
+ }
2421
+ deferred4_0 = ptr3;
2422
+ deferred4_1 = len3;
2423
+ return getStringFromWasm0(ptr3, len3);
2424
+ } finally {
2425
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2426
+ }
2427
+ }
2428
+
2429
+ /**
2430
+ * One expression with its trace (`EvalTracedWire` as JSON).
2431
+ * @param {string} context_json
2432
+ * @param {string} expression_json
2433
+ * @returns {string}
2434
+ */
2435
+ export function evaluateTraced(context_json, expression_json) {
2436
+ let deferred4_0;
2437
+ let deferred4_1;
2438
+ try {
2439
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2440
+ const len0 = WASM_VECTOR_LEN;
2441
+ const ptr1 = passStringToWasm0(expression_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2442
+ const len1 = WASM_VECTOR_LEN;
2443
+ const ret = wasm.evaluateTraced(ptr0, len0, ptr1, len1);
2444
+ var ptr3 = ret[0];
2445
+ var len3 = ret[1];
2446
+ if (ret[3]) {
2447
+ ptr3 = 0; len3 = 0;
2448
+ throw takeFromExternrefTable0(ret[2]);
2449
+ }
2450
+ deferred4_0 = ptr3;
2451
+ deferred4_1 = len3;
2452
+ return getStringFromWasm0(ptr3, len3);
2453
+ } finally {
2454
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2455
+ }
2456
+ }
2457
+
2458
+ /**
2459
+ * The program's emitter-to-listener wire table (`EventWire[]` as JSON), by the source rule the kernel delivers by.
2460
+ * @param {string} schema_json
2461
+ * @returns {string}
2462
+ */
2463
+ export function eventWires(schema_json) {
2464
+ let deferred3_0;
2465
+ let deferred3_1;
2466
+ try {
2467
+ const ptr0 = passStringToWasm0(schema_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2468
+ const len0 = WASM_VECTOR_LEN;
2469
+ const ret = wasm.eventWires(ptr0, len0);
2470
+ var ptr2 = ret[0];
2471
+ var len2 = ret[1];
2472
+ if (ret[3]) {
2473
+ ptr2 = 0; len2 = 0;
2474
+ throw takeFromExternrefTable0(ret[2]);
2475
+ }
2476
+ deferred3_0 = ptr2;
2477
+ deferred3_1 = len2;
2478
+ return getStringFromWasm0(ptr2, len2);
2479
+ } finally {
2480
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2481
+ }
2482
+ }
2483
+
2484
+ /**
2485
+ * Install the language data a host assembles from its installed `@almadar/core` and `@almadar/std`
2486
+ * (`readLanguageBundle`): the operator table that routes `program/*` and the other host effects.
2487
+ * @param {string} bundle_json
2488
+ */
2489
+ export function installLanguage(bundle_json) {
2490
+ const ptr0 = passStringToWasm0(bundle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2491
+ const len0 = WASM_VECTOR_LEN;
2492
+ const ret = wasm.installLanguage(ptr0, len0);
2493
+ if (ret[1]) {
2494
+ throw takeFromExternrefTable0(ret[0]);
2495
+ }
2496
+ }
2497
+
2498
+ /**
2499
+ * @param {string} ip
2500
+ * @returns {boolean}
2501
+ */
2502
+ export function isPublicAddress(ip) {
2503
+ const ptr0 = passStringToWasm0(ip, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2504
+ const len0 = WASM_VECTOR_LEN;
2505
+ const ret = wasm.isPublicAddress(ptr0, len0);
2506
+ if (ret[2]) {
2507
+ throw takeFromExternrefTable0(ret[1]);
2508
+ }
2509
+ return ret[0] !== 0;
2510
+ }
2511
+
2512
+ /**
2513
+ * A listen route's `with` mapping applied to the source payload (the mapped payload as JSON).
2514
+ * @param {string} mapping_json
2515
+ * @param {string} payload_json
2516
+ * @returns {string}
2517
+ */
2518
+ export function mapListenPayload(mapping_json, payload_json) {
2519
+ let deferred4_0;
2520
+ let deferred4_1;
2521
+ try {
2522
+ const ptr0 = passStringToWasm0(mapping_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2523
+ const len0 = WASM_VECTOR_LEN;
2524
+ const ptr1 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2525
+ const len1 = WASM_VECTOR_LEN;
2526
+ const ret = wasm.mapListenPayload(ptr0, len0, ptr1, len1);
2527
+ var ptr3 = ret[0];
2528
+ var len3 = ret[1];
2529
+ if (ret[3]) {
2530
+ ptr3 = 0; len3 = 0;
2531
+ throw takeFromExternrefTable0(ret[2]);
2532
+ }
2533
+ deferred4_0 = ptr3;
2534
+ deferred4_1 = len3;
2535
+ return getStringFromWasm0(ptr3, len3);
2536
+ } finally {
2537
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2538
+ }
2539
+ }
2540
+
2541
+ /**
2542
+ * The `{ event, payload }` a deferred keyed `os/` call's outcome (`Settled`) fires on its call site, or `null`.
2543
+ * @param {string} site_json
2544
+ * @param {string} key
2545
+ * @param {string} outcome_json
2546
+ * @returns {string}
2547
+ */
2548
+ export function osCompletionEvent(site_json, key, outcome_json) {
2549
+ let deferred5_0;
2550
+ let deferred5_1;
2551
+ try {
2552
+ const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2553
+ const len0 = WASM_VECTOR_LEN;
2554
+ const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2555
+ const len1 = WASM_VECTOR_LEN;
2556
+ const ptr2 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2557
+ const len2 = WASM_VECTOR_LEN;
2558
+ const ret = wasm.osCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2);
2559
+ var ptr4 = ret[0];
2560
+ var len4 = ret[1];
2561
+ if (ret[3]) {
2562
+ ptr4 = 0; len4 = 0;
2563
+ throw takeFromExternrefTable0(ret[2]);
2564
+ }
2565
+ deferred5_0 = ptr4;
2566
+ deferred5_1 = len4;
2567
+ return getStringFromWasm0(ptr4, len4);
2568
+ } finally {
2569
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
2570
+ }
2571
+ }
2572
+
2573
+ /**
2574
+ * The names of the `os/` operations whose keyed call may defer its completion, as a JSON array.
2575
+ * @returns {string}
2576
+ */
2577
+ export function osDeferringOps() {
2578
+ let deferred2_0;
2579
+ let deferred2_1;
2580
+ try {
2581
+ const ret = wasm.osDeferringOps();
2582
+ var ptr1 = ret[0];
2583
+ var len1 = ret[1];
2584
+ if (ret[3]) {
2585
+ ptr1 = 0; len1 = 0;
2586
+ throw takeFromExternrefTable0(ret[2]);
2587
+ }
2588
+ deferred2_0 = ptr1;
2589
+ deferred2_1 = len1;
2590
+ return getStringFromWasm0(ptr1, len1);
2591
+ } finally {
2592
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
2593
+ }
2594
+ }
2595
+
2596
+ /**
2597
+ * @param {string} glob
2598
+ * @param {string} path
2599
+ * @returns {boolean}
2600
+ */
2601
+ export function osGlobMatches(glob, path) {
2602
+ const ptr0 = passStringToWasm0(glob, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2603
+ const len0 = WASM_VECTOR_LEN;
2604
+ const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2605
+ const len1 = WASM_VECTOR_LEN;
2606
+ const ret = wasm.osGlobMatches(ptr0, len0, ptr1, len1);
2607
+ return ret !== 0;
2608
+ }
2609
+
2610
+ /**
2611
+ * The names of the `os/` operations whose keyed call is a stream, as a JSON array.
2612
+ * @returns {string}
2613
+ */
2614
+ export function osStreamOps() {
2615
+ let deferred2_0;
2616
+ let deferred2_1;
2617
+ try {
2618
+ const ret = wasm.osStreamOps();
2619
+ var ptr1 = ret[0];
2620
+ var len1 = ret[1];
2621
+ if (ret[3]) {
2622
+ ptr1 = 0; len1 = 0;
2623
+ throw takeFromExternrefTable0(ret[2]);
2624
+ }
2625
+ deferred2_0 = ptr1;
2626
+ deferred2_1 = len1;
2627
+ return getStringFromWasm0(ptr1, len1);
2628
+ } finally {
2629
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
2630
+ }
2631
+ }
2632
+
2633
+ /**
2634
+ * The typed event request a `program/dispatch` call names, as an object; a record that is no event request throws the reason.
2635
+ * @param {string} payload_json
2636
+ * @param {string} options_json
2637
+ * @returns {any}
2638
+ */
2639
+ export function parseEventRequest(payload_json, options_json) {
2640
+ const ptr0 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2641
+ const len0 = WASM_VECTOR_LEN;
2642
+ const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2643
+ const len1 = WASM_VECTOR_LEN;
2644
+ const ret = wasm.parseEventRequest(ptr0, len0, ptr1, len1);
2645
+ if (ret[2]) {
2646
+ throw takeFromExternrefTable0(ret[1]);
2647
+ }
2648
+ return takeFromExternrefTable0(ret[0]);
2649
+ }
2650
+
2651
+ export function report_panics() {
2652
+ wasm.report_panics();
2653
+ }
2654
+
2655
+ /**
2656
+ * What a `@user`/`@payload`/`@config`/`@now` term folds to for a row predicate (`RowBindingWire` as JSON).
2657
+ * @param {string} term
2658
+ * @param {string} bindings_json
2659
+ * @returns {string}
2660
+ */
2661
+ export function resolveRowBinding(term, bindings_json) {
2662
+ let deferred4_0;
2663
+ let deferred4_1;
2664
+ try {
2665
+ const ptr0 = passStringToWasm0(term, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2666
+ const len0 = WASM_VECTOR_LEN;
2667
+ const ptr1 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2668
+ const len1 = WASM_VECTOR_LEN;
2669
+ const ret = wasm.resolveRowBinding(ptr0, len0, ptr1, len1);
2670
+ var ptr3 = ret[0];
2671
+ var len3 = ret[1];
2672
+ if (ret[3]) {
2673
+ ptr3 = 0; len3 = 0;
2674
+ throw takeFromExternrefTable0(ret[2]);
2675
+ }
2676
+ deferred4_0 = ptr3;
2677
+ deferred4_1 = len3;
2678
+ return getStringFromWasm0(ptr3, len3);
2679
+ } finally {
2680
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2681
+ }
2682
+ }
2683
+
2684
+ /**
2685
+ * Resolve every prop value of a render against `contextJson` in one crossing: each binding, embedded ones
2686
+ * included, and each operator call (`EvalOutcomeWire[]` as JSON, in order).
2687
+ * @param {string} context_json
2688
+ * @param {string} values_json
2689
+ * @returns {string}
2690
+ */
2691
+ export function resolveValues(context_json, values_json) {
2692
+ let deferred4_0;
2693
+ let deferred4_1;
2694
+ try {
2695
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2696
+ const len0 = WASM_VECTOR_LEN;
2697
+ const ptr1 = passStringToWasm0(values_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2698
+ const len1 = WASM_VECTOR_LEN;
2699
+ const ret = wasm.resolveValues(ptr0, len0, ptr1, len1);
2700
+ var ptr3 = ret[0];
2701
+ var len3 = ret[1];
2702
+ if (ret[3]) {
2703
+ ptr3 = 0; len3 = 0;
2704
+ throw takeFromExternrefTable0(ret[2]);
2705
+ }
2706
+ deferred4_0 = ptr3;
2707
+ deferred4_1 = len3;
2708
+ return getStringFromWasm0(ptr3, len3);
2709
+ } finally {
2710
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2711
+ }
2712
+ }
2713
+
2714
+ /**
2715
+ * The rows that pass a `@read` policy and a call-site filter (each an `SExpr` as JSON, or empty).
2716
+ * @param {string} bindings_json
2717
+ * @param {string} rows_json
2718
+ * @param {string} policy_json
2719
+ * @param {string} filter_json
2720
+ * @param {string} entity_type
2721
+ * @returns {string}
2722
+ */
2723
+ export function scopeRows(bindings_json, rows_json, policy_json, filter_json, entity_type) {
2724
+ let deferred7_0;
2725
+ let deferred7_1;
2726
+ try {
2727
+ const ptr0 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2728
+ const len0 = WASM_VECTOR_LEN;
2729
+ const ptr1 = passStringToWasm0(rows_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2730
+ const len1 = WASM_VECTOR_LEN;
2731
+ const ptr2 = passStringToWasm0(policy_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2732
+ const len2 = WASM_VECTOR_LEN;
2733
+ const ptr3 = passStringToWasm0(filter_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2734
+ const len3 = WASM_VECTOR_LEN;
2735
+ const ptr4 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2736
+ const len4 = WASM_VECTOR_LEN;
2737
+ const ret = wasm.scopeRows(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
2738
+ var ptr6 = ret[0];
2739
+ var len6 = ret[1];
2740
+ if (ret[3]) {
2741
+ ptr6 = 0; len6 = 0;
2742
+ throw takeFromExternrefTable0(ret[2]);
2743
+ }
2744
+ deferred7_0 = ptr6;
2745
+ deferred7_1 = len6;
2746
+ return getStringFromWasm0(ptr6, len6);
2747
+ } finally {
2748
+ wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
2749
+ }
2750
+ }
2751
+
2752
+ /**
2753
+ * @param {string} site_json
2754
+ * @param {string} key
2755
+ * @param {string} op
2756
+ * @param {string} args_json
2757
+ * @param {string} outcome_json
2758
+ * @returns {string}
2759
+ */
2760
+ export function substrateCompletionEvent(site_json, key, op, args_json, outcome_json) {
2761
+ let deferred7_0;
2762
+ let deferred7_1;
2763
+ try {
2764
+ const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2765
+ const len0 = WASM_VECTOR_LEN;
2766
+ const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2767
+ const len1 = WASM_VECTOR_LEN;
2768
+ const ptr2 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2769
+ const len2 = WASM_VECTOR_LEN;
2770
+ const ptr3 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2771
+ const len3 = WASM_VECTOR_LEN;
2772
+ const ptr4 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2773
+ const len4 = WASM_VECTOR_LEN;
2774
+ const ret = wasm.substrateCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
2775
+ var ptr6 = ret[0];
2776
+ var len6 = ret[1];
2777
+ if (ret[3]) {
2778
+ ptr6 = 0; len6 = 0;
2779
+ throw takeFromExternrefTable0(ret[2]);
2780
+ }
2781
+ deferred7_0 = ptr6;
2782
+ deferred7_1 = len6;
2783
+ return getStringFromWasm0(ptr6, len6);
2784
+ } finally {
2785
+ wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
2786
+ }
2787
+ }
2788
+
2789
+ /**
2790
+ * Whether the Chrome match pattern `pattern` matches `url`.
2791
+ * @param {string} pattern
2792
+ * @param {string} url
2793
+ * @returns {boolean}
2794
+ */
2795
+ export function tabUrlMatches(pattern, url) {
2796
+ const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2797
+ const len0 = WASM_VECTOR_LEN;
2798
+ const ptr1 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2799
+ const len1 = WASM_VECTOR_LEN;
2800
+ const ret = wasm.tabUrlMatches(ptr0, len0, ptr1, len1);
2801
+ return ret !== 0;
2802
+ }
2803
+
2804
+ /**
2805
+ * Effects run in order against a row (`TraceEffectsWire` as JSON): a trace per effect, the events raised, the writes made.
2806
+ * @param {string} context_json
2807
+ * @param {string} effects_json
2808
+ * @returns {string}
2809
+ */
2810
+ export function traceEffects(context_json, effects_json) {
2811
+ let deferred4_0;
2812
+ let deferred4_1;
2813
+ try {
2814
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2815
+ const len0 = WASM_VECTOR_LEN;
2816
+ const ptr1 = passStringToWasm0(effects_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2817
+ const len1 = WASM_VECTOR_LEN;
2818
+ const ret = wasm.traceEffects(ptr0, len0, ptr1, len1);
2819
+ var ptr3 = ret[0];
2820
+ var len3 = ret[1];
2821
+ if (ret[3]) {
2822
+ ptr3 = 0; len3 = 0;
2823
+ throw takeFromExternrefTable0(ret[2]);
2824
+ }
2825
+ deferred4_0 = ptr3;
2826
+ deferred4_1 = len3;
2827
+ return getStringFromWasm0(ptr3, len3);
2828
+ } finally {
2829
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2830
+ }
2831
+ }
2832
+
2833
+ /**
2834
+ * The kernel's verdict on language packs (`[{ package, definition }]` as JSON): throws the refusal that names each pack, section and word.
2835
+ * @param {string} packs_json
2836
+ */
2837
+ export function validatePacks(packs_json) {
2838
+ const ptr0 = passStringToWasm0(packs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2839
+ const len0 = WASM_VECTOR_LEN;
2840
+ const ret = wasm.validatePacks(ptr0, len0);
2841
+ if (ret[1]) {
2842
+ throw takeFromExternrefTable0(ret[0]);
2843
+ }
2844
+ }
2845
+ function __wbg_get_imports() {
2846
+ const import0 = {
2847
+ __proto__: null,
2848
+ __wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
2849
+ const ret = Error(getStringFromWasm0(arg0, arg1));
2850
+ return ret;
2851
+ },
2852
+ __wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
2853
+ const ret = typeof(arg0) === 'function';
2854
+ return ret;
2855
+ },
2856
+ __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
2857
+ const val = arg0;
2858
+ const ret = typeof(val) === 'object' && val !== null;
2859
+ return ret;
2860
+ },
2861
+ __wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
2862
+ const ret = typeof(arg0) === 'string';
2863
+ return ret;
2864
+ },
2865
+ __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
2866
+ const ret = arg0 === undefined;
2867
+ return ret;
2868
+ },
2869
+ __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
2870
+ throw new Error(getStringFromWasm0(arg0, arg1));
2871
+ },
2872
+ __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
2873
+ const ret = arg0.call(arg1, arg2);
2874
+ return ret;
2875
+ }, arguments); },
2876
+ __wbg_crypto_38df2bab126b63dc: function(arg0) {
2877
+ const ret = arg0.crypto;
2878
+ return ret;
2879
+ },
2880
+ __wbg_error_96e899f14d8344a2: function(arg0, arg1) {
2881
+ console.error(getStringFromWasm0(arg0, arg1));
2882
+ },
2883
+ __wbg_getDate_a1a40c1c5f40fe3b: function(arg0) {
2884
+ const ret = arg0.getDate();
2885
+ return ret;
2886
+ },
2887
+ __wbg_getDay_aa318cce5da74c49: function(arg0) {
2888
+ const ret = arg0.getDay();
2889
+ return ret;
2890
+ },
2891
+ __wbg_getFullYear_6af8b229792ae254: function(arg0) {
2892
+ const ret = arg0.getFullYear();
2893
+ return ret;
2894
+ },
2895
+ __wbg_getHours_9f6561095682ce51: function(arg0) {
2896
+ const ret = arg0.getHours();
2897
+ return ret;
2898
+ },
2899
+ __wbg_getMinutes_b0d5cd90bf9b8f22: function(arg0) {
2900
+ const ret = arg0.getMinutes();
2901
+ return ret;
2902
+ },
2903
+ __wbg_getMonth_fffe29d654d5eb69: function(arg0) {
2904
+ const ret = arg0.getMonth();
2905
+ return ret;
2906
+ },
2907
+ __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
2908
+ arg0.getRandomValues(arg1);
2909
+ }, arguments); },
2910
+ __wbg_length_1f0964f4a5e2c6d8: function(arg0) {
2911
+ const ret = arg0.length;
2912
+ return ret;
2913
+ },
2914
+ __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
2915
+ const ret = arg0.msCrypto;
2916
+ return ret;
2917
+ },
2918
+ __wbg_new_0_3da9e97f24fc69be: function() {
2919
+ const ret = new Date();
2920
+ return ret;
2921
+ },
2922
+ __wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
2923
+ const ret = new Uint8Array(arg0 >>> 0);
2924
+ return ret;
2925
+ },
2926
+ __wbg_node_84ea875411254db1: function(arg0) {
2927
+ const ret = arg0.node;
2928
+ return ret;
2929
+ },
2930
+ __wbg_now_86c0d4ba3fa605b8: function() {
2931
+ const ret = Date.now();
2932
+ return ret;
2933
+ },
2934
+ __wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
2935
+ const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
2936
+ return ret;
2937
+ }, arguments); },
2938
+ __wbg_process_44c7a14e11e9f69e: function(arg0) {
2939
+ const ret = arg0.process;
2940
+ return ret;
2941
+ },
2942
+ __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
2943
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
2944
+ },
2945
+ __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
2946
+ arg0.randomFillSync(arg1);
2947
+ }, arguments); },
2948
+ __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
2949
+ const ret = module.require;
2950
+ return ret;
2951
+ }, arguments); },
2952
+ __wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
2953
+ const ret = typeof global === 'undefined' ? null : global;
2954
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2955
+ },
2956
+ __wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4: function() {
2957
+ const ret = typeof globalThis === 'undefined' ? null : globalThis;
2958
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2959
+ },
2960
+ __wbg_static_accessor_SELF_146583524fe1469b: function() {
2961
+ const ret = typeof self === 'undefined' ? null : self;
2962
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2963
+ },
2964
+ __wbg_static_accessor_WINDOW_f2829a2234d7819e: function() {
2965
+ const ret = typeof window === 'undefined' ? null : window;
2966
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2967
+ },
2968
+ __wbg_subarray_3ed232c8a6baee09: function(arg0, arg1, arg2) {
2969
+ const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
2970
+ return ret;
2971
+ },
2972
+ __wbg_versions_276b2795b1c6a219: function(arg0) {
2973
+ const ret = arg0.versions;
2974
+ return ret;
2975
+ },
2976
+ __wbindgen_cast_0000000000000001: function(arg0, arg1) {
2977
+ // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
2978
+ const ret = getArrayU8FromWasm0(arg0, arg1);
2979
+ return ret;
2980
+ },
2981
+ __wbindgen_cast_0000000000000002: function(arg0, arg1) {
2982
+ // Cast intrinsic for `Ref(String) -> Externref`.
2983
+ const ret = getStringFromWasm0(arg0, arg1);
2984
+ return ret;
2985
+ },
2986
+ __wbindgen_init_externref_table: function() {
2987
+ const table = wasm.__wbindgen_externrefs;
2988
+ const offset = table.grow(4);
2989
+ table.set(0, undefined);
2990
+ table.set(offset + 0, undefined);
2991
+ table.set(offset + 1, null);
2992
+ table.set(offset + 2, true);
2993
+ table.set(offset + 3, false);
2994
+ },
2995
+ };
2996
+ return {
2997
+ __proto__: null,
2998
+ "./orbital_wasm_bg.js": import0,
2999
+ };
3000
+ }
3001
+
3002
+ const CredentialVaultFinalization = (typeof FinalizationRegistry === 'undefined')
3003
+ ? { register: () => {}, unregister: () => {} }
3004
+ : new FinalizationRegistry(ptr => wasm.__wbg_credentialvault_free(ptr, 1));
3005
+ const KernelFinalization = (typeof FinalizationRegistry === 'undefined')
3006
+ ? { register: () => {}, unregister: () => {} }
3007
+ : new FinalizationRegistry(ptr => wasm.__wbg_kernel_free(ptr, 1));
3008
+ const MemoryStoreFinalization = (typeof FinalizationRegistry === 'undefined')
3009
+ ? { register: () => {}, unregister: () => {} }
3010
+ : new FinalizationRegistry(ptr => wasm.__wbg_memorystore_free(ptr, 1));
3011
+ const ServerFinalization = (typeof FinalizationRegistry === 'undefined')
3012
+ ? { register: () => {}, unregister: () => {} }
3013
+ : new FinalizationRegistry(ptr => wasm.__wbg_server_free(ptr, 1));
3014
+
3015
+ function addToExternrefTable0(obj) {
3016
+ const idx = wasm.__externref_table_alloc();
3017
+ wasm.__wbindgen_externrefs.set(idx, obj);
3018
+ return idx;
3019
+ }
3020
+
3021
+ function getArrayU8FromWasm0(ptr, len) {
3022
+ ptr = ptr >>> 0;
3023
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
3024
+ }
3025
+
3026
+ function getStringFromWasm0(ptr, len) {
3027
+ return decodeText(ptr >>> 0, len);
3028
+ }
3029
+
3030
+ let cachedUint8ArrayMemory0 = null;
3031
+ function getUint8ArrayMemory0() {
3032
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
3033
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
3034
+ }
3035
+ return cachedUint8ArrayMemory0;
3036
+ }
3037
+
3038
+ function handleError(f, args) {
3039
+ try {
3040
+ return f.apply(this, args);
3041
+ } catch (e) {
3042
+ const idx = addToExternrefTable0(e);
3043
+ wasm.__wbindgen_exn_store(idx);
3044
+ }
3045
+ }
3046
+
3047
+ function isLikeNone(x) {
3048
+ return x === undefined || x === null;
3049
+ }
3050
+
3051
+ function passStringToWasm0(arg, malloc, realloc) {
3052
+ if (realloc === undefined) {
3053
+ const buf = cachedTextEncoder.encode(arg);
3054
+ const ptr = malloc(buf.length, 1) >>> 0;
3055
+ getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
3056
+ WASM_VECTOR_LEN = buf.length;
3057
+ return ptr;
3058
+ }
3059
+
3060
+ let len = arg.length;
3061
+ let ptr = malloc(len, 1) >>> 0;
3062
+
3063
+ const mem = getUint8ArrayMemory0();
3064
+
3065
+ let offset = 0;
3066
+
3067
+ for (; offset < len; offset++) {
3068
+ const code = arg.charCodeAt(offset);
3069
+ if (code > 0x7F) break;
3070
+ mem[ptr + offset] = code;
3071
+ }
3072
+ if (offset !== len) {
3073
+ if (offset !== 0) {
3074
+ arg = arg.slice(offset);
3075
+ }
3076
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
3077
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
3078
+ const ret = cachedTextEncoder.encodeInto(arg, view);
3079
+
3080
+ offset += ret.written;
3081
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
3082
+ }
3083
+
3084
+ WASM_VECTOR_LEN = offset;
3085
+ return ptr;
3086
+ }
3087
+
3088
+ function takeFromExternrefTable0(idx) {
3089
+ const value = wasm.__wbindgen_externrefs.get(idx);
3090
+ wasm.__externref_table_dealloc(idx);
3091
+ return value;
3092
+ }
3093
+
3094
+ let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
3095
+ cachedTextDecoder.decode();
3096
+ const MAX_SAFARI_DECODE_BYTES = 2146435072;
3097
+ let numBytesDecoded = 0;
3098
+ function decodeText(ptr, len) {
3099
+ numBytesDecoded += len;
3100
+ if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
3101
+ cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
3102
+ cachedTextDecoder.decode();
3103
+ numBytesDecoded = len;
3104
+ }
3105
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
3106
+ }
3107
+
3108
+ const cachedTextEncoder = new TextEncoder();
3109
+
3110
+ if (!('encodeInto' in cachedTextEncoder)) {
3111
+ cachedTextEncoder.encodeInto = function (arg, view) {
3112
+ const buf = cachedTextEncoder.encode(arg);
3113
+ view.set(buf);
3114
+ return {
3115
+ read: arg.length,
3116
+ written: buf.length
3117
+ };
3118
+ };
3119
+ }
3120
+
3121
+ let WASM_VECTOR_LEN = 0;
3122
+
3123
+ let wasmModule, wasmInstance, wasm;
3124
+ function __wbg_finalize_init(instance, module) {
3125
+ wasmInstance = instance;
3126
+ wasm = instance.exports;
3127
+ wasmModule = module;
3128
+ cachedUint8ArrayMemory0 = null;
3129
+ wasm.__wbindgen_start();
3130
+ return wasm;
3131
+ }
3132
+
3133
+ async function __wbg_load(module, imports) {
3134
+ if (typeof Response === 'function' && module instanceof Response) {
3135
+ if (typeof WebAssembly.instantiateStreaming === 'function') {
3136
+ try {
3137
+ return await WebAssembly.instantiateStreaming(module, imports);
3138
+ } catch (e) {
3139
+ const validResponse = module.ok && expectedResponseType(module.type);
3140
+
3141
+ if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
3142
+ 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);
3143
+
3144
+ } else { throw e; }
3145
+ }
3146
+ }
3147
+
3148
+ const bytes = await module.arrayBuffer();
3149
+ return await WebAssembly.instantiate(bytes, imports);
3150
+ } else {
3151
+ const instance = await WebAssembly.instantiate(module, imports);
3152
+
3153
+ if (instance instanceof WebAssembly.Instance) {
3154
+ return { instance, module };
3155
+ } else {
3156
+ return instance;
3157
+ }
3158
+ }
3159
+
3160
+ function expectedResponseType(type) {
3161
+ switch (type) {
3162
+ case 'basic': case 'cors': case 'default': return true;
3163
+ }
3164
+ return false;
3165
+ }
3166
+ }
3167
+
3168
+ function initSync(module) {
3169
+ if (wasm !== undefined) return wasm;
3170
+
3171
+
3172
+ if (module !== undefined) {
3173
+ if (Object.getPrototypeOf(module) === Object.prototype) {
3174
+ ({module} = module)
3175
+ } else {
3176
+ console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
3177
+ }
3178
+ }
3179
+
3180
+ const imports = __wbg_get_imports();
3181
+ if (!(module instanceof WebAssembly.Module)) {
3182
+ module = new WebAssembly.Module(module);
3183
+ }
3184
+ const instance = new WebAssembly.Instance(module, imports);
3185
+ return __wbg_finalize_init(instance, module);
3186
+ }
3187
+
3188
+ async function __wbg_init(module_or_path) {
3189
+ if (wasm !== undefined) return wasm;
3190
+
3191
+
3192
+ if (module_or_path !== undefined) {
3193
+ if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
3194
+ ({module_or_path} = module_or_path)
3195
+ } else {
3196
+ console.warn('using deprecated parameters for the initialization function; pass a single object instead')
3197
+ }
3198
+ }
3199
+
3200
+ if (module_or_path === undefined) {
3201
+ module_or_path = new URL('orbital_wasm_bg.wasm', import.meta.url);
3202
+ }
3203
+ const imports = __wbg_get_imports();
3204
+
3205
+ if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
3206
+ module_or_path = fetch(module_or_path);
3207
+ }
3208
+
3209
+ const { instance, module } = await __wbg_load(await module_or_path, imports);
3210
+
3211
+ return __wbg_finalize_init(instance, module);
3212
+ }
3213
+
3214
+ export { initSync, __wbg_init as default };