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