wasm-idle 0.4.1 → 0.5.0

package/README.md

@@ -2,12 +2,80 @@
 
 ![wasm-idle](static/image.jpeg)
 
-Executes C++, Python, and Java code with working stdio.
+Executes C++, Python, Java, and Rust code with working stdio.
 
 Refer to src/lib/clang.
 
 Java uses TeaVM's browser compiler/runtime. TeaVM compiler/runtime/classlib assets are bundled under `static/teavm/` by default, and the asset base URL can be overridden with `PUBLIC_TEAVM_BASE_URL`.
 
+## Rust browser integration
+
+The demo app now bundles a local `wasm-rust` browser compiler under `static/wasm-rust/` and points the example `Terminal` at `/wasm-rust/index.js` by default. Refresh that bundle after rebuilding the sibling `wasm-rust` project with:
+
+```bash
+cd wasm-idle
+pnpm run sync:wasm-rust
+```
+
+The built-in Rust route now supports both `wasm32-wasip1` and `wasm32-wasip2`. The page exposes a
+target selector when Rust is active, defaults to `wasm32-wasip1`, and persists that choice in local
+storage.
+
+## Browser regression commands
+
+Browser-level Rust checks are reproducible from this repo:
+
+```bash
+cd wasm-idle
+pnpm run probe:rust-browser
+pnpm run test:browser:playwright
+
+WASM_IDLE_BROWSER_URL='http://localhost:5173/absproxy/5173/' \
+WASM_IDLE_REUSE_LOCAL_PREVIEW=1 \
+pnpm run probe:rust-browser
+
+WASM_IDLE_RUN_REAL_BROWSER_RUST=1 \
+WASM_IDLE_BROWSER_URL='http://localhost:5173/absproxy/5173/' \
+WASM_IDLE_REUSE_LOCAL_PREVIEW=1 \
+pnpm exec vitest run src/lib/playground/rust.playwright.test.ts
+```
+
+Both commands exercise the real Chromium page path. The default Rust probe now feeds stdin with a
+single line (`5\n`) and expects the page to finish without sending EOF, which keeps the regression
+aligned with the default Rust sample and proves that pressing Enter is enough for line-based stdin.
+Programs that intentionally read stdin until EOF can still be finished with `Ctrl+D` or the toolbar
+`Send EOF` button while the process is running.
+The browser helper writes stdin through the page-owned `window.__wasmIdleDebug.writeTerminalInput(...)`
+hook instead of trying to click xterm's hidden helper textarea, which proved too flaky for repeatable
+Playwright runs.
+If Rust ever reports `invalid metadata files for crate core` or `Unsupported archive identifier`,
+the browser almost always fetched a stale or wrong `wasm-rust` sysroot asset. Hard refresh the page
+and resync `static/wasm-rust/` from the sibling `wasm-rust/dist/`.
+When browser-rustc does retry, it now emits a visible warning instead of only a debug-level
+transition into attempt `2/5`, `3/5`, and so on.
+When the Rust `log` option is enabled, those compile-time `wasm-rust` progress and retry lines are
+also forwarded into the terminal transcript before the final runtime output, so the browser console
+is no longer required to inspect build progress.
+They also resync the vendored `wasm-rust` bundle and rebuild `wasm-idle` first, so the browser run is
+checked against the current assets rather than a stale preview output.
+The probe/test helper also claims a dedicated local preview port by default instead of reusing
+whatever already answers on `localhost`, which keeps the regression target tied to the current build.
+If you point the probe at `dev.seorii.io`, remember that route currently requires an authenticated
+session; the repo-owned regression target is the local preview path above.
+
+## Runtime expectations
+
+Rust still supports an external browser compiler module for library consumers. Point `PUBLIC_WASM_RUST_COMPILER_URL` at a built `wasm-rust` ESM entry such as `.../wasm-rust/dist/index.js`, or pass `runtimeAssets.rust.compilerUrl` at runtime.
+
+The Rust browser path now executes returned artifacts through the target-appropriate runtime inside
+the Rust worker:
+
+- `wasm32-wasip1` runs as preview1 core wasm through `@bjorn3/browser_wasi_shim`
+- `wasm32-wasip2` runs as a preview2 component through `preview2-shim` plus transpiled `jco` output
+
+The generic `src/lib/clang/app.ts` host remains in place for other runtimes, but Rust now delegates
+execution to `wasm-rust` so the selected target and returned artifact format stay aligned.
+
 `Terminal` and `playground(...).load(...)` support either the legacy shared `path`/`rootUrl` or per-runtime asset config:
 
 ```ts
@@ -20,10 +88,33 @@ const runtimeAssets: PlaygroundRuntimeAssets = {
 	},
 	java: {
 		baseUrl: 'https://cdn.example.com/repl/teavm/'
+	},
+	rust: {
+		compilerUrl: 'https://cdn.example.com/wasm-rust/index.js'
 	}
 };
 ```
 
