wasm-idle 1.0.5 → 1.0.7

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

@@ -2,6 +2,7 @@ export interface WorkerRuntimeAssetConfig {
     baseUrl: string;
     maxAssetBytes?: number;
     useAssetBridge: boolean;
+    useModuleBridge?: boolean;
 }
 export interface WorkerRuntimeAssetAllowlist {
     baseUrl: string;
@@ -16,4 +17,6 @@ export declare function configureWorkerRuntimeAssets(config: WorkerRuntimeAssetC
 export declare function configureWorkerRuntimeAssetAllowlist(allowlist: WorkerRuntimeAssetAllowlist | null): void;
 export declare function handleWorkerAssetMessage(data: any): boolean;
 export declare function loadWorkerRuntimeAsset(asset: string): Promise<LoadedWorkerAsset>;
+export declare function hasWorkerRuntimeModuleBridge(): boolean;
+export declare function loadWorkerRuntimeModule(asset: string): Promise<WebAssembly.Module>;
 export {};

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

@@ -4,11 +4,7 @@ import { isSharedBufferBackedView } from '../sharedBuffer';
 import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
 import { withVerifiedStreaming } from './clangStreaming';
 import { BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES } from '../clangAssetIntegrity';
-self.document = {
-    querySelectorAll() {
-        return [];
-    }
-};
+// Preserve native Worker globals: a partial document makes dev loaders misdetect a DOM.
 let stdinBufferClang, debugBufferClang, watchBufferClang, watchResultBufferClang, interruptBufferClang, clang;
 let hasInitialStdinClang = false;
 let initialStdinClang = null;
@@ -30,9 +26,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/elixir.js

@@ -1,7 +1,7 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
 import { ELIXIR_RUNTIME_ASSET_NAMES, snapshotElixirRuntimeAssetReceipts } from '../elixirAssets';
 import { fetchRuntimeAssetBytes } from './runtimeAssetFetch';
-import { verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { configureRuntimeAssetCache, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
 const workerDocument = {
     querySelectorAll() {
         return [];
@@ -403,15 +403,16 @@ async function loadRuntime(nextBundleUrl, nextAssetReceipts, nextMaxAssetBytes,
             const bytes = await fetchRuntimeAssetBytes({
                 url: assetUrl,
                 label: `Elixir runtime asset ${asset}`,
+                expected: { sha256: receipt.uncompressedSha256, bytes: receipt.uncompressedBytes },
+                verify: (bytes) => verifyRuntimeAssetIntegrity({
+                    asset,
+                    bytes,
+                    expected: receipt,
+                    stage: 'uncompressed',
+                    runtimeId: 'ELIXIR'
+                }),
                 maxAssetBytes: Math.min(receipt.uncompressedBytes, effectiveMaxAssetBytes)
             });
-            await verifyRuntimeAssetIntegrity({
-                asset,
-                bytes,
-                expected: receipt,
-                stage: 'uncompressed',
-                runtimeId: 'ELIXIR'
-            });
             loadedAssets.push([asset, bytes]);
         }
         const assets = Object.freeze(Object.fromEntries(loadedAssets));
@@ -465,6 +466,7 @@ self.onmessage = async (event) => {
     const evalLanguage = language === 'ERLANG' ? 'ERLANG' : 'ELIXIR';
     try {
         if (load) {
+            configureRuntimeAssetCache(event.data.persistentCache ?? {});
             await loadRuntime(nextBundleUrl, nextAssetReceipts, nextMaxAssetBytes, log);
             const configuredReceipts = snapshotElixirRuntimeAssetReceipts(nextAssetReceipts);
             bundleUrl = nextBundleUrl;

package/dist/playground/worker/fortran.js

@@ -4,7 +4,7 @@ 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';
+import { configureRuntimeAssetCache, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
 self.document = {
     querySelectorAll() {
         return [];
@@ -73,13 +73,9 @@ async function fetchVerifiedBytes(url, asset, receipt) {
     const bytes = await fetchRuntimeAssetBytes({
         url,
         label: asset,
-        maxAssetBytes: receipt.bytes
-    });
-    await verifyRuntimeAssetIntegrity({
-        asset,
-        bytes,
         expected: receipt,
-        runtimeId: 'FORTRAN'
+        verify: (bytes) => verifyRuntimeAssetIntegrity({ asset, bytes, expected: receipt, runtimeId: 'FORTRAN' }),
+        maxAssetBytes: receipt.bytes
     });
     return bytes;
 }
@@ -248,6 +244,7 @@ self.onmessage = async (event) => {
         return;
     const { code, buffer, load, log, prepare, compileArgs, programArgs, activePath, workspaceFiles, stdin, clangAssets, fortranAssets } = event.data;
     if (load) {
+        configureRuntimeAssetCache(event.data.persistentCache ?? {});
         try {
             await loadFortranRuntime(clangAssets, fortranAssets, log);
             postMessage({ load: true });

package/dist/playground/worker/haskell.js

@@ -1,5 +1,6 @@
 import { ConsoleStdout, Directory, File, OpenFile, PreopenDirectory, WASI, wasi } from '@bjorn3/browser_wasi_shim';
 import { installWasiExtractionQuota } from '@wasm-idle/llvm-core';
+import { configureRuntimeAssetCache } from '@wasm-idle/core';
 import { loadVerifiedHaskellRuntimeAssets, snapshotHaskellRuntimeAssetConfig } from '../haskellAssets';
 import { waitForBufferedStdin } from '../stdinBuffer';
 let moduleUrl = '';
@@ -397,6 +398,7 @@ self.onmessage = async (event) => {
     const { load, moduleUrl: nextModuleUrl, rootfsUrl: nextRootfsUrl, bsdtarUrl: nextBsdtarUrl, integrity: nextIntegrity, maxAssetBytes: nextMaxAssetBytes, mainSoPath: nextMainSoPath, searchDirs: nextSearchDirs, code, prepare, buffer, stdin, ghcArgs = '', activePath = 'main.hs', workspaceFiles = [], log } = event.data;
     try {
         if (load) {
+            configureRuntimeAssetCache(event.data.persistentCache ?? {});
             const nextConfig = snapshotHaskellRuntimeAssetConfig({
                 moduleUrl: nextModuleUrl,
                 rootfsUrl: nextRootfsUrl,

package/dist/playground/worker/lisp.js

@@ -1,4 +1,5 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
+import { configureRuntimeAssetCache } from '@wasm-idle/core';
 import { loadVerifiedLispRuntimeAssets } from '../lispAssets';
 let stdinBufferLisp = null;
 let runtimeConfig = null;
@@ -80,6 +81,7 @@ self.onmessage = async (event) => {
     const { load, runtimeConfig: nextRuntimeConfig, maxAssetBytes: nextMaxAssetBytes, buffer, code, prepare, args = [], stdin, activePath = 'main.scm', workspaceFiles = [], log } = event.data;
     try {
         if (load) {
+            configureRuntimeAssetCache(event.data.persistentCache ?? {});
             runtimeConfig = nextRuntimeConfig;
             runtimeMaxAssetBytes = resolveMaxAssetBytes(nextMaxAssetBytes);
             if (log) {

package/dist/playground/worker/ocaml.js

@@ -1,5 +1,5 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
-import { verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { configureRuntimeAssetCache, createRuntimeAssetCacheBackend, getRuntimeAssetCacheOptions, resolveRuntimeAssetCacheOptions, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
 import { fetchRuntimeAssetBytes } from './runtimeAssetFetch';
 const MAX_OCAML_MANIFEST_BYTES = 4 * 1024 * 1024;
 const MAX_OCAML_RUNTIME_ENTRY_BYTES = 32 * 1024 * 1024;
@@ -9,6 +9,7 @@ let moduleUrl = '';
 let manifestUrl = '';
 let moduleReceipt = null;
 let manifestReceipt = null;
+let loadPersistentCache;
 let maxAssetBytes = DEFAULT_MAX_OCAML_ASSET_BYTES;
 let loadedModuleIdentity = '';
 let loadedManifestIdentity = '';
@@ -124,6 +125,8 @@ async function loadCompiler(nextModuleUrl, nextReceipt, nextMaxAssetBytes) {
         const bytes = await fetchRuntimeAssetBytes({
             url: nextModuleUrl,
             label: 'OCaml runtime module',
+            expected: nextReceipt,
+            integrityContext: { runtimeId: 'OCAML' },
             cache: 'no-store',
             maxAssetBytes: nextReceipt.bytes
         });
@@ -218,6 +221,8 @@ async function loadManifest(nextManifestUrl, nextReceipt, nextMaxAssetBytes) {
         const bytes = await fetchRuntimeAssetBytes({
             url: nextManifestUrl,
             label: 'OCaml manifest',
+            expected: nextReceipt,
+            integrityContext: { runtimeId: 'OCAML' },
             cache: 'no-store',
             maxAssetBytes: nextReceipt.bytes
         });
@@ -493,6 +498,8 @@ self.onmessage = async (event) => {
     let log = true;
     try {
         if (event.data.load) {
+            configureRuntimeAssetCache(event.data.persistentCache ?? {});
+            loadPersistentCache = getRuntimeAssetCacheOptions();
             moduleUrl = event.data.moduleUrl;
             manifestUrl = event.data.manifestUrl;
             moduleReceipt = requireOuterAssetReceipt(event.data.moduleReceipt, 'module');
@@ -504,6 +511,10 @@ self.onmessage = async (event) => {
             return;
         }
         const { code, prepare, target = 'wasm', wasmBinaryenMode = 'fast', log: configuredLog = true, buffer, stdin, activePath = 'main.ml', workspaceFiles = [] } = event.data;
+        configureRuntimeAssetCache(resolveRuntimeAssetCacheOptions(loadPersistentCache, event.data.persistentCache));
+        const persistentCache = getRuntimeAssetCacheOptions().enabled
+            ? createRuntimeAssetCacheBackend()
+            : undefined;
         log = configuredLog;
         stdinBufferOcaml = buffer ? new Int32Array(buffer) : null;
         if (log) {
@@ -538,6 +549,7 @@ self.onmessage = async (event) => {
                 system: compilerModule.createBrowserWorkerSystemDispatcher({
                     manifest,
                     runtimeAssets: {
+                        ...(persistentCache ? { persistentCache } : {}),
                         limits: {
                             maxAssetBytes,
                             maxMetadataBytes: Math.min(MAX_OCAML_MANIFEST_BYTES, maxAssetBytes),

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/runtimeAssetFetch.d.ts

@@ -1,3 +1,4 @@
+import { type RuntimeAssetCacheOptions, type RuntimeAssetIntegrityEntry } from '@wasm-idle/core';
 export interface RuntimeAssetDownloadProgress {
     loaded: number;
     total?: number;
@@ -9,7 +10,16 @@ export interface RuntimeAssetFetchOptions {
     maxAssetBytes?: number;
     onProgress?: (progress: RuntimeAssetDownloadProgress) => void;
     signal?: AbortSignal;
+    expected?: RuntimeAssetIntegrityEntry;
+    persistentCache?: RuntimeAssetCacheOptions;
+    /** Preserve an existing runtime-specific verification boundary, including its diagnostics. */
+    verify?: (bytes: Uint8Array) => Promise<unknown>;
+    integrityContext?: {
+        asset?: string;
+        runtimeId?: string;
+        profileId?: string;
+    };
 }
 export declare const DEFAULT_RUNTIME_ASSET_MAX_BYTES: number;
 export declare function resolveRuntimeAssetUrl(value: string, label: string): URL;
-export declare function fetchRuntimeAssetBytes({ url, label, cache, maxAssetBytes, onProgress, signal }: RuntimeAssetFetchOptions): Promise<Uint8Array<ArrayBuffer>>;
+export declare function fetchRuntimeAssetBytes(options: RuntimeAssetFetchOptions): Promise<Uint8Array<ArrayBuffer>>;

package/dist/playground/worker/runtimeAssetFetch.js

@@ -1,3 +1,4 @@
+import { readPersistentRuntimeAsset, resolveRuntimeAssetCacheOptions, verifyRuntimeAssetIntegrity, writePersistentRuntimeAsset } from '@wasm-idle/core';
 export const DEFAULT_RUNTIME_ASSET_MAX_BYTES = 128 * 1024 * 1024;
 const DEFAULT_STREAM_BUFFER_BYTES = 64 * 1024;
 export function resolveRuntimeAssetUrl(value, label) {
@@ -33,7 +34,69 @@ function abortReason(signal) {
         ? reason
         : new DOMException('The runtime asset download was aborted', 'AbortError');
 }
-export async function fetchRuntimeAssetBytes({ url, label, cache, maxAssetBytes = DEFAULT_RUNTIME_ASSET_MAX_BYTES, onProgress, signal }) {
+export async function fetchRuntimeAssetBytes(options) {
+    // Unpinned custom assets retain their existing network path, with no implicit URL trust.
+    if (!options.expected)
+        return fetchRuntimeAssetBytesFromNetwork(options);
+    const maxAssetBytes = options.maxAssetBytes ?? DEFAULT_RUNTIME_ASSET_MAX_BYTES;
+    if (!Number.isSafeInteger(maxAssetBytes) || maxAssetBytes <= 0) {
+        throw new TypeError('Runtime asset maxAssetBytes must be a positive safe integer');
+    }
+    const url = resolveRuntimeAssetUrl(options.url, options.label).href;
+    const cache = resolveRuntimeAssetCacheOptions(options.persistentCache);
+    const expected = { ...options.expected };
+    const candidates = [{ sha256: expected.sha256, bytes: expected.bytes }];
+    if (expected.uncompressedSha256 !== undefined && expected.uncompressedBytes !== undefined) {
+        candidates.push({ sha256: expected.uncompressedSha256, bytes: expected.uncompressedBytes });
+    }
+    const validationKey = JSON.stringify([
+        'worker-asset-fetch-v1',
+        'exact-url',
+        'redirect-error',
+        'mime-unchecked',
+        maxAssetBytes
+    ]);
+    for (const receipt of candidates) {
+        if (receipt.bytes !== undefined && receipt.bytes > maxAssetBytes)
+            continue;
+        const hit = await readPersistentRuntimeAsset({
+            identity: { url, ...receipt, validationKey },
+            cache,
+            signal: options.signal
+        });
+        if (hit) {
+            if (hit.byteLength > maxAssetBytes)
+                throw new Error(`${options.label} exceeds the ${maxAssetBytes} byte limit`);
+            await options.verify?.(hit);
+            options.onProgress?.({ loaded: hit.byteLength, total: hit.byteLength });
+            if (options.signal?.aborted)
+                throw abortReason(options.signal);
+            return Uint8Array.from(hit);
+        }
+    }
+    const bytes = await fetchRuntimeAssetBytesFromNetwork(options);
+    const isGzip = bytes[0] === 0x1f && bytes[1] === 0x8b;
+    const receipt = !isGzip && candidates.length > 1 ? candidates[1] : candidates[0];
+    if (options.verify)
+        await options.verify(bytes);
+    else
+        await verifyRuntimeAssetIntegrity({
+            asset: url,
+            ...options.integrityContext,
+            bytes,
+            expected: receipt
+        });
+    await writePersistentRuntimeAsset({
+        identity: { url, ...receipt, validationKey },
+        cache,
+        signal: options.signal,
+        bytes
+    });
+    if (options.signal?.aborted)
+        throw abortReason(options.signal);
+    return bytes;
+}
+async function fetchRuntimeAssetBytesFromNetwork({ url, label, cache, maxAssetBytes = DEFAULT_RUNTIME_ASSET_MAX_BYTES, onProgress, signal }) {
     if (!Number.isSafeInteger(maxAssetBytes) || maxAssetBytes <= 0) {
         throw new TypeError('Runtime asset maxAssetBytes must be a positive safe integer');
     }

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;
+        }
+    }
+}