wasm-idle 1.0.5 → 1.0.7

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,

package/dist/playground/options.d.ts

@@ -21,6 +21,8 @@ export interface SandboxWorkspaceFile {
     content: string;
 }
 export interface SandboxExecutionOptions {
+    /** Overrides instance/global persistent asset caching for this operation. */
+    persistentCache?: import('@wasm-idle/core').RuntimeAssetCacheOptions;
     debugMode?: BrowserDebugMode;
     /** @deprecated Use debugMode. true maps to trace unless the caller explicitly selects lldb. */
     debug?: boolean;

package/dist/playground/pascal.js

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

package/dist/playground/perl.js

@@ -38,6 +38,7 @@ class Perl 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/prolog.js

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

package/dist/playground/python.d.ts

@@ -1,5 +1,6 @@
 import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
 import { WorkerAssetBridge } from './assetBridge';
+import { RuntimeAssetCache } from './runtimeAssetCache';
 import { type PlaygroundRuntimeAssets } from './assets';
 import type { Sandbox, SandboxProgress } from './sandbox';
 declare class Python implements Sandbox {
@@ -26,6 +27,10 @@ declare class Python implements Sandbox {
     exit: boolean;
     assetBridge: WorkerAssetBridge | null;
     private activeOperation;
+    private runtimeAssetCache;
+    private ownsRuntimeAssetCache;
+    private disposed;
+    private disposal?;
     private readonly workerSession;
     private beginOperation;
     private isOperationActive;
@@ -46,5 +51,7 @@ declare class Python implements Sandbox {
     kill(): void;
     terminate(reason?: unknown): void;
     clear(): Promise<void>;
+    setRuntimeAssetCache(cache: RuntimeAssetCache): void;
+    dispose(): Promise<void>;
 }
 export default Python;

package/dist/playground/python.js

@@ -1,4 +1,5 @@
 import { WorkerAssetBridge } from './assetBridge';
+import { RuntimeAssetCache } from './runtimeAssetCache';
 import { resolveRuntimeAssetConfig } from './assets';
 import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
 import { createWasmIdleSharedBuffer, requireSharedArrayBuffer } from './sharedBuffer';
@@ -29,6 +30,10 @@ class Python {
     exit = true;
     assetBridge = null;
     activeOperation = null;
+    runtimeAssetCache = new RuntimeAssetCache();
+    ownsRuntimeAssetCache = true;
+    disposed = false;
+    disposal;
     workerSession = new WorkerSession({
         label: 'Python',
         onDispose: (worker) => {
@@ -44,6 +49,8 @@ class Python {
         }
     });
     beginOperation(phase) {
+        if (this.disposed)
+            throw new Error('Python runtime has been disposed');
         if (this.activeOperation) {
             throw new BusyError('Python runtime already has an active operation', {
                 runtimeId: 'PYTHON3',
@@ -198,7 +205,7 @@ class Python {
                 this.pendingInput = [];
                 this.waitingForInput = false;
                 this.pendingEof = false;
-                const assetConfig = resolveRuntimeAssetConfig('python', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+                const assetConfig = resolveRuntimeAssetConfig('python', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '', options.persistentCache);
                 if (!this.isOperationActive(operation))
                     return;
                 const needsWorkerReset = !this.worker ||
@@ -220,7 +227,7 @@ class Python {
                     }
                     this.worker = worker;
                     this.workerSession.attach(worker);
-                    const assetBridge = new WorkerAssetBridge(worker, 'python', assetConfig, progress, limits.maxAssetBytes);
+                    const assetBridge = new WorkerAssetBridge(worker, 'python', assetConfig, progress, limits.maxAssetBytes, false, this.runtimeAssetCache);
                     if (!this.isOperationActive(operation) || this.worker !== worker) {
                         assetBridge.dispose();
                         return;
@@ -259,7 +266,8 @@ class Python {
                         assets: {
                             baseUrl: assetConfig.baseUrl,
                             maxAssetBytes: limits.maxAssetBytes,
-                            useAssetBridge: assetConfig.useAssetBridge
+                            useAssetBridge: assetConfig.useAssetBridge,
+                            useModuleBridge: true
                         }
                     });
                     return;
@@ -335,11 +343,13 @@ class Python {
             activePath = options.activePath;
             debugPath = options.debugPath;
             workspaceFiles = options.workspaceFiles;
+            const persistentCache = options.persistentCache;
             if (!this.isOperationActive(activeOperation)) {
                 return Promise.reject(this.releaseBeforeSession(activeOperation, 'Python execution cancelled'));
             }
             if (debug)
                 requireSharedArrayBuffer('Python debugging');
+            this.assetBridge?.setExecutionPersistentCache(persistentCache);
             this.setBreakpoints(debug ? breakpoints : []);
         }
         catch (error) {
@@ -545,11 +555,34 @@ class Python {
         resetBufferedStdin(this.watchResultBuffer);
         const debugBuffer = new Int32Array(this.debugBuffer);
         debugBuffer.fill(0);
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        if (!this.exit) {
-            this.workerSession.terminate();
-            this.exit = true;
-        }
+        new Uint8Array(this.interruptBuffer).fill(0);
+    }
+    setRuntimeAssetCache(cache) {
+        if (this.disposed)
+            throw new Error('Python runtime has been disposed');
+        if (this.worker || this.activeOperation)
+            throw new Error('Cannot replace an active runtime cache');
+        if (cache === this.runtimeAssetCache)
+            return;
+        if (this.ownsRuntimeAssetCache)
+            this.runtimeAssetCache.dispose();
+        this.runtimeAssetCache = cache;
+        this.ownsRuntimeAssetCache = false;
+    }
+    dispose() {
+        if (this.disposal)
+            return this.disposal;
+        this.disposed = true;
+        this.disposal = Promise.resolve()
+            .then(() => this.clear())
+            .finally(() => {
+            if (this.ownsRuntimeAssetCache)
+                this.runtimeAssetCache.dispose();
+            this.output = null;
+            this.ondebug = undefined;
+            this.image = undefined;
+        });
+        return this.disposal;
     }
 }
 export default Python;

package/dist/playground/runtimeAssetCache.d.ts

@@ -0,0 +1,26 @@
+/** Immutable bootstrap assets only: never store a worker, Wasm instance, or user filesystem. */
+export declare class RuntimeAssetCache {
+    private readonly maxBytes;
+    private readonly maxEntries;
+    private entries;
+    private identities;
+    private nextIdentity;
+    private bytes;
+    private hits;
+    private misses;
+    private disposed;
+    constructor(maxBytes?: number, maxEntries?: number);
+    /** Identity is owner-local; a custom loader must never alias another loader. */
+    identity(value: object | undefined): number;
+    get<T>(key: string): T | undefined;
+    /** Only the trusted host publishes fully verified results; failures are never retained. */
+    set<T>(key: string, value: T, bytes: number): void;
+    stats(): {
+        hits: number;
+        misses: number;
+        entries: number;
+        bytes: number;
+        disposed: boolean;
+    };
+    dispose(): void;
+}

package/dist/playground/runtimeAssetCache.js

@@ -0,0 +1,84 @@
+/** Immutable bootstrap assets only: never store a worker, Wasm instance, or user filesystem. */
+export class RuntimeAssetCache {
+    maxBytes;
+    maxEntries;
+    entries = new Map();
+    identities = new WeakMap();
+    nextIdentity = 0;
+    bytes = 0;
+    hits = 0;
+    misses = 0;
+    disposed = false;
+    constructor(maxBytes = 256 * 1024 * 1024, maxEntries = 64) {
+        this.maxBytes = maxBytes;
+        this.maxEntries = maxEntries;
+        if (!Number.isSafeInteger(maxBytes) ||
+            maxBytes < 0 ||
+            !Number.isSafeInteger(maxEntries) ||
+            maxEntries < 0) {
+            throw new TypeError('Runtime cache limits must be non-negative safe integers');
+        }
+    }
+    /** Identity is owner-local; a custom loader must never alias another loader. */
+    identity(value) {
+        if (!value)
+            return 0;
+        let identity = this.identities.get(value);
+        if (identity === undefined) {
+            identity = ++this.nextIdentity;
+            this.identities.set(value, identity);
+        }
+        return identity;
+    }
+    get(key) {
+        if (this.disposed)
+            return undefined;
+        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.value;
+    }
+    /** Only the trusted host publishes fully verified results; failures are never retained. */
+    set(key, value, bytes) {
+        if (this.disposed)
+            return;
+        if (!Number.isSafeInteger(bytes) || bytes < 0)
+            throw new TypeError('Invalid cache byte count');
+        const charge = bytes + key.length * 2;
+        if (this.maxEntries === 0 || charge > this.maxBytes)
+            return;
+        const previous = this.entries.get(key);
+        if (previous)
+            this.bytes -= previous.bytes;
+        this.entries.delete(key);
+        this.entries.set(key, { value, bytes: charge });
+        this.bytes += charge;
+        while (this.entries.size > this.maxEntries || this.bytes > this.maxBytes) {
+            const oldest = this.entries.keys().next().value;
+            this.bytes -= this.entries.get(oldest).bytes;
+            this.entries.delete(oldest);
+        }
+    }
+    stats() {
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            entries: this.entries.size,
+            bytes: this.bytes,
+            disposed: this.disposed
+        };
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.entries.clear();
+        this.identities = new WeakMap();
+        this.bytes = 0;
+    }
+}

package/dist/playground/runtimeSession.d.ts

@@ -0,0 +1,21 @@
+import { type PlaygroundBindingOptions } from '@wasm-idle/core';
+import type { PlaygroundBinding, SandboxRuntimeAssets } from './sandbox';
+import { RuntimeAssetCache } from './runtimeAssetCache';
+import { CompiledArtifactCache } from './compiledArtifactCache';
+export interface PlaygroundRuntimeSession {
+    createBinding(): PlaygroundBinding & {
+        dispose(): Promise<void>;
+    };
+    selectLanguage(language: string): Promise<void>;
+    dispose(): Promise<void>;
+    getCacheStats(): {
+        language: string | undefined;
+        assets: ReturnType<RuntimeAssetCache['stats']>;
+        artifacts: ReturnType<CompiledArtifactCache['stats']>;
+    };
+}
+/**
+ * A browser-owned language session. Panels own disposable execution leases, not the
+ * compiler cache. A problem/editor change may release all leases without cooling it.
+ */
+export declare function createRuntimeSession(runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): PlaygroundRuntimeSession;

package/dist/playground/runtimeSession.js

@@ -0,0 +1,119 @@
+import { createPlaygroundBinding, normalizeLanguageId, RuntimeConfigurationError } from '@wasm-idle/core';
+import playground from './index';
+import { RuntimeAssetCache } from './runtimeAssetCache';
+import { CompiledArtifactCache } from './compiledArtifactCache';
+import { createCachedClangSandbox } from './cachedClang';
+/**
+ * A browser-owned language session. Panels own disposable execution leases, not the
+ * compiler cache. A problem/editor change may release all leases without cooling it.
+ */
+export function createRuntimeSession(runtimeAssets, options = {}) {
+    let language;
+    let epoch = 0;
+    let disposed = false;
+    let disposal;
+    let assetCache = new RuntimeAssetCache();
+    let artifactCache = new CompiledArtifactCache();
+    const leases = new Set();
+    let retiring = Promise.resolve();
+    const stale = () => new RuntimeConfigurationError('Runtime session was disposed or its language changed', {
+        phase: 'dispose'
+    });
+    const release = (owned) => {
+        const previous = retiring;
+        retiring = Promise.allSettled([previous, ...owned.map((lease) => lease.dispose())]).then((results) => {
+            const failure = results.find((result) => result.status === 'rejected');
+            if (failure?.status === 'rejected')
+                throw failure.reason;
+        });
+        // Errors remain visible to the caller without unhandled background rejections.
+        void retiring.catch(() => undefined);
+        return retiring;
+    };
+    const session = {
+        async selectLanguage(value) {
+            if (disposed)
+                throw stale();
+            const next = normalizeLanguageId(value) || value.trim().toUpperCase();
+            if (!next)
+                return;
+            if (next === language)
+                return await retiring;
+            language = next;
+            epoch++;
+            assetCache.dispose();
+            artifactCache.clear();
+            assetCache = new RuntimeAssetCache();
+            artifactCache = new CompiledArtifactCache();
+            await release([...leases].filter((lease) => lease.epoch !== undefined));
+        },
+        createBinding() {
+            if (disposed)
+                throw stale();
+            let closed = false;
+            let closing;
+            const lease = {
+                epoch: undefined,
+                dispose() {
+                    if (closing)
+                        return closing;
+                    closed = true;
+                    leases.delete(lease);
+                    closing = Promise.resolve().then(() => core.dispose());
+                    return closing;
+                }
+            };
+            const core = createPlaygroundBinding(runtimeAssets, async (target) => {
+                if (closed || disposed)
+                    throw stale();
+                const selected = session.selectLanguage(target);
+                const selectedEpoch = epoch;
+                await selected;
+                if (closed || disposed || epoch !== selectedEpoch)
+                    throw stale();
+                lease.epoch = selectedEpoch;
+                const cache = assetCache;
+                const artifacts = artifactCache;
+                const sandbox = (await playground(target));
+                if (closed || disposed || epoch !== selectedEpoch) {
+                    if (sandbox.dispose)
+                        await sandbox.dispose();
+                    else
+                        await sandbox.terminate();
+                    throw stale();
+                }
+                sandbox.setRuntimeAssetCache?.(cache);
+                return target === 'C' || target === 'CPP'
+                    ? createCachedClangSandbox(sandbox, target, cache, artifacts)
+                    : sandbox;
+            }, options);
+            leases.add(lease);
+            const binding = core;
+            // Do not override core.dispose in place: the lease calls that exact owner method.
+            return new Proxy(binding, {
+                get(target, property) {
+                    if (property === 'dispose')
+                        return lease.dispose;
+                    const value = Reflect.get(target, property);
+                    return typeof value === 'function' ? value.bind(target) : value;
+                }
+            });
+        },
+        dispose() {
+            if (disposal)
+                return disposal;
+            disposed = true;
+            epoch++;
+            assetCache.dispose();
+            artifactCache.clear();
+            disposal = release([...leases]);
+            return disposal;
+        },
+        getCacheStats: () => ({
+            language,
+            assets: assetCache.stats(),
+            artifacts: artifactCache.stats()
+        })
+    };
+    return session;
+}

package/dist/playground/rust.d.ts

@@ -19,6 +19,7 @@ declare class Rust implements Sandbox {
     debugManifestUrl: string;
     debugManifestReceipt?: Readonly<RuntimeAssetIntegrityEntry>;
     executableGraphFingerprint: string;
+    private persistentCacheBaseline?;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     waitingForInput: boolean;
     pendingEof: boolean;

package/dist/playground/rust.js

@@ -8,7 +8,7 @@ import { resolveRustNonDebugResourceLimits } from './rustWorkerLimits';
 import { WASM_RUST_EXECUTABLE_GRAPH_PROFILE, WASM_RUST_RUNTIME_PROFILE } from './wasmRustVersion';
 import { WorkerSession } from './workerSession';
 import { reportWorkerInputReady, reportWorkerProgress } from './workerProgress';
-import { resolveExecutionLimits, TimeoutError } from '@wasm-idle/core';
+import { resolveExecutionLimits, resolveRuntimeAssetCacheOptions, TimeoutError } from '@wasm-idle/core';
 const debugBreakpointBufferInts = 1028;
 const rustLldbSourcePath = '/workspace/main.rs';
 const outputEncoder = new TextEncoder();
@@ -54,6 +54,7 @@ class Rust {
     debugManifestUrl = '';
     debugManifestReceipt;
     executableGraphFingerprint = '';
+    persistentCacheBaseline;
     oncompilerdiagnostic;
     waitingForInput = false;
     pendingEof = false;
@@ -122,6 +123,7 @@ class Rust {
             let clearCandidateWait = () => { };
             try {
                 const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+                const persistentCache = resolveRuntimeAssetCacheOptions(typeof runtimeAssets === 'object' ? runtimeAssets.persistentCache : undefined, _options.persistentCache);
                 const nextCompilerUrl = resolveRustCompilerUrl(runtimeAssets, currentUrl);
                 const nextDebugModuleUrl = resolveRustDebugModuleUrl(runtimeAssets, currentUrl);
                 const debugRuntime = resolveDebugRuntimeUrls(runtimeAssets, currentUrl);
@@ -175,6 +177,7 @@ class Rust {
                     this.executableGraphFingerprint !==
                         WASM_RUST_EXECUTABLE_GRAPH_PROFILE.fingerprint;
                 if (!needsWorkerReset) {
+                    this.persistentCacheBaseline = persistentCache;
                     this.debugRuntimeBaseUrl = nextDebugRuntimeBaseUrl;
                     this.debugManifestUrl = nextDebugManifestUrl;
                     this.debugManifestReceipt = nextDebugManifestReceipt;
@@ -182,6 +185,7 @@ class Rust {
                     return;
                 }
                 nextExecutableGraph = await loadVerifiedRustExecutableGraph({
+                    persistentCache,
                     moduleUrl: nextCompilerUrl,
                     currentUrl,
                     profile: WASM_RUST_EXECUTABLE_GRAPH_PROFILE,
@@ -255,6 +259,7 @@ class Rust {
                     };
                     candidateWorker.postMessage({
                         load: true,
+                        persistentCache,
                         compilerUrl: nextExecutableGraph.entryUrl,
                         debugModuleUrl: nextDebugModuleUrl,
                         path: nextAssetPath,
@@ -274,6 +279,7 @@ class Rust {
                 this.waitingForInput = false;
                 this.pendingEof = false;
                 this.compilerUrl = nextCompilerUrl;
+                this.persistentCacheBaseline = persistentCache;
                 this.debugModuleUrl = nextDebugModuleUrl;
                 this.assetPath = nextAssetPath;
                 this.debugRuntimeBaseUrl = nextDebugRuntimeBaseUrl;
@@ -360,7 +366,9 @@ class Rust {
             }
             let limits;
             let nonDebugResourceLimits;
+            let persistentCache;
             try {
+                persistentCache = resolveRuntimeAssetCacheOptions(this.persistentCacheBaseline, options.persistentCache);
                 limits = resolveExecutionLimits(options.limits);
                 nonDebugResourceLimits =
                     debugMode === 'none' ? resolveRustNonDebugResourceLimits(limits) : undefined;
@@ -567,6 +575,7 @@ class Rust {
                     startPhaseTimeout('run', limits.runTimeoutMs);
                     const compilerWorker = this.worker;
                     const lldbSession = new LldbSandboxSession({
+                        persistentCache,
                         manifestUrl: this.debugManifestUrl,
                         manifestReceipt: this.debugManifestReceipt,
                         runtimeBaseUrl: this.debugRuntimeBaseUrl,
@@ -671,6 +680,7 @@ class Rust {
             this.begin = Date.now();
             try {
                 this.worker.postMessage({
+                    persistentCache,
                     code,
                     prepare,
                     buffer: this.buffer,

package/dist/playground/rustExecutableGraph.d.ts

@@ -70,6 +70,7 @@ export interface RustExecutableGraphProgress {
     readonly totalBytes: number;
 }
 export interface LoadRustExecutableGraphOptions {
+    readonly persistentCache?: import('@wasm-idle/core').RuntimeAssetCacheOptions;
     readonly moduleUrl: string;
     readonly currentUrl?: string;
     readonly profile: unknown;

package/dist/playground/rustExecutableGraph.js

@@ -822,6 +822,7 @@ export async function loadVerifiedRustExecutableGraph(options) {
     if (options.assetTimeoutMs !== undefined)
         limits.assetTimeoutMs = options.assetTimeoutMs;
     const preflight = await preflightRuntimeAssets({
+        persistentCache: options.persistentCache,
         manifest: createPreflightManifest(profile, sourceContext.keysByPath),
         runtimeId: 'rust/executable-graph',
         rootUrl: sourceContext.storageRootUrl,

package/dist/playground/staticRuntimePreflight.d.ts

@@ -1,4 +1,4 @@
-import { type ExecutionLimits } from '@wasm-idle/core';
+import { type ExecutionLimits, type RuntimeAssetCacheOptions } from '@wasm-idle/core';
 import { type StaticRuntimePreflightProgress, type StaticRuntimePreflightRuntimeId } from './staticRuntimePreflightProtocol';
 export interface StaticRuntimeWorkerPreflightRequest {
     readonly runtimeId: StaticRuntimePreflightRuntimeId;
@@ -7,6 +7,7 @@ export interface StaticRuntimeWorkerPreflightRequest {
     readonly manifestUrl: string;
     readonly profile: unknown;
     readonly limits?: Partial<ExecutionLimits>;
+    readonly persistentCache?: RuntimeAssetCacheOptions;
     readonly signal?: AbortSignal;
     readonly reportProgress?: (progress: StaticRuntimePreflightProgress) => void;
 }

package/dist/playground/staticRuntimePreflight.js

@@ -1,8 +1,9 @@
-import { CancelledError, ProtocolError, TimeoutError, WorkerStartupError, resolveExecutionLimits } from '@wasm-idle/core';
+import { CancelledError, ProtocolError, TimeoutError, WorkerStartupError, resolveExecutionLimits, resolveRuntimeAssetCacheOptions } from '@wasm-idle/core';
 import { STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION, collectStaticRuntimePreflightTransferables, deserializeStaticRuntimePreflightError, isStaticRuntimePreflightProgress, isStaticRuntimePreflightSerializedError } from './staticRuntimePreflightProtocol';
 const REQUEST_ID = 1;
 export async function preflightStaticRuntimeAssetsInWorker(request) {
     const limits = resolveExecutionLimits(request.limits);
+    const persistentCache = resolveRuntimeAssetCacheOptions(request.persistentCache);
     if (request.signal?.aborted) {
         throw new CancelledError(`${request.displayName} runtime preflight cancelled`, {
             cause: request.signal.reason,
@@ -210,7 +211,8 @@ export async function preflightStaticRuntimeAssetsInWorker(request) {
                     baseUrl: request.baseUrl,
                     manifestUrl: request.manifestUrl,
                     profile: request.profile,
-                    limits
+                    limits,
+                    persistentCache
                 });
             }
             catch (error) {

package/dist/playground/staticRuntimePreflightExecute.js

@@ -8,6 +8,7 @@ export async function executeStaticRuntimePreflight(request, reportProgress, sig
         baseUrl: request.baseUrl,
         manifestUrl: request.manifestUrl,
         limits: request.limits,
+        persistentCache: request.persistentCache,
         signal,
         reportProgress: (progress) => reportProgress({ kind: 'asset', progress })
     };