wasm-idle 1.0.5 → 1.0.7

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;

package/dist/playground/tinygoExecutableGraph.js

@@ -1,4 +1,5 @@
 import { RUNTIME_REGISTRY_MANIFEST_SCHEMA_VERSION, RuntimeConfigurationError, preflightRuntimeAssets } from '@wasm-idle/core';
+import { decompressGzip } from '@wasm-idle/llvm-core';
 export const TINYGO_EXECUTABLE_GRAPH_FORMAT = 'wasm-idle-tinygo-executable-graph-v1';
 export const TINYGO_EXECUTABLE_GRAPH_FINGERPRINT_DOMAIN = 'wasm-idle:tinygo-executable-graph:v1\n';
 const SHA256_PATTERN = /^[a-f0-9]{64}$/u;
@@ -92,8 +93,16 @@ export function snapshotTinyGoExecutableGraphProfile(value) {
     const modules = {};
     for (const rawPath of modulePaths) {
         const modulePath = requireSafePath(rawPath, 'TinyGo executable module path');
+        const binary = /^assets\/upstream-binaryen-[a-f0-9]{16}\.wasm\.gz\.bin$/.test(modulePath);
+        if (!modulePath.endsWith('.js') && !binary)
+            throw configurationError('Unsupported TinyGo graph asset path');
         const sourceModule = requireRecord(sourceModules[rawPath], `TinyGo executable module ${modulePath}`);
-        requireExactKeys(sourceModule, ['bytes', 'sha256', 'imports'], `TinyGo executable module ${modulePath}`);
+        requireExactKeys(sourceModule, [
+            'bytes',
+            'sha256',
+            'imports',
+            ...(binary ? ['uncompressedBytes', 'uncompressedSha256'] : [])
+        ], `TinyGo executable module ${modulePath}`);
         if (!Number.isSafeInteger(sourceModule.bytes) || Number(sourceModule.bytes) <= 0) {
             throw configurationError(`TinyGo executable module ${modulePath} has an invalid size`);
         }
@@ -104,6 +113,15 @@ export function snapshotTinyGoExecutableGraphProfile(value) {
             throw configurationError(`TinyGo executable module ${modulePath} imports must be an array`);
         }
         const specifiers = new Set();
+        if (binary &&
+            (sourceModule.imports.length ||
+                !Number.isSafeInteger(sourceModule.uncompressedBytes) ||
+                Number(sourceModule.uncompressedBytes) < 8 ||
+                Number(sourceModule.uncompressedBytes) > 64 * 1024 * 1024 ||
+                typeof sourceModule.uncompressedSha256 !== 'string' ||
+                !SHA256_PATTERN.test(sourceModule.uncompressedSha256))) {
+            throw configurationError('Binaryen Wasm has invalid logical receipts or imports');
+        }
         const imports = sourceModule.imports.map((rawImport, index) => {
             const graphImport = requireRecord(rawImport, `TinyGo executable module ${modulePath} import ${index}`);
             requireExactKeys(graphImport, ['specifier', 'target', 'kind'], `TinyGo executable module ${modulePath} import ${index}`);
@@ -113,12 +131,14 @@ export function snapshotTinyGoExecutableGraphProfile(value) {
                 throw configurationError(`TinyGo executable module ${modulePath} has an invalid or duplicate import specifier`);
             }
             specifiers.add(specifier);
-            if (!['static', 'dynamic', 'worker'].includes(String(graphImport.kind))) {
+            if (!['static', 'dynamic', 'worker', 'asset'].includes(String(graphImport.kind))) {
                 throw configurationError(`TinyGo executable module ${modulePath} import ${specifier} has an invalid kind`);
             }
             if (resolveImportTarget(modulePath, specifier) !== target) {
                 throw configurationError(`TinyGo executable module ${modulePath} import ${specifier} does not resolve to ${target}`);
             }
+            if ((graphImport.kind === 'asset') !== target.endsWith('.wasm.gz.bin'))
+                throw configurationError('TinyGo graph import kind does not match its target');
             importCount += 1;
             if (importCount > MAX_IMPORTS) {
                 throw configurationError(`TinyGo executable graph exceeds ${MAX_IMPORTS} imports`);
@@ -132,10 +152,16 @@ export function snapshotTinyGoExecutableGraphProfile(value) {
         modules[modulePath] = Object.freeze({
             bytes: Number(sourceModule.bytes),
             sha256: sourceModule.sha256,
+            ...(binary
+                ? {
+                    uncompressedBytes: Number(sourceModule.uncompressedBytes),
+                    uncompressedSha256: sourceModule.uncompressedSha256
+                }
+                : {}),
             imports: Object.freeze(imports)
         });
     }
-    if (!Object.prototype.hasOwnProperty.call(modules, entryPath)) {
+    if (!Object.prototype.hasOwnProperty.call(modules, entryPath) || !entryPath.endsWith('.js')) {
         throw configurationError('TinyGo executable graph entry module is missing');
     }
     for (const [modulePath, module] of Object.entries(modules)) {
@@ -179,6 +205,8 @@ export function canonicalTinyGoExecutableGraphProfile(profile) {
     for (const modulePath of paths) {
         const module = profile.modules[modulePath];
         canonical += `module\0${modulePath}\0${module.bytes}\0${module.sha256}\n`;
+        if (module.uncompressedBytes !== undefined)
+            canonical += `wasm\0${modulePath}\0${module.uncompressedBytes}\0${module.uncompressedSha256}\n`;
     }
     const edges = paths.flatMap((modulePath) => profile.modules[modulePath].imports.map((graphImport) => ({
         importer: modulePath,
@@ -312,11 +340,15 @@ function createPreflightManifest(profile, keysByPath) {
                         key: keysByPath[modulePath],
                         path: modulePath,
                         compressedSha256: receipt.sha256,
-                        uncompressedSha256: receipt.sha256,
+                        uncompressedSha256: receipt.uncompressedSha256 ?? receipt.sha256,
                         compressedBytes: receipt.bytes,
-                        uncompressedBytes: receipt.bytes,
-                        mediaType: 'text/javascript',
-                        encoding: 'identity'
+                        uncompressedBytes: receipt.uncompressedBytes ?? receipt.bytes,
+                        mediaType: receipt.uncompressedBytes !== undefined
+                            ? 'application/wasm'
+                            : 'text/javascript',
+                        encoding: receipt.uncompressedBytes !== undefined
+                            ? 'gzip'
+                            : 'identity'
                     };
                 }),
                 contracts: {
@@ -357,6 +389,7 @@ export async function loadVerifiedTinyGoExecutableGraph(options) {
     if (options.assetTimeoutMs !== undefined)
         limits.assetTimeoutMs = options.assetTimeoutMs;
     const preflight = await preflightRuntimeAssets({
+        persistentCache: options.persistentCache,
         manifest: createPreflightManifest(profile, urls.keysByPath),
         runtimeId: 'tinygo/executable-graph',
         rootUrl: urls.baseUrl,
@@ -378,7 +411,17 @@ export async function loadVerifiedTinyGoExecutableGraph(options) {
             : undefined
     });
     const sources = {};
+    const binaries = {};
     for (const modulePath of Object.keys(profile.modules)) {
+        const receipt = profile.modules[modulePath];
+        if (receipt.uncompressedBytes !== undefined) {
+            const bytes = await decompressGzip(preflight.assets[urls.keysByPath[modulePath]].bytes, modulePath, receipt.uncompressedBytes, options.signal);
+            if (bytes.byteLength !== receipt.uncompressedBytes ||
+                (await sha256Hex(bytes, options.signal)) !== receipt.uncompressedSha256)
+                throw configurationError('Binaryen Wasm logical receipt mismatch');
+            binaries[modulePath] = bytes;
+            continue;
+        }
         try {
             sources[modulePath] = fatalDecoder.decode(preflight.assets[urls.keysByPath[modulePath]].bytes);
         }
@@ -420,6 +463,15 @@ export async function loadVerifiedTinyGoExecutableGraph(options) {
     };
     try {
         for (const modulePath of order) {
+            if (profile.modules[modulePath].uncompressedBytes !== undefined) {
+                const bytes = binaries[modulePath];
+                const blobUrl = URL.createObjectURL(new Blob([Uint8Array.from(bytes)], { type: 'application/wasm' }));
+                ownedUrls.push(blobUrl);
+                if (!SAFE_BLOB_URL_PATTERN.test(blobUrl))
+                    throw configurationError('TinyGo graph received an unsafe Wasm Blob URL');
+                moduleUrls[modulePath] = blobUrl;
+                continue;
+            }
             let source = sources[modulePath];
             for (const graphImport of profile.modules[modulePath].imports) {
                 source = replaceUniqueSpecifier(source, graphImport.specifier, moduleUrls[graphImport.target], modulePath);

package/dist/playground/typescript.js

@@ -1,5 +1,5 @@
 import { resolveTypeScriptModuleUrl } from './assets';
-import { AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, validateExecutionWorkspace } from '@wasm-idle/core';
 import {} from './options';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
@@ -477,6 +477,9 @@ class TypeScriptSandbox {
                     }
                     worker.postMessage({
                         load: true,
+                        persistentCache: resolveRuntimeAssetCacheOptions(typeof runtimeAssets === 'object'
+                            ? runtimeAssets?.persistentCache
+                            : undefined, options.persistentCache),
                         moduleUrl: nextModuleUrl,
                         moduleReceipt: { ...moduleReceipt },
                         maxAssetBytes: limits.maxAssetBytes

package/dist/playground/wasmGoVersion.d.ts

@@ -1 +1 @@
-export declare const WASM_GO_ASSET_VERSION = "ec36de55be7334e4";
+export declare const WASM_GO_ASSET_VERSION = "c92a5b9dc0c99663";

package/dist/playground/wasmGoVersion.js

@@ -1 +1 @@
-export const WASM_GO_ASSET_VERSION = 'ec36de55be7334e4';
+export const WASM_GO_ASSET_VERSION = 'c92a5b9dc0c99663';

package/dist/playground/wasmOcamlVersion.d.ts

@@ -1,6 +1,6 @@
-export declare const WASM_OCAML_ASSET_VERSION = "68238d5506114430a0e57ee849a4946d11ff4517b1b4e6c56607b7c60a8cfabb";
+export declare const WASM_OCAML_ASSET_VERSION = "0c26bdcda532857e22b68ae61490c18006d3d58e5a06351e48c6c0dfd439c147";
 export declare const WASM_OCAML_RUNTIME_PROFILE: Readonly<{
-    fingerprint: "68238d5506114430a0e57ee849a4946d11ff4517b1b4e6c56607b7c60a8cfabb";
+    fingerprint: "0c26bdcda532857e22b68ae61490c18006d3d58e5a06351e48c6c0dfd439c147";
     moduleReceipt: Readonly<{
         bytes: 1892;
         sha256: "17d80beb633799e9021dc1b851bc76283494d981ec20fc315462d740284fa13a";

package/dist/playground/wasmOcamlVersion.js

@@ -1,4 +1,4 @@
-export const WASM_OCAML_ASSET_VERSION = '68238d5506114430a0e57ee849a4946d11ff4517b1b4e6c56607b7c60a8cfabb';
+export const WASM_OCAML_ASSET_VERSION = '0c26bdcda532857e22b68ae61490c18006d3d58e5a06351e48c6c0dfd439c147';
 export const WASM_OCAML_RUNTIME_PROFILE = Object.freeze({
     fingerprint: WASM_OCAML_ASSET_VERSION,
     moduleReceipt: Object.freeze({