wasm-idle 1.0.6 → 1.0.8

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

@@ -205,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 ||
@@ -343,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) {

package/dist/playground/runtimeSession.d.ts

@@ -1,3 +1,4 @@
+import { type PlaygroundBindingOptions } from '@wasm-idle/core';
 import type { PlaygroundBinding, SandboxRuntimeAssets } from './sandbox';
 import { RuntimeAssetCache } from './runtimeAssetCache';
 import { CompiledArtifactCache } from './compiledArtifactCache';
@@ -17,4 +18,4 @@ export interface PlaygroundRuntimeSession {
  * 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): PlaygroundRuntimeSession;
+export declare function createRuntimeSession(runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): PlaygroundRuntimeSession;

package/dist/playground/runtimeSession.js

@@ -7,7 +7,7 @@ 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) {
+export function createRuntimeSession(runtimeAssets, options = {}) {
     let language;
     let epoch = 0;
     let disposed = false;
@@ -86,7 +86,7 @@ export function createRuntimeSession(runtimeAssets) {
                 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.

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 })
     };

package/dist/playground/staticRuntimePreflightProtocol.d.ts

@@ -1,4 +1,4 @@
-import { type ExecutionLimits, type RuntimeAssetPreflightProgress, type RuntimeErrorCode, type RuntimePhase, type RuntimeResourceKind } from '@wasm-idle/core';
+import { type ExecutionLimits, type RuntimeAssetCacheOptions, type RuntimeAssetPreflightProgress, type RuntimeErrorCode, type RuntimePhase, type RuntimeResourceKind } from '@wasm-idle/core';
 export declare const STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION: 1;
 export type StaticRuntimePreflightRuntimeId = 'BQN' | 'CLOJURESCRIPT' | 'FORTH' | 'J' | 'JANET' | 'PROLOG';
 export type StaticRuntimePreflightProgress = {
@@ -19,6 +19,7 @@ export interface StaticRuntimePreflightRequestMessage {
     readonly manifestUrl: string;
     readonly profile: unknown;
     readonly limits: ExecutionLimits;
+    readonly persistentCache?: RuntimeAssetCacheOptions;
 }
 export interface StaticRuntimePreflightProgressMessage {
     readonly protocolVersion: typeof STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION;

package/dist/playground/staticWorkerRuntime.d.ts

@@ -1,5 +1,5 @@
 import type { PlaygroundRuntimeAssets } from './assets';
-import { type ExecutionLimits, type RuntimeAssetIntegrityEntry, type RuntimeStdinMode, type RuntimeWorkerLifetimePolicy } from '@wasm-idle/core';
+import { type ExecutionLimits, type RuntimeAssetIntegrityEntry, type RuntimeAssetCacheOptions, type RuntimeStdinMode, type RuntimeWorkerLifetimePolicy } from '@wasm-idle/core';
 import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
 import type { Sandbox, SandboxProgress } from './sandbox';
 type StaticWorkerReceipt = Readonly<Required<Pick<RuntimeAssetIntegrityEntry, 'bytes' | 'sha256'>>>;
@@ -14,6 +14,7 @@ export interface StaticWorkerRuntimeUrls {
 }
 export interface StaticWorkerRuntimePreflightContext {
     readonly limits: ExecutionLimits;
+    readonly persistentCache?: RuntimeAssetCacheOptions;
     readonly signal?: AbortSignal;
     readonly reportProgress: (value: number, stage?: string) => void;
     /**
@@ -85,6 +86,7 @@ export declare class StaticWorkerRuntimeSandbox implements Sandbox {
     private disposePromise;
     private disposeReason;
     private lifecycleProgress?;
+    private persistentCache?;
     private readonly progressController;
     private progressUid;
     private startingRunId;

package/dist/playground/staticWorkerRuntime.js

@@ -1,4 +1,4 @@
-import { AssetNotFoundError, AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, ProtocolError, RuntimeConfigurationError, RuntimeExecutionError, RuntimeProgressController, RuntimeWorkerLifetimeController, TimeoutError, WorkerStartupError, isWasmIdleError, resolveExecutionLimits, validateExecutionWorkspace, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { AssetNotFoundError, AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, ProtocolError, RuntimeConfigurationError, RuntimeExecutionError, RuntimeProgressController, RuntimeWorkerLifetimeController, TimeoutError, WorkerStartupError, isWasmIdleError, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, readPersistentRuntimeAsset, writePersistentRuntimeAsset, validateExecutionWorkspace, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
 import { resolveSandboxExecutionArgs } from './options';
 import { StaticStdinRingHost } from './staticStdinRing';
 import { deserializeStaticRuntimePreflightError, isStaticRuntimePreflightSerializedError, inspectStaticRuntimePreflightBytes } from './staticRuntimePreflightProtocol';
@@ -39,6 +39,7 @@ export class StaticWorkerRuntimeSandbox {
     disposePromise = null;
     disposeReason = null;
     lifecycleProgress;
+    persistentCache;
     progressController = new RuntimeProgressController();
     progressUid = 0;
     startingRunId = null;
@@ -134,7 +135,8 @@ export class StaticWorkerRuntimeSandbox {
     async load(runtimeAssets = '', code = '', _log = true, _args = [], options = {}, progress) {
         this.assertNotDisposed();
         try {
-            const controls = this.resolveExecutionControls(options);
+            const persistentCache = typeof runtimeAssets === 'string' ? undefined : runtimeAssets.persistentCache;
+            const controls = this.resolveExecutionControls(options, persistentCache ?? {});
             this.assertOperationNotDisposed();
             if (controls.signal?.aborted) {
                 throw new CancelledError(`${this.config.displayName} startup cancelled`, {
@@ -149,6 +151,7 @@ export class StaticWorkerRuntimeSandbox {
             const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
             const urls = this.config.resolveRuntimeAssets(runtimeAssets, currentUrl);
             this.assertOperationNotDisposed();
+            this.persistentCache = persistentCache;
             const nextManifestUrl = urls.manifestUrl || '';
             const nextManifestFingerprint = urls.manifestFingerprint || '';
             const nextPreflightKey = urls.preflightKey || '';
@@ -304,9 +307,10 @@ export class StaticWorkerRuntimeSandbox {
     beginProgressLifecycle(progress, stage) {
         return this.progressController.begin(`${this.config.languageId.toLowerCase()}-${++this.progressUid}`, progress, stage);
     }
-    resolveExecutionControls(options) {
+    resolveExecutionControls(options, persistentCache = this.persistentCache) {
         return {
             limits: resolveExecutionLimits(options.limits),
+            persistentCache: resolveRuntimeAssetCacheOptions(persistentCache, options.persistentCache),
             ...(options.signal ? { signal: options.signal } : {})
         };
     }
@@ -400,6 +404,17 @@ export class StaticWorkerRuntimeSandbox {
         if (workerRequestUrl.hash) {
             throw new RuntimeConfigurationError(`${this.config.displayName} worker script URL must not include a fragment`, { runtimeId: this.config.languageId });
         }
+        const persistentIdentity = workerReceipt
+            ? {
+                url: workerRequestUrl.href,
+                sha256: workerReceipt.sha256,
+                bytes: workerReceipt.bytes,
+                validationKey: JSON.stringify([
+                    'static-worker-v1',
+                    this.config.requireExactWorkerResponseUrl === true
+                ])
+            }
+            : undefined;
         const phaseController = new AbortController();
         let timedOut = false;
         const onAbort = () => phaseController.abort(signal?.reason);
@@ -414,6 +429,18 @@ export class StaticWorkerRuntimeSandbox {
                 throw (phaseController.signal.reason ??
                     new DOMException('Worker script fetch aborted', 'AbortError'));
             }
+            if (persistentIdentity && workerReceipt) {
+                const cached = await readPersistentRuntimeAsset({
+                    identity: persistentIdentity,
+                    cache: controls.persistentCache,
+                    signal: phaseController.signal
+                });
+                if (cached) {
+                    await this.verifyWorkerReceipt(cached, workerReceipt, phaseController.signal);
+                    this.reportProgress(progress, 0.2, `${this.config.displayName} worker cached`);
+                    return Uint8Array.from(cached);
+                }
+            }
             const pendingResponse = Promise.resolve(fetch(workerRequestUrl.href, {
                 cache: this.config.inlineVerifiedWorker ? 'no-store' : 'force-cache',
                 credentials: 'omit',
@@ -531,6 +558,12 @@ export class StaticWorkerRuntimeSandbox {
                     const bytes = new Uint8Array(buffer);
                     if (workerReceipt) {
                         await this.verifyWorkerReceipt(bytes, workerReceipt, phaseController.signal);
+                        await writePersistentRuntimeAsset({
+                            identity: persistentIdentity,
+                            cache: controls.persistentCache,
+                            signal: phaseController.signal,
+                            bytes
+                        });
                         return bytes;
                     }
                     return undefined;
@@ -641,6 +674,12 @@ export class StaticWorkerRuntimeSandbox {
                     offset += chunk.byteLength;
                 }
                 await this.verifyWorkerReceipt(bytes, workerReceipt, phaseController.signal);
+                await writePersistentRuntimeAsset({
+                    identity: persistentIdentity,
+                    cache: controls.persistentCache,
+                    signal: phaseController.signal,
+                    bytes
+                });
                 return bytes;
             }
             return undefined;
@@ -856,6 +895,7 @@ self.postMessage = (message, transferOrOptions) => {
                 progress,
                 controls: {
                     limits: controls.limits,
+                    persistentCache: controls.persistentCache,
                     signal: startAbortController.signal
                 }
             };
@@ -916,6 +956,7 @@ self.postMessage = (message, transferOrOptions) => {
             try {
                 runtimePreflight = await this.config.preflightRuntimeAssets(urls, {
                     limits: controls.limits,
+                    persistentCache: controls.persistentCache,
                     signal: controls.signal,
                     reportProgress: (value, stage) => this.reportProgress(progress, value, stage),
                     createOwnedDelivery: (payload) => {

package/dist/playground/tcl.js

@@ -39,6 +39,7 @@ class Tcl 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/tinygo.d.ts

@@ -46,6 +46,8 @@ declare class TinyGo implements Sandbox {
     rustRuntimeBaseUrl: string;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     assetLoader: TinyGoRuntimeAssetLoader | undefined;
+    private persistentCache?;
+    private persistentCacheBaseline?;
     runtimeProfile: TinyGoUpstreamRuntimeProfile | undefined;
     executableGraph: LoadedTinyGoExecutableGraph | null;
     runtime: TinyGoRuntimeHooks | null;

package/dist/playground/tinygo.js

@@ -5,7 +5,7 @@ import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinB
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
 import { WorkerSession } from './workerSession';
 import { reportWorkerProgress } from './workerProgress';
-import { BusyError, CancelledError, DEFAULT_EXECUTION_LIMITS, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, WorkspaceValidationError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { BusyError, CancelledError, DEFAULT_EXECUTION_LIMITS, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, WorkspaceValidationError, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, fetchPinnedRuntimeAsset, validateExecutionWorkspace } from '@wasm-idle/core';
 const ACTIVITY_PREFIX_PATTERN = /^\[\d{2}:\d{2}:\d{2}\]\s?/gm;
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 const TINYGO_BROWSER_COMPILER_DEFAULT_MAX_WASM_MEMORY_BYTES = 2 * 1024 * 1024 * 1024;
@@ -73,6 +73,8 @@ class TinyGo {
     rustRuntimeBaseUrl = '';
     oncompilerdiagnostic;
     assetLoader = undefined;
+    persistentCache;
+    persistentCacheBaseline;
     runtimeProfile = undefined;
     executableGraph = null;
     runtime = null;
@@ -117,8 +119,11 @@ class TinyGo {
     }
     load(runtimeAssets = '', _code = '', _log = true, _args = [], options = {}, progress) {
         return this.executeOperation('startup', options, async (operation) => {
+            const persistentCache = resolveRuntimeAssetCacheOptions(typeof runtimeAssets === 'object' ? runtimeAssets.persistentCache : undefined, options.persistentCache);
             try {
                 this.assertOperation(operation);
+                this.persistentCacheBaseline = persistentCache;
+                this.persistentCache = persistentCache;
                 this.clearPendingStdin();
                 const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
                 this.assertOperation(operation);
@@ -692,6 +697,7 @@ class TinyGo {
                     });
                 }
                 nextExecutableGraph = await loadVerifiedTinyGoExecutableGraph({
+                    persistentCache: this.persistentCache,
                     moduleUrl,
                     profile: WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE,
                     signal: operation.controller.signal,
@@ -700,6 +706,42 @@ class TinyGo {
                 });
                 this.assertOperation(operation);
                 const executableGraph = nextExecutableGraph;
+                // The upstream loader owns gzip fallback and logical-byte verification.
+                // Preserve raw .wasm probes; cache only exact profile-pinned transport URLs.
+                const transportReceipts = new Map();
+                for (const [path, receipt] of [
+                    [runtimeProfile.manifestPath, runtimeProfile.manifestReceipt],
+                    ...Object.entries(runtimeProfile.assetReceipts)
+                ]) {
+                    const transportPath = receipt.uncompressedSha256 ? `${path}.gz` : path;
+                    transportReceipts.set(new URL(transportPath, executableGraph.assetBaseUrl).href, receipt);
+                }
+                const pinnedFetch = async (input, init) => {
+                    const url = typeof input === 'string'
+                        ? input
+                        : input instanceof URL
+                            ? input.href
+                            : input.url;
+                    const receipt = transportReceipts.get(url);
+                    if (!receipt)
+                        return globalThis.fetch(input, init);
+                    const owner = this.activeOperation;
+                    if (!owner)
+                        throw new Error('TinyGo asset load has no active operation');
+                    this.assertOperation(owner);
+                    const bytes = await fetchPinnedRuntimeAsset({
+                        url,
+                        receipt,
+                        persistentCache: this.persistentCache,
+                        maxAssetBytes: owner.limits?.maxAssetBytes ?? maxAssetBytes,
+                        signal: init?.signal ?? owner.controller.signal
+                    });
+                    this.assertOperation(owner);
+                    // This is a verified byte adapter, not a network response with a fabricated URL.
+                    return new Response(Uint8Array.from(bytes).buffer, {
+                        headers: { 'Content-Length': String(bytes.byteLength) }
+                    });
+                };
                 const runtimeModule = (await import(
                 /* @vite-ignore */ executableGraph.entryUrl));
                 this.assertOperation(operation);
@@ -762,7 +804,9 @@ class TinyGo {
                                 assetsPromise = loadUpstreamAssets({
                                     assetBaseUrl: executableGraph.assetBaseUrl,
                                     profile: runtimeProfile,
-                                    ...(assetLoader ? { loader: assetLoader } : {}),
+                                    ...(assetLoader
+                                        ? { loader: assetLoader }
+                                        : { fetchImpl: pinnedFetch }),
                                     onProgress: commonOptions.onProgress,
                                     signal: controller.signal,
                                     maxAssetBytes: assetLimit
@@ -1051,6 +1095,7 @@ class TinyGo {
     }
     run(code, prepare, _log = true, _prog, args = [], options = {}) {
         return this.executeOperation('execute', options, async (operation, request) => {
+            this.persistentCache = request.persistentCache;
             this.exit = false;
             try {
                 this.begin = Date.now();
@@ -1155,6 +1200,8 @@ class TinyGo {
                 throw error;
             }
         }, (operation) => {
+            this.assertOperation(operation);
+            const persistentCache = resolveRuntimeAssetCacheOptions(this.persistentCacheBaseline, options.persistentCache);
             this.assertOperation(operation);
             if (typeof code !== 'string') {
                 throw new TypeError('TinyGo source code must be a string');
@@ -1281,7 +1328,14 @@ class TinyGo {
             const buffer = this.buffer;
             this.assertOperation(operation);
             operation.buffer = buffer;
-            return { buffer, programArgs, stdin, target, workspaceFiles: runtimeWorkspace };
+            return {
+                buffer,
+                programArgs,
+                stdin,
+                target,
+                workspaceFiles: runtimeWorkspace,
+                persistentCache
+            };
         });
     }
     resetOwnedBuffers(operationBuffer) {

package/dist/playground/tinygoExecutableGraph.d.ts

@@ -1,6 +1,6 @@
 export declare const TINYGO_EXECUTABLE_GRAPH_FORMAT: "wasm-idle-tinygo-executable-graph-v1";
 export declare const TINYGO_EXECUTABLE_GRAPH_FINGERPRINT_DOMAIN: "wasm-idle:tinygo-executable-graph:v1\n";
-export type TinyGoExecutableImportKind = 'static' | 'dynamic' | 'worker';
+export type TinyGoExecutableImportKind = 'static' | 'dynamic' | 'worker' | 'asset';
 export interface TinyGoExecutableGraphImport {
     readonly specifier: string;
     readonly target: string;
@@ -9,6 +9,8 @@ export interface TinyGoExecutableGraphImport {
 export interface TinyGoExecutableGraphModule {
     readonly bytes: number;
     readonly sha256: string;
+    readonly uncompressedBytes?: number;
+    readonly uncompressedSha256?: string;
     readonly imports: readonly TinyGoExecutableGraphImport[];
 }
 export interface TinyGoExecutableGraphProfile {
@@ -30,6 +32,7 @@ export interface TinyGoExecutableGraphProgress {
     readonly totalBytes: number;
 }
 export interface LoadTinyGoExecutableGraphOptions {
+    readonly persistentCache?: import('@wasm-idle/core').RuntimeAssetCacheOptions;
     readonly moduleUrl: string;
     readonly currentUrl?: string;
     readonly profile: unknown;