wasm-idle 0.7.2 → 1.0.0

package/dist/playground/lispAssets.js

@@ -0,0 +1,74 @@
+import { loadVerifiedLispRuntime } from '@wasm-idle/core';
+import { fetchRuntimeAssetBytes, resolveRuntimeAssetUrl } from './worker/runtimeAssetFetch';
+const MAX_LISP_MANIFEST_BYTES = 1024 * 1024;
+const DEFAULT_MAX_LISP_ASSET_BYTES = 128 * 1024 * 1024;
+const decoder = new TextDecoder('utf-8', { fatal: true });
+function resolveMaxAssetBytes(value) {
+    const resolved = value ?? DEFAULT_MAX_LISP_ASSET_BYTES;
+    if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+        throw new TypeError('Lisp runtime maxAssetBytes must be a positive safe integer');
+    }
+    return resolved;
+}
+function assertManifestAssetLimits(value, maxAssetBytes) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return;
+    const manifest = value;
+    const assets = Array.isArray(manifest.assets) ? manifest.assets : [];
+    const storage = Array.isArray(manifest.storage) ? manifest.storage : [];
+    for (const asset of [...assets, ...storage]) {
+        if (Number.isSafeInteger(asset?.size) && asset.size > maxAssetBytes) {
+            throw new Error(`Lisp runtime asset ${String(asset.path || 'unknown')} exceeds the ${maxAssetBytes} byte limit`);
+        }
+    }
+}
+function requireLispRuntimeConfig(config) {
+    if (!config.moduleUrl || !config.manifestUrl) {
+        throw new TypeError('Lisp runtime requires moduleUrl and manifestUrl from one published runtime profile');
+    }
+    if (!/^[a-f0-9]{64}$/u.test(config.manifestFingerprint)) {
+        throw new TypeError('Lisp runtime requires an explicit 64-character manifestFingerprint trust anchor');
+    }
+    return {
+        moduleUrl: resolveRuntimeAssetUrl(config.moduleUrl, 'Lisp runtime module'),
+        manifestUrl: resolveRuntimeAssetUrl(config.manifestUrl, 'Lisp runtime manifest')
+    };
+}
+export async function loadVerifiedLispRuntimeAssets(config, options = {}) {
+    const { moduleUrl, manifestUrl } = requireLispRuntimeConfig(config);
+    const maxAssetBytes = resolveMaxAssetBytes(options.maxAssetBytes);
+    const manifestBytes = await fetchRuntimeAssetBytes({
+        url: manifestUrl.href,
+        label: 'Lisp runtime manifest',
+        cache: 'no-cache',
+        maxAssetBytes: Math.min(MAX_LISP_MANIFEST_BYTES, maxAssetBytes),
+        signal: options.signal
+    });
+    let manifest;
+    try {
+        manifest = JSON.parse(decoder.decode(manifestBytes));
+    }
+    catch (error) {
+        throw new TypeError(`Lisp runtime manifest is not valid UTF-8 JSON: ${error instanceof Error ? error.message : error}`);
+    }
+    assertManifestAssetLimits(manifest, maxAssetBytes);
+    const assetBaseUrl = new URL('./', moduleUrl);
+    return await loadVerifiedLispRuntime({
+        manifest,
+        expectedFingerprint: config.manifestFingerprint,
+        loadStorageAsset: async (asset, signal, logicalAsset) => {
+            const assetUrl = new URL(asset.path, assetBaseUrl);
+            assetUrl.search = moduleUrl.search || manifestUrl.search;
+            return await fetchRuntimeAssetBytes({
+                url: assetUrl.href,
+                label: `Lisp runtime asset ${asset.logicalPath}`,
+                cache: 'force-cache',
+                maxAssetBytes: Math.min(maxAssetBytes, Math.max(asset.size, logicalAsset.size)),
+                signal
+            });
+        },
+        signal: options.signal,
+        moduleEnvironment: options.moduleEnvironment,
+        decompressGzip: options.decompressGzip
+    });
+}

