wasm-idle 1.1.0 → 1.1.2

package/dist/playground/runtimeAssetCache.js

@@ -1,193 +1 @@
-const abortReason = (signal) => signal.reason ?? new DOMException('Runtime asset load aborted', 'AbortError');
-/** Immutable bootstrap assets only: never store a worker, Wasm instance, or user filesystem. */
-export class RuntimeAssetCache {
-    maxBytes;
-    maxEntries;
-    entries = new Map();
-    inFlight = new Map();
-    inFlightKeyBytes = 0;
-    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);
-        }
-    }
-    /** Share work, but give every consumer its own cancellation and progress subscription. */
-    share(key, signal, start, onProgress) {
-        if (signal.aborted)
-            return Promise.reject(abortReason(signal));
-        let operation = this.inFlight.get(key);
-        if (!operation) {
-            // A disabled or saturated owner cache still loads assets without retaining operations.
-            if (this.disposed ||
-                this.inFlight.size >= this.maxEntries ||
-                this.inFlightKeyBytes + key.length * 2 > this.maxBytes) {
-                return Promise.resolve().then(() => {
-                    if (signal.aborted)
-                        throw abortReason(signal);
-                    return start(signal, (progress) => onProgress?.(progress));
-                });
-            }
-            const pending = {
-                controller: new AbortController(),
-                promise: undefined,
-                consumers: new Set(),
-                progress: new Map(),
-                settled: false,
-                keyBytes: key.length * 2
-            };
-            this.inFlight.set(key, pending);
-            this.inFlightKeyBytes += pending.keyBytes;
-            pending.promise = Promise.resolve().then(() => {
-                if (pending.controller.signal.aborted)
-                    throw abortReason(pending.controller.signal);
-                return start(pending.controller.signal, (progress, progressKey = '') => {
-                    pending.progress.set(progressKey, progress);
-                    for (const consumer of pending.consumers) {
-                        try {
-                            consumer(progress);
-                        }
-                        catch {
-                            // One progress listener cannot interrupt another consumer's load.
-                        }
-                    }
-                });
-            });
-            const cleanup = () => {
-                pending.settled = true;
-                pending.progress.clear();
-                this.removeOperation(key, pending);
-            };
-            void pending.promise.then(cleanup, cleanup);
-            operation = pending;
-        }
-        const shared = operation;
-        return new Promise((resolve, reject) => {
-            let active = true;
-            const receiveProgress = (progress) => {
-                if (active)
-                    onProgress?.(progress);
-            };
-            const release = () => {
-                active = false;
-                signal.removeEventListener('abort', onAbort);
-                shared.consumers.delete(receiveProgress);
-                if (!shared.settled && shared.consumers.size === 0) {
-                    this.removeOperation(key, shared);
-                    shared.controller.abort(abortReason(signal));
-                }
-            };
-            const onAbort = () => {
-                if (!active)
-                    return;
-                release();
-                reject(abortReason(signal));
-            };
-            shared.consumers.add(receiveProgress);
-            signal.addEventListener('abort', onAbort, { once: true });
-            void shared.promise.then((value) => {
-                if (!active)
-                    return;
-                release();
-                resolve(value);
-            }, (error) => {
-                if (!active)
-                    return;
-                release();
-                reject(error);
-            });
-            for (const progress of shared.progress.values()) {
-                try {
-                    receiveProgress(progress);
-                }
-                catch {
-                    // Progress is advisory, including replay to a late subscriber.
-                }
-            }
-            if (signal.aborted)
-                onAbort();
-        });
-    }
-    removeOperation(key, operation) {
-        if (this.inFlight.get(key) !== operation)
-            return;
-        this.inFlight.delete(key);
-        this.inFlightKeyBytes -= operation.keyBytes;
-    }
-    stats() {
-        return {
-            hits: this.hits,
-            misses: this.misses,
-            entries: this.entries.size,
-            bytes: this.bytes,
-            inFlight: this.inFlight.size,
-            disposed: this.disposed
-        };
-    }
-    dispose() {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        this.entries.clear();
-        // Existing consumers may finish, but a disposed owner never retains their results.
-        this.inFlight.clear();
-        this.inFlightKeyBytes = 0;
-        this.identities = new WeakMap();
-        this.bytes = 0;
-    }
-}
+export { RuntimeAssetCache } from '@wasm-idle/core';

