wasm-idle 0.3.2 → 0.4.1

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/assets.d.ts

@@ -0,0 +1,12 @@
+export interface WorkerRuntimeAssetConfig {
+    baseUrl: string;
+    useAssetBridge: boolean;
+}
+interface LoadedWorkerAsset {
+    bytes: Uint8Array;
+    mimeType?: string;
+}
+export declare function configureWorkerRuntimeAssets(config: WorkerRuntimeAssetConfig | null): void;
+export declare function handleWorkerAssetMessage(data: any): boolean;
+export declare function loadWorkerRuntimeAsset(asset: string): Promise<LoadedWorkerAsset>;
+export {};

package/dist/playground/worker/assets.js

@@ -0,0 +1,257 @@
+const decoder = new TextDecoder();
+const originalFetch = globalThis.fetch.bind(globalThis);
+const NativeXMLHttpRequest = globalThis.XMLHttpRequest;
+let activeConfig = null;
+let interceptorsInstalled = false;
+let nextAssetRequestId = 0;
+const pendingAssetRequests = new Map();
+const responseBuffer = (bytes) => {
+    const buffer = bytes.buffer;
+    return bytes.byteOffset === 0 && bytes.byteLength === buffer.byteLength
+        ? buffer
+        : buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+};
+const trackedAssetUrl = (input) => {
+    if (!activeConfig)
+        return null;
+    if (typeof input === 'string')
+        return new URL(input, activeConfig.baseUrl).href;
+    if (input instanceof URL)
+        return input.href;
+    return input.url;
+};
+const trackedAssetName = (url) => {
+    if (!activeConfig || !url.startsWith(activeConfig.baseUrl))
+        return null;
+    return url.slice(activeConfig.baseUrl.length);
+};
+const isTrackedAssetUrl = (url) => trackedAssetName(url) !== null;
+const loadAssetFromBridge = async (asset) => {
+    const id = ++nextAssetRequestId;
+    return await new Promise((resolve, reject) => {
+        pendingAssetRequests.set(id, { resolve, reject });
+        self.postMessage({
+            assetRequest: {
+                id,
+                asset
+            }
+        });
+    });
+};
+const loadAssetFromUrl = async (url, asset) => {
+    const response = await originalFetch(url);
+    if (!response.ok)
+        throw new Error(`Failed to load ${asset}: ${response.status}`);
+    const total = Number(response.headers.get('content-length') || 0) || undefined;
+    const mimeType = response.headers.get('content-type') || undefined;
+    if (!response.body) {
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        self.postMessage({
+            assetProgress: {
+                asset,
+                loaded: bytes.byteLength,
+                total: total ?? bytes.byteLength
+            }
+        });
+        return { bytes, mimeType };
+    }
+    const reader = response.body.getReader();
+    let receivedLength = 0;
+    const chunks = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        const chunk = Uint8Array.from(value);
+        chunks.push(chunk);
+        receivedLength += chunk.byteLength;
+        self.postMessage({
+            assetProgress: {
+                asset,
+                loaded: receivedLength,
+                total
+            }
+        });
+    }
+    const bytes = new Uint8Array(receivedLength);
+    let position = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, position);
+        position += chunk.byteLength;
+    }
+    self.postMessage({
+        assetProgress: {
+            asset,
+            loaded: receivedLength,
+            total: total ?? receivedLength
+        }
+    });
+    return { bytes, mimeType };
+};
+async function loadTrackedAsset(url) {
+    const asset = trackedAssetName(url);
+    if (!asset || !activeConfig)
+        throw new Error('Untracked runtime asset request');
+    return activeConfig.useAssetBridge
+        ? await loadAssetFromBridge(asset)
+        : await loadAssetFromUrl(url, asset);
+}
+function createTrackedResponse(asset) {
+    return new Response(responseBuffer(asset.bytes), {
+        status: 200,
+        headers: asset.mimeType ? { 'Content-Type': asset.mimeType } : undefined
+    });
+}
+function installTrackedFetch() {
+    if (typeof NativeXMLHttpRequest === 'undefined')
+        return;
+    class RuntimeAssetXMLHttpRequest {
+        responseType = '';
+        response = null;
+        responseText = '';
+        readyState = 0;
+        status = 0;
+        statusText = '';
+        timeout = 0;
+        withCredentials = false;
+        onload = null;
+        onerror = null;
+        onprogress = null;
+        onreadystatechange = null;
+        native = null;
+        url = '';
+        open(method, url) {
+            const resolvedUrl = trackedAssetUrl(url);
+            if (!resolvedUrl || !isTrackedAssetUrl(resolvedUrl)) {
+                const nativeUrl = resolvedUrl || (url instanceof URL ? url.href : String(url));
+                this.native = new NativeXMLHttpRequest();
+                this.native.responseType = this.responseType;
+                this.native.timeout = this.timeout;
+                this.native.withCredentials = this.withCredentials;
+                this.native.onload = (event) => {
+                    this.response = this.native?.response;
+                    this.responseText = this.native?.responseText || '';
+                    this.readyState = this.native?.readyState || 0;
+                    this.status = this.native?.status || 0;
+                    this.statusText = this.native?.statusText || '';
+                    this.onreadystatechange?.call(this, event);
+                    this.onload?.call(this, event);
+                };
+                this.native.onerror = (event) => {
+                    this.readyState = this.native?.readyState || 4;
+                    this.status = this.native?.status || 0;
+                    this.statusText = this.native?.statusText || '';
+                    this.onreadystatechange?.call(this, event);
+                    this.onerror?.call(this, event);
+                };
+                this.native.onprogress = (event) => {
+                    this.onprogress?.call(this, event);
+                };
+                this.native.onreadystatechange = (event) => {
+                    this.readyState = this.native?.readyState || 0;
+                    this.onreadystatechange?.call(this, event);
+                };
+                this.native.open(method, nativeUrl);
+                return;
+            }
+            this.url = resolvedUrl;
+            this.readyState = 1;
+            this.onreadystatechange?.call(this, new ProgressEvent('readystatechange'));
+        }
+        setRequestHeader(name, value) {
+            this.native?.setRequestHeader(name, value);
+        }
+        async send(body) {
+            if (this.native) {
+                this.native.send(body);
+                return;
+            }
+            try {
+                const loaded = await loadTrackedAsset(this.url);
+                const buffer = responseBuffer(loaded.bytes);
+                this.status = 200;
+                this.statusText = 'OK';
+                this.readyState = 4;
+                if (this.responseType === 'arraybuffer') {
+                    this.response = buffer;
+                }
+                else if (this.responseType === 'blob') {
+                    this.response = new Blob([buffer], {
+                        type: loaded.mimeType || 'application/octet-stream'
+                    });
+                }
+                else {
+                    const text = decoder.decode(loaded.bytes);
+                    this.responseText = text;
+                    this.response = text;
+                }
+                const progressEvent = new ProgressEvent('progress', {
+                    lengthComputable: true,
+                    loaded: loaded.bytes.byteLength,
+                    total: loaded.bytes.byteLength
+                });
+                this.onprogress?.call(this, progressEvent);
+                this.onreadystatechange?.call(this, new ProgressEvent('readystatechange'));
+                this.onload?.call(this, new ProgressEvent('load'));
+            }
+            catch (error) {
+                this.readyState = 4;
+                this.status = 0;
+                this.statusText = error instanceof Error ? error.message : String(error);
+                this.onreadystatechange?.call(this, new ProgressEvent('readystatechange'));
+                this.onerror?.call(this, new ProgressEvent('error'));
+            }
+        }
+        abort() {
+            this.native?.abort();
+        }
+        getAllResponseHeaders() {
+            return this.native?.getAllResponseHeaders() || '';
+        }
+        getResponseHeader(name) {
+            return this.native?.getResponseHeader(name) || null;
+        }
+    }
+    globalThis.XMLHttpRequest = RuntimeAssetXMLHttpRequest;
+}
+function installRuntimeAssetInterceptors() {
+    if (interceptorsInstalled)
+        return;
+    interceptorsInstalled = true;
+    globalThis.fetch = (async (input, init) => {
+        const resolvedUrl = trackedAssetUrl(input);
+        if (!resolvedUrl || !isTrackedAssetUrl(resolvedUrl))
+            return originalFetch(input, init);
+        return createTrackedResponse(await loadTrackedAsset(resolvedUrl));
+    });
+    installTrackedFetch();
+}
+export function configureWorkerRuntimeAssets(config) {
+    activeConfig = config;
+    installRuntimeAssetInterceptors();
+}
+export function handleWorkerAssetMessage(data) {
+    const response = data?.assetResponse;
+    if (!response)
+        return false;
+    const pending = pendingAssetRequests.get(response.id);
+    if (!pending)
+        return true;
+    pendingAssetRequests.delete(response.id);
+    if (!response.ok) {
+        pending.reject(new Error(response.error || 'Runtime asset request failed'));
+        return true;
+    }
+    pending.resolve({
+        bytes: new Uint8Array(response.bytes),
+        mimeType: response.mimeType || undefined
+    });
+    return true;
+}
+export async function loadWorkerRuntimeAsset(asset) {
+    if (!activeConfig)
+        throw new Error('Runtime asset config unavailable');
+    return await loadTrackedAsset(new URL(asset, activeConfig.baseUrl).href);
+}

