wasm-idle 1.0.6 → 1.0.8

package/dist/playground/clangAssetIntegrity.d.ts

@@ -13,6 +13,12 @@ export declare const BUNDLED_CLANG_ASSET_INTEGRITY: Readonly<{
         uncompressedBytes: number;
         uncompressedSha256: string;
     }>;
+    'libc-printscan-long-double.a.gz': Readonly<{
+        bytes: number;
+        sha256: string;
+        uncompressedBytes: number;
+        uncompressedSha256: string;
+    }>;
     'bin/memfs.wasm.gz': Readonly<{
         bytes: number;
         sha256: string;

package/dist/playground/clangAssetIntegrity.js

@@ -4,8 +4,9 @@ export const BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES = Object.freeze({
     cppAddon: Object.freeze({ asset: 'bin/cpp-addon.tar.gz' })
 });
 export const BUNDLED_CLANG_ASSET_INTEGRITY = Object.freeze({
-    'runtime-manifest.v1.json': integrityEntry(876, '1420808d0391ff2d8a2fdf2a9f6bbce8f728e06b1ed1651029ed80b226101444'),
-    'bin/memfs.wasm.gz': integrityEntry(18_974, 'd86f141eacd58a93511fbfb7c4e81d498eb7106a8a57df1bea7d33df3ce1f403', 345_442, '2c72ee42bd9430029dda8c6bafc9f37143f6fe88d5f1ea950a70259ab748bcfe'),
+    'runtime-manifest.v1.json': integrityEntry(967, '0b854bc6b41924420cfcc840509ecbe03af3c63ca3edd4940897917e32c8d8ad'),
+    'libc-printscan-long-double.a.gz': integrityEntry(52_723, 'b3f11e17e40fb13371a97244fdde00d5bd951ad8e20dfdf88a069167d6be628b', 111_062, '33e04007d3547095068391b42189d1ac5398dd04e9da3118dfa644ffea7f4148'),
+    'bin/memfs.wasm.gz': integrityEntry(16_111, 'a3e43451bc15ae69a7f113009e2ee82ab4db711625c1782cd45d0d3c4d38175a', 38_071, '5b741e03dd3502bcfd80e4e5055232b5d633604e1461752efed0189f93407dc3'),
     'bin/clang.wasm.gz': integrityEntry(13_121_917, '8dc032057fbeb41e4a9986dfc54b2336c17532033dee172eb0095eba9c5fbe75', 35_658_969, 'd92ef06cdd3fea88acf384db15a6f2a344790c05bcba8e9f13f5b75b36ad4a99'),
     'bin/lld.wasm.gz': integrityEntry(6_417_339, '495813efde8f354c38483749cdface7a7d9e23c8411da45a6f5f80030159eb11', 16_171_013, '34d39bc410c098e7e09933b61cc8e28699447af9a28abf4544d71b6e9cad1f9d'),
     'bin/sysroot.tar.gz': integrityEntry(5_059_493, 'c0ef46e903492383a3c7069bfd4aed0e764e8df988f92bb81eb96bea50bf2c00', 19_312_640, 'e122f1acec0642d62d8976101c542aaa5346460df6eae5a3f8efb594ff32f5ae'),

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;

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/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;

package/dist/playground/ocaml.js

@@ -5,7 +5,7 @@ import { createWasmIdleSharedBuffer } from './sharedBuffer';
 import { WorkerSession } from './workerSession';
 import { reportWorkerInputReady, reportWorkerProgress } from './workerProgress';
 import { WASM_OCAML_RUNTIME_PROFILE } from './wasmOcamlVersion';
-import { BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, ProtocolError, RuntimeConfigurationError, TimeoutError, WorkspaceValidationError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, ProtocolError, RuntimeConfigurationError, TimeoutError, WorkspaceValidationError, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, validateExecutionWorkspace } from '@wasm-idle/core';
 const OCAML_EXECUTION_LIMIT_KEYS = [
     'assetTimeoutMs',
     'startupTimeoutMs',
@@ -55,6 +55,7 @@ class Ocaml {
     moduleReceiptIdentity = '';
     manifestReceiptIdentity = '';
     maxAssetBytes = 0;
+    persistentCache = resolveRuntimeAssetCacheOptions();
     oncompilerdiagnostic;
     waitingForInput = false;
     pendingEof = false;
@@ -308,6 +309,7 @@ class Ocaml {
         let nextModuleReceipt;
         let nextManifestReceipt;
         let buffer;
+        let persistentCache;
         try {
             signal = options.signal;
             if (!this.isOperationActive(operation)) {
@@ -322,6 +324,7 @@ class Ocaml {
                 return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
             }
             limits = this.resolveOperationLimits(operation, configuredLimits);
+            persistentCache = resolveRuntimeAssetCacheOptions(typeof runtimeAssets === 'object' ? runtimeAssets?.persistentCache : undefined, options.persistentCache);
             if (!this.isOperationActive(operation)) {
                 return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
             }
@@ -459,6 +462,7 @@ class Ocaml {
                             this.moduleReceiptIdentity = receiptIdentity(nextModuleReceipt);
                             this.manifestReceiptIdentity = receiptIdentity(nextManifestReceipt);
                             this.maxAssetBytes = limits.maxAssetBytes;
+                            this.persistentCache = persistentCache;
                             resolve();
                             this.completeOperation(operation);
                             return;
@@ -473,6 +477,7 @@ class Ocaml {
                 worker.onmessage = handler;
                 worker.postMessage({
                     load: true,
+                    persistentCache,
                     moduleUrl: nextModuleUrl,
                     manifestUrl: nextManifestUrl,
                     moduleReceipt: nextModuleReceipt,
@@ -481,6 +486,7 @@ class Ocaml {
                 });
             }
             else {
+                this.persistentCache = persistentCache;
                 progress?.set?.(1);
                 if (!this.isOperationActive(operation))
                     return;
@@ -529,6 +535,7 @@ class Ocaml {
         let buffer;
         let outputCallback;
         let onDiagnostic;
+        let persistentCache;
         try {
             signal = options.signal;
             if (!this.isOperationActive(operation)) {
@@ -545,6 +552,9 @@ class Ocaml {
             if (!configuredWorker)
                 throw 'Worker not loaded';
             worker = configuredWorker;
+            persistentCache = resolveRuntimeAssetCacheOptions(this.persistentCache, options.persistentCache);
+            if (!this.isOperationActive(operation))
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
             const configuredTarget = options.ocamlBackend;
             if (!this.isOperationActive(operation)) {
                 throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
@@ -814,6 +824,7 @@ class Ocaml {
                 try {
                     worker.postMessage({
                         code,
+                        persistentCache,
                         prepare,
                         target,
                         wasmBinaryenMode,