wasm-idle 0.3.1 → 0.4.0

package/dist/playground/worker/java.js

@@ -0,0 +1,248 @@
+import { prepareJavaStdinInjection } from '../javaStdin';
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { resolveTeaVmAssetUrl } from '../teavmConfig';
+let compilerLib = null;
+let compiler = null;
+let runtimeLoad = null;
+let loadedBaseUrl = '';
+let stdoutBuffer = '';
+let stderrBuffer = '';
+let stdinBufferJava = null;
+let stdinChunkJava = new Uint8Array(0);
+let stdinChunkOffsetJava = 0;
+let compiledCode = '';
+let compiledStdin = '';
+let compiledMainClass = '';
+let compiledWasm = null;
+let currentSourcePath = '';
+const isGzip = (bytes) => bytes.length >= 2 && bytes[0] === 0x1f && bytes[1] === 0x8b;
+const maybeDecompressWasm = async (bytes) => {
+    if (!isGzip(bytes))
+        return bytes;
+    if (typeof DecompressionStream === 'undefined') {
+        throw new Error('Generated WebAssembly is gzip-compressed, but DecompressionStream is unavailable');
+    }
+    const stream = new Blob([Uint8Array.from(bytes)])
+        .stream()
+        .pipeThrough(new DecompressionStream('gzip'));
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+};
+const flushStdout = () => {
+    if (!stdoutBuffer)
+        return;
+    self.postMessage({ output: stdoutBuffer });
+    stdoutBuffer = '';
+};
+const flushStderr = () => {
+    if (!stderrBuffer)
+        return;
+    self.postMessage({ output: stderrBuffer });
+    stderrBuffer = '';
+};
+const pushStdout = (charCode) => {
+    stdoutBuffer += String.fromCharCode(charCode);
+    if (charCode === 10)
+        flushStdout();
+};
+const pushStderr = (charCode) => {
+    stderrBuffer += String.fromCharCode(charCode);
+    if (charCode === 10)
+        flushStderr();
+};
+self.addEventListener('message', async (event) => {
+    const { load, baseUrl, buffer, code, prepare, args = [], stdin = '' } = event.data;
+    try {
+        if (load) {
+            if (!compiler || loadedBaseUrl !== baseUrl) {
+                loadedBaseUrl = baseUrl;
+                const runtimeSource = await fetch(resolveTeaVmAssetUrl(baseUrl, 'compiler.wasm-runtime.js')).then((response) => {
+                    if (!response.ok)
+                        throw new Error(`Failed to load TeaVM compiler runtime: ${response.status}`);
+                    return response.text();
+                });
+                const runtimeUrl = URL.createObjectURL(new Blob([runtimeSource], { type: 'text/javascript;charset=utf-8' }));
+                const runtimeModule = await import(/* @vite-ignore */ runtimeUrl);
+                const runtimeLoadFn = runtimeModule.load;
+                runtimeLoad = runtimeLoadFn;
+                const compilerWasm = await fetch(resolveTeaVmAssetUrl(baseUrl, 'compiler.wasm')).then(async (response) => {
+                    if (!response.ok)
+                        throw new Error(`Failed to load TeaVM compiler wasm: ${response.status}`);
+                    return await maybeDecompressWasm(new Uint8Array(await response.arrayBuffer()));
+                });
+                const compilerModule = await runtimeLoadFn(compilerWasm, {
+                    stackDeobfuscator: { enabled: false }
+                });
+                compilerLib = compilerModule.exports;
+                compiler = compilerLib.createCompiler();
+                const [sdk, runtimeClasslib] = await Promise.all([
+                    fetch(resolveTeaVmAssetUrl(baseUrl, 'compile-classlib-teavm.bin')).then(async (response) => {
+                        if (!response.ok)
+                            throw new Error(`Failed to load TeaVM SDK: ${response.status}`);
+                        return new Int8Array(await response.arrayBuffer());
+                    }),
+                    fetch(resolveTeaVmAssetUrl(baseUrl, 'runtime-classlib-teavm.bin')).then(async (response) => {
+                        if (!response.ok)
+                            throw new Error(`Failed to load TeaVM runtime classlib: ${response.status}`);
+                        return new Int8Array(await response.arrayBuffer());
+                    })
+                ]);
+                compiler.setSdk(sdk);
+                compiler.setTeaVMClasslib(runtimeClasslib);
+                compiledCode = '';
+                compiledStdin = '';
+                compiledMainClass = '';
+                compiledWasm = null;
+            }
+            self.postMessage({ load: true });
+            return;
+        }
+        if (!compiler || !runtimeLoad)
+            throw new Error('TeaVM compiler not loaded');
+        stdoutBuffer = '';
+        stderrBuffer = '';
+        const stdinInjection = prepareJavaStdinInjection(code, stdin);
+        if (prepare ||
+            compiledCode !== code ||
+            compiledStdin !== stdinInjection.stdinCacheKey ||
+            !compiledWasm) {
+            const packageMatch = code.match(/^\s*package\s+([A-Za-z_][\w.]*)\s*;/m);
+            const typeMatch = code.match(/^\s*public\s+(?:final\s+|abstract\s+)?(?:class|record|enum|interface)\s+([A-Za-z_]\w*)\b/m) ||
+                code.match(/^\s*(?:final\s+|abstract\s+)?(?:class|record|enum|interface)\s+([A-Za-z_]\w*)\b/m);
+            const className = typeMatch?.[1];
+            if (!className)
+                throw new Error('Java source must define a top-level class, record, enum, or interface');
+            const packageName = packageMatch?.[1] || '';
+            const sourcePath = packageName
+                ? `${packageName.replaceAll('.', '/')}/${className}.java`
+                : `${className}.java`;
+            const mainClass = packageName ? `${packageName}.${className}` : className;
+            currentSourcePath = sourcePath;
+            const diagnosticLines = [];
+            const diagnosticRegistration = compiler.onDiagnostic((diagnostic) => {
+                const severity = diagnostic.severity
+                    ? String(diagnostic.severity).toLowerCase()
+                    : 'error';
+                const location = diagnostic.fileName
+                    ? `${diagnostic.fileName}:${diagnostic.lineNumber || 0}${diagnostic.columnNumber ? `:${diagnostic.columnNumber}` : ''}`
+                    : 'TeaVM';
+                diagnosticLines.push(`${location}: ${severity}: ${diagnostic.message}`);
+                const fileName = diagnostic.fileName ? String(diagnostic.fileName) : null;
+                if (fileName &&
+                    fileName !== currentSourcePath &&
+                    fileName !== currentSourcePath.split('/').pop()) {
+                    return;
+                }
+                self.postMessage({
+                    diagnostic: {
+                        fileName,
+                        lineNumber: Number(diagnostic.lineNumber) || 1,
+                        columnNumber: Number(diagnostic.columnNumber) || 1,
+                        severity: severity === 'warning'
+                            ? 'warning'
+                            : severity === 'other'
+                                ? 'other'
+                                : 'error',
+                        message: String(diagnostic.message || '')
+                    }
+                });
+            });
+            const disposeDiagnosticRegistration = () => {
+                if (typeof diagnosticRegistration === 'function') {
+                    diagnosticRegistration();
+                    return;
+                }
+                diagnosticRegistration?.destroy?.();
+            };
+            compiler.clearSourceFiles?.();
+            compiler.clearInputClassFiles?.();
+            compiler.clearOutputFiles?.();
+            compiler.addSourceFile(sourcePath, stdinInjection.transformedCode);
+            if (stdinInjection.usesStdin &&
+                stdinInjection.helperSourcePath &&
+                stdinInjection.helperSource) {
+                compiler.addSourceFile(stdinInjection.helperSourcePath, stdinInjection.helperSource);
+            }
+            const javacOk = compiler.compile();
+            if (!javacOk) {
+                disposeDiagnosticRegistration();
+                throw new Error(diagnosticLines.join('\n') || 'TeaVM javac compilation failed');
+            }
+            const mainClasses = Array.from(compiler.detectMainClasses());
+            if (mainClasses.length !== 1) {
+                disposeDiagnosticRegistration();
+                throw new Error(mainClasses.length === 0
+                    ? 'Main method not found'
+                    : 'Multiple main methods found');
+            }
+            const generateOk = compiler.generateWebAssembly({
+                outputName: 'app',
+                mainClass
+            });
+            disposeDiagnosticRegistration();
+            if (!generateOk) {
+                throw new Error(diagnosticLines.join('\n') || 'TeaVM WebAssembly generation failed');
+            }
+            compiledCode = code;
+            compiledStdin = stdinInjection.stdinCacheKey;
+            compiledMainClass = mainClass;
+            compiledWasm = await maybeDecompressWasm(new Uint8Array(compiler.getWebAssemblyOutputFile('app.wasm')));
+        }
+        if (prepare) {
+            self.postMessage({ results: true });
+            return;
+        }
+        stdinBufferJava = new Int32Array(buffer);
+        const workerGlobal = globalThis;
+        const previousWindow = workerGlobal.window;
+        workerGlobal.window = workerGlobal;
+        workerGlobal.wasmIdleJavaStdin = {
+            readByte() {
+                while (true) {
+                    if (stdinChunkOffsetJava < stdinChunkJava.length) {
+                        return stdinChunkJava[stdinChunkOffsetJava++] ?? -1;
+                    }
+                    const chunk = waitForBufferedStdin(stdinBufferJava, () => self.postMessage({ buffer: true }));
+                    if (chunk === null) {
+                        return -1;
+                    }
+                    stdinChunkJava = new TextEncoder().encode(chunk);
+                    stdinChunkOffsetJava = 0;
+                }
+            }
+        };
+        try {
+            const module = await runtimeLoad(compiledWasm, {
+                installImports(imports) {
+                    imports.teavmConsole.putcharStdout = pushStdout;
+                    imports.teavmConsole.putcharStderr = pushStderr;
+                },
+                stackDeobfuscator: {
+                    enabled: false
+                }
+            });
+            module.exports.main(args);
+            flushStdout();
+            flushStderr();
+            self.postMessage({ results: true, mainClass: compiledMainClass });
+        }
+        finally {
+            delete workerGlobal.wasmIdleJavaStdin;
+            if (previousWindow === undefined) {
+                Reflect.deleteProperty(workerGlobal, 'window');
+            }
+            else {
+                workerGlobal.window = previousWindow;
+            }
+            stdinChunkJava = new Uint8Array(0);
+            stdinChunkOffsetJava = 0;
+            stdinBufferJava = null;
+        }
+    }
+    catch (error) {
+        flushStdout();
+        flushStderr();
+        self.postMessage({
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+});

package/dist/playground/worker/python.js

@@ -1,3 +1,4 @@
+import { flushQueuedStdin, readBufferedStdin, waitForBufferedStdin } from '../stdinBuffer';
 self.document = {
     querySelector() {
         return null;
@@ -6,7 +7,7 @@ self.document = {
         return [];
     }
 };
-let stdinBufferPyodide, interruptBufferPyodide, pyodide, path = '', packageBaseUrl = '';
+let stdinBufferPyodide, debugBufferPyodide, watchBufferPyodide, watchResultBufferPyodide, interruptBufferPyodide, pyodide, path = '', packageBaseUrl = '';
 let jungolRobotReady = false;
 const imageHook = `
 if not globals().get("__wasm_idle_img_inited__", False):
@@ -202,7 +203,7 @@ async function loadPackages(code) {
     }
 }
 self.onmessage = async (event) => {
-    const { code, buffer, load, interrupt, path: _p, prepare } = event.data;
+    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, path: _p, prepare, debug = false, breakpoints = [], pauseOnEntry = false } = event.data;
     if (load) {
         path = _p;
         postMessage({ output: 'Loading Pyodide...' });
@@ -230,6 +231,9 @@ self.onmessage = async (event) => {
         await loadPackages(code);
         const ts = Date.now();
         stdinBufferPyodide = new Int32Array(buffer);
+        debugBufferPyodide = new Int32Array(debugBuffer);
+        watchBufferPyodide = new Int32Array(watchBuffer);
+        watchResultBufferPyodide = new Int32Array(watchResultBuffer);
         interruptBufferPyodide = new Uint8Array(interrupt);
         pyodide.setInterruptBuffer(interruptBufferPyodide);
         const toPythonStr = (obj) => {
@@ -246,23 +250,7 @@ self.onmessage = async (event) => {
         self.prompt = self['__pyodide__input_' + ts] = (output) => {
             if (output)
                 postMessage({ output });
-            while (true) {
-                postMessage({ buffer: true });
-                const res = Atomics.wait(stdinBufferPyodide, 0, 0, 100);
-                if (res === 'not-equal') {
-                    try {
-                        const cpy = new Int32Array(stdinBufferPyodide.byteLength);
-                        cpy.set(stdinBufferPyodide);
-                        stdinBufferPyodide.fill(0);
-                        const dec = new TextDecoder();
-                        const strInfo = dec.decode(cpy).replace(/\x00/g, ''), padding = parseInt(strInfo.slice(-1));
-                        return strInfo.slice(0, -padding);
-                    }
-                    catch (e) {
-                        postMessage({ log: { e } });
-                    }
-                }
-            }
+            return waitForBufferedStdin(stdinBufferPyodide, () => postMessage({ buffer: true }));
         };
         self['__pyodide__output_' + ts] = (...data) => {
             let sep = ' ', end = '\r\n', output = '', clear = [];
@@ -284,24 +272,262 @@ self.onmessage = async (event) => {
             output += end;
             postMessage({ output });
         };
+        const debugPauseName = `__wasm_idle_python_debug_pause_${ts}`;
+        const debugWaitName = `__wasm_idle_python_debug_wait_${ts}`;
+        const debugReadWatchName = `__wasm_idle_python_debug_watch_read_${ts}`;
+        const debugWriteWatchName = `__wasm_idle_python_debug_watch_write_${ts}`;
+        self[debugPauseName] = (line, reason, localsJson, callStackJson) => {
+            let locals = [];
+            let callStack = [];
+            try {
+                locals = JSON.parse(localsJson);
+            }
+            catch {
+                locals = [];
+            }
+            try {
+                callStack = JSON.parse(callStackJson);
+            }
+            catch {
+                callStack = [];
+            }
+            postMessage({
+                debugEvent: {
+                    type: 'pause',
+                    line: Number(line),
+                    reason,
+                    locals,
+                    callStack
+                }
+            });
+        };
+        self[debugWaitName] = () => {
+            const sequence = Atomics.load(debugBufferPyodide, 0);
+            while (true) {
+                if (interruptBufferPyodide?.[0] === 2)
+                    return -1;
+                Atomics.wait(debugBufferPyodide, 0, sequence, 100);
+                if (interruptBufferPyodide?.[0] === 2)
+                    return -1;
+                const command = Atomics.exchange(debugBufferPyodide, 1, 0);
+                if (command)
+                    return command;
+            }
+        };
+        self[debugReadWatchName] = () => readBufferedStdin(watchBufferPyodide) || '';
+        self[debugWriteWatchName] = (value) => {
+            flushQueuedStdin([value], watchResultBufferPyodide);
+        };
+        const userFilename = '__wasm_idle_user__.py';
+        const normalizedBreakpoints = JSON.stringify([...(Array.isArray(breakpoints) ? breakpoints : [])]
+            .map((value) => Number(value))
+            .filter((value) => Number.isInteger(value) && value > 0));
         try {
-            await pyodide.runPythonAsync(`import asyncio
+            await pyodide.runPythonAsync(`import ast
+import builtins
+import inspect
+import json
+import sys
 from js import __pyodide__input_${ts}, __pyodide__output_${ts}
+${debug ? `from js import ${debugPauseName}, ${debugWaitName}` : ''}
+${debug ? `from js import ${debugReadWatchName}, ${debugWriteWatchName}` : ''}
 
-input = __pyodide__input_${ts}
-print = __pyodide__output_${ts}
-
-__builtins__.input = __pyodide__input_${ts}
-__builtins__.print = __pyodide__output_${ts}
+__wasm_idle_input = __pyodide__input_${ts}
+def __wasm_idle_input_wrapper(prompt = ""):
+    value = __wasm_idle_input(prompt)
+    if value is None:
+        raise EOFError
+    return value
+__wasm_idle_output = __pyodide__output_${ts}
+builtins.input = __wasm_idle_input_wrapper
+builtins.print = __wasm_idle_output
 
 ${imageHook}
 
-${code}`);
+${debug
+                ? `
+__wasm_idle_debug_breakpoints = set(${normalizedBreakpoints})
+__wasm_idle_debug_pause_on_entry = ${pauseOnEntry ? 'True' : 'False'}
+__wasm_idle_debug_step_mode = None
+__wasm_idle_debug_resume_skip = None
+__wasm_idle_debug_next_depth = None
+__wasm_idle_debug_next_line = None
+__wasm_idle_debug_step_out_depth = None
+
+def __wasm_idle_debug_depth(frame):
+    depth = 0
+    current = frame
+    while current is not None:
+        if current.f_code.co_filename == "${userFilename}":
+            depth += 1
+        current = current.f_back
+    return depth
+
+def __wasm_idle_debug_preview(value, depth = 0):
+    if depth >= 2:
+        return "..."
+    if value is None:
+        return "None"
+    if isinstance(value, bool):
+        return "True" if value else "False"
+    if isinstance(value, (int, float)):
+        return repr(value)
+    if isinstance(value, (bytes, bytearray)):
+        text = repr(bytes(value))
+        return text if len(text) <= 80 else text[:77] + "..."
+    if isinstance(value, str):
+        text = repr(value)
+        return text if len(text) <= 80 else text[:77] + "..."
+    if isinstance(value, list):
+        items = [__wasm_idle_debug_preview(item, depth + 1) for item in value[:8]]
+        if len(value) > 8:
+            items.append("...")
+        return "[" + ", ".join(items) + "]"
+    if isinstance(value, tuple):
+        items = [__wasm_idle_debug_preview(item, depth + 1) for item in value[:8]]
+        if len(value) > 8:
+            items.append("...")
+        if len(value) == 1 and items:
+            return "(" + items[0] + ",)"
+        return "(" + ", ".join(items) + ")"
+    if isinstance(value, dict):
+        items = []
+        for index, (key, item) in enumerate(value.items()):
+            if index >= 6:
+                items.append("...")
+                break
+            items.append(__wasm_idle_debug_preview(key, depth + 1) + ": " + __wasm_idle_debug_preview(item, depth + 1))
+        return "{" + ", ".join(items) + "}"
+    if isinstance(value, set):
+        items = [__wasm_idle_debug_preview(item, depth + 1) for item in sorted(list(value), key = repr)[:6]]
+        if len(value) > 6:
+            items.append("...")
+        return "{" + ", ".join(items) + "}"
+    try:
+        text = repr(value)
+        return text if len(text) <= 80 else text[:77] + "..."
+    except Exception:
+        return "?"
+
+def __wasm_idle_debug_locals(frame):
+    locals_preview = []
+    for name, value in frame.f_locals.items():
+        if name == "__builtins__" or name.startswith("__wasm_idle_") or name.startswith("."):
+            continue
+        locals_preview.append({"name": name, "value": __wasm_idle_debug_preview(value)})
+    locals_preview.sort(key = lambda item: item["name"])
+    return locals_preview
+
+def __wasm_idle_debug_stack(frame):
+    stack = []
+    current = frame
+    while current is not None:
+        if current.f_code.co_filename == "${userFilename}":
+            stack.append({"functionName": current.f_code.co_name, "line": current.f_lineno})
+        current = current.f_back
+    return stack
+
+def __wasm_idle_debug_trace(frame, event, arg):
+    global __wasm_idle_debug_pause_on_entry
+    global __wasm_idle_debug_step_mode
+    global __wasm_idle_debug_resume_skip
+    global __wasm_idle_debug_next_depth
+    global __wasm_idle_debug_next_line
+    global __wasm_idle_debug_step_out_depth
+
+    if frame.f_code.co_filename != "${userFilename}":
+        return None
+    if event != "line":
+        return __wasm_idle_debug_trace
+
+    depth = __wasm_idle_debug_depth(frame)
+    line = frame.f_lineno
+    if __wasm_idle_debug_resume_skip == (depth, line):
+        return __wasm_idle_debug_trace
+    if __wasm_idle_debug_resume_skip is not None:
+        __wasm_idle_debug_resume_skip = None
+
+    reason = None
+    if __wasm_idle_debug_pause_on_entry:
+        reason = "entry"
+    elif line in __wasm_idle_debug_breakpoints:
+        reason = "breakpoint"
+    elif __wasm_idle_debug_step_mode == "step":
+        reason = "step"
+    elif __wasm_idle_debug_step_mode == "next" and __wasm_idle_debug_next_depth is not None and depth <= __wasm_idle_debug_next_depth and line != __wasm_idle_debug_next_line:
+        reason = "nextLine"
+    elif __wasm_idle_debug_step_mode == "out" and __wasm_idle_debug_step_out_depth is not None and depth <= __wasm_idle_debug_step_out_depth:
+        reason = "stepOut"
+
+    if reason is None:
+        return __wasm_idle_debug_trace
+
+    __wasm_idle_debug_pause_on_entry = False
+    __wasm_idle_debug_step_mode = None
+    __wasm_idle_debug_next_depth = None
+    __wasm_idle_debug_next_line = None
+    __wasm_idle_debug_step_out_depth = None
+
+    ${debugPauseName}(line, reason, json.dumps(__wasm_idle_debug_locals(frame)), json.dumps(__wasm_idle_debug_stack(frame)))
+    while True:
+        command = ${debugWaitName}()
+        if command < 0:
+            raise KeyboardInterrupt()
+        if command != 5:
+            break
+        try:
+            expression = ${debugReadWatchName}()
+            result = __wasm_idle_debug_preview(eval(expression, frame.f_globals, frame.f_locals))
+        except Exception as error:
+            result = "?" if error.__class__.__name__ == "NameError" else "error"
+        ${debugWriteWatchName}(result)
+    __wasm_idle_debug_resume_skip = (depth, line)
+    if command == 2:
+        __wasm_idle_debug_step_mode = "step"
+    elif command == 3:
+        __wasm_idle_debug_step_mode = "next"
+        __wasm_idle_debug_next_depth = depth
+        __wasm_idle_debug_next_line = line
+    elif command == 4:
+        __wasm_idle_debug_step_mode = "out"
+        __wasm_idle_debug_step_out_depth = max(0, depth - 1)
+    return __wasm_idle_debug_trace
+
+sys.settrace(__wasm_idle_debug_trace)
+`
+                : ''}
+
+try:
+    __wasm_idle_globals = {"__name__": "__main__"}
+    __wasm_idle_result = eval(
+        compile(${JSON.stringify(code)}, "${userFilename}", "exec", flags = ast.PyCF_ALLOW_TOP_LEVEL_AWAIT),
+        __wasm_idle_globals,
+        __wasm_idle_globals,
+    )
+    if inspect.isawaitable(__wasm_idle_result):
+        await __wasm_idle_result
+finally:
+    sys.settrace(None)
+    ${debug
+                ? `
+    __wasm_idle_debug_step_mode = None
+    __wasm_idle_debug_resume_skip = None
+    __wasm_idle_debug_next_depth = None
+    __wasm_idle_debug_next_line = None
+    __wasm_idle_debug_step_out_depth = None
+`
+                : ''}
+`);
             self.postMessage({ results: true });
         }
         catch (e) {
             self.postMessage({ error: e.message || 'Unknown error' });
         }
+        finally {
+            delete self[debugPauseName];
+            delete self[debugWaitName];
+            delete self[debugReadWatchName];
+            delete self[debugWriteWatchName];
+        }
     }
 };
-export {};

package/dist/terminal/Terminal.svelte

@@ -1,5 +1,10 @@
 <script lang="ts">
-	import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from '../playground/options';
+	import type {
+		CompilerDiagnostic,
+		DebugCommand,
+		DebugSessionEvent,
+		SandboxExecutionOptions
+	} from '../playground/options';
 	import type { Sandbox } from '../playground/sandbox';
 	import type { TerminalControl } from './types';
 	import { Theme, registerAllPlugins } from './';
@@ -17,6 +22,7 @@
 		onfinish?: () => void;
 		onkey?: (e: KeyboardEvent) => void;
 		ondebug?: (event: DebugSessionEvent) => void;
+		oncompilediagnostic?: (diagnostic: CompilerDiagnostic) => void;
 		onimage?: (payload: { mime: string; b64: string; ts?: number }) => void;
 		terminal?: TerminalControl;
 	}
@@ -29,6 +35,7 @@
 		onfinish,
 		onkey,
 		ondebug,
+		oncompilediagnostic,
 		onimage,
 		terminal = $bindable()
 	}: Props = $props();
@@ -69,6 +76,7 @@
 		}
 		sandbox.image = onimage;
 		sandbox.ondebug = ondebug;
+		sandbox.oncompilerdiagnostic = oncompilediagnostic;
 		sandbox.output = (output: string) =>
 			_tc === tc && term && term.write(output.replaceAll('\n', '\r\n'));
 	}
@@ -100,12 +108,33 @@
 		first = false;
 	}
 
+	function appendInputText(text: string) {
+		if (!text) return;
+		input += text;
+		term?.write(text);
+	}
+
+	function submitCurrentInput() {
+		term?.write('\r\n');
+		sandbox.write?.(input + '\n');
+		input = '';
+	}
+
+	function applyPastedText(text: string) {
+		const lines = text.replaceAll('\r\n', '\n').replaceAll('\r', '\n').split('\n');
+		for (let i = 0; i < lines.length; i++) {
+			appendInputText(lines[i]);
+			if (i < lines.length - 1) submitCurrentInput();
+		}
+	}
+
 	const terminalControl: TerminalControl = {
 		async clear() {
 			await wait();
 			term?.reset();
 			term?.write(`\u001B[?25l\x1b[0m\x1b[?25h`);
 			if (term) term.options.cursorBlink = false;
+			input = '';
 			first = true;
 			await new Promise((r) => setTimeout(r, 100));
 		},
@@ -146,10 +175,14 @@
 			await wait();
 			sandbox.debugCommand?.(command);
 		},
+		async debugEvaluate(expression: string) {
+			await wait();
+			return (await sandbox.debugEvaluate?.(expression)) || '?';
+		},
 		async write(input: string) {
 			await wait();
-			term?.write(input + '\r\n');
-			sandbox.write?.(input.replaceAll('\r', '\n') + '\n');
+			applyPastedText(input);
+			if (!input.endsWith('\n') && !input.endsWith('\r')) submitCurrentInput();
 		}
 	};
 
@@ -186,9 +219,7 @@
 				const printable = !ev.altKey && !ev.ctrlKey && !ev.metaKey;
 				onkey?.(ev);
 				if (ev.key === 'Enter') {
-					term.write('\r\n');
-					sandbox.write?.(input + '\n');
-					input = '';
+					submitCurrentInput();
 				} else if (ev.key === 'Backspace') {
 					if (term.buffer.active.cursorX > 0) {
 						term.write('\b \b');
@@ -200,17 +231,16 @@
 							e.key <= String.fromCharCode(0x7e)) ||
 						e.key >= '\u00a0'
 					) {
-						input += e.key;
-						term.write(e.key);
+						appendInputText(e.key);
 					}
 				} else if ((ev.ctrlKey || ev.metaKey) && ev.key === 'c') {
 					sandbox.kill?.();
 				} else if ((ev.ctrlKey || ev.metaKey) && ev.key === 'd') {
-					sandbox.kill?.();
+					if (input.length > 0) submitCurrentInput();
+					else sandbox.eof?.();
 				} else if ((ev.ctrlKey || ev.metaKey) && ev.key === 'v') {
 					navigator.clipboard.readText().then((text) => {
-						term?.write(text);
-						sandbox.write?.(text);
+						applyPastedText(text);
 					});
 				}
 			});