wasm-idle 1.0.6 → 1.0.7

package/dist/playground/wasmTinyGoVersion.js

@@ -2,10 +2,10 @@ export const WASM_TINYGO_RUNTIME_PROFILE = Object.freeze({
     profileId: 'tinygo-0.40.1-wasip1-protocol-v6',
     protocolVersion: 6,
     manifestPath: 'tools/upstream/upstream-toolchain.v2.json',
-    manifestFingerprint: 'd3f20ca1974c52fa8e4b20e37a75f8171044e0351192b8bed85d7f83d4fffbbc',
+    manifestFingerprint: '03140d8fe8b9b477764da72a3a497077984faa4553e7a94901c8130b26680ce5',
     manifestReceipt: Object.freeze({
-        bytes: 1123,
-        sha256: '4f95485c52f5eec87d1b0906ac8ab4bcb403b8e3bdbcbac2319469353c6a4dfc'
+        bytes: 1124,
+        sha256: 'e53790b97125e48d77967bc87cc400fdfacfb678e6d847de372efa647cb4de4f'
     }),
     assetReceipts: Object.freeze({
         'tools/upstream/lld.wasm': Object.freeze({
@@ -19,14 +19,14 @@ export const WASM_TINYGO_RUNTIME_PROFILE = Object.freeze({
             sha256: 'b25c8ffd86af0e540cf058e38b273271100ff297316f30a38c8239c77d9357d1'
         }),
         'tools/upstream/producer-receipt.json': Object.freeze({
-            bytes: 7572,
-            sha256: 'bcf1ca1951a64896df98ae8d04137c80c503b1f5e64a099fae99d90deffe8b60'
+            bytes: 10207,
+            sha256: 'a400355ee1ca13c6a79bca0c7c2e8cf05ecf457fdc61c9fc69692bb17500842a'
         }),
         'tools/upstream/tinygo-compiler.wasm': Object.freeze({
-            bytes: 19961972,
-            sha256: '37e07f96700ee4a98c37879553144e4c3872fa91136be3a193cb33d5d11a372f',
-            uncompressedBytes: 70288217,
-            uncompressedSha256: 'a5f6cb6cbfff45e6c5ee6ab8f3bca37c5dabd19d443107707ad1de330ecb8db2'
+            bytes: 17488480,
+            sha256: '9700dd4403162a89cffa065011bb26c919b70a82b3e86d612ceb064a598111de',
+            uncompressedBytes: 54057556,
+            uncompressedSha256: 'a65f51c7d2845ea1469328705f2c9839f0151ee221e6a3efea851226e4e2d649'
         }),
         'tools/upstream/tinygo-package-graph.wasm': Object.freeze({
             bytes: 6058150,
@@ -35,8 +35,8 @@ export const WASM_TINYGO_RUNTIME_PROFILE = Object.freeze({
             uncompressedSha256: 'b7b28719bf97d5c5e140c3ec6f8f40a40fc7d02216e0160e460a34b79f61cb14'
         }),
         'tools/upstream/tinygoroot.tar.gz.bin': Object.freeze({
-            bytes: 28919860,
-            sha256: 'e9e8314b406e57a512b49d9716455665bfac36e24694763bdecf86f4b0c2fae3'
+            bytes: 29058996,
+            sha256: '6c085f441ecc5990b71628f0b47b80e9e9810ae6384093e65723f795b4bd8688'
         })
     })
 });
@@ -46,16 +46,34 @@ export const WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
     schemaVersion: 1,
     format: WASM_TINYGO_EXECUTABLE_GRAPH_FORMAT,
     entryPath: 'upstream.js',
-    fingerprint: '33fe04eb515aaaea7e7dd5571a4a614a48d51b991115f05288b236377c53c5b9',
+    fingerprint: '8ecbffd4b4e44ff67288d8c46328a1b06d0a0ac76d7a50a9e458603b68d0d795',
     modules: Object.freeze({
+        'assets/upstream-binaryen-59aad93503b5fd53.wasm.gz.bin': Object.freeze({
+            bytes: 2366782,
+            sha256: 'e497b67a6bcbee29639792a3d58ecacb22781287f7fe155bfdf079e6ca159dff',
+            uncompressedBytes: 9282194,
+            uncompressedSha256: '59aad93503b5fd539993f2f5571c11dce9ddb4c5d10b681abc8e5dc124aed526',
+            imports: Object.freeze([])
+        }),
         'assets/upstream-compile-worker-CFw6Ych6.js': Object.freeze({
             bytes: 558,
             sha256: '03a76345c69f8bd751dac18894f65c0918f1690fbbb661f38052819cd5ae8209',
             imports: Object.freeze([])
         }),
-        'assets/upstream-compile-worker-Dat9LBTc.js': Object.freeze({
-            bytes: 12538521,
-            sha256: 'b8d987c32914715b0ba91ace85585f5db467957d14982aa163c1febe9d6dfc04',
+        'assets/upstream-compile-worker-CUrboB1_.js': Object.freeze({
+            bytes: 103559,
+            sha256: '42337c2f06d04b51d79f0ec66ae685f0cfb2a78718b0636df980dc92dd1db9d5',
+            imports: Object.freeze([
+                Object.freeze({
+                    specifier: './upstream-compile-worker-CeYS3ydo.js',
+                    target: 'assets/upstream-compile-worker-CeYS3ydo.js',
+                    kind: 'dynamic'
+                })
+            ])
+        }),
+        'assets/upstream-compile-worker-CeYS3ydo.js': Object.freeze({
+            bytes: 181175,
+            sha256: 'faa2bf6a310cd23991babde1fb62cd34253d692fee03029fe3508eae4c24b1c0',
             imports: Object.freeze([
                 Object.freeze({
                     specifier: './upstream-compile-worker-CFw6Ych6.js',
@@ -66,6 +84,11 @@ export const WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
                     specifier: './upstream-compile-worker-NPJcbr3r.js',
                     target: 'assets/upstream-compile-worker-NPJcbr3r.js',
                     kind: 'dynamic'
+                }),
+                Object.freeze({
+                    specifier: './upstream-binaryen-59aad93503b5fd53.wasm.gz.bin',
+                    target: 'assets/upstream-binaryen-59aad93503b5fd53.wasm.gz.bin',
+                    kind: 'asset'
                 })
             ])
         }),
@@ -80,28 +103,17 @@ export const WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
                 })
             ])
         }),
-        'assets/upstream-compile-worker-R7P8Uy5f.js': Object.freeze({
-            bytes: 100032,
-            sha256: '1cc51b6435aa72d0ad9c513658a8ed4b2e9d5f94a28b0902b1f200364bccbf82',
-            imports: Object.freeze([
-                Object.freeze({
-                    specifier: './upstream-compile-worker-Dat9LBTc.js',
-                    target: 'assets/upstream-compile-worker-Dat9LBTc.js',
-                    kind: 'dynamic'
-                })
-            ])
-        }),
         'upstream.js': Object.freeze({
-            bytes: 123164,
-            sha256: 'bee971f17a538c1afc3fa01f2050a233a4b75030f0a8e258fd8ca76584cc93a6',
+            bytes: 126073,
+            sha256: '136a957aa940c3e2b8c7a925eb538f3fce81f699aa9113e1fd93ce0b35c879aa',
             imports: Object.freeze([
                 Object.freeze({
-                    specifier: 'assets/upstream-compile-worker-R7P8Uy5f.js',
-                    target: 'assets/upstream-compile-worker-R7P8Uy5f.js',
+                    specifier: 'assets/upstream-compile-worker-CUrboB1_.js',
+                    target: 'assets/upstream-compile-worker-CUrboB1_.js',
                     kind: 'worker'
                 })
             ])
         })
     })
 });
