@perspective-dev/client 4.5.1 → 5.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.
Files changed (37) hide show
  1. package/dist/cdn/perspective-server.worker.js +1 -1
  2. package/dist/cdn/perspective-server.worker.js.map +3 -3
  3. package/dist/cdn/perspective.js +2 -2
  4. package/dist/cdn/perspective.js.map +4 -4
  5. package/dist/esm/perspective.browser.d.ts +50 -1
  6. package/dist/esm/perspective.inline.js +2 -2
  7. package/dist/esm/perspective.inline.js.map +4 -4
  8. package/dist/esm/perspective.js +2 -2
  9. package/dist/esm/perspective.js.map +4 -4
  10. package/dist/esm/perspective.node.d.ts +3 -0
  11. package/dist/esm/perspective.node.js +328 -25
  12. package/dist/esm/perspective.node.js.map +4 -4
  13. package/dist/esm/ts-rs/TableInitOptions.d.ts +6 -0
  14. package/dist/esm/virtual_servers/clickhouse.js +1 -1
  15. package/dist/esm/virtual_servers/clickhouse.js.map +2 -2
  16. package/dist/esm/virtual_servers/duckdb.js +1 -1
  17. package/dist/esm/virtual_servers/duckdb.js.map +2 -2
  18. package/dist/esm/wasm/emscripten_api.d.ts +14 -1
  19. package/dist/esm/wasm/engine.d.ts +11 -1
  20. package/dist/esm/wasm/features.d.ts +4 -0
  21. package/dist/wasm/perspective-js.d.ts +5 -5
  22. package/dist/wasm/perspective-js.js +9 -9
  23. package/dist/wasm/perspective-js.wasm +0 -0
  24. package/dist/wasm/perspective-js.wasm.d.ts +5 -5
  25. package/package.json +1 -1
  26. package/src/rust/typed_array.rs +88 -54
  27. package/src/ts/perspective.browser.ts +176 -20
  28. package/src/ts/perspective.cdn.ts +11 -5
  29. package/src/ts/perspective.node.ts +157 -5
  30. package/src/ts/ts-rs/TableInitOptions.ts +7 -1
  31. package/src/ts/virtual_servers/clickhouse.ts +1 -0
  32. package/src/ts/virtual_servers/duckdb.ts +3 -1
  33. package/src/ts/wasm/cdn.ts +32 -0
  34. package/src/ts/wasm/emscripten_api.ts +25 -0
  35. package/src/ts/wasm/engine.ts +59 -12
  36. package/src/ts/wasm/features.ts +31 -0
  37. package/src/ts/wasm/perspective-server.poly.ts +173 -3
@@ -17,6 +17,8 @@ import * as psp_virtual from "./virtual_server.ts";
17
17
  import * as wasm_module from "../../dist/wasm/perspective-js.js";
18
18
  import * as api from "./wasm/browser.ts";
19
19
  import { load_wasm_stage_0 } from "./wasm/decompress.ts";
20
+ import { host_supports_memory64 } from "./wasm/features.ts";
21
+ export { host_supports_memory64 } from "./wasm/features.ts";
20
22
 
