wasm-idle 1.0.8 → 1.0.10

package/dist/playground/assets.d.ts

@@ -103,6 +103,9 @@ export interface WatRuntimeAssetConfig {
 export interface LuaRuntimeAssetConfig {
     moduleUrl?: string;
 }
+export interface FennelRuntimeAssetConfig {
+    compilerUrl?: string;
+}
 export interface HaskellRuntimeAssetConfig {
     moduleUrl?: string;
     rootfsUrl?: string;
@@ -122,6 +125,9 @@ export interface FortranRuntimeAssetConfig {
 export interface CobolRuntimeAssetConfig {
     baseUrl?: string;
 }
+export interface VRuntimeAssetConfig {
+    baseUrl?: string;
+}
 export interface ObjectiveCRuntimeAssetConfig {
     baseUrl?: string;
     libobjcUrl?: string;
@@ -493,6 +499,35 @@ export interface ClojureScriptRuntimePreflightProfile {
         uncompressedSha256?: string;
     }>;
 }
+export interface ReScriptRuntimeAssetConfig {
+    baseUrl?: string;
+    workerUrl?: string;
+    manifestUrl?: string;
+    manifestFingerprint?: string;
+    profileId?: string;
+    sourceRevision?: string;
+    manifestReceipt?: RuntimeAssetIntegrityEntry;
+    compilerReceipt?: RuntimeAssetIntegrityEntry;
+    workerReceipt?: Readonly<{
+        bytes: number;
+        sha256: string;
+    }>;
+}
+export interface ReScriptRuntimePreflightProfile {
+    readonly profileId: string;
+    readonly sourceRevision: string;
+    readonly manifestFingerprint: string;
+    readonly manifestReceipt?: Readonly<{
+        bytes?: number;
+        sha256: string;
+    }>;
+    readonly compilerReceipt?: Readonly<{
+        bytes?: number;
+        sha256: string;
+        uncompressedBytes?: number;
+        uncompressedSha256?: string;
+    }>;
+}
 export interface SwiftRuntimeAssetConfig {
     baseUrl?: string;
     workerUrl?: string;
@@ -508,6 +543,9 @@ export interface AssemblyScriptRuntimeAssetConfig {
 export interface DuckDbRuntimeAssetConfig {
     moduleUrl?: string;
 }
+export interface PostgresqlRuntimeAssetConfig {
+    moduleUrl?: string;
+}
 export interface PhpRuntimeAssetConfig {
     moduleUrl?: string;
 }
@@ -528,9 +566,11 @@ export interface PlaygroundRuntimeAssets extends RuntimeAssetKeySource {
     typescript?: TypeScriptRuntimeAssetConfig;
     wat?: WatRuntimeAssetConfig;
     lua?: LuaRuntimeAssetConfig;
+    fennel?: FennelRuntimeAssetConfig;
     haskell?: HaskellRuntimeAssetConfig;
     fortran?: FortranRuntimeAssetConfig;
     cobol?: CobolRuntimeAssetConfig;
+    v?: VRuntimeAssetConfig;
     objectivec?: ObjectiveCRuntimeAssetConfig;
     zig?: ZigRuntimeAssetConfig;
     lisp?: LispRuntimeAssetConfig;
@@ -551,12 +591,20 @@ export interface PlaygroundRuntimeAssets extends RuntimeAssetKeySource {
     c3?: {
         baseUrl?: string;
     };
+    grain?: {
+        baseUrl?: string;
+    };
+    hy?: {
+        baseUrl?: string;
+    };
     nim?: NimRuntimeAssetConfig;
     bash?: BashRuntimeAssetConfig;
     clojurescript?: ClojureScriptRuntimeAssetConfig;
+    rescript?: ReScriptRuntimeAssetConfig;
     swift?: SwiftRuntimeAssetConfig;
     assemblyscript?: AssemblyScriptRuntimeAssetConfig;
     duckdb?: DuckDbRuntimeAssetConfig;
+    postgresql?: PostgresqlRuntimeAssetConfig;
     sqlite?: SqliteRuntimeAssetConfig;
     php?: PhpRuntimeAssetConfig;
 }
@@ -605,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;
@@ -638,6 +686,7 @@ export declare function resolveErlangBundleUrl(options: string | PlaygroundRunti
 export declare function resolveTypeScriptModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveWatModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveLuaModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+export declare function resolveFennelCompilerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveZigCompilerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveHaskellModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveHaskellRootfsUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
@@ -649,6 +698,7 @@ export declare function resolveFortranF2cHeaderUrl(options: string | PlaygroundR
 export declare function resolveFortranAnalyzerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveFortranRuntimeAssetConfig(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): ResolvedFortranRuntimeAssetConfig;
 export declare function resolveCobolBaseUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+export declare function resolveVBaseUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveObjectiveCBaseUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveObjectiveCLibobjcUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveObjectiveCHeadersUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
@@ -774,6 +824,21 @@ export declare function resolveClojureScriptRuntimeAssetConfig(options: string |
         sha256: string;
     }>;
 };
+export declare function resolveReScriptBaseUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+export declare function resolveReScriptWorkerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+export declare function resolveReScriptManifestUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+export declare function resolveReScriptRuntimeAssetConfig(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): {
+    baseUrl: string;
+    workerUrl: string;
+    manifestUrl: string;
+    manifestFingerprint: string;
+    preflightKey: string;
+    preflightProfile: ReScriptRuntimePreflightProfile;
+    workerReceipt: Readonly<{
+        bytes: number;
+        sha256: string;
+    }>;
+};
 export declare function resolveForthBaseUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveForthWorkerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveForthManifestUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
@@ -887,7 +952,12 @@ export declare function resolveSqliteWasmUrl(options: string | PlaygroundRuntime
 export declare function resolveAssemblyScriptRuntimeModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveDuckDbRuntimeModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolvePhpRuntimeModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+export declare function resolvePostgresqlRuntimeModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveRubyRuntimeModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 export declare function resolveSqliteRuntimeModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
 /** C3 uses one code-pinned compiler/worker receipt, served from this base URL. */
 export declare function resolveC3BaseUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+/** Grain uses one code-pinned compiler/stdlib/worker receipt, served from this base URL. */
+export declare function resolveGrainBaseUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+/** Hy wheels are code-pinned receipts served from this base URL and installed into Pyodide. */
+export declare function resolveHyBaseUrl(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';
@@ -9,8 +9,10 @@ import { WASM_FORTH_ASSET_VERSION, WASM_FORTH_RUNTIME_PROFILE, WASM_FORTH_RUNNER
 import { WASM_BQN_ASSET_VERSION, WASM_BQN_RUNTIME_PROFILE, WASM_BQN_RUNNER_RECEIPT } from './wasmBqnVersion';
 import { WASM_BASH_RUNTIME_BUNDLE } from './wasmBashVersion';
 import { WASM_CLOJURESCRIPT_ASSET_VERSION, WASM_CLOJURESCRIPT_RUNNER_RECEIPT, WASM_CLOJURESCRIPT_RUNTIME_PROFILE } from './wasmClojureScriptVersion';
+import { WASM_RESCRIPT_ASSET_VERSION, WASM_RESCRIPT_RUNNER_RECEIPT, WASM_RESCRIPT_RUNTIME_PROFILE } from './wasmReScriptVersion';
 import { WASM_J_ASSET_VERSION, WASM_J_RUNNER_RECEIPT, WASM_J_RUNTIME_PROFILE } from './wasmJVersion';
 import { WASM_JANET_RUNTIME_BUNDLE } from './wasmJanetVersion';
+import { WASM_FENNEL_COMPILER_RECEIPT } from './wasmFennelVersion';
 import { WASM_JULIA_RUNTIME_BUNDLE } from './wasmJuliaVersion';
 import { WASM_LISP_ASSET_VERSION } from './wasmLispVersion';
 import { WASM_NIM_RUNTIME_BUNDLE } from './wasmNimVersion';
@@ -27,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'
@@ -43,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,
@@ -482,6 +487,18 @@ export function resolveLuaModuleUrl(options, currentUrl = '') {
     }
     return '';
 }
+export function resolveFennelCompilerUrl(options, currentUrl = '') {
+    const configuredCompilerUrl = (typeof options === 'object' && options?.fennel?.compilerUrl) ||
+        (publicEnv.PUBLIC_WASM_FENNEL_COMPILER_URL || '').trim();
+    if (configuredCompilerUrl) {
+        return resolveConfiguredUrl(configuredCompilerUrl, currentUrl);
+    }
+    const rootUrl = typeof options === 'string' ? options : options?.rootUrl;
+    if (rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(rootUrl) || ''}/${WASM_FENNEL_COMPILER_RECEIPT.path}`, currentUrl);
+    }
+    return '';
+}
 export function resolveZigCompilerUrl(options, currentUrl = '') {
     const configuredCompilerUrl = (typeof options === 'object' && options?.zig?.compilerUrl) ||
         (publicEnv.PUBLIC_WASM_ZIG_COMPILER_URL || '').trim();
@@ -600,6 +617,20 @@ export function resolveCobolBaseUrl(options, currentUrl = '') {
     }
     return normalizeBaseUrl('/wasm-cobol/', currentUrl);
 }
+export function resolveVBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.v?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_V_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-v/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-v/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-v/', currentUrl);
+}
 export function resolveObjectiveCBaseUrl(options, currentUrl = '') {
     const configuredBaseUrl = (typeof options === 'object' && options?.objectivec?.baseUrl) ||
         (publicEnv.PUBLIC_WASM_OBJECTIVEC_BASE_URL || '').trim();
@@ -1589,6 +1620,77 @@ export function resolveClojureScriptRuntimeAssetConfig(options, currentUrl = '')
         workerReceipt: configured?.workerReceipt || WASM_CLOJURESCRIPT_RUNNER_RECEIPT
     };
 }
+export function resolveReScriptBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.rescript?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_RESCRIPT_BASE_URL || '').trim();
+    if (configuredBaseUrl)
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-rescript/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-rescript/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-rescript/', currentUrl);
+}
+export function resolveReScriptWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.rescript?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_RESCRIPT_WORKER_URL || '').trim();
+    if (configuredWorkerUrl)
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-rescript/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-rescript/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-rescript/runner-worker.js', currentUrl);
+}
+export function resolveReScriptManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = typeof options === 'object' ? options?.rescript?.manifestUrl : undefined;
+    if (configuredManifestUrl) {
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    }
+    return `${resolveReScriptBaseUrl(options, currentUrl)}runtime-manifest.v1.json`;
+}
+export function resolveReScriptRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.rescript : undefined;
+    const manifestFingerprint = configured?.manifestFingerprint?.trim() || WASM_RESCRIPT_ASSET_VERSION;
+    const usesBundledProfile = manifestFingerprint === WASM_RESCRIPT_ASSET_VERSION;
+    const receipt = (configuredReceipt, bundledReceipt) => {
+        const selected = configuredReceipt || (usesBundledProfile ? bundledReceipt : undefined);
+        return selected
+            ? Object.freeze({
+                bytes: selected.bytes,
+                sha256: selected.sha256,
+                ...(selected.uncompressedBytes === undefined
+                    ? {}
+                    : { uncompressedBytes: selected.uncompressedBytes }),
+                ...(selected.uncompressedSha256 === undefined
+                    ? {}
+                    : { uncompressedSha256: selected.uncompressedSha256 })
+            })
+            : undefined;
+    };
+    const preflightProfile = Object.freeze({
+        profileId: configured?.profileId?.trim() ||
+            (usesBundledProfile ? WASM_RESCRIPT_RUNTIME_PROFILE.profileId : ''),
+        sourceRevision: configured?.sourceRevision?.trim() ||
+            (usesBundledProfile ? WASM_RESCRIPT_RUNTIME_PROFILE.sourceRevision : ''),
+        manifestFingerprint,
+        manifestReceipt: receipt(configured?.manifestReceipt, WASM_RESCRIPT_RUNTIME_PROFILE.manifestReceipt),
+        compilerReceipt: receipt(configured?.compilerReceipt, WASM_RESCRIPT_RUNTIME_PROFILE.compilerReceipt)
+    });
+    return {
+        baseUrl: resolveReScriptBaseUrl(options, currentUrl),
+        workerUrl: resolveReScriptWorkerUrl(options, currentUrl),
+        manifestUrl: resolveReScriptManifestUrl(options, currentUrl),
+        manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt: configured?.workerReceipt || WASM_RESCRIPT_RUNNER_RECEIPT
+    };
+}
 export function resolveForthBaseUrl(options, currentUrl = '') {
     const configuredBaseUrl = (typeof options === 'object' && options?.forth?.baseUrl) ||
         (publicEnv.PUBLIC_WASM_FORTH_BASE_URL || '').trim();
@@ -2268,6 +2370,9 @@ export function resolveDuckDbRuntimeModuleUrl(options, currentUrl = '') {
 export function resolvePhpRuntimeModuleUrl(options, currentUrl = '') {
     return resolveStaticRuntimeModuleUrl(options, typeof options === 'object' ? options?.php?.moduleUrl : undefined, publicEnv.PUBLIC_WASM_PHP_MODULE_URL || '', 'wasm-php', currentUrl);
 }
+export function resolvePostgresqlRuntimeModuleUrl(options, currentUrl = '') {
+    return resolveStaticRuntimeModuleUrl(options, typeof options === 'object' ? options?.postgresql?.moduleUrl : undefined, publicEnv.PUBLIC_WASM_POSTGRESQL_MODULE_URL || '', 'wasm-postgresql', currentUrl);
+}
 export function resolveRubyRuntimeModuleUrl(options, currentUrl = '') {
     return resolveRubyRuntimeAssetConfig(options, currentUrl).moduleUrl;
 }
@@ -2283,3 +2388,21 @@ export function resolveC3BaseUrl(options, currentUrl = '') {
     const root = typeof options === 'string' ? options : options?.rootUrl;
     return normalizeBaseUrl(`${normalizeRootUrl(root || '') || ''}/wasm-c3/`, currentUrl);
 }
+/** Grain uses one code-pinned compiler/stdlib/worker receipt, served from this base URL. */
+export function resolveGrainBaseUrl(options, currentUrl = '') {
+    const configured = (typeof options === 'object' && options?.grain?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_GRAIN_BASE_URL || '').trim();
+    if (configured)
+        return normalizeBaseUrl(configured, currentUrl);
+    const root = typeof options === 'string' ? options : options?.rootUrl;
+    return normalizeBaseUrl(`${normalizeRootUrl(root || '') || ''}/wasm-grain/`, currentUrl);
+}
+/** Hy wheels are code-pinned receipts served from this base URL and installed into Pyodide. */
+export function resolveHyBaseUrl(options, currentUrl = '') {
+    const configured = (typeof options === 'object' && options?.hy?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_HY_BASE_URL || '').trim();
+    if (configured)
+        return normalizeBaseUrl(configured, currentUrl);
+    const root = typeof options === 'string' ? options : options?.rootUrl;
+    return normalizeBaseUrl(`${normalizeRootUrl(root || '') || ''}/wasm-hy/`, currentUrl);
+}

package/dist/playground/cachedClang.js

@@ -32,6 +32,34 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
     let pendingEof = false;
     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.
+    let precompiledHeader;
+    let headerWorker;
+    function adoptHeaderWorker(worker, bridge) {
+        headerWorker?.dispose();
+        const dispose = () => {
+            if (headerWorker?.worker === worker)
+                headerWorker = undefined;
+            bridge?.dispose();
+            worker.onmessage = null;
+            worker.onerror = null;
+            worker.onmessageerror = null;
+            worker.terminate();
+        };
+        headerWorker = { worker, dispose };
+        worker.onerror = dispose;
+        worker.onmessageerror = dispose;
+        worker.onmessage = (event) => {
+            if (bridge?.handleMessage(event))
+                return;
+            if (event.data?.type !== 'precompiled-header')
+                return;
+            if (event.data.header)
+                precompiledHeader = event.data.header;
+            dispose();
+        };
+    }
     function resetInput() {
         pendingInput.length = 0;
         pendingEof = false;
@@ -90,17 +118,21 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
             const abort = () => finish(signal?.reason instanceof Error
                 ? signal.reason
                 : new Error('Process terminated'));
-            const finish = (error, value) => {
+            const finish = (error, value, keepForHeader = false) => {
                 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 (keepForHeader)
+                    adoptHeaderWorker(worker, bridge);
+                else {
+                    bridge?.dispose();
+                    worker.terminate();
+                }
                 if (error)
                     reject(error);
                 else
@@ -142,10 +174,11 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                             legacy.output?.(data.stdout);
                         if (data.stderr)
                             legacy.output?.(data.stderr);
+                        const keepForHeader = data.precompiledHeader === 'building';
                         if (data.type === 'error')
-                            finish(new Error(data.error));
+                            finish(new Error(data.error), undefined, keepForHeader);
                         else
-                            finish(undefined, data.artifact);
+                            finish(undefined, data.artifact, keepForHeader);
                     }
                     else if (data.type === 'done') {
                         if (data.exitCode !== 0 && data.exitCode !== null)
@@ -247,6 +280,10 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                         maxAssetBytes: limit,
                         languageSysroots,
                         log,
+                        persistentCache: executionAssetConfig.persistentCache,
+                        ...(language === 'CPP' && precompiledHeader
+                            ? { precompiledHeader }
+                            : {}),
                         assets: {
                             baseUrl: runtimeBaseUrl,
                             maxAssetBytes: limit,
@@ -315,6 +352,8 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                 return disposal;
             disposed = true;
             stop();
+            headerWorker?.dispose();
+            precompiledHeader = undefined;
             disposal = Promise.resolve(legacy.dispose ? legacy.dispose() : legacy.terminate());
             return disposal;
         }

package/dist/playground/clang.d.ts

@@ -36,6 +36,10 @@ declare class Clang implements Sandbox {
     private debugMode;
     private readonly lldbBreakpoints;
     private debugEvaluationQueue;
+    private precompiledHeader?;
+    private precompiledHeaderSent?;
+    private headerBuilder?;
+    private loadedRuntime?;
     private readonly workerSession;
     private disposeWorkerAssetBridge;
     constructor(language: 'C' | 'CPP');
@@ -60,6 +64,7 @@ declare class Clang implements Sandbox {
     debugDataBreakpointInfo(arguments_: DebugDataBreakpointInfoArguments): Promise<import("@wasm-idle/core").DebugDataBreakpointInfo | null>;
     debugSetDataBreakpoints(breakpoints: DebugDataBreakpoint[]): Promise<import("@wasm-idle/core").DebugResolvedDataBreakpoint[]>;
     kill(): Promise<void>;
+    private buildPrecompiledHeader;
     terminate(): Promise<void>;
     clear(): Promise<void>;
     setRuntimeAssetCache(cache: RuntimeAssetCache): void;

package/dist/playground/clang.js

@@ -48,6 +48,12 @@ class Clang {
     debugMode = 'none';
     lldbBreakpoints = new Map();
     debugEvaluationQueue = Promise.resolve();
+    // A helper worker builds the precompiled <bits/stdc++.h> so the warm worker stays free for
+    // runs. The header is sent once to each warm worker, which keeps it for later compiles.
+    precompiledHeader;
+    precompiledHeaderSent;
+    headerBuilder;
+    loadedRuntime;
     workerSession = new WorkerSession({
         label: 'Clang',
         onDispose: (worker) => {
@@ -102,6 +108,12 @@ class Clang {
             const languageSysrootProfiles = bundledAssets &&
                 typeof runtimeAssets !== 'string' &&
                 runtimeAssets.clang?.bundledLanguageSysroots === true;
+            this.loadedRuntime = {
+                assetConfig,
+                maxAssetBytes: limits.maxAssetBytes,
+                languageSysrootProfiles,
+                verifiedStreaming: bundledAssets
+            };
             const needsWorkerReset = !this.worker ||
                 !this.assetBridge ||
                 !this.assetBridge.matches(assetConfig, limits.maxAssetBytes, languageSysrootProfiles);
@@ -130,6 +142,7 @@ class Clang {
                 };
                 this.worker.postMessage({
                     load: true,
+                    persistentCache: assetConfig.persistentCache,
                     verifiedStreaming: bundledAssets,
                     languageSysrootProfiles,
                     log,
@@ -285,6 +298,17 @@ class Clang {
                     });
                     return;
                 }
+                if (event.data.precompiledHeaderKey)
+                    void this.buildPrecompiledHeader(event.data.precompiledHeaderKey, {
+                        code,
+                        language: this.language,
+                        compileArgs,
+                        activePath: options.activePath,
+                        cppVersion: options.cppVersion,
+                        cVersion: options.cVersion,
+                        debugMode,
+                        persistentCache: persistentCache ?? this.persistentCache
+                    });
                 if (results) {
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;
@@ -310,7 +334,16 @@ class Clang {
             interrupt[0] = 0;
             this.worker.onmessage = handler;
             this.begin = Date.now();
+            const precompiledHeader = this.language === 'CPP' &&
+                (this.precompiledHeaderSent?.worker !== this.worker ||
+                    this.precompiledHeaderSent.header !== this.precompiledHeader)
+                ? this.precompiledHeader
+                : undefined;
+            if (precompiledHeader)
+                this.precompiledHeaderSent = { worker: this.worker, header: precompiledHeader };
             this.worker?.postMessage({
+                persistentCache: persistentCache ?? this.persistentCache,
+                ...(precompiledHeader ? { precompiledHeader } : {}),
                 code,
                 prepare,
                 buffer: this.buffer,
@@ -412,6 +445,71 @@ class Clang {
     kill() {
         return this.terminate();
     }
+    async buildPrecompiledHeader(key, request) {
+        const runtime = this.loadedRuntime;
+        if (!runtime ||
+            this.disposed ||
+            this.precompiledHeader?.key === key ||
+            this.headerBuilder?.key === key)
+            return;
+        this.headerBuilder?.dispose();
+        let cancelled = false;
+        const pending = {
+            key,
+            dispose: () => {
+                cancelled = true;
+                if (this.headerBuilder === pending)
+                    this.headerBuilder = undefined;
+            }
+        };
+        this.headerBuilder = pending;
+        const { default: ClangWorker } = await import('./worker/clang?worker');
+        if (cancelled)
+            return;
+        const worker = new ClangWorker();
+        const bridge = new WorkerAssetBridge(worker, 'clang', runtime.assetConfig, undefined, runtime.maxAssetBytes, runtime.languageSysrootProfiles, this.runtimeAssetCache);
+        const builder = {
+            key,
+            dispose: () => {
+                if (this.headerBuilder === builder)
+                    this.headerBuilder = undefined;
+                bridge.dispose();
+                worker.onmessage = null;
+                worker.onerror = null;
+                worker.terminate();
+            }
+        };
+        this.headerBuilder = builder;
+        worker.onerror = builder.dispose;
+        worker.onmessage = (event) => {
+            if (bridge.handleMessage(event))
+                return;
+            const { data } = event;
+            if (data?.load)
+                worker.postMessage({ precompileHeader: true, ...request });
+            else if (data?.error)
+                builder.dispose();
+            else if (data && 'precompiledHeader' in data) {
+                if (data.precompiledHeader)
+                    this.precompiledHeader = data.precompiledHeader;
+                builder.dispose();
+            }
+        };
+        worker.postMessage({
+            load: true,
+            persistentCache: runtime.assetConfig.persistentCache,
+            verifiedStreaming: runtime.verifiedStreaming,
+            languageSysrootProfiles: runtime.languageSysrootProfiles,
+            log: false,
+            assets: {
+                baseUrl: runtime.assetConfig.baseUrl,
+                maxAssetBytes: runtime.maxAssetBytes,
+                useAssetBridge: runtime.assetConfig.useAssetBridge,
+                useModuleBridge: true
+            },
+            maxAssetBytes: runtime.maxAssetBytes
+        });
+    }
     async terminate() {
         const lldbSession = this.lldbSession;
         this.lldbSession = undefined;
@@ -460,6 +558,8 @@ class Clang {
         this.disposal = Promise.resolve()
             .then(() => this.clear())
             .finally(() => {
+            this.headerBuilder?.dispose();
+            this.precompiledHeader = undefined;
             if (this.ownsRuntimeAssetCache)
                 this.runtimeAssetCache.dispose();
             this.output = null;

package/dist/playground/clangWorkerProtocol.d.ts

@@ -1,4 +1,4 @@
-import type { BrowserClangArtifact, BrowserClangCompileProgress, BrowserClangCompileRequest, BrowserClangWorkspaceFile } from '@wasm-idle/llvm-core/clang';
+import type { BrowserClangArtifact, BrowserClangCompileProgress, BrowserClangCompileRequest, BrowserClangPrecompiledHeader, BrowserClangWorkspaceFile } from '@wasm-idle/llvm-core/clang';
 import type { WorkerRuntimeAssetConfig } from './worker/assets';
 export type ClangCompileWorkerRequest = {
     request: Omit<BrowserClangCompileRequest, 'onProgress'>;
@@ -7,7 +7,14 @@ export type ClangCompileWorkerRequest = {
     languageSysroots?: boolean;
     log?: boolean;
     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
+ * one `precompiled-header` message, with no header when Clang could not build it.
+ */
 export type ClangCompileWorkerResponse = {
     type: 'progress';
     progress: BrowserClangCompileProgress;
@@ -16,11 +23,16 @@ export type ClangCompileWorkerResponse = {
     artifact: BrowserClangArtifact;
     stdout: string;
     stderr: string;
+    precompiledHeader?: 'building';
 } | {
     type: 'error';
     error: string;
     stdout: string;
     stderr: string;
+    precompiledHeader?: 'building';
+} | {
+    type: 'precompiled-header';
+    header?: BrowserClangPrecompiledHeader;
 };
 export type ClangExecuteWorkerRequest = {
     artifact: BrowserClangArtifact;

package/dist/playground/fennel.d.ts

@@ -0,0 +1,9 @@
+import Lua from './lua';
+/**
+ * Fennel runs the pinned official `fennel.lua` compiler on the shared wasm-lua (wasmoon)
+ * worker. The worker fetches and verifies the compiler against its receipt before use.
+ */
+declare class Fennel extends Lua {
+    constructor();
+}
+export default Fennel;