@fluxstack/live 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -296,11 +296,229 @@ interface IRoomPubSubAdapter {
     publishStateChange(roomId: string, updates: any): Promise<void>;
 }
 
+interface LiveRoomManagerInterface {
+    joinRoom<TState = any>(componentId: string, roomId: string, ws: any, initialState?: TState, options?: {
+        deepDiff?: boolean;
+        deepDiffDepth?: number;
+        serverOnlyState?: boolean;
+    }, joinContext?: {
+        userId?: string;
+        payload?: any;
+    }): {
+        state: TState;
+        rejected?: false;
+    } | {
+        rejected: true;
+        reason: string;
+    };
+    leaveRoom(componentId: string, roomId: string, leaveReason?: 'leave' | 'disconnect' | 'cleanup'): 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[];
+    getMemberCount?(roomId: string): number;
+    getRoomInstance?(roomId: string): LiveRoom<any, any, any> | undefined;
+    getStats(): any;
+}
+interface LiveComponentContext {
+    roomEvents: RoomEventBus;
+    roomManager: LiveRoomManagerInterface;
+}
+/**
+ * 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;
+
+declare const BINARY_ROOM_EVENT = 2;
+declare const BINARY_ROOM_STATE = 3;
+interface RoomCodec {
+    encode(data: unknown): Uint8Array;
+    decode(buf: Uint8Array): unknown;
+}
+declare const msgpackCodec: RoomCodec;
+declare const jsonCodec: RoomCodec;
+type RoomCodecOption = 'msgpack' | 'json' | RoomCodec;
+declare function resolveCodec(option?: RoomCodecOption): RoomCodec;
+/**
+ * Build a binary room frame.
+ * Format: [frameType:u8][compIdLen:u8][compId:utf8][roomIdLen:u8][roomId:utf8][eventLen:u16BE][event:utf8][payload]
+ */
+declare function buildRoomFrame(frameType: number, componentId: string, roomId: string, event: string, payload: Uint8Array): Uint8Array;
+/**
+ * Build frame tail (roomId + event + payload) that is shared across all members.
+ * Per-member: prepend [frameType:u8][compIdLen:u8][compId:utf8].
+ */
+declare function buildRoomFrameTail(roomId: string, event: string, payload: Uint8Array): Uint8Array;
+/**
+ * Prepend per-member header to a shared tail.
+ * Header: [frameType:u8][compIdLen:u8][compId:utf8]
+ */
+declare function prependMemberHeader(frameType: number, componentId: string, tail: Uint8Array): Uint8Array;
+/**
+ * Parse a binary room frame header (client-side).
+ * Returns parsed fields and the payload offset.
+ */
+declare function parseRoomFrame(buf: Uint8Array): {
+    frameType: number;
+    componentId: string;
+    roomId: string;
+    event: string;
+    payload: Uint8Array;
+} | null;
+
+interface RoomJoinContext {
+    componentId: string;
+    userId?: string;
+    payload?: any;
+}
+interface RoomLeaveContext {
+    componentId: string;
+    userId?: string;
+    reason: 'leave' | 'disconnect' | 'cleanup';
+}
+interface RoomEventContext {
+    componentId: string;
+    userId?: string;
+}
+interface LiveRoomOptions {
+    /** Enable deep diff for room state. Default: true */
+    deepDiff?: boolean;
+    /** Max recursion depth for deep diff. Default: 3 */
+    deepDiffDepth?: number;
+    /** Max number of members allowed. Undefined = unlimited */
+    maxMembers?: number;
+    /**
+     * Wire codec for room messages. Default: 'msgpack' (binary).
+     * - 'msgpack' — Built-in MessagePack encoder (zero deps, ~30% smaller, ~2-3x faster)
+     * - 'json' — Standard JSON (text-based, larger but human-readable)
+     * - Custom RoomCodec object with encode/decode methods
+     */
+    codec?: RoomCodecOption;
+}
+/**
+ * Base class for typed rooms with lifecycle hooks and public/private state.
+ *
+ * @typeParam TState - Public state synced to all connected clients
+ * @typeParam TMeta - Private server-only metadata (never broadcasted)
+ * @typeParam TEvents - Event map for typed emit/on
+ */
+declare abstract class LiveRoom<TState extends Record<string, any> = Record<string, any>, TMeta extends Record<string, any> = Record<string, any>, TEvents extends Record<string, any> = Record<string, any>> {
+    /** Unique room type name. Used as prefix in compound room IDs (e.g. "chat:lobby"). */
+    static roomName: string;
+    /** Initial public state template. Cloned per room instance. */
+    static defaultState: Record<string, any>;
+    /** Initial private metadata template. Cloned per room instance. */
+    static defaultMeta: Record<string, any>;
+    /** Room-level options */
+    static $options?: LiveRoomOptions;
+    /** The unique room instance identifier (e.g. "chat:lobby") */
+    readonly id: string;
+    /** Public state — synced to all connected clients via setState(). */
+    state: TState;
+    /** Private metadata — NEVER leaves the server. Mutate directly. */
+    meta: TMeta;
+    /** @internal Type brand for client-side event inference.
+     * No runtime value. Usage: `$room<CounterRoom>('id').on(...)` */
+    readonly $events: TEvents;
+    /** @internal Reference to the room manager for broadcasting */
+    protected readonly _manager: LiveRoomManagerInterface;
+    constructor(id: string, manager: LiveRoomManagerInterface);
+    /**
+     * Update public state and broadcast changes to all room members.
+     * Uses deep diff by default — only changed fields are sent over the wire.
+     */
+    setState(updates: Partial<TState>): void;
+    /**
+     * Emit a typed event to all members in this room.
+     * @returns Number of members notified
+     */
+    emit<K extends keyof TEvents & string>(event: K, data: TEvents[K]): number;
+    /** Get current member count */
+    get memberCount(): number;
+    /**
+     * Called when a component attempts to join this room.
+     * Return false to reject the join.
+     */
+    onJoin(_ctx: RoomJoinContext): void | false | Promise<void | false>;
+    /**
+     * Called after a component leaves this room.
+     */
+    onLeave(_ctx: RoomLeaveContext): void | Promise<void>;
+    /**
+     * Called when an event is emitted to this room.
+     * Can intercept/validate events before broadcasting.
+     */
+    onEvent(_event: string, _data: any, _ctx: RoomEventContext): void | Promise<void>;
+    /**
+     * Called once when the room is first created (first member joins).
+     */
+    onCreate(): void | Promise<void>;
+    /**
+     * Called when the last member leaves and the room is about to be destroyed.
+     * Return false to keep the room alive (e.g., persist state).
+     */
+    onDestroy(): void | false | Promise<void | false>;
+}
+/** Extract the public state type from a LiveRoom subclass */
+type InferRoomState<R> = R extends LiveRoom<infer S, any, any> ? S : Record<string, any>;
+/** Extract the private meta type from a LiveRoom subclass */
+type InferRoomMeta<R> = R extends LiveRoom<any, infer M, any> ? M : Record<string, any>;
+/** Extract the events type from a LiveRoom subclass */
+type InferRoomEvents<R> = R extends LiveRoom<any, any, infer E> ? E : Record<string, any>;
+/** LiveRoom class constructor type */
+type LiveRoomClass<R extends LiveRoom = LiveRoom> = {
+    new (id: string, manager: LiveRoomManagerInterface): R;
+    roomName: string;
+    defaultState: Record<string, any>;
+    defaultMeta: Record<string, any>;
+    $options?: LiveRoomOptions;
+};
+
+declare class RoomRegistry {
+    private rooms;
+    /**
+     * Register a LiveRoom subclass.
+     * @throws If the class doesn't define a static roomName
+     */
+    register(roomClass: LiveRoomClass): void;
+    /**
+     * Get a registered room class by name.
+     */
+    get(name: string): LiveRoomClass | undefined;
+    /**
+     * Check if a room class is registered.
+     */
+    has(name: string): boolean;
+    /**
+     * Resolve a compound room ID (e.g. "chat:lobby") to its registered class.
+     * Returns undefined if the prefix doesn't match any registered room.
+     */
+    resolveFromId(roomId: string): LiveRoomClass | undefined;
+    /**
+     * Get all registered room names.
+     */
+    getRegisteredNames(): string[];
+    /**
+     * Check if a value is a LiveRoom subclass.
+     */
+    static isLiveRoomClass(cls: unknown): cls is LiveRoomClass;
+}
+
 declare class LiveRoomManager {
     private roomEvents;
     private pubsub?;
     private rooms;
     private componentRooms;
+    /** Room registry for LiveRoom class lookup. Set by LiveServer. */
+    roomRegistry?: RoomRegistry;
     /**
      * @param roomEvents - Local server-side event bus
      * @param pubsub - Optional cross-instance pub/sub adapter (e.g. Redis).
@@ -309,28 +527,44 @@ declare class LiveRoomManager {
      */
     constructor(roomEvents: RoomEventBus, pubsub?: IRoomPubSubAdapter | undefined);
     /**
-     * Component joins a room
+     * Component joins a room.
+     * @param options.deepDiff - Enable/disable deep diff for this room's state. Default: true
+     * @param joinContext - Optional context for LiveRoom lifecycle hooks (userId, payload)
      */
-    joinRoom<TState = any>(componentId: string, roomId: string, ws: GenericWebSocket, initialState?: TState): {
+    joinRoom<TState = any>(componentId: string, roomId: string, ws: GenericWebSocket, initialState?: TState, options?: {
+        deepDiff?: boolean;
+        deepDiffDepth?: number;
+        serverOnlyState?: boolean;
+    }, joinContext?: {
+        userId?: string;
+        payload?: any;
+    }): {
         state: TState;
+        rejected?: false;
+    } | {
+        rejected: true;
+        reason: string;
     };
     /**
      * Component leaves a room
+     * @param leaveReason - Why the component is leaving. Default: 'leave'
      */
-    leaveRoom(componentId: string, roomId: string): void;
+    leaveRoom(componentId: string, roomId: string, leaveReason?: 'leave' | 'disconnect' | 'cleanup'): void;
     /**
      * Component disconnects - leave all rooms.
-     * Batches removals: removes member from all rooms first,
+     * Batches removals: calls onLeave hooks, removes member from all rooms,
      * then sends leave notifications in bulk.
      */
     cleanupComponent(componentId: string): void;
     /**
-     * Emit event to all members in a room
+     * Emit event to all members in a room.
+     * For LiveRoom-backed rooms, calls onEvent() hook before broadcasting.
      */
     emitToRoom(roomId: string, event: string, data: any, excludeComponentId?: string): number;
     /**
      * Update room state.
-     * Mutates state in-place with Object.assign to avoid full-object spread.
+     * When deepDiff is enabled (default), deep-diffs plain objects to send only changed fields.
+     * When disabled, uses shallow diff (reference equality) like classic behavior.
      */
     setRoomState(roomId: string, updates: any, excludeComponentId?: string): void;
     /**
@@ -339,17 +573,35 @@ declare class LiveRoomManager {
     getRoomState<TState = any>(roomId: string): TState;
     /**
      * Broadcast to all members in a room.
-     * Serializes the message ONCE and sends the same string to all members.
+     *
+     * When the room has a binary codec (LiveRoom-backed), builds a binary frame
+     * once (encode payload + frame tail), then prepends per-member componentId header.
+     *
+     * When no codec (legacy rooms), uses JSON with serialize-once optimization:
+     * builds the JSON string template once, then inserts each member's componentId.
      */
     private broadcastToRoom;
     /**
      * Check if component is in a room
      */
     isInRoom(componentId: string, roomId: string): boolean;
+    /**
+     * Check if room state is server-only (no client writes)
+     */
+    isServerOnlyState(roomId: string): boolean;
     /**
      * Get rooms for a component
      */
     getComponentRooms(componentId: string): string[];
+    /**
+     * Get member count for a room
+     */
+    getMemberCount(roomId: string): number;
+    /**
+     * Get the LiveRoom instance for a room (if backed by a typed room class).
+     * Used by ComponentRoomProxy to expose custom methods.
+     */
+    getRoomInstance(roomId: string): LiveRoom<any, any, any> | undefined;
     /**
      * Get statistics
      */
@@ -363,80 +615,6 @@ declare class LiveRoomManager {
     };
 }
 
-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?;
@@ -953,46 +1131,19 @@ declare class WebSocketConnectionManager extends EventEmitter {
     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;
-
 /** Symbol key for singleton emit override */
 declare const EMIT_OVERRIDE_KEY: unique symbol;
 
+interface ComponentOptions {
+    /** Enable deep diff for plain objects in setState(). Default: false */
+    deepDiff?: boolean;
+    /** Enable deep diff for room state updates. Default: true */
+    roomDeepDiff?: boolean;
+    /** Max recursion depth for deep diff (component + room). Default: 3 */
+    deepDiffDepth?: number;
+    /** When true, room state can only be set from server-side code. Client ROOM_STATE_SET is rejected. Default: false */
+    serverOnlyRoomState?: boolean;
+}
 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;
@@ -1052,6 +1203,13 @@ declare abstract class LiveComponent<TState = ComponentState, TPrivate extends R
      * All clients share the same state.
      */
     static singleton?: boolean;
+    /**
+     * Component behavior options.
+     *
+     * @example
+     * static $options = { deepDiff: true }
+     */
+    static $options?: ComponentOptions;
     readonly id: string;
     state: TState;
     protected ws: GenericWebSocket;
@@ -1073,7 +1231,30 @@ declare abstract class LiveComponent<TState = ComponentState, TPrivate extends R
         userId?: string;
     });
     get $private(): TPrivate;
