wasm-idle 1.0.5 → 1.0.7

package/dist/playground/clojurescriptPreflight.js

@@ -219,6 +219,7 @@ export async function preflightClojureScriptRuntimeAssets(request) {
                 compiler: compilerRequestUrl
             },
             fetch: request.fetch,
+            persistentCache: request.persistentCache,
             signal: controller.signal,
             limits: { ...limits, maxAssetBytes },
             maxConcurrentDownloads: 2,

package/dist/playground/compiledArtifactCache.d.ts

@@ -0,0 +1,21 @@
+import type { BrowserClangArtifact, BrowserClangCompileRequest } from '@wasm-idle/llvm-core/clang';
+/** Only immutable compiler output lives here, never a worker, instance, or filesystem. */
+export declare class CompiledArtifactCache {
+    private entries;
+    private bytes;
+    private hits;
+    private misses;
+    private maxEntries;
+    private maxBytes;
+    constructor(maxEntries?: number, maxBytes?: number);
+    get(key: string): BrowserClangArtifact | undefined;
+    set(key: string, artifact: BrowserClangArtifact): void;
+    clear(): void;
+    stats(): {
+        hits: number;
+        misses: number;
+        entries: number;
+        bytes: number;
+    };
+}
+export declare function clangCompileKey(runtimeBaseUrl: string, maxAssetBytes: number, request: BrowserClangCompileRequest, languageSysroots?: boolean): string;

package/dist/playground/compiledArtifactCache.js

@@ -0,0 +1,67 @@
+/** Only immutable compiler output lives here, never a worker, instance, or filesystem. */
+export class CompiledArtifactCache {
+    entries = new Map();
+    bytes = 0;
+    hits = 0;
+    misses = 0;
+    maxEntries;
+    maxBytes;
+    constructor(maxEntries = 8, maxBytes = 32 * 1024 * 1024) {
+        this.maxEntries = maxEntries;
+        this.maxBytes = maxBytes;
+    }
+    get(key) {
+        const entry = this.entries.get(key);
+        if (!entry) {
+            this.misses++;
+            return undefined;
+        }
+        this.hits++;
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        return entry.artifact;
+    }
+    set(key, artifact) {
+        const size = artifact.bytes.byteLength + key.length * 2;
+        if (size > this.maxBytes)
+            return;
+        const old = this.entries.get(key);
+        if (old)
+            this.bytes -= old.size;
+        this.entries.delete(key);
+        this.entries.set(key, { artifact, size });
+        this.bytes += size;
+        while (this.entries.size > this.maxEntries || this.bytes > this.maxBytes) {
+            const oldest = this.entries.keys().next().value;
+            this.bytes -= this.entries.get(oldest).size;
+            this.entries.delete(oldest);
+        }
+    }
+    clear() {
+        this.entries.clear();
+        this.bytes = 0;
+    }
+    stats() {
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            entries: this.entries.size,
+            bytes: this.bytes
+        };
+    }
+}
+export function clangCompileKey(runtimeBaseUrl, maxAssetBytes, request, languageSysroots = false) {
+    return JSON.stringify([
+        'wasm-idle/clang-cache-v2',
+        runtimeBaseUrl,
+        maxAssetBytes,
+        languageSysroots,
+        request.language,
+        request.code,
+        request.activePath,
+        request.compileArgs,
+        request.cVersion,
+        request.cppVersion,
+        [...(request.workspaceFiles || [])].sort((a, b) => a.path.localeCompare(b.path))
+    ]);
+}

package/dist/playground/elixir.js

@@ -1,6 +1,6 @@
 import { resolveElixirBundleUrl, resolveErlangBundleUrl } from './assets';
 import { snapshotElixirRuntimeAssetReceipts } from './elixirAssets';
-import { AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, validateExecutionWorkspace } from '@wasm-idle/core';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
 import { WorkerSession } from './workerSession';
