wasm-idle 0.7.2 → 1.0.0

package/dist/playground/bqnPreflight.js

@@ -0,0 +1,399 @@
+import { AssetIntegrityError, AssetTooLargeError, CancelledError, RuntimeConfigurationError, TimeoutError, UnsupportedBrowserFeatureError, isWasmIdleError, preflightRuntimeAssets, resolveExecutionLimits, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+export const BQN_PREFLIGHT_PROTOCOL = 'wasm-idle-bqn-preflight';
+export const BQN_PREFLIGHT_PROTOCOL_VERSION = 1;
+export const BQN_PREFLIGHT_RUNTIME_ID = 'BQN';
+const MAX_MANIFEST_BYTES = 64 * 1024;
+const VERIFIED_WASM_STORAGE_PATH = 'BQN.wasm.gz.bin';
+export async function preflightBqnRuntimeAssets(request) {
+    if (!request || typeof request !== 'object') {
+        throw new RuntimeConfigurationError('BQN runtime preflight request is required', {
+            phase: 'asset',
+            runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    let baseUrl;
+    let manifestUrl;
+    try {
+        baseUrl = new URL(request.baseUrl);
+        if (!baseUrl.pathname.endsWith('/'))
+            baseUrl.pathname += '/';
+        manifestUrl = new URL(request.manifestUrl, baseUrl);
+    }
+    catch (error) {
+        throw new RuntimeConfigurationError('BQN runtime asset URLs are invalid', {
+            cause: error,
+            phase: 'asset',
+            runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    if ((baseUrl.protocol !== 'https:' && baseUrl.protocol !== 'http:') ||
+        baseUrl.username ||
+        baseUrl.password ||
+        baseUrl.search ||
+        baseUrl.hash) {
+        throw new RuntimeConfigurationError('BQN runtime base must be a credential-free HTTP(S) directory URL without a query or fragment', { phase: 'asset', runtimeId: BQN_PREFLIGHT_RUNTIME_ID });
+    }
+    if ((manifestUrl.protocol !== 'https:' && manifestUrl.protocol !== 'http:') ||
+        manifestUrl.username ||
+        manifestUrl.password ||
+        manifestUrl.hash ||
+        manifestUrl.origin !== baseUrl.origin ||
+        !manifestUrl.pathname.startsWith(baseUrl.pathname)) {
+        throw new RuntimeConfigurationError('BQN runtime manifest must be an HTTP(S) asset beneath the configured runtime base', { phase: 'asset', runtimeId: BQN_PREFLIGHT_RUNTIME_ID });
+    }
+    const manifestPath = manifestUrl.pathname.slice(baseUrl.pathname.length);
+    if (!manifestPath ||
+        manifestPath.includes('\\') ||
+        manifestPath.includes('\0') ||
+        manifestPath.split('/').some((segment) => !segment || segment === '.' || segment === '..')) {
+        throw new RuntimeConfigurationError('BQN runtime manifest path must be a normalized file beneath the runtime base', { phase: 'asset', runtimeId: BQN_PREFLIGHT_RUNTIME_ID });
+    }
+    if (manifestPath === 'BQN.js' || manifestPath === VERIFIED_WASM_STORAGE_PATH) {
+        throw new RuntimeConfigurationError('BQN runtime manifest and executable asset paths must be distinct', { phase: 'asset', runtimeId: BQN_PREFLIGHT_RUNTIME_ID });
+    }
+    const profile = request.profile;
+    if (!profile ||
+        typeof profile !== 'object' ||
+        typeof profile.profileId !== 'string' ||
+        !/^dzaima-cbqn-[A-Za-z0-9._-]+$/u.test(profile.profileId) ||
+        typeof profile.sourceRevision !== 'string' ||
+        !/^[A-Za-z0-9:;._-]+$/u.test(profile.sourceRevision) ||
+        typeof profile.manifestFingerprint !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(profile.manifestFingerprint)) {
+        throw new RuntimeConfigurationError('BQN runtime preflight profile is invalid', {
+            phase: 'asset',
+            runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    for (const [label, receipt] of [
+        ['manifest', profile.manifestReceipt],
+        ['module', profile.moduleReceipt]
+    ]) {
+        if (!receipt ||
+            typeof receipt !== 'object' ||
+            !Number.isSafeInteger(receipt.bytes) ||
+            (receipt.bytes ?? 0) <= 0 ||
+            typeof receipt.sha256 !== 'string' ||
+            !/^[a-f0-9]{64}$/u.test(receipt.sha256)) {
+            throw new RuntimeConfigurationError(`BQN runtime ${label} preflight receipt is invalid`, {
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+            });
+        }
+    }
+    const wasmReceipt = profile.wasmReceipt;
+    if (!wasmReceipt ||
+        typeof wasmReceipt !== 'object' ||
+        !Number.isSafeInteger(wasmReceipt.bytes) ||
+        (wasmReceipt.bytes ?? 0) <= 0 ||
+        typeof wasmReceipt.sha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(wasmReceipt.sha256) ||
+        !Number.isSafeInteger(wasmReceipt.uncompressedBytes) ||
+        (wasmReceipt.uncompressedBytes ?? 0) <= 0 ||
+        typeof wasmReceipt.uncompressedSha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(wasmReceipt.uncompressedSha256)) {
+        throw new RuntimeConfigurationError('BQN runtime Wasm preflight receipt is invalid', {
+            phase: 'asset',
+            profileId: profile.profileId,
+            runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    const limits = resolveExecutionLimits(request.limits);
+    const oversized = [
+        [
+            'manifest',
+            profile.manifestReceipt.bytes,
+            Math.min(MAX_MANIFEST_BYTES, limits.maxAssetBytes)
+        ],
+        ['module', profile.moduleReceipt.bytes, limits.maxAssetBytes],
+        ['compressed Wasm', wasmReceipt.bytes, limits.maxAssetBytes],
+        ['logical Wasm', wasmReceipt.uncompressedBytes, limits.maxAssetBytes]
+    ];
+    for (const [label, bytes, limit] of oversized) {
+        if (bytes > limit) {
+            throw new AssetTooLargeError(`BQN runtime ${label} exceeds the ${limit} byte limit`, {
+                actual: bytes,
+                limit,
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+            });
+        }
+    }
+    if (typeof DecompressionStream !== 'function') {
+        throw new UnsupportedBrowserFeatureError('DecompressionStream(gzip)', {
+            phase: 'asset',
+            profileId: profile.profileId,
+            runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    const expectedManifestQuery = `?v=${profile.manifestFingerprint}`;
+    if (manifestUrl.search && manifestUrl.search !== expectedManifestQuery) {
+        throw new RuntimeConfigurationError('BQN runtime manifest query must be the pinned manifest fingerprint cache-buster', {
+            phase: 'asset',
+            profileId: profile.profileId,
+            runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    const manifestRequestUrl = new URL(manifestUrl);
+    if (!manifestRequestUrl.search) {
+        manifestRequestUrl.searchParams.set('v', profile.manifestFingerprint);
+    }
+    const moduleRequestUrl = new URL('BQN.js', baseUrl);
+    moduleRequestUrl.searchParams.set('v', profile.moduleReceipt.sha256);
+    const wasmRequestUrl = new URL(VERIFIED_WASM_STORAGE_PATH, baseUrl);
+    wasmRequestUrl.searchParams.set('v', wasmReceipt.sha256);
+    const registry = {
+        schemaVersion: 2,
+        manifestId: 'wasm-idle/bqn-preflight',
+        revision: profile.manifestFingerprint,
+        runtimes: [
+            {
+                runtimeId: BQN_PREFLIGHT_RUNTIME_ID,
+                identity: {
+                    languageId: 'BQN',
+                    implementationId: 'dzaima/CBQN',
+                    implementationVersion: profile.sourceRevision,
+                    profile: {
+                        profileId: profile.profileId,
+                        manifestSchemaVersion: 2,
+                        manifestSha256: profile.manifestReceipt.sha256,
+                        protocolVersion: BQN_PREFLIGHT_PROTOCOL_VERSION,
+                        trustProfileId: 'wasm-idle-static-worker-v1',
+                        trustProfileSchemaVersion: 1
+                    }
+                },
+                capabilities: {
+                    stdin: 'streaming',
+                    workspace: false,
+                    abort: true,
+                    artifacts: false,
+                    streamingOutput: true
+                },
+                workerLifetime: { mode: 'per-run' },
+                requiredBrowserFeatures: ['wasm', 'decompression-stream'],
+                assetRoot: '.',
+                assets: [
+                    {
+                        key: 'manifest',
+                        path: manifestPath,
+                        compressedSha256: profile.manifestReceipt.sha256,
+                        uncompressedSha256: profile.manifestReceipt.sha256,
+                        compressedBytes: profile.manifestReceipt.bytes,
+                        uncompressedBytes: profile.manifestReceipt.bytes,
+                        mediaType: 'application/json',
+                        encoding: 'identity'
+                    },
+                    {
+                        key: 'module',
+                        path: 'BQN.js',
+                        compressedSha256: profile.moduleReceipt.sha256,
+                        uncompressedSha256: profile.moduleReceipt.sha256,
+                        compressedBytes: profile.moduleReceipt.bytes,
+                        uncompressedBytes: profile.moduleReceipt.bytes,
+                        mediaType: 'text/javascript',
+                        encoding: 'identity'
+                    },
+                    {
+                        key: 'wasm',
+                        path: VERIFIED_WASM_STORAGE_PATH,
+                        compressedSha256: wasmReceipt.sha256,
+                        uncompressedSha256: wasmReceipt.uncompressedSha256,
+                        compressedBytes: wasmReceipt.bytes,
+                        uncompressedBytes: wasmReceipt.uncompressedBytes,
+                        mediaType: 'application/wasm',
+                        encoding: 'gzip'
+                    }
+                ],
+                contracts: {
+                    routeId: 'bqn',
+                    runtimeAssetKey: 'bqn',
+                    documentationId: 'BQN',
+                    syncTarget: 'sync:wasm-bqn',
+                    browserTestId: 'browser:bqn'
+                }
+            }
+        ]
+    };
+    const controller = new AbortController();
+    let timedOut = false;
+    const abortFromCaller = () => controller.abort(request.signal?.reason);
+    request.signal?.addEventListener('abort', abortFromCaller, { once: true });
+    if (request.signal?.aborted)
+        abortFromCaller();
+    const timeout = setTimeout(() => {
+        timedOut = true;
+        controller.abort(new DOMException('BQN runtime preflight timed out', 'TimeoutError'));
+    }, limits.assetTimeoutMs);
+    try {
+        const preflight = await preflightRuntimeAssets({
+            manifest: registry,
+            runtimeId: BQN_PREFLIGHT_RUNTIME_ID,
+            rootUrl: baseUrl,
+            assetUrls: {
+                manifest: manifestRequestUrl,
+                module: moduleRequestUrl,
+                wasm: wasmRequestUrl
+            },
+            fetch: request.fetch,
+            signal: controller.signal,
+            limits,
+            maxConcurrentDownloads: 3,
+            reportProgress: request.reportProgress
+        });
+        const manifestAsset = preflight.assets.manifest;
+        const moduleAsset = preflight.assets.module;
+        const wasmAsset = preflight.assets.wasm;
+        if (!manifestAsset || !moduleAsset || !wasmAsset) {
+            throw new RuntimeConfigurationError('BQN runtime preflight returned an incomplete asset set', {
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        if (wasmAsset.bytes[0] !== 0x1f || wasmAsset.bytes[1] !== 0x8b) {
+            throw new AssetIntegrityError('BQN runtime Wasm storage asset is not gzip data', {
+                profileId: profile.profileId,
+                runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        const compressedBody = new Response(Uint8Array.from(wasmAsset.bytes)).body;
+        if (!compressedBody) {
+            throw new UnsupportedBrowserFeatureError('ReadableStream response bodies', {
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        const stream = compressedBody.pipeThrough(new DecompressionStream('gzip'));
+        const reader = stream.getReader();
+        const wasmBytes = new Uint8Array(wasmReceipt.uncompressedBytes);
+        let offset = 0;
+        const cancelDecompression = () => {
+            try {
+                void reader.cancel(controller.signal.reason).catch(() => undefined);
+            }
+            catch {
+                // Preserve the cancellation or integrity failure that stopped decompression.
+            }
+        };
+        controller.signal.addEventListener('abort', cancelDecompression, { once: true });
+        try {
+            for (;;) {
+                if (controller.signal.aborted)
+                    throw controller.signal.reason;
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (offset + value.byteLength > wasmBytes.byteLength) {
+                    const error = new AssetIntegrityError('BQN runtime Wasm gzip output exceeds its logical receipt', { profileId: profile.profileId, runtimeId: BQN_PREFLIGHT_RUNTIME_ID });
+                    try {
+                        await reader.cancel(error);
+                    }
+                    catch {
+                        // Preserve the expansion-limit failure.
+                    }
+                    throw error;
+                }
+                wasmBytes.set(value, offset);
+                offset += value.byteLength;
+                request.reportDecompressionProgress?.(offset, wasmBytes.byteLength);
+            }
+        }
+        catch (error) {
+            if (controller.signal.aborted || isWasmIdleError(error))
+                throw error;
+            throw new AssetIntegrityError('BQN runtime Wasm gzip decompression failed', {
+                cause: error,
+                profileId: profile.profileId,
+                runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        finally {
+            controller.signal.removeEventListener('abort', cancelDecompression);
+            try {
+                reader.releaseLock();
+            }
+            catch {
+                // Cancellation may already have detached the stream reader.
+            }
+        }
+        if (offset !== wasmBytes.byteLength) {
+            throw new AssetIntegrityError('BQN runtime Wasm gzip output is shorter than its logical receipt', {
+                profileId: profile.profileId,
+                runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        const logicalIntegrity = verifyRuntimeAssetIntegrity({
+            asset: 'BQN.wasm',
+            bytes: wasmBytes,
+            expected: wasmReceipt,
+            stage: 'uncompressed',
+            mimeType: 'application/wasm',
+            profileId: profile.profileId,
+            runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+        });
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const rejectOnAbort = () => {
+                if (settled)
+                    return;
+                settled = true;
+                controller.signal.removeEventListener('abort', rejectOnAbort);
+                reject(controller.signal.reason ??
+                    new DOMException('BQN runtime integrity verification aborted', 'AbortError'));
+            };
+            controller.signal.addEventListener('abort', rejectOnAbort, { once: true });
+            void logicalIntegrity.then(() => {
+                if (settled)
+                    return;
+                settled = true;
+                controller.signal.removeEventListener('abort', rejectOnAbort);
+                resolve();
+            }, (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                controller.signal.removeEventListener('abort', rejectOnAbort);
+                reject(error);
+            });
+            if (controller.signal.aborted)
+                rejectOnAbort();
+        });
+        return Object.freeze({
+            protocol: BQN_PREFLIGHT_PROTOCOL,
+            protocolVersion: BQN_PREFLIGHT_PROTOCOL_VERSION,
+            profileId: profile.profileId,
+            sourceRevision: profile.sourceRevision,
+            manifestFingerprint: profile.manifestFingerprint,
+            manifestBytes: Uint8Array.from(manifestAsset.bytes),
+            moduleBytes: Uint8Array.from(moduleAsset.bytes),
+            wasmBytes
+        });
+    }
+    catch (error) {
+        if (timedOut) {
+            throw new TimeoutError(`BQN runtime preflight timed out after ${limits.assetTimeoutMs} ms`, {
+                cause: error,
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: BQN_PREFLIGHT_RUNTIME_ID,
+                timeoutMs: limits.assetTimeoutMs
+            });
+        }
+        if (request.signal?.aborted) {
+            throw new CancelledError('BQN runtime preflight cancelled', {
+                cause: request.signal.reason,
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: BQN_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+        request.signal?.removeEventListener('abort', abortFromCaller);
+    }
+}

package/dist/playground/c3.d.ts

@@ -0,0 +1,15 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+export declare const C3_DEFAULT_WASM_MEMORY_BYTES: number;
+/** Real c3c + builtin LLD; guest I/O is the documented env byte ABI. */
+declare class C3 extends StaticWorkerRuntimeSandbox {
+    readonly defaultExecutionLimits: Readonly<{
+        maxWasmMemoryBytes: number;
+    }>;
+    readonly memoryEvidence: {
+        current: unknown;
+    };
+    constructor();
+    load(...args: Parameters<StaticWorkerRuntimeSandbox['load']>): Promise<void>;
+    run(...args: Parameters<StaticWorkerRuntimeSandbox['run']>): Promise<string | boolean>;
+}
+export default C3;

package/dist/playground/c3.js

@@ -0,0 +1,154 @@
+import { resolveC3BaseUrl } from './assets';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { bundledC3Profile as profile, bundledC3WorkerReceipt } from './wasmC3Version';
+import { preflightRuntimeAssets, RuntimeConfigurationError } from '@wasm-idle/core';
+export const C3_DEFAULT_WASM_MEMORY_BYTES = 1024 ** 3;
+function c3ExecutionOptions(options = {}) {
+    if (options.compileArgs?.length)
+        throw new RuntimeConfigurationError('C3 uses fixed wasm32 compiler flags; compileArgs are unsupported.', { runtimeId: 'C3' });
+    return {
+        ...options,
+        limits: {
+            ...options.limits,
+            maxWasmMemoryBytes: options.limits?.maxWasmMemoryBytes ?? C3_DEFAULT_WASM_MEMORY_BYTES
+        }
+    };
+}
+const registry = {
+    schemaVersion: 2,
+    manifestId: 'wasm-idle/c3-preflight',
+    revision: profile.producerReceipt.sha256,
+    runtimes: [
+        {
+            runtimeId: 'C3',
+            identity: {
+                languageId: 'C3',
+                implementationId: 'c3c',
+                implementationVersion: '0.8.3',
+                profile: {
+                    profileId: profile.profileId,
+                    manifestSchemaVersion: 1,
+                    manifestSha256: profile.producerReceipt.sha256,
+                    protocolVersion: 1,
+                    trustProfileId: 'wasm-idle-static-worker-v1',
+                    trustProfileSchemaVersion: 1
+                }
+            },
+            capabilities: {
+                stdin: 'streaming',
+                workspace: true,
+                abort: true,
+                artifacts: false,
+                streamingOutput: true
+            },
+            workerLifetime: { mode: 'per-run' },
+            requiredBrowserFeatures: ['wasm'],
+            assetRoot: '.',
+            assets: [
+                [
+                    'compilerJavaScriptBytes',
+                    'c3c.mjs',
+                    'text/javascript',
+                    profile.compilerJavaScriptReceipt
+                ],
+                ['compilerWasmBytes', 'c3c.wasm', 'application/wasm', profile.compilerWasmReceipt],
+                [
+                    'producerReceiptBytes',
+                    'producer-receipt.json',
+                    'application/json',
+                    profile.producerReceipt
+                ]
+            ].map(([key, path, mediaType, receipt]) => {
+                const integrity = receipt;
+                return {
+                    key: key,
+                    path: path,
+                    mediaType: mediaType,
+                    compressedSha256: integrity.sha256,
+                    uncompressedSha256: integrity.sha256,
+                    compressedBytes: integrity.bytes,
+                    uncompressedBytes: integrity.bytes,
+                    encoding: 'identity'
+                };
+            }),
+            contracts: {
+                routeId: 'c3',
+                runtimeAssetKey: 'c3',
+                documentationId: 'C3',
+                syncTarget: 'sync:wasm-c3',
+                browserTestId: 'browser:c3'
+            }
+        }
+    ]
+};
+/** Real c3c + builtin LLD; guest I/O is the documented env byte ABI. */
+class C3 extends StaticWorkerRuntimeSandbox {
+    defaultExecutionLimits = Object.freeze({
+        maxWasmMemoryBytes: C3_DEFAULT_WASM_MEMORY_BYTES
+    });
+    memoryEvidence;
+    constructor() {
+        const memoryEvidence = { current: undefined };
+        super({
+            displayName: 'C3',
+            languageId: 'C3',
+            defaultActivePath: 'main.c3',
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            stdin: { mode: 'streaming', sourceHintPattern: /\breadByte\b/u },
+            inlineVerifiedWorker: true,
+            moduleWorker: true,
+            includeExecutionLimits: true,
+            enforcePhaseTimeouts: true,
+            onEvidence(evidence) {
+                memoryEvidence.current = evidence;
+            },
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const baseUrl = resolveC3BaseUrl(runtimeAssets, currentUrl);
+                return {
+                    baseUrl,
+                    workerUrl: new URL('runner-worker.js', baseUrl).href,
+                    manifestUrl: new URL('producer-receipt.json', baseUrl).href,
+                    manifestFingerprint: profile.producerReceipt.sha256,
+                    preflightKey: profile.producerReceipt.sha256,
+                    workerReceipt: bundledC3WorkerReceipt
+                };
+            },
+            async preflightRuntimeAssets(urls, context) {
+                memoryEvidence.current = undefined;
+                const result = await preflightRuntimeAssets({
+                    manifest: registry,
+                    runtimeId: 'C3',
+                    rootUrl: urls.baseUrl,
+                    limits: context.limits,
+                    signal: context.signal,
+                    redirect: 'error',
+                    requireExactResponseUrl: true,
+                    maxTotalDeliveryBytes: profile.compilerJavaScriptReceipt.bytes +
+                        profile.compilerWasmReceipt.bytes +
+                        profile.producerReceipt.bytes,
+                    reportProgress(progress) {
+                        context.reportProgress(0.1, `Preflighting C3 ${progress.assetKey}`);
+                    }
+                });
+                return context.createOwnedDelivery(Object.freeze({
+                    protocol: 'wasm-idle-c3-preflight',
+                    profileId: profile.profileId,
+                    compilerJavaScriptBytes: result.assets.compilerJavaScriptBytes.bytes,
+                    compilerWasmBytes: result.assets.compilerWasmBytes.bytes,
+                    producerReceiptBytes: result.assets.producerReceiptBytes.bytes
+                }));
+            }
+        });
+        this.memoryEvidence = memoryEvidence;
+    }
+    async load(...args) {
+        args[4] = c3ExecutionOptions(args[4]);
+        return super.load(...args);
+    }
+    async run(...args) {
+        args[5] = c3ExecutionOptions(args[5]);
+        return super.run(...args);
+    }
+}
+export default C3;

package/dist/playground/clang.d.ts

@@ -1,19 +1,19 @@
-import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { DebugCommand, DebugDataBreakpoint, DebugDataBreakpointInfoArguments, DebugSessionEvent, SandboxExecutionOptions } from './options';
 import { WorkerAssetBridge } from './assetBridge';
-import { type PlaygroundRuntimeAssets } from './assets';
+import { type PlaygroundRuntimeAssets, type RuntimeAssetIntegrityEntry } from './assets';
 import type { Sandbox } from './sandbox';
-import type { Writable } from 'svelte/store';
+import { type ProgressSink } from './workerProgress';
 declare class Clang implements Sandbox {
     language: 'C' | 'CPP';
     ts: number;
     output: any;
     ondebug?: (event: DebugSessionEvent) => void;
     worker?: Worker;
-    buffer: SharedArrayBuffer;
-    debugBuffer: SharedArrayBuffer;
-    watchBuffer: SharedArrayBuffer;
-    watchResultBuffer: SharedArrayBuffer;
-    interruptBuffer: SharedArrayBuffer;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    debugBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    watchBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    watchResultBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    interruptBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
     pendingInput: string[];
     begin: number;
     elapse: number;
@@ -23,22 +23,38 @@ declare class Clang implements Sandbox {
     pendingEof: boolean;
     exit: boolean;
     assetBridge: WorkerAssetBridge | null;
-    activeReject: ((reason?: string) => void) | null;
+    debugRuntimeBaseUrl: string;
+    debugManifestUrl: string;
+    debugManifestReceipt?: Readonly<RuntimeAssetIntegrityEntry>;
+    private lldbSession?;
+    private debugMode;
+    private readonly lldbBreakpoints;
+    private debugEvaluationQueue;
+    private readonly workerSession;
+    private disposeWorkerAssetBridge;
     constructor(language: 'C' | 'CPP');
-    load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions, progress?: {
-        set?: (value: number) => void;
-    } | import('svelte/store').Writable<number>): Promise<void>;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: ProgressSink): Promise<void>;
     write(input: string): void;
     eof(): void;
     private flushPendingInput;
-    run(code: string, prepare: boolean, log?: boolean, prog?: Writable<number> | {
-        set?: (value: number) => void;
-    }, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
-    debugCommand(command: DebugCommand): void;
-    setBreakpoints(lines: number[]): void;
+    run(code: string, prepare: boolean, log?: boolean, prog?: ProgressSink, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    debugCommand(command: DebugCommand): Promise<void> | undefined;
+    debugPause(): Promise<void> | undefined;
+    setBreakpoints(lines: number[], sourcePath?: string): Promise<void> | undefined;
     debugEvaluate(expression: string): Promise<string>;
-    kill(): void;
-    terminate(): void;
+    debugVariables(variablesReference: number, start?: number, count?: number): Promise<import("@wasm-idle/core").DebugVariable[]>;
+    debugScopes(frameId: number): Promise<import("@wasm-idle/core").DebugScope[]>;
+    debugFrameScopes(frameId: number): Promise<import("@wasm-idle/core").DebugScope[]>;
+    debugFrameName(frameId: number): Promise<string | null>;
+    debugReadMemory(memoryReference: string, offset: number, count: number): Promise<import("@wasm-idle/core").DebugMemory | null>;
+    debugWriteMemory(memoryReference: string, offset: number, data: Uint8Array, allowPartial?: boolean): Promise<{
+        offset?: number;
+        bytesWritten: number;
+    } | null>;
+    debugDataBreakpointInfo(arguments_: DebugDataBreakpointInfoArguments): Promise<import("@wasm-idle/core").DebugDataBreakpointInfo | null>;
+    debugSetDataBreakpoints(breakpoints: DebugDataBreakpoint[]): Promise<import("@wasm-idle/core").DebugResolvedDataBreakpoint[]>;
+    kill(): Promise<void>;
+    terminate(): Promise<void>;
     clear(): Promise<void>;
 }
 export default Clang;