@almadar/kernel 18.0.0 → 19.0.1

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