woxi-wasm 0.1.0

package/index.d.ts

@@ -0,0 +1,64 @@
+/** One structured output item produced by evaluating a statement. */
+export interface OutputItem {
+  /** Kind of output this item carries. */
+  type:
+    | "text"
+    | "graphics"
+    | "print"
+    | "warning"
+    | "error"
+    | "sound"
+    | "manipulate";
+  /** Textual content (present for text/print/warning/error items). */
+  text?: string;
+  /** SVG markup (present for graphics items and rich text renderings). */
+  svg?: string;
+  /** Base64-encoded audio data (present for sound items). */
+  audio?: string;
+  /** MIME type of the audio data (present for sound items). */
+  mime?: string;
+  /** Label shown next to the audio player (optional on sound items). */
+  label?: string;
+  /** Additional fields (e.g. the Manipulate widget spec). */
+  [key: string]: unknown;
+}
+
+/**
+ * Evaluate one or more Wolfram Language statements and return the combined
+ * output (Print output followed by the final result) as a string.
+ * Evaluation errors are returned as a string starting with "Error: ".
+ */
+export function evaluate(code: string): string;
+
+/** Evaluate all top-level statements and return structured output items. */
+export function evaluateAll(code: string): OutputItem[];
+
+/** Split code into top-level statements (for progressive evaluation). */
+export function splitStatements(code: string): string[];
+
+/** Evaluate a single statement, returning structured output items. */
+export function evaluateStatement(statement: string): OutputItem[];
+
+/** SVG graphics captured by the last evaluate() call ("" when none). */
+export function getGraphics(): string;
+
+/** Base64-encoded audio captured by the last evaluate() call ("" when none). */
+export function getSound(): string;
+
+/** Warnings emitted by the last evaluate() call. */
+export function getWarnings(): string[];
+
+/** Clear all interpreter state (variables and function definitions). */
+export function clear(): void;
+
+/** Toggle dark-mode colors for SVG output. */
+export function setDarkMode(enabled: boolean): void;
+
+/** Register an in-memory file so `Import["name"]` can read it. */
+export function setVirtualFile(
+  name: string,
+  data: string | Uint8Array | ArrayBuffer,
+): void;
+
+/** Remove all files registered with setVirtualFile(). */
+export function clearVirtualFiles(): void;

package/index.js

