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