wasm-idle 1.0.12 → 1.1.2

package/dist/playground/cachedClang.js

@@ -1,8 +1,11 @@
-import { resolveExecutionLimits, resolveRuntimeAssetCacheOptions } from '@wasm-idle/core';
+import { resolveExecutionLimits, resolveRuntimeAssetCacheOptions, OutputLimitError } from '@wasm-idle/core';
 import { resolveRuntimeAssetConfig } from './assets';
 import { WorkerAssetBridge } from './assetBridge';
 import { shouldStreamBundledClang } from './clangStreamingPolicy';
 import { CompiledArtifactCache, clangCompileKey } from './compiledArtifactCache';
+import { CLANG_STDIN_DATA, CLANG_STDIN_EOF, CLANG_STDIN_HEADER_BYTES } from './clangWorkerProtocol';
+const MAX_BUFFERED_INPUT_BYTES = 128 * 1024;
+const MAX_HEADER_BUILD_TIMEOUT_MS = 30_000;
 const workers = {
     async compile() {
         const { default: CompileWorker } = await import('./worker/cachedClangCompile?worker');
@@ -20,6 +23,7 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
     let runtimeBaseUrl = '';
     let assetConfig;
     let maxAssetBytes = 0;
+    let maxWasmMemoryBytes = 0;
     let languageSysroots = false;
     let activeWorker;
     let cancelWorker;
@@ -30,47 +34,97 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
     let inputBuffer;
     let inputRequested = false;
     let pendingEof = false;
+    let loadedMaxInputBytes = MAX_BUFFERED_INPUT_BYTES;
+    let maxBufferedInputBytes = loadedMaxInputBytes;
+    let pendingInputBytes = 0;
+    let loadedHeaderTimeoutMs = MAX_HEADER_BUILD_TIMEOUT_MS;
+    let headerTimeoutMs = loadedHeaderTimeoutMs;
+    let loadedMaxWorkers = 1;
+    let maxWorkers = loadedMaxWorkers;
     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.
+    // Header builds survive ordinary cancellation, within their own deadline and Worker budget.
     let precompiledHeader;
     let headerWorker;
+    function disposeWorker(worker, bridge) {
+        worker.onmessage = null;
+        worker.onerror = null;
+        worker.onmessageerror = null;
+        try {
+            bridge?.dispose();
+        }
+        catch {
+            // Cleanup must preserve the primary result and still attempt Worker termination.
+        }
+        try {
+            worker.terminate();
+        }
+        catch {
+            // Preserve the primary result even if a custom Worker fails to terminate.
+        }
+    }
     function adoptHeaderWorker(worker, bridge) {
         headerWorker?.dispose();
+        let settled = false;
+        let timeout;
         const dispose = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
             if (headerWorker?.worker === worker)
                 headerWorker = undefined;
-            bridge?.dispose();
-            worker.onmessage = null;
-            worker.onerror = null;
-            worker.onmessageerror = null;
-            worker.terminate();
+            disposeWorker(worker, bridge);
         };
         headerWorker = { worker, dispose };
+        timeout = setTimeout(dispose, headerTimeoutMs);
         worker.onerror = dispose;
         worker.onmessageerror = dispose;
         worker.onmessage = (event) => {
-            if (bridge?.handleMessage(event))
-                return;
-            if (event.data?.type !== 'precompiled-header')
+            if (settled || disposed || headerWorker?.worker !== worker)
                 return;
-            if (event.data.header)
-                precompiledHeader = event.data.header;
-            dispose();
+            try {
+                if (bridge?.handleMessage(event))
+                    return;
+                if (event.data?.type === 'error' && event.data.code === 'output-limit') {
+                    dispose();
+                    return;
+                }
+                if (event.data?.type !== 'precompiled-header')
+                    return;
+                if (event.data.header)
+                    precompiledHeader = event.data.header;
+                dispose();
+            }
+            catch {
+                dispose();
+            }
         };
     }
     function resetInput() {
         pendingInput.length = 0;
+        pendingInputBytes = 0;
         pendingEof = false;
         inputRequested = false;
         inputBuffer = undefined;
+        maxBufferedInputBytes = loadedMaxInputBytes;
+    }
+    function bufferedInputBytes() {
+        const control = inputBuffer && new Int32Array(inputBuffer, 0, 2);
+        // DATA remains owned by the consumer until it requests its next chunk.
+        const publishedBytes = control && Atomics.load(control, 0) === CLANG_STDIN_DATA ? Atomics.load(control, 1) : 0;
+        return pendingInputBytes + publishedBytes;
+    }
+    function assertInputCapacity(actual, limit = maxBufferedInputBytes) {
+        if (actual > limit) {
+            throw new RangeError(`C/C++ stdin buffered bytes exceed ${limit}`);
+        }
     }
     function flushInput() {
         if (!inputRequested || !inputBuffer)
             return;
         const control = new Int32Array(inputBuffer, 0, 2);
-        const payload = new Uint8Array(inputBuffer, 8);
+        const payload = new Uint8Array(inputBuffer, CLANG_STDIN_HEADER_BYTES);
         const next = pendingInput[0];
         if (next) {
             const length = Math.min(next.byteLength, payload.byteLength);
@@ -78,13 +132,14 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
             if (length === next.byteLength)
                 pendingInput.shift();
             else
-                pendingInput[0] = next.subarray(length);
+                pendingInput[0] = next.slice(length);
+            pendingInputBytes -= length;
             Atomics.store(control, 1, length);
-            Atomics.store(control, 0, 1);
+            Atomics.store(control, 0, CLANG_STDIN_DATA);
         }
         else if (pendingEof) {
             Atomics.store(control, 1, 0);
-            Atomics.store(control, 0, 2);
+            Atomics.store(control, 0, CLANG_STDIN_EOF);
         }
         else
             return;
@@ -98,9 +153,12 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
         resetInput();
     }
     async function workerOperation(factory, message, token, progress, compileLimit = 0, signal, executionAssetConfig = assetConfig) {
+        // The background compiler and the next foreground Worker share one budget.
+        if (headerWorker && maxWorkers < 2)
+            headerWorker.dispose();
         const worker = await factory();
         if (token !== generation || signal?.aborted) {
-            worker.terminate();
+            disposeWorker(worker);
             throw signal?.reason ?? new Error('Process terminated');
         }
         return new Promise((resolve, reject) => {
@@ -110,7 +168,7 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                     bridge = new WorkerAssetBridge(worker, 'clang', executionAssetConfig, progress, compileLimit, languageSysroots, runtimeCache);
             }
             catch (error) {
-                worker.terminate();
+                disposeWorker(worker);
                 reject(error);
                 return;
             }
@@ -124,15 +182,10 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                 activeWorker = undefined;
                 cancelWorker = undefined;
                 signal?.removeEventListener('abort', abort);
-                worker.onmessage = null;
-                worker.onerror = null;
-                worker.onmessageerror = null;
                 if (keepForHeader)
                     adoptHeaderWorker(worker, bridge);
-                else {
-                    bridge?.dispose();
-                    worker.terminate();
-                }
+                else
+                    disposeWorker(worker, bridge);
                 if (error)
                     reject(error);
                 else
@@ -170,6 +223,17 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                         flushInput();
                     }
                     else if (data.type === 'compiled' || data.type === 'error') {
+                        if (data.type === 'error' && data.code === 'output-limit') {
+                            finish(new OutputLimitError(data.error, {
+                                limit: data.limit,
+                                actual: data.actual,
+                                phase: 'compile'
+                            }));
+                            return;
+                        }
+                        for (const diagnostic of data.diagnostics ?? []) {
+                            legacy.oncompilerdiagnostic?.({ ...diagnostic });
+                        }
                         if (data.stdout)
                             legacy.output?.(data.stdout);
                         if (data.stderr)
@@ -178,7 +242,10 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                         if (data.type === 'error')
                             finish(new Error(data.error), undefined, keepForHeader);
                         else
-                            finish(undefined, data.artifact, keepForHeader);
+                            finish(undefined, {
+                                artifact: data.artifact,
+                                diagnostics: data.diagnostics ?? []
+                            }, keepForHeader);
                     }
                     else if (data.type === 'done') {
                         if (data.exitCode !== 0 && data.exitCode !== null)
@@ -222,6 +289,11 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                 return legacy.load(assets, code, log, args, options, progress);
             runtimeBaseUrl = assetConfig.baseUrl;
             maxAssetBytes = resolveExecutionLimits(options.limits).maxAssetBytes;
+            maxWasmMemoryBytes = resolveExecutionLimits(options.limits).maxWasmMemoryBytes;
+            loadedMaxInputBytes = Math.min(MAX_BUFFERED_INPUT_BYTES, resolveExecutionLimits(options.limits).maxWorkspaceBytes);
+            maxBufferedInputBytes = loadedMaxInputBytes;
+            loadedHeaderTimeoutMs = Math.min(MAX_HEADER_BUILD_TIMEOUT_MS, resolveExecutionLimits(options.limits).compileTimeoutMs);
+            loadedMaxWorkers = resolveExecutionLimits(options.limits).maxWorkers;
             languageSysroots = config?.clang?.bundledLanguageSysroots === true;
         },
         async run(code, prepare, log = true, progress, args = [], options = {}) {
@@ -246,10 +318,13 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
             };
             options.signal?.throwIfAborted();
             const token = ++generation;
+            headerTimeoutMs = Math.min(loadedHeaderTimeoutMs, resolveExecutionLimits(options.limits).compileTimeoutMs);
+            maxWorkers = Math.min(loadedMaxWorkers, resolveExecutionLimits(options.limits).maxWorkers);
             // Reactive UI arrays/records are Proxies and cannot cross postMessage.
             // Snapshot known fields before awaiting compilation, so the cache key,
             // compiler and executor also observe the same input values.
             const request = {
+                maxWasmMemoryBytes: Math.min(maxWasmMemoryBytes, resolveExecutionLimits(options.limits).maxWasmMemoryBytes),
                 code,
                 language,
                 activePath: options.activePath,
@@ -268,16 +343,37 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                 ? undefined
                 : Object.fromEntries(Object.entries(options.env));
             const stdin = options.stdin;
+            const inputLimit = Math.min(loadedMaxInputBytes, resolveExecutionLimits(options.limits).maxWorkspaceBytes);
+            if (!prepare && typeof stdin === 'string') {
+                // A string stdin is a complete input stream and replaces any queued writes.
+                // Check UTF-16 length first to avoid encoding an arbitrarily large write.
+                assertInputCapacity(stdin.length, inputLimit);
+                assertInputCapacity(encoder.encode(stdin).byteLength, inputLimit);
+                resetInput();
+                pendingEof = true;
+            }
+            else {
+                assertInputCapacity(bufferedInputBytes(), inputLimit);
+            }
             const limit = Math.min(maxAssetBytes, resolveExecutionLimits(options.limits).maxAssetBytes);
             const key = clangCompileKey(runtimeBaseUrl, limit, request, languageSysroots);
             let artifact = cache.get(key);
+            // Per-run backpressure starts only after admission and ends with this run.
+            maxBufferedInputBytes = inputLimit;
             running = true;
             try {
-                if (!artifact) {
-                    artifact = await workerOperation(() => factories.compile(), {
+                if (artifact) {
+                    for (const diagnostic of cache.getDiagnostics(key))
+                        legacy.oncompilerdiagnostic?.(diagnostic);
+                    if (token !== generation)
+                        throw new Error('Process terminated');
+                }
+                else {
+                    const compiled = await workerOperation(() => factories.compile(), {
                         request,
                         runtimeBaseUrl,
                         maxAssetBytes: limit,
+                        maxOutputBytes: resolveExecutionLimits(options.limits).maxOutputBytes,
                         languageSysroots,
                         log,
                         persistentCache: executionAssetConfig.persistentCache,
@@ -293,14 +389,16 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
                     }, token, progress, limit, options.signal, executionAssetConfig);
                     if (token !== generation)
                         throw new Error('Process terminated');
-                    cache.set(key, artifact);
+                    artifact = compiled.artifact;
+                    cache.set(key, artifact, compiled.diagnostics);
                 }
                 progress?.set?.(1);
                 if (prepare)
                     return true;
-                inputBuffer = new SharedArrayBuffer(65536 + 8);
+                inputBuffer = new SharedArrayBuffer(Math.min(65536, maxBufferedInputBytes) + CLANG_STDIN_HEADER_BYTES);
                 return await workerOperation(() => factories.execute(), {
                     artifact,
+                    maxWasmMemoryBytes: request.maxWasmMemoryBytes,
                     code,
                     activePath: request.activePath,
                     workspaceFiles: request.workspaceFiles,
@@ -313,16 +411,27 @@ export function createCachedClangSandbox(legacy, language, runtimeCache, cache =
             finally {
                 if (token === generation) {
                     running = false;
+                    maxBufferedInputBytes = loadedMaxInputBytes;
                     if (!prepare)
                         resetInput();
                 }
             }
         },
         write(input) {
+            if (disposed)
+                throw new Error('C/C++ sandbox was disposed');
             if (!cached)
                 return legacy.write?.(input);
-            if (input)
-                pendingInput.push(encoder.encode(input));
+            if (pendingEof)
+                throw new Error('C/C++ stdin is closed');
+            if (input) {
+                const buffered = bufferedInputBytes();
+                assertInputCapacity(buffered + input.length);
+                const bytes = encoder.encode(input);
+                assertInputCapacity(buffered + bytes.byteLength);
+                pendingInput.push(bytes);
+                pendingInputBytes += bytes.byteLength;
+            }
             flushInput();
         },
         eof() {

package/dist/playground/clangAssetIntegrity.js

@@ -7,10 +7,10 @@ export const BUNDLED_CLANG_ASSET_INTEGRITY = Object.freeze({
     'runtime-manifest.v1.json': integrityEntry(967, '0b854bc6b41924420cfcc840509ecbe03af3c63ca3edd4940897917e32c8d8ad'),
     'libc-printscan-long-double.a.gz': integrityEntry(52_723, 'b3f11e17e40fb13371a97244fdde00d5bd951ad8e20dfdf88a069167d6be628b', 111_062, '33e04007d3547095068391b42189d1ac5398dd04e9da3118dfa644ffea7f4148'),
     'bin/memfs.wasm.gz': integrityEntry(16_111, 'a3e43451bc15ae69a7f113009e2ee82ab4db711625c1782cd45d0d3c4d38175a', 38_071, '5b741e03dd3502bcfd80e4e5055232b5d633604e1461752efed0189f93407dc3'),
-    'bin/clang.wasm.gz': integrityEntry(13_121_917, '8dc032057fbeb41e4a9986dfc54b2336c17532033dee172eb0095eba9c5fbe75', 35_658_969, 'd92ef06cdd3fea88acf384db15a6f2a344790c05bcba8e9f13f5b75b36ad4a99'),
-    'bin/lld.wasm.gz': integrityEntry(6_417_339, '495813efde8f354c38483749cdface7a7d9e23c8411da45a6f5f80030159eb11', 16_171_013, '34d39bc410c098e7e09933b61cc8e28699447af9a28abf4544d71b6e9cad1f9d'),
-    'bin/sysroot.tar.gz': integrityEntry(5_059_493, 'c0ef46e903492383a3c7069bfd4aed0e764e8df988f92bb81eb96bea50bf2c00', 19_312_640, 'e122f1acec0642d62d8976101c542aaa5346460df6eae5a3f8efb594ff32f5ae'),
-    'bin/c-sysroot.tar.gz': integrityEntry(1_216_797, 'fb3e1cdacac3eceddcfe2e57cbbf78e593ec2a298f01acb61c06e4b9d24fbbee', 3_736_064, '720c620e459025e918747768b9f5f1aef7b48c6df1b34c1a31fb2e5b1b7a213e'),
-    'bin/cpp-addon.tar.gz': integrityEntry(3_840_608, '47e9946c5aaeb3b35a1d42d6a80eae8987c596f4f858b207e492c00d8680af9e', 15_572_992, '7d61b724d377dc4e5670725055fb2884ebc8153d697e05093992004d5859310d'),
-    'language-sysroots.v1.json': integrityEntry(175_348, 'd69acbdb636009dc5b2243f13f1580264f64a34362f0af67c9cd661388b565d0')
+    'bin/clang.wasm.gz': integrityEntry(13_124_999, 'cc7b6b229af392f439a1ca89dbb8d5e016792264a0a6ee59608ff24e269be982', 35_597_829, 'fe7c40c2369d4a1b91d87cd2a38b1a5be11cd7f381373b7888be0b5f209e2d5b'),
+    'bin/lld.wasm.gz': integrityEntry(6_421_841, '798ce825f3e3cf9a695b6a049f157ba28d38731a3dc5e699ccdf23d69d3a5c20', 16_136_490, '77949fed32d5481979b8ebe6081009e3ec69c7219cb355e3f388a316746ea9b7'),
+    'bin/sysroot.tar.gz': integrityEntry(6_780_412, '6188b500fa7af2dceadcbd6dcf2619b6935fa94c224c1c2078426666ebea1d50', 35_594_240, 'fb6d8a8786ec395009d44f62ff24a5bf09ff8672340b7dae9f48e28cf1569cba'),
+    'bin/c-sysroot.tar.gz': integrityEntry(2_006_388, 'da7a29250b2fe2d928fa8818069ff67e1dcb26c529bbf01f40bbeb251535ecaa', 12_213_760, '517b32208f4e556b22eb5ac775411c39fb75239dfaf81f206e6052e168425b62'),
+    'bin/cpp-addon.tar.gz': integrityEntry(4_776_509, '6e243c219561b1f5aad64db4a9ff8bbeb85a97b5e3b5df3ed71d8340d35a8cd7', 23_382_528, 'feaf2aa538623ec8c543ccb49e9a833d2a1aa6dee7a9ad502c277deba24ef642'),
+    'language-sysroots.v1.json': integrityEntry(426_858, '08f6c2c87b4bebc9599193334e1d0ed322ebb38cbdd2bbb83d2b8c3a4cb61263')
 });

package/dist/playground/clangWorkerProtocol.d.ts

@@ -1,9 +1,11 @@
 import type { BrowserClangArtifact, BrowserClangCompileProgress, BrowserClangCompileRequest, BrowserClangPrecompiledHeader, BrowserClangWorkspaceFile } from '@wasm-idle/llvm-core/clang';
+import type { CompilerDiagnostic } from '@wasm-idle/llvm-core/clang';
 import type { WorkerRuntimeAssetConfig } from './worker/assets';
 export type ClangCompileWorkerRequest = {
     request: Omit<BrowserClangCompileRequest, 'onProgress'>;
     runtimeBaseUrl: string;
     maxAssetBytes?: number;
+    maxOutputBytes?: number;
     languageSysroots?: boolean;
     log?: boolean;
     assets: WorkerRuntimeAssetConfig;
@@ -23,18 +25,27 @@ export type ClangCompileWorkerResponse = {
     artifact: BrowserClangArtifact;
     stdout: string;
     stderr: string;
+    diagnostics?: CompilerDiagnostic[];
     precompiledHeader?: 'building';
-} | {
+} | ({
     type: 'error';
     error: string;
     stdout: string;
     stderr: string;
+    diagnostics?: CompilerDiagnostic[];
     precompiledHeader?: 'building';
+} & ({
+    code?: undefined;
 } | {
+    code: 'output-limit';
+    limit: number;
+    actual: number;
+})) | {
     type: 'precompiled-header';
     header?: BrowserClangPrecompiledHeader;
 };
 export type ClangExecuteWorkerRequest = {
+    maxWasmMemoryBytes?: number;
     artifact: BrowserClangArtifact;
     programArgs?: string[];
     env?: Record<string, string>;

package/dist/playground/cobol.d.ts

@@ -1,4 +1,5 @@
 import { WorkerAssetBridge } from './assetBridge';
+import type { RuntimeAssetCache } from './runtimeAssetCache';
 import { type PlaygroundRuntimeAssets } from './assets';
 import type { SandboxExecutionOptions } from './options';
 import type { Sandbox, SandboxProgress } from './sandbox';
@@ -18,10 +19,12 @@ declare class Cobol implements Sandbox {
     assetBridge: WorkerAssetBridge | null;
     activeCobolBaseUrl: string;
     private activeOperation;
+    private runtimeAssetCache?;
     private disposed;
     private disposePromise;
     private readonly disposeCancellation;
     private readonly workerSession;
+    setRuntimeAssetCache(cache: RuntimeAssetCache): void;
     private beginOperation;
     private isOperationActive;
     private releaseOperation;

package/dist/playground/cobol.js

@@ -26,6 +26,7 @@ class Cobol {
     assetBridge = null;
     activeCobolBaseUrl = '';
     activeOperation = null;
+    runtimeAssetCache;
     disposed = false;
     disposePromise = null;
     disposeCancellation = new CancelledError('COBOL sandbox disposed', {
@@ -53,6 +54,14 @@ class Cobol {
             this.pendingEof = false;
         }
     });
+    setRuntimeAssetCache(cache) {
+        if (this.runtimeAssetCache === cache)
+            return;
+        if (this.disposed || this.worker || this.activeOperation) {
+            throw new RuntimeConfigurationError('Cannot replace an active COBOL compiler cache');
+        }
+        this.runtimeAssetCache = cache;
+    }
     beginOperation(phase) {
         if (this.disposed) {
             throw new RuntimeConfigurationError('COBOL sandbox is disposed', {
@@ -303,7 +312,7 @@ class Cobol {
                     }
                     let assetBridge;
                     try {
-                        assetBridge = new WorkerAssetBridge(worker, 'clang', clangAssets, progress, limits.maxAssetBytes);
+                        assetBridge = new WorkerAssetBridge(worker, 'clang', clangAssets, progress, limits.maxAssetBytes, false, this.runtimeAssetCache);
                     }
                     catch (error) {
                         try {

package/dist/playground/commonlisp.d.ts

@@ -0,0 +1,8 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+/** Real upstream ECL (Embeddable Common-Lisp) built to Wasm by the wasm-llvm producer. */
+export default class CommonLisp extends StaticWorkerRuntimeSandbox {
+    readonly evidence: {
+        current: unknown;
+    };
+    constructor();
+}

package/dist/playground/commonlisp.js

@@ -0,0 +1,33 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { preflightCommonLispRuntimeAssets, resolveCommonLispRuntimeAssetConfig } from './commonlispAssets';
+/** Real upstream ECL (Embeddable Common-Lisp) built to Wasm by the wasm-llvm producer. */
+export default class CommonLisp extends StaticWorkerRuntimeSandbox {
+    evidence;
+    constructor() {
+        const evidence = { current: undefined };
+        super({
+            displayName: 'Common Lisp',
+            languageId: 'COMMONLISP',
+            defaultActivePath: 'main.lisp',
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            inlineVerifiedWorker: true,
+            requireExactWorkerResponseUrl: true,
+            moduleWorker: true,
+            includeExecutionLimits: true,
+            onEvidence(value) {
+                evidence.current = value;
+            },
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\(\s*(?:read|read-line|read-char|read-byte|peek-char)\b|\*standard-input\*/i
+            },
+            resolveRuntimeAssets: resolveCommonLispRuntimeAssetConfig,
+            async preflightRuntimeAssets(urls, context) {
+                evidence.current = undefined;
+                return context.createOwnedDelivery(await preflightCommonLispRuntimeAssets(urls.baseUrl, context));
+            }
+        });
+        this.evidence = evidence;
+    }
+}

package/dist/playground/commonlispAssets.d.ts

@@ -0,0 +1,30 @@
+import { type ExecutionLimits, type RuntimeAssetCacheOptions } from '@wasm-idle/core';
+import type { PlaygroundRuntimeAssets } from './assets';
+export declare const COMMONLISP_INITIAL_MEMORY_BYTES: number;
+/** 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 declare const COMMONLISP_WASM_STORAGE_PATH = "ecl.wasm.gz.bin";
+export declare const COMMONLISP_RUNTIME_MANIFEST: import("@wasm-idle/core").RuntimeRegistryManifest;
+export declare function resolveCommonLispRuntimeAssetConfig(assets: string | PlaygroundRuntimeAssets, currentUrl: string): {
+    baseUrl: string;
+    workerUrl: string;
+    manifestFingerprint: "56f1eb7cf6470619cb3393e99d5c8ad1841a001ab758f388c006ca1d801ba071";
+    workerReceipt: {
+        readonly bytes: 12104;
+        readonly sha256: "d179242c40cdce862ff45bb35f736eaf8e79b97bdc06754576406ad4de698b7d";
+    };
+};
+export declare function preflightCommonLispRuntimeAssets(baseUrl: string, options: {
+    limits: ExecutionLimits;
+    persistentCache?: RuntimeAssetCacheOptions;
+    signal?: AbortSignal;
+    reportProgress?: (value: number, stage: string) => void;
+    fetch?: typeof globalThis.fetch;
+}): Promise<Readonly<{
+    fingerprint: "56f1eb7cf6470619cb3393e99d5c8ad1841a001ab758f388c006ca1d801ba071";
+    'producer-receipt.json': Uint8Array<ArrayBufferLike>;
+    'ecl.mjs': Uint8Array<ArrayBufferLike>;
+    'ecl.wasm': Uint8Array<ArrayBuffer>;
+}>>;
+/** Decode the verified gzip delivery into an exactly sized buffer and verify the logical receipt. */
+export declare function decompressCommonLispWasm(compressed: Uint8Array, signal?: AbortSignal): Promise<Uint8Array<ArrayBuffer>>;