wasm-idle 0.4.0 → 0.5.0

package/dist/playground/worker/python.js

@@ -1,4 +1,5 @@
 import { flushQueuedStdin, readBufferedStdin, waitForBufferedStdin } from '../stdinBuffer';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
 self.document = {
     querySelector() {
         return null;
@@ -7,8 +8,7 @@ self.document = {
         return [];
     }
 };
-let stdinBufferPyodide, debugBufferPyodide, watchBufferPyodide, watchResultBufferPyodide, interruptBufferPyodide, pyodide, path = '', packageBaseUrl = '';
-let jungolRobotReady = false;
+let stdinBufferPyodide, debugBufferPyodide, watchBufferPyodide, watchResultBufferPyodide, interruptBufferPyodide, pyodide, baseUrl = '', packageBaseUrl = '';
 const imageHook = `
 if not globals().get("__wasm_idle_img_inited__", False):
     globals()["__wasm_idle_img_inited__"] = True
@@ -157,33 +157,12 @@ async function loadPyodide(path) {
     if (pyodide)
         return;
     const { loadPyodide } = await import('pyodide');
-    pyodide = await loadPyodide({ indexURL: path + '/pyodide' });
-    packageBaseUrl = path + '/pyodide';
+    pyodide = await loadPyodide({ indexURL: path });
+    packageBaseUrl = path;
     const setCdnUrl = pyodide?.setCdnUrl;
     if (typeof setCdnUrl === 'function')
         setCdnUrl(packageBaseUrl);
 }
-async function ensureRobotJungol() {
-    if (jungolRobotReady || !pyodide)
-        return;
-    try {
-        const res = await fetch(path + '/jungol-robot/jungol_robot.zip');
-        if (!res.ok)
-            throw new Error('jungol-robot zip not found');
-        const data = await res.arrayBuffer();
-        const siteRaw = pyodide.runPython('import site; site.getsitepackages()[0]');
-        const sitePath = typeof siteRaw === 'string' ? siteRaw : siteRaw.toString();
-        const unpackArchive = pyodide?.unpackArchive;
-        if (typeof unpackArchive !== 'function')
-            throw new Error('pyodide.unpackArchive unavailable');
-        unpackArchive(data, 'zip', sitePath);
-        pyodide.runPython('import importlib; importlib.invalidate_caches()');
-        jungolRobotReady = true;
-    }
-    catch (e) {
-        console.warn('jungol-robot preload failed', e);
-    }
-}
 async function loadPackages(code) {
     if (!code)
         return;
@@ -203,20 +182,22 @@ async function loadPackages(code) {
     }
 }
 self.onmessage = async (event) => {
-    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, path: _p, prepare, debug = false, breakpoints = [], pauseOnEntry = false } = event.data;
+    if (handleWorkerAssetMessage(event.data))
+        return;
+    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, assets, prepare, debug = false, breakpoints = [], pauseOnEntry = false } = event.data;
     if (load) {
-        path = _p;
+        const runtimeAssets = assets;
+        baseUrl = runtimeAssets?.baseUrl || baseUrl;
+        configureWorkerRuntimeAssets(runtimeAssets || null);
         postMessage({ output: 'Loading Pyodide...' });
-        await loadPyodide(path);
-        await ensureRobotJungol();
+        await loadPyodide(baseUrl);
         postMessage({ output: ' Done.\n\r' });
         postMessage({ load: true });
     }
     else if (prepare) {
         postMessage({ output: 'Loading packages...' });
         try {
-            await loadPyodide(path);
-            await ensureRobotJungol();
+            await loadPyodide(baseUrl);
             await loadPackages(code);
             postMessage({ output: ' Done.\n\r' });
             self.postMessage({ results: true });
@@ -226,8 +207,7 @@ self.onmessage = async (event) => {
         }
     }
     else if (code) {
-        await loadPyodide(path);
-        await ensureRobotJungol();
+        await loadPyodide(baseUrl);
         await loadPackages(code);
         const ts = Date.now();
         stdinBufferPyodide = new Int32Array(buffer);

package/dist/playground/worker/rust.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -5,7 +5,12 @@
 		DebugSessionEvent,
 		SandboxExecutionOptions
 	} from '../playground/options';
-	import type { Sandbox } from '../playground/sandbox';
+	import type { PlaygroundRuntimeAssets } from '../playground/assets';
+	import type {
+		BoundSandbox,
+		PlaygroundBinding,
+		SandboxRuntimeAssets
+	} from '../playground/sandbox';
 	import type { TerminalControl } from './types';
 	import { Theme, registerAllPlugins } from './';
 	import load from '../playground';
@@ -16,6 +21,8 @@
 	interface Props {
 		dark?: boolean;
 		path?: string;
+		runtimeAssets?: string | PlaygroundRuntimeAssets;
+		playground?: PlaygroundBinding;
 		font?: string;
 
 		onload?: () => void;
@@ -30,6 +37,8 @@
 	let {
 		dark = false,
 		path = '',
+		runtimeAssets = undefined,
+		playground = undefined,
 		font = "'D2 coding', monospace",
 		onload,
 		onfinish,
@@ -44,13 +53,37 @@
 		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;
+		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,
+		end: number
+	) {
+		if (!progress) return undefined;
+		return {
+			set(value: number) {
+				const clamped = Number.isFinite(value) ? Math.min(Math.max(value, 0), 1) : 0;
+				progress.set?.(start + (end - start) * clamped);
+			}
+		};
+	}
 
 	function wait() {
 		return new Promise<void>((r) => {
@@ -64,34 +97,46 @@
 	}
 
 	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) => {
-				term?.write(`\r\n\x1B[1;3;31m${msg}\u001B[?25l`);
+				if (stopRequested) return false;
+				writeTerminalOutput(`\r\n\x1B[1;3;31m${msg}\u001B[?25l`);
 				return false;
 			})
 			.finally(() => {
+				stopRequested = false;
 				onfinish?.();
 				finish = true;
 				if (term) term.options.cursorBlink = false;
@@ -102,6 +147,7 @@
 		await wait();
 		if (!term) return;
 		term.options.cursorBlink = blink;
+		term.write('\u001B[?25h');
 		term.focus();
 
 		if (!first) term?.write(`\r\n\x1b[0m`);
@@ -116,7 +162,7 @@
 
 	function submitCurrentInput() {
 		term?.write('\r\n');
-		sandbox.write?.(input + '\n');
+		sandbox?.write?.(input + '\n');
 		input = '';
 	}
 
@@ -128,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));
@@ -146,11 +201,23 @@
 			args: string[] = [],
 			options: SandboxExecutionOptions = {}
 		) {
+			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(path, code, log, args, options)),
+				initSandbox(language).then(() =>
+					sandbox.load(code, log, args, options, loadProgress)
+				),
 				initTerm(false)
 			]);
-			return !!(await runSandbox(sandbox.run(code, true, log, prog, args, options)));
+			prepareProgress?.set?.(0);
+			return !!(await runSandbox(
+				sandbox.run(code, true, log, prepareProgress, args, options)
+			));
 		},
 		async run(
 			language: string,
@@ -161,7 +228,7 @@
 			options: SandboxExecutionOptions = {}
 		) {
 			await Promise.all([
-				initSandbox(language).then(() => sandbox.load(path, code, log, args, options)),
+				initSandbox(language).then(() => sandbox.load(code, log, args, options, prog)),
 				initTerm()
 			]);
 			return await runSandbox(sandbox.run(code, false, log, prog, args, options));
@@ -171,18 +238,36 @@
 			term?.dispose();
 			if (sandbox) await sandbox.clear();
 		},
+		async stop() {
+			await wait();
+			stopRequested = true;
+			finish = true;
+			if (sandbox?.kill) sandbox.kill();
+			else sandbox?.terminate?.();
+		},
 		async debugCommand(command: DebugCommand) {
 			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?.();
 		}
 	};
 
@@ -214,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();
@@ -233,12 +328,13 @@
 					) {
 						appendInputText(e.key);
 					}
-				} else if ((ev.ctrlKey || ev.metaKey) && ev.key === 'c') {
+				} else if (isCopyShortcut) {
+					ev.preventDefault();
 					sandbox.kill?.();
-				} else if ((ev.ctrlKey || ev.metaKey) && ev.key === 'd') {
+				} else if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'd') {
 					if (input.length > 0) submitCurrentInput();
-					else sandbox.eof?.();
-				} else if ((ev.ctrlKey || ev.metaKey) && ev.key === 'v') {
+					sandbox?.eof?.();
+				} else if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'v') {
 					navigator.clipboard.readText().then((text) => {
 						applyPastedText(text);
 					});
@@ -258,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>
@@ -272,4 +369,10 @@
 		width: 100%;
 		height: 100%;
 	}
+
+	:global(.xterm),
+	:global(.xterm .xterm-viewport),
+	:global(.xterm .composition-view) {
+		background-color: transparent;
+	}
 </style>

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

@@ -1,9 +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: '#111827',
+        background: 'rgba(0, 0, 0, 0)',
         cursor: '#FFFFFF',
         cursorAccent: '#ffffff',
         selection: '#ffffff44',
@@ -24,7 +24,7 @@ const theme = {
     },
     Tango_Light: {
         foreground: '#111',
-        background: '#FFFFFF',
+        background: 'rgba(255, 255, 255, 0)',
         cursor: '#000000',
         cursorAccent: '#000000',
         selection: '#00000044',

package/dist/terminal/types.d.ts

@@ -7,8 +7,12 @@ export interface TerminalControl {
     prepare: (language: string, code: string, log?: boolean, prog?: ProgressLike, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean>;
     run: (language: string, code: string, log?: boolean, prog?: ProgressLike, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean | string>;
     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,13 +1,16 @@
 {
 	"name": "wasm-idle",
-	"version": "0.4.0",
-	"description": "A simple web app to run C++/Python code in the browser",
+	"version": "0.5.0",
+	"description": "A simple web app to run C++/Python/Java code in the browser",
 	"license": "MIT",
 	"type": "module",
 	"scripts": {
 		"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",
@@ -22,32 +25,35 @@
 		"@eslint/js": "^10.0.1",
 		"@sveltejs/adapter-auto": "^7.0.1",
 		"@sveltejs/adapter-static": "^3.0.10",
-		"@sveltejs/kit": "^2.53.4",
+		"@sveltejs/kit": "^2.55.0",
 		"@sveltejs/package": "^2.5.7",
-		"@sveltejs/vite-plugin-svelte": "^6.2.4",
+		"@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.0",
-		"@typescript-eslint/parser": "^8.57.0",
-		"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": "^28.1.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.53.10",
+		"svelte": "^5.55.0",
 		"svelte-check": "^4.4.5",
 		"tslib": "^2.8.1",
 		"typescript": "^5.9.3",
-		"typescript-eslint": "^8.57.0",
-		"vite": "^7.3.1",
-		"vitest": "^4.0.18"
+		"typescript-eslint": "^8.57.1",
+		"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",