@fluxstack/live 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1400 @@
+import { EventEmitter } from 'events';
+
+/**
+ * Credentials sent by the client during WebSocket authentication.
+ * Extensible to support any auth strategy (JWT, API key, crypto, etc.)
+ */
+interface LiveAuthCredentials {
+    /** JWT or opaque token */
+    token?: string;
+    /** Public key (for crypto-auth) */
+    publicKey?: string;
+    /** Signature (for crypto-auth) */
+    signature?: string;
+    /** Signature timestamp */
+    timestamp?: number;
+    /** Anti-replay nonce */
+    nonce?: string;
+    /** Additional fields for custom providers */
+    [key: string]: unknown;
+}
+/**
+ * Authenticated user information.
+ * Returned by LiveAuthProvider after validation.
+ */
+interface LiveAuthUser {
+    /** Unique user identifier */
+    id: string;
+    /** Roles assigned to the user (e.g., 'admin', 'moderator') */
+    roles?: string[];
+    /** Granular permissions (e.g., 'chat.write', 'chat.admin') */
+    permissions?: string[];
+    /** Additional fields (name, email, etc.) */
+    [key: string]: unknown;
+}
+/**
+ * Auth context available inside LiveComponent via this.$auth.
+ * Provides type-safe helpers for checking roles and permissions.
+ */
+interface LiveAuthContext {
+    /** Whether the user is authenticated */
+    readonly authenticated: boolean;
+    /** User data (undefined if not authenticated) */
+    readonly user?: LiveAuthUser;
+    /** Original token used for authentication */
+    readonly token?: string;
+    /** Timestamp of when authentication occurred */
+    readonly authenticatedAt?: number;
+    /** Check if user has a specific role */
+    hasRole(role: string): boolean;
+    /** Check if user has ANY of the roles */
+    hasAnyRole(roles: string[]): boolean;
+    /** Check if user has ALL roles */
+    hasAllRoles(roles: string[]): boolean;
+    /** Check if user has a specific permission */
+    hasPermission(permission: string): boolean;
+    /** Check if user has ALL permissions */
+    hasAllPermissions(permissions: string[]): boolean;
+    /** Check if user has ANY of the permissions */
+    hasAnyPermission(permissions: string[]): boolean;
+}
+/**
+ * Interface for authentication strategy implementations.
+ * Each provider implements its own validation logic.
+ *
+ * Examples: JWTAuthProvider, CryptoAuthProvider, SessionAuthProvider
+ */
+interface LiveAuthProvider {
+    /** Unique provider name (e.g., 'jwt', 'crypto', 'session') */
+    readonly name: string;
+    /**
+     * Validate credentials and return auth context.
+     * Returns null if credentials are invalid.
+     */
+    authenticate(credentials: LiveAuthCredentials): Promise<LiveAuthContext | null>;
+    /**
+     * (Optional) Custom per-action authorization.
+     * Returns true if the user can execute the action.
+     */
+    authorizeAction?(context: LiveAuthContext, componentName: string, action: string): Promise<boolean>;
+    /**
+     * (Optional) Custom per-room authorization.
+     * Returns true if the user can join the room.
+     */
+    authorizeRoom?(context: LiveAuthContext, roomId: string): Promise<boolean>;
+}
+/**
+ * Declarative auth configuration for a LiveComponent.
+ * Defined as a static property on the class.
+ */
+interface LiveComponentAuth {
+    /** Whether authentication is required to mount the component. Default: false */
+    required?: boolean;
+    /** Required roles (OR logic - any role suffices) */
+    roles?: string[];
+    /** Required permissions (AND logic - all must be present) */
+    permissions?: string[];
+}
+/**
+ * Per-action auth configuration.
+ */
+interface LiveActionAuth {
+    /** Required roles for this action (OR logic) */
+    roles?: string[];
+    /** Required permissions for this action (AND logic) */
+    permissions?: string[];
+}
+/** Map of action name -> auth configuration */
+type LiveActionAuthMap = Record<string, LiveActionAuth>;
+/**
+ * Result of an authorization check.
+ */
+interface LiveAuthResult {
+    /** Whether authorization was successful */
+    allowed: boolean;
+    /** Denial reason (if allowed === false) */
+    reason?: string;
+}
+
+/**
+ * Minimal WebSocket interface that any server framework can implement.
+ * Compatible with Bun ServerWebSocket, Elysia WS, `ws` package, etc.
+ */
+interface GenericWebSocket {
+    /** Send data to the client */
+    send(data: string | ArrayBuffer | Uint8Array, compress?: boolean): void | number;
+    /** Close the connection */
+    close(code?: number, reason?: string): void;
+    /** Connection data storage */
+    data: LiveWSData;
+    /** Remote address of the client */
+    readonly remoteAddress: string;
+    /** WebSocket ready state: 0=CONNECTING, 1=OPEN, 2=CLOSING, 3=CLOSED */
+    readonly readyState: 0 | 1 | 2 | 3;
+}
+/**
+ * Data stored on each WebSocket connection.
+ * Attached to ws.data by the transport adapter on open.
+ */
+interface LiveWSData {
+    connectionId: string;
+    components: Map<string, any>;
+    subscriptions: Set<string>;
+    connectedAt: Date;
+    userId?: string;
+    /** Auth context for the connection */
+    authContext?: LiveAuthContext;
+}
+/** @deprecated Use GenericWebSocket instead */
+type FluxStackWebSocket = GenericWebSocket;
+/** @deprecated Use LiveWSData instead */
+type FluxStackWSData = LiveWSData;
+/**
+ * The transport layer that each server adapter must implement.
+ * LiveServer calls these methods to register WS and HTTP handlers.
+ */
+interface LiveTransport {
+    /** Register the main WebSocket endpoint for Live Components */
+    registerWebSocket(config: WebSocketConfig): void | Promise<void>;
+    /** Register HTTP monitoring/debug routes */
+    registerHttpRoutes(routes: HttpRouteDefinition[]): void | Promise<void>;
+    /** Optional startup hook */
+    start?(): void | Promise<void>;
+    /** Optional shutdown hook */
+    shutdown?(): void | Promise<void>;
+}
+/**
+ * Configuration for the Live Components WebSocket endpoint.
+ * The transport adapter wires these callbacks to its own WS implementation.
+ */
+interface WebSocketConfig {
+    /** Path for the WebSocket endpoint (e.g., '/api/live/ws') */
+    path: string;
+    /** Called when a new client connects */
+    onOpen(ws: GenericWebSocket): void | Promise<void>;
+    /** Called when a message is received (JSON or binary) */
+    onMessage(ws: GenericWebSocket, message: unknown, isBinary: boolean): void | Promise<void>;
+    /** Called when a client disconnects */
+    onClose(ws: GenericWebSocket, code: number, reason: string): void | Promise<void>;
+    /** Called on WebSocket error */
+    onError?(ws: GenericWebSocket, error: Error): void;
+}
+/**
+ * Framework-agnostic HTTP route definition.
+ * Each transport adapter maps these to its own router.
+ */
+interface HttpRouteDefinition {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    path: string;
+    handler: (request: HttpRequest) => HttpResponse | Promise<HttpResponse>;
+    metadata?: {
+        summary?: string;
+        description?: string;
+        tags?: string[];
+    };
+}
+/**
+ * Normalized HTTP request object passed to route handlers.
+ */
+interface HttpRequest {
+    params: Record<string, string>;
+    query: Record<string, string | undefined>;
+    body: unknown;
+    headers: Record<string, string | undefined>;
+}
+/**
+ * Normalized HTTP response returned by route handlers.
+ */
+interface HttpResponse {
+    status?: number;
+    body: unknown;
+    headers?: Record<string, string>;
+}
+
+type EventHandler<T = any> = (data: T) => void;
+interface RoomSubscription {
+    roomType: string;
+    roomId: string;
+    event: string;
+    handler: EventHandler;
+    componentId: string;
+}
+declare function createTypedRoomEventBus<TRoomEvents extends Record<string, Record<string, any>>>(): {
+    on<K extends keyof TRoomEvents, E extends keyof TRoomEvents[K]>(roomType: K, roomId: string, event: E, componentId: string, handler: EventHandler<TRoomEvents[K][E]>): () => void;
+    emit<K extends keyof TRoomEvents, E extends keyof TRoomEvents[K]>(roomType: K, roomId: string, event: E, data: TRoomEvents[K][E], excludeComponentId?: string): number;
+    unsubscribeAll(componentId: string): number;
+    clearRoom<K extends keyof TRoomEvents>(roomType: K, roomId: string): number;
+    getStats(): {
+        totalSubscriptions: number;
+        rooms: Record<string, {
+            events: Record<string, number>;
+        }>;
+    };
+};
+declare class RoomEventBus {
+    private subscriptions;
+    private getKey;
+    on(roomType: string, roomId: string, event: string, componentId: string, handler: EventHandler): () => void;
+    emit(roomType: string, roomId: string, event: string, data: any, excludeComponentId?: string): number;
+    unsubscribeAll(componentId: string): number;
+    clearRoom(roomType: string, roomId: string): number;
+    getStats(): {
+        totalSubscriptions: number;
+        rooms: Record<string, {
+            events: Record<string, number>;
+        }>;
+    };
+}
+
+declare class LiveRoomManager {
+    private roomEvents;
+    private rooms;
+    private componentRooms;
+    constructor(roomEvents: RoomEventBus);
+    /**
+     * Component joins a room
+     */
+    joinRoom<TState = any>(componentId: string, roomId: string, ws: GenericWebSocket, initialState?: TState): {
+        state: TState;
+    };
+    /**
+     * Component leaves a room
+     */
+    leaveRoom(componentId: string, roomId: string): void;
+    /**
+     * Component disconnects - leave all rooms
+     */
+    cleanupComponent(componentId: string): void;
+    /**
+     * Emit event to all members in a room
+     */
+    emitToRoom(roomId: string, event: string, data: any, excludeComponentId?: string): number;
+    /**
+     * Update room state
+     */
+    setRoomState(roomId: string, updates: any, excludeComponentId?: string): void;
+    /**
+     * Get room state
+     */
+    getRoomState<TState = any>(roomId: string): TState;
+    /**
+     * Broadcast to all members in a room
+     */
+    private broadcastToRoom;
+    /**
+     * Check if component is in a room
+     */
+    isInRoom(componentId: string, roomId: string): boolean;
+    /**
+     * Get rooms for a component
+     */
+    getComponentRooms(componentId: string): string[];
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        totalRooms: number;
+        rooms: Record<string, {
+            members: number;
+            createdAt: number;
+            lastActivity: number;
+        }>;
+    };
+}
+
+type DebugEventType = 'COMPONENT_MOUNT' | 'COMPONENT_UNMOUNT' | 'COMPONENT_REHYDRATE' | 'STATE_CHANGE' | 'ACTION_CALL' | 'ACTION_RESULT' | 'ACTION_ERROR' | 'ROOM_JOIN' | 'ROOM_LEAVE' | 'ROOM_EMIT' | 'ROOM_EVENT_RECEIVED' | 'WS_CONNECT' | 'WS_DISCONNECT' | 'ERROR' | 'LOG';
+interface DebugEvent {
+    id: string;
+    timestamp: number;
+    type: DebugEventType;
+    componentId: string | null;
+    componentName: string | null;
+    data: Record<string, unknown>;
+}
+interface ComponentSnapshot {
+    componentId: string;
+    componentName: string;
+    /** Developer-defined label for easier identification in the debugger */
+    debugLabel?: string;
+    state: Record<string, unknown>;
+    rooms: string[];
+    mountedAt: number;
+    lastActivity: number;
+    actionCount: number;
+    stateChangeCount: number;
+    errorCount: number;
+}
+interface DebugSnapshot {
+    components: ComponentSnapshot[];
+    connections: number;
+    uptime: number;
+    totalEvents: number;
+}
+interface DebugWsMessage {
+    type: 'DEBUG_EVENT' | 'DEBUG_SNAPSHOT' | 'DEBUG_WELCOME' | 'DEBUG_DISABLED';
+    event?: DebugEvent;
+    snapshot?: DebugSnapshot;
+    enabled?: boolean;
+    timestamp: number;
+}
+declare class LiveDebugger {
+    private events;
+    private componentSnapshots;
+    private debugClients;
+    private _enabled;
+    private startTime;
+    private eventCounter;
+    constructor(enabled?: boolean);
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    emit(type: DebugEventType | string, componentId: string | null, componentName: string | null, data?: Record<string, unknown>): void;
+    trackComponentMount(componentId: string, componentName: string, initialState: Record<string, unknown>, room?: string, debugLabel?: string): void;
+    trackComponentUnmount(componentId: string): void;
+    trackStateChange(componentId: string, delta: Record<string, unknown>, fullState: Record<string, unknown>, source?: 'proxy' | 'setState' | 'rehydrate'): void;
+    trackActionCall(componentId: string, action: string, payload: unknown): void;
+    trackActionResult(componentId: string, action: string, result: unknown, duration: number): void;
+    trackActionError(componentId: string, action: string, error: string, duration: number): void;
+    trackRoomJoin(componentId: string, roomId: string): void;
+    trackRoomLeave(componentId: string, roomId: string): void;
+    trackRoomEmit(componentId: string, roomId: string, event: string, data: unknown): void;
+    trackConnection(connectionId: string): void;
+    trackDisconnection(connectionId: string, componentCount: number): void;
+    trackError(componentId: string | null, error: string, context?: Record<string, unknown>): void;
+    registerDebugClient(ws: GenericWebSocket): void;
+    unregisterDebugClient(ws: GenericWebSocket): void;
+    getSnapshot(): DebugSnapshot;
+    getComponentState(componentId: string): ComponentSnapshot | null;
+    getEvents(filter?: {
+        componentId?: string;
+        type?: DebugEventType;
+        limit?: number;
+    }): DebugEvent[];
+    clearEvents(): void;
+    private broadcastEvent;
+    private sanitizeData;
+    private sanitizeState;
+    private updateSnapshot;
+}
+
+declare class LiveAuthManager {
+    private providers;
+    private defaultProviderName?;
+    /**
+     * Register an auth provider.
+     */
+    register(provider: LiveAuthProvider): void;
+    /**
+     * Remove an auth provider.
+     */
+    unregister(name: string): void;
+    /**
+     * Set the default auth provider.
+     */
+    setDefault(name: string): void;
+    /**
+     * Returns true if at least one provider is registered.
+     */
+    hasProviders(): boolean;
+    /**
+     * Returns the default provider or undefined.
+     */
+    getDefaultProvider(): LiveAuthProvider | undefined;
+    /**
+     * Authenticate credentials using the specified provider, or try all providers.
+     * Returns ANONYMOUS_CONTEXT if no credentials or no providers.
+     */
+    authenticate(credentials: LiveAuthCredentials, providerName?: string): Promise<LiveAuthContext>;
+    /**
+     * Verify auth context meets component requirements.
+     */
+    authorizeComponent(authContext: LiveAuthContext, authConfig: LiveComponentAuth | undefined): LiveAuthResult;
+    /**
+     * Verify auth context allows executing a specific action.
+     */
+    authorizeAction(authContext: LiveAuthContext, componentName: string, action: string, actionAuth: LiveActionAuth | undefined, providerName?: string): Promise<LiveAuthResult>;
+    /**
+     * Verify auth context allows joining a room.
+     */
+    authorizeRoom(authContext: LiveAuthContext, roomId: string, providerName?: string): Promise<LiveAuthResult>;
+    /**
+     * Get info about registered providers.
+     */
+    getInfo(): {
+        providers: string[];
+        defaultProvider?: string;
+    };
+}
+
+interface SignedState {
+    data: string;
+    signature: string;
+    timestamp: number;
+    version: number;
+    componentId: string;
+    nonce?: string;
+    compressed?: boolean;
+    encrypted?: boolean;
+}
+interface StateSignatureConfig {
+    /** HMAC secret for signing. Defaults to env LIVE_STATE_SECRET or a random key. */
+    secret?: string;
+    /** Enable key rotation */
+    rotationEnabled?: boolean;
+    /** Key rotation interval in ms */
+    rotationInterval?: number;
+    /** Enable compression */
+    compressionEnabled?: boolean;
+    /** Enable encryption */
+    encryptionEnabled?: boolean;
+    /** Enable anti-replay nonces */
+    nonceEnabled?: boolean;
+    /** Maximum state age in ms */
+    maxStateAge?: number;
+    /** Enable state backups */
+    backupEnabled?: boolean;
+    /** Max state backups to keep */
+    maxBackups?: number;
+}
+declare class StateSignatureManager {
+    private secret;
+    private previousSecrets;
+    private rotationTimer?;
+    private usedNonces;
+    private nonceCleanupTimer?;
+    private stateBackups;
+    private config;
+    constructor(config?: StateSignatureConfig);
+    signState(componentId: string, state: Record<string, unknown>, version: number, options?: {
+        compress?: boolean;
+        backup?: boolean;
+    }): Promise<SignedState>;
+    validateState(signedState: SignedState): Promise<{
+        valid: boolean;
+        error?: string;
+    }>;
+    extractData(signedState: SignedState): Promise<Record<string, unknown>>;
+    getBackups(componentId: string): SignedState[];
+    getLatestBackup(componentId: string): SignedState | null;
+    private backupState;
+    private computeSignature;
+    private computeSignatureWithKey;
+    private timingSafeEqual;
+    private deriveEncryptionKey;
+    private setupKeyRotation;
+    private cleanupNonces;
+    shutdown(): void;
+}
+
+interface ComponentPerformanceMetrics {
+    componentId: string;
+    componentName: string;
+    mountTime: number;
+    actionTimes: Map<string, number[]>;
+    renderTimes: number[];
+    stateChanges: number;
+    errorCount: number;
+    lastActivity: number;
+}
+interface PerformanceAlert {
+    type: 'slow_action' | 'slow_render' | 'high_error_rate' | 'memory_warning';
+    componentId: string;
+    componentName: string;
+    message: string;
+    value: number;
+    threshold: number;
+    timestamp: number;
+}
+interface PerformanceConfig {
+    /** Threshold for slow action warnings (ms) */
+    slowActionThreshold?: number;
+    /** Threshold for slow render warnings (ms) */
+    slowRenderThreshold?: number;
+    /** Max errors before warning */
+    highErrorRateThreshold?: number;
+    /** Enable performance alerts */
+    alertsEnabled?: boolean;
+}
+declare class PerformanceMonitor extends EventEmitter {
+    private components;
+    private alerts;
+    private config;
+    constructor(config?: PerformanceConfig);
+    initializeComponent(componentId: string, componentName: string): void;
+    recordRenderTime(componentId: string, time: number): void;
+    recordActionTime(componentId: string, action: string, time: number, error?: Error): void;
+    recordStateChange(componentId: string): void;
+    removeComponent(componentId: string): void;
+    getComponentMetrics(componentId: string): ComponentPerformanceMetrics | null;
+    getAllMetrics(): ComponentPerformanceMetrics[];
+    getAlerts(limit?: number): PerformanceAlert[];
+    clearAlerts(): void;
+    getStats(): {
+        totalComponents: number;
+        totalAlerts: number;
+        components: {
+            id: string;
+            name: string;
+            renderCount: number;
+            avgRenderTime: number;
+            actionCount: number;
+            stateChanges: number;
+            errorCount: number;
+        }[];
+    };
+    private addAlert;
+}
+
+interface LiveMessage {
+    type: 'COMPONENT_MOUNT' | 'COMPONENT_UNMOUNT' | 'COMPONENT_REHYDRATE' | 'COMPONENT_ACTION' | 'CALL_ACTION' | 'ACTION_RESPONSE' | 'PROPERTY_UPDATE' | 'STATE_UPDATE' | 'STATE_DELTA' | 'STATE_REHYDRATED' | 'ERROR' | 'BROADCAST' | 'FILE_UPLOAD_START' | 'FILE_UPLOAD_CHUNK' | 'FILE_UPLOAD_COMPLETE' | 'COMPONENT_PING' | 'COMPONENT_PONG' | 'AUTH' | 'ROOM_JOIN' | 'ROOM_LEAVE' | 'ROOM_EMIT' | 'ROOM_STATE_SET' | 'ROOM_STATE_GET';
+    componentId: string;
+    action?: string;
+    property?: string;
+    payload?: any;
+    timestamp?: number;
+    userId?: string;
+    room?: string;
+    requestId?: string;
+    responseId?: string;
+    expectResponse?: boolean;
+}
+interface WebSocketResponse {
+    type: 'MESSAGE_RESPONSE' | 'CONNECTION_ESTABLISHED' | 'ERROR' | 'BROADCAST' | 'ACTION_RESPONSE' | 'COMPONENT_MOUNTED' | 'COMPONENT_REHYDRATED' | 'STATE_UPDATE' | 'STATE_DELTA' | 'STATE_REHYDRATED' | 'FILE_UPLOAD_PROGRESS' | 'FILE_UPLOAD_COMPLETE' | 'FILE_UPLOAD_ERROR' | 'FILE_UPLOAD_START_RESPONSE' | 'COMPONENT_PONG' | 'AUTH_RESPONSE' | 'ROOM_EVENT' | 'ROOM_STATE' | 'ROOM_SYSTEM' | 'ROOM_JOINED' | 'ROOM_LEFT';
+    originalType?: string;
+    componentId?: string;
+    success?: boolean;
+    result?: any;
+    requestId?: string;
+    responseId?: string;
+    error?: string;
+    timestamp?: number;
+    connectionId?: string;
+    payload?: any;
+    uploadId?: string;
+    chunkIndex?: number;
+    totalChunks?: number;
+    bytesUploaded?: number;
+    totalBytes?: number;
+    progress?: number;
+    filename?: string;
+    fileUrl?: string;
+    signedState?: any;
+    oldComponentId?: string;
+    newComponentId?: string;
+}
+interface RoomMessage {
+    type: 'ROOM_JOIN' | 'ROOM_LEAVE' | 'ROOM_EMIT' | 'ROOM_STATE_SET' | 'ROOM_STATE_GET';
+    componentId: string;
+    roomId: string;
+    event?: string;
+    data?: any;
+    requestId?: string;
+    timestamp: number;
+}
+interface ComponentState {
+    [key: string]: any;
+}
+interface BroadcastMessage {
+    type: string;
+    payload: any;
+    room?: string;
+    excludeUser?: string;
+}
+interface LiveComponentInstance<TState = ComponentState, TActions = Record<string, Function>> {
+    id: string;
+    state: TState;
+    call: <T extends keyof TActions>(action: T, ...args: any[]) => Promise<any>;
+    set: <K extends keyof TState>(property: K, value: TState[K]) => void;
+    loading: boolean;
+    errors: Record<string, string>;
+    connected: boolean;
+    room?: string;
+}
+interface WebSocketMessage {
+    type: string;
+    componentId?: string;
+    action?: string;
+    payload?: any;
+    timestamp?: number;
+    userId?: string;
+    room?: string;
+    requestId?: string;
+    responseId?: string;
+    expectResponse?: boolean;
+}
+interface HybridState<T> {
+    data: T;
+    validation: StateValidation;
+    conflicts: StateConflict[];
+    status: 'synced' | 'conflict' | 'disconnected';
+}
+interface StateValidation {
+    checksum: string;
+    version: number;
+    source: 'client' | 'server' | 'mount';
+    timestamp: number;
+}
+interface StateConflict {
+    property: string;
+    clientValue: any;
+    serverValue: any;
+    timestamp: number;
+    resolved: boolean;
+}
+interface HybridComponentOptions {
+    fallbackToLocal?: boolean;
+    room?: string;
+    userId?: string;
+    autoMount?: boolean;
+    debug?: boolean;
+    onConnect?: () => void;
+    onMount?: () => void;
+    onRehydrate?: () => void;
+    onDisconnect?: () => void;
+    onError?: (error: string) => void;
+    onStateChange?: (newState: any, oldState: any) => void;
+}
+interface ServerRoomHandle<TState = any, TEvents extends Record<string, any> = Record<string, any>> {
+    readonly id: string;
+    readonly state: TState;
+    join: (initialState?: TState) => void;
+    leave: () => void;
+    emit: <K extends keyof TEvents>(event: K, data: TEvents[K]) => number;
+    on: <K extends keyof TEvents>(event: K, handler: (data: TEvents[K]) => void) => () => void;
+    setState: (updates: Partial<TState>) => void;
+}
+interface ServerRoomProxy<TState = any, TEvents extends Record<string, any> = Record<string, any>> {
+    (roomId: string): ServerRoomHandle<TState, TEvents>;
+    readonly id: string | undefined;
+    readonly state: TState;
+    join: (initialState?: TState) => void;
+    leave: () => void;
+    emit: <K extends keyof TEvents>(event: K, data: TEvents[K]) => number;
+    on: <K extends keyof TEvents>(event: K, handler: (data: TEvents[K]) => void) => () => void;
+    setState: (updates: Partial<TState>) => void;
+}
+interface FileChunkData {
+    uploadId: string;
+    filename: string;
+    fileType: string;
+    fileSize: number;
+    chunkIndex: number;
+    totalChunks: number;
+    chunkSize: number;
+    data: string;
+    hash?: string;
+}
+interface FileUploadStartMessage {
+    type: 'FILE_UPLOAD_START';
+    componentId: string;
+    uploadId: string;
+    filename: string;
+    fileType: string;
+    fileSize: number;
+    chunkSize?: number;
+    requestId?: string;
+}
+interface FileUploadChunkMessage {
+    type: 'FILE_UPLOAD_CHUNK';
+    componentId: string;
+    uploadId: string;
+    chunkIndex: number;
+    totalChunks: number;
+    data: string | Buffer;
+    hash?: string;
+    requestId?: string;
+}
+interface BinaryChunkHeader {
+    type: 'FILE_UPLOAD_CHUNK';
+    componentId: string;
+    uploadId: string;
+    chunkIndex: number;
+    totalChunks: number;
+    requestId?: string;
+}
+interface FileUploadCompleteMessage {
+    type: 'FILE_UPLOAD_COMPLETE';
+    componentId: string;
+    uploadId: string;
+    requestId?: string;
+}
+interface FileUploadProgressResponse {
+    type: 'FILE_UPLOAD_PROGRESS';
+    componentId: string;
+    uploadId: string;
+    chunkIndex: number;
+    totalChunks: number;
+    bytesUploaded: number;
+    totalBytes: number;
+    progress: number;
+    requestId?: string;
+    timestamp: number;
+}
+interface FileUploadCompleteResponse {
+    type: 'FILE_UPLOAD_COMPLETE';
+    componentId: string;
+    uploadId: string;
+    success: boolean;
+    filename?: string;
+    fileUrl?: string;
+    error?: string;
+    requestId?: string;
+    timestamp: number;
+}
+interface ActiveUpload {
+    uploadId: string;
+    componentId: string;
+    filename: string;
+    fileType: string;
+    fileSize: number;
+    totalChunks: number;
+    receivedChunks: Map<number, string | Buffer>;
+    bytesReceived: number;
+    startTime: number;
+    lastChunkTime: number;
+    tempFilePath?: string;
+}
+interface ComponentDefinition<TState = ComponentState> {
+    name: string;
+    initialState: TState;
+    component: new (initialState: TState, ws: any, options?: {
+        room?: string;
+        userId?: string;
+    }) => any;
+}
+
+interface FileUploadConfig {
+    maxUploadSize?: number;
+    chunkTimeout?: number;
+    maxBytesPerUser?: number;
+    quotaResetInterval?: number;
+    allowedTypes?: string[];
+    blockedExtensions?: string[];
+    uploadsDir?: string;
+    /** Custom file assembly handler - if not provided, uses default fs assembly */
+    assembleFile?: (upload: ActiveUpload) => Promise<string>;
+}
+declare class FileUploadManager {
+    private activeUploads;
+    private readonly maxUploadSize;
+    private readonly chunkTimeout;
+    private userUploadBytes;
+    private readonly maxBytesPerUser;
+    private readonly quotaResetInterval;
+    private readonly allowedTypes;
+    private readonly blockedExtensions;
+    private readonly uploadsDir;
+    private readonly customAssembleFile?;
+    private cleanupTimer?;
+    private quotaTimer?;
+    constructor(config?: FileUploadConfig);
+    startUpload(message: FileUploadStartMessage, userId?: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    receiveChunk(message: FileUploadChunkMessage, binaryData?: Buffer | null): Promise<FileUploadProgressResponse | null>;
+    completeUpload(message: FileUploadCompleteMessage): Promise<FileUploadCompleteResponse>;
+    private defaultAssembleFile;
+    private validateContentMagicBytes;
+    private cleanupStaleUploads;
+    private resetUploadQuotas;
+    getUserUploadUsage(userId: string): {
+        used: number;
+        limit: number;
+        remaining: number;
+    };
+    getUploadStatus(uploadId: string): ActiveUpload | null;
+    getStats(): {
+        activeUploads: number;
+        maxUploadSize: number;
+        allowedTypes: string[];
+    };
+    shutdown(): void;
+}
+
+interface ConnectionConfig {
+    maxConnections: number;
+    connectionTimeout: number;
+    heartbeatInterval: number;
+    reconnectAttempts: number;
+    reconnectDelay: number;
+    maxReconnectDelay: number;
+    jitterFactor: number;
+    loadBalancing: 'round-robin' | 'least-connections' | 'random';
+    healthCheckInterval: number;
+    messageQueueSize: number;
+    offlineQueueEnabled: boolean;
+}
+interface ConnectionMetrics {
+    id: string;
+    connectedAt: Date;
+    lastActivity: Date;
+    messagesSent: number;
+    messagesReceived: number;
+    bytesTransferred: number;
+    latency: number;
+    status: 'connecting' | 'connected' | 'disconnecting' | 'disconnected' | 'error';
+    errorCount: number;
+    reconnectCount: number;
+}
+interface ConnectionHealth {
+    id: string;
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    lastCheck: Date;
+    issues: string[];
+    metrics: ConnectionMetrics;
+}
+declare class WebSocketConnectionManager extends EventEmitter {
+    private connections;
+    private connectionMetrics;
+    private connectionPools;
+    private messageQueues;
+    private healthCheckTimer?;
+    private heartbeatTimer?;
+    private config;
+    private loadBalancerIndex;
+    constructor(config?: Partial<ConnectionConfig>);
+    registerConnection(ws: GenericWebSocket, connectionId: string, poolId?: string): void;
+    addToPool(connectionId: string, poolId: string): void;
+    removeFromPool(connectionId: string, poolId: string): void;
+    cleanupConnection(connectionId: string): void;
+    getConnectionMetrics(connectionId: string): ConnectionMetrics | null;
+    getAllConnectionMetrics(): ConnectionMetrics[];
+    getSystemStats(): {
+        totalConnections: number;
+        activeConnections: number;
+        totalPools: number;
+        totalQueuedMessages: number;
+        maxConnections: number;
+        connectionUtilization: number;
+    };
+    private setupHealthMonitoring;
+    private setupHeartbeat;
+    private performHealthChecks;
+    shutdown(): void;
+}
+
+interface LiveRoomManagerInterface {
+    joinRoom<TState = any>(componentId: string, roomId: string, ws: any, initialState?: TState): {
+        state: TState;
+    };
+    leaveRoom(componentId: string, roomId: string): void;
+    cleanupComponent(componentId: string): void;
+    emitToRoom(roomId: string, event: string, data: any, excludeComponentId?: string): number;
+    setRoomState(roomId: string, updates: any, excludeComponentId?: string): void;
+    getRoomState<TState = any>(roomId: string): TState;
+    isInRoom(componentId: string, roomId: string): boolean;
+    getComponentRooms(componentId: string): string[];
+    getStats(): any;
+}
+interface LiveDebuggerInterface {
+    enabled: boolean;
+    trackStateChange(componentId: string, delta: Record<string, unknown>, fullState: Record<string, unknown>, source?: string): void;
+    trackActionCall(componentId: string, action: string, payload: unknown): void;
+    trackActionResult(componentId: string, action: string, result: unknown, duration: number): void;
+    trackActionError(componentId: string, action: string, error: string, duration: number): void;
+    trackRoomEmit(componentId: string, roomId: string, event: string, data: unknown): void;
+}
+interface LiveComponentContext {
+    roomEvents: RoomEventBus;
+    roomManager: LiveRoomManagerInterface;
+    debugger?: LiveDebuggerInterface;
+}
+/**
+ * Set the global Live Component context.
+ * Called once by LiveServer.start() before any components are mounted.
+ */
+declare function setLiveComponentContext(ctx: LiveComponentContext): void;
+/**
+ * Get the global Live Component context.
+ * Throws if LiveServer.start() hasn't been called yet.
+ */
+declare function getLiveComponentContext(): LiveComponentContext;
+
+/** @internal Symbol key for singleton emit override */
+declare const EMIT_OVERRIDE_KEY: unique symbol;
+declare abstract class LiveComponent<TState = ComponentState, TPrivate extends Record<string, any> = Record<string, any>> {
+    /** Component name for registry lookup - must be defined in subclasses */
+    static componentName: string;
+    /** Default state - must be defined in subclasses */
+    static defaultState: any;
+    /**
+     * Per-component logging control. Silent by default.
+     *
+     * @example
+     * static logging = true                           // all categories
+     * static logging = ['lifecycle', 'messages']      // specific categories
+     */
+    static logging?: boolean | readonly ('lifecycle' | 'messages' | 'state' | 'performance' | 'rooms' | 'websocket')[];
+    /**
+     * Component-level auth configuration.
+     */
+    static auth?: LiveComponentAuth;
+    /**
+     * Per-action auth configuration.
+     */
+    static actionAuth?: LiveActionAuthMap;
+    /**
+     * Data that survives HMR reloads.
+     */
+    static persistent?: Record<string, any>;
+    /**
+     * When true, only ONE server-side instance exists for this component.
+     * All clients share the same state.
+     */
+    static singleton?: boolean;
+    readonly id: string;
+    private _state;
+    state: TState;
+    protected ws: GenericWebSocket;
+    room?: string;
+    userId?: string;
+    broadcastToRoom: (message: BroadcastMessage) => void;
+    private _privateState;
+    private _authContext;
+    private roomEventUnsubscribers;
+    private joinedRooms;
+    protected roomType: string;
+    private roomHandles;
+    private _inStateChange;
+    [EMIT_OVERRIDE_KEY]: ((type: string, payload: any) => void) | null;
+    constructor(initialState: Partial<TState>, ws: GenericWebSocket, options?: {
+        room?: string;
+        userId?: string;
+    });
+    private createDirectStateAccessors;
+    private createStateProxy;
+    get $private(): TPrivate;
+    get $room(): ServerRoomProxy;
+    /**
+     * List of room IDs this component is participating in
+     */
+    get $rooms(): string[];
+    get $auth(): LiveAuthContext;
+    /** @internal */
+    setAuthContext(context: LiveAuthContext): void;
+    get $persistent(): Record<string, any>;
+    protected onConnect(): void;
+    protected onMount(): void | Promise<void>;
+    protected onDisconnect(): void;
+    protected onDestroy(): void;
+    protected onStateChange(changes: Partial<TState>): void;
+    protected onRoomJoin(roomId: string): void;
+    protected onRoomLeave(roomId: string): void;
+    protected onRehydrate(previousState: TState): void;
+    protected onAction(action: string, payload: any): void | false | Promise<void | false>;
+    protected onClientJoin(connectionId: string, connectionCount: number): void;
+    protected onClientLeave(connectionId: string, connectionCount: number): void;
+    setState(updates: Partial<TState> | ((prev: TState) => Partial<TState>)): void;
+    setValue<K extends keyof TState>(payload: {
+        key: K;
+        value: TState[K];
+    }): Promise<{
+        success: true;
+        key: K;
+        value: TState[K];
+    }>;
+    static publicActions?: readonly string[];
+    private static readonly BLOCKED_ACTIONS;
+    executeAction(action: string, payload: any): Promise<any>;
+    protected emit(type: string, payload: any): void;
+    protected broadcast(type: string, payload: any, excludeCurrentUser?: boolean): void;
+    protected emitRoomEvent(event: string, data: any, notifySelf?: boolean): number;
+    protected onRoomEvent<T = any>(event: string, handler: (data: T) => void): void;
+    protected emitRoomEventWithState(event: string, data: any, stateUpdates: Partial<TState>): number;
+    protected subscribeToRoom(roomId: string): Promise<void>;
+    protected unsubscribeFromRoom(): Promise<void>;
+    private generateId;
+    destroy(): void;
+    getSerializableState(): TState;
+}
+
+interface ComponentMetadata {
+    id: string;
+    name: string;
+    version: string;
+    mountedAt: Date;
+    lastActivity: Date;
+    state: 'mounting' | 'active' | 'inactive' | 'error' | 'destroying';
+    healthStatus: 'healthy' | 'degraded' | 'unhealthy';
+    dependencies: string[];
+    services: Map<string, any>;
+    metrics: ComponentMetrics;
+    migrationHistory: StateMigration[];
+}
+interface ComponentMetrics {
+    renderCount: number;
+    actionCount: number;
+    errorCount: number;
+    averageRenderTime: number;
+    memoryUsage: number;
+    lastRenderTime?: number;
+}
+interface StateMigration {
+    fromVersion: string;
+    toVersion: string;
+    migratedAt: Date;
+    success: boolean;
+    error?: string;
+}
+interface ComponentRegistryDeps {
+    authManager: LiveAuthManager;
+    debugger: LiveDebugger;
+    stateSignature: StateSignatureManager;
+    performanceMonitor: PerformanceMonitor;
+}
+declare class ComponentRegistry {
+    private components;
+    private definitions;
+    private metadata;
+    private rooms;
+    private wsConnections;
+    private autoDiscoveredComponents;
+    private healthCheckInterval?;
+    private singletons;
+    private authManager;
+    private debugger;
+    private stateSignature;
+    private performanceMonitor;
+    constructor(deps: ComponentRegistryDeps);
+    private setupHealthMonitoring;
+    registerComponent<TState>(definition: ComponentDefinition<TState>): void;
+    registerComponentClass(name: string, componentClass: new (initialState: any, ws: GenericWebSocket, options?: {
+        room?: string;
+        userId?: string;
+    }) => LiveComponent<any>): void;
+    autoDiscoverComponents(componentsPath: string): Promise<void>;
+    private isLiveComponentClass;
+    mountComponent(ws: GenericWebSocket, componentName: string, props?: Record<string, unknown>, options?: {
+        room?: string;
+        userId?: string;
+        version?: string;
+        debugLabel?: string;
+    }): Promise<{
+        componentId: string;
+        initialState: unknown;
+        signedState: unknown;
+    }>;
+    rehydrateComponent(componentId: string, componentName: string, signedState: SignedState, ws: GenericWebSocket, options?: {
+        room?: string;
+        userId?: string;
+    }): Promise<{
+        success: boolean;
+        newComponentId?: string;
+        error?: string;
+    }>;
+    private ensureWsData;
+    private isSingletonComponent;
+    private removeSingletonConnection;
+    unmountComponent(componentId: string, ws?: GenericWebSocket): Promise<void>;
+    private getSingletonName;
+    executeAction(componentId: string, action: string, payload: any): Promise<any>;
+    updateProperty(componentId: string, property: string, value: any): void;
+    subscribeToRoom(componentId: string, roomId: string): void;
+    unsubscribeFromRoom(componentId: string, roomId: string): void;
+    private unsubscribeFromAllRooms;
+    broadcastToRoom(message: BroadcastMessage, senderComponentId?: string): void;
+    handleMessage(ws: GenericWebSocket, message: LiveMessage): Promise<{
+        success: boolean;
+        result?: unknown;
+        error?: string;
+    } | null>;
+    cleanupConnection(ws: GenericWebSocket): void;
+    getStats(): {
+        components: number;
+        definitions: number;
+        rooms: number;
+        connections: number;
+        singletons: {
+            [k: string]: {
+                componentId: string;
+                connections: number;
+            };
+        };
+        roomDetails: {
+            [k: string]: number;
+        };
+    };
+    getRegisteredComponentNames(): string[];
+    getComponent(componentId: string): LiveComponent | undefined;
+    getRoomComponents(roomId: string): LiveComponent[];
+    private createComponentMetadata;
+    updateComponentActivity(componentId: string): boolean;
+    recordComponentMetrics(componentId: string, renderTime?: number, action?: string): void;
+    recordComponentError(componentId: string, error: Error): void;
+    private performHealthChecks;
+    private cleanupComponent;
+    cleanup(): void;
+}
+
+declare class ConnectionRateLimiter {
+    private tokens;
+    private lastRefill;
+    private readonly maxTokens;
+    private readonly refillRate;
+    constructor(maxTokens?: number, refillRate?: number);
+    tryConsume(count?: number): boolean;
+    private refill;
+}
+/**
+ * Manages rate limiters for all connections.
+ */
+declare class RateLimiterRegistry {
+    private limiters;
+    private maxTokens;
+    private refillRate;
+    constructor(maxTokens?: number, refillRate?: number);
+    /**
+     * Get or create a rate limiter for a connection.
+     */
+    get(connectionId: string): ConnectionRateLimiter;
+    /**
+     * Remove a rate limiter for a disconnected connection.
+     */
+    remove(connectionId: string): void;
+}
+
+interface LiveServerOptions {
+    /** Transport adapter (Elysia, Express, etc.) */
+    transport: LiveTransport;
+    /** WebSocket endpoint path. Defaults to '/api/live/ws' */
+    wsPath?: string;
+    /** Enable debug mode. Defaults to false. */
+    debug?: boolean;
+    /** State signature configuration */
+    stateSignature?: StateSignatureConfig;
+    /** Performance monitor configuration */
+    performance?: PerformanceConfig;
+    /** File upload configuration */
+    fileUpload?: FileUploadConfig;
+    /** Connection manager configuration */
+    connection?: Partial<ConnectionConfig>;
+    /** Rate limiter: max tokens per connection */
+    rateLimitMaxTokens?: number;
+    /** Rate limiter: tokens refilled per second */
+    rateLimitRefillRate?: number;
+    /** Components path for auto-discovery */
+    componentsPath?: string;
+    /** HTTP monitoring routes prefix. Set to false to disable. Defaults to '/api/live' */
+    httpPrefix?: string | false;
+}
+declare class LiveServer {
+    readonly roomEvents: RoomEventBus;
+    readonly roomManager: LiveRoomManager;
+    readonly debugger: LiveDebugger;
+    readonly authManager: LiveAuthManager;
+    readonly stateSignature: StateSignatureManager;
+    readonly performanceMonitor: PerformanceMonitor;
+    readonly fileUploadManager: FileUploadManager;
+    readonly connectionManager: WebSocketConnectionManager;
+    readonly registry: ComponentRegistry;
+    readonly rateLimiter: RateLimiterRegistry;
+    private transport;
+    private options;
+    constructor(options: LiveServerOptions);
+    /**
+     * Register an auth provider.
+     */
+    useAuth(provider: LiveAuthProvider): this;
+    /**
+     * Start the LiveServer: register WS + HTTP handlers on the transport.
+     */
+    start(): Promise<void>;
+    /**
+     * Graceful shutdown.
+     */
+    shutdown(): Promise<void>;
+    private handleOpen;
+    private handleMessage;
+    private handleClose;
+    private handleError;
+    private handleRoomMessage;
+    private buildHttpRoutes;
+}
+
+/**
+ * Encode a binary chunk message for transmission.
+ * @param header - JSON metadata about the chunk
+ * @param data - Raw binary data
+ * @returns Combined buffer ready to send over WebSocket
+ */
+declare function encodeBinaryChunk(header: BinaryChunkHeader, data: Buffer | Uint8Array): Buffer;
+/**
+ * Decode a binary chunk message received over WebSocket.
+ * @param raw - Raw ArrayBuffer or Uint8Array from WebSocket
+ * @returns Parsed header and binary chunk data
+ */
+declare function decodeBinaryChunk(raw: ArrayBuffer | Uint8Array): {
+    header: BinaryChunkHeader;
+    data: Buffer;
+};
+
+/** Current protocol version */
+declare const PROTOCOL_VERSION = 1;
+/** Default WebSocket path */
+declare const DEFAULT_WS_PATH = "/api/live/ws";
+/** Default chunk size for file uploads (64KB) */
+declare const DEFAULT_CHUNK_SIZE: number;
+
+/**
+ * Auth context for authenticated users.
+ * Provides type-safe helpers for role and permission checks.
+ *
+ * Used internally by the framework - devs access via this.$auth in LiveComponent.
+ */
+declare class AuthenticatedContext implements LiveAuthContext {
+    readonly authenticated = true;
+    readonly user: LiveAuthUser;
+    readonly token?: string;
+    readonly authenticatedAt: number;
+    constructor(user: LiveAuthUser, token?: string);
+    hasRole(role: string): boolean;
+    hasAnyRole(roles: string[]): boolean;
+    hasAllRoles(roles: string[]): boolean;
+    hasPermission(permission: string): boolean;
+    hasAllPermissions(permissions: string[]): boolean;
+    hasAnyPermission(permissions: string[]): boolean;
+}
+/**
+ * Context for unauthenticated users (guest).
+ * Returned when no credentials are provided or when auth fails.
+ */
+declare class AnonymousContext implements LiveAuthContext {
+    readonly authenticated = false;
+    readonly user: undefined;
+    readonly token: undefined;
+    readonly authenticatedAt: undefined;
+    hasRole(): boolean;
+    hasAnyRole(): boolean;
+    hasAllRoles(): boolean;
+    hasPermission(): boolean;
+    hasAllPermissions(): boolean;
+    hasAnyPermission(): boolean;
+}
+/** Singleton for anonymous contexts */
+declare const ANONYMOUS_CONTEXT: AnonymousContext;
+
+type RoomStateData = Record<string, any>;
+interface RoomInfo {
+    state: RoomStateData;
+    componentCount: number;
+    createdAt: number;
+    lastUpdate: number;
+}
+declare function createTypedRoomState<TRoomTypes extends Record<string, RoomStateData>>(): {
+    get<K extends keyof TRoomTypes>(type: K, roomId: string, defaultState: TRoomTypes[K]): TRoomTypes[K];
+    update<K extends keyof TRoomTypes>(type: K, roomId: string, updates: Partial<TRoomTypes[K]>): TRoomTypes[K];
+    set<K extends keyof TRoomTypes>(type: K, roomId: string, state: TRoomTypes[K]): void;
+    join<K extends keyof TRoomTypes>(type: K, roomId: string): void;
+    leave<K extends keyof TRoomTypes>(type: K, roomId: string): void;
+    has<K extends keyof TRoomTypes>(type: K, roomId: string): boolean;
+    delete<K extends keyof TRoomTypes>(type: K, roomId: string): boolean;
+    getStats(): {
+        totalRooms: number;
+        rooms: Record<string, {
+            componentCount: number;
+            stateKeys: string[];
+        }>;
+    };
+};
+declare class RoomStateManager {
+    private rooms;
+    get<T extends RoomStateData>(roomId: string, defaultState?: T): T;
+    update<T extends RoomStateData>(roomId: string, updates: Partial<T>): T;
+    set<T extends RoomStateData>(roomId: string, state: T): void;
+    join(roomId: string): void;
+    leave(roomId: string): void;
+    has(roomId: string): boolean;
+    delete(roomId: string): boolean;
+    getStats(): {
+        totalRooms: number;
+        rooms: Record<string, {
+            componentCount: number;
+            stateKeys: string[];
+        }>;
+    };
+}
+
+type LiveLogCategory = 'lifecycle' | 'messages' | 'state' | 'performance' | 'rooms' | 'websocket';
+type LiveLogConfig = boolean | readonly LiveLogCategory[];
+/**
+ * Register a component's logging config (called on mount)
+ */
+declare function registerComponentLogging(componentId: string, config: LiveLogConfig | undefined): void;
+/**
+ * Unregister component logging (called on unmount/cleanup)
+ */
+declare function unregisterComponentLogging(componentId: string): void;
+/**
+ * Log a message gated by the component's logging config.
+ * Always forwarded to the Live Debugger when active.
+ */
+declare function liveLog(category: LiveLogCategory, componentId: string | null, message: string, ...args: unknown[]): void;
+/**
+ * Warn-level log gated by config.
+ * Always forwarded to the Live Debugger when active.
+ */
+declare function liveWarn(category: LiveLogCategory, componentId: string | null, message: string, ...args: unknown[]): void;
+
+/**
+ * Extract all public action methods from a LiveComponent class
+ * Excludes constructor, destroy, lifecycle methods, and inherited methods
+ */
+type ExtractActions<T extends LiveComponent<any>> = {
+    [K in keyof T as K extends string ? T[K] extends (payload?: any) => Promise<any> ? K extends 'executeAction' | 'destroy' | 'getSerializableState' | 'setState' ? never : K : never : never]: T[K];
+};
+/**
+ * Get all action names from a component
+ */
+type ActionNames<T extends LiveComponent<any>> = keyof ExtractActions<T>;
+/**
+ * Get the payload type for a specific action
+ */
+type ActionPayload<T extends LiveComponent<any>, K extends ActionNames<T>> = ExtractActions<T>[K] extends (payload: infer P) => any ? P : ExtractActions<T>[K] extends () => any ? undefined : never;
+/**
+ * Get the return type for a specific action (unwrapped from Promise)
+ */
+type ActionReturn<T extends LiveComponent<any>, K extends ActionNames<T>> = ExtractActions<T>[K] extends (...args: any[]) => Promise<infer R> ? R : ExtractActions<T>[K] extends (...args: any[]) => infer R ? R : never;
+/**
+ * Get the state type from a LiveComponent class
+ */
+type InferComponentState<T extends LiveComponent<any>> = T extends LiveComponent<infer S> ? S : never;
+/**
+ * Get the private state type from a LiveComponent class
+ */
+type InferPrivateState<T extends LiveComponent<any, any>> = T extends LiveComponent<any, infer P> ? P : never;
+/**
+ * Type-safe call signature for a component
+ */
+type TypedCall<T extends LiveComponent<any>> = <K extends ActionNames<T>>(action: K, ...args: ActionPayload<T, K> extends undefined ? [] : [payload: ActionPayload<T, K>]) => Promise<void>;
+/**
+ * Type-safe callAndWait signature for a component
+ */
+type TypedCallAndWait<T extends LiveComponent<any>> = <K extends ActionNames<T>>(action: K, ...args: ActionPayload<T, K> extends undefined ? [payload?: undefined, timeout?: number] : [payload: ActionPayload<T, K>, timeout?: number]) => Promise<ActionReturn<T, K>>;
+/**
+ * Type-safe setValue signature for a component
+ */
+type TypedSetValue<T extends LiveComponent<any>> = <K extends keyof InferComponentState<T>>(key: K, value: InferComponentState<T>[K]) => Promise<void>;
+/**
+ * Return type for useTypedLiveComponent hook
+ */
+interface UseTypedLiveComponentReturn<T extends LiveComponent<any>> {
+    state: InferComponentState<T>;
+    loading: boolean;
+    error: string | null;
+    connected: boolean;
+    componentId: string | null;
+    status: 'synced' | 'disconnected' | 'connecting' | 'reconnecting' | 'loading' | 'mounting' | 'error';
+    call: TypedCall<T>;
+    callAndWait: TypedCallAndWait<T>;
+    setValue: TypedSetValue<T>;
+    mount: () => Promise<void>;
+    unmount: () => Promise<void>;
+    useControlledField: <K extends keyof InferComponentState<T>>(field: K, action?: string) => {
+        value: InferComponentState<T>[K];
+        setValue: (value: InferComponentState<T>[K]) => void;
+        commit: (value?: InferComponentState<T>[K]) => Promise<void>;
+        isDirty: boolean;
+    };
+}
+
+export { ANONYMOUS_CONTEXT, type ActionNames, type ActionPayload, type ActionReturn, type ActiveUpload, AnonymousContext, AuthenticatedContext, type BinaryChunkHeader, type BroadcastMessage, type ComponentDefinition, type ComponentMetadata, type ComponentMetrics, type ComponentPerformanceMetrics, ComponentRegistry, type ComponentSnapshot, type ComponentState, type ConnectionConfig, type ConnectionHealth, type ConnectionMetrics, ConnectionRateLimiter, DEFAULT_CHUNK_SIZE, DEFAULT_WS_PATH, type DebugEvent, type DebugEventType, type DebugSnapshot, type DebugWsMessage, type EventHandler, type ExtractActions, type FileChunkData, type FileUploadChunkMessage, type FileUploadCompleteMessage, type FileUploadCompleteResponse, type FileUploadConfig, FileUploadManager, type FileUploadProgressResponse, type FileUploadStartMessage, type FluxStackWSData, type FluxStackWebSocket, type GenericWebSocket, type HttpRequest, type HttpResponse, type HttpRouteDefinition, type HybridComponentOptions, type HybridState, type InferComponentState, type InferPrivateState, type LiveActionAuth, type LiveActionAuthMap, type LiveAuthContext, type LiveAuthCredentials, LiveAuthManager, type LiveAuthProvider, type LiveAuthResult, type LiveAuthUser, LiveComponent, type LiveComponentAuth, type LiveComponentContext, type LiveComponentInstance, LiveDebugger, type LiveLogCategory, type LiveLogConfig, type LiveMessage, LiveRoomManager, LiveServer, type LiveServerOptions, type LiveTransport, type LiveWSData, PROTOCOL_VERSION, type PerformanceAlert, type PerformanceConfig, PerformanceMonitor, RateLimiterRegistry, RoomEventBus, type RoomInfo, type RoomMessage, type RoomStateData, RoomStateManager, type RoomSubscription, type ServerRoomHandle, type ServerRoomProxy, type SignedState, type StateMigration, type StateSignatureConfig, StateSignatureManager, type TypedCall, type TypedCallAndWait, type TypedSetValue, type UseTypedLiveComponentReturn, type WebSocketConfig, WebSocketConnectionManager, type WebSocketMessage, type WebSocketResponse, createTypedRoomEventBus, createTypedRoomState, decodeBinaryChunk, encodeBinaryChunk, getLiveComponentContext, liveLog, liveWarn, registerComponentLogging, setLiveComponentContext, unregisterComponentLogging };