wasm-idle 0.3.1 → 0.4.0

package/dist/playground/javaStdin.js

@@ -0,0 +1,90 @@
+const JAVA_STDIN_HELPER_CLASS = 'WasmIdleStdin';
+export const prepareJavaStdinInjection = (code, stdin) => {
+    const usesStdin = code.includes('System.in');
+    if (!usesStdin) {
+        return {
+            usesStdin: false,
+            stdinCacheKey: '',
+            transformedCode: code,
+            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`;
+    const transformedCode = code.replaceAll('System.in', `${JAVA_STDIN_HELPER_CLASS}.open()`);
+    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,5 @@ export interface SandboxExecutionOptions {
     debug?: boolean;
     breakpoints?: number[];
     pauseOnEntry?: boolean;
+    stdin?: string;
 }

package/dist/playground/python.d.ts

@@ -1,27 +1,37 @@
+import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
 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;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    exit: boolean;
     load(path: string, code?: string, log?: boolean, _args?: string[], _options?: SandboxExecutionOptions): 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,17 +1,27 @@
+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;
+    waitingForInput = false;
+    pendingEof = false;
+    exit = true;
     load(path, code = '', log = true, _args = [], _options = {}) {
         return new Promise(async (resolve) => {
-            this.internalBuffer = [];
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
             if (!this.worker) {
                 this.worker = new (await import('./worker/python?worker')).default();
                 this.worker.onmessage = () => resolve();
@@ -24,40 +34,65 @@ class Python {
         });
     }
     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.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 +103,64 @@ 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.exit = true;
+        }
     }
 }
 export default Python;

package/dist/playground/sandbox.d.ts

@@ -1,4 +1,4 @@
-import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { CompilerDiagnostic, DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
 import type { Writable } from 'svelte/store';
 type ProgressLike = Writable<number> | {
     set?: (value: number) => void;
@@ -14,7 +14,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;

package/dist/playground/stdinBuffer.js

@@ -0,0 +1,100 @@
+const SEQUENCE_INDEX = 0;
+const LENGTH_INDEX = 1;
+const HEADER_BYTES = Int32Array.BYTES_PER_ELEMENT * 2;
+const EOF_LENGTH = -1;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const controlViewOf = (buffer) => buffer instanceof Int32Array ? buffer : new Int32Array(buffer);
+const payloadViewOf = (control) => new Uint8Array(control.buffer, control.byteOffset + HEADER_BYTES, control.byteLength - HEADER_BYTES);
+const splitChunk = (input, maxBytes) => {
+    const encoded = encoder.encode(input);
+    if (encoded.length <= maxBytes) {
+        return { chunk: input, bytes: encoded, rest: '' };
+    }
+    let left = 0;
+    let right = input.length;
+    while (left < right) {
+        const middle = Math.ceil((left + right) / 2);
+        if (encoder.encode(input.slice(0, middle)).length <= maxBytes) {
+            left = middle;
+        }
+        else {
+            right = middle - 1;
+        }
+    }
+    const chunk = input.slice(0, left);
+    return {
+        chunk,
+        bytes: encoder.encode(chunk),
+        rest: input.slice(left)
+    };
+};
+export const flushQueuedStdin = (queue, buffer) => {
+    if (!queue.length)
+        return false;
+    const control = controlViewOf(buffer);
+    const payload = payloadViewOf(control);
+    const next = queue[0];
+    const { bytes, rest } = splitChunk(next, payload.length);
+    payload.fill(0);
+    payload.set(bytes);
+    Atomics.store(control, LENGTH_INDEX, bytes.length);
+    Atomics.add(control, SEQUENCE_INDEX, 1);
+    Atomics.notify(control, SEQUENCE_INDEX);
+    if (rest) {
+        queue[0] = rest;
+    }
+    else {
+        queue.shift();
+    }
+    return true;
+};
+export const readBufferedStdin = (buffer) => {
+    const control = controlViewOf(buffer);
+    const length = Atomics.load(control, LENGTH_INDEX);
+    if (length === EOF_LENGTH)
+        return null;
+    const payload = payloadViewOf(control);
+    return decoder.decode(payload.slice(0, length));
+};
+export const bufferedSequence = (buffer) => Atomics.load(controlViewOf(buffer), SEQUENCE_INDEX);
+export const waitForBufferedSequenceChange = (buffer, sequence, timeoutMs = 5000) => new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const poll = () => {
+        if (bufferedSequence(buffer) !== sequence) {
+            resolve(readBufferedStdin(buffer));
+            return;
+        }
+        if (Date.now() - startedAt >= timeoutMs) {
+            reject(new Error('Timed out waiting for buffered value'));
+            return;
+        }
+        setTimeout(poll, 10);
+    };
+    poll();
+});
+export const flushBufferedEof = (buffer) => {
+    const control = controlViewOf(buffer);
+    const payload = payloadViewOf(control);
+    payload.fill(0);
+    Atomics.store(control, LENGTH_INDEX, EOF_LENGTH);
+    Atomics.add(control, SEQUENCE_INDEX, 1);
+    Atomics.notify(control, SEQUENCE_INDEX);
+};
+export const waitForBufferedStdin = (buffer, requestInput) => {
+    const sequence = Atomics.load(buffer, SEQUENCE_INDEX);
+    requestInput();
+    while (true) {
+        const result = Atomics.wait(buffer, SEQUENCE_INDEX, sequence, 100);
+        if (result === 'not-equal') {
+            return readBufferedStdin(buffer);
+        }
+    }
+};
+export const resetBufferedStdin = (buffer) => {
+    const control = controlViewOf(buffer);
+    const payload = payloadViewOf(control);
+    payload.fill(0);
+    Atomics.store(control, SEQUENCE_INDEX, 0);
+    Atomics.store(control, LENGTH_INDEX, 0);
+};

package/dist/playground/teavmConfig.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizeTeaVmBaseUrl: (baseUrl: string) => string;
+export declare const resolveTeaVmBaseUrl: (pathPrefix?: string, currentUrl?: string) => string;
+export declare const resolveTeaVmAssetUrl: (baseUrl: string, assetPath: string) => string;

package/dist/playground/teavmConfig.js

@@ -0,0 +1,14 @@
+export const normalizeTeaVmBaseUrl = (baseUrl) => baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+const normalizePathPrefix = (pathPrefix) => {
+    if (!pathPrefix)
+        return '';
+    return pathPrefix.endsWith('/') ? pathPrefix.slice(0, -1) : pathPrefix;
+};
+export const resolveTeaVmBaseUrl = (pathPrefix = '', currentUrl = '') => {
+    const configuredBaseUrl = (import.meta.env.PUBLIC_TEAVM_BASE_URL || '').trim();
+    const baseUrl = configuredBaseUrl
+        ? normalizeTeaVmBaseUrl(configuredBaseUrl)
+        : `${normalizePathPrefix(pathPrefix) || ''}/teavm/`;
+    return currentUrl ? new URL(baseUrl, currentUrl).href : baseUrl;
+};
+export const resolveTeaVmAssetUrl = (baseUrl, assetPath) => new URL(assetPath, normalizeTeaVmBaseUrl(baseUrl)).href;

package/dist/playground/worker/clang.js

@@ -1,3 +1,4 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
 self.document = {
     querySelectorAll() {
         return [];
@@ -9,25 +10,7 @@ async function loadClang(path, log) {
     clang = new Clang({
         stdout: (output) => postMessage({ output }),
         onDebugEvent: (debugEvent) => postMessage({ debugEvent }),
-        stdin: () => {
-            while (true) {
-                postMessage({ buffer: true });
-                const res = Atomics.wait(stdinBufferClang, 0, 0, 100);
-                if (res === 'not-equal') {
-                    try {
-                        const cpy = new Int32Array(stdinBufferClang.byteLength);
-                        cpy.set(stdinBufferClang);
-                        stdinBufferClang.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 } });
-                    }
-                }
-            }
-        },
+        stdin: () => waitForBufferedStdin(stdinBufferClang, () => postMessage({ buffer: true })) ?? '',
         progress: (value) => postMessage({ progress: value }),
         log,
         path
@@ -79,4 +62,3 @@ self.onmessage = async (event) => {
         }
     }
 };
-export {};

package/dist/playground/worker/java.d.ts

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