wasm-idle 0.6.0 → 0.7.0

package/dist/playground/worker/elixir.js

@@ -0,0 +1,317 @@
+import atomVmWasmUrl from '../../../../node_modules/@swmansion/popcorn/dist/AtomVM.wasm?url';
+import initAtomVm from '../../../../node_modules/@swmansion/popcorn/dist/AtomVM.mjs';
+import { waitForBufferedStdin } from '../stdinBuffer';
+const workerDocument = {
+    querySelectorAll() {
+        return [];
+    }
+};
+const workerHost = {
+    document: workerDocument,
+    postMessage(message) {
+        postMessage(message);
+    }
+};
+const popcornBrowserGlobal = ['globalThis', 'window'].join('.');
+const popcornParentGlobal = [popcornBrowserGlobal, 'parent'].join('.');
+const workerHostGlobal = 'globalThis.__wasmIdleElixirWorkerHost';
+self.document = workerDocument;
+globalThis.__wasmIdleElixirWorkerHost = workerHost;
+class TrackedValue {
+    key;
+    value;
+    constructor({ key, value }) {
+        if (typeof key !== 'number') {
+            throw new Error('key property in TrackedValue must be a number');
+        }
+        this.key = key;
+        this.value = value;
+    }
+}
+globalThis.TrackedValue = TrackedValue;
+let bundleUrl = '';
+let loadedBundleUrl = '';
+let runtimePromise = null;
+let stdinBufferElixir = null;
+function deserialize(module, message) {
+    return JSON.parse(message, (_key, value) => {
+        const isRef = typeof value === 'object' &&
+            value !== null &&
+            Object.hasOwn(value, 'popcorn_ref') &&
+            Object.getOwnPropertyNames(value).length === 1;
+        if (!isRef) {
+            return value;
+        }
+        return module.trackedObjectsMap.get(value.popcorn_ref);
+    });
+}
+function ensureFunctionEval(maybeFunction) {
+    if (typeof maybeFunction !== 'function') {
+        throw new Error('Script passed to onRunTrackedJs() is not wrapped in a function');
+    }
+}
+function ensureResultKeyList(result) {
+    if (!Array.isArray(result) && result !== undefined) {
+        throw new Error('Script passed to onRunTrackedJs() returned invalid value, accepted values are arrays and undefined');
+    }
+}
+function configureTrackedObjectBridge(module, resolveReadyProcess) {
+    let appReadyProcess;
+    let elixirReady = false;
+    module.serialize = JSON.stringify;
+    module.deserialize = (message) => deserialize(module, message);
+    module.cleanupFunctions = new Map();
+    module.sendEvent = (eventName, payload) => {
+        if (eventName === 'popcorn_app_ready') {
+            const readyPayload = typeof payload === 'object' && payload !== null && Object.hasOwn(payload, 'name')
+                ? payload.name
+                : payload;
+            appReadyProcess =
+                readyPayload === null || readyPayload === undefined ? null : String(readyPayload);
+            if (elixirReady) {
+                resolveReadyProcess(appReadyProcess);
+            }
+            return;
+        }
+        if (eventName === 'popcorn_elixir_ready') {
+            elixirReady = true;
+            if (appReadyProcess !== undefined) {
+                resolveReadyProcess(appReadyProcess);
+            }
+        }
+    };
+    module.onElixirReady = (process) => {
+        module.onElixirReady = null;
+        resolveReadyProcess(process);
+    };
+    module.onTrackedObjectDelete = (key) => {
+        const cleanup = module.cleanupFunctions.get(key);
+        module.cleanupFunctions.delete(key);
+        try {
+            cleanup?.();
+        }
+        catch (error) {
+            console.error(error);
+        }
+        finally {
+            module.trackedObjectsMap.delete(key);
+        }
+    };
+    module.onRunTrackedJs = (scriptString, isDebug) => {
+        const trackValue = (tracked) => {
+            if (tracked instanceof TrackedValue) {
+                module.trackedObjectsMap.set(tracked.key, tracked.value);
+                return tracked.key;
+            }
+            const key = module.nextTrackedObjectKey();
+            module.trackedObjectsMap.set(key, tracked);
+            return key;
+        };
+        let fn;
+        try {
+            const indirectEval = globalThis.eval;
+            const workerScript = scriptString
+                .replaceAll(`${popcornParentGlobal}.document`, `${workerHostGlobal}.document`)
+                .replaceAll(popcornParentGlobal, workerHostGlobal)
+                .replaceAll(popcornBrowserGlobal, workerHostGlobal);
+            fn = indirectEval(workerScript);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+        if (isDebug) {
+            ensureFunctionEval(fn);
+        }
+        let result;
+        try {
+            result = fn?.(module);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+        if (isDebug) {
+            ensureResultKeyList(result);
+        }
+        return result?.map(trackValue) ?? [];
+    };
+    module.onGetTrackedObjects = (keys) => keys.map((key) => module.serialize(module.trackedObjectsMap.get(key)));
+}
+function configureMessagingBridge(module) {
+    const originalCast = module.cast.bind(module);
+    const originalCall = module.call.bind(module);
+    module.cast = (process, args) => {
+        originalCast(process, module.serialize(args));
+    };
+    module.call = (process, args) => originalCall(process, module.serialize(args));
+}
+async function startVm(avmBundle, log) {
+    let resolveProcess = null;
+    const processPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            resolveProcess = null;
+            reject(new Error('Elixir runtime did not become ready'));
+        }, 30_000);
+        resolveProcess = (process) => {
+            clearTimeout(timeout);
+            resolveProcess = null;
+            resolve(process);
+        };
+    });
+    const module = (await initAtomVm({
+        locateFile(path) {
+            if (path === 'AtomVM.wasm') {
+                return atomVmWasmUrl;
+            }
+            return path;
+        },
+        preRun: [
+            ({ FS }) => {
+                FS.mkdir('/data');
+                FS.writeFile('/data/bundle.avm', avmBundle);
+            }
+        ],
+        arguments: ['/data/bundle.avm'],
+        print(text) {
+            postMessage({ output: text });
+        },
+        printErr(text) {
+            postMessage({ output: text });
+        },
+        onAbort() {
+            if (log) {
+                console.error('[wasm-idle:elixir-worker] AtomVM aborted');
+            }
+            setTimeout(() => postMessage({ error: 'Elixir runtime aborted' }), 100);
+        }
+    }));
+    configureTrackedObjectBridge(module, (process) => resolveProcess?.(process));
+    configureMessagingBridge(module);
+    return {
+        module,
+        process: await processPromise
+    };
+}
+async function loadRuntime(nextBundleUrl, log) {
+    if (!nextBundleUrl) {
+        throw new Error('Elixir runtime is not configured. Set PUBLIC_WASM_ELIXIR_BUNDLE_URL or runtimeAssets.elixir.bundleUrl.');
+    }
+    if (loadedBundleUrl === nextBundleUrl && runtimePromise) {
+        return await runtimePromise;
+    }
+    loadedBundleUrl = nextBundleUrl;
+    runtimePromise = (async () => {
+        if (log) {
+            console.log(`[wasm-idle:elixir-worker] load bundleUrl=${nextBundleUrl}`);
+        }
+        const bundleBuffer = await fetch(nextBundleUrl).then((response) => {
+            if (!response.ok) {
+                throw new Error(`Failed to fetch Elixir bundle: ${response.status} ${response.statusText}`);
+            }
+            return response.arrayBuffer();
+        });
+        return await startVm(new Int8Array(bundleBuffer), log);
+    })();
+    return await runtimePromise;
+}
+function normalizeCallError(module, error) {
+    if (error === 'noproc') {
+        runtimePromise = null;
+        loadedBundleUrl = '';
+        return 'Elixir runtime process is unavailable';
+    }
+    if (typeof error === 'string') {
+        try {
+            const value = module.deserialize(error);
+            return typeof value === 'string' ? value : JSON.stringify(value);
+        }
+        catch {
+            return error;
+        }
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+self.onmessage = async (event) => {
+    const { load, bundleUrl: nextBundleUrl, buffer, code, prepare, log = true } = event.data;
+    try {
+        if (load) {
+            bundleUrl = nextBundleUrl;
+            await loadRuntime(bundleUrl, log);
+            postMessage({ load: true });
+            return;
+        }
+        if (!bundleUrl) {
+            throw new Error('Elixir runtime not loaded');
+        }
+        stdinBufferElixir = buffer ? new Int32Array(buffer) : null;
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        const runtime = await loadRuntime(bundleUrl, log);
+        if (!runtime.process) {
+            throw new Error('Elixir runtime did not expose a default process');
+        }
+        if (log) {
+            console.log(`[wasm-idle:elixir-worker] eval bytes=${code.length}`);
+        }
+        let evalCode = code;
+        if (stdinBufferElixir && /\bIO\.(?:gets|read)\s*\(/.test(code)) {
+            const chunk = waitForBufferedStdin(stdinBufferElixir, () => postMessage({ buffer: true }));
+            const stdinLines = chunk == null ? [] : chunk.match(/[^\n]*\n|[^\n]+$/g) || [];
+            let stdinLineOffset = 0;
+            evalCode = code
+                .replace(/\bIO\.gets\s*\([^)]*\)/g, () => {
+                const line = stdinLines[stdinLineOffset++];
+                return line === undefined ? 'nil' : JSON.stringify(line);
+            })
+                .replace(/\bIO\.read\s*\(\s*(?::stdio\s*,\s*)?:line\s*\)/g, () => {
+                const line = stdinLines[stdinLineOffset++];
+                return line === undefined ? 'nil' : JSON.stringify(line);
+            })
+                .replace(/\bIO\.read\s*\(\s*(?::stdio\s*,\s*)?:all\s*\)/g, () => {
+                const remainingInput = stdinLines.slice(stdinLineOffset).join('');
+                stdinLineOffset = stdinLines.length;
+                return JSON.stringify(remainingInput);
+            });
+        }
+        const response = await runtime.module.call(runtime.process, ['eval_elixir', evalCode]);
+        const rendered = runtime.module.deserialize(response);
+        if (typeof rendered === 'string') {
+            postMessage({ results: rendered });
+            return;
+        }
+        if (rendered === undefined) {
+            postMessage({ results: true });
+            return;
+        }
+        postMessage({ results: JSON.stringify(rendered) });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:elixir-worker] failed', error);
+        }
+        if (runtimePromise) {
+            try {
+                const runtime = await runtimePromise;
+                postMessage({ error: normalizeCallError(runtime.module, error) });
+                return;
+            }
+            catch {
+                // Ignore secondary runtime load errors and surface the original failure instead.
+            }
+        }
+        postMessage({
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+};

package/dist/playground/worker/go.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/playground/worker/go.js

@@ -0,0 +1,163 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+self.document = {
+    querySelectorAll() {
+        return [];
+    }
+};
+let stdinBufferGo = null;
+let compilerUrl = '';
+let loadedCompilerUrl = '';
+let compilerPromise = null;
+let compiledArtifact = null;
+let compiledCacheKey = '';
+async function loadCompiler(url) {
+    if (!url) {
+        throw new Error('Go runtime is not configured. Set PUBLIC_WASM_GO_COMPILER_URL or runtimeAssets.go.compilerUrl.');
+    }
+    if (loadedCompilerUrl === url && compilerPromise) {
+        return await compilerPromise;
+    }
+    loadedCompilerUrl = url;
+    compiledArtifact = null;
+    compiledCacheKey = '';
+    compilerPromise = (async () => {
+        const module = await import(/* @vite-ignore */ url);
+        const factory = typeof module.createGoCompiler === 'function'
+            ? module.createGoCompiler
+            : typeof module.default === 'function'
+                ? module.default
+                : null;
+        if (!factory) {
+            throw new Error('wasm-go module must export createGoCompiler or a default factory');
+        }
+        if (typeof module.executeBrowserGoArtifact !== 'function') {
+            throw new Error('wasm-go module must export executeBrowserGoArtifact');
+        }
+        return {
+            compiler: await factory(),
+            executeBrowserGoArtifact: module.executeBrowserGoArtifact
+        };
+    })();
+    return await compilerPromise;
+}
+function normalizeDiagnostic(diagnostic) {
+    return {
+        fileName: diagnostic?.fileName ?? null,
+        lineNumber: Math.max(1, Number(diagnostic?.lineNumber || 1)),
+        columnNumber: typeof diagnostic?.columnNumber === 'number'
+            ? Math.max(1, diagnostic.columnNumber)
+            : undefined,
+        severity: diagnostic?.severity === 'warning' || diagnostic?.severity === 'other'
+            ? diagnostic.severity
+            : 'error',
+        message: String(diagnostic?.message || '')
+    };
+}
+self.onmessage = async (event) => {
+    const { load, compilerUrl: nextCompilerUrl, buffer, code, prepare, args = [], target = 'wasip1/wasm', log } = event.data;
+    try {
+        if (load) {
+            compilerUrl = nextCompilerUrl;
+            if (log) {
+                console.log(`[wasm-idle:go-worker] load compilerUrl=${compilerUrl}`);
+            }
+            await loadCompiler(compilerUrl);
+            postMessage({ load: true });
+            return;
+        }
+        stdinBufferGo = new Int32Array(buffer);
+        const runtime = await loadCompiler(compilerUrl);
+        const compileCacheKey = `${target}\n${code}`;
+        if (!compiledArtifact || compiledCacheKey !== compileCacheKey) {
+            if (log) {
+                console.log(`[wasm-idle:go-worker] compile start prepare=${String(prepare)} target=${target} bytes=${code.length}`);
+            }
+            const result = await runtime.compiler.compile({
+                code,
+                target,
+                prepare,
+                log,
+                onProgress(progress) {
+                    postMessage({ progress });
+                }
+            });
+            if (log) {
+                console.log(`[wasm-idle:go-worker] compile settled success=${String(result.success)} hasWasm=${String(Boolean(result.artifact?.wasm))} stdout=${String(Boolean(result.stdout))} stderr=${String(Boolean(result.stderr))}`);
+            }
+            for (const diagnostic of result.diagnostics || []) {
+                postMessage({ diagnostic: normalizeDiagnostic(diagnostic) });
+            }
+            if (result.stdout)
+                postMessage({ output: result.stdout });
+            if (!result.success) {
+                throw new Error(result.stderr ||
+                    result.diagnostics?.map((diagnostic) => diagnostic.message).join('\n') ||
+                    'Go compilation failed');
+            }
+            if (result.stderr)
+                postMessage({ output: result.stderr });
+            if (!result.artifact?.wasm) {
+                throw new Error('wasm-go did not return a wasm artifact');
+            }
+            compiledArtifact = result.artifact;
+            compiledCacheKey = compileCacheKey;
+            if (log) {
+                console.log(`[wasm-idle:go-worker] cached artifact target=${compiledArtifact.target} format=${compiledArtifact.format}`);
+            }
+        }
+        if (prepare) {
+            if (log) {
+                console.log('[wasm-idle:go-worker] prepare complete');
+            }
+            postMessage({ results: true });
+            return;
+        }
+        if (log) {
+            console.log(`[wasm-idle:go-worker] runtime start target=${compiledArtifact.target} format=${compiledArtifact.format}`);
+        }
+        const execution = await runtime.executeBrowserGoArtifact(compiledArtifact, {
+            args,
+            env: {
+                USER: 'jungol'
+            },
+            stdin: () => {
+                const chunk = waitForBufferedStdin(stdinBufferGo, () => postMessage({ buffer: true }));
+                if (chunk == null) {
+                    if (log) {
+                        console.log('[wasm-idle:go-stdin] fd_read(bytes=0, eof=true)');
+                    }
+                    return null;
+                }
+                if (log) {
+                    console.log(`[wasm-idle:go-stdin] fd_fill(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                }
+                return chunk;
+            },
+            stdout: (output) => {
+                if (output) {
+                    postMessage({ output });
+                }
+            },
+            stderr: (output) => {
+                if (output) {
+                    postMessage({ output });
+                }
+            }
+        });
+        if (log) {
+            console.log(`[wasm-idle:go-worker] wasi run complete exitCode=${String(execution.exitCode)}`);
+        }
+        if (execution.exitCode !== 0) {
+            throw new Error(execution.stderr
+                ? `Go program exited with code ${execution.exitCode}\n${execution.stderr}`
+                : `Go program exited with code ${execution.exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:go-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

package/dist/playground/worker/ocaml.d.ts

@@ -0,0 +1 @@
+export {};