package/dist/playground/worker/clang.js

@@ -1,3 +1,4 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
 self.document = {
     querySelectorAll() {
         return [];
@@ -9,32 +10,14 @@ 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
     });
 }
 self.onmessage = async (event) => {
-    const { code, buffer, debugBuffer, load, interrupt, log, path, prepare, args, debug, breakpoints, pauseOnEntry } = event.data;
+    const { code, buffer, debugBuffer, load, interrupt, log, path, prepare, language, compileArgs, programArgs, cppVersion, cVersion, debug, breakpoints, pauseOnEntry } = event.data;
     if (load) {
         await loadClang(path, log);
         postMessage({ load: true });
@@ -45,7 +28,11 @@ self.onmessage = async (event) => {
         interruptBufferClang = new Uint8Array(interrupt);
         try {
             await clang.compileLink(code, {
-                args,
+                language,
+                compileArgs,
+                programArgs,
+                cppVersion,
+                cVersion,
                 debug,
                 breakpoints,
                 pauseOnEntry,
@@ -65,7 +52,11 @@ self.onmessage = async (event) => {
         interruptBufferClang = new Uint8Array(interrupt);
         try {
             await clang.compileLinkRun(code, {
-                args,
+                language,
+                compileArgs,
+                programArgs,
+                cppVersion,
+                cVersion,
                 debug,
                 breakpoints,
                 pauseOnEntry,
@@ -79,4 +70,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,228 @@
+import { prepareJavaStdinInjection } from '../javaStdin';
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage, loadWorkerRuntimeAsset } from './assets';
+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 decoder = new TextDecoder();
+const toInt8Array = (bytes) => new Int8Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+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) => {
+    if (handleWorkerAssetMessage(event.data))
+        return;
+    const { load, assets, buffer, code, prepare, args = [], stdin = '' } = event.data;
+    try {
+        if (load) {
+            const runtimeAssets = assets;
+            configureWorkerRuntimeAssets(runtimeAssets || null);
+            const baseUrl = runtimeAssets?.baseUrl || '';
+            if (!compiler || loadedBaseUrl !== baseUrl) {
+                loadedBaseUrl = baseUrl;
+                const runtimeSource = decoder.decode((await loadWorkerRuntimeAsset('compiler.wasm-runtime.js')).bytes);
+                const runtimeUrl = URL.createObjectURL(new Blob([runtimeSource], { type: 'text/javascript;charset=utf-8' }));
+                const runtimeModule = await import(/* @vite-ignore */ runtimeUrl);
+                URL.revokeObjectURL(runtimeUrl);
+                const runtimeLoadFn = runtimeModule.load;
+                runtimeLoad = runtimeLoadFn;
+                const compilerWasm = (await loadWorkerRuntimeAsset('compiler.wasm')).bytes;
+                const compilerModule = await runtimeLoadFn(compilerWasm, {
+                    stackDeobfuscator: { enabled: false }
+                });
+                compilerLib = compilerModule.exports;
+                compiler = compilerLib.createCompiler();
+                const [sdk, runtimeClasslib] = await Promise.all([
+                    loadWorkerRuntimeAsset('compile-classlib-teavm.bin').then(({ bytes }) => toInt8Array(bytes)),
+                    loadWorkerRuntimeAsset('runtime-classlib-teavm.bin').then(({ bytes }) => toInt8Array(bytes))
+                ]);
+                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 = 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)
+        });
+    }
+});