wasm-idle 1.0.4 → 1.0.6

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';
@@ -39,6 +40,10 @@ class Clang {
     debugManifestUrl = '';
     debugManifestReceipt;
     lldbSession;
+    runtimeAssetCache = new RuntimeAssetCache();
+    ownsRuntimeAssetCache = true;
+    disposed = false;
+    disposal;
     debugMode = 'none';
     lldbBreakpoints = new Map();
     debugEvaluationQueue = Promise.resolve();
@@ -74,6 +79,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) {
@@ -107,7 +114,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 +136,8 @@ class Clang {
                     assets: {
                         baseUrl: assetConfig.baseUrl,
                         maxAssetBytes: limits.maxAssetBytes,
-                        useAssetBridge: assetConfig.useAssetBridge
+                        useAssetBridge: assetConfig.useAssetBridge,
+                        useModuleBridge: true
                     },
                     maxAssetBytes: limits.maxAssetBytes
                 });
@@ -172,6 +180,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')
@@ -422,11 +432,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/compiledArtifactCache.d.ts

@@ -0,0 +1,21 @@
+import type { BrowserClangArtifact, BrowserClangCompileRequest } from '@wasm-idle/llvm-core/clang';
+/** Only immutable compiler output lives here, never a worker, instance, or filesystem. */
+export declare class CompiledArtifactCache {
+    private entries;
+    private bytes;
+    private hits;
+    private misses;
+    private maxEntries;
+    private maxBytes;
+    constructor(maxEntries?: number, maxBytes?: number);
+    get(key: string): BrowserClangArtifact | undefined;
+    set(key: string, artifact: BrowserClangArtifact): void;
+    clear(): void;
+    stats(): {
+        hits: number;
+        misses: number;
+        entries: number;
+        bytes: number;
+    };
+}
+export declare function clangCompileKey(runtimeBaseUrl: string, maxAssetBytes: number, request: BrowserClangCompileRequest, languageSysroots?: boolean): string;

package/dist/playground/compiledArtifactCache.js

@@ -0,0 +1,67 @@
+/** Only immutable compiler output lives here, never a worker, instance, or filesystem. */
+export class CompiledArtifactCache {
+    entries = new Map();
+    bytes = 0;
+    hits = 0;
+    misses = 0;
+    maxEntries;
+    maxBytes;
+    constructor(maxEntries = 8, maxBytes = 32 * 1024 * 1024) {
+        this.maxEntries = maxEntries;
+        this.maxBytes = maxBytes;
+    }
+    get(key) {
+        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.artifact;
+    }
+    set(key, artifact) {
+        const size = artifact.bytes.byteLength + key.length * 2;
+        if (size > this.maxBytes)
+            return;
+        const old = this.entries.get(key);
+        if (old)
+            this.bytes -= old.size;
+        this.entries.delete(key);
+        this.entries.set(key, { artifact, size });
+        this.bytes += size;
+        while (this.entries.size > this.maxEntries || this.bytes > this.maxBytes) {
+            const oldest = this.entries.keys().next().value;
+            this.bytes -= this.entries.get(oldest).size;
+            this.entries.delete(oldest);
+        }
+    }
+    clear() {
+        this.entries.clear();
+        this.bytes = 0;
+    }
+    stats() {
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            entries: this.entries.size,
+            bytes: this.bytes
+        };
+    }
+}
+export function clangCompileKey(runtimeBaseUrl, maxAssetBytes, request, languageSysroots = false) {
+    return JSON.stringify([
+        'wasm-idle/clang-cache-v2',
+        runtimeBaseUrl,
+        maxAssetBytes,
+        languageSysroots,
+        request.language,
+        request.code,
+        request.activePath,
+        request.compileArgs,
+        request.cVersion,
+        request.cppVersion,
+        [...(request.workspaceFiles || [])].sort((a, b) => a.path.localeCompare(b.path))
+    ]);
+}

package/dist/playground/python.d.ts

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

package/dist/playground/python.js

@@ -1,4 +1,5 @@
 import { WorkerAssetBridge } from './assetBridge';
+import { RuntimeAssetCache } from './runtimeAssetCache';
 import { resolveRuntimeAssetConfig } from './assets';
 import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
 import { createWasmIdleSharedBuffer, requireSharedArrayBuffer } from './sharedBuffer';
