wasm-idle 0.4.0 → 0.5.0

package/dist/playground/rust.js

@@ -0,0 +1,175 @@
+import { resolveRustCompilerUrl } from './assets';
+import { resolveSandboxExecutionArgs } from './options';
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+class Rust {
+    output = null;
+    worker = null;
+    buffer = new SharedArrayBuffer(1024);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    compilerUrl = '';
+    assetPath = '';
+    activeReject = null;
+    oncompilerdiagnostic;
+    waitingForInput = false;
+    pendingEof = false;
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], _options = {}, progress) {
+        return new Promise(async (resolve, reject) => {
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+            const nextCompilerUrl = resolveRustCompilerUrl(runtimeAssets, currentUrl);
+            const nextAssetPath = typeof runtimeAssets === 'string'
+                ? runtimeAssets
+                : runtimeAssets?.rootUrl ||
+                    (typeof window !== 'undefined'
+                        ? window.location.pathname.replace(/\/$/, '')
+                        : '');
+            if (!nextCompilerUrl) {
+                return reject('Rust runtime is not configured. Set PUBLIC_WASM_RUST_COMPILER_URL or runtimeAssets.rust.compilerUrl.');
+            }
+            const needsWorkerReset = !this.worker || this.compilerUrl !== nextCompilerUrl || this.assetPath !== nextAssetPath;
+            this.compilerUrl = nextCompilerUrl;
+            this.assetPath = nextAssetPath;
+            if (needsWorkerReset && this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+            }
+            if (!this.worker) {
+                this.worker = new (await import('./worker/rust?worker')).default();
+                this.worker.onerror = (event) => {
+                    const location = event.filename && event.lineno
+                        ? ` (${event.filename}:${event.lineno}:${event.colno})`
+                        : '';
+                    reject(`Rust worker script error: ${event.message || 'unknown error'}${location}`);
+                };
+                this.worker.onmessageerror = () => {
+                    reject('Rust worker message deserialization failed');
+                };
+                this.worker.onmessage = (event) => {
+                    if (event.data?.load) {
+                        progress?.set?.(1);
+                        resolve();
+                    }
+                    if (event.data?.error)
+                        reject(event.data.error);
+                };
+                this.worker.postMessage({
+                    load: true,
+                    compilerUrl: this.compilerUrl,
+                    path: this.assetPath
+                });
+            }
+            else {
+                progress?.set?.(1);
+                resolve();
+            }
+        });
+    }
+    write(input) {
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        this.flushPendingInput();
+    }
+    eof() {
+        this.pendingEof = true;
+        this.flushPendingInput();
+    }
+    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((resolve, reject) => {
+            if (!this.worker)
+                return reject('Worker not loaded');
+            const { programArgs } = resolveSandboxExecutionArgs('RUST', args, options);
+            const targetTriple = options.rustTargetTriple || 'wasm32-wasip1';
+            const _uid = ++this.uid;
+            this.activeReject = reject;
+            const handler = (event) => {
+                if (!this.worker)
+                    return reject('Worker not loaded');
+                if (_uid !== this.uid)
+                    return (this.worker.onmessage = null);
+                const { output, results, error, buffer, diagnostic, progress } = event.data;
+                if (buffer) {
+                    this.waitingForInput = true;
+                    this.flushPendingInput();
+                }
+                if (progress && typeof progress.percent === 'number') {
+                    _prog?.set?.(Math.max(0, Math.min(progress.percent / 100, 1)));
+                }
+                if (output)
+                    this.output(output);
+                if (diagnostic)
+                    this.oncompilerdiagnostic?.(diagnostic);
+                if (results) {
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.activeReject = null;
+                    resolve(results);
+                }
+                if (error) {
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.activeReject = null;
+                    reject(error);
+                }
+            };
+            this.worker.onmessage = handler;
+            this.begin = Date.now();
+            this.worker.postMessage({
+                code,
+                prepare,
+                buffer: this.buffer,
+                args: programArgs,
+                targetTriple,
+                log: _log
+            });
+        });
+    }
+    kill() {
+        this.terminate();
+    }
+    terminate() {
+        this.activeReject?.('Process terminated');
+        this.activeReject = null;
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.uid += 1;
+        this.worker?.terminate?.();
+        delete this.worker;
+        this.exit = true;
+    }
+    async clear() {
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        if (this.worker)
+            this.worker.onmessage = null;
+        resetBufferedStdin(this.buffer);
+        if (!this.exit) {
+            this.terminate();
+        }
+    }
+}
+export default Rust;

package/dist/playground/sandbox.d.ts

