wasm-idle 0.7.0 → 0.7.1

package/dist/clangd/session.js

@@ -1,7 +1,7 @@
 import { CloseAction, ErrorAction, MonacoLanguageClient, MonacoServices } from '@hancomac/monaco-languageclient';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
 import { CLANGD_CPP_FILE_URI, CLANGD_WORKSPACE_URI, normalizeClangdBaseUrl } from './config';
 import ClangdWorker from './worker?worker';
+import { BrowserMessageReader, BrowserMessageWriter } from '../utils/vscodeJsonrpcBrowser';
 let servicesInstalled = false;
 export class ClangdSession {
     Monaco;

package/dist/clangd/worker.js

@@ -1,7 +1,7 @@
 /// <reference lib="WebWorker" />
 import { CLANGD_CPP_FILE_PATH, CLANGD_WORKSPACE_PATH, createClangdCompileFlags, normalizeClangdBaseUrl } from './config';
 import { JsonStream } from './jsonStream';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
+import { BrowserMessageReader, BrowserMessageWriter } from '../utils/vscodeJsonrpcBrowser';
 const textEncoder = new TextEncoder();
 const jsonStream = new JsonStream();
 let resolveStdinReady = () => { };

package/dist/lsp/cpp/server.js

@@ -1,6 +1,6 @@
 import { resolveCppLanguageServerBaseUrl } from '../runtime';
 import ClangdWorker from '../../clangd/worker?worker';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
+import { BrowserMessageReader, BrowserMessageWriter } from '../../utils/vscodeJsonrpcBrowser';
 const currentUrl = () => globalThis.location?.href || '';
 async function createServer(baseUrl) {
     let resolveReady = () => { };

package/dist/lsp/python/server.js

@@ -1,6 +1,6 @@
 import { resolvePythonLanguageServerBaseUrl } from '../runtime';
 import PythonLspWorker from './main.worker?worker';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
+import { BrowserMessageReader, BrowserMessageWriter } from '../../utils/vscodeJsonrpcBrowser';
 const currentUrl = () => globalThis.location?.href || '';
 async function createServer(pyodideBaseUrl) {
     let resolveReady = () => { };

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/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/utils/vscodeJsonrpcBrowser.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserMessageReader as BrowserMessageReaderInstance, BrowserMessageWriter as BrowserMessageWriterInstance } from 'vscode-jsonrpc/lib/browser/main';
+export declare const BrowserMessageReader: new (port: MessagePort | Worker | DedicatedWorkerGlobalScope) => BrowserMessageReaderInstance;
+export declare const BrowserMessageWriter: new (port: MessagePort | Worker | DedicatedWorkerGlobalScope) => BrowserMessageWriterInstance;
+export type BrowserMessageReader = BrowserMessageReaderInstance;
+export type BrowserMessageWriter = BrowserMessageWriterInstance;

package/dist/utils/vscodeJsonrpcBrowser.js

@@ -0,0 +1,4 @@
+import jsonrpc from 'vscode-jsonrpc';
+const browserJsonrpc = jsonrpc;
+export const BrowserMessageReader = browserJsonrpc.BrowserMessageReader;
+export const BrowserMessageWriter = browserJsonrpc.BrowserMessageWriter;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wasm-idle",
-	"version": "0.7.0",
+	"version": "0.7.1",
 	"description": "A simple web app to run code in the browser",
 	"license": "MIT",
 	"type": "module",