/**
 * Typed, explicit main/worker transport with state, event, and RPC lanes.
 *
 * This module intentionally knows nothing about Three.js, the DOM, or the runtime
 * dispatcher. Applications map only the protocol fields they deliberately expose.
 *
 * @module three-blocks/worker
 */
export declare const WORKER_PROTOCOL_VERSION = 1;
export type StructuredClonePrimitive = null | undefined | void | boolean | number | bigint | string;
export type StructuredCloneBuiltin = ArrayBuffer | ArrayBufferView | Date | RegExp | SharedArrayBuffer;
declare const TRANSFERABLE_VALUE: unique symbol;
/** Explicitly marks an opaque host value that is sent once through a transfer list. */
export type TransferableValue<TValue extends object> = TValue & {
    readonly [TRANSFERABLE_VALUE]: true;
};
/** Identity helper making transfer-only protocol fields visible to the type system. */
export declare function asTransferable<TValue extends object>(value: TValue): TransferableValue<TValue>;
/** Values accepted by the browser structured-clone algorithm or a transfer list. */
export type StructuredCloneable = StructuredClonePrimitive | StructuredCloneBuiltin | readonly StructuredCloneable[] | {
    readonly [key: string]: StructuredCloneable;
};
/** Recursively preserves a contract shape while replacing non-cloneable members with never. */
export type StructuredCloneableShape<TValue> = TValue extends TransferableValue<object> ? TValue : TValue extends (...args: never[]) => unknown ? never : TValue extends StructuredClonePrimitive | StructuredCloneBuiltin ? TValue : TValue extends ReadonlyMap<infer TKey, infer TEntry> ? ReadonlyMap<StructuredCloneableShape<TKey>, StructuredCloneableShape<TEntry>> : TValue extends ReadonlySet<infer TEntry> ? ReadonlySet<StructuredCloneableShape<TEntry>> : TValue extends readonly (infer TEntry)[] ? readonly StructuredCloneableShape<TEntry>[] : TValue extends object ? {
    readonly [TKey in keyof TValue]: StructuredCloneableShape<TValue[TKey]>;
} : never;
type CloneableContractArguments<TState extends object, TEvents extends object, TRequests extends object, TOptions> = TState extends StructuredCloneableShape<TState> ? TEvents extends StructuredCloneableShape<TEvents> ? TRequests extends StructuredCloneableShape<TRequests> ? [options?: TOptions] : [options: TOptions | undefined, structuredCloneContractError: never] : [options: TOptions | undefined, structuredCloneContractError: never] : [options: TOptions | undefined, structuredCloneContractError: never];
export type WorkerLifecyclePhase = 'connect' | 'state' | 'event' | 'request' | 'response' | 'transport' | 'dispose';
export interface SerializedWorkerError {
    readonly name: string;
    readonly message: string;
    readonly stack?: string;
    readonly source?: string;
    readonly lifecyclePhase: WorkerLifecyclePhase;
    readonly code?: string;
}
export interface SerializeWorkerErrorOptions {
    readonly source?: string;
    readonly lifecyclePhase: WorkerLifecyclePhase;
    readonly code?: string;
}
export type WorkerTransportErrorCode = 'clone-rejected' | 'disposed' | 'endpoint-replaced' | 'invalid-message' | 'missing-handler' | 'no-endpoint' | 'not-connected' | 'protocol-mismatch' | 'remote-error' | 'sequence-error' | 'transport-error';
export declare class WorkerTransportError extends Error {
    readonly code: WorkerTransportErrorCode;
    readonly serialized: SerializedWorkerError | undefined;
    constructor(code: WorkerTransportErrorCode, message: string, serialized?: SerializedWorkerError);
}
export declare class RemoteWorkerError extends Error {
    readonly remote: SerializedWorkerError;
    constructor(remote: SerializedWorkerError);
}
export interface MessageEventLike<T = unknown> {
    readonly data: T;
}
export type MessageEndpointListener = (event: MessageEventLike) => void;
/** The DOM-free subset shared by Worker, MessagePort, and Node MessagePort adapters. */
export interface MessageEndpoint {
    postMessage(message: unknown, transfer?: readonly object[]): void;
    addEventListener(type: 'message', listener: MessageEndpointListener): void;
    removeEventListener(type: 'message', listener: MessageEndpointListener): void;
    start?(): void;
    close?(): void;
}
/**
 * Structural browser endpoint accepted without application-side casts.
 *
 * The deliberately non-callable `never[]` signatures let the native overloads on
 * Worker, MessagePort, and DedicatedWorkerGlobalScope satisfy this contract while all
 * calls remain centralized in `messageEndpoint()` below.
 */
