wasm-idle 0.4.1 → 0.5.0

package/dist/playground/worker/rust.js

@@ -0,0 +1,159 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+self.document = {
+    querySelectorAll() {
+        return [];
+    }
+};
+let stdinBufferRust = null;
+let compilerUrl = '';
+let runtimeBaseUrl = '';
+let loadedCompilerUrl = '';
+let compilerPromise = null;
+let compiledArtifact = null;
+let compiledCacheKey = '';
+async function loadCompiler(url) {
+    if (!url) {
+        throw new Error('Rust runtime is not configured. Set PUBLIC_WASM_RUST_COMPILER_URL or runtimeAssets.rust.compilerUrl.');
+    }
+    if (loadedCompilerUrl === url && compilerPromise) {
+        return await compilerPromise;
+    }
+    loadedCompilerUrl = url;
+    try {
+        runtimeBaseUrl = new URL('./runtime/', url).toString();
+    }
+    catch {
+        runtimeBaseUrl = url;
+    }
+    compiledArtifact = null;
+    compiledCacheKey = '';
+    compilerPromise = (async () => {
+        const module = await import(/* @vite-ignore */ url);
+        const factory = typeof module.createRustCompiler === 'function'
+            ? module.createRustCompiler
+            : typeof module.default === 'function'
+                ? module.default
+                : null;
+        if (!factory) {
+            throw new Error('wasm-rust module must export createRustCompiler or a default factory');
+        }
+        if (typeof module.executeBrowserRustArtifact !== 'function') {
+            throw new Error('wasm-rust module must export executeBrowserRustArtifact');
+        }
+        return {
+            compiler: await factory(),
+            executeBrowserRustArtifact: module.executeBrowserRustArtifact
+        };
+    })();
+    return await compilerPromise;
+}
+self.onmessage = async (event) => {
+    const { load, compilerUrl: nextCompilerUrl, buffer, code, prepare, args = [], targetTriple = 'wasm32-wasip1', log } = event.data;
+    try {
+        if (load) {
+            compilerUrl = nextCompilerUrl;
+            if (log) {
+                console.log(`[wasm-idle:rust-worker] load compilerUrl=${compilerUrl}`);
+            }
+            await loadCompiler(compilerUrl);
+            postMessage({ load: true });
+            return;
+        }
+        stdinBufferRust = new Int32Array(buffer);
+        const runtime = await loadCompiler(compilerUrl);
+        const compileCacheKey = `${targetTriple}\n${code}`;
+        if (!compiledArtifact || compiledCacheKey !== compileCacheKey) {
+            if (log) {
+                console.log(`[wasm-idle:rust-worker] compile start prepare=${String(prepare)} target=${targetTriple} bytes=${code.length}`);
+            }
+            const result = await runtime.compiler.compile({
+                code,
+                edition: '2024',
+                crateType: 'bin',
+                targetTriple,
+                prepare,
+                log,
+                onProgress(progress) {
+                    postMessage({ progress });
+                }
+            });
+            if (log) {
+                console.log(`[wasm-idle:rust-worker] compile settled success=${String(result.success)} hasWasm=${String(Boolean(result.artifact?.wasm))} stdout=${String(Boolean(result.stdout))} stderr=${String(Boolean(result.stderr))}`);
+            }
+            for (const diagnostic of result.diagnostics || []) {
+                postMessage({ diagnostic });
+            }
+            if (result.stdout)
+                postMessage({ output: result.stdout });
+            if (!result.success) {
+                throw new Error(result.stderr ||
+                    result.diagnostics?.map((diagnostic) => diagnostic.message).join('\n') ||
+                    'Rust compilation failed');
+            }
+            if (result.stderr)
+                postMessage({ output: result.stderr });
+            if (!result.artifact?.wasm) {
+                throw new Error('wasm-rust did not return a wasm artifact');
+            }
+            compiledArtifact = result.artifact;
+            compiledCacheKey = compileCacheKey;
+            if (log) {
+                console.log(`[wasm-idle:rust-worker] cached artifact target=${compiledArtifact.targetTriple} format=${compiledArtifact.format}`);
+            }
+        }
+        if (prepare) {
+            if (log) {
+                console.log('[wasm-idle:rust-worker] prepare complete');
+            }
+            postMessage({ results: true });
+            return;
+        }
+        if (log) {
+            console.log(`[wasm-idle:rust-worker] runtime start target=${compiledArtifact.targetTriple} format=${compiledArtifact.format}`);
+        }
+        const execution = await runtime.executeBrowserRustArtifact(compiledArtifact, runtimeBaseUrl, {
+            args,
+            env: {
+                USER: 'jungol'
+            },
+            stdin: () => {
+                const chunk = waitForBufferedStdin(stdinBufferRust, () => postMessage({ buffer: true }));
+                if (chunk == null) {
+                    if (log) {
+                        console.log('[wasm-idle:rust-stdin] fd_read(bytes=0, eof=true)');
+                    }
+                    return null;
+                }
+                if (log) {
+                    console.log(`[wasm-idle:rust-stdin] fd_fill(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                }
+                return chunk;
+            },
+            stdout: (output) => {
+                if (output) {
+                    postMessage({ output });
+                }
+            },
+            stderr: (output) => {
+                if (output) {
+                    postMessage({ output });
+                }
+            }
+        });
+        if (log) {
+            console.log(`[wasm-idle:rust-worker] wasi run complete exitCode=${String(execution.exitCode)}`);
+        }
+        if (execution.exitCode !== 0) {
+            throw new Error(execution.stderr
+                ? `Rust program exited with code ${execution.exitCode}\n${execution.stderr}`
+                : `Rust program exited with code ${execution.exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:rust-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

package/dist/terminal/Terminal.svelte

@@ -6,7 +6,11 @@
 		SandboxExecutionOptions
 	} from '../playground/options';
 	import type { PlaygroundRuntimeAssets } from '../playground/assets';
-	import type { Sandbox } from '../playground/sandbox';
+	import type {
+		BoundSandbox,
+		PlaygroundBinding,
+		SandboxRuntimeAssets
+	} from '../playground/sandbox';
 	import type { TerminalControl } from './types';
 	import { Theme, registerAllPlugins } from './';
 	import load from '../playground';
@@ -18,6 +22,7 @@
 		dark?: boolean;
 		path?: string;
 		runtimeAssets?: string | PlaygroundRuntimeAssets;
+		playground?: PlaygroundBinding;
 		font?: string;
 
 		onload?: () => void;
@@ -33,6 +38,7 @@
 		dark = false,
 		path = '',
 		runtimeAssets = undefined,
+		playground = undefined,
 		font = "'D2 coding', monospace",
 		onload,
 		onfinish,
@@ -47,15 +53,24 @@
 		clientWidth = $state(0),
 		clientHeight = $state(0),
 		term = $state<TerminalType>(),
+		debugOutput = $state(''),
 		finish = true,
 		input = '',
-		sandbox: Sandbox,
+		sandbox: BoundSandbox,
 		first = true,
 		tc = 0,
 		plugin = $state(),
 		ll: string | null = null,
+		loadedRuntimeAssets = $state<SandboxRuntimeAssets | undefined>(undefined),
+		loadedPlayground = $state<PlaygroundBinding | undefined>(undefined),
 		stopRequested = false;
 
+	function writeTerminalOutput(text: string) {
+		if (!text) return;
+		debugOutput += text;
+		term?.write(text);
+	}
+
 	function phaseProgress(
 		progress: { set?: (value: number) => void } | undefined,
 		start: number,
@@ -82,32 +97,42 @@
 	}
 
 	async function initSandbox(language: string) {
+		const currentPlayground = playground;
+		const currentRuntimeAssets = currentPlayground?.runtimeAssets || runtimeAssets || path;
 		let _tc = ++tc;
 		await wait();
 		if (sandbox) await sandbox.clear();
 		input = '';
 		finish = false;
-		if (ll !== language) {
-			sandbox = await load(language);
+		if (
+			ll !== language ||
+			loadedRuntimeAssets !== currentRuntimeAssets ||
+			loadedPlayground !== currentPlayground
+		) {
+			sandbox = currentPlayground
+				? await currentPlayground.load(language)
+				: await load(language, currentRuntimeAssets);
 			await sandbox.clear();
 			ll = language;
+			loadedRuntimeAssets = currentRuntimeAssets;
+			loadedPlayground = currentPlayground;
 		}
 		sandbox.image = onimage;
 		sandbox.ondebug = ondebug;
 		sandbox.oncompilerdiagnostic = oncompilediagnostic;
 		sandbox.output = (output: string) =>
-			_tc === tc && term && term.write(output.replaceAll('\n', '\r\n'));
+			_tc === tc && writeTerminalOutput(output.replaceAll('\n', '\r\n'));
 	}
 
 	function runSandbox<T>(pr: Promise<T>) {
 		return pr
 			.then((x) => {
-				term?.write(`\r\nProcess finished after ${sandbox.elapse}ms\u001B[?25l`);
+				writeTerminalOutput(`\r\nProcess finished after ${sandbox.elapse}ms\u001B[?25l`);
 				return x;
 			})
 			.catch((msg) => {
 				if (stopRequested) return false;
-				term?.write(`\r\n\x1B[1;3;31m${msg}\u001B[?25l`);
+				writeTerminalOutput(`\r\n\x1B[1;3;31m${msg}\u001B[?25l`);
 				return false;
 			})
 			.finally(() => {
@@ -137,7 +162,7 @@
 
 	function submitCurrentInput() {
 		term?.write('\r\n');
-		sandbox.write?.(input + '\n');
+		sandbox?.write?.(input + '\n');
 		input = '';
 	}
 
@@ -149,12 +174,21 @@
 		}
 	}
 
+	async function waitForInput() {
+		await wait();
+		const startedAt = Date.now();
+		while (!sandbox && Date.now() - startedAt < 30_000) {
+			await new Promise((resolve) => setTimeout(resolve, 10));
+		}
+	}
+
 	const terminalControl: TerminalControl = {
 		async clear() {
 			await wait();
 			term?.reset();
 			term?.write(`\u001B[?25l\x1b[0m\x1b[?25h`);
 			if (term) term.options.cursorBlink = false;
+			debugOutput = '';
 			input = '';
 			first = true;
 			await new Promise((r) => setTimeout(r, 100));
@@ -167,11 +201,16 @@
 			args: string[] = [],
 			options: SandboxExecutionOptions = {}
 		) {
-			const loadProgress = phaseProgress(prog, 0, 0.85);
-			const prepareProgress = phaseProgress(prog, 0.85, 0.99);
+			prog?.set?.(0);
+			const loadProgress =
+				language === 'RUST' ? phaseProgress(prog, 0, 0.05) : phaseProgress(prog, 0, 0.85);
+			const prepareProgress =
+				language === 'RUST'
+					? phaseProgress(prog, 0.05, 0.99)
+					: phaseProgress(prog, 0.85, 0.99);
 			await Promise.all([
 				initSandbox(language).then(() =>
-					sandbox.load(runtimeAssets || path, code, log, args, options, loadProgress)
+					sandbox.load(code, log, args, options, loadProgress)
 				),
 				initTerm(false)
 			]);
@@ -189,9 +228,7 @@
 			options: SandboxExecutionOptions = {}
 		) {
 			await Promise.all([
-				initSandbox(language).then(() =>
-					sandbox.load(runtimeAssets || path, code, log, args, options, prog)
-				),
+				initSandbox(language).then(() => sandbox.load(code, log, args, options, prog)),
 				initTerm()
 			]);
 			return await runSandbox(sandbox.run(code, false, log, prog, args, options));
@@ -212,14 +249,25 @@
 			await wait();
 			sandbox.debugCommand?.(command);
 		},
+		async setBreakpoints(lines: number[]) {
+			await wait();
+			sandbox.setBreakpoints?.(lines);
+		},
 		async debugEvaluate(expression: string) {
 			await wait();
 			return (await sandbox.debugEvaluate?.(expression)) || '?';
 		},
+		async waitForInput() {
+			await waitForInput();
+		},
 		async write(input: string) {
-			await wait();
+			await waitForInput();
 			applyPastedText(input);
 			if (!input.endsWith('\n') && !input.endsWith('\r')) submitCurrentInput();
+		},
+		async eof() {
+			await waitForInput();
+			sandbox?.eof?.();
 		}
 	};
 
@@ -251,9 +299,19 @@
 			});
 			term.open(ref);
 			term.onKey((e: { key: string; domEvent: KeyboardEvent }) => {
-				if (finish || !term) return;
+				if (!term) return;
 				const ev = e.domEvent;
 				const printable = !ev.altKey && !ev.ctrlKey && !ev.metaKey;
+				const isCopyShortcut = (ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'c';
+				if (isCopyShortcut && term.hasSelection()) {
+					const selectedText = term.getSelection();
+					if (selectedText) {
+						ev.preventDefault();
+						navigator.clipboard.writeText(selectedText).catch(() => {});
+						return;
+					}
+				}
+				if (finish) return;
 				onkey?.(ev);
 				if (ev.key === 'Enter') {
 					submitCurrentInput();
@@ -270,18 +328,12 @@
 					) {
 						appendInputText(e.key);
 					}
-				} else if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'c') {
-					if (term.hasSelection()) {
-						const selectedText = term.getSelection();
-						if (selectedText) {
-							navigator.clipboard.writeText(selectedText).catch(() => {});
-							return;
-						}
-					}
+				} else if (isCopyShortcut) {
+					ev.preventDefault();
 					sandbox.kill?.();
 				} else if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'd') {
 					if (input.length > 0) submitCurrentInput();
-					else sandbox.eof?.();
+					sandbox?.eof?.();
 				} else if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'v') {
 					navigator.clipboard.readText().then((text) => {
 						applyPastedText(text);
@@ -302,6 +354,7 @@
 
 <main>
 	<div bind:this={ref} bind:clientWidth bind:clientHeight></div>
+	<pre data-testid="terminal-debug-output" style="display: none;">{debugOutput}</pre>
 </main>
 
 <style>

package/dist/terminal/Terminal.svelte.d.ts

@@ -1,11 +1,13 @@
 import type { CompilerDiagnostic, DebugSessionEvent } from '../playground/options';
 import type { PlaygroundRuntimeAssets } from '../playground/assets';
+import type { PlaygroundBinding } from '../playground/sandbox';
 import type { TerminalControl } from './types';
 import '@xterm/xterm/css/xterm.css';
 interface Props {
     dark?: boolean;
     path?: string;
     runtimeAssets?: string | PlaygroundRuntimeAssets;
+    playground?: PlaygroundBinding;
     font?: string;
     onload?: () => void;
     onfinish?: () => void;

package/dist/terminal/theme.js

@@ -1,7 +1,7 @@
 const theme = {
     Tango_Dark: {
         foreground: '#eee',
-        background: 'transparent',
+        background: 'rgba(0, 0, 0, 0)',
         cursor: '#FFFFFF',
         cursorAccent: '#ffffff',
         selection: '#ffffff44',
@@ -24,7 +24,7 @@ const theme = {
     },
     Tango_Light: {
         foreground: '#111',
-        background: 'rgba(0, 0, 0, 0)',
+        background: 'rgba(255, 255, 255, 0)',
         cursor: '#000000',
         cursorAccent: '#000000',
         selection: '#00000044',

package/dist/terminal/types.d.ts

@@ -9,7 +9,10 @@ export interface TerminalControl {
     destroy: () => Promise<void>;
     stop?: () => Promise<void>;
     debugCommand: (command: DebugCommand) => Promise<void>;
+    setBreakpoints?: (lines: number[]) => Promise<void>;
     debugEvaluate?: (expression: string) => Promise<string>;
+    waitForInput?: () => Promise<void>;
     write: (input: string) => Promise<void>;
+    eof?: () => Promise<void>;
 }
 export type { CompilerDiagnostic, DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wasm-idle",
-	"version": "0.4.1",
+	"version": "0.5.0",
 	"description": "A simple web app to run C++/Python/Java code in the browser",
 	"license": "MIT",
 	"type": "module",
@@ -8,6 +8,9 @@
 		"dev": "vite dev",
 		"build": "vite build && npm run package",
 		"preview": "vite preview",
+		"probe:rust-browser": "pnpm run sync:wasm-rust && pnpm build && node scripts/probe-rust-browser.mjs",
+		"test:browser:playwright": "pnpm run sync:wasm-rust && pnpm build && WASM_IDLE_RUN_REAL_BROWSER_RUST=1 pnpm exec vitest run src/lib/playground/rust.playwright.test.ts",
+		"sync:wasm-rust": "node scripts/sync-wasm-rust.mjs",
 		"package": "svelte-kit sync && svelte-package && publint",
 		"prepublishOnly": "npm run package",
 		"test": "vitest run",
@@ -27,27 +30,30 @@
 		"@sveltejs/vite-plugin-svelte": "^7.0.0",
 		"@testing-library/svelte": "^5.3.1",
 		"@testing-library/user-event": "^14.6.1",
-		"@typescript-eslint/eslint-plugin": "^8.57.1",
-		"@typescript-eslint/parser": "^8.57.1",
-		"eslint": "^10.0.3",
+		"@types/node": "^25.5.0",
+		"@typescript-eslint/eslint-plugin": "^8.57.2",
+		"@typescript-eslint/parser": "^8.57.2",
+		"eslint": "^10.1.0",
 		"eslint-config-prettier": "^10.1.8",
-		"eslint-plugin-svelte": "^3.15.2",
+		"eslint-plugin-svelte": "^3.16.0",
 		"eslint-plugin-svelte3": "^4.0.0",
 		"gh-pages": "^6.3.0",
 		"globals": "^17.4.0",
-		"jsdom": "^29.0.0",
+		"jsdom": "^29.0.1",
 		"monaco-editor": "^0.55.1",
+		"playwright-core": "^1.58.2",
 		"prettier": "^3.8.1",
 		"prettier-plugin-svelte": "^3.5.1",
-		"svelte": "^5.54.0",
+		"svelte": "^5.55.0",
 		"svelte-check": "^4.4.5",
 		"tslib": "^2.8.1",
 		"typescript": "^5.9.3",
 		"typescript-eslint": "^8.57.1",
-		"vite": "^8.0.0",
-		"vitest": "^4.1.0"
+		"vite": "^8.0.3",
+		"vitest": "^4.1.1"
 	},
 	"dependencies": {
+		"@bjorn3/browser_wasi_shim": "^0.4.2",
 		"@hancomac/monaco-languageclient": "^1.1.0",
 		"@xterm/addon-canvas": "^0.7.0",
 		"@xterm/addon-fit": "^0.11.0",