/**
 * Transport abstraction for RpcClient. Lets the client speak either to an
 * in-process Worker (leader mode) or to a Unix socket / Windows named pipe
 * server (follower mode).
 *
 * Also defines the IPC wire protocol constants shared by both sides of the
 * socket (handshake + heartbeat). RPC call/response messages piggyback on
 * the same framing but pass through unchanged to RpcServer.
 */
/**
 * IPC protocol version. Bump whenever the framing or handshake format
 * changes in a backwards-incompatible way. Followers refuse to connect to
 * a leader with a different major version.
 */
export declare const GRAPH_IPC_VERSION = 1;
/** Default time after which a peer with no heartbeat is considered dead. */
export declare const HEARTBEAT_TIMEOUT_MS = 30000;
/** Default interval at which peers exchange heartbeats. */
export declare const HEARTBEAT_INTERVAL_MS = 5000;
export type IpcMessage = {
    kind: 'hello';
    version: number;
    role: 'client' | 'server';
    accepted?: boolean;
    reason?: string;
} | {
    kind: 'ping';
    t: number;
} | {
    kind: 'pong';
    t: number;
} | {
    kind: 'rpc';
    payload: unknown;
} | {
    kind: 'goodbye';
    reason?: string;
};
export interface RpcTransport {
    send(message: unknown): void;
    onMessage(handler: (message: unknown) => void): void;
    onError(handler: (error: Error) => void): void;
    onClose(handler: () => void): void;
    close(): void;
    /** Cheap liveness probe — false means no further RPCs can succeed. */
    isHealthy(): boolean;
}
/**
 * Wraps a Worker into the RpcTransport interface. Passes raw RPC payloads
 * through postMessage (no framing needed inside the process).
 */
export declare class WorkerTransport implements RpcTransport {
    private worker;
    private emitter;
    private closed;
    private erroredWith;
    constructor(worker: Worker);
    send(message: unknown): void;
    onMessage(handler: (message: unknown) => void): void;
    onError(handler: (error: Error) => void): void;
    onClose(handler: () => void): void;
    close(): void;
    isHealthy(): boolean;
}
export interface SocketTransportOptions {
    socketPath: string;
    connectTimeoutMs?: number;
    heartbeatIntervalMs?: number;
    heartbeatTimeoutMs?: number;
    logger?: {
        error?: (msg: string, err?: unknown) => void;
        debug?: (msg: string) => void;
    };
}
/**
 * Connect to a leader over a Unix socket / Windows named pipe. Does the
 * version handshake up-front; if it fails, `connect()` rejects and the
 * transport is closed.
 */
export declare class SocketTransport implements RpcTransport {
    private opts;
    private socket;
    private decoder;
    private emitter;
    private closed;
    private erroredWith;
    private heartbeatTimer;
    private heartbeatTimeoutHandle;
    private lastPongAt;
    constructor(opts: SocketTransportOptions);
    connect(): Promise<void>;
    private attachPostHandshakeHandlers;
    private dispatch;
    private startHeartbeat;
    private stopHeartbeat;
    send(payload: unknown): void;
    onMessage(handler: (message: unknown) => void): void;
    onError(handler: (error: Error) => void): void;
    onClose(handler: () => void): void;
    close(): void;
    isHealthy(): boolean;
}
//# sourceMappingURL=ipc-transport.d.ts.map