-Python custom loaders receive file names under the Pyodide asset root and can serve both core assets and package files. TeaVM custom loaders receive file names under the TeaVM asset root. Compressed TeaVM runtime assets are no longer unpacked inside the library; provide the final file URL or handle decompression in your own loader.
+Python custom loaders receive file names under the Pyodide asset root and can serve both core assets and package files. TeaVM custom loaders receive file names under the TeaVM asset root. Rust expects a browser-loadable compiler module URL; that module is responsible for serving its own nested runtime assets. Compressed TeaVM runtime assets are no longer unpacked inside the library; provide the final file URL or handle decompression in your own loader.
+
+If you want a host app to reuse the same runtime asset configuration for both `<Terminal>` and direct `playground(...)` access, bind it once:
+
+```ts
+import Terminal, { createPlaygroundBinding } from 'wasm-idle';
+
+const wasmIdle = createPlaygroundBinding({
+	rootUrl: 'https://cdn.example.com/repl',
+	rust: {
+		compilerUrl: 'https://cdn.example.com/wasm-rust/index.js'
+	}
+});
+
+const sandbox = await wasmIdle.load('PYTHON');
+await sandbox.load('print("hi")', false);
+```
+
+```svelte
+<Terminal {...wasmIdle.terminalProps} bind:terminal />
+```
 
