wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/duckdb.js

@@ -0,0 +1,136 @@
+import { importRuntimeModule } from '../runtimeModule';
+const encoder = new TextEncoder();
+let dbPromise = null;
+let runtimeModuleUrl = '';
+async function loadDuckDB(moduleUrl, log) {
+    if (!moduleUrl)
+        throw new Error('DuckDB runtime module URL is not configured.');
+    if (runtimeModuleUrl !== moduleUrl) {
+        runtimeModuleUrl = moduleUrl;
+        dbPromise = null;
+    }
+    if (dbPromise)
+        return await dbPromise;
+    dbPromise = (async () => {
+        const { duckdb, bundles } = await importRuntimeModule(moduleUrl);
+        const bundle = await duckdb.selectBundle(bundles);
+        if (!bundle.mainWorker) {
+            throw new Error('DuckDB selected bundle does not include a browser worker');
+        }
+        const worker = new Worker(bundle.mainWorker);
+        const db = new duckdb.AsyncDuckDB(log ? new duckdb.ConsoleLogger() : new duckdb.VoidLogger(), worker);
+        await db.instantiate(bundle.mainModule, bundle.pthreadWorker);
+        return db;
+    })();
+    return await dbPromise;
+}
+function stringifyCell(value) {
+    if (value == null)
+        return 'NULL';
+    if (value instanceof Uint8Array) {
+        return `x'${Array.from(value, (byte) => byte.toString(16).padStart(2, '0')).join('')}'`;
+    }
+    if (typeof value === 'bigint')
+        return value.toString();
+    return String(value);
+}
+function formatTable(table) {
+    if (!table.numCols)
+        return '';
+    const columns = table.schema.fields.map((field) => field.name);
+    const lines = [columns.join('\t')];
+    for (let rowIndex = 0; rowIndex < table.numRows; rowIndex += 1) {
+        const row = table.get(rowIndex);
+        lines.push(columns.map((column) => stringifyCell(row?.[column])).join('\t'));
+    }
+    return `${lines.join('\n')}\n`;
+}
+function normalizeWorkspacePath(path) {
+    return path
+        .replace(/^\/+/, '')
+        .split('/')
+        .filter((part) => part && part !== '.' && part !== '..' && !part.includes('\0'))
+        .join('/');
+}
+function isSqlPath(path) {
+    const normalized = path.toLowerCase();
+    return normalized.endsWith('.sql') || normalized.endsWith('.duckdb');
+}
+async function registerWorkspaceFiles(db, activePath, code, workspaceFiles, stdin) {
+    const setupSql = [];
+    const files = workspaceFiles.length
+        ? workspaceFiles
+        : [{ path: activePath || 'main.duckdb', content: code }];
+    for (const file of files) {
+        if (!file || typeof file.path !== 'string' || typeof file.content !== 'string')
+            continue;
+        const normalizedPath = normalizeWorkspacePath(file.path);
+        if (!normalizedPath)
+            continue;
+        const content = normalizedPath === activePath ? code : file.content;
+        await db.registerFileText(normalizedPath, content);
+        if (isSqlPath(normalizedPath) && normalizedPath !== activePath) {
+            setupSql.push({ path: normalizedPath, content });
+        }
+    }
+    if (typeof stdin === 'string') {
+        await db.registerFileText('stdin.txt', stdin);
+        await db.registerFileBuffer('/dev/stdin', encoder.encode(stdin));
+    }
+    return setupSql.sort((left, right) => left.path.localeCompare(right.path));
+}
+self.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, code, prepare, activePath = 'main.duckdb', workspaceFiles = [], stdin, log } = event.data;
+    try {
+        if (load) {
+            if (log) {
+                console.log('[wasm-idle:duckdb-worker] load');
+            }
+            await loadDuckDB(nextModuleUrl || runtimeModuleUrl, Boolean(log));
+            postMessage({ load: true });
+            return;
+        }
+        const db = await loadDuckDB(runtimeModuleUrl, Boolean(log));
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        await db.reset();
+        const normalizedActivePath = normalizeWorkspacePath(activePath || 'main.duckdb');
+        const setupSql = await registerWorkspaceFiles(db, normalizedActivePath, code, workspaceFiles, stdin);
+        const connection = await db.connect();
+        try {
+            if (log) {
+                console.log(`[wasm-idle:duckdb-worker] exec start bytes=${code.length} activePath=${normalizedActivePath}`);
+            }
+            for (const setup of setupSql) {
+                await connection.query(setup.content);
+            }
+            postMessage({
+                progress: {
+                    kind: 'ready',
+                    state: 'running',
+                    reason: 'started',
+                    label: 'DuckDB query started'
+                }
+            });
+            const table = await connection.query(code);
+            const output = formatTable(table);
+            if (output)
+                postMessage({ output });
+            if (log) {
+                console.log('[wasm-idle:duckdb-worker] exec settled');
+            }
+        }
+        finally {
+            await connection.close().catch(() => { });
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:duckdb-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

package/dist/playground/worker/elixir.js

@@ -1,4 +1,7 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
+import { ELIXIR_RUNTIME_ASSET_NAMES, snapshotElixirRuntimeAssetReceipts } from '../elixirAssets';
+import { fetchRuntimeAssetBytes } from './runtimeAssetFetch';
+import { verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
 const workerDocument = {
     querySelectorAll() {
         return [];
@@ -13,6 +16,7 @@ const workerHost = {
 const popcornBrowserGlobal = ['globalThis', 'window'].join('.');
 const popcornParentGlobal = [popcornBrowserGlobal, 'parent'].join('.');
 const workerHostGlobal = 'globalThis.__wasmIdleElixirWorkerHost';
+const MAX_ELIXIR_ASSET_BYTES = 128 * 1024 * 1024;
 self.document = workerDocument;
 globalThis.__wasmIdleElixirWorkerHost = workerHost;
 class TrackedValue {
@@ -28,7 +32,9 @@ class TrackedValue {
 }
 globalThis.TrackedValue = TrackedValue;
 let bundleUrl = '';
-let loadedBundleUrl = '';
+let bundleReceipts = null;
+let bundleMaxAssetBytes = MAX_ELIXIR_ASSET_BYTES;
+let loadedRuntimeIdentity = '';
 let runtimePromise = null;
 let stdinBufferElixir = null;
 const elixirStdinCallNames = [
@@ -39,17 +45,39 @@ const elixirStdinCallNames = [
     ':io.get_line',
     ':io.get_chars'
 ];
+const erlangStdinCallNames = ['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();
+    const assetUrl = new URL(assetName, absoluteBundleUrl);
+    assetUrl.search = absoluteBundleUrl.search;
+    return assetUrl.toString();
 }
-async function resolveAtomVmInitializer(moduleAssetUrl) {
+function createAtomVmModuleBlob(moduleBytes) {
+    const copy = new Uint8Array(moduleBytes.byteLength);
+    copy.set(moduleBytes);
+    return new Blob([copy.buffer], { type: 'text/javascript' });
+}
+async function resolveAtomVmInitializer(moduleBytes) {
     const injectedInitializer = globalThis.__wasmIdleAtomVmInit;
     if (typeof injectedInitializer === 'function') {
         return injectedInitializer;
     }
-    const module = (await import(/* @vite-ignore */ moduleAssetUrl));
-    return module.default;
+    if (typeof URL.createObjectURL !== 'function' || typeof URL.revokeObjectURL !== 'function') {
+        throw new Error('Elixir runtime requires Blob URL support');
+    }
+    const moduleUrl = URL.createObjectURL(createAtomVmModuleBlob(moduleBytes));
+    try {
+        const module = (await import(/* @vite-ignore */ moduleUrl));
+        return module.default;
+    }
+    finally {
+        try {
+            URL.revokeObjectURL(moduleUrl);
+        }
+        catch {
+            // Blob URL cleanup must not replace the verified module import outcome.
+        }
+    }
 }
 function skipQuotedLiteral(source, start) {
     const heredoc = source.slice(start, start + 3);
@@ -268,7 +296,7 @@ function configureMessagingBridge(module) {
     };
     module.call = (process, args) => originalCall(process, module.serialize(args));
 }
-async function startVm(avmBundle, bundleAssetUrl, log) {
+async function startVm(assets, bundleAssetUrl, log) {
     let resolveProcess = null;
     const processPromise = new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
@@ -281,10 +309,11 @@ async function startVm(avmBundle, bundleAssetUrl, log) {
             resolve(process);
         };
     });
-    const atomVmModuleUrl = resolveElixirRuntimeAssetUrl('AtomVM.mjs', bundleAssetUrl);
     const atomVmWasmUrl = resolveElixirRuntimeAssetUrl('AtomVM.wasm', bundleAssetUrl);
-    const initAtomVm = await resolveAtomVmInitializer(atomVmModuleUrl);
+    const initAtomVm = await resolveAtomVmInitializer(assets['AtomVM.mjs']);
     const module = (await initAtomVm({
+        mainScriptUrlOrBlob: createAtomVmModuleBlob(assets['AtomVM.mjs']),
+        wasmBinary: assets['AtomVM.wasm'],
         locateFile(path) {
             if (path === 'AtomVM.wasm') {
                 return atomVmWasmUrl;
@@ -294,7 +323,7 @@ async function startVm(avmBundle, bundleAssetUrl, log) {
         preRun: [
             ({ FS }) => {
                 FS.mkdir('/data');
-                FS.writeFile('/data/bundle.avm', avmBundle);
+                FS.writeFile('/data/bundle.avm', new Int8Array(assets['bundle.avm']));
             }
         ],
         arguments: ['/data/bundle.avm'],
@@ -318,32 +347,93 @@ async function startVm(avmBundle, bundleAssetUrl, log) {
         process: await processPromise
     };
 }
-async function loadRuntime(nextBundleUrl, log) {
-    if (!nextBundleUrl) {
+async function loadRuntime(nextBundleUrl, nextAssetReceipts, nextMaxAssetBytes, log) {
+    if (typeof nextBundleUrl !== 'string' || !nextBundleUrl.trim()) {
         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;
+    let requestUrl;
+    try {
+        const locationOrigin = globalThis.location?.origin;
+        const locationHref = globalThis.location?.href;
+        const baseUrl = locationOrigin && locationOrigin !== 'null'
+            ? `${locationOrigin}/`
+            : locationHref?.startsWith('blob:')
+                ? locationHref.slice('blob:'.length)
+                : locationHref || 'http://localhost/';
+        requestUrl = new URL(nextBundleUrl.trim(), baseUrl);
     }
-    loadedBundleUrl = nextBundleUrl;
-    runtimePromise = (async () => {
-        if (log) {
-            console.log(`[wasm-idle:elixir-worker] load bundleUrl=${nextBundleUrl}`);
+    catch {
+        throw new Error(`Elixir bundle URL is invalid: ${nextBundleUrl}`);
+    }
+    if (requestUrl.protocol !== 'http:' && requestUrl.protocol !== 'https:') {
+        throw new Error(`Elixir bundle URL must use HTTP(S): ${nextBundleUrl}`);
+    }
+    if (requestUrl.username || requestUrl.password) {
+        throw new Error(`Elixir bundle URL must not include credentials: ${nextBundleUrl}`);
+    }
+    if (requestUrl.hash) {
+        throw new Error(`Elixir bundle URL must not include a fragment: ${nextBundleUrl}`);
+    }
+    const configuredMaxAssetBytes = nextMaxAssetBytes ?? MAX_ELIXIR_ASSET_BYTES;
+    if (!Number.isSafeInteger(configuredMaxAssetBytes) || configuredMaxAssetBytes <= 0) {
+        throw new TypeError('Elixir runtime maxAssetBytes must be a positive safe integer');
+    }
+    const effectiveMaxAssetBytes = Math.min(MAX_ELIXIR_ASSET_BYTES, configuredMaxAssetBytes);
+    const receipts = snapshotElixirRuntimeAssetReceipts(nextAssetReceipts);
+    for (const asset of ELIXIR_RUNTIME_ASSET_NAMES) {
+        const actual = Math.max(receipts[asset].bytes, receipts[asset].uncompressedBytes);
+        if (actual > effectiveMaxAssetBytes) {
+            throw new Error(`Elixir runtime asset ${asset} exceeds the ${effectiveMaxAssetBytes} byte limit`);
         }
-        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), nextBundleUrl, log);
+    }
+    const identity = JSON.stringify([requestUrl.href, receipts, configuredMaxAssetBytes]);
+    if (loadedRuntimeIdentity === identity && runtimePromise) {
+        return await runtimePromise;
+    }
+    if (log) {
+        console.log(`[wasm-idle:elixir-worker] load bundleUrl=${requestUrl.href}`);
+    }
+    const candidate = (async () => {
+        const loadedAssets = [];
+        for (const asset of ELIXIR_RUNTIME_ASSET_NAMES) {
+            const assetUrl = asset === 'bundle.avm'
+                ? requestUrl.href
+                : resolveElixirRuntimeAssetUrl(asset, requestUrl.href);
+            const receipt = receipts[asset];
+            const bytes = await fetchRuntimeAssetBytes({
+                url: assetUrl,
+                label: `Elixir runtime asset ${asset}`,
+                maxAssetBytes: Math.min(receipt.uncompressedBytes, effectiveMaxAssetBytes)
+            });
+            await verifyRuntimeAssetIntegrity({
+                asset,
+                bytes,
+                expected: receipt,
+                stage: 'uncompressed',
+                runtimeId: 'ELIXIR'
+            });
+            loadedAssets.push([asset, bytes]);
+        }
+        const assets = Object.freeze(Object.fromEntries(loadedAssets));
+        return await startVm(assets, requestUrl.href, log);
     })();
-    return await runtimePromise;
+    loadedRuntimeIdentity = identity;
+    runtimePromise = candidate;
+    try {
+        return await candidate;
+    }
+    catch (error) {
+        if (runtimePromise === candidate) {
+            runtimePromise = null;
+            loadedRuntimeIdentity = '';
+        }
+        throw error;
+    }
 }
 function normalizeCallError(module, error) {
     if (error === 'noproc') {
         runtimePromise = null;
-        loadedBundleUrl = '';
+        loadedRuntimeIdentity = '';
         return 'Elixir runtime process is unavailable';
     }
     if (typeof error === 'string') {
@@ -365,16 +455,30 @@ function normalizeCallError(module, error) {
         return String(error);
     }
 }
+function postExecutionReady(label) {
+    postMessage({
+        progress: { kind: 'ready', state: 'running', reason: 'started', label }
+    });
+}
 self.onmessage = async (event) => {
-    const { load, bundleUrl: nextBundleUrl, buffer, code, prepare, log = true } = event.data;
+    const { load, bundleUrl: nextBundleUrl, assetReceipts: nextAssetReceipts, maxAssetBytes: nextMaxAssetBytes, buffer, code, diagnose = false, prepare, stdin, language = 'ELIXIR', log = true } = event.data;
+    const evalLanguage = language === 'ERLANG' ? 'ERLANG' : 'ELIXIR';
     try {
         if (load) {
+            await loadRuntime(nextBundleUrl, nextAssetReceipts, nextMaxAssetBytes, log);
+            const configuredReceipts = snapshotElixirRuntimeAssetReceipts(nextAssetReceipts);
             bundleUrl = nextBundleUrl;
-            await loadRuntime(bundleUrl, log);
+            bundleReceipts = configuredReceipts;
+            bundleMaxAssetBytes = nextMaxAssetBytes ?? MAX_ELIXIR_ASSET_BYTES;
             postMessage({ load: true });
             return;
         }
-        if (!bundleUrl) {
+        if (nextBundleUrl) {
+            bundleUrl = nextBundleUrl;
+            bundleReceipts = snapshotElixirRuntimeAssetReceipts(nextAssetReceipts);
+            bundleMaxAssetBytes = nextMaxAssetBytes ?? MAX_ELIXIR_ASSET_BYTES;
+        }
+        if (!bundleUrl || !bundleReceipts) {
             throw new Error('Elixir runtime not loaded');
         }
         stdinBufferElixir = buffer ? new Int32Array(buffer) : null;
@@ -382,21 +486,22 @@ self.onmessage = async (event) => {
             postMessage({ results: true });
             return;
         }
-        const runtime = await loadRuntime(bundleUrl, log);
+        const runtime = await loadRuntime(bundleUrl, bundleReceipts, bundleMaxAssetBytes, log);
         if (!runtime.process) {
-            throw new Error('Elixir runtime did not expose a default process');
+            throw new Error('Popcorn runtime did not expose a default process');
         }
         if (log) {
-            console.log(`[wasm-idle:elixir-worker] eval bytes=${code.length}`);
+            console.log(`[wasm-idle:elixir-worker] ${evalLanguage.toLowerCase()} eval bytes=${code.length}`);
         }
         let evalCode = code;
-        if (stdinBufferElixir && /(?:\bIO\.|\:io\.)/.test(code)) {
-            let bufferedInput = '';
-            let reachedEof = false;
+        const currentStdinBuffer = stdinBufferElixir;
+        if (evalLanguage === 'ELIXIR' && currentStdinBuffer && /(?:\bIO\.|\:io\.)/.test(code)) {
+            let bufferedInput = typeof stdin === 'string' ? stdin : '';
+            let reachedEof = typeof stdin === 'string';
             const pullStdinChunk = () => {
                 if (reachedEof)
                     return false;
-                const nextChunk = waitForBufferedStdin(stdinBufferElixir, () => postMessage({ buffer: true }));
+                const nextChunk = waitForBufferedStdin(currentStdinBuffer, () => postMessage({ buffer: true }));
                 if (nextChunk === null) {
                     reachedEof = true;
                     return false;
@@ -448,11 +553,11 @@ self.onmessage = async (event) => {
                 return JSON.stringify(consumed);
             };
             const wrapWithDeviceEvaluation = (deviceArg, valueExpr) => deviceArg
-                ? `((fn __wasm_idle_device__ -> _ = __wasm_idle_device__; ${valueExpr} end).(${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}))`;
+                ? `((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) {
@@ -536,7 +641,8 @@ self.onmessage = async (event) => {
                             ? 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)) {
+                else if (callName === ':io.get_line' &&
+                    (args.length === 1 || args.length === 2)) {
                     replacement =
                         args.length === 2
                             ? wrapWithPromptOutput(args[1], readLineLiteral(':eof'), args[0])
@@ -558,7 +664,167 @@ self.onmessage = async (event) => {
             }
             evalCode = rewritten;
         }
-        const response = await runtime.module.call(runtime.process, ['eval_elixir', evalCode]);
+        if (evalLanguage === 'ERLANG' && currentStdinBuffer && /\bio:/.test(code)) {
+            let bufferedInput = typeof stdin === 'string' ? stdin : '';
+            let reachedEof = typeof stdin === 'string';
+            const pullStdinChunk = () => {
+                if (reachedEof)
+                    return false;
+                const nextChunk = waitForBufferedStdin(currentStdinBuffer, () => postMessage({ buffer: true }));
+                if (nextChunk === null) {
+                    reachedEof = true;
+                    return false;
+                }
+                bufferedInput += nextChunk;
+                return true;
+            };
+            const readLineLiteral = () => {
+                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 'eof';
+                        }
+                        const remainder = bufferedInput;
+                        bufferedInput = '';
+                        return JSON.stringify(remainder);
+                    }
+                }
+            };
+            const readCountLiteral = (count) => {
+                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 'eof';
+                }
+                const consumed = bufferedInput.slice(0, Math.min(count, bufferedInput.length));
+                bufferedInput = bufferedInput.slice(consumed.length);
+                return JSON.stringify(consumed);
+            };
+            const wrapWithPromptOutput = (promptArg, valueExpr, deviceArg) => deviceArg
+                ? `((fun(WasmIdleDevice, WasmIdlePrompt) -> _ = WasmIdleDevice, io:format("~s", [WasmIdlePrompt]), ${valueExpr} end)(${deviceArg}, ${promptArg}))`
+                : `((fun(WasmIdlePrompt) -> io:format("~s", [WasmIdlePrompt]), ${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 = erlangStdinCallNames.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:get_line' && (args.length === 1 || args.length === 2)) {
+                    replacement =
+                        args.length === 2
+                            ? wrapWithPromptOutput(args[1], readLineLiteral(), args[0])
+                            : wrapWithPromptOutput(args[0], readLineLiteral());
+                }
+                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), args[0])
+                            : wrapWithPromptOutput(args[0], readCountLiteral(count));
+                }
+                rewritten += replacement;
+                cursor = closeParenIndex + 1;
+            }
+            evalCode = rewritten;
+        }
+        let response;
+        if (evalLanguage === 'ERLANG') {
+            const moduleMatch = evalCode.match(/^\s*-module\(\s*([a-z][A-Za-z0-9_@]*|'(?:[^'\\]|\\.)+')\s*\)\s*\./m);
+            if (diagnose) {
+                if (moduleMatch) {
+                    await runtime.module.call(runtime.process, ['eval_erlang_module', evalCode]);
+                }
+                else {
+                    await runtime.module.call(runtime.process, [
+                        'eval_erlang',
+                        `{ok, WasmIdleTokens, _} = erl_scan:string(${JSON.stringify(code)}), erl_parse:parse_exprs(WasmIdleTokens).`
+                    ]);
+                }
+                postMessage({ results: true });
+                return;
+            }
+            if (moduleMatch) {
+                await runtime.module.call(runtime.process, ['eval_erlang_module', evalCode]);
+                postExecutionReady('Erlang program started');
+                response = await runtime.module.call(runtime.process, [
+                    'eval_erlang',
+                    `${moduleMatch[1]}:main().`
+                ]);
+            }
+            else {
+                postExecutionReady('Erlang expression started');
+                response = await runtime.module.call(runtime.process, ['eval_erlang', evalCode]);
+            }
+        }
+        else if (diagnose) {
+            await runtime.module.call(runtime.process, [
+                'eval_elixir',
+                `Code.string_to_quoted!(${JSON.stringify(code)})`
+            ]);
+            postMessage({ results: true });
+            return;
+        }
+        else {
+            postExecutionReady('Elixir program started');
+            response = await runtime.module.call(runtime.process, ['eval_elixir', evalCode]);
+        }
         const rendered = runtime.module.deserialize(response);
         if (typeof rendered === 'string') {
             postMessage({ results: rendered });

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

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