wasm-idle 0.7.0 → 0.7.2

package/dist/playground/clang.js

@@ -1,3 +1,5 @@
+import { WorkerAssetBridge } from './assetBridge';
+import { resolveRuntimeAssetConfig } from './assets';
 import { resolveSandboxExecutionArgs } from './options';
 import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
 const debugBreakpointBufferInts = 1028;
@@ -20,23 +22,48 @@ class Clang {
     waitingForInput = false;
     pendingEof = false;
     exit = true;
+    assetBridge = null;
     activeReject = null;
     constructor(language) {
         this.language = language;
     }
-    load(runtimeAssets = '', code = '', log = true, args = [], _options = {}, _progress) {
+    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 || '';
+            const assetConfig = resolveRuntimeAssetConfig('clang', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+            const needsWorkerReset = !this.worker || !this.assetBridge || !this.assetBridge.matches(assetConfig);
+            if (needsWorkerReset && this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+                this.assetBridge = null;
+            }
             if (!this.worker) {
                 this.worker = new (await import('./worker/clang?worker')).default();
-                this.worker.onmessage = () => resolve();
-                this.worker.postMessage({ load: true, path, log, code, args });
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', assetConfig, progress);
+                this.worker.onmessage = (event) => {
+                    if (this.assetBridge?.handleMessage(event))
+                        return;
+                    if (event.data?.progress != null)
+                        progress?.set?.(event.data.progress);
+                    if (event.data?.load)
+                        resolve();
+                };
+                this.worker.postMessage({
+                    load: true,
+                    log,
+                    code,
+                    args,
+                    assets: {
+                        baseUrl: assetConfig.baseUrl,
+                        useAssetBridge: assetConfig.useAssetBridge
+                    }
+                });
             }
             else {
+                this.assetBridge?.rebind(this.worker, assetConfig, progress);
                 this.worker.postMessage({ log });
                 resolve();
             }
@@ -74,6 +101,8 @@ class Clang {
             this.setBreakpoints(options.debug ? [...(options.breakpoints || [])] : []);
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
+                if (this.assetBridge?.handleMessage(event))
+                    return;
                 if (!this.worker)
                     return reject('Worker not loaded');
                 if (_uid !== this.uid)
@@ -180,6 +209,7 @@ class Clang {
         Atomics.notify(control, 0);
         this.worker?.terminate?.();
         delete this.worker;
+        this.assetBridge = null;
         this.exit = true;
     }
     async clear() {
@@ -198,6 +228,7 @@ class Clang {
         if (!this.exit) {
             this.worker?.terminate?.();
             delete this.worker;
+            this.assetBridge = null;
             this.exit = true;
         }
     }

package/dist/playground/ocaml.js

@@ -96,6 +96,7 @@ class Ocaml {
             if (!this.worker)
                 return reject('Worker not loaded');
             const target = options.ocamlBackend || 'wasm';
+            const wasmBinaryenMode = options.ocamlWasmBinaryenMode || 'fast';
             const _uid = ++this.uid;
             this.activeReject = reject;
             const handler = async (event) => {
@@ -308,6 +309,7 @@ class Ocaml {
                 code,
                 prepare,
                 target,
+                wasmBinaryenMode,
                 log: _log,
                 buffer: this.buffer
             });

package/dist/playground/options.d.ts

@@ -15,7 +15,9 @@ export interface CompilerDiagnostic {
 }
 export type RustTargetTriple = 'wasm32-wasip1' | 'wasm32-wasip2' | 'wasm32-wasip3';
 export type GoTarget = 'wasip1/wasm' | 'wasip2/wasm' | 'wasip3/wasm' | 'js/wasm';
+export type TinyGoTarget = 'wasm' | 'wasip1' | 'wasip2' | 'wasip3';
 export type OcamlBackend = 'js' | 'wasm';
+export type OcamlWasmBinaryenMode = 'fast' | 'full';
 export type DebugVariableKind = 'number' | 'bool' | 'array' | 'text';
 export type DebugArrayElementKind = 'int' | 'float' | 'double' | 'bool' | 'char';
 export interface DebugStructFieldMetadata {
@@ -62,7 +64,9 @@ export interface SandboxExecutionOptions {
     cVersion?: string;
     rustTargetTriple?: RustTargetTriple;
     goTarget?: GoTarget;
+    tinygoTarget?: TinyGoTarget;
     ocamlBackend?: OcamlBackend;
+    ocamlWasmBinaryenMode?: OcamlWasmBinaryenMode;
 }
 export interface ResolvedSandboxExecutionArgs {
     compileArgs: string[];

package/dist/playground/tinygo.d.ts

@@ -1,5 +1,5 @@
 import { type PlaygroundRuntimeAssets, type TinyGoRuntimeAssetLoader, type TinyGoRuntimeAssetPackReference } from './assets';
-import { type SandboxExecutionOptions } from './options';
+import { type SandboxExecutionOptions, type TinyGoTarget } from './options';
 import type { Sandbox } from './sandbox';
 type TinyGoRuntimeHooks = {
     boot(): Promise<void>;
@@ -15,6 +15,9 @@ type TinyGoRuntimeHooks = {
         entrypoint?: '_start' | '_initialize' | 'main' | null;
         reason?: 'bootstrap-artifact' | 'missing-wasi-entrypoint';
     } | null;
+    setBuildRequestOverrides?(overrides: {
+        target?: TinyGoTarget;
+    } | null): void;
     setWorkspaceFiles(files: Record<string, string> | null): void;
     dispose?(): void;
 };

package/dist/playground/tinygo.js

@@ -146,7 +146,8 @@ class TinyGo {
         }
         const moduleUrl = this.moduleUrl;
         this.runtimePromise = (async () => {
-            const runtimeModule = (await import(/* @vite-ignore */ moduleUrl));
+            const runtimeModule = (await import(
+            /* @vite-ignore */ moduleUrl));
             if (typeof runtimeModule.createBundledTinyGoRuntime === 'function') {
                 this.runtime = runtimeModule.createBundledTinyGoRuntime({
                     assetLoader: this.assetLoader,
@@ -212,7 +213,6 @@ class TinyGo {
                 });
                 return this.runtime;
             }
-            ;
             throw new Error('TinyGo runtime module must export createBundledTinyGoRuntime or createTinyGoRuntime');
         })().catch((error) => {
             this.disposeRuntime();
@@ -245,11 +245,13 @@ class TinyGo {
         }
         return 'TinyGo compilation failed';
     }
-    async compileArtifact(code, log = true, prog) {
+    async compileArtifact(code, target = 'wasm', log = true, prog) {
+        const hostCompileTarget = target === 'wasm' ? 'wasip1' : target;
         const compileCacheKey = JSON.stringify({
             code,
             hostCompileUrls: this.hostCompileUrls,
-            moduleUrl: this.moduleUrl
+            moduleUrl: this.moduleUrl,
+            target
         });
         if (this.compiledArtifact && this.compiledCacheKey === compileCacheKey) {
             return;
@@ -266,7 +268,8 @@ class TinyGo {
                             'content-type': 'application/json'
                         },
                         body: JSON.stringify({
-                            source: code
+                            source: code,
+                            target: hostCompileTarget
                         })
                     });
                 }
@@ -337,6 +340,7 @@ class TinyGo {
         runtime.reset();
         this.lastActivityLog = runtime.readActivityLog();
         runtime.setWorkspaceFiles({ 'main.go': code });
+        runtime.setBuildRequestOverrides?.({ target });
         this.runtimeProgress = prog;
         this.runtimeProgressAssets.clear();
         this.runtimeProgressStart = 0.05;
@@ -420,7 +424,8 @@ class TinyGo {
             try {
                 this.begin = Date.now();
                 await this.ensureWorker();
-                await this.compileArtifact(code, _log, prepare ? _prog : undefined);
+                const target = options.tinygoTarget || 'wasm';
+                await this.compileArtifact(code, target, _log, prepare ? _prog : undefined);
                 if (prepare) {
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;

package/dist/playground/wasmOcamlVersion.d.ts

@@ -1 +1 @@
-export declare const WASM_OCAML_ASSET_VERSION = "bd4c85620ead3426";
+export declare const WASM_OCAML_ASSET_VERSION = "5215e843db69fc28";

package/dist/playground/wasmOcamlVersion.js

@@ -1 +1 @@
-export const WASM_OCAML_ASSET_VERSION = "bd4c85620ead3426";
+export const WASM_OCAML_ASSET_VERSION = "5215e843db69fc28";

package/dist/playground/wasmTinyGoVersion.d.ts

@@ -1 +1 @@
-export declare const WASM_TINYGO_ASSET_VERSION = "c45e1d6b3e297250";
+export declare const WASM_TINYGO_ASSET_VERSION = "be561e38c81e2e23";

package/dist/playground/wasmTinyGoVersion.js

@@ -1 +1 @@
-export const WASM_TINYGO_ASSET_VERSION = "c45e1d6b3e297250";
+export const WASM_TINYGO_ASSET_VERSION = 'be561e38c81e2e23';

package/dist/playground/worker/clang.js

@@ -1,4 +1,5 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
 self.document = {
     querySelectorAll() {
         return [];
@@ -17,9 +18,13 @@ async function loadClang(path, log) {
     });
 }
 self.onmessage = async (event) => {
-    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, log, path, prepare, language, compileArgs, programArgs, cppVersion, cVersion, debug, breakpoints, pauseOnEntry } = event.data;
+    if (handleWorkerAssetMessage(event.data))
+        return;
+    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, log, path, assets, prepare, language, compileArgs, programArgs, cppVersion, cVersion, debug, breakpoints, pauseOnEntry } = event.data;
     if (load) {
-        await loadClang(path, log);
+        const runtimeAssets = assets;
+        configureWorkerRuntimeAssets(runtimeAssets || null);
+        await loadClang(runtimeAssets?.baseUrl || path || '', log);
         postMessage({ load: true });
     }
     else if (prepare) {

package/dist/playground/worker/elixir.js

@@ -1,5 +1,3 @@
-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() {
@@ -33,6 +31,130 @@ let bundleUrl = '';
 let loadedBundleUrl = '';
 let runtimePromise = null;
 let stdinBufferElixir = null;
+const elixirStdinCallNames = [
+    'IO.gets',
+    'IO.read',
+    'IO.binread',
+    'IO.getn',
+    ':io.get_line',
+    ':io.get_chars'
+];
+function resolveElixirRuntimeAssetUrl(assetName, bundleAssetUrl) {
+    const absoluteBundleUrl = new URL(bundleAssetUrl.startsWith('/') ? `http://localhost${bundleAssetUrl}` : bundleAssetUrl, globalThis.location?.href || 'http://localhost/');
+    return new URL(assetName, absoluteBundleUrl).toString();
+}
+async function resolveAtomVmInitializer(moduleAssetUrl) {
+    const injectedInitializer = globalThis.__wasmIdleAtomVmInit;
+    if (typeof injectedInitializer === 'function') {
+        return injectedInitializer;
+    }
+    const module = (await import(/* @vite-ignore */ moduleAssetUrl));
+    return module.default;
+}
+function skipQuotedLiteral(source, start) {
+    const heredoc = source.slice(start, start + 3);
+    if (heredoc === '"""' || heredoc === "'''") {
+        const end = source.indexOf(heredoc, start + 3);
+        return end === -1 ? source.length : end + 3;
+    }
+    const quote = source[start];
+    let index = start + 1;
+    while (index < source.length) {
+        if (source[index] === '\\') {
+            index += 2;
+            continue;
+        }
+        if (source[index] === quote) {
+            return index + 1;
+        }
+        index += 1;
+    }
+    return source.length;
+}
+function findClosingParen(source, openParenIndex) {
+    let depth = 1;
+    let index = openParenIndex + 1;
+    while (index < source.length) {
+        const current = source[index];
+        if (current === '"' || current === "'") {
+            index = skipQuotedLiteral(source, index);
+            continue;
+        }
+        if (current === '#') {
+            const newlineIndex = source.indexOf('\n', index);
+            if (newlineIndex === -1) {
+                return -1;
+            }
+            index = newlineIndex + 1;
+            continue;
+        }
+        if (current === '(') {
+            depth += 1;
+        }
+        else if (current === ')') {
+            depth -= 1;
+            if (depth === 0) {
+                return index;
+            }
+        }
+        index += 1;
+    }
+    return -1;
+}
+function splitTopLevelArgs(source) {
+    const parts = [];
+    let start = 0;
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let index = 0;
+    while (index < source.length) {
+        const current = source[index];
+        if (current === '"' || current === "'") {
+            index = skipQuotedLiteral(source, index);
+            continue;
+        }
+        if (current === '#') {
+            const newlineIndex = source.indexOf('\n', index);
+            if (newlineIndex === -1)
+                break;
+            index = newlineIndex + 1;
+            continue;
+        }
+        if (current === '(')
+            parenDepth += 1;
+        if (current === ')')
+            parenDepth -= 1;
+        if (current === '{')
+            braceDepth += 1;
+        if (current === '}')
+            braceDepth -= 1;
+        if (current === '[')
+            bracketDepth += 1;
+        if (current === ']')
+            bracketDepth -= 1;
+        if (current === ',' && parenDepth === 0 && braceDepth === 0 && bracketDepth === 0) {
+            parts.push(source.slice(start, index).trim());
+            start = index + 1;
+        }
+        index += 1;
+    }
+    const trailing = source.slice(start).trim();
+    if (trailing) {
+        parts.push(trailing);
+    }
+    return parts;
+}
+function parseLiteralCount(source) {
+    const normalized = source.trim().replaceAll('_', '');
+    if (/^\d+$/.test(normalized)) {
+        const parsed = Number.parseInt(normalized, 10);
+        if (Number.isSafeInteger(parsed)) {
+            return parsed;
+        }
+    }
+    return null;
+}
 function deserialize(module, message) {
     return JSON.parse(message, (_key, value) => {
         const isRef = typeof value === 'object' &&
@@ -146,7 +268,7 @@ function configureMessagingBridge(module) {
     };
     module.call = (process, args) => originalCall(process, module.serialize(args));
 }
-async function startVm(avmBundle, log) {
+async function startVm(avmBundle, bundleAssetUrl, log) {
     let resolveProcess = null;
     const processPromise = new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
@@ -159,6 +281,9 @@ async function startVm(avmBundle, log) {
             resolve(process);
         };
     });
+    const atomVmModuleUrl = resolveElixirRuntimeAssetUrl('AtomVM.mjs', bundleAssetUrl);
+    const atomVmWasmUrl = resolveElixirRuntimeAssetUrl('AtomVM.wasm', bundleAssetUrl);
+    const initAtomVm = await resolveAtomVmInitializer(atomVmModuleUrl);
     const module = (await initAtomVm({
         locateFile(path) {
             if (path === 'AtomVM.wasm') {
@@ -211,7 +336,7 @@ async function loadRuntime(nextBundleUrl, log) {
             }
             return response.arrayBuffer();
         });
-        return await startVm(new Int8Array(bundleBuffer), log);
+        return await startVm(new Int8Array(bundleBuffer), nextBundleUrl, log);
     })();
     return await runtimePromise;
 }
@@ -265,24 +390,173 @@ self.onmessage = async (event) => {
             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);
-            });
+        if (stdinBufferElixir && /(?:\bIO\.|\:io\.)/.test(code)) {
+            let bufferedInput = '';
+            let reachedEof = false;
+            const pullStdinChunk = () => {
+                if (reachedEof)
+                    return false;
+                const nextChunk = waitForBufferedStdin(stdinBufferElixir, () => postMessage({ buffer: true }));
+                if (nextChunk === null) {
+                    reachedEof = true;
+                    return false;
+                }
+                bufferedInput += nextChunk;
+                return true;
+            };
+            const readLineLiteral = (eofLiteral) => {
+                while (true) {
+                    const newlineIndex = bufferedInput.indexOf('\n');
+                    if (newlineIndex !== -1) {
+                        const line = bufferedInput.slice(0, newlineIndex + 1);
+                        bufferedInput = bufferedInput.slice(newlineIndex + 1);
+                        return JSON.stringify(line);
+                    }
+                    if (!pullStdinChunk()) {
+                        if (!bufferedInput) {
+                            return eofLiteral;
+                        }
+                        const remainder = bufferedInput;
+                        bufferedInput = '';
+                        return JSON.stringify(remainder);
+                    }
+                }
+            };
+            const readCountLiteral = (count, eofLiteral) => {
+                if (count === 0) {
+                    return JSON.stringify('');
+                }
+                while (bufferedInput.length < count && pullStdinChunk()) {
+                    // Keep requesting chunks until the requested count or EOF is available.
+                }
+                if (!bufferedInput) {
+                    return eofLiteral;
+                }
+                const consumed = bufferedInput.slice(0, Math.min(count, bufferedInput.length));
+                bufferedInput = bufferedInput.slice(consumed.length);
+                return JSON.stringify(consumed);
+            };
+            const readAllLiteral = (eofLiteral) => {
+                while (pullStdinChunk()) {
+                    // Drain stdin until EOF for :all reads.
+                }
+                if (!bufferedInput) {
+                    return eofLiteral;
+                }
+                const consumed = bufferedInput;
+                bufferedInput = '';
+                return JSON.stringify(consumed);
+            };
+            const wrapWithDeviceEvaluation = (deviceArg, valueExpr) => deviceArg
+                ? `((fn __wasm_idle_device__ -> _ = __wasm_idle_device__; ${valueExpr} end).(${deviceArg}))`
+                : valueExpr;
+            const wrapWithPromptOutput = (promptArg, valueExpr, deviceArg) => deviceArg
+                ? `((fn __wasm_idle_device__, __wasm_idle_prompt__ -> _ = __wasm_idle_device__; IO.write(__wasm_idle_prompt__); ${valueExpr} end).(${deviceArg}, ${promptArg}))`
+                : `((fn __wasm_idle_prompt__ -> IO.write(__wasm_idle_prompt__); ${valueExpr} end).(${promptArg}))`;
+            let rewritten = '';
+            let cursor = 0;
+            while (cursor < code.length) {
+                const current = code[cursor];
+                if (current === '"' || current === "'") {
+                    const nextCursor = skipQuotedLiteral(code, cursor);
+                    rewritten += code.slice(cursor, nextCursor);
+                    cursor = nextCursor;
+                    continue;
+                }
+                if (current === '#') {
+                    const newlineIndex = code.indexOf('\n', cursor);
+                    if (newlineIndex === -1) {
+                        rewritten += code.slice(cursor);
+                        break;
+                    }
+                    rewritten += code.slice(cursor, newlineIndex + 1);
+                    cursor = newlineIndex + 1;
+                    continue;
+                }
+                const callName = elixirStdinCallNames.find((candidate) => {
+                    if (!code.startsWith(candidate, cursor)) {
+                        return false;
+                    }
+                    const previous = code[cursor - 1] || '';
+                    return !/[A-Za-z0-9_:.?!]/.test(previous);
+                });
+                if (!callName) {
+                    rewritten += current;
+                    cursor += 1;
+                    continue;
+                }
+                let openParenIndex = cursor + callName.length;
+                while (/\s/.test(code[openParenIndex] || '')) {
+                    openParenIndex += 1;
+                }
+                if (code[openParenIndex] !== '(') {
+                    rewritten += current;
+                    cursor += 1;
+                    continue;
+                }
+                const closeParenIndex = findClosingParen(code, openParenIndex);
+                if (closeParenIndex === -1) {
+                    rewritten += code.slice(cursor);
+                    break;
+                }
+                const originalCall = code.slice(cursor, closeParenIndex + 1);
+                const args = splitTopLevelArgs(code.slice(openParenIndex + 1, closeParenIndex));
+                let replacement = originalCall;
+                if (callName === 'IO.gets' && (args.length === 1 || args.length === 2)) {
+                    replacement =
+                        args.length === 2
+                            ? wrapWithPromptOutput(args[1], readLineLiteral('nil'), args[0])
+                            : wrapWithPromptOutput(args[0], readLineLiteral('nil'));
+                }
+                else if ((callName === 'IO.read' || callName === 'IO.binread') &&
+                    (args.length === 1 || args.length === 2)) {
+                    const deviceArg = args.length === 2 ? args[0] : undefined;
+                    const modeArg = args[args.length - 1];
+                    if (modeArg === ':line') {
+                        replacement = wrapWithDeviceEvaluation(deviceArg, readLineLiteral(':eof'));
+                    }
+                    else if (modeArg === ':all') {
+                        replacement = wrapWithDeviceEvaluation(deviceArg, readAllLiteral(':eof'));
+                    }
+                    else {
+                        const count = parseLiteralCount(modeArg);
+                        if (count === null) {
+                            throw new Error(`${callName} stdin bridge requires a literal non-negative count`);
+                        }
+                        replacement = wrapWithDeviceEvaluation(deviceArg, readCountLiteral(count, ':eof'));
+                    }
+                }
+                else if (callName === 'IO.getn' && (args.length === 2 || args.length === 3)) {
+                    const count = parseLiteralCount(args[args.length - 1]);
+                    if (count === null) {
+                        throw new Error('IO.getn stdin bridge requires a literal non-negative count');
+                    }
+                    replacement =
+                        args.length === 3
+                            ? wrapWithPromptOutput(args[1], readCountLiteral(count, ':eof'), args[0])
+                            : wrapWithPromptOutput(args[0], readCountLiteral(count, ':eof'));
+                }
+                else if (callName === ':io.get_line' && (args.length === 1 || args.length === 2)) {
+                    replacement =
+                        args.length === 2
+                            ? wrapWithPromptOutput(args[1], readLineLiteral(':eof'), args[0])
+                            : wrapWithPromptOutput(args[0], readLineLiteral(':eof'));
+                }
+                else if (callName === ':io.get_chars' &&
+                    (args.length === 2 || args.length === 3)) {
+                    const count = parseLiteralCount(args[args.length - 1]);
+                    if (count === null) {
+                        throw new Error(':io.get_chars stdin bridge requires a literal non-negative count');
+                    }
+                    replacement =
+                        args.length === 3
+                            ? wrapWithPromptOutput(args[1], readCountLiteral(count, ':eof'), args[0])
+                            : wrapWithPromptOutput(args[0], readCountLiteral(count, ':eof'));
+                }
+                rewritten += replacement;
+                cursor = closeParenIndex + 1;
+            }
+            evalCode = rewritten;
         }
         const response = await runtime.module.call(runtime.process, ['eval_elixir', evalCode]);
         const rendered = runtime.module.deserialize(response);

package/dist/playground/worker/ocaml.js

@@ -363,7 +363,7 @@ async function executeCompileResult(result, log = false) {
     }
 }
 self.onmessage = async (event) => {
-    const { load, moduleUrl: nextModuleUrl, manifestUrl: nextManifestUrl, code, prepare, target = 'wasm', log = true, buffer } = event.data;
+    const { load, moduleUrl: nextModuleUrl, manifestUrl: nextManifestUrl, code, prepare, target = 'wasm', wasmBinaryenMode = 'fast', log = true, buffer } = event.data;
     try {
         if (load) {
             moduleUrl = nextModuleUrl;
@@ -374,7 +374,7 @@ self.onmessage = async (event) => {
         }
         stdinBufferOcaml = buffer ? new Int32Array(buffer) : null;
         if (log) {
-            console.log(`[wasm-idle:ocaml-worker] compile start prepare=${prepare} target=${target}`);
+            console.log(`[wasm-idle:ocaml-worker] compile start prepare=${prepare} target=${target} binaryen=${wasmBinaryenMode}`);
         }
         postMessage({ progress: { stage: 'compile-bootstrap', percent: 10 } });
         const [compilerModule, manifest] = await Promise.all([
@@ -382,7 +382,7 @@ self.onmessage = async (event) => {
             loadManifest(manifestUrl)
         ]);
         postMessage({ progress: { stage: 'compile-ready', percent: 25 } });
-        const compileKey = `${target}\n${code}`;
+        const compileKey = `${target}\n${wasmBinaryenMode}\n${code}`;
         let compiledFresh = false;
         if (!compiledResult || compiledCacheKey !== compileKey) {
             const result = await compilerModule.compile({
@@ -391,7 +391,8 @@ self.onmessage = async (event) => {
                 },
                 entry: 'main.ml',
                 target,
-                effectsMode: 'cps'
+                effectsMode: 'cps',
+                wasmBinaryenMode
             }, {
                 system: compilerModule.createBrowserWorkerSystemDispatcher({
                     manifest

package/dist/playground/worker/tinygo.js

@@ -99,17 +99,20 @@ self.onmessage = async (event) => {
                 exitCode = wasiRuntime.start(instance);
             }
             else if (typeof exportsObject.memory === 'object' &&
-                typeof exportsObject.main === 'function') {
+                (typeof exportsObject.main === 'function' ||
+                    typeof exportsObject._initialize === 'function')) {
                 wasiRuntime.initialize(instance);
                 if (typeof exportsObject._initialize !== 'function' &&
                     typeof exportsObject.__wasm_call_ctors === 'function') {
                     exportsObject.__wasm_call_ctors();
                 }
-                const mainResult = exportsObject.main();
-                exitCode = typeof mainResult === 'number' ? mainResult : 0;
+                if (typeof exportsObject.main === 'function') {
+                    const mainResult = exportsObject.main();
+                    exitCode = typeof mainResult === 'number' ? mainResult : 0;
+                }
             }
             else {
-                throw new Error('TinyGo worker expected a WASI artifact with _start or a reactor artifact with main');
+                throw new Error('TinyGo worker expected a WASI artifact with _start or a reactor artifact with _initialize or main');
             }
         }
         catch (error) {

package/dist/terminal/Terminal.svelte

@@ -107,6 +107,10 @@
 						hasPythonLoader: !!currentRuntimeAssets?.python?.loader,
 						javaBaseUrl: currentRuntimeAssets?.java?.baseUrl || '',
 						hasJavaLoader: !!currentRuntimeAssets?.java?.loader,
+						clangBaseUrl: currentRuntimeAssets?.clang?.baseUrl || '',
+						hasClangLoader: !!currentRuntimeAssets?.clang?.loader,
+						clangdBaseUrl: currentRuntimeAssets?.clangd?.baseUrl || '',
+						hasClangdLoader: !!currentRuntimeAssets?.clangd?.loader,
 						rustCompilerUrl: currentRuntimeAssets?.rust?.compilerUrl || '',
 						goCompilerUrl: currentRuntimeAssets?.go?.compilerUrl || '',
 						elixirBundleUrl: currentRuntimeAssets?.elixir?.bundleUrl || '',