wasm-idle 0.4.0 → 0.5.0

package/dist/playground/java.js

@@ -1,5 +1,7 @@
+import { resolveSandboxExecutionArgs } from './options';
+import { WorkerAssetBridge } from './assetBridge';
+import { resolveRuntimeAssetConfig } from './assets';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
-import { resolveTeaVmBaseUrl } from './teavmConfig';
 class Java {
     output = null;
     worker = null;
@@ -14,23 +16,43 @@ class Java {
     oncompilerdiagnostic;
     waitingForInput = false;
     pendingEof = false;
-    load(path, _code = '', _log = true, _args = [], _options = {}) {
+    assetBridge = null;
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], _options = {}, progress) {
         return new Promise(async (resolve, reject) => {
             this.pendingInput = [];
             this.waitingForInput = false;
             this.pendingEof = false;
-            this.baseUrl = resolveTeaVmBaseUrl(path, typeof window !== 'undefined' ? window.location.href : '');
+            const assetConfig = resolveRuntimeAssetConfig('java', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+            this.baseUrl = assetConfig.baseUrl;
+            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/java?worker')).default();
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'java', 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, baseUrl: this.baseUrl });
+                this.worker.postMessage({
+                    load: true,
+                    assets: {
+                        baseUrl: assetConfig.baseUrl,
+                        useAssetBridge: assetConfig.useAssetBridge
+                    }
+                });
             }
             else {
+                if (!this.assetBridge)
+                    return reject('Worker asset bridge unavailable');
+                this.assetBridge.rebind(this.worker, assetConfig, progress);
                 resolve();
             }
         });
