wasm-idle 0.4.0 → 0.5.0

package/dist/playground/assetBridge.js

@@ -0,0 +1,192 @@
+import { JAVA_RUNTIME_LOAD_ASSETS, PYTHON_RUNTIME_LOAD_ASSETS } from './assets';
+const encoder = new TextEncoder();
+const transferBuffer = (bytes) => bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+    ? bytes.buffer
+    : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+const expectedAssetsForRuntime = (runtime) => new Set(runtime === 'python' ? [...PYTHON_RUNTIME_LOAD_ASSETS] : [...JAVA_RUNTIME_LOAD_ASSETS]);
+class RuntimeLoadProgress {
+    fractions = new Map();
+    expectedAssets;
+    progress;
+    constructor(runtime) {
+        this.expectedAssets = expectedAssetsForRuntime(runtime);
+        this.reset();
+    }
+    reset(progress) {
+        this.progress = progress;
+        this.fractions.clear();
+        for (const asset of this.expectedAssets)
+            this.fractions.set(asset, 0);
+        this.emit();
+    }
+    update(asset, loaded, total) {
+        if (!this.expectedAssets.has(asset))
+            return;
+        const fraction = total && total > 0 ? Math.min(loaded / total, 1) : loaded > 0 ? 1 : 0;
+        this.fractions.set(asset, fraction);
+        this.emit();
+    }
+    emit() {
+        if (!this.progress)
+            return;
+        if (!this.fractions.size)
+            return this.progress.set?.(0);
+        let total = 0;
+        for (const fraction of this.fractions.values())
+            total += fraction;
+        this.progress.set?.(total / this.fractions.size);
+    }
+}
+export class WorkerAssetBridge {
+    worker;
+    runtime;
+    config;
+    progress;
+    constructor(worker, runtime, config, progress) {
+        this.worker = worker;
+        this.runtime = runtime;
+        this.config = config;
+        this.progress = new RuntimeLoadProgress(runtime);
+        this.progress.reset(progress);
+    }
+    matches(config) {
+        return (this.config.baseUrl === config.baseUrl &&
+            this.config.loader === config.loader &&
+            this.config.useAssetBridge === config.useAssetBridge);
+    }
+    rebind(worker, config, progress) {
+        this.worker = worker;
+        this.config = config;
+        this.progress.reset(progress);
+    }
+    resetProgress(progress) {
+        this.progress.reset(progress);
+    }
+    handleMessage(event) {
+        const assetRequest = event.data?.assetRequest;
+        if (assetRequest) {
+            void this.respond(assetRequest);
+            return true;
+        }
+        const assetProgress = event.data?.assetProgress;
+        if (assetProgress) {
+            this.progress.update(assetProgress.asset, assetProgress.loaded, assetProgress.total);
+            return true;
+        }
+        return false;
+    }
+    async respond(request) {
+        try {
+            const loaded = await this.loadAsset(request.asset);
+            const buffer = transferBuffer(loaded.bytes);
+            this.worker.postMessage({
+                assetResponse: {
+                    id: request.id,
+                    ok: true,
+                    bytes: buffer,
+                    mimeType: loaded.mimeType
+                }
+            }, [buffer]);
+        }
+        catch (error) {
+            this.worker.postMessage({
+                assetResponse: {
+                    id: request.id,
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error)
+                }
+            });
+        }
+    }
+    async loadAsset(asset) {
+        const reportProgress = (loaded, total) => this.progress.update(asset, loaded, total);
+        if (this.config.loader) {
+            const loaded = await this.normalizeLoaderResult(await this.config.loader({
+                runtime: this.runtime,
+                asset,
+                reportProgress
+            }), asset);
+            if (loaded)
+                return loaded;
+        }
+        return await this.fetchAsset(new URL(asset, this.config.baseUrl).href, asset);
+    }
+    async normalizeLoaderResult(result, asset) {
+        if (!result)
+            return null;
+        if (typeof result === 'string' || result instanceof URL) {
+            return await this.fetchAsset(String(result), asset);
+        }
+        if (result instanceof ArrayBuffer) {
+            const bytes = new Uint8Array(result);
+            this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+            return { bytes };
+        }
+        if (result instanceof Uint8Array) {
+            this.progress.update(asset, result.byteLength, result.byteLength);
+            return { bytes: result };
+        }
+        if (result instanceof Blob) {
+            const bytes = new Uint8Array(await result.arrayBuffer());
+            this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+            return { bytes, mimeType: result.type || undefined };
+        }
+        if ('url' in result && result.url) {
+            return await this.fetchAsset(String(result.url), asset);
+        }
+        if ('data' in result) {
+            if (typeof result.data === 'string') {
+                const bytes = encoder.encode(result.data);
+                this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+                return { bytes, mimeType: result.mimeType };
+            }
+            if (result.data instanceof ArrayBuffer) {
+                const bytes = new Uint8Array(result.data);
+                this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+                return { bytes, mimeType: result.mimeType };
+            }
+            if (result.data instanceof Uint8Array) {
+                this.progress.update(asset, result.data.byteLength, result.data.byteLength);
+                return { bytes: result.data, mimeType: result.mimeType };
+            }
+            const bytes = new Uint8Array(await result.data.arrayBuffer());
+            this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+            return { bytes, mimeType: result.mimeType || result.data.type || undefined };
+        }
+        return null;
+    }
+    async fetchAsset(url, asset) {
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Failed to load ${asset}: ${response.status}`);
+        const contentLength = 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());
+            this.progress.update(asset, bytes.byteLength, contentLength ?? 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;
+            this.progress.update(asset, receivedLength, contentLength);
+        }
+        const bytes = new Uint8Array(receivedLength);
+        let position = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, position);
+            position += chunk.byteLength;
+        }
+        this.progress.update(asset, receivedLength, contentLength ?? receivedLength);
+        return { bytes, mimeType };
+    }
+}

package/dist/playground/assets.d.ts

@@ -0,0 +1,37 @@
+export type RuntimeAssetRuntime = 'python' | 'java';
+export interface RuntimeAssetLoadRequest {
+    runtime: RuntimeAssetRuntime;
+    asset: string;
+    reportProgress: (loaded: number, total?: number) => void;
+}
+export interface RuntimeAssetDataResult {
+    data: string | ArrayBuffer | Uint8Array | Blob;
+    mimeType?: string;
+}
+export interface RuntimeAssetUrlResult {
+    url: string | URL;
+}
+export type RuntimeAssetLoaderResult = RuntimeAssetDataResult | RuntimeAssetUrlResult | string | URL | ArrayBuffer | Uint8Array | Blob | null | undefined;
+export type RuntimeAssetLoader = (request: RuntimeAssetLoadRequest) => RuntimeAssetLoaderResult | Promise<RuntimeAssetLoaderResult>;
+export interface RuntimeAssetConfig {
+    baseUrl?: string;
+    loader?: RuntimeAssetLoader;
+}
+export interface RustRuntimeAssetConfig {
+    compilerUrl?: string;
+}
+export interface PlaygroundRuntimeAssets {
+    rootUrl?: string;
+    python?: RuntimeAssetConfig;
+    java?: RuntimeAssetConfig;
+    rust?: RustRuntimeAssetConfig;
+}
+export interface ResolvedRuntimeAssetConfig {
+    baseUrl: string;
+    loader?: RuntimeAssetLoader;
+    useAssetBridge: boolean;
+}
+export declare const PYTHON_RUNTIME_LOAD_ASSETS: readonly ["pyodide.asm.js", "pyodide-lock.json", "pyodide.asm.wasm", "python_stdlib.zip"];
+export declare const JAVA_RUNTIME_LOAD_ASSETS: readonly ["compiler.wasm-runtime.js", "compiler.wasm", "compile-classlib-teavm.bin", "runtime-classlib-teavm.bin"];
+export declare function resolveRuntimeAssetConfig(runtime: RuntimeAssetRuntime, options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): ResolvedRuntimeAssetConfig;
+export declare function resolveRustCompilerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): any;

package/dist/playground/assets.js

@@ -0,0 +1,105 @@
+import { env as publicEnv } from '$env/dynamic/public';
+import { normalizeTeaVmBaseUrl, resolveTeaVmBaseUrl } from './teavmConfig';
+export const PYTHON_RUNTIME_LOAD_ASSETS = [
+    'pyodide.asm.js',
+    'pyodide-lock.json',
+    'pyodide.asm.wasm',
+    'python_stdlib.zip'
+];
+export const JAVA_RUNTIME_LOAD_ASSETS = [
+    'compiler.wasm-runtime.js',
+    'compiler.wasm',
+    'compile-classlib-teavm.bin',
+    'runtime-classlib-teavm.bin'
+];
+const PYTHON_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/python/';
+const JAVA_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/java/';
+const normalizeBaseUrl = (baseUrl, currentUrl = '') => {
+    const normalized = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    return currentUrl ? new URL(normalized, currentUrl).href : normalized;
+};
+const normalizeRootUrl = (rootUrl) => rootUrl.endsWith('/') ? rootUrl.slice(0, -1) : rootUrl;
+const resolvePythonBaseUrl = (rootUrl = '', currentUrl = '') => normalizeBaseUrl(`${normalizeRootUrl(rootUrl) || ''}/pyodide/`, currentUrl);
+const resolvePythonRuntimeAssetConfig = (options, currentUrl = '') => {
+    if (typeof options === 'string') {
+        return {
+            baseUrl: resolvePythonBaseUrl(options, currentUrl),
+            useAssetBridge: false
+        };
+    }
+    const runtimeConfig = options?.python;
+    if (runtimeConfig?.baseUrl) {
+        return {
+            baseUrl: normalizeBaseUrl(runtimeConfig.baseUrl, currentUrl),
+            loader: runtimeConfig.loader,
+            useAssetBridge: !!runtimeConfig.loader
+        };
+    }
+    if (options?.rootUrl) {
+        return {
+            baseUrl: resolvePythonBaseUrl(options.rootUrl, currentUrl),
+            loader: runtimeConfig?.loader,
+            useAssetBridge: !!runtimeConfig?.loader
+        };
+    }
+    if (runtimeConfig?.loader) {
+        return {
+            baseUrl: PYTHON_VIRTUAL_BASE_URL,
+            loader: runtimeConfig.loader,
+            useAssetBridge: true
+        };
+    }
+    return {
+        baseUrl: resolvePythonBaseUrl('', currentUrl),
+        useAssetBridge: false
+    };
+};
+const resolveJavaBaseUrl = (rootUrl = '', currentUrl = '') => resolveTeaVmBaseUrl(rootUrl, currentUrl);
+const resolveJavaRuntimeAssetConfig = (options, currentUrl = '') => {
+    if (typeof options === 'string') {
+        return {
+            baseUrl: resolveJavaBaseUrl(options, currentUrl),
+            useAssetBridge: false
+        };
+    }
+    const runtimeConfig = options?.java;
+    if (runtimeConfig?.baseUrl) {
+        return {
+            baseUrl: currentUrl
+                ? new URL(normalizeTeaVmBaseUrl(runtimeConfig.baseUrl), currentUrl).href
+                : normalizeTeaVmBaseUrl(runtimeConfig.baseUrl),
+            loader: runtimeConfig.loader,
+            useAssetBridge: !!runtimeConfig.loader
+        };
+    }
+    if (options?.rootUrl) {
+        return {
+            baseUrl: resolveJavaBaseUrl(options.rootUrl, currentUrl),
+            loader: runtimeConfig?.loader,
+            useAssetBridge: !!runtimeConfig?.loader
+        };
+    }
+    if (runtimeConfig?.loader) {
+        return {
+            baseUrl: JAVA_VIRTUAL_BASE_URL,
+            loader: runtimeConfig.loader,
+            useAssetBridge: true
+        };
+    }
+    return {
+        baseUrl: resolveJavaBaseUrl('', currentUrl),
+        useAssetBridge: false
+    };
+};
+export function resolveRuntimeAssetConfig(runtime, options, currentUrl = '') {
+    return runtime === 'python'
+        ? resolvePythonRuntimeAssetConfig(options, currentUrl)
+        : resolveJavaRuntimeAssetConfig(options, currentUrl);
+}
+export function resolveRustCompilerUrl(options, currentUrl = '') {
+    const configuredCompilerUrl = (typeof options === 'object' && options?.rust?.compilerUrl) ||
+        (publicEnv.PUBLIC_WASM_RUST_COMPILER_URL || '').trim();
+    if (!configuredCompilerUrl)
+        return '';
+    return currentUrl ? new URL(configuredCompilerUrl, currentUrl).href : configuredCompilerUrl;
+}

package/dist/playground/clang.d.ts

@@ -1,13 +1,17 @@
 import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { PlaygroundRuntimeAssets } from './assets';
 import type { Sandbox } from './sandbox';
 import type { Writable } from 'svelte/store';
 declare class Clang implements Sandbox {
+    language: 'C' | 'CPP';
     ts: number;
     output: any;
     ondebug?: (event: DebugSessionEvent) => void;
     worker?: Worker;
     buffer: SharedArrayBuffer;
     debugBuffer: SharedArrayBuffer;
+    watchBuffer: SharedArrayBuffer;
+    watchResultBuffer: SharedArrayBuffer;
     interruptBuffer: SharedArrayBuffer;
     pendingInput: string[];
     begin: number;
@@ -17,7 +21,11 @@ declare class Clang implements Sandbox {
     waitingForInput: boolean;
     pendingEof: boolean;
     exit: boolean;
-    load(path: string, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
+    activeReject: ((reason?: string) => void) | null;
+    constructor(language: 'C' | 'CPP');
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions, _progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<void>;
     write(input: string): void;
     eof(): void;
     private flushPendingInput;
@@ -25,6 +33,8 @@ declare class Clang implements Sandbox {
         set?: (value: number) => void;
     }, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
     debugCommand(command: DebugCommand): void;
+    setBreakpoints(lines: number[]): void;
+    debugEvaluate(expression: string): Promise<string>;
     kill(): void;
     terminate(): void;
     clear(): Promise<void>;

package/dist/playground/clang.js

@@ -1,11 +1,16 @@
-import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+import { resolveSandboxExecutionArgs } from './options';
+import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
+const debugBreakpointBufferInts = 1028;
 class Clang {
+    language;
     ts = Date.now();
     output = null;
     ondebug;
     worker = null;
     buffer = new SharedArrayBuffer(1024);
-    debugBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 4);
+    debugBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * debugBreakpointBufferInts);
+    watchBuffer = new SharedArrayBuffer(1024);
+    watchResultBuffer = new SharedArrayBuffer(1024);
     interruptBuffer = new SharedArrayBuffer(1);
     pendingInput = [];
     begin = 0;
@@ -15,12 +20,17 @@ class Clang {
     waitingForInput = false;
     pendingEof = false;
     exit = true;
-    load(path, code = '', log = true, args = [], _options = {}) {
+    activeReject = null;
+    constructor(language) {
+        this.language = language;
+    }
+    load(runtimeAssets = '', code = '', log = true, args = [], _options = {}, _progress) {
         return new Promise(async (resolve) => {
             this.log = log;
             this.pendingInput = [];
             this.waitingForInput = false;
             this.pendingEof = false;
+            const path = typeof runtimeAssets === 'string' ? runtimeAssets : runtimeAssets?.rootUrl || '';
             if (!this.worker) {
                 this.worker = new (await import('./worker/clang?worker')).default();
                 this.worker.onmessage = () => resolve();
@@ -59,6 +69,9 @@ class Clang {
         return new Promise(async (resolve, reject) => {
             if (!this.worker)
                 return reject('Worker not loaded');
+            this.activeReject = reject;
+            const { compileArgs, programArgs } = resolveSandboxExecutionArgs(this.language, args, options);
+            this.setBreakpoints(options.debug ? [...(options.breakpoints || [])] : []);
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
                 if (!this.worker)
@@ -79,6 +92,7 @@ class Clang {
                     this.exit = true;
                     this.waitingForInput = false;
                     this.pendingEof = false;
+                    this.activeReject = null;
                     this.ondebug?.({ type: 'stop' });
                     resolve(results);
                 }
@@ -88,6 +102,7 @@ class Clang {
                     this.elapse = Date.now() - this.begin;
                     this.waitingForInput = false;
                     this.pendingEof = false;
+                    this.activeReject = null;
                     this.exit = true;
                     this.ondebug?.({ type: 'stop' });
                     reject(error);
@@ -103,10 +118,16 @@ class Clang {
                 prepare,
                 buffer: this.buffer,
                 debugBuffer: this.debugBuffer,
+                watchBuffer: this.watchBuffer,
+                watchResultBuffer: this.watchResultBuffer,
                 interrupt: this.interruptBuffer,
                 context: {},
                 log,
-                args,
+                language: this.language,
+                compileArgs,
+                programArgs,
+                cppVersion: options.cppVersion,
+                cVersion: options.cVersion,
                 debug: !!options.debug,
                 breakpoints: [...(options.breakpoints || [])],
                 pauseOnEntry: !!options.pauseOnEntry
@@ -120,15 +141,46 @@ class Clang {
         Atomics.notify(control, 0);
         this.ondebug?.({ type: 'resume', command });
     }
+    setBreakpoints(lines) {
+        const control = new Int32Array(this.debugBuffer);
+        const next = [...new Set(lines.filter((line) => Number.isInteger(line) && line > 0))]
+            .sort((left, right) => left - right)
+            .slice(0, Math.max(0, control.length - 4));
+        for (let index = 4; index < control.length; index += 1) {
+            Atomics.store(control, index, next[index - 4] || 0);
+        }
+        Atomics.store(control, 3, next.length);
+        Atomics.add(control, 2, 1);
+    }
+    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.activeReject?.('Process terminated');
+        this.activeReject = null;
+        this.waitingForInput = false;
         this.pendingEof = false;
+        this.uid += 1;
         new Uint8Array(this.interruptBuffer)[0] = 2;
         const control = new Int32Array(this.debugBuffer);
         Atomics.add(control, 0, 1);
         Atomics.notify(control, 0);
+        this.worker?.terminate?.();
+        delete this.worker;
+        this.exit = true;
     }
     async clear() {
         this.terminate();
@@ -138,6 +190,8 @@ class Clang {
         if (this.worker)
             this.worker.onmessage = null;
         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));

package/dist/playground/index.d.ts

@@ -1,6 +1,6 @@
-import Clang from './clang';
-import Java from './java';
-import Python from './python';
-import type { Sandbox } from './sandbox';
+import type { BoundSandbox, PlaygroundBinding, Sandbox, SandboxRuntimeAssets } from './sandbox';
 export declare const supportedLanguages: string[];
-export default function load(language: string): Promise<Sandbox | Clang | Java | Python>;
+export declare function createPlaygroundBinding(runtimeAssets: SandboxRuntimeAssets): PlaygroundBinding;
+declare function playground(language: string): Promise<Sandbox>;
+declare function playground(language: string, runtimeAssets: SandboxRuntimeAssets): Promise<BoundSandbox>;
+export default playground;

package/dist/playground/index.js

@@ -1,11 +1,45 @@
 import Clang from './clang';
 import Java from './java';
 import Python from './python';
+import Rust from './rust';
 const sandboxCache = {};
-export const supportedLanguages = ['PYTHON3', 'PYPY3', 'C', 'CPP', 'JAVA'];
-export default async function load(language) {
-    if (sandboxCache[language])
-        return sandboxCache[language];
+export const supportedLanguages = ['PYTHON3', 'PYPY3', 'C', 'CPP', 'JAVA', 'RUST'];
+function bindRuntimeAssets(sandbox, runtimeAssets) {
+    return new Proxy(sandbox, {
+        get(target, prop, receiver) {
+            if (prop === 'runtimeAssets')
+                return runtimeAssets;
+            if (prop === 'load') {
+                return (code = '', log = true, args = [], options = {}, progress) => target.load(runtimeAssets, code, log, args, options, progress);
+            }
+            const value = Reflect.get(target, prop, receiver);
+            return typeof value === 'function' ? value.bind(target) : value;
+        },
+        set(target, prop, value, receiver) {
+            return Reflect.set(target, prop, value, receiver);
+        }
+    });
+}
+export function createPlaygroundBinding(runtimeAssets) {
+    const binding = {
+        runtimeAssets,
+        terminalProps: {},
+        async load(language) {
+            return bindRuntimeAssets(await playground(language), runtimeAssets);
+        }
+    };
+    binding.terminalProps = {
+        playground: binding,
+        runtimeAssets
+    };
+    return binding;
+}
+async function playground(language, runtimeAssets) {
+    if (sandboxCache[language]) {
+        return runtimeAssets
+            ? bindRuntimeAssets(sandboxCache[language], runtimeAssets)
+            : sandboxCache[language];
+    }
     let sandbox;
     switch (language) {
         case 'PYTHON3':
@@ -14,12 +48,17 @@ export default async function load(language) {
             sandbox = new Python();
             break;
         case 'C':
+            sandbox = new Clang('C');
+            break;
         case 'CPP':
-            sandbox = new Clang();
+            sandbox = new Clang('CPP');
             break;
         case 'JAVA':
             sandbox = new Java();
             break;
+        case 'RUST':
+            sandbox = new Rust();
+            break;
         default:
             throw new Error(`Unsupported language: ${language}`);
     }
@@ -37,6 +76,9 @@ export default async function load(language) {
             sandboxCache['CPP'] = sandbox;
         if (language === 'JAVA')
             sandboxCache['JAVA'] = sandbox;
+        if (language === 'RUST')
+            sandboxCache['RUST'] = sandbox;
     }
-    return sandbox;
+    return runtimeAssets ? bindRuntimeAssets(sandbox, runtimeAssets) : sandbox;
 }
+export default playground;

package/dist/playground/java.d.ts

@@ -1,4 +1,6 @@
-import type { CompilerDiagnostic, SandboxExecutionOptions } from './options';
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import { WorkerAssetBridge } from './assetBridge';
+import { type PlaygroundRuntimeAssets } from './assets';
 import type { Sandbox } from './sandbox';
 declare class Java implements Sandbox {
     output: any;
@@ -14,7 +16,10 @@ declare class Java implements Sandbox {
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     waitingForInput: boolean;
     pendingEof: boolean;
-    load(path: string, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
+    assetBridge: WorkerAssetBridge | null;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<void>;
     write(input: string): void;
     eof(): void;
     private flushPendingInput;