wasm-idle 0.3.2 → 0.4.1

package/dist/playground/worker/python.js

@@ -1,3 +1,5 @@
+import { flushQueuedStdin, readBufferedStdin, waitForBufferedStdin } from '../stdinBuffer';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
 self.document = {
     querySelector() {
         return null;
@@ -6,8 +8,7 @@ self.document = {
         return [];
     }
 };
-let stdinBufferPyodide, 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
@@ -156,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;
@@ -202,20 +182,22 @@ async function loadPackages(code) {
     }
 }
 self.onmessage = async (event) => {
-    const { code, buffer, load, interrupt, path: _p, prepare } = 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 });
@@ -225,11 +207,13 @@ 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);
+        debugBufferPyodide = new Int32Array(debugBuffer);
+        watchBufferPyodide = new Int32Array(watchBuffer);
+        watchResultBufferPyodide = new Int32Array(watchResultBuffer);
         interruptBufferPyodide = new Uint8Array(interrupt);
         pyodide.setInterruptBuffer(interruptBufferPyodide);
         const toPythonStr = (obj) => {
@@ -246,23 +230,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 +252,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,11 @@
 <script lang="ts">
-	import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from '../playground/options';
+	import type {
+		CompilerDiagnostic,
+		DebugCommand,
+		DebugSessionEvent,
+		SandboxExecutionOptions
+	} from '../playground/options';
+	import type { PlaygroundRuntimeAssets } from '../playground/assets';
 	import type { Sandbox } from '../playground/sandbox';
 	import type { TerminalControl } from './types';
 	import { Theme, registerAllPlugins } from './';
@@ -11,12 +17,14 @@
 	interface Props {
 		dark?: boolean;
 		path?: string;
+		runtimeAssets?: string | PlaygroundRuntimeAssets;
 		font?: string;
 
 		onload?: () => void;
 		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;
 	}
@@ -24,11 +32,13 @@
 	let {
 		dark = false,
 		path = '',
+		runtimeAssets = undefined,
 		font = "'D2 coding', monospace",
 		onload,
 		onfinish,
 		onkey,
 		ondebug,
+		oncompilediagnostic,
 		onimage,
 		terminal = $bindable()
 	}: Props = $props();
@@ -43,7 +53,22 @@
 		first = true,
 		tc = 0,
 		plugin = $state(),
-		ll: string | null = null;
+		ll: string | null = null,
+		stopRequested = false;
+
+	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) => {
@@ -69,6 +94,7 @@
 		}
 		sandbox.image = onimage;
 		sandbox.ondebug = ondebug;
+		sandbox.oncompilerdiagnostic = oncompilediagnostic;
 		sandbox.output = (output: string) =>
 			_tc === tc && term && term.write(output.replaceAll('\n', '\r\n'));
 	}
@@ -80,10 +106,12 @@
 				return x;
 			})
 			.catch((msg) => {
+				if (stopRequested) return false;
 				term?.write(`\r\n\x1B[1;3;31m${msg}\u001B[?25l`);
 				return false;
 			})
 			.finally(() => {
+				stopRequested = false;
 				onfinish?.();
 				finish = true;
 				if (term) term.options.cursorBlink = false;
@@ -94,18 +122,40 @@
 		await wait();
 		if (!term) return;
 		term.options.cursorBlink = blink;
+		term.write('\u001B[?25h');
 		term.focus();
 
 		if (!first) term?.write(`\r\n\x1b[0m`);
 		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));
 		},
@@ -117,11 +167,18 @@
 			args: string[] = [],
 			options: SandboxExecutionOptions = {}
 		) {
+			const loadProgress = phaseProgress(prog, 0, 0.85);
+			const prepareProgress = phaseProgress(prog, 0.85, 0.99);
 			await Promise.all([
-				initSandbox(language).then(() => sandbox.load(path, code, log, args, options)),
+				initSandbox(language).then(() =>
+					sandbox.load(runtimeAssets || path, 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,
@@ -132,7 +189,9 @@
 			options: SandboxExecutionOptions = {}
 		) {
 			await Promise.all([
-				initSandbox(language).then(() => sandbox.load(path, code, log, args, options)),
+				initSandbox(language).then(() =>
+					sandbox.load(runtimeAssets || path, code, log, args, options, prog)
+				),
 				initTerm()
 			]);
 			return await runSandbox(sandbox.run(code, false, log, prog, args, options));
@@ -142,14 +201,25 @@
 			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 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 +256,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 +268,23 @@
 							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.toLowerCase() === 'c') {
+					if (term.hasSelection()) {
+						const selectedText = term.getSelection();
+						if (selectedText) {
+							navigator.clipboard.writeText(selectedText).catch(() => {});
+							return;
+						}
 					}
-				} else if ((ev.ctrlKey || ev.metaKey) && ev.key === 'c') {
-					sandbox.kill?.();
-				} else if ((ev.ctrlKey || ev.metaKey) && ev.key === 'd') {
 					sandbox.kill?.();
-				} else if ((ev.ctrlKey || ev.metaKey) && ev.key === 'v') {
+				} 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.toLowerCase() === 'v') {
 					navigator.clipboard.readText().then((text) => {
-						term?.write(text);
-						sandbox.write?.(text);
+						applyPastedText(text);
 					});
 				}
 			});
@@ -242,4 +316,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,14 +1,17 @@
-import type { DebugSessionEvent } from '../playground/options';
+import type { CompilerDiagnostic, DebugSessionEvent } from '../playground/options';
+import type { PlaygroundRuntimeAssets } from '../playground/assets';
 import type { TerminalControl } from './types';
 import '@xterm/xterm/css/xterm.css';
 interface Props {
     dark?: boolean;
     path?: string;
+    runtimeAssets?: string | PlaygroundRuntimeAssets;
     font?: string;
     onload?: () => void;
     onfinish?: () => void;
     onkey?: (e: KeyboardEvent) => void;
     ondebug?: (event: DebugSessionEvent) => void;
+    oncompilediagnostic?: (diagnostic: CompilerDiagnostic) => void;
     onimage?: (payload: {
         mime: string;
         b64: string;

package/dist/terminal/theme.js

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

package/dist/terminal/types.d.ts

@@ -1,4 +1,4 @@
-import type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions } from '../playground/options';
+import type { CompilerDiagnostic, DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions } from '../playground/options';
 export interface ProgressLike {
     set?: (value: number) => void;
 }
@@ -7,7 +7,9 @@ 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>;
+    debugEvaluate?: (expression: string) => Promise<string>;
     write: (input: string) => Promise<void>;
 }
-export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions };
+export type { CompilerDiagnostic, DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions };