import { type ResolveWorkerHost } from "./worker-egress-guard.js";
import type { WorkerPermissions } from "./worker-permissions.js";
import type { WorkerRequest, WorkerResponse } from "./worker-types.js";
export interface ProjectWorkerOptions {
    projectId: string;
    permissions: WorkerPermissions;
    requestTimeoutMs: number;
    workerScriptUrl?: string;
    /** Extension-owned renderer module imported only for isolated SSR requests. */
    isolatedSsrRendererModuleUrl?: string;
    /** Override for deterministic egress resolution tests. */
    egressResolveHost?: ResolveWorkerHost;
    /** Host-owned policy snapshot. Project code must never be able to change it. */
    allowInternalEgress: boolean;
}
/**
 * Status of a project worker.
 */
export type WorkerStatus = "idle" | "busy" | "crashed" | "terminated";
export declare class ProjectWorker {
    readonly projectId: string;
    private worker;
    private controlPort;
    private workerGeneration;
    private pending;
    private streamHandlers;
    private idleListeners;
    private suppressIdleNotifications;
    private requestTimeoutMs;
    private readonly permissions;
    private readonly assertReadScopeGenerationConfined;
    private workerScriptUrl?;
    private readonly isolatedSsrRendererModuleUrl?;
    private egressResolveHost?;
    private readonly allowInternalEgress;
    private egressBroker;
    private shutdownPromise;
    private _requestCount;
    private _lastActivityAt;
    private _status;
    constructor(options: ProjectWorkerOptions);
    get status(): WorkerStatus;
    get requestCount(): number;
    get lastActivityAt(): number;
    get hasPendingRequests(): boolean;
    /** Subscribe to the transition where all worker protocol work has settled. */
    onIdle(listener: () => void): () => void;
    /**
     * Start the worker. Idempotent — safe to call if already running.
     */
    start(): void;
    /**
     * Execute a request in this worker. Returns a typed response.
     */
    execute(request: WorkerRequest): Promise<WorkerResponse>;
    /**
     * Execute a streaming request. Returns a ReadableStream that yields
     * chunks as they arrive from the Worker via postMessage.
     *
     * Each execution uses an authenticated, sequenced one-credit protocol. A
     * string result is never accepted after streaming delivery begins.
     */
    executeStream(request: WorkerRequest): ReadableStream<Uint8Array>;
    /**
     * Health check — send a ping and wait for pong.
     */
    isHealthy(timeoutMs?: number): Promise<boolean>;
    /**
     * Clear the worker's module cache. Used for dev mode hot reload.
     */
    clearModuleCache(): void;
    /**
     * Terminate the worker. Rejects all pending requests.
     */
    terminate(): void;
    /**
     * Terminate the worker and wait until all worker-owned resources are closed.
     *
     * The returned promise is single-flight and never rejects: teardown failures
     * are logged after every close attempt, while callers still receive a
     * deterministic quiescence boundary.
     */
    shutdown(): Promise<void>;
    private createSSRWireState;
    private postSSRExecutionOpen;
    private postToWorker;
    private failWorker;
    private beginShutdown;
    private closeControlPort;
    private getWorkerScriptUrl;
    private handleMessage;
    private handleSSRWireMessage;
    private updateIdleStatus;
    private notifyIdleListeners;
    private rejectAllPending;
}
//# sourceMappingURL=project-worker.d.ts.map