wasm-idle 0.7.2 → 1.0.0

package/dist/playground/clang.js

@@ -1,19 +1,30 @@
 import { WorkerAssetBridge } from './assetBridge';
-import { resolveRuntimeAssetConfig } from './assets';
+import { resolveDebugRuntimeUrls, resolveRuntimeAssetConfig } from './assets';
+import { LldbSandboxSession } from './lldbSession';
+import { normalizeDwarfWorkspacePath } from '@wasm-idle/llvm-core/clang';
+import { resolveExecutionLimits } from '@wasm-idle/core';
 import { resolveSandboxExecutionArgs } from './options';
 import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
+import { createWasmIdleSharedBuffer, requireSharedArrayBuffer } from './sharedBuffer';
+import { WorkerSession } from './workerSession';
+import { reportWorkerInputReady, reportWorkerProgress } from './workerProgress';
 const debugBreakpointBufferInts = 1028;
+function normalizeLldbSourcePath(sourcePath, fallback) {
+    const normalized = normalizeDwarfWorkspacePath(sourcePath?.replace(/^\/workspace\//u, '') || fallback) ||
+        fallback;
+    return `/workspace/${normalized}`;
+}
 class Clang {
     language;
     ts = Date.now();
     output = null;
     ondebug;
     worker = null;
-    buffer = new SharedArrayBuffer(1024);
-    debugBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * debugBreakpointBufferInts);
-    watchBuffer = new SharedArrayBuffer(1024);
-    watchResultBuffer = new SharedArrayBuffer(1024);
-    interruptBuffer = new SharedArrayBuffer(1);
+    buffer = createWasmIdleSharedBuffer(1024);
+    debugBuffer = createWasmIdleSharedBuffer(Int32Array.BYTES_PER_ELEMENT * debugBreakpointBufferInts);
+    watchBuffer = createWasmIdleSharedBuffer(1024);
+    watchResultBuffer = createWasmIdleSharedBuffer(1024);
+    interruptBuffer = createWasmIdleSharedBuffer(1);
     pendingInput = [];
     begin = 0;
     elapse = 0;
@@ -23,33 +34,85 @@ class Clang {
     pendingEof = false;
     exit = true;
     assetBridge = null;
-    activeReject = null;
+    debugRuntimeBaseUrl = '';
+    debugManifestUrl = '';
+    debugManifestReceipt;
+    lldbSession;
+    debugMode = 'none';
+    lldbBreakpoints = new Map();
+    debugEvaluationQueue = Promise.resolve();
+    workerSession = new WorkerSession({
+        label: 'Clang',
+        onDispose: (worker) => {
+            this.disposeWorkerAssetBridge(worker);
+            if (this.worker === worker)
+                delete this.worker;
+            this.exit = true;
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            this.ondebug?.({ type: 'stop' });
+            void this.lldbSession?.disconnect();
+            this.lldbSession = undefined;
+        }
+    });
+    disposeWorkerAssetBridge(worker) {
+        if (this.worker !== worker)
+            return;
+        const assetBridge = this.assetBridge;
+        this.assetBridge = null;
+        try {
+            assetBridge?.dispose();
+        }
+        catch {
+            // Asset cleanup must not replace the worker operation result.
+        }
+    }
     constructor(language) {
         this.language = language;
     }
-    load(runtimeAssets = '', code = '', log = true, args = [], _options = {}, progress) {
-        return new Promise(async (resolve) => {
+    load(runtimeAssets = '', code = '', log = true, args = [], options = {}, progress) {
+        let limits;
+        try {
+            limits = resolveExecutionLimits(options.limits);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        return this.workerSession.load(async (resolve, reject, operation) => {
             this.log = log;
             this.pendingInput = [];
             this.waitingForInput = false;
             this.pendingEof = false;
             const assetConfig = resolveRuntimeAssetConfig('clang', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
-            const needsWorkerReset = !this.worker || !this.assetBridge || !this.assetBridge.matches(assetConfig);
+            const debugRuntime = resolveDebugRuntimeUrls(runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+            this.debugRuntimeBaseUrl = debugRuntime.baseUrl;
+            this.debugManifestUrl = debugRuntime.manifestUrl;
+            this.debugManifestReceipt = debugRuntime.manifestReceipt;
+            const needsWorkerReset = !this.worker ||
+                !this.assetBridge ||
+                !this.assetBridge.matches(assetConfig, limits.maxAssetBytes);
             if (needsWorkerReset && this.worker) {
-                this.worker.terminate();
-                delete this.worker;
-                this.assetBridge = null;
+                this.workerSession.reset();
             }
             if (!this.worker) {
-                this.worker = new (await import('./worker/clang?worker')).default();
-                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', assetConfig, progress);
+                const { default: ClangWorker } = await import('./worker/clang?worker');
+                if (!this.workerSession.isActive(operation))
+                    return;
+                const worker = new ClangWorker();
+                if (!this.workerSession.attach(worker, operation))
+                    return;
+                this.worker = worker;
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', assetConfig, progress, limits.maxAssetBytes);
                 this.worker.onmessage = (event) => {
+                    if (!this.workerSession.isActive(operation))
+                        return;
                     if (this.assetBridge?.handleMessage(event))
                         return;
-                    if (event.data?.progress != null)
-                        progress?.set?.(event.data.progress);
+                    reportWorkerProgress(progress, event.data?.progress);
                     if (event.data?.load)
                         resolve();
+                    if (event.data?.error)
+                        reject(event.data.error);
                 };
                 this.worker.postMessage({
                     load: true,
@@ -58,23 +121,33 @@ class Clang {
                     args,
                     assets: {
                         baseUrl: assetConfig.baseUrl,
+                        maxAssetBytes: limits.maxAssetBytes,
                         useAssetBridge: assetConfig.useAssetBridge
-                    }
+                    },
+                    maxAssetBytes: limits.maxAssetBytes
                 });
             }
             else {
-                this.assetBridge?.rebind(this.worker, assetConfig, progress);
+                this.assetBridge?.rebind(this.worker, assetConfig, progress, limits.maxAssetBytes);
                 this.worker.postMessage({ log });
                 resolve();
             }
         });
     }
     write(input) {
+        if (this.lldbSession) {
+            void this.lldbSession.write(input);
+            return;
+        }
         this.pendingInput.push(input);
         this.pendingEof = false;
         this.flushPendingInput();
     }
     eof() {
+        if (this.lldbSession) {
+            void this.lldbSession.eof();
+            return;
+        }
         this.pendingEof = true;
         this.flushPendingInput();
     }
@@ -92,36 +165,108 @@ class Clang {
         }
     }
     run(code, prepare, log = this.log, prog, args = [], options = {}) {
+        const debugMode = options.debugMode || (options.debug ? 'trace' : 'none');
+        this.debugMode = debugMode;
+        if (debugMode !== 'none')
+            requireSharedArrayBuffer(`${this.language} debugging`);
         this.exit = false;
-        return new Promise(async (resolve, reject) => {
+        return new Promise((resolve, reject) => {
             if (!this.worker)
                 return reject('Worker not loaded');
-            this.activeReject = reject;
+            const operation = this.workerSession.beginRun(this.worker, reject);
             const { compileArgs, programArgs } = resolveSandboxExecutionArgs(this.language, args, options);
-            this.setBreakpoints(options.debug ? [...(options.breakpoints || [])] : []);
+            const sourcePath = normalizeLldbSourcePath(options.debugPath || options.activePath, this.language === 'C' ? 'main.c' : 'main.cc');
+            this.lldbBreakpoints.clear();
+            if (debugMode === 'lldb') {
+                for (const sourceBreakpoints of options.sourceBreakpoints || []) {
+                    this.setBreakpoints(sourceBreakpoints.lines, sourceBreakpoints.sourcePath);
+                }
+                this.setBreakpoints([...(options.breakpoints || [])], sourcePath);
+            }
+            else {
+                this.setBreakpoints([...(options.breakpoints || [])], sourcePath);
+            }
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
+                if (!this.workerSession.isActive(operation))
+                    return;
                 if (this.assetBridge?.handleMessage(event))
                     return;
                 if (!this.worker)
                     return reject('Worker not loaded');
                 if (_uid !== this.uid)
                     return (this.worker.onmessage = null);
-                const { id, output, results, log, error, buffer, progress, debugEvent } = event.data;
+                const { id, output, results, log, error, buffer, progress, debugEvent, lldbArtifact } = event.data;
                 if (buffer) {
                     this.waitingForInput = true;
+                    if (!prepare) {
+                        reportWorkerInputReady(prog, `${this.language} runtime ready for input`);
+                    }
                     this.flushPendingInput();
                 }
                 if (output)
                     this.output(output);
                 if (debugEvent)
                     this.ondebug?.(debugEvent);
+                if (lldbArtifact) {
+                    const compilerWorker = this.worker;
+                    const lldbSession = new LldbSandboxSession({
+                        manifestUrl: this.debugManifestUrl,
+                        manifestReceipt: this.debugManifestReceipt,
+                        runtimeBaseUrl: this.debugRuntimeBaseUrl,
+                        artifact: lldbArtifact,
+                        sourcePath,
+                        breakpoints: [...(options.breakpoints || [])],
+                        sourceBreakpoints: Array.from(this.lldbBreakpoints, ([sourcePath, lines]) => ({
+                            sourcePath,
+                            lines: [...lines]
+                        })),
+                        pauseOnEntry: !!options.pauseOnEntry,
+                        pauseAtMain: true,
+                        programArgs,
+                        stdin: options.stdin,
+                        onDebugEvent: (debugEvent) => this.ondebug?.(debugEvent),
+                        onOutput: (debugOutput) => this.output(debugOutput)
+                    });
+                    this.lldbSession = lldbSession;
+                    for (const input of this.pendingInput.splice(0))
+                        void lldbSession.write(input);
+                    if (this.pendingEof) {
+                        this.pendingEof = false;
+                        void lldbSession.eof();
+                    }
+                    if (compilerWorker && this.workerSession.release(compilerWorker)) {
+                        this.disposeWorkerAssetBridge(compilerWorker);
+                        if (this.worker === compilerWorker)
+                            delete this.worker;
+                    }
+                    void lldbSession.start().then((result) => {
+                        if (!this.workerSession.isActive(operation))
+                            return;
+                        if (this.lldbSession === lldbSession)
+                            this.lldbSession = undefined;
+                        this.elapse = Date.now() - this.begin;
+                        this.exit = true;
+                        this.workerSession.complete(operation);
+                        resolve(result);
+                    }, (sessionError) => {
+                        if (!this.workerSession.isActive(operation))
+                            return;
+                        if (this.lldbSession === lldbSession)
+                            this.lldbSession = undefined;
+                        this.elapse = Date.now() - this.begin;
+                        this.exit = true;
+                        this.workerSession.complete(operation);
+                        reject(sessionError);
+                    });
+                    return;
+                }
                 if (results) {
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;
                     this.waitingForInput = false;
                     this.pendingEof = false;
-                    this.activeReject = null;
+                    this.workerSession.complete(operation);
                     this.ondebug?.({ type: 'stop' });
                     resolve(results);
                 }
@@ -131,13 +276,12 @@ class Clang {
                     this.elapse = Date.now() - this.begin;
                     this.waitingForInput = false;
                     this.pendingEof = false;
-                    this.activeReject = null;
+                    this.workerSession.complete(operation);
                     this.exit = true;
                     this.ondebug?.({ type: 'stop' });
                     reject(error);
                 }
-                if (progress)
-                    prog?.set?.(progress);
+                reportWorkerProgress(prog, progress);
             };
             interrupt[0] = 0;
             this.worker.onmessage = handler;
@@ -151,26 +295,43 @@ class Clang {
                 watchResultBuffer: this.watchResultBuffer,
                 interrupt: this.interruptBuffer,
                 context: {},
+                stdin: options.stdin,
                 log,
                 language: this.language,
                 compileArgs,
                 programArgs,
+                activePath: options.activePath,
+                workspaceFiles: options.workspaceFiles,
                 cppVersion: options.cppVersion,
                 cVersion: options.cVersion,
-                debug: !!options.debug,
+                debugMode,
+                debug: debugMode === 'trace',
                 breakpoints: [...(options.breakpoints || [])],
                 pauseOnEntry: !!options.pauseOnEntry
             });
         });
     }
     debugCommand(command) {
+        if (this.lldbSession)
+            return this.lldbSession.debugCommand(command);
         const control = new Int32Array(this.debugBuffer);
         Atomics.store(control, 1, command === 'stepInto' ? 2 : command === 'nextLine' ? 3 : command === 'stepOut' ? 4 : 1);
         Atomics.add(control, 0, 1);
         Atomics.notify(control, 0);
         this.ondebug?.({ type: 'resume', command });
     }
-    setBreakpoints(lines) {
+    debugPause() {
+        return this.lldbSession?.pause();
+    }
+    setBreakpoints(lines, sourcePath) {
+        const resolvedSourcePath = normalizeLldbSourcePath(sourcePath, this.language === 'C' ? 'main.c' : 'main.cc');
+        if (this.lldbSession) {
+            return this.lldbSession.setBreakpoints(lines, resolvedSourcePath);
+        }
+        if (this.debugMode === 'lldb') {
+            this.lldbBreakpoints.set(resolvedSourcePath, [...lines]);
+            return;
+        }
         const control = new Int32Array(this.debugBuffer);
         const next = [...new Set(lines.filter((line) => Number.isInteger(line) && line > 0))]
             .sort((left, right) => left - right)
@@ -181,25 +342,56 @@ class Clang {
         Atomics.store(control, 3, next.length);
         Atomics.add(control, 2, 1);
     }
-    async debugEvaluate(expression) {
-        if (!this.worker)
-            throw new Error('Worker not loaded');
-        resetBufferedStdin(this.watchResultBuffer);
-        const previousSequence = bufferedSequence(this.watchResultBuffer);
-        flushQueuedStdin([expression], this.watchBuffer);
-        const control = new Int32Array(this.debugBuffer);
-        Atomics.store(control, 1, 5);
-        Atomics.add(control, 0, 1);
-        Atomics.notify(control, 0);
-        return ((await waitForBufferedSequenceChange(this.watchResultBuffer, previousSequence, 5000)) ??
-            '?');
+    debugEvaluate(expression) {
+        if (this.lldbSession)
+            return this.lldbSession.evaluate(expression);
+        const evaluation = this.debugEvaluationQueue.then(async () => {
+            if (!this.worker)
+                throw new Error('Worker not loaded');
+            resetBufferedStdin(this.watchResultBuffer);
+            const previousSequence = bufferedSequence(this.watchResultBuffer);
+            flushQueuedStdin([expression], this.watchBuffer);
+            const control = new Int32Array(this.debugBuffer);
+            Atomics.store(control, 1, 5);
+            Atomics.add(control, 0, 1);
+            Atomics.notify(control, 0);
+            return ((await waitForBufferedSequenceChange(this.watchResultBuffer, previousSequence, 5000)) ?? '?');
+        });
+        this.debugEvaluationQueue = evaluation.then(() => undefined, () => undefined);
+        return evaluation;
+    }
+    debugVariables(variablesReference, start, count) {
+        return this.lldbSession?.variables(variablesReference, start, count) ?? Promise.resolve([]);
+    }
+    debugScopes(frameId) {
+        return this.lldbSession?.scopes(frameId) ?? Promise.resolve([]);
+    }
+    debugFrameScopes(frameId) {
+        return this.lldbSession?.frameScopes(frameId) ?? Promise.resolve([]);
+    }
+    debugFrameName(frameId) {
+        return this.lldbSession?.formattedFrameName(frameId) ?? Promise.resolve(null);
+    }
+    debugReadMemory(memoryReference, offset, count) {
+        return (this.lldbSession?.readMemory(memoryReference, offset, count) ?? Promise.resolve(null));
+    }
+    debugWriteMemory(memoryReference, offset, data, allowPartial = false) {
+        return (this.lldbSession?.writeMemory(memoryReference, offset, data, allowPartial) ??
+            Promise.resolve(null));
+    }
+    debugDataBreakpointInfo(arguments_) {
+        return this.lldbSession?.dataBreakpointInfo(arguments_) ?? Promise.resolve(null);
+    }
+    debugSetDataBreakpoints(breakpoints) {
+        return this.lldbSession?.setDataBreakpoints(breakpoints) ?? Promise.resolve([]);
     }
     kill() {
-        this.terminate();
+        return this.terminate();
     }
-    terminate() {
-        this.activeReject?.('Process terminated');
-        this.activeReject = null;
+    async terminate() {
+        const lldbSession = this.lldbSession;
+        this.lldbSession = undefined;
+        const disconnecting = lldbSession?.disconnect();
         this.waitingForInput = false;
         this.pendingEof = false;
         this.uid += 1;
@@ -207,13 +399,12 @@ class Clang {
         const control = new Int32Array(this.debugBuffer);
         Atomics.add(control, 0, 1);
         Atomics.notify(control, 0);
-        this.worker?.terminate?.();
-        delete this.worker;
-        this.assetBridge = null;
+        this.workerSession.terminate();
         this.exit = true;
+        await disconnecting;
     }
     async clear() {
-        this.terminate();
+        await this.terminate();
         this.pendingInput = [];
         this.waitingForInput = false;
         this.pendingEof = false;
@@ -226,9 +417,7 @@ class Clang {
         debugBuffer.fill(0);
         await new Promise((resolve) => setTimeout(resolve, 200));
         if (!this.exit) {
-            this.worker?.terminate?.();
-            delete this.worker;
-            this.assetBridge = null;
+            this.workerSession.terminate();
             this.exit = true;
         }
     }

package/dist/playground/clangAssetIntegrity.d.ts

@@ -0,0 +1,32 @@
+export declare const BUNDLED_CLANG_ASSET_INTEGRITY: Readonly<{
+    'runtime-manifest.v1.json': Readonly<{
+        bytes: number;
+        sha256: string;
+        uncompressedBytes: number;
+        uncompressedSha256: string;
+    }>;
+    'bin/memfs.wasm.gz': Readonly<{
+        bytes: number;
+        sha256: string;
+        uncompressedBytes: number;
+        uncompressedSha256: string;
+    }>;
+    'bin/clang.wasm.gz': Readonly<{
+        bytes: number;
+        sha256: string;
+        uncompressedBytes: number;
+        uncompressedSha256: string;
+    }>;
+    'bin/lld.wasm.gz': Readonly<{
+        bytes: number;
+        sha256: string;
+        uncompressedBytes: number;
+        uncompressedSha256: string;
+    }>;
+    'bin/sysroot.tar.gz': Readonly<{
+        bytes: number;
+        sha256: string;
+        uncompressedBytes: number;
+        uncompressedSha256: string;
+    }>;
+}>;

package/dist/playground/clangAssetIntegrity.js

@@ -0,0 +1,8 @@
+const integrityEntry = (bytes, sha256, uncompressedBytes = bytes, uncompressedSha256 = sha256) => Object.freeze({ bytes, sha256, uncompressedBytes, uncompressedSha256 });
+export const BUNDLED_CLANG_ASSET_INTEGRITY = Object.freeze({
+    'runtime-manifest.v1.json': integrityEntry(876, '1420808d0391ff2d8a2fdf2a9f6bbce8f728e06b1ed1651029ed80b226101444'),
+    'bin/memfs.wasm.gz': integrityEntry(18_974, 'd86f141eacd58a93511fbfb7c4e81d498eb7106a8a57df1bea7d33df3ce1f403', 345_442, '2c72ee42bd9430029dda8c6bafc9f37143f6fe88d5f1ea950a70259ab748bcfe'),
+    'bin/clang.wasm.gz': integrityEntry(15_721_977, 'b1174438d9a67b7ff11e623541b9a0572c024a9e798084b9b021dd9da2da0874', 44_159_206, '60747a8272f337195c961fb7b7140f0789360267845016f1abb026f056aad083'),
+    'bin/lld.wasm.gz': integrityEntry(7_837_837, 'f842a9b5df3c6d326f0260bfd313c11c2e22bc8b8ae0387deede9a4af55779cd', 20_795_796, '14f08c475b24ef45313cab7a086693525955c2c000b833faaaf48ad35b2521f8'),
+    'bin/sysroot.tar.gz': integrityEntry(5_059_892, '68437624a81c465b93895615e7afd3f235ff256de17dc1927b124e783614e3e4', 19_312_640, '963478e663d6ee2a3ae418ce7427f4535fb59831bb933f95938ccb2253cbb388')
+});

package/dist/playground/clojurescript.d.ts

@@ -0,0 +1,5 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+declare class ClojureScript extends StaticWorkerRuntimeSandbox {
+    constructor();
+}
+export default ClojureScript;

package/dist/playground/clojurescript.js

@@ -0,0 +1,59 @@
+import { resolveClojureScriptRuntimeAssetConfig } from './assets';
+import { preflightStaticRuntimeAssetsInWorker } from './staticRuntimePreflight';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError } from '@wasm-idle/core';
+class ClojureScript extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'CLOJURESCRIPT',
+            displayName: 'ClojureScript',
+            defaultActivePath: 'main.cljs',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\b(?:wasm-idle\.runtime\/)?(?:read-line|stdin)\b|\bread-line\b/
+            },
+            inlineVerifiedWorker: true,
+            runtimePreflightDelivery: 'transfer-owned',
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveClojureScriptRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = resolved.preflightProfile;
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('ClojureScript runtime requires a manifest fingerprint and worker receipt.', { runtimeId: 'CLOJURESCRIPT' });
+                }
+                return resolved;
+            },
+            async preflightRuntimeAssets(urls, context) {
+                const profile = urls.preflightProfile;
+                const loadedByAsset = new Map();
+                const totalDownloadBytes = (profile.manifestReceipt?.bytes ?? 0) + (profile.compilerReceipt?.bytes ?? 0);
+                const payload = await preflightStaticRuntimeAssetsInWorker({
+                    runtimeId: 'CLOJURESCRIPT',
+                    displayName: 'ClojureScript',
+                    baseUrl: urls.baseUrl,
+                    manifestUrl: urls.manifestUrl || '',
+                    profile,
+                    limits: context.limits,
+                    signal: context.signal,
+                    reportProgress(progress) {
+                        if (progress.kind === 'asset') {
+                            loadedByAsset.set(progress.progress.assetKey, progress.progress.loadedBytes);
+                            const loadedBytes = [...loadedByAsset.values()].reduce((total, loaded) => total + loaded, 0);
+                            const fraction = totalDownloadBytes > 0
+                                ? loadedBytes / totalDownloadBytes
+                                : 0;
+                            context.reportProgress(0.04 + Math.min(1, fraction) * 0.11, `Preflighting ClojureScript asset ${progress.progress.assetKey}`);
+                            return;
+                        }
+                        const { loadedBytes, totalBytes } = progress;
+                        const fraction = totalBytes > 0 ? loadedBytes / totalBytes : 0;
+                        context.reportProgress(0.15 + Math.min(1, fraction) * 0.02, 'Decompressing verified ClojureScript compiler');
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default ClojureScript;

package/dist/playground/clojurescriptPreflight.d.ts

@@ -0,0 +1,26 @@
+import type { ClojureScriptRuntimePreflightProfile } from './assets';
+import { type ExecutionLimits, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
+export declare const CLOJURESCRIPT_PREFLIGHT_PROTOCOL: "wasm-idle-clojurescript-preflight";
+export declare const CLOJURESCRIPT_PREFLIGHT_PROTOCOL_VERSION: 1;
+export declare const CLOJURESCRIPT_PREFLIGHT_RUNTIME_ID: "CLOJURESCRIPT";
+export interface ClojureScriptRuntimePreflightRequest {
+    readonly baseUrl: string;
+    readonly manifestUrl: string;
+    readonly profile: ClojureScriptRuntimePreflightProfile;
+    readonly limits?: Partial<ExecutionLimits>;
+    readonly signal?: AbortSignal;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly reportProgress?: (progress: RuntimeAssetPreflightProgress) => void;
+    readonly reportDecompressionProgress?: (loadedBytes: number, totalBytes: number) => void;
+}
+export interface ClojureScriptRuntimePreflightPayload {
+    readonly protocol: typeof CLOJURESCRIPT_PREFLIGHT_PROTOCOL;
+    readonly protocolVersion: typeof CLOJURESCRIPT_PREFLIGHT_PROTOCOL_VERSION;
+    readonly profileId: string;
+    readonly sourceRevision: string;
+    readonly integrationRevision: string;
+    readonly manifestFingerprint: string;
+    readonly manifestBytes: Uint8Array;
+    readonly compilerBytes: Uint8Array;
+}
+export declare function preflightClojureScriptRuntimeAssets(request: ClojureScriptRuntimePreflightRequest): Promise<ClojureScriptRuntimePreflightPayload>;