wasm-idle 1.0.5 → 1.0.6

package/dist/playground/worker/assets.js

@@ -14,6 +14,7 @@ let activeDirectAssetUrls = new Map();
 let interceptorsInstalled = false;
 let nextAssetRequestId = 0;
 const pendingAssetRequests = new Map();
+const pendingModuleRequests = new Map();
 const cancelResponseBody = (response, reason) => {
     try {
         void Promise.resolve(response.body?.cancel(reason)).catch(() => undefined);
@@ -441,6 +442,10 @@ export function configureWorkerRuntimeAssets(config) {
         (!Number.isSafeInteger(config.maxAssetBytes) || config.maxAssetBytes <= 0)) {
         throw new TypeError('Runtime asset maxAssetBytes must be a positive safe integer');
     }
+    for (const pending of pendingModuleRequests.values()) {
+        pending.reject(new Error('Runtime module configuration changed'));
+    }
+    pendingModuleRequests.clear();
     activeDirectAssetBaseUrl = null;
     activeDirectAssetUrls = new Map();
     activeConfig = config;
@@ -508,6 +513,20 @@ export function handleWorkerAssetMessage(data) {
     const response = data?.assetResponse;
     if (!response)
         return false;
+    const moduleRequest = pendingModuleRequests.get(response.id);
+    if (moduleRequest) {
+        pendingModuleRequests.delete(response.id);
+        if (!response.ok) {
+            moduleRequest.reject(new Error(response.error || 'Runtime module request failed'));
+        }
+        else if (!(response.module instanceof WebAssembly.Module)) {
+            moduleRequest.reject(new Error('Runtime module response is invalid'));
+        }
+        else {
+            moduleRequest.resolve(response.module);
+        }
+        return true;
+    }
     const pending = pendingAssetRequests.get(response.id);
     if (!pending)
         return true;
@@ -531,3 +550,25 @@ export async function loadWorkerRuntimeAsset(asset) {
     }
     return await loadTrackedAsset(assetUrl);
 }
+export function hasWorkerRuntimeModuleBridge() {
+    return activeConfig?.useAssetBridge === true || activeConfig?.useModuleBridge === true;
+}
+export async function loadWorkerRuntimeModule(asset) {
+    if (!hasWorkerRuntimeModuleBridge())
+        throw new Error('Runtime module bridge unavailable');
+    const assetUrl = trackedAssetUrl(asset);
+    if (!assetUrl || !isTrackedAssetUrl(assetUrl)) {
+        throw new Error('Untracked runtime module request');
+    }
+    const id = ++nextAssetRequestId;
+    return await new Promise((resolve, reject) => {
+        pendingModuleRequests.set(id, { resolve, reject });
+        try {
+            self.postMessage({ assetRequest: { id, asset, module: true } });
+        }
+        catch (error) {
+            pendingModuleRequests.delete(id);
+            reject(error);
+        }
+    });
+}

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

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

package/dist/playground/worker/cachedClangCompile.js

@@ -0,0 +1,85 @@
+import { BrowserClangRuntime, loadRuntimeManifest, resolveRuntimeManifestUrl } from '@wasm-idle/llvm-core/clang';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
+import { compileWorkerRuntimeAsset } from './runtimeModule';
+import { BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES } from '../clangAssetIntegrity';
+const worker = globalThis;
+let started = false;
+worker.onmessage = async ({ data }) => {
+    if (handleWorkerAssetMessage(data))
+        return;
+    if (started)
+        return;
+    started = true;
+    const output = [];
+    try {
+        if (data.request.debug || (data.request.debugMode && data.request.debugMode !== 'none')) {
+            throw new Error('Cached C/C++ execution does not support debug artifacts.');
+        }
+        configureWorkerRuntimeAssets(data.assets);
+        const manifest = await loadRuntimeManifest(resolveRuntimeManifestUrl(data.runtimeBaseUrl), fetch, undefined, data.maxAssetBytes);
+        if (data.languageSysroots)
+            manifest.compiler.sysroot.profiles = BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES;
+        const moduleAssets = new Map([
+            [
+                manifest.compiler.clang.asset,
+                new URL(manifest.compiler.clang.asset, data.runtimeBaseUrl).href
+            ],
+            [
+                manifest.compiler.lld.asset,
+                new URL(manifest.compiler.lld.asset, data.runtimeBaseUrl).href
+            ]
+        ].map(([asset, url]) => [url, asset]));
+        class CachedRuntime extends BrowserClangRuntime {
+            async getModule(url, progress, signal) {
+                const asset = moduleAssets.get(url);
+                if (!asset)
+                    return super.getModule(url, progress, signal);
+                signal?.throwIfAborted();
+                const module = await compileWorkerRuntimeAsset(asset);
+                signal?.throwIfAborted();
+                progress?.set?.(1);
+                return module;
+            }
+        }
+        // Every source cache miss gets fresh compiler memory and files. The host
+        // session keeps the immutable tool Modules and verified asset bytes alive.
+        const runtime = new CachedRuntime({
+            runtimeBaseUrl: data.runtimeBaseUrl,
+            maxAssetBytes: data.maxAssetBytes,
+            manifest,
+            log: data.log ?? false,
+            stdout: (chunk) => output.push(chunk),
+            progress: (value) => worker.postMessage({
+                type: 'progress',
+                progress: {
+                    stage: 'bootstrap',
+                    completed: Math.round(value * 100),
+                    total: 100,
+                    percent: value * 100,
+                    message: 'Loading compiler runtime'
+                }
+            })
+        });
+        await runtime.ready;
+        worker.postMessage({
+            type: 'progress',
+            progress: {
+                stage: 'compile',
+                completed: 0,
+                total: 100,
+                percent: 0,
+                message: 'Compiling source'
+            }
+        });
+        const artifact = await runtime.compileArtifact(data.request.code, data.request);
+        worker.postMessage({ type: 'compiled', artifact, stdout: output.join(''), stderr: '' });
+    }
+    catch (error) {
+        worker.postMessage({
+            type: 'error',
+            error: error instanceof Error ? error.message : String(error),
+            stdout: output.join(''),
+            stderr: ''
+        });
+    }
+};

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

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

package/dist/playground/worker/cachedClangExecute.js

@@ -0,0 +1,67 @@
+import { executeBrowserClangArtifact } from '@wasm-idle/llvm-core/clang';
+import { CLANG_STDIN_DATA, CLANG_STDIN_EOF, CLANG_STDIN_HEADER_BYTES, CLANG_STDIN_WAITING } from '../clangWorkerProtocol';
+const worker = globalThis;
+worker.onmessage = async ({ data }) => {
+    worker.onmessage = null;
+    try {
+        const hasStaticInput = typeof data.stdin === 'string';
+        let staticInput = hasStaticInput ? new TextEncoder().encode(data.stdin) : null;
+        let reachedEof = false;
+        const control = hasStaticInput ? null : new Int32Array(data.inputBuffer, 0, 2);
+        const payload = hasStaticInput
+            ? null
+            : 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
+        }));
+        if (data.code !== undefined) {
+            files.push({
+                path: data.activePath || (data.artifact.language === 'C' ? 'main.c' : 'main.cc'),
+                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, {
+            args: data.programArgs,
+            env: data.env,
+            files,
+            stdin: () => {
+                if (hasStaticInput) {
+                    const next = staticInput;
+                    staticInput = null;
+                    return next?.byteLength ? next : null;
+                }
+                if (reachedEof)
+                    return null;
+                Atomics.store(control, 0, CLANG_STDIN_WAITING);
+                worker.postMessage({ type: 'stdin' });
+                while (Atomics.load(control, 0) === CLANG_STDIN_WAITING) {
+                    Atomics.wait(control, 0, CLANG_STDIN_WAITING);
+                }
+                const state = Atomics.load(control, 0);
+                if (state === CLANG_STDIN_EOF) {
+                    reachedEof = true;
+                    return null;
+                }
+                const length = Atomics.load(control, 1);
+                if (state !== CLANG_STDIN_DATA || length < 0 || length > payload.byteLength) {
+                    throw new Error('Invalid C/C++ stdin buffer response.');
+                }
+                return payload.slice(0, length);
+            },
+            stdout: (output) => worker.postMessage({ type: 'output', output }),
+            stderr: (output) => worker.postMessage({ type: 'output', output })
+        });
+        worker.postMessage({ type: 'done', exitCode: result.exitCode });
+    }
+    catch (error) {
+        worker.postMessage({
+            type: 'error',
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+};

package/dist/playground/worker/clang.js

@@ -30,9 +30,7 @@ async function loadClang(path, log, maxAssetBytes, verifiedStreaming = false, la
             }
         }
         : manifest;
-    const Runtime = verifiedStreaming
-        ? withVerifiedStreaming(BrowserClangRuntime, path, maxAssetBytes)
-        : BrowserClangRuntime;
+    const Runtime = withVerifiedStreaming(BrowserClangRuntime, path, maxAssetBytes, verifiedStreaming);
     clang = new Runtime({
         stdout: (output) => postMessage({ output }),
         onDebugEvent: (debugEvent) => postMessage({ debugEvent }),

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

@@ -1,3 +1,3 @@
 import type { BrowserClangRuntime } from '@wasm-idle/llvm-core/clang';
 /** Application-only adapter. The host opts in only for the built-in trust profile. */
-export declare function withVerifiedStreaming(Runtime: typeof BrowserClangRuntime, baseUrl: string, maxAssetBytes?: number): typeof BrowserClangRuntime;
+export declare function withVerifiedStreaming(Runtime: typeof BrowserClangRuntime, baseUrl: string, maxAssetBytes?: number, verifiedStreaming?: boolean): typeof BrowserClangRuntime;

package/dist/playground/worker/clangStreaming.js

@@ -1,17 +1,35 @@
 import { compileVerifiedWasmAsset } from '@wasm-idle/llvm-core/core/verified-wasm';
 import { BUNDLED_CLANG_ASSET_INTEGRITY } from '../clangAssetIntegrity';
+import { hasWorkerRuntimeModuleBridge } from './assets';
+import { compileWorkerRuntimeAsset } from './runtimeModule';
 // Capture before configureWorkerRuntimeAssets installs its whole-buffer fetch shim.
 const nativeFetch = globalThis.fetch?.bind(globalThis);
 const toolNames = ['bin/clang.wasm.gz', 'bin/lld.wasm.gz'];
 /** Application-only adapter. The host opts in only for the built-in trust profile. */
-export function withVerifiedStreaming(Runtime, baseUrl, maxAssetBytes = 128 * 1024 * 1024) {
-    if (!nativeFetch || !globalThis.crypto?.subtle || typeof DecompressionStream !== 'function')
+export function withVerifiedStreaming(Runtime, baseUrl, maxAssetBytes = 128 * 1024 * 1024, verifiedStreaming = true) {
+    const bridgeModules = hasWorkerRuntimeModuleBridge();
+    if (!bridgeModules &&
+        (!verifiedStreaming ||
+            !nativeFetch ||
+            !globalThis.crypto?.subtle ||
+            typeof DecompressionStream !== 'function'))
         return Runtime;
     const urls = new Map(toolNames.map((name) => [new URL(name, baseUrl).href, name]));
     // Scope the two immutable tool modules to this one runtime construction, not globals.
     const loads = new Map();
     return class extends Runtime {
         async getModule(url, progress, signal) {
+            if (bridgeModules) {
+                const root = new URL(baseUrl);
+                const target = new URL(url, root);
+                if (target.origin === root.origin && target.pathname.startsWith(root.pathname)) {
+                    signal?.throwIfAborted();
+                    const module = await compileWorkerRuntimeAsset(`${target.pathname.slice(root.pathname.length)}${target.search}`);
+                    signal?.throwIfAborted();
+                    progress?.set?.(1);
+                    return module;
+                }
+            }
             const name = urls.get(url);
             if (!name)
                 return super.getModule(url, progress, signal);

package/dist/playground/worker/python.js

@@ -1,6 +1,7 @@
 import { flushQueuedStdin, readBufferedStdin, waitForBufferedStdin } from '../stdinBuffer';
 import { isSharedBufferBackedView } from '../sharedBuffer';
 import { parsePythonPackageLock } from '../pythonPackageLock';
+import { withCachedPyodideModule } from './runtimeModule';
 import { configureWorkerRuntimeAssetAllowlist, configureWorkerRuntimeAssets, handleWorkerAssetMessage, loadWorkerRuntimeAsset } from './assets';
 self.document = {
     querySelector() {
@@ -215,11 +216,11 @@ async function loadPyodide(path) {
         lockFileContents = parsedLock.lock;
     }
     const { loadPyodide } = runtimeModule;
-    pyodide = await loadPyodide({
+    pyodide = await withCachedPyodideModule(runtimeBaseUrl, () => loadPyodide({
         indexURL: path,
         packageBaseUrl,
         ...(lockFileContents ? { lockFileContents } : {})
-    });
+    }));
 }
 async function loadPackages(code) {
     if (!code)

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

@@ -0,0 +1,8 @@
+/** The host compiles trusted runtime assets; workers never populate the shared module cache. */
+export declare function compileWorkerRuntimeAsset(asset: string): Promise<WebAssembly.Module>;
+/**
+ * Pyodide 0.29.3 creates its own instantiateWasm hook, including its sentinel imports.
+ * Intercept only the exact bootstrap fetch/Response during initialization so those imports
+ * remain intact. Other Wasm (including the sentinel) and all package fetches are untouched.
+ */
+export declare function withCachedPyodideModule<T>(baseUrl: string, initialize: () => Promise<T>): Promise<T>;

package/dist/playground/worker/runtimeModule.js

@@ -0,0 +1,49 @@
+import { decompressGzip } from '@wasm-idle/llvm-core';
+import { hasWorkerRuntimeModuleBridge, loadWorkerRuntimeAsset, loadWorkerRuntimeModule } from './assets';
+/** The host compiles trusted runtime assets; workers never populate the shared module cache. */
+export async function compileWorkerRuntimeAsset(asset) {
+    if (hasWorkerRuntimeModuleBridge())
+        return await loadWorkerRuntimeModule(asset);
+    const { bytes } = await loadWorkerRuntimeAsset(asset);
+    const wasm = bytes[0] === 0x1f && bytes[1] === 0x8b ? await decompressGzip(bytes) : bytes;
+    return await WebAssembly.compile(wasm.slice().buffer);
+}
+/**
+ * Pyodide 0.29.3 creates its own instantiateWasm hook, including its sentinel imports.
+ * Intercept only the exact bootstrap fetch/Response during initialization so those imports
+ * remain intact. Other Wasm (including the sentinel) and all package fetches are untouched.
+ */
+export async function withCachedPyodideModule(baseUrl, initialize) {
+    const runtimeUrl = new URL('pyodide.asm.wasm', baseUrl).href;
+    // Compile before entering Pyodide, whose bootstrap catches instantiation failures internally.
+    const module = await compileWorkerRuntimeAsset('pyodide.asm.wasm');
+    const previousFetch = globalThis.fetch;
+    const previousInstantiateStreaming = WebAssembly.instantiateStreaming;
+    const responses = new WeakSet();
+    const fetchRuntime = async (input, init) => {
+        const url = input instanceof Request ? input.url : new URL(String(input), baseUrl).href;
+        if (url !== runtimeUrl)
+            return await previousFetch(input, init);
+        const response = new Response(null, { headers: { 'content-type': 'application/wasm' } });
+        responses.add(response);
+        return response;
+    };
+    const instantiateRuntime = async (source, imports) => {
+        const response = await source;
+        if (!responses.has(response))
+            return await previousInstantiateStreaming(response, imports);
+        return { module, instance: await WebAssembly.instantiate(module, imports) };
+    };
+    globalThis.fetch = fetchRuntime;
+    WebAssembly.instantiateStreaming = instantiateRuntime;
+    try {
+        return await initialize();
+    }
+    finally {
+        if (globalThis.fetch === fetchRuntime)
+            globalThis.fetch = previousFetch;
+        if (WebAssembly.instantiateStreaming === instantiateRuntime) {
+            WebAssembly.instantiateStreaming = previousInstantiateStreaming;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-idle",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "A simple web app to run code in the browser",
   "license": "MIT",
   "type": "module",
@@ -61,15 +61,15 @@
     "vitest": "^4.1.4",
     "waforth": "0.20.1",
     "webr": "0.6.0",
-    "@wasm-idle/debug": "1.0.5",
-    "@wasm-idle/lsp": "1.0.5",
-    "@wasm-idle/terminal": "1.0.5"
+    "@wasm-idle/lsp": "1.0.6",
+    "@wasm-idle/terminal": "1.0.6",
+    "@wasm-idle/debug": "1.0.6"
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "^0.4.2",
     "fflate": "0.8.3",
-    "@wasm-idle/core": "1.0.5",
-    "@wasm-idle/llvm-core": "1.0.5"
+    "@wasm-idle/core": "1.0.6",
+    "@wasm-idle/llvm-core": "1.0.6"
   },
   "files": [
     "dist",