wasm-idle 1.0.6 → 1.0.7

package/README.md

@@ -15,6 +15,10 @@ Compiler source pins, patches, and reproducible asset builds live in
 [`seo-rii/wasm-llvm`](https://github.com/seo-rii/wasm-llvm); wasm-idle loads the generated
 artifacts from external URLs instead of embedding them in npm packages.
 
+Verified downloads can be retained across reloads using a version-pinned, capacity-bounded
+CacheStorage/IndexedDB cache. See [persistent asset cache configuration and coverage](docs/runtime-asset-cache.md)
+for global/per-call opt-out, cleanup and prefetch APIs.
+
 ## Language support policy
 
 wasm-idle language support must run user code through the real language implementation in the
@@ -221,9 +225,9 @@ when they exist.
 | Language / IDs                     | Package/version base                                                                                                                                                           | Execution defaults / flags                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Customization                                                                                                                                                                                                                                                                                                                                    |
 | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | C3<br>`C3`                         | wasm-llvm/c3-browser: C3 0.8.3 / LLVM 22.1.8                                                                                                                                   | Verified c3c and builtin LLD compile real C3 in a fresh browser Worker; UTF-8 env.readByte/env.writeByte ABI and exported main; std::io and WASI unavailable                                                                                                                                                                                                                                                                                                                                                                                                            | `runtimeAssets.c3.baseUrl`, `stdin`, `activePath`, `workspaceFiles`; fixed compiler flags and bounded Wasm memories                                                                                                                                                                                                                              |
-| C<br>`C`                           | @wasm-idle/llvm-core@1.0.3 / Clang 22.1.8 WASI sysroot from the `wasm-llvm` producer                                                                                           | `clang` for `wasm32-wasi`; default `-std=gnu11`; LLDB mode compiles untouched source with embedded DWARF at `-g -O0` and runs it in WAMR; normal runs still use the browser WASI host; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                               | `runtimeAssets.clang.baseUrl`/`loader` or `rootUrl`; `compileArgs`, `programArgs`, `cVersion`, `activePath`, `workspaceFiles`, `debugMode`, `breakpoints`, `pauseOnEntry`                                                                                                                                                                        |
-| C++<br>`CPP`                       | @wasm-idle/llvm-core@1.0.3 / Clang 22.1.8 WASI sysroot from the `wasm-llvm` producer                                                                                           | `clang++` for `wasm32-wasi`; default `-std=gnu++20`; LLDB mode compiles untouched source with embedded DWARF at `-g -O0` and runs it in WAMR; normal runs still use the browser WASI host; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                           | `runtimeAssets.clang.baseUrl`/`loader` or `rootUrl`; `compileArgs`, `programArgs`, `cppVersion`, `activePath`, `workspaceFiles`, `debugMode`, `breakpoints`, `pauseOnEntry`                                                                                                                                                                      |
-| Objective-C<br>`OBJC`              | GNUstep libobjc2 v2.3 assets from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.0.3                                                                                        | `clang -x objective-c -fobjc-runtime=gnustep-2.0 -fblocks` for `wasm32-wasi`; links `libobjc.a`, `libgnustep-base.a`, and `libffi.a` when Foundation is imported; Foundation headers are inlined from `foundation-headers.json`; includes a constructor wrapper for Objective-C class registration; auto-compiles `.m`/`.mm`/`.c` workspace files; trace debug instruments active source and uses wasm-idle controls; supports `stdin` and `programArgs`; large Objective-C assets may be served as gzip-only `.gz` files through the service worker or worker fallback | `runtimeAssets.objectivec.baseUrl`/`libobjcUrl`/`headersUrl`/`libgnustepBaseUrl`/`libgnustepBaseObjectUrl`/`foundationHeadersUrl`/`libffiUrl` or `PUBLIC_WASM_OBJECTIVEC_*`; `runtimeAssets.clang.baseUrl`/`loader` for the clang toolchain; `activePath`, `workspaceFiles`, `compileArgs`, `debug`, `breakpoints`, `pauseOnEntry`               |
+| C<br>`C`                           | @wasm-idle/llvm-core@1.0.7 / Clang 22.1.8 WASI sysroot from the `wasm-llvm` producer                                                                                           | `clang` for `wasm32-wasi`; default `-std=gnu11`; LLDB mode compiles untouched source with embedded DWARF at `-g -O0` and runs it in WAMR; normal runs still use the browser WASI host; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                               | `runtimeAssets.clang.baseUrl`/`loader` or `rootUrl`; `compileArgs`, `programArgs`, `cVersion`, `activePath`, `workspaceFiles`, `debugMode`, `breakpoints`, `pauseOnEntry`                                                                                                                                                                        |
+| C++<br>`CPP`                       | @wasm-idle/llvm-core@1.0.7 / Clang 22.1.8 WASI sysroot from the `wasm-llvm` producer                                                                                           | `clang++` for `wasm32-wasi`; default `-std=gnu++20`; LLDB mode compiles untouched source with embedded DWARF at `-g -O0` and runs it in WAMR; normal runs still use the browser WASI host; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                           | `runtimeAssets.clang.baseUrl`/`loader` or `rootUrl`; `compileArgs`, `programArgs`, `cppVersion`, `activePath`, `workspaceFiles`, `debugMode`, `breakpoints`, `pauseOnEntry`                                                                                                                                                                      |
+| Objective-C<br>`OBJC`              | GNUstep libobjc2 v2.3 assets from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.0.7                                                                                        | `clang -x objective-c -fobjc-runtime=gnustep-2.0 -fblocks` for `wasm32-wasi`; links `libobjc.a`, `libgnustep-base.a`, and `libffi.a` when Foundation is imported; Foundation headers are inlined from `foundation-headers.json`; includes a constructor wrapper for Objective-C class registration; auto-compiles `.m`/`.mm`/`.c` workspace files; trace debug instruments active source and uses wasm-idle controls; supports `stdin` and `programArgs`; large Objective-C assets may be served as gzip-only `.gz` files through the service worker or worker fallback | `runtimeAssets.objectivec.baseUrl`/`libobjcUrl`/`headersUrl`/`libgnustepBaseUrl`/`libgnustepBaseObjectUrl`/`foundationHeadersUrl`/`libffiUrl` or `PUBLIC_WASM_OBJECTIVEC_*`; `runtimeAssets.clang.baseUrl`/`loader` for the clang toolchain; `activePath`, `workspaceFiles`, `compileArgs`, `debug`, `breakpoints`, `pauseOnEntry`               |
 | Python<br>`PYTHON3`                | static ESM `static/pyodide/pyodide.mjs` / pyodide@0.29.3                                                                                                                       | loads `pyodide.mjs`, `pyodide.asm.js`, `pyodide.asm.wasm`, and `python_stdlib.zip` from the configured static asset tree on demand; supports `stdin`, workspace files, and trace debugging                                                                                                                                                                                                                                                                                                                                                                              | `runtimeAssets.python.baseUrl`/`loader` or `rootUrl`; `stdin`, `activePath`, `workspaceFiles`, `debug`, `breakpoints`, `pauseOnEntry`, `debugPath`                                                                                                                                                                                               |
 | Java<br>`JAVA`                     | @wasm-idle/runtime-teavm@0.0.0 / TeaVM compiler assets                                                                                                                         | `compiler.wasm` compiles Java to browser WASM/JS; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `runtimeAssets.java.baseUrl`/`loader` or `rootUrl`                                                                                                                                                                                                                                                                                               |
 | Rust<br>`RUST`                     | wasm-rust@0.1.0 / rust-1.99.0-browser-integrated-v1 + integrated LLVM/LLD 22.1.8 from the `wasm-llvm` producer; exact rustc/LLVM provenance is recorded for LLDB compatibility | browser host `wasm32-wasip1-threads`; default target `wasm32-wasip1`, selectable `wasm32-wasip1`, `wasm32-wasip2`, `wasm32-wasip3`; LLDB mode is currently limited to `wasm32-wasip1` and emits embedded DWARF with `-C debuginfo=2 -C opt-level=0`; normal Preview 1/2/3 execution remains unchanged; supports `stdin` and `programArgs`                                                                                                                                                                                                                               | `runtimeAssets.rust.compilerUrl`, `runtimeAssets.rust.debugModuleUrl`, or `PUBLIC_WASM_RUST_COMPILER_URL`; `rootUrl`, `rustTargetTriple`, `programArgs`, `debugMode`; compiler requests accept `edition`, `crateType`, `extendedTimeout`, `log`, and `onProgress`; runtime manifest controls compiler memory, timeout, and shared workspace size |
@@ -261,8 +265,8 @@ when they exist.
 | Ruby<br>`RUBY`                     | receipt-pinned `static/wasm-ruby` profile produced from @ruby/3.4-wasm-wasi@2.9.3-2.9.4 + @ruby/wasm-wasi@2.9.3-2.9.4                                                          | host-verifies the manifest, canonical stored module and gzip bytes, and logical WASM before transferring three owned buffers to a no-fetch CRuby 3.4 worker; supports `stdin`, `programArgs`, and workspace files                                                                                                                                                                                                                                                                                                                                                       | `rootUrl` mirrors reuse the bundled profile; explicit `runtimeAssets.ruby` overrides require one complete profile and same-origin canonical paths; URL-only `PUBLIC_WASM_RUBY_*` overrides fail closed; `stdin`, `programArgs`, `workspaceFiles`                                                                                                 |
 | Haskell<br>`HASKELL`               | ghc-in-browser / GHC 9.14.0.20251031 WASI rootfs                                                                                                                               | loads `dyld.mjs`, `rootfs.tar.zst`, `bsdtar.wasm`; `compileArgs` become GHC args, otherwise legacy `args` become GHC args                                                                                                                                                                                                                                                                                                                                                                                                                                               | `runtimeAssets.haskell.moduleUrl`/`rootfsUrl`/`bsdtarUrl`; `mainSoPath`, `searchDirs`, `activePath`, `workspaceFiles`                                                                                                                                                                                                                            |
 | LFortran<br>`LFORTRAN`             | receipt-pinned `wasm-llvm/producer/lfortran-browser` artifacts in `static/wasm-lfortran`                                                                                       | real LFortran 0.65.0-97-gab867a23 LLVM evaluator compiles and executes Emscripten side modules in a fresh Worker; shared-ring stdin supports delayed READ and EOF; experimental Fortran feature coverage                                                                                                                                                                                                                                                                                                                                                                | `runtimeAssets.lfortran.baseUrl` relocates the reviewed bundle; `stdin`, `activePath`, workspace data/include files, cancellation and execution limits; no program arguments or multi-file module build orchestration                                                                                                                            |
-| Fortran<br>`FORTRAN`               | Netlib f2c 2022-09-09 + `@cowasm/f2c 1.0.0` libf2c + @wasm-idle/llvm-core@1.0.3                                                                                                | runs `f2c.wasm` in WASI, compiles generated C with the llvm-core Clang host, links `libf2c.a`, then executes the resulting WASI module with `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                   | `runtimeAssets.fortran.baseUrl`/`f2cWasmUrl`/`libf2cUrl`/`f2cHeaderUrl`/`analyzerUrl` or `PUBLIC_WASM_FORTRAN_*`; `runtimeAssets.clang.baseUrl`/`loader` for the C backend; `activePath`, `workspaceFiles`, `compileArgs`                                                                                                                        |
-| COBOL<br>`COBOL`                   | GnuCOBOL 3.2 + GMP 6.3.0 assets from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.0.3                                                                                     | native gzip delivery for the frontend Wasm and filesystem tar assets; translates free-format COBOL with the real GnuCOBOL `cobc` frontend, compiles the generated C with the llvm-core Clang host, links libcob/GMP, and executes the resulting WASI module with `stdin` and `programArgs`                                                                                                                                                                                                                                                                              | `runtimeAssets.cobol.baseUrl` or `PUBLIC_WASM_COBOL_BASE_URL`; `runtimeAssets.clang.baseUrl`/`loader` for the C backend; `activePath`, `workspaceFiles`, `compileArgs`                                                                                                                                                                           |
+| Fortran<br>`FORTRAN`               | Netlib f2c 2022-09-09 + `@cowasm/f2c 1.0.0` libf2c + @wasm-idle/llvm-core@1.0.7                                                                                                | runs `f2c.wasm` in WASI, compiles generated C with the llvm-core Clang host, links `libf2c.a`, then executes the resulting WASI module with `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                   | `runtimeAssets.fortran.baseUrl`/`f2cWasmUrl`/`libf2cUrl`/`f2cHeaderUrl`/`analyzerUrl` or `PUBLIC_WASM_FORTRAN_*`; `runtimeAssets.clang.baseUrl`/`loader` for the C backend; `activePath`, `workspaceFiles`, `compileArgs`                                                                                                                        |
+| COBOL<br>`COBOL`                   | GnuCOBOL 3.2 + GMP 6.3.0 assets from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.0.7                                                                                     | native gzip delivery for the frontend Wasm and filesystem tar assets; translates free-format COBOL with the real GnuCOBOL `cobc` frontend, compiles the generated C with the llvm-core Clang host, links libcob/GMP, and executes the resulting WASI module with `stdin` and `programArgs`                                                                                                                                                                                                                                                                              | `runtimeAssets.cobol.baseUrl` or `PUBLIC_WASM_COBOL_BASE_URL`; `runtimeAssets.clang.baseUrl`/`loader` for the C backend; `activePath`, `workspaceFiles`, `compileArgs`                                                                                                                                                                           |
 | R<br>`R`                           | versioned static `static/webr/<hash>/webr.js` / webr@0.6.0                                                                                                                     | loads the browser ESM entry `webr.js` and its WebR runtime files from the configured static asset tree on demand; supports `stdin`, `programArgs`, and workspace files                                                                                                                                                                                                                                                                                                                                                                                                  | `runtimeAssets.r.baseUrl` or `PUBLIC_WASM_R_BASE_URL`; `stdin`, `programArgs`, `activePath`, `workspaceFiles`                                                                                                                                                                                                                                    |
 | Octave<br>`OCTAVE`                 | Octave 10.3.0 (octave-10.3.0-pl5321h996e327_3.tar.bz2)                                                                                                                         | Octave CLI Emscripten worker; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `runtimeAssets.octave.baseUrl`/`workerUrl`/`manifestUrl` or `PUBLIC_WASM_OCTAVE_*`                                                                                                                                                                                                                                                               |
 | DuckDB<br>`DUCKDB`                 | static ESM `static/wasm-duckdb/runtime.mjs` produced from @duckdb/duckdb-wasm@1.33.1-dev45.0                                                                                   | selects the best DuckDB-Wasm MVP/EH bundle on demand and creates a fresh in-memory database per run; `stdin` is registered as `stdin.txt` and `/dev/stdin` rather than terminal stdin                                                                                                                                                                                                                                                                                                                                                                                   | `runtimeAssets.duckdb.moduleUrl` or `PUBLIC_WASM_DUCKDB_MODULE_URL` or `rootUrl`; `stdin`, `activePath`, `workspaceFiles`                                                                                                                                                                                                                        |
@@ -323,6 +327,15 @@ toolchains can be consumed from pinned external runtime repositories:
   normal runtime workspace packages. `tools/dool` contains the Docker judge backend for Elixir and
   the other server-side language runners.
 
+Deployment builds retain both legacy `.gz` and canonical `.gz.bin` URLs by default.
+After building and compressing the page, `pnpm run compact:build-runtimes` reports
+byte-identical duplicates without changing files. Add `--drop-legacy-aliases` to
+remove those duplicate files and add compatibility routing to the generated service
+worker. This only preserves legacy URLs in service-worker-controlled requests:
+external SDKs and uncontrolled first requests to the removed `.gz` URLs need to
+migrate to `.gz.bin` or use server aliases. Opt in only after that migration. Source
+assets and producer receipts stay intact; rerun compaction after each page build.
+
 Useful workspace commands:
 
 ```bash

package/dist/index.d.ts

@@ -2,10 +2,11 @@ import playground, { createPlaygroundBinding } from './playground';
 export default playground;
 export { createPlaygroundBinding, playground };
 export { createRuntimeSession } from './playground/runtimeSession';
+export { configureRuntimeAssetCache, createRuntimeAssetCacheBackend, fetchPinnedRuntimeAsset, prefetchRuntimeAssets, resolveRuntimeAssetLockEntry, type PrefetchRuntimeAssetsOptions, type PrefetchRuntimeAssetsResult, type RuntimeAssetCacheStats, type RuntimeAssetCacheBackend, type RuntimeAssetCacheBackendIdentity, type PinnedRuntimeAssetRequest, getRuntimeAssetCacheOptions, getRuntimeAssetCacheStats, clearRuntimeAssetCache, pruneRuntimeAssetCache, requestRuntimeAssetCachePersistence, type RuntimeAssetCacheOptions } from '@wasm-idle/core';
 export type { PlaygroundRuntimeSession } from './playground/runtimeSession';
 export { isSharedArrayBufferAvailable, requireSharedArrayBuffer } from './playground/sharedBuffer';
 export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, TerminalControl } from '@wasm-idle/core';
 export type { CompilerDiagnostic, SandboxExecutionOptions } from './playground/options';
 export type { PlaygroundRuntimeAssets, RuntimeAssetConfig, RuntimeAssetLoadRequest, RuntimeAssetLoader, RuntimeAssetLoaderResult } from './playground/assets';
 export type { BoundSandbox, PlaygroundBinding, PlaygroundTerminalProps, SandboxProgress, SandboxRuntimeAssets } from './playground/sandbox';
-export type { PlaygroundBindingOptions } from "@wasm-idle/core";
+export type { PlaygroundBindingOptions } from '@wasm-idle/core';

package/dist/index.js

@@ -2,4 +2,5 @@ import playground, { createPlaygroundBinding } from './playground';
 export default playground;
 export { createPlaygroundBinding, playground };
 export { createRuntimeSession } from './playground/runtimeSession';
+export { configureRuntimeAssetCache, createRuntimeAssetCacheBackend, fetchPinnedRuntimeAsset, prefetchRuntimeAssets, resolveRuntimeAssetLockEntry, getRuntimeAssetCacheOptions, getRuntimeAssetCacheStats, clearRuntimeAssetCache, pruneRuntimeAssetCache, requestRuntimeAssetCachePersistence } from '@wasm-idle/core';
 export { isSharedArrayBufferAvailable, requireSharedArrayBuffer } from './playground/sharedBuffer';

package/dist/playground/assetBridge.d.ts

@@ -1,5 +1,5 @@
 import { type ResolvedRuntimeAssetConfig, type RuntimeAssetRuntime } from './assets';
-import { type ProgressLike } from '@wasm-idle/core';
+import { type RuntimeAssetCacheOptions, type ResolvedRuntimeAssetCacheOptions, type ProgressLike } from '@wasm-idle/core';
 import { RuntimeAssetCache } from './runtimeAssetCache';
 export declare const boundedUtf8ByteLength: (value: string, maxBytes?: number) => number;
 export declare class WorkerAssetBridge {
@@ -7,6 +7,8 @@ export declare class WorkerAssetBridge {
     private worker;
     private readonly runtime;
     private config;
+    private persistentCacheBaseline;
+    private readonly persistentCacheBySignal;
     private progress;
     private expectedAssets;
     private languageSysroots;
@@ -17,6 +19,8 @@ export declare class WorkerAssetBridge {
     private maxAssetBytes;
     constructor(worker: Worker, runtime: RuntimeAssetRuntime, config: ResolvedRuntimeAssetConfig, progress?: ProgressLike, maxAssetBytes?: number, languageSysroots?: boolean, cache?: RuntimeAssetCache | undefined);
     matches(config: ResolvedRuntimeAssetConfig, maxAssetBytes?: number, languageSysroots?: boolean): boolean;
+    /** Apply one execution's policy without changing the configuration established by load(). */
+    setExecutionPersistentCache(override?: RuntimeAssetCacheOptions): ResolvedRuntimeAssetCacheOptions;
     rebind(worker: Worker, config: ResolvedRuntimeAssetConfig, progress?: ProgressLike, maxAssetBytes?: number, languageSysroots?: boolean): void;
     dispose(): void;
     resetProgress(progress?: ProgressLike): void;
@@ -31,6 +35,7 @@ export declare class WorkerAssetBridge {
     private verifyIntegrity;
     private normalizeLoaderResult;
     private fetchAsset;
+    private fetchAssetFromNetwork;
     private requireAllowedAssetUrl;
     private abortActiveLoads;
 }

package/dist/playground/assetBridge.js

@@ -1,5 +1,5 @@
 import { RUNTIME_LOAD_ASSETS } from './assets';
-import { ProtocolError, verifyRuntimeAssetIntegrity, verifyRuntimeAssetPair } from '@wasm-idle/core';
+import { ProtocolError, verifyRuntimeAssetIntegrity, verifyRuntimeAssetPair, readPersistentRuntimeAsset, writePersistentRuntimeAsset, resolveRuntimeAssetLockEntry, resolveRuntimeAssetCacheOptions } from '@wasm-idle/core';
 import { decompressGzip } from '@wasm-idle/llvm-core';
 import { readPythonPackageAssets } from './pythonPackageLock';
 import { BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES } from './clangAssetIntegrity';
@@ -379,6 +379,8 @@ export class WorkerAssetBridge {
     worker;
     runtime;
     config;
+    persistentCacheBaseline;
+    persistentCacheBySignal = new WeakMap();
     progress;
     expectedAssets;
     languageSysroots;
@@ -391,7 +393,8 @@ export class WorkerAssetBridge {
         this.cache = cache;
         this.worker = worker;
         this.runtime = runtime;
-        this.config = config;
+        this.persistentCacheBaseline = resolveRuntimeAssetCacheOptions(config.persistentCache);
+        this.config = { ...config, persistentCache: this.persistentCacheBaseline };
         this.maxAssetBytes = requireBridgeMaxAssetBytes(maxAssetBytes);
         this.languageSysroots = canUseClangLanguageSysroots(runtime, config, languageSysroots);
         this.progress = new RuntimeLoadProgress(runtime, this.languageSysroots);
@@ -407,7 +410,17 @@ export class WorkerAssetBridge {
             this.config.loader === config.loader &&
             integrityKey(this.config) === integrityKey(config) &&
             allowedBaseUrlsKey(this.config) === allowedBaseUrlsKey(config) &&
-            this.config.useAssetBridge === config.useAssetBridge);
+            this.config.useAssetBridge === config.useAssetBridge &&
+            JSON.stringify(this.persistentCacheBaseline) ===
+                JSON.stringify(resolveRuntimeAssetCacheOptions(config.persistentCache)));
+    }
+    /** Apply one execution's policy without changing the configuration established by load(). */
+    setExecutionPersistentCache(override) {
+        if (this.state !== 'active')
+            throw new Error('Cannot configure an inactive worker asset bridge');
+        const cache = resolveRuntimeAssetCacheOptions(this.persistentCacheBaseline, override);
+        this.config = { ...this.config, persistentCache: cache };
+        return cache;
     }
     rebind(worker, config, progress, maxAssetBytes = this.maxAssetBytes, languageSysroots = this.languageSysroots) {
         if (this.state === 'disposed') {
@@ -430,7 +443,8 @@ export class WorkerAssetBridge {
                 throw new Error('Cannot rebind a disposed worker asset bridge');
             }
             this.worker = worker;
-            this.config = config;
+            this.persistentCacheBaseline = resolveRuntimeAssetCacheOptions(config.persistentCache);
+            this.config = { ...config, persistentCache: this.persistentCacheBaseline };
             this.maxAssetBytes = nextMaxAssetBytes;
             this.languageSysroots = nextLanguageSysroots;
             this.expectedAssets = expectedAssetsForRuntime(this.runtime, nextLanguageSysroots);
@@ -525,6 +539,7 @@ export class WorkerAssetBridge {
         const worker = this.worker;
         const generation = this.generation;
         const controller = new AbortController();
+        this.persistentCacheBySignal.set(controller.signal, resolveRuntimeAssetCacheOptions(this.config.persistentCache));
         this.activeLoads.add(controller);
         try {
             this.validateAssetRequest(request.asset);
@@ -555,6 +570,7 @@ export class WorkerAssetBridge {
                         const receipt = BUNDLED_CLANG_ASSET_INTEGRITY[request.asset];
                         module = await compileVerifiedWasmAsset(new URL(request.asset, this.config.baseUrl).href, receipt, {
                             fetch: globalThis.fetch.bind(globalThis),
+                            persistentCache: this.persistentCacheBySignal.get(controller.signal),
                             maxAssetBytes: this.maxAssetBytes,
                             signal: controller.signal,
                             onProgress: (loaded, total) => this.progress.update(request.asset, loaded, total)
@@ -831,6 +847,56 @@ export class WorkerAssetBridge {
         return null;
     }
     async fetchAsset(url, asset, signal, maxAssetBytes = this.sourceAssetByteLimit(asset)) {
+        const requestUrl = this.requireAllowedAssetUrl(asset, url);
+        const persistentCache = this.persistentCacheBySignal.get(signal) ?? this.config.persistentCache;
+        const configured = this.config.integrity?.[asset];
+        const expected = typeof configured === 'string' ? { sha256: configured } : configured;
+        const lock = this.config.assetPrefix
+            ? resolveRuntimeAssetLockEntry(requestUrl, {
+                assetRoot: this.config.baseUrl,
+                assetPrefix: this.config.assetPrefix
+            })
+            : undefined;
+        // Existing .gz receipts without a pair describe logical bytes, not stored gzip bytes.
+        const receipt = expected && (!asset.endsWith('.gz') || expected.uncompressedSha256) ? expected : lock;
+        const identity = receipt
+            ? {
+                url: requestUrl.href,
+                sha256: receipt.sha256,
+                bytes: receipt.bytes,
+                validationKey: JSON.stringify([
+                    'bridge-v1',
+                    this.config.baseUrl,
+                    allowedBaseUrlsKey(this.config),
+                    maxAssetBytes
+                ])
+            }
+            : undefined;
+        if (identity && (identity.bytes === undefined || identity.bytes <= maxAssetBytes)) {
+            const bytes = await readPersistentRuntimeAsset({
+                identity,
+                cache: persistentCache,
+                signal
+            });
+            if (bytes) {
+                requireRuntimeAssetSize(asset, bytes.byteLength, maxAssetBytes);
+                this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+                return { bytes, mimeType: receipt?.mediaType, transferOwnership: true };
+            }
+        }
+        const loaded = await this.fetchAssetFromNetwork(url, asset, signal, maxAssetBytes);
+        if (identity && !loaded.contentEncoding) {
+            // Only checksum-matching bytes are published. Existing runtime validation still runs.
+            await writePersistentRuntimeAsset({
+                identity,
+                cache: persistentCache,
+                signal,
+                bytes: loaded.bytes
+            });
+        }
+        return loaded;
+    }
+    async fetchAssetFromNetwork(url, asset, signal, maxAssetBytes = this.sourceAssetByteLimit(asset)) {
         const requestUrl = this.requireAllowedAssetUrl(asset, url);
         if (signal.aborted)
             throw runtimeAssetAbortReason(signal);

package/dist/playground/assets.d.ts

@@ -1,3 +1,4 @@
+import { type RuntimeAssetCacheOptions } from '@wasm-idle/core';
 import { type DOuterAssetReceipts } from './dOuterAssets';
 import type { ElixirRuntimeAssetReceipts } from './elixirAssets';
 import { type FortranExecutionAssetReceipts } from './fortranAssets';
@@ -25,6 +26,7 @@ export type RuntimeAssetLoader = (request: RuntimeAssetLoadRequest) => RuntimeAs
 export type RuntimeAssetIntegrityEntry = CoreRuntimeAssetIntegrityEntry;
 export type RuntimeAssetIntegrityMap = Record<string, string | RuntimeAssetIntegrityEntry>;
 export interface RuntimeAssetConfig {
+    persistentCache?: import('@wasm-idle/core').RuntimeAssetCacheOptions;
     baseUrl?: string;
     loader?: RuntimeAssetLoader;
     loaderKey?: string;
@@ -139,11 +141,14 @@ export interface LispRuntimeAssetConfig {
     moduleUrl?: string;
     manifestUrl?: string;
     manifestFingerprint?: string;
+    /** Optional raw JSON byte receipt; distinct from the canonical manifest fingerprint. */
+    manifestReceipt?: RuntimeAssetIntegrityEntry;
 }
 export interface ResolvedLispRuntimeAssetConfig {
     moduleUrl: string;
     manifestUrl: string;
     manifestFingerprint: string;
+    manifestReceipt?: RuntimeAssetIntegrityEntry;
 }
 export interface RubyRuntimeAssetConfig {
     /** Keep full stdlib compatibility, but load its data separately from the core Wasm. */
@@ -563,6 +568,9 @@ export interface TinyGoRuntimeAssetLoaderRequest {
 export type TinyGoRuntimeAssetLoaderResult = RuntimeAssetDataResult | RuntimeAssetUrlResult | string | URL | ArrayBuffer | Uint8Array | Blob | null | undefined;
 export type TinyGoRuntimeAssetLoader = (request: TinyGoRuntimeAssetLoaderRequest) => TinyGoRuntimeAssetLoaderResult | Promise<TinyGoRuntimeAssetLoaderResult>;
 export interface ResolvedRuntimeAssetConfig {
+    persistentCache?: import('@wasm-idle/core').RuntimeAssetCacheOptions;
+    /** Built-in lock prefix; custom loaders use only explicitly supplied receipts. */
+    assetPrefix?: string;
     baseUrl: string;
     loader?: RuntimeAssetLoader;
     integrity?: RuntimeAssetIntegrityMap;
@@ -607,7 +615,7 @@ export declare const RUNTIME_LOAD_ASSETS: {
     clang: readonly ["runtime-manifest.v1.json", "bin/memfs.wasm.gz", "bin/clang.wasm.gz", "bin/lld.wasm.gz", "bin/sysroot.tar.gz"];
     clangd: readonly ["clangd.js", "clangd.wasm.gz"];
 };
-export declare function resolveRuntimeAssetConfig(runtime: RuntimeAssetRuntime, options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): ResolvedRuntimeAssetConfig;
+export declare function resolveRuntimeAssetConfig(runtime: RuntimeAssetRuntime, options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string, callCache?: RuntimeAssetCacheOptions): ResolvedRuntimeAssetConfig;
 export declare function resolveRustCompilerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveDebugRuntimeUrls(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): {
     baseUrl: string;

package/dist/playground/assets.js

@@ -1,4 +1,5 @@
 import { env as dynamicPublicEnv } from '$env/dynamic/public';
+import { resolveRuntimeAssetCacheOptions, resolveRuntimeAssetLockEntry } from '@wasm-idle/core';
 import { BUNDLED_CLANG_ASSET_INTEGRITY } from './clangAssetIntegrity';
 import { snapshotDOuterAssetConfig } from './dOuterAssets';
 import { snapshotFortranExecutionAssetReceipts } from './fortranAssets';
@@ -100,7 +101,21 @@ const RUNTIME_ASSET_FOLDERS = {
 const resolveRuntimeRootBaseUrl = (config, rootUrl = '', currentUrl = '') => config.resolveRootBaseUrl?.(rootUrl, currentUrl) ||
     resolveFolderRuntimeBaseUrl(config.folder, rootUrl, currentUrl);
 const resolveRuntimeConfiguredBaseUrl = (config, baseUrl, currentUrl = '') => config.resolveConfiguredBaseUrl?.(baseUrl, currentUrl) || normalizeBaseUrl(baseUrl, currentUrl);
-export function resolveRuntimeAssetConfig(runtime, options, currentUrl = '') {
+export function resolveRuntimeAssetConfig(runtime, options, currentUrl = '', callCache) {
+    const config = resolveRuntimeAssetConfigWithoutCache(runtime, options, currentUrl);
+    const runtimeConfig = typeof options === 'object' ? options?.[runtime] : undefined;
+    const persistentCache = resolveRuntimeAssetCacheOptions(typeof options === 'object' ? options?.persistentCache : undefined, runtimeConfig?.persistentCache, callCache);
+    const assetPrefix = !config.loader && !runtimeConfig?.baseUrl
+        ? RUNTIME_ASSET_FOLDERS[runtime].folder
+        : undefined;
+    return {
+        ...config,
+        persistentCache,
+        assetPrefix,
+        useAssetBridge: config.useAssetBridge || (persistentCache.enabled && !!assetPrefix)
+    };
+}
+function resolveRuntimeAssetConfigWithoutCache(runtime, options, currentUrl = '') {
     const runtimeFolder = RUNTIME_ASSET_FOLDERS[runtime];
     if (typeof options === 'string') {
         const integrity = resolveRuntimeAssetIntegrity(runtime, undefined);
@@ -733,12 +748,21 @@ export function resolveLispRuntimeAssetConfig(options, currentUrl = '') {
     const configuredFingerprint = configured?.manifestFingerprint?.trim() ||
         (publicEnv.PUBLIC_WASM_LISP_MANIFEST_FINGERPRINT || '').trim();
     const usesBundledRoot = !configuredModuleUrl && !publicModuleUrl && rootUrl !== undefined;
+    const manifestUrl = configuredManifestUrl
+        ? resolveConfiguredUrl(configuredManifestUrl, currentUrl)
+        : deriveLispManifestUrl(moduleUrl, currentUrl);
+    const manifestReceipt = configured?.manifestReceipt ??
+        (usesBundledRoot && !configuredManifestUrl && !configuredFingerprint
+            ? resolveRuntimeAssetLockEntry(manifestUrl, {
+                assetRoot: new URL('./', new URL(moduleUrl, currentUrl || 'http://localhost/')),
+                assetPrefix: 'wasm-lisp'
+            })
+            : undefined);
     return {
         moduleUrl,
-        manifestUrl: configuredManifestUrl
-            ? resolveConfiguredUrl(configuredManifestUrl, currentUrl)
-            : deriveLispManifestUrl(moduleUrl, currentUrl),
-        manifestFingerprint: configuredFingerprint || (usesBundledRoot ? WASM_LISP_ASSET_VERSION : '')
+        manifestUrl,
+        manifestFingerprint: configuredFingerprint || (usesBundledRoot ? WASM_LISP_ASSET_VERSION : ''),
+        ...(manifestReceipt ? { manifestReceipt: Object.freeze({ ...manifestReceipt }) } : {})
     };
 }
 const RUBY_RUNTIME_CONFIG_KEYS = [

package/dist/playground/awk.js

@@ -40,6 +40,7 @@ class Awk extends StaticWorkerRuntimeSandbox {
                     manifestUrl: resolved.manifestUrl,
                     profile,
                     limits: context.limits,
+                    persistentCache: context.persistentCache,
                     signal: context.signal,
                     reportProgress(progress) {
                         loadedByAsset.set(progress.assetKey, progress.loadedBytes);

package/dist/playground/bash.d.ts

@@ -14,6 +14,7 @@ declare class Bash implements Sandbox {
     private activeOperation;
     private readyWorker;
     private loadedConfig;
+    private persistentCache?;
     private requestUid;
     private sessionUid;
     private disposed;

package/dist/playground/bash.js

@@ -1,7 +1,7 @@
 import { resolveBashRuntimeAssetConfig } from './assets';
 import { BASH_WORKER_PROTOCOL_VERSION, isBashWorkerToHostMessage } from './bashWorkerProtocol';
 import { reportWorkerProgress } from './workerProgress';
-import { AssetTooLargeError, AssetIntegrityError, AssetNotFoundError, BusyError, CancelledError, CompileError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, ProtocolError, ResourceLimitError, RuntimeConfigurationError, RuntimeExecutionError, TimeoutError, UnsupportedBrowserFeatureError, UnsupportedLanguageError, WasmIdleError, WorkerStartupError, preflightBashRuntimeAssets, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { AssetTooLargeError, AssetIntegrityError, AssetNotFoundError, BusyError, CancelledError, CompileError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, ProtocolError, ResourceLimitError, RuntimeConfigurationError, RuntimeExecutionError, TimeoutError, UnsupportedBrowserFeatureError, UnsupportedLanguageError, WasmIdleError, WorkerStartupError, preflightBashRuntimeAssets, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, validateExecutionWorkspace } from '@wasm-idle/core';
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 const textEncoder = new TextEncoder();
 const abortReason = (signal, phase) => signal.reason !== undefined
@@ -29,6 +29,7 @@ class Bash {
     activeOperation = null;
     readyWorker = null;
     loadedConfig = null;
+    persistentCache;
     requestUid = 0;
     sessionUid = 0;
     disposed = false;
@@ -85,6 +86,9 @@ class Bash {
             const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
             const resolved = resolveBashRuntimeAssetConfig(runtimeAssets, currentUrl);
             this.requireActive(operation);
+            this.persistentCache =
+                typeof runtimeAssets === 'string' ? undefined : runtimeAssets.persistentCache;
+            operation.persistentCache = resolveRuntimeAssetCacheOptions(this.persistentCache, options.persistentCache);
             const config = {
                 ...resolved,
                 identity: createBashConfigIdentity(resolved.preflightKey, limits),
@@ -165,6 +169,7 @@ class Bash {
             this.requireActive(operation);
             if (signal?.aborted)
                 throw abortReason(signal, operation.stage);
+            operation.persistentCache = resolveRuntimeAssetCacheOptions(this.persistentCache, options.persistentCache);
             const limits = resolveExecutionLimits(options.limits);
             this.requireActive(operation);
             if (!this.readyWorker) {
@@ -481,6 +486,7 @@ class Bash {
                 webcUrl: config.webcUrl,
                 profile: config.preflightProfile,
                 limits: config.limits,
+                persistentCache: operation.persistentCache,
                 signal: preflightController.signal,
                 reportProgress: ({ assetKey, loadedBytes }) => {
                     loadedByAsset.set(assetKey, loadedBytes);

package/dist/playground/bqn.js

@@ -35,6 +35,7 @@ class Bqn extends StaticWorkerRuntimeSandbox {
                     manifestUrl: urls.manifestUrl || '',
                     profile,
                     limits: context.limits,
+                    persistentCache: context.persistentCache,
                     signal: context.signal,
                     reportProgress(progress) {
                         if (progress.kind === 'asset') {

package/dist/playground/bqnPreflight.d.ts

@@ -1,5 +1,5 @@
 import type { BqnRuntimePreflightProfile } from './assets';
-import { type ExecutionLimits, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
+import { type ExecutionLimits, type RuntimeAssetCacheOptions, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
 export declare const BQN_PREFLIGHT_PROTOCOL: "wasm-idle-bqn-preflight";
 export declare const BQN_PREFLIGHT_PROTOCOL_VERSION: 1;
 export declare const BQN_PREFLIGHT_RUNTIME_ID: "BQN";
@@ -8,6 +8,7 @@ export interface BqnRuntimePreflightRequest {
     readonly manifestUrl: string;
     readonly profile: BqnRuntimePreflightProfile;
     readonly limits?: Partial<ExecutionLimits>;
+    readonly persistentCache?: RuntimeAssetCacheOptions;
     readonly signal?: AbortSignal;
     readonly fetch?: typeof globalThis.fetch;
     readonly reportProgress?: (progress: RuntimeAssetPreflightProgress) => void;

package/dist/playground/bqnPreflight.js

@@ -237,6 +237,7 @@ export async function preflightBqnRuntimeAssets(request) {
                 wasm: wasmRequestUrl
             },
             fetch: request.fetch,
+            persistentCache: request.persistentCache,
             signal: controller.signal,
             limits,
             maxConcurrentDownloads: 3,

package/dist/playground/c3.js

@@ -121,6 +121,7 @@ class C3 extends StaticWorkerRuntimeSandbox {
                     runtimeId: 'C3',
                     rootUrl: urls.baseUrl,
                     limits: context.limits,
+                    persistentCache: context.persistentCache,
                     signal: context.signal,
                     redirect: 'error',
                     requireExactResponseUrl: true,

package/dist/playground/cachedClang.js

@@ -1,4 +1,4 @@
-import { resolveExecutionLimits } from '@wasm-idle/core';
+import { resolveExecutionLimits, resolveRuntimeAssetCacheOptions } from '@wasm-idle/core';
 import { resolveRuntimeAssetConfig } from './assets';
 import { WorkerAssetBridge } from './assetBridge';
 import { shouldStreamBundledClang } from './clangStreamingPolicy';
@@ -69,7 +69,7 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
         cancelWorker?.(new Error('Process terminated'));
         resetInput();
     }
-    async function workerOperation(factory, message, token, progress, compileLimit = 0, signal) {
+    async function workerOperation(factory, message, token, progress, compileLimit = 0, signal, executionAssetConfig = assetConfig) {
         const worker = await factory();
         if (token !== generation || signal?.aborted) {
             worker.terminate();
@@ -79,7 +79,7 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
             let bridge;
             try {
                 if (compileLimit)
-                    bridge = new WorkerAssetBridge(worker, 'clang', assetConfig, progress, compileLimit, languageSysroots, runtimeCache);
+                    bridge = new WorkerAssetBridge(worker, 'clang', executionAssetConfig, progress, compileLimit, languageSysroots, runtimeCache);
             }
             catch (error) {
                 worker.terminate();
@@ -172,7 +172,7 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                 throw new Error('C/C++ sandbox was disposed');
             loadedAssets = assets;
             const config = typeof assets === 'object' ? assets : undefined;
-            assetConfig = resolveRuntimeAssetConfig('clang', assets, globalThis.location?.href || 'http://localhost/');
+            assetConfig = resolveRuntimeAssetConfig('clang', assets, globalThis.location?.href || 'http://localhost/', options.persistentCache);
             const debugMode = options.debugMode || (options.debug ? 'trace' : 'none');
             const cacheEligible = debugMode === 'none' &&
                 shouldStreamBundledClang(assetConfig) &&
@@ -194,16 +194,23 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
         async run(code, prepare, log = true, progress, args = [], options = {}) {
             if (disposed)
                 throw new Error('C/C++ sandbox was disposed');
+            if (running)
+                throw new Error('C/C++ sandbox is already running');
             if (cached &&
                 ((options.debugMode || (options.debug ? 'trace' : 'none')) !== 'none' ||
                     (options.stdin !== undefined && typeof options.stdin !== 'string') ||
                     options.workspaceFiles?.some((file) => typeof file.content !== 'string'))) {
-                await overrides.load(loadedAssets, code, log, args, options, progress);
+                await overrides.load(loadedAssets, code, log, args, {
+                    ...options,
+                    persistentCache: assetConfig.persistentCache
+                }, progress);
             }
             if (!cached)
                 return legacy.run(code, prepare, log, progress, args, options);
-            if (running)
-                throw new Error('C/C++ sandbox is already running');
+            const executionAssetConfig = {
+                ...assetConfig,
+                persistentCache: resolveRuntimeAssetCacheOptions(assetConfig.persistentCache, options.persistentCache)
+            };
             options.signal?.throwIfAborted();
             const token = ++generation;
             // Reactive UI arrays/records are Proxies and cannot cross postMessage.
@@ -246,7 +253,7 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                             useAssetBridge: assetConfig.useAssetBridge,
                             useModuleBridge: true
                         }
-                    }, token, progress, limit, options.signal);
+                    }, token, progress, limit, options.signal, executionAssetConfig);
                     if (token !== generation)
                         throw new Error('Process terminated');
                     cache.set(key, artifact);

package/dist/playground/clang.d.ts

@@ -27,6 +27,7 @@ declare class Clang implements Sandbox {
     debugRuntimeBaseUrl: string;
     debugManifestUrl: string;
     debugManifestReceipt?: Readonly<RuntimeAssetIntegrityEntry>;
+    private persistentCache?;
     private lldbSession?;
     private runtimeAssetCache;
     private ownsRuntimeAssetCache;

package/dist/playground/clang.js

@@ -39,6 +39,7 @@ class Clang {
     debugRuntimeBaseUrl = '';
     debugManifestUrl = '';
     debugManifestReceipt;
+    persistentCache;
     lldbSession;
     runtimeAssetCache = new RuntimeAssetCache();
     ownsRuntimeAssetCache = true;
@@ -91,9 +92,10 @@ class Clang {
             this.pendingInput = [];
             this.waitingForInput = false;
             this.pendingEof = false;
-            const assetConfig = resolveRuntimeAssetConfig('clang', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+            const assetConfig = resolveRuntimeAssetConfig('clang', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '', options.persistentCache);
             const debugRuntime = resolveDebugRuntimeUrls(runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
             this.debugRuntimeBaseUrl = debugRuntime.baseUrl;
+            this.persistentCache = assetConfig.persistentCache;
             this.debugManifestUrl = debugRuntime.manifestUrl;
             this.debugManifestReceipt = debugRuntime.manifestReceipt;
             const bundledAssets = shouldStreamBundledClang(assetConfig);
@@ -191,6 +193,10 @@ class Clang {
             if (!this.worker)
                 return reject('Worker not loaded');
             const operation = this.workerSession.beginRun(this.worker, reject);
+            const persistentCacheOverride = options.persistentCache;
+            if (!this.workerSession.isActive(operation))
+                return;
+            const persistentCache = this.assetBridge?.setExecutionPersistentCache(persistentCacheOverride);
             const { compileArgs, programArgs } = resolveSandboxExecutionArgs(this.language, args, options);
             const sourcePath = normalizeLldbSourcePath(options.debugPath || options.activePath, this.language === 'C' ? 'main.c' : 'main.cc');
             this.lldbBreakpoints.clear();
@@ -228,6 +234,7 @@ class Clang {
                 if (lldbArtifact) {
                     const compilerWorker = this.worker;
                     const lldbSession = new LldbSandboxSession({
+                        persistentCache: persistentCache ?? this.persistentCache,
                         manifestUrl: this.debugManifestUrl,
                         manifestReceipt: this.debugManifestReceipt,
                         runtimeBaseUrl: this.debugRuntimeBaseUrl,

package/dist/playground/clojurescript.js

@@ -35,6 +35,7 @@ class ClojureScript extends StaticWorkerRuntimeSandbox {
                     manifestUrl: urls.manifestUrl || '',
                     profile,
                     limits: context.limits,
+                    persistentCache: context.persistentCache,
                     signal: context.signal,
                     reportProgress(progress) {
                         if (progress.kind === 'asset') {

package/dist/playground/clojurescriptPreflight.d.ts

@@ -1,5 +1,5 @@
 import type { ClojureScriptRuntimePreflightProfile } from './assets';
-import { type ExecutionLimits, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
+import { type ExecutionLimits, type RuntimeAssetCacheOptions, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
 export declare const CLOJURESCRIPT_PREFLIGHT_PROTOCOL: "wasm-idle-clojurescript-preflight";
 export declare const CLOJURESCRIPT_PREFLIGHT_PROTOCOL_VERSION: 1;
 export declare const CLOJURESCRIPT_PREFLIGHT_RUNTIME_ID: "CLOJURESCRIPT";
@@ -8,6 +8,7 @@ export interface ClojureScriptRuntimePreflightRequest {
     readonly manifestUrl: string;
     readonly profile: ClojureScriptRuntimePreflightProfile;
     readonly limits?: Partial<ExecutionLimits>;
+    readonly persistentCache?: RuntimeAssetCacheOptions;
     readonly signal?: AbortSignal;
     readonly fetch?: typeof globalThis.fetch;
     readonly reportProgress?: (progress: RuntimeAssetPreflightProgress) => void;