wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/clang.js

@@ -1,4 +1,6 @@
+import { normalizeDwarfWorkspacePath } from '@wasm-idle/llvm-core/clang';
 import { waitForBufferedStdin } from '../stdinBuffer';
+import { isSharedBufferBackedView } from '../sharedBuffer';
 import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
 self.document = {
     querySelectorAll() {
@@ -6,26 +8,48 @@ self.document = {
     }
 };
 let stdinBufferClang, debugBufferClang, watchBufferClang, watchResultBufferClang, interruptBufferClang, clang;
-async function loadClang(path, log) {
-    const { default: Clang } = await import('../../clang');
-    clang = new Clang({
+let hasInitialStdinClang = false;
+let initialStdinClang = null;
+function postProgress(percent, stage) {
+    postMessage({ progress: { percent, stage } });
+}
+async function loadClang(path, log, maxAssetBytes) {
+    const { BrowserClangRuntime, loadRuntimeManifest, resolveRuntimeManifestUrl } = await import('@wasm-idle/llvm-core/clang');
+    const manifest = await loadRuntimeManifest(resolveRuntimeManifestUrl(path), fetch, undefined, maxAssetBytes);
+    clang = new BrowserClangRuntime({
         stdout: (output) => postMessage({ output }),
         onDebugEvent: (debugEvent) => postMessage({ debugEvent }),
-        stdin: () => waitForBufferedStdin(stdinBufferClang, () => postMessage({ buffer: true })) ?? '',
+        stdin: () => {
+            if (hasInitialStdinClang) {
+                const chunk = initialStdinClang;
+                initialStdinClang = null;
+                return chunk ?? '';
+            }
+            return (waitForBufferedStdin(stdinBufferClang, () => postMessage({ buffer: true })) ?? '');
+        },
         progress: (value) => postMessage({ progress: value }),
         log,
-        path
+        maxAssetBytes,
+        runtimeBaseUrl: path,
+        manifest
     });
+    await clang.ready;
 }
 self.onmessage = async (event) => {
     if (handleWorkerAssetMessage(event.data))
         return;
-    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, log, path, assets, prepare, language, compileArgs, programArgs, cppVersion, cVersion, debug, breakpoints, pauseOnEntry } = event.data;
+    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, log, path, assets, prepare, language, compileArgs, programArgs, activePath, workspaceFiles, cppVersion, cVersion, debugMode, debug, breakpoints, pauseOnEntry, stdin, maxAssetBytes } = event.data;
+    const resolvedDebugMode = debugMode || (debug ? 'trace' : 'none');
     if (load) {
-        const runtimeAssets = assets;
-        configureWorkerRuntimeAssets(runtimeAssets || null);
-        await loadClang(runtimeAssets?.baseUrl || path || '', log);
-        postMessage({ load: true });
+        try {
+            const runtimeAssets = assets;
+            configureWorkerRuntimeAssets(runtimeAssets || null);
+            await loadClang(runtimeAssets?.baseUrl || path || '', log, maxAssetBytes);
+            postMessage({ load: true });
+        }
+        catch (error) {
+            self.postMessage({ error: error.message || 'Unable to load the C/C++ runtime.' });
+        }
     }
     else if (prepare) {
         stdinBufferClang = new Int32Array(buffer);
@@ -33,14 +57,23 @@ self.onmessage = async (event) => {
         watchBufferClang = new Int32Array(watchBuffer);
         watchResultBufferClang = new Int32Array(watchResultBuffer);
         interruptBufferClang = new Uint8Array(interrupt);
+        hasInitialStdinClang = typeof stdin === 'string';
+        initialStdinClang = hasInitialStdinClang ? stdin : null;
+        if (resolvedDebugMode === 'trace' && !isSharedBufferBackedView(debugBufferClang)) {
+            self.postMessage({ error: 'C/C++ debugging requires SharedArrayBuffer.' });
+            return;
+        }
         try {
-            await clang.compileLink(code, {
+            postProgress(5, `Compiling ${language === 'C' ? 'C' : 'C++'} source`);
+            await clang.compileArtifact(code, {
                 language,
                 compileArgs,
                 programArgs,
+                activePath,
+                workspaceFiles,
                 cppVersion,
                 cVersion,
-                debug,
+                debugMode: resolvedDebugMode,
                 breakpoints,
                 pauseOnEntry,
                 debugBuffer: debugBufferClang,
@@ -48,6 +81,7 @@ self.onmessage = async (event) => {
                 watchBuffer: watchBufferClang,
                 watchResultBuffer: watchResultBufferClang
             });
+            postProgress(100, `${language === 'C' ? 'C' : 'C++'} program ready`);
             self.postMessage({ results: true });
         }
         catch (error) {
@@ -61,14 +95,59 @@ self.onmessage = async (event) => {
         watchBufferClang = new Int32Array(watchBuffer);
         watchResultBufferClang = new Int32Array(watchResultBuffer);
         interruptBufferClang = new Uint8Array(interrupt);
+        hasInitialStdinClang = typeof stdin === 'string';
+        initialStdinClang = hasInitialStdinClang ? stdin : null;
+        if (resolvedDebugMode === 'trace' && !isSharedBufferBackedView(debugBufferClang)) {
+            self.postMessage({ error: 'C/C++ debugging requires SharedArrayBuffer.' });
+            return;
+        }
         try {
+            if (resolvedDebugMode === 'lldb') {
+                const artifact = await clang.compileArtifact(code, {
+                    language,
+                    compileArgs,
+                    programArgs,
+                    activePath,
+                    workspaceFiles,
+                    cppVersion,
+                    cVersion,
+                    debugMode: 'lldb'
+                });
+                if (!artifact.debug) {
+                    throw new Error('wasm-clang did not return an LLDB DWARF descriptor');
+                }
+                const inputPath = normalizeDwarfWorkspacePath(activePath || (language === 'C' ? 'main.c' : 'main.cc')) || (language === 'C' ? 'main.c' : 'main.cc');
+                const sources = new Map();
+                for (const file of workspaceFiles || []) {
+                    const sourcePath = normalizeDwarfWorkspacePath(file.path);
+                    if (sourcePath)
+                        sources.set(`/workspace/${sourcePath}`, file.content);
+                }
+                sources.set(`/workspace/${inputPath}`, code);
+                self.postMessage({
+                    lldbArtifact: {
+                        bytes: new Uint8Array(artifact.bytes),
+                        descriptor: artifact.debug,
+                        sources: artifact.debug.files.map(({ path, contentSha256 }) => {
+                            const content = sources.get(path);
+                            if (content === undefined) {
+                                throw new Error(`Missing LLDB source content for ${path}`);
+                            }
+                            return { path, content, contentSha256 };
+                        })
+                    }
+                });
+                return;
+            }
             await clang.compileLinkRun(code, {
                 language,
                 compileArgs,
                 programArgs,
+                activePath,
+                workspaceFiles,
                 cppVersion,
                 cVersion,
-                debug,
+                debugMode: resolvedDebugMode,
                 breakpoints,
                 pauseOnEntry,
                 debugBuffer: debugBufferClang,

package/dist/playground/worker/cobol.js

@@ -0,0 +1,107 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
+import { createCobolCompiler, executeBrowserCobolArtifact } from '@wasm-idle/llvm-core/cobol';
+self.document = {
+    querySelectorAll() {
+        return [];
+    }
+};
+let compiler = null;
+let stdinBufferCobol = null;
+let hasInitialStdinCobol = false;
+let initialStdinCobol = null;
+let initialStdinConsumedCobol = false;
+const normalizeWorkspacePath = (value) => value
+    .replaceAll('\\', '/')
+    .split('/')
+    .filter((part) => part && part !== '.' && part !== '..')
+    .join('/');
+const ensureTrailingNewline = (source) => (source.endsWith('\n') ? source : `${source}\n`);
+function resolveInputPath(activePath) {
+    const normalized = normalizeWorkspacePath(activePath || '');
+    if (!normalized)
+        return 'main.cob';
+    return /\.[A-Za-z0-9_-]+$/.test(normalized) ? normalized : `${normalized}.cob`;
+}
+function readProgramStdin() {
+    if (hasInitialStdinCobol) {
+        if (initialStdinConsumedCobol)
+            return null;
+        initialStdinConsumedCobol = true;
+        return initialStdinCobol ?? '';
+    }
+    return waitForBufferedStdin(stdinBufferCobol, () => postMessage({ buffer: true }));
+}
+async function loadCobolRuntime(clangAssets, cobolBaseUrl, maxAssetBytes, log) {
+    configureWorkerRuntimeAssets(clangAssets || null);
+    compiler = await createCobolCompiler({
+        runtimeBaseUrl: cobolBaseUrl,
+        clangRuntimeBaseUrl: clangAssets?.baseUrl || '',
+        maxAssetBytes,
+        log
+    });
+}
+self.onmessage = async (event) => {
+    if (handleWorkerAssetMessage(event.data))
+        return;
+    const { code, buffer, load, log, prepare, compileArgs, programArgs, activePath, workspaceFiles, stdin, clangAssets, cobolBaseUrl, maxAssetBytes } = event.data;
+    if (load) {
+        try {
+            await loadCobolRuntime(clangAssets, cobolBaseUrl, maxAssetBytes, log);
+            postMessage({ load: true });
+        }
+        catch (error) {
+            postMessage({ error: error.message });
+        }
+    }
+    else if (typeof log === 'boolean' && !code) {
+        // The compiler receives the current logging preference for every compilation.
+        if (typeof code === 'string')
+            postMessage({ results: true });
+    }
+    else if (code) {
+        if (!compiler) {
+            postMessage({ error: 'COBOL runtime is not loaded.' });
+            return;
+        }
+        stdinBufferCobol = new Int32Array(buffer);
+        hasInitialStdinCobol = typeof stdin === 'string';
+        initialStdinCobol = hasInitialStdinCobol ? stdin : null;
+        initialStdinConsumedCobol = false;
+        try {
+            const files = (workspaceFiles || []);
+            const result = await compiler.compile({
+                code: ensureTrailingNewline(code),
+                fileName: resolveInputPath(activePath),
+                sourceFormat: 'free',
+                compileArgs: compileArgs || [],
+                workspaceFiles: files,
+                log,
+                onProgress: ({ percent, message }) => {
+                    postMessage({ progress: percent / 100 });
+                    if (log)
+                        postMessage({ log: message });
+                }
+            });
+            if (!result.success || !result.artifact) {
+                throw new Error(result.stderr || 'GnuCOBOL did not produce a WebAssembly program.');
+            }
+            if (!prepare) {
+                const execution = await executeBrowserCobolArtifact(result.artifact, {
+                    args: programArgs || [],
+                    stdin: readProgramStdin,
+                    stdout: (output) => postMessage({ output }),
+                    stderr: (output) => postMessage({ output }),
+                    files: files.map(({ path, content }) => ({ path, contents: content }))
+                });
+                if (execution.exitCode) {
+                    throw new Error(`COBOL program exited with ${execution.exitCode}`);
+                }
+            }
+            postMessage({ results: true });
+        }
+        catch (error) {
+            postMessage({ error: error.message });
+        }
+    }
+};

package/dist/playground/worker/d.js

@@ -0,0 +1,199 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { loadVerifiedDOuterAssets, snapshotDOuterAssetConfig } from '../dOuterAssets';
+import { createRuntimeAssetsKey, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+let stdinBufferD = null;
+let runtimeConfig = null;
+let loadedRuntimeKey = '';
+let runtimePromise = null;
+let compiledArtifact = null;
+let compiledCacheKey = '';
+async function loadRuntime(config) {
+    const snapshot = snapshotDOuterAssetConfig(config);
+    const runtimeKey = createRuntimeAssetsKey({ d: snapshot });
+    if (!runtimeKey)
+        throw new TypeError('D runtime asset key could not be created');
+    if (loadedRuntimeKey === runtimeKey && runtimePromise) {
+        return await runtimePromise;
+    }
+    loadedRuntimeKey = runtimeKey;
+    compiledArtifact = null;
+    compiledCacheKey = '';
+    const pendingRuntime = (async () => {
+        const { moduleBytes, manifestBytes } = await loadVerifiedDOuterAssets(snapshot);
+        const moduleObjectUrl = URL.createObjectURL(new Blob([moduleBytes.slice().buffer], { type: 'text/javascript' }));
+        let module;
+        try {
+            module = await import(/* @vite-ignore */ moduleObjectUrl);
+        }
+        finally {
+            try {
+                URL.revokeObjectURL(moduleObjectUrl);
+            }
+            catch {
+                // Cleanup must not replace module import success or failure.
+            }
+        }
+        const factory = typeof module.createDCompiler === 'function'
+            ? module.createDCompiler
+            : typeof module.default === 'function'
+                ? module.default
+                : null;
+        if (!factory) {
+            throw new Error('wasm-d module must export createDCompiler or a default factory');
+        }
+        if (typeof module.executeBrowserDArtifact !== 'function') {
+            throw new Error('wasm-d module must export executeBrowserDArtifact');
+        }
+        if (typeof module.parseRuntimeManifest !== 'function') {
+            throw new Error('wasm-d module must export parseRuntimeManifest');
+        }
+        const manifestSource = new TextDecoder('utf-8', { fatal: true }).decode(manifestBytes);
+        const manifest = module.parseRuntimeManifest(JSON.parse(manifestSource));
+        const manifestUrl = new URL(snapshot.manifestUrl);
+        const runtimeBaseUrl = new URL('./', manifestUrl);
+        runtimeBaseUrl.search = manifestUrl.search;
+        return {
+            compiler: await factory({
+                runtimeBaseUrl: runtimeBaseUrl.href,
+                manifest,
+                verifyRuntimeAssetIntegrity
+            }),
+            executeBrowserDArtifact: module.executeBrowserDArtifact
+        };
+    })();
+    runtimePromise = pendingRuntime;
+    try {
+        return await pendingRuntime;
+    }
+    catch (error) {
+        if (runtimePromise === pendingRuntime && loadedRuntimeKey === runtimeKey) {
+            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,
+        severity: diagnostic?.severity === 'warning' || diagnostic?.severity === 'other'
+            ? diagnostic.severity
+            : 'error',
+        message: String(diagnostic?.message || '')
+    };
+}
+self.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, manifestUrl: nextManifestUrl, outerIntegrity, buffer, code, prepare, args = [], stdin, fileName = 'main.d', log } = event.data;
+    try {
+        if (load) {
+            runtimeConfig = snapshotDOuterAssetConfig({
+                moduleUrl: nextModuleUrl,
+                manifestUrl: nextManifestUrl,
+                integrity: outerIntegrity
+            });
+            if (log)
+                console.log(`[wasm-idle:d-worker] load moduleUrl=${runtimeConfig.moduleUrl}`);
+            await loadRuntime(runtimeConfig);
+            postMessage({ load: true });
+            return;
+        }
+        stdinBufferD = new Int32Array(buffer);
+        if (!runtimeConfig)
+            throw new Error('D runtime has not been loaded');
+        const runtime = await loadRuntime(runtimeConfig);
+        const compileCacheKey = `${fileName}\n${code}`;
+        if (!compiledArtifact || compiledCacheKey !== compileCacheKey) {
+            if (log) {
+                console.log(`[wasm-idle:d-worker] compile start prepare=${String(prepare)} file=${fileName} bytes=${code.length}`);
+            }
+            const result = await runtime.compiler.compile({
+                code,
+                fileName,
+                target: 'wasm32-wasi',
+                log,
+                onProgress(progress) {
+                    postMessage({ progress });
+                }
+            });
+            if (log) {
+                console.log(`[wasm-idle:d-worker] compile settled success=${String(result.success)} hasWasm=${String(Boolean(result.artifact?.wasm))} 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) {
+                throw new Error(result.stderr ||
+                    result.diagnostics
+                        ?.map((diagnostic) => diagnostic.message)
+                        .join('\n') ||
+                    'D compilation failed');
+            }
+            if (result.stderr)
+                postMessage({ output: result.stderr });
+            if (!result.artifact?.wasm && !result.artifact?.bytes) {
+                throw new Error('wasm-d did not return a wasm artifact');
+            }
+            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.executeBrowserDArtifact(compiledArtifact, {
+            args,
+            env: {
+                USER: 'jungol'
+            },
+            stdin: () => {
+                if (hasInitialStdin) {
+                    const chunk = initialStdin;
+                    initialStdin = null;
+                    if (log) {
+                        console.log(chunk == null
+                            ? '[wasm-idle:d-stdin] read(bytes=0, eof=true)'
+                            : `[wasm-idle:d-stdin] read(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                    }
+                    return chunk;
+                }
+                const chunk = waitForBufferedStdin(stdinBufferD, () => postMessage({ buffer: true }));
+                if (chunk == null) {
+                    if (log)
+                        console.log('[wasm-idle:d-stdin] read(bytes=0, eof=true)');
+                    return null;
+                }
+                if (log) {
+                    console.log(`[wasm-idle:d-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
+                ? `D program exited with code ${execution.exitCode}\n${execution.stderr}`
+                : `D program exited with code ${execution.exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log)
+            console.error('[wasm-idle:d-worker] failed', error);
+        postMessage({ error: error?.message || String(error) });
+    }
+};

package/dist/playground/worker/dotnet.js

@@ -0,0 +1,141 @@
+export {};
+const workerSelf = globalThis;
+workerSelf.dotnetSidecar = true;
+workerSelf.document ??= {
+    addEventListener() { },
+    dispatchEvent() {
+        return true;
+    },
+    querySelectorAll() {
+        return [];
+    },
+    removeEventListener() { }
+};
+let moduleUrl = '';
+let loadedModuleUrl = '';
+let runtimePromise = null;
+let compiler = null;
+let compiledArtifact = null;
+let compiledCacheKey = '';
+function languageLabel(language) {
+    return language === 'csharp' ? 'C#' : language === 'vbnet' ? 'VB.NET' : 'F#';
+}
+async function loadRuntime(url) {
+    if (!url) {
+        throw new Error('.NET runtime module is not configured. Set runtimeAssets.dotnet.moduleUrl.');
+    }
+    if (loadedModuleUrl === url && runtimePromise && compiler) {
+        return await runtimePromise;
+    }
+    loadedModuleUrl = url;
+    compiledArtifact = null;
+    compiledCacheKey = '';
+    runtimePromise = (async () => {
+        const runtimeModule = (await import(/* @vite-ignore */ url));
+        if (typeof runtimeModule.createDotnetCompiler !== 'function') {
+            throw new Error('wasm-dotnet module must export createDotnetCompiler');
+        }
+        if (typeof runtimeModule.executeBrowserDotnetArtifact !== 'function') {
+            throw new Error('wasm-dotnet module must export executeBrowserDotnetArtifact');
+        }
+        compiler = runtimeModule.createDotnetCompiler({
+            onFatalError(error) {
+                postMessage({ error: error.message, fatal: true });
+            }
+        });
+        return runtimeModule;
+    })();
+    return await runtimePromise;
+}
+workerSelf.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, code, language = 'fsharp', prepare, args = [], stdin = '', maxOutputBytes = 1024 * 1024, log } = event.data;
+    try {
+        if (load) {
+            moduleUrl = nextModuleUrl;
+            if (log) {
+                console.log(`[wasm-idle:dotnet-worker] load moduleUrl=${moduleUrl}`);
+            }
+            await loadRuntime(moduleUrl);
+            postMessage({ load: true });
+            return;
+        }
+        const runtime = await loadRuntime(moduleUrl);
+        const compileLanguage = language === 'csharp' ? 'csharp' : language === 'vbnet' ? 'vbnet' : 'fsharp';
+        const compileCacheKey = `${compileLanguage}\n${code}`;
+        if (!compiledArtifact || compiledCacheKey !== compileCacheKey) {
+            if (!compiler) {
+                throw new Error('.NET compiler was not initialized');
+            }
+            if (log) {
+                console.log(`[wasm-idle:dotnet-worker] compile start language=${compileLanguage} prepare=${String(prepare)} bytes=${code.length}`);
+            }
+            const result = await compiler.compile({
+                code,
+                language: compileLanguage,
+                target: 'browser-wasm',
+                prepare,
+                log,
+                onProgress(progress) {
+                    postMessage({ progress });
+                }
+            });
+            for (const diagnostic of result.diagnostics || []) {
+                postMessage({ diagnostic });
+            }
+            for (const line of result.logs || []) {
+                postMessage({ output: line.endsWith('\n') ? line : `${line}\n` });
+            }
+            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') ||
+                    `${languageLabel(compileLanguage)} compilation failed`);
+            }
+            if (result.stderr)
+                postMessage({ output: result.stderr });
+            compiledArtifact = result.artifact;
+            compiledCacheKey = compileCacheKey;
+        }
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        postMessage({
+            progress: {
+                kind: 'ready',
+                state: 'running',
+                reason: 'started',
+                label: `Running ${languageLabel(compileLanguage)} program`
+            }
+        });
+        const execution = await runtime.executeBrowserDotnetArtifact(compiledArtifact, {
+            args,
+            env: {
+                USER: 'jungol'
+            },
+            stdin,
+            maxOutputBytes,
+            stdout: (output) => {
+                if (output)
+                    postMessage({ output });
+            },
+            stderr: (output) => {
+                if (output)
+                    postMessage({ output });
+            }
+        });
+        if (execution.exitCode !== 0) {
+            throw new Error(`${languageLabel(compileLanguage)} program exited with code ${execution.exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:dotnet-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

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

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