wasm-idle 0.6.0 → 0.7.0

package/dist/playground/go.js

@@ -0,0 +1,166 @@
+import { resolveGoCompilerUrl } from './assets';
+import { resolveSandboxExecutionArgs } from './options';
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+class Go {
+    output = null;
+    worker = null;
+    buffer = new SharedArrayBuffer(1024);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    compilerUrl = '';
+    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 = resolveGoCompilerUrl(runtimeAssets, currentUrl);
+            if (!nextCompilerUrl) {
+                return reject('Go runtime is not configured. Set PUBLIC_WASM_GO_COMPILER_URL or runtimeAssets.go.compilerUrl.');
+            }
+            const needsWorkerReset = !this.worker || this.compilerUrl !== nextCompilerUrl;
+            this.compilerUrl = nextCompilerUrl;
+            if (needsWorkerReset && this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+            }
+            if (!this.worker) {
+                this.worker = new (await import('./worker/go?worker')).default();
+                this.worker.onerror = (event) => {
+                    const location = event.filename && event.lineno
+                        ? ` (${event.filename}:${event.lineno}:${event.colno})`
+                        : '';
+                    reject(`Go worker script error: ${event.message || 'unknown error'}${location}`);
+                };
+                this.worker.onmessageerror = () => {
+                    reject('Go 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
+                });
+            }
+            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('GO', args, options);
+            const target = options.goTarget || 'wasip1/wasm';
+            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,
+                target,
+                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 Go;

package/dist/playground/index.js

@@ -1,9 +1,24 @@
 import Clang from './clang';
+import Elixir from './elixir';
+import Go from './go';
 import Java from './java';
+import Ocaml from './ocaml';
 import Python from './python';
 import Rust from './rust';
+import TinyGo from './tinygo';
 const sandboxCache = {};
-export const supportedLanguages = ['PYTHON3', 'PYPY3', 'C', 'CPP', 'JAVA', 'RUST'];
+export const supportedLanguages = [
+    'PYTHON3',
+    'PYPY3',
+    'C',
+    'CPP',
+    'JAVA',
+    'RUST',
+    'GO',
+    'ELIXIR',
+    'TINYGO',
+    'OCAML'
+];
 function bindRuntimeAssets(sandbox, runtimeAssets) {
     return new Proxy(sandbox, {
         get(target, prop, receiver) {
@@ -59,6 +74,18 @@ async function playground(language, runtimeAssets) {
         case 'RUST':
             sandbox = new Rust();
             break;
+        case 'GO':
+            sandbox = new Go();
+            break;
+        case 'ELIXIR':
+            sandbox = new Elixir();
+            break;
+        case 'TINYGO':
+            sandbox = new TinyGo();
+            break;
+        case 'OCAML':
+            sandbox = new Ocaml();
+            break;
         default:
             throw new Error(`Unsupported language: ${language}`);
     }
@@ -78,6 +105,14 @@ async function playground(language, runtimeAssets) {
             sandboxCache['JAVA'] = sandbox;
         if (language === 'RUST')
             sandboxCache['RUST'] = sandbox;
+        if (language === 'GO')
+            sandboxCache['GO'] = sandbox;
+        if (language === 'ELIXIR')
+            sandboxCache['ELIXIR'] = sandbox;
+        if (language === 'TINYGO')
+            sandboxCache['TINYGO'] = sandbox;
+        if (language === 'OCAML')
+            sandboxCache['OCAML'] = sandbox;
     }
     return runtimeAssets ? bindRuntimeAssets(sandbox, runtimeAssets) : sandbox;
 }

package/dist/playground/ocaml.d.ts

@@ -0,0 +1,32 @@
+import { type PlaygroundRuntimeAssets } from './assets';
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import type { Sandbox } from './sandbox';
+declare class Ocaml implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: SharedArrayBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    moduleUrl: string;
+    manifestUrl: string;
+    activeReject: ((reason: string) => void) | null;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    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;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>, _args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    kill(): void;
+    terminate(): void;
+    clear(): Promise<void>;
+}
+export default Ocaml;

package/dist/playground/ocaml.js

@@ -0,0 +1,341 @@
+import { resolveOcamlManifestUrl, resolveOcamlModuleUrl } from './assets';
+import {} from './options';
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+class Ocaml {
+    output = null;
+    worker = null;
+    buffer = new SharedArrayBuffer(1024);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    moduleUrl = '';
+    manifestUrl = '';
+    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;
+            resetBufferedStdin(this.buffer);
+            const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+            const nextModuleUrl = resolveOcamlModuleUrl(runtimeAssets, currentUrl);
+            const nextManifestUrl = resolveOcamlManifestUrl(runtimeAssets, currentUrl);
+            if (!nextModuleUrl || !nextManifestUrl) {
+                return reject('OCaml runtime is not configured. Set runtimeAssets.ocaml.moduleUrl and runtimeAssets.ocaml.manifestUrl or sync the bundled wasm-of-js-of-ocaml assets.');
+            }
+            const needsWorkerReset = !this.worker ||
+                this.moduleUrl !== nextModuleUrl ||
+                this.manifestUrl !== nextManifestUrl;
+            this.moduleUrl = nextModuleUrl;
+            this.manifestUrl = nextManifestUrl;
+            if (needsWorkerReset && this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+            }
+            if (!this.worker) {
+                this.worker = new (await import('./worker/ocaml?worker')).default();
+                this.worker.onerror = (event) => {
+                    const location = event.filename && event.lineno
+                        ? ` (${event.filename}:${event.lineno}:${event.colno})`
+                        : '';
+                    reject(`OCaml worker script error: ${event.message || 'unknown error'}${location}`);
+                };
+                this.worker.onmessageerror = () => {
+                    reject('OCaml 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,
+                    moduleUrl: this.moduleUrl,
+                    manifestUrl: this.manifestUrl
+                });
+            }
+            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 target = options.ocamlBackend || 'wasm';
+            const _uid = ++this.uid;
+            this.activeReject = reject;
+            const handler = async (event) => {
+                if (!this.worker)
+                    return reject('Worker not loaded');
+                if (_uid !== this.uid)
+                    return (this.worker.onmessage = null);
+                const { output, results, error, diagnostic, progress, runtime } = event.data;
+                if (progress && typeof progress.percent === 'number') {
+                    _prog?.set?.(Math.max(0, Math.min(progress.percent / 100, 1)));
+                }
+                if (event.data?.buffer) {
+                    this.waitingForInput = true;
+                    this.flushPendingInput();
+                }
+                if (output)
+                    this.output(output);
+                if (diagnostic)
+                    this.oncompilerdiagnostic?.(diagnostic);
+                if (runtime) {
+                    const createdObjectUrls = [];
+                    const originalConsole = window.console;
+                    const originalFetch = window.fetch.bind(window);
+                    const originalInstantiate = WebAssembly.instantiate.bind(WebAssembly);
+                    const originalInstantiateStreaming = WebAssembly.instantiateStreaming
+                        ? WebAssembly.instantiateStreaming.bind(WebAssembly)
+                        : undefined;
+                    const runtimePromiseKey = '__wasm_of_js_of_ocaml_runtime_promise';
+                    const assetResolverKey = '__wasm_of_js_of_ocaml_resolve_asset';
+                    const runtimeGlobal = window;
+                    const hadProcess = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'process');
+                    const hadRequire = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'require');
+                    const hadModule = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'module');
+                    const hadExports = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'exports');
+                    const originalProcess = runtimeGlobal.process;
+                    const originalRequire = runtimeGlobal.require;
+                    const originalModule = runtimeGlobal.module;
+                    const originalExports = runtimeGlobal.exports;
+                    originalConsole.log(`[wasm-idle:ocaml-runtime] start source=${String(runtime.sourcePath || '')} chars=${String(String(runtime.programSource || '').length)} assets=${String(Array.isArray(runtime.assetFiles) ? runtime.assetFiles.length : 0)}`);
+                    const sourceDir = String(runtime.sourcePath || '').replace(/\/[^/]+$/, '');
+                    const assetEntries = Array.isArray(runtime.assetFiles)
+                        ? runtime.assetFiles.map((assetFile) => {
+                            const copiedAssetData = new Uint8Array(assetFile.data.byteLength);
+                            copiedAssetData.set(assetFile.data);
+                            const objectUrl = URL.createObjectURL(new Blob([copiedAssetData], {
+                                type: assetFile.path.endsWith('.wasm')
+                                    ? 'application/wasm'
+                                    : 'application/octet-stream'
+                            }));
+                            createdObjectUrls.push(objectUrl);
+                            return {
+                                path: assetFile.path,
+                                basename: assetFile.path.split('/').at(-1) || assetFile.path,
+                                relativeFromSourceDir: assetFile.path.startsWith(`${sourceDir}/`)
+                                    ? assetFile.path.slice(sourceDir.length + 1)
+                                    : assetFile.path.replace(/^\/+/, ''),
+                                objectUrl
+                            };
+                        })
+                        : [];
+                    const emitOutput = (...args) => {
+                        const text = args.map((value) => String(value)).join(' ');
+                        this.output(text.endsWith('\n') ? text : `${text}\n`);
+                    };
+                    const resolveAssetUrl = (requestedAsset) => assetEntries
+                        .map((assetEntry) => {
+                        const candidates = [String(requestedAsset)];
+                        try {
+                            candidates.push(new URL(String(requestedAsset), window.location.href).pathname);
+                        }
+                        catch {
+                            // ignore URL parse errors
+                        }
+                        return candidates.some((candidate) => candidate === assetEntry.path ||
+                            candidate === assetEntry.relativeFromSourceDir ||
+                            candidate.endsWith(`/${assetEntry.relativeFromSourceDir}`) ||
+                            candidate.endsWith(`/${assetEntry.basename}`))
+                            ? assetEntry.objectUrl
+                            : null;
+                    })
+                        .find((candidate) => !!candidate) || null;
+                    window.console = {
+                        ...originalConsole,
+                        log: (...args) => {
+                            emitOutput(...args);
+                            originalConsole.log(...args);
+                        },
+                        info: (...args) => {
+                            emitOutput(...args);
+                            originalConsole.info(...args);
+                        },
+                        warn: (...args) => {
+                            emitOutput(...args);
+                            originalConsole.warn(...args);
+                        },
+                        error: (...args) => {
+                            emitOutput(...args);
+                            originalConsole.error(...args);
+                        }
+                    };
+                    window.fetch = (async (input, init) => {
+                        const requestUrl = typeof input === 'string'
+                            ? input
+                            : input instanceof URL
+                                ? input.toString()
+                                : input.url;
+                        const resolvedAssetUrl = resolveAssetUrl(requestUrl);
+                        if (resolvedAssetUrl) {
+                            return await originalFetch(resolvedAssetUrl, init);
+                        }
+                        return await originalFetch(input, init);
+                    });
+                    WebAssembly.instantiate = (async (source, importObject) => {
+                        return await originalInstantiate(source, importObject);
+                    });
+                    if (originalInstantiateStreaming) {
+                        WebAssembly.instantiateStreaming = (async (source, importObject) => {
+                            return await originalInstantiateStreaming(source, importObject);
+                        });
+                    }
+                    runtimeGlobal.process = undefined;
+                    runtimeGlobal.require = undefined;
+                    runtimeGlobal.module = undefined;
+                    runtimeGlobal.exports = undefined;
+                    runtimeGlobal[assetResolverKey] = resolveAssetUrl;
+                    try {
+                        const normalizedSource = String(runtime.programSource || '').includes('($=>async a=>{')
+                            ? String(runtime.programSource).replace('($=>async a=>{', `globalThis.${runtimePromiseKey}=($=>async a=>{`)
+                            : String(runtime.programSource || '');
+                        const sourceWithAssetResolver = normalizedSource.replace(/function ([A-Za-z$_][\w$]*)\(([A-Za-z$_][\w$]*)\)\{const ([A-Za-z$_][\w$]*)=([A-Za-z$_][\w$]*)\?new URL\(\2,\4\):\2;return fetch\(\3\)\}/, `function $1($2){if(globalThis.${assetResolverKey}){const resolvedAsset=globalThis.${assetResolverKey}($2);if(resolvedAsset)return fetch(resolvedAsset)}const $3=$4?new URL($2,$4):$2;return fetch($3)}`);
+                        new Function(`${sourceWithAssetResolver}\n//# sourceURL=${String(runtime.sourcePath || 'ocaml-runtime.js')}`)();
+                        originalConsole.log('[wasm-idle:ocaml-runtime] script invoked');
+                        const runtimePromise = runtimeGlobal[runtimePromiseKey];
+                        originalConsole.log(`[wasm-idle:ocaml-runtime] runtime promise=${String(runtimePromise instanceof Promise)}`);
+                        if (runtimePromise instanceof Promise) {
+                            await runtimePromise;
+                        }
+                        this.elapse = Date.now() - this.begin;
+                        this.exit = true;
+                        this.activeReject = null;
+                        resolve(true);
+                    }
+                    catch (runtimeError) {
+                        this.elapse = Date.now() - this.begin;
+                        this.exit = true;
+                        this.activeReject = null;
+                        reject(runtimeError?.message || String(runtimeError));
+                    }
+                    finally {
+                        window.console = originalConsole;
+                        window.fetch = originalFetch;
+                        WebAssembly.instantiate = originalInstantiate;
+                        if (originalInstantiateStreaming) {
+                            WebAssembly.instantiateStreaming = originalInstantiateStreaming;
+                        }
+                        delete runtimeGlobal[runtimePromiseKey];
+                        delete runtimeGlobal[assetResolverKey];
+                        if (!hadProcess) {
+                            delete runtimeGlobal.process;
+                        }
+                        else {
+                            runtimeGlobal.process = originalProcess;
+                        }
+                        if (!hadRequire) {
+                            delete runtimeGlobal.require;
+                        }
+                        else {
+                            runtimeGlobal.require = originalRequire;
+                        }
+                        if (!hadModule) {
+                            delete runtimeGlobal.module;
+                        }
+                        else {
+                            runtimeGlobal.module = originalModule;
+                        }
+                        if (!hadExports) {
+                            delete runtimeGlobal.exports;
+                        }
+                        else {
+                            runtimeGlobal.exports = originalExports;
+                        }
+                        for (const objectUrl of createdObjectUrls) {
+                            URL.revokeObjectURL(objectUrl);
+                        }
+                    }
+                    return;
+                }
+                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 = (event) => {
+                void handler(event);
+            };
+            this.begin = Date.now();
+            this.worker.postMessage({
+                code,
+                prepare,
+                target,
+                log: _log,
+                buffer: this.buffer
+            });
+        });
+    }
+    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 Ocaml;

package/dist/playground/options.d.ts

@@ -14,6 +14,8 @@ export interface CompilerDiagnostic {
     message: string;
 }
 export type RustTargetTriple = 'wasm32-wasip1' | 'wasm32-wasip2' | 'wasm32-wasip3';
+export type GoTarget = 'wasip1/wasm' | 'wasip2/wasm' | 'wasip3/wasm' | 'js/wasm';
+export type OcamlBackend = 'js' | 'wasm';
 export type DebugVariableKind = 'number' | 'bool' | 'array' | 'text';
 export type DebugArrayElementKind = 'int' | 'float' | 'double' | 'bool' | 'char';
 export interface DebugStructFieldMetadata {
@@ -59,6 +61,8 @@ export interface SandboxExecutionOptions {
     cppVersion?: string;
     cVersion?: string;
     rustTargetTriple?: RustTargetTriple;
+    goTarget?: GoTarget;
+    ocamlBackend?: OcamlBackend;
 }
 export interface ResolvedSandboxExecutionArgs {
     compileArgs: string[];