wasm-idle 1.1.0 → 1.1.2

package/dist/playground/wasmTinyGoVersion.js

@@ -46,7 +46,7 @@ export const WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
     schemaVersion: 1,
     format: WASM_TINYGO_EXECUTABLE_GRAPH_FORMAT,
     entryPath: 'upstream.js',
-    fingerprint: '8ecbffd4b4e44ff67288d8c46328a1b06d0a0ac76d7a50a9e458603b68d0d795',
+    fingerprint: '8b2e87ec50b586591903adcff8c547b37c3b23d4e12f97d8266035cefdeebac4',
     modules: Object.freeze({
         'assets/upstream-binaryen-59aad93503b5fd53.wasm.gz.bin': Object.freeze({
             bytes: 2366782,
@@ -55,14 +55,9 @@ export const WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
             uncompressedSha256: '59aad93503b5fd539993f2f5571c11dce9ddb4c5d10b681abc8e5dc124aed526',
             imports: Object.freeze([])
         }),
-        'assets/upstream-compile-worker-CFw6Ych6.js': Object.freeze({
-            bytes: 558,
-            sha256: '03a76345c69f8bd751dac18894f65c0918f1690fbbb661f38052819cd5ae8209',
-            imports: Object.freeze([])
-        }),
-        'assets/upstream-compile-worker-CUrboB1_.js': Object.freeze({
-            bytes: 103559,
-            sha256: '42337c2f06d04b51d79f0ec66ae685f0cfb2a78718b0636df980dc92dd1db9d5',
+        'assets/upstream-compile-worker-6CYe8gHb.js': Object.freeze({
+            bytes: 105574,
+            sha256: '30c6b0d3f0968222e0d78f7ec54300838eca0326558e448bc48ab213e35aae2f',
             imports: Object.freeze([
                 Object.freeze({
                     specifier: './upstream-compile-worker-CeYS3ydo.js',
@@ -71,6 +66,11 @@ export const WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
                 })
             ])
         }),
+        'assets/upstream-compile-worker-CFw6Ych6.js': Object.freeze({
+            bytes: 558,
+            sha256: '03a76345c69f8bd751dac18894f65c0918f1690fbbb661f38052819cd5ae8209',
+            imports: Object.freeze([])
+        }),
         'assets/upstream-compile-worker-CeYS3ydo.js': Object.freeze({
             bytes: 181175,
             sha256: 'faa2bf6a310cd23991babde1fb62cd34253d692fee03029fe3508eae4c24b1c0',
@@ -104,16 +104,16 @@ export const WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
             ])
         }),
         'upstream.js': Object.freeze({
-            bytes: 126073,
-            sha256: '136a957aa940c3e2b8c7a925eb538f3fce81f699aa9113e1fd93ce0b35c879aa',
+            bytes: 126235,
+            sha256: 'b780e6d7492c60f9c7481eda0b3ef45be15887ee367b8728532e824a4592e3b1',
             imports: Object.freeze([
                 Object.freeze({
-                    specifier: 'assets/upstream-compile-worker-CUrboB1_.js',
-                    target: 'assets/upstream-compile-worker-CUrboB1_.js',
+                    specifier: 'assets/upstream-compile-worker-6CYe8gHb.js',
+                    target: 'assets/upstream-compile-worker-6CYe8gHb.js',
                     kind: 'worker'
                 })
             ])
         })
     })
 });
-export const WASM_TINYGO_ASSET_VERSION = '0b2e827ae219eecc806d4118ee4a2b6032adbe7a960e6c0e471c4491d9a1f2f3';
+export const WASM_TINYGO_ASSET_VERSION = '43cb86856c8d017a66529bbed945b564b3c6a8d6a59bf3e98afb47d1ac25f8f2';

package/dist/playground/wasmTypeScriptVersion.d.ts

