create-fluxstack 1.9.1 → 1.12.0

package/core/server/live/WebSocketConnectionManager.ts

@@ -2,6 +2,7 @@
 // Advanced connection management with pooling, load balancing, and health monitoring
 
 import { EventEmitter } from 'events'
+import type { FluxStackWebSocket } from '@core/types/types'
 
 export interface ConnectionConfig {
   maxConnections: number
@@ -56,11 +57,11 @@ export interface LoadBalancerStats {
 }
 
 export class WebSocketConnectionManager extends EventEmitter {
-  private connections = new Map<string, any>() // connectionId -> websocket
+  private connections = new Map<string, FluxStackWebSocket>() // connectionId -> websocket
   private connectionMetrics = new Map<string, ConnectionMetrics>()
   private connectionPools = new Map<string, Set<string>>() // poolId -> connectionIds
   private messageQueues = new Map<string, QueuedMessage[]>() // connectionId -> queued messages
-  private healthCheckInterval: NodeJS.Timeout
+  private healthCheckInterval!: NodeJS.Timeout
   private config: ConnectionConfig
   private loadBalancerIndex = 0
 
@@ -89,7 +90,7 @@ export class WebSocketConnectionManager extends EventEmitter {
   /**
    * Register a new WebSocket connection
    */
-  registerConnection(ws: any, connectionId: string, poolId?: string): void {
+  registerConnection(ws: FluxStackWebSocket, connectionId: string, poolId?: string): void {
     if (this.connections.size >= this.config.maxConnections) {
       throw new Error('Maximum connections exceeded')
     }
@@ -129,26 +130,33 @@ export class WebSocketConnectionManager extends EventEmitter {
   /**
    * Setup connection event handlers
    */
-  private setupConnectionHandlers(ws: any, connectionId: string): void {
+  private setupConnectionHandlers(ws: FluxStackWebSocket, connectionId: string): void {
     const metrics = this.connectionMetrics.get(connectionId)
     if (!metrics) return
 
     // Handle incoming messages
+    // Note: Bun/Elysia WebSockets use different event handling patterns
+    // This code provides compatibility layer for both Node.js style (on/addListener) and browser style (addEventListener)
+    const wsAny = ws as any
     const addListener = (event: string, handler: (...args: any[]) => void) => {
-      if (typeof ws.on === 'function') {
-        ws.on(event, handler)
-      } else if (typeof ws.addEventListener === 'function') {
-        ws.addEventListener(event as any, handler as any)
-      } else if (typeof ws.addListener === 'function') {
-        ws.addListener(event, handler)
+      if (typeof wsAny.on === 'function') {
+        wsAny.on(event, handler)
+      } else if (typeof wsAny.addEventListener === 'function') {
+        wsAny.addEventListener(event, handler)
+      } else if (typeof wsAny.addListener === 'function') {
+        wsAny.addListener(event, handler)
       }
     }
 
     addListener('message', (data: any) => {
       metrics.messagesReceived++
       metrics.lastActivity = new Date()
-      metrics.bytesTransferred += Buffer.byteLength(data)
-      
+      if (typeof data === 'string') {
+        metrics.bytesTransferred += Buffer.byteLength(data)
+      } else if (data instanceof Buffer) {
+        metrics.bytesTransferred += data.length
+      }
+
       this.emit('messageReceived', { connectionId, data })
     })
 
@@ -168,10 +176,10 @@ export class WebSocketConnectionManager extends EventEmitter {
     // Handle pong responses for latency measurement
     addListener('pong', () => {
       const now = Date.now()
-      const pingTime = (ws as any)._pingTime
+      const pingTime = wsAny._pingTime
       if (pingTime) {
         metrics.latency = now - pingTime
-        delete (ws as any)._pingTime
+        delete wsAny._pingTime
       }
     })
   }
@@ -205,7 +213,7 @@ export class WebSocketConnectionManager extends EventEmitter {
    * Send message with load balancing and queuing
    */
   async sendMessage(
-    message: any, 
+    message: any,
     target?: { connectionId?: string; poolId?: string },
     options?: { priority?: number; maxRetries?: number; queueIfOffline?: boolean }
   ): Promise<boolean> {
@@ -243,7 +251,7 @@ export class WebSocketConnectionManager extends EventEmitter {
    * Send message to specific connection
    */
   private async sendToConnection(
-    connectionId: string, 
+    connectionId: string,
     message: any,
     options: { priority: number; maxRetries: number; queueIfOffline: boolean }
   ): Promise<boolean> {
@@ -288,7 +296,7 @@ export class WebSocketConnectionManager extends EventEmitter {
    * Queue message for offline delivery
    */
   private queueMessage(
-    connectionId: string, 
+    connectionId: string,
     message: any,
     options: { priority: number; maxRetries: number }
   ): boolean {
@@ -494,8 +502,11 @@ export class WebSocketConnectionManager extends EventEmitter {
     for (const [connectionId, ws] of this.connections) {
       if (ws.readyState === 1) { // WebSocket.OPEN
         try {
-          (ws as any)._pingTime = Date.now()
-          ws.ping()
+          const wsAny = ws as any
+          wsAny._pingTime = Date.now()
+          if (typeof wsAny.ping === 'function') {
+            wsAny.ping()
+          }
         } catch (error) {
           console.error(`❌ Heartbeat failed for ${connectionId}:`, error)
         }

package/core/server/live/auto-generated-components.ts

@@ -1,26 +1,41 @@
-// 🔥 Auto-generated Live Components Registration
-// This file is automatically generated during build time - DO NOT EDIT MANUALLY
-// Generated at: 2025-11-18T01:48:36.705Z
-
-import { LiveClockComponent } from "@/app/server/live/LiveClockComponent"
-import { componentRegistry } from "@/core/server/live/ComponentRegistry"
-
-// Register all components statically for production bundle
-function registerAllComponents() {
-  try {
-    // Auto-generated component registrations
-    componentRegistry.registerComponentClass('LiveClock', LiveClockComponent)
-    
-    console.log('📝 Live components registered successfully! (1 components)')
-  } catch (error) {
-    console.warn('⚠️ Error registering components:', error)
-  }
-}
-
-// Auto-register components
-registerAllComponents()
-
-// Export all components to ensure they're included in the bundle
-export { 
-  LiveClockComponent
-}
+// 🔥 Auto-generated Live Components Registration
+// This file is automatically generated during build time - DO NOT EDIT MANUALLY
+// Generated at: 2026-02-09T22:13:45.496Z
+
+import { LiveChat } from "@app/server/live/LiveChat"
+import { LiveCounter } from "@app/server/live/LiveCounter"
+import { LiveForm } from "@app/server/live/LiveForm"
+import { LiveLocalCounter } from "@app/server/live/LiveLocalCounter"
+import { LiveRoomChat } from "@app/server/live/LiveRoomChat"
+import { LiveUpload } from "@app/server/live/LiveUpload"
+import { componentRegistry } from "@core/server/live/ComponentRegistry"
+
+// Register all components statically for production bundle
+function registerAllComponents() {
+  try {
+    // Auto-generated component registrations
+    componentRegistry.registerComponentClass('LiveChat', LiveChat)
+    componentRegistry.registerComponentClass('LiveCounter', LiveCounter)
+    componentRegistry.registerComponentClass('LiveForm', LiveForm)
+    componentRegistry.registerComponentClass('LiveLocalCounter', LiveLocalCounter)
+    componentRegistry.registerComponentClass('LiveRoomChat', LiveRoomChat)
+    componentRegistry.registerComponentClass('LiveUpload', LiveUpload)
+    
+    console.log('📝 Live components registered successfully! (6 components)')
+  } catch (error) {
+    console.warn('⚠️ Error registering components:', error)
+  }
+}
+
+// Auto-register components
+registerAllComponents()
+
+// Export all components to ensure they're included in the bundle
+export { 
+  LiveChat,
+  LiveCounter,
+  LiveForm,
+  LiveLocalCounter,
+  LiveRoomChat,
+  LiveUpload
+}

package/core/server/live/index.ts

@@ -0,0 +1,14 @@
+// 🔥 FluxStack Live - Server Exports
+
+export { roomState, createTypedRoomState } from './RoomStateManager'
+export type { RoomStateData, RoomInfo } from './RoomStateManager'
+
+export { roomEvents, createTypedRoomEventBus } from './RoomEventBus'
+export type { EventHandler, RoomSubscription } from './RoomEventBus'
+
+export { componentRegistry } from './ComponentRegistry'
+export { liveComponentsPlugin } from './websocket-plugin'
+export { connectionManager } from './WebSocketConnectionManager'
+export { fileUploadManager } from './FileUploadManager'
+export { stateSignature } from './StateSignature'
+export { performanceMonitor } from './LiveComponentPerformanceMonitor'

package/core/server/live/websocket-plugin.ts

@@ -4,8 +4,9 @@ import { componentRegistry } from './ComponentRegistry'
 import { fileUploadManager } from './FileUploadManager'
 import { connectionManager } from './WebSocketConnectionManager'
 import { performanceMonitor } from './LiveComponentPerformanceMonitor'
-import type { LiveMessage, FileUploadStartMessage, FileUploadChunkMessage, FileUploadCompleteMessage } from '@/core/plugins/types'
-import type { Plugin, PluginContext } from '@/core/index'
+import { liveRoomManager, type RoomMessage } from './LiveRoomManager'
+import type { LiveMessage, FileUploadStartMessage, FileUploadChunkMessage, FileUploadCompleteMessage, BinaryChunkHeader, FluxStackWebSocket, FluxStackWSData } from '@core/types/types'
+import type { Plugin, PluginContext } from '@core/index'
 import { t, Elysia } from 'elysia'
 import path from 'path'
 
@@ -131,46 +132,38 @@ export const liveComponentsPlugin: Plugin = {
     
     // Create grouped routes for Live Components with documentation
     const liveRoutes = new Elysia({ prefix: '/api/live', tags: ['Live Components'] })
-      // WebSocket route
+      // WebSocket route - supports both JSON and binary messages
       .ws('/ws', {
-        body: t.Object({
-          type: t.String(),
-          componentId: t.String(),
-          action: t.Optional(t.String()),
-          payload: t.Optional(t.Any()),
-          timestamp: t.Optional(t.Number()),
-          userId: t.Optional(t.String()),
-          room: t.Optional(t.String()),
-          requestId: t.Optional(t.String()),
-          expectResponse: t.Optional(t.Boolean()),
-          // File upload specific fields
-          uploadId: t.Optional(t.String()),
-          filename: t.Optional(t.String()),
-          fileType: t.Optional(t.String()),
-          fileSize: t.Optional(t.Number()),
-          chunkSize: t.Optional(t.Number()),
-          chunkIndex: t.Optional(t.Number()),
-          totalChunks: t.Optional(t.Number()),
-          data: t.Optional(t.String()),
-          hash: t.Optional(t.String())
-        }),
+        // Use t.Any() to allow both JSON objects and binary data
+        // Binary messages will be ArrayBuffer/Uint8Array, JSON will be parsed objects
+        body: t.Any(),
         
         open(ws) {
+          const socket = ws as unknown as FluxStackWebSocket
           const connectionId = `ws-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
           console.log(`🔌 Live Components WebSocket connected: ${connectionId}`)
-          
+
           // Register connection with enhanced connection manager
-          connectionManager.registerConnection(ws, connectionId, 'live-components')
-          
+          connectionManager.registerConnection(ws as unknown as FluxStackWebSocket, connectionId, 'live-components')
+
           // Initialize and store connection data in ws.data
-          if (!ws.data) {
-            ws.data = {}
+          const wsData: FluxStackWSData = {
+            connectionId,
+            components: new Map(),
+            subscriptions: new Set(),
+            connectedAt: new Date()
+          }
+
+          // Assign data to websocket (Elysia creates ws.data from context)
+          if (!socket.data) {
+            (socket as { data: FluxStackWSData }).data = wsData
+          } else {
+            socket.data.connectionId = connectionId
+            socket.data.components = new Map()
+            socket.data.subscriptions = new Set()
+            socket.data.connectedAt = new Date()
           }
-          ws.data.connectionId = connectionId
-          ws.data.components = new Map()
-          ws.data.subscriptions = new Set()
-          ws.data.connectedAt = new Date()
-          
+
           // Send connection confirmation
           ws.send(JSON.stringify({
             type: 'CONNECTION_ESTABLISHED',
@@ -185,50 +178,96 @@ export const liveComponentsPlugin: Plugin = {
           }))
         },
         
-        async message(ws, message: LiveMessage) {
+        async message(ws: unknown, rawMessage: LiveMessage | ArrayBuffer | Uint8Array) {
+          const socket = ws as FluxStackWebSocket
           try {
-            // Add connection metadata
-            message.timestamp = Date.now()
-            
+            let message: LiveMessage
+            let binaryChunkData: Buffer | null = null
+
+            // Check if this is a binary message (file upload chunk)
+            if (rawMessage instanceof ArrayBuffer || rawMessage instanceof Uint8Array) {
+              // Binary protocol: [4 bytes header length][JSON header][binary data]
+              const buffer = rawMessage instanceof ArrayBuffer
+                ? Buffer.from(rawMessage)
+                : Buffer.from(rawMessage.buffer, rawMessage.byteOffset, rawMessage.byteLength)
+
+              // Read header length (first 4 bytes, little-endian)
+              const headerLength = buffer.readUInt32LE(0)
+
+              // Extract and parse JSON header
+              const headerJson = buffer.slice(4, 4 + headerLength).toString('utf-8')
+              const header = JSON.parse(headerJson) as BinaryChunkHeader
+
+              // Extract binary chunk data
+              binaryChunkData = buffer.slice(4 + headerLength)
+
+              console.log(`📦 Binary chunk received: ${binaryChunkData.length} bytes for upload ${header.uploadId}`)
+
+              // Create message with binary data attached
+              message = {
+                ...header,
+                data: binaryChunkData, // Buffer instead of base64 string
+                timestamp: Date.now()
+              } as unknown as LiveMessage
+            } else {
+              // Regular JSON message
+              message = rawMessage as LiveMessage
+              message.timestamp = Date.now()
+            }
+
             console.log(`📨 Received message:`, {
               type: message.type,
               componentId: message.componentId,
               action: message.action,
-              requestId: message.requestId
+              requestId: message.requestId,
+              isBinary: binaryChunkData !== null
             })
 
             // Handle different message types
             switch (message.type) {
               case 'COMPONENT_MOUNT':
-                await handleComponentMount(ws, message)
+                await handleComponentMount(socket, message)
                 break
               case 'COMPONENT_REHYDRATE':
-                await handleComponentRehydrate(ws, message)
+                await handleComponentRehydrate(socket, message)
                 break
               case 'COMPONENT_UNMOUNT':
-                await handleComponentUnmount(ws, message)
+                await handleComponentUnmount(socket, message)
                 break
               case 'CALL_ACTION':
-                await handleActionCall(ws, message)
+                await handleActionCall(socket, message)
                 break
               case 'PROPERTY_UPDATE':
-                await handlePropertyUpdate(ws, message)
+                await handlePropertyUpdate(socket, message)
                 break
               case 'COMPONENT_PING':
-                await handleComponentPing(ws, message)
+                await handleComponentPing(socket, message)
                 break
               case 'FILE_UPLOAD_START':
-                await handleFileUploadStart(ws, message as FileUploadStartMessage)
+                await handleFileUploadStart(socket, message as FileUploadStartMessage)
                 break
               case 'FILE_UPLOAD_CHUNK':
-                await handleFileUploadChunk(ws, message as FileUploadChunkMessage)
+                await handleFileUploadChunk(socket, message as FileUploadChunkMessage, binaryChunkData)
                 break
               case 'FILE_UPLOAD_COMPLETE':
-                await handleFileUploadComplete(ws, message as unknown as FileUploadCompleteMessage)
+                await handleFileUploadComplete(socket, message as unknown as FileUploadCompleteMessage)
+                break
+              // Room system messages
+              case 'ROOM_JOIN':
+                await handleRoomJoin(socket, message as unknown as RoomMessage)
+                break
+              case 'ROOM_LEAVE':
+                await handleRoomLeave(socket, message as unknown as RoomMessage)
+                break
+              case 'ROOM_EMIT':
+                await handleRoomEmit(socket, message as unknown as RoomMessage)
+                break
+              case 'ROOM_STATE_SET':
+                await handleRoomStateSet(socket, message as unknown as RoomMessage)
                 break
               default:
                 console.warn(`❌ Unknown message type: ${message.type}`)
-                ws.send(JSON.stringify({
+                socket.send(JSON.stringify({
                   type: 'ERROR',
                   error: `Unknown message type: ${message.type}`,
                   timestamp: Date.now()
@@ -236,7 +275,7 @@ export const liveComponentsPlugin: Plugin = {
             }
           } catch (error) {
             console.error('❌ WebSocket message error:', error)
-            ws.send(JSON.stringify({
+            socket.send(JSON.stringify({
               type: 'ERROR',
               error: error instanceof Error ? error.message : 'Unknown error',
               timestamp: Date.now()
@@ -245,16 +284,17 @@ export const liveComponentsPlugin: Plugin = {
         },
         
         close(ws) {
-          const connectionId = ws.data?.connectionId
+          const socket = ws as unknown as FluxStackWebSocket
+          const connectionId = socket.data?.connectionId
           console.log(`🔌 Live Components WebSocket disconnected: ${connectionId}`)
-          
+
           // Cleanup connection in connection manager
           if (connectionId) {
             connectionManager.cleanupConnection(connectionId)
           }
-          
+
           // Cleanup components for this connection
-          componentRegistry.cleanupConnection(ws)
+          componentRegistry.cleanupConnection(socket)
         }
       })
 
@@ -456,9 +496,9 @@ export const liveComponentsPlugin: Plugin = {
 }
 
 // Handler functions for WebSocket messages
-async function handleComponentMount(ws: any, message: LiveMessage) {
+async function handleComponentMount(ws: FluxStackWebSocket, message: LiveMessage) {
   const result = await componentRegistry.handleMessage(ws, message)
-  
+
   if (result !== null) {
     const response = {
       type: 'COMPONENT_MOUNTED',
@@ -473,7 +513,7 @@ async function handleComponentMount(ws: any, message: LiveMessage) {
   }
 }
 
-async function handleComponentRehydrate(ws: any, message: LiveMessage) {
+async function handleComponentRehydrate(ws: FluxStackWebSocket, message: LiveMessage) {
   console.log('🔄 Processing component re-hydration request:', {
     componentId: message.componentId,
     payload: message.payload
@@ -532,7 +572,7 @@ async function handleComponentRehydrate(ws: any, message: LiveMessage) {
   }
 }
 
-async function handleComponentUnmount(ws: any, message: LiveMessage) {
+async function handleComponentUnmount(ws: FluxStackWebSocket, message: LiveMessage) {
   const result = await componentRegistry.handleMessage(ws, message)
   
   if (result !== null) {
@@ -547,7 +587,7 @@ async function handleComponentUnmount(ws: any, message: LiveMessage) {
   }
 }
 
-async function handleActionCall(ws: any, message: LiveMessage) {
+async function handleActionCall(ws: FluxStackWebSocket, message: LiveMessage) {
   const result = await componentRegistry.handleMessage(ws, message)
   
   if (result !== null) {
@@ -565,7 +605,7 @@ async function handleActionCall(ws: any, message: LiveMessage) {
   }
 }
 
-async function handlePropertyUpdate(ws: any, message: LiveMessage) {
+async function handlePropertyUpdate(ws: FluxStackWebSocket, message: LiveMessage) {
   const result = await componentRegistry.handleMessage(ws, message)
 
   if (result !== null) {
@@ -582,7 +622,7 @@ async function handlePropertyUpdate(ws: any, message: LiveMessage) {
   }
 }
 
-async function handleComponentPing(ws: any, message: LiveMessage) {
+async function handleComponentPing(ws: FluxStackWebSocket, message: LiveMessage) {
   // Update component's last activity timestamp
   const updated = componentRegistry.updateComponentActivity(message.componentId)
 
@@ -599,7 +639,7 @@ async function handleComponentPing(ws: any, message: LiveMessage) {
 }
 
 // File Upload Handler Functions
-async function handleFileUploadStart(ws: any, message: FileUploadStartMessage) {
+async function handleFileUploadStart(ws: FluxStackWebSocket, message: FileUploadStartMessage) {
   console.log('📤 Starting file upload:', message.uploadId)
   
   const result = await fileUploadManager.startUpload(message)
@@ -617,13 +657,19 @@ async function handleFileUploadStart(ws: any, message: FileUploadStartMessage) {
   ws.send(JSON.stringify(response))
 }
 
-async function handleFileUploadChunk(ws: any, message: FileUploadChunkMessage) {
-  console.log(`📦 Receiving chunk ${message.chunkIndex + 1} for upload ${message.uploadId}`)
-  
-  const progressResponse = await fileUploadManager.receiveChunk(message, ws)
-  
+async function handleFileUploadChunk(ws: FluxStackWebSocket, message: FileUploadChunkMessage, binaryData: Buffer | null = null) {
+  console.log(`📦 Receiving chunk ${message.chunkIndex + 1} for upload ${message.uploadId}${binaryData ? ' (binary)' : ' (base64)'}`)
+
+  const progressResponse = await fileUploadManager.receiveChunk(message, ws, binaryData)
+
   if (progressResponse) {
-    ws.send(JSON.stringify(progressResponse))
+    // Add requestId to response so client can correlate it
+    const responseWithRequestId = {
+      ...progressResponse,
+      requestId: message.requestId,
+      success: true
+    }
+    ws.send(JSON.stringify(responseWithRequestId))
   } else {
     // Send error response
     const errorResponse = {
@@ -632,15 +678,130 @@ async function handleFileUploadChunk(ws: any, message: FileUploadChunkMessage) {
       uploadId: message.uploadId,
       error: 'Failed to process chunk',
       requestId: message.requestId,
+      success: false,
       timestamp: Date.now()
     }
     ws.send(JSON.stringify(errorResponse))
   }
 }
 
-async function handleFileUploadComplete(ws: any, message: FileUploadCompleteMessage) {
+async function handleFileUploadComplete(ws: FluxStackWebSocket, message: FileUploadCompleteMessage) {
   console.log('✅ Completing file upload:', message.uploadId)
-  
+
   const completeResponse = await fileUploadManager.completeUpload(message)
-  ws.send(JSON.stringify(completeResponse))
-}
+
+  // Add requestId to response so client can correlate it
+  const responseWithRequestId = {
+    ...completeResponse,
+    requestId: message.requestId
+  }
+
+  ws.send(JSON.stringify(responseWithRequestId))
+}
+
+// ===== Room System Handlers =====
+
+async function handleRoomJoin(ws: FluxStackWebSocket, message: RoomMessage) {
+  console.log(`🚪 Component ${message.componentId} joining room ${message.roomId}`)
+
+  try {
+    const result = liveRoomManager.joinRoom(
+      message.componentId,
+      message.roomId,
+      ws,
+      message.data?.initialState
+    )
+
+    const response = {
+      type: 'ROOM_JOINED',
+      componentId: message.componentId,
+      roomId: message.roomId,
+      success: true,
+      state: result.state,
+      requestId: message.requestId,
+      timestamp: Date.now()
+    }
+
+    ws.send(JSON.stringify(response))
+  } catch (error: any) {
+    ws.send(JSON.stringify({
+      type: 'ERROR',
+      componentId: message.componentId,
+      roomId: message.roomId,
+      error: error.message,
+      requestId: message.requestId,
+      timestamp: Date.now()
+    }))
+  }
+}
+
+async function handleRoomLeave(ws: FluxStackWebSocket, message: RoomMessage) {
+  console.log(`🚶 Component ${message.componentId} leaving room ${message.roomId}`)
+
+  try {
+    liveRoomManager.leaveRoom(message.componentId, message.roomId)
+
+    const response = {
+      type: 'ROOM_LEFT',
+      componentId: message.componentId,
+      roomId: message.roomId,
+      success: true,
+      requestId: message.requestId,
+      timestamp: Date.now()
+    }
+
+    ws.send(JSON.stringify(response))
+  } catch (error: any) {
+    ws.send(JSON.stringify({
+      type: 'ERROR',
+      componentId: message.componentId,
+      roomId: message.roomId,
+      error: error.message,
+      requestId: message.requestId,
+      timestamp: Date.now()
+    }))
+  }
+}
+
+async function handleRoomEmit(ws: FluxStackWebSocket, message: RoomMessage) {
+  console.log(`📡 Component ${message.componentId} emitting '${message.event}' to room ${message.roomId}`)
+
+  try {
+    const count = liveRoomManager.emitToRoom(
+      message.roomId,
+      message.event!,
+      message.data,
+      message.componentId // Excluir quem enviou
+    )
+
+    console.log(`   → Notified ${count} components`)
+  } catch (error: any) {
+    ws.send(JSON.stringify({
+      type: 'ERROR',
+      componentId: message.componentId,
+      roomId: message.roomId,
+      error: error.message,
+      timestamp: Date.now()
+    }))
+  }
+}
+
+async function handleRoomStateSet(ws: FluxStackWebSocket, message: RoomMessage) {
+  console.log(`📝 Component ${message.componentId} updating state in room ${message.roomId}`)
+
+  try {
+    liveRoomManager.setRoomState(
+      message.roomId,
+      message.data ?? {},
+      message.componentId // Excluir quem enviou
+    )
+  } catch (error: any) {
+    ws.send(JSON.stringify({
+      type: 'ERROR',
+      componentId: message.componentId,
+      roomId: message.roomId,
+      error: error.message,
+      timestamp: Date.now()
+    }))
+  }
+}