wasm-idle 0.2.5 → 0.3.1

package/dist/playground/sandbox.d.ts

@@ -1,12 +1,25 @@
+import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { Writable } from 'svelte/store';
+type ProgressLike = Writable<number> | {
+    set?: (value: number) => void;
+};
 export interface Sandbox {
     constructor: any;
     eof: () => void;
-    load: (path: string, code?: string, log?: boolean) => Promise<void>;
-    run: (code: string, prepare: boolean, log?: boolean) => Promise<string>;
+    load: (path: string, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions) => Promise<void>;
+    run: (code: string, prepare: boolean, log?: boolean, prog?: ProgressLike, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean | string>;
     terminate: () => void;
     clear: () => Promise<void>;
     kill?: () => void;
     write?: (data: string) => void;
     output?: (data: string) => void;
+    ondebug?: (event: DebugSessionEvent) => void;
+    debugCommand?: (command: DebugCommand) => void;
+    image?: (data: {
+        mime: string;
+        b64: string;
+        ts?: number;
+    }) => void;
     elapse?: number;
 }
+export {};

package/dist/playground/worker/clang.js

@@ -3,11 +3,12 @@ self.document = {
         return [];
     }
 };
-let stdinBufferClang, interruptBufferClang, clang;
+let stdinBufferClang, debugBufferClang, interruptBufferClang, clang;
 async function loadClang(path, log) {
     const { default: Clang } = await import('../../clang');
     clang = new Clang({
         stdout: (output) => postMessage({ output }),
+        onDebugEvent: (debugEvent) => postMessage({ debugEvent }),
         stdin: () => {
             while (true) {
                 postMessage({ buffer: true });
@@ -33,16 +34,24 @@ async function loadClang(path, log) {
     });
 }
 self.onmessage = async (event) => {
-    const { code, buffer, load, interrupt, log, path, prepare, args } = event.data;
+    const { code, buffer, debugBuffer, load, interrupt, log, path, prepare, args, debug, breakpoints, pauseOnEntry } = event.data;
     if (load) {
         await loadClang(path, log);
         postMessage({ load: true });
     }
     else if (prepare) {
         stdinBufferClang = new Int32Array(buffer);
+        debugBufferClang = new Int32Array(debugBuffer);
         interruptBufferClang = new Uint8Array(interrupt);
         try {
-            await clang.compileLink(code, { args });
+            await clang.compileLink(code, {
+                args,
+                debug,
+                breakpoints,
+                pauseOnEntry,
+                debugBuffer: debugBufferClang,
+                interruptBuffer: interruptBufferClang
+            });
             self.postMessage({ results: true });
         }
         catch (error) {
@@ -52,9 +61,17 @@ self.onmessage = async (event) => {
     else if (code) {
         clang.log = log;
         stdinBufferClang = new Int32Array(buffer);
+        debugBufferClang = new Int32Array(debugBuffer);
         interruptBufferClang = new Uint8Array(interrupt);
         try {
-            await clang.compileLinkRun(code, { args });
+            await clang.compileLinkRun(code, {
+                args,
+                debug,
+                breakpoints,
+                pauseOnEntry,
+                debugBuffer: debugBufferClang,
+                interruptBuffer: interruptBufferClang
+            });
             self.postMessage({ results: true });
         }
         catch (error) {

package/dist/playground/worker/python.js

@@ -6,12 +6,200 @@ self.document = {
         return [];
     }
 };
-let stdinBufferPyodide, interruptBufferPyodide, pyodide, path = '';
+let stdinBufferPyodide, interruptBufferPyodide, pyodide, path = '', packageBaseUrl = '';
+let jungolRobotReady = false;
+const imageHook = `
+if not globals().get("__wasm_idle_img_inited__", False):
+    globals()["__wasm_idle_img_inited__"] = True
+    import base64, io, time
+    try:
+        from js import postMessage
+    except Exception:
+        postMessage = None
+    _MAX_WIDTH = 1280
+    _MAX_HEIGHT = 720
+    _WEBP_QUALITY = 85
+    try:
+        from PIL import Image
+        _RESAMPLE = Image.Resampling.LANCZOS if hasattr(Image, "Resampling") else Image.LANCZOS
+    except Exception:
+        Image = None
+        _RESAMPLE = None
+
+    def __wasm_idle_rasterize_svg(raw):
+        try:
+            import cairosvg
+            return cairosvg.svg2png(bytestring=raw)
+        except Exception:
+            return None
+
+    def __wasm_idle_to_webp(raw):
+        if Image is None or _RESAMPLE is None:
+            return None
+        try:
+            img = Image.open(io.BytesIO(raw))
+            img.load()
+            if _MAX_WIDTH > 0 and _MAX_HEIGHT > 0:
+                img.thumbnail((_MAX_WIDTH, _MAX_HEIGHT), _RESAMPLE)
+            if img.mode not in ("RGB", "RGBA"):
+                img = img.convert("RGBA" if "A" in img.mode else "RGB")
+            buf = io.BytesIO()
+            img.save(buf, format="WEBP", quality=_WEBP_QUALITY, method=6)
+            return buf.getvalue()
+        except Exception:
+            return None
+
+    def __wasm_idle_send_img(mime, raw):
+        try:
+            if postMessage is None:
+                return
+            if raw is None:
+                return
+            if isinstance(raw, str):
+                raw_bytes = raw.encode("utf-8")
+            else:
+                raw_bytes = raw
+            if mime == "image/svg+xml":
+                raster = __wasm_idle_rasterize_svg(raw_bytes)
+                if raster:
+                    raw_bytes = raster
+                    mime = "image/png"
+            webp = __wasm_idle_to_webp(raw_bytes)
+            if webp:
+                raw_bytes = webp
+                mime = "image/webp"
+            b64 = base64.b64encode(raw_bytes).decode("ascii")
+            ts = int(time.time() * 1000)
+            postMessage({"type": "img", "data": {"mime": mime, "b64": b64, "ts": ts}})
+        except Exception:
+            pass
+
+    def __wasm_idle_capture_fig(fig):
+        try:
+            buf = io.BytesIO()
+            fig.savefig(buf, format="png", bbox_inches="tight")
+            __wasm_idle_send_img("image/png", buf.getvalue())
+            buf.close()
+        except Exception:
+            pass
+
+    try:
+        import matplotlib
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+        from matplotlib.figure import Figure
+        _orig_show = plt.show
+
+        def _show(*args, **kwargs):
+            try:
+                figs = [plt.figure(num) for num in plt.get_fignums()]
+                if not figs:
+                    figs = [plt.gcf()]
+                for fig in figs:
+                    __wasm_idle_capture_fig(fig)
+                plt.close("all")
+            except Exception:
+                pass
+            try:
+                return _orig_show(*args, **kwargs)
+            except Exception:
+                return None
+
+        plt.show = _show
+
+        _orig_fig_show = Figure.show
+
+        def _fig_show(self, *args, **kwargs):
+            try:
+                __wasm_idle_capture_fig(self)
+            except Exception:
+                pass
+            try:
+                return _orig_fig_show(self, *args, **kwargs)
+            except Exception:
+                return None
+
+        Figure.show = _fig_show
+    except Exception:
+        pass
+
+    try:
+        from IPython import display as _ip_display
+        _orig_display = _ip_display.display
+
+        def _display(*objs, **kwargs):
+            for obj in objs:
+                try:
+                    if hasattr(obj, "_repr_png_"):
+                        data = obj._repr_png_()
+                        if data:
+                            __wasm_idle_send_img("image/png", data)
+                            continue
+                    if hasattr(obj, "_repr_svg_"):
+                        data = obj._repr_svg_()
+                        if data:
+                            __wasm_idle_send_img("image/svg+xml", data)
+                            continue
+                except Exception:
+                    pass
+            try:
+                return _orig_display(*objs, **kwargs)
+            except Exception:
+                return None
+
+        _ip_display.display = _display
+    except Exception:
+        pass
+`;
+const cdnFallbackUrl = (version) => version ? `https://cdn.jsdelivr.net/pyodide/v${version}/full/` : '';
 async function loadPyodide(path) {
     if (pyodide)
         return;
     const { loadPyodide } = await import('pyodide');
     pyodide = await loadPyodide({ indexURL: path + '/pyodide' });
+    packageBaseUrl = path + '/pyodide';
+    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;
+    try {
+        await pyodide.loadPackagesFromImports(code);
+    }
+    catch (e) {
+        const fallback = cdnFallbackUrl(pyodide?.version || '');
+        const setCdnUrl = pyodide?.setCdnUrl;
+        if (fallback && fallback !== packageBaseUrl && typeof setCdnUrl === 'function') {
+            setCdnUrl(fallback);
+            packageBaseUrl = fallback;
+            await pyodide.loadPackagesFromImports(code);
+            return;
+        }
+        throw e;
+    }
 }
 self.onmessage = async (event) => {
     const { code, buffer, load, interrupt, path: _p, prepare } = event.data;
@@ -19,6 +207,7 @@ self.onmessage = async (event) => {
         path = _p;
         postMessage({ output: 'Loading Pyodide...' });
         await loadPyodide(path);
+        await ensureRobotJungol();
         postMessage({ output: ' Done.\n\r' });
         postMessage({ load: true });
     }
@@ -26,7 +215,8 @@ self.onmessage = async (event) => {
         postMessage({ output: 'Loading packages...' });
         try {
             await loadPyodide(path);
-            await pyodide.loadPackagesFromImports(code);
+            await ensureRobotJungol();
+            await loadPackages(code);
             postMessage({ output: ' Done.\n\r' });
             self.postMessage({ results: true });
         }
@@ -36,7 +226,8 @@ self.onmessage = async (event) => {
     }
     else if (code) {
         await loadPyodide(path);
-        await pyodide.loadPackagesFromImports(code);
+        await ensureRobotJungol();
+        await loadPackages(code);
         const ts = Date.now();
         stdinBufferPyodide = new Int32Array(buffer);
         interruptBufferPyodide = new Uint8Array(interrupt);
@@ -103,6 +294,8 @@ print = __pyodide__output_${ts}
 __builtins__.input = __pyodide__input_${ts}
 __builtins__.print = __pyodide__output_${ts}
 
+${imageHook}
+
 ${code}`);
             self.postMessage({ results: true });
         }

package/dist/terminal/Terminal.svelte

@@ -1,12 +1,13 @@
 <script lang="ts">
+	import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from '../playground/options';
 	import type { Sandbox } from '../playground/sandbox';
+	import type { TerminalControl } from './types';
 	import { Theme, registerAllPlugins } from './';
 	import load from '../playground';
 	import { onMount } from 'svelte';
 	import '@xterm/xterm/css/xterm.css';
 	import type { Terminal as TerminalType } from '@xterm/xterm';
 
-	type TerminalControl = typeof terminalControl;
 	interface Props {
 		dark?: boolean;
 		path?: string;
@@ -15,6 +16,8 @@
 		onload?: () => void;
 		onfinish?: () => void;
 		onkey?: (e: KeyboardEvent) => void;
+		ondebug?: (event: DebugSessionEvent) => void;
+		onimage?: (payload: { mime: string; b64: string; ts?: number }) => void;
 		terminal?: TerminalControl;
 	}
 
@@ -25,6 +28,8 @@
 		onload,
 		onfinish,
 		onkey,
+		ondebug,
+		onimage,
 		terminal = $bindable()
 	}: Props = $props();
 
@@ -62,11 +67,13 @@
 			await sandbox.clear();
 			ll = language;
 		}
+		sandbox.image = onimage;
+		sandbox.ondebug = ondebug;
 		sandbox.output = (output: string) =>
 			_tc === tc && term && term.write(output.replaceAll('\n', '\r\n'));
 	}
 
-	function runSandbox(pr: Promise<boolean>) {
+	function runSandbox<T>(pr: Promise<T>) {
 		return pr
 			.then((x) => {
 				term?.write(`\r\nProcess finished after ${sandbox.elapse}ms\u001B[?25l`);
@@ -76,11 +83,10 @@
 				term?.write(`\r\n\x1B[1;3;31m${msg}\u001B[?25l`);
 				return false;
 			})
-			.finally((ret) => {
+			.finally(() => {
 				onfinish?.();
 				finish = true;
 				if (term) term.options.cursorBlink = false;
-				return ret;
 			});
 	}
 
@@ -94,7 +100,7 @@
 		first = false;
 	}
 
-	const terminalControl = {
+	const terminalControl: TerminalControl = {
 		async clear() {
 			await wait();
 			term?.reset();
@@ -103,25 +109,43 @@
 			first = true;
 			await new Promise((r) => setTimeout(r, 100));
 		},
-		async prepare(language: string, code: string, log = true, prog, args) {
+		async prepare(
+			language: string,
+			code: string,
+			log = true,
+			prog?: { set?: (value: number) => void },
+			args: string[] = [],
+			options: SandboxExecutionOptions = {}
+		) {
 			await Promise.all([
-				initSandbox(language).then(() => sandbox.load(path, code, log)),
+				initSandbox(language).then(() => sandbox.load(path, code, log, args, options)),
 				initTerm(false)
 			]);
-			return await runSandbox(sandbox.run(code, true, log, prog, args));
+			return !!(await runSandbox(sandbox.run(code, true, log, prog, args, options)));
 		},
-		async run(language: string, code: string, log = true, prog, args) {
+		async run(
+			language: string,
+			code: string,
+			log = true,
+			prog?: { set?: (value: number) => void },
+			args: string[] = [],
+			options: SandboxExecutionOptions = {}
+		) {
 			await Promise.all([
-				initSandbox(language).then(() => sandbox.load(path, code, log)),
+				initSandbox(language).then(() => sandbox.load(path, code, log, args, options)),
 				initTerm()
 			]);
-			return await runSandbox(sandbox.run(code, false, log, prog, args));
+			return await runSandbox(sandbox.run(code, false, log, prog, args, options));
 		},
 		async destroy() {
 			await wait();
 			term?.dispose();
 			if (sandbox) await sandbox.clear();
 		},
+		async debugCommand(command: DebugCommand) {
+			await wait();
+			sandbox.debugCommand?.(command);
+		},
 		async write(input: string) {
 			await wait();
 			term?.write(input + '\r\n');

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

@@ -1,18 +1,21 @@
+import type { DebugSessionEvent } from '../playground/options';
+import type { TerminalControl } from './types';
 import '@xterm/xterm/css/xterm.css';
-declare const Terminal: import("svelte").Component<{
+interface Props {
     dark?: boolean;
     path?: string;
     font?: string;
     onload?: () => void;
     onfinish?: () => void;
     onkey?: (e: KeyboardEvent) => void;
-    terminal?: {
-        clear(): Promise<void>;
-        prepare(language: string, code: string, log: boolean | undefined, prog: any, args: any): Promise<boolean>;
-        run(language: string, code: string, log: boolean | undefined, prog: any, args: any): Promise<boolean>;
-        destroy(): Promise<void>;
-        write(input: string): Promise<void>;
-    };
-}, {}, "terminal">;
+    ondebug?: (event: DebugSessionEvent) => void;
+    onimage?: (payload: {
+        mime: string;
+        b64: string;
+        ts?: number;
+    }) => void;
+    terminal?: TerminalControl;
+}
+declare const Terminal: import("svelte").Component<Props, {}, "terminal">;
 type Terminal = ReturnType<typeof Terminal>;
 export default Terminal;

package/dist/terminal/index.d.ts

@@ -1,5 +1,7 @@
 import Theme from './theme';
 import registerAllPlugins from './plugin';
 import Terminal from './Terminal.svelte';
+import type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions, TerminalControl } from './types';
 export { Theme, registerAllPlugins };
+export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions, TerminalControl };
 export default Terminal;

package/dist/terminal/theme.js

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

package/dist/terminal/types.d.ts

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

package/dist/terminal/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wasm-idle",
-	"version": "0.2.5",
+	"version": "0.3.1",
 	"description": "A simple web app to run C++/Python code in the browser",
 	"license": "MIT",
 	"type": "module",
@@ -10,49 +10,58 @@
 		"preview": "vite preview",
 		"package": "svelte-kit sync && svelte-package && publint",
 		"prepublishOnly": "npm run package",
+		"test": "vitest run",
+		"test:watch": "vitest",
 		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
 		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
 		"lint": "prettier --check . && eslint .",
-		"format": "prettier --write ."
+		"format": "prettier --write .",
+		"page": "npm run build && node gh-pages.js"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.19.0",
-		"@sveltejs/adapter-auto": "^4.0.0",
-		"@sveltejs/adapter-static": "^3.0.8",
-		"@sveltejs/kit": "^2.17.1",
-		"@sveltejs/package": "^2.3.10",
-		"@sveltejs/vite-plugin-svelte": "^5.0.3",
-		"@typescript-eslint/eslint-plugin": "^8.23.0",
-		"@typescript-eslint/parser": "^8.23.0",
-		"eslint": "^9.19.0",
-		"eslint-config-prettier": "^10.0.1",
-		"eslint-plugin-svelte": "^2.46.1",
+		"@eslint/js": "^10.0.1",
+		"@sveltejs/adapter-auto": "^7.0.1",
+		"@sveltejs/adapter-static": "^3.0.10",
+		"@sveltejs/kit": "^2.53.4",
+		"@sveltejs/package": "^2.5.7",
+		"@sveltejs/vite-plugin-svelte": "^6.2.4",
+		"@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",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-svelte": "^3.15.2",
 		"eslint-plugin-svelte3": "^4.0.0",
 		"gh-pages": "^6.3.0",
-		"globals": "^15.14.0",
-		"monaco-editor": "^0.52.2",
-		"prettier": "^3.4.2",
-		"prettier-plugin-svelte": "^3.3.3",
-		"svelte": "^5.19.7",
-		"svelte-check": "^4.1.4",
+		"globals": "^17.4.0",
+		"jsdom": "^28.1.0",
+		"monaco-editor": "^0.55.1",
+		"prettier": "^3.8.1",
+		"prettier-plugin-svelte": "^3.5.1",
+		"svelte": "^5.53.10",
+		"svelte-check": "^4.4.5",
 		"tslib": "^2.8.1",
-		"typescript": "^5.7.3",
-		"typescript-eslint": "^8.23.0",
-		"vite": "^6.0.11"
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.57.0",
+		"vite": "^7.3.1",
+		"vitest": "^4.0.18"
 	},
 	"dependencies": {
+		"@hancomac/monaco-languageclient": "^1.1.0",
 		"@xterm/addon-canvas": "^0.7.0",
-		"@xterm/addon-fit": "^0.10.0",
-		"@xterm/addon-ligatures": "^0.9.0",
-		"@xterm/addon-search": "^0.15.0",
-		"@xterm/addon-serialize": "^0.13.0",
-		"@xterm/addon-unicode11": "^0.8.0",
-		"@xterm/addon-web-links": "^0.11.0",
-		"@xterm/addon-webgl": "^0.18.0",
-		"@xterm/xterm": "^5.5.0",
-		"@zip.js/zip.js": "^2.7.57",
-		"publint": "^0.3.3",
-		"pyodide": "0.26.2"
+		"@xterm/addon-fit": "^0.11.0",
+		"@xterm/addon-ligatures": "^0.10.0",
+		"@xterm/addon-search": "^0.16.0",
+		"@xterm/addon-serialize": "^0.14.0",
+		"@xterm/addon-unicode11": "^0.9.0",
+		"@xterm/addon-web-links": "^0.12.0",
+		"@xterm/addon-webgl": "^0.19.0",
+		"@xterm/xterm": "^6.0.0",
+		"@zip.js/zip.js": "^2.8.23",
+		"publint": "^0.3.18",
+		"pyodide": "0.26.2",
+		"vscode-jsonrpc": "^8.2.1"
 	},
 	"files": [
 		"dist",