wasm-idle 1.0.8 → 1.0.9

package/dist/playground/assets.js

@@ -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';
@@ -482,6 +484,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 +614,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 +1617,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 +2367,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 +2385,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,9 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                         maxAssetBytes: limit,
                         languageSysroots,
                         log,
+                        ...(language === 'CPP' && precompiledHeader
+                            ? { precompiledHeader }
+                            : {}),
                         assets: {
                             baseUrl: runtimeBaseUrl,
                             maxAssetBytes: limit,
@@ -315,6 +351,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);
@@ -285,6 +297,16 @@ 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
+                    });
                 if (results) {
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;
@@ -310,7 +332,15 @@ 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({
+                ...(precompiledHeader ? { precompiledHeader } : {}),
                 code,
                 prepare,
                 buffer: this.buffer,
@@ -412,6 +442,70 @@ 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,
+            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 +554,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,13 @@ 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;
 };
+/**
+ * `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 +22,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;

package/dist/playground/fennel.js

@@ -0,0 +1,30 @@
+import { resolveFennelCompilerUrl } from './assets';
+import Lua from './lua';
+import { WASM_FENNEL_COMPILER_RECEIPT } from './wasmFennelVersion';
+import { RuntimeConfigurationError } from '@wasm-idle/core';
+/**
+ * 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.
+ */
+class Fennel extends Lua {
+    constructor() {
+        super({
+            label: 'Fennel',
+            runtimeId: 'FENNEL',
+            defaultActivePath: 'main.fnl',
+            resolveWorkerLoadExtras(runtimeAssets, currentUrl) {
+                const compilerUrl = resolveFennelCompilerUrl(runtimeAssets, currentUrl);
+                if (!compilerUrl) {
+                    throw new RuntimeConfigurationError('Fennel compiler is not configured. Set PUBLIC_WASM_FENNEL_COMPILER_URL or runtimeAssets.fennel.compilerUrl.', { runtimeId: 'FENNEL' });
+                }
+                return {
+                    fennelCompiler: {
+                        url: compilerUrl,
+                        receipt: { ...WASM_FENNEL_COMPILER_RECEIPT }
+                    }
+                };
+            }
+        });
+    }
+}
+export default Fennel;

package/dist/playground/fennelBootstrap.d.ts

@@ -0,0 +1,31 @@
+import type { WasmFennelCompilerReceipt } from './wasmFennelVersion';
+/**
+ * Fennel runs the official, receipt-verified `fennel.lua` compiler on the wasm-lua VM.
+ * These helpers build the Lua entry chunks that load that compiler and hand it the user's
+ * Fennel source; they never parse or translate Fennel themselves.
+ */
+export interface FennelCompilerAsset {
+    url: string;
+    receipt: WasmFennelCompilerReceipt;
+}
+export interface FennelDiagnostic {
+    fileName: string | null;
+    lineNumber: number;
+    columnNumber?: number;
+    severity: 'error';
+    message: string;
+}
+export declare function luaQuotedString(value: string): string;
+/** Lua chunk that only compiles the Fennel source, raising the compiler error on failure. */
+export declare function buildFennelCompileChunk(fennelSource: string, code: string, fileName: string): string;
+/** Lua chunk that evaluates the Fennel program through `fennel.eval`. */
+export declare function buildFennelRunChunk(fennelSource: string, code: string, fileName: string): string;
+/** Drops the host Lua traceback that wasmoon appends to errors raised by the entry chunk. */
+export declare function stripHostLuaTraceback(message: string): string;
+export declare function parseFennelDiagnostic(message: string, fileName: string): FennelDiagnostic;
+/**
+ * Verifies the fetched fennel.lua asset against its pinned receipt. Accepts either the
+ * gzip delivery bytes or bytes a server already decoded via Content-Encoding.
+ */
+export declare function verifyFennelCompilerBytes(bytes: Uint8Array, receipt: WasmFennelCompilerReceipt): Promise<string>;
+export declare function loadFennelCompilerSource(asset: FennelCompilerAsset): Promise<string>;

package/dist/playground/fennelBootstrap.js

@@ -0,0 +1,118 @@
+const GZIP_MAGIC_0 = 0x1f;
+const GZIP_MAGIC_1 = 0x8b;
+const SHA256_PATTERN = /^[a-f0-9]{64}$/u;
+export function luaQuotedString(value) {
+    let quoted = '"';
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (character === '\\')
+            quoted += '\\\\';
+        else if (character === '"')
+            quoted += '\\"';
+        else if (codePoint < 0x20 || codePoint === 0x7f)
+            quoted += `\\${String(codePoint).padStart(3, '0')}`;
+        else
+            quoted += character;
+    }
+    return `${quoted}"`;
+}
+function fennelLoaderChunk(fennelSource) {
+    // fennel.lua is a single chunk ending in `return mod`; wrapping it in a vararg function
+    // keeps it byte-for-byte unmodified while letting the entry chunk reuse the module.
+    return `local fennel = (function(...)\n${fennelSource}\nend)("fennel")\npackage.loaded.fennel = fennel\n`;
+}
+function fennelOptions(fileName) {
+    return `{ filename = ${luaQuotedString(fileName)}, ["error-pinpoint"] = false }`;
+}
+/** Lua chunk that only compiles the Fennel source, raising the compiler error on failure. */
+export function buildFennelCompileChunk(fennelSource, code, fileName) {
+    return (fennelLoaderChunk(fennelSource) +
+        `local options = ${fennelOptions(fileName)}\n` +
+        // Match fennel.eval, which rejects unknown globals against the current environment.
+        `options.allowedGlobals = require("fennel.specials")["current-global-names"]()\n` +
+        `local ok, err = pcall(fennel.compileString, ${luaQuotedString(code)}, options)\n` +
+        `if not ok then error(tostring(err), 0) end\n`);
+}
+/** Lua chunk that evaluates the Fennel program through `fennel.eval`. */
+export function buildFennelRunChunk(fennelSource, code, fileName) {
+    return (fennelLoaderChunk(fennelSource) +
+        `local ok, err = xpcall(fennel.eval, function(e) return tostring(e) end, ${luaQuotedString(code)}, ${fennelOptions(fileName)})\n` +
+        `if not ok then error(err, 0) end\n`);
+}
+/** Drops the host Lua traceback that wasmoon appends to errors raised by the entry chunk. */
+export function stripHostLuaTraceback(message) {
+    const index = message.indexOf('\nstack traceback:');
+    return (index === -1 ? message : message.slice(0, index)).trimEnd();
+}
+export function parseFennelDiagnostic(message, fileName) {
+    const clean = stripHostLuaTraceback(message.replace(/^Error:\s*/u, ''));
+    const firstLine = clean.split('\n', 1)[0] ?? '';
+    const match = /^([^:\n]+):(\d+):(?:(\d+):)?\s*([\s\S]*)$/u.exec(firstLine);
+    return {
+        fileName: match?.[1] || fileName,
+        lineNumber: Math.max(1, Number(match?.[2] || 1)),
+        columnNumber: match?.[3] ? Math.max(1, Number(match[3]) + 1) : undefined,
+        severity: 'error',
+        message: (match?.[4] || clean || message).trim()
+    };
+}
+async function sha256Hex(bytes) {
+    const digest = await crypto.subtle.digest('SHA-256', bytes);
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+async function gunzip(bytes) {
+    const stream = new Blob([bytes])
+        .stream()
+        .pipeThrough(new DecompressionStream('gzip'));
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+function assertReceipt(receipt) {
+    if (!SHA256_PATTERN.test(receipt.sha256) ||
+        !SHA256_PATTERN.test(receipt.uncompressedSha256) ||
+        !Number.isSafeInteger(receipt.bytes) ||
+        !Number.isSafeInteger(receipt.uncompressedBytes)) {
+        throw new Error('Fennel compiler receipt is malformed');
+    }
+}
+/**
+ * Verifies the fetched fennel.lua asset against its pinned receipt. Accepts either the
+ * gzip delivery bytes or bytes a server already decoded via Content-Encoding.
+ */
+export async function verifyFennelCompilerBytes(bytes, receipt) {
+    assertReceipt(receipt);
+    let decoded = bytes;
+    if (bytes[0] === GZIP_MAGIC_0 && bytes[1] === GZIP_MAGIC_1) {
+        if (bytes.byteLength !== receipt.bytes) {
+            throw new Error(`Fennel compiler asset is ${bytes.byteLength} bytes; receipt expects ${receipt.bytes}`);
+        }
+        if ((await sha256Hex(bytes)) !== receipt.sha256) {
+            throw new Error('Fennel compiler asset SHA-256 does not match its pinned receipt');
+        }
+        decoded = await gunzip(bytes);
+    }
+    if (decoded.byteLength !== receipt.uncompressedBytes) {
+        throw new Error(`Fennel compiler source is ${decoded.byteLength} bytes; receipt expects ${receipt.uncompressedBytes}`);
+    }
+    if ((await sha256Hex(decoded)) !== receipt.uncompressedSha256) {
+        throw new Error('Fennel compiler source SHA-256 does not match its pinned receipt');
+    }
+    return new TextDecoder('utf-8', { fatal: true }).decode(decoded);
+}
+export async function loadFennelCompilerSource(asset) {
+    if (!asset?.url)
+        throw new Error('Fennel compiler URL is not configured');
+    const response = await fetch(asset.url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch Fennel compiler (${response.status})`);
+    }
+    const declaredLength = Number(response.headers.get('content-length'));
+    const maxBytes = Math.max(asset.receipt.bytes, asset.receipt.uncompressedBytes);
+    if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+        throw new Error(`Fennel compiler asset exceeds its ${maxBytes} byte receipt`);
+    }
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (bytes.byteLength > maxBytes) {
+        throw new Error(`Fennel compiler asset exceeds its ${maxBytes} byte receipt`);
+    }
+    return await verifyFennelCompilerBytes(bytes, asset.receipt);
+}

package/dist/playground/grain.d.ts

@@ -0,0 +1,9 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+/** Upstream Grain compiler (js_of_ocaml build) plus a WASI host for the program it emits. */
+declare class Grain extends StaticWorkerRuntimeSandbox {
+    readonly memoryEvidence: {
+        current: unknown;
+    };
+    constructor();
+}
+export default Grain;