wasm-idle 0.3.2 → 0.4.1

package/dist/playground/javaStdin.js

@@ -0,0 +1,323 @@
+const JAVA_STDIN_HELPER_CLASS = 'WasmIdleStdin';
+const JAVA_SCANNER_COMPAT_SENTINEL = '// wasm-idle Scanner compatibility shim';
+const JAVA_SCANNER_COMPAT_SHIM = `${JAVA_SCANNER_COMPAT_SENTINEL}
+final class Scanner implements AutoCloseable {
+    private final java.io.InputStream input;
+    private int bufferedChar = Integer.MIN_VALUE;
+    private String bufferedToken = null;
+    private boolean closed = false;
+
+    Scanner(java.io.InputStream input) {
+        this.input = input;
+    }
+
+    Scanner(String source) {
+        this(
+            new java.io.ByteArrayInputStream(
+                source != null ? source.getBytes() : new byte[0]
+            )
+        );
+    }
+
+    private void ensureOpen() {
+        if (closed) {
+            throw new IllegalStateException("Scanner closed");
+        }
+    }
+
+    private int readByteInternal() {
+        try {
+            return input.read();
+        } catch (java.io.IOException error) {
+            throw new RuntimeException(error);
+        }
+    }
+
+    private int readByte() {
+        ensureOpen();
+        if (bufferedChar != Integer.MIN_VALUE) {
+            int value = bufferedChar;
+            bufferedChar = Integer.MIN_VALUE;
+            return value;
+        }
+        return readByteInternal();
+    }
+
+    private int peekByte() {
+        ensureOpen();
+        if (bufferedChar == Integer.MIN_VALUE) {
+            bufferedChar = readByteInternal();
+        }
+        return bufferedChar;
+    }
+
+    private boolean isWhitespace(int value) {
+        return value == ' ' || value == '\\n' || value == '\\r' || value == '\\t' || value == '\\f';
+    }
+
+    private boolean skipWhitespace() {
+        int value = peekByte();
+        while (value != -1 && isWhitespace(value)) {
+            readByte();
+            value = peekByte();
+        }
+        return value != -1;
+    }
+
+    private String readTokenValue() {
+        java.lang.StringBuilder token = new java.lang.StringBuilder();
+        int value = peekByte();
+        while (value != -1 && !isWhitespace(value)) {
+            token.append((char) readByte());
+            value = peekByte();
+        }
+        return token.toString();
+    }
+
+    public boolean hasNext() {
+        ensureOpen();
+        if (bufferedToken != null) {
+            return true;
+        }
+        if (!skipWhitespace()) {
+            return false;
+        }
+        bufferedToken = readTokenValue();
+        return true;
+    }
+
+    public String next() {
+        ensureOpen();
+        if (bufferedToken != null) {
+            String token = bufferedToken;
+            bufferedToken = null;
+            return token;
+        }
+        if (!skipWhitespace()) {
+            throw new RuntimeException("No more tokens");
+        }
+        return readTokenValue();
+    }
+
+    public String nextLine() {
+        ensureOpen();
+        java.lang.StringBuilder line = new java.lang.StringBuilder();
+        if (bufferedToken != null) {
+            line.append(bufferedToken);
+            bufferedToken = null;
+        }
+        int value = peekByte();
+        if (line.length() == 0 && value == -1) {
+            return "";
+        }
+        if (line.length() == 0 && value == '\\r') {
+            readByte();
+            if (peekByte() == '\\n') {
+                readByte();
+            }
+            return "";
+        }
+        if (line.length() == 0 && value == '\\n') {
+            readByte();
+            return "";
+        }
+        while (true) {
+            value = readByte();
+            if (value == -1 || value == '\\n' || value == '\\r') {
+                break;
+            }
+            line.append((char) value);
+        }
+        if (value == '\\r' && peekByte() == '\\n') {
+            readByte();
+        }
+        return line.toString();
+    }
+
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+
+    public float nextFloat() {
+        return Float.parseFloat(next());
+    }
+
+    public double nextDouble() {
+        return Double.parseDouble(next());
+    }
+
+    public boolean hasNextInt() {
+        if (!hasNext()) {
+            return false;
+        }
+        try {
+            Integer.parseInt(bufferedToken);
+            return true;
+        } catch (RuntimeException error) {
+            return false;
+        }
+    }
+
+    public boolean hasNextLong() {
+        if (!hasNext()) {
+            return false;
+        }
+        try {
+            Long.parseLong(bufferedToken);
+            return true;
+        } catch (RuntimeException error) {
+            return false;
+        }
+    }
+
+    public boolean hasNextFloat() {
+        if (!hasNext()) {
+            return false;
+        }
+        try {
+            Float.parseFloat(bufferedToken);
+            return true;
+        } catch (RuntimeException error) {
+            return false;
+        }
+    }
+
+    public boolean hasNextDouble() {
+        if (!hasNext()) {
+            return false;
+        }
+        try {
+            Double.parseDouble(bufferedToken);
+            return true;
+        } catch (RuntimeException error) {
+            return false;
+        }
+    }
+
+    public void close() {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        try {
+            input.close();
+        } catch (java.io.IOException error) {
+            throw new RuntimeException(error);
+        }
+    }
+}`;
+export const prepareJavaStdinInjection = (code, stdin) => {
+    const usesStdin = code.includes('System.in');
+    const usesScanner = /\bScanner\b/.test(code) &&
+        !code.includes(JAVA_SCANNER_COMPAT_SENTINEL) &&
+        !/\b(?:class|interface|enum|record)\s+Scanner\b/.test(code) &&
+        !/^[ \t]*import[ \t]+(?!java\.util\.Scanner\b)(?!static\b)[\w.]+\.Scanner[ \t]*;[ \t]*$/m.test(code);
+    if (!usesStdin) {
+        if (!usesScanner) {
+            return {
+                usesStdin: false,
+                stdinCacheKey: '',
+                transformedCode: code,
+                helperSourcePath: null,
+                helperSource: null
+            };
+        }
+        const transformedCode = code
+            .replace(/^[ \t]*import[ \t]+java\.util\.Scanner[ \t]*;[ \t]*$/gm, (match) => match.replace(/[^\r\n]/g, ' '))
+            .replaceAll(/\bjava\.util\.Scanner\b/g, 'Scanner');
+        return {
+            usesStdin: false,
+            stdinCacheKey: '',
+            transformedCode: `${transformedCode.trimEnd()}\n\n${JAVA_SCANNER_COMPAT_SHIM}\n`,
+            helperSourcePath: null,
+            helperSource: null
+        };
+    }
+    const packageMatch = code.match(/^\s*package\s+([A-Za-z_][\w.]*)\s*;/m);
+    const packageName = packageMatch?.[1] || '';
+    const helperSourcePath = packageName
+        ? `${packageName.replaceAll('.', '/')}/${JAVA_STDIN_HELPER_CLASS}.java`
+        : `${JAVA_STDIN_HELPER_CLASS}.java`;
+    let transformedCode = code.replaceAll('System.in', `${JAVA_STDIN_HELPER_CLASS}.open()`);
+    if (usesScanner) {
+        transformedCode = transformedCode
+            .replace(/^[ \t]*import[ \t]+java\.util\.Scanner[ \t]*;[ \t]*$/gm, (match) => match.replace(/[^\r\n]/g, ' '))
+            .replaceAll(/\bjava\.util\.Scanner\b/g, 'Scanner');
+        transformedCode = `${transformedCode.trimEnd()}\n\n${JAVA_SCANNER_COMPAT_SHIM}\n`;
+    }
+    const encodedBytes = [...new TextEncoder().encode(stdin)].join(', ');
+    return {
+        usesStdin: true,
+        stdinCacheKey: stdin,
+        transformedCode,
+        helperSourcePath,
+        helperSource: `${packageName ? `package ${packageName};\n\n` : ''}import java.io.InputStream;
+import org.teavm.jso.JSObject;
+import org.teavm.jso.browser.Window;
+import org.teavm.jso.core.JSFunction;
+import org.teavm.jso.core.JSMapLike;
+
+final class ${JAVA_STDIN_HELPER_CLASS} extends InputStream {
+    private static final byte[] INITIAL_DATA = new byte[] { ${encodedBytes} };
+    private static final ${JAVA_STDIN_HELPER_CLASS} INSTANCE = new ${JAVA_STDIN_HELPER_CLASS}();
+    private int position = 0;
+
+    private ${JAVA_STDIN_HELPER_CLASS}() {
+    }
+
+    static InputStream open() {
+        return INSTANCE;
+    }
+
+    private int readFromHost() {
+        Window current = Window.current();
+        if (current == null) {
+            return -1;
+        }
+        JSMapLike<JSObject> globals = current.cast();
+        JSObject stdin = globals.get("wasmIdleJavaStdin");
+        if (stdin == null) {
+            return -1;
+        }
+        JSFunction readByte = stdin.<JSMapLike<JSObject>>cast().get("readByte").cast();
+        Object value = readByte.call(stdin);
+        return value != null ? Integer.parseInt(value.toString()) : -1;
+    }
+
+    @Override
+    public int read(byte[] b, int off, int len) {
+        if (b == null) {
+            throw new NullPointerException();
+        }
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (len == 0) {
+            return 0;
+        }
+        if (position < INITIAL_DATA.length) {
+            int count = Math.min(len, INITIAL_DATA.length - position);
+            System.arraycopy(INITIAL_DATA, position, b, off, count);
+            position += count;
+            return count;
+        }
+        int next = readFromHost();
+        if (next == -1) {
+            return -1;
+        }
+        b[off] = (byte) next;
+        return 1;
+    }
+
+    @Override
+    public int read() {
+        return position < INITIAL_DATA.length ? INITIAL_DATA[position++] & 0xff : readFromHost();
+    }
+}
+`
+    };
+};