package/dist/playground/lldbManifest.d.ts

@@ -0,0 +1,3 @@
+import { type RuntimeAssetIntegrityEntry } from '@wasm-idle/core';
+import { type RuntimeManifestV2 } from '@wasm-idle/llvm-core/debug';
+export declare function loadVerifiedDebugRuntimeManifest(url: string, expected: Readonly<RuntimeAssetIntegrityEntry> | undefined, fetchImpl: typeof fetch, signal?: AbortSignal): Promise<RuntimeManifestV2>;

package/dist/playground/lldbManifest.js

@@ -0,0 +1,155 @@
+import { AssetIntegrityError, AssetTooLargeError, RuntimeConfigurationError, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { parseDebugRuntimeManifest } from '@wasm-idle/llvm-core/debug';
+const MAX_DEBUG_MANIFEST_BYTES = 64 * 1024;
+function abortReason(signal) {
+    return signal.reason ?? new DOMException('The operation was aborted', 'AbortError');
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortReason(signal);
+}
+async function cancelResponseBody(response, reason) {
+    try {
+        await response.body?.cancel(reason);
+    }
+    catch {
+        // Preserve the validation or lifecycle failure that initiated cancellation.
+    }
+}
+export async function loadVerifiedDebugRuntimeManifest(url, expected, fetchImpl, signal) {
+    if (!expected || !/^[a-f0-9]{64}$/u.test(expected.sha256)) {
+        throw new RuntimeConfigurationError('LLDB runtime requires an expected manifest SHA-256 receipt.');
+    }
+    if (expected.bytes !== undefined &&
+        (!Number.isSafeInteger(expected.bytes) || expected.bytes < 0)) {
+        throw new RuntimeConfigurationError('LLDB runtime manifest receipt has an invalid byte size.');
+    }
+    if (expected.bytes !== undefined && expected.bytes > MAX_DEBUG_MANIFEST_BYTES) {
+        throw new AssetTooLargeError(`LLDB runtime manifest receipt exceeds ${MAX_DEBUG_MANIFEST_BYTES} bytes.`, {
+            limit: MAX_DEBUG_MANIFEST_BYTES,
+            actual: expected.bytes,
+            runtimeId: 'wasm-debug',
+            profileId: 'lldb-v2'
+        });
+    }
+    const receipt = Object.freeze({
+        sha256: expected.sha256,
+        ...(expected.bytes === undefined ? {} : { bytes: expected.bytes })
+    });
+    throwIfAborted(signal);
+    const response = await fetchImpl(url, { cache: 'no-store', signal });
+    if (!response.ok) {
+        const error = new Error(`Unable to load the LLDB runtime manifest (${response.status}).`);
+        await cancelResponseBody(response, error);
+        throw error;
+    }
+    if (signal?.aborted) {
+        const error = abortReason(signal);
+        await cancelResponseBody(response, error);
+        throw error;
+    }
+    const contentLengthHeader = response.headers.get('content-length');
+    if (contentLengthHeader !== null) {
+        if (!/^\d+$/u.test(contentLengthHeader)) {
+            const error = new AssetIntegrityError('LLDB runtime manifest returned an invalid Content-Length.', { runtimeId: 'wasm-debug', profileId: 'lldb-v2' });
+            await cancelResponseBody(response, error);
+            throw error;
+        }
+        const declaredBytes = Number(contentLengthHeader);
+        if (!Number.isSafeInteger(declaredBytes)) {
+            const error = new AssetIntegrityError('LLDB runtime manifest returned an invalid Content-Length.', { runtimeId: 'wasm-debug', profileId: 'lldb-v2' });
+            await cancelResponseBody(response, error);
+            throw error;
+        }
+        if (declaredBytes > MAX_DEBUG_MANIFEST_BYTES) {
+            const error = new AssetTooLargeError(`LLDB runtime manifest exceeds ${MAX_DEBUG_MANIFEST_BYTES} bytes.`, {
+                limit: MAX_DEBUG_MANIFEST_BYTES,
+                actual: declaredBytes,
+                runtimeId: 'wasm-debug',
+                profileId: 'lldb-v2'
+            });
+            await cancelResponseBody(response, error);
+            throw error;
+        }
+    }
+    if (!response.body) {
+        throw new AssetIntegrityError('LLDB runtime manifest response body is unavailable.', {
+            runtimeId: 'wasm-debug',
+            profileId: 'lldb-v2'
+        });
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let receivedBytes = 0;
+    let readerFinished = false;
+    let readerCancelled = false;
+    const cancelOnAbort = () => {
+        readerCancelled = true;
+        void reader.cancel(abortReason(signal)).catch(() => undefined);
+    };
+    signal?.addEventListener('abort', cancelOnAbort, { once: true });
+    try {
+        while (true) {
+            throwIfAborted(signal);
+            const { done, value } = await reader.read();
+            throwIfAborted(signal);
+            if (done) {
+                readerFinished = true;
+                break;
+            }
+            if (!ArrayBuffer.isView(value) ||
+                Object.prototype.toString.call(value) !== '[object Uint8Array]') {
+                throw new AssetIntegrityError('LLDB runtime manifest stream returned a non-byte chunk.', { runtimeId: 'wasm-debug', profileId: 'lldb-v2' });
+            }
+            const nextBytes = receivedBytes + value.byteLength;
+            if (nextBytes > MAX_DEBUG_MANIFEST_BYTES) {
+                const error = new AssetTooLargeError(`LLDB runtime manifest exceeds ${MAX_DEBUG_MANIFEST_BYTES} bytes.`, {
+                    limit: MAX_DEBUG_MANIFEST_BYTES,
+                    actual: nextBytes,
+                    runtimeId: 'wasm-debug',
+                    profileId: 'lldb-v2'
+                });
+                readerCancelled = true;
+                try {
+                    await reader.cancel(error);
+                }
+                catch {
+                    // Preserve the size-limit failure that initiated cancellation.
+                }
+                throw error;
+            }
+            chunks.push(Uint8Array.from(value));
+            receivedBytes = nextBytes;
+        }
+    }
+    catch (error) {
+        if (!readerFinished && !readerCancelled) {
+            try {
+                readerCancelled = true;
+                await reader.cancel(error);
+            }
+            catch {
+                // Preserve the read or validation failure that initiated cancellation.
+            }
+        }
+        throw error;
+    }
+    finally {
+        signal?.removeEventListener('abort', cancelOnAbort);
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(receivedBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    await verifyRuntimeAssetIntegrity({
+        asset: 'runtime-manifest.v2.json',
+        bytes,
+        expected: receipt,
+        runtimeId: 'wasm-debug',
+        profileId: 'lldb-v2'
+    });
+    return parseDebugRuntimeManifest(JSON.parse(new TextDecoder().decode(bytes)));
+}

package/dist/playground/lldbSession.d.ts

@@ -0,0 +1,115 @@
+import type { DebugCommand, DebugDataBreakpoint, DebugDataBreakpointInfo, DebugDataBreakpointInfoArguments, DebugMemory, DebugScope, DebugSessionEvent, DebugResolvedDataBreakpoint, DebugVariable } from './options';
+import { type RuntimeAssetIntegrityEntry } from '@wasm-idle/core';
+export interface LldbArtifactPayload {
+    bytes: Uint8Array | ArrayBuffer;
+    descriptor?: {
+        moduleSha256?: string;
+        compiler?: {
+            name?: string;
+            version?: string;
+            revision?: string;
+            llvmVersion?: string;
+            llvmRevision?: string;
+        };
+    };
+    sources: Array<{
+        path: `/workspace/${string}`;
+        content: string;
+        contentSha256?: string;
+    }>;
+}
+export interface LldbSandboxSessionOptions {
+    manifestUrl: string;
+    manifestReceipt?: Readonly<RuntimeAssetIntegrityEntry>;
+    runtimeBaseUrl: string;
+    artifact: LldbArtifactPayload;
+    sourcePath: `/workspace/${string}`;
+    breakpoints: number[];
+    sourceBreakpoints?: Array<{
+        sourcePath: `/workspace/${string}`;
+        lines: number[];
+    }>;
+    pauseOnEntry: boolean;
+    /** C/C++ source entry; the low-level runtime still stops safely before _start executes. */
+    pauseAtMain?: boolean;
+    programArgs?: string[];
+    stdin?: string;
+    onDebugEvent: (event: DebugSessionEvent) => void;
+    onOutput: (output: string) => void;
+    fetchImpl?: typeof fetch;
+}
+export declare class LldbSandboxSession {
+    private readonly options;
+    private session?;
+    private startupAbortController?;
+    private activeThreadId;
+    private activeFrameId?;
+    private stoppedFrames;
+    private supportsValueFormatting;
+    private command;
+    private pauseRequested;
+    private pauseRequestVersion;
+    private targetStopped;
+    private entryPhase;
+    private entrySetup?;
+    private stopped;
+    private stateVersion;
+    private completionResolve?;
+    private completionReject?;
+    private sessionDisposal?;
+    private readonly pendingInput;
+    private pendingEof;
+    private inputReady;
+    private lifecycleVersion;
+    private initialized;
+    private supportsEvaluateExpressions;
+    private supportsReadMemory;
+    private supportsWriteMemory;
+    private supportsDataBreakpoints;
+    private breakpointVersion;
+    private scopeRequestVersion;
+    private dapExitCode;
+    private readonly breakpointsBySource;
+    private readonly breakpointRequestVersions;
+    private readonly sourceContentSha256ByPath;
+    constructor(options: LldbSandboxSessionOptions);
+    start(): Promise<true>;
+    write(input: string): Promise<void>;
+    eof(): Promise<void>;
+    debugCommand(command: DebugCommand): Promise<void>;
+    pause(): Promise<void>;
+    setBreakpoints(lines: number[], sourcePath?: `/workspace/${string}`): Promise<void>;
+    evaluate(expression: string): Promise<string>;
+    variables(variablesReference: number, start?: number, count?: number): Promise<DebugVariable[]>;
+    /** Ask the adapter to format one stopped frame, without changing evaluation selection. */
+    formattedFrameName(frameId: number): Promise<string | null>;
+    /** Scope metadata lookup does not select a frame or retire other value requests. */
+    frameScopes(frameId: number): Promise<DebugScope[]>;
+    /** Select the evaluation frame, keeping the existing public debugScopes contract. */
+    scopes(frameId: number): Promise<DebugScope[]>;
+    readMemory(memoryReference: string, offset: number, count: number): Promise<DebugMemory | null>;
+    writeMemory(memoryReference: string, offset: number, data: Uint8Array, allowPartial?: boolean): Promise<{
+        offset?: number;
+        bytesWritten: number;
+    } | null>;
+    dataBreakpointInfo(arguments_: DebugDataBreakpointInfoArguments): Promise<DebugDataBreakpointInfo | null>;
+    setDataBreakpoints(breakpoints: DebugDataBreakpoint[]): Promise<DebugResolvedDataBreakpoint[]>;
+    disconnect(): Promise<void>;
+    private handleDapEvent;
+    private resolveStoppedState;
+    private setMainEntryBreakpoint;
+    private requestScopes;
+    private isCurrentValueRequest;
+    private rethrowProtocolError;
+    private asProtocolError;
+    private finish;
+    private fail;
+    private publishStop;
+    private publishActiveDebugEvent;
+    private trackSessionDisposal;
+    private requireSession;
+    private publishResolvedBreakpoints;
+    private observeInputFlush;
+    private retireInput;
+    private flushInput;
+}