wasm-idle 1.1.0 → 1.1.2

package/dist/playground/c3.js

@@ -2,6 +2,7 @@ import { resolveC3BaseUrl } from './assets';
 import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
 import { bundledC3Profile as profile, bundledC3WorkerReceipt } from './wasmC3Version';
 import { preflightRuntimeAssets, RuntimeConfigurationError } from '@wasm-idle/core';
+import { limitC3WasmMemory } from './c3Memory.js';
 export const C3_DEFAULT_WASM_MEMORY_BYTES = 1024 ** 3;
 function c3ExecutionOptions(options = {}) {
     if (options.compileArgs?.length)
@@ -114,6 +115,27 @@ class C3 extends StaticWorkerRuntimeSandbox {
                     workerReceipt: bundledC3WorkerReceipt
                 };
             },
+            compilerModules(_urls, limits) {
+                const totalCap = Math.min(limits.maxWasmMemoryBytes, 2 * 1024 ** 3);
+                const guestCap = Math.min(64 * 1024 ** 2, Math.floor(totalCap / 8 / 65536) * 65536);
+                const compilerCap = totalCap - guestCap;
+                return {
+                    compiler: {
+                        receipt: profile.compilerWasmReceipt,
+                        compileKey: `c3-defined-memory-cap-v1:${compilerCap}`,
+                        async compile(bytes) {
+                            const limited = await limitC3WasmMemory(bytes, compilerCap, {
+                                verifyModules: false
+                            });
+                            const module = await WebAssembly.compile(limited.bytes);
+                            if (WebAssembly.Module.imports(module).some((item) => item.kind === 'memory')) {
+                                throw new Error('Imported C3 Wasm memories are unsupported');
+                            }
+                            return module;
+                        }
+                    }
+                };
+            },
             async preflightRuntimeAssets(urls, context) {
                 memoryEvidence.current = undefined;
                 const result = await preflightRuntimeAssets({

package/dist/playground/c3Memory.d.ts

@@ -0,0 +1,19 @@
+/** @param {Uint8Array<ArrayBuffer>} bytes */
+export function c3Digest(bytes: Uint8Array<ArrayBuffer>): Promise<string>;
+/**
+ * @param {Uint8Array<ArrayBuffer>} bytes
+ * @param {number} maximumBytes
+ * @param {{verifyModules?: boolean}} [options]
+ */
+export function limitC3WasmMemory(bytes: Uint8Array<ArrayBuffer>, maximumBytes: number, { verifyModules }?: {
+    verifyModules?: boolean;
+}): Promise<{
+    bytes: Uint8Array<ArrayBuffer>;
+    evidence: {
+        originalSha256: string;
+        limitedSha256: string;
+        initialBytes: number;
+        maximumBytes: number;
+        originalMaximumBytes: number | null;
+    };
+}>;

package/dist/playground/c3Memory.js

@@ -0,0 +1,117 @@
+const C3_WASM_PAGE_BYTES = 65536;
+
+/** @param {Uint8Array<ArrayBuffer>} bytes */
+export async function c3Digest(bytes) {
+	return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', bytes)), (value) =>
+		value.toString(16).padStart(2, '0')
+	).join('');
+}
+
+// Only lower the limit of one defined, unshared wasm32 memory. Instructions and data stay intact.
+/**
+ * @param {Uint8Array<ArrayBuffer>} bytes
+ * @param {number} maximumBytes
+ * @param {{verifyModules?: boolean}} [options]
+ */
+export async function limitC3WasmMemory(bytes, maximumBytes, { verifyModules = true } = {}) {
+	if (
+		!(bytes instanceof Uint8Array) ||
+		bytes.length < 8 ||
+		!Number.isSafeInteger(maximumBytes) ||
+		maximumBytes < 0
+	) {
+		throw new Error('Invalid C3 Wasm memory limit request');
+	}
+	const header = [0, 97, 115, 109, 1, 0, 0, 0];
+	if (!header.every((byte, index) => bytes[index] === byte))
+		throw new Error('Invalid Wasm header');
+	let offset = 8;
+	const u32 = (end = bytes.length) => {
+		let result = 0;
+		for (let index = 0; index < 5; index++) {
+			if (offset >= end) throw new Error('Truncated Wasm integer');
+			const byte = bytes[offset++];
+			if (index === 4 && byte > 15) throw new Error('Invalid Wasm u32');
+			result += (byte & 127) * 2 ** (7 * index);
+			if (!(byte & 128)) return result;
+		}
+		throw new Error('Invalid Wasm integer');
+	};
+	/** @param {number} value */
+	const encode = (value) => {
+		const result = [];
+		do {
+			const low = value % 128;
+			value = Math.floor(value / 128);
+			result.push(low | (value ? 128 : 0));
+		} while (value);
+		return result;
+	};
+	let memory;
+	while (offset < bytes.length) {
+		const start = offset;
+		const id = bytes[offset++];
+		const size = u32();
+		const end = offset + size;
+		if (end > bytes.length) throw new Error('Truncated Wasm section');
+		if (id === 5) {
+			if (memory || u32(end) !== 1)
+				throw new Error('C3 supports exactly one defined Wasm memory');
+			const flags = u32(end);
+			if (flags !== 0 && flags !== 1)
+				throw new Error('Shared and memory64 C3 memories are unsupported');
+			const minimum = u32(end);
+			const originalMaximum = flags === 1 ? u32(end) : null;
+			if (
+				offset !== end ||
+				minimum > 65536 ||
+				(originalMaximum !== null && (originalMaximum < minimum || originalMaximum > 65536))
+			) {
+				throw new Error('Invalid Wasm memory section');
+			}
+			const maximum = Math.min(
+				Math.floor(maximumBytes / C3_WASM_PAGE_BYTES),
+				originalMaximum ?? 65536
+			);
+			if (minimum > maximum) {
+				const error = new Error(
+					'C3 Wasm initial memory exceeds the configured memory limit'
+				);
+				Object.assign(error, {
+					code: 'resource-limit',
+					resource: 'wasm-memory',
+					actual: minimum * C3_WASM_PAGE_BYTES,
+					limit: maximumBytes
+				});
+				throw error;
+			}
+			memory = { start, end, minimum, maximum, originalMaximum };
+		}
+		offset = end;
+	}
+	if (!memory) throw new Error('C3 requires one defined Wasm memory');
+	if (verifyModules) {
+		const module = await WebAssembly.compile(bytes);
+		if (WebAssembly.Module.imports(module).some((item) => item.kind === 'memory')) {
+			throw new Error('Imported C3 Wasm memories are unsupported');
+		}
+	}
+	const payload = [1, 1, ...encode(memory.minimum), ...encode(memory.maximum)];
+	const section = Uint8Array.from([5, ...encode(payload.length), ...payload]);
+	const limited = new Uint8Array(bytes.length - (memory.end - memory.start) + section.length);
+	limited.set(bytes.subarray(0, memory.start));
+	limited.set(section, memory.start);
+	limited.set(bytes.subarray(memory.end), memory.start + section.length);
+	if (verifyModules) await WebAssembly.compile(limited);
+	return {
+		bytes: limited,
+		evidence: {
+			originalSha256: await c3Digest(bytes),
+			limitedSha256: await c3Digest(limited),
+			initialBytes: memory.minimum * C3_WASM_PAGE_BYTES,
+			maximumBytes: memory.maximum * C3_WASM_PAGE_BYTES,
+			originalMaximumBytes:
+				memory.originalMaximum === null ? null : memory.originalMaximum * C3_WASM_PAGE_BYTES
+		}
+	};
+}

package/dist/playground/cachedClang.js

@@ -1,8 +1,11 @@
-import { resolveExecutionLimits, resolveRuntimeAssetCacheOptions } from '@wasm-idle/core';
+import { resolveExecutionLimits, resolveRuntimeAssetCacheOptions, OutputLimitError } from '@wasm-idle/core';
 import { resolveRuntimeAssetConfig } from './assets';
 import { WorkerAssetBridge } from './assetBridge';
 import { shouldStreamBundledClang } from './clangStreamingPolicy';
 import { CompiledArtifactCache, clangCompileKey } from './compiledArtifactCache';
+import { CLANG_STDIN_DATA, CLANG_STDIN_EOF, CLANG_STDIN_HEADER_BYTES } from './clangWorkerProtocol';
+const MAX_BUFFERED_INPUT_BYTES = 128 * 1024;
+const MAX_HEADER_BUILD_TIMEOUT_MS = 30_000;
 const workers = {
     async compile() {
         const { default: CompileWorker } = await import('./worker/cachedClangCompile?worker');
@@ -20,6 +23,7 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
     let runtimeBaseUrl = '';
     let assetConfig;
     let maxAssetBytes = 0;
+    let maxWasmMemoryBytes = 0;
     let languageSysroots = false;
     let activeWorker;
     let cancelWorker;
@@ -30,47 +34,97 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
     let inputBuffer;
     let inputRequested = false;
     let pendingEof = false;
+    let loadedMaxInputBytes = MAX_BUFFERED_INPUT_BYTES;
+    let maxBufferedInputBytes = loadedMaxInputBytes;
+    let pendingInputBytes = 0;
+    let loadedHeaderTimeoutMs = MAX_HEADER_BUILD_TIMEOUT_MS;
+    let headerTimeoutMs = loadedHeaderTimeoutMs;
+    let loadedMaxWorkers = 1;
+    let maxWorkers = loadedMaxWorkers;
     const pendingInput = [];
     const encoder = new TextEncoder();
-    // Built in the background by the compile worker after a <bits/stdc++.h> source; it outlives
-    // runs and cancellations and is discarded only with the sandbox.
+    // Header builds survive ordinary cancellation, within their own deadline and Worker budget.
     let precompiledHeader;
     let headerWorker;
+    function disposeWorker(worker, bridge) {
+        worker.onmessage = null;
+        worker.onerror = null;
+        worker.onmessageerror = null;
+        try {
+            bridge?.dispose();
+        }
+        catch {
+            // Cleanup must preserve the primary result and still attempt Worker termination.
+        }
+        try {
+            worker.terminate();
+        }
+        catch {
+            // Preserve the primary result even if a custom Worker fails to terminate.
+        }
+    }
     function adoptHeaderWorker(worker, bridge) {
         headerWorker?.dispose();
+        let settled = false;
+        let timeout;
         const dispose = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
             if (headerWorker?.worker === worker)
                 headerWorker = undefined;
-            bridge?.dispose();
-            worker.onmessage = null;
-            worker.onerror = null;
-            worker.onmessageerror = null;
-            worker.terminate();
+            disposeWorker(worker, bridge);
         };
         headerWorker = { worker, dispose };
+        timeout = setTimeout(dispose, headerTimeoutMs);
         worker.onerror = dispose;
         worker.onmessageerror = dispose;
         worker.onmessage = (event) => {
-            if (bridge?.handleMessage(event))
-                return;
-            if (event.data?.type !== 'precompiled-header')
+            if (settled || disposed || headerWorker?.worker !== worker)
                 return;
-            if (event.data.header)
-                precompiledHeader = event.data.header;
-            dispose();
+            try {
+                if (bridge?.handleMessage(event))
+                    return;
+                if (event.data?.type === 'error' && event.data.code === 'output-limit') {
+                    dispose();
+                    return;
+                }
+                if (event.data?.type !== 'precompiled-header')
+                    return;
+                if (event.data.header)
+                    precompiledHeader = event.data.header;
+                dispose();
+            }
+            catch {
+                dispose();
+            }
         };
     }
     function resetInput() {
         pendingInput.length = 0;
+        pendingInputBytes = 0;
         pendingEof = false;
         inputRequested = false;
         inputBuffer = undefined;
+        maxBufferedInputBytes = loadedMaxInputBytes;
+    }
+    function bufferedInputBytes() {
+        const control = inputBuffer && new Int32Array(inputBuffer, 0, 2);
+        // DATA remains owned by the consumer until it requests its next chunk.
+        const publishedBytes = control && Atomics.load(control, 0) === CLANG_STDIN_DATA ? Atomics.load(control, 1) : 0;
+        return pendingInputBytes + publishedBytes;
+    }
+    function assertInputCapacity(actual, limit = maxBufferedInputBytes) {
+        if (actual > limit) {
+            throw new RangeError(`C/C++ stdin buffered bytes exceed ${limit}`);
+        }
     }
     function flushInput() {
         if (!inputRequested || !inputBuffer)
             return;
         const control = new Int32Array(inputBuffer, 0, 2);
-        const payload = new Uint8Array(inputBuffer, 8);
+        const payload = new Uint8Array(inputBuffer, CLANG_STDIN_HEADER_BYTES);
         const next = pendingInput[0];
         if (next) {
             const length = Math.min(next.byteLength, payload.byteLength);
@@ -78,13 +132,14 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
             if (length === next.byteLength)
                 pendingInput.shift();
             else
-                pendingInput[0] = next.subarray(length);
+                pendingInput[0] = next.slice(length);
+            pendingInputBytes -= length;
             Atomics.store(control, 1, length);
-            Atomics.store(control, 0, 1);
+            Atomics.store(control, 0, CLANG_STDIN_DATA);
         }
         else if (pendingEof) {
             Atomics.store(control, 1, 0);
-            Atomics.store(control, 0, 2);
+            Atomics.store(control, 0, CLANG_STDIN_EOF);
         }
         else
             return;
@@ -98,9 +153,12 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
         resetInput();
     }
     async function workerOperation(factory, message, token, progress, compileLimit = 0, signal, executionAssetConfig = assetConfig) {
+        // The background compiler and the next foreground Worker share one budget.
+        if (headerWorker && maxWorkers < 2)
+            headerWorker.dispose();
         const worker = await factory();
         if (token !== generation || signal?.aborted) {
-            worker.terminate();
+            disposeWorker(worker);
             throw signal?.reason ?? new Error('Process terminated');
         }
         return new Promise((resolve, reject) => {
@@ -110,7 +168,7 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                     bridge = new WorkerAssetBridge(worker, 'clang', executionAssetConfig, progress, compileLimit, languageSysroots, runtimeCache);
             }
             catch (error) {
-                worker.terminate();
+                disposeWorker(worker);
                 reject(error);
                 return;
             }
@@ -124,15 +182,10 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                 activeWorker = undefined;
                 cancelWorker = undefined;
                 signal?.removeEventListener('abort', abort);
-                worker.onmessage = null;
-                worker.onerror = null;
-                worker.onmessageerror = null;
                 if (keepForHeader)
                     adoptHeaderWorker(worker, bridge);
-                else {
-                    bridge?.dispose();
-                    worker.terminate();
-                }
+                else
+                    disposeWorker(worker, bridge);
                 if (error)
                     reject(error);
                 else
@@ -170,6 +223,17 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                         flushInput();
                     }
                     else if (data.type === 'compiled' || data.type === 'error') {
+                        if (data.type === 'error' && data.code === 'output-limit') {
+                            finish(new OutputLimitError(data.error, {
+                                limit: data.limit,
+                                actual: data.actual,
+                                phase: 'compile'
+                            }));
+                            return;
+                        }
+                        for (const diagnostic of data.diagnostics ?? []) {
+                            legacy.oncompilerdiagnostic?.({ ...diagnostic });
+                        }
                         if (data.stdout)
                             legacy.output?.(data.stdout);
                         if (data.stderr)
@@ -178,7 +242,10 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                         if (data.type === 'error')
                             finish(new Error(data.error), undefined, keepForHeader);
                         else
-                            finish(undefined, data.artifact, keepForHeader);
+                            finish(undefined, {
+                                artifact: data.artifact,
+                                diagnostics: data.diagnostics ?? []
+                            }, keepForHeader);
                     }
                     else if (data.type === 'done') {
                         if (data.exitCode !== 0 && data.exitCode !== null)
@@ -222,6 +289,11 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                 return legacy.load(assets, code, log, args, options, progress);
             runtimeBaseUrl = assetConfig.baseUrl;
             maxAssetBytes = resolveExecutionLimits(options.limits).maxAssetBytes;
+            maxWasmMemoryBytes = resolveExecutionLimits(options.limits).maxWasmMemoryBytes;
+            loadedMaxInputBytes = Math.min(MAX_BUFFERED_INPUT_BYTES, resolveExecutionLimits(options.limits).maxWorkspaceBytes);
+            maxBufferedInputBytes = loadedMaxInputBytes;
+            loadedHeaderTimeoutMs = Math.min(MAX_HEADER_BUILD_TIMEOUT_MS, resolveExecutionLimits(options.limits).compileTimeoutMs);
+            loadedMaxWorkers = resolveExecutionLimits(options.limits).maxWorkers;
             languageSysroots = config?.clang?.bundledLanguageSysroots === true;
         },
         async run(code, prepare, log = true, progress, args = [], options = {}) {
@@ -246,10 +318,13 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
             };
             options.signal?.throwIfAborted();
             const token = ++generation;
+            headerTimeoutMs = Math.min(loadedHeaderTimeoutMs, resolveExecutionLimits(options.limits).compileTimeoutMs);
+            maxWorkers = Math.min(loadedMaxWorkers, resolveExecutionLimits(options.limits).maxWorkers);
             // 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 = {
+                maxWasmMemoryBytes: Math.min(maxWasmMemoryBytes, resolveExecutionLimits(options.limits).maxWasmMemoryBytes),
                 code,
                 language,
                 activePath: options.activePath,
@@ -268,16 +343,37 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                 ? undefined
                 : Object.fromEntries(Object.entries(options.env));
             const stdin = options.stdin;
+            const inputLimit = Math.min(loadedMaxInputBytes, resolveExecutionLimits(options.limits).maxWorkspaceBytes);
+            if (!prepare && typeof stdin === 'string') {
+                // A string stdin is a complete input stream and replaces any queued writes.
+                // Check UTF-16 length first to avoid encoding an arbitrarily large write.
+                assertInputCapacity(stdin.length, inputLimit);
+                assertInputCapacity(encoder.encode(stdin).byteLength, inputLimit);
+                resetInput();
+                pendingEof = true;
+            }
+            else {
+                assertInputCapacity(bufferedInputBytes(), inputLimit);
+            }
             const limit = Math.min(maxAssetBytes, resolveExecutionLimits(options.limits).maxAssetBytes);
             const key = clangCompileKey(runtimeBaseUrl, limit, request, languageSysroots);
             let artifact = cache.get(key);
+            // Per-run backpressure starts only after admission and ends with this run.
+            maxBufferedInputBytes = inputLimit;
             running = true;
             try {
-                if (!artifact) {
-                    artifact = await workerOperation(() => factories.compile(), {
+                if (artifact) {
+                    for (const diagnostic of cache.getDiagnostics(key))
+                        legacy.oncompilerdiagnostic?.(diagnostic);
+                    if (token !== generation)
+                        throw new Error('Process terminated');
+                }
+                else {
+                    const compiled = await workerOperation(() => factories.compile(), {
                         request,
                         runtimeBaseUrl,
                         maxAssetBytes: limit,
+                        maxOutputBytes: resolveExecutionLimits(options.limits).maxOutputBytes,
                         languageSysroots,
                         log,
                         persistentCache: executionAssetConfig.persistentCache,
@@ -293,14 +389,16 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                     }, token, progress, limit, options.signal, executionAssetConfig);
                     if (token !== generation)
                         throw new Error('Process terminated');
-                    cache.set(key, artifact);
+                    artifact = compiled.artifact;
+                    cache.set(key, artifact, compiled.diagnostics);
                 }
                 progress?.set?.(1);
                 if (prepare)
                     return true;
-                inputBuffer = new SharedArrayBuffer(65536 + 8);
+                inputBuffer = new SharedArrayBuffer(Math.min(65536, maxBufferedInputBytes) + CLANG_STDIN_HEADER_BYTES);
                 return await workerOperation(() => factories.execute(), {
                     artifact,
+                    maxWasmMemoryBytes: request.maxWasmMemoryBytes,
                     code,
                     activePath: request.activePath,
                     workspaceFiles: request.workspaceFiles,
@@ -313,16 +411,27 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
             finally {
                 if (token === generation) {
                     running = false;
+                    maxBufferedInputBytes = loadedMaxInputBytes;
                     if (!prepare)
                         resetInput();
                 }
             }
         },
         write(input) {
+            if (disposed)
+                throw new Error('C/C++ sandbox was disposed');
             if (!cached)
                 return legacy.write?.(input);
-            if (input)
-                pendingInput.push(encoder.encode(input));
+            if (pendingEof)
+                throw new Error('C/C++ stdin is closed');
+            if (input) {
+                const buffered = bufferedInputBytes();
+                assertInputCapacity(buffered + input.length);
+                const bytes = encoder.encode(input);
+                assertInputCapacity(buffered + bytes.byteLength);
+                pendingInput.push(bytes);
+                pendingInputBytes += bytes.byteLength;
+            }
             flushInput();
         },
         eof() {

package/dist/playground/clangAssetIntegrity.js

@@ -7,10 +7,10 @@ export const BUNDLED_CLANG_ASSET_INTEGRITY = Object.freeze({
     'runtime-manifest.v1.json': integrityEntry(967, '0b854bc6b41924420cfcc840509ecbe03af3c63ca3edd4940897917e32c8d8ad'),
     'libc-printscan-long-double.a.gz': integrityEntry(52_723, 'b3f11e17e40fb13371a97244fdde00d5bd951ad8e20dfdf88a069167d6be628b', 111_062, '33e04007d3547095068391b42189d1ac5398dd04e9da3118dfa644ffea7f4148'),
     'bin/memfs.wasm.gz': integrityEntry(16_111, 'a3e43451bc15ae69a7f113009e2ee82ab4db711625c1782cd45d0d3c4d38175a', 38_071, '5b741e03dd3502bcfd80e4e5055232b5d633604e1461752efed0189f93407dc3'),
-    'bin/clang.wasm.gz': integrityEntry(13_121_917, '8dc032057fbeb41e4a9986dfc54b2336c17532033dee172eb0095eba9c5fbe75', 35_658_969, 'd92ef06cdd3fea88acf384db15a6f2a344790c05bcba8e9f13f5b75b36ad4a99'),
-    'bin/lld.wasm.gz': integrityEntry(6_417_339, '495813efde8f354c38483749cdface7a7d9e23c8411da45a6f5f80030159eb11', 16_171_013, '34d39bc410c098e7e09933b61cc8e28699447af9a28abf4544d71b6e9cad1f9d'),
-    'bin/sysroot.tar.gz': integrityEntry(5_059_493, 'c0ef46e903492383a3c7069bfd4aed0e764e8df988f92bb81eb96bea50bf2c00', 19_312_640, 'e122f1acec0642d62d8976101c542aaa5346460df6eae5a3f8efb594ff32f5ae'),
-    'bin/c-sysroot.tar.gz': integrityEntry(1_216_797, 'fb3e1cdacac3eceddcfe2e57cbbf78e593ec2a298f01acb61c06e4b9d24fbbee', 3_736_064, '720c620e459025e918747768b9f5f1aef7b48c6df1b34c1a31fb2e5b1b7a213e'),
-    'bin/cpp-addon.tar.gz': integrityEntry(3_840_608, '47e9946c5aaeb3b35a1d42d6a80eae8987c596f4f858b207e492c00d8680af9e', 15_572_992, '7d61b724d377dc4e5670725055fb2884ebc8153d697e05093992004d5859310d'),
-    'language-sysroots.v1.json': integrityEntry(175_348, 'd69acbdb636009dc5b2243f13f1580264f64a34362f0af67c9cd661388b565d0')
+    'bin/clang.wasm.gz': integrityEntry(13_124_999, 'cc7b6b229af392f439a1ca89dbb8d5e016792264a0a6ee59608ff24e269be982', 35_597_829, 'fe7c40c2369d4a1b91d87cd2a38b1a5be11cd7f381373b7888be0b5f209e2d5b'),
+    'bin/lld.wasm.gz': integrityEntry(6_421_841, '798ce825f3e3cf9a695b6a049f157ba28d38731a3dc5e699ccdf23d69d3a5c20', 16_136_490, '77949fed32d5481979b8ebe6081009e3ec69c7219cb355e3f388a316746ea9b7'),
+    'bin/sysroot.tar.gz': integrityEntry(6_780_412, '6188b500fa7af2dceadcbd6dcf2619b6935fa94c224c1c2078426666ebea1d50', 35_594_240, 'fb6d8a8786ec395009d44f62ff24a5bf09ff8672340b7dae9f48e28cf1569cba'),
+    'bin/c-sysroot.tar.gz': integrityEntry(2_006_388, 'da7a29250b2fe2d928fa8818069ff67e1dcb26c529bbf01f40bbeb251535ecaa', 12_213_760, '517b32208f4e556b22eb5ac775411c39fb75239dfaf81f206e6052e168425b62'),
+    'bin/cpp-addon.tar.gz': integrityEntry(4_776_509, '6e243c219561b1f5aad64db4a9ff8bbeb85a97b5e3b5df3ed71d8340d35a8cd7', 23_382_528, 'feaf2aa538623ec8c543ccb49e9a833d2a1aa6dee7a9ad502c277deba24ef642'),
+    'language-sysroots.v1.json': integrityEntry(426_858, '08f6c2c87b4bebc9599193334e1d0ed322ebb38cbdd2bbb83d2b8c3a4cb61263')
 });

package/dist/playground/clangWorkerProtocol.d.ts

@@ -1,9 +1,11 @@
 import type { BrowserClangArtifact, BrowserClangCompileProgress, BrowserClangCompileRequest, BrowserClangPrecompiledHeader, BrowserClangWorkspaceFile } from '@wasm-idle/llvm-core/clang';
+import type { CompilerDiagnostic } from '@wasm-idle/llvm-core/clang';
 import type { WorkerRuntimeAssetConfig } from './worker/assets';
 export type ClangCompileWorkerRequest = {
     request: Omit<BrowserClangCompileRequest, 'onProgress'>;
     runtimeBaseUrl: string;
     maxAssetBytes?: number;
+    maxOutputBytes?: number;
     languageSysroots?: boolean;
     log?: boolean;
     assets: WorkerRuntimeAssetConfig;
@@ -23,18 +25,27 @@ export type ClangCompileWorkerResponse = {
     artifact: BrowserClangArtifact;
     stdout: string;
     stderr: string;
+    diagnostics?: CompilerDiagnostic[];
     precompiledHeader?: 'building';
-} | {
+} | ({
     type: 'error';
     error: string;
     stdout: string;
     stderr: string;
+    diagnostics?: CompilerDiagnostic[];
     precompiledHeader?: 'building';
+} & ({
+    code?: undefined;
 } | {
+    code: 'output-limit';
+    limit: number;
+    actual: number;
+})) | {
     type: 'precompiled-header';
     header?: BrowserClangPrecompiledHeader;
 };
 export type ClangExecuteWorkerRequest = {
+    maxWasmMemoryBytes?: number;
     artifact: BrowserClangArtifact;
     programArgs?: string[];
     env?: Record<string, string>;

package/dist/playground/cobol.d.ts

@@ -1,4 +1,5 @@
 import { WorkerAssetBridge } from './assetBridge';
+import type { RuntimeAssetCache } from './runtimeAssetCache';
 import { type PlaygroundRuntimeAssets } from './assets';
 import type { SandboxExecutionOptions } from './options';
 import type { Sandbox, SandboxProgress } from './sandbox';
@@ -18,10 +19,12 @@ declare class Cobol implements Sandbox {
     assetBridge: WorkerAssetBridge | null;
     activeCobolBaseUrl: string;
     private activeOperation;
+    private runtimeAssetCache?;
     private disposed;
     private disposePromise;
     private readonly disposeCancellation;
     private readonly workerSession;
+    setRuntimeAssetCache(cache: RuntimeAssetCache): void;
     private beginOperation;
     private isOperationActive;
     private releaseOperation;

package/dist/playground/cobol.js

@@ -26,6 +26,7 @@ class Cobol {
     assetBridge = null;
     activeCobolBaseUrl = '';
     activeOperation = null;
+    runtimeAssetCache;
     disposed = false;
     disposePromise = null;
     disposeCancellation = new CancelledError('COBOL sandbox disposed', {
@@ -53,6 +54,14 @@ class Cobol {
             this.pendingEof = false;
         }
     });
+    setRuntimeAssetCache(cache) {
+        if (this.runtimeAssetCache === cache)
+            return;
+        if (this.disposed || this.worker || this.activeOperation) {
+            throw new RuntimeConfigurationError('Cannot replace an active COBOL compiler cache');
+        }
+        this.runtimeAssetCache = cache;
+    }
     beginOperation(phase) {
         if (this.disposed) {
             throw new RuntimeConfigurationError('COBOL sandbox is disposed', {
@@ -303,7 +312,7 @@ class Cobol {
                     }
                     let assetBridge;
                     try {
-                        assetBridge = new WorkerAssetBridge(worker, 'clang', clangAssets, progress, limits.maxAssetBytes);
+                        assetBridge = new WorkerAssetBridge(worker, 'clang', clangAssets, progress, limits.maxAssetBytes, false, this.runtimeAssetCache);
                     }
                     catch (error) {
                         try {

package/dist/playground/commonlispAssets.d.ts

@@ -10,8 +10,8 @@ export declare function resolveCommonLispRuntimeAssetConfig(assets: string | Pla
     workerUrl: string;
     manifestFingerprint: "56f1eb7cf6470619cb3393e99d5c8ad1841a001ab758f388c006ca1d801ba071";
     workerReceipt: {
-        readonly bytes: 11814;
-        readonly sha256: "46b24c0fbde93dfaa71ddbce697d717c772ad8fd03f8486ad2102c41145606c6";
+        readonly bytes: 12104;
+        readonly sha256: "d179242c40cdce862ff45bb35f736eaf8e79b97bdc06754576406ad4de698b7d";
     };
 };
 export declare function preflightCommonLispRuntimeAssets(baseUrl: string, options: {

package/dist/playground/compiledArtifactCache.d.ts

@@ -1,4 +1,5 @@
 import type { BrowserClangArtifact, BrowserClangCompileRequest } from '@wasm-idle/llvm-core/clang';
+import type { CompilerDiagnostic } from '@wasm-idle/llvm-core/clang';
 /** Only immutable compiler output lives here, never a worker, instance, or filesystem. */
 export declare class CompiledArtifactCache {
     private entries;
@@ -9,7 +10,8 @@ export declare class CompiledArtifactCache {
     private maxBytes;
     constructor(maxEntries?: number, maxBytes?: number);
     get(key: string): BrowserClangArtifact | undefined;
-    set(key: string, artifact: BrowserClangArtifact): void;
+    getDiagnostics(key: string): CompilerDiagnostic[];
+    set(key: string, artifact: BrowserClangArtifact, diagnostics?: CompilerDiagnostic[]): void;
     clear(): void;
     stats(): {
         hits: number;