wasm-idle 0.3.2 → 0.4.0

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);
 					});
 				}
 			});

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

@@ -1,4 +1,4 @@
-import type { DebugSessionEvent } from '../playground/options';
+import type { CompilerDiagnostic, DebugSessionEvent } from '../playground/options';
 import type { TerminalControl } from './types';
 import '@xterm/xterm/css/xterm.css';
 interface Props {
@@ -9,6 +9,7 @@ interface Props {
     onfinish?: () => void;
     onkey?: (e: KeyboardEvent) => void;
     ondebug?: (event: DebugSessionEvent) => void;
+    oncompilediagnostic?: (diagnostic: CompilerDiagnostic) => void;
     onimage?: (payload: {
         mime: string;
         b64: string;

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;
 }
@@ -8,6 +8,7 @@ export interface TerminalControl {
     run: (language: string, code: string, log?: boolean, prog?: ProgressLike, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean | string>;
     destroy: () => 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wasm-idle",
-	"version": "0.3.2",
+	"version": "0.4.0",
 	"description": "A simple web app to run C++/Python code in the browser",
 	"license": "MIT",
 	"type": "module",