wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/r.js

@@ -0,0 +1,192 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+const encoder = new TextEncoder();
+let stdinBufferR = null;
+let baseUrl = '';
+let loadedBaseUrl = '';
+let webRPromise = null;
+function postProgress(percent) {
+    postMessage({ progress: { percent: Math.max(0, Math.min(100, percent)) } });
+}
+function rString(value) {
+    return JSON.stringify(value);
+}
+function normalizeWorkspacePath(path) {
+    const parts = [];
+    for (const part of path.replace(/^\/+/, '').split('/')) {
+        if (!part || part === '.')
+            continue;
+        if (part === '..') {
+            parts.pop();
+            continue;
+        }
+        if (part.includes('\0'))
+            continue;
+        parts.push(part);
+    }
+    return parts.join('/');
+}
+function dirname(path) {
+    const slashIndex = path.lastIndexOf('/');
+    return slashIndex === -1 ? '' : path.slice(0, slashIndex);
+}
+async function mkdirp(webR, path) {
+    const normalized = normalizeWorkspacePath(path);
+    if (!normalized)
+        return;
+    let current = '';
+    for (const part of normalized.split('/')) {
+        current += `/${part}`;
+        const info = await webR.FS.analyzePath(current).catch(() => null);
+        if (!info?.exists)
+            await webR.FS.mkdir(current);
+    }
+}
+async function writeWorkspaceFile(webR, path, content) {
+    const normalized = normalizeWorkspacePath(path);
+    if (!normalized)
+        return;
+    const fullPath = `/workspace/${normalized}`;
+    await mkdirp(webR, dirname(`workspace/${normalized}`));
+    await webR.FS.writeFile(fullPath, encoder.encode(content));
+}
+async function loadWebR(url, log = true) {
+    if (!url) {
+        throw new Error('R runtime is not configured. Set PUBLIC_WASM_R_BASE_URL or runtimeAssets.r.baseUrl.');
+    }
+    if (loadedBaseUrl === url && webRPromise) {
+        return await webRPromise;
+    }
+    loadedBaseUrl = url;
+    webRPromise?.then((runtime) => runtime.close()).catch(() => { });
+    webRPromise = (async () => {
+        postProgress(5);
+        const moduleUrl = `${url.endsWith('/') ? url : `${url}/`}webr.js`;
+        const { ChannelType, WebR: WebRConstructor } = (await import(
+        /* @vite-ignore */ moduleUrl));
+        const webR = new WebRConstructor({
+            baseUrl: url,
+            serviceWorkerUrl: url,
+            channelType: ChannelType.PostMessage,
+            interactive: false,
+            REnv: {
+                R_HOME: '/usr/lib/R',
+                R_ENABLE_JIT: '0'
+            }
+        });
+        await webR.init();
+        postProgress(90);
+        await mkdirp(webR, 'workspace');
+        await webR.evalRVoid('options(device = webr::canvas)');
+        if (log) {
+            console.log(`[wasm-idle:r-worker] webR ready baseUrl=${url}`);
+        }
+        postProgress(100);
+        return webR;
+    })();
+    return await webRPromise;
+}
+function codeMightReadStdin(code) {
+    return /\b(stdin|readLines|readline|scan)\s*\(/.test(code);
+}
+function readInitialStdin(code, initialStdin, log = true) {
+    if (typeof initialStdin === 'string')
+        return initialStdin;
+    if (!codeMightReadStdin(code))
+        return '';
+    const chunk = waitForBufferedStdin(stdinBufferR, () => postMessage({ buffer: true }));
+    if (log) {
+        console.log(chunk == null
+            ? '[wasm-idle:r-stdin] read(bytes=0, eof=true)'
+            : `[wasm-idle:r-stdin] read(bytes=${encoder.encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+    }
+    return chunk || '';
+}
+function buildRunnerSource(activePath, args) {
+    const argsSource = args.map(rString).join(', ');
+    return `
+.wasm_idle_stdin_path <- "/workspace/.stdin"
+stdin <- function() file(.wasm_idle_stdin_path, open = "r")
+.wasm_idle_args <- c(${argsSource})
+commandArgs <- function(trailingOnly = FALSE) {
+  if (trailingOnly) .wasm_idle_args else c("R", .wasm_idle_args)
+}
+source(${rString(`/workspace/${normalizeWorkspacePath(activePath)}`)}, local = TRUE, echo = FALSE, print.eval = FALSE)
+`;
+}
+function emitCapturedOutput(output) {
+    for (const entry of output) {
+        if (entry.type === 'stdout' || entry.type === 'stderr') {
+            if (entry.data)
+                postMessage({ output: String(entry.data) });
+            continue;
+        }
+        const message = typeof entry.data === 'string'
+            ? entry.data
+            : typeof entry.data?.message === 'string'
+                ? entry.data.message
+                : '';
+        if (message)
+            postMessage({ output: `${message}\n` });
+    }
+}
+self.onmessage = async (event) => {
+    const { load, baseUrl: nextBaseUrl, buffer, code, prepare, args = [], stdin, activePath = 'main.R', workspaceFiles = [], log } = event.data;
+    try {
+        if (load) {
+            baseUrl = nextBaseUrl || '';
+            if (log) {
+                console.log(`[wasm-idle:r-worker] load baseUrl=${baseUrl}`);
+            }
+            await loadWebR(baseUrl, log);
+            postMessage({ load: true });
+            return;
+        }
+        stdinBufferR = new Int32Array(buffer);
+        const webR = await loadWebR(baseUrl, log);
+        if (prepare) {
+            await webR.evalRVoid(`parse(text = ${rString(code)})`, {
+                captureStreams: true,
+                captureConditions: true,
+                captureGraphics: false
+            });
+            postMessage({ results: true });
+            return;
+        }
+        await mkdirp(webR, 'workspace');
+        for (const file of workspaceFiles) {
+            await writeWorkspaceFile(webR, file.path, file.content);
+        }
+        await writeWorkspaceFile(webR, activePath, code);
+        await webR.FS.writeFile('/workspace/.stdin', encoder.encode(readInitialStdin(code, stdin, log)));
+        if (log) {
+            console.log(`[wasm-idle:r-worker] eval start bytes=${code.length} activePath=${activePath}`);
+        }
+        postMessage({
+            progress: {
+                kind: 'ready',
+                state: 'running',
+                reason: 'started',
+                label: 'R program started'
+            }
+        });
+        const captured = await webR.globalShelter.captureR(buildRunnerSource(activePath, args), {
+            captureStreams: true,
+            captureConditions: true,
+            captureGraphics: false,
+            withAutoprint: false,
+            throwJsException: true
+        });
+        emitCapturedOutput(captured.output || []);
+        await webR.globalShelter.purge();
+        if (log) {
+            console.log(`[wasm-idle:r-worker] eval settled output=${captured.output?.length || 0}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:r-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

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

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

package/dist/playground/worker/ruby.js

@@ -0,0 +1,248 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { importRuntimeModule } from '../runtimeModule';
+import { RUBY_RUNTIME_VERIFIED_WASM_URL, rewriteVerifiedRubyRuntimeModule, verifyRubyRuntimePreflightPayload } from '@wasm-idle/core';
+const encoder = new TextEncoder();
+let stdinBufferRuby = null;
+let runtimeState = 'uninitialized';
+let loadedRuntime = null;
+async function loadRubyModule(runtimePreflight, maxAssetBytes) {
+    if (runtimeState !== 'uninitialized') {
+        throw new Error('Ruby runtime is already loaded.');
+    }
+    runtimeState = 'loading';
+    try {
+        const payload = await verifyRubyRuntimePreflightPayload(runtimePreflight, {
+            maxAssetBytes
+        });
+        const buffers = [payload.manifestBytes, payload.moduleJavaScriptBytes, payload.wasmBytes];
+        if (buffers.some((bytes) => !ArrayBuffer.isView(bytes) ||
+            Object.prototype.toString.call(bytes) !== '[object Uint8Array]' ||
+            !(bytes.buffer instanceof ArrayBuffer) ||
+            bytes.byteOffset !== 0 ||
+            bytes.byteLength !== bytes.buffer.byteLength) ||
+            new Set(buffers.map((bytes) => bytes.buffer)).size !== buffers.length) {
+            throw new TypeError('Ruby execution worker requires unique owned runtime preflight bytes');
+        }
+        const wasmBytes = payload.wasmBytes;
+        const moduleSource = rewriteVerifiedRubyRuntimeModule(payload);
+        if (typeof Blob !== 'function' ||
+            typeof URL.createObjectURL !== 'function' ||
+            typeof URL.revokeObjectURL !== 'function') {
+            throw new Error('Ruby runtime requires Blob module URL support.');
+        }
+        const verifiedModuleUrl = URL.createObjectURL(new Blob([moduleSource], { type: 'text/javascript' }));
+        let runtime;
+        let module;
+        try {
+            [runtime, module] = await Promise.all([
+                importRuntimeModule(verifiedModuleUrl),
+                WebAssembly.compile(wasmBytes)
+            ]);
+        }
+        finally {
+            try {
+                URL.revokeObjectURL(verifiedModuleUrl);
+            }
+            catch {
+                // Blob URL cleanup must not replace import or compilation outcomes.
+            }
+        }
+        if (!runtime.RubyVM ||
+            !runtime.consolePrinter ||
+            !runtime.wasiShim ||
+            runtime.rubyStdlibWasmUrl !== RUBY_RUNTIME_VERIFIED_WASM_URL) {
+            throw new Error('Ruby runtime module is missing required verified Ruby or WASI exports.');
+        }
+        loadedRuntime = { module, runtime };
+        runtimeState = 'ready';
+        return loadedRuntime;
+    }
+    catch (error) {
+        loadedRuntime = null;
+        runtimeState = 'uninitialized';
+        throw error;
+    }
+}
+function createRubyStdin(runtime, initialStdin, requestInput) {
+    const { Fd, Inode, wasi } = runtime.wasiShim;
+    return new (class extends Fd {
+        ino = Inode.issue_ino();
+        currentStdin = initialStdin;
+        pendingBytes = null;
+        fixedInitialStdin = initialStdin != null;
+        fd_fdstat_get() {
+            const fdstat = new wasi.Fdstat(wasi.FILETYPE_CHARACTER_DEVICE, 0);
+            fdstat.fs_rights_base = BigInt(wasi.RIGHTS_FD_READ);
+            return { ret: wasi.ERRNO_SUCCESS, fdstat };
+        }
+        fd_filestat_get() {
+            return {
+                ret: wasi.ERRNO_SUCCESS,
+                filestat: new wasi.Filestat(this.ino, wasi.FILETYPE_CHARACTER_DEVICE, 0n)
+            };
+        }
+        fd_read(size) {
+            let bytes = this.pendingBytes;
+            if (!bytes?.length) {
+                const chunk = this.readChunk();
+                if (chunk == null)
+                    return { ret: wasi.ERRNO_SUCCESS, data: new Uint8Array() };
+                bytes = encoder.encode(chunk);
+            }
+            if (bytes.length <= size) {
+                this.pendingBytes = null;
+                return { ret: wasi.ERRNO_SUCCESS, data: bytes };
+            }
+            const head = bytes.slice(0, size);
+            this.pendingBytes = bytes.slice(size);
+            return { ret: wasi.ERRNO_SUCCESS, data: head };
+        }
+        readChunk() {
+            if (this.currentStdin != null) {
+                const chunk = this.currentStdin;
+                this.currentStdin = null;
+                return chunk;
+            }
+            if (this.fixedInitialStdin)
+                return null;
+            return requestInput();
+        }
+    })();
+}
+function insertWorkspaceFile(tree, path, content) {
+    const [head, ...rest] = path.split('/').filter(Boolean);
+    if (!head)
+        return;
+    if (!rest.length) {
+        tree.set(head, content);
+        return;
+    }
+    const existing = tree.get(head);
+    const child = existing instanceof Map ? existing : new Map();
+    tree.set(head, child);
+    insertWorkspaceFile(child, rest.join('/'), content);
+}
+function materializeWorkspaceTree(runtime, tree) {
+    const { Directory, File } = runtime.wasiShim;
+    const contents = new Map();
+    for (const [name, entry] of tree) {
+        contents.set(name, entry instanceof Map
+            ? new Directory(materializeWorkspaceTree(runtime, entry))
+            : new File(encoder.encode(entry), { readonly: true }));
+    }
+    return contents;
+}
+function workspaceContents(runtime, workspaceFiles) {
+    const tree = new Map();
+    for (const file of workspaceFiles) {
+        const normalizedPath = file.path.replace(/^\/+/, '');
+        if (!normalizedPath || normalizedPath.includes('\0'))
+            continue;
+        insertWorkspaceFile(tree, normalizedPath, file.content);
+    }
+    return materializeWorkspaceTree(runtime, tree);
+}
+self.onmessage = async (event) => {
+    const message = event.data;
+    const { load, runtimePreflight, maxAssetBytes, buffer, code, prepare, args = [], stdin, activePath = 'main.rb', workspaceFiles = [], log } = message;
+    try {
+        if (Object.prototype.hasOwnProperty.call(message, 'load')) {
+            const actualKeys = Object.keys(message).sort();
+            const expectedKeys = ['load', 'maxAssetBytes', 'runtimePreflight'];
+            if (load !== true ||
+                actualKeys.length !== expectedKeys.length ||
+                actualKeys.some((key, index) => key !== expectedKeys[index]) ||
+                !Number.isSafeInteger(maxAssetBytes) ||
+                maxAssetBytes <= 0) {
+                throw new Error('Ruby runtime load message has an invalid shape.');
+            }
+            postMessage({ progress: { percent: 5, stage: 'Loading Ruby runtime' } });
+            await loadRubyModule(runtimePreflight, maxAssetBytes);
+            postMessage({ progress: { percent: 100, stage: 'Ruby runtime ready' } });
+            postMessage({ load: true });
+            return;
+        }
+        stdinBufferRuby = new Int32Array(buffer);
+        if (runtimeState !== 'ready' || !loadedRuntime) {
+            throw new Error('Ruby runtime is not ready.');
+        }
+        runtimeState = 'running';
+        const { module: rubyModule, runtime } = loadedRuntime;
+        if (prepare) {
+            postMessage({ results: true });
+            runtimeState = 'ready';
+            return;
+        }
+        let stdout = '';
+        let stderr = '';
+        const printer = runtime.consolePrinter({
+            stdout(output) {
+                stdout += output;
+                if (output)
+                    postMessage({ output });
+            },
+            stderr(output) {
+                stderr += output;
+                if (output)
+                    postMessage({ output });
+            }
+        });
+        const hasInitialStdin = typeof stdin === 'string';
+        const rubyStdin = createRubyStdin(runtime, hasInitialStdin ? stdin : null, () => {
+            const chunk = waitForBufferedStdin(stdinBufferRuby, () => postMessage({ buffer: true }));
+            if (log) {
+                console.log(chunk == null
+                    ? '[wasm-idle:ruby-stdin] read(bytes=0, eof=true)'
+                    : `[wasm-idle:ruby-stdin] read(bytes=${encoder.encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+            }
+            return chunk;
+        });
+        const { File, OpenFile, PreopenDirectory, WASI } = runtime.wasiShim;
+        const fds = [
+            rubyStdin,
+            new OpenFile(new File([])),
+            new OpenFile(new File([])),
+            new PreopenDirectory('/', workspaceContents(runtime, workspaceFiles))
+        ];
+        const wasiInstance = new WASI(['ruby.wasm', ...args], ['USER=jungol'], fds, {
+            debug: false
+        });
+        const { vm } = await runtime.RubyVM.instantiateModule({
+            module: rubyModule,
+            wasip1: wasiInstance,
+            args: ['ruby.wasm', '-EUTF-8', '-e_=0', ...args],
+            addToImports(imports) {
+                printer.addToImports(imports);
+            },
+            setMemory(memory) {
+                printer.setMemory(memory);
+            }
+        });
+        if (log) {
+            console.log(`[wasm-idle:ruby-worker] eval start bytes=${code.length} activePath=${activePath}`);
+        }
+        postMessage({
+            progress: {
+                kind: 'ready',
+                state: 'running',
+                reason: 'started',
+                label: 'Ruby program started'
+            }
+        });
+        vm.eval(code);
+        if (log) {
+            console.log(`[wasm-idle:ruby-worker] eval settled stdout=${String(Boolean(stdout))} stderr=${String(Boolean(stderr))}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:ruby-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+    finally {
+        if (runtimeState === 'running')
+            runtimeState = 'ready';
+    }
+};

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

@@ -0,0 +1,15 @@
+export interface RuntimeAssetDownloadProgress {
+    loaded: number;
+    total?: number;
+}
+export interface RuntimeAssetFetchOptions {
+    url: string;
+    label: string;
+    cache?: RequestCache;
+    maxAssetBytes?: number;
+    onProgress?: (progress: RuntimeAssetDownloadProgress) => void;
+    signal?: AbortSignal;
+}
+export declare const DEFAULT_RUNTIME_ASSET_MAX_BYTES: number;
+export declare function resolveRuntimeAssetUrl(value: string, label: string): URL;
+export declare function fetchRuntimeAssetBytes({ url, label, cache, maxAssetBytes, onProgress, signal }: RuntimeAssetFetchOptions): Promise<Uint8Array<ArrayBuffer>>;