-export const WASM_TINYGO_ASSET_VERSION = '5ff593680ea205ac06ce66afd181d811f46933a5358113a11206b6b89d95707f';
+export const WASM_TINYGO_ASSET_VERSION = '0b2e827ae219eecc806d4118ee4a2b6032adbe7a960e6c0e471c4491d9a1f2f3';

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;

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/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/rust.js

@@ -2,7 +2,7 @@ import { waitForBufferedStdin } from '../stdinBuffer';
 import { isSharedBufferBackedView } from '../sharedBuffer';
 import { snapshotRustNonDebugResourceLimits } from '../rustWorkerLimits';
 import { WASM_RUST_EXECUTABLE_GRAPH_PROFILE, WASM_RUST_RUNTIME_PROFILE } from '../wasmRustVersion';
-import { createRuntimeAssetDeliveryBudget } from '@wasm-idle/core';
+import { createRuntimeAssetDeliveryBudget, createRuntimeAssetCacheBackend, resolveRuntimeAssetCacheOptions } from '@wasm-idle/core';
 const lowercaseSha256Pattern = /^[0-9a-f]{64}$/u;
 const testOnlyCompilerModuleImporter = import.meta.env.MODE === 'test'
     ? globalThis.__WASM_IDLE_TEST_ONLY_RUST_COMPILER_MODULE_IMPORTER__
