@almadar/kernel 18.0.0 → 19.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,4634 @@
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
+ * @param {string | null} [route]
613
+ * @returns {string}
614
+ */
615
+ dispatchMount(seeds_json, entity_id, payload_json, route) {
616
+ let deferred6_0;
617
+ let deferred6_1;
618
+ try {
619
+ const ptr0 = passStringToWasm0(seeds_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
620
+ const len0 = WASM_VECTOR_LEN;
621
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
622
+ var len1 = WASM_VECTOR_LEN;
623
+ var ptr2 = isLikeNone(payload_json) ? 0 : passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
624
+ var len2 = WASM_VECTOR_LEN;
625
+ var ptr3 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
626
+ var len3 = WASM_VECTOR_LEN;
627
+ const ret = wasm.kernel_dispatchMount(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
628
+ var ptr5 = ret[0];
629
+ var len5 = ret[1];
630
+ if (ret[3]) {
631
+ ptr5 = 0; len5 = 0;
632
+ throw takeFromExternrefTable0(ret[2]);
633
+ }
634
+ deferred6_0 = ptr5;
635
+ deferred6_1 = len5;
636
+ return getStringFromWasm0(ptr5, len5);
637
+ } finally {
638
+ wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
639
+ }
640
+ }
641
+ /**
642
+ * @param {number} flight
643
+ * @returns {boolean}
644
+ */
645
+ endFlight(flight) {
646
+ const ret = wasm.kernel_endFlight(this.__wbg_ptr, flight);
647
+ return ret !== 0;
648
+ }
649
+ /**
650
+ * @param {string | null | undefined} route_path
651
+ * @param {string} mount_key
652
+ * @param {string} traits_json
653
+ * @returns {string}
654
+ */
655
+ enter(route_path, mount_key, traits_json) {
656
+ let deferred5_0;
657
+ let deferred5_1;
658
+ try {
659
+ var ptr0 = isLikeNone(route_path) ? 0 : passStringToWasm0(route_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
660
+ var len0 = WASM_VECTOR_LEN;
661
+ const ptr1 = passStringToWasm0(mount_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
662
+ const len1 = WASM_VECTOR_LEN;
663
+ const ptr2 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
664
+ const len2 = WASM_VECTOR_LEN;
665
+ const ret = wasm.kernel_enter(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
666
+ var ptr4 = ret[0];
667
+ var len4 = ret[1];
668
+ if (ret[3]) {
669
+ ptr4 = 0; len4 = 0;
670
+ throw takeFromExternrefTable0(ret[2]);
671
+ }
672
+ deferred5_0 = ptr4;
673
+ deferred5_1 = len4;
674
+ return getStringFromWasm0(ptr4, len4);
675
+ } finally {
676
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
677
+ }
678
+ }
679
+ /**
680
+ * `undefined` when the leg carried no rows to fold against.
681
+ * @param {string | null | undefined} carried_json
682
+ * @param {string} seeded_json
683
+ * @param {string | null} [entity_id]
684
+ * @returns {string | undefined}
685
+ */
686
+ foldBase(carried_json, seeded_json, entity_id) {
687
+ var ptr0 = isLikeNone(carried_json) ? 0 : passStringToWasm0(carried_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
688
+ var len0 = WASM_VECTOR_LEN;
689
+ const ptr1 = passStringToWasm0(seeded_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
690
+ const len1 = WASM_VECTOR_LEN;
691
+ var ptr2 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
692
+ var len2 = WASM_VECTOR_LEN;
693
+ const ret = wasm.kernel_foldBase(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
694
+ if (ret[3]) {
695
+ throw takeFromExternrefTable0(ret[2]);
696
+ }
697
+ let v4;
698
+ if (ret[0] !== 0) {
699
+ v4 = getStringFromWasm0(ret[0], ret[1]).slice();
700
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
701
+ }
702
+ return v4;
703
+ }
704
+ /**
705
+ * @param {number} flight
706
+ * @param {string} response_json
707
+ * @param {string | null} [already_delivered_json]
708
+ * @param {string | null} [base_json]
709
+ * @returns {string}
710
+ */
711
+ foldInOrder(flight, response_json, already_delivered_json, base_json) {
712
+ let deferred5_0;
713
+ let deferred5_1;
714
+ try {
715
+ const ptr0 = passStringToWasm0(response_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
716
+ const len0 = WASM_VECTOR_LEN;
717
+ var ptr1 = isLikeNone(already_delivered_json) ? 0 : passStringToWasm0(already_delivered_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
718
+ var len1 = WASM_VECTOR_LEN;
719
+ var ptr2 = isLikeNone(base_json) ? 0 : passStringToWasm0(base_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
720
+ var len2 = WASM_VECTOR_LEN;
721
+ const ret = wasm.kernel_foldInOrder(this.__wbg_ptr, flight, ptr0, len0, ptr1, len1, ptr2, len2);
722
+ var ptr4 = ret[0];
723
+ var len4 = ret[1];
724
+ if (ret[3]) {
725
+ ptr4 = 0; len4 = 0;
726
+ throw takeFromExternrefTable0(ret[2]);
727
+ }
728
+ deferred5_0 = ptr4;
729
+ deferred5_1 = len4;
730
+ return getStringFromWasm0(ptr4, len4);
731
+ } finally {
732
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
733
+ }
734
+ }
735
+ /**
736
+ * `undefined` when no tick is due this frame.
737
+ * @param {number} now_ms
738
+ * @returns {string | undefined}
739
+ */
740
+ frame(now_ms) {
741
+ const ret = wasm.kernel_frame(this.__wbg_ptr, now_ms);
742
+ if (ret[3]) {
743
+ throw takeFromExternrefTable0(ret[2]);
744
+ }
745
+ let v1;
746
+ if (ret[0] !== 0) {
747
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
748
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
749
+ }
750
+ return v1;
751
+ }
752
+ framePause() {
753
+ wasm.kernel_framePause(this.__wbg_ptr);
754
+ }
755
+ frameResume() {
756
+ wasm.kernel_frameResume(this.__wbg_ptr);
757
+ }
758
+ /**
759
+ * @param {number} since
760
+ * @returns {string}
761
+ */
762
+ framesSince(since) {
763
+ let deferred2_0;
764
+ let deferred2_1;
765
+ try {
766
+ const ret = wasm.kernel_framesSince(this.__wbg_ptr, since);
767
+ var ptr1 = ret[0];
768
+ var len1 = ret[1];
769
+ if (ret[3]) {
770
+ ptr1 = 0; len1 = 0;
771
+ throw takeFromExternrefTable0(ret[2]);
772
+ }
773
+ deferred2_0 = ptr1;
774
+ deferred2_1 = len1;
775
+ return getStringFromWasm0(ptr1, len1);
776
+ } finally {
777
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
778
+ }
779
+ }
780
+ /**
781
+ * @param {string} trait_name
782
+ * @param {string | null} [entity_id]
783
+ * @returns {string}
784
+ */
785
+ getState(trait_name, entity_id) {
786
+ let deferred3_0;
787
+ let deferred3_1;
788
+ try {
789
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
790
+ const len0 = WASM_VECTOR_LEN;
791
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
792
+ var len1 = WASM_VECTOR_LEN;
793
+ const ret = wasm.kernel_getState(this.__wbg_ptr, ptr0, len0, ptr1, len1);
794
+ deferred3_0 = ret[0];
795
+ deferred3_1 = ret[1];
796
+ return getStringFromWasm0(ret[0], ret[1]);
797
+ } finally {
798
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
799
+ }
800
+ }
801
+ /**
802
+ * @returns {string}
803
+ */
804
+ lastError() {
805
+ let deferred1_0;
806
+ let deferred1_1;
807
+ try {
808
+ const ret = wasm.kernel_lastError(this.__wbg_ptr);
809
+ deferred1_0 = ret[0];
810
+ deferred1_1 = ret[1];
811
+ return getStringFromWasm0(ret[0], ret[1]);
812
+ } finally {
813
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
814
+ }
815
+ }
816
+ /**
817
+ * @returns {string}
818
+ */
819
+ leave() {
820
+ let deferred2_0;
821
+ let deferred2_1;
822
+ try {
823
+ const ret = wasm.kernel_leave(this.__wbg_ptr);
824
+ var ptr1 = ret[0];
825
+ var len1 = ret[1];
826
+ if (ret[3]) {
827
+ ptr1 = 0; len1 = 0;
828
+ throw takeFromExternrefTable0(ret[2]);
829
+ }
830
+ deferred2_0 = ptr1;
831
+ deferred2_1 = len1;
832
+ return getStringFromWasm0(ptr1, len1);
833
+ } finally {
834
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
835
+ }
836
+ }
837
+ /**
838
+ * @param {string} traits_json
839
+ */
840
+ mount(traits_json) {
841
+ const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
842
+ const len0 = WASM_VECTOR_LEN;
843
+ const ret = wasm.kernel_mount(this.__wbg_ptr, ptr0, len0);
844
+ if (ret[1]) {
845
+ throw takeFromExternrefTable0(ret[0]);
846
+ }
847
+ }
848
+ /**
849
+ * @param {string} resolved_schema_json
850
+ * @param {string} client_id
851
+ */
852
+ constructor(resolved_schema_json, client_id) {
853
+ const ptr0 = passStringToWasm0(resolved_schema_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
854
+ const len0 = WASM_VECTOR_LEN;
855
+ const ptr1 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
856
+ const len1 = WASM_VECTOR_LEN;
857
+ const ret = wasm.kernel_new(ptr0, len0, ptr1, len1);
858
+ if (ret[2]) {
859
+ throw takeFromExternrefTable0(ret[1]);
860
+ }
861
+ this.__wbg_ptr = ret[0];
862
+ KernelFinalization.register(this, this.__wbg_ptr, this);
863
+ return this;
864
+ }
865
+ /**
866
+ * @returns {string | undefined}
867
+ */
868
+ nextFold() {
869
+ const ret = wasm.kernel_nextFold(this.__wbg_ptr);
870
+ if (ret[3]) {
871
+ throw takeFromExternrefTable0(ret[2]);
872
+ }
873
+ let v1;
874
+ if (ret[0] !== 0) {
875
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
876
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
877
+ }
878
+ return v1;
879
+ }
880
+ /**
881
+ * @returns {number}
882
+ */
883
+ openFlight() {
884
+ const ret = wasm.kernel_openFlight(this.__wbg_ptr);
885
+ return ret;
886
+ }
887
+ /**
888
+ * @param {string | null} [page]
889
+ * @param {string | null} [route]
890
+ * @returns {string}
891
+ */
892
+ pageCircuit(page, route) {
893
+ let deferred4_0;
894
+ let deferred4_1;
895
+ try {
896
+ var ptr0 = isLikeNone(page) ? 0 : passStringToWasm0(page, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
897
+ var len0 = WASM_VECTOR_LEN;
898
+ var ptr1 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
899
+ var len1 = WASM_VECTOR_LEN;
900
+ const ret = wasm.kernel_pageCircuit(this.__wbg_ptr, ptr0, len0, ptr1, len1);
901
+ var ptr3 = ret[0];
902
+ var len3 = ret[1];
903
+ if (ret[3]) {
904
+ ptr3 = 0; len3 = 0;
905
+ throw takeFromExternrefTable0(ret[2]);
906
+ }
907
+ deferred4_0 = ptr3;
908
+ deferred4_1 = len3;
909
+ return getStringFromWasm0(ptr3, len3);
910
+ } finally {
911
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
912
+ }
913
+ }
914
+ /**
915
+ * @param {string} traits_json
916
+ * @returns {string}
917
+ */
918
+ remount(traits_json) {
919
+ let deferred3_0;
920
+ let deferred3_1;
921
+ try {
922
+ const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
923
+ const len0 = WASM_VECTOR_LEN;
924
+ const ret = wasm.kernel_remount(this.__wbg_ptr, ptr0, len0);
925
+ var ptr2 = ret[0];
926
+ var len2 = ret[1];
927
+ if (ret[3]) {
928
+ ptr2 = 0; len2 = 0;
929
+ throw takeFromExternrefTable0(ret[2]);
930
+ }
931
+ deferred3_0 = ptr2;
932
+ deferred3_1 = len2;
933
+ return getStringFromWasm0(ptr2, len2);
934
+ } finally {
935
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
936
+ }
937
+ }
938
+ /**
939
+ * @param {string} seeds_json
940
+ * @param {string | null} [entity_id]
941
+ * @returns {string}
942
+ */
943
+ reseedLeg(seeds_json, entity_id) {
944
+ let deferred4_0;
945
+ let deferred4_1;
946
+ try {
947
+ const ptr0 = passStringToWasm0(seeds_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
948
+ const len0 = WASM_VECTOR_LEN;
949
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
950
+ var len1 = WASM_VECTOR_LEN;
951
+ const ret = wasm.kernel_reseedLeg(this.__wbg_ptr, ptr0, len0, ptr1, len1);
952
+ var ptr3 = ret[0];
953
+ var len3 = ret[1];
954
+ if (ret[3]) {
955
+ ptr3 = 0; len3 = 0;
956
+ throw takeFromExternrefTable0(ret[2]);
957
+ }
958
+ deferred4_0 = ptr3;
959
+ deferred4_1 = len3;
960
+ return getStringFromWasm0(ptr3, len3);
961
+ } finally {
962
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
963
+ }
964
+ }
965
+ /**
966
+ * A row-set reference resolved against this kernel's rows for its current user (`{ rows, total }`).
967
+ * @param {string} ref_json
968
+ * @returns {string}
969
+ */
970
+ resolveRows(ref_json) {
971
+ let deferred3_0;
972
+ let deferred3_1;
973
+ try {
974
+ const ptr0 = passStringToWasm0(ref_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
975
+ const len0 = WASM_VECTOR_LEN;
976
+ const ret = wasm.kernel_resolveRows(this.__wbg_ptr, ptr0, len0);
977
+ var ptr2 = ret[0];
978
+ var len2 = ret[1];
979
+ if (ret[3]) {
980
+ ptr2 = 0; len2 = 0;
981
+ throw takeFromExternrefTable0(ret[2]);
982
+ }
983
+ deferred3_0 = ptr2;
984
+ deferred3_1 = len2;
985
+ return getStringFromWasm0(ptr2, len2);
986
+ } finally {
987
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
988
+ }
989
+ }
990
+ /**
991
+ * @param {string} trait_name
992
+ * @param {string | null | undefined} entity_id
993
+ * @param {string} snapshot_json
994
+ * @returns {string}
995
+ */
996
+ restore(trait_name, entity_id, snapshot_json) {
997
+ let deferred5_0;
998
+ let deferred5_1;
999
+ try {
1000
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1001
+ const len0 = WASM_VECTOR_LEN;
1002
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1003
+ var len1 = WASM_VECTOR_LEN;
1004
+ const ptr2 = passStringToWasm0(snapshot_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1005
+ const len2 = WASM_VECTOR_LEN;
1006
+ const ret = wasm.kernel_restore(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1007
+ var ptr4 = ret[0];
1008
+ var len4 = ret[1];
1009
+ if (ret[3]) {
1010
+ ptr4 = 0; len4 = 0;
1011
+ throw takeFromExternrefTable0(ret[2]);
1012
+ }
1013
+ deferred5_0 = ptr4;
1014
+ deferred5_1 = len4;
1015
+ return getStringFromWasm0(ptr4, len4);
1016
+ } finally {
1017
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
1018
+ }
1019
+ }
1020
+ /**
1021
+ * @param {string} route_path
1022
+ * @returns {string}
1023
+ */
1024
+ routeMounts(route_path) {
1025
+ let deferred3_0;
1026
+ let deferred3_1;
1027
+ try {
1028
+ const ptr0 = passStringToWasm0(route_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1029
+ const len0 = WASM_VECTOR_LEN;
1030
+ const ret = wasm.kernel_routeMounts(this.__wbg_ptr, ptr0, len0);
1031
+ var ptr2 = ret[0];
1032
+ var len2 = ret[1];
1033
+ if (ret[3]) {
1034
+ ptr2 = 0; len2 = 0;
1035
+ throw takeFromExternrefTable0(ret[2]);
1036
+ }
1037
+ deferred3_0 = ptr2;
1038
+ deferred3_1 = len2;
1039
+ return getStringFromWasm0(ptr2, len2);
1040
+ } finally {
1041
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1042
+ }
1043
+ }
1044
+ /**
1045
+ * @param {string} entity_type
1046
+ * @param {string} rows_json
1047
+ */
1048
+ seed(entity_type, rows_json) {
1049
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1050
+ const len0 = WASM_VECTOR_LEN;
1051
+ const ptr1 = passStringToWasm0(rows_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1052
+ const len1 = WASM_VECTOR_LEN;
1053
+ const ret = wasm.kernel_seed(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1054
+ if (ret[1]) {
1055
+ throw takeFromExternrefTable0(ret[0]);
1056
+ }
1057
+ }
1058
+ /**
1059
+ * The theme key bound to this client's session (`theme/set`, mirrored from the server's frames), or `undefined`.
1060
+ * @returns {string | undefined}
1061
+ */
1062
+ sessionTheme() {
1063
+ const ret = wasm.kernel_sessionTheme(this.__wbg_ptr);
1064
+ let v1;
1065
+ if (ret[0] !== 0) {
1066
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
1067
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1068
+ }
1069
+ return v1;
1070
+ }
1071
+ /**
1072
+ * Carry each tick's `effectResults` on the frame response, for a verifier. Off by default (P-015).
1073
+ * @param {boolean} carry
1074
+ */
1075
+ setFrameEffectResults(carry) {
1076
+ wasm.kernel_setFrameEffectResults(this.__wbg_ptr, carry);
1077
+ }
1078
+ /**
1079
+ * The host runs the listeners of every emit it marks `dispatched` (the JS runtime, `orbital-server`).
1080
+ * @param {boolean} fans_out
1081
+ */
1082
+ setHostFansOut(fans_out) {
1083
+ wasm.kernel_setHostFansOut(this.__wbg_ptr, fans_out);
1084
+ }
1085
+ /**
1086
+ * Carry each hop's `@entity` before and after it on the dispatch's transitions (`observed`), for a verifier
1087
+ * judging `@ensures`. Off by default (EXEC-STEP-10).
1088
+ * @param {boolean} record
1089
+ */
1090
+ setRecordEntityAfter(record) {
1091
+ wasm.kernel_setRecordEntityAfter(this.__wbg_ptr, record);
1092
+ }
1093
+ /**
1094
+ * @param {string} mode
1095
+ */
1096
+ setThemeMode(mode) {
1097
+ const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1098
+ const len0 = WASM_VECTOR_LEN;
1099
+ const ret = wasm.kernel_setThemeMode(this.__wbg_ptr, ptr0, len0);
1100
+ if (ret[1]) {
1101
+ throw takeFromExternrefTable0(ret[0]);
1102
+ }
1103
+ }
1104
+ /**
1105
+ * Record each dispatch as a trace item while on, for the host's `program/live { kind: "trace" }` streams.
1106
+ * @param {boolean} on
1107
+ */
1108
+ setTraceOn(on) {
1109
+ wasm.kernel_setTraceOn(this.__wbg_ptr, on);
1110
+ }
1111
+ /**
1112
+ * The host's report of whether a trait's rendered output is on screen; gates its `[visible]` ticks.
1113
+ * @param {string} trait_name
1114
+ * @param {boolean} on_screen
1115
+ */
1116
+ setTraitOnScreen(trait_name, on_screen) {
1117
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1118
+ const len0 = WASM_VECTOR_LEN;
1119
+ wasm.kernel_setTraitOnScreen(this.__wbg_ptr, ptr0, len0, on_screen);
1120
+ }
1121
+ /**
1122
+ * The page's locale `i18n/t` paints in when a dispatch names none; the program carries its own messages.
1123
+ * @param {string | null} [locale]
1124
+ */
1125
+ setViewerLocale(locale) {
1126
+ var ptr0 = isLikeNone(locale) ? 0 : passStringToWasm0(locale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1127
+ var len0 = WASM_VECTOR_LEN;
1128
+ const ret = wasm.kernel_setViewerLocale(this.__wbg_ptr, ptr0, len0);
1129
+ if (ret[1]) {
1130
+ throw takeFromExternrefTable0(ret[0]);
1131
+ }
1132
+ }
1133
+ /**
1134
+ * @returns {string}
1135
+ */
1136
+ snapshot() {
1137
+ let deferred2_0;
1138
+ let deferred2_1;
1139
+ try {
1140
+ const ret = wasm.kernel_snapshot(this.__wbg_ptr);
1141
+ var ptr1 = ret[0];
1142
+ var len1 = ret[1];
1143
+ if (ret[3]) {
1144
+ ptr1 = 0; len1 = 0;
1145
+ throw takeFromExternrefTable0(ret[2]);
1146
+ }
1147
+ deferred2_0 = ptr1;
1148
+ deferred2_1 = len1;
1149
+ return getStringFromWasm0(ptr1, len1);
1150
+ } finally {
1151
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1152
+ }
1153
+ }
1154
+ /**
1155
+ * @param {string} leg_json
1156
+ * @returns {string}
1157
+ */
1158
+ statefulLeg(leg_json) {
1159
+ let deferred3_0;
1160
+ let deferred3_1;
1161
+ try {
1162
+ const ptr0 = passStringToWasm0(leg_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1163
+ const len0 = WASM_VECTOR_LEN;
1164
+ const ret = wasm.kernel_statefulLeg(this.__wbg_ptr, ptr0, len0);
1165
+ var ptr2 = ret[0];
1166
+ var len2 = ret[1];
1167
+ if (ret[3]) {
1168
+ ptr2 = 0; len2 = 0;
1169
+ throw takeFromExternrefTable0(ret[2]);
1170
+ }
1171
+ deferred3_0 = ptr2;
1172
+ deferred3_1 = len2;
1173
+ return getStringFromWasm0(ptr2, len2);
1174
+ } finally {
1175
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1176
+ }
1177
+ }
1178
+ /**
1179
+ * The trace items recorded since the last take, in dispatch order: a JSON array.
1180
+ * @returns {string}
1181
+ */
1182
+ takeTrace() {
1183
+ let deferred2_0;
1184
+ let deferred2_1;
1185
+ try {
1186
+ const ret = wasm.kernel_takeTrace(this.__wbg_ptr);
1187
+ var ptr1 = ret[0];
1188
+ var len1 = ret[1];
1189
+ if (ret[3]) {
1190
+ ptr1 = 0; len1 = 0;
1191
+ throw takeFromExternrefTable0(ret[2]);
1192
+ }
1193
+ deferred2_0 = ptr1;
1194
+ deferred2_1 = len1;
1195
+ return getStringFromWasm0(ptr1, len1);
1196
+ } finally {
1197
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1198
+ }
1199
+ }
1200
+ /**
1201
+ * @param {string} trait_name
1202
+ * @param {string} tick_name
1203
+ * @param {string | null} [entity_id]
1204
+ * @returns {string}
1205
+ */
1206
+ tick(trait_name, tick_name, entity_id) {
1207
+ let deferred5_0;
1208
+ let deferred5_1;
1209
+ try {
1210
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1211
+ const len0 = WASM_VECTOR_LEN;
1212
+ const ptr1 = passStringToWasm0(tick_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1213
+ const len1 = WASM_VECTOR_LEN;
1214
+ var ptr2 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1215
+ var len2 = WASM_VECTOR_LEN;
1216
+ const ret = wasm.kernel_tick(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1217
+ var ptr4 = ret[0];
1218
+ var len4 = ret[1];
1219
+ if (ret[3]) {
1220
+ ptr4 = 0; len4 = 0;
1221
+ throw takeFromExternrefTable0(ret[2]);
1222
+ }
1223
+ deferred5_0 = ptr4;
1224
+ deferred5_1 = len4;
1225
+ return getStringFromWasm0(ptr4, len4);
1226
+ } finally {
1227
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
1228
+ }
1229
+ }
1230
+ /**
1231
+ * @returns {number}
1232
+ */
1233
+ tickCount() {
1234
+ const ret = wasm.kernel_tickCount(this.__wbg_ptr);
1235
+ return ret >>> 0;
1236
+ }
1237
+ /**
1238
+ * The config the kernel binds as `@config` for a registered trait, as JSON text.
1239
+ * @param {string} trait_name
1240
+ * @returns {string}
1241
+ */
1242
+ traitConfig(trait_name) {
1243
+ let deferred3_0;
1244
+ let deferred3_1;
1245
+ try {
1246
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1247
+ const len0 = WASM_VECTOR_LEN;
1248
+ const ret = wasm.kernel_traitConfig(this.__wbg_ptr, ptr0, len0);
1249
+ var ptr2 = ret[0];
1250
+ var len2 = ret[1];
1251
+ if (ret[3]) {
1252
+ ptr2 = 0; len2 = 0;
1253
+ throw takeFromExternrefTable0(ret[2]);
1254
+ }
1255
+ deferred3_0 = ptr2;
1256
+ deferred3_1 = len2;
1257
+ return getStringFromWasm0(ptr2, len2);
1258
+ } finally {
1259
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1260
+ }
1261
+ }
1262
+ /**
1263
+ * @param {string} traits_json
1264
+ * @returns {string}
1265
+ */
1266
+ unmount(traits_json) {
1267
+ let deferred3_0;
1268
+ let deferred3_1;
1269
+ try {
1270
+ const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1271
+ const len0 = WASM_VECTOR_LEN;
1272
+ const ret = wasm.kernel_unmount(this.__wbg_ptr, ptr0, len0);
1273
+ var ptr2 = ret[0];
1274
+ var len2 = ret[1];
1275
+ if (ret[3]) {
1276
+ ptr2 = 0; len2 = 0;
1277
+ throw takeFromExternrefTable0(ret[2]);
1278
+ }
1279
+ deferred3_0 = ptr2;
1280
+ deferred3_1 = len2;
1281
+ return getStringFromWasm0(ptr2, len2);
1282
+ } finally {
1283
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1284
+ }
1285
+ }
1286
+ }
1287
+ if (Symbol.dispose) Kernel.prototype[Symbol.dispose] = Kernel.prototype.free;
1288
+
1289
+ export class MemoryStore {
1290
+ __destroy_into_raw() {
1291
+ const ptr = this.__wbg_ptr;
1292
+ this.__wbg_ptr = 0;
1293
+ MemoryStoreFinalization.unregister(this);
1294
+ return ptr;
1295
+ }
1296
+ free() {
1297
+ const ptr = this.__destroy_into_raw();
1298
+ wasm.__wbg_memorystore_free(ptr, 0);
1299
+ }
1300
+ /**
1301
+ * @param {string} entity_type
1302
+ * @param {string} collection
1303
+ */
1304
+ bindCollection(entity_type, collection) {
1305
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1306
+ const len0 = WASM_VECTOR_LEN;
1307
+ const ptr1 = passStringToWasm0(collection, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1308
+ const len1 = WASM_VECTOR_LEN;
1309
+ wasm.memorystore_bindCollection(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1310
+ }
1311
+ clear() {
1312
+ wasm.memorystore_clear(this.__wbg_ptr);
1313
+ }
1314
+ /**
1315
+ * @param {string} entity_type
1316
+ * @param {string} data_json
1317
+ * @returns {string}
1318
+ */
1319
+ create(entity_type, data_json) {
1320
+ let deferred4_0;
1321
+ let deferred4_1;
1322
+ try {
1323
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1324
+ const len0 = WASM_VECTOR_LEN;
1325
+ const ptr1 = passStringToWasm0(data_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1326
+ const len1 = WASM_VECTOR_LEN;
1327
+ const ret = wasm.memorystore_create(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1328
+ var ptr3 = ret[0];
1329
+ var len3 = ret[1];
1330
+ if (ret[3]) {
1331
+ ptr3 = 0; len3 = 0;
1332
+ throw takeFromExternrefTable0(ret[2]);
1333
+ }
1334
+ deferred4_0 = ptr3;
1335
+ deferred4_1 = len3;
1336
+ return getStringFromWasm0(ptr3, len3);
1337
+ } finally {
1338
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1339
+ }
1340
+ }
1341
+ /**
1342
+ * @param {string} entity_type
1343
+ * @param {string} id
1344
+ */
1345
+ delete(entity_type, id) {
1346
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1347
+ const len0 = WASM_VECTOR_LEN;
1348
+ const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1349
+ const len1 = WASM_VECTOR_LEN;
1350
+ const ret = wasm.memorystore_delete(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1351
+ if (ret[1]) {
1352
+ throw takeFromExternrefTable0(ret[0]);
1353
+ }
1354
+ }
1355
+ /**
1356
+ * @param {string} entity_type
1357
+ * @param {string} id
1358
+ * @returns {string}
1359
+ */
1360
+ getById(entity_type, id) {
1361
+ let deferred4_0;
1362
+ let deferred4_1;
1363
+ try {
1364
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1365
+ const len0 = WASM_VECTOR_LEN;
1366
+ const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1367
+ const len1 = WASM_VECTOR_LEN;
1368
+ const ret = wasm.memorystore_getById(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1369
+ var ptr3 = ret[0];
1370
+ var len3 = ret[1];
1371
+ if (ret[3]) {
1372
+ ptr3 = 0; len3 = 0;
1373
+ throw takeFromExternrefTable0(ret[2]);
1374
+ }
1375
+ deferred4_0 = ptr3;
1376
+ deferred4_1 = len3;
1377
+ return getStringFromWasm0(ptr3, len3);
1378
+ } finally {
1379
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1380
+ }
1381
+ }
1382
+ /**
1383
+ * @param {string} entity_type
1384
+ * @returns {string}
1385
+ */
1386
+ list(entity_type) {
1387
+ let deferred3_0;
1388
+ let deferred3_1;
1389
+ try {
1390
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1391
+ const len0 = WASM_VECTOR_LEN;
1392
+ const ret = wasm.memorystore_list(this.__wbg_ptr, ptr0, len0);
1393
+ var ptr2 = ret[0];
1394
+ var len2 = ret[1];
1395
+ if (ret[3]) {
1396
+ ptr2 = 0; len2 = 0;
1397
+ throw takeFromExternrefTable0(ret[2]);
1398
+ }
1399
+ deferred3_0 = ptr2;
1400
+ deferred3_1 = len2;
1401
+ return getStringFromWasm0(ptr2, len2);
1402
+ } finally {
1403
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1404
+ }
1405
+ }
1406
+ constructor() {
1407
+ const ret = wasm.memorystore_new();
1408
+ this.__wbg_ptr = ret;
1409
+ MemoryStoreFinalization.register(this, this.__wbg_ptr, this);
1410
+ return this;
1411
+ }
1412
+ /**
1413
+ * @returns {string}
1414
+ */
1415
+ queryCapabilities() {
1416
+ let deferred2_0;
1417
+ let deferred2_1;
1418
+ try {
1419
+ const ret = wasm.memorystore_queryCapabilities(this.__wbg_ptr);
1420
+ var ptr1 = ret[0];
1421
+ var len1 = ret[1];
1422
+ if (ret[3]) {
1423
+ ptr1 = 0; len1 = 0;
1424
+ throw takeFromExternrefTable0(ret[2]);
1425
+ }
1426
+ deferred2_0 = ptr1;
1427
+ deferred2_1 = len1;
1428
+ return getStringFromWasm0(ptr1, len1);
1429
+ } finally {
1430
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1431
+ }
1432
+ }
1433
+ /**
1434
+ * @param {string} entity_type
1435
+ * @param {string} query_json
1436
+ * @returns {string}
1437
+ */
1438
+ queryIds(entity_type, query_json) {
1439
+ let deferred4_0;
1440
+ let deferred4_1;
1441
+ try {
1442
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1443
+ const len0 = WASM_VECTOR_LEN;
1444
+ const ptr1 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1445
+ const len1 = WASM_VECTOR_LEN;
1446
+ const ret = wasm.memorystore_queryIds(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1447
+ var ptr3 = ret[0];
1448
+ var len3 = ret[1];
1449
+ if (ret[3]) {
1450
+ ptr3 = 0; len3 = 0;
1451
+ throw takeFromExternrefTable0(ret[2]);
1452
+ }
1453
+ deferred4_0 = ptr3;
1454
+ deferred4_1 = len3;
1455
+ return getStringFromWasm0(ptr3, len3);
1456
+ } finally {
1457
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1458
+ }
1459
+ }
1460
+ /**
1461
+ * @param {string} entity_type
1462
+ * @param {string} query_json
1463
+ * @returns {string}
1464
+ */
1465
+ queryPage(entity_type, query_json) {
1466
+ let deferred4_0;
1467
+ let deferred4_1;
1468
+ try {
1469
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1470
+ const len0 = WASM_VECTOR_LEN;
1471
+ const ptr1 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1472
+ const len1 = WASM_VECTOR_LEN;
1473
+ const ret = wasm.memorystore_queryPage(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1474
+ var ptr3 = ret[0];
1475
+ var len3 = ret[1];
1476
+ if (ret[3]) {
1477
+ ptr3 = 0; len3 = 0;
1478
+ throw takeFromExternrefTable0(ret[2]);
1479
+ }
1480
+ deferred4_0 = ptr3;
1481
+ deferred4_1 = len3;
1482
+ return getStringFromWasm0(ptr3, len3);
1483
+ } finally {
1484
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1485
+ }
1486
+ }
1487
+ /**
1488
+ * @returns {string}
1489
+ */
1490
+ snapshot() {
1491
+ let deferred2_0;
1492
+ let deferred2_1;
1493
+ try {
1494
+ const ret = wasm.memorystore_snapshot(this.__wbg_ptr);
1495
+ var ptr1 = ret[0];
1496
+ var len1 = ret[1];
1497
+ if (ret[3]) {
1498
+ ptr1 = 0; len1 = 0;
1499
+ throw takeFromExternrefTable0(ret[2]);
1500
+ }
1501
+ deferred2_0 = ptr1;
1502
+ deferred2_1 = len1;
1503
+ return getStringFromWasm0(ptr1, len1);
1504
+ } finally {
1505
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1506
+ }
1507
+ }
1508
+ /**
1509
+ * @param {string} entity_type
1510
+ * @param {string} id
1511
+ * @param {string} data_json
1512
+ * @returns {string}
1513
+ */
1514
+ update(entity_type, id, data_json) {
1515
+ let deferred5_0;
1516
+ let deferred5_1;
1517
+ try {
1518
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1519
+ const len0 = WASM_VECTOR_LEN;
1520
+ const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1521
+ const len1 = WASM_VECTOR_LEN;
1522
+ const ptr2 = passStringToWasm0(data_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1523
+ const len2 = WASM_VECTOR_LEN;
1524
+ const ret = wasm.memorystore_update(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1525
+ var ptr4 = ret[0];
1526
+ var len4 = ret[1];
1527
+ if (ret[3]) {
1528
+ ptr4 = 0; len4 = 0;
1529
+ throw takeFromExternrefTable0(ret[2]);
1530
+ }
1531
+ deferred5_0 = ptr4;
1532
+ deferred5_1 = len4;
1533
+ return getStringFromWasm0(ptr4, len4);
1534
+ } finally {
1535
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
1536
+ }
1537
+ }
1538
+ /**
1539
+ * @param {string} batch_json
1540
+ * @returns {string}
1541
+ */
1542
+ writeBatch(batch_json) {
1543
+ let deferred3_0;
1544
+ let deferred3_1;
1545
+ try {
1546
+ const ptr0 = passStringToWasm0(batch_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1547
+ const len0 = WASM_VECTOR_LEN;
1548
+ const ret = wasm.memorystore_writeBatch(this.__wbg_ptr, ptr0, len0);
1549
+ var ptr2 = ret[0];
1550
+ var len2 = ret[1];
1551
+ if (ret[3]) {
1552
+ ptr2 = 0; len2 = 0;
1553
+ throw takeFromExternrefTable0(ret[2]);
1554
+ }
1555
+ deferred3_0 = ptr2;
1556
+ deferred3_1 = len2;
1557
+ return getStringFromWasm0(ptr2, len2);
1558
+ } finally {
1559
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1560
+ }
1561
+ }
1562
+ /**
1563
+ * @returns {string}
1564
+ */
1565
+ writeCapabilities() {
1566
+ let deferred2_0;
1567
+ let deferred2_1;
1568
+ try {
1569
+ const ret = wasm.memorystore_writeCapabilities(this.__wbg_ptr);
1570
+ var ptr1 = ret[0];
1571
+ var len1 = ret[1];
1572
+ if (ret[3]) {
1573
+ ptr1 = 0; len1 = 0;
1574
+ throw takeFromExternrefTable0(ret[2]);
1575
+ }
1576
+ deferred2_0 = ptr1;
1577
+ deferred2_1 = len1;
1578
+ return getStringFromWasm0(ptr1, len1);
1579
+ } finally {
1580
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1581
+ }
1582
+ }
1583
+ /**
1584
+ * @param {string} op_json
1585
+ * @returns {string}
1586
+ */
1587
+ writeWhere(op_json) {
1588
+ let deferred3_0;
1589
+ let deferred3_1;
1590
+ try {
1591
+ const ptr0 = passStringToWasm0(op_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1592
+ const len0 = WASM_VECTOR_LEN;
1593
+ const ret = wasm.memorystore_writeWhere(this.__wbg_ptr, ptr0, len0);
1594
+ var ptr2 = ret[0];
1595
+ var len2 = ret[1];
1596
+ if (ret[3]) {
1597
+ ptr2 = 0; len2 = 0;
1598
+ throw takeFromExternrefTable0(ret[2]);
1599
+ }
1600
+ deferred3_0 = ptr2;
1601
+ deferred3_1 = len2;
1602
+ return getStringFromWasm0(ptr2, len2);
1603
+ } finally {
1604
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1605
+ }
1606
+ }
1607
+ }
1608
+ if (Symbol.dispose) MemoryStore.prototype[Symbol.dispose] = MemoryStore.prototype.free;
1609
+
1610
+ /**
1611
+ * The server role: `start` a request, answer the I/O it asks for, `resume` the flight until it is done.
1612
+ */
1613
+ export class Server {
1614
+ static __wrap(ptr) {
1615
+ const obj = Object.create(Server.prototype);
1616
+ obj.__wbg_ptr = ptr;
1617
+ ServerFinalization.register(obj, obj.__wbg_ptr, obj);
1618
+ return obj;
1619
+ }
1620
+ __destroy_into_raw() {
1621
+ const ptr = this.__wbg_ptr;
1622
+ this.__wbg_ptr = 0;
1623
+ ServerFinalization.unregister(this);
1624
+ return ptr;
1625
+ }
1626
+ free() {
1627
+ const ptr = this.__destroy_into_raw();
1628
+ wasm.__wbg_server_free(ptr, 0);
1629
+ }
1630
+ /**
1631
+ * @param {number} flight
1632
+ * @returns {boolean}
1633
+ */
1634
+ abandon(flight) {
1635
+ const ret = wasm.server_abandon(this.__wbg_ptr, flight);
1636
+ if (ret[2]) {
1637
+ throw takeFromExternrefTable0(ret[1]);
1638
+ }
1639
+ return ret[0] !== 0;
1640
+ }
1641
+ /**
1642
+ * @param {string} side
1643
+ * @returns {string}
1644
+ */
1645
+ bootMounts(side) {
1646
+ let deferred3_0;
1647
+ let deferred3_1;
1648
+ try {
1649
+ const ptr0 = passStringToWasm0(side, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1650
+ const len0 = WASM_VECTOR_LEN;
1651
+ const ret = wasm.server_bootMounts(this.__wbg_ptr, ptr0, len0);
1652
+ var ptr2 = ret[0];
1653
+ var len2 = ret[1];
1654
+ if (ret[3]) {
1655
+ ptr2 = 0; len2 = 0;
1656
+ throw takeFromExternrefTable0(ret[2]);
1657
+ }
1658
+ deferred3_0 = ptr2;
1659
+ deferred3_1 = len2;
1660
+ return getStringFromWasm0(ptr2, len2);
1661
+ } finally {
1662
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1663
+ }
1664
+ }
1665
+ /**
1666
+ * @param {number} id
1667
+ * @returns {boolean}
1668
+ */
1669
+ closeSessionStream(id) {
1670
+ const ret = wasm.server_closeSessionStream(this.__wbg_ptr, id);
1671
+ if (ret[2]) {
1672
+ throw takeFromExternrefTable0(ret[1]);
1673
+ }
1674
+ return ret[0] !== 0;
1675
+ }
1676
+ /**
1677
+ * One question about the registered program (a `ContractQuery` as JSON): its answer as JSON.
1678
+ * @param {string} query_json
1679
+ * @returns {string}
1680
+ */
1681
+ contractQuery(query_json) {
1682
+ let deferred3_0;
1683
+ let deferred3_1;
1684
+ try {
1685
+ const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1686
+ const len0 = WASM_VECTOR_LEN;
1687
+ const ret = wasm.server_contractQuery(this.__wbg_ptr, ptr0, len0);
1688
+ var ptr2 = ret[0];
1689
+ var len2 = ret[1];
1690
+ if (ret[3]) {
1691
+ ptr2 = 0; len2 = 0;
1692
+ throw takeFromExternrefTable0(ret[2]);
1693
+ }
1694
+ deferred3_0 = ptr2;
1695
+ deferred3_1 = len2;
1696
+ return getStringFromWasm0(ptr2, len2);
1697
+ } finally {
1698
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1699
+ }
1700
+ }
1701
+ /**
1702
+ * @returns {boolean}
1703
+ */
1704
+ declaresTicks() {
1705
+ const ret = wasm.server_declaresTicks(this.__wbg_ptr);
1706
+ return ret !== 0;
1707
+ }
1708
+ /**
1709
+ * @returns {string}
1710
+ */
1711
+ dispatchStream() {
1712
+ let deferred2_0;
1713
+ let deferred2_1;
1714
+ try {
1715
+ const ret = wasm.server_dispatchStream(this.__wbg_ptr);
1716
+ var ptr1 = ret[0];
1717
+ var len1 = ret[1];
1718
+ if (ret[3]) {
1719
+ ptr1 = 0; len1 = 0;
1720
+ throw takeFromExternrefTable0(ret[2]);
1721
+ }
1722
+ deferred2_0 = ptr1;
1723
+ deferred2_1 = len1;
1724
+ return getStringFromWasm0(ptr1, len1);
1725
+ } finally {
1726
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1727
+ }
1728
+ }
1729
+ /**
1730
+ * @param {string} url
1731
+ * @returns {boolean}
1732
+ */
1733
+ egressAllows(url) {
1734
+ const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1735
+ const len0 = WASM_VECTOR_LEN;
1736
+ const ret = wasm.server_egressAllows(this.__wbg_ptr, ptr0, len0);
1737
+ return ret !== 0;
1738
+ }
1739
+ /**
1740
+ * @returns {string}
1741
+ */
1742
+ flushTickRelay() {
1743
+ let deferred2_0;
1744
+ let deferred2_1;
1745
+ try {
1746
+ const ret = wasm.server_flushTickRelay(this.__wbg_ptr);
1747
+ var ptr1 = ret[0];
1748
+ var len1 = ret[1];
1749
+ if (ret[3]) {
1750
+ ptr1 = 0; len1 = 0;
1751
+ throw takeFromExternrefTable0(ret[2]);
1752
+ }
1753
+ deferred2_0 = ptr1;
1754
+ deferred2_1 = len1;
1755
+ return getStringFromWasm0(ptr1, len1);
1756
+ } finally {
1757
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1758
+ }
1759
+ }
1760
+ /**
1761
+ * A server holding this one's registered program and none of its session: what a stateless host serves
1762
+ * each request from, instead of registering the program again.
1763
+ * @returns {Server}
1764
+ */
1765
+ fork() {
1766
+ const ret = wasm.server_fork(this.__wbg_ptr);
1767
+ if (ret[2]) {
1768
+ throw takeFromExternrefTable0(ret[1]);
1769
+ }
1770
+ return Server.__wrap(ret[0]);
1771
+ }
1772
+ /**
1773
+ * @param {string} program_json
1774
+ * @returns {Server}
1775
+ */
1776
+ forkProgram(program_json) {
1777
+ const ptr0 = passStringToWasm0(program_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1778
+ const len0 = WASM_VECTOR_LEN;
1779
+ const ret = wasm.server_forkProgram(this.__wbg_ptr, ptr0, len0);
1780
+ if (ret[2]) {
1781
+ throw takeFromExternrefTable0(ret[1]);
1782
+ }
1783
+ return Server.__wrap(ret[0]);
1784
+ }
1785
+ /**
1786
+ * @param {string} trait_name
1787
+ * @param {string | null} [entity_id]
1788
+ * @returns {string}
1789
+ */
1790
+ getState(trait_name, entity_id) {
1791
+ let deferred3_0;
1792
+ let deferred3_1;
1793
+ try {
1794
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1795
+ const len0 = WASM_VECTOR_LEN;
1796
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1797
+ var len1 = WASM_VECTOR_LEN;
1798
+ const ret = wasm.server_getState(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1799
+ deferred3_0 = ret[0];
1800
+ deferred3_1 = ret[1];
1801
+ return getStringFromWasm0(ret[0], ret[1]);
1802
+ } finally {
1803
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1804
+ }
1805
+ }
1806
+ /**
1807
+ * @param {number} flight
1808
+ * @returns {boolean}
1809
+ */
1810
+ holdsLane(flight) {
1811
+ const ret = wasm.server_holdsLane(this.__wbg_ptr, flight);
1812
+ if (ret[2]) {
1813
+ throw takeFromExternrefTable0(ret[1]);
1814
+ }
1815
+ return ret[0] !== 0;
1816
+ }
1817
+ /**
1818
+ * @returns {number}
1819
+ */
1820
+ inFlight() {
1821
+ const ret = wasm.server_inFlight(this.__wbg_ptr);
1822
+ return ret >>> 0;
1823
+ }
1824
+ /**
1825
+ * @returns {string}
1826
+ */
1827
+ lastError() {
1828
+ let deferred1_0;
1829
+ let deferred1_1;
1830
+ try {
1831
+ const ret = wasm.server_lastError(this.__wbg_ptr);
1832
+ deferred1_0 = ret[0];
1833
+ deferred1_1 = ret[1];
1834
+ return getStringFromWasm0(ret[0], ret[1]);
1835
+ } finally {
1836
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1837
+ }
1838
+ }
1839
+ /**
1840
+ * @param {string} item_json
1841
+ * @param {string | null} [client_id]
1842
+ * @returns {boolean}
1843
+ */
1844
+ liveItemDelivered(item_json, client_id) {
1845
+ const ptr0 = passStringToWasm0(item_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1846
+ const len0 = WASM_VECTOR_LEN;
1847
+ var ptr1 = isLikeNone(client_id) ? 0 : passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1848
+ var len1 = WASM_VECTOR_LEN;
1849
+ const ret = wasm.server_liveItemDelivered(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1850
+ if (ret[2]) {
1851
+ throw takeFromExternrefTable0(ret[1]);
1852
+ }
1853
+ return ret[0] !== 0;
1854
+ }
1855
+ /**
1856
+ * @param {string} traits_json
1857
+ */
1858
+ mount(traits_json) {
1859
+ const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1860
+ const len0 = WASM_VECTOR_LEN;
1861
+ const ret = wasm.server_mount(this.__wbg_ptr, ptr0, len0);
1862
+ if (ret[1]) {
1863
+ throw takeFromExternrefTable0(ret[0]);
1864
+ }
1865
+ }
1866
+ /**
1867
+ * @param {string} client
1868
+ * @param {string} orbital
1869
+ * @param {string} traits_json
1870
+ */
1871
+ mountClient(client, orbital, traits_json) {
1872
+ const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1873
+ const len0 = WASM_VECTOR_LEN;
1874
+ const ptr1 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1875
+ const len1 = WASM_VECTOR_LEN;
1876
+ const ptr2 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1877
+ const len2 = WASM_VECTOR_LEN;
1878
+ const ret = wasm.server_mountClient(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1879
+ if (ret[1]) {
1880
+ throw takeFromExternrefTable0(ret[0]);
1881
+ }
1882
+ }
1883
+ /**
1884
+ * @param {string} resolved_schema_json
1885
+ */
1886
+ constructor(resolved_schema_json) {
1887
+ const ptr0 = passStringToWasm0(resolved_schema_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1888
+ const len0 = WASM_VECTOR_LEN;
1889
+ const ret = wasm.server_new(ptr0, len0);
1890
+ if (ret[2]) {
1891
+ throw takeFromExternrefTable0(ret[1]);
1892
+ }
1893
+ this.__wbg_ptr = ret[0];
1894
+ ServerFinalization.register(this, this.__wbg_ptr, this);
1895
+ return this;
1896
+ }
1897
+ /**
1898
+ * The oldest queued request, started now the lane is free (`NextWire` JSON), or `null`.
1899
+ * @returns {string}
1900
+ */
1901
+ next() {
1902
+ let deferred2_0;
1903
+ let deferred2_1;
1904
+ try {
1905
+ const ret = wasm.server_next(this.__wbg_ptr);
1906
+ var ptr1 = ret[0];
1907
+ var len1 = ret[1];
1908
+ if (ret[3]) {
1909
+ ptr1 = 0; len1 = 0;
1910
+ throw takeFromExternrefTable0(ret[2]);
1911
+ }
1912
+ deferred2_0 = ptr1;
1913
+ deferred2_1 = len1;
1914
+ return getStringFromWasm0(ptr1, len1);
1915
+ } finally {
1916
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1917
+ }
1918
+ }
1919
+ /**
1920
+ * A live stream of `client`'s session opened (EXEC-DIST-9); the id closes it.
1921
+ * @param {string} client
1922
+ * @returns {number}
1923
+ */
1924
+ openSessionStream(client) {
1925
+ const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1926
+ const len0 = WASM_VECTOR_LEN;
1927
+ const ret = wasm.server_openSessionStream(this.__wbg_ptr, ptr0, len0);
1928
+ return ret;
1929
+ }
1930
+ /**
1931
+ * @param {string} requirement_json
1932
+ * @param {string | null} [orbital]
1933
+ * @returns {boolean}
1934
+ */
1935
+ osAllows(requirement_json, orbital) {
1936
+ const ptr0 = passStringToWasm0(requirement_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1937
+ const len0 = WASM_VECTOR_LEN;
1938
+ var ptr1 = isLikeNone(orbital) ? 0 : passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1939
+ var len1 = WASM_VECTOR_LEN;
1940
+ const ret = wasm.server_osAllows(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1941
+ if (ret[2]) {
1942
+ throw takeFromExternrefTable0(ret[1]);
1943
+ }
1944
+ return ret[0] !== 0;
1945
+ }
1946
+ /**
1947
+ * @param {string} op
1948
+ * @param {string} args_json
1949
+ * @returns {string}
1950
+ */
1951
+ osResolveArgs(op, args_json) {
1952
+ let deferred4_0;
1953
+ let deferred4_1;
1954
+ try {
1955
+ const ptr0 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1956
+ const len0 = WASM_VECTOR_LEN;
1957
+ const ptr1 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1958
+ const len1 = WASM_VECTOR_LEN;
1959
+ const ret = wasm.server_osResolveArgs(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1960
+ var ptr3 = ret[0];
1961
+ var len3 = ret[1];
1962
+ if (ret[3]) {
1963
+ ptr3 = 0; len3 = 0;
1964
+ throw takeFromExternrefTable0(ret[2]);
1965
+ }
1966
+ deferred4_0 = ptr3;
1967
+ deferred4_1 = len3;
1968
+ return getStringFromWasm0(ptr3, len3);
1969
+ } finally {
1970
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1971
+ }
1972
+ }
1973
+ /**
1974
+ * @param {string | null} [page]
1975
+ * @param {string | null} [route]
1976
+ * @returns {string}
1977
+ */
1978
+ pageCircuit(page, route) {
1979
+ let deferred4_0;
1980
+ let deferred4_1;
1981
+ try {
1982
+ var ptr0 = isLikeNone(page) ? 0 : passStringToWasm0(page, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1983
+ var len0 = WASM_VECTOR_LEN;
1984
+ var ptr1 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1985
+ var len1 = WASM_VECTOR_LEN;
1986
+ const ret = wasm.server_pageCircuit(this.__wbg_ptr, ptr0, len0, ptr1, len1);
1987
+ var ptr3 = ret[0];
1988
+ var len3 = ret[1];
1989
+ if (ret[3]) {
1990
+ ptr3 = 0; len3 = 0;
1991
+ throw takeFromExternrefTable0(ret[2]);
1992
+ }
1993
+ deferred4_0 = ptr3;
1994
+ deferred4_1 = len3;
1995
+ return getStringFromWasm0(ptr3, len3);
1996
+ } finally {
1997
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
1998
+ }
1999
+ }
2000
+ /**
2001
+ * @param {string} orbital
2002
+ * @param {string} request_json
2003
+ * @returns {string}
2004
+ */
2005
+ relayTick(orbital, request_json) {
2006
+ let deferred4_0;
2007
+ let deferred4_1;
2008
+ try {
2009
+ const ptr0 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2010
+ const len0 = WASM_VECTOR_LEN;
2011
+ const ptr1 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2012
+ const len1 = WASM_VECTOR_LEN;
2013
+ const ret = wasm.server_relayTick(this.__wbg_ptr, ptr0, len0, ptr1, len1);
2014
+ var ptr3 = ret[0];
2015
+ var len3 = ret[1];
2016
+ if (ret[3]) {
2017
+ ptr3 = 0; len3 = 0;
2018
+ throw takeFromExternrefTable0(ret[2]);
2019
+ }
2020
+ deferred4_0 = ptr3;
2021
+ deferred4_1 = len3;
2022
+ return getStringFromWasm0(ptr3, len3);
2023
+ } finally {
2024
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2025
+ }
2026
+ }
2027
+ /**
2028
+ * @param {string} client
2029
+ */
2030
+ releaseClient(client) {
2031
+ const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2032
+ const len0 = WASM_VECTOR_LEN;
2033
+ wasm.server_releaseClient(this.__wbg_ptr, ptr0, len0);
2034
+ }
2035
+ /**
2036
+ * @param {string} traits_json
2037
+ */
2038
+ remount(traits_json) {
2039
+ const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2040
+ const len0 = WASM_VECTOR_LEN;
2041
+ const ret = wasm.server_remount(this.__wbg_ptr, ptr0, len0);
2042
+ if (ret[1]) {
2043
+ throw takeFromExternrefTable0(ret[0]);
2044
+ }
2045
+ }
2046
+ /**
2047
+ * @param {string} ref_json
2048
+ * @param {string | null} [client_id]
2049
+ * @returns {string}
2050
+ */
2051
+ resolveRows(ref_json, client_id) {
2052
+ let deferred4_0;
2053
+ let deferred4_1;
2054
+ try {
2055
+ const ptr0 = passStringToWasm0(ref_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2056
+ const len0 = WASM_VECTOR_LEN;
2057
+ var ptr1 = isLikeNone(client_id) ? 0 : passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2058
+ var len1 = WASM_VECTOR_LEN;
2059
+ const ret = wasm.server_resolveRows(this.__wbg_ptr, ptr0, len0, ptr1, len1);
2060
+ var ptr3 = ret[0];
2061
+ var len3 = ret[1];
2062
+ if (ret[3]) {
2063
+ ptr3 = 0; len3 = 0;
2064
+ throw takeFromExternrefTable0(ret[2]);
2065
+ }
2066
+ deferred4_0 = ptr3;
2067
+ deferred4_1 = len3;
2068
+ return getStringFromWasm0(ptr3, len3);
2069
+ } finally {
2070
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2071
+ }
2072
+ }
2073
+ /**
2074
+ * @param {number} flight
2075
+ * @param {string} replies_json
2076
+ * @returns {string}
2077
+ */
2078
+ resume(flight, replies_json) {
2079
+ let deferred3_0;
2080
+ let deferred3_1;
2081
+ try {
2082
+ const ptr0 = passStringToWasm0(replies_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2083
+ const len0 = WASM_VECTOR_LEN;
2084
+ const ret = wasm.server_resume(this.__wbg_ptr, flight, ptr0, len0);
2085
+ var ptr2 = ret[0];
2086
+ var len2 = ret[1];
2087
+ if (ret[3]) {
2088
+ ptr2 = 0; len2 = 0;
2089
+ throw takeFromExternrefTable0(ret[2]);
2090
+ }
2091
+ deferred3_0 = ptr2;
2092
+ deferred3_1 = len2;
2093
+ return getStringFromWasm0(ptr2, len2);
2094
+ } finally {
2095
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2096
+ }
2097
+ }
2098
+ /**
2099
+ * @param {number} flight
2100
+ * @param {string} replies_json
2101
+ * @returns {string}
2102
+ */
2103
+ resumeResolve(flight, replies_json) {
2104
+ let deferred3_0;
2105
+ let deferred3_1;
2106
+ try {
2107
+ const ptr0 = passStringToWasm0(replies_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2108
+ const len0 = WASM_VECTOR_LEN;
2109
+ const ret = wasm.server_resumeResolve(this.__wbg_ptr, flight, ptr0, len0);
2110
+ var ptr2 = ret[0];
2111
+ var len2 = ret[1];
2112
+ if (ret[3]) {
2113
+ ptr2 = 0; len2 = 0;
2114
+ throw takeFromExternrefTable0(ret[2]);
2115
+ }
2116
+ deferred3_0 = ptr2;
2117
+ deferred3_1 = len2;
2118
+ return getStringFromWasm0(ptr2, len2);
2119
+ } finally {
2120
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2121
+ }
2122
+ }
2123
+ /**
2124
+ * @param {string} route_path
2125
+ * @returns {string}
2126
+ */
2127
+ routeMounts(route_path) {
2128
+ let deferred3_0;
2129
+ let deferred3_1;
2130
+ try {
2131
+ const ptr0 = passStringToWasm0(route_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2132
+ const len0 = WASM_VECTOR_LEN;
2133
+ const ret = wasm.server_routeMounts(this.__wbg_ptr, ptr0, len0);
2134
+ var ptr2 = ret[0];
2135
+ var len2 = ret[1];
2136
+ if (ret[3]) {
2137
+ ptr2 = 0; len2 = 0;
2138
+ throw takeFromExternrefTable0(ret[2]);
2139
+ }
2140
+ deferred3_0 = ptr2;
2141
+ deferred3_1 = len2;
2142
+ return getStringFromWasm0(ptr2, len2);
2143
+ } finally {
2144
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2145
+ }
2146
+ }
2147
+ /**
2148
+ * @param {string} entity_type
2149
+ * @param {string} query_json
2150
+ * @param {string} write_json
2151
+ */
2152
+ setCapabilities(entity_type, query_json, write_json) {
2153
+ const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2154
+ const len0 = WASM_VECTOR_LEN;
2155
+ const ptr1 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2156
+ const len1 = WASM_VECTOR_LEN;
2157
+ const ptr2 = passStringToWasm0(write_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2158
+ const len2 = WASM_VECTOR_LEN;
2159
+ const ret = wasm.server_setCapabilities(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
2160
+ if (ret[1]) {
2161
+ throw takeFromExternrefTable0(ret[0]);
2162
+ }
2163
+ }
2164
+ /**
2165
+ * @param {string} program_json
2166
+ */
2167
+ setManagedProgram(program_json) {
2168
+ const ptr0 = passStringToWasm0(program_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2169
+ const len0 = WASM_VECTOR_LEN;
2170
+ const ret = wasm.server_setManagedProgram(this.__wbg_ptr, ptr0, len0);
2171
+ if (ret[1]) {
2172
+ throw takeFromExternrefTable0(ret[0]);
2173
+ }
2174
+ }
2175
+ /**
2176
+ * @param {string} anchors_json
2177
+ * @returns {string}
2178
+ */
2179
+ setOsAnchors(anchors_json) {
2180
+ let deferred3_0;
2181
+ let deferred3_1;
2182
+ try {
2183
+ const ptr0 = passStringToWasm0(anchors_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2184
+ const len0 = WASM_VECTOR_LEN;
2185
+ const ret = wasm.server_setOsAnchors(this.__wbg_ptr, ptr0, len0);
2186
+ var ptr2 = ret[0];
2187
+ var len2 = ret[1];
2188
+ if (ret[3]) {
2189
+ ptr2 = 0; len2 = 0;
2190
+ throw takeFromExternrefTable0(ret[2]);
2191
+ }
2192
+ deferred3_0 = ptr2;
2193
+ deferred3_1 = len2;
2194
+ return getStringFromWasm0(ptr2, len2);
2195
+ } finally {
2196
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2197
+ }
2198
+ }
2199
+ /**
2200
+ * @param {boolean} stateful
2201
+ */
2202
+ setStateful(stateful) {
2203
+ wasm.server_setStateful(this.__wbg_ptr, stateful);
2204
+ }
2205
+ /**
2206
+ * @param {number} interval_ms
2207
+ */
2208
+ setTickRelayInterval(interval_ms) {
2209
+ wasm.server_setTickRelayInterval(this.__wbg_ptr, interval_ms);
2210
+ }
2211
+ /**
2212
+ * @param {string} orbital
2213
+ * @param {string} request_json
2214
+ * @returns {string}
2215
+ */
2216
+ start(orbital, request_json) {
2217
+ let deferred4_0;
2218
+ let deferred4_1;
2219
+ try {
2220
+ const ptr0 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2221
+ const len0 = WASM_VECTOR_LEN;
2222
+ const ptr1 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2223
+ const len1 = WASM_VECTOR_LEN;
2224
+ const ret = wasm.server_start(this.__wbg_ptr, ptr0, len0, ptr1, len1);
2225
+ var ptr3 = ret[0];
2226
+ var len3 = ret[1];
2227
+ if (ret[3]) {
2228
+ ptr3 = 0; len3 = 0;
2229
+ throw takeFromExternrefTable0(ret[2]);
2230
+ }
2231
+ deferred4_0 = ptr3;
2232
+ deferred4_1 = len3;
2233
+ return getStringFromWasm0(ptr3, len3);
2234
+ } finally {
2235
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2236
+ }
2237
+ }
2238
+ /**
2239
+ * @param {number} now_ms
2240
+ * @returns {string}
2241
+ */
2242
+ tickPass(now_ms) {
2243
+ let deferred2_0;
2244
+ let deferred2_1;
2245
+ try {
2246
+ const ret = wasm.server_tickPass(this.__wbg_ptr, now_ms);
2247
+ var ptr1 = ret[0];
2248
+ var len1 = ret[1];
2249
+ if (ret[3]) {
2250
+ ptr1 = 0; len1 = 0;
2251
+ throw takeFromExternrefTable0(ret[2]);
2252
+ }
2253
+ deferred2_0 = ptr1;
2254
+ deferred2_1 = len1;
2255
+ return getStringFromWasm0(ptr1, len1);
2256
+ } finally {
2257
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
2258
+ }
2259
+ }
2260
+ tickPause() {
2261
+ wasm.server_tickPause(this.__wbg_ptr);
2262
+ }
2263
+ /**
2264
+ * @returns {boolean}
2265
+ */
2266
+ tickPaused() {
2267
+ const ret = wasm.server_tickPaused(this.__wbg_ptr);
2268
+ return ret !== 0;
2269
+ }
2270
+ tickResume() {
2271
+ wasm.server_tickResume(this.__wbg_ptr);
2272
+ }
2273
+ /**
2274
+ * Feed a deferred raw `os/` outcome into the TLS operation the kernel parked under `key`: `null` when `key` parks
2275
+ * none, `{ ask: { op, args } }` for the next raw ask the host must answer, or `{ done: Settled }`.
2276
+ * @param {string} key
2277
+ * @param {string} outcome_json
2278
+ * @returns {string}
2279
+ */
2280
+ tlsComplete(key, outcome_json) {
2281
+ let deferred4_0;
2282
+ let deferred4_1;
2283
+ try {
2284
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2285
+ const len0 = WASM_VECTOR_LEN;
2286
+ const ptr1 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2287
+ const len1 = WASM_VECTOR_LEN;
2288
+ const ret = wasm.server_tlsComplete(this.__wbg_ptr, ptr0, len0, ptr1, len1);
2289
+ var ptr3 = ret[0];
2290
+ var len3 = ret[1];
2291
+ if (ret[3]) {
2292
+ ptr3 = 0; len3 = 0;
2293
+ throw takeFromExternrefTable0(ret[2]);
2294
+ }
2295
+ deferred4_0 = ptr3;
2296
+ deferred4_1 = len3;
2297
+ return getStringFromWasm0(ptr3, len3);
2298
+ } finally {
2299
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2300
+ }
2301
+ }
2302
+ /**
2303
+ * @param {string} client
2304
+ * @param {string} orbital
2305
+ * @param {string} traits_json
2306
+ */
2307
+ unmountClient(client, orbital, traits_json) {
2308
+ const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2309
+ const len0 = WASM_VECTOR_LEN;
2310
+ const ptr1 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2311
+ const len1 = WASM_VECTOR_LEN;
2312
+ const ptr2 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2313
+ const len2 = WASM_VECTOR_LEN;
2314
+ const ret = wasm.server_unmountClient(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
2315
+ if (ret[1]) {
2316
+ throw takeFromExternrefTable0(ret[0]);
2317
+ }
2318
+ }
2319
+ }
2320
+ if (Symbol.dispose) Server.prototype[Symbol.dispose] = Server.prototype.free;
2321
+
2322
+ /**
2323
+ * Whether a row may be created, updated or deleted under a directive (`MutationVerdictWire` as JSON).
2324
+ * @param {string} operation
2325
+ * @param {string} bindings_json
2326
+ * @param {string} row_json
2327
+ * @param {string} policy_json
2328
+ * @param {string} entity_type
2329
+ * @returns {string}
2330
+ */
2331
+ export function checkMutationAccess(operation, bindings_json, row_json, policy_json, entity_type) {
2332
+ let deferred7_0;
2333
+ let deferred7_1;
2334
+ try {
2335
+ const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2336
+ const len0 = WASM_VECTOR_LEN;
2337
+ const ptr1 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2338
+ const len1 = WASM_VECTOR_LEN;
2339
+ const ptr2 = passStringToWasm0(row_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2340
+ const len2 = WASM_VECTOR_LEN;
2341
+ const ptr3 = passStringToWasm0(policy_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2342
+ const len3 = WASM_VECTOR_LEN;
2343
+ const ptr4 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2344
+ const len4 = WASM_VECTOR_LEN;
2345
+ const ret = wasm.checkMutationAccess(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
2346
+ var ptr6 = ret[0];
2347
+ var len6 = ret[1];
2348
+ if (ret[3]) {
2349
+ ptr6 = 0; len6 = 0;
2350
+ throw takeFromExternrefTable0(ret[2]);
2351
+ }
2352
+ deferred7_0 = ptr6;
2353
+ deferred7_1 = len6;
2354
+ return getStringFromWasm0(ptr6, len6);
2355
+ } finally {
2356
+ wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
2357
+ }
2358
+ }
2359
+
2360
+ /**
2361
+ * One `ContractQuery` (as JSON) answered for a host with no registered program, as JSON.
2362
+ * @param {string} query_json
2363
+ * @returns {string}
2364
+ */
2365
+ export function contractQueryWithoutProgram(query_json) {
2366
+ let deferred3_0;
2367
+ let deferred3_1;
2368
+ try {
2369
+ const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2370
+ const len0 = WASM_VECTOR_LEN;
2371
+ const ret = wasm.contractQueryWithoutProgram(ptr0, len0);
2372
+ var ptr2 = ret[0];
2373
+ var len2 = ret[1];
2374
+ if (ret[3]) {
2375
+ ptr2 = 0; len2 = 0;
2376
+ throw takeFromExternrefTable0(ret[2]);
2377
+ }
2378
+ deferred3_0 = ptr2;
2379
+ deferred3_1 = len2;
2380
+ return getStringFromWasm0(ptr2, len2);
2381
+ } finally {
2382
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2383
+ }
2384
+ }
2385
+
2386
+ /**
2387
+ * Every guard of a render against a context in one crossing (`GuardOutcomeWire[]` as JSON).
2388
+ * @param {string} context_json
2389
+ * @param {string} guards_json
2390
+ * @returns {string}
2391
+ */
2392
+ export function evaluateGuards(context_json, guards_json) {
2393
+ let deferred4_0;
2394
+ let deferred4_1;
2395
+ try {
2396
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2397
+ const len0 = WASM_VECTOR_LEN;
2398
+ const ptr1 = passStringToWasm0(guards_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2399
+ const len1 = WASM_VECTOR_LEN;
2400
+ const ret = wasm.evaluateGuards(ptr0, len0, ptr1, len1);
2401
+ var ptr3 = ret[0];
2402
+ var len3 = ret[1];
2403
+ if (ret[3]) {
2404
+ ptr3 = 0; len3 = 0;
2405
+ throw takeFromExternrefTable0(ret[2]);
2406
+ }
2407
+ deferred4_0 = ptr3;
2408
+ deferred4_1 = len3;
2409
+ return getStringFromWasm0(ptr3, len3);
2410
+ } finally {
2411
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2412
+ }
2413
+ }
2414
+
2415
+ /**
2416
+ * Evaluate `expressionsJson` (`SExpr[]`) against `contextJson` (`EvalContextWire`) in one crossing:
2417
+ * `EvalOutcomeWire[]` as JSON, in order.
2418
+ * @param {string} context_json
2419
+ * @param {string} expressions_json
2420
+ * @returns {string}
2421
+ */
2422
+ export function evaluateMany(context_json, expressions_json) {
2423
+ let deferred4_0;
2424
+ let deferred4_1;
2425
+ try {
2426
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2427
+ const len0 = WASM_VECTOR_LEN;
2428
+ const ptr1 = passStringToWasm0(expressions_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2429
+ const len1 = WASM_VECTOR_LEN;
2430
+ const ret = wasm.evaluateMany(ptr0, len0, ptr1, len1);
2431
+ var ptr3 = ret[0];
2432
+ var len3 = ret[1];
2433
+ if (ret[3]) {
2434
+ ptr3 = 0; len3 = 0;
2435
+ throw takeFromExternrefTable0(ret[2]);
2436
+ }
2437
+ deferred4_0 = ptr3;
2438
+ deferred4_1 = len3;
2439
+ return getStringFromWasm0(ptr3, len3);
2440
+ } finally {
2441
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2442
+ }
2443
+ }
2444
+
2445
+ /**
2446
+ * One expression with its trace (`EvalTracedWire` as JSON).
2447
+ * @param {string} context_json
2448
+ * @param {string} expression_json
2449
+ * @returns {string}
2450
+ */
2451
+ export function evaluateTraced(context_json, expression_json) {
2452
+ let deferred4_0;
2453
+ let deferred4_1;
2454
+ try {
2455
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2456
+ const len0 = WASM_VECTOR_LEN;
2457
+ const ptr1 = passStringToWasm0(expression_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2458
+ const len1 = WASM_VECTOR_LEN;
2459
+ const ret = wasm.evaluateTraced(ptr0, len0, ptr1, len1);
2460
+ var ptr3 = ret[0];
2461
+ var len3 = ret[1];
2462
+ if (ret[3]) {
2463
+ ptr3 = 0; len3 = 0;
2464
+ throw takeFromExternrefTable0(ret[2]);
2465
+ }
2466
+ deferred4_0 = ptr3;
2467
+ deferred4_1 = len3;
2468
+ return getStringFromWasm0(ptr3, len3);
2469
+ } finally {
2470
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2471
+ }
2472
+ }
2473
+
2474
+ /**
2475
+ * The program's emitter-to-listener wire table (`EventWire[]` as JSON), by the source rule the kernel delivers by.
2476
+ * @param {string} schema_json
2477
+ * @returns {string}
2478
+ */
2479
+ export function eventWires(schema_json) {
2480
+ let deferred3_0;
2481
+ let deferred3_1;
2482
+ try {
2483
+ const ptr0 = passStringToWasm0(schema_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2484
+ const len0 = WASM_VECTOR_LEN;
2485
+ const ret = wasm.eventWires(ptr0, len0);
2486
+ var ptr2 = ret[0];
2487
+ var len2 = ret[1];
2488
+ if (ret[3]) {
2489
+ ptr2 = 0; len2 = 0;
2490
+ throw takeFromExternrefTable0(ret[2]);
2491
+ }
2492
+ deferred3_0 = ptr2;
2493
+ deferred3_1 = len2;
2494
+ return getStringFromWasm0(ptr2, len2);
2495
+ } finally {
2496
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2497
+ }
2498
+ }
2499
+
2500
+ /**
2501
+ * @param {string} layer_json
2502
+ * @param {number} epoch_now_ms
2503
+ * @param {string} dimension
2504
+ * @param {number} tile_width
2505
+ * @returns {string}
2506
+ */
2507
+ export function expandFxLayer(layer_json, epoch_now_ms, dimension, tile_width) {
2508
+ let deferred4_0;
2509
+ let deferred4_1;
2510
+ try {
2511
+ const ptr0 = passStringToWasm0(layer_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2512
+ const len0 = WASM_VECTOR_LEN;
2513
+ const ptr1 = passStringToWasm0(dimension, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2514
+ const len1 = WASM_VECTOR_LEN;
2515
+ const ret = wasm.expandFxLayer(ptr0, len0, epoch_now_ms, ptr1, len1, tile_width);
2516
+ var ptr3 = ret[0];
2517
+ var len3 = ret[1];
2518
+ if (ret[3]) {
2519
+ ptr3 = 0; len3 = 0;
2520
+ throw takeFromExternrefTable0(ret[2]);
2521
+ }
2522
+ deferred4_0 = ptr3;
2523
+ deferred4_1 = len3;
2524
+ return getStringFromWasm0(ptr3, len3);
2525
+ } finally {
2526
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2527
+ }
2528
+ }
2529
+
2530
+ /**
2531
+ * @param {string} seed
2532
+ * @param {number} salt
2533
+ * @returns {number}
2534
+ */
2535
+ export function fxHash01(seed, salt) {
2536
+ const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2537
+ const len0 = WASM_VECTOR_LEN;
2538
+ const ret = wasm.fxHash01(ptr0, len0, salt);
2539
+ return ret;
2540
+ }
2541
+
2542
+ /**
2543
+ * @param {string} view_json
2544
+ * @param {number} epoch_now_ms
2545
+ * @param {number} tick_ms
2546
+ * @returns {string}
2547
+ */
2548
+ export function fxLifecycle(view_json, epoch_now_ms, tick_ms) {
2549
+ let deferred3_0;
2550
+ let deferred3_1;
2551
+ try {
2552
+ const ptr0 = passStringToWasm0(view_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2553
+ const len0 = WASM_VECTOR_LEN;
2554
+ const ret = wasm.fxLifecycle(ptr0, len0, epoch_now_ms, tick_ms);
2555
+ var ptr2 = ret[0];
2556
+ var len2 = ret[1];
2557
+ if (ret[3]) {
2558
+ ptr2 = 0; len2 = 0;
2559
+ throw takeFromExternrefTable0(ret[2]);
2560
+ }
2561
+ deferred3_0 = ptr2;
2562
+ deferred3_1 = len2;
2563
+ return getStringFromWasm0(ptr2, len2);
2564
+ } finally {
2565
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2566
+ }
2567
+ }
2568
+
2569
+ /**
2570
+ * Install the language data a host assembles from its installed `@almadar/core` and `@almadar/std`
2571
+ * (`readLanguageBundle`): the operator table that routes `program/*` and the other host effects.
2572
+ * @param {string} bundle_json
2573
+ */
2574
+ export function installLanguage(bundle_json) {
2575
+ const ptr0 = passStringToWasm0(bundle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2576
+ const len0 = WASM_VECTOR_LEN;
2577
+ const ret = wasm.installLanguage(ptr0, len0);
2578
+ if (ret[1]) {
2579
+ throw takeFromExternrefTable0(ret[0]);
2580
+ }
2581
+ }
2582
+
2583
+ /**
2584
+ * @param {string} ip
2585
+ * @returns {boolean}
2586
+ */
2587
+ export function isPublicAddress(ip) {
2588
+ const ptr0 = passStringToWasm0(ip, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2589
+ const len0 = WASM_VECTOR_LEN;
2590
+ const ret = wasm.isPublicAddress(ptr0, len0);
2591
+ if (ret[2]) {
2592
+ throw takeFromExternrefTable0(ret[1]);
2593
+ }
2594
+ return ret[0] !== 0;
2595
+ }
2596
+
2597
+ /**
2598
+ * A listen route's `with` mapping applied to the source payload (the mapped payload as JSON).
2599
+ * @param {string} mapping_json
2600
+ * @param {string} payload_json
2601
+ * @returns {string}
2602
+ */
2603
+ export function mapListenPayload(mapping_json, payload_json) {
2604
+ let deferred4_0;
2605
+ let deferred4_1;
2606
+ try {
2607
+ const ptr0 = passStringToWasm0(mapping_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2608
+ const len0 = WASM_VECTOR_LEN;
2609
+ const ptr1 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2610
+ const len1 = WASM_VECTOR_LEN;
2611
+ const ret = wasm.mapListenPayload(ptr0, len0, ptr1, len1);
2612
+ var ptr3 = ret[0];
2613
+ var len3 = ret[1];
2614
+ if (ret[3]) {
2615
+ ptr3 = 0; len3 = 0;
2616
+ throw takeFromExternrefTable0(ret[2]);
2617
+ }
2618
+ deferred4_0 = ptr3;
2619
+ deferred4_1 = len3;
2620
+ return getStringFromWasm0(ptr3, len3);
2621
+ } finally {
2622
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2623
+ }
2624
+ }
2625
+
2626
+ /**
2627
+ * The `{ event, payload }` a deferred keyed `os/` call's outcome (`Settled`) fires on its call site, or `null`.
2628
+ * @param {string} site_json
2629
+ * @param {string} key
2630
+ * @param {string} outcome_json
2631
+ * @returns {string}
2632
+ */
2633
+ export function osCompletionEvent(site_json, key, outcome_json) {
2634
+ let deferred5_0;
2635
+ let deferred5_1;
2636
+ try {
2637
+ const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2638
+ const len0 = WASM_VECTOR_LEN;
2639
+ const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2640
+ const len1 = WASM_VECTOR_LEN;
2641
+ const ptr2 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2642
+ const len2 = WASM_VECTOR_LEN;
2643
+ const ret = wasm.osCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2);
2644
+ var ptr4 = ret[0];
2645
+ var len4 = ret[1];
2646
+ if (ret[3]) {
2647
+ ptr4 = 0; len4 = 0;
2648
+ throw takeFromExternrefTable0(ret[2]);
2649
+ }
2650
+ deferred5_0 = ptr4;
2651
+ deferred5_1 = len4;
2652
+ return getStringFromWasm0(ptr4, len4);
2653
+ } finally {
2654
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
2655
+ }
2656
+ }
2657
+
2658
+ /**
2659
+ * The names of the `os/` operations whose keyed call may defer its completion, as a JSON array.
2660
+ * @returns {string}
2661
+ */
2662
+ export function osDeferringOps() {
2663
+ let deferred2_0;
2664
+ let deferred2_1;
2665
+ try {
2666
+ const ret = wasm.osDeferringOps();
2667
+ var ptr1 = ret[0];
2668
+ var len1 = ret[1];
2669
+ if (ret[3]) {
2670
+ ptr1 = 0; len1 = 0;
2671
+ throw takeFromExternrefTable0(ret[2]);
2672
+ }
2673
+ deferred2_0 = ptr1;
2674
+ deferred2_1 = len1;
2675
+ return getStringFromWasm0(ptr1, len1);
2676
+ } finally {
2677
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
2678
+ }
2679
+ }
2680
+
2681
+ /**
2682
+ * @param {string} glob
2683
+ * @param {string} path
2684
+ * @returns {boolean}
2685
+ */
2686
+ export function osGlobMatches(glob, path) {
2687
+ const ptr0 = passStringToWasm0(glob, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2688
+ const len0 = WASM_VECTOR_LEN;
2689
+ const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2690
+ const len1 = WASM_VECTOR_LEN;
2691
+ const ret = wasm.osGlobMatches(ptr0, len0, ptr1, len1);
2692
+ return ret !== 0;
2693
+ }
2694
+
2695
+ /**
2696
+ * The names of the `os/` operations whose keyed call is a stream, as a JSON array.
2697
+ * @returns {string}
2698
+ */
2699
+ export function osStreamOps() {
2700
+ let deferred2_0;
2701
+ let deferred2_1;
2702
+ try {
2703
+ const ret = wasm.osStreamOps();
2704
+ var ptr1 = ret[0];
2705
+ var len1 = ret[1];
2706
+ if (ret[3]) {
2707
+ ptr1 = 0; len1 = 0;
2708
+ throw takeFromExternrefTable0(ret[2]);
2709
+ }
2710
+ deferred2_0 = ptr1;
2711
+ deferred2_1 = len1;
2712
+ return getStringFromWasm0(ptr1, len1);
2713
+ } finally {
2714
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
2715
+ }
2716
+ }
2717
+
2718
+ /**
2719
+ * The typed event request a `program/dispatch` call names, as an object; a record that is no event request throws the reason.
2720
+ * @param {string} payload_json
2721
+ * @param {string} options_json
2722
+ * @returns {any}
2723
+ */
2724
+ export function parseEventRequest(payload_json, options_json) {
2725
+ const ptr0 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2726
+ const len0 = WASM_VECTOR_LEN;
2727
+ const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2728
+ const len1 = WASM_VECTOR_LEN;
2729
+ const ret = wasm.parseEventRequest(ptr0, len0, ptr1, len1);
2730
+ if (ret[2]) {
2731
+ throw takeFromExternrefTable0(ret[1]);
2732
+ }
2733
+ return takeFromExternrefTable0(ret[0]);
2734
+ }
2735
+
2736
+ export function report_panics() {
2737
+ wasm.report_panics();
2738
+ }
2739
+
2740
+ /**
2741
+ * @param {string} item_json
2742
+ * @param {string | null} [presets_json]
2743
+ * @returns {string}
2744
+ */
2745
+ export function resolveFxView(item_json, presets_json) {
2746
+ let deferred4_0;
2747
+ let deferred4_1;
2748
+ try {
2749
+ const ptr0 = passStringToWasm0(item_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2750
+ const len0 = WASM_VECTOR_LEN;
2751
+ var ptr1 = isLikeNone(presets_json) ? 0 : passStringToWasm0(presets_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2752
+ var len1 = WASM_VECTOR_LEN;
2753
+ const ret = wasm.resolveFxView(ptr0, len0, ptr1, len1);
2754
+ var ptr3 = ret[0];
2755
+ var len3 = ret[1];
2756
+ if (ret[3]) {
2757
+ ptr3 = 0; len3 = 0;
2758
+ throw takeFromExternrefTable0(ret[2]);
2759
+ }
2760
+ deferred4_0 = ptr3;
2761
+ deferred4_1 = len3;
2762
+ return getStringFromWasm0(ptr3, len3);
2763
+ } finally {
2764
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2765
+ }
2766
+ }
2767
+
2768
+ /**
2769
+ * What a `@user`/`@payload`/`@config`/`@now` term folds to for a row predicate (`RowBindingWire` as JSON).
2770
+ * @param {string} term
2771
+ * @param {string} bindings_json
2772
+ * @returns {string}
2773
+ */
2774
+ export function resolveRowBinding(term, bindings_json) {
2775
+ let deferred4_0;
2776
+ let deferred4_1;
2777
+ try {
2778
+ const ptr0 = passStringToWasm0(term, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2779
+ const len0 = WASM_VECTOR_LEN;
2780
+ const ptr1 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2781
+ const len1 = WASM_VECTOR_LEN;
2782
+ const ret = wasm.resolveRowBinding(ptr0, len0, ptr1, len1);
2783
+ var ptr3 = ret[0];
2784
+ var len3 = ret[1];
2785
+ if (ret[3]) {
2786
+ ptr3 = 0; len3 = 0;
2787
+ throw takeFromExternrefTable0(ret[2]);
2788
+ }
2789
+ deferred4_0 = ptr3;
2790
+ deferred4_1 = len3;
2791
+ return getStringFromWasm0(ptr3, len3);
2792
+ } finally {
2793
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2794
+ }
2795
+ }
2796
+
2797
+ /**
2798
+ * Resolve every prop value of a render against `contextJson` in one crossing: each binding, embedded ones
2799
+ * included, and each operator call (`EvalOutcomeWire[]` as JSON, in order).
2800
+ * @param {string} context_json
2801
+ * @param {string} values_json
2802
+ * @returns {string}
2803
+ */
2804
+ export function resolveValues(context_json, values_json) {
2805
+ let deferred4_0;
2806
+ let deferred4_1;
2807
+ try {
2808
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2809
+ const len0 = WASM_VECTOR_LEN;
2810
+ const ptr1 = passStringToWasm0(values_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2811
+ const len1 = WASM_VECTOR_LEN;
2812
+ const ret = wasm.resolveValues(ptr0, len0, ptr1, len1);
2813
+ var ptr3 = ret[0];
2814
+ var len3 = ret[1];
2815
+ if (ret[3]) {
2816
+ ptr3 = 0; len3 = 0;
2817
+ throw takeFromExternrefTable0(ret[2]);
2818
+ }
2819
+ deferred4_0 = ptr3;
2820
+ deferred4_1 = len3;
2821
+ return getStringFromWasm0(ptr3, len3);
2822
+ } finally {
2823
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2824
+ }
2825
+ }
2826
+
2827
+ /**
2828
+ * The rows that pass a `@read` policy and a call-site filter (each an `SExpr` as JSON, or empty).
2829
+ * @param {string} bindings_json
2830
+ * @param {string} rows_json
2831
+ * @param {string} policy_json
2832
+ * @param {string} filter_json
2833
+ * @param {string} entity_type
2834
+ * @returns {string}
2835
+ */
2836
+ export function scopeRows(bindings_json, rows_json, policy_json, filter_json, entity_type) {
2837
+ let deferred7_0;
2838
+ let deferred7_1;
2839
+ try {
2840
+ const ptr0 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2841
+ const len0 = WASM_VECTOR_LEN;
2842
+ const ptr1 = passStringToWasm0(rows_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2843
+ const len1 = WASM_VECTOR_LEN;
2844
+ const ptr2 = passStringToWasm0(policy_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2845
+ const len2 = WASM_VECTOR_LEN;
2846
+ const ptr3 = passStringToWasm0(filter_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2847
+ const len3 = WASM_VECTOR_LEN;
2848
+ const ptr4 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2849
+ const len4 = WASM_VECTOR_LEN;
2850
+ const ret = wasm.scopeRows(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
2851
+ var ptr6 = ret[0];
2852
+ var len6 = ret[1];
2853
+ if (ret[3]) {
2854
+ ptr6 = 0; len6 = 0;
2855
+ throw takeFromExternrefTable0(ret[2]);
2856
+ }
2857
+ deferred7_0 = ptr6;
2858
+ deferred7_1 = len6;
2859
+ return getStringFromWasm0(ptr6, len6);
2860
+ } finally {
2861
+ wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
2862
+ }
2863
+ }
2864
+
2865
+ /**
2866
+ * @param {string} matrix_json
2867
+ * @param {number} x
2868
+ * @param {number} y
2869
+ * @returns {string}
2870
+ */
2871
+ export function skinApplyAffine(matrix_json, x, y) {
2872
+ let deferred3_0;
2873
+ let deferred3_1;
2874
+ try {
2875
+ const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2876
+ const len0 = WASM_VECTOR_LEN;
2877
+ const ret = wasm.skinApplyAffine(ptr0, len0, x, y);
2878
+ var ptr2 = ret[0];
2879
+ var len2 = ret[1];
2880
+ if (ret[3]) {
2881
+ ptr2 = 0; len2 = 0;
2882
+ throw takeFromExternrefTable0(ret[2]);
2883
+ }
2884
+ deferred3_0 = ptr2;
2885
+ deferred3_1 = len2;
2886
+ return getStringFromWasm0(ptr2, len2);
2887
+ } finally {
2888
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2889
+ }
2890
+ }
2891
+
2892
+ /**
2893
+ * @param {string} a_json
2894
+ * @param {string} b_json
2895
+ * @returns {string}
2896
+ */
2897
+ export function skinComposeAffine(a_json, b_json) {
2898
+ let deferred4_0;
2899
+ let deferred4_1;
2900
+ try {
2901
+ const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2902
+ const len0 = WASM_VECTOR_LEN;
2903
+ const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2904
+ const len1 = WASM_VECTOR_LEN;
2905
+ const ret = wasm.skinComposeAffine(ptr0, len0, ptr1, len1);
2906
+ var ptr3 = ret[0];
2907
+ var len3 = ret[1];
2908
+ if (ret[3]) {
2909
+ ptr3 = 0; len3 = 0;
2910
+ throw takeFromExternrefTable0(ret[2]);
2911
+ }
2912
+ deferred4_0 = ptr3;
2913
+ deferred4_1 = len3;
2914
+ return getStringFromWasm0(ptr3, len3);
2915
+ } finally {
2916
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2917
+ }
2918
+ }
2919
+
2920
+ /**
2921
+ * @param {string} matrix_json
2922
+ * @param {number} bone
2923
+ * @returns {string}
2924
+ */
2925
+ export function skinInvertAffine(matrix_json, bone) {
2926
+ let deferred3_0;
2927
+ let deferred3_1;
2928
+ try {
2929
+ const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2930
+ const len0 = WASM_VECTOR_LEN;
2931
+ const ret = wasm.skinInvertAffine(ptr0, len0, bone);
2932
+ var ptr2 = ret[0];
2933
+ var len2 = ret[1];
2934
+ if (ret[3]) {
2935
+ ptr2 = 0; len2 = 0;
2936
+ throw takeFromExternrefTable0(ret[2]);
2937
+ }
2938
+ deferred3_0 = ptr2;
2939
+ deferred3_1 = len2;
2940
+ return getStringFromWasm0(ptr2, len2);
2941
+ } finally {
2942
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2943
+ }
2944
+ }
2945
+
2946
+ /**
2947
+ * @param {string} src_json
2948
+ * @param {string} dst_json
2949
+ * @returns {string}
2950
+ */
2951
+ export function skinTriangleAffine(src_json, dst_json) {
2952
+ let deferred4_0;
2953
+ let deferred4_1;
2954
+ try {
2955
+ const ptr0 = passStringToWasm0(src_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2956
+ const len0 = WASM_VECTOR_LEN;
2957
+ const ptr1 = passStringToWasm0(dst_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2958
+ const len1 = WASM_VECTOR_LEN;
2959
+ const ret = wasm.skinTriangleAffine(ptr0, len0, ptr1, len1);
2960
+ var ptr3 = ret[0];
2961
+ var len3 = ret[1];
2962
+ if (ret[3]) {
2963
+ ptr3 = 0; len3 = 0;
2964
+ throw takeFromExternrefTable0(ret[2]);
2965
+ }
2966
+ deferred4_0 = ptr3;
2967
+ deferred4_1 = len3;
2968
+ return getStringFromWasm0(ptr3, len3);
2969
+ } finally {
2970
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2971
+ }
2972
+ }
2973
+
2974
+ /**
2975
+ * @param {string} points_json
2976
+ * @returns {string}
2977
+ */
2978
+ export function skinVertexBounds(points_json) {
2979
+ let deferred3_0;
2980
+ let deferred3_1;
2981
+ try {
2982
+ const ptr0 = passStringToWasm0(points_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2983
+ const len0 = WASM_VECTOR_LEN;
2984
+ const ret = wasm.skinVertexBounds(ptr0, len0);
2985
+ var ptr2 = ret[0];
2986
+ var len2 = ret[1];
2987
+ if (ret[3]) {
2988
+ ptr2 = 0; len2 = 0;
2989
+ throw takeFromExternrefTable0(ret[2]);
2990
+ }
2991
+ deferred3_0 = ptr2;
2992
+ deferred3_1 = len2;
2993
+ return getStringFromWasm0(ptr2, len2);
2994
+ } finally {
2995
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2996
+ }
2997
+ }
2998
+
2999
+ /**
3000
+ * @param {string} mesh_json
3001
+ * @param {string} bind_json
3002
+ * @param {string} current_json
3003
+ * @returns {string}
3004
+ */
3005
+ export function skinVertices(mesh_json, bind_json, current_json) {
3006
+ let deferred5_0;
3007
+ let deferred5_1;
3008
+ try {
3009
+ const ptr0 = passStringToWasm0(mesh_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3010
+ const len0 = WASM_VECTOR_LEN;
3011
+ const ptr1 = passStringToWasm0(bind_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3012
+ const len1 = WASM_VECTOR_LEN;
3013
+ const ptr2 = passStringToWasm0(current_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3014
+ const len2 = WASM_VECTOR_LEN;
3015
+ const ret = wasm.skinVertices(ptr0, len0, ptr1, len1, ptr2, len2);
3016
+ var ptr4 = ret[0];
3017
+ var len4 = ret[1];
3018
+ if (ret[3]) {
3019
+ ptr4 = 0; len4 = 0;
3020
+ throw takeFromExternrefTable0(ret[2]);
3021
+ }
3022
+ deferred5_0 = ptr4;
3023
+ deferred5_1 = len4;
3024
+ return getStringFromWasm0(ptr4, len4);
3025
+ } finally {
3026
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
3027
+ }
3028
+ }
3029
+
3030
+ /**
3031
+ * @param {string} bones_json
3032
+ * @param {string} pose_json
3033
+ * @returns {string}
3034
+ */
3035
+ export function skinWorldMatrices(bones_json, pose_json) {
3036
+ let deferred4_0;
3037
+ let deferred4_1;
3038
+ try {
3039
+ const ptr0 = passStringToWasm0(bones_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3040
+ const len0 = WASM_VECTOR_LEN;
3041
+ const ptr1 = passStringToWasm0(pose_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3042
+ const len1 = WASM_VECTOR_LEN;
3043
+ const ret = wasm.skinWorldMatrices(ptr0, len0, ptr1, len1);
3044
+ var ptr3 = ret[0];
3045
+ var len3 = ret[1];
3046
+ if (ret[3]) {
3047
+ ptr3 = 0; len3 = 0;
3048
+ throw takeFromExternrefTable0(ret[2]);
3049
+ }
3050
+ deferred4_0 = ptr3;
3051
+ deferred4_1 = len3;
3052
+ return getStringFromWasm0(ptr3, len3);
3053
+ } finally {
3054
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
3055
+ }
3056
+ }
3057
+
3058
+ /**
3059
+ * @param {string} site_json
3060
+ * @param {string} key
3061
+ * @param {string} op
3062
+ * @param {string} args_json
3063
+ * @param {string} outcome_json
3064
+ * @returns {string}
3065
+ */
3066
+ export function substrateCompletionEvent(site_json, key, op, args_json, outcome_json) {
3067
+ let deferred7_0;
3068
+ let deferred7_1;
3069
+ try {
3070
+ const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3071
+ const len0 = WASM_VECTOR_LEN;
3072
+ const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3073
+ const len1 = WASM_VECTOR_LEN;
3074
+ const ptr2 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3075
+ const len2 = WASM_VECTOR_LEN;
3076
+ const ptr3 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3077
+ const len3 = WASM_VECTOR_LEN;
3078
+ const ptr4 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3079
+ const len4 = WASM_VECTOR_LEN;
3080
+ const ret = wasm.substrateCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
3081
+ var ptr6 = ret[0];
3082
+ var len6 = ret[1];
3083
+ if (ret[3]) {
3084
+ ptr6 = 0; len6 = 0;
3085
+ throw takeFromExternrefTable0(ret[2]);
3086
+ }
3087
+ deferred7_0 = ptr6;
3088
+ deferred7_1 = len6;
3089
+ return getStringFromWasm0(ptr6, len6);
3090
+ } finally {
3091
+ wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
3092
+ }
3093
+ }
3094
+
3095
+ /**
3096
+ * Whether the Chrome match pattern `pattern` matches `url`.
3097
+ * @param {string} pattern
3098
+ * @param {string} url
3099
+ * @returns {boolean}
3100
+ */
3101
+ export function tabUrlMatches(pattern, url) {
3102
+ const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3103
+ const len0 = WASM_VECTOR_LEN;
3104
+ const ptr1 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3105
+ const len1 = WASM_VECTOR_LEN;
3106
+ const ret = wasm.tabUrlMatches(ptr0, len0, ptr1, len1);
3107
+ return ret !== 0;
3108
+ }
3109
+
3110
+ /**
3111
+ * Effects run in order against a row (`TraceEffectsWire` as JSON): a trace per effect, the events raised, the writes made.
3112
+ * @param {string} context_json
3113
+ * @param {string} effects_json
3114
+ * @returns {string}
3115
+ */
3116
+ export function traceEffects(context_json, effects_json) {
3117
+ let deferred4_0;
3118
+ let deferred4_1;
3119
+ try {
3120
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3121
+ const len0 = WASM_VECTOR_LEN;
3122
+ const ptr1 = passStringToWasm0(effects_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3123
+ const len1 = WASM_VECTOR_LEN;
3124
+ const ret = wasm.traceEffects(ptr0, len0, ptr1, len1);
3125
+ var ptr3 = ret[0];
3126
+ var len3 = ret[1];
3127
+ if (ret[3]) {
3128
+ ptr3 = 0; len3 = 0;
3129
+ throw takeFromExternrefTable0(ret[2]);
3130
+ }
3131
+ deferred4_0 = ptr3;
3132
+ deferred4_1 = len3;
3133
+ return getStringFromWasm0(ptr3, len3);
3134
+ } finally {
3135
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
3136
+ }
3137
+ }
3138
+
3139
+ /**
3140
+ * The kernel's verdict on language packs (`[{ package, definition }]` as JSON): throws the refusal that names each pack, section and word.
3141
+ * @param {string} packs_json
3142
+ */
3143
+ export function validatePacks(packs_json) {
3144
+ const ptr0 = passStringToWasm0(packs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3145
+ const len0 = WASM_VECTOR_LEN;
3146
+ const ret = wasm.validatePacks(ptr0, len0);
3147
+ if (ret[1]) {
3148
+ throw takeFromExternrefTable0(ret[0]);
3149
+ }
3150
+ }
3151
+ function __wbg_get_imports() {
3152
+ const import0 = {
3153
+ __proto__: null,
3154
+ __wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
3155
+ const ret = Error(getStringFromWasm0(arg0, arg1));
3156
+ return ret;
3157
+ },
3158
+ __wbg_Window_defb2c76b3875a73: function(arg0) {
3159
+ const ret = arg0.Window;
3160
+ return ret;
3161
+ },
3162
+ __wbg_WorkerGlobalScope_184e45d6565eb3f0: function(arg0) {
3163
+ const ret = arg0.WorkerGlobalScope;
3164
+ return ret;
3165
+ },
3166
+ __wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
3167
+ const ret = debugString(arg1);
3168
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3169
+ const len1 = WASM_VECTOR_LEN;
3170
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3171
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3172
+ },
3173
+ __wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
3174
+ const ret = typeof(arg0) === 'function';
3175
+ return ret;
3176
+ },
3177
+ __wbg___wbindgen_is_null_ea9085d691f535d3: function(arg0) {
3178
+ const ret = arg0 === null;
3179
+ return ret;
3180
+ },
3181
+ __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
3182
+ const val = arg0;
3183
+ const ret = typeof(val) === 'object' && val !== null;
3184
+ return ret;
3185
+ },
3186
+ __wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
3187
+ const ret = typeof(arg0) === 'string';
3188
+ return ret;
3189
+ },
3190
+ __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
3191
+ const ret = arg0 === undefined;
3192
+ return ret;
3193
+ },
3194
+ __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
3195
+ throw new Error(getStringFromWasm0(arg0, arg1));
3196
+ },
3197
+ __wbg__wbg_cb_unref_fffb441def202758: function(arg0) {
3198
+ arg0._wbg_cb_unref();
3199
+ },
3200
+ __wbg_arrayBuffer_3b637f0fa65c5351: function() { return handleError(function (arg0) {
3201
+ const ret = arg0.arrayBuffer();
3202
+ return ret;
3203
+ }, arguments); },
3204
+ __wbg_beginRenderPass_8f60a9940800c223: function() { return handleError(function (arg0, arg1) {
3205
+ const ret = arg0.beginRenderPass(arg1);
3206
+ return ret;
3207
+ }, arguments); },
3208
+ __wbg_buffer_54b87055582c8a81: function(arg0) {
3209
+ const ret = arg0.buffer;
3210
+ return ret;
3211
+ },
3212
+ __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
3213
+ const ret = arg0.call(arg1, arg2);
3214
+ return ret;
3215
+ }, arguments); },
3216
+ __wbg_configure_6e4ddb3faabc6005: function() { return handleError(function (arg0, arg1) {
3217
+ arg0.configure(arg1);
3218
+ }, arguments); },
3219
+ __wbg_copyTextureToBuffer_09ba100a04b1b001: function() { return handleError(function (arg0, arg1, arg2, arg3) {
3220
+ arg0.copyTextureToBuffer(arg1, arg2, arg3);
3221
+ }, arguments); },
3222
+ __wbg_createBindGroupLayout_1dad97f44fda2929: function() { return handleError(function (arg0, arg1) {
3223
+ const ret = arg0.createBindGroupLayout(arg1);
3224
+ return ret;
3225
+ }, arguments); },
3226
+ __wbg_createBindGroup_0ee0646375643dfb: function(arg0, arg1) {
3227
+ const ret = arg0.createBindGroup(arg1);
3228
+ return ret;
3229
+ },
3230
+ __wbg_createBuffer_474baee88e74f68a: function() { return handleError(function (arg0, arg1) {
3231
+ const ret = arg0.createBuffer(arg1);
3232
+ return ret;
3233
+ }, arguments); },
3234
+ __wbg_createCommandEncoder_5229e112300218b4: function(arg0, arg1) {
3235
+ const ret = arg0.createCommandEncoder(arg1);
3236
+ return ret;
3237
+ },
3238
+ __wbg_createPipelineLayout_bf0deba7918ca157: function(arg0, arg1) {
3239
+ const ret = arg0.createPipelineLayout(arg1);
3240
+ return ret;
3241
+ },
3242
+ __wbg_createRenderPipeline_7baf812b1e7e39e8: function() { return handleError(function (arg0, arg1) {
3243
+ const ret = arg0.createRenderPipeline(arg1);
3244
+ return ret;
3245
+ }, arguments); },
3246
+ __wbg_createSampler_5970d585f322df95: function(arg0, arg1) {
3247
+ const ret = arg0.createSampler(arg1);
3248
+ return ret;
3249
+ },
3250
+ __wbg_createShaderModule_744311a1dd685c14: function(arg0, arg1) {
3251
+ const ret = arg0.createShaderModule(arg1);
3252
+ return ret;
3253
+ },
3254
+ __wbg_createTexture_f357c38256411287: function() { return handleError(function (arg0, arg1) {
3255
+ const ret = arg0.createTexture(arg1);
3256
+ return ret;
3257
+ }, arguments); },
3258
+ __wbg_createView_e7a36ec95c4190f3: function() { return handleError(function (arg0, arg1) {
3259
+ const ret = arg0.createView(arg1);
3260
+ return ret;
3261
+ }, arguments); },
3262
+ __wbg_crypto_38df2bab126b63dc: function(arg0) {
3263
+ const ret = arg0.crypto;
3264
+ return ret;
3265
+ },
3266
+ __wbg_draw_b93abd56938fa3b6: function(arg0, arg1, arg2, arg3, arg4) {
3267
+ arg0.draw(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
3268
+ },
3269
+ __wbg_end_2fdce848e1c526bc: function(arg0) {
3270
+ arg0.end();
3271
+ },
3272
+ __wbg_error_96e899f14d8344a2: function(arg0, arg1) {
3273
+ console.error(getStringFromWasm0(arg0, arg1));
3274
+ },
3275
+ __wbg_fetch_58167e2c1ef32e0a: function(arg0, arg1, arg2) {
3276
+ const ret = arg0.fetch(getStringFromWasm0(arg1, arg2));
3277
+ return ret;
3278
+ },
3279
+ __wbg_finish_7370ad1c0e62b448: function(arg0) {
3280
+ const ret = arg0.finish();
3281
+ return ret;
3282
+ },
3283
+ __wbg_finish_797b32d15bab2338: function(arg0, arg1) {
3284
+ const ret = arg0.finish(arg1);
3285
+ return ret;
3286
+ },
3287
+ __wbg_getCurrentTexture_628ddb7c08d25190: function() { return handleError(function (arg0) {
3288
+ const ret = arg0.getCurrentTexture();
3289
+ return ret;
3290
+ }, arguments); },
3291
+ __wbg_getDate_a1a40c1c5f40fe3b: function(arg0) {
3292
+ const ret = arg0.getDate();
3293
+ return ret;
3294
+ },
3295
+ __wbg_getDay_aa318cce5da74c49: function(arg0) {
3296
+ const ret = arg0.getDay();
3297
+ return ret;
3298
+ },
3299
+ __wbg_getFullYear_6af8b229792ae254: function(arg0) {
3300
+ const ret = arg0.getFullYear();
3301
+ return ret;
3302
+ },
3303
+ __wbg_getHours_9f6561095682ce51: function(arg0) {
3304
+ const ret = arg0.getHours();
3305
+ return ret;
3306
+ },
3307
+ __wbg_getMappedRange_9f13d158ba3946fd: function() { return handleError(function (arg0, arg1, arg2) {
3308
+ const ret = arg0.getMappedRange(arg1, arg2);
3309
+ return ret;
3310
+ }, arguments); },
3311
+ __wbg_getMinutes_b0d5cd90bf9b8f22: function(arg0) {
3312
+ const ret = arg0.getMinutes();
3313
+ return ret;
3314
+ },
3315
+ __wbg_getMonth_fffe29d654d5eb69: function(arg0) {
3316
+ const ret = arg0.getMonth();
3317
+ return ret;
3318
+ },
3319
+ __wbg_getPreferredCanvasFormat_a2b6306e828c2f60: function(arg0) {
3320
+ const ret = arg0.getPreferredCanvasFormat();
3321
+ return (__wbindgen_enum_GpuTextureFormat.indexOf(ret) + 1 || 96) - 1;
3322
+ },
3323
+ __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
3324
+ arg0.getRandomValues(arg1);
3325
+ }, arguments); },
3326
+ __wbg_get_18e0163e38e5048d: function() { return handleError(function (arg0, arg1, arg2, arg3) {
3327
+ const ret = arg1.get(getStringFromWasm0(arg2, arg3));
3328
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3329
+ var len1 = WASM_VECTOR_LEN;
3330
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3331
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3332
+ }, arguments); },
3333
+ __wbg_gpu_ac6dc8fb638a26c3: function(arg0) {
3334
+ const ret = arg0.gpu;
3335
+ return ret;
3336
+ },
3337
+ __wbg_headers_cf9c80f30e2a4eff: function(arg0) {
3338
+ const ret = arg0.headers;
3339
+ return ret;
3340
+ },
3341
+ __wbg_instanceof_GpuAdapter_fb230cdccb184887: function(arg0) {
3342
+ let result;
3343
+ try {
3344
+ result = arg0 instanceof GPUAdapter;
3345
+ } catch (_) {
3346
+ result = false;
3347
+ }
3348
+ const ret = result;
3349
+ return ret;
3350
+ },
3351
+ __wbg_instanceof_Response_c8b64b2256f01bec: function(arg0) {
3352
+ let result;
3353
+ try {
3354
+ result = arg0 instanceof Response;
3355
+ } catch (_) {
3356
+ result = false;
3357
+ }
3358
+ const ret = result;
3359
+ return ret;
3360
+ },
3361
+ __wbg_instanceof_Window_05ba1ee4f6781663: function(arg0) {
3362
+ let result;
3363
+ try {
3364
+ result = arg0 instanceof Window;
3365
+ } catch (_) {
3366
+ result = false;
3367
+ }
3368
+ const ret = result;
3369
+ return ret;
3370
+ },
3371
+ __wbg_label_84abde6506fa15b7: function(arg0, arg1) {
3372
+ const ret = arg1.label;
3373
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3374
+ const len1 = WASM_VECTOR_LEN;
3375
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3376
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3377
+ },
3378
+ __wbg_length_1f0964f4a5e2c6d8: function(arg0) {
3379
+ const ret = arg0.length;
3380
+ return ret;
3381
+ },
3382
+ __wbg_limits_a80585efb442d985: function(arg0) {
3383
+ const ret = arg0.limits;
3384
+ return ret;
3385
+ },
3386
+ __wbg_limits_d4ef440224084d65: function(arg0) {
3387
+ const ret = arg0.limits;
3388
+ return ret;
3389
+ },
3390
+ __wbg_mapAsync_3546b4b874e14738: function(arg0, arg1, arg2, arg3) {
3391
+ const ret = arg0.mapAsync(arg1 >>> 0, arg2, arg3);
3392
+ return ret;
3393
+ },
3394
+ __wbg_maxBindGroups_2fac2855adae76bb: function(arg0) {
3395
+ const ret = arg0.maxBindGroups;
3396
+ return ret;
3397
+ },
3398
+ __wbg_maxBindingsPerBindGroup_7b8b526a1900701d: function(arg0) {
3399
+ const ret = arg0.maxBindingsPerBindGroup;
3400
+ return ret;
3401
+ },
3402
+ __wbg_maxBufferSize_475dcdac4810587e: function(arg0) {
3403
+ const ret = arg0.maxBufferSize;
3404
+ return ret;
3405
+ },
3406
+ __wbg_maxColorAttachmentBytesPerSample_5a04a2d5a9e122bb: function(arg0) {
3407
+ const ret = arg0.maxColorAttachmentBytesPerSample;
3408
+ return ret;
3409
+ },
3410
+ __wbg_maxColorAttachments_2a487bb283cf8f08: function(arg0) {
3411
+ const ret = arg0.maxColorAttachments;
3412
+ return ret;
3413
+ },
3414
+ __wbg_maxComputeInvocationsPerWorkgroup_72908780df74614a: function(arg0) {
3415
+ const ret = arg0.maxComputeInvocationsPerWorkgroup;
3416
+ return ret;
3417
+ },
3418
+ __wbg_maxComputeWorkgroupSizeX_92eeefd082aefd07: function(arg0) {
3419
+ const ret = arg0.maxComputeWorkgroupSizeX;
3420
+ return ret;
3421
+ },
3422
+ __wbg_maxComputeWorkgroupSizeY_54fecee60bfa33ae: function(arg0) {
3423
+ const ret = arg0.maxComputeWorkgroupSizeY;
3424
+ return ret;
3425
+ },
3426
+ __wbg_maxComputeWorkgroupSizeZ_868f559f4eebf95f: function(arg0) {
3427
+ const ret = arg0.maxComputeWorkgroupSizeZ;
3428
+ return ret;
3429
+ },
3430
+ __wbg_maxComputeWorkgroupStorageSize_b4fd07bd827bde34: function(arg0) {
3431
+ const ret = arg0.maxComputeWorkgroupStorageSize;
3432
+ return ret;
3433
+ },
3434
+ __wbg_maxComputeWorkgroupsPerDimension_2d88e3f8e1f984fc: function(arg0) {
3435
+ const ret = arg0.maxComputeWorkgroupsPerDimension;
3436
+ return ret;
3437
+ },
3438
+ __wbg_maxDynamicStorageBuffersPerPipelineLayout_d6f0075161a2ec8e: function(arg0) {
3439
+ const ret = arg0.maxDynamicStorageBuffersPerPipelineLayout;
3440
+ return ret;
3441
+ },
3442
+ __wbg_maxDynamicUniformBuffersPerPipelineLayout_4fc01fff17019d2b: function(arg0) {
3443
+ const ret = arg0.maxDynamicUniformBuffersPerPipelineLayout;
3444
+ return ret;
3445
+ },
3446
+ __wbg_maxSampledTexturesPerShaderStage_224452301226d09a: function(arg0) {
3447
+ const ret = arg0.maxSampledTexturesPerShaderStage;
3448
+ return ret;
3449
+ },
3450
+ __wbg_maxSamplersPerShaderStage_34936f99dde7ae66: function(arg0) {
3451
+ const ret = arg0.maxSamplersPerShaderStage;
3452
+ return ret;
3453
+ },
3454
+ __wbg_maxStorageBufferBindingSize_9582c7cfe68faac0: function(arg0) {
3455
+ const ret = arg0.maxStorageBufferBindingSize;
3456
+ return ret;
3457
+ },
3458
+ __wbg_maxStorageBuffersPerShaderStage_6403069e851040db: function(arg0) {
3459
+ const ret = arg0.maxStorageBuffersPerShaderStage;
3460
+ return ret;
3461
+ },
3462
+ __wbg_maxStorageTexturesPerShaderStage_e44d7d6ed85de663: function(arg0) {
3463
+ const ret = arg0.maxStorageTexturesPerShaderStage;
3464
+ return ret;
3465
+ },
3466
+ __wbg_maxTextureArrayLayers_0f2fe636cc0fa44f: function(arg0) {
3467
+ const ret = arg0.maxTextureArrayLayers;
3468
+ return ret;
3469
+ },
3470
+ __wbg_maxTextureDimension1D_501e1e21119c564f: function(arg0) {
3471
+ const ret = arg0.maxTextureDimension1D;
3472
+ return ret;
3473
+ },
3474
+ __wbg_maxTextureDimension2D_ac594a0008180ab6: function(arg0) {
3475
+ const ret = arg0.maxTextureDimension2D;
3476
+ return ret;
3477
+ },
3478
+ __wbg_maxTextureDimension3D_8e5638a46d5786b0: function(arg0) {
3479
+ const ret = arg0.maxTextureDimension3D;
3480
+ return ret;
3481
+ },
3482
+ __wbg_maxUniformBufferBindingSize_a4c4feca62b81571: function(arg0) {
3483
+ const ret = arg0.maxUniformBufferBindingSize;
3484
+ return ret;
3485
+ },
3486
+ __wbg_maxUniformBuffersPerShaderStage_505f14dd3f814492: function(arg0) {
3487
+ const ret = arg0.maxUniformBuffersPerShaderStage;
3488
+ return ret;
3489
+ },
3490
+ __wbg_maxVertexAttributes_c4f4881b2d20616b: function(arg0) {
3491
+ const ret = arg0.maxVertexAttributes;
3492
+ return ret;
3493
+ },
3494
+ __wbg_maxVertexBufferArrayStride_da0782b779fc1a38: function(arg0) {
3495
+ const ret = arg0.maxVertexBufferArrayStride;
3496
+ return ret;
3497
+ },
3498
+ __wbg_maxVertexBuffers_90e848bae7f01af3: function(arg0) {
3499
+ const ret = arg0.maxVertexBuffers;
3500
+ return ret;
3501
+ },
3502
+ __wbg_minStorageBufferOffsetAlignment_58fcc139ce14bbb9: function(arg0) {
3503
+ const ret = arg0.minStorageBufferOffsetAlignment;
3504
+ return ret;
3505
+ },
3506
+ __wbg_minUniformBufferOffsetAlignment_33ca7570ff80f825: function(arg0) {
3507
+ const ret = arg0.minUniformBufferOffsetAlignment;
3508
+ return ret;
3509
+ },
3510
+ __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
3511
+ const ret = arg0.msCrypto;
3512
+ return ret;
3513
+ },
3514
+ __wbg_navigator_51379c10a84aeec9: function(arg0) {
3515
+ const ret = arg0.navigator;
3516
+ return ret;
3517
+ },
3518
+ __wbg_navigator_99621db14b3f1099: function(arg0) {
3519
+ const ret = arg0.navigator;
3520
+ return ret;
3521
+ },
3522
+ __wbg_new_0_3da9e97f24fc69be: function() {
3523
+ const ret = new Date();
3524
+ return ret;
3525
+ },
3526
+ __wbg_new_32b398fb48b6d94a: function() {
3527
+ const ret = new Array();
3528
+ return ret;
3529
+ },
3530
+ __wbg_new_cd45aabdf6073e84: function(arg0) {
3531
+ const ret = new Uint8Array(arg0);
3532
+ return ret;
3533
+ },
3534
+ __wbg_new_da52cf8fe3429cb2: function() {
3535
+ const ret = new Object();
3536
+ return ret;
3537
+ },
3538
+ __wbg_new_from_slice_77cdfb7977362f3c: function(arg0, arg1) {
3539
+ const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
3540
+ return ret;
3541
+ },
3542
+ __wbg_new_with_byte_offset_and_length_54c7724ee3ec7d82: function(arg0, arg1, arg2) {
3543
+ const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
3544
+ return ret;
3545
+ },
3546
+ __wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
3547
+ const ret = new Uint8Array(arg0 >>> 0);
3548
+ return ret;
3549
+ },
3550
+ __wbg_node_84ea875411254db1: function(arg0) {
3551
+ const ret = arg0.node;
3552
+ return ret;
3553
+ },
3554
+ __wbg_now_86c0d4ba3fa605b8: function() {
3555
+ const ret = Date.now();
3556
+ return ret;
3557
+ },
3558
+ __wbg_ok_acc5e3fb89668864: function(arg0) {
3559
+ const ret = arg0.ok;
3560
+ return ret;
3561
+ },
3562
+ __wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
3563
+ const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
3564
+ return ret;
3565
+ }, arguments); },
3566
+ __wbg_process_44c7a14e11e9f69e: function(arg0) {
3567
+ const ret = arg0.process;
3568
+ return ret;
3569
+ },
3570
+ __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
3571
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
3572
+ },
3573
+ __wbg_push_d2ae3af0c1217ae6: function(arg0, arg1) {
3574
+ const ret = arg0.push(arg1);
3575
+ return ret;
3576
+ },
3577
+ __wbg_queueMicrotask_0ab5b2d2393e99b9: function(arg0) {
3578
+ const ret = arg0.queueMicrotask;
3579
+ return ret;
3580
+ },
3581
+ __wbg_queueMicrotask_6a09b7bc46549209: function(arg0) {
3582
+ queueMicrotask(arg0);
3583
+ },
3584
+ __wbg_queue_8cb065d04b06cb13: function(arg0) {
3585
+ const ret = arg0.queue;
3586
+ return ret;
3587
+ },
3588
+ __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
3589
+ arg0.randomFillSync(arg1);
3590
+ }, arguments); },
3591
+ __wbg_requestAdapter_4814cb479d2dcf15: function(arg0, arg1) {
3592
+ const ret = arg0.requestAdapter(arg1);
3593
+ return ret;
3594
+ },
3595
+ __wbg_requestDevice_1b8f321791aa8b00: function(arg0, arg1) {
3596
+ const ret = arg0.requestDevice(arg1);
3597
+ return ret;
3598
+ },
3599
+ __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
3600
+ const ret = module.require;
3601
+ return ret;
3602
+ }, arguments); },
3603
+ __wbg_resolve_2191a4dfe481c25b: function(arg0) {
3604
+ const ret = Promise.resolve(arg0);
3605
+ return ret;
3606
+ },
3607
+ __wbg_setBindGroup_9fdf11fd244aa68a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
3608
+ arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
3609
+ }, arguments); },
3610
+ __wbg_setBindGroup_a7e88440d0ecac88: function(arg0, arg1, arg2) {
3611
+ arg0.setBindGroup(arg1 >>> 0, arg2);
3612
+ },
3613
+ __wbg_setPipeline_092493bfd77760ee: function(arg0, arg1) {
3614
+ arg0.setPipeline(arg1);
3615
+ },
3616
+ __wbg_setVertexBuffer_1ed692dc2726f6c3: function(arg0, arg1, arg2, arg3, arg4) {
3617
+ arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
3618
+ },
3619
+ __wbg_set_61e45ae8061eca11: function(arg0, arg1, arg2) {
3620
+ arg0.set(arg1, arg2 >>> 0);
3621
+ },
3622
+ __wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
3623
+ const ret = Reflect.set(arg0, arg1, arg2);
3624
+ return ret;
3625
+ }, arguments); },
3626
+ __wbg_set_a_9b35e9a1b60244b3: function(arg0, arg1) {
3627
+ arg0.a = arg1;
3628
+ },
3629
+ __wbg_set_access_67a4b0ae1c0f32f5: function(arg0, arg1) {
3630
+ arg0.access = __wbindgen_enum_GpuStorageTextureAccess[arg1];
3631
+ },
3632
+ __wbg_set_address_mode_u_1a44abe112b27750: function(arg0, arg1) {
3633
+ arg0.addressModeU = __wbindgen_enum_GpuAddressMode[arg1];
3634
+ },
3635
+ __wbg_set_address_mode_v_764da2dbc77dbf3e: function(arg0, arg1) {
3636
+ arg0.addressModeV = __wbindgen_enum_GpuAddressMode[arg1];
3637
+ },
3638
+ __wbg_set_address_mode_w_7c5135c7d56f9b4c: function(arg0, arg1) {
3639
+ arg0.addressModeW = __wbindgen_enum_GpuAddressMode[arg1];
3640
+ },
3641
+ __wbg_set_alpha_52d96a0bda4f4afe: function(arg0, arg1) {
3642
+ arg0.alpha = arg1;
3643
+ },
3644
+ __wbg_set_alpha_mode_5c1f4c4115bbe318: function(arg0, arg1) {
3645
+ arg0.alphaMode = __wbindgen_enum_GpuCanvasAlphaMode[arg1];
3646
+ },
3647
+ __wbg_set_alpha_to_coverage_enabled_36cef063cffb5d84: function(arg0, arg1) {
3648
+ arg0.alphaToCoverageEnabled = arg1 !== 0;
3649
+ },
3650
+ __wbg_set_array_layer_count_c2e975f5b62596bb: function(arg0, arg1) {
3651
+ arg0.arrayLayerCount = arg1 >>> 0;
3652
+ },
3653
+ __wbg_set_array_stride_eb9d409a95d2c1b3: function(arg0, arg1) {
3654
+ arg0.arrayStride = arg1;
3655
+ },
3656
+ __wbg_set_aspect_a453970e75d8e849: function(arg0, arg1) {
3657
+ arg0.aspect = __wbindgen_enum_GpuTextureAspect[arg1];
3658
+ },
3659
+ __wbg_set_attributes_edcbef656678a257: function(arg0, arg1) {
3660
+ arg0.attributes = arg1;
3661
+ },
3662
+ __wbg_set_b_5708a52cef50b19f: function(arg0, arg1) {
3663
+ arg0.b = arg1;
3664
+ },
3665
+ __wbg_set_base_array_layer_b67db9750fbc7053: function(arg0, arg1) {
3666
+ arg0.baseArrayLayer = arg1 >>> 0;
3667
+ },
3668
+ __wbg_set_base_mip_level_35f2fc3293e96083: function(arg0, arg1) {
3669
+ arg0.baseMipLevel = arg1 >>> 0;
3670
+ },
3671
+ __wbg_set_beginning_of_pass_write_index_8e570668cd8cad5e: function(arg0, arg1) {
3672
+ arg0.beginningOfPassWriteIndex = arg1 >>> 0;
3673
+ },
3674
+ __wbg_set_bind_group_layouts_436bd62a9b35e1ab: function(arg0, arg1) {
3675
+ arg0.bindGroupLayouts = arg1;
3676
+ },
3677
+ __wbg_set_binding_b575483e08d5ba4a: function(arg0, arg1) {
3678
+ arg0.binding = arg1 >>> 0;
3679
+ },
3680
+ __wbg_set_binding_c9feebb53a130ebe: function(arg0, arg1) {
3681
+ arg0.binding = arg1 >>> 0;
3682
+ },
3683
+ __wbg_set_blend_765238525504b1db: function(arg0, arg1) {
3684
+ arg0.blend = arg1;
3685
+ },
3686
+ __wbg_set_buffer_468874ee2bc9df02: function(arg0, arg1) {
3687
+ arg0.buffer = arg1;
3688
+ },
3689
+ __wbg_set_buffer_6c45652fb024e808: function(arg0, arg1) {
3690
+ arg0.buffer = arg1;
3691
+ },
3692
+ __wbg_set_buffer_83041e80a2b2c1b9: function(arg0, arg1) {
3693
+ arg0.buffer = arg1;
3694
+ },
3695
+ __wbg_set_buffers_986b265eda61fae6: function(arg0, arg1) {
3696
+ arg0.buffers = arg1;
3697
+ },
3698
+ __wbg_set_bytes_per_row_c127092e4fe9be22: function(arg0, arg1) {
3699
+ arg0.bytesPerRow = arg1 >>> 0;
3700
+ },
3701
+ __wbg_set_bytes_per_row_fecf7d0d8d5038d0: function(arg0, arg1) {
3702
+ arg0.bytesPerRow = arg1 >>> 0;
3703
+ },
3704
+ __wbg_set_clear_value_764be6f32f502d0a: function(arg0, arg1) {
3705
+ arg0.clearValue = arg1;
3706
+ },
3707
+ __wbg_set_code_0a82fa86cf58ca3b: function(arg0, arg1, arg2) {
3708
+ arg0.code = getStringFromWasm0(arg1, arg2);
3709
+ },
3710
+ __wbg_set_color_attachments_fad73def169d9610: function(arg0, arg1) {
3711
+ arg0.colorAttachments = arg1;
3712
+ },
3713
+ __wbg_set_color_c25fb8769b4f010f: function(arg0, arg1) {
3714
+ arg0.color = arg1;
3715
+ },
3716
+ __wbg_set_compare_1e2214a402af6db3: function(arg0, arg1) {
3717
+ arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
3718
+ },
3719
+ __wbg_set_compare_e61cc62d8f7e2191: function(arg0, arg1) {
3720
+ arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
3721
+ },
3722
+ __wbg_set_count_f285d8c62f4de679: function(arg0, arg1) {
3723
+ arg0.count = arg1 >>> 0;
3724
+ },
3725
+ __wbg_set_cull_mode_e6ca97d167dede04: function(arg0, arg1) {
3726
+ arg0.cullMode = __wbindgen_enum_GpuCullMode[arg1];
3727
+ },
3728
+ __wbg_set_depth_bias_clamp_e8da3e9edc037b18: function(arg0, arg1) {
3729
+ arg0.depthBiasClamp = arg1;
3730
+ },
3731
+ __wbg_set_depth_bias_edf83e7d032bdd2a: function(arg0, arg1) {
3732
+ arg0.depthBias = arg1;
3733
+ },
3734
+ __wbg_set_depth_bias_slope_scale_1746553a2d960310: function(arg0, arg1) {
3735
+ arg0.depthBiasSlopeScale = arg1;
3736
+ },
3737
+ __wbg_set_depth_clear_value_f6f20e460b0c4012: function(arg0, arg1) {
3738
+ arg0.depthClearValue = arg1;
3739
+ },
3740
+ __wbg_set_depth_compare_f18e709a5dc4a0b0: function(arg0, arg1) {
3741
+ arg0.depthCompare = __wbindgen_enum_GpuCompareFunction[arg1];
3742
+ },
3743
+ __wbg_set_depth_fail_op_45f4179ddfc376cd: function(arg0, arg1) {
3744
+ arg0.depthFailOp = __wbindgen_enum_GpuStencilOperation[arg1];
3745
+ },
3746
+ __wbg_set_depth_load_op_c3d15137e916dd5a: function(arg0, arg1) {
3747
+ arg0.depthLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
3748
+ },
3749
+ __wbg_set_depth_or_array_layers_17284e1eac0007a1: function(arg0, arg1) {
3750
+ arg0.depthOrArrayLayers = arg1 >>> 0;
3751
+ },
3752
+ __wbg_set_depth_read_only_9a8994459a0acf9e: function(arg0, arg1) {
3753
+ arg0.depthReadOnly = arg1 !== 0;
3754
+ },
3755
+ __wbg_set_depth_stencil_8716a627d44d796e: function(arg0, arg1) {
3756
+ arg0.depthStencil = arg1;
3757
+ },
3758
+ __wbg_set_depth_stencil_attachment_08fe1db9243adb49: function(arg0, arg1) {
3759
+ arg0.depthStencilAttachment = arg1;
3760
+ },
3761
+ __wbg_set_depth_store_op_881c8dbe0d67045d: function(arg0, arg1) {
3762
+ arg0.depthStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
3763
+ },
3764
+ __wbg_set_depth_write_enabled_9b608c3bf190f04a: function(arg0, arg1) {
3765
+ arg0.depthWriteEnabled = arg1 !== 0;
3766
+ },
3767
+ __wbg_set_device_bf67f52a587f9aab: function(arg0, arg1) {
3768
+ arg0.device = arg1;
3769
+ },
3770
+ __wbg_set_dimension_3144c827eb67b110: function(arg0, arg1) {
3771
+ arg0.dimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
3772
+ },
3773
+ __wbg_set_dimension_9054f7ab0acbfd31: function(arg0, arg1) {
3774
+ arg0.dimension = __wbindgen_enum_GpuTextureDimension[arg1];
3775
+ },
3776
+ __wbg_set_dst_factor_77c088c0ad43b684: function(arg0, arg1) {
3777
+ arg0.dstFactor = __wbindgen_enum_GpuBlendFactor[arg1];
3778
+ },
3779
+ __wbg_set_end_of_pass_write_index_568e7295b1b273a3: function(arg0, arg1) {
3780
+ arg0.endOfPassWriteIndex = arg1 >>> 0;
3781
+ },
3782
+ __wbg_set_entries_247b5e665db79583: function(arg0, arg1) {
3783
+ arg0.entries = arg1;
3784
+ },
3785
+ __wbg_set_entries_bfbb6a7f04b96709: function(arg0, arg1) {
3786
+ arg0.entries = arg1;
3787
+ },
3788
+ __wbg_set_entry_point_1d7ecf099e15fa2b: function(arg0, arg1, arg2) {
3789
+ arg0.entryPoint = getStringFromWasm0(arg1, arg2);
3790
+ },
3791
+ __wbg_set_entry_point_a698bc91b472d5a9: function(arg0, arg1, arg2) {
3792
+ arg0.entryPoint = getStringFromWasm0(arg1, arg2);
3793
+ },
3794
+ __wbg_set_external_texture_a0db2eb13c76e01c: function(arg0, arg1) {
3795
+ arg0.externalTexture = arg1;
3796
+ },
3797
+ __wbg_set_fail_op_a6890cff6b560a14: function(arg0, arg1) {
3798
+ arg0.failOp = __wbindgen_enum_GpuStencilOperation[arg1];
3799
+ },
3800
+ __wbg_set_format_237b3e4047d1be9a: function(arg0, arg1) {
3801
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
3802
+ },
3803
+ __wbg_set_format_53479155b45c92ea: function(arg0, arg1) {
3804
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
3805
+ },
3806
+ __wbg_set_format_7c20bfc7e4802e1e: function(arg0, arg1) {
3807
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
3808
+ },
3809
+ __wbg_set_format_84af8ed546a319fa: function(arg0, arg1) {
3810
+ arg0.format = __wbindgen_enum_GpuVertexFormat[arg1];
3811
+ },
3812
+ __wbg_set_format_9f32450123336995: function(arg0, arg1) {
3813
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
3814
+ },
3815
+ __wbg_set_format_c9dcecebf9c1e619: function(arg0, arg1) {
3816
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
3817
+ },
3818
+ __wbg_set_format_d9d3420c1a9d1c59: function(arg0, arg1) {
3819
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
3820
+ },
3821
+ __wbg_set_fragment_2c6f6192456fed1c: function(arg0, arg1) {
3822
+ arg0.fragment = arg1;
3823
+ },
3824
+ __wbg_set_front_face_fd34f06ac9239d11: function(arg0, arg1) {
3825
+ arg0.frontFace = __wbindgen_enum_GpuFrontFace[arg1];
3826
+ },
3827
+ __wbg_set_g_7bb456722103c5e6: function(arg0, arg1) {
3828
+ arg0.g = arg1;
3829
+ },
3830
+ __wbg_set_has_dynamic_offset_0c8a607543be8069: function(arg0, arg1) {
3831
+ arg0.hasDynamicOffset = arg1 !== 0;
3832
+ },
3833
+ __wbg_set_height_7d9d8f892e6964c6: function(arg0, arg1) {
3834
+ arg0.height = arg1 >>> 0;
3835
+ },
3836
+ __wbg_set_height_96611e96eee67c44: function(arg0, arg1) {
3837
+ arg0.height = arg1 >>> 0;
3838
+ },
3839
+ __wbg_set_height_bbeef8f354041577: function(arg0, arg1) {
3840
+ arg0.height = arg1 >>> 0;
3841
+ },
3842
+ __wbg_set_label_01228663ea03b92f: function(arg0, arg1, arg2) {
3843
+ arg0.label = getStringFromWasm0(arg1, arg2);
3844
+ },
3845
+ __wbg_set_label_13a2dd9810399e8b: function(arg0, arg1, arg2) {
3846
+ arg0.label = getStringFromWasm0(arg1, arg2);
3847
+ },
3848
+ __wbg_set_label_22e57f4c5b38215f: function(arg0, arg1, arg2) {
3849
+ arg0.label = getStringFromWasm0(arg1, arg2);
3850
+ },
3851
+ __wbg_set_label_382417d222111912: function(arg0, arg1, arg2) {
3852
+ arg0.label = getStringFromWasm0(arg1, arg2);
3853
+ },
3854
+ __wbg_set_label_4d049edb707ba31c: function(arg0, arg1, arg2) {
3855
+ arg0.label = getStringFromWasm0(arg1, arg2);
3856
+ },
3857
+ __wbg_set_label_5724e5c6286e8a4e: function(arg0, arg1, arg2) {
3858
+ arg0.label = getStringFromWasm0(arg1, arg2);
3859
+ },
3860
+ __wbg_set_label_8354c6463558484f: function(arg0, arg1, arg2) {
3861
+ arg0.label = getStringFromWasm0(arg1, arg2);
3862
+ },
3863
+ __wbg_set_label_acd66edf00f8e40f: function(arg0, arg1, arg2) {
3864
+ arg0.label = getStringFromWasm0(arg1, arg2);
3865
+ },
3866
+ __wbg_set_label_b3da7636c69f1a4c: function(arg0, arg1, arg2) {
3867
+ arg0.label = getStringFromWasm0(arg1, arg2);
3868
+ },
3869
+ __wbg_set_label_b7f797c13bc822c4: function(arg0, arg1, arg2) {
3870
+ arg0.label = getStringFromWasm0(arg1, arg2);
3871
+ },
3872
+ __wbg_set_label_e026aa2aea731594: function(arg0, arg1, arg2) {
3873
+ arg0.label = getStringFromWasm0(arg1, arg2);
3874
+ },
3875
+ __wbg_set_label_e6bc3b86ef6deeb8: function(arg0, arg1, arg2) {
3876
+ arg0.label = getStringFromWasm0(arg1, arg2);
3877
+ },
3878
+ __wbg_set_label_e7f76bba99d72971: function(arg0, arg1, arg2) {
3879
+ arg0.label = getStringFromWasm0(arg1, arg2);
3880
+ },
3881
+ __wbg_set_layout_210c56f1b01e883b: function(arg0, arg1) {
3882
+ arg0.layout = arg1;
3883
+ },
3884
+ __wbg_set_layout_44943c4c7d78f826: function(arg0, arg1) {
3885
+ arg0.layout = arg1;
3886
+ },
3887
+ __wbg_set_load_op_103e6ce0a06327b3: function(arg0, arg1) {
3888
+ arg0.loadOp = __wbindgen_enum_GpuLoadOp[arg1];
3889
+ },
3890
+ __wbg_set_lod_max_clamp_3706b17de6a5a11a: function(arg0, arg1) {
3891
+ arg0.lodMaxClamp = arg1;
3892
+ },
3893
+ __wbg_set_lod_min_clamp_1f4b28d77d0c87c4: function(arg0, arg1) {
3894
+ arg0.lodMinClamp = arg1;
3895
+ },
3896
+ __wbg_set_mag_filter_2c8c212ff297b151: function(arg0, arg1) {
3897
+ arg0.magFilter = __wbindgen_enum_GpuFilterMode[arg1];
3898
+ },
3899
+ __wbg_set_mapped_at_creation_12773dff1bb6ea0f: function(arg0, arg1) {
3900
+ arg0.mappedAtCreation = arg1 !== 0;
3901
+ },
3902
+ __wbg_set_mask_94311bacf22c96b1: function(arg0, arg1) {
3903
+ arg0.mask = arg1 >>> 0;
3904
+ },
3905
+ __wbg_set_max_anisotropy_56bff110d0b4830f: function(arg0, arg1) {
3906
+ arg0.maxAnisotropy = arg1;
3907
+ },
3908
+ __wbg_set_min_binding_size_164df827e02821e1: function(arg0, arg1) {
3909
+ arg0.minBindingSize = arg1;
3910
+ },
3911
+ __wbg_set_min_filter_66d70efb70601bf9: function(arg0, arg1) {
3912
+ arg0.minFilter = __wbindgen_enum_GpuFilterMode[arg1];
3913
+ },
3914
+ __wbg_set_mip_level_7f56c1c607dda5cf: function(arg0, arg1) {
3915
+ arg0.mipLevel = arg1 >>> 0;
3916
+ },
3917
+ __wbg_set_mip_level_count_3402f5315a423b69: function(arg0, arg1) {
3918
+ arg0.mipLevelCount = arg1 >>> 0;
3919
+ },
3920
+ __wbg_set_mip_level_count_ed029120a0ee12b8: function(arg0, arg1) {
3921
+ arg0.mipLevelCount = arg1 >>> 0;
3922
+ },
3923
+ __wbg_set_mipmap_filter_1b3d153bd834ec26: function(arg0, arg1) {
3924
+ arg0.mipmapFilter = __wbindgen_enum_GpuMipmapFilterMode[arg1];
3925
+ },
3926
+ __wbg_set_module_119c125107e59165: function(arg0, arg1) {
3927
+ arg0.module = arg1;
3928
+ },
3929
+ __wbg_set_module_3336e0ce2672c07c: function(arg0, arg1) {
3930
+ arg0.module = arg1;
3931
+ },
3932
+ __wbg_set_multisample_1cdb4998c4f73341: function(arg0, arg1) {
3933
+ arg0.multisample = arg1;
3934
+ },
3935
+ __wbg_set_multisampled_e9d7bed0e68d1d6f: function(arg0, arg1) {
3936
+ arg0.multisampled = arg1 !== 0;
3937
+ },
3938
+ __wbg_set_offset_01c04218a4ccfa08: function(arg0, arg1) {
3939
+ arg0.offset = arg1;
3940
+ },
3941
+ __wbg_set_offset_5ea55c758ce6f103: function(arg0, arg1) {
3942
+ arg0.offset = arg1;
3943
+ },
3944
+ __wbg_set_offset_bd11f79890456c6f: function(arg0, arg1) {
3945
+ arg0.offset = arg1;
3946
+ },
3947
+ __wbg_set_offset_f07a73165707eb4c: function(arg0, arg1) {
3948
+ arg0.offset = arg1;
3949
+ },
3950
+ __wbg_set_operation_845ee9de4c1808be: function(arg0, arg1) {
3951
+ arg0.operation = __wbindgen_enum_GpuBlendOperation[arg1];
3952
+ },
3953
+ __wbg_set_origin_6be40076fb0623f4: function(arg0, arg1) {
3954
+ arg0.origin = arg1;
3955
+ },
3956
+ __wbg_set_pass_op_f4a566b4a6b819e0: function(arg0, arg1) {
3957
+ arg0.passOp = __wbindgen_enum_GpuStencilOperation[arg1];
3958
+ },
3959
+ __wbg_set_power_preference_0721cf46746c0c7d: function(arg0, arg1) {
3960
+ arg0.powerPreference = __wbindgen_enum_GpuPowerPreference[arg1];
3961
+ },
3962
+ __wbg_set_primitive_94234ea756a4c469: function(arg0, arg1) {
3963
+ arg0.primitive = arg1;
3964
+ },
3965
+ __wbg_set_query_set_667d2dcfcedd1ec2: function(arg0, arg1) {
3966
+ arg0.querySet = arg1;
3967
+ },
3968
+ __wbg_set_r_13b3eba61d4ba4d9: function(arg0, arg1) {
3969
+ arg0.r = arg1;
3970
+ },
3971
+ __wbg_set_required_features_5202fa8cd082e531: function(arg0, arg1) {
3972
+ arg0.requiredFeatures = arg1;
3973
+ },
3974
+ __wbg_set_resolve_target_8251ec563ce24501: function(arg0, arg1) {
3975
+ arg0.resolveTarget = arg1;
3976
+ },
3977
+ __wbg_set_resource_c73d0c2d815f7211: function(arg0, arg1) {
3978
+ arg0.resource = arg1;
3979
+ },
3980
+ __wbg_set_rows_per_image_00c8e938dae40dae: function(arg0, arg1) {
3981
+ arg0.rowsPerImage = arg1 >>> 0;
3982
+ },
3983
+ __wbg_set_rows_per_image_e6e2c0c4a7e4fa8d: function(arg0, arg1) {
3984
+ arg0.rowsPerImage = arg1 >>> 0;
3985
+ },
3986
+ __wbg_set_sample_count_05dcc9952f4fa7ac: function(arg0, arg1) {
3987
+ arg0.sampleCount = arg1 >>> 0;
3988
+ },
3989
+ __wbg_set_sample_type_93886b8f9794f85c: function(arg0, arg1) {
3990
+ arg0.sampleType = __wbindgen_enum_GpuTextureSampleType[arg1];
3991
+ },
3992
+ __wbg_set_sampler_02989e99b27a50db: function(arg0, arg1) {
3993
+ arg0.sampler = arg1;
3994
+ },
3995
+ __wbg_set_shader_location_33bfc2cc417fdde2: function(arg0, arg1) {
3996
+ arg0.shaderLocation = arg1 >>> 0;
3997
+ },
3998
+ __wbg_set_size_b3e6b2bf58d62082: function(arg0, arg1) {
3999
+ arg0.size = arg1;
4000
+ },
4001
+ __wbg_set_size_c2a556d5571231f5: function(arg0, arg1) {
4002
+ arg0.size = arg1;
4003
+ },
4004
+ __wbg_set_size_f7b29f6cb1669c4d: function(arg0, arg1) {
4005
+ arg0.size = arg1;
4006
+ },
4007
+ __wbg_set_src_factor_deefdfd4b6427b5e: function(arg0, arg1) {
4008
+ arg0.srcFactor = __wbindgen_enum_GpuBlendFactor[arg1];
4009
+ },
4010
+ __wbg_set_stencil_back_9971eece60c613eb: function(arg0, arg1) {
4011
+ arg0.stencilBack = arg1;
4012
+ },
4013
+ __wbg_set_stencil_clear_value_4b82f2d7e6d9f496: function(arg0, arg1) {
4014
+ arg0.stencilClearValue = arg1 >>> 0;
4015
+ },
4016
+ __wbg_set_stencil_front_c82ccf19db426a5b: function(arg0, arg1) {
4017
+ arg0.stencilFront = arg1;
4018
+ },
4019
+ __wbg_set_stencil_load_op_dbc3af9713146f24: function(arg0, arg1) {
4020
+ arg0.stencilLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
4021
+ },
4022
+ __wbg_set_stencil_read_mask_926bce469fa8eaf3: function(arg0, arg1) {
4023
+ arg0.stencilReadMask = arg1 >>> 0;
4024
+ },
4025
+ __wbg_set_stencil_read_only_88136eaf94225fec: function(arg0, arg1) {
4026
+ arg0.stencilReadOnly = arg1 !== 0;
4027
+ },
4028
+ __wbg_set_stencil_store_op_e10e50255bf42e8b: function(arg0, arg1) {
4029
+ arg0.stencilStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
4030
+ },
4031
+ __wbg_set_stencil_write_mask_3a7b75284ae036de: function(arg0, arg1) {
4032
+ arg0.stencilWriteMask = arg1 >>> 0;
4033
+ },
4034
+ __wbg_set_step_mode_2a36020da93d6f16: function(arg0, arg1) {
4035
+ arg0.stepMode = __wbindgen_enum_GpuVertexStepMode[arg1];
4036
+ },
4037
+ __wbg_set_storage_texture_50af47fec531be02: function(arg0, arg1) {
4038
+ arg0.storageTexture = arg1;
4039
+ },
4040
+ __wbg_set_store_op_23c150f1deb52749: function(arg0, arg1) {
4041
+ arg0.storeOp = __wbindgen_enum_GpuStoreOp[arg1];
4042
+ },
4043
+ __wbg_set_strip_index_format_bd4035f66052e74e: function(arg0, arg1) {
4044
+ arg0.stripIndexFormat = __wbindgen_enum_GpuIndexFormat[arg1];
4045
+ },
4046
+ __wbg_set_targets_d4d849b9c6abd35a: function(arg0, arg1) {
4047
+ arg0.targets = arg1;
4048
+ },
4049
+ __wbg_set_texture_884f2777c0fe1e91: function(arg0, arg1) {
4050
+ arg0.texture = arg1;
4051
+ },
4052
+ __wbg_set_texture_a1baf7da91d20351: function(arg0, arg1) {
4053
+ arg0.texture = arg1;
4054
+ },
4055
+ __wbg_set_timestamp_writes_fdf8168751575b7f: function(arg0, arg1) {
4056
+ arg0.timestampWrites = arg1;
4057
+ },
4058
+ __wbg_set_topology_0a07d5f484aff275: function(arg0, arg1) {
4059
+ arg0.topology = __wbindgen_enum_GpuPrimitiveTopology[arg1];
4060
+ },
4061
+ __wbg_set_type_109702a7ec65b49d: function(arg0, arg1) {
4062
+ arg0.type = __wbindgen_enum_GpuSamplerBindingType[arg1];
4063
+ },
4064
+ __wbg_set_type_55112c374bcc5a9d: function(arg0, arg1) {
4065
+ arg0.type = __wbindgen_enum_GpuBufferBindingType[arg1];
4066
+ },
4067
+ __wbg_set_unclipped_depth_b15740038a226817: function(arg0, arg1) {
4068
+ arg0.unclippedDepth = arg1 !== 0;
4069
+ },
4070
+ __wbg_set_usage_75d0e81d39ff5284: function(arg0, arg1) {
4071
+ arg0.usage = arg1 >>> 0;
4072
+ },
4073
+ __wbg_set_usage_ac04cadda4108c1a: function(arg0, arg1) {
4074
+ arg0.usage = arg1 >>> 0;
4075
+ },
4076
+ __wbg_set_usage_ad30cd3b0e0f4244: function(arg0, arg1) {
4077
+ arg0.usage = arg1 >>> 0;
4078
+ },
4079
+ __wbg_set_usage_cc34543608cf3335: function(arg0, arg1) {
4080
+ arg0.usage = arg1 >>> 0;
4081
+ },
4082
+ __wbg_set_vertex_13029c78ba2f0430: function(arg0, arg1) {
4083
+ arg0.vertex = arg1;
4084
+ },
4085
+ __wbg_set_view_6f2831c0da43be15: function(arg0, arg1) {
4086
+ arg0.view = arg1;
4087
+ },
4088
+ __wbg_set_view_b18c2cccd427261d: function(arg0, arg1) {
4089
+ arg0.view = arg1;
4090
+ },
4091
+ __wbg_set_view_dimension_50f3edb06107948f: function(arg0, arg1) {
4092
+ arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
4093
+ },
4094
+ __wbg_set_view_dimension_925bb358df1f2b9d: function(arg0, arg1) {
4095
+ arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
4096
+ },
4097
+ __wbg_set_view_formats_3d2a72ffb1f55a75: function(arg0, arg1) {
4098
+ arg0.viewFormats = arg1;
4099
+ },
4100
+ __wbg_set_view_formats_ae87e8e12aa858fc: function(arg0, arg1) {
4101
+ arg0.viewFormats = arg1;
4102
+ },
4103
+ __wbg_set_visibility_bdebc70a7c0f236d: function(arg0, arg1) {
4104
+ arg0.visibility = arg1 >>> 0;
4105
+ },
4106
+ __wbg_set_width_40592253da7b2113: function(arg0, arg1) {
4107
+ arg0.width = arg1 >>> 0;
4108
+ },
4109
+ __wbg_set_width_49ac9b7d914afc85: function(arg0, arg1) {
4110
+ arg0.width = arg1 >>> 0;
4111
+ },
4112
+ __wbg_set_width_8e30d010cd66830d: function(arg0, arg1) {
4113
+ arg0.width = arg1 >>> 0;
4114
+ },
4115
+ __wbg_set_write_mask_c03e8a45a9236e80: function(arg0, arg1) {
4116
+ arg0.writeMask = arg1 >>> 0;
4117
+ },
4118
+ __wbg_set_x_3c1cb8191b848172: function(arg0, arg1) {
4119
+ arg0.x = arg1 >>> 0;
4120
+ },
4121
+ __wbg_set_y_9024331910317eff: function(arg0, arg1) {
4122
+ arg0.y = arg1 >>> 0;
4123
+ },
4124
+ __wbg_set_z_b6182f4c230116a7: function(arg0, arg1) {
4125
+ arg0.z = arg1 >>> 0;
4126
+ },
4127
+ __wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
4128
+ const ret = typeof global === 'undefined' ? null : global;
4129
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4130
+ },
4131
+ __wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4: function() {
4132
+ const ret = typeof globalThis === 'undefined' ? null : globalThis;
4133
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4134
+ },
4135
+ __wbg_static_accessor_SELF_146583524fe1469b: function() {
4136
+ const ret = typeof self === 'undefined' ? null : self;
4137
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4138
+ },
4139
+ __wbg_static_accessor_WINDOW_f2829a2234d7819e: function() {
4140
+ const ret = typeof window === 'undefined' ? null : window;
4141
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4142
+ },
4143
+ __wbg_status_c45b3b9b3033184a: function(arg0) {
4144
+ const ret = arg0.status;
4145
+ return ret;
4146
+ },
4147
+ __wbg_subarray_3ed232c8a6baee09: function(arg0, arg1, arg2) {
4148
+ const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
4149
+ return ret;
4150
+ },
4151
+ __wbg_submit_fc5b9a1154201a58: function(arg0, arg1) {
4152
+ arg0.submit(arg1);
4153
+ },
4154
+ __wbg_then_16d107c451e9905d: function(arg0, arg1, arg2) {
4155
+ const ret = arg0.then(arg1, arg2);
4156
+ return ret;
4157
+ },
4158
+ __wbg_then_4a0b9283a66c4a8a: function(arg0, arg1, arg2) {
4159
+ const ret = arg0.then(arg1, arg2);
4160
+ return ret;
4161
+ },
4162
+ __wbg_then_6ec10ae38b3e92f7: function(arg0, arg1) {
4163
+ const ret = arg0.then(arg1);
4164
+ return ret;
4165
+ },
4166
+ __wbg_unmap_50b3be4aaf23fa39: function(arg0) {
4167
+ arg0.unmap();
4168
+ },
4169
+ __wbg_versions_276b2795b1c6a219: function(arg0) {
4170
+ const ret = arg0.versions;
4171
+ return ret;
4172
+ },
4173
+ __wbg_writeTexture_9d4c493be748d189: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
4174
+ arg0.writeTexture(arg1, arg2, arg3, arg4);
4175
+ }, arguments); },
4176
+ __wbindgen_cast_0000000000000001: function(arg0, arg1) {
4177
+ // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1895, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
4178
+ const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hd92f3b0a1cff0691);
4179
+ return ret;
4180
+ },
4181
+ __wbindgen_cast_0000000000000002: function(arg0, arg1) {
4182
+ // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3191, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
4183
+ const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5);
4184
+ return ret;
4185
+ },
4186
+ __wbindgen_cast_0000000000000003: function(arg0) {
4187
+ // Cast intrinsic for `F64 -> Externref`.
4188
+ const ret = arg0;
4189
+ return ret;
4190
+ },
4191
+ __wbindgen_cast_0000000000000004: function(arg0, arg1) {
4192
+ // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
4193
+ const ret = getArrayU8FromWasm0(arg0, arg1);
4194
+ return ret;
4195
+ },
4196
+ __wbindgen_cast_0000000000000005: function(arg0, arg1) {
4197
+ // Cast intrinsic for `Ref(String) -> Externref`.
4198
+ const ret = getStringFromWasm0(arg0, arg1);
4199
+ return ret;
4200
+ },
4201
+ __wbindgen_init_externref_table: function() {
4202
+ const table = wasm.__wbindgen_externrefs;
4203
+ const offset = table.grow(4);
4204
+ table.set(0, undefined);
4205
+ table.set(offset + 0, undefined);
4206
+ table.set(offset + 1, null);
4207
+ table.set(offset + 2, true);
4208
+ table.set(offset + 3, false);
4209
+ },
4210
+ };
4211
+ return {
4212
+ __proto__: null,
4213
+ "./orbital_wasm_bg.js": import0,
4214
+ };
4215
+ }
4216
+
4217
+ function wasm_bindgen__convert__closures_____invoke__hd92f3b0a1cff0691(arg0, arg1, arg2) {
4218
+ wasm.wasm_bindgen__convert__closures_____invoke__hd92f3b0a1cff0691(arg0, arg1, arg2);
4219
+ }
4220
+
4221
+ function wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5(arg0, arg1, arg2) {
4222
+ const ret = wasm.wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5(arg0, arg1, arg2);
4223
+ if (ret[1]) {
4224
+ throw takeFromExternrefTable0(ret[0]);
4225
+ }
4226
+ }
4227
+
4228
+
4229
+ const __wbindgen_enum_GpuAddressMode = ["clamp-to-edge", "repeat", "mirror-repeat"];
4230
+
4231
+
4232
+ const __wbindgen_enum_GpuBlendFactor = ["zero", "one", "src", "one-minus-src", "src-alpha", "one-minus-src-alpha", "dst", "one-minus-dst", "dst-alpha", "one-minus-dst-alpha", "src-alpha-saturated", "constant", "one-minus-constant", "src1", "one-minus-src1", "src1-alpha", "one-minus-src1-alpha"];
4233
+
4234
+
4235
+ const __wbindgen_enum_GpuBlendOperation = ["add", "subtract", "reverse-subtract", "min", "max"];
4236
+
4237
+
4238
+ const __wbindgen_enum_GpuBufferBindingType = ["uniform", "storage", "read-only-storage"];
4239
+
4240
+
4241
+ const __wbindgen_enum_GpuCanvasAlphaMode = ["opaque", "premultiplied"];
4242
+
4243
+
4244
+ const __wbindgen_enum_GpuCompareFunction = ["never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always"];
4245
+
4246
+
4247
+ const __wbindgen_enum_GpuCullMode = ["none", "front", "back"];
4248
+
4249
+
4250
+ const __wbindgen_enum_GpuFilterMode = ["nearest", "linear"];
4251
+
4252
+
4253
+ const __wbindgen_enum_GpuFrontFace = ["ccw", "cw"];
4254
+
4255
+
4256
+ const __wbindgen_enum_GpuIndexFormat = ["uint16", "uint32"];
4257
+
4258
+
4259
+ const __wbindgen_enum_GpuLoadOp = ["load", "clear"];
4260
+
4261
+
4262
+ const __wbindgen_enum_GpuMipmapFilterMode = ["nearest", "linear"];
4263
+
4264
+
4265
+ const __wbindgen_enum_GpuPowerPreference = ["low-power", "high-performance"];
4266
+
4267
+
4268
+ const __wbindgen_enum_GpuPrimitiveTopology = ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"];
4269
+
4270
+
4271
+ const __wbindgen_enum_GpuSamplerBindingType = ["filtering", "non-filtering", "comparison"];
4272
+
4273
+
4274
+ const __wbindgen_enum_GpuStencilOperation = ["keep", "zero", "replace", "invert", "increment-clamp", "decrement-clamp", "increment-wrap", "decrement-wrap"];
4275
+
4276
+
4277
+ const __wbindgen_enum_GpuStorageTextureAccess = ["write-only", "read-only", "read-write"];
4278
+
4279
+
4280
+ const __wbindgen_enum_GpuStoreOp = ["store", "discard"];
4281
+
4282
+
4283
+ const __wbindgen_enum_GpuTextureAspect = ["all", "stencil-only", "depth-only"];
4284
+
4285
+
4286
+ const __wbindgen_enum_GpuTextureDimension = ["1d", "2d", "3d"];
4287
+
4288
+
4289
+ const __wbindgen_enum_GpuTextureFormat = ["r8unorm", "r8snorm", "r8uint", "r8sint", "r16uint", "r16sint", "r16float", "rg8unorm", "rg8snorm", "rg8uint", "rg8sint", "r32uint", "r32sint", "r32float", "rg16uint", "rg16sint", "rg16float", "rgba8unorm", "rgba8unorm-srgb", "rgba8snorm", "rgba8uint", "rgba8sint", "bgra8unorm", "bgra8unorm-srgb", "rgb9e5ufloat", "rgb10a2uint", "rgb10a2unorm", "rg11b10ufloat", "rg32uint", "rg32sint", "rg32float", "rgba16uint", "rgba16sint", "rgba16float", "rgba32uint", "rgba32sint", "rgba32float", "stencil8", "depth16unorm", "depth24plus", "depth24plus-stencil8", "depth32float", "depth32float-stencil8", "bc1-rgba-unorm", "bc1-rgba-unorm-srgb", "bc2-rgba-unorm", "bc2-rgba-unorm-srgb", "bc3-rgba-unorm", "bc3-rgba-unorm-srgb", "bc4-r-unorm", "bc4-r-snorm", "bc5-rg-unorm", "bc5-rg-snorm", "bc6h-rgb-ufloat", "bc6h-rgb-float", "bc7-rgba-unorm", "bc7-rgba-unorm-srgb", "etc2-rgb8unorm", "etc2-rgb8unorm-srgb", "etc2-rgb8a1unorm", "etc2-rgb8a1unorm-srgb", "etc2-rgba8unorm", "etc2-rgba8unorm-srgb", "eac-r11unorm", "eac-r11snorm", "eac-rg11unorm", "eac-rg11snorm", "astc-4x4-unorm", "astc-4x4-unorm-srgb", "astc-5x4-unorm", "astc-5x4-unorm-srgb", "astc-5x5-unorm", "astc-5x5-unorm-srgb", "astc-6x5-unorm", "astc-6x5-unorm-srgb", "astc-6x6-unorm", "astc-6x6-unorm-srgb", "astc-8x5-unorm", "astc-8x5-unorm-srgb", "astc-8x6-unorm", "astc-8x6-unorm-srgb", "astc-8x8-unorm", "astc-8x8-unorm-srgb", "astc-10x5-unorm", "astc-10x5-unorm-srgb", "astc-10x6-unorm", "astc-10x6-unorm-srgb", "astc-10x8-unorm", "astc-10x8-unorm-srgb", "astc-10x10-unorm", "astc-10x10-unorm-srgb", "astc-12x10-unorm", "astc-12x10-unorm-srgb", "astc-12x12-unorm", "astc-12x12-unorm-srgb"];
4290
+
4291
+
4292
+ const __wbindgen_enum_GpuTextureSampleType = ["float", "unfilterable-float", "depth", "sint", "uint"];
4293
+
4294
+
4295
+ const __wbindgen_enum_GpuTextureViewDimension = ["1d", "2d", "2d-array", "cube", "cube-array", "3d"];
4296
+
4297
+
4298
+ const __wbindgen_enum_GpuVertexFormat = ["uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
4299
+
4300
+
4301
+ const __wbindgen_enum_GpuVertexStepMode = ["vertex", "instance"];
4302
+ const CredentialVaultFinalization = (typeof FinalizationRegistry === 'undefined')
4303
+ ? { register: () => {}, unregister: () => {} }
4304
+ : new FinalizationRegistry(ptr => wasm.__wbg_credentialvault_free(ptr, 1));
4305
+ const KernelFinalization = (typeof FinalizationRegistry === 'undefined')
4306
+ ? { register: () => {}, unregister: () => {} }
4307
+ : new FinalizationRegistry(ptr => wasm.__wbg_kernel_free(ptr, 1));
4308
+ const MemoryStoreFinalization = (typeof FinalizationRegistry === 'undefined')
4309
+ ? { register: () => {}, unregister: () => {} }
4310
+ : new FinalizationRegistry(ptr => wasm.__wbg_memorystore_free(ptr, 1));
4311
+ const ServerFinalization = (typeof FinalizationRegistry === 'undefined')
4312
+ ? { register: () => {}, unregister: () => {} }
4313
+ : new FinalizationRegistry(ptr => wasm.__wbg_server_free(ptr, 1));
4314
+
4315
+ function addToExternrefTable0(obj) {
4316
+ const idx = wasm.__externref_table_alloc();
4317
+ wasm.__wbindgen_externrefs.set(idx, obj);
4318
+ return idx;
4319
+ }
4320
+
4321
+ const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
4322
+ ? { register: () => {}, unregister: () => {} }
4323
+ : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
4324
+
4325
+ function debugString(val) {
4326
+ // primitive types
4327
+ const type = typeof val;
4328
+ if (type == 'number' || type == 'boolean' || val == null) {
4329
+ return `${val}`;
4330
+ }
4331
+ if (type == 'string') {
4332
+ return `"${val}"`;
4333
+ }
4334
+ if (type == 'symbol') {
4335
+ const description = val.description;
4336
+ if (description == null) {
4337
+ return 'Symbol';
4338
+ } else {
4339
+ return `Symbol(${description})`;
4340
+ }
4341
+ }
4342
+ if (type == 'function') {
4343
+ const name = val.name;
4344
+ if (typeof name == 'string' && name.length > 0) {
4345
+ return `Function(${name})`;
4346
+ } else {
4347
+ return 'Function';
4348
+ }
4349
+ }
4350
+ // objects
4351
+ if (Array.isArray(val)) {
4352
+ const length = val.length;
4353
+ let debug = '[';
4354
+ if (length > 0) {
4355
+ debug += debugString(val[0]);
4356
+ }
4357
+ for(let i = 1; i < length; i++) {
4358
+ debug += ', ' + debugString(val[i]);
4359
+ }
4360
+ debug += ']';
4361
+ return debug;
4362
+ }
4363
+ // Test for built-in
4364
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
4365
+ let className;
4366
+ if (builtInMatches && builtInMatches.length > 1) {
4367
+ className = builtInMatches[1];
4368
+ } else {
4369
+ // Failed to match the standard '[object ClassName]'
4370
+ return toString.call(val);
4371
+ }
4372
+ if (className == 'Object') {
4373
+ // we're a user defined class or Object
4374
+ // JSON.stringify avoids problems with cycles, and is generally much
4375
+ // easier than looping through ownProperties of `val`.
4376
+ try {
4377
+ return 'Object(' + JSON.stringify(val) + ')';
4378
+ } catch (_) {
4379
+ return 'Object';
4380
+ }
4381
+ }
4382
+ // errors
4383
+ if (val instanceof Error) {
4384
+ return `${val.name}: ${val.message}\n${val.stack}`;
4385
+ }
4386
+ // TODO we could test for more things here, like `Set`s and `Map`s.
4387
+ return className;
4388
+ }
4389
+
4390
+ function getArrayU32FromWasm0(ptr, len) {
4391
+ ptr = ptr >>> 0;
4392
+ return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
4393
+ }
4394
+
4395
+ function getArrayU8FromWasm0(ptr, len) {
4396
+ ptr = ptr >>> 0;
4397
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
4398
+ }
4399
+
4400
+ let cachedDataViewMemory0 = null;
4401
+ function getDataViewMemory0() {
4402
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
4403
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
4404
+ }
4405
+ return cachedDataViewMemory0;
4406
+ }
4407
+
4408
+ function getStringFromWasm0(ptr, len) {
4409
+ return decodeText(ptr >>> 0, len);
4410
+ }
4411
+
4412
+ let cachedUint32ArrayMemory0 = null;
4413
+ function getUint32ArrayMemory0() {
4414
+ if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
4415
+ cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
4416
+ }
4417
+ return cachedUint32ArrayMemory0;
4418
+ }
4419
+
4420
+ let cachedUint8ArrayMemory0 = null;
4421
+ function getUint8ArrayMemory0() {
4422
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
4423
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
4424
+ }
4425
+ return cachedUint8ArrayMemory0;
4426
+ }
4427
+
4428
+ function handleError(f, args) {
4429
+ try {
4430
+ return f.apply(this, args);
4431
+ } catch (e) {
4432
+ const idx = addToExternrefTable0(e);
4433
+ wasm.__wbindgen_exn_store(idx);
4434
+ }
4435
+ }
4436
+
4437
+ function isLikeNone(x) {
4438
+ return x === undefined || x === null;
4439
+ }
4440
+
4441
+ function makeMutClosure(arg0, arg1, f) {
4442
+ const state = { a: arg0, b: arg1, cnt: 1 };
4443
+ const real = (...args) => {
4444
+
4445
+ // First up with a closure we increment the internal reference
4446
+ // count. This ensures that the Rust closure environment won't
4447
+ // be deallocated while we're invoking it.
4448
+ state.cnt++;
4449
+ const a = state.a;
4450
+ state.a = 0;
4451
+ try {
4452
+ return f(a, state.b, ...args);
4453
+ } finally {
4454
+ state.a = a;
4455
+ real._wbg_cb_unref();
4456
+ }
4457
+ };
4458
+ real._wbg_cb_unref = () => {
4459
+ if (--state.cnt === 0) {
4460
+ wasm.__wbindgen_destroy_closure(state.a, state.b);
4461
+ state.a = 0;
4462
+ CLOSURE_DTORS.unregister(state);
4463
+ }
4464
+ };
4465
+ CLOSURE_DTORS.register(real, state, state);
4466
+ return real;
4467
+ }
4468
+
4469
+ function passStringToWasm0(arg, malloc, realloc) {
4470
+ if (realloc === undefined) {
4471
+ const buf = cachedTextEncoder.encode(arg);
4472
+ const ptr = malloc(buf.length, 1) >>> 0;
4473
+ getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
4474
+ WASM_VECTOR_LEN = buf.length;
4475
+ return ptr;
4476
+ }
4477
+
4478
+ let len = arg.length;
4479
+ let ptr = malloc(len, 1) >>> 0;
4480
+
4481
+ const mem = getUint8ArrayMemory0();
4482
+
4483
+ let offset = 0;
4484
+
4485
+ for (; offset < len; offset++) {
4486
+ const code = arg.charCodeAt(offset);
4487
+ if (code > 0x7F) break;
4488
+ mem[ptr + offset] = code;
4489
+ }
4490
+ if (offset !== len) {
4491
+ if (offset !== 0) {
4492
+ arg = arg.slice(offset);
4493
+ }
4494
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
4495
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
4496
+ const ret = cachedTextEncoder.encodeInto(arg, view);
4497
+
4498
+ offset += ret.written;
4499
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
4500
+ }
4501
+
4502
+ WASM_VECTOR_LEN = offset;
4503
+ return ptr;
4504
+ }
4505
+
4506
+ function takeFromExternrefTable0(idx) {
4507
+ const value = wasm.__wbindgen_externrefs.get(idx);
4508
+ wasm.__externref_table_dealloc(idx);
4509
+ return value;
4510
+ }
4511
+
4512
+ let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
4513
+ cachedTextDecoder.decode();
4514
+ const MAX_SAFARI_DECODE_BYTES = 2146435072;
4515
+ let numBytesDecoded = 0;
4516
+ function decodeText(ptr, len) {
4517
+ numBytesDecoded += len;
4518
+ if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
4519
+ cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
4520
+ cachedTextDecoder.decode();
4521
+ numBytesDecoded = len;
4522
+ }
4523
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
4524
+ }
4525
+
4526
+ const cachedTextEncoder = new TextEncoder();
4527
+
4528
+ if (!('encodeInto' in cachedTextEncoder)) {
4529
+ cachedTextEncoder.encodeInto = function (arg, view) {
4530
+ const buf = cachedTextEncoder.encode(arg);
4531
+ view.set(buf);
4532
+ return {
4533
+ read: arg.length,
4534
+ written: buf.length
4535
+ };
4536
+ };
4537
+ }
4538
+
4539
+ let WASM_VECTOR_LEN = 0;
4540
+
4541
+ let wasmModule, wasmInstance, wasm;
4542
+ function __wbg_finalize_init(instance, module) {
4543
+ wasmInstance = instance;
4544
+ wasm = instance.exports;
4545
+ wasmModule = module;
4546
+ cachedDataViewMemory0 = null;
4547
+ cachedUint32ArrayMemory0 = null;
4548
+ cachedUint8ArrayMemory0 = null;
4549
+ wasm.__wbindgen_start();
4550
+ return wasm;
4551
+ }
4552
+
4553
+ async function __wbg_load(module, imports) {
4554
+ if (typeof Response === 'function' && module instanceof Response) {
4555
+ if (typeof WebAssembly.instantiateStreaming === 'function') {
4556
+ try {
4557
+ return await WebAssembly.instantiateStreaming(module, imports);
4558
+ } catch (e) {
4559
+ const validResponse = module.ok && expectedResponseType(module.type);
4560
+
4561
+ if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
4562
+ 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);
4563
+
4564
+ } else { throw e; }
4565
+ }
4566
+ }
4567
+
4568
+ const bytes = await module.arrayBuffer();
4569
+ return await WebAssembly.instantiate(bytes, imports);
4570
+ } else {
4571
+ const instance = await WebAssembly.instantiate(module, imports);
4572
+
4573
+ if (instance instanceof WebAssembly.Instance) {
4574
+ return { instance, module };
4575
+ } else {
4576
+ return instance;
4577
+ }
4578
+ }
4579
+
4580
+ function expectedResponseType(type) {
4581
+ switch (type) {
4582
+ case 'basic': case 'cors': case 'default': return true;
4583
+ }
4584
+ return false;
4585
+ }
4586
+ }
4587
+
4588
+ function initSync(module) {
4589
+ if (wasm !== undefined) return wasm;
4590
+
4591
+
4592
+ if (module !== undefined) {
4593
+ if (Object.getPrototypeOf(module) === Object.prototype) {
4594
+ ({module} = module)
4595
+ } else {
4596
+ console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
4597
+ }
4598
+ }
4599
+
4600
+ const imports = __wbg_get_imports();
4601
+ if (!(module instanceof WebAssembly.Module)) {
4602
+ module = new WebAssembly.Module(module);
4603
+ }
4604
+ const instance = new WebAssembly.Instance(module, imports);
4605
+ return __wbg_finalize_init(instance, module);
4606
+ }
4607
+
4608
+ async function __wbg_init(module_or_path) {
4609
+ if (wasm !== undefined) return wasm;
4610
+
4611
+
4612
+ if (module_or_path !== undefined) {
4613
+ if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
4614
+ ({module_or_path} = module_or_path)
4615
+ } else {
4616
+ console.warn('using deprecated parameters for the initialization function; pass a single object instead')
4617
+ }
4618
+ }
4619
+
4620
+ if (module_or_path === undefined) {
4621
+ module_or_path = new URL('orbital_wasm_bg.wasm', import.meta.url);
4622
+ }
4623
+ const imports = __wbg_get_imports();
4624
+
4625
+ if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
4626
+ module_or_path = fetch(module_or_path);
4627
+ }
4628
+
4629
+ const { instance, module } = await __wbg_load(await module_or_path, imports);
4630
+
4631
+ return __wbg_finalize_init(instance, module);
4632
+ }
4633
+
4634
+ export { initSync, __wbg_init as default };