@@ -1,13 +1,15 @@
 import type { CompilerDiagnostic, DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { PlaygroundRuntimeAssets } from './assets';
 import type { Writable } from 'svelte/store';
-type ProgressLike = Writable<number> | {
+export type SandboxRuntimeAssets = string | PlaygroundRuntimeAssets;
+export type SandboxProgress = Writable<number> | {
     set?: (value: number) => void;
 };
 export interface Sandbox {
     constructor: any;
     eof: () => void;
-    load: (path: string, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions) => Promise<void>;
-    run: (code: string, prepare: boolean, log?: boolean, prog?: ProgressLike, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean | string>;
+    load: (runtimeAssets?: SandboxRuntimeAssets, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress) => Promise<void>;
+    run: (code: string, prepare: boolean, log?: boolean, prog?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean | string>;
     terminate: () => void;
     clear: () => Promise<void>;
     kill?: () => void;
@@ -16,6 +18,7 @@ export interface Sandbox {
     ondebug?: (event: DebugSessionEvent) => void;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     debugCommand?: (command: DebugCommand) => void;
+    setBreakpoints?: (lines: number[]) => void;
     debugEvaluate?: (expression: string) => Promise<string>;
     image?: (data: {
         mime: string;
@@ -24,4 +27,16 @@ export interface Sandbox {
     }) => void;
     elapse?: number;
 }
-export {};
+export interface BoundSandbox extends Omit<Sandbox, 'load'> {
+    load: (code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress) => Promise<void>;
+    runtimeAssets: SandboxRuntimeAssets;
+}
+export interface PlaygroundTerminalProps {
+    playground: PlaygroundBinding;
+    runtimeAssets: SandboxRuntimeAssets;
+}
+export interface PlaygroundBinding {
+    runtimeAssets: SandboxRuntimeAssets;
+    terminalProps: PlaygroundTerminalProps;
+    load: (language: string) => Promise<BoundSandbox>;
+}

package/dist/playground/wasmRustVersion.d.ts

@@ -0,0 +1 @@
+export declare const WASM_RUST_ASSET_VERSION = "2d36c8a3cd2cbbfd";

package/dist/playground/wasmRustVersion.js

@@ -0,0 +1 @@
+export const WASM_RUST_ASSET_VERSION = "2d36c8a3cd2cbbfd";

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

@@ -4,7 +4,7 @@ self.document = {
         return [];
     }
 };
-let stdinBufferClang, debugBufferClang, interruptBufferClang, clang;
+let stdinBufferClang, debugBufferClang, watchBufferClang, watchResultBufferClang, interruptBufferClang, clang;
 async function loadClang(path, log) {
     const { default: Clang } = await import('../../clang');
     clang = new Clang({
@@ -17,7 +17,7 @@ async function loadClang(path, log) {
     });
 }
 self.onmessage = async (event) => {
-    const { code, buffer, debugBuffer, load, interrupt, log, path, prepare, args, debug, breakpoints, pauseOnEntry } = event.data;
+    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, log, path, prepare, language, compileArgs, programArgs, cppVersion, cVersion, debug, breakpoints, pauseOnEntry } = event.data;
     if (load) {
         await loadClang(path, log);
         postMessage({ load: true });
@@ -25,15 +25,23 @@ self.onmessage = async (event) => {
     else if (prepare) {
         stdinBufferClang = new Int32Array(buffer);
         debugBufferClang = new Int32Array(debugBuffer);
+        watchBufferClang = new Int32Array(watchBuffer);
+        watchResultBufferClang = new Int32Array(watchResultBuffer);
         interruptBufferClang = new Uint8Array(interrupt);
         try {
             await clang.compileLink(code, {
-                args,
+                language,
+                compileArgs,
+                programArgs,
+                cppVersion,
+                cVersion,
                 debug,
                 breakpoints,
                 pauseOnEntry,
                 debugBuffer: debugBufferClang,
-                interruptBuffer: interruptBufferClang
+                interruptBuffer: interruptBufferClang,
+                watchBuffer: watchBufferClang,
+                watchResultBuffer: watchResultBufferClang
             });
             self.postMessage({ results: true });
         }
@@ -45,15 +53,23 @@ self.onmessage = async (event) => {
         clang.log = log;
         stdinBufferClang = new Int32Array(buffer);
         debugBufferClang = new Int32Array(debugBuffer);
+        watchBufferClang = new Int32Array(watchBuffer);
+        watchResultBufferClang = new Int32Array(watchResultBuffer);
         interruptBufferClang = new Uint8Array(interrupt);
         try {
             await clang.compileLinkRun(code, {
-                args,
+                language,
+                compileArgs,
+                programArgs,
+                cppVersion,
+                cVersion,
                 debug,
                 breakpoints,
                 pauseOnEntry,
                 debugBuffer: debugBufferClang,
-                interruptBuffer: interruptBufferClang
+                interruptBuffer: interruptBufferClang,
+                watchBuffer: watchBufferClang,
+                watchResultBuffer: watchResultBufferClang
             });
             self.postMessage({ results: true });
         }

package/dist/playground/worker/java.js

@@ -1,6 +1,6 @@
 import { prepareJavaStdinInjection } from '../javaStdin';
 import { waitForBufferedStdin } from '../stdinBuffer';
-import { resolveTeaVmAssetUrl } from '../teavmConfig';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage, loadWorkerRuntimeAsset } from './assets';
 let compilerLib = null;
 let compiler = null;
 let runtimeLoad = null;
@@ -15,18 +15,8 @@ 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 decoder = new TextDecoder();
+const toInt8Array = (bytes) => new Int8Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
 const flushStdout = () => {
     if (!stdoutBuffer)
         return;
@@ -50,41 +40,31 @@ const pushStderr = (charCode) => {
         flushStderr();
 };
 self.addEventListener('message', async (event) => {
-    const { load, baseUrl, buffer, code, prepare, args = [], stdin = '' } = event.data;
+    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 = 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 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 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 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([
-                    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());
-                    })
+                    loadWorkerRuntimeAsset('compile-classlib-teavm.bin').then(({ bytes }) => toInt8Array(bytes)),
+                    loadWorkerRuntimeAsset('runtime-classlib-teavm.bin').then(({ bytes }) => toInt8Array(bytes))
                 ]);
                 compiler.setSdk(sdk);
                 compiler.setTeaVMClasslib(runtimeClasslib);
@@ -185,7 +165,7 @@ self.addEventListener('message', async (event) => {
             compiledCode = code;
             compiledStdin = stdinInjection.stdinCacheKey;
             compiledMainClass = mainClass;
-            compiledWasm = await maybeDecompressWasm(new Uint8Array(compiler.getWebAssemblyOutputFile('app.wasm')));
+            compiledWasm = new Uint8Array(compiler.getWebAssemblyOutputFile('app.wasm'));
         }
         if (prepare) {
             self.postMessage({ results: true });