wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/fortran.js

@@ -0,0 +1,295 @@
+import { WASI } from '@bjorn3/browser_wasi_shim';
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { snapshotFortranExecutionAssetReceipts } from '../fortranAssets';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
+import { fetchRuntimeAssetBytes, resolveRuntimeAssetUrl } from './runtimeAssetFetch';
+import { BrowserClangRuntime, createBrowserWasiHost, executeBrowserClangArtifact, loadRuntimeManifest, resolveRuntimeManifestUrl } from '@wasm-idle/llvm-core/clang';
+import { verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+self.document = {
+    querySelectorAll() {
+        return [];
+    }
+};
+const textDecoder = new TextDecoder('utf-8', { fatal: true });
+const F2C_COMPAT_SOURCE = `#include <stdarg.h>
+#include <stdio.h>
+
+typedef void (*sighandler_t)(int);
+
+int fiprintf(FILE *stream, const char *format, ...) {
+    va_list ap;
+    va_start(ap, format);
+    int result = vfprintf(stream, format, ap);
+    va_end(ap);
+    return result;
+}
+
+int siprintf(char *str, const char *format, ...) {
+    va_list ap;
+    va_start(ap, format);
+    int result = vsprintf(str, format, ap);
+    va_end(ap);
+    return result;
+}
+
+int __small_sprintf(char *str, const char *format, ...) {
+    va_list ap;
+    va_start(ap, format);
+    int result = vsprintf(str, format, ap);
+    va_end(ap);
+    return result;
+}
+
+sighandler_t signal(int signum, sighandler_t handler) {
+    (void)signum;
+    return handler;
+}
+
+FILE *tmpfile(void) {
+    return NULL;
+}
+`;
+let stdinBufferFortran = null;
+let clang = null;
+let f2cModule = null;
+let hasInitialStdinFortran = false;
+let initialStdinFortran = null;
+let initialStdinConsumedFortran = false;
+const normalizeWorkspacePath = (value) => value
+    .replaceAll('\\', '/')
+    .split('/')
+    .filter((part) => part && part !== '.' && part !== '..')
+    .join('/');
+const basename = (value) => value.split('/').pop() || value;
+const stemOf = (value) => basename(value).replace(/\.[^.]+$/, '') || 'main';
+const ensureTrailingNewline = (source) => (source.endsWith('\n') ? source : `${source}\n`);
+const resolveInputPath = (activePath) => {
+    const normalized = normalizeWorkspacePath(activePath || '');
+    if (!normalized)
+        return 'main.f';
+    return /\.[A-Za-z0-9_-]+$/.test(normalized) ? normalized : `${normalized}.f`;
+};
+async function fetchVerifiedBytes(url, asset, receipt) {
+    const bytes = await fetchRuntimeAssetBytes({
+        url,
+        label: asset,
+        maxAssetBytes: receipt.bytes
+    });
+    await verifyRuntimeAssetIntegrity({
+        asset,
+        bytes,
+        expected: receipt,
+        runtimeId: 'FORTRAN'
+    });
+    return bytes;
+}
+async function fetchVerifiedText(url, asset, receipt) {
+    return textDecoder.decode(await fetchVerifiedBytes(url, asset, receipt));
+}
+async function loadFortranRuntime(clangAssets, fortranAssets, log) {
+    const receipts = snapshotFortranExecutionAssetReceipts(fortranAssets.integrity);
+    if (!Number.isSafeInteger(fortranAssets.maxAssetBytes) || fortranAssets.maxAssetBytes <= 0) {
+        throw new TypeError('Fortran maxAssetBytes must be a positive safe integer');
+    }
+    for (const [asset, url] of [
+        ['f2c.wasm', fortranAssets.f2cWasmUrl],
+        ['libf2c.a', fortranAssets.libf2cUrl],
+        ['f2c.h', fortranAssets.f2cHeaderUrl]
+    ]) {
+        resolveRuntimeAssetUrl(url, asset);
+        if (receipts[asset].bytes > fortranAssets.maxAssetBytes) {
+            throw new Error(`Fortran execution asset ${asset} exceeds the ${fortranAssets.maxAssetBytes} byte limit`);
+        }
+    }
+    const f2cWasmBytes = await fetchVerifiedBytes(fortranAssets.f2cWasmUrl, 'f2c.wasm', receipts['f2c.wasm']);
+    const libf2cBytes = await fetchVerifiedBytes(fortranAssets.libf2cUrl, 'libf2c.a', receipts['libf2c.a']);
+    const f2cHeader = await fetchVerifiedText(fortranAssets.f2cHeaderUrl, 'f2c.h', receipts['f2c.h']);
+    const nextF2cModule = await WebAssembly.compile(f2cWasmBytes);
+    configureWorkerRuntimeAssets(clangAssets || null);
+    const clangBaseUrl = clangAssets?.baseUrl || '';
+    const manifest = await loadRuntimeManifest(resolveRuntimeManifestUrl(clangBaseUrl), fetch, undefined, fortranAssets.maxAssetBytes);
+    const nextClang = new BrowserClangRuntime({
+        stdout: (output) => postMessage({ output }),
+        stdin: () => '',
+        progress: (value) => postMessage({ progress: value }),
+        log,
+        maxAssetBytes: fortranAssets.maxAssetBytes,
+        runtimeBaseUrl: clangBaseUrl,
+        manifest
+    });
+    await nextClang.ready;
+    nextClang.memfs.addFile('f2c.h', f2cHeader);
+    nextClang.memfs.addFile('libf2c.a', libf2cBytes);
+    clang = nextClang;
+    f2cModule = nextF2cModule;
+}
+function readProgramStdin() {
+    if (hasInitialStdinFortran) {
+        if (initialStdinConsumedFortran)
+            return null;
+        initialStdinConsumedFortran = true;
+        return initialStdinFortran ?? '';
+    }
+    return waitForBufferedStdin(stdinBufferFortran, () => postMessage({ buffer: true }));
+}
+function workspaceFilesForF2c(code, inputPath, workspaceFiles = []) {
+    const fileMap = new Map();
+    for (const file of workspaceFiles) {
+        const safePath = normalizeWorkspacePath(file.path);
+        if (safePath)
+            fileMap.set(safePath, file.content);
+    }
+    fileMap.set(inputPath, ensureTrailingNewline(code));
+    return Array.from(fileMap, ([path, contents]) => ({ path, contents }));
+}
+function readHostFileBytes(host, path) {
+    const segments = normalizeWorkspacePath(path).split('/').filter(Boolean);
+    let node = host.rootDirectory;
+    for (const segment of segments) {
+        node = node?.contents?.get(segment);
+        if (!node)
+            return null;
+    }
+    const data = node?.data;
+    if (data instanceof Uint8Array)
+        return new Uint8Array(data);
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    return null;
+}
+function findFirstGeneratedCFile(directory, prefix = '') {
+    for (const [name, node] of directory.contents || []) {
+        const nextPath = prefix ? `${prefix}/${name}` : name;
+        if (node?.contents) {
+            const nested = findFirstGeneratedCFile(node, nextPath);
+            if (nested)
+                return nested;
+            continue;
+        }
+        if (nextPath.endsWith('.c') && node?.data instanceof Uint8Array) {
+            return new Uint8Array(node.data);
+        }
+    }
+    return null;
+}
+async function translateFortranToC(code, activePath, workspaceFiles) {
+    if (!f2cModule)
+        throw new Error('Fortran runtime is not loaded.');
+    const inputPath = resolveInputPath(activePath);
+    const outputPath = `${stemOf(inputPath)}.c`;
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const host = createBrowserWasiHost({
+        args: [inputPath],
+        env: { TMPDIR: '/tmp' },
+        files: workspaceFilesForF2c(code, inputPath, workspaceFiles),
+        programName: 'f2c.wasm',
+        stdout: (chunk) => stdoutChunks.push(chunk),
+        stderr: (chunk) => stderrChunks.push(chunk)
+    });
+    const wasiInstance = new WASI(host.args, host.envEntries, host.fds, { debug: false });
+    const instance = (await WebAssembly.instantiate(f2cModule, {
+        wasi_snapshot_preview1: wasiInstance.wasiImport,
+        wasi_unstable: wasiInstance.wasiImport
+    }));
+    const exitCode = wasiInstance.start(instance);
+    const stdout = stdoutChunks.join('');
+    const stderr = stderrChunks.join('');
+    if (exitCode) {
+        throw new Error(`f2c exited with ${exitCode}${stderr ? `\n${stderr}` : ''}`);
+    }
+    const generated = readHostFileBytes(host, outputPath) || findFirstGeneratedCFile(host.rootDirectory);
+    if (!generated) {
+        throw new Error(`f2c did not produce ${outputPath}${stderr || stdout ? `\n${stderr}${stdout}` : ''}`);
+    }
+    return {
+        cPath: outputPath,
+        cSource: textDecoder.decode(generated)
+    };
+}
+async function compileAndLinkFortran(cPath, cSource, compileArgs = []) {
+    if (!clang)
+        throw new Error('Fortran clang backend is not loaded.');
+    const mainObj = `${stemOf(cPath)}.o`;
+    const compatObj = 'f2c_compat.o';
+    const wasmPath = `${stemOf(cPath)}.wasm`;
+    await clang.compile({
+        input: cPath,
+        code: cSource,
+        obj: mainObj,
+        language: 'C',
+        compileArgs: ['-I.', '-w', ...compileArgs]
+    });
+    await clang.compile({
+        input: 'f2c_compat.c',
+        code: F2C_COMPAT_SOURCE,
+        obj: compatObj,
+        language: 'C',
+        compileArgs: ['-w']
+    });
+    const stackSize = 1024 * 1024;
+    const libdir = 'lib/wasm32-wasi';
+    const compilerRuntimeLibDir = clang.compilerConfig?.compilerRuntimeLibDir || 'lib/clang/8.0.1/lib/wasi';
+    const lld = await clang.getModule(clang.assetUrls.lld);
+    await clang.run(lld, clang.log, 'wasm-ld', '--export-dynamic', '-z', `stack-size=${stackSize}`, `-L${libdir}/noeh`, `-L${libdir}`, `${libdir}/crt1.o`, mainObj, compatObj, 'libf2c.a', '-lc', '-lm', `-L${compilerRuntimeLibDir}`, '-lclang_rt.builtins-wasm32', '-o', wasmPath);
+    const bytes = Uint8Array.from(clang.memfs.getFileContents(wasmPath));
+    const wasm = await WebAssembly.compile(bytes);
+    return {
+        bytes,
+        wasm,
+        target: 'wasm32-wasi',
+        format: 'wasi-core-wasm',
+        fileName: wasmPath,
+        language: 'C'
+    };
+}
+self.onmessage = async (event) => {
+    if (handleWorkerAssetMessage(event.data))
+        return;
+    const { code, buffer, load, log, prepare, compileArgs, programArgs, activePath, workspaceFiles, stdin, clangAssets, fortranAssets } = event.data;
+    if (load) {
+        try {
+            await loadFortranRuntime(clangAssets, fortranAssets, log);
+            postMessage({ load: true });
+        }
+        catch (error) {
+            postMessage({ error: error.message });
+        }
+    }
+    else if (typeof log === 'boolean' && !code) {
+        if (clang)
+            clang.log = log;
+        if (typeof code === 'string')
+            postMessage({ results: true });
+    }
+    else if (code) {
+        if (!clang) {
+            postMessage({ error: 'Fortran runtime is not loaded.' });
+            return;
+        }
+        clang.log = log;
+        stdinBufferFortran = new Int32Array(buffer);
+        hasInitialStdinFortran = typeof stdin === 'string';
+        initialStdinFortran = hasInitialStdinFortran ? stdin : null;
+        initialStdinConsumedFortran = false;
+        try {
+            const translated = await translateFortranToC(code, activePath, workspaceFiles || []);
+            const artifact = await compileAndLinkFortran(translated.cPath, translated.cSource, compileArgs || []);
+            if (!prepare) {
+                const result = await executeBrowserClangArtifact(artifact, {
+                    args: programArgs || [],
+                    stdin: readProgramStdin,
+                    stdout: (output) => postMessage({ output }),
+                    stderr: (output) => postMessage({ output })
+                });
+                if (result.exitCode) {
+                    throw new Error(`Fortran program exited with ${result.exitCode}`);
+                }
+            }
+            postMessage({ results: true });
+        }
+        catch (error) {
+            postMessage({ error: error.message });
+        }
+    }
+};

package/dist/playground/worker/go.js

@@ -1,23 +1,36 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
+import { isSharedBufferBackedView } from '../sharedBuffer';
+import { instrumentGoDebugSource } from '../goDebugInstrumentation';
 self.document = {
     querySelectorAll() {
         return [];
     }
 };
 let stdinBufferGo = null;
+let debugBufferGo = null;
 let compilerUrl = '';
-let loadedCompilerUrl = '';
+let manifestUrl = '';
+let loadedCompilerKey = '';
+let compilerLimits;
 let compilerPromise = null;
 let compiledArtifact = null;
 let compiledCacheKey = '';
-async function loadCompiler(url) {
+async function loadCompiler(url, runtimeManifestUrl, limits) {
     if (!url) {
         throw new Error('Go runtime is not configured. Set PUBLIC_WASM_GO_COMPILER_URL or runtimeAssets.go.compilerUrl.');
     }
-    if (loadedCompilerUrl === url && compilerPromise) {
+    const compilerKey = [
+        url,
+        runtimeManifestUrl,
+        limits?.assetTimeoutMs ?? '',
+        limits?.compileTimeoutMs ?? '',
+        limits?.maxAssetBytes ?? '',
+        limits?.maxWasmMemoryBytes ?? ''
+    ].join('\n');
+    if (loadedCompilerKey === compilerKey && compilerPromise) {
         return await compilerPromise;
     }
-    loadedCompilerUrl = url;
+    loadedCompilerKey = compilerKey;
     compiledArtifact = null;
     compiledCacheKey = '';
     compilerPromise = (async () => {
@@ -34,7 +47,14 @@ async function loadCompiler(url) {
             throw new Error('wasm-go module must export executeBrowserGoArtifact');
         }
         return {
-            compiler: await factory(),
+            compiler: await factory({
+                ...(runtimeManifestUrl ? { runtimeManifestUrl } : {}),
+                assetTimeoutMs: limits?.assetTimeoutMs,
+                compileTimeoutMs: limits?.compileTimeoutMs,
+                linkTimeoutMs: limits?.compileTimeoutMs,
+                maxAssetBytes: limits?.maxAssetBytes,
+                maxWasmMemoryBytes: limits?.maxWasmMemoryBytes
+            }),
             executeBrowserGoArtifact: module.executeBrowserGoArtifact
         };
     })();
@@ -53,30 +73,180 @@ function normalizeDiagnostic(diagnostic) {
         message: String(diagnostic?.message || '')
     };
 }
+function normalizedBreakpointSet(values) {
+    return new Set([...(Array.isArray(values) ? values : [])]
+        .map((value) => Number(value))
+        .filter((value) => Number.isInteger(value) && value > 0));
+}
+function refreshGoDebugBreakpoints(state, control) {
+    const version = Atomics.load(control, 2);
+    if (state.breakpointVersion === version)
+        return;
+    state.breakpointVersion = version;
+    const count = Math.max(0, Math.min(Atomics.load(control, 3), control.length - 4));
+    const next = new Set();
+    for (let index = 0; index < count; index += 1) {
+        const line = Atomics.load(control, 4 + index);
+        if (Number.isInteger(line) && line > 0)
+            next.add(line);
+    }
+    state.breakpoints = next;
+}
+function parseGoDebugStack(stackJson, fallbackLine) {
+    try {
+        const stack = JSON.parse(stackJson);
+        if (Array.isArray(stack)) {
+            return stack
+                .map((frame) => ({
+                functionName: String(frame?.functionName || 'main'),
+                line: Math.max(1, Number(frame?.line || fallbackLine))
+            }))
+                .filter((frame) => frame.line > 0);
+        }
+    }
+    catch {
+        // Keep running even if user code corrupts the hook argument.
+    }
+    return [{ functionName: 'main', line: fallbackLine }];
+}
+function waitForGoDebugCommand(state, control, depth, line) {
+    let sequence = Atomics.load(control, 0);
+    while (true) {
+        Atomics.wait(control, 0, sequence, 100);
+        const command = Atomics.exchange(control, 1, 0);
+        if (!command) {
+            sequence = Atomics.load(control, 0);
+            continue;
+        }
+        state.resumeSkip = `${depth}:${line}`;
+        state.stepMode = null;
+        state.nextDepth = null;
+        state.nextLine = null;
+        state.stepOutDepth = null;
+        if (command === 2) {
+            state.stepMode = 'step';
+        }
+        else if (command === 3) {
+            state.stepMode = 'next';
+            state.nextDepth = depth;
+            state.nextLine = line;
+        }
+        else if (command === 4) {
+            state.stepMode = 'out';
+            state.stepOutDepth = Math.max(0, depth - 1);
+        }
+        return;
+    }
+}
+function createGoDebugHost(options) {
+    const state = {
+        breakpointVersion: Atomics.load(options.control, 2),
+        breakpoints: normalizedBreakpointSet(options.breakpoints),
+        pauseOnEntry: options.pauseOnEntry,
+        stepMode: null,
+        resumeSkip: null,
+        nextDepth: null,
+        nextLine: null,
+        stepOutDepth: null
+    };
+    const previousHook = globalThis.__wasmIdleGoDebugLine;
+    globalThis.__wasmIdleGoDebugLine = (rawLine, rawStackJson) => {
+        const line = Math.max(1, Number(rawLine || 1));
+        refreshGoDebugBreakpoints(state, options.control);
+        const callStack = parseGoDebugStack(String(rawStackJson || '[]'), line);
+        const depth = Math.max(1, callStack.length);
+        const skipKey = `${depth}:${line}`;
+        if (state.resumeSkip === skipKey)
+            return;
+        if (state.resumeSkip)
+            state.resumeSkip = null;
+        let reason = null;
+        if (state.pauseOnEntry) {
+            reason = 'entry';
+        }
+        else if (state.breakpoints.has(line)) {
+            reason = 'breakpoint';
+        }
+        else if (state.stepMode === 'step') {
+            reason = 'step';
+        }
+        else if (state.stepMode === 'next' &&
+            state.nextDepth !== null &&
+            depth <= state.nextDepth &&
+            line !== state.nextLine) {
+            reason = 'nextLine';
+        }
+        else if (state.stepMode === 'out' &&
+            state.stepOutDepth !== null &&
+            depth <= state.stepOutDepth) {
+            reason = 'stepOut';
+        }
+        if (!reason)
+            return;
+        state.pauseOnEntry = false;
+        state.stepMode = null;
+        state.nextDepth = null;
+        state.nextLine = null;
+        state.stepOutDepth = null;
+        postMessage({
+            debugEvent: {
+                type: 'pause',
+                line,
+                reason,
+                locals: [],
+                callStack
+            }
+        });
+        waitForGoDebugCommand(state, options.control, depth, line);
+    };
+    return () => {
+        if (previousHook === undefined) {
+            delete globalThis.__wasmIdleGoDebugLine;
+        }
+        else {
+            globalThis.__wasmIdleGoDebugLine = previousHook;
+        }
+    };
+}
 self.onmessage = async (event) => {
-    const { load, compilerUrl: nextCompilerUrl, buffer, code, prepare, args = [], target = 'wasip1/wasm', log } = event.data;
+    const { load, compilerUrl: nextCompilerUrl, manifestUrl: nextManifestUrl, runtimeLimits, buffer, debugBuffer, code, prepare, args = [], stdin, target = 'wasip1/wasm', log, debug = false, breakpoints = [], pauseOnEntry = false } = event.data;
     try {
         if (load) {
             compilerUrl = nextCompilerUrl;
+            manifestUrl = nextManifestUrl;
+            compilerLimits = runtimeLimits;
             if (log) {
                 console.log(`[wasm-idle:go-worker] load compilerUrl=${compilerUrl}`);
             }
-            await loadCompiler(compilerUrl);
+            await loadCompiler(compilerUrl, manifestUrl, compilerLimits);
             postMessage({ load: true });
             return;
         }
         stdinBufferGo = new Int32Array(buffer);
-        const runtime = await loadCompiler(compilerUrl);
-        const compileCacheKey = `${target}\n${code}`;
+        debugBufferGo = debugBuffer ? new Int32Array(debugBuffer) : null;
+        if (debug && (!debugBufferGo || !isSharedBufferBackedView(debugBufferGo))) {
+            postMessage({ error: 'Go debugging requires SharedArrayBuffer.' });
+            return;
+        }
+        const runtime = await loadCompiler(compilerUrl, manifestUrl, compilerLimits);
+        const effectiveTarget = debug ? 'js/wasm' : target;
+        const compileCode = debug ? instrumentGoDebugSource(code) : code;
+        const compileCacheKey = `${effectiveTarget}\n${compileCode}`;
         if (!compiledArtifact || compiledCacheKey !== compileCacheKey) {
+            postMessage({ phase: 'compile' });
             if (log) {
-                console.log(`[wasm-idle:go-worker] compile start prepare=${String(prepare)} target=${target} bytes=${code.length}`);
+                console.log(`[wasm-idle:go-worker] compile start prepare=${String(prepare)} target=${effectiveTarget} bytes=${compileCode.length}`);
             }
             const result = await runtime.compiler.compile({
-                code,
-                target,
+                code: compileCode,
+                target: effectiveTarget,
                 prepare,
                 log,
+                assetTimeoutMs: runtimeLimits?.assetTimeoutMs,
+                compileTimeoutMs: runtimeLimits?.compileTimeoutMs,
+                linkTimeoutMs: runtimeLimits?.compileTimeoutMs,
+                maxAssetBytes: runtimeLimits?.maxAssetBytes,
+                maxWasmMemoryBytes: runtimeLimits?.maxWasmMemoryBytes,
                 onProgress(progress) {
                     postMessage({ progress });
                 }
@@ -91,7 +261,9 @@ self.onmessage = async (event) => {
                 postMessage({ output: result.stdout });
             if (!result.success) {
                 throw new Error(result.stderr ||
-                    result.diagnostics?.map((diagnostic) => diagnostic.message).join('\n') ||
+                    result.diagnostics
+                        ?.map((diagnostic) => diagnostic.message)
+                        .join('\n') ||
                     'Go compilation failed');
             }
             if (result.stderr)
@@ -115,37 +287,71 @@ self.onmessage = async (event) => {
         if (log) {
             console.log(`[wasm-idle:go-worker] runtime start target=${compiledArtifact.target} format=${compiledArtifact.format}`);
         }
-        const execution = await runtime.executeBrowserGoArtifact(compiledArtifact, {
-            args,
-            env: {
-                USER: 'jungol'
-            },
-            stdin: () => {
-                const chunk = waitForBufferedStdin(stdinBufferGo, () => postMessage({ buffer: true }));
-                if (chunk == null) {
+        postMessage({ phase: 'execute' });
+        const restoreGoDebugHost = debug && debugBufferGo
+            ? createGoDebugHost({
+                control: debugBufferGo,
+                breakpoints,
+                pauseOnEntry: !!pauseOnEntry
+            })
+            : null;
+        const hasInitialStdin = typeof stdin === 'string';
+        let initialStdin = hasInitialStdin ? stdin : null;
+        let execution = null;
+        try {
+            execution = await runtime.executeBrowserGoArtifact(compiledArtifact, {
+                args,
+                runtimeManifestUrl: manifestUrl,
+                assetTimeoutMs: runtimeLimits?.assetTimeoutMs,
+                runTimeoutMs: runtimeLimits?.runTimeoutMs,
+                maxAssetBytes: runtimeLimits?.maxAssetBytes,
+                maxWasmMemoryBytes: runtimeLimits?.maxWasmMemoryBytes,
+                env: {
+                    USER: 'jungol'
+                },
+                stdin: () => {
+                    if (hasInitialStdin) {
+                        const chunk = initialStdin;
+                        initialStdin = null;
+                        if (log) {
+                            console.log(chunk == null
+                                ? '[wasm-idle:go-stdin] fd_read(bytes=0, eof=true)'
+                                : `[wasm-idle:go-stdin] fd_fill(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                        }
+                        return chunk;
+                    }
+                    const chunk = waitForBufferedStdin(stdinBufferGo, () => postMessage({ buffer: true }));
+                    if (chunk == null) {
+                        if (log) {
+                            console.log('[wasm-idle:go-stdin] fd_read(bytes=0, eof=true)');
+                        }
+                        return null;
+                    }
                     if (log) {
-                        console.log('[wasm-idle:go-stdin] fd_read(bytes=0, eof=true)');
+                        console.log(`[wasm-idle:go-stdin] fd_fill(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                    }
+                    return chunk;
+                },
+                stdout: (output) => {
+                    if (output) {
+                        postMessage({ output });
+                    }
+                },
+                stderr: (output) => {
+                    if (output) {
+                        postMessage({ output });
                     }
-                    return null;
-                }
-                if (log) {
-                    console.log(`[wasm-idle:go-stdin] fd_fill(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
-                }
-                return chunk;
-            },
-            stdout: (output) => {
-                if (output) {
-                    postMessage({ output });
-                }
-            },
-            stderr: (output) => {
-                if (output) {
-                    postMessage({ output });
                 }
-            }
-        });
+            });
+        }
+        finally {
+            restoreGoDebugHost?.();
+        }
         if (log) {
-            console.log(`[wasm-idle:go-worker] wasi run complete exitCode=${String(execution.exitCode)}`);
+            console.log(`[wasm-idle:go-worker] wasi run complete exitCode=${String(execution?.exitCode)}`);
+        }
+        if (!execution) {
+            throw new Error('Go program did not return an execution result');
         }
         if (execution.exitCode !== 0) {
             throw new Error(execution.stderr

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

@@ -0,0 +1,7 @@
+export declare function parseHaskellDiagnostics(output: string): {
+    fileName: string | null;
+    lineNumber: number;
+    columnNumber: number;
+    severity: string;
+    message: string;
+}[];