package/dist/playground/runtimeSession.d.ts

@@ -15,7 +15,7 @@ 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.
+ * A browser-owned runtime session. Panels own disposable execution leases, while
+ * verified compiler assets survive problem, editor and language changes.
  */
 export declare function createRuntimeSession(runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): PlaygroundRuntimeSession;

package/dist/playground/runtimeSession.js

@@ -4,16 +4,16 @@ 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.
+ * A browser-owned runtime session. Panels own disposable execution leases, while
+ * verified compiler assets survive problem, editor and language changes.
  */
 export function createRuntimeSession(runtimeAssets, options = {}) {
     let language;
     let epoch = 0;
     let disposed = false;
     let disposal;
-    let assetCache = new RuntimeAssetCache();
-    let artifactCache = new CompiledArtifactCache();
+    const assetCache = new RuntimeAssetCache();
+    const artifactCache = new CompiledArtifactCache();
     const leases = new Set();
     let retiring = Promise.resolve();
     const stale = () => new RuntimeConfigurationError('Runtime session was disposed or its language changed', {
@@ -21,14 +21,17 @@ export function createRuntimeSession(runtimeAssets, options = {}) {
     });
     const release = (owned) => {
         const previous = retiring;
-        retiring = Promise.allSettled([previous, ...owned.map((lease) => lease.dispose())]).then((results) => {
+        const released = 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;
+        // Keep ordering as a completion barrier; report this failure only to its owner.
+        retiring = released.catch(() => undefined);
+        return released;
     };
     const session = {
         async selectLanguage(value) {
@@ -41,10 +44,7 @@ export function createRuntimeSession(runtimeAssets, options = {}) {
                 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() {

package/dist/playground/rust.d.ts

@@ -1,6 +1,7 @@
 import { type PlaygroundRuntimeAssets, type RuntimeAssetIntegrityEntry } from './assets';
 import { type DebugCommand, type DebugDataBreakpoint, type DebugDataBreakpointInfoArguments, type DebugSessionEvent, type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
 import type { Sandbox, SandboxProgress } from './sandbox';
+import { RuntimeAssetCache } from '@wasm-idle/core';
 declare class Rust implements Sandbox {
     output: any;
     ondebug?: (event: DebugSessionEvent) => void;
@@ -19,6 +20,9 @@ declare class Rust implements Sandbox {
     debugManifestUrl: string;
     debugManifestReceipt?: Readonly<RuntimeAssetIntegrityEntry>;
     executableGraphFingerprint: string;
+    private runtimeAssetsKey;
+    private runtimeAssetCache;
+    private ownsRuntimeAssetCache;
     private persistentCacheBaseline?;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     waitingForInput: boolean;
@@ -58,6 +62,8 @@ declare class Rust implements Sandbox {
     debugDataBreakpointInfo(arguments_: DebugDataBreakpointInfoArguments): Promise<import("@wasm-idle/core").DebugDataBreakpointInfo | null>;
     debugSetDataBreakpoints(breakpoints: DebugDataBreakpoint[]): Promise<import("@wasm-idle/core").DebugResolvedDataBreakpoint[]>;
     kill(): Promise<void>;
+    setRuntimeAssetCache(cache: RuntimeAssetCache): void;
+    dispose(): Promise<void>;
     terminate(): Promise<void>;
     clear(): Promise<void>;
 }

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, resolveRuntimeAssetCacheOptions, TimeoutError } from '@wasm-idle/core';
+import { createRuntimeAssetsKey, RuntimeAssetCache, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, serveRuntimeWasmModule, TimeoutError } from '@wasm-idle/core';
 const debugBreakpointBufferInts = 1028;
 const rustLldbSourcePath = '/workspace/main.rs';
 const outputEncoder = new TextEncoder();
@@ -54,6 +54,9 @@ class Rust {
     debugManifestUrl = '';
     debugManifestReceipt;
     executableGraphFingerprint = '';
+    runtimeAssetsKey = '';
+    runtimeAssetCache = new RuntimeAssetCache();
+    ownsRuntimeAssetCache = true;
     persistentCacheBaseline;
     oncompilerdiagnostic;
     waitingForInput = false;
@@ -122,9 +125,10 @@ class Rust {
             let candidateLoadReject = null;
             let clearCandidateWait = () => { };
             try {
-                const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+                const currentUrl = globalThis.location?.href ?? '';
                 const persistentCache = resolveRuntimeAssetCacheOptions(typeof runtimeAssets === 'object' ? runtimeAssets.persistentCache : undefined, _options.persistentCache);
                 const nextCompilerUrl = resolveRustCompilerUrl(runtimeAssets, currentUrl);
+                const nextRuntimeAssetsKey = createRuntimeAssetsKey(runtimeAssets) ?? '';
                 const nextDebugModuleUrl = resolveRustDebugModuleUrl(runtimeAssets, currentUrl);
                 const debugRuntime = resolveDebugRuntimeUrls(runtimeAssets, currentUrl);
                 const nextDebugRuntimeBaseUrl = debugRuntime.baseUrl;
@@ -133,9 +137,8 @@ class Rust {
                 const nextAssetPath = typeof runtimeAssets === 'string'
                     ? runtimeAssets
                     : runtimeAssets?.rootUrl ||
-                        (typeof window !== 'undefined'
-                            ? window.location.pathname.replace(/\/$/, '')
-                            : '');
+                        globalThis.location?.pathname.replace(/\/$/, '') ||
+                        '';
                 if (!nextCompilerUrl) {
                     throw new Error('Rust runtime is not configured. Set runtimeAssets.rust.compilerUrl.');
                 }
@@ -174,6 +177,7 @@ class Rust {
                     this.compilerUrl !== nextCompilerUrl ||
                     this.debugModuleUrl !== nextDebugModuleUrl ||
                     this.assetPath !== nextAssetPath ||
+                    this.runtimeAssetsKey !== nextRuntimeAssetsKey ||
                     this.executableGraphFingerprint !==
                         WASM_RUST_EXECUTABLE_GRAPH_PROFILE.fingerprint;
                 if (!needsWorkerReset) {
@@ -279,6 +283,7 @@ class Rust {
                 this.waitingForInput = false;
                 this.pendingEof = false;
                 this.compilerUrl = nextCompilerUrl;
+                this.runtimeAssetsKey = nextRuntimeAssetsKey;
                 this.persistentCacheBaseline = persistentCache;
                 this.debugModuleUrl = nextDebugModuleUrl;
                 this.assetPath = nextAssetPath;
@@ -383,6 +388,20 @@ class Rust {
             let phaseTimeoutState;
             let outputBytes = 0;
             let diagnosticCount = 0;
+            let moduleBroker;
+            const moduleServices = new Set();
+            const closeCompilerModuleBroker = () => {
+                if (moduleBroker) {
+                    moduleBroker.port1.onmessage = null;
+                    moduleBroker.port1.onmessageerror = null;
+                    moduleBroker.port1.close();
+                    moduleBroker.port2.close();
+                    moduleBroker = undefined;
+                }
+                for (const service of moduleServices)
+                    service.close();
+                moduleServices.clear();
+            };
             const clearScheduledPhaseTimeout = () => {
                 if (phaseTimeout !== undefined)
                     clearTimeout(phaseTimeout);
@@ -459,6 +478,7 @@ class Rust {
                     return;
                 settled = true;
                 this.runActive = false;
+                closeCompilerModuleBroker();
                 clearPhaseTimeout();
                 if (this.activeDebugPhaseTimeout === debugPhaseTimeout) {
                     this.activeDebugPhaseTimeout = undefined;
@@ -471,6 +491,7 @@ class Rust {
                     return;
                 settled = true;
                 this.runActive = false;
+                closeCompilerModuleBroker();
                 clearPhaseTimeout();
                 if (this.activeDebugPhaseTimeout === debugPhaseTimeout) {
                     this.activeDebugPhaseTimeout = undefined;
@@ -572,6 +593,7 @@ class Rust {
                 if (debugEvent)
                     forwardDebugEvent(debugEvent);
                 if (lldbArtifact) {
+                    closeCompilerModuleBroker();
                     startPhaseTimeout('run', limits.runTimeoutMs);
                     const compilerWorker = this.worker;
                     const lldbSession = new LldbSandboxSession({
@@ -679,8 +701,63 @@ class Rust {
             this.worker.onmessage = handler;
             this.begin = Date.now();
             try {
+                if (typeof MessageChannel === 'function' && typeof MessagePort === 'function') {
+                    moduleBroker = new MessageChannel();
+                    const isActiveModuleBroker = () => !settled && _uid === this.uid && this.workerSession.isActive(operation);
+                    moduleBroker.port1.onmessageerror = () => {
+                        if (isActiveModuleBroker()) {
+                            this.workerSession.terminate(new Error('Rust module broker message failed'));
+                        }
+                    };
+                    moduleBroker.port1.onmessage = (event) => {
+                        const message = event.data;
+                        if (!isActiveModuleBroker()) {
+                            if (message?.port instanceof MessagePort) {
+                                try {
+                                    message.port.close();
+                                }
+                                catch {
+                                    // A retired endpoint cannot affect the current worker operation.
+                                }
+                            }
+                            return;
+                        }
+                        if (!(message?.port instanceof MessagePort)) {
+                            this.workerSession.terminate(new Error('Invalid Rust module service request'));
+                            return;
+                        }
+                        if (message.type !== 'rustc-module-service') {
+                            message.port.close();
+                            this.workerSession.terminate(new Error('Invalid Rust module service request'));
+                            return;
+                        }
+                        try {
+                            const receipt = WASM_RUST_RUNTIME_PROFILE.assetReceipts['wasm-rust/runtime/rustc/rustc.wasm.gz'];
+                            moduleServices.add(serveRuntimeWasmModule(message.port, {
+                                cache: this.runtimeAssetCache,
+                                receipt: {
+                                    bytes: receipt.uncompressedBytes,
+                                    sha256: receipt.uncompressedSha256
+                                },
+                                identity: JSON.stringify([
+                                    this.runtimeAssetsKey,
+                                    this.compilerUrl,
+                                    WASM_RUST_RUNTIME_PROFILE.profileId,
+                                    this.executableGraphFingerprint
+                                ]),
+                                compileKey: 'rustc-native-default-v1',
+                                maxAssetBytes: limits.maxAssetBytes
+                            }));
+                        }
+                        catch (error) {
+                            message.port.close();
+                            this.workerSession.terminate(error);
+                        }
+                    };
+                }
                 this.worker.postMessage({
                     persistentCache,
+                    ...(moduleBroker ? { rustcModuleBroker: moduleBroker.port2 } : {}),
                     code,
                     prepare,
                     buffer: this.buffer,
@@ -704,7 +781,7 @@ class Rust {
                             }
                             : {})
                     }
-                });
+                }, moduleBroker ? [moduleBroker.port2] : []);
             }
             catch (error) {
                 this.workerSession.terminate(error);
@@ -776,6 +853,26 @@ class Rust {
     kill() {
         return this.terminate();
     }
+    setRuntimeAssetCache(cache) {
+        if (cache === this.runtimeAssetCache)
+            return;
+        if (this.worker || this.loadController || this.runActive) {
+            throw new Error('Cannot replace the Rust runtime asset cache while its worker is active');
+        }
+        if (this.ownsRuntimeAssetCache)
+            this.runtimeAssetCache.dispose();
+        this.runtimeAssetCache = cache;
+        this.ownsRuntimeAssetCache = false;
+    }
+    async dispose() {
+        try {
+            await this.terminate();
+        }
+        finally {
+            if (this.ownsRuntimeAssetCache)
+                this.runtimeAssetCache.dispose();
+        }
+    }
     async terminate() {
         this.loadGeneration += 1;
         this.loadController?.abort(new Error('Rust runtime terminated'));

package/dist/playground/staticStdinRing.d.ts

@@ -1,5 +1,5 @@
 export declare const STATIC_STDIN_RING_PROTOCOL: "wasm-idle-static-stdin-ring";
-export declare const STATIC_STDIN_RING_PROTOCOL_VERSION: 1;
+export declare const STATIC_STDIN_RING_PROTOCOL_VERSION: 2;
 export declare const STATIC_STDIN_RING_CONTROL_SLOTS: 4;
 export declare const STATIC_STDIN_RING_CONTROL_BYTES: number;
 export declare const STATIC_STDIN_RING_WRITE_INDEX: 0;
@@ -27,6 +27,7 @@ export declare class StaticStdinRingHost {
     readonly maxBufferedBytes: number;
     private readonly control;
     private readonly data;
+    private readonly counterRange;
     private readonly pending;
     private pendingBytes;
     private pendingOffset;

package/dist/playground/staticStdinRing.js

@@ -1,5 +1,5 @@
 export const STATIC_STDIN_RING_PROTOCOL = 'wasm-idle-static-stdin-ring';
-export const STATIC_STDIN_RING_PROTOCOL_VERSION = 1;
+export const STATIC_STDIN_RING_PROTOCOL_VERSION = 2;
 export const STATIC_STDIN_RING_CONTROL_SLOTS = 4;
 export const STATIC_STDIN_RING_CONTROL_BYTES = STATIC_STDIN_RING_CONTROL_SLOTS * Int32Array.BYTES_PER_ELEMENT;
 export const STATIC_STDIN_RING_WRITE_INDEX = 0;
@@ -24,6 +24,7 @@ export class StaticStdinRingHost {
     maxBufferedBytes;
     control;
     data;
+    counterRange;
     pending = [];
     pendingBytes = 0;
     pendingOffset = 0;
@@ -43,12 +44,18 @@ export class StaticStdinRingHost {
         if (maxBufferedBytes < capacity) {
             throw new TypeError('Static stdin maximum buffered bytes must cover the ring capacity');
         }
+        if (capacity > 2 ** 31) {
+            throw new TypeError('Static stdin ring capacity must not exceed 2^31 bytes');
+        }
         if (typeof SharedArrayBuffer !== 'function') {
             throw new TypeError('SharedArrayBuffer is required for streaming static stdin');
         }
         const buffer = new SharedArrayBuffer(STATIC_STDIN_RING_CONTROL_BYTES + capacity);
         this.control = new Int32Array(buffer, 0, STATIC_STDIN_RING_CONTROL_SLOTS);
         this.data = new Uint8Array(buffer, STATIC_STDIN_RING_CONTROL_BYTES, capacity);
+        // A capacity-aligned modulus preserves physical offsets at rollover for
+        // non-power-of-two rings too. At least two full rings fit in this range.
+        this.counterRange = Math.floor(2 ** 32 / capacity) * capacity;
         this.maxBufferedBytes = maxBufferedBytes;
         this.descriptor = Object.freeze({
             protocol: STATIC_STDIN_RING_PROTOCOL,
@@ -107,10 +114,12 @@ export class StaticStdinRingHost {
         this.flush();
     }
     ringBytes() {
-        const write = Atomics.load(this.control, STATIC_STDIN_RING_WRITE_INDEX);
-        const read = Atomics.load(this.control, STATIC_STDIN_RING_READ_INDEX);
-        const used = write - read;
-        if (used < 0 || used > this.data.byteLength) {
+        const write = Atomics.load(this.control, STATIC_STDIN_RING_WRITE_INDEX) >>> 0;
+        const read = Atomics.load(this.control, STATIC_STDIN_RING_READ_INDEX) >>> 0;
+        const used = (write - read + this.counterRange) % this.counterRange;
+        if (write >= this.counterRange ||
+            read >= this.counterRange ||
+            used > this.data.byteLength) {
             throw new Error('Static stdin ring counters are invalid');
         }
         return used;
@@ -118,10 +127,12 @@ export class StaticStdinRingHost {
     flush() {
         if (this.cancelled)
             return;
-        let write = Atomics.load(this.control, STATIC_STDIN_RING_WRITE_INDEX);
-        const read = Atomics.load(this.control, STATIC_STDIN_RING_READ_INDEX);
-        const used = write - read;
-        if (used < 0 || used > this.data.byteLength) {
+        let write = Atomics.load(this.control, STATIC_STDIN_RING_WRITE_INDEX) >>> 0;
+        const read = Atomics.load(this.control, STATIC_STDIN_RING_READ_INDEX) >>> 0;
+        const used = (write - read + this.counterRange) % this.counterRange;
+        if (write >= this.counterRange ||
+            read >= this.counterRange ||
+            used > this.data.byteLength) {
             throw new Error('Static stdin ring counters are invalid');
         }
         let available = this.data.byteLength - used;
@@ -136,7 +147,7 @@ export class StaticStdinRingHost {
             if (first < count) {
                 this.data.set(chunk.subarray(this.pendingOffset + first, this.pendingOffset + count), 0);
             }
-            write += count;
+            write = (write + count) % this.counterRange;
             available -= count;
             this.pendingOffset += count;
             this.pendingBytes -= count;

package/dist/playground/staticWorkerRuntime.d.ts

@@ -1,5 +1,5 @@
 import type { PlaygroundRuntimeAssets } from './assets';
-import { type ExecutionLimits, type RuntimeAssetIntegrityEntry, type RuntimeAssetCacheOptions, type RuntimeStdinMode, type RuntimeWorkerLifetimePolicy } from '@wasm-idle/core';
+import { type ExecutionLimits, type RuntimeAssetIntegrityEntry, type RuntimeAssetCacheOptions, type RuntimeAssetCache, type RuntimeWasmModuleReceipt, 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'>>>;
@@ -55,8 +55,16 @@ export interface StaticWorkerRuntimeConfig {
     workerLifetime?: RuntimeWorkerLifetimePolicy;
     resolveRuntimeAssets: (runtimeAssets: string | PlaygroundRuntimeAssets, currentUrl: string) => StaticWorkerRuntimeUrls;
     preflightRuntimeAssets?: (urls: StaticWorkerRuntimeUrls, context: StaticWorkerRuntimePreflightContext) => unknown | Promise<unknown>;
+    /** Only the host selects verified logical receipts and deterministic compilation settings. */
+    compilerModules?: (urls: StaticWorkerRuntimeUrls, limits: ExecutionLimits) => Readonly<Record<string, StaticWorkerCompilerModule>>;
     runtimePreflightDelivery?: 'structured-clone' | 'transfer-owned' | 'transfer-owned-worker-cache';
 }
+export interface StaticWorkerCompilerModule {
+    readonly receipt: RuntimeWasmModuleReceipt;
+    /** Include the transform implementation version, options and any enforced memory cap. */
+    readonly compileKey: string;
+    readonly compile?: (ownedBytes: Uint8Array<ArrayBuffer>) => Promise<WebAssembly.Module>;
+}
 type StdinWaiter = {
     reject: (reason: unknown) => void;
     resolve: () => void;
@@ -101,7 +109,13 @@ export declare class StaticWorkerRuntimeSandbox implements Sandbox {
     private readonly workerRuntimePreflightMaxAssetBytes;
     private readonly workersWithCachedRuntimePreflight;
     private workerStartMaxAssetBytes;
+    private runtimeAssetCache?;
+    private readonly workerCompilerModuleServices;
     constructor(config: StaticWorkerRuntimeConfig);
+    /** The application owns this cache; worker or sandbox disposal never disposes it. */
+    setRuntimeAssetCache(cache: RuntimeAssetCache): void;
+    private createCompilerModulePorts;
+    private closeCompilerModuleServices;
     private usesOwnedRuntimePreflight;
     private usesWorkerCachedRuntimePreflight;
     private resetWorkerForLowerAssetLimit;