@@ -0,0 +1,174 @@
+// JavaScript wrapper around the Woxi WebAssembly build (see ../src/wasm.rs).
+//
+// The generated bindings in pkg/ (built by `make npm-build` in the repo
+// root) expose the raw wasm-bindgen functions. This module adds:
+//
+// - camelCase names and JSON parsing for the structured APIs
+// - a Node implementation of the `__woxi_fetch_url` host hook, so
+//   `Import["https://..."]` works out of the box
+// - panic recovery: a Rust panic leaves the wasm instance unusable, so the
+//   wrapper converts it into a JS Error carrying the panic message and
+//   transparently loads a fresh instance on the next call
+
+"use strict"
+
+const path = require("node:path")
+
+const PKG_ENTRY = path.join(__dirname, "pkg", "woxi.js")
+
+let lastPanicMessage = null
+
+// Host hook called by the wasm panic hook right before the trap fires.
+if (typeof globalThis.__woxi_report_panic !== "function") {
+  globalThis.__woxi_report_panic = (msg) => {
+    lastPanicMessage = msg
+  }
+}
+
+// Host hook used by `Import["https://..."]`: fetch a URL synchronously and
+// return its body base64-encoded. The wasm side is fully synchronous, so we
+// shell out to a child Node process that performs the async fetch.
+if (typeof globalThis.__woxi_fetch_url !== "function") {
+  globalThis.__woxi_fetch_url = (url) => {
+    const { execFileSync } = require("node:child_process")
+    const script = `
+      fetch(process.argv[1])
+        .then((res) => {
+          if (!res.ok) throw new Error("HTTP status " + res.status)
+          return res.arrayBuffer()
+        })
+        .then((buf) => process.stdout.write(Buffer.from(buf).toString("base64")))
+        .catch((err) => { process.stderr.write(String(err.message || err)); process.exit(1) })
+    `
+    try {
+      return execFileSync(process.execPath, ["-e", script, url], {
+        encoding: "utf8",
+        maxBuffer: 512 * 1024 * 1024,
+      })
+    } catch (err) {
+      const stderr = err.stderr ? String(err.stderr).trim() : ""
+      throw new Error(stderr || `failed to fetch ${url}`)
+    }
+  }
+}
+
+let wasm = null
+
+function getWasm() {
+  if (wasm === null) {
+    // Drop stale copies from the require cache so that a reload after a
+    // panic instantiates a fresh wasm instance instead of the broken one.
+    delete require.cache[require.resolve(PKG_ENTRY)]
+    wasm = require(PKG_ENTRY)
+  }
+  return wasm
+}
+
+// Run a raw wasm call, translating a Rust panic (which surfaces as a
+// WebAssembly "unreachable" RuntimeError) into a descriptive JS Error and
+// discarding the now-broken instance.
+function guarded(fn) {
+  lastPanicMessage = null
+  try {
+    return fn(getWasm())
+  } catch (err) {
+    if (lastPanicMessage !== null) {
+      wasm = null // instance is poisoned - reload lazily on the next call
+      throw new Error(`Woxi crashed while evaluating: ${lastPanicMessage}`, {
+        cause: err,
+      })
+    }
+    throw err
+  }
+}
+
+/**
+ * Evaluate one or more Wolfram Language statements and return the combined
+ * output (Print output followed by the final result) as a string.
+ */
+function evaluate(code) {
+  return guarded((w) => w.evaluate(code))
+}
+
+/**
+ * Evaluate all top-level statements and return structured output items
+ * ({type: "text" | "graphics" | "print" | "warning" | "error" | ...}).
+ */
+function evaluateAll(code) {
+  return JSON.parse(guarded((w) => w.evaluate_all(code)))
+}
+
+/** Split code into top-level statements (for progressive evaluation). */
+function splitStatements(code) {
+  return JSON.parse(guarded((w) => w.split_statements(code)))
+}
+
+/** Evaluate a single statement, returning structured output items. */
+function evaluateStatement(statement) {
+  return JSON.parse(guarded((w) => w.evaluate_statement(statement)))
+}
+
+/** SVG graphics captured by the last evaluate() call ("" when none). */
+function getGraphics() {
+  return guarded((w) => w.get_graphics())
+}
+
+/** Base64-encoded audio captured by the last evaluate() call ("" when none). */
+function getSound() {
+  return guarded((w) => w.get_sound())
+}
+
+/** Warnings emitted by the last evaluate() call. */
+function getWarnings() {
+  const text = guarded((w) => w.get_warnings())
+  return text === "" ? [] : text.split("\n")
+}
+
+/** Clear all interpreter state (variables and function definitions). */
+function clear() {
+  guarded((w) => w.clear())
+}
+
+/** Toggle dark-mode colors for SVG output. */
+function setDarkMode(enabled) {
+  guarded((w) => w.set_dark_mode(enabled))
+}
+
+/**
+ * Register an in-memory file so `Import["name"]` can read it. `data` may be
+ * a string, Buffer, Uint8Array, or ArrayBuffer.
+ */
+function setVirtualFile(name, data) {
+  let bytes
+  if (typeof data === "string") {
+    bytes = new TextEncoder().encode(data)
+  } else if (data instanceof Uint8Array) {
+    bytes = data
+  } else if (data instanceof ArrayBuffer) {
+    bytes = new Uint8Array(data)
+  } else {
+    throw new TypeError(
+      "setVirtualFile data must be a string, Uint8Array, Buffer, or ArrayBuffer",
+    )
+  }
+  guarded((w) => w.set_virtual_file(name, bytes))
+}
+
+/** Remove all files registered with setVirtualFile(). */
+function clearVirtualFiles() {
+  guarded((w) => w.clear_virtual_files())
+}
+
+module.exports = {
+  evaluate,
+  evaluateAll,
+  splitStatements,
+  evaluateStatement,
+  getGraphics,
+  getSound,
+  getWarnings,
+  clear,
+  setDarkMode,
+  setVirtualFile,
+  clearVirtualFiles,
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "woxi-wasm",
+  "version": "0.1.0",
+  "description": "Interpreter for a subset of the Wolfram Language, compiled to WebAssembly",
+  "keywords": [
+    "wolfram",
+    "wolfram-language",
+    "mathematica",
+    "cas",
+    "math",
+    "interpreter",
+    "wasm"
+  ],
+  "license": "AGPL-3.0-or-later",
+  "author": "Adrian Sieber",
+  "homepage": "https://woxi.ad-si.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ad-si/Woxi.git",
+    "directory": "npm"
+  },
+  "bugs": {
+    "url": "https://github.com/ad-si/Woxi/issues"
+  },
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "pkg/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "make -C .. npm-build",
+    "test": "node --test",
+    "prepublishOnly": "node -e \"require('./pkg/woxi.js')\" || (echo 'pkg/ is missing - run `make npm-build` in the repo root first' && exit 1)"
+  }
+}

