@almadar/kernel 18.0.0 → 19.0.0

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