wasm-idle 0.4.0 → 0.4.1

package/README.md

@@ -8,4 +8,22 @@ Refer to src/lib/clang.
 
 Java uses TeaVM's browser compiler/runtime. TeaVM compiler/runtime/classlib assets are bundled under `static/teavm/` by default, and the asset base URL can be overridden with `PUBLIC_TEAVM_BASE_URL`.
 
+`Terminal` and `playground(...).load(...)` support either the legacy shared `path`/`rootUrl` or per-runtime asset config:
+
+```ts
+import type { PlaygroundRuntimeAssets } from 'wasm-idle';
+
+const runtimeAssets: PlaygroundRuntimeAssets = {
+	rootUrl: 'https://cdn.example.com/repl',
+	python: {
+		loader: async ({ asset }) => ({ url: `https://cdn.example.com/repl/pyodide/${asset}` })
+	},
+	java: {
+		baseUrl: 'https://cdn.example.com/repl/teavm/'
+	}
+};
+```
+
+Python custom loaders receive file names under the Pyodide asset root and can serve both core assets and package files. TeaVM custom loaders receive file names under the TeaVM asset root. Compressed TeaVM runtime assets are no longer unpacked inside the library; provide the final file URL or handle decompression in your own loader.
+
 Powered by [wasm-clang](https://github.com/binji/wasm-clang), Pyodide, and TeaVM.

package/dist/clang/app.js

@@ -74,7 +74,9 @@ export default class App {
             return ESUCCESS;
         session.currentFunctionId = functionId;
         session.currentLine = line;
-        const frame = [...session.frames].reverse().find((candidate) => candidate.functionId === functionId);
+        const frame = [...session.frames]
+            .reverse()
+            .find((candidate) => candidate.functionId === functionId);
         if (frame)
             frame.line = line;
         session.pauseOnEntry = false;
@@ -93,7 +95,10 @@ export default class App {
                     : variable.length
                         ? [variable.length]
                         : [];
-                if (!Number.isFinite(address) || address <= 0 || !dimensions.length || !variable.elementKind) {
+                if (!Number.isFinite(address) ||
+                    address <= 0 ||
+                    !dimensions.length ||
+                    !variable.elementKind) {
                     return [{ name: variable.name, value: '?' }];
                 }
                 const elementStride = variable.elementKind === 'double'
@@ -115,7 +120,9 @@ export default class App {
                             }
                             if (variable.elementKind === 'char') {
                                 const charCode = this.mem.read8(offset);
-                                values.push(charCode >= 0x20 && charCode <= 0x7e ? `'${String.fromCharCode(charCode)}'` : `${charCode}`);
+                                values.push(charCode >= 0x20 && charCode <= 0x7e
+                                    ? `'${String.fromCharCode(charCode)}'`
+                                    : `${charCode}`);
                                 continue;
                             }
                             if (variable.elementKind === 'float') {
@@ -147,7 +154,9 @@ export default class App {
                     }
                     if (variable.elementKind === 'char') {
                         const charCode = this.mem.read8(offset);
-                        values.push(charCode >= 0x20 && charCode <= 0x7e ? `'${String.fromCharCode(charCode)}'` : `${charCode}`);
+                        values.push(charCode >= 0x20 && charCode <= 0x7e
+                            ? `'${String.fromCharCode(charCode)}'`
+                            : `${charCode}`);
                         continue;
                     }
                     if (variable.elementKind === 'float') {
@@ -186,7 +195,10 @@ export default class App {
             locals: [...locals, ...globals],
             callStack: [...session.frames]
                 .reverse()
-                .map((stackFrame) => ({ functionName: stackFrame.functionName, line: stackFrame.line }))
+                .map((stackFrame) => ({
+                functionName: stackFrame.functionName,
+                line: stackFrame.line
+            }))
         });
         const sequence = Atomics.load(buffer, 0);
         while (true) {

package/dist/clang/index.d.ts

@@ -2,6 +2,7 @@ import type { DebugVariable, DebugVariableMetadata } from '../playground/options
 import App from './app';
 import { MemFS } from './memory';
 import { type Writable } from 'svelte/store';
+type ClangSourceLanguage = 'C' | 'CPP';
 interface APIOption {
     stdin: () => string;
     stdout: (str: string) => void;
@@ -17,7 +18,12 @@ interface APIOption {
     path: string;
 }
 interface DebugRunOptions {
+    language?: ClangSourceLanguage;
     args?: string[];
+    compileArgs?: string[];
+    programArgs?: string[];
+    cppVersion?: string;
+    cVersion?: string;
     debug?: boolean;
     breakpoints?: number[];
     pauseOnEntry?: boolean;

package/dist/clang/index.js

@@ -20,7 +20,94 @@ const clangCommonArgs = [
     '80',
     '-fcolor-diagnostics'
 ];
-const clangLanguageStandardArg = '-std=gnu++2a';
+const defaultCppStandardArg = '-std=gnu++2a';
+const defaultCStandardArg = '-std=gnu11';
+function normalizeStandardCode(value) {
+    return (value || '').trim().toUpperCase().replaceAll(/\s+/g, '');
+}
+function resolveCppStandardArg(version) {
+    switch (normalizeStandardCode(version)) {
+        case '03':
+        case 'CPP03':
+        case 'C++03':
+        case 'GNU++03':
+        case 'GNUC++03':
+            return '-std=gnu++03';
+        case '11':
+        case 'CPP11':
+        case 'C++11':
+        case 'GNU++11':
+        case 'GNUC++11':
+            return '-std=gnu++11';
+        case '14':
+        case 'CPP14':
+        case 'C++14':
+        case 'GNU++14':
+        case 'GNUC++14':
+            return '-std=gnu++14';
+        case '17':
+        case 'CPP17':
+        case 'C++17':
+        case 'GNU++17':
+        case 'GNUC++17':
+            return '-std=gnu++17';
+        case '20':
+        case '23':
+        case '26':
+        case 'CPP20':
+        case 'CPP23':
+        case 'CPP26':
+        case 'C++20':
+        case 'C++23':
+        case 'C++26':
+        case 'GNU++20':
+        case 'GNU++23':
+        case 'GNU++26':
+        case 'GNUC++20':
+        case 'GNUC++23':
+        case 'GNUC++26':
+            return defaultCppStandardArg;
+        default:
+            return defaultCppStandardArg;
+    }
+}
+function resolveCStandardArg(version) {
+    switch (normalizeStandardCode(version)) {
+        case '99':
+        case 'C99':
+        case 'GNU99':
+        case 'GNUC99':
+            return '-std=gnu99';
+        case '11':
+        case 'C11':
+        case 'GNU11':
+        case 'GNUC11':
+            return '-std=gnu11';
+        case '17':
+        case '18':
+        case 'C17':
+        case 'C18':
+        case 'GNU17':
+        case 'GNU18':
+        case 'GNUC17':
+        case 'GNUC18':
+            return '-std=gnu17';
+        default:
+            return defaultCStandardArg;
+    }
+}
+function resolveClangLanguageArgs(language, options) {
+    if (language === 'C') {
+        return {
+            languageArg: 'c',
+            standardArg: resolveCStandardArg(options.cVersion)
+        };
+    }
+    return {
+        languageArg: 'c++',
+        standardArg: resolveCppStandardArg(options.cppVersion)
+    };
+}
 const toUtf8 = (text) => {
     const surrogate = encodeURIComponent(text);
     let result = '';
@@ -127,8 +214,11 @@ export default class Clang {
         const input = options.input;
         let source = options.code;
         const obj = options.obj;
+        const language = options.language === 'C' ? 'C' : 'CPP';
+        const compileArgs = options.compileArgs ?? options.args ?? [];
+        const { languageArg, standardArg } = resolveClangLanguageArgs(language, options);
         const debug = !!options.debug;
-        const opt = debug ? '0' : (options.opt || '2');
+        const opt = debug ? '0' : options.opt || '2';
         if (debug) {
             const lines = source.split('\n');
             let braceDepth = 0;
@@ -231,7 +321,8 @@ export default class Clang {
                     }
                     else {
                         analysisLine =
-                            analysisLine.slice(0, commentStart) + analysisLine.slice(commentEnd + 2);
+                            analysisLine.slice(0, commentStart) +
+                                analysisLine.slice(commentEnd + 2);
                     }
                 }
                 const lineComment = analysisLine.indexOf('//');
@@ -343,7 +434,9 @@ export default class Clang {
                         let declarationParenDepth = 0;
                         let declarationBraceDepth = 0;
                         for (const character of declarationMatch[2]) {
-                            if (character === ',' && declarationParenDepth === 0 && declarationBraceDepth === 0) {
+                            if (character === ',' &&
+                                declarationParenDepth === 0 &&
+                                declarationBraceDepth === 0) {
                                 if (declarationBuffer.trim())
                                     declarations.push(declarationBuffer.trim());
                                 declarationBuffer = '';
@@ -491,7 +584,8 @@ export default class Clang {
                                 }
                             }
                             for (const [name, variable] of globalVariables) {
-                                if (currentFunctionVariables.has(name) || currentFunctionContainers.has(name))
+                                if (currentFunctionVariables.has(name) ||
+                                    currentFunctionContainers.has(name))
                                     continue;
                                 const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
                                 if (new RegExp(`(?:^|[^\\w])(?:\\+\\+|--)\\s*${escapedName}\\b`).test(normalized) ||
@@ -529,7 +623,8 @@ export default class Clang {
                                     for (const [name, variable] of currentFunctionVariables) {
                                         const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
                                         const mutationPattern = new RegExp(`(?:^|[^\\w])(?:\\+\\+|--)\\s*${escapedName}\\b|\\b${escapedName}\\s*(?:[+\\-*/%]?=|\\+\\+|--)`);
-                                        if (!initLooksLikeDeclaration && mutationPattern.test(initSource)) {
+                                        if (!initLooksLikeDeclaration &&
+                                            mutationPattern.test(initSource)) {
                                             initHooks.push(`${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(${currentFunctionId}, ${variable.slot}, ${name})`);
                                         }
                                         if (mutationPattern.test(updateSource)) {
@@ -648,9 +743,11 @@ export default class Clang {
                         if (!nameMatch)
                             continue;
                         const name = nameMatch[1];
-                        const kind = /\bbool\b/.test(cleaned) ? 'bool' : /\b(?:int|float|double|char|short|long)\b/.test(cleaned)
-                            ? 'number'
-                            : '';
+                        const kind = /\bbool\b/.test(cleaned)
+                            ? 'bool'
+                            : /\b(?:int|float|double|char|short|long)\b/.test(cleaned)
+                                ? 'number'
+                                : '';
                         if (!kind)
                             continue;
                         const slot = nextVariableSlot++;
@@ -721,11 +818,11 @@ export default class Clang {
             '-O' + opt,
             '-o',
             obj,
-            clangLanguageStandardArg,
+            standardArg,
             '-x',
-            'c++',
+            languageArg,
             input,
-            ...(options.args || [])
+            ...compileArgs
         ];
         this.trace(`compile ${input} -> ${obj}`);
         return await this.run(clang, true, 'clang', ...compilerArgs);
@@ -781,34 +878,53 @@ export default class Clang {
         return stillRunning ? app : null;
     }
     async compileLink(code, options = {}) {
-        const { args = [], debug = false, breakpoints = [], pauseOnEntry = false, debugBuffer, interruptBuffer } = options;
-        const input = `test.cc`, obj = `test.o`, wasm = `test.wasm`;
+        const { language = 'CPP', args = [], compileArgs = args, debug = false, breakpoints = [], pauseOnEntry = false, cppVersion, cVersion, debugBuffer, interruptBuffer } = options;
+        const input = language === 'C' ? `test.c` : `test.cc`, obj = `test.o`, wasm = `test.wasm`;
         this.beginTrace(debug);
         this.debugBreakpoints = new Set(debug ? breakpoints : []);
         this.debugPauseOnEntry = debug && pauseOnEntry;
         this.debugBuffer = debugBuffer;
         this.debugInterruptBuffer = interruptBuffer;
-        const buildKey = JSON.stringify({ code, args, debug });
+        const buildKey = JSON.stringify({
+            code,
+            language,
+            compileArgs,
+            cppVersion,
+            cVersion,
+            debug
+        });
         if (this.lastBuildKey === buildKey) {
             this.trace(`reuse ${wasm}`);
             return this.wasm;
         }
-        await this.compile({ input, code, obj, args, debug });
+        await this.compile({
+            input,
+            code,
+            obj,
+            language,
+            compileArgs,
+            cppVersion,
+            cVersion,
+            debug
+        });
         await this.link(obj, wasm, debug);
         this.lastBuildKey = buildKey;
         const wasmBytes = Uint8Array.from(this.memfs.getFileContents(wasm));
         return (this.wasm = await this.hostLogAsync(`Compiling ${wasm}`, WebAssembly.compile(wasmBytes)));
     }
     async compileLinkRun(code, options = {}) {
-        const { args = [], debug = false, breakpoints = [], pauseOnEntry = false, debugBuffer, interruptBuffer } = options;
+        const { language = 'CPP', args = [], compileArgs = args, programArgs = [], debug = false, breakpoints = [], pauseOnEntry = false, cppVersion, cVersion, debugBuffer, interruptBuffer } = options;
         this.debug = debug;
         return await this.run(await this.compileLink(code, {
-            args,
+            language,
+            compileArgs,
             debug,
             breakpoints,
             pauseOnEntry,
+            cppVersion,
+            cVersion,
             debugBuffer,
             interruptBuffer
-        }), true, `test.wasm`);
+        }), true, `test.wasm`, ...programArgs);
     }
 }

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export default Terminal;
 export { playground };
 export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions, TerminalControl } from './terminal';
 export type { CompilerDiagnostic } from './playground/options';
+export type { PlaygroundRuntimeAssets, RuntimeAssetConfig, RuntimeAssetLoadRequest, RuntimeAssetLoader, RuntimeAssetLoaderResult } from './playground/assets';
 export type { DebugLanguageAdapter } from './debug';

package/dist/playground/assetBridge.d.ts

@@ -0,0 +1,20 @@
+import { type ResolvedRuntimeAssetConfig, type RuntimeAssetRuntime } from './assets';
+type ProgressLike = {
+    set?: (value: number) => void;
+};
+export declare class WorkerAssetBridge {
+    private worker;
+    private readonly runtime;
+    private config;
+    private readonly progress;
+    constructor(worker: Worker, runtime: RuntimeAssetRuntime, config: ResolvedRuntimeAssetConfig, progress?: ProgressLike);
+    matches(config: ResolvedRuntimeAssetConfig): boolean;
+    rebind(worker: Worker, config: ResolvedRuntimeAssetConfig, progress?: ProgressLike): void;
+    resetProgress(progress?: ProgressLike): void;
+    handleMessage(event: MessageEvent<any>): boolean;
+    private respond;
+    private loadAsset;
+    private normalizeLoaderResult;
+    private fetchAsset;
+}
+export {};

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,32 @@
+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 PlaygroundRuntimeAssets {
+    rootUrl?: string;
+    python?: RuntimeAssetConfig;
+    java?: RuntimeAssetConfig;
+}
+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;