-Powered by [wasm-clang](https://github.com/binji/wasm-clang), Pyodide, and TeaVM.
+Powered by [wasm-clang](https://github.com/binji/wasm-clang), Pyodide, TeaVM, and `wasm-rust`.

package/dist/clang/app.d.ts

@@ -3,7 +3,10 @@ import { Memory, type MemFS } from './memory';
 interface DebugSession {
     buffer?: Int32Array;
     interruptBuffer?: Uint8Array;
+    watchBuffer?: Int32Array;
+    watchResultBuffer?: Int32Array;
     breakpoints: Set<number>;
+    breakpointVersion: number;
     pauseOnEntry: boolean;
     stepArmed: boolean;
     nextLineArmed: boolean;
@@ -52,6 +55,7 @@ export default class App {
     constructor(module: WebAssembly.Module, memfs: MemFS, name: string, ...args: string[]);
     run(): Promise<boolean | undefined>;
     proc_exit(code: number): void;
+    debugEvaluate(expression: string): string;
     private pauseDebugSession;
     __wasm_idle_debug_enter(functionId: number, line: number): number;
     __wasm_idle_debug_leave(functionId: number): number;

package/dist/clang/app.js

@@ -2,6 +2,8 @@ import { bindNew } from './apply';
 import { Memory } from './memory';
 import { getInstance } from './wasm';
 import { AbortError, NotImplemented, ProcExit } from './error';
+import { evaluateDebugExpressionWithResolver, parseStoredDebugValue } from '../debug/expression';
+import { flushQueuedStdin, readBufferedStdin } from '../playground/stdinBuffer';
 const ESUCCESS = 0;
 const RAF_PROC_EXIT_CODE = 0xc0c0a;
 export default class App {
@@ -21,11 +23,17 @@ export default class App {
         this.environ = { USER: 'jungol' };
         this.memfs = memfs;
         const env = bindNew(this, '__wasm_idle_debug_enter', '__wasm_idle_debug_leave', '__wasm_idle_debug_line', '__wasm_idle_debug_value_num', '__wasm_idle_debug_value_bool', '__wasm_idle_debug_value_addr', '__wasm_idle_debug_value_text');
-        const wasi_unstable = {
+        const wasi = {
             ...bindNew(this, 'proc_exit', 'environ_sizes_get', 'environ_get', 'args_sizes_get', 'args_get', 'random_get', 'clock_time_get', 'poll_oneoff'),
             ...this.memfs.exports
         };
-        this.ready = getInstance(module, { wasi_unstable, env }).then((instance) => {
+        // Rust/WASI modules import `wasi_snapshot_preview1`, while older toolchains here still use
+        // `wasi_unstable`. Expose the same host under both names so either artifact shape runs.
+        this.ready = getInstance(module, {
+            wasi_unstable: wasi,
+            wasi_snapshot_preview1: wasi,
+            env
+        }).then((instance) => {
             this.instance = instance;
             this.exports = this.instance.exports;
             this.mem = new Memory(this.exports.memory);
@@ -66,8 +74,116 @@ export default class App {
         this.trace('start() returned without proc_exit');
     }
     proc_exit(code) {
+        this.trace(`proc_exit_throw(code=${code})`);
         throw new ProcExit(code);
     }
+    debugEvaluate(expression) {
+        const session = this.debugSession;
+        if (!session)
+            throw new Error('unavailable');
+        const frame = [...session.frames]
+            .reverse()
+            .find((candidate) => candidate.functionId === session.currentFunctionId);
+        const activeLine = session.currentLine;
+        const activeLocals = [...(session.variableMetadata[session.currentFunctionId] || [])]
+            .reverse()
+            .filter((variable) => activeLine >= variable.fromLine && activeLine <= variable.toLine);
+        const activeGlobals = [...(session.globalVariableMetadata || [])]
+            .reverse()
+            .filter((variable) => activeLine >= variable.fromLine && activeLine <= variable.toLine);
+        return evaluateDebugExpressionWithResolver(expression, (name) => {
+            const resolveArrayValue = (variable, addressValue) => {
+                const dimensions = variable.dimensions?.length
+                    ? variable.dimensions
+                    : variable.length
+                        ? [variable.length]
+                        : [];
+                const address = Number(addressValue);
+                if (!Number.isFinite(address) ||
+                    address <= 0 ||
+                    !dimensions.length ||
+                    (!variable.elementKind && !variable.structFields?.length)) {
+                    throw new Error('unavailable');
+                }
+                this.mem?.check?.();
+                const scalarSize = variable.structFields?.length && variable.structSize
+                    ? variable.structSize
+                    : variable.elementKind === 'double'
+                        ? 8
+                        : variable.elementKind === 'bool' || variable.elementKind === 'char'
+                            ? 1
+                            : 4;
+                const readScalar = (kind, offset) => {
+                    if (kind === 'bool')
+                        return !!this.mem.read8(offset);
+                    if (kind === 'char') {
+                        const charCode = this.mem.read8(offset);
+                        return charCode >= 0x20 && charCode <= 0x7e
+                            ? String.fromCharCode(charCode)
+                            : charCode;
+                    }
+                    if (kind === 'float')
+                        return this.mem.readFloat32(offset);
+                    if (kind === 'double')
+                        return this.mem.readFloat64(offset);
+                    return this.mem.readInt32(offset);
+                };
+                const buildStructValue = (baseAddress) => ({
+                    __debugExpressionKind: 'object',
+                    has: (fieldName) => !!variable.structFields?.some((field) => field.name === fieldName),
+                    get: (fieldName) => {
+                        const field = variable.structFields?.find((candidate) => candidate.name === fieldName);
+                        if (!field)
+                            throw new Error('unavailable');
+                        return readScalar(field.kind, baseAddress + field.offset);
+                    },
+                    keys: () => variable.structFields?.map((field) => field.name) || []
+                });
+                const buildArrayValue = (baseAddress, remainingDimensions) => ({
+                    __debugExpressionKind: 'array',
+                    length: remainingDimensions[0],
+                    truncated: remainingDimensions[0] > 8,
+                    get: (index) => {
+                        if (!Number.isInteger(index) ||
+                            index < 0 ||
+                            index >= remainingDimensions[0]) {
+                            throw new Error('unavailable');
+                        }
+                        if (remainingDimensions.length > 1) {
+                            const nestedStride = remainingDimensions
+                                .slice(1)
+                                .reduce((total, size) => total * size, 1) * scalarSize;
+                            return buildArrayValue(baseAddress + index * nestedStride, remainingDimensions.slice(1));
+                        }
+                        if (variable.structFields?.length && variable.structSize) {
+                            return buildStructValue(baseAddress + index * variable.structSize);
+                        }
+                        if (!variable.elementKind)
+                            throw new Error('unavailable');
+                        return readScalar(variable.elementKind, baseAddress + index * scalarSize);
+                    },
+                    keys: () => Array.from({ length: Math.min(remainingDimensions[0], 8) }, (_, index) => index)
+                });
+                return buildArrayValue(address, dimensions);
+            };
+            const resolveVariableValue = (variable, storedValue) => {
+                if (storedValue == null || storedValue === '?')
+                    throw new Error('unavailable');
+                if (variable.kind === 'array')
+                    return resolveArrayValue(variable, storedValue);
+                return parseStoredDebugValue(storedValue);
+            };
+            const localVariable = activeLocals.find((variable) => variable.name === name);
+            if (localVariable) {
+                return resolveVariableValue(localVariable, frame?.values.get(localVariable.slot));
+            }
+            const globalVariable = activeGlobals.find((variable) => variable.name === name);
+            if (globalVariable) {
+                return resolveVariableValue(globalVariable, session.globalValues.get(globalVariable.slot));
+            }
+            throw new Error('unavailable');
+        });
+    }
     pauseDebugSession(session, functionId, line, reason) {
         const buffer = session.buffer;
         if (!buffer)
@@ -98,9 +214,46 @@ export default class App {
                 if (!Number.isFinite(address) ||
                     address <= 0 ||
                     !dimensions.length ||
-                    !variable.elementKind) {
+                    (!variable.elementKind && !variable.structFields?.length)) {
                     return [{ name: variable.name, value: '?' }];
                 }
+                if (variable.structFields?.length && variable.structSize) {
+                    const previewLength = Math.min(dimensions[0], 8);
+                    const values = [];
+                    for (let index = 0; index < previewLength; index += 1) {
+                        const fieldValues = [];
+                        for (const field of variable.structFields) {
+                            const offset = address + index * variable.structSize + field.offset;
+                            if (field.kind === 'bool') {
+                                fieldValues.push(`${field.name}: ${this.mem.read8(offset) ? 'true' : 'false'}`);
+                                continue;
+                            }
+                            if (field.kind === 'char') {
+                                const charCode = this.mem.read8(offset);
+                                fieldValues.push(`${field.name}: ${charCode >= 0x20 && charCode <= 0x7e ? `'${String.fromCharCode(charCode)}'` : `${charCode}`}`);
+                                continue;
+                            }
+                            if (field.kind === 'float') {
+                                fieldValues.push(`${field.name}: ${this.mem.readFloat32(offset)}`);
+                                continue;
+                            }
+                            if (field.kind === 'double') {
+                                fieldValues.push(`${field.name}: ${this.mem.readFloat64(offset)}`);
+                                continue;
+                            }
+                            fieldValues.push(`${field.name}: ${this.mem.readInt32(offset)}`);
+                        }
+                        values.push(`{${fieldValues.join(', ')}}`);
+                    }
+                    return [
+                        {
+                            name: variable.name,
+                            value: `[${values.join(', ')}${dimensions[0] > previewLength ? ', ...' : ''}]`
+                        }
+                    ];
+                }
+                if (!variable.elementKind)
+                    return [{ name: variable.name, value: '?' }];
                 const elementStride = variable.elementKind === 'double'
                     ? 8
                     : variable.elementKind === 'bool' || variable.elementKind === 'char'
@@ -185,6 +338,132 @@ export default class App {
                 return [];
             if (line < variable.fromLine || line > variable.toLine)
                 return [];
+            if (variable.kind === 'array') {
+                this.mem?.check?.();
+                const address = Number(session.globalValues?.get(variable.slot) ?? Number.NaN);
+                const dimensions = variable.dimensions?.length
+                    ? variable.dimensions
+                    : variable.length
+                        ? [variable.length]
+                        : [];
+                if (!Number.isFinite(address) ||
+                    address <= 0 ||
+                    !dimensions.length ||
+                    (!variable.elementKind && !variable.structFields?.length)) {
+                    return [{ name: variable.name, value: '?' }];
+                }
+                if (variable.structFields?.length && variable.structSize) {
+                    const previewLength = Math.min(dimensions[0], 8);
+                    const values = [];
+                    for (let index = 0; index < previewLength; index += 1) {
+                        const fieldValues = [];
+                        for (const field of variable.structFields) {
+                            const offset = address + index * variable.structSize + field.offset;
+                            if (field.kind === 'bool') {
+                                fieldValues.push(`${field.name}: ${this.mem.read8(offset) ? 'true' : 'false'}`);
+                                continue;
+                            }
+                            if (field.kind === 'char') {
+                                const charCode = this.mem.read8(offset);
+                                fieldValues.push(`${field.name}: ${charCode >= 0x20 && charCode <= 0x7e ? `'${String.fromCharCode(charCode)}'` : `${charCode}`}`);
+                                continue;
+                            }
+                            if (field.kind === 'float') {
+                                fieldValues.push(`${field.name}: ${this.mem.readFloat32(offset)}`);
+                                continue;
+                            }
+                            if (field.kind === 'double') {
+                                fieldValues.push(`${field.name}: ${this.mem.readFloat64(offset)}`);
+                                continue;
+                            }
+                            fieldValues.push(`${field.name}: ${this.mem.readInt32(offset)}`);
+                        }
+                        values.push(`{${fieldValues.join(', ')}}`);
+                    }
+                    return [
+                        {
+                            name: variable.name,
+                            value: `[${values.join(', ')}${dimensions[0] > previewLength ? ', ...' : ''}]`
+                        }
+                    ];
+                }
+                if (!variable.elementKind)
+                    return [{ name: variable.name, value: '?' }];
+                const elementStride = variable.elementKind === 'double'
+                    ? 8
+                    : variable.elementKind === 'bool' || variable.elementKind === 'char'
+                        ? 1
+                        : 4;
+                if (dimensions.length === 2) {
+                    const previewRows = Math.min(dimensions[0], 4);
+                    const previewCols = Math.min(dimensions[1], 8);
+                    const rows = [];
+                    for (let row = 0; row < previewRows; row += 1) {
+                        const values = [];
+                        for (let col = 0; col < previewCols; col += 1) {
+                            const offset = address + (row * dimensions[1] + col) * elementStride;
+                            if (variable.elementKind === 'bool') {
+                                values.push(this.mem.read8(offset) ? 'true' : 'false');
+                                continue;
+                            }
+                            if (variable.elementKind === 'char') {
+                                const charCode = this.mem.read8(offset);
+                                values.push(charCode >= 0x20 && charCode <= 0x7e
+                                    ? `'${String.fromCharCode(charCode)}'`
+                                    : `${charCode}`);
+                                continue;
+                            }
+                            if (variable.elementKind === 'float') {
+                                values.push(`${this.mem.readFloat32(offset)}`);
+                                continue;
+                            }
+                            if (variable.elementKind === 'double') {
+                                values.push(`${this.mem.readFloat64(offset)}`);
+                                continue;
+                            }
+                            values.push(`${this.mem.readInt32(offset)}`);
+                        }
+                        rows.push(`[${values.join(', ')}${dimensions[1] > previewCols ? ', ...' : ''}]`);
+                    }
+                    return [
+                        {
+                            name: variable.name,
+                            value: `[${rows.join(', ')}${dimensions[0] > previewRows ? ', ...' : ''}]`
+                        }
+                    ];
+                }
+                const previewLength = Math.min(dimensions[0], 8);
+                const values = [];
+                for (let index = 0; index < previewLength; index += 1) {
+                    const offset = address + index * elementStride;
+                    if (variable.elementKind === 'bool') {
+                        values.push(this.mem.read8(offset) ? 'true' : 'false');
+                        continue;
+                    }
+                    if (variable.elementKind === 'char') {
+                        const charCode = this.mem.read8(offset);
+                        values.push(charCode >= 0x20 && charCode <= 0x7e
+                            ? `'${String.fromCharCode(charCode)}'`
+                            : `${charCode}`);
+                        continue;
+                    }
+                    if (variable.elementKind === 'float') {
+                        values.push(`${this.mem.readFloat32(offset)}`);
+                        continue;
+                    }
+                    if (variable.elementKind === 'double') {
+                        values.push(`${this.mem.readFloat64(offset)}`);
+                        continue;
+                    }
+                    values.push(`${this.mem.readInt32(offset)}`);
+                }
+                return [
+                    {
+                        name: variable.name,
+                        value: `[${values.join(', ')}${dimensions[0] > previewLength ? ', ...' : ''}]`
+                    }
+                ];
+            }
             const value = session.globalValues?.get(variable.slot) ?? '?';
             return [{ name: variable.name, value }];
         }) || [];
@@ -193,9 +472,7 @@ export default class App {
             line,
             reason,
             locals: [...locals, ...globals],
-            callStack: [...session.frames]
-                .reverse()
-                .map((stackFrame) => ({
+            callStack: [...session.frames].reverse().map((stackFrame) => ({
                 functionName: stackFrame.functionName,
                 line: stackFrame.line
             }))
@@ -238,6 +515,18 @@ export default class App {
                 session.resumeSkipLine = session.currentLine;
                 return ESUCCESS;
             }
+            if (command === 5) {
+                const expression = session.watchBuffer ? readBufferedStdin(session.watchBuffer) : '';
+                let result = '?';
+                try {
+                    result = expression ? this.debugEvaluate(expression) : '?';
+                }
+                catch (error) {
+                    result = error instanceof Error && error.message === 'unavailable' ? '?' : 'error';
+                }
+                if (session.watchResultBuffer)
+                    flushQueuedStdin([result], session.watchResultBuffer);
+            }
         }
     }
     __wasm_idle_debug_enter(functionId, line) {
@@ -356,6 +645,18 @@ export default class App {
         const session = this.debugSession;
         if (!session?.buffer)
             return ESUCCESS;
+        const sharedBreakpointVersion = Atomics.load(session.buffer, 2);
+        if (sharedBreakpointVersion !== session.breakpointVersion) {
+            const count = Math.max(0, Atomics.load(session.buffer, 3));
+            const nextBreakpoints = new Set();
+            for (let index = 0; index < count && index + 4 < session.buffer.length; index += 1) {
+                const breakpoint = Atomics.load(session.buffer, index + 4);
+                if (breakpoint > 0)
+                    nextBreakpoints.add(breakpoint);
+            }
+            session.breakpoints = nextBreakpoints;
+            session.breakpointVersion = sharedBreakpointVersion;
+        }
         if (session.resumeSkipActive) {
             if (functionId === session.resumeSkipFunctionId && line === session.resumeSkipLine) {
                 return ESUCCESS;
@@ -392,19 +693,20 @@ export default class App {
             // +2 to account for = and \0 in "name=value\0".
             size += name.length + value.length + 2;
         }
-        this.mem.write64(environ_count_out, names.length);
-        this.mem.write64(environ_buf_size_out, size);
+        this.mem.write32(environ_count_out, names.length);
+        this.mem.write32(environ_buf_size_out, size);
+        this.trace(`environ_sizes_get(count=${names.length}, bytes=${size})`);
         return ESUCCESS;
     }
     environ_get(environ_ptrs, environ_buf) {
         this.mem.check();
         const names = Object.getOwnPropertyNames(this.environ);
+        this.trace(`environ_get(entries=${JSON.stringify(names)})`);
         for (const name of names) {
             this.mem.write32(environ_ptrs, environ_buf);
             environ_ptrs += 4;
             environ_buf += this.mem.writeStr(environ_buf, `${name}=${this.environ[name]}`);
         }
-        this.mem.write32(environ_ptrs, 0);
         return ESUCCESS;
     }
     args_sizes_get(argc_out, argv_buf_size_out) {
@@ -413,18 +715,19 @@ export default class App {
         for (let arg of this.argv) {
             size += arg.length + 1; // "arg\0".
         }
-        this.mem.write64(argc_out, this.argv.length);
-        this.mem.write64(argv_buf_size_out, size);
+        this.mem.write32(argc_out, this.argv.length);
+        this.mem.write32(argv_buf_size_out, size);
+        this.trace(`args_sizes_get(count=${this.argv.length}, bytes=${size})`);
         return ESUCCESS;
     }
     args_get(argv_ptrs, argv_buf) {
         this.mem.check();
+        this.trace(`args_get(argv=${JSON.stringify(this.argv)})`);
         for (let arg of this.argv) {
             this.mem.write32(argv_ptrs, argv_buf);
             argv_ptrs += 4;
             argv_buf += this.mem.writeStr(argv_buf, arg);
         }
-        this.mem.write32(argv_ptrs, 0);
         return ESUCCESS;
     }
     random_get(buf, buf_len) {

package/dist/clang/index.d.ts

@@ -29,6 +29,8 @@ interface DebugRunOptions {
     pauseOnEntry?: boolean;
     debugBuffer?: Int32Array;
     interruptBuffer?: Uint8Array;
+    watchBuffer?: Int32Array;
+    watchResultBuffer?: Int32Array;
 }
 export default class Clang {
     ready: Promise<void>;
@@ -44,6 +46,8 @@ export default class Clang {
     debugPauseOnEntry: boolean;
     debugBuffer?: Int32Array;
     debugInterruptBuffer?: Uint8Array;
+    debugWatchBuffer?: Int32Array;
+    debugWatchResultBuffer?: Int32Array;
     onDebugEvent?: (event: {
         type: 'pause';
         line: number;