wasm-idle 0.3.2 → 0.4.0

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

package/dist/playground/worker/java.js

@@ -0,0 +1,248 @@
+import { prepareJavaStdinInjection } from '../javaStdin';
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { resolveTeaVmAssetUrl } from '../teavmConfig';
+let compilerLib = null;
+let compiler = null;
+let runtimeLoad = null;
+let loadedBaseUrl = '';
+let stdoutBuffer = '';
+let stderrBuffer = '';
+let stdinBufferJava = null;
+let stdinChunkJava = new Uint8Array(0);
+let stdinChunkOffsetJava = 0;
+let compiledCode = '';
+let compiledStdin = '';
+let compiledMainClass = '';
+let compiledWasm = null;
+let currentSourcePath = '';
+const isGzip = (bytes) => bytes.length >= 2 && bytes[0] === 0x1f && bytes[1] === 0x8b;
+const maybeDecompressWasm = async (bytes) => {
+    if (!isGzip(bytes))
+        return bytes;
+    if (typeof DecompressionStream === 'undefined') {
+        throw new Error('Generated WebAssembly is gzip-compressed, but DecompressionStream is unavailable');
+    }
+    const stream = new Blob([Uint8Array.from(bytes)])
+        .stream()
+        .pipeThrough(new DecompressionStream('gzip'));
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+};
+const flushStdout = () => {
+    if (!stdoutBuffer)
+        return;
+    self.postMessage({ output: stdoutBuffer });
+    stdoutBuffer = '';
+};
+const flushStderr = () => {
+    if (!stderrBuffer)
+        return;
+    self.postMessage({ output: stderrBuffer });
+    stderrBuffer = '';
+};
+const pushStdout = (charCode) => {
+    stdoutBuffer += String.fromCharCode(charCode);
+    if (charCode === 10)
+        flushStdout();
+};
+const pushStderr = (charCode) => {
+    stderrBuffer += String.fromCharCode(charCode);
+    if (charCode === 10)
+        flushStderr();
+};
+self.addEventListener('message', async (event) => {
+    const { load, baseUrl, buffer, code, prepare, args = [], stdin = '' } = event.data;
+    try {
+        if (load) {
+            if (!compiler || loadedBaseUrl !== baseUrl) {
+                loadedBaseUrl = baseUrl;
+                const runtimeSource = await fetch(resolveTeaVmAssetUrl(baseUrl, 'compiler.wasm-runtime.js')).then((response) => {
+                    if (!response.ok)
+                        throw new Error(`Failed to load TeaVM compiler runtime: ${response.status}`);
+                    return response.text();
+                });
+                const runtimeUrl = URL.createObjectURL(new Blob([runtimeSource], { type: 'text/javascript;charset=utf-8' }));
+                const runtimeModule = await import(/* @vite-ignore */ runtimeUrl);
+                const runtimeLoadFn = runtimeModule.load;
+                runtimeLoad = runtimeLoadFn;
+                const compilerWasm = await fetch(resolveTeaVmAssetUrl(baseUrl, 'compiler.wasm')).then(async (response) => {
+                    if (!response.ok)
+                        throw new Error(`Failed to load TeaVM compiler wasm: ${response.status}`);
+                    return await maybeDecompressWasm(new Uint8Array(await response.arrayBuffer()));
+                });
+                const compilerModule = await runtimeLoadFn(compilerWasm, {
+                    stackDeobfuscator: { enabled: false }
+                });
+                compilerLib = compilerModule.exports;
+                compiler = compilerLib.createCompiler();
+                const [sdk, runtimeClasslib] = await Promise.all([
+                    fetch(resolveTeaVmAssetUrl(baseUrl, 'compile-classlib-teavm.bin')).then(async (response) => {
+                        if (!response.ok)
+                            throw new Error(`Failed to load TeaVM SDK: ${response.status}`);
+                        return new Int8Array(await response.arrayBuffer());
+                    }),
+                    fetch(resolveTeaVmAssetUrl(baseUrl, 'runtime-classlib-teavm.bin')).then(async (response) => {
+                        if (!response.ok)
+                            throw new Error(`Failed to load TeaVM runtime classlib: ${response.status}`);
+                        return new Int8Array(await response.arrayBuffer());
+                    })
+                ]);
+                compiler.setSdk(sdk);
+                compiler.setTeaVMClasslib(runtimeClasslib);
+                compiledCode = '';
+                compiledStdin = '';
+                compiledMainClass = '';
+                compiledWasm = null;
+            }
+            self.postMessage({ load: true });
+            return;
+        }
+        if (!compiler || !runtimeLoad)
+            throw new Error('TeaVM compiler not loaded');
+        stdoutBuffer = '';
+        stderrBuffer = '';
+        const stdinInjection = prepareJavaStdinInjection(code, stdin);
+        if (prepare ||
+            compiledCode !== code ||
+            compiledStdin !== stdinInjection.stdinCacheKey ||
+            !compiledWasm) {
+            const packageMatch = code.match(/^\s*package\s+([A-Za-z_][\w.]*)\s*;/m);
+            const typeMatch = code.match(/^\s*public\s+(?:final\s+|abstract\s+)?(?:class|record|enum|interface)\s+([A-Za-z_]\w*)\b/m) ||
+                code.match(/^\s*(?:final\s+|abstract\s+)?(?:class|record|enum|interface)\s+([A-Za-z_]\w*)\b/m);
+            const className = typeMatch?.[1];
+            if (!className)
+                throw new Error('Java source must define a top-level class, record, enum, or interface');
+            const packageName = packageMatch?.[1] || '';
+            const sourcePath = packageName
+                ? `${packageName.replaceAll('.', '/')}/${className}.java`
+                : `${className}.java`;
+            const mainClass = packageName ? `${packageName}.${className}` : className;
+            currentSourcePath = sourcePath;
+            const diagnosticLines = [];
+            const diagnosticRegistration = compiler.onDiagnostic((diagnostic) => {
+                const severity = diagnostic.severity
+                    ? String(diagnostic.severity).toLowerCase()
+                    : 'error';
+                const location = diagnostic.fileName
+                    ? `${diagnostic.fileName}:${diagnostic.lineNumber || 0}${diagnostic.columnNumber ? `:${diagnostic.columnNumber}` : ''}`
+                    : 'TeaVM';
+                diagnosticLines.push(`${location}: ${severity}: ${diagnostic.message}`);
+                const fileName = diagnostic.fileName ? String(diagnostic.fileName) : null;
+                if (fileName &&
+                    fileName !== currentSourcePath &&
+                    fileName !== currentSourcePath.split('/').pop()) {
+                    return;
+                }
+                self.postMessage({
+                    diagnostic: {
+                        fileName,
+                        lineNumber: Number(diagnostic.lineNumber) || 1,
+                        columnNumber: Number(diagnostic.columnNumber) || 1,
+                        severity: severity === 'warning'
+                            ? 'warning'
+                            : severity === 'other'
+                                ? 'other'
+                                : 'error',
+                        message: String(diagnostic.message || '')
+                    }
+                });
+            });
+            const disposeDiagnosticRegistration = () => {
+                if (typeof diagnosticRegistration === 'function') {
+                    diagnosticRegistration();
+                    return;
+                }
+                diagnosticRegistration?.destroy?.();
+            };
+            compiler.clearSourceFiles?.();
+            compiler.clearInputClassFiles?.();
+            compiler.clearOutputFiles?.();
+            compiler.addSourceFile(sourcePath, stdinInjection.transformedCode);
+            if (stdinInjection.usesStdin &&
+                stdinInjection.helperSourcePath &&
+                stdinInjection.helperSource) {
+                compiler.addSourceFile(stdinInjection.helperSourcePath, stdinInjection.helperSource);
+            }
+            const javacOk = compiler.compile();
+            if (!javacOk) {
+                disposeDiagnosticRegistration();
+                throw new Error(diagnosticLines.join('\n') || 'TeaVM javac compilation failed');
+            }
+            const mainClasses = Array.from(compiler.detectMainClasses());
+            if (mainClasses.length !== 1) {
+                disposeDiagnosticRegistration();
+                throw new Error(mainClasses.length === 0
+                    ? 'Main method not found'
+                    : 'Multiple main methods found');
+            }
+            const generateOk = compiler.generateWebAssembly({
+                outputName: 'app',
+                mainClass
+            });
+            disposeDiagnosticRegistration();
+            if (!generateOk) {
+                throw new Error(diagnosticLines.join('\n') || 'TeaVM WebAssembly generation failed');
+            }
+            compiledCode = code;
+            compiledStdin = stdinInjection.stdinCacheKey;
+            compiledMainClass = mainClass;
+            compiledWasm = await maybeDecompressWasm(new Uint8Array(compiler.getWebAssemblyOutputFile('app.wasm')));
+        }
+        if (prepare) {
+            self.postMessage({ results: true });
+            return;
+        }
+        stdinBufferJava = new Int32Array(buffer);
+        const workerGlobal = globalThis;
+        const previousWindow = workerGlobal.window;
+        workerGlobal.window = workerGlobal;
+        workerGlobal.wasmIdleJavaStdin = {
+            readByte() {
+                while (true) {
+                    if (stdinChunkOffsetJava < stdinChunkJava.length) {
+                        return stdinChunkJava[stdinChunkOffsetJava++] ?? -1;
+                    }
+                    const chunk = waitForBufferedStdin(stdinBufferJava, () => self.postMessage({ buffer: true }));
+                    if (chunk === null) {
+                        return -1;
+                    }
+                    stdinChunkJava = new TextEncoder().encode(chunk);
+                    stdinChunkOffsetJava = 0;
+                }
+            }
+        };
+        try {
+            const module = await runtimeLoad(compiledWasm, {
+                installImports(imports) {
+                    imports.teavmConsole.putcharStdout = pushStdout;
+                    imports.teavmConsole.putcharStderr = pushStderr;
+                },
+                stackDeobfuscator: {
+                    enabled: false
+                }
+            });
+            module.exports.main(args);
+            flushStdout();
+            flushStderr();
+            self.postMessage({ results: true, mainClass: compiledMainClass });
+        }
+        finally {
+            delete workerGlobal.wasmIdleJavaStdin;
+            if (previousWindow === undefined) {
+                Reflect.deleteProperty(workerGlobal, 'window');
+            }
+            else {
+                workerGlobal.window = previousWindow;
+            }
+            stdinChunkJava = new Uint8Array(0);
+            stdinChunkOffsetJava = 0;
+            stdinBufferJava = null;
+        }
+    }
+    catch (error) {
+        flushStdout();
+        flushStderr();
+        self.postMessage({
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+});