@sema-lang/sema-wasm 1.17.0 → 1.19.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "@sema-lang/sema-wasm",
   "type": "module",
   "description": "WebAssembly bindings for the Sema Lisp interpreter",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/sema_wasm.d.ts

@@ -34,13 +34,21 @@ export class SemaInterpreter {
      * Delete a file from the virtual filesystem. Returns true if the file existed.
      */
     deleteFile(path: string): boolean;
+    /**
+     * Snapshot the entire VFS as a plain JS object `{ files: {path: content},
+     * dirs: [path] }` — structured-clonable across `postMessage`. Used by the
+     * playground to mirror the worker's VFS back to the main thread after each
+     * eval (and to seed the worker before one). See `loadVfs`.
+     */
+    dumpVfs(): any;
     /**
      * Evaluate code, returns JSON: {"value": "...", "output": ["...", ...], "error": null}
      * or {"value": null, "output": [...], "error": "..."}
      */
     eval(code: string): any;
     /**
-     * Evaluate code with async HTTP support (tree-walker, global env)
+     * Evaluate code with async HTTP support in the persistent global env
+     * (top-level defines persist across calls). Runs on the bytecode VM.
      */
     evalAsync(code: string): Promise<any>;
     /**
@@ -64,6 +72,16 @@ export class SemaInterpreter {
      * Returns a JS array of line numbers (sorted). Returns empty array on parse/compile error.
      */
     getValidBreakpointLines(code: string): Array<any>;
+    /**
+     * Enable real wall-clock `async/sleep` via `Atomics.wait` on the given
+     * control buffer. Call this once from a Web Worker (where blocking is
+     * allowed), passing an `Int32Array` over a `SharedArrayBuffer` shared with
+     * the main thread. After this, the scheduler's virtual-clock advances also
+     * block the worker for the real duration. Do NOT call on the main thread —
+     * `Atomics.wait` is illegal there; leaving it uninstalled keeps the
+     * instant virtual-clock behavior.
+     */
+    installAtomicsSleep(view: Int32Array): void;
     /**
      * Check if a path is a directory in the virtual filesystem.
      */
@@ -72,6 +90,11 @@ export class SemaInterpreter {
      * List files and directories in the given directory path.
      */
     listFiles(dir: string): any;
+    /**
+     * Replace the entire VFS from a snapshot produced by `dumpVfs`. Resets
+     * first, so the VFS exactly matches the snapshot.
+     */
+    loadVfs(snapshot: any): void;
     /**
      * Create a directory in the virtual filesystem.
      */
@@ -93,6 +116,13 @@ export class SemaInterpreter {
      * Clear all files and directories from the virtual filesystem.
      */
     resetVFS(): void;
+    /**
+     * Install a sink called with each completed output line as it is produced,
+     * so the Web Worker can stream `println` output to the main thread live
+     * (a long-running / sleeping program shows output as it happens). Pass a
+     * JS function `(line: string) => void`.
+     */
+    setOutputSink(sink: Function): void;
     /**
      * Get the Sema version
      */
@@ -133,6 +163,7 @@ export interface InitOutput {
     readonly semainterpreter_debugStepOver: (a: number) => any;
     readonly semainterpreter_debugStop: (a: number) => void;
     readonly semainterpreter_deleteFile: (a: number, b: number, c: number) => number;
+    readonly semainterpreter_dumpVfs: (a: number) => any;
     readonly semainterpreter_eval: (a: number, b: number, c: number) => any;
     readonly semainterpreter_evalAsync: (a: number, b: number, c: number) => any;
     readonly semainterpreter_evalGlobal: (a: number, b: number, c: number) => any;
@@ -140,22 +171,25 @@ export interface InitOutput {
     readonly semainterpreter_evalVMAsync: (a: number, b: number, c: number) => any;
     readonly semainterpreter_fileExists: (a: number, b: number, c: number) => number;
     readonly semainterpreter_getValidBreakpointLines: (a: number, b: number, c: number) => any;
+    readonly semainterpreter_installAtomicsSleep: (a: number, b: any) => void;
     readonly semainterpreter_isDirectory: (a: number, b: number, c: number) => number;
     readonly semainterpreter_listFiles: (a: number, b: number, c: number) => any;
+    readonly semainterpreter_loadVfs: (a: number, b: any) => void;
     readonly semainterpreter_mkdir: (a: number, b: number, c: number) => void;
     readonly semainterpreter_new: () => number;
     readonly semainterpreter_preloadModule: (a: number, b: number, c: number, d: number, e: number) => any;
     readonly semainterpreter_readFile: (a: number, b: number, c: number) => any;
     readonly semainterpreter_registerFunction: (a: number, b: number, c: number, d: any) => void;
     readonly semainterpreter_resetVFS: (a: number) => void;
+    readonly semainterpreter_setOutputSink: (a: number, b: any) => void;
     readonly semainterpreter_version: (a: number) => [number, number];
     readonly semainterpreter_vfsStats: (a: number) => any;
     readonly semainterpreter_writeFile: (a: number, b: number, c: number, d: number, e: number) => any;
-    readonly wasm_bindgen__closure__destroy__h19edff4739fe5c6d: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__he66a5a361c9d594c: (a: number, b: number) => void;
     readonly wasm_bindgen__closure__destroy__h9d93f7a1700d9cb1: (a: number, b: number) => void;
     readonly wasm_bindgen__convert__closures_____invoke__h657571cdcabda118: (a: number, b: number, c: any) => [number, number];
     readonly wasm_bindgen__convert__closures_____invoke__h11cf443fa67993f6: (a: number, b: number, c: any, d: any) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__hf46ac06c62dffa73: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h570a435bff50d28f: (a: number, b: number) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;

package/sema_wasm.js

@@ -130,6 +130,17 @@ export class SemaInterpreter {
         const ret = wasm.semainterpreter_deleteFile(this.__wbg_ptr, ptr0, len0);
         return ret !== 0;
     }
+    /**
+     * Snapshot the entire VFS as a plain JS object `{ files: {path: content},
+     * dirs: [path] }` — structured-clonable across `postMessage`. Used by the
+     * playground to mirror the worker's VFS back to the main thread after each
+     * eval (and to seed the worker before one). See `loadVfs`.
+     * @returns {any}
+     */
+    dumpVfs() {
+        const ret = wasm.semainterpreter_dumpVfs(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Evaluate code, returns JSON: {"value": "...", "output": ["...", ...], "error": null}
      * or {"value": null, "output": [...], "error": "..."}
@@ -143,7 +154,8 @@ export class SemaInterpreter {
         return ret;
     }
     /**
-     * Evaluate code with async HTTP support (tree-walker, global env)
+     * Evaluate code with async HTTP support in the persistent global env
+     * (top-level defines persist across calls). Runs on the bytecode VM.
      * @param {string} code
      * @returns {Promise<any>}
      */
@@ -209,6 +221,19 @@ export class SemaInterpreter {
         const ret = wasm.semainterpreter_getValidBreakpointLines(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * Enable real wall-clock `async/sleep` via `Atomics.wait` on the given
+     * control buffer. Call this once from a Web Worker (where blocking is
+     * allowed), passing an `Int32Array` over a `SharedArrayBuffer` shared with
+     * the main thread. After this, the scheduler's virtual-clock advances also
+     * block the worker for the real duration. Do NOT call on the main thread —
+     * `Atomics.wait` is illegal there; leaving it uninstalled keeps the
+     * instant virtual-clock behavior.
+     * @param {Int32Array} view
+     */
+    installAtomicsSleep(view) {
+        wasm.semainterpreter_installAtomicsSleep(this.__wbg_ptr, view);
+    }
     /**
      * Check if a path is a directory in the virtual filesystem.
      * @param {string} path
@@ -231,6 +256,14 @@ export class SemaInterpreter {
         const ret = wasm.semainterpreter_listFiles(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * Replace the entire VFS from a snapshot produced by `dumpVfs`. Resets
+     * first, so the VFS exactly matches the snapshot.
+     * @param {any} snapshot
+     */
+    loadVfs(snapshot) {
+        wasm.semainterpreter_loadVfs(this.__wbg_ptr, snapshot);
+    }
     /**
      * Create a directory in the virtual filesystem.
      * @param {string} path
@@ -287,6 +320,16 @@ export class SemaInterpreter {
     resetVFS() {
         wasm.semainterpreter_resetVFS(this.__wbg_ptr);
     }
+    /**
+     * Install a sink called with each completed output line as it is produced,
+     * so the Web Worker can stream `println` output to the main thread live
+     * (a long-running / sleeping program shows output as it happens). Pass a
+     * JS function `(line: string) => void`.
+     * @param {Function} sink
+     */
+    setOutputSink(sink) {
+        wasm.semainterpreter_setOutputSink(this.__wbg_ptr, sink);
+    }
     /**
      * Get the Sema version
      * @returns {string}
@@ -423,6 +466,13 @@ function __wbg_get_imports() {
             const ret = arg0.fetch(arg1);
             return ret;
         },
+        __wbg_getAllResponseHeaders_0d155233eff8d5a4: function() { return handleError(function (arg0, arg1) {
+            const ret = arg1.getAllResponseHeaders();
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
         __wbg_getRandomValues_76dfc69825c9c552: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
@@ -485,10 +535,18 @@ function __wbg_get_imports() {
             const ret = Symbol.iterator;
             return ret;
         },
+        __wbg_keys_ab0d051a1c55236d: function(arg0) {
+            const ret = Object.keys(arg0);
+            return ret;
+        },
         __wbg_length_b3416cf66a5452c8: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_load_d8bce92127bf3f7d: function() { return handleError(function (arg0, arg1) {
+            const ret = Atomics.load(arg0, arg1 >>> 0);
+            return ret;
+        }, arguments); },
         __wbg_new_0_1dcafdf5e786e876: function() {
             const ret = new Date();
             return ret;
@@ -505,6 +563,10 @@ function __wbg_get_imports() {
             const ret = new AbortController();
             return ret;
         }, arguments); },
+        __wbg_new_cb1d07f18f0aae72: function() { return handleError(function () {
+            const ret = new XMLHttpRequest();
+            return ret;
+        }, arguments); },
         __wbg_new_typed_aaaeaf29cf802876: function(arg0, arg1) {
             try {
                 var state0 = {a: arg0, b: arg1};
@@ -539,6 +601,9 @@ function __wbg_get_imports() {
             const ret = Date.now();
             return ret;
         },
+        __wbg_open_ab5f9641f561c051: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), arg5 !== 0);
+        }, arguments); },
         __wbg_parse_e9eddd2a82c706eb: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
@@ -558,6 +623,22 @@ function __wbg_get_imports() {
             const ret = Promise.resolve(arg0);
             return ret;
         },
+        __wbg_responseText_3ee457c31fe90e0e: function() { return handleError(function (arg0, arg1) {
+            const ret = arg1.responseText;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_send_442fe07c698a9f29: function() { return handleError(function (arg0) {
+            arg0.send();
+        }, arguments); },
+        __wbg_send_7aad46f9e0f7ecca: function() { return handleError(function (arg0, arg1, arg2) {
+            arg0.send(arg1 === 0 ? undefined : getStringFromWasm0(arg1, arg2));
+        }, arguments); },
+        __wbg_setRequestHeader_4d392f8eb9f8a78b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.setRequestHeader(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
         __wbg_setTimeout_7f7035ad0b026458: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.setTimeout(arg1, arg2);
             return ret;
@@ -605,6 +686,10 @@ function __wbg_get_imports() {
             const ret = arg0.status;
             return ret;
         },
+        __wbg_status_d5251b0ac97c56d5: function() { return handleError(function (arg0) {
+            const ret = arg0.status;
+            return ret;
+        }, arguments); },
         __wbg_stringify_5ae93966a84901ac: function() { return handleError(function (arg0) {
             const ret = JSON.stringify(arg0);
             return ret;
@@ -625,13 +710,17 @@ function __wbg_get_imports() {
             const ret = arg0.value;
             return ret;
         },
+        __wbg_wait_764625a35886f35b: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = Atomics.wait(arg0, arg1 >>> 0, arg2, arg3);
+            return ret;
+        }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1654, function: Function { arguments: [], shim_idx: 1655, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h19edff4739fe5c6d, wasm_bindgen__convert__closures_____invoke__hf46ac06c62dffa73);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1580, function: Function { arguments: [], shim_idx: 1581, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__he66a5a361c9d594c, wasm_bindgen__convert__closures_____invoke__h570a435bff50d28f);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1988, function: Function { arguments: [Externref], shim_idx: 1989, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1886, function: Function { arguments: [Externref], shim_idx: 1887, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h9d93f7a1700d9cb1, wasm_bindgen__convert__closures_____invoke__h657571cdcabda118);
             return ret;
         },
@@ -661,8 +750,8 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__hf46ac06c62dffa73(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hf46ac06c62dffa73(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h570a435bff50d28f(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h570a435bff50d28f(arg0, arg1);
 }
 
 function wasm_bindgen__convert__closures_____invoke__h657571cdcabda118(arg0, arg1, arg2) {