wasm-idle 1.0.9 → 1.0.10

package/dist/playground/assetBridge.js

@@ -225,9 +225,13 @@ class RuntimeLoadProgress {
     progress;
     lockedTotal;
     measurementInvalid = false;
-    constructor(runtime, languageSysroots = false) {
+    constructor(runtime, languageSysroots = false, clangdHeaders = false) {
         this.expectedAssets = expectedAssetsForRuntime(runtime);
         this.optionalAssets = new Set();
+        if (runtime === 'clangd' && !clangdHeaders) {
+            this.expectedAssets.delete('clangd.headers.json.gz');
+            this.optionalAssets.add('clangd.headers.json.gz');
+        }
         if (runtime === 'clang') {
             this.expectedAssets.delete(printscanLongDoubleAsset);
             this.optionalAssets.add(printscanLongDoubleAsset);
@@ -387,7 +391,6 @@ export class WorkerAssetBridge {
     runtime;
     config;
     persistentCacheBaseline;
-    persistentCacheBySignal = new WeakMap();
     progress;
     expectedAssets;
     languageSysroots;
@@ -404,7 +407,7 @@ export class WorkerAssetBridge {
         this.config = { ...config, persistentCache: this.persistentCacheBaseline };
         this.maxAssetBytes = requireBridgeMaxAssetBytes(maxAssetBytes);
         this.languageSysroots = canUseClangLanguageSysroots(runtime, config, languageSysroots);
-        this.progress = new RuntimeLoadProgress(runtime, this.languageSysroots);
+        this.progress = new RuntimeLoadProgress(runtime, this.languageSysroots, config.assetPrefix === 'clangd' || !!config.integrity?.['clangd.headers.json.gz']);
         this.expectedAssets = expectedAssetsForRuntime(runtime, this.languageSysroots);
         this.progress.reset(progress);
     }
@@ -455,7 +458,7 @@ export class WorkerAssetBridge {
             this.maxAssetBytes = nextMaxAssetBytes;
             this.languageSysroots = nextLanguageSysroots;
             this.expectedAssets = expectedAssetsForRuntime(this.runtime, nextLanguageSysroots);
-            this.progress = new RuntimeLoadProgress(this.runtime, nextLanguageSysroots);
+            this.progress = new RuntimeLoadProgress(this.runtime, nextLanguageSysroots, config.assetPrefix === 'clangd' || !!config.integrity?.['clangd.headers.json.gz']);
             this.progress.reset(progress);
             if (this.state !== 'rebinding' || this.generation !== generation) {
                 throw new Error('Cannot rebind a disposed worker asset bridge');
@@ -482,7 +485,7 @@ export class WorkerAssetBridge {
             return;
         this.progress.reset(progress);
     }
-    configuredReceiptByteLimit(asset, value) {
+    configuredReceiptByteLimit(context, asset, value) {
         if (value === undefined)
             return undefined;
         if (!Number.isSafeInteger(value) || value < 0) {
@@ -492,37 +495,37 @@ export class WorkerAssetBridge {
             });
         }
         const byteLimit = value;
-        if (byteLimit > this.maxAssetBytes) {
-            throw runtimeAssetSizeError(asset, this.maxAssetBytes);
+        if (byteLimit > context.maxAssetBytes) {
+            throw runtimeAssetSizeError(asset, context.maxAssetBytes);
         }
         return byteLimit;
     }
-    runtimeAssetByteLimit(asset) {
-        const configured = this.config.integrity?.[asset];
+    runtimeAssetByteLimit(context, asset) {
+        const configured = context.config.integrity?.[asset];
         if (!configured || typeof configured === 'string')
-            return this.maxAssetBytes;
-        return (this.configuredReceiptByteLimit(asset, configured.uncompressedBytes ?? configured.bytes) ?? this.maxAssetBytes);
+            return context.maxAssetBytes;
+        return (this.configuredReceiptByteLimit(context, asset, configured.uncompressedBytes ?? configured.bytes) ?? context.maxAssetBytes);
     }
-    sourceAssetByteLimit(asset) {
-        const configured = this.config.integrity?.[asset];
+    sourceAssetByteLimit(context, asset) {
+        const configured = context.config.integrity?.[asset];
         if (!configured || typeof configured === 'string')
-            return this.maxAssetBytes;
+            return context.maxAssetBytes;
         const paired = configured.uncompressedBytes !== undefined ||
             configured.uncompressedSha256 !== undefined;
         if (asset.endsWith('.gz')) {
             if (!paired)
-                return this.maxAssetBytes;
-            const deliveryLimit = this.configuredReceiptByteLimit(asset, configured.bytes);
-            const runtimeLimit = this.configuredReceiptByteLimit(asset, configured.uncompressedBytes);
+                return context.maxAssetBytes;
+            const deliveryLimit = this.configuredReceiptByteLimit(context, asset, configured.bytes);
+            const runtimeLimit = this.configuredReceiptByteLimit(context, asset, configured.uncompressedBytes);
             return deliveryLimit !== undefined || runtimeLimit !== undefined
                 ? Math.max(deliveryLimit ?? 0, runtimeLimit ?? 0)
-                : this.maxAssetBytes;
+                : context.maxAssetBytes;
         }
-        const deliveryLimit = this.configuredReceiptByteLimit(asset, configured.bytes);
-        const runtimeLimit = this.configuredReceiptByteLimit(asset, configured.uncompressedBytes);
+        const deliveryLimit = this.configuredReceiptByteLimit(context, asset, configured.bytes);
+        const runtimeLimit = this.configuredReceiptByteLimit(context, asset, configured.uncompressedBytes);
         return deliveryLimit !== undefined || runtimeLimit !== undefined
             ? Math.max(deliveryLimit ?? 0, runtimeLimit ?? 0)
-            : this.maxAssetBytes;
+            : context.maxAssetBytes;
     }
     handleMessage(event) {
         const assetRequest = event.data?.assetRequest;
@@ -546,69 +549,112 @@ export class WorkerAssetBridge {
         const worker = this.worker;
         const generation = this.generation;
         const controller = new AbortController();
-        this.persistentCacheBySignal.set(controller.signal, resolveRuntimeAssetCacheOptions(this.config.persistentCache));
+        const progress = this.progress;
+        const context = this.captureLoadContext();
+        const receiveProgress = (event) => {
+            if (controller.signal.aborted || generation !== this.generation)
+                return;
+            if (event.kind === 'download') {
+                progress.update(event.asset, event.loaded, event.total);
+            }
+            else {
+                progress.activity(event.phase, event.asset);
+            }
+        };
+        const loadContext = (report) => ({
+            ...context,
+            progress: {
+                update: (asset, loaded, total) => report({ kind: 'download', asset, loaded, total }, `download:${asset}`),
+                activity: (phase, asset) => report({ kind: 'activity', asset, phase }, `activity:${asset}`)
+            }
+        });
         this.activeLoads.add(controller);
         try {
-            this.validateAssetRequest(request.asset);
-            const key = JSON.stringify([
+            this.validateAssetRequest(loadContext(receiveProgress), request.asset);
+            const identity = [
                 this.runtime,
-                this.config.baseUrl,
-                this.cache?.identity(this.config.loader),
-                integrityKey(this.config),
-                allowedBaseUrlsKey(this.config),
-                this.config.useAssetBridge,
-                this.maxAssetBytes,
+                context.config.baseUrl,
+                this.cache?.identity(context.config.loader),
+                integrityKey(context.config),
+                allowedBaseUrlsKey(context.config),
+                context.config.useAssetBridge,
+                context.maxAssetBytes,
                 this.languageSysroots,
-                request.asset,
-                request.module === true ? 'module' : 'bytes'
-            ]);
+                request.asset
+            ];
+            const bytesKey = JSON.stringify([...identity, 'bytes']);
+            const moduleKey = JSON.stringify([...identity, 'module']);
+            const share = (key, signal, start, report = receiveProgress) => {
+                // Completed verified values can cross storage policies. In-flight work cannot:
+                // a request disabling persistence must not join a load that reads or writes it.
+                const operationKey = JSON.stringify([key, context.config.persistentCache]);
+                return this.cache
+                    ? this.cache.share(operationKey, signal, start, report)
+                    : start(signal, report);
+            };
+            const loadBytes = async (signal, report = receiveProgress, retain = false) => {
+                let loaded = this.cache?.get(bytesKey);
+                if (loaded)
+                    return loaded;
+                loaded = await share(bytesKey, signal, async (operationSignal, publish) => {
+                    const loaded = await this.loadVerifiedAsset(loadContext(publish), request.asset, operationSignal);
+                    // Keep shared backing buffers private, even when the result exceeds retention limits.
+                    return this.cache
+                        ? { bytes: Uint8Array.from(loaded.bytes), mimeType: loaded.mimeType }
+                        : loaded;
+                }, report);
+                if (signal.aborted)
+                    throw runtimeAssetAbortReason(signal);
+                if (retain)
+                    this.cache?.set(bytesKey, loaded, loaded.bytes.byteLength);
+                return loaded;
+            };
             if (request.module === true) {
                 if (!/\.wasm(?:\.gz)?$/u.test(request.asset)) {
                     throw new Error('Only runtime Wasm assets can be compiled');
                 }
-                let module = this.cache?.get(key);
+                let module = this.cache?.get(moduleKey);
                 if (!module) {
-                    const streaming = this.runtime === 'clang' &&
-                        shouldStreamBundledClang(this.config) &&
-                        (request.asset === 'bin/clang.wasm.gz' ||
-                            request.asset === 'bin/lld.wasm.gz');
-                    let bytes;
-                    if (streaming) {
-                        const receipt = BUNDLED_CLANG_ASSET_INTEGRITY[request.asset];
-                        module = await compileVerifiedWasmAsset(new URL(request.asset, this.config.baseUrl).href, receipt, {
-                            fetch: globalThis.fetch.bind(globalThis),
-                            persistentCache: this.persistentCacheBySignal.get(controller.signal),
-                            maxAssetBytes: this.maxAssetBytes,
-                            signal: controller.signal,
-                            onProgress: (loaded, total) => this.progress.update(request.asset, loaded, total)
-                        });
-                        bytes = receipt.uncompressedBytes;
-                    }
-                    else {
-                        const loaded = await this.loadVerifiedAsset(request.asset, controller.signal);
-                        bytes = loaded.bytes.byteLength;
-                        module = await WebAssembly.compile(Uint8Array.from(loaded.bytes));
-                    }
-                    if (controller.signal.aborted || generation !== this.generation)
-                        return;
-                    this.cache?.set(key, module, bytes);
+                    module = await share(moduleKey, controller.signal, async (signal, report) => {
+                        const streaming = this.runtime === 'clang' &&
+                            shouldStreamBundledClang(context.config) &&
+                            (request.asset === 'bin/clang.wasm.gz' ||
+                                request.asset === 'bin/lld.wasm.gz');
+                        let bytes;
+                        let module;
+                        if (streaming) {
+                            const receipt = BUNDLED_CLANG_ASSET_INTEGRITY[request.asset];
+                            module = await compileVerifiedWasmAsset(new URL(request.asset, context.config.baseUrl).href, receipt, {
+                                fetch: globalThis.fetch.bind(globalThis),
+                                persistentCache: context.config.persistentCache,
+                                maxAssetBytes: context.maxAssetBytes,
+                                signal,
+                                onProgress: (loaded, total) => report({
+                                    kind: 'download',
+                                    asset: request.asset,
+                                    loaded,
+                                    total
+                                }, `download:${request.asset}`)
+                            });
+                            bytes = receipt.uncompressedBytes;
+                        }
+                        else {
+                            const loaded = await loadBytes(signal, (event) => report(event, `${event.kind}:${event.asset}`));
+                            bytes = loaded.bytes.byteLength;
+                            module = await WebAssembly.compile(Uint8Array.from(loaded.bytes));
+                        }
+                        if (signal.aborted)
+                            throw runtimeAssetAbortReason(signal);
+                        this.cache?.set(moduleKey, module, bytes);
+                        return module;
+                    });
                 }
                 if (controller.signal.aborted || generation !== this.generation)
                     return;
                 worker.postMessage({ assetResponse: { id: request.id, ok: true, module } });
                 return;
             }
-            let loaded = this.cache?.get(key);
-            if (!loaded) {
-                loaded = await this.loadVerifiedAsset(request.asset, controller.signal);
-                if (controller.signal.aborted || generation !== this.generation)
-                    return;
-                // Keep private copies: never transfer or lend the owner cache's backing buffer.
-                if (this.cache) {
-                    loaded = { bytes: Uint8Array.from(loaded.bytes), mimeType: loaded.mimeType };
-                    this.cache.set(key, loaded, loaded.bytes.byteLength);
-                }
-            }
+            const loaded = await loadBytes(controller.signal, receiveProgress, true);
             if (this.runtime === 'python' && request.asset === 'pyodide-lock.json') {
                 this.pythonPackageAssets = readPythonPackageAssets(loaded.bytes);
             }
@@ -644,15 +690,24 @@ export class WorkerAssetBridge {
             this.activeLoads.delete(controller);
         }
     }
-    async loadVerifiedAsset(asset, signal) {
-        const loaded = await this.loadAsset(asset, signal);
+    captureLoadContext() {
+        return {
+            config: { ...this.config },
+            maxAssetBytes: this.maxAssetBytes,
+            expectedAssets: new Set(this.expectedAssets),
+            pythonPackageAssets: new Set(this.pythonPackageAssets),
+            progress: this.progress
+        };
+    }
+    async loadVerifiedAsset(context, asset, signal) {
+        const loaded = await this.loadAsset(asset, signal, context);
         const deliveryBytes = canonicalUint8Array(loaded.bytes);
-        const sourceAssetByteLimit = this.sourceAssetByteLimit(asset);
-        const runtimeAssetByteLimit = this.runtimeAssetByteLimit(asset);
+        const sourceAssetByteLimit = this.sourceAssetByteLimit(context, asset);
+        const runtimeAssetByteLimit = this.runtimeAssetByteLimit(context, asset);
         requireRuntimeAssetSize(asset, deliveryBytes.byteLength, sourceAssetByteLimit);
         let normalizedRuntimeBytes;
         if (asset.endsWith('.gz')) {
-            this.progress.activity('decompressing', asset);
+            context.progress.activity('decompressing', asset);
             normalizedRuntimeBytes = await decompressGzip(deliveryBytes, asset, runtimeAssetByteLimit, signal);
         }
         else {
@@ -673,10 +728,10 @@ export class WorkerAssetBridge {
             signal.addEventListener('abort', cancelOnAbort, { once: true });
         });
         try {
-            if (this.config.integrity?.[asset]) {
-                this.progress.activity('verifying', asset);
+            if (context.config.integrity?.[asset]) {
+                context.progress.activity('verifying', asset);
             }
-            const verification = this.verifyIntegrity(asset, deliveryBytes, runtimeBytes, loaded.mimeType, !httpDecodedGzip);
+            const verification = this.verifyIntegrity(context, asset, deliveryBytes, runtimeBytes, loaded.mimeType, !httpDecodedGzip);
             await Promise.race([verification, aborted]);
         }
         finally {
@@ -694,27 +749,27 @@ export class WorkerAssetBridge {
             transferOwnership: normalizedRuntimeBytes === deliveryBytes ? loaded.transferOwnership : true
         };
     }
-    validateAssetRequest(asset) {
-        if (!this.expectedAssets.has(asset) && !this.pythonPackageAssets.has(asset)) {
+    validateAssetRequest(context, asset) {
+        if (!context.expectedAssets.has(asset) && !context.pythonPackageAssets.has(asset)) {
             throw new Error(`Unexpected ${this.runtime} runtime asset: ${asset}`);
         }
-        if (this.config.integrity && !Object.hasOwn(this.config.integrity, asset)) {
+        if (context.config.integrity && !Object.hasOwn(context.config.integrity, asset)) {
             throw new Error(`Runtime asset ${asset} is missing integrity metadata`);
         }
     }
-    async loadAsset(asset, signal) {
-        this.validateAssetRequest(asset);
+    async loadAsset(asset, signal, context = this.captureLoadContext()) {
+        this.validateAssetRequest(context, asset);
         if (signal.aborted) {
             throw runtimeAssetAbortReason(signal);
         }
-        const sourceAssetByteLimit = this.sourceAssetByteLimit(asset);
-        this.runtimeAssetByteLimit(asset);
+        const sourceAssetByteLimit = this.sourceAssetByteLimit(context, asset);
+        this.runtimeAssetByteLimit(context, asset);
         const reportProgress = (loaded, total) => {
             if (!signal.aborted)
-                this.progress.update(asset, loaded, total);
+                context.progress.update(asset, loaded, total);
         };
-        if (this.config.loader) {
-            const pendingResult = Promise.resolve(this.config.loader({
+        if (context.config.loader) {
+            const pendingResult = Promise.resolve(context.config.loader({
                 runtime: this.runtime,
                 asset,
                 reportProgress,
@@ -749,17 +804,17 @@ export class WorkerAssetBridge {
             if (signal.aborted) {
                 throw runtimeAssetAbortReason(signal);
             }
-            const loaded = await this.normalizeLoaderResult(result, asset, signal, sourceAssetByteLimit);
+            const loaded = await this.normalizeLoaderResult(context, result, asset, signal, sourceAssetByteLimit);
             if (signal.aborted) {
                 throw runtimeAssetAbortReason(signal);
             }
             if (loaded)
                 return loaded;
         }
-        return await this.fetchAsset(asset, asset, signal, sourceAssetByteLimit);
+        return await this.fetchAsset(context, asset, asset, signal, sourceAssetByteLimit);
     }
-    async verifyIntegrity(asset, deliveryBytes, runtimeBytes, mimeType, hasDeliveryBytes = true) {
-        const configured = this.config.integrity?.[asset];
+    async verifyIntegrity(context, asset, deliveryBytes, runtimeBytes, mimeType, hasDeliveryBytes = true) {
+        const configured = context.config.integrity?.[asset];
         if (!configured)
             return;
         const expected = typeof configured === 'string' ? { sha256: configured } : configured;
@@ -796,15 +851,15 @@ export class WorkerAssetBridge {
             mimeType
         });
     }
-    async normalizeLoaderResult(result, asset, signal, maxAssetBytes) {
+    async normalizeLoaderResult(context, result, asset, signal, maxAssetBytes) {
         if (!result)
             return null;
         if (typeof result === 'string' || result instanceof URL) {
-            return await this.fetchAsset(String(result), asset, signal, maxAssetBytes);
+            return await this.fetchAsset(context, String(result), asset, signal, maxAssetBytes);
         }
         const directBytes = snapshotLoaderBytes(result, asset, maxAssetBytes);
         if (directBytes) {
-            this.progress.update(asset, directBytes.byteLength, directBytes.byteLength);
+            context.progress.update(asset, directBytes.byteLength, directBytes.byteLength);
             return { bytes: directBytes, transferOwnership: true };
         }
         const directBlob = tryCanonicalBlob(result);
@@ -827,23 +882,23 @@ export class WorkerAssetBridge {
             requireRuntimeAssetSize(asset, size, maxAssetBytes);
             const source = await readAbortableArrayBuffer(blob, signal);
             const bytes = snapshotMaterializedArrayBuffer(source, asset, maxAssetBytes);
-            this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+            context.progress.update(asset, bytes.byteLength, bytes.byteLength);
             return { bytes, mimeType, transferOwnership: true };
         }
         if ('url' in result && result.url) {
-            return await this.fetchAsset(String(result.url), asset, signal, maxAssetBytes);
+            return await this.fetchAsset(context, String(result.url), asset, signal, maxAssetBytes);
         }
         if ('data' in result) {
             if (typeof result.data === 'string') {
                 requireRuntimeAssetSize(asset, boundedUtf8ByteLength(result.data, maxAssetBytes), maxAssetBytes);
                 const bytes = canonicalUint8Array(encoder.encode(result.data));
                 requireRuntimeAssetSize(asset, bytes.byteLength, maxAssetBytes);
-                this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+                context.progress.update(asset, bytes.byteLength, bytes.byteLength);
                 return { bytes, mimeType: result.mimeType, transferOwnership: true };
             }
             const bytes = snapshotLoaderBytes(result.data, asset, maxAssetBytes);
             if (bytes) {
-                this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+                context.progress.update(asset, bytes.byteLength, bytes.byteLength);
                 return {
                     bytes,
                     mimeType: result.mimeType,
@@ -853,15 +908,15 @@ export class WorkerAssetBridge {
         }
         return null;
     }
-    async fetchAsset(url, asset, signal, maxAssetBytes = this.sourceAssetByteLimit(asset)) {
-        const requestUrl = this.requireAllowedAssetUrl(asset, url);
-        const persistentCache = this.persistentCacheBySignal.get(signal) ?? this.config.persistentCache;
-        const configured = this.config.integrity?.[asset];
+    async fetchAsset(context, url, asset, signal, maxAssetBytes = this.sourceAssetByteLimit(context, asset)) {
+        const requestUrl = this.requireAllowedAssetUrl(context, asset, url);
+        const persistentCache = context.config.persistentCache;
+        const configured = context.config.integrity?.[asset];
         const expected = typeof configured === 'string' ? { sha256: configured } : configured;
-        const lock = this.config.assetPrefix
+        const lock = context.config.assetPrefix
             ? resolveRuntimeAssetLockEntry(requestUrl, {
-                assetRoot: this.config.baseUrl,
-                assetPrefix: this.config.assetPrefix
+                assetRoot: context.config.baseUrl,
+                assetPrefix: context.config.assetPrefix
             })
             : undefined;
         // Existing .gz receipts without a pair describe logical bytes, not stored gzip bytes.
@@ -873,8 +928,8 @@ export class WorkerAssetBridge {
                 bytes: receipt.bytes,
                 validationKey: JSON.stringify([
                     'bridge-v1',
-                    this.config.baseUrl,
-                    allowedBaseUrlsKey(this.config),
+                    context.config.baseUrl,
+                    allowedBaseUrlsKey(context.config),
                     maxAssetBytes
                 ])
             }
@@ -887,11 +942,11 @@ export class WorkerAssetBridge {
             });
             if (bytes) {
                 requireRuntimeAssetSize(asset, bytes.byteLength, maxAssetBytes);
-                this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+                context.progress.update(asset, bytes.byteLength, bytes.byteLength);
                 return { bytes, mimeType: receipt?.mediaType, transferOwnership: true };
             }
         }
-        const loaded = await this.fetchAssetFromNetwork(url, asset, signal, maxAssetBytes);
+        const loaded = await this.fetchAssetFromNetwork(context, url, asset, signal, maxAssetBytes);
         if (identity && !loaded.contentEncoding) {
             // Only checksum-matching bytes are published. Existing runtime validation still runs.
             await writePersistentRuntimeAsset({
@@ -903,8 +958,8 @@ export class WorkerAssetBridge {
         }
         return loaded;
     }
-    async fetchAssetFromNetwork(url, asset, signal, maxAssetBytes = this.sourceAssetByteLimit(asset)) {
-        const requestUrl = this.requireAllowedAssetUrl(asset, url);
+    async fetchAssetFromNetwork(context, url, asset, signal, maxAssetBytes = this.sourceAssetByteLimit(context, asset)) {
+        const requestUrl = this.requireAllowedAssetUrl(context, asset, url);
         if (signal.aborted)
             throw runtimeAssetAbortReason(signal);
         const pendingResponse = Promise.resolve(fetch(requestUrl.href, {
@@ -994,7 +1049,7 @@ export class WorkerAssetBridge {
         const contentEncoding = response.headers.get('content-encoding') || undefined;
         if (!response.body) {
             const bytes = snapshotMaterializedArrayBuffer(await readAbortableArrayBuffer(response, signal), asset, maxAssetBytes);
-            this.progress.update(asset, bytes.byteLength, contentLength ?? bytes.byteLength);
+            context.progress.update(asset, bytes.byteLength, contentLength ?? bytes.byteLength);
             return { bytes, contentEncoding, mimeType, transferOwnership: true };
         }
         const reader = response.body.getReader();
@@ -1062,11 +1117,11 @@ export class WorkerAssetBridge {
                 }
                 bytes.set(chunk, receivedLength);
                 receivedLength = nextLength;
-                this.progress.update(asset, receivedLength, contentLength);
+                context.progress.update(asset, receivedLength, contentLength);
             }
             if (receivedLength !== bytes.byteLength)
                 bytes = bytes.slice(0, receivedLength);
-            this.progress.update(asset, receivedLength, contentLength ?? receivedLength);
+            context.progress.update(asset, receivedLength, contentLength ?? receivedLength);
             loadedAsset = { bytes, contentEncoding, mimeType, transferOwnership: true };
         }
         catch (error) {
@@ -1105,10 +1160,10 @@ export class WorkerAssetBridge {
             throw releaseError;
         return loadedAsset;
     }
-    requireAllowedAssetUrl(asset, value) {
+    requireAllowedAssetUrl(context, asset, value) {
         let url;
         try {
-            url = new URL(value, this.config.baseUrl);
+            url = new URL(value, context.config.baseUrl);
         }
         catch {
             throw new Error(`Runtime asset ${asset} has an invalid URL`);
@@ -1122,7 +1177,7 @@ export class WorkerAssetBridge {
         if (url.hash) {
             throw new Error(`Runtime asset ${asset} URL must not include a fragment`);
         }
-        const allowed = [this.config.baseUrl, ...(this.config.allowedBaseUrls || [])].some((baseUrl) => {
+        const allowed = [context.config.baseUrl, ...(context.config.allowedBaseUrls || [])].some((baseUrl) => {
             let base;
             try {
                 base = new URL(baseUrl, url);

package/dist/playground/assets.d.ts

@@ -653,15 +653,15 @@ export interface ResolvedZigRuntimeAssetConfig {
     stdlibUrl: string;
     integrity: ZigExecutionAssetReceipts;
 }
-export declare const PYTHON_RUNTIME_LOAD_ASSETS: readonly ["pyodide.mjs", "pyodide.asm.js", "pyodide-lock.json", "pyodide.asm.wasm", "python_stdlib.zip"];
+export declare const PYTHON_RUNTIME_LOAD_ASSETS: readonly ["pyodide.mjs", "pyodide.asm.mjs", "pyodide-lock.json", "pyodide.asm.wasm", "python_stdlib.zip"];
 export declare const JAVA_RUNTIME_LOAD_ASSETS: readonly ["compiler.wasm-runtime.js", "compiler.wasm", "compile-classlib-teavm.bin", "runtime-classlib-teavm.bin"];
 export declare const CLANG_RUNTIME_LOAD_ASSETS: readonly ["runtime-manifest.v1.json", "bin/memfs.wasm.gz", "bin/clang.wasm.gz", "bin/lld.wasm.gz", "bin/sysroot.tar.gz"];
-export declare const CLANGD_RUNTIME_LOAD_ASSETS: readonly ["clangd.js", "clangd.wasm.gz"];
+export declare const CLANGD_RUNTIME_LOAD_ASSETS: readonly ["clangd.js", "clangd.wasm.gz", "clangd.headers.json.gz"];
 export declare const RUNTIME_LOAD_ASSETS: {
-    python: readonly ["pyodide.mjs", "pyodide.asm.js", "pyodide-lock.json", "pyodide.asm.wasm", "python_stdlib.zip"];
+    python: readonly ["pyodide.mjs", "pyodide.asm.mjs", "pyodide-lock.json", "pyodide.asm.wasm", "python_stdlib.zip"];
     java: readonly ["compiler.wasm-runtime.js", "compiler.wasm", "compile-classlib-teavm.bin", "runtime-classlib-teavm.bin"];
     clang: readonly ["runtime-manifest.v1.json", "bin/memfs.wasm.gz", "bin/clang.wasm.gz", "bin/lld.wasm.gz", "bin/sysroot.tar.gz"];
-    clangd: readonly ["clangd.js", "clangd.wasm.gz"];
+    clangd: readonly ["clangd.js", "clangd.wasm.gz", "clangd.headers.json.gz"];
 };
 export declare function resolveRuntimeAssetConfig(runtime: RuntimeAssetRuntime, options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string, callCache?: RuntimeAssetCacheOptions): ResolvedRuntimeAssetConfig;
 export declare function resolveRustCompilerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;

package/dist/playground/assets.js

@@ -1,4 +1,4 @@
-import { env as dynamicPublicEnv } from '$env/dynamic/public';
+import * as publicEnv from '$app/env/public';
 import { resolveRuntimeAssetCacheOptions, resolveRuntimeAssetLockEntry } from '@wasm-idle/core';
 import { BUNDLED_CLANG_ASSET_INTEGRITY } from './clangAssetIntegrity';
 import { snapshotDOuterAssetConfig } from './dOuterAssets';
@@ -29,10 +29,9 @@ import { WASM_FORTRAN_EXECUTION_ASSET_RECEIPTS } from './wasmFortranExecutionAss
 import { WASM_D_OUTER_ASSET_RECEIPTS } from './wasmDIntegrity';
 import { WASM_ZIG_ASSET_RECEIPTS } from './wasmZigVersion';
 import { snapshotZigExecutionAssetReceipts } from './zigAssets';
-const publicEnv = (dynamicPublicEnv || {});
 export const PYTHON_RUNTIME_LOAD_ASSETS = [
     'pyodide.mjs',
-    'pyodide.asm.js',
+    'pyodide.asm.mjs',
     'pyodide-lock.json',
     'pyodide.asm.wasm',
     'python_stdlib.zip'
@@ -45,7 +44,11 @@ export const CLANG_RUNTIME_LOAD_ASSETS = [
     'bin/lld.wasm.gz',
     'bin/sysroot.tar.gz'
 ];
-export const CLANGD_RUNTIME_LOAD_ASSETS = ['clangd.js', 'clangd.wasm.gz'];
+export const CLANGD_RUNTIME_LOAD_ASSETS = [
+    'clangd.js',
+    'clangd.wasm.gz',
+    'clangd.headers.json.gz'
+];
 export const RUNTIME_LOAD_ASSETS = {
     python: PYTHON_RUNTIME_LOAD_ASSETS,
     java: JAVA_RUNTIME_LOAD_ASSETS,

package/dist/playground/cachedClang.js

@@ -280,6 +280,7 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                         maxAssetBytes: limit,
                         languageSysroots,
                         log,
+                        persistentCache: executionAssetConfig.persistentCache,
                         ...(language === 'CPP' && precompiledHeader
                             ? { precompiledHeader }
                             : {}),

package/dist/playground/clang.js

@@ -142,6 +142,7 @@ class Clang {
                 };
                 this.worker.postMessage({
                     load: true,
+                    persistentCache: assetConfig.persistentCache,
                     verifiedStreaming: bundledAssets,
                     languageSysrootProfiles,
                     log,
@@ -305,7 +306,8 @@ class Clang {
                         activePath: options.activePath,
                         cppVersion: options.cppVersion,
                         cVersion: options.cVersion,
-                        debugMode
+                        debugMode,
+                        persistentCache: persistentCache ?? this.persistentCache
                     });
                 if (results) {
                     this.elapse = Date.now() - this.begin;
@@ -340,6 +342,7 @@ class Clang {
             if (precompiledHeader)
                 this.precompiledHeaderSent = { worker: this.worker, header: precompiledHeader };
             this.worker?.postMessage({
+                persistentCache: persistentCache ?? this.persistentCache,
                 ...(precompiledHeader ? { precompiledHeader } : {}),
                 code,
                 prepare,
@@ -494,6 +497,7 @@ class Clang {
         };
         worker.postMessage({
             load: true,
+            persistentCache: runtime.assetConfig.persistentCache,
             verifiedStreaming: runtime.verifiedStreaming,
             languageSysrootProfiles: runtime.languageSysrootProfiles,
             log: false,

package/dist/playground/clangWorkerProtocol.d.ts

@@ -9,6 +9,7 @@ export type ClangCompileWorkerRequest = {
     assets: WorkerRuntimeAssetConfig;
     /** The last precompiled <bits/stdc++.h>; the worker ignores it when its key differs. */
     precompiledHeader?: BrowserClangPrecompiledHeader;
+    persistentCache?: import('@wasm-idle/core').RuntimeAssetCacheOptions;
 };
 /**
  * `precompiledHeader: 'building'` means the worker stays alive after the result and later posts

package/dist/playground/runtimeAssetCache.d.ts

@@ -3,6 +3,8 @@ export declare class RuntimeAssetCache {
     private readonly maxBytes;
     private readonly maxEntries;
     private entries;
+    private inFlight;
+    private inFlightKeyBytes;
     private identities;
     private nextIdentity;
     private bytes;
@@ -15,11 +17,15 @@ export declare class RuntimeAssetCache {
     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;
+    /** Share work, but give every consumer its own cancellation and progress subscription. */
+    share<T, Progress = never>(key: string, signal: AbortSignal, start: (signal: AbortSignal, report: (progress: Progress, progressKey?: string) => void) => Promise<T>, onProgress?: (progress: Progress) => void): Promise<T>;
+    private removeOperation;
     stats(): {
         hits: number;
         misses: number;
         entries: number;
         bytes: number;
+        inFlight: number;
         disposed: boolean;
     };
     dispose(): void;