21
23
  export {
22
24
  GenericSQLVirtualServerModel,
@@ -30,7 +32,40 @@ import {
30
32
  VirtualServer,
31
33
  } from "../../dist/wasm/perspective-js.js";
32
34
 
33
- let GLOBAL_SERVER_WASM: Promise<ArrayBuffer | WebAssembly.Module>;
35
+ /**
36
+ * A single Perspective engine binary, in any form `init_server` accepts.
37
+ * Thunk sources are only invoked if selected — register both bitnesses as
38
+ * `() => fetch(...)` and only the winning binary is ever downloaded.
39
+ */
40
+ export type ServerWasmSource =
41
+ | Uint8Array
42
+ | ArrayBuffer
43
+ | Response
44
+ | WebAssembly.Module
45
+ | Promise<ArrayBuffer | Response | WebAssembly.Module>
46
+ | (() => Promise<ArrayBuffer | Response | WebAssembly.Module>);
47
+
48
+ /**
49
+ * Engine binaries by bitness. Registering `wasm64` is the opt-in for the
50
+ * Memory64 engine (4GB heap ceiling raised to 16GB, at some engine
51
+ * performance cost) — it is selected whenever the host supports Memory64.
52
+ */
53
+ export interface ServerWasmRegistration {
54
+ wasm32?: ServerWasmSource;
55
+ wasm64?: ServerWasmSource;
56
+ }
57
+
58
+ export interface InitServerOptions {
59
+ disable_stage_0?: boolean;
60
+ }
61
+
62
+ interface ServerWasmRegistry extends ServerWasmRegistration {
63
+ sole?: ServerWasmSource;
64
+ disable_stage_0: boolean;
65
+ }
66
+
67
+ let SERVER_REGISTRY: ServerWasmRegistry | undefined;
68
+ let GLOBAL_SERVER_WASM: Promise<ArrayBuffer | WebAssembly.Module> | undefined;
34
69
 
35
70
  export async function createMessageHandler(
36
71
  handler: psp_virtual.VirtualServerHandler,
@@ -38,28 +73,144 @@ export async function createMessageHandler(
38
73
  return psp_virtual.createMessageHandler(await get_client(), handler);
39
74
  }
40
75
 
76
+ function is_wasm_source(
77
+ wasm: ServerWasmSource | ServerWasmRegistration,
78
+ ): wasm is ServerWasmSource {
79
+ return (
80
+ wasm instanceof Uint8Array ||
81
+ wasm instanceof ArrayBuffer ||
82
+ (typeof Response !== "undefined" && wasm instanceof Response) ||
83
+ wasm instanceof Promise ||
84
+ wasm instanceof WebAssembly.Module ||
85
+ typeof wasm === "function"
86
+ );
87
+ }
88
+
89
+ async function materialize_server_wasm(
90
+ source: ServerWasmSource,
91
+ disable_stage_0: boolean,
92
+ ): Promise<ArrayBuffer | WebAssembly.Module> {
93
+ let wasm = typeof source === "function" ? await source() : await source;
94
+ if (wasm instanceof Uint8Array) {
95
+ wasm = wasm.buffer as ArrayBuffer;
96
+ }
97
+
98
+ if (typeof Response !== "undefined" && wasm instanceof Response) {
99
+ if (!wasm.ok) {
100
+ throw new Error(
101
+ `Failed to fetch perspective server wasm (HTTP ${wasm.status} "${wasm.url}")`,
102
+ );
103
+ }
104
+
105
+ if (disable_stage_0) {
106
+ return await wasm.arrayBuffer();
107
+ }
108
+ }
109
+
110
+ if (disable_stage_0) {
111
+ return wasm as ArrayBuffer | WebAssembly.Module;
112
+ }
113
+
114
+ const bytes = await load_wasm_stage_0(wasm);
115
+ return bytes.buffer as ArrayBuffer;
116
+ }
117
+
118
+ async function select_server_wasm(
119
+ registry: ServerWasmRegistry,
120
+ ): Promise<ArrayBuffer | WebAssembly.Module> {
121
+ if (registry.sole !== undefined) {
122
+ return await materialize_server_wasm(
123
+ registry.sole,
124
+ registry.disable_stage_0,
125
+ );
126
+ }
127
+
128
+ // A lone `wasm64` registration is an explicit opt-in and is used as-is
129
+ // regardless of the probe (an unsupporting host fails at instantiation,
130
+ // which is the correct error).
131
+ if (
132
+ registry.wasm64 !== undefined &&
133
+ (registry.wasm32 === undefined || host_supports_memory64())
134
+ ) {
135
+ try {
136
+ return await materialize_server_wasm(
137
+ registry.wasm64,
138
+ registry.disable_stage_0,
139
+ );
140
+ } catch (e) {
141
+ if (registry.wasm32 === undefined) {
142
+ throw e;
143
+ }
144
+
145
+ console.warn(
146
+ "Memory64 perspective server wasm failed to load, falling back to wasm32",
147
+ e,
148
+ );
149
+ }
150
+ }
151
+
152
+ return await materialize_server_wasm(
153
+ registry.wasm32!,
154
+ registry.disable_stage_0,
155
+ );
156
+ }
157
+
158
+ /**
159
+ * Register the Perspective engine ("server") WebAssembly binary that backs
160
+ * `worker()`.
161
+ *
162
+ * The single-argument form registers one binary of either bitness. The
163
+ * object form registers a wasm32 and/or wasm64 (Memory64) binary; the wasm64
164
+ * binary is preferred whenever the host supports Memory64, raising the
165
+ * engine's heap ceiling from 4GB to 16GB (at some engine performance cost —
166
+ * register only `wasm32` to opt out). Sources registered as thunks are only
167
+ * invoked if selected, so the losing binary is never downloaded; if the
168
+ * selected wasm64 source fails to load and a wasm32 source is also
169
+ * registered, selection falls back to wasm32 with a console warning.
170
+ *
171
+ * Selection and download are deferred to the first `worker()` call.
172
+ *
173
+ * # Examples
174
+ *
175
+ * ```javascript
176
+ * perspective.init_server(
177
+ * fetch("perspective-server.wasm"),
178
+ * );
179
+ *
180
+ * perspective.init_server({
181
+ * wasm32: () => fetch("perspective-server.wasm"),
182
+ * wasm64: () => fetch("perspective-server.memory64.wasm"),
183
+ * });
184
+ * ```
185
+ */
41
186
  export function init_server(
42
- wasm:
43
- | Uint8Array
44
- | Promise<ArrayBuffer | Response | WebAssembly.Module>
45
- | ArrayBuffer
46
- | Response
47
- | WebAssembly.Module,
48
- disable_stage_0: boolean = false,
187
+ wasm: ServerWasmSource | ServerWasmRegistration,
188
+ options: boolean | InitServerOptions = false,
49
189
  ) {
50
- if (wasm instanceof Uint8Array) {
51
- GLOBAL_SERVER_WASM = Promise.resolve(wasm.buffer);
52
- } else if (wasm instanceof Response) {
53
- GLOBAL_SERVER_WASM = Promise.resolve(wasm);
54
- } else if (wasm instanceof Promise) {
55
- GLOBAL_SERVER_WASM = wasm;
56
- } else {
57
- GLOBAL_SERVER_WASM = Promise.resolve(wasm);
190
+ const disable_stage_0 =
191
+ typeof options === "boolean" ? options : !!options.disable_stage_0;
192
+
193
+ GLOBAL_SERVER_WASM = undefined;
194
+ if (is_wasm_source(wasm)) {
195
+ SERVER_REGISTRY = { sole: wasm, disable_stage_0 };
196
+ return;
58
197
  }
59
198
 
60
- if (!disable_stage_0) {
61
- GLOBAL_SERVER_WASM = GLOBAL_SERVER_WASM.then((x) =>
62
- load_wasm_stage_0(x).then((x) => x.buffer as ArrayBuffer),
199
+ // `WebAssembly.Module`'s lib type is structurally empty, so TypeScript
200
+ // can't negatively narrow this branch itself.
201
+ const registration = wasm as ServerWasmRegistration;
202
+ if (
203
+ registration.wasm32 !== undefined ||
204
+ registration.wasm64 !== undefined
205
+ ) {
206
+ SERVER_REGISTRY = {
207
+ wasm32: registration.wasm32,
208
+ wasm64: registration.wasm64,
209
+ disable_stage_0,
210
+ };
211
+ } else {
212
+ throw new Error(
213
+ "init_server requires a wasm source or a {wasm32, wasm64} registration",
63
214
  );
64
215
  }
65
216
  }
@@ -175,10 +326,14 @@ export async function getCompiledClientWasm(): Promise<WebAssembly.Module> {
175
326
  }
176
327
 
177
328
  function get_server() {
178
- if (GLOBAL_SERVER_WASM === undefined) {
329
+ if (SERVER_REGISTRY === undefined) {
179
330
  throw new Error("Missing perspective-server.wasm");
180
331
  }
181
332
 
333
+ if (GLOBAL_SERVER_WASM === undefined) {
334
+ GLOBAL_SERVER_WASM = select_server_wasm(SERVER_REGISTRY);
335
+ }
336
+
182
337
  return GLOBAL_SERVER_WASM.then((x) =>
183
338
  x instanceof WebAssembly.Module ? x : x.slice(0),
184
339
  );
@@ -234,6 +389,7 @@ export default {
234
389
  worker,
235
390
  init_client,
236
391
  init_server,
392
+ host_supports_memory64,
237
393
  createMessageHandler,
238
394
  getCompiledClientWasm,
239
395
  GenericSQLVirtualServerModel,
@@ -12,11 +12,17 @@
12
12
 
13
13
  import perspective from "./perspective.browser.ts";
14
14
  export * from "./perspective.browser.ts";
15
+ import { resolve_server_wasm_url } from "./wasm/cdn.ts";
15
16
 
16
- const url = new URL(
17
- "../../../server/dist/wasm/perspective-server.wasm",
18
- import.meta.url,
19
- );
17
+ perspective.init_server({
18
+ wasm32: () => fetch(resolve_server_wasm_url(import.meta.url)),
19
+ wasm64: () =>
20
+ fetch(
21
+ resolve_server_wasm_url(
22
+ import.meta.url,
23
+ "perspective-server.memory64.wasm",
24
+ ),
25
+ ),
26
+ });
20
27
 
21
- perspective.init_server(fetch(url));
22
28
  export default perspective;
@@ -16,6 +16,16 @@ export type * from "./virtual_server.ts";
16
16
  import WebSocket, { WebSocketServer as HttpWebSocketServer } from "ws";
17
17
  import stoppable from "stoppable";
18
18
  import { promises as fs } from "node:fs";
19
+ import {
20
+ openSync,
21
+ readSync,
22
+ writeSync,
23
+ closeSync,
24
+ mkdirSync,
25
+ unlinkSync,
26
+ rmSync,
27
+ } from "node:fs";
28
+ import os from "node:os";
19
29
  import http from "node:http";
20
30
  import path from "node:path";
21
31
  import { webcrypto } from "node:crypto";
@@ -25,7 +35,10 @@ import { createRequire } from "node:module";
25
35
 
26
36
  import * as perspective_client from "../../dist/wasm/perspective-js.js";
27
37
  import { load_wasm_stage_0 } from "./wasm/decompress.js";
38
+ import { host_supports_memory64 } from "./wasm/features.ts";
28
39
  import * as engine from "./wasm/engine.ts";
40
+
41
+ export { host_supports_memory64 } from "./wasm/features.ts";
29
42
  import { compile_perspective } from "./wasm/emscripten_api.ts";
30
43
  import * as psp_websocket from "./websocket.ts";
31
44
  import * as api from "./wasm/browser.ts";
@@ -56,12 +69,150 @@ const uncompressed_client_wasm = await fs
56
69
  .then((buffer) => load_wasm_stage_0(buffer.buffer as ArrayBuffer));
57
70
 
58
71
  await perspective_client.default({ module_or_path: uncompressed_client_wasm });
59
- const SYNC_MODULE = await fs
60
- .readFile(
72
+
73
+ function make_node_disk_bridge({
74
+ heap,
75
+ toAddr,
76
+ readCString,
77
+ }: {
78
+ heap: () => Uint8Array;
79
+ toAddr: (p: number | bigint) => number;
80
+ readCString: (p: number | bigint) => string;
81
+ }) {
82
+ const root = path.join(os.tmpdir(), `perspective-${process.pid}`);
83
+ const resolve_path = (name: string) => {
84
+ const p = path.join(root, name);
85
+ if (!p.startsWith(root)) {
86
+ throw new Error(`refusing disk path outside root: ${name}`);
87
+ }
88
+ return p;
89
+ };
90
+
91
+ let cleaned = false;
92
+ const cleanup = () => {
93
+ if (cleaned) return;
94
+ cleaned = true;
95
+ try {
96
+ rmSync(root, { recursive: true, force: true });
97
+ } catch (e) {
98
+ /* best effort */
99
+ }
100
+ };
101
+ process.on("exit", cleanup);
102
+ process.on("SIGINT", () => {
103
+ cleanup();
104
+ process.exit(130);
105
+ });
106
+
107
+ return {
108
+ // node:fs is synchronous — nothing to pre-open between safepoint phases.
109
+ async ensureOpen(_name: string) {},
110
+ store(
111
+ namePtr: number | bigint,
112
+ dataPtr: number | bigint,
113
+ len: number,
114
+ ): number {
115
+ try {
116
+ const p = resolve_path(readCString(namePtr));
117
+ mkdirSync(path.dirname(p), { recursive: true });
118
+ const fd = openSync(p, "w");
119
+ try {
120
+ if (len > 0) {
121
+ const addr = toAddr(dataPtr);
122
+ const view = heap().subarray(addr, addr + len);
123
+ let off = 0;
124
+ while (off < len) {
125
+ off += writeSync(fd, view, off, len - off, off);
126
+ }
127
+ }
128
+ } finally {
129
+ closeSync(fd);
130
+ }
131
+ return len;
132
+ } catch (e) {
133
+ console.error("node disk store failed", e);
134
+ return -1;
135
+ }
136
+ },
137
+ load(
138
+ namePtr: number | bigint,
139
+ dataPtr: number | bigint,
140
+ len: number,
141
+ ): number {
142
+ try {
143
+ if (len <= 0) return 0;
144
+ let fd: number;
145
+ try {
146
+ fd = openSync(resolve_path(readCString(namePtr)), "r");
147
+ } catch (e) {
148
+ return 0; // never-flushed file reads as zeros
149
+ }
150
+ try {
151
+ const addr = toAddr(dataPtr);
152
+ const view = heap().subarray(addr, addr + len);
153
+ let off = 0;
154
+ let n: number;
155
+ while (
156
+ off < len &&
157
+ (n = readSync(fd, view, off, len - off, off)) > 0
158
+ ) {
159
+ off += n;
160
+ }
161
+ return off;
162
+ } finally {
163
+ closeSync(fd);
164
+ }
165
+ } catch (e) {
166
+ return 0;
167
+ }
168
+ },
169
+ remove(namePtr: number | bigint) {
170
+ try {
171
+ unlinkSync(resolve_path(readCString(namePtr)));
172
+ } catch (e) {
173
+ /* already gone */
174
+ }
175
+ },
176
+ };
177
+ }
178
+
179
+ async function compile_server_module(wasm_path: string) {
180
+ const buffer = await fs.readFile(wasm_path);
181
+ const bytes = await load_wasm_stage_0(buffer.buffer as ArrayBuffer);
182
+ return await compile_perspective(bytes.buffer as ArrayBuffer, {
183
+ make_disk_bridge: make_node_disk_bridge,
184
+ });
185
+ }
186
+
187
+ async function load_server_module() {
188
+ if (host_supports_memory64()) {
189
+ let wasm_path;
190
+ try {
191
+ wasm_path = resolve(
192
+ "@perspective-dev/server/dist/wasm/perspective-server.memory64.wasm",
193
+ );
194
+ } catch (e) {
195
+ wasm_path = undefined;
196
+ }
197
+
198
+ if (wasm_path !== undefined) {
199
+ try {
200
+ return await compile_server_module(wasm_path);
201
+ } catch (e) {
202
+ console.warn(
203
+ "Memory64 perspective server wasm failed to load, falling back to wasm32",
204
+ e,
205
+ );
206
+ }
207
+ }
208
+ }
209
+
210
+ return await compile_server_module(
61
211
  resolve("@perspective-dev/server/dist/wasm/perspective-server.wasm"),
62
- )
63
- .then((buffer) => load_wasm_stage_0(buffer.buffer as ArrayBuffer))
64
- .then((buffer) => compile_perspective(buffer.buffer as ArrayBuffer));
212
+ );
213
+ }
214
+
215
+ const SYNC_MODULE = await load_server_module();
65
216
 
66
217
  let SYNC_CLIENT: perspective_client.Client;
67
218
 
@@ -391,6 +542,7 @@ export default {
391
542
  join,
392
543
  websocket,
393
544
  worker,
545
+ host_supports_memory64,
394
546
  get_hosted_table_names,
395
547
  on_hosted_tables_update,
396
548
  remove_hosted_tables_update,
@@ -18,4 +18,10 @@ index?: string,
18
18
  * _earliest_ rows will be overwritten (where _earliest_ is defined as
19
19
  * relative to insertion order).
20
20
  */
21
- limit?: number, };
21
+ limit?: number,
22
+ /**
23
+ * Back this [`Table`]'s canonical data with the on-disk storage backend
24
+ * instead of memory. On native targets this is a memory-mapped file; on
25
+ * WASM it is OPFS (Worker only). Defaults to in-memory.
26
+ */
27
+ page_to_disk?: boolean, };
@@ -214,6 +214,7 @@ export class ClickhouseHandler implements perspective.VirtualServerHandler {
214
214
  this.sqlBuilder = new mod!.GenericSQLVirtualServerModel({
215
215
  create_entity: "VIEW",
216
216
  grouping_fn: "GROUPING",
217
+ column_separator: "|",
217
218
  });
218
219
  }
219
220
 
@@ -184,7 +184,9 @@ export class DuckDBHandler implements perspective.VirtualServerHandler {
184
184
  }
185
185
 
186
186
  this.db = db;
187
- this.sqlBuilder = new mod!.GenericSQLVirtualServerModel();
187
+ this.sqlBuilder = new mod!.GenericSQLVirtualServerModel({
188
+ column_separator: "|",
189
+ });
188
190
  }
189
191
 
190
192
  getFeatures() {
@@ -0,0 +1,32 @@
1
+ // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
2
+ // ┃ ██████ ██████ ██████ █ █ █ █ █ █▄ ▀███ █ ┃
3
+ // ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█ ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄ ▀█ █ ▀▀▀▀▀ ┃
4
+ // ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄ █ ▄▄▄▄▄ ┃
5
+ // ┃ █ ██████ █ ▀█▄ █ ██████ █ ███▌▐███ ███████▄ █ ┃
6
+ // ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
7
+ // ┃ Copyright (c) 2017, the Perspective Authors. ┃
8
+ // ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
9
+ // ┃ This file is part of the Perspective library, distributed under the terms ┃
10
+ // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
11
+ // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
12
+
13
+ /**
14
+ * Resolve the URL of one of `@perspective-dev/server`'s engine WASM binaries
15
+ * relative to the URL of the `@perspective-dev/client` CDN bundle which loads
16
+ * it.
17
+ */
18
+ export function resolve_server_wasm_url(
19
+ client_url: string,
20
+ filename: string = "perspective-server.wasm",
21
+ ): string {
22
+ const rewritten = client_url.replace(
23
+ /\/client(@[^/]+)?\/dist\/cdn\/[^/?#]*([?#].*)?$/,
24
+ (_, tag) => `/server${tag ?? ""}/dist/wasm/${filename}`,
25
+ );
26
+
27
+ if (rewritten !== client_url) {
28
+ return rewritten;
29
+ }
30
+
31
+ return new URL(`../../../server/dist/wasm/${filename}`, client_url).href;
32
+ }
@@ -17,13 +17,38 @@ import type * as perspective_server_t from "@perspective-dev/server/dist/wasm/pe
17
17
  export type PspPtr = BigInt | number;
18
18
  export type EmscriptenServer = bigint | number;
19
19
 
20
+ export interface DiskBridgeHelpers {
21
+ heap: () => Uint8Array;
22
+ toAddr: (p: number | bigint) => number;
23
+ readCString: (p: number | bigint) => string;
24
+ }
25
+
26
+ export interface CompileOptions {
27
+ make_disk_bridge?: (helpers: DiskBridgeHelpers) => {
28
+ store(
29
+ namePtr: number | bigint,
30
+ dataPtr: number | bigint,
31
+ len: number,
32
+ ): number;
33
+ load(
34
+ namePtr: number | bigint,
35
+ dataPtr: number | bigint,
36
+ len: number,
37
+ ): number;
38
+ remove(namePtr: number | bigint): void;
39
+ ensureOpen(name: string): Promise<void>;
40
+ };
41
+ }
42
+
20
43
  export async function compile_perspective(
21
44
  wasmBinary: ArrayBuffer,
45
+ opts?: CompileOptions,
22
46
  ): Promise<perspective_server_t.MainModule> {
23
47
  const module = await perspective_server.default({
24
48
  locateFile(x: any) {
25
49
  return x;
26
50
  },
51
+ make_disk_bridge: opts?.make_disk_bridge,
27
52
  instantiateWasm: async (
28
53
  imports: any,
29
54
  receive: (_: WebAssembly.Instance) => void,