package/pkg/woxi.d.ts

@@ -0,0 +1,111 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Render a Manipulate body, its extra display elements, and any pending
+ * interactive write-backs in one call. Used by widgets that have display
+ * elements (e.g. a `Checkbox` grid) that both read and rewrite shared
+ * state.
+ *
+ * `displays_json` and `mutations_json` are JSON string arrays. Each
+ * mutation is an assignment (e.g. `data[[3, 5]] = 1`) applied before the
+ * re-render; the updated value of every mutated variable is returned under
+ * `state` so the frontend can keep its binding set in sync.
+ *
+ * The result is `{"output":{svg|text|textSvg}, "displays":[<tree>…],
+ * "state":{name:value,…}}`.
+ */
+export function evaluate_manipulate_full(body: string, displays_json: string, bindings_json: string, mutations_json: string): string;
+/**
+ * Register (or replace) an in-memory file so `Import["name"]` can read it
+ * in the browser.
+ */
+export function set_virtual_file(name: string, data: Uint8Array): void;
+/**
+ * Return the captured SVG graphics from the last `evaluate()` call, if any.
+ * Returns an empty string when there is no graphics output.
+ */
+export function get_graphics(): string;
+/**
+ * Evaluate all top-level statements and return a JSON array of output items.
+ * Each item has a "type" field ("text", "graphics", "print", "warning", "error",
+ * "manipulate") and corresponding content fields.
+ */
+export function evaluate_all(input: string): string;
+/**
+ * Evaluate a single statement and return a JSON array of output items
+ * (same shape as `evaluate_all`'s elements). Use together with
+ * `split_statements` for progressive output.
+ */
+export function evaluate_statement(stmt: string): string;
+/**
+ * Split `input` into top-level statements and return a JSON array of strings.
+ * Lets the front-end loop one statement at a time so output (and side
+ * effects like `Pause[n]`) appear progressively rather than batched.
+ */
+export function split_statements(input: string): string;
+/**
+ * Remove all host-registered in-memory files.
+ */
+export function clear_virtual_files(): void;
+/**
+ * Evaluate a Manipulate body with a specific set of variable bindings
+ * and return a single JSON output item representing the result.
+ *
+ * `body` must be the body expression in InputForm (as produced by
+ * `evaluate_all`'s manipulate item). `bindings_json` must be a JSON
+ * object mapping variable names to InputForm-serialized values, e.g.
+ * `{"a": "1.5", "b": "\"foo\""}`.
+ *
+ * The result is a JSON object of the same shape as `initial` from
+ * the evaluate_all manipulate item: `{"svg": "...", "text": "..."}`.
+ */
+export function evaluate_manipulate(body: string, bindings_json: string): string;
+/**
+ * Evaluate, returning only the final expression result (no Print output).
+ */
+export function evaluate_expr(input: string): string;
+/**
+ * Return SVG rendering of the last text result (with superscripts etc.).
+ * Returns an empty string when there is no output SVG (e.g. for Graphics results).
+ */
+export function get_output_svg(): string;
+/**
+ * Enable or disable dark mode for SVG output colors.
+ */
+export function set_dark_mode(enabled: boolean): void;
+/**
+ * Evaluate a Wolfram Language expression and return the result.
+ * If the expression produces Print output, it is prepended to the result.
+ */
+export function evaluate(input: string): string;
+/**
+ * Return warnings from the last `evaluate()` call as newline-separated text.
+ * Returns an empty string when there are no warnings.
+ */
+export function get_warnings(): string;
+/**
+ * Return the playable audio (base64-encoded) from the last `evaluate()`
+ * call, if any. Returns an empty string when there is no sound.
+ */
+export function get_sound(): string;
+/**
+ * Clear all interpreter state (variables and function definitions).
+ */
+export function clear(): void;
+export function init(): void;
+/**
+ * Evaluate each Manipulate control's `Enabled` condition against a binding
+ * set and return a JSON array of booleans (one per control, in order).
+ *
+ * `conditions_json` is a JSON string array aligned with the control list;
+ * an empty string marks a control with no condition (always enabled).
+ * `bindings_json` is the same JSON object of variable bindings used by
+ * `evaluate_manipulate`. Used by the Playground to grey out controls that a
+ * `Enabled -> Dynamic[…]` option has switched off for the current state.
+ */
+export function evaluate_manipulate_enabled(conditions_json: string, bindings_json: string): string;
+/**
+ * Return the captured GraphicsBox expression from the last `evaluate()` call.
+ * Returns an empty string when there is no graphics output.
+ */
+export function get_graphicsbox(): string;