package/dist/playground/options.d.ts

@@ -4,6 +4,15 @@ export interface DebugVariable {
     name: string;
     value: string;
 }
+export type CompilerDiagnosticSeverity = 'error' | 'warning' | 'other';
+export interface CompilerDiagnostic {
+    fileName?: string | null;
+    lineNumber: number;
+    columnNumber?: number;
+    endColumnNumber?: number;
+    severity: CompilerDiagnosticSeverity;
+    message: string;
+}
 export type DebugVariableKind = 'number' | 'bool' | 'array' | 'text';
 export type DebugArrayElementKind = 'int' | 'float' | 'double' | 'bool' | 'char';
 export interface DebugVariableMetadata {
@@ -36,4 +45,14 @@ export interface SandboxExecutionOptions {
     debug?: boolean;
     breakpoints?: number[];
     pauseOnEntry?: boolean;
+    stdin?: string;
+    compileArgs?: string[];
+    programArgs?: string[];
+    cppVersion?: string;
+    cVersion?: string;
+}
+export interface ResolvedSandboxExecutionArgs {
+    compileArgs: string[];
+    programArgs: string[];
 }
+export declare function resolveSandboxExecutionArgs(language: string, args?: string[], options?: SandboxExecutionOptions): ResolvedSandboxExecutionArgs;

package/dist/playground/options.js

@@ -1 +1,15 @@
-export {};
+function cloneArgs(value) {
+    return Array.isArray(value) ? [...value] : [];
+}
+export function resolveSandboxExecutionArgs(language, args = [], options = {}) {
+    if (language === 'C' || language === 'CPP') {
+        return {
+            compileArgs: cloneArgs(options.compileArgs ?? args),
+            programArgs: cloneArgs(options.programArgs)
+        };
+    }
+    return {
+        compileArgs: cloneArgs(options.compileArgs),
+        programArgs: cloneArgs(options.programArgs ?? args)
+    };
+}

package/dist/playground/python.d.ts

@@ -1,27 +1,42 @@
+import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import { WorkerAssetBridge } from './assetBridge';
+import { type PlaygroundRuntimeAssets } from './assets';
 import type { Sandbox } from './sandbox';
-import type { SandboxExecutionOptions } from './options';
 declare class Python implements Sandbox {
     ts: number;
     output: any;
+    ondebug?: (event: DebugSessionEvent) => void;
     image?: (data: {
         mime: string;
         b64: string;
         ts?: number;
     }) => void;
-    worker: Worker;
+    worker?: Worker;
     buffer: SharedArrayBuffer;
+    debugBuffer: SharedArrayBuffer;
+    watchBuffer: SharedArrayBuffer;
+    watchResultBuffer: SharedArrayBuffer;
     interruptBuffer: SharedArrayBuffer;
-    internalBuffer: string[];
+    pendingInput: string[];
     begin: number;
     elapse: number;
     uid: number;
-    load(path: string, code?: string, log?: boolean, _args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    exit: boolean;
+    assetBridge: WorkerAssetBridge | null;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<void>;
     write(input: string): void;
-    _write(input: string): void;
     eof(): void;
+    private flushPendingInput;
     run(code: string, prepare: boolean, _log?: boolean, _prog?: {
         set?: (value: number) => void;
-    } | import('svelte/store').Writable<number>, _args?: string[], _options?: SandboxExecutionOptions): Promise<boolean | string>;
+    } | import('svelte/store').Writable<number>, _args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    debugCommand(command: DebugCommand): void;
+    debugEvaluate(expression: string): Promise<string>;
+    kill(): void;
     terminate(): void;
     clear(): Promise<void>;
 }

package/dist/playground/python.js

@@ -1,63 +1,129 @@
+import { WorkerAssetBridge } from './assetBridge';
+import { resolveRuntimeAssetConfig } from './assets';
+import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
 class Python {
     ts = Date.now();
     output = null;
+    ondebug;
     image;
     worker = null;
     buffer = new SharedArrayBuffer(1024);
+    debugBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 4);
+    watchBuffer = new SharedArrayBuffer(1024);
+    watchResultBuffer = new SharedArrayBuffer(1024);
     interruptBuffer = new SharedArrayBuffer(1);
-    internalBuffer = [];
+    pendingInput = [];
     begin = 0;
     elapse = 0;
     uid = 0;
-    load(path, code = '', log = true, _args = [], _options = {}) {
-        return new Promise(async (resolve) => {
-            this.internalBuffer = [];
+    waitingForInput = false;
+    pendingEof = false;
+    exit = true;
+    assetBridge = null;
+    load(runtimeAssets = '', code = '', log = true, _args = [], _options = {}, progress) {
+        return new Promise(async (resolve, reject) => {
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            const assetConfig = resolveRuntimeAssetConfig('python', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+            const needsWorkerReset = !this.worker || !this.assetBridge || !this.assetBridge.matches(assetConfig);
+            if (needsWorkerReset && this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+                this.assetBridge = null;
+            }
             if (!this.worker) {
                 this.worker = new (await import('./worker/python?worker')).default();
-                this.worker.onmessage = () => resolve();
-                this.worker.postMessage({ load: true, path, log, code });
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'python', assetConfig, progress);
+                this.worker.onmessage = (event) => {
+                    if (this.assetBridge?.handleMessage(event))
+                        return;
+                    if (event.data?.load)
+                        resolve();
+                    if (event.data?.error)
+                        reject(event.data.error);
+                };
+                this.worker.postMessage({
+                    load: true,
+                    log,
+                    code,
+                    assets: {
+                        baseUrl: assetConfig.baseUrl,
+                        useAssetBridge: assetConfig.useAssetBridge
+                    }
+                });
             }
             else {
+                if (!this.assetBridge)
+                    return reject('Worker asset bridge unavailable');
+                this.assetBridge.rebind(this.worker, assetConfig, progress);
                 this.worker.postMessage({ log });
                 resolve();
             }
         });
     }
     write(input) {
-        this.internalBuffer.push(input);
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        this.flushPendingInput();
     }
-    _write(input) {
-        let strInfo = input, padding = 4 - (strInfo.length % 4);
-        while (strInfo.length % 4 !== 3)
-            strInfo += ' ';
-        strInfo += padding;
-        const buffer = new Int32Array(this.buffer);
-        const enc = new TextEncoder();
-        const data = enc.encode(strInfo);
-        buffer.set(new Int32Array(data.buffer.slice(data.byteOffset), 0));
+    eof() {
+        this.pendingEof = true;
+        this.flushPendingInput();
     }
-    eof() { }
-    run(code, prepare, _log = true, _prog, _args = [], _options = {}) {
+    flushPendingInput() {
+        if (!this.waitingForInput)
+            return;
+        if (flushQueuedStdin(this.pendingInput, this.buffer)) {
+            this.waitingForInput = false;
+            return;
+        }
+        if (this.pendingEof) {
+            flushBufferedEof(this.buffer);
+            this.pendingEof = false;
+            this.waitingForInput = false;
+        }
+    }
+    run(code, prepare, _log = true, _prog, _args = [], options = {}) {
+        this.exit = false;
         return new Promise(async (resolve, reject) => {
+            if (!this.worker)
+                return reject('Worker not loaded');
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
+                if (this.assetBridge?.handleMessage(event))
+                    return;
+                if (!this.worker)
+                    return reject('Worker not loaded');
                 if (_uid !== this.uid)
                     return (this.worker.onmessage = null);
-                const { id, output, results, log, error, buffer, type, data: payload } = event.data;
-                if (buffer && this.internalBuffer.length)
-                    this._write(this.internalBuffer.splice(0, 1)[0]);
+                const { output, results, log, error, buffer, type, data: payload, debugEvent } = event.data;
+                if (buffer) {
+                    this.waitingForInput = true;
+                    this.flushPendingInput();
+                }
                 if (type === 'img' && payload)
                     this.image?.(payload);
                 if (output)
                     this.output(output);
+                if (debugEvent)
+                    this.ondebug?.(debugEvent);
                 if (results) {
                     this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.ondebug?.({ type: 'stop' });
                     resolve(results);
                 }
                 if (log)
                     console.log(log);
                 if (error) {
                     this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.ondebug?.({ type: 'stop' });
                     reject(error);
                 }
             };
@@ -68,22 +134,66 @@ class Python {
                 code,
                 prepare,
                 buffer: this.buffer,
+                debugBuffer: this.debugBuffer,
+                watchBuffer: this.watchBuffer,
+                watchResultBuffer: this.watchResultBuffer,
                 interrupt: this.interruptBuffer,
-                context: {}
+                context: {},
+                debug: !!options.debug,
+                breakpoints: [...(options.breakpoints || [])],
+                pauseOnEntry: !!options.pauseOnEntry
             });
         });
     }
+    debugCommand(command) {
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.store(control, 1, command === 'stepInto' ? 2 : command === 'nextLine' ? 3 : command === 'stepOut' ? 4 : 1);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
+        this.ondebug?.({ type: 'resume', command });
+    }
+    async debugEvaluate(expression) {
+        if (!this.worker)
+            throw new Error('Worker not loaded');
+        resetBufferedStdin(this.watchResultBuffer);
+        const previousSequence = bufferedSequence(this.watchResultBuffer);
+        flushQueuedStdin([expression], this.watchBuffer);
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.store(control, 1, 5);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
+        return ((await waitForBufferedSequenceChange(this.watchResultBuffer, previousSequence, 5000)) ??
+            '?');
+    }
+    kill() {
+        this.terminate();
+    }
     terminate() {
+        this.pendingEof = false;
         new Uint8Array(this.interruptBuffer)[0] = 2;
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
     }
     async clear() {
         this.terminate();
-        this.internalBuffer = [];
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
         if (this.worker)
             this.worker.onmessage = null;
-        const buffer = new Int32Array(this.buffer);
-        buffer.fill(0);
+        resetBufferedStdin(this.buffer);
+        resetBufferedStdin(this.watchBuffer);
+        resetBufferedStdin(this.watchResultBuffer);
+        const debugBuffer = new Int32Array(this.debugBuffer);
+        debugBuffer.fill(0);
         await new Promise((resolve) => setTimeout(resolve, 200));
+        if (!this.exit) {
+            this.worker?.terminate?.();
+            delete this.worker;
+            this.assetBridge = null;
+            this.exit = true;
+        }
     }
 }
 export default Python;

package/dist/playground/sandbox.d.ts

@@ -1,4 +1,5 @@
-import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { CompilerDiagnostic, DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { PlaygroundRuntimeAssets } from './assets';
 import type { Writable } from 'svelte/store';
 type ProgressLike = Writable<number> | {
     set?: (value: number) => void;
@@ -6,7 +7,7 @@ type ProgressLike = Writable<number> | {
 export interface Sandbox {
     constructor: any;
     eof: () => void;
-    load: (path: string, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions) => Promise<void>;
+    load: (runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: ProgressLike) => Promise<void>;
     run: (code: string, prepare: boolean, log?: boolean, prog?: ProgressLike, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean | string>;
     terminate: () => void;
     clear: () => Promise<void>;
@@ -14,7 +15,9 @@ export interface Sandbox {
     write?: (data: string) => void;
     output?: (data: string) => void;
     ondebug?: (event: DebugSessionEvent) => void;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     debugCommand?: (command: DebugCommand) => void;
+    debugEvaluate?: (expression: string) => Promise<string>;
     image?: (data: {
         mime: string;
         b64: string;

package/dist/playground/stdinBuffer.d.ts

@@ -0,0 +1,7 @@
+export declare const flushQueuedStdin: (queue: string[], buffer: SharedArrayBuffer | Int32Array) => boolean;
+export declare const readBufferedStdin: (buffer: SharedArrayBuffer | Int32Array) => string | null;
+export declare const bufferedSequence: (buffer: SharedArrayBuffer | Int32Array) => number;
+export declare const waitForBufferedSequenceChange: (buffer: SharedArrayBuffer | Int32Array, sequence: number, timeoutMs?: number) => Promise<string | null>;
+export declare const flushBufferedEof: (buffer: SharedArrayBuffer | Int32Array) => void;
+export declare const waitForBufferedStdin: (buffer: Int32Array, requestInput: () => void) => string | null;
+export declare const resetBufferedStdin: (buffer: SharedArrayBuffer | Int32Array) => void;