@@ -27,6 +27,7 @@ let loadedCompilerUrl = '';
 let loadedExecutableGraphFingerprint = '';
 let acceptedCompilerBootstrap = false;
 let activeExecution = false;
+let persistentCacheBaseline;
 let compilerPromise = null;
 let compiledArtifact = null;
 let compiledCacheKey = '';
@@ -402,7 +403,7 @@ function createRustDebugHost(options) {
     };
 }
 self.onmessage = async (event) => {
-    const { load, compilerUrl: nextCompilerUrl, runtimeProfile: nextRuntimeProfile, verifiedModuleUrls: nextVerifiedModuleUrls, executableGraphFingerprint: nextExecutableGraphFingerprint, debugModuleUrl: nextDebugModuleUrl, buffer, debugBuffer, code, prepare, args = [], stdin, targetTriple = 'wasm32-wasip1', log, debug = false, debugMode: requestedDebugMode, breakpoints = [], pauseOnEntry = false, limits: executionLimits } = event.data;
+    const { load, persistentCache, compilerUrl: nextCompilerUrl, runtimeProfile: nextRuntimeProfile, verifiedModuleUrls: nextVerifiedModuleUrls, executableGraphFingerprint: nextExecutableGraphFingerprint, debugModuleUrl: nextDebugModuleUrl, buffer, debugBuffer, code, prepare, args = [], stdin, targetTriple = 'wasm32-wasip1', log, debug = false, debugMode: requestedDebugMode, breakpoints = [], pauseOnEntry = false, limits: executionLimits } = event.data;
     let ownsExecution = false;
     try {
         if (load) {
@@ -410,6 +411,7 @@ self.onmessage = async (event) => {
                 throw new Error('wasm-rust application worker accepts exactly one bootstrap');
             }
             acceptedCompilerBootstrap = true;
+            persistentCacheBaseline = resolveRuntimeAssetCacheOptions(persistentCache);
             compilerUrl = nextCompilerUrl;
             debugModuleUrl = nextDebugModuleUrl;
             runtimeProfile = nextRuntimeProfile || null;
@@ -430,6 +432,10 @@ self.onmessage = async (event) => {
         }
         activeExecution = true;
         ownsExecution = true;
+        const executionCache = resolveRuntimeAssetCacheOptions(persistentCacheBaseline, persistentCache);
+        const assetCache = executionCache.enabled
+            ? createRuntimeAssetCacheBackend(executionCache)
+            : undefined;
         const debugMode = requestedDebugMode === undefined ? (debug ? 'trace' : 'none') : requestedDebugMode;
         if (debugMode !== 'none' && debugMode !== 'trace' && debugMode !== 'lldb') {
             throw new Error(`Unsupported Rust debug mode: ${String(debugMode)}`);
@@ -481,6 +487,7 @@ self.onmessage = async (event) => {
                 console.log(`[wasm-idle:rust-worker] compile start prepare=${String(prepare)} target=${targetTriple} bytes=${compileCode.length}`);
             }
             const result = await runtime.compiler.compile({
+                ...(assetCache ? { assetCache } : {}),
                 code: compileCode,
                 debugMode,
                 ...(nonDebugResourceLimits

package/dist/playground/worker/staticRuntimePreflight.js

@@ -1,3 +1,4 @@
+import { configureRuntimeAssetCache } from '@wasm-idle/core';
 import { executeStaticRuntimePreflight } from '../staticRuntimePreflightExecute';
 import { STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION, collectStaticRuntimePreflightTransferables, serializeStaticRuntimePreflightError } from '../staticRuntimePreflightProtocol';
 const workerSelf = globalThis;
@@ -29,6 +30,7 @@ workerSelf.onmessage = async (event) => {
         return;
     handled = true;
     try {
+        configureRuntimeAssetCache(request.persistentCache ?? false);
         const payload = await executeStaticRuntimePreflight(request, (progress) => {
             workerSelf.postMessage({
                 protocolVersion: STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION,

package/dist/playground/worker/typescript.js

@@ -1,6 +1,6 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
 import { fetchRuntimeAssetBytes } from './runtimeAssetFetch';
-import { verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { configureRuntimeAssetCache, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
 let stdinBufferTypeScript = null;
 let moduleUrl = '';
 let moduleReceipt = null;
@@ -69,6 +69,8 @@ async function loadRuntime(urlValue, receiptValue, maxAssetBytesValue) {
         const bytes = await fetchRuntimeAssetBytes({
             url,
             label: 'TypeScript runtime module',
+            expected: receipt,
+            integrityContext: { runtimeId: 'TYPESCRIPT' },
             maxAssetBytes: receipt.bytes
         });
         await verifyRuntimeAssetIntegrity({
@@ -133,6 +135,7 @@ self.onmessage = async (event) => {
     const { load, moduleUrl: nextModuleUrl, moduleReceipt: nextModuleReceipt, maxAssetBytes: nextMaxAssetBytes, buffer, code, prepare, args = [], stdin, language = 'typescript', activePath = language === 'typescript' ? 'main.ts' : 'main.js', workspaceFiles = [], log } = event.data;
     try {
         if (load) {
+            configureRuntimeAssetCache(event.data.persistentCache ?? {});
             const configuredModuleUrl = requireModuleUrl(nextModuleUrl);
             const configuredModuleReceipt = snapshotModuleReceipt(nextModuleReceipt);
             const configuredMaxAssetBytes = requireMaxAssetBytes(nextMaxAssetBytes);

package/dist/playground/worker/zig.js

@@ -1,6 +1,6 @@
 import { ConsoleStdout, Directory, Fd, File, OpenFile, PreopenDirectory, WASI, wasi } from '@bjorn3/browser_wasi_shim';
 import { decompressGzip, untar } from '@wasm-idle/llvm-core';
-import { verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { configureRuntimeAssetCache, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
 import { waitForBufferedStdin } from '../stdinBuffer';
 import { snapshotZigExecutionAssetReceipts } from '../zigAssets';
 import { fetchRuntimeAssetBytes, resolveRuntimeAssetUrl } from './runtimeAssetFetch';
@@ -138,10 +138,12 @@ function buildWorkspaceRoot(code, activePath, workspaceFiles) {
     addFileToDirectory(root, entryPath, encoder.encode(code));
     return { root, entryPath };
 }
-async function fetchBytes(url, asset, maxAssetBytes, progressStart, progressEnd) {
+async function fetchBytes(url, asset, maxAssetBytes, progressStart, progressEnd, expected) {
     const data = await fetchRuntimeAssetBytes({
         url,
         label: asset,
+        expected,
+        integrityContext: { asset, runtimeId: 'ZIG' },
         maxAssetBytes,
         onProgress: ({ loaded, total }) => {
             if (total && total > 0) {
@@ -398,8 +400,8 @@ async function loadAssets(nextCompilerUrl, nextStdlibUrl, nextIntegrity, maxAsse
     const pending = (async () => {
         postProgress(5);
         const [compilerBytes, stdlibBytes] = await Promise.all([
-            fetchBytes(nextCompilerUrl, 'zig_small.wasm', receipts['zig_small.wasm'].bytes, 5, 45),
-            fetchBytes(nextStdlibUrl, 'std.tar.gz', Math.max(receipts['std.tar.gz'].bytes, receipts['std.tar.gz'].uncompressedBytes || 0), 45, 70)
+            fetchBytes(nextCompilerUrl, 'zig_small.wasm', receipts['zig_small.wasm'].bytes, 5, 45, receipts['zig_small.wasm']),
+            fetchBytes(nextStdlibUrl, 'std.tar.gz', Math.max(receipts['std.tar.gz'].bytes, receipts['std.tar.gz'].uncompressedBytes || 0), 45, 70, receipts['std.tar.gz'])
         ]);
         await verifyRuntimeAssetIntegrity({
             asset: 'zig_small.wasm',
@@ -526,6 +528,7 @@ self.onmessage = async (event) => {
     const { load, compilerUrl: nextCompilerUrl, stdlibUrl: nextStdlibUrl, integrity: nextIntegrity, maxAssetBytes: nextMaxAssetBytes, buffer, code, prepare, args = [], compileArgs = [], stdin, activePath = 'main.zig', workspaceFiles = [], targetTriple = 'wasm64-wasi', log } = event.data;
     try {
         if (load) {
+            configureRuntimeAssetCache(event.data.persistentCache ?? {});
             if (log) {
                 console.log(`[wasm-idle:zig-worker] load compilerUrl=${nextCompilerUrl} stdlibUrl=${nextStdlibUrl}`);
             }

package/dist/playground/zig.js

@@ -2,7 +2,7 @@ import { resolveSandboxExecutionArgs } from './options';
 import { resolveZigCompilerUrl, resolveZigStdlibUrl } from './assets';
 import { snapshotZigExecutionAssetReceipts } from './zigAssets';
 import { WASM_ZIG_ASSET_RECEIPTS } from './wasmZigVersion';
-import { BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, validateExecutionWorkspace } from '@wasm-idle/core';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
 import { WorkerSession } from './workerSession';
@@ -370,6 +370,9 @@ class Zig {
                     worker.onmessage = handler;
                     worker.postMessage({
                         load: true,
+                        persistentCache: resolveRuntimeAssetCacheOptions(typeof runtimeAssets === 'object'
+                            ? runtimeAssets?.persistentCache
+                            : undefined, options.persistentCache),
                         compilerUrl: nextCompilerUrl,
                         stdlibUrl: nextStdlibUrl,
                         integrity: nextIntegrity,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-idle",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "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/lsp": "1.0.6",
-    "@wasm-idle/terminal": "1.0.6",
-    "@wasm-idle/debug": "1.0.6"
+    "@wasm-idle/debug": "1.0.7",
+    "@wasm-idle/terminal": "1.0.7",
+    "@wasm-idle/lsp": "1.0.7"
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "^0.4.2",
     "fflate": "0.8.3",
-    "@wasm-idle/core": "1.0.6",
-    "@wasm-idle/llvm-core": "1.0.6"
+    "@wasm-idle/core": "1.0.7",
+    "@wasm-idle/llvm-core": "1.0.7"
   },
   "files": [
     "dist",
@@ -190,8 +190,11 @@
     "sync:webr": "node scripts/sync-runtime.mjs webr",
     "compress:static-runtimes": "node scripts/compress-static-runtime-assets.mjs static",
     "compress:build-runtimes": "node scripts/compress-static-runtime-assets.mjs build",
+    "compact:build-runtimes": "node scripts/compact-runtime-aliases.mjs build",
     "layer:static-runtimes": "node scripts/build-layered-runtime-assets.mjs static",
     "asset:sizes": "node scripts/static-asset-sizes.mjs report",
+    "assets:lock": "node scripts/generate-runtime-asset-lock.mjs",
+    "check:assets-lock": "node scripts/generate-runtime-asset-lock.mjs --check",
     "check:asset-sizes": "node scripts/static-asset-sizes.mjs check",
     "build:page-runtimes": "node scripts/prepare-page-runtimes.mjs",
     "verify:wasm-typescript-freshness": "pnpm --dir runtimes/wasm-typescript build && node scripts/sync-wasm-typescript.mjs --verify",
@@ -201,7 +204,7 @@
     "support:matrix": "node scripts/support-matrix.mjs write",
     "check:support-matrix": "node scripts/support-matrix.mjs check",
     "sync:page-runtimes": "pnpm run sync:pyodide && pnpm run sync:webr && pnpm run sync:wasm-of-js-of-ocaml && pnpm run sync:wasm-typescript && pnpm run sync:wasm-octave && pnpm run sync:wasm-prolog && pnpm run sync:wasm-gleam && pnpm run sync:wasm-perl && pnpm run sync:wasm-tcl && pnpm run sync:wasm-awk && pnpm run sync:wasm-pascal && pnpm run sync:wasm-forth && pnpm run sync:wasm-j && pnpm run sync:wasm-bqn && pnpm run sync:wasm-janet && pnpm run sync:wasm-julia && pnpm run sync:wasm-nim && pnpm run sync:wasm-ruby && pnpm run sync:wasm-bash && pnpm run sync:wasm-clojurescript",
-    "page:build": "pnpm run verify:page-c3 && pnpm run verify:page-lfortran && pnpm run prepare:test-assets -- clang && pnpm run build:page-runtimes && pnpm run sync:page-runtimes && pnpm run build:static-runtime-modules && pnpm run prepare:wasm-debug-release && pnpm run layer:static-runtimes && pnpm run compress:static-runtimes && pnpm run build && pnpm run compress:build-runtimes && pnpm run verify:page-c3 build && pnpm run verify:page-lfortran build",
+    "page:build": "pnpm run verify:page-c3 && pnpm run verify:page-lfortran && pnpm run prepare:test-assets -- clang && pnpm run build:page-runtimes && pnpm run sync:page-runtimes && pnpm run build:static-runtime-modules && pnpm run prepare:wasm-debug-release && pnpm run layer:static-runtimes && pnpm run compress:static-runtimes && pnpm run assets:lock && pnpm run check:assets-lock && pnpm run build && pnpm run compress:build-runtimes && pnpm run verify:page-c3 build && pnpm run verify:page-lfortran build",
     "package:root": "svelte-kit sync && node scripts/clean-package-output.mjs && svelte-package --tsconfig ./tsconfig.package.json && publint",
     "package": "pnpm run build:publish-deps && pnpm run package:root",
     "verify:package": "node scripts/verify-package.mjs",