-    get $room(): ServerRoomProxy;
+    /**
+     * Unified room accessor.
+     *
+     * Usage:
+     * - `this.$room` — default room handle (legacy)
+     * - `this.$room('roomId')` — untyped room handle (legacy)
+     * - `this.$room(ChatRoom, 'lobby')` — typed handle with custom methods
+     */
+    get $room(): ServerRoomProxy & {
+        <R extends LiveRoom<any, any, any>>(roomClass: LiveRoomClass<R>, instanceId: string): R & {
+            readonly id: string;
+            join: (payload?: any) => {
+                rejected?: false;
+            } | {
+                rejected: true;
+                reason: string;
+            };
+            leave: () => void;
+            emit: R['emit'];
+            on: <K extends string>(event: K, handler: (data: any) => void) => () => void;
+            setState: (updates: Partial<R['state']>) => void;
+            readonly memberCount: number;
+        };
+    };
     /**
      * List of room IDs this component is participating in.
      * Cached — invalidated on join/leave.
@@ -1238,7 +1419,6 @@ interface StateMigration {
 }
 interface ComponentRegistryDeps {
     authManager: LiveAuthManager;
-    debugger: LiveDebugger;
     stateSignature: StateSignatureManager;
     performanceMonitor: PerformanceMonitor;
     cluster?: IClusterAdapter;
@@ -1255,7 +1435,6 @@ declare class ComponentRegistry {
     private remoteSingletons;
     private cluster?;
     private authManager;
-    private debugger;
     private stateSignature;
     private performanceMonitor;
     constructor(deps: ComponentRegistryDeps);
@@ -1403,11 +1582,12 @@ interface LiveServerOptions {
      *  component state is mirrored to a shared store (Redis), and actions on
      *  remote singletons are forwarded to the owner instance. */
     cluster?: IClusterAdapter;
