wasm-idle 0.7.2 → 1.0.0

package/dist/playground/staticWorkerRuntime.d.ts

@@ -0,0 +1,154 @@
+import type { PlaygroundRuntimeAssets } from './assets';
+import { type ExecutionLimits, type RuntimeAssetIntegrityEntry, type RuntimeStdinMode, type RuntimeWorkerLifetimePolicy } from '@wasm-idle/core';
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
+type StaticWorkerReceipt = Readonly<Required<Pick<RuntimeAssetIntegrityEntry, 'bytes' | 'sha256'>>>;
+export interface StaticWorkerRuntimeUrls {
+    baseUrl: string;
+    workerUrl: string;
+    manifestUrl?: string;
+    manifestFingerprint?: string;
+    preflightKey?: string;
+    preflightProfile?: unknown;
+    workerReceipt?: StaticWorkerReceipt;
+}
+export interface StaticWorkerRuntimePreflightContext {
+    readonly limits: ExecutionLimits;
+    readonly signal?: AbortSignal;
+    readonly reportProgress: (value: number, stage?: string) => void;
+    /**
+     * Relinquishes a verified payload to this one worker-start operation.
+     *
+     * The frozen payload must be a plain object whose binary fields are non-empty Uint8Arrays
+     * spanning distinct, exclusively owned ArrayBuffers. Every top-level Uint8Array is adopted;
+     * callers cannot select or omit transferables. The returned ticket is opaque, operation-bound,
+     * and may be returned only from this preflight callback.
+     */
+    readonly createOwnedDelivery: (payload: unknown) => StaticWorkerRuntimeOwnedDelivery;
+}
+declare const staticWorkerRuntimeOwnedDeliveryBrand: unique symbol;
+export interface StaticWorkerRuntimeOwnedDelivery {
+    readonly [staticWorkerRuntimeOwnedDeliveryBrand]: true;
+}
+export type StaticWorkerRuntimeStdin = {
+    readonly mode: 'none';
+} | {
+    readonly mode: 'prebuffered';
+    readonly sourceHintPattern: RegExp;
+} | {
+    readonly mode: 'streaming';
+    readonly sourceHintPattern: RegExp;
+};
+export interface StaticWorkerRuntimeConfig {
+    languageId: string;
+    displayName: string;
+    defaultActivePath: string;
+    inlineVerifiedWorker?: boolean;
+    requireExactWorkerResponseUrl?: boolean;
+    moduleWorker?: boolean;
+    /** Opt in only when the worker enforces the resolved limits and reports execution-ready. */
+    includeExecutionLimits?: boolean;
+    enforcePhaseTimeouts?: boolean;
+    onEvidence?: (evidence: unknown) => void;
+    stdin: StaticWorkerRuntimeStdin;
+    workerLifetime?: RuntimeWorkerLifetimePolicy;
+    resolveRuntimeAssets: (runtimeAssets: string | PlaygroundRuntimeAssets, currentUrl: string) => StaticWorkerRuntimeUrls;
+    preflightRuntimeAssets?: (urls: StaticWorkerRuntimeUrls, context: StaticWorkerRuntimePreflightContext) => unknown | Promise<unknown>;
+    runtimePreflightDelivery?: 'structured-clone' | 'transfer-owned' | 'transfer-owned-worker-cache';
+}
+type StdinWaiter = {
+    reject: (reason: unknown) => void;
+    resolve: () => void;
+};
+export declare class StaticWorkerRuntimeSandbox implements Sandbox {
+    private readonly config;
+    output: any;
+    worker?: Worker;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    baseUrl: string;
+    workerUrl: string;
+    manifestUrl: string;
+    manifestFingerprint: string;
+    preflightKey: string;
+    workerReceipt: StaticWorkerReceipt | null;
+    activeReject: ((reason: unknown) => void) | null;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    pendingEof: boolean;
+    stdinWaiters: StdinWaiter[];
+    private activeRun;
+    private bootstrapUrl;
+    private disposed;
+    private disposePromise;
+    private disposeReason;
+    private lifecycleProgress?;
+    private readonly progressController;
+    private progressUid;
+    private startingRunId;
+    private startupReject;
+    private workerLease;
+    private readonly workerLifetimeController;
+    private workerStartAbortController;
+    private workerGeneration;
+    private workerStartPromise;
+    private resolvedRuntimeUrls;
+    private readonly workerRuntimePreflight;
+    private readonly workerRuntimePreflightMaxAssetBytes;
+    private readonly workersWithCachedRuntimePreflight;
+    private workerStartMaxAssetBytes;
+    constructor(config: StaticWorkerRuntimeConfig);
+    private usesOwnedRuntimePreflight;
+    private usesWorkerCachedRuntimePreflight;
+    private resetWorkerForLowerAssetLimit;
+    private getDisposeReason;
+    private assertNotDisposed;
+    private assertOperationNotDisposed;
+    private preserveDisposeReason;
+    get stdinMode(): RuntimeStdinMode;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, _log?: boolean, _args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
+    write(input: string): void;
+    eof(): void;
+    private resolveStdinWaiters;
+    private rejectStdinWaiters;
+    private clearPendingStdin;
+    private sourceMayReadStdin;
+    private collectStdinForRun;
+    private selectProgress;
+    private beginProgressLifecycle;
+    private resolveExecutionControls;
+    private validateWorkspace;
+    private reportProgress;
+    private reportRunReady;
+    private reportRunSettled;
+    private verifyWorkerReceipt;
+    private preloadWorkerScript;
+    private createBootstrapUrl;
+    private revokeBootstrapUrl;
+    private ensureWorkerStarted;
+    private startWorker;
+    private handleWorkerMessage;
+    private formatWorkerError;
+    private errorMessage;
+    private handleWorkerFailure;
+    private resolveRun;
+    private rejectRun;
+    private claimRun;
+    private cleanupRun;
+    private releasePreparedWorkerIfIdle;
+    private releaseWorkerLease;
+    handleMemoryPressure(): number;
+    private retireManagedWorker;
+    private retireRuntimePreflight;
+    private detachAndTerminateWorker;
+    private disposeWorker;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    kill(): void;
+    private terminateLifecycle;
+    terminate(): void;
+    dispose(): Promise<void>;
+    clear(): Promise<void>;
+}
+export {};