wasm-idle 1.0.5 → 1.0.7

package/dist/playground/bash.js

@@ -1,7 +1,7 @@
 import { resolveBashRuntimeAssetConfig } from './assets';
 import { BASH_WORKER_PROTOCOL_VERSION, isBashWorkerToHostMessage } from './bashWorkerProtocol';
 import { reportWorkerProgress } from './workerProgress';
-import { AssetTooLargeError, AssetIntegrityError, AssetNotFoundError, BusyError, CancelledError, CompileError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, ProtocolError, ResourceLimitError, RuntimeConfigurationError, RuntimeExecutionError, TimeoutError, UnsupportedBrowserFeatureError, UnsupportedLanguageError, WasmIdleError, WorkerStartupError, preflightBashRuntimeAssets, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { AssetTooLargeError, AssetIntegrityError, AssetNotFoundError, BusyError, CancelledError, CompileError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, ProtocolError, ResourceLimitError, RuntimeConfigurationError, RuntimeExecutionError, TimeoutError, UnsupportedBrowserFeatureError, UnsupportedLanguageError, WasmIdleError, WorkerStartupError, preflightBashRuntimeAssets, resolveExecutionLimits, resolveRuntimeAssetCacheOptions, validateExecutionWorkspace } from '@wasm-idle/core';
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 const textEncoder = new TextEncoder();
 const abortReason = (signal, phase) => signal.reason !== undefined
@@ -29,6 +29,7 @@ class Bash {
     activeOperation = null;
     readyWorker = null;
     loadedConfig = null;
+    persistentCache;
     requestUid = 0;
     sessionUid = 0;
     disposed = false;
@@ -85,6 +86,9 @@ class Bash {
             const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
             const resolved = resolveBashRuntimeAssetConfig(runtimeAssets, currentUrl);
             this.requireActive(operation);
+            this.persistentCache =
+                typeof runtimeAssets === 'string' ? undefined : runtimeAssets.persistentCache;
+            operation.persistentCache = resolveRuntimeAssetCacheOptions(this.persistentCache, options.persistentCache);
             const config = {
                 ...resolved,
                 identity: createBashConfigIdentity(resolved.preflightKey, limits),
@@ -165,6 +169,7 @@ class Bash {
             this.requireActive(operation);
             if (signal?.aborted)
                 throw abortReason(signal, operation.stage);
+            operation.persistentCache = resolveRuntimeAssetCacheOptions(this.persistentCache, options.persistentCache);
             const limits = resolveExecutionLimits(options.limits);
             this.requireActive(operation);
             if (!this.readyWorker) {
@@ -481,6 +486,7 @@ class Bash {
                 webcUrl: config.webcUrl,
                 profile: config.preflightProfile,
                 limits: config.limits,
+                persistentCache: operation.persistentCache,
                 signal: preflightController.signal,
                 reportProgress: ({ assetKey, loadedBytes }) => {
                     loadedByAsset.set(assetKey, loadedBytes);

package/dist/playground/bqn.js

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

package/dist/playground/bqnPreflight.d.ts

@@ -1,5 +1,5 @@
 import type { BqnRuntimePreflightProfile } from './assets';
-import { type ExecutionLimits, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
+import { type ExecutionLimits, type RuntimeAssetCacheOptions, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
 export declare const BQN_PREFLIGHT_PROTOCOL: "wasm-idle-bqn-preflight";
 export declare const BQN_PREFLIGHT_PROTOCOL_VERSION: 1;
 export declare const BQN_PREFLIGHT_RUNTIME_ID: "BQN";
@@ -8,6 +8,7 @@ export interface BqnRuntimePreflightRequest {
     readonly manifestUrl: string;
     readonly profile: BqnRuntimePreflightProfile;
     readonly limits?: Partial<ExecutionLimits>;
+    readonly persistentCache?: RuntimeAssetCacheOptions;
     readonly signal?: AbortSignal;
     readonly fetch?: typeof globalThis.fetch;
     readonly reportProgress?: (progress: RuntimeAssetPreflightProgress) => void;

package/dist/playground/bqnPreflight.js

@@ -237,6 +237,7 @@ export async function preflightBqnRuntimeAssets(request) {
                 wasm: wasmRequestUrl
             },
             fetch: request.fetch,
+            persistentCache: request.persistentCache,
             signal: controller.signal,
             limits,
             maxConcurrentDownloads: 3,

package/dist/playground/c3.js

@@ -121,6 +121,7 @@ class C3 extends StaticWorkerRuntimeSandbox {
                     runtimeId: 'C3',
                     rootUrl: urls.baseUrl,
                     limits: context.limits,
+                    persistentCache: context.persistentCache,
                     signal: context.signal,
                     redirect: 'error',
                     requireExactResponseUrl: true,

package/dist/playground/cachedClang.d.ts

@@ -0,0 +1,10 @@
+import { type Sandbox } from '@wasm-idle/core';
+import type { RuntimeAssetCache } from './runtimeAssetCache';
+import { CompiledArtifactCache } from './compiledArtifactCache';
+type WorkerFactories = {
+    compile(): Worker | Promise<Worker>;
+    execute(): Worker | Promise<Worker>;
+};
+/** Wrap the public sandbox contract; all other languages and debugger operations stay unchanged. */
+export declare function createCachedClangSandbox(legacy: Sandbox, language: 'C' | 'CPP', runtimeCache: RuntimeAssetCache, cache?: CompiledArtifactCache, factories?: WorkerFactories): Sandbox;
+export {};

package/dist/playground/cachedClang.js

@@ -0,0 +1,330 @@
+import { resolveExecutionLimits, resolveRuntimeAssetCacheOptions } from '@wasm-idle/core';
+import { resolveRuntimeAssetConfig } from './assets';
+import { WorkerAssetBridge } from './assetBridge';
+import { shouldStreamBundledClang } from './clangStreamingPolicy';
+import { CompiledArtifactCache, clangCompileKey } from './compiledArtifactCache';
+const workers = {
+    async compile() {
+        const { default: CompileWorker } = await import('./worker/cachedClangCompile?worker');
+        return new CompileWorker();
+    },
+    async execute() {
+        const { default: ExecuteWorker } = await import('./worker/cachedClangExecute?worker');
+        return new ExecuteWorker();
+    }
+};
+/** Wrap the public sandbox contract; all other languages and debugger operations stay unchanged. */
+export function createCachedClangSandbox(legacy, language, runtimeCache, cache = new CompiledArtifactCache(), factories = workers) {
+    let cached = false;
+    let loadedAssets = '';
+    let runtimeBaseUrl = '';
+    let assetConfig;
+    let maxAssetBytes = 0;
+    let languageSysroots = false;
+    let activeWorker;
+    let cancelWorker;
+    let generation = 0;
+    let running = false;
+    let disposed = false;
+    let disposal;
+    let inputBuffer;
+    let inputRequested = false;
+    let pendingEof = false;
+    const pendingInput = [];
+    const encoder = new TextEncoder();
+    function resetInput() {
+        pendingInput.length = 0;
+        pendingEof = false;
+        inputRequested = false;
+        inputBuffer = undefined;
+    }
+    function flushInput() {
+        if (!inputRequested || !inputBuffer)
+            return;
+        const control = new Int32Array(inputBuffer, 0, 2);
+        const payload = new Uint8Array(inputBuffer, 8);
+        const next = pendingInput[0];
+        if (next) {
+            const length = Math.min(next.byteLength, payload.byteLength);
+            payload.set(next.subarray(0, length));
+            if (length === next.byteLength)
+                pendingInput.shift();
+            else
+                pendingInput[0] = next.subarray(length);
+            Atomics.store(control, 1, length);
+            Atomics.store(control, 0, 1);
+        }
+        else if (pendingEof) {
+            Atomics.store(control, 1, 0);
+            Atomics.store(control, 0, 2);
+        }
+        else
+            return;
+        inputRequested = false;
+        Atomics.notify(control, 0);
+    }
+    function stop() {
+        generation++;
+        running = false;
+        cancelWorker?.(new Error('Process terminated'));
+        resetInput();
+    }
+    async function workerOperation(factory, message, token, progress, compileLimit = 0, signal, executionAssetConfig = assetConfig) {
+        const worker = await factory();
+        if (token !== generation || signal?.aborted) {
+            worker.terminate();
+            throw signal?.reason ?? new Error('Process terminated');
+        }
+        return new Promise((resolve, reject) => {
+            let bridge;
+            try {
+                if (compileLimit)
+                    bridge = new WorkerAssetBridge(worker, 'clang', executionAssetConfig, progress, compileLimit, languageSysroots, runtimeCache);
+            }
+            catch (error) {
+                worker.terminate();
+                reject(error);
+                return;
+            }
+            activeWorker = worker;
+            const abort = () => finish(signal?.reason instanceof Error
+                ? signal.reason
+                : new Error('Process terminated'));
+            const finish = (error, value) => {
+                if (activeWorker !== worker)
+                    return;
+                activeWorker = undefined;
+                cancelWorker = undefined;
+                signal?.removeEventListener('abort', abort);
+                bridge?.dispose();
+                worker.onmessage = null;
+                worker.onerror = null;
+                worker.onmessageerror = null;
+                worker.terminate();
+                if (error)
+                    reject(error);
+                else
+                    resolve(value);
+            };
+            cancelWorker = finish;
+            signal?.addEventListener('abort', abort, { once: true });
+            worker.onerror = (event) => finish(new Error(event.message || 'C/C++ worker failed'));
+            worker.onmessageerror = () => finish(new Error('C/C++ worker message could not be decoded'));
+            worker.onmessage = (event) => {
+                if (activeWorker !== worker)
+                    return;
+                try {
+                    if (bridge?.handleMessage(event))
+                        return;
+                    const { data } = event;
+                    if (data.type === 'output')
+                        legacy.output?.(data.output);
+                    else if (data.type === 'progress') {
+                        progress?.set?.(data.progress.percent / 100);
+                        progress?.report?.({
+                            kind: 'activity',
+                            phase: 'compiling',
+                            label: data.progress.message
+                        });
+                    }
+                    else if (data.type === 'stdin') {
+                        inputRequested = true;
+                        progress?.report?.({
+                            kind: 'ready',
+                            state: 'waiting-input',
+                            reason: 'stdin-request',
+                            label: 'Runtime ready for input'
+                        });
+                        flushInput();
+                    }
+                    else if (data.type === 'compiled' || data.type === 'error') {
+                        if (data.stdout)
+                            legacy.output?.(data.stdout);
+                        if (data.stderr)
+                            legacy.output?.(data.stderr);
+                        if (data.type === 'error')
+                            finish(new Error(data.error));
+                        else
+                            finish(undefined, data.artifact);
+                    }
+                    else if (data.type === 'done') {
+                        if (data.exitCode !== 0 && data.exitCode !== null)
+                            finish(new Error(`Program exited with code ${data.exitCode}`));
+                        else
+                            finish(undefined, true);
+                    }
+                }
+                catch (error) {
+                    finish(error instanceof Error ? error : new Error(String(error)));
+                }
+            };
+            try {
+                worker.postMessage(message);
+            }
+            catch (error) {
+                finish(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    const overrides = {
+        async load(assets = '', code = '', log = true, args = [], options = {}, progress) {
+            if (disposed)
+                throw new Error('C/C++ sandbox was disposed');
+            loadedAssets = assets;
+            const config = typeof assets === 'object' ? assets : undefined;
+            assetConfig = resolveRuntimeAssetConfig('clang', assets, globalThis.location?.href || 'http://localhost/', options.persistentCache);
+            const debugMode = options.debugMode || (options.debug ? 'trace' : 'none');
+            const cacheEligible = debugMode === 'none' &&
+                shouldStreamBundledClang(assetConfig) &&
+                !options.workspaceFiles?.some((file) => typeof file.content !== 'string') &&
+                (options.stdin === undefined || typeof options.stdin === 'string') &&
+                typeof SharedArrayBuffer !== 'undefined';
+            if (!cached)
+                await legacy.clear();
+            if (disposed)
+                throw new Error('C/C++ sandbox was disposed');
+            stop();
+            cached = cacheEligible;
+            if (!cached)
+                return legacy.load(assets, code, log, args, options, progress);
+            runtimeBaseUrl = assetConfig.baseUrl;
+            maxAssetBytes = resolveExecutionLimits(options.limits).maxAssetBytes;
+            languageSysroots = config?.clang?.bundledLanguageSysroots === true;
+        },
+        async run(code, prepare, log = true, progress, args = [], options = {}) {
+            if (disposed)
+                throw new Error('C/C++ sandbox was disposed');
+            if (running)
+                throw new Error('C/C++ sandbox is already running');
+            if (cached &&
+                ((options.debugMode || (options.debug ? 'trace' : 'none')) !== 'none' ||
+                    (options.stdin !== undefined && typeof options.stdin !== 'string') ||
+                    options.workspaceFiles?.some((file) => typeof file.content !== 'string'))) {
+                await overrides.load(loadedAssets, code, log, args, {
+                    ...options,
+                    persistentCache: assetConfig.persistentCache
+                }, progress);
+            }
+            if (!cached)
+                return legacy.run(code, prepare, log, progress, args, options);
+            const executionAssetConfig = {
+                ...assetConfig,
+                persistentCache: resolveRuntimeAssetCacheOptions(assetConfig.persistentCache, options.persistentCache)
+            };
+            options.signal?.throwIfAborted();
+            const token = ++generation;
+            // Reactive UI arrays/records are Proxies and cannot cross postMessage.
+            // Snapshot known fields before awaiting compilation, so the cache key,
+            // compiler and executor also observe the same input values.
+            const request = {
+                code,
+                language,
+                activePath: options.activePath,
+                workspaceFiles: options.workspaceFiles === undefined
+                    ? undefined
+                    : Array.from(options.workspaceFiles, (file) => ({
+                        path: file.path,
+                        content: file.content
+                    })),
+                compileArgs: Array.from(options.compileArgs ?? args),
+                cVersion: options.cVersion,
+                cppVersion: options.cppVersion
+            };
+            const programArgs = Array.from(options.programArgs ?? []);
+            const env = options.env === undefined
+                ? undefined
+                : Object.fromEntries(Object.entries(options.env));
+            const stdin = options.stdin;
+            const limit = Math.min(maxAssetBytes, resolveExecutionLimits(options.limits).maxAssetBytes);
+            const key = clangCompileKey(runtimeBaseUrl, limit, request, languageSysroots);
+            let artifact = cache.get(key);
+            running = true;
+            try {
+                if (!artifact) {
+                    artifact = await workerOperation(() => factories.compile(), {
+                        request,
+                        runtimeBaseUrl,
+                        maxAssetBytes: limit,
+                        languageSysroots,
+                        log,
+                        assets: {
+                            baseUrl: runtimeBaseUrl,
+                            maxAssetBytes: limit,
+                            useAssetBridge: assetConfig.useAssetBridge,
+                            useModuleBridge: true
+                        }
+                    }, token, progress, limit, options.signal, executionAssetConfig);
+                    if (token !== generation)
+                        throw new Error('Process terminated');
+                    cache.set(key, artifact);
+                }
+                progress?.set?.(1);
+                if (prepare)
+                    return true;
+                inputBuffer = new SharedArrayBuffer(65536 + 8);
+                return await workerOperation(() => factories.execute(), {
+                    artifact,
+                    code,
+                    activePath: request.activePath,
+                    workspaceFiles: request.workspaceFiles,
+                    programArgs,
+                    env,
+                    stdin,
+                    inputBuffer
+                }, token, progress, 0, options.signal);
+            }
+            finally {
+                if (token === generation) {
+                    running = false;
+                    if (!prepare)
+                        resetInput();
+                }
+            }
+        },
+        write(input) {
+            if (!cached)
+                return legacy.write?.(input);
+            if (input)
+                pendingInput.push(encoder.encode(input));
+            flushInput();
+        },
+        eof() {
+            if (!cached)
+                return legacy.eof();
+            pendingEof = true;
+            flushInput();
+        },
+        async clear() {
+            stop();
+            if (!cached)
+                await legacy.clear();
+        },
+        async terminate() {
+            stop();
+            if (!cached)
+                await legacy.terminate();
+        },
+        async kill() {
+            await overrides.terminate();
+        },
+        async cancel() {
+            await overrides.terminate();
+        },
+        dispose() {
+            if (disposal)
+                return disposal;
+            disposed = true;
+            stop();
+            disposal = Promise.resolve(legacy.dispose ? legacy.dispose() : legacy.terminate());
+            return disposal;
+        }
+    };
+    return new Proxy(legacy, {
+        get(target, property) {
+            if (Object.hasOwn(overrides, property))
+                return overrides[property];
+            const value = Reflect.get(target, property);
+            return typeof value === 'function' ? value.bind(target) : value;
+        }
+    });
+}

package/dist/playground/clang.d.ts

@@ -1,5 +1,6 @@
 import type { DebugCommand, DebugDataBreakpoint, DebugDataBreakpointInfoArguments, DebugSessionEvent, SandboxExecutionOptions } from './options';
 import { WorkerAssetBridge } from './assetBridge';
+import { RuntimeAssetCache } from './runtimeAssetCache';
 import { type PlaygroundRuntimeAssets, type RuntimeAssetIntegrityEntry } from './assets';
 import type { Sandbox } from './sandbox';
 import { type ProgressSink } from './workerProgress';
@@ -26,7 +27,12 @@ declare class Clang implements Sandbox {
     debugRuntimeBaseUrl: string;
     debugManifestUrl: string;
     debugManifestReceipt?: Readonly<RuntimeAssetIntegrityEntry>;
+    private persistentCache?;
     private lldbSession?;
+    private runtimeAssetCache;
+    private ownsRuntimeAssetCache;
+    private disposed;
+    private disposal?;
     private debugMode;
     private readonly lldbBreakpoints;
     private debugEvaluationQueue;
@@ -56,5 +62,7 @@ declare class Clang implements Sandbox {
     kill(): Promise<void>;
     terminate(): Promise<void>;
     clear(): Promise<void>;
+    setRuntimeAssetCache(cache: RuntimeAssetCache): void;
+    dispose(): Promise<void>;
 }
 export default Clang;

package/dist/playground/clang.js

@@ -1,5 +1,6 @@
 import { shouldStreamBundledClang } from './clangStreamingPolicy';
 import { WorkerAssetBridge } from './assetBridge';
+import { RuntimeAssetCache } from './runtimeAssetCache';
 import { resolveDebugRuntimeUrls, resolveRuntimeAssetConfig } from './assets';
 import { LldbSandboxSession } from './lldbSession';
 import { normalizeDwarfWorkspacePath } from '@wasm-idle/llvm-core/clang';
@@ -38,7 +39,12 @@ class Clang {
     debugRuntimeBaseUrl = '';
     debugManifestUrl = '';
     debugManifestReceipt;
+    persistentCache;
     lldbSession;
+    runtimeAssetCache = new RuntimeAssetCache();
+    ownsRuntimeAssetCache = true;
+    disposed = false;
+    disposal;
     debugMode = 'none';
     lldbBreakpoints = new Map();
     debugEvaluationQueue = Promise.resolve();
@@ -74,6 +80,8 @@ class Clang {
     load(runtimeAssets = '', code = '', log = true, args = [], options = {}, progress) {
         let limits;
         try {
+            if (this.disposed)
+                throw new Error('Clang runtime has been disposed');
             limits = resolveExecutionLimits(options.limits);
         }
         catch (error) {
@@ -84,9 +92,10 @@ class Clang {
             this.pendingInput = [];
             this.waitingForInput = false;
             this.pendingEof = false;
-            const assetConfig = resolveRuntimeAssetConfig('clang', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+            const assetConfig = resolveRuntimeAssetConfig('clang', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '', options.persistentCache);
             const debugRuntime = resolveDebugRuntimeUrls(runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
             this.debugRuntimeBaseUrl = debugRuntime.baseUrl;
+            this.persistentCache = assetConfig.persistentCache;
             this.debugManifestUrl = debugRuntime.manifestUrl;
             this.debugManifestReceipt = debugRuntime.manifestReceipt;
             const bundledAssets = shouldStreamBundledClang(assetConfig);
@@ -107,7 +116,7 @@ class Clang {
                 if (!this.workerSession.attach(worker, operation))
                     return;
                 this.worker = worker;
-                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', assetConfig, progress, limits.maxAssetBytes, languageSysrootProfiles);
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', assetConfig, progress, limits.maxAssetBytes, languageSysrootProfiles, this.runtimeAssetCache);
                 this.worker.onmessage = (event) => {
                     if (!this.workerSession.isActive(operation))
                         return;
@@ -129,7 +138,8 @@ class Clang {
                     assets: {
                         baseUrl: assetConfig.baseUrl,
                         maxAssetBytes: limits.maxAssetBytes,
-                        useAssetBridge: assetConfig.useAssetBridge
+                        useAssetBridge: assetConfig.useAssetBridge,
+                        useModuleBridge: true
                     },
                     maxAssetBytes: limits.maxAssetBytes
                 });
@@ -172,6 +182,8 @@ class Clang {
         }
     }
     run(code, prepare, log = this.log, prog, args = [], options = {}) {
+        if (this.disposed)
+            return Promise.reject(new Error('Clang runtime has been disposed'));
         const debugMode = options.debugMode || (options.debug ? 'trace' : 'none');
         this.debugMode = debugMode;
         if (debugMode !== 'none')
@@ -181,6 +193,10 @@ class Clang {
             if (!this.worker)
                 return reject('Worker not loaded');
             const operation = this.workerSession.beginRun(this.worker, reject);
+            const persistentCacheOverride = options.persistentCache;
+            if (!this.workerSession.isActive(operation))
+                return;
+            const persistentCache = this.assetBridge?.setExecutionPersistentCache(persistentCacheOverride);
             const { compileArgs, programArgs } = resolveSandboxExecutionArgs(this.language, args, options);
             const sourcePath = normalizeLldbSourcePath(options.debugPath || options.activePath, this.language === 'C' ? 'main.c' : 'main.cc');
             this.lldbBreakpoints.clear();
@@ -218,6 +234,7 @@ class Clang {
                 if (lldbArtifact) {
                     const compilerWorker = this.worker;
                     const lldbSession = new LldbSandboxSession({
+                        persistentCache: persistentCache ?? this.persistentCache,
                         manifestUrl: this.debugManifestUrl,
                         manifestReceipt: this.debugManifestReceipt,
                         runtimeBaseUrl: this.debugRuntimeBaseUrl,
@@ -422,11 +439,33 @@ class Clang {
         resetBufferedStdin(this.watchResultBuffer);
         const debugBuffer = new Int32Array(this.debugBuffer);
         debugBuffer.fill(0);
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        if (!this.exit) {
-            this.workerSession.terminate();
-            this.exit = true;
-        }
+        new Uint8Array(this.interruptBuffer).fill(0);
+    }
+    setRuntimeAssetCache(cache) {
+        if (this.disposed)
+            throw new Error('Clang runtime has been disposed');
+        if (this.worker)
+            throw new Error('Cannot replace an active runtime cache');
+        if (cache === this.runtimeAssetCache)
+            return;
+        if (this.ownsRuntimeAssetCache)
+            this.runtimeAssetCache.dispose();
+        this.runtimeAssetCache = cache;
+        this.ownsRuntimeAssetCache = false;
+    }
+    dispose() {
+        if (this.disposal)
+            return this.disposal;
+        this.disposed = true;
+        this.disposal = Promise.resolve()
+            .then(() => this.clear())
+            .finally(() => {
+            if (this.ownsRuntimeAssetCache)
+                this.runtimeAssetCache.dispose();
+            this.output = null;
+            this.ondebug = undefined;
+        });
+        return this.disposal;
     }
 }
 export default Clang;

package/dist/playground/clangWorkerProtocol.d.ts

@@ -0,0 +1,57 @@
+import type { BrowserClangArtifact, BrowserClangCompileProgress, BrowserClangCompileRequest, BrowserClangWorkspaceFile } from '@wasm-idle/llvm-core/clang';
+import type { WorkerRuntimeAssetConfig } from './worker/assets';
+export type ClangCompileWorkerRequest = {
+    request: Omit<BrowserClangCompileRequest, 'onProgress'>;
+    runtimeBaseUrl: string;
+    maxAssetBytes?: number;
+    languageSysroots?: boolean;
+    log?: boolean;
+    assets: WorkerRuntimeAssetConfig;
+};
+export type ClangCompileWorkerResponse = {
+    type: 'progress';
+    progress: BrowserClangCompileProgress;
+} | {
+    type: 'compiled';
+    artifact: BrowserClangArtifact;
+    stdout: string;
+    stderr: string;
+} | {
+    type: 'error';
+    error: string;
+    stdout: string;
+    stderr: string;
+};
+export type ClangExecuteWorkerRequest = {
+    artifact: BrowserClangArtifact;
+    programArgs?: string[];
+    env?: Record<string, string>;
+    workspaceFiles?: BrowserClangWorkspaceFile[];
+    activePath?: string;
+    code?: string;
+    inputBuffer: SharedArrayBuffer;
+    stdin?: string;
+};
+export type ClangExecuteWorkerResponse = {
+    type: 'stdin';
+} | {
+    type: 'output';
+    output: string;
+} | {
+    type: 'done';
+    exitCode: number | null;
+} | {
+    type: 'error';
+    error: string;
+};
+/**
+ * One stdin response occupies two Int32 control words followed by UTF-8 bytes.
+ * Before requesting input the worker sets state to WAITING, posts `stdin`, and
+ * waits on word 0. The parent writes bytes and length, then atomically publishes
+ * DATA or EOF and notifies word 0. It writes only in response to a request.
+ * The worker copies DATA before making another request; EOF remains latched.
+ */
+export declare const CLANG_STDIN_HEADER_BYTES: number;
+export declare const CLANG_STDIN_WAITING = 0;
+export declare const CLANG_STDIN_DATA = 1;
+export declare const CLANG_STDIN_EOF = 2;

package/dist/playground/clangWorkerProtocol.js

@@ -0,0 +1,11 @@
+/**
+ * One stdin response occupies two Int32 control words followed by UTF-8 bytes.
+ * Before requesting input the worker sets state to WAITING, posts `stdin`, and
+ * waits on word 0. The parent writes bytes and length, then atomically publishes
+ * DATA or EOF and notifies word 0. It writes only in response to a request.
+ * The worker copies DATA before making another request; EOF remains latched.
+ */
+export const CLANG_STDIN_HEADER_BYTES = Int32Array.BYTES_PER_ELEMENT * 2;
+export const CLANG_STDIN_WAITING = 0;
+export const CLANG_STDIN_DATA = 1;
+export const CLANG_STDIN_EOF = 2;

package/dist/playground/clojurescript.js

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

package/dist/playground/clojurescriptPreflight.d.ts

@@ -1,5 +1,5 @@
 import type { ClojureScriptRuntimePreflightProfile } from './assets';
-import { type ExecutionLimits, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
+import { type ExecutionLimits, type RuntimeAssetCacheOptions, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
 export declare const CLOJURESCRIPT_PREFLIGHT_PROTOCOL: "wasm-idle-clojurescript-preflight";
 export declare const CLOJURESCRIPT_PREFLIGHT_PROTOCOL_VERSION: 1;
 export declare const CLOJURESCRIPT_PREFLIGHT_RUNTIME_ID: "CLOJURESCRIPT";
@@ -8,6 +8,7 @@ export interface ClojureScriptRuntimePreflightRequest {
     readonly manifestUrl: string;
     readonly profile: ClojureScriptRuntimePreflightProfile;
     readonly limits?: Partial<ExecutionLimits>;
+    readonly persistentCache?: RuntimeAssetCacheOptions;
     readonly signal?: AbortSignal;
     readonly fetch?: typeof globalThis.fetch;
     readonly reportProgress?: (progress: RuntimeAssetPreflightProgress) => void;