export interface BrowserMessageEndpoint {
    postMessage(...arguments_: never[]): unknown;
    addEventListener(...arguments_: never[]): unknown;
    removeEventListener(...arguments_: never[]): unknown;
    start?(...arguments_: never[]): unknown;
    close?(...arguments_: never[]): unknown;
}
export type MessageEndpointSource = MessageEndpoint | BrowserMessageEndpoint;
/** Normalize a native Worker, MessagePort, worker global, or test adapter once. */
export declare function messageEndpoint(source: MessageEndpointSource): MessageEndpoint;
export interface RequestDefinition<TParameters, TResult> {
    readonly parameters: TParameters;
    readonly result: TResult;
}
export type RequestParameters<TDefinition> = TDefinition extends RequestDefinition<infer TParameters, unknown> ? TParameters : never;
export type RequestResult<TDefinition> = TDefinition extends RequestDefinition<unknown, infer TResult> ? TResult : never;
export interface SendOptions {
    readonly transfer?: readonly object[];
}
export type CloneValue = (value: unknown) => unknown;
export interface WorkerClientOptions {
    readonly protocolVersion?: number;
    readonly source?: string;
    readonly validateStructuredClone?: boolean;
    readonly cloneValue?: CloneValue;
    readonly closeEndpointOnReplace?: boolean;
    readonly closeEndpointOnDispose?: boolean;
    readonly onError?: (error: SerializedWorkerError) => void;
}
export interface WorkerServerOptions {
    readonly protocolVersion?: number;
    readonly source?: string;
    readonly validateStructuredClone?: boolean;
    readonly cloneValue?: CloneValue;
    readonly closeEndpointOnDispose?: boolean;
    readonly onError?: (error: SerializedWorkerError) => void;
}
export interface WorkerHandlerContext<TName extends string = string> {
    readonly key: TName;
    readonly protocolVersion: number;
    readonly source: string;
}
export interface WorkerStateHandlerContext<TName extends string = string> extends WorkerHandlerContext<TName> {
    readonly lane: 'state';
    readonly sequence: number;
}
export interface WorkerEventHandlerContext<TName extends string = string> extends WorkerHandlerContext<TName> {
    readonly lane: 'event';
    readonly sequence: number;
}
export interface WorkerRequestHandlerContext<TName extends string = string> extends WorkerHandlerContext<TName> {
    readonly lane: 'request';
    readonly requestId: string;
}
type StringKey<TValue extends object> = Extract<keyof TValue, string>;
type MaybePromise<TValue> = TValue | PromiseLike<TValue>;
export declare class WorkerTransfer<TResult> {
    readonly value: TResult;
    readonly transfer: readonly object[];
    constructor(value: TResult, transfer: readonly object[]);
}
export declare function withTransfer<TResult>(value: TResult, transfer: readonly object[]): WorkerTransfer<TResult>;
export type WorkerStateHandlers<TState extends object> = {
    [TName in StringKey<TState>]?: (value: TState[TName], context: WorkerStateHandlerContext<TName>) => MaybePromise<void>;
};
export type WorkerEventHandlers<TEvents extends object> = {
    [TName in StringKey<TEvents>]?: (value: TEvents[TName], context: WorkerEventHandlerContext<TName>) => MaybePromise<void>;
};
export type WorkerRequestHandlers<TRequests extends object> = {
    [TName in StringKey<TRequests>]?: (parameters: RequestParameters<TRequests[TName]>, context: WorkerRequestHandlerContext<TName>) => MaybePromise<RequestResult<TRequests[TName]> | WorkerTransfer<RequestResult<TRequests[TName]>>>;
};
export interface WorkerServerHandlers<TState extends object, TEvents extends object, TRequests extends object> {
    readonly state?: WorkerStateHandlers<TState>;
    readonly events?: WorkerEventHandlers<TEvents>;
    readonly requests?: WorkerRequestHandlers<TRequests>;
}
export interface WorkerStateLane<TState extends object> {
    /** Transfer-bearing state is sent once and cannot be retained for endpoint replay. */
    set<TName extends StringKey<TState>>(name: TName, value: TState[TName], options?: SendOptions): void;
    clear<TName extends StringKey<TState>>(name: TName): void;
}
export interface WorkerEventLane<TEvents extends object> {
    emit<TName extends StringKey<TEvents>>(name: TName, value: TEvents[TName], options?: SendOptions): void;
}
export interface WorkerRpcLane<TRequests extends object> {
    request<TName extends StringKey<TRequests>>(name: TName, parameters: RequestParameters<TRequests[TName]>, options?: SendOptions): Promise<RequestResult<TRequests[TName]>>;
}
export declare function serializeWorkerError(error: unknown, options: SerializeWorkerErrorOptions): SerializedWorkerError;
/** Main-side transport retaining only latest state across endpoint replacement. */
export declare class WorkerClient<TState extends object, TEvents extends object, TRequests extends object> {
    #private;
    readonly state: WorkerStateLane<TState>;
    readonly events: WorkerEventLane<TEvents>;
    readonly rpc: WorkerRpcLane<TRequests>;
    constructor(...arguments_: CloneableContractArguments<TState, TEvents, TRequests, WorkerClientOptions>);
    get connected(): boolean;
    get disposed(): boolean;
    get lastError(): SerializedWorkerError | undefined;
    replaceEndpoint(source: MessageEndpointSource): Promise<void>;
    dispose(): void;
}
/** Worker-side adapter invoking only the explicitly supplied state/event/RPC maps. */
export declare class WorkerServer<TState extends object, TEvents extends object, TRequests extends object> {
    #private;
    constructor(source: MessageEndpointSource, handlers: WorkerServerHandlers<TState, TEvents, TRequests>, ...arguments_: CloneableContractArguments<TState, TEvents, TRequests, WorkerServerOptions>);
    get disposed(): boolean;
    whenIdle(): Promise<void>;
    dispose(): void;
}
export declare function createWorkerClient<TState extends object, TEvents extends object, TRequests extends object>(...arguments_: CloneableContractArguments<TState, TEvents, TRequests, WorkerClientOptions>): WorkerClient<TState, TEvents, TRequests>;
export declare function createWorkerServer<TState extends object, TEvents extends object, TRequests extends object>(endpoint: MessageEndpointSource, handlers: WorkerServerHandlers<TState, TEvents, TRequests>, ...arguments_: CloneableContractArguments<TState, TEvents, TRequests, WorkerServerOptions>): WorkerServer<TState, TEvents, TRequests>;
export {};