+    /** LiveRoom classes to register. These define typed rooms with lifecycle hooks. */
+    rooms?: LiveRoomClass[];
 }
 declare class LiveServer {
     readonly roomEvents: RoomEventBus;
     readonly roomManager: LiveRoomManager;
-    readonly debugger: LiveDebugger;
     readonly authManager: LiveAuthManager;
     readonly stateSignature: StateSignatureManager;
     readonly performanceMonitor: PerformanceMonitor;
@@ -1415,6 +1595,7 @@ declare class LiveServer {
     readonly connectionManager: WebSocketConnectionManager;
     readonly registry: ComponentRegistry;
     readonly rateLimiter: RateLimiterRegistry;
+    readonly roomRegistry: RoomRegistry;
     private transport;
     private options;
     constructor(options: LiveServerOptions);
@@ -1422,6 +1603,11 @@ declare class LiveServer {
      * Register an auth provider.
      */
     useAuth(provider: LiveAuthProvider): this;
+    /**
+     * Register a LiveRoom class.
+     * Can be called before start() to register room types dynamically.
+     */
+    useRoom(roomClass: LiveRoomClass): this;
     /**
      * Start the LiveServer: register WS + HTTP handlers on the transport.
      */
@@ -1452,6 +1638,11 @@ interface PendingMessage {
  * Messages are batched per-WS and sent as a JSON array.
  */
 declare function queueWsMessage(ws: GenericWebSocket, message: PendingMessage): void;
+/**
+ * Send a binary message immediately (bypass batching).
+ * Binary frames are never batched — they are self-framing.
+ */
+declare function sendBinaryImmediate(ws: GenericWebSocket, data: Uint8Array): void;
 /**
  * Send a message immediately (bypass batching).
  * Used for ACTION_RESPONSE and other request-response patterns
@@ -1594,12 +1785,10 @@ declare function registerComponentLogging(componentId: string, config: LiveLogCo
 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;
 
@@ -1665,4 +1854,4 @@ interface UseTypedLiveComponentReturn<T extends LiveComponent<any>> {
     };
 }
 
-export { ANONYMOUS_CONTEXT, type ActionNames, type ActionPayload, type ActionReturn, type ActiveUpload, AnonymousContext, AuthenticatedContext, type BinaryChunkHeader, type BroadcastMessage, type ClusterActionRequest, type ClusterActionResponse, type ClusterComponentState, type ClusterDeltaHandler, type ClusterSingletonClaim, type ClusterSingletonOwner, 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, EMIT_OVERRIDE_KEY, 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 IClusterAdapter, type IRoomPubSubAdapter, type IRoomStorageAdapter, InMemoryRoomAdapter, 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, queueWsMessage, registerComponentLogging, sendImmediate, setLiveComponentContext, unregisterComponentLogging };
+export { ANONYMOUS_CONTEXT, type ActionNames, type ActionPayload, type ActionReturn, type ActiveUpload, AnonymousContext, AuthenticatedContext, BINARY_ROOM_EVENT, BINARY_ROOM_STATE, type BinaryChunkHeader, type BroadcastMessage, type ClusterActionRequest, type ClusterActionResponse, type ClusterComponentState, type ClusterDeltaHandler, type ClusterSingletonClaim, type ClusterSingletonOwner, type ComponentDefinition, type ComponentMetadata, type ComponentMetrics, type ComponentPerformanceMetrics, ComponentRegistry, type ComponentState, type ConnectionConfig, type ConnectionHealth, type ConnectionMetrics, ConnectionRateLimiter, DEFAULT_CHUNK_SIZE, DEFAULT_WS_PATH, EMIT_OVERRIDE_KEY, 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 IClusterAdapter, type IRoomPubSubAdapter, type IRoomStorageAdapter, InMemoryRoomAdapter, type InferComponentState, type InferPrivateState, type InferRoomEvents, type InferRoomMeta, type InferRoomState, type LiveActionAuth, type LiveActionAuthMap, type LiveAuthContext, type LiveAuthCredentials, LiveAuthManager, type LiveAuthProvider, type LiveAuthResult, type LiveAuthUser, LiveComponent, type LiveComponentAuth, type LiveComponentContext, type LiveComponentInstance, type LiveLogCategory, type LiveLogConfig, type LiveMessage, LiveRoom, type LiveRoomClass, LiveRoomManager, type LiveRoomManagerInterface, type LiveRoomOptions, LiveServer, type LiveServerOptions, type LiveTransport, type LiveWSData, PROTOCOL_VERSION, type PerformanceAlert, type PerformanceConfig, PerformanceMonitor, RateLimiterRegistry, type RoomCodec, type RoomCodecOption, RoomEventBus, type RoomEventContext, type RoomInfo, type RoomJoinContext, type RoomLeaveContext, type RoomMessage, RoomRegistry, 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, buildRoomFrame, buildRoomFrameTail, createTypedRoomEventBus, createTypedRoomState, decodeBinaryChunk, encodeBinaryChunk, getLiveComponentContext, jsonCodec, liveLog, liveWarn, msgpackCodec, parseRoomFrame, prependMemberHeader, queueWsMessage, registerComponentLogging, resolveCodec, sendBinaryImmediate, sendImmediate, setLiveComponentContext, unregisterComponentLogging };