@@ -1,9 +1,9 @@
-export declare const WASM_TYPESCRIPT_ASSET_VERSION = "2d968f66f878ce33";
+export declare const WASM_TYPESCRIPT_ASSET_VERSION = "e48868a1d3851320";
 export declare const WASM_TYPESCRIPT_MODULE_RECEIPT: Readonly<{
-    bytes: 3759064;
-    sha256: "2c8942b6383d25d4582e9db0ee38d85b61eb8016f16e57c840f3c20af9ac848b";
+    bytes: 3882154;
+    sha256: "df071064e3d1e8ce1c5bae87853db00021681d069b3ef046a884b95fa58eadfe";
 }>;
 export declare const WASM_JAVASCRIPT_MODULE_RECEIPT: Readonly<{
-    bytes: 35866;
-    sha256: "21b176cfe1ce4d39519979422bd1b3b598f183e9b3fe042ecc8cc37a535c3608";
+    bytes: 158899;
+    sha256: "9e2df469ef3934424fba004bb66b5a3b042ecaf1ad3496789ac8fe8e67389d65";
 }>;

package/dist/playground/wasmTypeScriptVersion.js

@@ -1,9 +1,9 @@
-export const WASM_TYPESCRIPT_ASSET_VERSION = '2d968f66f878ce33';
+export const WASM_TYPESCRIPT_ASSET_VERSION = 'e48868a1d3851320';
 export const WASM_TYPESCRIPT_MODULE_RECEIPT = Object.freeze({
-    bytes: 3759064,
-    sha256: '2c8942b6383d25d4582e9db0ee38d85b61eb8016f16e57c840f3c20af9ac848b'
+    bytes: 3882154,
+    sha256: 'df071064e3d1e8ce1c5bae87853db00021681d069b3ef046a884b95fa58eadfe'
 });
 export const WASM_JAVASCRIPT_MODULE_RECEIPT = Object.freeze({
-    bytes: 35866,
-    sha256: '21b176cfe1ce4d39519979422bd1b3b598f183e9b3fe042ecc8cc37a535c3608'
+    bytes: 158899,
+    sha256: '9e2df469ef3934424fba004bb66b5a3b042ecaf1ad3496789ac8fe8e67389d65'
 });

package/dist/playground/worker/cachedClangCompile.js

@@ -1,7 +1,8 @@
-import { BrowserClangRuntime, loadRuntimeManifest, resolveRuntimeManifestUrl } from '@wasm-idle/llvm-core/clang';
+import { BrowserClangRuntime, loadRuntimeManifest, extractCompilerDiagnostics, resolveRuntimeManifestUrl } from '@wasm-idle/llvm-core/clang';
 import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
 import { compileWorkerRuntimeAsset } from './runtimeModule';
 import { BUNDLED_CLANG_ASSET_INTEGRITY, BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES } from '../clangAssetIntegrity';
