wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/lisp.js

@@ -0,0 +1,195 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { loadVerifiedLispRuntimeAssets } from '../lispAssets';
+let stdinBufferLisp = null;
+let runtimeConfig = null;
+const DEFAULT_MAX_LISP_ASSET_BYTES = 128 * 1024 * 1024;
+let runtimeMaxAssetBytes = DEFAULT_MAX_LISP_ASSET_BYTES;
+let loadedRuntimeKey = '';
+let runtimePromise = null;
+let compiledArtifact = null;
+let compiledCacheKey = '';
+function resolveMaxAssetBytes(value) {
+    const resolved = value ?? DEFAULT_MAX_LISP_ASSET_BYTES;
+    if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+        throw new TypeError('Lisp runtime maxAssetBytes must be a positive safe integer');
+    }
+    return resolved;
+}
+async function loadRuntime(config, maxAssetBytes) {
+    if (!config) {
+        throw new Error('Lisp runtime is not configured. Provide its module, manifest, and fingerprint.');
+    }
+    const runtimeKey = JSON.stringify([config, maxAssetBytes]);
+    if (loadedRuntimeKey === runtimeKey && runtimePromise) {
+        return await runtimePromise;
+    }
+    loadedRuntimeKey = runtimeKey;
+    compiledArtifact = null;
+    compiledCacheKey = '';
+    const nextRuntimePromise = (async () => {
+        const verified = await loadVerifiedLispRuntimeAssets(config, { maxAssetBytes });
+        const module = verified.module;
+        const factory = typeof module.createLispCompiler === 'function'
+            ? module.createLispCompiler
+            : typeof module.default === 'function'
+                ? module.default
+                : null;
+        if (!factory) {
+            throw new Error('wasm-lisp module must export createLispCompiler or a default factory');
+        }
+        if (typeof module.executeBrowserLispArtifact !== 'function') {
+            throw new Error('wasm-lisp module must export executeBrowserLispArtifact');
+        }
+        return {
+            compiler: (await factory({
+                compilerModule: verified.compilerModule,
+                compilerCoreModules: verified.compilerCoreModules
+            })),
+            executeBrowserLispArtifact: module.executeBrowserLispArtifact
+        };
+    })();
+    runtimePromise = nextRuntimePromise;
+    try {
+        return await nextRuntimePromise;
+    }
+    catch (error) {
+        if (runtimePromise === nextRuntimePromise) {
+            runtimePromise = null;
+            loadedRuntimeKey = '';
+        }
+        throw error;
+    }
+}
+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, runtimeConfig: nextRuntimeConfig, maxAssetBytes: nextMaxAssetBytes, buffer, code, prepare, args = [], stdin, activePath = 'main.scm', workspaceFiles = [], log } = event.data;
+    try {
+        if (load) {
+            runtimeConfig = nextRuntimeConfig;
+            runtimeMaxAssetBytes = resolveMaxAssetBytes(nextMaxAssetBytes);
+            if (log) {
+                console.log(`[wasm-idle:lisp-worker] load profile=${runtimeConfig?.manifestFingerprint || 'missing'}`);
+            }
+            await loadRuntime(runtimeConfig, runtimeMaxAssetBytes);
+            postMessage({ load: true });
+            return;
+        }
+        stdinBufferLisp = new Int32Array(buffer);
+        const runtime = await loadRuntime(runtimeConfig, runtimeMaxAssetBytes);
+        const compileCacheKey = JSON.stringify({
+            activePath,
+            code,
+            workspaceFiles
+        });
+        if (!compiledArtifact || compiledCacheKey !== compileCacheKey) {
+            if (log) {
+                console.log(`[wasm-idle:lisp-worker] compile start prepare=${String(prepare)} bytes=${code.length}`);
+            }
+            const result = await runtime.compiler.compile({
+                code,
+                fileName: activePath,
+                files: workspaceFiles,
+                log
+            });
+            if (log) {
+                console.log(`[wasm-idle:lisp-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') ||
+                    'Lisp compilation failed');
+            }
+            if (result.stderr)
+                postMessage({ output: result.stderr });
+            compiledArtifact = result.artifact;
+            compiledCacheKey = compileCacheKey;
+        }
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        const hasInitialStdin = typeof stdin === 'string';
+        let initialStdin = hasInitialStdin ? stdin : null;
+        const execution = await runtime.executeBrowserLispArtifact(compiledArtifact, {
+            args,
+            env: {
+                USER: 'jungol'
+            },
+            onReady: () => postMessage({
+                progress: {
+                    kind: 'ready',
+                    state: 'running',
+                    reason: 'started',
+                    label: 'Lisp program started'
+                }
+            }),
+            files: workspaceFiles,
+            activePath,
+            stdin: () => {
+                if (hasInitialStdin) {
+                    const chunk = initialStdin;
+                    initialStdin = null;
+                    if (log) {
+                        console.log(chunk == null
+                            ? '[wasm-idle:lisp-stdin] read(bytes=0, eof=true)'
+                            : `[wasm-idle:lisp-stdin] read(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                    }
+                    return chunk;
+                }
+                const chunk = waitForBufferedStdin(stdinBufferLisp, () => postMessage({ buffer: true }));
+                if (chunk == null) {
+                    if (log) {
+                        console.log('[wasm-idle:lisp-stdin] read(bytes=0, eof=true)');
+                    }
+                    return null;
+                }
+                if (log) {
+                    console.log(`[wasm-idle:lisp-stdin] read(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                }
+                return chunk;
+            },
+            stdout: (output) => {
+                if (output)
+                    postMessage({ output });
+            },
+            stderr: (output) => {
+                if (output)
+                    postMessage({ output });
+            }
+        });
+        if (execution.exitCode !== 0) {
+            throw new Error(execution.stderr
+                ? `Lisp program exited with code ${execution.exitCode}\n${execution.stderr}`
+                : `Lisp program exited with code ${execution.exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:lisp-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

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

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

package/dist/playground/worker/lua.js

@@ -0,0 +1,163 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+let stdinBufferLua = null;
+let moduleUrl = '';
+let loadedModuleUrl = '';
+let runtimePromise = null;
+let compiledArtifact = null;
+let compiledCacheKey = '';
+async function loadRuntime(url) {
+    if (!url) {
+        throw new Error('Lua runtime is not configured. Set PUBLIC_WASM_LUA_MODULE_URL or runtimeAssets.lua.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.createLuaCompiler === 'function'
+            ? module.createLuaCompiler
+            : typeof module.default === 'function'
+                ? module.default
+                : null;
+        if (!factory) {
+            throw new Error('wasm-lua module must export createLuaCompiler or a default factory');
+        }
+        if (typeof module.executeBrowserLuaArtifact !== 'function') {
+            throw new Error('wasm-lua module must export executeBrowserLuaArtifact');
+        }
+        return {
+            compiler: await factory(),
+            executeBrowserLuaArtifact: module.executeBrowserLuaArtifact
+        };
+    })();
+    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, buffer, code, prepare, args = [], stdin, activePath = 'main.lua', workspaceFiles = [], log } = event.data;
+    try {
+        if (load) {
+            moduleUrl = nextModuleUrl;
+            if (log) {
+                console.log(`[wasm-idle:lua-worker] load moduleUrl=${moduleUrl}`);
+            }
+            await loadRuntime(moduleUrl);
+            postMessage({ load: true });
+            return;
+        }
+        stdinBufferLua = new Int32Array(buffer);
+        const runtime = await loadRuntime(moduleUrl);
+        const compileCacheKey = JSON.stringify({
+            activePath,
+            code,
+            workspaceFiles
+        });
+        if (!compiledArtifact || compiledCacheKey !== compileCacheKey) {
+            if (log) {
+                console.log(`[wasm-idle:lua-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:lua-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') ||
+                    'Lua compilation failed');
+            }
+            if (result.stderr)
+                postMessage({ output: result.stderr });
+            compiledArtifact = result.artifact;
+            compiledCacheKey = compileCacheKey;
+        }
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        const hasInitialStdin = typeof stdin === 'string';
+        let initialStdin = hasInitialStdin ? stdin : null;
+        const execution = await runtime.executeBrowserLuaArtifact(compiledArtifact, {
+            args,
+            onReady: () => postMessage({
+                progress: {
+                    kind: 'ready',
+                    state: 'running',
+                    reason: 'started',
+                    label: 'Lua program started'
+                }
+            }),
+            stdin: () => {
+                if (hasInitialStdin) {
+                    const chunk = initialStdin;
+                    initialStdin = null;
+                    if (log) {
+                        console.log(chunk == null
+                            ? '[wasm-idle:lua-stdin] read(bytes=0, eof=true)'
+                            : `[wasm-idle:lua-stdin] read(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                    }
+                    return chunk;
+                }
+                const chunk = waitForBufferedStdin(stdinBufferLua, () => postMessage({ buffer: true }));
+                if (chunk == null) {
+                    if (log) {
+                        console.log('[wasm-idle:lua-stdin] read(bytes=0, eof=true)');
+                    }
+                    return null;
+                }
+                if (log) {
+                    console.log(`[wasm-idle:lua-stdin] read(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                }
+                return chunk;
+            },
+            stdout: (output) => {
+                if (output)
+                    postMessage({ output });
+            },
+            stderr: (output) => {
+                if (output)
+                    postMessage({ output });
+            }
+        });
+        if (execution.exitCode !== 0) {
+            throw new Error(execution.stderr
+                ? `Lua program exited with code ${execution.exitCode}\n${execution.stderr}`
+                : `Lua program exited with code ${execution.exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:lua-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

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

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

package/dist/playground/worker/objectivec.js

@@ -0,0 +1,10 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
+import { installObjectiveCWorker } from '@wasm-idle/llvm-core/objective-c';
+import { verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+installObjectiveCWorker(self, {
+    configureRuntimeAssets: configureWorkerRuntimeAssets,
+    handleAssetMessage: handleWorkerAssetMessage,
+    waitForStdin: waitForBufferedStdin,
+    verifyRuntimeAssetIntegrity
+});