@@ -62,9 +84,12 @@ class Java {
         return new Promise((resolve, reject) => {
             if (!this.worker)
                 return reject('Worker not loaded');
+            const { programArgs } = resolveSandboxExecutionArgs('JAVA', args, options);
             const _uid = ++this.uid;
             this.activeReject = reject;
             const handler = (event) => {
+                if (this.assetBridge?.handleMessage(event))
+                    return;
                 if (!this.worker)
                     return reject('Worker not loaded');
                 if (_uid !== this.uid)
@@ -101,7 +126,7 @@ class Java {
                 code,
                 prepare,
                 buffer: this.buffer,
-                args,
+                args: programArgs,
                 stdin: options.stdin || '',
                 baseUrl: this.baseUrl
             });
@@ -118,6 +143,7 @@ class Java {
         this.uid += 1;
         this.worker?.terminate?.();
         delete this.worker;
+        this.assetBridge = null;
         this.exit = true;
     }
     async clear() {

package/dist/playground/javaStdin.js

@@ -1,11 +1,238 @@
 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: code,
+            transformedCode: `${transformedCode.trimEnd()}\n\n${JAVA_SCANNER_COMPAT_SHIM}\n`,
             helperSourcePath: null,
             helperSource: null
         };
@@ -15,7 +242,13 @@ export const prepareJavaStdinInjection = (code, stdin) => {
     const helperSourcePath = packageName
         ? `${packageName.replaceAll('.', '/')}/${JAVA_STDIN_HELPER_CLASS}.java`
         : `${JAVA_STDIN_HELPER_CLASS}.java`;
-    const transformedCode = code.replaceAll('System.in', `${JAVA_STDIN_HELPER_CLASS}.open()`);
+    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,

package/dist/playground/options.d.ts

@@ -13,8 +13,14 @@ export interface CompilerDiagnostic {
     severity: CompilerDiagnosticSeverity;
     message: string;
 }
+export type RustTargetTriple = 'wasm32-wasip1' | 'wasm32-wasip2' | 'wasm32-wasip3';
 export type DebugVariableKind = 'number' | 'bool' | 'array' | 'text';
 export type DebugArrayElementKind = 'int' | 'float' | 'double' | 'bool' | 'char';
+export interface DebugStructFieldMetadata {
+    name: string;
+    kind: DebugArrayElementKind;
+    offset: number;
+}
 export interface DebugVariableMetadata {
     slot: number;
     name: string;
@@ -24,6 +30,8 @@ export interface DebugVariableMetadata {
     elementKind?: DebugArrayElementKind;
     length?: number;
     dimensions?: number[];
+    structFields?: DebugStructFieldMetadata[];
+    structSize?: number;
 }
 export interface DebugFrame {
     functionName: string;
@@ -46,4 +54,14 @@ export interface SandboxExecutionOptions {
     breakpoints?: number[];
     pauseOnEntry?: boolean;
     stdin?: string;
+    compileArgs?: string[];
+    programArgs?: string[];
+    cppVersion?: string;
+    cVersion?: string;
+    rustTargetTriple?: RustTargetTriple;
+}
+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,4 +1,6 @@
 import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import { WorkerAssetBridge } from './assetBridge';
+import { type PlaygroundRuntimeAssets } from './assets';
 import type { Sandbox } from './sandbox';
 declare class Python implements Sandbox {
     ts: number;
@@ -22,7 +24,11 @@ declare class Python implements Sandbox {
     waitingForInput: boolean;
     pendingEof: boolean;
     exit: boolean;
-    load(path: string, code?: string, log?: boolean, _args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
+    assetBridge: WorkerAssetBridge | null;
+    activeReject: ((reason?: string) => void) | 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;
     eof(): void;
     private flushPendingInput;

package/dist/playground/python.js

@@ -1,3 +1,5 @@
+import { WorkerAssetBridge } from './assetBridge';
+import { resolveRuntimeAssetConfig } from './assets';
 import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
 class Python {
     ts = Date.now();
@@ -17,17 +19,45 @@ class Python {
     waitingForInput = false;
     pendingEof = false;
     exit = true;
-    load(path, code = '', log = true, _args = [], _options = {}) {
-        return new Promise(async (resolve) => {
+    assetBridge = null;
+    activeReject = 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();
             }
@@ -60,8 +90,11 @@ class Python {
         return new Promise(async (resolve, reject) => {
             if (!this.worker)
                 return reject('Worker not loaded');
+            this.activeReject = reject;
             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)
@@ -82,6 +115,7 @@ class Python {
                     this.exit = true;
                     this.waitingForInput = false;
                     this.pendingEof = false;
+                    this.activeReject = null;
                     this.ondebug?.({ type: 'stop' });
                     resolve(results);
                 }
@@ -92,6 +126,7 @@ class Python {
                     this.exit = true;
                     this.waitingForInput = false;
                     this.pendingEof = false;
+                    this.activeReject = null;
                     this.ondebug?.({ type: 'stop' });
                     reject(error);
                 }
@@ -131,17 +166,26 @@ class Python {
         Atomics.store(control, 1, 5);
         Atomics.add(control, 0, 1);
         Atomics.notify(control, 0);
-        return (await waitForBufferedSequenceChange(this.watchResultBuffer, previousSequence, 5000)) ?? '?';
+        return ((await waitForBufferedSequenceChange(this.watchResultBuffer, previousSequence, 5000)) ??
+            '?');
     }
     kill() {
         this.terminate();
     }
     terminate() {
+        this.activeReject?.('Process terminated');
+        this.activeReject = null;
+        this.waitingForInput = false;
         this.pendingEof = false;
+        this.uid += 1;
         new Uint8Array(this.interruptBuffer)[0] = 2;
         const control = new Int32Array(this.debugBuffer);
         Atomics.add(control, 0, 1);
         Atomics.notify(control, 0);
+        this.worker?.terminate?.();
+        delete this.worker;
+        this.assetBridge = null;
+        this.exit = true;
     }
     async clear() {
         this.terminate();
@@ -159,6 +203,7 @@ class Python {
         if (!this.exit) {
             this.worker?.terminate?.();
             delete this.worker;
+            this.assetBridge = null;
             this.exit = true;
         }
     }

package/dist/playground/rust.d.ts

@@ -0,0 +1,32 @@
+import { type PlaygroundRuntimeAssets } from './assets';
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import type { Sandbox } from './sandbox';
+declare class Rust implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: SharedArrayBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    compilerUrl: string;
+    assetPath: string;
+    activeReject: ((reason: string) => void) | null;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    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;
+    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>;
+    kill(): void;
+    terminate(): void;
+    clear(): Promise<void>;
+}
+export default Rust;