package/pkg/woxi.js

@@ -0,0 +1,858 @@
+
+let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+/**
+ * Render a Manipulate body, its extra display elements, and any pending
+ * interactive write-backs in one call. Used by widgets that have display
+ * elements (e.g. a `Checkbox` grid) that both read and rewrite shared
+ * state.
+ *
+ * `displays_json` and `mutations_json` are JSON string arrays. Each
+ * mutation is an assignment (e.g. `data[[3, 5]] = 1`) applied before the
+ * re-render; the updated value of every mutated variable is returned under
+ * `state` so the frontend can keep its binding set in sync.
+ *
+ * The result is `{"output":{svg|text|textSvg}, "displays":[<tree>…],
+ * "state":{name:value,…}}`.
+ * @param {string} body
+ * @param {string} displays_json
+ * @param {string} bindings_json
+ * @param {string} mutations_json
+ * @returns {string}
+ */
+exports.evaluate_manipulate_full = function(body, displays_json, bindings_json, mutations_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(body, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(displays_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(mutations_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.evaluate_manipulate_full(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        deferred5_0 = ret[0];
+        deferred5_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+};
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+ * Register (or replace) an in-memory file so `Import["name"]` can read it
+ * in the browser.
+ * @param {string} name
+ * @param {Uint8Array} data
+ */
+exports.set_virtual_file = function(name, data) {
+    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    wasm.set_virtual_file(ptr0, len0, ptr1, len1);
+};
+
+/**
+ * Return the captured SVG graphics from the last `evaluate()` call, if any.
+ * Returns an empty string when there is no graphics output.
+ * @returns {string}
+ */
+exports.get_graphics = function() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.get_graphics();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+};
+
+/**
+ * Evaluate all top-level statements and return a JSON array of output items.
+ * Each item has a "type" field ("text", "graphics", "print", "warning", "error",
+ * "manipulate") and corresponding content fields.
+ * @param {string} input
+ * @returns {string}
+ */
+exports.evaluate_all = function(input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.evaluate_all(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+};
+
+/**
+ * Evaluate a single statement and return a JSON array of output items
+ * (same shape as `evaluate_all`'s elements). Use together with
+ * `split_statements` for progressive output.
+ * @param {string} stmt
+ * @returns {string}
+ */
+exports.evaluate_statement = function(stmt) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(stmt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.evaluate_statement(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+};
+
+/**
+ * Split `input` into top-level statements and return a JSON array of strings.
+ * Lets the front-end loop one statement at a time so output (and side
+ * effects like `Pause[n]`) appear progressively rather than batched.
+ * @param {string} input
+ * @returns {string}
+ */
+exports.split_statements = function(input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.split_statements(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+};
+
+/**
+ * Remove all host-registered in-memory files.
+ */
+exports.clear_virtual_files = function() {
+    wasm.clear_virtual_files();
+};
+
+/**
+ * Evaluate a Manipulate body with a specific set of variable bindings
+ * and return a single JSON output item representing the result.
+ *
+ * `body` must be the body expression in InputForm (as produced by
+ * `evaluate_all`'s manipulate item). `bindings_json` must be a JSON
+ * object mapping variable names to InputForm-serialized values, e.g.
+ * `{"a": "1.5", "b": "\"foo\""}`.
+ *
+ * The result is a JSON object of the same shape as `initial` from
+ * the evaluate_all manipulate item: `{"svg": "...", "text": "..."}`.
+ * @param {string} body
+ * @param {string} bindings_json
+ * @returns {string}
+ */
+exports.evaluate_manipulate = function(body, bindings_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(body, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.evaluate_manipulate(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+};
+
+/**
+ * Evaluate, returning only the final expression result (no Print output).
+ * @param {string} input
+ * @returns {string}
+ */
+exports.evaluate_expr = function(input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.evaluate_expr(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+};
+
+/**
+ * Return SVG rendering of the last text result (with superscripts etc.).
+ * Returns an empty string when there is no output SVG (e.g. for Graphics results).
+ * @returns {string}
+ */
+exports.get_output_svg = function() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.get_output_svg();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+};
+
+/**
+ * Enable or disable dark mode for SVG output colors.
+ * @param {boolean} enabled
+ */
+exports.set_dark_mode = function(enabled) {
+    wasm.set_dark_mode(enabled);
+};
+
+/**
+ * Evaluate a Wolfram Language expression and return the result.
+ * If the expression produces Print output, it is prepended to the result.
+ * @param {string} input
+ * @returns {string}
+ */
+exports.evaluate = function(input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.evaluate(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+};
+
+/**
+ * Return warnings from the last `evaluate()` call as newline-separated text.
+ * Returns an empty string when there are no warnings.
+ * @returns {string}
+ */
+exports.get_warnings = function() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.get_warnings();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+};
+
+/**
+ * Return the playable audio (base64-encoded) from the last `evaluate()`
+ * call, if any. Returns an empty string when there is no sound.
+ * @returns {string}
+ */
+exports.get_sound = function() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.get_sound();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+};
+
+/**
+ * Clear all interpreter state (variables and function definitions).
+ */
+exports.clear = function() {
+    wasm.clear();
+};
+
+exports.init = function() {
+    wasm.init();
+};
+
+/**
+ * Evaluate each Manipulate control's `Enabled` condition against a binding
+ * set and return a JSON array of booleans (one per control, in order).
+ *
+ * `conditions_json` is a JSON string array aligned with the control list;
+ * an empty string marks a control with no condition (always enabled).
+ * `bindings_json` is the same JSON object of variable bindings used by
+ * `evaluate_manipulate`. Used by the Playground to grey out controls that a
+ * `Enabled -> Dynamic[…]` option has switched off for the current state.
+ * @param {string} conditions_json
+ * @param {string} bindings_json
+ * @returns {string}
+ */
+exports.evaluate_manipulate_enabled = function(conditions_json, bindings_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(conditions_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.evaluate_manipulate_enabled(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+};
+
+/**
+ * Return the captured GraphicsBox expression from the last `evaluate()` call.
+ * Returns an empty string when there is no graphics output.
+ * @returns {string}
+ */
+exports.get_graphicsbox = function() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.get_graphicsbox();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+};
+
+exports.__wbg___wbindgen_debug_string_df47ffb5e35e6763 = function(arg0, arg1) {
+    const ret = debugString(arg1);
+    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);
+};
+
+exports.__wbg___wbindgen_is_function_ee8a6c5833c90377 = function(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_object_c818261d21f283a4 = function(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_string_fbb76cb2940daafd = function(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_undefined_2d472862bd29a478 = function(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+};
+
+exports.__wbg___wbindgen_throw_b855445ff6a94295 = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+exports.__wbg___woxi_fetch_url_b456f49aff4e3138 = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = __woxi_fetch_url(getStringFromWasm0(arg1, arg2));
+    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) };
+
+exports.__wbg___woxi_report_panic_13444e27f27ce1cd = function() { return handleError(function (arg0, arg1) {
+    __woxi_report_panic(getStringFromWasm0(arg0, arg1));
+}, arguments) };
+
+exports.__wbg_append_ed363d026656dfbd = function() { return handleError(function (arg0, arg1) {
+    arg0.append(arg1);
+}, arguments) };
+
+exports.__wbg_body_8c26b54829a0c4cb = function(arg0) {
+    const ret = arg0.body;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_call_525440f72fbfc0ea = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments) };
+
+exports.__wbg_call_e762c39fa8ea36bf = function() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+}, arguments) };
+
+exports.__wbg_createElement_964ab674a0176cd8 = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.createElement(getStringFromWasm0(arg1, arg2));
+    return ret;
+}, arguments) };
+
+exports.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
+    const ret = arg0.crypto;
+    return ret;
+};
+
+exports.__wbg_document_725ae06eb442a6db = function(arg0) {
+    const ret = arg0.document;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+};
+
+exports.__wbg_getDate_5a70d2f6a482d99f = function(arg0) {
+    const ret = arg0.getDate();
+    return ret;
+};
+
+exports.__wbg_getFullYear_8240d5a15191feae = function(arg0) {
+    const ret = arg0.getFullYear();
+    return ret;
+};
+
+exports.__wbg_getHours_5e476e0b9ebc42d1 = function(arg0) {
+    const ret = arg0.getHours();
+    return ret;
+};
+
+exports.__wbg_getMilliseconds_9fc7184d90e04a16 = function(arg0) {
+    const ret = arg0.getMilliseconds();
+    return ret;
+};
+
+exports.__wbg_getMinutes_c95dfb65f1ea8f02 = function(arg0) {
+    const ret = arg0.getMinutes();
+    return ret;
+};
+
+exports.__wbg_getMonth_25c1c5a601d72773 = function(arg0) {
+    const ret = arg0.getMonth();
+    return ret;
+};
+
+exports.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
+    arg0.getRandomValues(arg1);
+}, arguments) };
+
+exports.__wbg_getSeconds_8113bf8709718eb2 = function(arg0) {
+    const ret = arg0.getSeconds();
+    return ret;
+};
+
+exports.__wbg_getTime_14776bfb48a1bff9 = function(arg0) {
+    const ret = arg0.getTime();
+    return ret;
+};
+
+exports.__wbg_getTimezoneOffset_d391cb11d54969f8 = function(arg0) {
+    const ret = arg0.getTimezoneOffset();
+    return ret;
+};
+
+exports.__wbg_instanceof_HtmlElement_e20a729df22f9e1c = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof HTMLElement;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+exports.__wbg_instanceof_Window_4846dbb3de56c84c = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Window;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+exports.__wbg_length_69bca3cb64fc8748 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+exports.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
+    const ret = arg0.msCrypto;
+    return ret;
+};
+
+exports.__wbg_new_0_f9740686d739025c = function() {
+    const ret = new Date();
+    return ret;
+};
+
+exports.__wbg_new_8a6f238a6ece86ea = function() {
+    const ret = new Error();
+    return ret;
+};
+
+exports.__wbg_new_93d9417ed3fb115d = function(arg0) {
+    const ret = new Date(arg0);
+    return ret;
+};
+
+exports.__wbg_new_no_args_ee98eee5275000a4 = function(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+exports.__wbg_new_with_length_01aa0dc35aa13543 = function(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+};
+
+exports.__wbg_new_with_year_month_day_6236812cf591750d = function(arg0, arg1, arg2) {
+    const ret = new Date(arg0 >>> 0, arg1, arg2);
+    return ret;
+};
+
+exports.__wbg_node_905d3e251edff8a2 = function(arg0) {
+    const ret = arg0.node;
+    return ret;
+};
+
+exports.__wbg_now_2c95c9de01293173 = function(arg0) {
+    const ret = arg0.now();
+    return ret;
+};
+
+exports.__wbg_now_793306c526e2e3b6 = function() {
+    const ret = Date.now();
+    return ret;
+};
+
+exports.__wbg_offsetHeight_9cb4257b24361e2a = function(arg0) {
+    const ret = arg0.offsetHeight;
+    return ret;
+};
+
+exports.__wbg_offsetWidth_16b33c540f3e9ddb = function(arg0) {
+    const ret = arg0.offsetWidth;
+    return ret;
+};
+
+exports.__wbg_performance_7a3ffd0b17f663ad = function(arg0) {
+    const ret = arg0.performance;
+    return ret;
+};
+
+exports.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
+    const ret = arg0.process;
+    return ret;
+};
+
+exports.__wbg_prototypesetcall_2a6620b6922694b2 = function(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+};
+
+exports.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
+    arg0.randomFillSync(arg1);
+}, arguments) };
+
+exports.__wbg_remove_4ba46706a8e17d9d = function(arg0) {
+    arg0.remove();
+};
+
+exports.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {
+    const ret = module.require;
+    return ret;
+}, arguments) };
+
+exports.__wbg_setAttribute_9bad76f39609daac = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    arg0.setAttribute(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+}, arguments) };
+
+exports.__wbg_set_textContent_12af0b0f84feb710 = function(arg0, arg1, arg2) {
+    arg0.textContent = arg1 === 0 ? undefined : getStringFromWasm0(arg1, arg2);
+};
+
+exports.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+    const ret = arg1.stack;
+    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);
+};
+
+exports.__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e = function() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac = function() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_static_accessor_SELF_6fdf4b64710cc91b = function() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2 = function() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_subarray_480600f3d6a9f26c = function(arg0, arg1, arg2) {
+    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+    return ret;
+};
+
+exports.__wbg_versions_c01dfd4722a88165 = function(arg0) {
+    const ret = arg0.versions;
+    return ret;
+};
+
+exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+exports.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return ret;
+};
+
+exports.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+};
+
+exports.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+
+const wasmPath = `${__dirname}/woxi_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+const wasm = exports.__wasm = new WebAssembly.Instance(wasmModule, imports).exports;
+
+wasm.__wbindgen_start();
+

package/pkg/woxi_bg.wasm.d.ts

@@ -0,0 +1,28 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const clear_virtual_files: () => void;
+export const evaluate: (a: number, b: number) => [number, number];
+export const evaluate_all: (a: number, b: number) => [number, number];
+export const evaluate_expr: (a: number, b: number) => [number, number];
+export const evaluate_manipulate: (a: number, b: number, c: number, d: number) => [number, number];
+export const evaluate_manipulate_enabled: (a: number, b: number, c: number, d: number) => [number, number];
+export const evaluate_manipulate_full: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+export const evaluate_statement: (a: number, b: number) => [number, number];
+export const get_graphics: () => [number, number];
+export const get_graphicsbox: () => [number, number];
+export const get_output_svg: () => [number, number];
+export const get_sound: () => [number, number];
+export const get_warnings: () => [number, number];
+export const set_dark_mode: (a: number) => void;
+export const set_virtual_file: (a: number, b: number, c: number, d: number) => void;
+export const split_statements: (a: number, b: number) => [number, number];
+export const clear: () => void;
+export const init: () => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/readme.md

@@ -0,0 +1,111 @@
+# Woxi
+
+An interpreter for a subset of the
+[Wolfram Language](https://www.wolfram.com/language/)
+powered by Rust and compiled to WebAssembly.
+
+This package wraps the [Woxi](https://github.com/ad-si/Woxi) interpreter
+so it can be used from Node.js — no Wolfram installation required.
+Woxi is a computer algebra system (CAS): computations are solved symbolically.
+
+
+## Installation
+
+```sh
+npm install woxi-wasm
+```
+
+(The package is named `woxi-wasm` because the name `woxi` is not
+available on npm.)
+
+
+## Usage
+
+```js
+import { evaluate } from "woxi-wasm"
+
+evaluate("Plus[1, 2]")        //=> "3"
+evaluate("1/3 + 1/6")         //=> "1/2"
+evaluate("Sqrt[8]")           //=> "2*Sqrt[2]"
+evaluate('StringReverse["hello"]')  //=> "olleh"
+```
+
+CommonJS works too:
+
+```js
+const { evaluate } = require("woxi-wasm")
+```
+
+Interpreter state (variables, function definitions) persists across calls:
+
+```js
+import woxi from "woxi-wasm"
+
+woxi.evaluate("f[x_] := x^2")
+woxi.evaluate("f[5]")  //=> "25"
+woxi.clear()           // reset all state
+```
+
+
+### Structured output
+
+`evaluateAll` returns one item per output, including graphics as SVG:
+
+```js
+const items = woxi.evaluateAll('Print["hi"]\nGraphics[{Disk[]}]')
+//=> [
+//     { type: "print", text: "hi" },
+//     { type: "graphics", svg: "<svg …" },
+//   ]
+```
+
+Item types: `text`, `print`, `graphics`, `warning`, `error`, `sound`,
+and `manipulate`.
+
+
+### Virtual files
+
+There is no filesystem access from WebAssembly, so `Import[…]` reads from
+an in-memory store you populate first:
+
+```js
+woxi.setVirtualFile("data.csv", "a,b\n1,2\n")
+woxi.evaluate('Import["data.csv"]')  //=> "{{a, b}, {1, 2}}"
+```
+
+`Import["https://…"]` fetches over HTTP automatically.
+
+
+## API
+
+| Function                     | Description                                       |
+|------------------------------|---------------------------------------------------|
+| `evaluate(code)`             | Evaluate code, return output as a string          |
+| `evaluateAll(code)`          | Evaluate code, return structured output items     |
+| `splitStatements(code)`      | Split code into top-level statements              |
+| `evaluateStatement(stmt)`    | Evaluate a single statement (structured output)   |
+| `getGraphics()`              | SVG captured by the last `evaluate()` call        |
+| `getSound()`                 | Base64 audio captured by the last call            |
+| `getWarnings()`              | Warnings of the last call as an array             |
+| `clear()`                    | Clear all interpreter state                       |
+| `setDarkMode(enabled)`       | Toggle dark-mode colors for SVG output            |
+| `setVirtualFile(name, data)` | Register an in-memory file for `Import[…]`        |
+| `clearVirtualFiles()`        | Remove all registered in-memory files             |
+
+TypeScript definitions are included.
+
+
+## Development
+
+The wasm bundle in `pkg/` is generated from the Rust sources — build it from
+the [repository](https://github.com/ad-si/Woxi) root:
+
+```sh
+make npm-build   # build pkg/ with wasm-pack
+make npm-test    # build + run the JS test suite
+```
+
+
+## License
+
+[AGPL-3.0-or-later](https://github.com/ad-si/Woxi/blob/main/license.txt)