wasm-idle 1.0.11 → 1.1.0

package/dist/playground/commonlispAssets.js

@@ -0,0 +1,184 @@
+import { AssetIntegrityError, defineRuntimeRegistryManifest, UnsupportedBrowserFeatureError, preflightRuntimeAssets, ResourceLimitError, RuntimeConfigurationError, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { WASM_COMMONLISP_PROFILE as profile } from './wasmCommonLispVersion';
+export const COMMONLISP_INITIAL_MEMORY_BYTES = 64 * 1024 * 1024;
+/** ecl.wasm is delivered as the producer's pinned gzip bytes; `.bin` keeps hosts from adding
+ * Content-Encoding, so the browser never transparently decodes it before verification. */
+export const COMMONLISP_WASM_STORAGE_PATH = 'ecl.wasm.gz.bin';
+const identityAsset = (name, mediaType) => ({
+    key: name,
+    path: name,
+    compressedSha256: profile.assets[name].sha256,
+    uncompressedSha256: profile.assets[name].sha256,
+    compressedBytes: profile.assets[name].bytes,
+    uncompressedBytes: profile.assets[name].bytes,
+    encoding: 'identity',
+    mediaType
+});
+const deliveryAssets = [
+    identityAsset('producer-receipt.json', 'application/json'),
+    identityAsset('ecl.mjs', 'text/javascript'),
+    {
+        key: 'ecl.wasm',
+        path: COMMONLISP_WASM_STORAGE_PATH,
+        compressedSha256: profile.assets['ecl.wasm.gz'].sha256,
+        uncompressedSha256: profile.runtime['ecl.wasm'].sha256,
+        compressedBytes: profile.assets['ecl.wasm.gz'].bytes,
+        uncompressedBytes: profile.runtime['ecl.wasm'].bytes,
+        encoding: 'gzip',
+        mediaType: 'application/wasm'
+    }
+];
+export const COMMONLISP_RUNTIME_MANIFEST = defineRuntimeRegistryManifest({
+    schemaVersion: 2,
+    manifestId: 'wasm-idle/commonlisp',
+    revision: profile.assets['producer-receipt.json'].sha256,
+    runtimes: [
+        {
+            runtimeId: 'COMMONLISP',
+            identity: {
+                languageId: 'COMMONLISP',
+                implementationId: 'ecl-emscripten',
+                implementationVersion: profile.version,
+                profile: {
+                    profileId: profile.profileId,
+                    manifestSchemaVersion: 1,
+                    manifestSha256: profile.assets['producer-receipt.json'].sha256,
+                    protocolVersion: 1,
+                    trustProfileId: profile.profileId,
+                    trustProfileSchemaVersion: 1
+                }
+            },
+            capabilities: {
+                stdin: 'streaming',
+                workspace: true,
+                abort: true,
+                artifacts: false,
+                streamingOutput: true
+            },
+            workerLifetime: { mode: 'per-run' },
+            requiredBrowserFeatures: ['wasm', 'wasm-exceptions', 'decompression-stream'],
+            assetRoot: '.',
+            assets: deliveryAssets,
+            contracts: {
+                routeId: 'COMMONLISP',
+                runtimeAssetKey: 'commonlisp',
+                documentationId: 'commonlisp',
+                syncTarget: 'wasm-commonlisp',
+                browserTestId: 'COMMONLISP'
+            }
+        }
+    ]
+});
+export function resolveCommonLispRuntimeAssetConfig(assets, currentUrl) {
+    const root = typeof assets === 'string' ? assets : assets.rootUrl || '';
+    const override = typeof assets === 'string' ? undefined : assets.commonlisp?.baseUrl;
+    const baseUrl = new URL(override ?? `${root.replace(/\/+$/, '')}/wasm-commonlisp/`, currentUrl);
+    if (!['http:', 'https:'].includes(baseUrl.protocol) ||
+        baseUrl.username ||
+        baseUrl.password ||
+        baseUrl.search ||
+        baseUrl.hash) {
+        throw new RuntimeConfigurationError('Common Lisp requires a credential-free HTTP(S) asset directory.', { runtimeId: 'COMMONLISP' });
+    }
+    if (!baseUrl.pathname.endsWith('/'))
+        baseUrl.pathname += '/';
+    const workerUrl = new URL('runner-worker.js', baseUrl);
+    workerUrl.searchParams.set('v', profile.workerReceipt.sha256);
+    return {
+        baseUrl: baseUrl.href,
+        workerUrl: workerUrl.href,
+        manifestFingerprint: profile.assets['producer-receipt.json'].sha256,
+        workerReceipt: profile.workerReceipt
+    };
+}
+export async function preflightCommonLispRuntimeAssets(baseUrl, options) {
+    if (options.limits.maxWasmMemoryBytes < COMMONLISP_INITIAL_MEMORY_BYTES) {
+        throw new ResourceLimitError('Common Lisp needs at least 64 MiB of Wasm memory.', {
+            runtimeId: 'COMMONLISP',
+            phase: 'asset',
+            resource: 'wasm-memory',
+            actual: COMMONLISP_INITIAL_MEMORY_BYTES,
+            limit: options.limits.maxWasmMemoryBytes
+        });
+    }
+    const loaded = new Map();
+    const total = deliveryAssets.reduce((sum, asset) => sum + asset.compressedBytes, 0);
+    const result = await preflightRuntimeAssets({
+        manifest: COMMONLISP_RUNTIME_MANIFEST,
+        runtimeId: 'COMMONLISP',
+        rootUrl: baseUrl,
+        assetUrls: Object.fromEntries(deliveryAssets.map((asset) => [
+            asset.key,
+            new URL(`${asset.path}?v=${asset.compressedSha256}`, baseUrl)
+        ])),
+        limits: options.limits,
+        persistentCache: options.persistentCache,
+        signal: options.signal,
+        fetch: options.fetch,
+        redirect: 'error',
+        requireExactResponseUrl: true,
+        maxConcurrentDownloads: 2,
+        maxTotalDeliveryBytes: total,
+        reportProgress(progress) {
+            loaded.set(progress.assetKey, progress.loadedBytes);
+            options.reportProgress?.(0.04 + (0.13 * [...loaded.values()].reduce((a, b) => a + b, 0)) / total, `Verifying ECL ${progress.assetKey}`);
+        }
+    });
+    const wasm = await decompressCommonLispWasm(result.assets['ecl.wasm'].bytes, options.signal);
+    return Object.freeze({
+        fingerprint: profile.assets['producer-receipt.json'].sha256,
+        'producer-receipt.json': result.assets['producer-receipt.json'].bytes,
+        'ecl.mjs': result.assets['ecl.mjs'].bytes,
+        'ecl.wasm': wasm
+    });
+}
+/** Decode the verified gzip delivery into an exactly sized buffer and verify the logical receipt. */
+export async function decompressCommonLispWasm(compressed, signal) {
+    const context = { runtimeId: 'COMMONLISP', profileId: profile.profileId };
+    if (typeof DecompressionStream !== 'function')
+        throw new UnsupportedBrowserFeatureError('DecompressionStream(gzip)', {
+            ...context,
+            phase: 'asset'
+        });
+    const expected = profile.runtime['ecl.wasm'];
+    const body = new Response(Uint8Array.from(compressed)).body;
+    const reader = body.pipeThrough(new DecompressionStream('gzip')).getReader();
+    const wasm = new Uint8Array(expected.bytes);
+    let offset = 0;
+    try {
+        for (;;) {
+            signal?.throwIfAborted();
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (offset + value.byteLength > wasm.byteLength)
+                throw new AssetIntegrityError('ECL ecl.wasm gzip output exceeds its receipt', context);
+            wasm.set(value, offset);
+            offset += value.byteLength;
+        }
+    }
+    catch (error) {
+        void reader.cancel().catch(() => undefined);
+        if (error instanceof AssetIntegrityError || signal?.aborted)
+            throw error;
+        throw new AssetIntegrityError('ECL ecl.wasm gzip decompression failed', {
+            ...context,
+            cause: error
+        });
+    }
+    if (offset !== wasm.byteLength)
+        throw new AssetIntegrityError('ECL ecl.wasm gzip output is truncated', context);
+    await verifyRuntimeAssetIntegrity({
+        asset: 'ecl.wasm',
+        bytes: wasm,
+        expected: {
+            ...expected,
+            uncompressedSha256: expected.sha256,
+            uncompressedBytes: expected.bytes
+        },
+        stage: 'uncompressed',
+        mimeType: 'application/wasm',
+        ...context
+    });
+    return wasm;
+}

package/dist/playground/golfscript.d.ts

@@ -0,0 +1,6 @@
+import Ruby from './ruby';
+/** Runs the unchanged upstream GolfScript interpreter on the real bundled Ruby VM. */
+declare class Golfscript extends Ruby {
+    constructor();
+}
+export default Golfscript;

package/dist/playground/golfscript.js

@@ -0,0 +1,8 @@
+import Ruby from './ruby';
+/** Runs the unchanged upstream GolfScript interpreter on the real bundled Ruby VM. */
+class Golfscript extends Ruby {
+    constructor() {
+        super('golfscript');
+    }
+}
+export default Golfscript;

package/dist/playground/index.d.ts

@@ -1,6 +1,6 @@
 import type { BoundSandbox, PlaygroundBinding, Sandbox, SandboxRuntimeAssets } from './sandbox';
 import { type PlaygroundBindingOptions } from '@wasm-idle/core';
-export declare const supportedLanguages: ("C" | "CPP" | "OBJC" | "OBJECTIVECXX" | "D" | "TINYGO" | "RUBY" | "PERL" | "TCL" | "AWK" | "PASCAL" | "JANET" | "JULIA" | "NIM" | "BASH" | "BQN" | "CLOJURESCRIPT" | "FORTH" | "J" | "PROLOG" | "RESCRIPT" | "C3" | "PYTHON3" | "JAVA" | "RUST" | "GO" | "CSHARP" | "FSHARP" | "VBNET" | "ELIXIR" | "ERLANG" | "GLEAM" | "GRAIN" | "HY" | "FORTRAN" | "LFORTRAN" | "COBOL" | "V" | "OCAML" | "JAVASCRIPT" | "TYPESCRIPT" | "ASSEMBLYSCRIPT" | "WAT" | "WASM" | "LUA" | "FENNEL" | "ZIG" | "LISP" | "HASKELL" | "R" | "OCTAVE" | "DUCKDB" | "SQLITE" | "POSTGRESQL" | "PHP")[];
+export declare const supportedLanguages: ("C" | "CPP" | "OBJC" | "OBJECTIVECXX" | "D" | "TINYGO" | "RUBY" | "PERL" | "TCL" | "AWK" | "PASCAL" | "JANET" | "JULIA" | "NIM" | "BASH" | "GOLFSCRIPT" | "APECODE" | "AHEUI" | "PYTHON3" | "BRAINFUCK" | "BEFUNGE93" | "WHITESPACE" | "MALBOLGE" | "UHMLANG" | "LOLCODE" | "WASM" | "BQN" | "CLOJURESCRIPT" | "FORTH" | "J" | "PROLOG" | "RESCRIPT" | "C3" | "JAVA" | "RUST" | "GO" | "CSHARP" | "FSHARP" | "VBNET" | "ELIXIR" | "ERLANG" | "GLEAM" | "GRAIN" | "HY" | "FORTRAN" | "LFORTRAN" | "LEAN4" | "COBOL" | "V" | "OCAML" | "JAVASCRIPT" | "TYPESCRIPT" | "ASSEMBLYSCRIPT" | "WAT" | "LUA" | "FENNEL" | "ZIG" | "LISP" | "COMMONLISP" | "HASKELL" | "R" | "OCTAVE" | "DUCKDB" | "SQLITE" | "POSTGRESQL" | "PHP")[];
 export declare function createPlaygroundBinding(runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): PlaygroundBinding;
 declare function playground(language: string): Promise<Sandbox>;
 declare function playground(language: string, runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): Promise<BoundSandbox>;

package/dist/playground/index.js

@@ -1,5 +1,86 @@
 import { createPlaygroundBinding as createCorePlaygroundBinding, isSupportedLanguageId, normalizeLanguageId, supportedLanguageIds } from '@wasm-idle/core';
 const sandboxRoutes = [
+    {
+        languageId: 'GOLFSCRIPT',
+        load: async () => {
+            const { default: Golfscript } = await import('./golfscript');
+            return new Golfscript();
+        }
+    },
+    {
+        languageId: 'APECODE',
+        load: async () => {
+            const { default: Apecode } = await import('./apecode');
+            return new Apecode();
+        }
+    },
+    {
+        languageId: 'LOLCODE',
+        load: async () => {
+            const [{ default: Wasm }, { WASI_INTERPRETERS }] = await Promise.all([
+                import('./wasm'),
+                import('./wasiInterpreters')
+            ]);
+            return new Wasm(WASI_INTERPRETERS.LOLCODE);
+        }
+    },
+    {
+        languageId: 'UHMLANG',
+        load: async () => {
+            const [{ default: Wasm }, { WASI_INTERPRETERS }] = await Promise.all([
+                import('./wasm'),
+                import('./wasiInterpreters')
+            ]);
+            return new Wasm(WASI_INTERPRETERS.UHMLANG);
+        }
+    },
+    {
+        languageId: 'AHEUI',
+        load: async () => {
+            const { default: Aheui } = await import('./aheui');
+            return new Aheui();
+        }
+    },
+    {
+        languageId: 'MALBOLGE',
+        load: async () => {
+            const [{ default: Wasm }, { WASI_INTERPRETERS }] = await Promise.all([
+                import('./wasm'),
+                import('./wasiInterpreters')
+            ]);
+            return new Wasm(WASI_INTERPRETERS.MALBOLGE);
+        }
+    },
+    {
+        languageId: 'WHITESPACE',
+        load: async () => {
+            const [{ default: Wasm }, { WASI_INTERPRETERS }] = await Promise.all([
+                import('./wasm'),
+                import('./wasiInterpreters')
+            ]);
+            return new Wasm(WASI_INTERPRETERS.WHITESPACE);
+        }
+    },
+    {
+        languageId: 'BEFUNGE93',
+        load: async () => {
+            const [{ default: Wasm }, { WASI_INTERPRETERS }] = await Promise.all([
+                import('./wasm'),
+                import('./wasiInterpreters')
+            ]);
+            return new Wasm(WASI_INTERPRETERS.BEFUNGE93);
+        }
+    },
+    {
+        languageId: 'BRAINFUCK',
+        load: async () => {
+            const [{ default: Wasm }, { WASI_INTERPRETERS }] = await Promise.all([
+                import('./wasm'),
+                import('./wasiInterpreters')
+            ]);
+            return new Wasm(WASI_INTERPRETERS.BRAINFUCK);
+        }
+    },
     {
         languageId: 'C3',
         load: async () => {
@@ -231,6 +312,13 @@ const sandboxRoutes = [
             return new LFortran();
         }
     },
+    {
+        languageId: 'LEAN4',
+        load: async () => {
+            const { default: Lean4 } = await import('./lean4');
+            return new Lean4();
+        }
+    },
     {
         languageId: 'FORTRAN',
         load: async () => {
@@ -329,6 +417,13 @@ const sandboxRoutes = [
             return new Lisp();
         }
     },
+    {
+        languageId: 'COMMONLISP',
+        load: async () => {
+            const { default: CommonLisp } = await import('./commonlisp');
+            return new CommonLisp();
+        }
+    },
     {
         languageId: 'RUBY',
         load: async () => {

package/dist/playground/javaRuntimeStdin.d.ts

@@ -0,0 +1,9 @@
+import { type PreparedJavaStdinInjection } from './javaStdin';
+/** Browser execution input is runtime data. Retain the snapshot API for standalone callers. */
+export declare function prepareJavaRuntimeStdinInjection(code: string): PreparedJavaStdinInjection;
+/** Single cursor shared by compatibility byte reads and bounded block reads. */
+export declare function createJavaStdinBridge(initialInput: string, explicit: boolean, readInput: () => string | null, maxChunkBytes?: number): {
+    readByte(): number;
+    readChunk(): Int8Array | null;
+    dispose(): void;
+};

package/dist/playground/javaRuntimeStdin.js

@@ -0,0 +1,145 @@
+import { prepareJavaStdinInjection } from './javaStdin';
+/** Browser execution input is runtime data. Retain the snapshot API for standalone callers. */
+export function prepareJavaRuntimeStdinInjection(code) {
+    const injection = prepareJavaStdinInjection(code, '', false);
+    if (!injection.usesStdin || !injection.helperSourcePath)
+        return injection;
+    const parts = injection.helperSourcePath.split('/');
+    const className = parts.pop().replace(/\.java$/, '');
+    const packageName = parts.join('.');
+    return {
+        ...injection,
+        stdinCacheKey: 'host-chunks-v2-jso',
+        helperSource: `${packageName ? `package ${packageName};\n\n` : ''}import java.io.InputStream;
+import org.teavm.jso.JSObject;
+import org.teavm.jso.browser.Window;
+import org.teavm.jso.core.JSFunction;
+import org.teavm.jso.core.JSMapLike;
+import org.teavm.jso.core.JSObjects;
+import org.teavm.jso.typedarrays.Int8Array;
+
+final class ${className} extends InputStream {
+    private static final ${className} INSTANCE = new ${className}();
+    private byte[] chunk = new byte[0];
+    private int position = 0;
+    private boolean ended = false;
+
+    private ${className}() {}
+
+    static InputStream open() {
+        return INSTANCE;
+    }
+
+    // Use classlib overlay methods: the pinned source compiler cannot compile @JSBody.
+    // A host call obtains a block; copying its bytes keeps Java array ownership explicit.
+    private static byte[] readFromHost() {
+        Window current = Window.current();
+        if (current == null) return null;
+        JSMapLike<JSObject> globals = current.cast();
+        JSObject stdin = globals.get("wasmIdleJavaStdin");
+        if (stdin == null) return null;
+        JSMapLike<JSObject> input = stdin.cast();
+        if (JSObjects.hasProperty(stdin, "readChunk")) {
+            JSFunction readChunk = input.get("readChunk").cast();
+            JSObject result = (JSObject) readChunk.call(stdin);
+            if (result == null) return null;
+            Int8Array array = result.cast();
+            byte[] next = new byte[array.getLength()];
+            for (int i = 0; i < next.length; i++) next[i] = array.get(i);
+            return next;
+        }
+        JSFunction readByte = input.get("readByte").cast();
+        Object value = readByte.call(stdin);
+        int next = value != null ? Integer.parseInt(value.toString()) : -1;
+        return next < 0 ? null : new byte[] { (byte) next };
+    }
+
+    private boolean ensureChunk() {
+        while (position == chunk.length && !ended) {
+            byte[] next = readFromHost();
+            position = 0;
+            if (next == null) {
+                chunk = new byte[0];
+                ended = true;
+            } else {
+                chunk = next;
+            }
+        }
+        return position < chunk.length;
+    }
+
+    @Override
+    public int read() {
+        return ensureChunk() ? chunk[position++] & 0xff : -1;
+    }
+
+    @Override
+    public int read(byte[] bytes, int offset, int length) {
+        if (bytes == null) throw new NullPointerException();
+        if (offset < 0 || length < 0 || length > bytes.length - offset) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (length == 0) return 0;
+        if (!ensureChunk()) return -1;
+        int count = Math.min(length, chunk.length - position);
+        System.arraycopy(chunk, position, bytes, offset, count);
+        position += count;
+        return count;
+    }
+
+    @Override
+    public int available() {
+        return chunk.length - position;
+    }
+}
+`
+    };
+}
+/** Single cursor shared by compatibility byte reads and bounded block reads. */
+export function createJavaStdinBridge(initialInput, explicit, readInput, maxChunkBytes = 4096) {
+    if (!Number.isSafeInteger(maxChunkBytes) || maxChunkBytes < 1) {
+        throw new RangeError('Java stdin chunk size must be a positive safe integer');
+    }
+    const encoder = new TextEncoder();
+    let bytes = encoder.encode(initialInput);
+    let offset = 0;
+    let ended = false;
+    function ensureBytes() {
+        while (offset === bytes.length && !ended) {
+            const input = explicit ? null : readInput();
+            bytes = input === null ? new Uint8Array(0) : encoder.encode(input);
+            offset = 0;
+            ended = input === null;
+        }
+        return offset < bytes.length;
+    }
+    function releaseConsumed() {
+        if (offset === bytes.length) {
+            bytes = new Uint8Array(0);
+            offset = 0;
+        }
+    }
+    return {
+        readByte() {
+            if (!ensureBytes())
+                return -1;
+            const value = bytes[offset++];
+            releaseConsumed();
+            return value;
+        },
+        readChunk() {
+            if (!ensureBytes())
+                return null;
+            const count = Math.min(maxChunkBytes, bytes.length - offset);
+            const chunk = new Int8Array(bytes.buffer, bytes.byteOffset + offset, count);
+            offset += count;
+            releaseConsumed();
+            return chunk;
+        },
+        dispose() {
+            bytes = new Uint8Array(0);
+            offset = 0;
+            ended = true;
+        }
+    };
+}

package/dist/playground/lean4.d.ts

@@ -0,0 +1,13 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+/** Upstream Lean 4 frontend and IR interpreter (`lean --run`) compiled to wasm32 Emscripten. */
+export default class Lean4 extends StaticWorkerRuntimeSandbox {
+    readonly defaultExecutionLimits: Readonly<{
+        maxWasmMemoryBytes: number;
+    }>;
+    readonly evidence: {
+        current: unknown;
+    };
+    constructor();
+    load(...args: Parameters<StaticWorkerRuntimeSandbox['load']>): Promise<void>;
+    run(...args: Parameters<StaticWorkerRuntimeSandbox['run']>): Promise<string | boolean>;
+}

package/dist/playground/lean4.js

@@ -0,0 +1,50 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { LEAN4_DEFAULT_WASM_MEMORY_BYTES, preflightLean4RuntimeAssets, resolveLean4RuntimeAssetConfig } from './lean4Assets';
+function lean4ExecutionOptions(options = {}) {
+    return {
+        ...options,
+        limits: {
+            ...options.limits,
+            maxWasmMemoryBytes: options.limits?.maxWasmMemoryBytes ?? LEAN4_DEFAULT_WASM_MEMORY_BYTES
+        }
+    };
+}
+/** Upstream Lean 4 frontend and IR interpreter (`lean --run`) compiled to wasm32 Emscripten. */
+export default class Lean4 extends StaticWorkerRuntimeSandbox {
+    defaultExecutionLimits = Object.freeze({
+        maxWasmMemoryBytes: LEAN4_DEFAULT_WASM_MEMORY_BYTES
+    });
+    evidence;
+    constructor() {
+        const evidence = { current: undefined };
+        super({
+            displayName: 'Lean 4',
+            languageId: 'LEAN4',
+            defaultActivePath: 'Main.lean',
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            inlineVerifiedWorker: true,
+            requireExactWorkerResponseUrl: true,
+            moduleWorker: true,
+            includeExecutionLimits: true,
+            onEvidence(value) {
+                evidence.current = value;
+            },
+            stdin: { mode: 'streaming', sourceHintPattern: /\b(?:getStdin|getLine|readToEnd)\b/u },
+            resolveRuntimeAssets: resolveLean4RuntimeAssetConfig,
+            async preflightRuntimeAssets(urls, context) {
+                evidence.current = undefined;
+                return context.createOwnedDelivery(await preflightLean4RuntimeAssets(urls.baseUrl, context));
+            }
+        });
+        this.evidence = evidence;
+    }
+    async load(...args) {
+        args[4] = lean4ExecutionOptions(args[4]);
+        return super.load(...args);
+    }
+    async run(...args) {
+        args[5] = lean4ExecutionOptions(args[5]);
+        return super.run(...args);
+    }
+}

package/dist/playground/lean4Assets.d.ts

@@ -0,0 +1,25 @@
+import { type ExecutionLimits, type RuntimeAssetCacheOptions } from '@wasm-idle/core';
+import type { PlaygroundRuntimeAssets } from './assets';
+/** Linear memory needed to start Lean, import Init, and interpret a small program. */
+export declare const LEAN4_INITIAL_MEMORY_BYTES: number;
+/** Default limit: importing the 277 MB Init library grows the heap to about 370 MiB. */
+export declare const LEAN4_DEFAULT_WASM_MEMORY_BYTES: number;
+export declare const LEAN4_RUNTIME_MANIFEST: import("@wasm-idle/core").RuntimeRegistryManifest;
+export declare function resolveLean4RuntimeAssetConfig(runtimeAssets: string | PlaygroundRuntimeAssets, currentUrl: string): {
+    baseUrl: string;
+    workerUrl: string;
+    manifestFingerprint: "e60eb3fdcc108fa7c6127c5a8925ffb622706facb17bc4f84e9ed27f82495fa1";
+    workerReceipt: {
+        readonly bytes: 15759;
+        readonly sha256: "469ef5ec7accf4c221d06134ccd4989f14e9229c61dd35c386617a015aec6f03";
+    };
+};
+export declare function preflightLean4RuntimeAssets(baseUrl: string, options: {
+    limits: ExecutionLimits;
+    persistentCache?: RuntimeAssetCacheOptions;
+    signal?: AbortSignal;
+    reportProgress?: (value: number, stage: string) => void;
+    fetch?: typeof globalThis.fetch;
+}): Promise<Readonly<{
+    fingerprint: "e60eb3fdcc108fa7c6127c5a8925ffb622706facb17bc4f84e9ed27f82495fa1";
+}>>;