wasm-idle 0.6.1 → 0.7.1

package/dist/playground/worker/tinygo.js

@@ -0,0 +1,140 @@
+import { ConsoleStdout, Fd, WASI, WASIProcExit, wasi } from '@bjorn3/browser_wasi_shim';
+import { waitForBufferedStdin } from '../stdinBuffer';
+self.document = {
+    querySelectorAll() {
+        return [];
+    }
+};
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+let stdinBufferTinyGo = null;
+let stdinChunkTinyGo = new Uint8Array(0);
+let stdinChunkOffsetTinyGo = 0;
+class TinyGoStdin extends Fd {
+    fd_fdstat_get() {
+        const fdstat = new wasi.Fdstat(wasi.FILETYPE_CHARACTER_DEVICE, 0);
+        fdstat.fs_rights_base = BigInt(wasi.RIGHTS_FD_READ);
+        fdstat.fs_rights_inherited = 0n;
+        return { ret: wasi.ERRNO_SUCCESS, fdstat };
+    }
+    fd_filestat_get() {
+        return {
+            ret: wasi.ERRNO_SUCCESS,
+            filestat: new wasi.Filestat(0n, wasi.FILETYPE_CHARACTER_DEVICE, 0n)
+        };
+    }
+    fd_read(size) {
+        if (stdinBufferTinyGo === null) {
+            return {
+                ret: wasi.ERRNO_SUCCESS,
+                data: new Uint8Array(0)
+            };
+        }
+        if (stdinChunkOffsetTinyGo >= stdinChunkTinyGo.length) {
+            const nextChunk = waitForBufferedStdin(stdinBufferTinyGo, () => postMessage({ buffer: true }));
+            if (nextChunk === null) {
+                stdinChunkTinyGo = new Uint8Array(0);
+                stdinChunkOffsetTinyGo = 0;
+                return {
+                    ret: wasi.ERRNO_SUCCESS,
+                    data: new Uint8Array(0)
+                };
+            }
+            stdinChunkTinyGo = encoder.encode(nextChunk);
+            stdinChunkOffsetTinyGo = 0;
+        }
+        const end = Math.min(stdinChunkOffsetTinyGo + size, stdinChunkTinyGo.length);
+        const data = stdinChunkTinyGo.slice(stdinChunkOffsetTinyGo, end);
+        stdinChunkOffsetTinyGo = end;
+        return {
+            ret: wasi.ERRNO_SUCCESS,
+            data
+        };
+    }
+}
+self.onmessage = async (event) => {
+    const { load, artifact, buffer, args = [], log } = event.data;
+    try {
+        if (load) {
+            postMessage({ load: true });
+            return;
+        }
+        const bytes = artifact instanceof Uint8Array
+            ? artifact
+            : artifact instanceof ArrayBuffer
+                ? new Uint8Array(artifact)
+                : ArrayBuffer.isView(artifact)
+                    ? new Uint8Array(artifact.buffer, artifact.byteOffset, artifact.byteLength)
+                    : null;
+        if (!bytes) {
+            throw new Error('TinyGo worker expected a wasm artifact');
+        }
+        stdinBufferTinyGo = new Int32Array(buffer);
+        stdinChunkTinyGo = new Uint8Array(0);
+        stdinChunkOffsetTinyGo = 0;
+        const stdout = new ConsoleStdout((chunk) => {
+            const text = decoder.decode(chunk);
+            if (text)
+                postMessage({ output: text });
+        });
+        const stderr = new ConsoleStdout((chunk) => {
+            const text = decoder.decode(chunk);
+            if (text)
+                postMessage({ output: text });
+        });
+        const wasiRuntime = new WASI(args, ['USER=jungol'], [new TinyGoStdin(), stdout, stderr]);
+        const wasmModule = (await WebAssembly.instantiate(bytes, {
+            wasi_snapshot_preview1: wasiRuntime.wasiImport,
+            wasi_unstable: wasiRuntime.wasiImport
+        }));
+        const instance = typeof WebAssembly.Instance === 'function' && wasmModule instanceof WebAssembly.Instance
+            ? wasmModule
+            : 'instance' in wasmModule
+                ? wasmModule.instance
+                : wasmModule;
+        const exportsObject = instance.exports;
+        let exitCode = 0;
+        try {
+            if (typeof exportsObject._start === 'function') {
+                exitCode = wasiRuntime.start(instance);
+            }
+            else if (typeof exportsObject.memory === 'object' &&
+                (typeof exportsObject.main === 'function' ||
+                    typeof exportsObject._initialize === 'function')) {
+                wasiRuntime.initialize(instance);
+                if (typeof exportsObject._initialize !== 'function' &&
+                    typeof exportsObject.__wasm_call_ctors === 'function') {
+                    exportsObject.__wasm_call_ctors();
+                }
+                if (typeof exportsObject.main === 'function') {
+                    const mainResult = exportsObject.main();
+                    exitCode = typeof mainResult === 'number' ? mainResult : 0;
+                }
+            }
+            else {
+                throw new Error('TinyGo worker expected a WASI artifact with _start or a reactor artifact with _initialize or main');
+            }
+        }
+        catch (error) {
+            if (error instanceof WASIProcExit) {
+                exitCode = error.code;
+            }
+            else {
+                throw error;
+            }
+        }
+        if (log) {
+            console.log(`[wasm-idle:tinygo-worker] wasi run complete exitCode=${String(exitCode)}`);
+        }
+        if (exitCode !== 0) {
+            throw new Error(`TinyGo program exited with code ${exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:tinygo-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

package/dist/terminal/Terminal.svelte

@@ -61,8 +61,7 @@
 		tc = 0,
 		plugin = $state(),
 		ll: string | null = null,
-		loadedRuntimeAssets = $state<SandboxRuntimeAssets | undefined>(undefined),
-		loadedPlayground = $state<PlaygroundBinding | undefined>(undefined),
+		loadedRuntimeAssetsKey: string | undefined = undefined,
 		stopRequested = false;
 
 	function writeTerminalOutput(text: string) {
@@ -99,23 +98,39 @@
 	async function initSandbox(language: string) {
 		const currentPlayground = playground;
 		const currentRuntimeAssets = currentPlayground?.runtimeAssets || runtimeAssets || path;
+		const currentRuntimeAssetsKey =
+			typeof currentRuntimeAssets === 'string'
+				? currentRuntimeAssets
+				: JSON.stringify({
+						rootUrl: currentRuntimeAssets?.rootUrl || '',
+						pythonBaseUrl: currentRuntimeAssets?.python?.baseUrl || '',
+						hasPythonLoader: !!currentRuntimeAssets?.python?.loader,
+						javaBaseUrl: currentRuntimeAssets?.java?.baseUrl || '',
+						hasJavaLoader: !!currentRuntimeAssets?.java?.loader,
+						rustCompilerUrl: currentRuntimeAssets?.rust?.compilerUrl || '',
+						goCompilerUrl: currentRuntimeAssets?.go?.compilerUrl || '',
+						elixirBundleUrl: currentRuntimeAssets?.elixir?.bundleUrl || '',
+						ocamlModuleUrl: currentRuntimeAssets?.ocaml?.moduleUrl || '',
+						ocamlManifestUrl: currentRuntimeAssets?.ocaml?.manifestUrl || '',
+						tinygoAppUrl: currentRuntimeAssets?.tinygo?.appUrl || '',
+						tinygoHostCompileUrl: currentRuntimeAssets?.tinygo?.hostCompileUrl || '',
+						tinygoModuleUrl: currentRuntimeAssets?.tinygo?.moduleUrl || '',
+						tinygoDisableHostCompile: !!currentRuntimeAssets?.tinygo?.disableHostCompile
+					});
+		const requiresSandboxReset =
+			ll !== language || loadedRuntimeAssetsKey !== currentRuntimeAssetsKey;
 		let _tc = ++tc;
 		await wait();
-		if (sandbox) await sandbox.clear();
+		if (sandbox && requiresSandboxReset) await sandbox.clear();
 		input = '';
 		finish = false;
-		if (
-			ll !== language ||
-			loadedRuntimeAssets !== currentRuntimeAssets ||
-			loadedPlayground !== currentPlayground
-		) {
+		if (!sandbox || requiresSandboxReset) {
 			sandbox = currentPlayground
 				? await currentPlayground.load(language)
 				: await load(language, currentRuntimeAssets);
 			await sandbox.clear();
 			ll = language;
-			loadedRuntimeAssets = currentRuntimeAssets;
-			loadedPlayground = currentPlayground;
+			loadedRuntimeAssetsKey = currentRuntimeAssetsKey;
 		}
 		sandbox.image = onimage;
 		sandbox.ondebug = ondebug;
@@ -203,9 +218,17 @@
 		) {
 			prog?.set?.(0);
 			const loadProgress =
-				language === 'RUST' ? phaseProgress(prog, 0, 0.05) : phaseProgress(prog, 0, 0.85);
+				language === 'RUST' ||
+				language === 'GO' ||
+				language === 'TINYGO' ||
+				language === 'OCAML'
+					? phaseProgress(prog, 0, 0.05)
+					: phaseProgress(prog, 0, 0.85);
 			const prepareProgress =
-				language === 'RUST'
+				language === 'RUST' ||
+				language === 'GO' ||
+				language === 'TINYGO' ||
+				language === 'OCAML'
 					? phaseProgress(prog, 0.05, 0.99)
 					: phaseProgress(prog, 0.85, 0.99);
 			await Promise.all([
@@ -298,10 +321,40 @@
 				allowProposedApi: true
 			});
 			term.open(ref);
+			term.onData((data: string) => {
+				if (!term || finish) return;
+				let pendingText = '';
+				for (const chunk of data) {
+					if (chunk === '\r' || chunk === '\n') {
+						if (pendingText) {
+							appendInputText(pendingText);
+							pendingText = '';
+						}
+						submitCurrentInput();
+						continue;
+					}
+					if (chunk === '\u007f') {
+						if (pendingText) {
+							appendInputText(pendingText);
+							pendingText = '';
+						}
+						if (term.buffer.active.cursorX > 0 && input.length > 0) {
+							term.write('\b \b');
+							input = Array.from(input).slice(0, -1).join('');
+						}
+						continue;
+					}
+					if ((chunk.codePointAt(0) || 0) >= 0x20) {
+						pendingText += chunk;
+					}
+				}
+				if (pendingText) {
+					appendInputText(pendingText);
+				}
+			});
 			term.onKey((e: { key: string; domEvent: KeyboardEvent }) => {
 				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();
@@ -313,28 +366,15 @@
 				}
 				if (finish) return;
 				onkey?.(ev);
-				if (ev.key === 'Enter') {
-					submitCurrentInput();
-				} else if (ev.key === 'Backspace') {
-					if (term.buffer.active.cursorX > 0) {
-						term.write('\b \b');
-						if (input.length > 0) input = input.substring(0, input.length - 1);
-					}
-				} else if (printable) {
-					if (
-						(e.key >= String.fromCharCode(0x20) &&
-							e.key <= String.fromCharCode(0x7e)) ||
-						e.key >= '\u00a0'
-					) {
-						appendInputText(e.key);
-					}
-				} else if (isCopyShortcut) {
+				if (isCopyShortcut) {
 					ev.preventDefault();
 					sandbox.kill?.();
 				} else if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'd') {
+					ev.preventDefault();
 					if (input.length > 0) submitCurrentInput();
 					sandbox?.eof?.();
 				} else if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'v') {
+					ev.preventDefault();
 					navigator.clipboard.readText().then((text) => {
 						applyPastedText(text);
 					});

package/dist/utils/vscodeJsonrpcBrowser.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserMessageReader as BrowserMessageReaderInstance, BrowserMessageWriter as BrowserMessageWriterInstance } from 'vscode-jsonrpc/lib/browser/main';
+export declare const BrowserMessageReader: new (port: MessagePort | Worker | DedicatedWorkerGlobalScope) => BrowserMessageReaderInstance;
+export declare const BrowserMessageWriter: new (port: MessagePort | Worker | DedicatedWorkerGlobalScope) => BrowserMessageWriterInstance;
+export type BrowserMessageReader = BrowserMessageReaderInstance;
+export type BrowserMessageWriter = BrowserMessageWriterInstance;

package/dist/utils/vscodeJsonrpcBrowser.js

@@ -0,0 +1,4 @@
+import jsonrpc from 'vscode-jsonrpc';
+const browserJsonrpc = jsonrpc;
+export const BrowserMessageReader = browserJsonrpc.BrowserMessageReader;
+export const BrowserMessageWriter = browserJsonrpc.BrowserMessageWriter;

package/package.json

@@ -1,17 +1,28 @@
 {
 	"name": "wasm-idle",
-	"version": "0.6.1",
-	"description": "A simple web app to run C++/Python/Java code in the browser",
+	"version": "0.7.1",
+	"description": "A simple web app to run code in the browser",
 	"license": "MIT",
 	"type": "module",
 	"scripts": {
 		"dev": "vite dev",
+		"build:preview": "vite build",
 		"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",
+		"probe:go-browser": "node scripts/probe-go-browser.mjs",
+		"probe:ocaml-browser": "node scripts/probe-ocaml-browser.mjs",
+		"probe:rust-browser": "node scripts/probe-rust-browser.mjs",
+		"probe:tinygo-browser": "node scripts/probe-tinygo-browser.mjs",
+		"probe:tinygo-browser:static": "WASM_IDLE_DISABLE_TINYGO_HOST_COMPILE=1 node scripts/probe-tinygo-browser.mjs",
 		"sync:pyodide": "node scripts/sync-pyodide.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",
+		"test:browser:go": "WASM_IDLE_RUN_REAL_BROWSER_GO=1 pnpm exec vitest run src/lib/playground/go.playwright.test.ts",
+		"test:browser:ocaml": "WASM_IDLE_RUN_REAL_BROWSER_OCAML=1 pnpm exec vitest run src/lib/playground/ocaml.playwright.test.ts",
+		"test:browser:playwright": "WASM_IDLE_RUN_REAL_BROWSER_RUST=1 pnpm exec vitest run src/lib/playground/rust.playwright.test.ts",
+		"test:browser:tinygo": "WASM_IDLE_RUN_REAL_BROWSER_TINYGO=1 pnpm exec vitest run src/lib/playground/tinygo.playwright.test.ts",
+		"sync:wasm-of-js-of-ocaml": "node scripts/sync-wasm-of-js-of-ocaml.mjs",
+		"sync:wasm-go": "node scripts/sync-wasm-go.mjs",
 		"sync:wasm-rust": "node scripts/sync-wasm-rust.mjs",
+		"sync:wasm-tinygo": "node scripts/sync-wasm-tinygo.mjs",
 		"package": "svelte-kit sync && svelte-package && publint",
 		"prepublishOnly": "npm run package",
 		"test": "vitest run",
@@ -26,36 +37,37 @@
 		"@eslint/js": "^10.0.1",
 		"@sveltejs/adapter-auto": "^7.0.1",
 		"@sveltejs/adapter-static": "^3.0.10",
-		"@sveltejs/kit": "^2.55.0",
+		"@sveltejs/kit": "^2.57.1",
 		"@sveltejs/package": "^2.5.7",
 		"@sveltejs/vite-plugin-svelte": "^7.0.0",
 		"@testing-library/svelte": "^5.3.1",
 		"@testing-library/user-event": "^14.6.1",
-		"@types/node": "^25.5.0",
-		"@typescript-eslint/eslint-plugin": "^8.57.2",
-		"@typescript-eslint/parser": "^8.57.2",
-		"eslint": "^10.1.0",
+		"@types/node": "^25.6.0",
+		"@typescript-eslint/eslint-plugin": "^8.58.2",
+		"@typescript-eslint/parser": "^8.58.2",
+		"eslint": "^10.2.0",
 		"eslint-config-prettier": "^10.1.8",
-		"eslint-plugin-svelte": "^3.16.0",
+		"eslint-plugin-svelte": "^3.17.0",
 		"eslint-plugin-svelte3": "^4.0.0",
 		"gh-pages": "^6.3.0",
-		"globals": "^17.4.0",
-		"jsdom": "^29.0.1",
+		"globals": "^17.5.0",
+		"jsdom": "^29.0.2",
 		"monaco-editor": "^0.55.1",
-		"playwright-core": "^1.58.2",
-		"prettier": "^3.8.1",
+		"playwright-core": "^1.59.1",
+		"prettier": "^3.8.3",
 		"prettier-plugin-svelte": "^3.5.1",
-		"svelte": "^5.55.0",
-		"svelte-check": "^4.4.5",
+		"svelte": "^5.55.4",
+		"svelte-check": "^4.4.6",
 		"tslib": "^2.8.1",
-		"typescript": "^5.9.3",
-		"typescript-eslint": "^8.57.1",
-		"vite": "^8.0.3",
-		"vitest": "^4.1.1"
+		"typescript": "^6.0.2",
+		"typescript-eslint": "^8.58.2",
+		"vite": "^8.0.8",
+		"vitest": "^4.1.4"
 	},
 	"dependencies": {
 		"@bjorn3/browser_wasi_shim": "^0.4.2",
 		"@hancomac/monaco-languageclient": "^1.1.0",
+		"@swmansion/popcorn": "0.2.2",
 		"@xterm/addon-canvas": "^0.7.0",
 		"@xterm/addon-fit": "^0.11.0",
 		"@xterm/addon-ligatures": "^0.10.0",
@@ -65,7 +77,7 @@
 		"@xterm/addon-web-links": "^0.12.0",
 		"@xterm/addon-webgl": "^0.19.0",
 		"@xterm/xterm": "^6.0.0",
-		"@zip.js/zip.js": "^2.8.23",
+		"@zip.js/zip.js": "^2.8.26",
 		"publint": "^0.3.18",
 		"pyodide": "0.29.3",
 		"vscode-jsonrpc": "^8.2.1"