wasm-idle 1.1.0 → 1.1.2

package/dist/playground/goDebugInstrumentation.js

@@ -69,59 +69,112 @@ function stripLineComment(line) {
     const commentStart = lineCommentStart(line);
     return commentStart === -1 ? line : line.slice(0, commentStart);
 }
-function countNesting(line) {
-    const source = stripLineComment(line);
-    let quote = '';
-    let escaped = false;
-    let braces = 0;
-    let parens = 0;
-    let brackets = 0;
-    for (const character of source) {
-        if (quote) {
-            if (quote === '`') {
-                if (character === '`')
-                    quote = '';
-                continue;
-            }
-            if (escaped) {
-                escaped = false;
-                continue;
-            }
-            if (character === '\\') {
-                escaped = true;
-                continue;
+const goKeywords = new Set([
+    ...'break case chan const continue default defer else fallthrough for func go'.split(' '),
+    ...'goto if import interface map package range return select struct switch type var'.split(' ')
+]);
+// Final tokens after which Go inserts a semicolon at a line break. Literals are tokenized as
+// '0' (number), '"' (string), "'" (rune) and '`' (raw string).
+const statementEndTokens = new Set([
+    ...'break continue fallthrough return ++ -- ) ] }'.split(' '),
+    ...['0', '"', "'", '`']
+]);
+function isIdentifier(token) {
+    return token !== undefined && /^[\p{L}_]/u.test(token) && !goKeywords.has(token);
+}
+function endsStatement(token) {
+    return statementEndTokens.has(token) || isIdentifier(token);
+}
+// Inside an if/for/switch header Go reads `T{` as the block, but `[]T{`, `[N]*pkg.T{`,
+// `map[K]V{` and `struct{...}{` still open composite literals.
+function followsLiteralType(tokens, braceIndex, closedFrame) {
+    let index = braceIndex - 1;
+    if (tokens[index] === '}')
+        return closedFrame === 'type';
+    if (!isIdentifier(tokens[index]))
+        return false;
+    index -= 1;
+    if (tokens[index] === '.' && isIdentifier(tokens[index - 1]))
+        index -= 2;
+    const pointer = tokens[index] === '*';
+    while (tokens[index] === '*')
+        index -= 1;
+    if (tokens[index] !== ']')
+        return false;
+    if (!pointer)
+        return true;
+    // `a[i] * b {` multiplies; only `[]*T` and `map[K]*V` are element types.
+    let open = index - 1;
+    for (let depth = 1; open >= 0; open -= 1) {
+        if (tokens[open] === ']')
+            depth += 1;
+        else if (tokens[open] === '[' && --depth === 0)
+            break;
+    }
+    return open === index - 1 || tokens[open - 1] === 'map';
+}
+function lineTokens(line, state) {
+    const tokens = [];
+    const wordPattern = /[\p{L}_][\p{L}\p{N}_]*|\.?\d[\p{L}\p{N}_.]*/uy;
+    let index = 0;
+    while (index < line.length) {
+        if (state.rawString || state.blockComment) {
+            const end = line.indexOf(state.rawString ? '`' : '*/', index);
+            if (end === -1)
+                break;
+            if (state.rawString)
+                tokens.push('`');
+            index = end + (state.rawString ? 1 : 2);
+            state.rawString = false;
+            state.blockComment = false;
+            continue;
+        }
+        const character = line[index] || '';
+        if (/\s/.test(character)) {
+            index += 1;
+            continue;
+        }
+        if (line.startsWith('//', index))
+            break;
+        if (line.startsWith('/*', index)) {
+            state.blockComment = true;
+            index += 2;
+            continue;
+        }
+        if (character === '`') {
+            state.rawString = true;
+            index += 1;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            index += 1;
+            while (index < line.length && line[index] !== character) {
+                index += line[index] === '\\' ? 2 : 1;
             }
-            if (character === quote)
-                quote = '';
+            tokens.push(character);
+            index += 1;
             continue;
         }
-        if (character === '"' || character === "'" || character === '`') {
-            quote = character;
+        wordPattern.lastIndex = index;
+        const word = wordPattern.exec(line)?.[0];
+        if (word) {
+            tokens.push(/^[\p{L}_]/u.test(word) ? word : '0');
+            index += word.length;
             continue;
         }
-        if (character === '{')
-            braces += 1;
-        else if (character === '}')
-            braces -= 1;
-        else if (character === '(')
-            parens += 1;
-        else if (character === ')')
-            parens -= 1;
-        else if (character === '[')
-            brackets += 1;
-        else if (character === ']')
-            brackets -= 1;
+        const operator = ['++', '--', ':=', '...'].find((candidate) => line.startsWith(candidate, index)) ||
+            character;
+        tokens.push(operator);
+        index += operator.length;
     }
-    return { braces, parens, brackets };
+    return tokens;
 }
 function functionNameFromLine(line) {
     const source = stripLineComment(line).trim();
     const match = source.match(/^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/);
     return match?.[1] || null;
 }
-function shouldInstrumentLine(line, parenDepth, bracketDepth) {
-    if (parenDepth > 0 || bracketDepth > 0)
-        return false;
+function shouldInstrumentLine(line) {
     const trimmed = stripLineComment(line).trim();
     if (!trimmed)
         return false;
@@ -190,31 +243,108 @@ function instrumentFunctionLines(source) {
     const lines = source.split('\n');
     const instrumented = [];
     const functionStack = [];
+    const lexState = { rawString: false, blockComment: false };
+    const frames = [];
+    // Frame depths where a `func` signature still awaits its body, and where an if/for/switch
+    // header still awaits its block.
+    let pendingFunctionDepths = [];
+    let headerDepth = -1;
+    let closedFrame;
+    let previousToken = ';';
+    let continuesStatement = false;
+    let followsLabel = false;
     let braceDepth = 0;
-    let parenDepth = 0;
-    let bracketDepth = 0;
     for (let index = 0; index < lines.length; index += 1) {
         const line = lines[index] || '';
         const lineNumber = index + 1;
-        const functionName = functionNameFromLine(line);
+        const startsInCode = !lexState.rawString && !lexState.blockComment;
+        const functionName = startsInCode ? functionNameFromLine(line) : null;
         const inFunction = functionStack.length > 0;
         const indent = line.match(/^\s*/)?.[0] || '';
-        if (inFunction && shouldInstrumentLine(line, parenDepth, bracketDepth)) {
+        // Only hook lines that start a statement directly inside a block: not inside a raw
+        // string, comment, composite literal, call or index, and not continuing the previous line.
+        if (inFunction &&
+            startsInCode &&
+            frames.at(-1) === 'block' &&
+            !frames.includes('(') &&
+            !frames.includes('[') &&
+            !continuesStatement &&
+            !followsLabel &&
+            shouldInstrumentLine(line)) {
             instrumented.push(`${indent}__wasmIdleDebugLine(${lineNumber})`);
         }
         instrumented.push(line);
-        const nesting = countNesting(line);
-        const nextBraceDepth = braceDepth + nesting.braces;
-        const nextParenDepth = Math.max(0, parenDepth + nesting.parens);
-        const nextBracketDepth = Math.max(0, bracketDepth + nesting.brackets);
-        if (functionName && nesting.braces > 0) {
+        const tokens = lineTokens(line, lexState);
+        let braces = 0;
+        for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex += 1) {
+            const token = tokens[tokenIndex] || '';
+            const depth = frames.length;
+            if (token === '(' || token === '[') {
+                frames.push(token);
+            }
+            else if (token === ')' || token === ']' || token === '}') {
+                closedFrame = frames.pop();
+                if (token === '}')
+                    braces -= 1;
+                pendingFunctionDepths = pendingFunctionDepths.filter((pending) => pending <= frames.length);
+                if (headerDepth > frames.length)
+                    headerDepth = -1;
+            }
+            else if (token === '{') {
+                let frame = '{';
+                if (pendingFunctionDepths.includes(depth)) {
+                    frame = 'block';
+                    pendingFunctionDepths = pendingFunctionDepths.filter((pending) => pending !== depth);
+                }
+                else if (previousToken === 'struct' || previousToken === 'interface') {
+                    frame = 'type';
+                }
+                else if (['else', 'for', 'switch', 'select'].includes(previousToken) ||
+                    (headerDepth === depth &&
+                        tokenIndex === tokens.length - 1 &&
+                        !followsLiteralType(tokens, tokenIndex, closedFrame)) ||
+                    ([';', '{', ':'].includes(previousToken) &&
+                        (frames.at(-1) ?? 'block') === 'block')) {
+                    // Go ends an if/for/switch header at the `{` that closes its line; any other
+                    // `{` after an operand (`P{`, `[]int{`) opens a literal.
+                    frame = 'block';
+                    if (headerDepth === depth)
+                        headerDepth = -1;
+                }
+                frames.push(frame);
+                braces += 1;
+            }
+            else if (token === 'func' && previousToken !== ']' && previousToken !== 'chan') {
+                pendingFunctionDepths.push(depth);
+            }
+            else if (['if', 'for', 'switch', 'select'].includes(token)) {
+                headerDepth = depth;
+            }
+            else if ([',', ';', '=', ':='].includes(token)) {
+                pendingFunctionDepths = pendingFunctionDepths.filter((pending) => pending !== depth);
+            }
+            previousToken = token;
+        }
+        const lastToken = tokens.at(-1);
+        if (lastToken !== undefined) {
+            const trimmed = stripLineComment(line).trim();
+            continuesStatement = !endsStatement(lastToken) && !['{', ':', ';'].includes(lastToken);
+            followsLabel = /^[A-Za-z_]\w*:$/.test(trimmed) && trimmed !== 'default:';
+            if (endsStatement(lastToken)) {
+                previousToken = ';';
+                pendingFunctionDepths = pendingFunctionDepths.filter((pending) => pending < frames.length);
+                if (headerDepth >= frames.length)
+                    headerDepth = -1;
+            }
+        }
+        // A signature line that ends inside a raw string or block comment has no place for the
+        // entry hook; leave that function uninstrumented rather than edit the literal.
+        if (functionName && braces > 0 && !lexState.rawString && !lexState.blockComment) {
             const bodyIndent = `${indent}\t`;
             instrumented.push(`${bodyIndent}__wasmIdleDebugEnter(${JSON.stringify(functionName)}, ${lineNumber})`, `${bodyIndent}defer __wasmIdleDebugLeave()`);
-            functionStack.push({ depth: nextBraceDepth, name: functionName });
+            functionStack.push({ depth: braceDepth + braces, name: functionName });
         }
-        braceDepth = nextBraceDepth;
-        parenDepth = nextParenDepth;
-        bracketDepth = nextBracketDepth;
+        braceDepth += braces;
         while (functionStack.length &&
             braceDepth < functionStack[functionStack.length - 1].depth) {
             functionStack.pop();

package/dist/playground/java.js

@@ -687,8 +687,9 @@ class Java {
                         resolve(results);
                         return;
                     }
-                    if (error)
-                        failRun(error);
+                    if (Object.hasOwn(event.data, 'error')) {
+                        failRun(error === '' ? 'Java execution failed' : error);
+                    }
                 }
                 catch (error) {
                     failRun(error, true);

package/dist/playground/javaRuntimeErrors.d.ts

@@ -0,0 +1,9 @@
+/** A real Java entry point keeps exception formatting inside the Java class library. */
+export declare function prepareJavaExceptionBridge(mainClass: string, sourceTexts: readonly string[], classFiles: readonly string[]): {
+    mainClass: string;
+    sourceFileName: string;
+    formatterSourceFileName: string;
+    formatExport: string;
+    source: string;
+    formatterSource: string;
+};

package/dist/playground/javaRuntimeErrors.js

@@ -0,0 +1,60 @@
+/** A real Java entry point keeps exception formatting inside the Java class library. */
+export function prepareJavaExceptionBridge(mainClass, sourceTexts, classFiles) {
+    const packageName = mainClass.slice(0, Math.max(0, mainClass.lastIndexOf('.')));
+    const packagePath = packageName ? `${packageName.replaceAll('.', '/')}/` : '';
+    const entryClass = mainClass.slice(mainClass.lastIndexOf('.') + 1);
+    const sourcePrefix = packageName ? `package ${packageName};\n\n` : '';
+    let className = 'WasmIdleJavaEntryPoint';
+    while (classFiles.some((path) => path === `${packagePath}${className}.class` ||
+        path.startsWith(`${packagePath}${className}$`)))
+        className += '_';
+    let formatterClass = 'WasmIdleJavaExceptionBridge';
+    while (classFiles.some((path) => path === `${packagePath}${formatterClass}.class` ||
+        path.startsWith(`${packagePath}${formatterClass}$`)))
+        formatterClass += '_';
+    // Conservatively reserve names even when user identifiers use Java Unicode escapes.
+    const decodedSources = sourceTexts.map((source) => source.replace(/\\u+([0-9a-f]{4})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))));
+    let formatExport = 'wasmIdleFormatJavaException';
+    while (decodedSources.some((source) => source.includes(formatExport)))
+        formatExport += '_';
+    return {
+        mainClass: packageName ? `${packageName}.${formatterClass}` : formatterClass,
+        sourceFileName: `${className}.java`,
+        formatterSourceFileName: `${formatterClass}.java`,
+        formatExport,
+        // No imported types can hide the user entry class, even when it is named String.
+        source: `${sourcePrefix}final class ${className} {
+    static ${formatterClass}.Program program() {
+        return ${entryClass}::main;
+    }
+}
+`,
+        formatterSource: `${sourcePrefix}import java.lang.String;
+import java.lang.Throwable;
+import java.io.StringWriter;
+import java.io.PrintWriter;
+import org.teavm.jso.JSExport;
+import org.teavm.jso.JSObject;
+import org.teavm.jso.JSExceptions;
+
+final class ${formatterClass} {
+    interface Program {
+        void run(String[] args) throws Throwable;
+    }
+
+    public static void main(String[] args) throws Throwable {
+        ${className}.program().run(args);
+    }
+
+    @JSExport
+    public static String ${formatExport}(JSObject error) {
+        Throwable exception = JSExceptions.getJavaException(error);
+        if (exception == null) return null;
+        StringWriter text = new StringWriter();
+        exception.printStackTrace(new PrintWriter(text));
+        return text.toString();
+    }
+}
+`
+    };
+}

package/dist/playground/lean4Assets.d.ts

@@ -8,10 +8,10 @@ export declare const LEAN4_RUNTIME_MANIFEST: import("@wasm-idle/core").RuntimeRe
 export declare function resolveLean4RuntimeAssetConfig(runtimeAssets: string | PlaygroundRuntimeAssets, currentUrl: string): {
     baseUrl: string;
     workerUrl: string;
-    manifestFingerprint: "e60eb3fdcc108fa7c6127c5a8925ffb622706facb17bc4f84e9ed27f82495fa1";
+    manifestFingerprint: "335bd6e1720371fc161859cb7c2858600ec12314c30da1f0e5e503e324a96d42";
     workerReceipt: {
-        readonly bytes: 15759;
-        readonly sha256: "469ef5ec7accf4c221d06134ccd4989f14e9229c61dd35c386617a015aec6f03";
+        readonly bytes: 16049;
+        readonly sha256: "3611a263c4304246c9ee2967c07be2a1c70764a39d642db87ba0b86bfbe9d519";
     };
 };
 export declare function preflightLean4RuntimeAssets(baseUrl: string, options: {
@@ -21,5 +21,5 @@ export declare function preflightLean4RuntimeAssets(baseUrl: string, options: {
     reportProgress?: (value: number, stage: string) => void;
     fetch?: typeof globalThis.fetch;
 }): Promise<Readonly<{
-    fingerprint: "e60eb3fdcc108fa7c6127c5a8925ffb622706facb17bc4f84e9ed27f82495fa1";
+    fingerprint: "335bd6e1720371fc161859cb7c2858600ec12314c30da1f0e5e503e324a96d42";
 }>>;

package/dist/playground/lfortran.js

@@ -1,5 +1,6 @@
 import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
 import { preflightLfortranRuntimeAssets, resolveLfortranRuntimeAssetConfig } from './lfortranAssets';
+import { WASM_LFORTRAN_PROFILE as profile } from './wasmLfortranVersion';
 /** Real upstream FortranEvaluator using LLVM and Emscripten dynamic side modules. */
 export default class LFortran extends StaticWorkerRuntimeSandbox {
     memoryEvidence;
@@ -20,6 +21,15 @@ export default class LFortran extends StaticWorkerRuntimeSandbox {
             },
             stdin: { mode: 'streaming', sourceHintPattern: /\bread\b/i },
             resolveRuntimeAssets: resolveLfortranRuntimeAssetConfig,
+            compilerModules() {
+                return {
+                    compiler: {
+                        receipt: profile.assets['lfortran.wasm'],
+                        // Defined memories live in fresh instances; the compiler imports the job's bounded memory.
+                        compileKey: 'lfortran-native-imported-memory-v1'
+                    }
+                };
+            },
             async preflightRuntimeAssets(urls, context) {
                 memoryEvidence.current = undefined;
                 return context.createOwnedDelivery(await preflightLfortranRuntimeAssets(urls.baseUrl, context));

package/dist/playground/lfortranAssets.d.ts

@@ -7,8 +7,8 @@ export declare function resolveLfortranRuntimeAssetConfig(assets: string | Playg
     workerUrl: string;
     manifestFingerprint: "11c9baef85c5221440edc4462690312cda62b48998a133b9a397ce32c6a97c45";
     workerReceipt: {
-        readonly bytes: 11569;
-        readonly sha256: "e801cbf4dca7be9fc6fd1205dc4e6ab17af4530f42527dcc8e544eb8373a1469";
+        readonly bytes: 13875;
+        readonly sha256: "6443226c53cdadbbfdc25d43d1c07c4f13d8855cfe5cfd609f45ca9b29a96cdf";
     };
 };
 export declare function preflightLfortranRuntimeAssets(baseUrl: string, options: {

package/dist/playground/nim.js

@@ -14,6 +14,28 @@ class Nim extends StaticWorkerRuntimeSandbox {
                 sourceHintPattern: /\b(?:stdin|readLine|readAll|lines)\b/i
             },
             inlineVerifiedWorker: true,
+            includeExecutionLimits: true,
+            compilerModules(urls) {
+                const profile = snapshotNimRuntimePreflightProfile(urls.preflightProfile);
+                return Object.fromEntries([
+                    ['nim', profile.nimWasmReceipt],
+                    ['clang', profile.clangWasmReceipt],
+                    ['lld', profile.lldWasmReceipt],
+                    ['memfs', profile.memfsWasmReceipt]
+                ].map(([key, receipt]) => {
+                    const integrity = receipt;
+                    return [
+                        key,
+                        {
+                            receipt: {
+                                bytes: integrity.uncompressedBytes,
+                                sha256: integrity.uncompressedSha256
+                            },
+                            compileKey: 'nim-llvm8-native-v1'
+                        }
+                    ];
+                }));
+            },
             resolveRuntimeAssets(runtimeAssets, currentUrl) {
                 const resolved = resolveNimRuntimeAssetConfig(runtimeAssets, currentUrl);
                 const profile = snapshotNimRuntimePreflightProfile(resolved.preflightProfile);

package/dist/playground/objectivec.d.ts

@@ -1,4 +1,5 @@
 import { WorkerAssetBridge } from './assetBridge';
+import type { RuntimeAssetCache } from './runtimeAssetCache';
 import type { DebugCommand, DebugSessionEvent } from './options';
 import { type PlaygroundRuntimeAssets } from './assets';
 import type { SandboxExecutionOptions } from './options';
@@ -24,8 +25,10 @@ declare class ObjectiveC implements Sandbox {
     exit: boolean;
     assetBridge: WorkerAssetBridge | null;
     activeObjectiveCAssetsKey: string;
+    private runtimeAssetCache?;
     private readonly workerSession;
     constructor(language?: ObjectiveCSandboxLanguage);
+    setRuntimeAssetCache(cache: RuntimeAssetCache): void;
     load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
     write(input: string): void;
     eof(): void;

package/dist/playground/objectivec.js

@@ -5,7 +5,7 @@ import { createWasmIdleSharedBuffer, requireSharedArrayBuffer } from './sharedBu
 import { WorkerSession } from './workerSession';
 import { reportWorkerInputReady } from './workerProgress';
 import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
-import { AssetTooLargeError, createRuntimeAssetsKey, resolveExecutionLimits } from '@wasm-idle/core';
+import { AssetTooLargeError, RuntimeConfigurationError, createRuntimeAssetsKey, resolveExecutionLimits } from '@wasm-idle/core';
 const debugBreakpointBufferInts = 1028;
 const objectiveCAssetsKey = (assets) => createRuntimeAssetsKey({ objectivec: assets }) || '';
 class ObjectiveC {
@@ -28,6 +28,7 @@ class ObjectiveC {
     exit = true;
     assetBridge = null;
     activeObjectiveCAssetsKey = '';
+    runtimeAssetCache;
     workerSession = new WorkerSession({
         label: 'Objective-C',
         onDispose: (worker) => {
@@ -52,6 +53,14 @@ class ObjectiveC {
     constructor(language = 'OBJC') {
         this.language = language;
     }
+    setRuntimeAssetCache(cache) {
+        if (this.runtimeAssetCache === cache)
+            return;
+        if (this.worker) {
+            throw new RuntimeConfigurationError('Cannot replace an active Objective-C compiler cache');
+        }
+        this.runtimeAssetCache = cache;
+    }
     load(runtimeAssets = '', code = '', log = true, args = [], options = {}, progress) {
         let limits;
         try {
@@ -93,7 +102,7 @@ class ObjectiveC {
                 if (!this.workerSession.attach(worker, operation))
                     return;
                 this.worker = worker;
-                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', clangAssets, progress, limits.maxAssetBytes);
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', clangAssets, progress, limits.maxAssetBytes, false, this.runtimeAssetCache);
                 this.activeObjectiveCAssetsKey = nextObjectiveCAssetsKey;
                 this.worker.onmessage = (event) => {
                     if (!this.workerSession.isActive(operation))

package/dist/playground/options.d.ts

@@ -40,6 +40,8 @@ export interface SandboxExecutionOptions {
     workspaceFiles?: SandboxWorkspaceFile[];
     compileArgs?: string[];
     programArgs?: string[];
+    /** Requested environment overrides; a runtime may reject unsupported options. */
+    env?: Record<string, string>;
     cppVersion?: string;
     cVersion?: string;
     rustTargetTriple?: RustTargetTriple;

package/dist/playground/python.js

@@ -380,6 +380,14 @@ class Python {
             activePath = options.activePath;
             debugPath = options.debugPath;
             workspaceFiles = options.workspaceFiles;
+            if (this.workerLanguage === 'python') {
+                if (_args.length || options.programArgs?.length) {
+                    throw new RuntimeConfigurationError('Python does not support program arguments', { runtimeId: this.runtimeId });
+                }
+                if (options.env !== undefined) {
+                    throw new RuntimeConfigurationError('Python does not support environment overrides', { runtimeId: this.runtimeId });
+                }
+            }
             if (this.usesInterpreterStdio) {
                 limits = resolveExecutionLimits(options.limits);
                 if (_args.length || options.programArgs?.length) {

package/dist/playground/runtimeAssetCache.d.ts

@@ -1,32 +1 @@
-/** Immutable bootstrap assets only: never store a worker, Wasm instance, or user filesystem. */
-export declare class RuntimeAssetCache {
-    private readonly maxBytes;
-    private readonly maxEntries;
-    private entries;
-    private inFlight;
-    private inFlightKeyBytes;
-    private identities;
-    private nextIdentity;
-    private bytes;
-    private hits;
-    private misses;
-    private disposed;
-    constructor(maxBytes?: number, maxEntries?: number);
-    /** Identity is owner-local; a custom loader must never alias another loader. */
-    identity(value: object | undefined): number;
-    get<T>(key: string): T | undefined;
-    /** Only the trusted host publishes fully verified results; failures are never retained. */
-    set<T>(key: string, value: T, bytes: number): void;
-    /** Share work, but give every consumer its own cancellation and progress subscription. */
-    share<T, Progress = never>(key: string, signal: AbortSignal, start: (signal: AbortSignal, report: (progress: Progress, progressKey?: string) => void) => Promise<T>, onProgress?: (progress: Progress) => void): Promise<T>;
-    private removeOperation;
-    stats(): {
-        hits: number;
-        misses: number;
-        entries: number;
-        bytes: number;
-        inFlight: number;
-        disposed: boolean;
-    };
-    dispose(): void;
-}
+export { RuntimeAssetCache } from '@wasm-idle/core';