wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/wasm.js

@@ -0,0 +1,273 @@
+import { ConsoleStdout, Fd, WASI, WASIProcExit, wasi } from '@bjorn3/browser_wasi_shim';
+import { waitForBufferedStdin } from '../stdinBuffer';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+let stdinChunkWasm = new Uint8Array(0);
+let stdinChunkOffsetWasm = 0;
+class WasmStdin extends Fd {
+    buffer;
+    log;
+    initialStdin;
+    hasInitialStdin;
+    constructor(initialStdin, buffer, log) {
+        super();
+        this.buffer = buffer;
+        this.log = log;
+        this.initialStdin = typeof initialStdin === 'string' ? initialStdin : null;
+        this.hasInitialStdin = typeof initialStdin === 'string';
+    }
+    fd_fdstat_get() {
+        const fdstat = new wasi.Fdstat(wasi.FILETYPE_CHARACTER_DEVICE, 0);
+        fdstat.fs_rights_base = BigInt(wasi.RIGHTS_FD_READ);
+        fdstat.fs_rights_inherited = 0n;
+        return { ret: wasi.ERRNO_SUCCESS, fdstat };
+    }
+    fd_filestat_get() {
+        return {
+            ret: wasi.ERRNO_SUCCESS,
+            filestat: new wasi.Filestat(0n, wasi.FILETYPE_CHARACTER_DEVICE, 0n)
+        };
+    }
+    fd_read(size) {
+        if (stdinChunkOffsetWasm >= stdinChunkWasm.length) {
+            const nextChunk = this.readNextChunk();
+            if (nextChunk === null) {
+                stdinChunkWasm = new Uint8Array(0);
+                stdinChunkOffsetWasm = 0;
+                return {
+                    ret: wasi.ERRNO_SUCCESS,
+                    data: new Uint8Array(0)
+                };
+            }
+            stdinChunkWasm = encoder.encode(nextChunk);
+            stdinChunkOffsetWasm = 0;
+        }
+        const end = Math.min(stdinChunkOffsetWasm + size, stdinChunkWasm.length);
+        const data = stdinChunkWasm.slice(stdinChunkOffsetWasm, end);
+        stdinChunkOffsetWasm = end;
+        return {
+            ret: wasi.ERRNO_SUCCESS,
+            data
+        };
+    }
+    readByte() {
+        if (stdinChunkOffsetWasm >= stdinChunkWasm.length) {
+            const nextChunk = this.readNextChunk();
+            if (nextChunk === null) {
+                stdinChunkWasm = new Uint8Array(0);
+                stdinChunkOffsetWasm = 0;
+                return -1;
+            }
+            stdinChunkWasm = encoder.encode(nextChunk);
+            stdinChunkOffsetWasm = 0;
+        }
+        return stdinChunkWasm[stdinChunkOffsetWasm++] ?? -1;
+    }
+    readNextChunk() {
+        if (this.hasInitialStdin) {
+            const chunk = this.initialStdin;
+            this.initialStdin = null;
+            this.logRead(chunk);
+            return chunk;
+        }
+        if (!this.buffer) {
+            this.logRead(null);
+            return null;
+        }
+        const chunk = waitForBufferedStdin(this.buffer, () => postMessage({ buffer: true }));
+        this.logRead(chunk);
+        return chunk;
+    }
+    logRead(chunk) {
+        if (!this.log)
+            return;
+        if (chunk === null) {
+            console.log('[wasm-idle:wasm-stdin] read(bytes=0, eof=true)');
+            return;
+        }
+        console.log(`[wasm-idle:wasm-stdin] read(bytes=${encoder.encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+    }
+}
+function normalizeWorkspacePath(path) {
+    return path
+        .replace(/^\/+/, '')
+        .split('/')
+        .filter((part) => part && part !== '.' && part !== '..' && !part.includes('\0'))
+        .join('/');
+}
+function sourceFromWorkspace(code, activePath, workspaceFiles) {
+    const normalizedActivePath = normalizeWorkspacePath(activePath || 'main.wasm');
+    const file = workspaceFiles.find((entry) => normalizeWorkspacePath(entry.path) === normalizedActivePath);
+    return file?.content || code;
+}
+function decodeBase64(value) {
+    const normalized = value.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, '=');
+    const binary = atob(padded);
+    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+function decodeHex(value) {
+    const normalized = value.replace(/^0x/iu, '').replace(/\s+/gu, '');
+    const bytes = new Uint8Array(normalized.length / 2);
+    for (let index = 0; index < bytes.length; index += 1) {
+        bytes[index] = Number.parseInt(normalized.slice(index * 2, index * 2 + 2), 16);
+    }
+    return bytes;
+}
+function decodeWasmBytes(source) {
+    const withoutComments = source
+        .split(/\r?\n/u)
+        .filter((line) => !line.trimStart().startsWith('#'))
+        .join('\n')
+        .trim();
+    const dataUrlMatch = /^data:[^,]*,\s*([\s\S]+)$/iu.exec(withoutComments);
+    const prefixedBase64 = /^(?:base64|wasm):\s*([\s\S]+)$/iu.exec(withoutComments);
+    const candidate = (dataUrlMatch?.[1] || prefixedBase64?.[1] || withoutComments).replace(/\s+/gu, '');
+    let bytes;
+    try {
+        bytes =
+            /^(?:0x)?[0-9a-f]+$/iu.test(candidate) &&
+                candidate.replace(/^0x/iu, '').length % 2 === 0
+                ? decodeHex(candidate)
+                : decodeBase64(candidate);
+    }
+    catch {
+        throw new Error('WASM source must decode to a WebAssembly binary');
+    }
+    if (bytes.length < 4 ||
+        bytes[0] !== 0x00 ||
+        bytes[1] !== 0x61 ||
+        bytes[2] !== 0x73 ||
+        bytes[3] !== 0x6d) {
+        throw new Error('WASM source must decode to a WebAssembly binary');
+    }
+    return bytes;
+}
+self.onmessage = async (event) => {
+    const { load, code, prepare, buffer, stdin, args = [], activePath = 'main.wasm', workspaceFiles = [], log } = event.data;
+    try {
+        if (load) {
+            postMessage({ load: true });
+            return;
+        }
+        const source = sourceFromWorkspace(code, activePath, workspaceFiles);
+        const bytes = decodeWasmBytes(source);
+        const wasmBuffer = new ArrayBuffer(bytes.byteLength);
+        new Uint8Array(wasmBuffer).set(bytes);
+        if (prepare) {
+            await WebAssembly.compile(wasmBuffer);
+            postMessage({ results: true });
+            return;
+        }
+        stdinChunkWasm = new Uint8Array(0);
+        stdinChunkOffsetWasm = 0;
+        const stdinReader = new WasmStdin(stdin, buffer ? new Int32Array(buffer) : null, Boolean(log));
+        const stdout = new ConsoleStdout((chunk) => {
+            const text = decoder.decode(chunk);
+            if (text)
+                postMessage({ output: text });
+        });
+        const stderr = new ConsoleStdout((chunk) => {
+            const text = decoder.decode(chunk);
+            if (text)
+                postMessage({ output: text });
+        });
+        const wasiRuntime = new WASI(args, ['USER=wasm-idle'], [stdinReader, stdout, stderr]);
+        const compiledModule = await WebAssembly.compile(wasmBuffer);
+        const importModules = WebAssembly.Module.imports(compiledModule).map((entry) => entry.module);
+        const usesWasi = importModules.includes('wasi_snapshot_preview1') ||
+            importModules.includes('wasi_unstable');
+        const instance = await WebAssembly.instantiate(compiledModule, {
+            env: {
+                readByte() {
+                    return stdinReader.readByte();
+                }
+            },
+            wasi_snapshot_preview1: wasiRuntime.wasiImport,
+            wasi_unstable: wasiRuntime.wasiImport
+        });
+        const exportsObject = instance.exports;
+        postMessage({
+            progress: {
+                kind: 'ready',
+                state: 'running',
+                reason: 'started',
+                label: 'WASM program started'
+            }
+        });
+        let exitCode = 0;
+        let printed = false;
+        try {
+            if (usesWasi && typeof exportsObject._start === 'function') {
+                exitCode = wasiRuntime.start(instance);
+            }
+            else if (usesWasi && typeof exportsObject.memory === 'object') {
+                wasiRuntime.initialize(instance);
+                if (typeof exportsObject.main === 'function') {
+                    const result = exportsObject.main();
+                    if (typeof result === 'number' || typeof result === 'bigint') {
+                        postMessage({ output: `main=${String(result)}\n` });
+                        printed = true;
+                    }
+                }
+            }
+            else if (typeof exportsObject._start === 'function') {
+                const result = exportsObject._start();
+                if (typeof result === 'number' || typeof result === 'bigint') {
+                    postMessage({ output: `_start=${String(result)}\n` });
+                    printed = true;
+                }
+            }
+            else if (typeof exportsObject.main === 'function') {
+                const result = exportsObject.main();
+                if (typeof result === 'number' || typeof result === 'bigint') {
+                    postMessage({ output: `main=${String(result)}\n` });
+                    printed = true;
+                }
+            }
+            else {
+                for (const [name, value] of Object.entries(exportsObject)) {
+                    if (name.startsWith('_') || typeof value !== 'function')
+                        continue;
+                    try {
+                        const result = value();
+                        if (typeof result === 'number' || typeof result === 'bigint') {
+                            postMessage({ output: `${name}=${String(result)}\n` });
+                            printed = true;
+                        }
+                    }
+                    catch {
+                        // Parameterized exports are still valid but cannot be auto-run.
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof WASIProcExit) {
+                exitCode = error.code;
+            }
+            else {
+                throw error;
+            }
+        }
+        if (exitCode !== 0) {
+            throw new Error(`WASM module exited with code ${exitCode}`);
+        }
+        if (!printed && !usesWasi && typeof exportsObject._start !== 'function') {
+            const exportNames = Object.keys(exportsObject).sort().join(', ');
+            postMessage({
+                output: exportNames ? `exports: ${exportNames}\n` : 'compiled WebAssembly module\n'
+            });
+        }
+        if (log) {
+            console.log('[wasm-idle:wasm-worker] run settled');
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:wasm-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

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

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

package/dist/playground/worker/wat.js

@@ -0,0 +1,188 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+const encoder = new TextEncoder();
+let moduleUrl = '';
+let loadedModuleUrl = '';
+let runtimePromise = null;
+let compiledArtifact = null;
+let compiledCacheKey = '';
+class WatStdin {
+    buffer;
+    log;
+    initialStdin;
+    fixedInitialStdin;
+    currentBytes = new Uint8Array(0);
+    currentOffset = 0;
+    constructor(initialStdin, buffer, log) {
+        this.buffer = buffer;
+        this.log = log;
+        this.initialStdin = typeof initialStdin === 'string' ? initialStdin : null;
+        this.fixedInitialStdin = typeof initialStdin === 'string';
+    }
+    readByte() {
+        while (this.currentOffset >= this.currentBytes.length) {
+            const chunk = this.readChunk();
+            if (chunk == null)
+                return -1;
+            if (!chunk)
+                continue;
+            this.currentBytes = encoder.encode(chunk);
+            this.currentOffset = 0;
+        }
+        return this.currentBytes[this.currentOffset++] ?? -1;
+    }
+    readChunk() {
+        if (this.initialStdin != null) {
+            const chunk = this.initialStdin;
+            this.initialStdin = null;
+            return chunk;
+        }
+        if (this.fixedInitialStdin || !this.buffer)
+            return null;
+        const chunk = waitForBufferedStdin(this.buffer, () => postMessage({ buffer: true }));
+        if (this.log) {
+            console.log(chunk == null
+                ? '[wasm-idle:wat-stdin] read(bytes=0, eof=true)'
+                : `[wasm-idle:wat-stdin] read(bytes=${encoder.encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+        }
+        return chunk;
+    }
+}
+async function loadRuntime(url) {
+    if (!url) {
+        throw new Error('WAT runtime is not configured. Set PUBLIC_WASM_WAT_MODULE_URL or runtimeAssets.wat.moduleUrl.');
+    }
+    if (loadedModuleUrl === url && runtimePromise) {
+        return await runtimePromise;
+    }
+    loadedModuleUrl = url;
+    compiledArtifact = null;
+    compiledCacheKey = '';
+    runtimePromise = (async () => {
+        const module = await import(/* @vite-ignore */ url);
+        const factory = typeof module.createWatCompiler === 'function'
+            ? module.createWatCompiler
+            : typeof module.default === 'function'
+                ? module.default
+                : null;
+        if (!factory) {
+            throw new Error('wasm-wat module must export createWatCompiler or a default factory');
+        }
+        if (typeof module.executeBrowserWatArtifact !== 'function') {
+            throw new Error('wasm-wat module must export executeBrowserWatArtifact');
+        }
+        return {
+            compiler: await factory(),
+            executeBrowserWatArtifact: module.executeBrowserWatArtifact
+        };
+    })();
+    return await runtimePromise;
+}
+function normalizeDiagnostic(diagnostic) {
+    return {
+        fileName: diagnostic?.fileName ?? null,
+        lineNumber: Math.max(1, Number(diagnostic?.lineNumber || 1)),
+        columnNumber: typeof diagnostic?.columnNumber === 'number'
+            ? Math.max(1, diagnostic.columnNumber)
+            : undefined,
+        endColumnNumber: typeof diagnostic?.endColumnNumber === 'number'
+            ? Math.max(1, diagnostic.endColumnNumber)
+            : undefined,
+        severity: diagnostic?.severity === 'warning' || diagnostic?.severity === 'other'
+            ? diagnostic.severity
+            : 'error',
+        message: String(diagnostic?.message || '')
+    };
+}
+self.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, code, prepare, buffer, stdin, activePath = 'main.wat', workspaceFiles = [], log } = event.data;
+    try {
+        if (load) {
+            moduleUrl = nextModuleUrl;
+            if (log) {
+                console.log(`[wasm-idle:wat-worker] load moduleUrl=${moduleUrl}`);
+            }
+            await loadRuntime(moduleUrl);
+            postMessage({ load: true });
+            return;
+        }
+        const runtime = await loadRuntime(moduleUrl);
+        const compileCacheKey = JSON.stringify({
+            activePath,
+            code,
+            workspaceFiles
+        });
+        if (!compiledArtifact || compiledCacheKey !== compileCacheKey) {
+            if (log) {
+                console.log(`[wasm-idle:wat-worker] compile start prepare=${String(prepare)} bytes=${code.length}`);
+            }
+            const result = await runtime.compiler.compile({
+                code,
+                fileName: activePath,
+                log
+            });
+            if (log) {
+                console.log(`[wasm-idle:wat-worker] compile settled success=${String(result.success)} stdout=${String(Boolean(result.stdout))} stderr=${String(Boolean(result.stderr))}`);
+            }
+            for (const diagnostic of result.diagnostics || []) {
+                postMessage({ diagnostic: normalizeDiagnostic(diagnostic) });
+            }
+            if (result.stdout)
+                postMessage({ output: result.stdout });
+            if (!result.success || !result.artifact) {
+                throw new Error(result.stderr ||
+                    result.diagnostics
+                        ?.map((diagnostic) => diagnostic.message)
+                        .join('\n') ||
+                    'WAT compilation failed');
+            }
+            if (result.stderr)
+                postMessage({ output: result.stderr });
+            compiledArtifact = result.artifact;
+            compiledCacheKey = compileCacheKey;
+        }
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        const stdinReader = new WatStdin(stdin, buffer ? new Int32Array(buffer) : null, Boolean(log));
+        const execution = await runtime.executeBrowserWatArtifact(compiledArtifact, {
+            files: workspaceFiles,
+            activePath,
+            onReady: () => postMessage({
+                progress: {
+                    kind: 'ready',
+                    state: 'running',
+                    reason: 'started',
+                    label: 'WAT program started'
+                }
+            }),
+            imports: {
+                env: {
+                    readByte() {
+                        return stdinReader.readByte();
+                    }
+                }
+            },
+            stdout: (output) => {
+                if (output)
+                    postMessage({ output });
+            },
+            stderr: (output) => {
+                if (output)
+                    postMessage({ output });
+            }
+        });
+        if (execution.exitCode !== 0) {
+            throw new Error(execution.stderr
+                ? `WAT module exited with code ${execution.exitCode}\n${execution.stderr}`
+                : `WAT module exited with code ${execution.exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:wat-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

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

@@ -0,0 +1,8 @@
+import { Directory } from '@bjorn3/browser_wasi_shim';
+import { type ZigExecutionAssetReceipt } from '../zigAssets';
+interface ZigStdlibArchiveLimits {
+    maxExpandedBytes?: number;
+    maxFiles?: number;
+}
+export declare function loadStdDirectory(source: Uint8Array, assetUrl: string, limits?: ZigStdlibArchiveLimits, receipt?: ZigExecutionAssetReceipt): Promise<Directory>;
+export {};