@@ -285,6 +285,9 @@ class Elixir {
                     worker.onmessage = handler;
                     worker.postMessage({
                         load: true,
+                        persistentCache: resolveRuntimeAssetCacheOptions(typeof runtimeAssets === 'object'
+                            ? runtimeAssets?.persistentCache
+                            : undefined, options.persistentCache),
                         bundleUrl: this.bundleUrl,
                         assetReceipts,
                         maxAssetBytes: limits.maxAssetBytes,

package/dist/playground/forth.js

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

package/dist/playground/forthPreflight.d.ts

@@ -1,5 +1,5 @@
 import type { ForthRuntimePreflightProfile } 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 FORTH_PREFLIGHT_PROTOCOL: "wasm-idle-forth-preflight";
 export declare const FORTH_PREFLIGHT_PROTOCOL_VERSION: 1;
 export declare const FORTH_PREFLIGHT_RUNTIME_ID: "FORTH";
@@ -8,6 +8,7 @@ export interface ForthRuntimePreflightRequest {
     readonly manifestUrl: string;
     readonly profile: ForthRuntimePreflightProfile;
     readonly limits?: Partial<ExecutionLimits>;
+    readonly persistentCache?: RuntimeAssetCacheOptions;
     readonly signal?: AbortSignal;
     readonly fetch?: typeof globalThis.fetch;
     readonly reportProgress?: (progress: RuntimeAssetPreflightProgress) => void;

package/dist/playground/forthPreflight.js

@@ -172,6 +172,7 @@ export async function preflightForthRuntimeAssets(request) {
             runtime: runtimeRequestUrl
         },
         fetch: request.fetch,
+        persistentCache: request.persistentCache,
         signal: request.signal,
         limits: request.limits,
         maxConcurrentDownloads: 2,

package/dist/playground/fortran.js

@@ -1,6 +1,6 @@
 import { WorkerAssetBridge } from './assetBridge';
 import { resolveFortranRuntimeAssetConfig, resolveRuntimeAssetConfig } from './assets';
-import { AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, validateExecutionWorkspace } from '@wasm-idle/core';
 import { FORTRAN_EXECUTION_ASSET_NAMES } from './fortranAssets';
 import { resolveSandboxExecutionArgs } from './options';
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
@@ -288,6 +288,7 @@ class Fortran {
                     let assetBridge;
                     try {
                         assetBridge = new WorkerAssetBridge(worker, 'clang', clangAssets, progress, limits.maxAssetBytes);
+                        assetBridge.setExecutionPersistentCache(options.persistentCache);
                     }
                     catch (error) {
                         try {
@@ -353,6 +354,9 @@ class Fortran {
                     worker.onmessage = handler;
                     worker.postMessage({
                         load: true,
+                        persistentCache: resolveRuntimeAssetCacheOptions(typeof runtimeAssets === 'object'
+                            ? runtimeAssets?.persistentCache
+                            : undefined, options.persistentCache),
                         log,
                         code,
                         args,
@@ -373,6 +377,7 @@ class Fortran {
                     if (!assetBridge)
                         return rejectOperation('Fortran asset bridge is not loaded');
                     assetBridge.rebind(worker, clangAssets, progress, limits.maxAssetBytes);
+                    assetBridge.setExecutionPersistentCache(options.persistentCache);
                     if (!this.isOperationActive(operation) ||
                         this.worker !== worker ||
                         this.assetBridge !== assetBridge) {
@@ -444,6 +449,7 @@ class Fortran {
             const assetBridge = this.assetBridge;
             if (!assetBridge)
                 throw 'Fortran asset bridge is not loaded';
+            assetBridge.setExecutionPersistentCache(options.persistentCache);
             const hasExplicitStdin = stdin !== undefined;
             if (hasExplicitStdin) {
                 activeOperation.explicitStdin = true;

package/dist/playground/haskell.js

@@ -1,5 +1,5 @@
 import { resolveHaskellBsdtarUrl, resolveHaskellModuleUrl, resolveHaskellRootfsUrl } from './assets';
-import { BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, snapshotHaskellRuntimeAssetReceipts, validateExecutionWorkspace } from '@wasm-idle/core';
+import { BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, snapshotHaskellRuntimeAssetReceipts, validateExecutionWorkspace } from '@wasm-idle/core';
 import { resolveSandboxExecutionArgs } from './options';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
@@ -367,6 +367,9 @@ class Haskell {
                     worker.onmessage = handler;
                     worker.postMessage({
                         load: true,
+                        persistentCache: resolveRuntimeAssetCacheOptions(typeof runtimeAssets === 'object'
+                            ? runtimeAssets?.persistentCache
+                            : undefined, options.persistentCache),
                         ...runtime,
                         log: _log
                     });

package/dist/playground/haskellAssets.d.ts

@@ -1,4 +1,4 @@
-import { type HaskellRuntimeAssetName, type HaskellRuntimeAssetReceipt, type HaskellRuntimeAssetReceipts } from '@wasm-idle/core';
+import { type RuntimeAssetCacheOptions, type HaskellRuntimeAssetName, type HaskellRuntimeAssetReceipt, type HaskellRuntimeAssetReceipts } from '@wasm-idle/core';
 export type { HaskellRuntimeAssetReceipt, HaskellRuntimeAssetReceipts };
 export interface HaskellRuntimeAssetConfig {
     readonly moduleUrl: string;
@@ -15,6 +15,7 @@ export interface HaskellRuntimeAssetProgress {
 export declare function snapshotHaskellRuntimeAssetConfig(config: HaskellRuntimeAssetConfig): HaskellRuntimeAssetConfig;
 export declare function loadVerifiedHaskellRuntimeAssets(config: HaskellRuntimeAssetConfig, options?: {
     readonly signal?: AbortSignal;
+    readonly persistentCache?: RuntimeAssetCacheOptions;
     readonly onProgress?: (progress: HaskellRuntimeAssetProgress) => void;
 }): Promise<Readonly<{
     config: HaskellRuntimeAssetConfig;

package/dist/playground/haskellAssets.js

@@ -51,20 +51,20 @@ export async function loadVerifiedHaskellRuntimeAssets(config, options = {}) {
                         ? 'Haskell GHC rootfs'
                         : 'Haskell rootfs extractor',
                 cache: 'no-store',
+                expected: receipt,
+                verify: (bytes) => verifyRuntimeAssetIntegrity({
+                    asset,
+                    bytes,
+                    expected: receipt,
+                    runtimeId: 'HASKELL'
+                }),
+                persistentCache: options.persistentCache,
                 maxAssetBytes: Math.min(receipt.bytes, snapshot.maxAssetBytes),
                 signal: controller.signal,
                 onProgress(progress) {
                     options.onProgress?.({ asset, ...progress });
                 }
             });
-            if (controller.signal.aborted)
-                throw controller.signal.reason;
-            await verifyRuntimeAssetIntegrity({
-                asset,
-                bytes,
-                expected: receipt,
-                runtimeId: 'HASKELL'
-            });
             if (controller.signal.aborted)
                 throw controller.signal.reason;
             return bytes;

package/dist/playground/index.d.ts

@@ -3,5 +3,5 @@ import { type PlaygroundBindingOptions } from '@wasm-idle/core';
 export declare const supportedLanguages: ("C" | "CPP" | "OBJC" | "D" | "TINYGO" | "RUBY" | "PERL" | "TCL" | "AWK" | "PASCAL" | "JANET" | "JULIA" | "NIM" | "BASH" | "BQN" | "CLOJURESCRIPT" | "FORTH" | "J" | "PROLOG" | "C3" | "PYTHON3" | "JAVA" | "RUST" | "GO" | "CSHARP" | "FSHARP" | "VBNET" | "ELIXIR" | "ERLANG" | "GLEAM" | "FORTRAN" | "LFORTRAN" | "COBOL" | "OCAML" | "JAVASCRIPT" | "TYPESCRIPT" | "ASSEMBLYSCRIPT" | "WAT" | "WASM" | "LUA" | "ZIG" | "LISP" | "HASKELL" | "R" | "OCTAVE" | "DUCKDB" | "SQLITE" | "PHP")[];
 export declare function createPlaygroundBinding(runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): PlaygroundBinding;
 declare function playground(language: string): Promise<Sandbox>;
-declare function playground(language: string, runtimeAssets: SandboxRuntimeAssets): Promise<BoundSandbox>;
+declare function playground(language: string, runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): Promise<BoundSandbox>;
 export default playground;

package/dist/playground/index.js

@@ -353,7 +353,7 @@ export const supportedLanguages = [...supportedLanguageIds];
 export function createPlaygroundBinding(runtimeAssets, options = {}) {
     return createCorePlaygroundBinding(runtimeAssets, playground, options);
 }
-async function playground(language, runtimeAssets) {
+async function playground(language, runtimeAssets, options = {}) {
     const normalizedLanguage = normalizeLanguageId(language);
     if (!isSupportedLanguageId(normalizedLanguage)) {
         throw new Error(`Unsupported language: ${language}`);
@@ -362,7 +362,7 @@ async function playground(language, runtimeAssets) {
     if (!route)
         throw new Error(`Missing sandbox route: ${normalizedLanguage}`);
     return runtimeAssets
-        ? createPlaygroundBinding(runtimeAssets).load(normalizedLanguage)
+        ? createPlaygroundBinding(runtimeAssets, options).load(normalizedLanguage)
         : route.load();
 }
 export default playground;

package/dist/playground/j.js

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

package/dist/playground/jPreflight.d.ts

@@ -1,5 +1,5 @@
 import type { JRuntimePreflightProfile } 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 J_PREFLIGHT_PROTOCOL: "wasm-idle-j-preflight";
 export declare const J_PREFLIGHT_PROTOCOL_VERSION: 1;
 export declare const J_PREFLIGHT_RUNTIME_ID: "J";
@@ -8,6 +8,7 @@ export interface JRuntimePreflightRequest {
     readonly manifestUrl: string;
     readonly profile: JRuntimePreflightProfile;
     readonly limits?: Partial<ExecutionLimits>;
+    readonly persistentCache?: RuntimeAssetCacheOptions;
     readonly signal?: AbortSignal;
     readonly fetch?: typeof globalThis.fetch;
     readonly reportProgress?: (progress: RuntimeAssetPreflightProgress) => void;

package/dist/playground/jPreflight.js

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

package/dist/playground/janet.js

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

package/dist/playground/java.js

@@ -285,10 +285,16 @@ class Java {
                 let resolverAssets = runtimeAssets;
                 if (runtimeAssets && typeof runtimeAssets === 'object') {
                     const runtimeConfig = runtimeAssets.java;
+                    if (!this.isOperationActive(activeOperation))
+                        return;
+                    const persistentCache = runtimeAssets.persistentCache;
                     if (!this.isOperationActive(activeOperation))
                         return;
                     let java;
                     if (runtimeConfig) {
+                        const persistentCache = runtimeConfig.persistentCache;
+                        if (!this.isOperationActive(activeOperation))
+                            return;
                         const baseUrl = runtimeConfig.baseUrl;
                         if (!this.isOperationActive(activeOperation))
                             return;
@@ -352,7 +358,7 @@ class Java {
                             : undefined;
                         if (!this.isOperationActive(activeOperation))
                             return;
-                        java = { baseUrl, loader, integrity, allowedBaseUrls };
+                        java = { baseUrl, loader, integrity, allowedBaseUrls, persistentCache };
                     }
                     let rootUrl;
                     let rootUrlRead = false;
@@ -367,10 +373,11 @@ class Java {
                             }
                             return rootUrl;
                         },
-                        java
+                        java,
+                        persistentCache
                     };
                 }
-                const assetConfig = resolveRuntimeAssetConfig('java', resolverAssets, currentUrl);
+                const assetConfig = resolveRuntimeAssetConfig('java', resolverAssets, currentUrl, options.persistentCache);
                 if (!this.isOperationActive(activeOperation))
                     return;
                 for (const asset of TEAVM_RUNTIME_ASSET_NAMES) {
@@ -449,11 +456,14 @@ class Java {
                             baseUrl: assetConfig.baseUrl,
                             useAssetBridge: assetConfig.useAssetBridge,
                             maxAssetBytes: limits.maxAssetBytes,
-                            streamCompiler: !assetConfig.loader && TEAVM_RUNTIME_ASSET_NAMES.every((asset) => {
-                                const receipt = assetConfig.integrity?.[asset];
-                                const expected = TEAVM_RUNTIME_ASSET_RECEIPTS[asset];
-                                return typeof receipt === 'object' && receipt.bytes === expected.bytes && receipt.sha256 === expected.sha256;
-                            })
+                            streamCompiler: !assetConfig.loader &&
+                                TEAVM_RUNTIME_ASSET_NAMES.every((asset) => {
+                                    const receipt = assetConfig.integrity?.[asset];
+                                    const expected = TEAVM_RUNTIME_ASSET_RECEIPTS[asset];
+                                    return (typeof receipt === 'object' &&
+                                        receipt.bytes === expected.bytes &&
+                                        receipt.sha256 === expected.sha256);
+                                })
                         }
                     });
                 }
@@ -556,9 +566,11 @@ class Java {
                 maxTotalBytes: Math.min(workspaceLimits.maxTotalBytes ?? DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, limits.maxWorkspaceBytes)
             });
             stdin = options.stdin;
+            const persistentCache = options.persistentCache;
             if (!this.isOperationActive(activeOperation) || signal?.aborted) {
                 return Promise.reject(this.releaseBeforeSession(activeOperation, 'Java execution cancelled'));
             }
+            assetBridge?.setExecutionPersistentCache(persistentCache);
             unbindPreSessionAbort();
         }
         catch (error) {

package/dist/playground/julia.js

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

package/dist/playground/lfortranAssets.d.ts

@@ -1,4 +1,4 @@
-import { type ExecutionLimits } from '@wasm-idle/core';
+import { type ExecutionLimits, type RuntimeAssetCacheOptions } from '@wasm-idle/core';
 import type { PlaygroundRuntimeAssets } from './assets';
 export declare const LFORTRAN_INITIAL_MEMORY_BYTES: number;
 export declare const LFORTRAN_RUNTIME_MANIFEST: import("@wasm-idle/core").RuntimeRegistryManifest;
@@ -13,6 +13,7 @@ export declare function resolveLfortranRuntimeAssetConfig(assets: string | Playg
 };
 export declare function preflightLfortranRuntimeAssets(baseUrl: string, options: {
     limits: ExecutionLimits;
+    persistentCache?: RuntimeAssetCacheOptions;
     signal?: AbortSignal;
     reportProgress?: (value: number, stage: string) => void;
     fetch?: typeof globalThis.fetch;

package/dist/playground/lfortranAssets.js

@@ -100,6 +100,7 @@ export async function preflightLfortranRuntimeAssets(baseUrl, options) {
             new URL(`${name === 'lfortran.data' ? 'lfortran.data.bin' : name}?v=${asset.sha256}`, baseUrl)
         ])),
         limits: options.limits,
+        persistentCache: options.persistentCache,
         signal: options.signal,
         fetch: options.fetch,
         redirect: 'error',

package/dist/playground/lisp.js

@@ -1,5 +1,5 @@
 import { resolveLispRuntimeAssetConfig } from './assets';
-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 { resolveSandboxExecutionArgs } from './options';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
@@ -329,6 +329,9 @@ class Lisp {
                     worker.onmessage = handler;
                     worker.postMessage({
                         load: true,
+                        persistentCache: resolveRuntimeAssetCacheOptions(typeof runtimeAssets === 'object'
+                            ? runtimeAssets?.persistentCache
+                            : undefined, options.persistentCache),
                         runtimeConfig: nextRuntimeConfig,
                         maxAssetBytes: limits.maxAssetBytes
                     });

package/dist/playground/lispAssets.d.ts

@@ -1,6 +1,7 @@
-import { type LispRuntimeModuleEnvironment, type VerifiedLispRuntime } from '@wasm-idle/core';
+import { type RuntimeAssetCacheOptions, type LispRuntimeModuleEnvironment, type VerifiedLispRuntime } from '@wasm-idle/core';
 import type { ResolvedLispRuntimeAssetConfig } from './assets';
 export interface LoadVerifiedLispRuntimeAssetsOptions {
+    persistentCache?: RuntimeAssetCacheOptions;
     signal?: AbortSignal;
     maxAssetBytes?: number;
     moduleEnvironment?: LispRuntimeModuleEnvironment;

package/dist/playground/lispAssets.js

@@ -41,6 +41,8 @@ export async function loadVerifiedLispRuntimeAssets(config, options = {}) {
         url: manifestUrl.href,
         label: 'Lisp runtime manifest',
         cache: 'no-cache',
+        expected: config.manifestReceipt,
+        persistentCache: options.persistentCache,
         maxAssetBytes: Math.min(MAX_LISP_MANIFEST_BYTES, maxAssetBytes),
         signal: options.signal
     });
@@ -63,6 +65,14 @@ export async function loadVerifiedLispRuntimeAssets(config, options = {}) {
                 url: assetUrl.href,
                 label: `Lisp runtime asset ${asset.logicalPath}`,
                 cache: 'force-cache',
+                expected: {
+                    sha256: asset.sha256,
+                    bytes: asset.size,
+                    uncompressedSha256: logicalAsset.sha256,
+                    uncompressedBytes: logicalAsset.size
+                },
+                persistentCache: options.persistentCache,
+                integrityContext: { asset: asset.logicalPath, runtimeId: 'LISP' },
                 maxAssetBytes: Math.min(maxAssetBytes, Math.max(asset.size, logicalAsset.size)),
                 signal
             });

package/dist/playground/lldbManifest.d.ts

@@ -1,3 +1,3 @@
-import { type RuntimeAssetIntegrityEntry } from '@wasm-idle/core';
+import { type RuntimeAssetCacheOptions, type RuntimeAssetIntegrityEntry } from '@wasm-idle/core';
 import { type RuntimeManifestV2 } from '@wasm-idle/llvm-core/debug';
-export declare function loadVerifiedDebugRuntimeManifest(url: string, expected: Readonly<RuntimeAssetIntegrityEntry> | undefined, fetchImpl: typeof fetch, signal?: AbortSignal): Promise<RuntimeManifestV2>;
+export declare function loadVerifiedDebugRuntimeManifest(url: string, expected: Readonly<RuntimeAssetIntegrityEntry> | undefined, fetchImpl: typeof fetch, signal?: AbortSignal, persistentCache?: RuntimeAssetCacheOptions): Promise<RuntimeManifestV2>;

package/dist/playground/lldbManifest.js

@@ -1,4 +1,4 @@
-import { AssetIntegrityError, AssetTooLargeError, RuntimeConfigurationError, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { AssetIntegrityError, AssetTooLargeError, RuntimeConfigurationError, verifyRuntimeAssetIntegrity, readPersistentRuntimeAsset, resolveRuntimeAssetCacheOptions, writePersistentRuntimeAsset } from '@wasm-idle/core';
 import { parseDebugRuntimeManifest } from '@wasm-idle/llvm-core/debug';
 const MAX_DEBUG_MANIFEST_BYTES = 64 * 1024;
 function abortReason(signal) {
@@ -16,7 +16,7 @@ async function cancelResponseBody(response, reason) {
         // Preserve the validation or lifecycle failure that initiated cancellation.
     }
 }
-export async function loadVerifiedDebugRuntimeManifest(url, expected, fetchImpl, signal) {
+export async function loadVerifiedDebugRuntimeManifest(url, expected, fetchImpl, signal, persistentCache) {
     if (!expected || !/^[a-f0-9]{64}$/u.test(expected.sha256)) {
         throw new RuntimeConfigurationError('LLDB runtime requires an expected manifest SHA-256 receipt.');
     }
@@ -37,6 +37,18 @@ export async function loadVerifiedDebugRuntimeManifest(url, expected, fetchImpl,
         ...(expected.bytes === undefined ? {} : { bytes: expected.bytes })
     });
     throwIfAborted(signal);
+    const policy = resolveRuntimeAssetCacheOptions(persistentCache);
+    const cache = {
+        ...policy,
+        maxEntryBytes: Math.min(policy.maxEntryBytes, MAX_DEBUG_MANIFEST_BYTES)
+    };
+    const identity = { url, ...receipt, validationKey: 'lldb-manifest-v1' };
+    const cached = await readPersistentRuntimeAsset({ identity, cache, signal });
+    if (cached) {
+        if (cached.byteLength > MAX_DEBUG_MANIFEST_BYTES)
+            throw new Error('Cached LLDB manifest exceeds size limit');
+        return parseDebugRuntimeManifest(JSON.parse(new TextDecoder().decode(cached)));
+    }
     const response = await fetchImpl(url, { cache: 'no-store', signal });
     if (!response.ok) {
         const error = new Error(`Unable to load the LLDB runtime manifest (${response.status}).`);
@@ -151,5 +163,7 @@ export async function loadVerifiedDebugRuntimeManifest(url, expected, fetchImpl,
         runtimeId: 'wasm-debug',
         profileId: 'lldb-v2'
     });
-    return parseDebugRuntimeManifest(JSON.parse(new TextDecoder().decode(bytes)));
+    const manifest = parseDebugRuntimeManifest(JSON.parse(new TextDecoder().decode(bytes)));
+    await writePersistentRuntimeAsset({ identity, cache, signal, bytes });
+    return manifest;
 }

package/dist/playground/lldbSession.d.ts

@@ -19,6 +19,7 @@ export interface LldbArtifactPayload {
     }>;
 }
 export interface LldbSandboxSessionOptions {
+    persistentCache?: import('@wasm-idle/core').RuntimeAssetCacheOptions;
     manifestUrl: string;
     manifestReceipt?: Readonly<RuntimeAssetIntegrityEntry>;
     runtimeBaseUrl: string;

package/dist/playground/lldbSession.js

@@ -184,7 +184,7 @@ export class LldbSandboxSession {
         }
         let manifest;
         try {
-            manifest = await loadVerifiedDebugRuntimeManifest(this.options.manifestUrl, this.options.manifestReceipt, this.options.fetchImpl ?? fetch, startupAbortController.signal);
+            manifest = await loadVerifiedDebugRuntimeManifest(this.options.manifestUrl, this.options.manifestReceipt, this.options.fetchImpl ?? fetch, startupAbortController.signal, this.options.persistentCache);
         }
         catch (error) {
             if (lifecycleVersion !== this.lifecycleVersion)
@@ -223,6 +223,7 @@ export class LldbSandboxSession {
         }));
         const configuredBreakpointVersion = this.breakpointVersion;
         session = createBrowserLldbSession({
+            persistentCache: this.options.persistentCache,
             manifest,
             runtimeBaseUrl: this.options.runtimeBaseUrl,
             module: this.options.artifact.bytes,

package/dist/playground/nim.js

@@ -52,6 +52,7 @@ class Nim extends StaticWorkerRuntimeSandbox {
                     manifestUrl: urls.manifestUrl || '',
                     profile,
                     limits: context.limits,
+                    persistentCache: context.persistentCache,
                     signal: context.signal,
                     reportProgress(progress) {
                         loadedByAsset.set(progress.assetKey, progress.loadedBytes);

package/dist/playground/ocaml.d.ts

@@ -15,6 +15,7 @@ declare class Ocaml implements Sandbox {
     private moduleReceiptIdentity;
     private manifestReceiptIdentity;
     private maxAssetBytes;
+    private persistentCache;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     waitingForInput: boolean;
     pendingEof: boolean;