+import { OutputLimitError, resolveExecutionLimits } from '@wasm-idle/core';
 const worker = globalThis;
 let started = false;
 worker.onmessage = async ({ data }) => {
@@ -11,8 +12,36 @@ worker.onmessage = async ({ data }) => {
         return;
     started = true;
     const output = [];
+    const encoder = new TextEncoder();
+    let outputBytes = 0;
+    let outputLimitError;
+    const controller = new AbortController();
     let runtime;
     try {
+        const maxOutputBytes = resolveExecutionLimits(data.maxOutputBytes === undefined ? {} : { maxOutputBytes: data.maxOutputBytes }).maxOutputBytes;
+        const checkOutputBytes = (additionalBytes) => {
+            if (outputLimitError)
+                throw outputLimitError;
+            const actual = outputBytes + additionalBytes;
+            if (actual <= maxOutputBytes)
+                return;
+            outputLimitError = new OutputLimitError(`Compiler output exceeded ${maxOutputBytes} bytes`, { limit: maxOutputBytes, actual, phase: 'compile' });
+            const stdout = output.join('');
+            // Report before retaining a chunk, including temporarily buffered PCH diagnostics.
+            worker.postMessage({
+                type: 'error',
+                error: outputLimitError.message,
+                code: 'output-limit',
+                limit: maxOutputBytes,
+                actual,
+                stdout,
+                diagnostics: extractCompilerDiagnostics(stdout),
+                stderr: ''
+            });
+            // A header builder can recover close-time stream errors; prevent its cache write too.
+            controller.abort(outputLimitError);
+            throw outputLimitError;
+        };
         if (data.request.debug || (data.request.debugMode && data.request.debugMode !== 'none')) {
             throw new Error('Cached C/C++ execution does not support debug artifacts.');
         }
@@ -53,8 +82,16 @@ worker.onmessage = async ({ data }) => {
             maxAssetBytes: data.maxAssetBytes,
             manifest,
             persistentCache: data.persistentCache,
+            signal: controller.signal,
             log: data.log ?? false,
-            stdout: (chunk) => output.push(chunk),
+            stdout: (chunk) => {
+                if (!chunk)
+                    return;
+                const bytes = encoder.encode(chunk).byteLength;
+                checkOutputBytes(bytes);
+                outputBytes += bytes;
+                output.push(chunk);
+            },
             progress: (value) => worker.postMessage({
                 type: 'progress',
                 progress: {
@@ -79,9 +116,12 @@ worker.onmessage = async ({ data }) => {
         });
         const artifact = await runtime.compileArtifact(data.request.code, {
             ...data.request,
+            onBufferedOutput: checkOutputBytes,
             persistentCache: data.persistentCache,
             precompiledHeader: data.precompiledHeader
         });
+        if (outputLimitError)
+            return;
         if (runtime.usedPrecompiledHeader)
             worker.postMessage({
                 type: 'progress',
@@ -93,19 +133,25 @@ worker.onmessage = async ({ data }) => {
                     message: 'Compiled with precompiled <bits/stdc++.h>'
                 }
             });
+        const stdout = output.join('');
         worker.postMessage({
             type: 'compiled',
             artifact,
-            stdout: output.join(''),
+            stdout,
+            diagnostics: extractCompilerDiagnostics(stdout),
             stderr: '',
             ...buildingPrecompiledHeader(runtime)
         });
     }
     catch (error) {
+        if (outputLimitError)
+            return;
+        const stdout = output.join('');
         worker.postMessage({
             type: 'error',
             error: error instanceof Error ? error.message : String(error),
-            stdout: output.join(''),
+            stdout,
+            diagnostics: extractCompilerDiagnostics(stdout),
             stderr: '',
             ...buildingPrecompiledHeader(runtime)
         });
@@ -114,6 +160,8 @@ worker.onmessage = async ({ data }) => {
     // headers, prepares <bits/stdc++.h> for the next compile.
     if (runtime && buildingPrecompiledHeader(runtime).precompiledHeader) {
         const header = await runtime.buildPrecompiledHeader().catch(() => undefined);
+        if (outputLimitError)
+            return;
         worker.postMessage({ type: 'precompiled-header', header }, header ? [header.bytes.buffer] : []);
     }
 };

package/dist/playground/worker/cachedClangExecute.js

@@ -13,19 +13,20 @@ worker.onmessage = async ({ data }) => {
             : new Uint8Array(data.inputBuffer, CLANG_STDIN_HEADER_BYTES);
         if (payload && payload.byteLength === 0)
             throw new Error('C/C++ stdin buffer is empty.');
-        const files = (data.workspaceFiles || []).map(({ path, content }) => ({
-            path,
-            contents: content
-        }));
+        const activePath = data.activePath || (data.artifact.language === 'C' ? 'main.c' : 'main.cc');
+        const files = (data.workspaceFiles || [])
+            .filter(({ path }) => data.code === undefined || path !== activePath)
+            .map(({ path, content }) => ({ path, contents: content }));
         if (data.code !== undefined) {
             files.push({
-                path: data.activePath || (data.artifact.language === 'C' ? 'main.c' : 'main.cc'),
+                path: activePath,
                 contents: data.code
             });
         }
         // The public executor creates a fresh WASI host, files, descriptors and Wasm
         // instance. Only the immutable compiled Module is reused across executions.
         const result = await executeBrowserClangArtifact(data.artifact, {
+            maxWasmMemoryBytes: data.maxWasmMemoryBytes,
             args: data.programArgs,
             env: data.env,
             files,

package/dist/playground/worker/clang.js

@@ -19,6 +19,25 @@ function missingPrecompiledHeader() {
 function postProgress(percent, stage) {
     postMessage({ progress: { percent, stage } });
 }
+function normalizeLldbWorkspaceFiles(files) {
+    // Both compiler phases and LLDB accept text; retain BOMs and original FS bytes.
+    const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+    return files.map((file) => {
+        let content = file.content;
+        if (typeof content !== 'string') {
+            const path = `/workspace/${normalizeDwarfWorkspacePath(file.path)}`;
+            if (!(content instanceof Uint8Array))
+                throw new TypeError(`LLDB workspace file content must be a string or Uint8Array: ${path}`);
+            try {
+                content = decoder.decode(content);
+            }
+            catch (cause) {
+                throw new Error(`LLDB workspace file is not valid UTF-8: ${path}`, { cause });
+            }
+        }
+        return { ...file, content };
+    });
+}
 async function loadClang(path, log, maxAssetBytes, verifiedStreaming = false, languageSysrootProfiles = false, persistentCache) {
     const { BrowserClangRuntime, loadRuntimeManifest, resolveRuntimeManifestUrl } = await import('@wasm-idle/llvm-core/clang');
     const manifest = await loadRuntimeManifest(resolveRuntimeManifestUrl(path), fetch, undefined, maxAssetBytes);
@@ -106,7 +125,9 @@ self.onmessage = async (event) => {
                 compileArgs,
                 programArgs,
                 activePath,
-                workspaceFiles,
+                workspaceFiles: resolvedDebugMode === 'lldb'
+                    ? normalizeLldbWorkspaceFiles(workspaceFiles || [])
+                    : workspaceFiles,
                 cppVersion,
                 cVersion,
                 debugMode: resolvedDebugMode,
@@ -143,12 +164,21 @@ self.onmessage = async (event) => {
         }
         try {
             if (resolvedDebugMode === 'lldb') {
+                const inputPath = normalizeDwarfWorkspacePath(activePath || (language === 'C' ? 'main.c' : 'main.cc')) || (language === 'C' ? 'main.c' : 'main.cc');
+                const sources = new Map();
+                const compilerWorkspaceFiles = normalizeLldbWorkspaceFiles(workspaceFiles || []);
+                for (const file of compilerWorkspaceFiles) {
+                    const sourcePath = normalizeDwarfWorkspacePath(file.path);
+                    if (sourcePath)
+                        sources.set(`/workspace/${sourcePath}`, file.content);
+                }
+                sources.set(`/workspace/${inputPath}`, code);
                 const artifact = await clang.compileArtifact(code, {
                     language,
                     compileArgs,
                     programArgs,
                     activePath,
-                    workspaceFiles,
+                    workspaceFiles: compilerWorkspaceFiles,
                     cppVersion,
                     cVersion,
                     debugMode: 'lldb',
@@ -158,14 +188,6 @@ self.onmessage = async (event) => {
                 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),

package/dist/playground/worker/cobol.js

@@ -51,7 +51,7 @@ self.onmessage = async (event) => {
             postMessage({ load: true });
         }
         catch (error) {
-            postMessage({ error: error.message });
+            postMessage({ error: error?.message || String(error) });
         }
     }
     else if (typeof log === 'boolean' && !code) {
@@ -101,7 +101,7 @@ self.onmessage = async (event) => {
             postMessage({ results: true });
         }
         catch (error) {
-            postMessage({ error: error.message });
+            postMessage({ error: error?.message || String(error) });
         }
     }
 };

package/dist/playground/worker/d.js

@@ -1,12 +1,13 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
 import { loadVerifiedDOuterAssets, snapshotDOuterAssetConfig } from '../dOuterAssets';
-import { createRuntimeAssetsKey, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { createRuntimeAssetsKey, requestRuntimeWasmModule, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
 let stdinBufferD = null;
 let runtimeConfig = null;
 let loadedRuntimeKey = '';
 let runtimePromise = null;
 let compiledArtifact = null;
 let compiledCacheKey = '';
+let compilerModulePorts;
 async function loadRuntime(config) {
     const snapshot = snapshotDOuterAssetConfig(config);
     const runtimeKey = createRuntimeAssetsKey({ d: snapshot });
@@ -56,7 +57,13 @@ async function loadRuntime(config) {
             compiler: await factory({
                 runtimeBaseUrl: runtimeBaseUrl.href,
                 manifest,
-                verifyRuntimeAssetIntegrity
+                verifyRuntimeAssetIntegrity,
+                compileModule(kind, bytes, signal) {
+                    const port = compilerModulePorts?.[kind];
+                    return port
+                        ? requestRuntimeWasmModule(Uint8Array.from(bytes), port, { signal })
+                        : WebAssembly.compile(Uint8Array.from(bytes).buffer);
+                }
             }),
             executeBrowserDArtifact: module.executeBrowserDArtifact
         };
@@ -102,6 +109,7 @@ self.onmessage = async (event) => {
             return;
         }
         stdinBufferD = new Int32Array(buffer);
+        compilerModulePorts = event.data.compilerModulePorts;
         if (!runtimeConfig)
             throw new Error('D runtime has not been loaded');
         const runtime = await loadRuntime(runtimeConfig);
@@ -185,9 +193,8 @@ self.onmessage = async (event) => {
             }
         });
         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}`);
+            // stderr was already streamed to the terminal above.
+            throw new Error(`D program exited with code ${execution.exitCode}`);
         }
         postMessage({ results: true });
     }

package/dist/playground/worker/fortran.js

@@ -250,7 +250,7 @@ self.onmessage = async (event) => {
             postMessage({ load: true });
         }
         catch (error) {
-            postMessage({ error: error.message });
+            postMessage({ error: error?.message || String(error) });
         }
     }
     else if (typeof log === 'boolean' && !code) {
@@ -286,7 +286,7 @@ self.onmessage = async (event) => {
             postMessage({ results: true });
         }
         catch (error) {
-            postMessage({ error: error.message });
+            postMessage({ error: error?.message || String(error) });
         }
     }
 };

package/dist/playground/worker/go.js

@@ -210,6 +210,7 @@ function createGoDebugHost(options) {
 }
 self.onmessage = async (event) => {
     const { load, compilerUrl: nextCompilerUrl, manifestUrl: nextManifestUrl, runtimeLimits, buffer, debugBuffer, code, prepare, args = [], stdin, target = 'wasip1/wasm', log, debug = false, breakpoints = [], pauseOnEntry = false } = event.data;
+    let abandonedJsWasmRun = false;
     try {
         if (load) {
             compilerUrl = nextCompilerUrl;
@@ -344,8 +345,16 @@ self.onmessage = async (event) => {
                 }
             });
         }
+        catch (error) {
+            // wasm_exec.js runs js/wasm programs on this worker's event loop, so a rejected
+            // run (such as an expired runtime deadline) may still be running here.
+            abandonedJsWasmRun = effectiveTarget === 'js/wasm';
+            throw error;
+        }
         finally {
-            restoreGoDebugHost?.();
+            // The abandoned program may still call the hook until the host discards this worker.
+            if (!abandonedJsWasmRun)
+                restoreGoDebugHost?.();
         }
         if (log) {
             console.log(`[wasm-idle:go-worker] wasi run complete exitCode=${String(execution?.exitCode)}`);
@@ -354,9 +363,8 @@ self.onmessage = async (event) => {
             throw new Error('Go program did not return an execution result');
         }
         if (execution.exitCode !== 0) {
-            throw new Error(execution.stderr
-                ? `Go program exited with code ${execution.exitCode}\n${execution.stderr}`
-                : `Go program exited with code ${execution.exitCode}`);
+            // stderr was already streamed to the terminal above.
+            throw new Error(`Go program exited with code ${execution.exitCode}`);
         }
         postMessage({ results: true });
     }
@@ -364,6 +372,9 @@ self.onmessage = async (event) => {
         if (log) {
             console.error('[wasm-idle:go-worker] failed', error);
         }
-        postMessage({ error: error?.message || String(error) });
+        postMessage({
+            error: error?.message || String(error),
+            ...(abandonedJsWasmRun ? { fatal: true } : {})
+        });
     }
 };

package/dist/playground/worker/haskell.js

@@ -99,7 +99,7 @@ function outputLine(line) {
     postMessage({ output: line.endsWith('\n') ? line : `${line}\n` });
 }
 function remapDiagnosticPath(line) {
-    const match = /^(.*?)(:\d+:\d+:\s+(?:error|warning):)/i.exec(line);
+    const match = /^(.*?)(:(?:\d+:\d+(?:-\d+)?|\(\d+,\d+\)-\(\d+,\d+\)):\s+(?:error|warning):)/i.exec(line);
     if (!match)
         return line;
     const workspacePath = activeDiagnosticPaths?.get(match[1]);
@@ -264,10 +264,12 @@ export function parseHaskellDiagnostics(output) {
     const diagnostics = [];
     const lines = output.split(/\r\n|\r|\n/);
     for (let index = 0; index < lines.length; index += 1) {
-        const match = /^(.*?):(\d+):(\d+):\s+(error|warning):\s*(.*)$/i.exec(lines[index]);
+        // GHC locations are `l:c`, `l:c-c`, or `(l,c)-(l,c)`.
+        const match = /^(.*?):(?:(\d+):(\d+)(?:-\d+)?|\((\d+),(\d+)\)-\(\d+,\d+\)):\s+(error|warning):\s*(.*)$/i.exec(lines[index]);
         if (!match)
             continue;
-        let message = match[5].trim();
+        // GHC 9.6+ prefixes the message with tags such as `[GHC-88464] [-Wunused-top-binds]`.
+        let message = match[7].replace(/^(?:\[(?:GHC-\d+|-W[^\]]*)\]\s*)*/, '').trim();
         if (!message) {
             for (const extraLine of lines.slice(index + 1)) {
                 const trimmed = extraLine.trim();
@@ -279,9 +281,9 @@ export function parseHaskellDiagnostics(output) {
         }
         diagnostics.push({
             fileName: match[1] || null,
-            lineNumber: Math.max(1, Number(match[2] || 1)),
-            columnNumber: Math.max(1, Number(match[3] || 1)),
-            severity: match[4].toLowerCase() === 'warning' ? 'warning' : 'error',
+            lineNumber: Math.max(1, Number(match[2] || match[4] || 1)),
+            columnNumber: Math.max(1, Number(match[3] || match[5] || 1)),
+            severity: match[6].toLowerCase() === 'warning' ? 'warning' : 'error',
             message: message || lines[index]
         });
     }
@@ -447,7 +449,8 @@ self.onmessage = async (event) => {
             for (const diagnostic of parseHaskellDiagnostics(stderrText)) {
                 postMessage({ diagnostic });
             }
-            throw new Error(stderrText.trim() || formatError(error), { cause: error });
+            // The host stderr callback already streamed stderrText to the terminal.
+            throw new Error(formatError(error), { cause: error });
         }
         finally {
             activeStderrCollector = null;