@@ -29,6 +30,10 @@ class Python {
     exit = true;
     assetBridge = null;
     activeOperation = null;
+    runtimeAssetCache = new RuntimeAssetCache();
+    ownsRuntimeAssetCache = true;
+    disposed = false;
+    disposal;
     workerSession = new WorkerSession({
         label: 'Python',
         onDispose: (worker) => {
@@ -44,6 +49,8 @@ class Python {
         }
     });
     beginOperation(phase) {
+        if (this.disposed)
+            throw new Error('Python runtime has been disposed');
         if (this.activeOperation) {
             throw new BusyError('Python runtime already has an active operation', {
                 runtimeId: 'PYTHON3',
@@ -220,7 +227,7 @@ class Python {
                     }
                     this.worker = worker;
                     this.workerSession.attach(worker);
-                    const assetBridge = new WorkerAssetBridge(worker, 'python', assetConfig, progress, limits.maxAssetBytes);
+                    const assetBridge = new WorkerAssetBridge(worker, 'python', assetConfig, progress, limits.maxAssetBytes, false, this.runtimeAssetCache);
                     if (!this.isOperationActive(operation) || this.worker !== worker) {
                         assetBridge.dispose();
                         return;
@@ -259,7 +266,8 @@ class Python {
                         assets: {
                             baseUrl: assetConfig.baseUrl,
                             maxAssetBytes: limits.maxAssetBytes,
-                            useAssetBridge: assetConfig.useAssetBridge
+                            useAssetBridge: assetConfig.useAssetBridge,
+                            useModuleBridge: true
                         }
                     });
                     return;
@@ -545,11 +553,34 @@ class Python {
         resetBufferedStdin(this.watchResultBuffer);
         const debugBuffer = new Int32Array(this.debugBuffer);
         debugBuffer.fill(0);
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        if (!this.exit) {
-            this.workerSession.terminate();
-            this.exit = true;
-        }
+        new Uint8Array(this.interruptBuffer).fill(0);
+    }
+    setRuntimeAssetCache(cache) {
+        if (this.disposed)
+            throw new Error('Python runtime has been disposed');
+        if (this.worker || this.activeOperation)
+            throw new Error('Cannot replace an active runtime cache');
+        if (cache === this.runtimeAssetCache)
+            return;
+        if (this.ownsRuntimeAssetCache)
+            this.runtimeAssetCache.dispose();
+        this.runtimeAssetCache = cache;
+        this.ownsRuntimeAssetCache = false;
+    }
+    dispose() {
+        if (this.disposal)
+            return this.disposal;
+        this.disposed = true;
+        this.disposal = Promise.resolve()
+            .then(() => this.clear())
+            .finally(() => {
+            if (this.ownsRuntimeAssetCache)
+                this.runtimeAssetCache.dispose();
+            this.output = null;
+            this.ondebug = undefined;
+            this.image = undefined;
+        });
+        return this.disposal;
     }
 }
 export default Python;

package/dist/playground/runtimeAssetCache.d.ts

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

package/dist/playground/runtimeAssetCache.js

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

package/dist/playground/runtimeSession.d.ts

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

package/dist/playground/runtimeSession.js

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

package/dist/playground/worker/assets.d.ts

@@ -2,6 +2,7 @@ export interface WorkerRuntimeAssetConfig {
     baseUrl: string;
     maxAssetBytes?: number;
     useAssetBridge: boolean;
+    useModuleBridge?: boolean;
 }
 export interface WorkerRuntimeAssetAllowlist {
     baseUrl: string;
@@ -16,4 +17,6 @@ export declare function configureWorkerRuntimeAssets(config: WorkerRuntimeAssetC
 export declare function configureWorkerRuntimeAssetAllowlist(allowlist: WorkerRuntimeAssetAllowlist | null): void;
 export declare function handleWorkerAssetMessage(data: any): boolean;
 export declare function loadWorkerRuntimeAsset(asset: string): Promise<LoadedWorkerAsset>;
+export declare function hasWorkerRuntimeModuleBridge(): boolean;
+export declare function loadWorkerRuntimeModule(asset: string): Promise<WebAssembly.Module>;
 export {};