@fluxstack/live 0.1.0

package/dist/index.js

@@ -0,0 +1,3334 @@
+import { randomBytes, createCipheriv, createDecipheriv, createHmac } from 'crypto';
+import { gzipSync, gunzipSync } from 'zlib';
+import { EventEmitter } from 'events';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/rooms/RoomEventBus.ts
+function createTypedRoomEventBus() {
+  const subscriptions = /* @__PURE__ */ new Map();
+  const getKey = (roomType, roomId, event) => `${roomType}:${roomId}:${event}`;
+  const getRoomKey = (roomType, roomId) => `${roomType}:${roomId}`;
+  return {
+    on(roomType, roomId, event, componentId, handler) {
+      const key = getKey(roomType, roomId, event);
+      if (!subscriptions.has(key)) {
+        subscriptions.set(key, /* @__PURE__ */ new Set());
+      }
+      const subscription = {
+        roomType,
+        roomId,
+        event,
+        handler,
+        componentId
+      };
+      subscriptions.get(key).add(subscription);
+      return () => {
+        subscriptions.get(key)?.delete(subscription);
+        if (subscriptions.get(key)?.size === 0) {
+          subscriptions.delete(key);
+        }
+      };
+    },
+    emit(roomType, roomId, event, data, excludeComponentId) {
+      const key = getKey(roomType, roomId, event);
+      const subs = subscriptions.get(key);
+      if (!subs || subs.size === 0) return 0;
+      let notified = 0;
+      for (const sub of subs) {
+        if (excludeComponentId && sub.componentId === excludeComponentId) continue;
+        try {
+          sub.handler(data);
+          notified++;
+        } catch (error) {
+          console.error(`[RoomEventBus] Error in handler [${key}]:`, error);
+        }
+      }
+      return notified;
+    },
+    unsubscribeAll(componentId) {
+      let removed = 0;
+      for (const [key, subs] of subscriptions) {
+        for (const sub of subs) {
+          if (sub.componentId === componentId) {
+            subs.delete(sub);
+            removed++;
+          }
+        }
+        if (subs.size === 0) {
+          subscriptions.delete(key);
+        }
+      }
+      return removed;
+    },
+    clearRoom(roomType, roomId) {
+      const prefix = getRoomKey(roomType, roomId);
+      let removed = 0;
+      for (const key of subscriptions.keys()) {
+        if (key.startsWith(prefix)) {
+          removed += subscriptions.get(key)?.size ?? 0;
+          subscriptions.delete(key);
+        }
+      }
+      return removed;
+    },
+    getStats() {
+      const rooms = {};
+      let total = 0;
+      for (const [key, subs] of subscriptions) {
+        const parts = key.split(":");
+        const roomKey = `${parts[0]}:${parts[1]}`;
+        const event = parts[2] ?? "";
+        if (!rooms[roomKey]) {
+          rooms[roomKey] = { events: {} };
+        }
+        rooms[roomKey].events[event] = subs.size;
+        total += subs.size;
+      }
+      return { totalSubscriptions: total, rooms };
+    }
+  };
+}
+var RoomEventBus = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  getKey(roomType, roomId, event) {
+    return `${roomType}:${roomId}:${event}`;
+  }
+  on(roomType, roomId, event, componentId, handler) {
+    const key = this.getKey(roomType, roomId, event);
+    if (!this.subscriptions.has(key)) {
+      this.subscriptions.set(key, /* @__PURE__ */ new Set());
+    }
+    const subscription = { roomType, roomId, event, handler, componentId };
+    this.subscriptions.get(key).add(subscription);
+    return () => {
+      this.subscriptions.get(key)?.delete(subscription);
+      if (this.subscriptions.get(key)?.size === 0) {
+        this.subscriptions.delete(key);
+      }
+    };
+  }
+  emit(roomType, roomId, event, data, excludeComponentId) {
+    const key = this.getKey(roomType, roomId, event);
+    const subs = this.subscriptions.get(key);
+    if (!subs || subs.size === 0) return 0;
+    let notified = 0;
+    for (const sub of subs) {
+      if (excludeComponentId && sub.componentId === excludeComponentId) continue;
+      try {
+        sub.handler(data);
+        notified++;
+      } catch (error) {
+        console.error(`[RoomEventBus] Error in handler [${key}]:`, error);
+      }
+    }
+    return notified;
+  }
+  unsubscribeAll(componentId) {
+    let removed = 0;
+    for (const [key, subs] of this.subscriptions) {
+      for (const sub of subs) {
+        if (sub.componentId === componentId) {
+          subs.delete(sub);
+          removed++;
+        }
+      }
+      if (subs.size === 0) {
+        this.subscriptions.delete(key);
+      }
+    }
+    return removed;
+  }
+  clearRoom(roomType, roomId) {
+    const prefix = `${roomType}:${roomId}`;
+    let removed = 0;
+    for (const key of this.subscriptions.keys()) {
+      if (key.startsWith(prefix)) {
+        removed += this.subscriptions.get(key)?.size ?? 0;
+        this.subscriptions.delete(key);
+      }
+    }
+    return removed;
+  }
+  getStats() {
+    const rooms = {};
+    let total = 0;
+    for (const [key, subs] of this.subscriptions) {
+      const parts = key.split(":");
+      const roomKey = `${parts[0]}:${parts[1]}`;
+      const event = parts[2] ?? "";
+      if (!rooms[roomKey]) {
+        rooms[roomKey] = { events: {} };
+      }
+      rooms[roomKey].events[event] = subs.size;
+      total += subs.size;
+    }
+    return { totalSubscriptions: total, rooms };
+  }
+};
+
+// src/debug/LiveLogger.ts
+var componentConfigs = /* @__PURE__ */ new Map();
+var globalConfigParsed = false;
+var globalConfig = false;
+function parseGlobalConfig() {
+  if (globalConfigParsed) return globalConfig;
+  globalConfigParsed = true;
+  const envValue = typeof process !== "undefined" ? process.env?.LIVE_LOGGING : void 0;
+  if (!envValue || envValue === "false") {
+    globalConfig = false;
+  } else if (envValue === "true") {
+    globalConfig = true;
+  } else {
+    globalConfig = envValue.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  return globalConfig;
+}
+function registerComponentLogging(componentId, config) {
+  if (config !== void 0 && config !== false) {
+    componentConfigs.set(componentId, config);
+  }
+}
+function unregisterComponentLogging(componentId) {
+  componentConfigs.delete(componentId);
+}
+function shouldLog(componentId, category) {
+  if (componentId) {
+    const config = componentConfigs.get(componentId);
+    if (config === void 0 || config === false) return false;
+    if (config === true) return true;
+    return config.includes(category);
+  }
+  const cfg = parseGlobalConfig();
+  if (cfg === false) return false;
+  if (cfg === true) return true;
+  return cfg.includes(category);
+}
+var _debugger = null;
+function _setLoggerDebugger(dbg) {
+  _debugger = dbg;
+}
+function emitToDebugger(category, level, componentId, message, args) {
+  if (!_debugger?.enabled) return;
+  const data = { category, level, message };
+  if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
+    data.details = args[0];
+  } else if (args.length > 0) {
+    data.details = args;
+  }
+  _debugger.emit("LOG", componentId, null, data);
+}
+function liveLog(category, componentId, message, ...args) {
+  emitToDebugger(category, "info", componentId, message, args);
+  if (shouldLog(componentId, category)) {
+    if (args.length > 0) {
+      console.log(message, ...args);
+    } else {
+      console.log(message);
+    }
+  }
+}
+function liveWarn(category, componentId, message, ...args) {
+  emitToDebugger(category, "warn", componentId, message, args);
+  if (shouldLog(componentId, category)) {
+    if (args.length > 0) {
+      console.warn(message, ...args);
+    } else {
+      console.warn(message);
+    }
+  }
+}
+
+// src/protocol/constants.ts
+var PROTOCOL_VERSION = 1;
+var DEFAULT_WS_PATH = "/api/live/ws";
+var DEFAULT_CHUNK_SIZE = 64 * 1024;
+var DEFAULT_RATE_LIMIT_MAX_TOKENS = 100;
+var DEFAULT_RATE_LIMIT_REFILL_RATE = 50;
+var MAX_ROOM_STATE_SIZE = 10 * 1024 * 1024;
+
+// src/rooms/LiveRoomManager.ts
+var LiveRoomManager = class {
+  // componentId -> roomIds
+  constructor(roomEvents) {
+    this.roomEvents = roomEvents;
+  }
+  rooms = /* @__PURE__ */ new Map();
+  componentRooms = /* @__PURE__ */ new Map();
+  /**
+   * Component joins a room
+   */
+  joinRoom(componentId, roomId, ws, initialState) {
+    if (!roomId || !/^[a-zA-Z0-9_:.-]{1,64}$/.test(roomId)) {
+      throw new Error("Invalid room name. Must be 1-64 alphanumeric characters, hyphens, underscores, dots, or colons.");
+    }
+    if (!this.rooms.has(roomId)) {
+      this.rooms.set(roomId, {
+        id: roomId,
+        state: initialState || {},
+        members: /* @__PURE__ */ new Map(),
+        createdAt: Date.now(),
+        lastActivity: Date.now()
+      });
+      liveLog("rooms", componentId, `Room '${roomId}' created`);
+    }
+    const room = this.rooms.get(roomId);
+    room.members.set(componentId, {
+      componentId,
+      ws,
+      joinedAt: Date.now()
+    });
+    room.lastActivity = Date.now();
+    if (!this.componentRooms.has(componentId)) {
+      this.componentRooms.set(componentId, /* @__PURE__ */ new Set());
+    }
+    this.componentRooms.get(componentId).add(roomId);
+    liveLog("rooms", componentId, `Component '${componentId}' joined room '${roomId}' (${room.members.size} members)`);
+    this.broadcastToRoom(roomId, {
+      type: "ROOM_SYSTEM",
+      componentId,
+      roomId,
+      event: "$sub:join",
+      data: {
+        subscriberId: componentId,
+        count: room.members.size
+      },
+      timestamp: Date.now()
+    }, componentId);
+    return { state: room.state };
+  }
+  /**
+   * Component leaves a room
+   */
+  leaveRoom(componentId, roomId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return;
+    room.members.delete(componentId);
+    room.lastActivity = Date.now();
+    this.componentRooms.get(componentId)?.delete(roomId);
+    liveLog("rooms", componentId, `Component '${componentId}' left room '${roomId}' (${room.members.size} members)`);
+    this.broadcastToRoom(roomId, {
+      type: "ROOM_SYSTEM",
+      componentId,
+      roomId,
+      event: "$sub:leave",
+      data: {
+        subscriberId: componentId,
+        count: room.members.size
+      },
+      timestamp: Date.now()
+    });
+    if (room.members.size === 0) {
+      setTimeout(() => {
+        const currentRoom = this.rooms.get(roomId);
+        if (currentRoom && currentRoom.members.size === 0) {
+          this.rooms.delete(roomId);
+          liveLog("rooms", null, `Room '${roomId}' destroyed (empty)`);
+        }
+      }, 5 * 60 * 1e3);
+    }
+  }
+  /**
+   * Component disconnects - leave all rooms
+   */
+  cleanupComponent(componentId) {
+    const rooms = this.componentRooms.get(componentId);
+    if (!rooms) return;
+    for (const roomId of rooms) {
+      this.leaveRoom(componentId, roomId);
+    }
+    this.componentRooms.delete(componentId);
+  }
+  /**
+   * Emit event to all members in a room
+   */
+  emitToRoom(roomId, event, data, excludeComponentId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return 0;
+    room.lastActivity = Date.now();
+    this.roomEvents.emit("room", roomId, event, data, excludeComponentId);
+    return this.broadcastToRoom(roomId, {
+      type: "ROOM_EVENT",
+      componentId: "",
+      roomId,
+      event,
+      data,
+      timestamp: Date.now()
+    }, excludeComponentId);
+  }
+  /**
+   * Update room state
+   */
+  setRoomState(roomId, updates, excludeComponentId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return;
+    const newState = { ...room.state, ...updates };
+    const stateSize = Buffer.byteLength(JSON.stringify(newState), "utf8");
+    if (stateSize > MAX_ROOM_STATE_SIZE) {
+      throw new Error("Room state exceeds maximum size limit");
+    }
+    room.state = newState;
+    room.lastActivity = Date.now();
+    this.broadcastToRoom(roomId, {
+      type: "ROOM_STATE",
+      componentId: "",
+      roomId,
+      event: "$state:update",
+      data: { state: updates },
+      timestamp: Date.now()
+    }, excludeComponentId);
+  }
+  /**
+   * Get room state
+   */
+  getRoomState(roomId) {
+    return this.rooms.get(roomId)?.state || {};
+  }
+  /**
+   * Broadcast to all members in a room
+   */
+  broadcastToRoom(roomId, message, excludeComponentId) {
+    const room = this.rooms.get(roomId);
+    if (!room) return 0;
+    let sent = 0;
+    for (const [componentId, member] of room.members) {
+      if (excludeComponentId && componentId === excludeComponentId) continue;
+      try {
+        if (member.ws && member.ws.readyState === 1) {
+          member.ws.send(JSON.stringify({
+            ...message,
+            componentId
+          }));
+          sent++;
+        }
+      } catch (error) {
+        console.error(`Failed to send to ${componentId}:`, error);
+      }
+    }
+    return sent;
+  }
+  /**
+   * Check if component is in a room
+   */
+  isInRoom(componentId, roomId) {
+    return this.rooms.get(roomId)?.members.has(componentId) ?? false;
+  }
+  /**
+   * Get rooms for a component
+   */
+  getComponentRooms(componentId) {
+    return Array.from(this.componentRooms.get(componentId) || []);
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const rooms = {};
+    for (const [id, room] of this.rooms) {
+      rooms[id] = {
+        members: room.members.size,
+        createdAt: room.createdAt,
+        lastActivity: room.lastActivity
+      };
+    }
+    return {
+      totalRooms: this.rooms.size,
+      rooms
+    };
+  }
+};
+
+// src/debug/LiveDebugger.ts
+var MAX_EVENTS = 500;
+var MAX_STATE_SIZE = 5e4;
+var LiveDebugger = class {
+  events = [];
+  componentSnapshots = /* @__PURE__ */ new Map();
+  debugClients = /* @__PURE__ */ new Set();
+  _enabled = false;
+  startTime = Date.now();
+  eventCounter = 0;
+  constructor(enabled = false) {
+    this._enabled = enabled;
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  set enabled(value) {
+    this._enabled = value;
+  }
+  // ===== Event Emission =====
+  emit(type, componentId, componentName, data = {}) {
+    if (!this._enabled) return;
+    const event = {
+      id: `dbg-${++this.eventCounter}`,
+      timestamp: Date.now(),
+      type,
+      componentId,
+      componentName,
+      data: this.sanitizeData(data)
+    };
+    this.events.push(event);
+    if (this.events.length > MAX_EVENTS) {
+      this.events.shift();
+    }
+    if (componentId) {
+      this.updateSnapshot(event);
+    }
+    this.broadcastEvent(event);
+  }
+  // ===== Component Tracking =====
+  trackComponentMount(componentId, componentName, initialState, room, debugLabel) {
+    if (!this._enabled) return;
+    const snapshot = {
+      componentId,
+      componentName,
+      debugLabel,
+      state: this.sanitizeState(initialState),
+      rooms: room ? [room] : [],
+      mountedAt: Date.now(),
+      lastActivity: Date.now(),
+      actionCount: 0,
+      stateChangeCount: 0,
+      errorCount: 0
+    };
+    this.componentSnapshots.set(componentId, snapshot);
+    this.emit("COMPONENT_MOUNT", componentId, componentName, {
+      initialState: snapshot.state,
+      room: room ?? null,
+      debugLabel: debugLabel ?? null
+    });
+  }
+  trackComponentUnmount(componentId) {
+    if (!this._enabled) return;
+    const snapshot = this.componentSnapshots.get(componentId);
+    const componentName = snapshot?.componentName ?? null;
+    this.emit("COMPONENT_UNMOUNT", componentId, componentName, {
+      lifetime: snapshot ? Date.now() - snapshot.mountedAt : 0,
+      totalActions: snapshot?.actionCount ?? 0,
+      totalStateChanges: snapshot?.stateChangeCount ?? 0,
+      totalErrors: snapshot?.errorCount ?? 0
+    });
+    this.componentSnapshots.delete(componentId);
+  }
+  trackStateChange(componentId, delta, fullState, source = "setState") {
+    if (!this._enabled) return;
+    const snapshot = this.componentSnapshots.get(componentId);
+    if (snapshot) {
+      snapshot.state = this.sanitizeState(fullState);
+      snapshot.stateChangeCount++;
+      snapshot.lastActivity = Date.now();
+    }
+    this.emit("STATE_CHANGE", componentId, snapshot?.componentName ?? null, {
+      delta,
+      fullState: this.sanitizeState(fullState),
+      source
+    });
+  }
+  trackActionCall(componentId, action, payload) {
+    if (!this._enabled) return;
+    const snapshot = this.componentSnapshots.get(componentId);
+    if (snapshot) {
+      snapshot.actionCount++;
+      snapshot.lastActivity = Date.now();
+    }
+    this.emit("ACTION_CALL", componentId, snapshot?.componentName ?? null, {
+      action,
+      payload: this.sanitizeData({ payload }).payload
+    });
+  }
+  trackActionResult(componentId, action, result, duration) {
+    if (!this._enabled) return;
+    const snapshot = this.componentSnapshots.get(componentId);
+    this.emit("ACTION_RESULT", componentId, snapshot?.componentName ?? null, {
+      action,
+      result: this.sanitizeData({ result }).result,
+      duration
+    });
+  }
+  trackActionError(componentId, action, error, duration) {
+    if (!this._enabled) return;
+    const snapshot = this.componentSnapshots.get(componentId);
+    if (snapshot) {
+      snapshot.errorCount++;
+    }
+    this.emit("ACTION_ERROR", componentId, snapshot?.componentName ?? null, {
+      action,
+      error,
+      duration
+    });
+  }
+  trackRoomJoin(componentId, roomId) {
+    if (!this._enabled) return;
+    const snapshot = this.componentSnapshots.get(componentId);
+    if (snapshot && !snapshot.rooms.includes(roomId)) {
+      snapshot.rooms.push(roomId);
+    }
+    this.emit("ROOM_JOIN", componentId, snapshot?.componentName ?? null, { roomId });
+  }
+  trackRoomLeave(componentId, roomId) {
+    if (!this._enabled) return;
+    const snapshot = this.componentSnapshots.get(componentId);
+    if (snapshot) {
+      snapshot.rooms = snapshot.rooms.filter((r) => r !== roomId);
+    }
+    this.emit("ROOM_LEAVE", componentId, snapshot?.componentName ?? null, { roomId });
+  }
+  trackRoomEmit(componentId, roomId, event, data) {
+    if (!this._enabled) return;
+    const snapshot = this.componentSnapshots.get(componentId);
+    this.emit("ROOM_EMIT", componentId, snapshot?.componentName ?? null, {
+      roomId,
+      event,
+      data: this.sanitizeData({ data }).data
+    });
+  }
+  trackConnection(connectionId) {
+    if (!this._enabled) return;
+    this.emit("WS_CONNECT", null, null, { connectionId });
+  }
+  trackDisconnection(connectionId, componentCount) {
+    if (!this._enabled) return;
+    this.emit("WS_DISCONNECT", null, null, { connectionId, componentCount });
+  }
+  trackError(componentId, error, context) {
+    if (!this._enabled) return;
+    const snapshot = componentId ? this.componentSnapshots.get(componentId) : null;
+    if (snapshot) {
+      snapshot.errorCount++;
+    }
+    this.emit("ERROR", componentId, snapshot?.componentName ?? null, {
+      error,
+      ...context
+    });
+  }
+  // ===== Debug Client Management =====
+  registerDebugClient(ws) {
+    if (!this._enabled) {
+      const disabled = {
+        type: "DEBUG_DISABLED",
+        enabled: false,
+        timestamp: Date.now()
+      };
+      ws.send(JSON.stringify(disabled));
+      ws.close();
+      return;
+    }
+    this.debugClients.add(ws);
+    const welcome = {
+      type: "DEBUG_WELCOME",
+      enabled: true,
+      snapshot: this.getSnapshot(),
+      timestamp: Date.now()
+    };
+    ws.send(JSON.stringify(welcome));
+    for (const event of this.events.slice(-100)) {
+      const msg = {
+        type: "DEBUG_EVENT",
+        event,
+        timestamp: Date.now()
+      };
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  unregisterDebugClient(ws) {
+    this.debugClients.delete(ws);
+  }
+  // ===== Snapshot =====
+  getSnapshot() {
+    return {
+      components: Array.from(this.componentSnapshots.values()),
+      connections: this.debugClients.size,
+      uptime: Date.now() - this.startTime,
+      totalEvents: this.eventCounter
+    };
+  }
+  getComponentState(componentId) {
+    return this.componentSnapshots.get(componentId) ?? null;
+  }
+  getEvents(filter) {
+    let filtered = this.events;
+    if (filter?.componentId) {
+      filtered = filtered.filter((e) => e.componentId === filter.componentId);
+    }
+    if (filter?.type) {
+      filtered = filtered.filter((e) => e.type === filter.type);
+    }
+    const limit = filter?.limit ?? 100;
+    return filtered.slice(-limit);
+  }
+  clearEvents() {
+    this.events = [];
+  }
+  // ===== Internal =====
+  broadcastEvent(event) {
+    if (this.debugClients.size === 0) return;
+    const msg = {
+      type: "DEBUG_EVENT",
+      event,
+      timestamp: Date.now()
+    };
+    const json = JSON.stringify(msg);
+    for (const client of this.debugClients) {
+      try {
+        client.send(json);
+      } catch {
+        this.debugClients.delete(client);
+      }
+    }
+  }
+  sanitizeData(data) {
+    try {
+      const json = JSON.stringify(data);
+      if (json.length > MAX_STATE_SIZE) {
+        return { _truncated: true, _size: json.length, _preview: json.slice(0, 500) + "..." };
+      }
+      return JSON.parse(json);
+    } catch {
+      return { _serialization_error: true };
+    }
+  }
+  sanitizeState(state) {
+    try {
+      const json = JSON.stringify(state);
+      if (json.length > MAX_STATE_SIZE) {
+        return { _truncated: true, _size: json.length };
+      }
+      return JSON.parse(json);
+    } catch {
+      return { _serialization_error: true };
+    }
+  }
+  updateSnapshot(event) {
+    if (!event.componentId) return;
+    const snapshot = this.componentSnapshots.get(event.componentId);
+    if (snapshot) {
+      snapshot.lastActivity = event.timestamp;
+    }
+  }
+};
+
+// src/auth/LiveAuthContext.ts
+var AuthenticatedContext = class {
+  authenticated = true;
+  user;
+  token;
+  authenticatedAt;
+  constructor(user, token) {
+    this.user = user;
+    this.token = token;
+    this.authenticatedAt = Date.now();
+  }
+  hasRole(role) {
+    return this.user.roles?.includes(role) ?? false;
+  }
+  hasAnyRole(roles) {
+    if (!this.user.roles?.length) return false;
+    return roles.some((role) => this.user.roles.includes(role));
+  }
+  hasAllRoles(roles) {
+    if (!this.user.roles?.length) return roles.length === 0;
+    return roles.every((role) => this.user.roles.includes(role));
+  }
+  hasPermission(permission) {
+    return this.user.permissions?.includes(permission) ?? false;
+  }
+  hasAllPermissions(permissions) {
+    if (!this.user.permissions?.length) return permissions.length === 0;
+    return permissions.every((perm) => this.user.permissions.includes(perm));
+  }
+  hasAnyPermission(permissions) {
+    if (!this.user.permissions?.length) return false;
+    return permissions.some((perm) => this.user.permissions.includes(perm));
+  }
+};
+var AnonymousContext = class {
+  authenticated = false;
+  user = void 0;
+  token = void 0;
+  authenticatedAt = void 0;
+  hasRole() {
+    return false;
+  }
+  hasAnyRole() {
+    return false;
+  }
+  hasAllRoles() {
+    return false;
+  }
+  hasPermission() {
+    return false;
+  }
+  hasAllPermissions() {
+    return false;
+  }
+  hasAnyPermission() {
+    return false;
+  }
+};
+var ANONYMOUS_CONTEXT = new AnonymousContext();
+
+// src/auth/LiveAuthManager.ts
+var LiveAuthManager = class {
+  providers = /* @__PURE__ */ new Map();
+  defaultProviderName;
+  /**
+   * Register an auth provider.
+   */
+  register(provider) {
+    this.providers.set(provider.name, provider);
+    if (!this.defaultProviderName) {
+      this.defaultProviderName = provider.name;
+    }
+    console.log(`[Auth] Provider registered: ${provider.name}`);
+  }
+  /**
+   * Remove an auth provider.
+   */
+  unregister(name) {
+    this.providers.delete(name);
+    if (this.defaultProviderName === name) {
+      this.defaultProviderName = this.providers.keys().next().value;
+    }
+  }
+  /**
+   * Set the default auth provider.
+   */
+  setDefault(name) {
+    if (!this.providers.has(name)) {
+      throw new Error(`Auth provider '${name}' not registered`);
+    }
+    this.defaultProviderName = name;
+  }
+  /**
+   * Returns true if at least one provider is registered.
+   */
+  hasProviders() {
+    return this.providers.size > 0;
+  }
+  /**
+   * Returns the default provider or undefined.
+   */
+  getDefaultProvider() {
+    if (!this.defaultProviderName) return void 0;
+    return this.providers.get(this.defaultProviderName);
+  }
+  /**
+   * Authenticate credentials using the specified provider, or try all providers.
+   * Returns ANONYMOUS_CONTEXT if no credentials or no providers.
+   */
+  async authenticate(credentials, providerName) {
+    if (!credentials || Object.keys(credentials).every((k) => !credentials[k])) {
+      return ANONYMOUS_CONTEXT;
+    }
+    if (this.providers.size === 0) {
+      return ANONYMOUS_CONTEXT;
+    }
+    if (providerName) {
+      const provider = this.providers.get(providerName);
+      if (!provider) {
+        console.warn(`[Auth] Provider '${providerName}' not found`);
+        return ANONYMOUS_CONTEXT;
+      }
+      try {
+        const context = await provider.authenticate(credentials);
+        return context || ANONYMOUS_CONTEXT;
+      } catch (error) {
+        console.error(`[Auth] Failed via '${providerName}':`, error.message);
+        return ANONYMOUS_CONTEXT;
+      }
+    }
+    const providersToTry = [];
+    if (this.defaultProviderName) {
+      const defaultProvider = this.providers.get(this.defaultProviderName);
+      if (defaultProvider) providersToTry.push(defaultProvider);
+    }
+    for (const [name, provider] of this.providers) {
+      if (name !== this.defaultProviderName) {
+        providersToTry.push(provider);
+      }
+    }
+    for (const provider of providersToTry) {
+      try {
+        const context = await provider.authenticate(credentials);
+        if (context && context.authenticated) {
+          return context;
+        }
+      } catch {
+      }
+    }
+    return ANONYMOUS_CONTEXT;
+  }
+  /**
+   * Verify auth context meets component requirements.
+   */
+  authorizeComponent(authContext, authConfig) {
+    if (!authConfig) {
+      return { allowed: true };
+    }
+    if (authConfig.required && !authContext.authenticated) {
+      return { allowed: false, reason: "Authentication required" };
+    }
+    if (authConfig.roles?.length) {
+      if (!authContext.authenticated) {
+        return { allowed: false, reason: `Authentication required. Roles needed: ${authConfig.roles.join(", ")}` };
+      }
+      if (!authContext.hasAnyRole(authConfig.roles)) {
+        return { allowed: false, reason: `Insufficient roles. Required one of: ${authConfig.roles.join(", ")}` };
+      }
+    }
+    if (authConfig.permissions?.length) {
+      if (!authContext.authenticated) {
+        return { allowed: false, reason: `Authentication required. Permissions needed: ${authConfig.permissions.join(", ")}` };
+      }
+      if (!authContext.hasAllPermissions(authConfig.permissions)) {
+        return { allowed: false, reason: `Insufficient permissions. Required all: ${authConfig.permissions.join(", ")}` };
+      }
+    }
+    return { allowed: true };
+  }
+  /**
+   * Verify auth context allows executing a specific action.
+   */
+  async authorizeAction(authContext, componentName, action, actionAuth, providerName) {
+    if (!actionAuth) {
+      return { allowed: true };
+    }
+    if (actionAuth.roles?.length) {
+      if (!authContext.authenticated) {
+        return { allowed: false, reason: `Authentication required for action '${action}'` };
+      }
+      if (!authContext.hasAnyRole(actionAuth.roles)) {
+        return { allowed: false, reason: `Insufficient roles for action '${action}'. Required one of: ${actionAuth.roles.join(", ")}` };
+      }
+    }
+    if (actionAuth.permissions?.length) {
+      if (!authContext.authenticated) {
+        return { allowed: false, reason: `Authentication required for action '${action}'` };
+      }
+      if (!authContext.hasAllPermissions(actionAuth.permissions)) {
+        return { allowed: false, reason: `Insufficient permissions for action '${action}'. Required all: ${actionAuth.permissions.join(", ")}` };
+      }
+    }
+    const name = providerName || this.defaultProviderName;
+    if (name) {
+      const provider = this.providers.get(name);
+      if (provider?.authorizeAction) {
+        const allowed = await provider.authorizeAction(authContext, componentName, action);
+        if (!allowed) {
+          return { allowed: false, reason: `Action '${action}' denied by auth provider '${name}'` };
+        }
+      }
+    }
+    return { allowed: true };
+  }
+  /**
+   * Verify auth context allows joining a room.
+   */
+  async authorizeRoom(authContext, roomId, providerName) {
+    const name = providerName || this.defaultProviderName;
+    if (!name) return { allowed: true };
+    const provider = this.providers.get(name);
+    if (!provider?.authorizeRoom) return { allowed: true };
+    try {
+      const allowed = await provider.authorizeRoom(authContext, roomId);
+      if (!allowed) {
+        return { allowed: false, reason: `Access to room '${roomId}' denied by auth provider '${name}'` };
+      }
+      return { allowed: true };
+    } catch (error) {
+      return { allowed: false, reason: `Room authorization error: ${error.message}` };
+    }
+  }
+  /**
+   * Get info about registered providers.
+   */
+  getInfo() {
+    return {
+      providers: Array.from(this.providers.keys()),
+      defaultProvider: this.defaultProviderName
+    };
+  }
+};
+var StateSignatureManager = class {
+  secret;
+  previousSecrets = [];
+  rotationTimer;
+  usedNonces = /* @__PURE__ */ new Set();
+  nonceCleanupTimer;
+  stateBackups = /* @__PURE__ */ new Map();
+  config;
+  constructor(config = {}) {
+    const defaultSecret = typeof process !== "undefined" ? process.env?.LIVE_STATE_SECRET : void 0;
+    this.config = {
+      secret: config.secret ?? defaultSecret ?? "",
+      rotationEnabled: config.rotationEnabled ?? false,
+      rotationInterval: config.rotationInterval ?? 24 * 60 * 60 * 1e3,
+      compressionEnabled: config.compressionEnabled ?? true,
+      encryptionEnabled: config.encryptionEnabled ?? false,
+      nonceEnabled: config.nonceEnabled ?? false,
+      maxStateAge: config.maxStateAge ?? 7 * 24 * 60 * 60 * 1e3,
+      backupEnabled: config.backupEnabled ?? true,
+      maxBackups: config.maxBackups ?? 3
+    };
+    if (!this.config.secret) {
+      this.config.secret = randomBytes(32).toString("hex");
+      liveWarn("state", null, "No LIVE_STATE_SECRET provided. Using random key (state will not persist across restarts).");
+    }
+    this.secret = Buffer.from(this.config.secret, "utf-8");
+    if (this.config.rotationEnabled) {
+      this.setupKeyRotation();
+    }
+    if (this.config.nonceEnabled) {
+      this.nonceCleanupTimer = setInterval(() => this.cleanupNonces(), 60 * 60 * 1e3);
+    }
+  }
+  async signState(componentId, state, version, options) {
+    let dataStr = JSON.stringify(state);
+    let compressed = false;
+    let encrypted = false;
+    if ((options?.compress ?? this.config.compressionEnabled) && dataStr.length > 1024) {
+      const compressedBuf = gzipSync(Buffer.from(dataStr, "utf-8"));
+      const compressedB64 = compressedBuf.toString("base64");
+      if (compressedB64.length < dataStr.length * 0.9) {
+        dataStr = compressedB64;
+        compressed = true;
+      }
+    }
+    if (this.config.encryptionEnabled) {
+      const iv = randomBytes(16);
+      const key = this.deriveEncryptionKey();
+      const cipher = createCipheriv("aes-256-cbc", key, iv);
+      let encryptedData = cipher.update(dataStr, "utf-8", "base64");
+      encryptedData += cipher.final("base64");
+      dataStr = iv.toString("base64") + ":" + encryptedData;
+      encrypted = true;
+    }
+    const nonce = this.config.nonceEnabled ? randomBytes(16).toString("hex") : void 0;
+    const signedState = {
+      data: dataStr,
+      signature: "",
+      timestamp: Date.now(),
+      version,
+      componentId,
+      nonce,
+      compressed,
+      encrypted
+    };
+    signedState.signature = this.computeSignature(signedState);
+    if (options?.backup ?? this.config.backupEnabled) {
+      this.backupState(componentId, signedState);
+    }
+    return signedState;
+  }
+  async validateState(signedState) {
+    try {
+      const age = Date.now() - signedState.timestamp;
+      if (age > this.config.maxStateAge) {
+        return { valid: false, error: "State expired" };
+      }
+      if (signedState.nonce && this.config.nonceEnabled) {
+        if (this.usedNonces.has(signedState.nonce)) {
+          return { valid: false, error: "Nonce already used (replay attempt)" };
+        }
+      }
+      const expectedSig = this.computeSignature(signedState);
+      if (this.timingSafeEqual(signedState.signature, expectedSig)) {
+        if (signedState.nonce) this.usedNonces.add(signedState.nonce);
+        return { valid: true };
+      }
+      for (const prevSecret of this.previousSecrets) {
+        const prevSig = this.computeSignatureWithKey(signedState, prevSecret);
+        if (this.timingSafeEqual(signedState.signature, prevSig)) {
+          if (signedState.nonce) this.usedNonces.add(signedState.nonce);
+          return { valid: true };
+        }
+      }
+      return { valid: false, error: "Invalid signature" };
+    } catch (error) {
+      return { valid: false, error: error.message };
+    }
+  }
+  async extractData(signedState) {
+    let dataStr = signedState.data;
+    if (signedState.encrypted) {
+      const [ivB64, encryptedData] = dataStr.split(":");
+      const iv = Buffer.from(ivB64, "base64");
+      const key = this.deriveEncryptionKey();
+      const decipher = createDecipheriv("aes-256-cbc", key, iv);
+      dataStr = decipher.update(encryptedData, "base64", "utf-8");
+      dataStr += decipher.final("utf-8");
+    }
+    if (signedState.compressed) {
+      const decompressed = gunzipSync(Buffer.from(dataStr, "base64"));
+      dataStr = decompressed.toString("utf-8");
+    }
+    return JSON.parse(dataStr);
+  }
+  getBackups(componentId) {
+    return (this.stateBackups.get(componentId) || []).map((b) => b.signedState);
+  }
+  getLatestBackup(componentId) {
+    const backups = this.stateBackups.get(componentId);
+    if (!backups || backups.length === 0) return null;
+    return backups[backups.length - 1].signedState;
+  }
+  backupState(componentId, signedState) {
+    if (!this.stateBackups.has(componentId)) {
+      this.stateBackups.set(componentId, []);
+    }
+    const backups = this.stateBackups.get(componentId);
+    backups.push({ signedState, backedUpAt: Date.now() });
+    while (backups.length > this.config.maxBackups) {
+      backups.shift();
+    }
+  }
+  computeSignature(signedState) {
+    return this.computeSignatureWithKey(signedState, this.secret);
+  }
+  computeSignatureWithKey(signedState, key) {
+    const payload = `${signedState.componentId}:${signedState.version}:${signedState.timestamp}:${signedState.data}${signedState.nonce ? ":" + signedState.nonce : ""}`;
+    return createHmac("sha256", key).update(payload).digest("hex");
+  }
+  timingSafeEqual(a, b) {
+    if (a.length !== b.length) return false;
+    const bufA = Buffer.from(a);
+    const bufB = Buffer.from(b);
+    try {
+      const { timingSafeEqual: tse } = __require("crypto");
+      return tse(bufA, bufB);
+    } catch {
+      return a === b;
+    }
+  }
+  deriveEncryptionKey() {
+    return createHmac("sha256", this.secret).update("encryption-key-derivation").digest();
+  }
+  setupKeyRotation() {
+    this.rotationTimer = setInterval(() => {
+      this.previousSecrets.unshift(this.secret);
+      if (this.previousSecrets.length > 3) {
+        this.previousSecrets.pop();
+      }
+      this.secret = randomBytes(32);
+      liveLog("state", null, "Key rotation completed");
+    }, this.config.rotationInterval);
+  }
+  cleanupNonces() {
+    if (this.usedNonces.size > 1e5) {
+      this.usedNonces.clear();
+    }
+  }
+  shutdown() {
+    if (this.rotationTimer) clearInterval(this.rotationTimer);
+    if (this.nonceCleanupTimer) clearInterval(this.nonceCleanupTimer);
+  }
+};
+var PerformanceMonitor = class extends EventEmitter {
+  components = /* @__PURE__ */ new Map();
+  alerts = [];
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      slowActionThreshold: config.slowActionThreshold ?? 1e3,
+      slowRenderThreshold: config.slowRenderThreshold ?? 500,
+      highErrorRateThreshold: config.highErrorRateThreshold ?? 10,
+      alertsEnabled: config.alertsEnabled ?? true
+    };
+  }
+  initializeComponent(componentId, componentName) {
+    this.components.set(componentId, {
+      componentId,
+      componentName,
+      mountTime: Date.now(),
+      actionTimes: /* @__PURE__ */ new Map(),
+      renderTimes: [],
+      stateChanges: 0,
+      errorCount: 0,
+      lastActivity: Date.now()
+    });
+  }
+  recordRenderTime(componentId, time) {
+    const metrics = this.components.get(componentId);
+    if (!metrics) return;
+    metrics.renderTimes.push(time);
+    metrics.lastActivity = Date.now();
+    if (this.config.alertsEnabled && time > this.config.slowRenderThreshold) {
+      this.addAlert({
+        type: "slow_render",
+        componentId,
+        componentName: metrics.componentName,
+        message: `Slow render: ${time}ms (threshold: ${this.config.slowRenderThreshold}ms)`,
+        value: time,
+        threshold: this.config.slowRenderThreshold,
+        timestamp: Date.now()
+      });
+    }
+  }
+  recordActionTime(componentId, action, time, error) {
+    const metrics = this.components.get(componentId);
+    if (!metrics) return;
+    if (!metrics.actionTimes.has(action)) {
+      metrics.actionTimes.set(action, []);
+    }
+    metrics.actionTimes.get(action).push(time);
+    metrics.lastActivity = Date.now();
+    if (error) {
+      metrics.errorCount++;
+      if (this.config.alertsEnabled && metrics.errorCount >= this.config.highErrorRateThreshold) {
+        this.addAlert({
+          type: "high_error_rate",
+          componentId,
+          componentName: metrics.componentName,
+          message: `High error rate: ${metrics.errorCount} errors`,
+          value: metrics.errorCount,
+          threshold: this.config.highErrorRateThreshold,
+          timestamp: Date.now()
+        });
+      }
+    }
+    if (this.config.alertsEnabled && time > this.config.slowActionThreshold) {
+      this.addAlert({
+        type: "slow_action",
+        componentId,
+        componentName: metrics.componentName,
+        message: `Slow action '${action}': ${time}ms (threshold: ${this.config.slowActionThreshold}ms)`,
+        value: time,
+        threshold: this.config.slowActionThreshold,
+        timestamp: Date.now()
+      });
+    }
+  }
+  recordStateChange(componentId) {
+    const metrics = this.components.get(componentId);
+    if (metrics) {
+      metrics.stateChanges++;
+      metrics.lastActivity = Date.now();
+    }
+  }
+  removeComponent(componentId) {
+    this.components.delete(componentId);
+  }
+  getComponentMetrics(componentId) {
+    return this.components.get(componentId) ?? null;
+  }
+  getAllMetrics() {
+    return Array.from(this.components.values());
+  }
+  getAlerts(limit = 50) {
+    return this.alerts.slice(-limit);
+  }
+  clearAlerts() {
+    this.alerts = [];
+  }
+  getStats() {
+    return {
+      totalComponents: this.components.size,
+      totalAlerts: this.alerts.length,
+      components: Array.from(this.components.entries()).map(([id, m]) => ({
+        id,
+        name: m.componentName,
+        renderCount: m.renderTimes.length,
+        avgRenderTime: m.renderTimes.length > 0 ? m.renderTimes.reduce((a, b) => a + b, 0) / m.renderTimes.length : 0,
+        actionCount: Array.from(m.actionTimes.values()).reduce((sum, times) => sum + times.length, 0),
+        stateChanges: m.stateChanges,
+        errorCount: m.errorCount
+      }))
+    };
+  }
+  addAlert(alert) {
+    this.alerts.push(alert);
+    if (this.alerts.length > 1e3) {
+      this.alerts = this.alerts.slice(-500);
+    }
+    liveWarn("performance", alert.componentId, alert.message);
+    this.emit("alert", alert);
+  }
+};
+
+// src/upload/FileUploadManager.ts
+var MAGIC_BYTES = {
+  "image/jpeg": [{ bytes: [255, 216, 255] }],
+  "image/png": [{ bytes: [137, 80, 78, 71, 13, 10, 26, 10] }],
+  "image/gif": [
+    { bytes: [71, 73, 70, 56, 55, 97] },
+    { bytes: [71, 73, 70, 56, 57, 97] }
+  ],
+  "image/webp": [{ bytes: [82, 73, 70, 70], offset: 0 }],
+  "application/pdf": [{ bytes: [37, 80, 68, 70] }],
+  "application/zip": [
+    { bytes: [80, 75, 3, 4] },
+    { bytes: [80, 75, 5, 6] }
+  ],
+  "application/gzip": [{ bytes: [31, 139] }]
+};
+var FileUploadManager = class {
+  activeUploads = /* @__PURE__ */ new Map();
+  maxUploadSize;
+  chunkTimeout;
+  userUploadBytes = /* @__PURE__ */ new Map();
+  maxBytesPerUser;
+  quotaResetInterval;
+  allowedTypes;
+  blockedExtensions;
+  uploadsDir;
+  customAssembleFile;
+  cleanupTimer;
+  quotaTimer;
+  constructor(config = {}) {
+    this.maxUploadSize = config.maxUploadSize ?? 50 * 1024 * 1024;
+    this.chunkTimeout = config.chunkTimeout ?? 3e4;
+    this.maxBytesPerUser = config.maxBytesPerUser ?? 500 * 1024 * 1024;
+    this.quotaResetInterval = config.quotaResetInterval ?? 24 * 60 * 60 * 1e3;
+    this.allowedTypes = config.allowedTypes ?? [
+      "image/jpeg",
+      "image/png",
+      "image/gif",
+      "image/webp",
+      "image/svg+xml",
+      "application/pdf",
+      "text/plain",
+      "text/csv",
+      "text/markdown",
+      "application/json",
+      "application/zip",
+      "application/gzip"
+    ];
+    this.blockedExtensions = new Set(config.blockedExtensions ?? [
+      ".exe",
+      ".bat",
+      ".cmd",
+      ".com",
+      ".msi",
+      ".scr",
+      ".pif",
+      ".sh",
+      ".bash",
+      ".zsh",
+      ".csh",
+      ".ps1",
+      ".psm1",
+      ".psd1",
+      ".vbs",
+      ".vbe",
+      ".js",
+      ".jse",
+      ".wsf",
+      ".wsh",
+      ".dll",
+      ".sys",
+      ".drv",
+      ".so",
+      ".dylib"
+    ]);
+    this.uploadsDir = config.uploadsDir ?? "./uploads";
+    this.customAssembleFile = config.assembleFile;
+    this.cleanupTimer = setInterval(() => this.cleanupStaleUploads(), 5 * 60 * 1e3);
+    this.quotaTimer = setInterval(() => this.resetUploadQuotas(), this.quotaResetInterval);
+  }
+  async startUpload(message, userId) {
+    try {
+      const { uploadId, componentId, filename, fileType, fileSize, chunkSize = 64 * 1024 } = message;
+      if (fileSize > this.maxUploadSize) {
+        throw new Error(`File too large: ${fileSize} bytes. Max: ${this.maxUploadSize} bytes`);
+      }
+      if (userId) {
+        const currentUsage = this.userUploadBytes.get(userId) || 0;
+        if (currentUsage + fileSize > this.maxBytesPerUser) {
+          throw new Error(`Upload quota exceeded for user.`);
+        }
+      }
+      if (this.allowedTypes.length > 0 && !this.allowedTypes.includes(fileType)) {
+        throw new Error(`File type not allowed: ${fileType}`);
+      }
+      const pathModule = await import('path');
+      const safeBase = pathModule.basename(filename);
+      const ext = pathModule.extname(safeBase).toLowerCase();
+      if (this.blockedExtensions.has(ext)) {
+        throw new Error(`File extension not allowed: ${ext}`);
+      }
+      const parts = safeBase.split(".");
+      if (parts.length > 2) {
+        for (let i = 1; i < parts.length - 1; i++) {
+          const intermediateExt = "." + parts[i].toLowerCase();
+          if (this.blockedExtensions.has(intermediateExt)) {
+            throw new Error(`Suspicious double extension detected: ${intermediateExt} in ${safeBase}`);
+          }
+        }
+      }
+      if (safeBase.length > 255) {
+        throw new Error("Filename too long");
+      }
+      if (this.activeUploads.has(uploadId)) {
+        throw new Error(`Upload ${uploadId} already in progress`);
+      }
+      const totalChunks = Math.ceil(fileSize / chunkSize);
+      const upload = {
+        uploadId,
+        componentId,
+        filename,
+        fileType,
+        fileSize,
+        totalChunks,
+        receivedChunks: /* @__PURE__ */ new Map(),
+        bytesReceived: 0,
+        startTime: Date.now(),
+        lastChunkTime: Date.now()
+      };
+      this.activeUploads.set(uploadId, upload);
+      if (userId) {
+        const currentUsage = this.userUploadBytes.get(userId) || 0;
+        this.userUploadBytes.set(userId, currentUsage + fileSize);
+      }
+      liveLog("messages", componentId, `Upload started: ${uploadId} (${filename}, ${fileSize} bytes)`);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+  async receiveChunk(message, binaryData = null) {
+    const { uploadId, chunkIndex, totalChunks, data } = message;
+    const upload = this.activeUploads.get(uploadId);
+    if (!upload) throw new Error(`Upload ${uploadId} not found`);
+    if (chunkIndex < 0 || chunkIndex >= totalChunks) {
+      throw new Error(`Invalid chunk index: ${chunkIndex}`);
+    }
+    if (!upload.receivedChunks.has(chunkIndex)) {
+      let chunkBytes;
+      if (binaryData) {
+        upload.receivedChunks.set(chunkIndex, binaryData);
+        chunkBytes = binaryData.length;
+      } else {
+        upload.receivedChunks.set(chunkIndex, data);
+        chunkBytes = Buffer.from(data, "base64").length;
+      }
+      upload.lastChunkTime = Date.now();
+      upload.bytesReceived += chunkBytes;
+    }
+    const progress = upload.bytesReceived / upload.fileSize * 100;
+    return {
+      type: "FILE_UPLOAD_PROGRESS",
+      componentId: upload.componentId,
+      uploadId: upload.uploadId,
+      chunkIndex,
+      totalChunks,
+      bytesUploaded: Math.min(upload.bytesReceived, upload.fileSize),
+      totalBytes: upload.fileSize,
+      progress: Math.min(progress, 100),
+      timestamp: Date.now()
+    };
+  }
+  async completeUpload(message) {
+    try {
+      const { uploadId } = message;
+      const upload = this.activeUploads.get(uploadId);
+      if (!upload) throw new Error(`Upload ${uploadId} not found`);
+      if (upload.bytesReceived !== upload.fileSize) {
+        throw new Error(`Incomplete upload: received ${upload.bytesReceived}/${upload.fileSize} bytes`);
+      }
+      this.validateContentMagicBytes(upload);
+      const fileUrl = this.customAssembleFile ? await this.customAssembleFile(upload) : await this.defaultAssembleFile(upload);
+      this.activeUploads.delete(uploadId);
+      return {
+        type: "FILE_UPLOAD_COMPLETE",
+        componentId: upload.componentId,
+        uploadId: upload.uploadId,
+        success: true,
+        filename: upload.filename,
+        fileUrl,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      return {
+        type: "FILE_UPLOAD_COMPLETE",
+        componentId: "",
+        uploadId: message.uploadId,
+        success: false,
+        error: error.message,
+        timestamp: Date.now()
+      };
+    }
+  }
+  async defaultAssembleFile(upload) {
+    const { writeFile, mkdir } = await import('fs/promises');
+    const { existsSync } = await import('fs');
+    const { join, extname, basename } = await import('path');
+    if (!existsSync(this.uploadsDir)) {
+      await mkdir(this.uploadsDir, { recursive: true });
+    }
+    const extension = extname(basename(upload.filename)).toLowerCase();
+    const safeFilename = `${crypto.randomUUID()}${extension}`;
+    const filePath = join(this.uploadsDir, safeFilename);
+    const chunks = [];
+    for (let i = 0; i < upload.totalChunks; i++) {
+      const chunkData = upload.receivedChunks.get(i);
+      if (chunkData) {
+        if (Buffer.isBuffer(chunkData)) {
+          chunks.push(chunkData);
+        } else {
+          chunks.push(Buffer.from(chunkData, "base64"));
+        }
+      }
+    }
+    await writeFile(filePath, Buffer.concat(chunks));
+    return `/uploads/${safeFilename}`;
+  }
+  validateContentMagicBytes(upload) {
+    const expectedSignatures = MAGIC_BYTES[upload.fileType];
+    if (!expectedSignatures) return;
+    const firstChunk = upload.receivedChunks.get(0);
+    if (!firstChunk) throw new Error("Cannot validate file content: first chunk missing");
+    const headerBuffer = Buffer.isBuffer(firstChunk) ? firstChunk : Buffer.from(firstChunk, "base64");
+    let matched = false;
+    for (const sig of expectedSignatures) {
+      const offset = sig.offset ?? 0;
+      if (headerBuffer.length < offset + sig.bytes.length) continue;
+      let sigMatches = true;
+      for (let i = 0; i < sig.bytes.length; i++) {
+        if (headerBuffer[offset + i] !== sig.bytes[i]) {
+          sigMatches = false;
+          break;
+        }
+      }
+      if (sigMatches) {
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      throw new Error(
+        `File content does not match claimed type '${upload.fileType}'. The file may be disguised as a different format.`
+      );
+    }
+  }
+  cleanupStaleUploads() {
+    const now = Date.now();
+    for (const [uploadId, upload] of this.activeUploads) {
+      if (now - upload.lastChunkTime > this.chunkTimeout * 2) {
+        this.activeUploads.delete(uploadId);
+        liveLog("messages", null, `Cleaned up stale upload: ${uploadId}`);
+      }
+    }
+  }
+  resetUploadQuotas() {
+    this.userUploadBytes.clear();
+  }
+  getUserUploadUsage(userId) {
+    const used = this.userUploadBytes.get(userId) || 0;
+    return { used, limit: this.maxBytesPerUser, remaining: Math.max(0, this.maxBytesPerUser - used) };
+  }
+  getUploadStatus(uploadId) {
+    return this.activeUploads.get(uploadId) || null;
+  }
+  getStats() {
+    return {
+      activeUploads: this.activeUploads.size,
+      maxUploadSize: this.maxUploadSize,
+      allowedTypes: this.allowedTypes
+    };
+  }
+  shutdown() {
+    if (this.cleanupTimer) clearInterval(this.cleanupTimer);
+    if (this.quotaTimer) clearInterval(this.quotaTimer);
+  }
+};
+var WebSocketConnectionManager = class extends EventEmitter {
+  connections = /* @__PURE__ */ new Map();
+  connectionMetrics = /* @__PURE__ */ new Map();
+  connectionPools = /* @__PURE__ */ new Map();
+  messageQueues = /* @__PURE__ */ new Map();
+  healthCheckTimer;
+  heartbeatTimer;
+  config;
+  loadBalancerIndex = 0;
+  constructor(config) {
+    super();
+    this.config = {
+      maxConnections: 1e4,
+      connectionTimeout: 3e4,
+      heartbeatInterval: 3e4,
+      reconnectAttempts: 5,
+      reconnectDelay: 1e3,
+      maxReconnectDelay: 3e4,
+      jitterFactor: 0.1,
+      loadBalancing: "round-robin",
+      healthCheckInterval: 6e4,
+      messageQueueSize: 1e3,
+      offlineQueueEnabled: true,
+      ...config
+    };
+    this.setupHealthMonitoring();
+    this.setupHeartbeat();
+  }
+  registerConnection(ws, connectionId, poolId) {
+    if (this.connections.size >= this.config.maxConnections) {
+      throw new Error("Maximum connections exceeded");
+    }
+    const metrics = {
+      id: connectionId,
+      connectedAt: /* @__PURE__ */ new Date(),
+      lastActivity: /* @__PURE__ */ new Date(),
+      messagesSent: 0,
+      messagesReceived: 0,
+      bytesTransferred: 0,
+      latency: 0,
+      status: "connected",
+      errorCount: 0,
+      reconnectCount: 0
+    };
+    this.connections.set(connectionId, ws);
+    this.connectionMetrics.set(connectionId, metrics);
+    if (poolId) {
+      this.addToPool(connectionId, poolId);
+    }
+    this.messageQueues.set(connectionId, []);
+    liveLog("websocket", null, `Connection registered: ${connectionId}`);
+    this.emit("connectionRegistered", { connectionId, poolId });
+  }
+  addToPool(connectionId, poolId) {
+    if (!this.connectionPools.has(poolId)) {
+      this.connectionPools.set(poolId, /* @__PURE__ */ new Set());
+    }
+    this.connectionPools.get(poolId).add(connectionId);
+  }
+  removeFromPool(connectionId, poolId) {
+    const pool = this.connectionPools.get(poolId);
+    if (pool) {
+      pool.delete(connectionId);
+      if (pool.size === 0) this.connectionPools.delete(poolId);
+    }
+  }
+  cleanupConnection(connectionId) {
+    this.connections.delete(connectionId);
+    this.connectionMetrics.delete(connectionId);
+    this.messageQueues.delete(connectionId);
+    for (const [poolId, pool] of this.connectionPools) {
+      if (pool.has(connectionId)) {
+        this.removeFromPool(connectionId, poolId);
+      }
+    }
+  }
+  getConnectionMetrics(connectionId) {
+    return this.connectionMetrics.get(connectionId) || null;
+  }
+  getAllConnectionMetrics() {
+    return Array.from(this.connectionMetrics.values());
+  }
+  getSystemStats() {
+    const totalConnections = this.connections.size;
+    const activeConnections = Array.from(this.connections.values()).filter((ws) => ws.readyState === 1).length;
+    const totalPools = this.connectionPools.size;
+    const totalQueuedMessages = Array.from(this.messageQueues.values()).reduce((sum, queue) => sum + queue.length, 0);
+    return {
+      totalConnections,
+      activeConnections,
+      totalPools,
+      totalQueuedMessages,
+      maxConnections: this.config.maxConnections,
+      connectionUtilization: totalConnections / this.config.maxConnections * 100
+    };
+  }
+  setupHealthMonitoring() {
+    this.healthCheckTimer = setInterval(() => this.performHealthChecks(), this.config.healthCheckInterval);
+  }
+  setupHeartbeat() {
+    this.heartbeatTimer = setInterval(() => {
+      for (const [connectionId, ws] of this.connections) {
+        if (ws.readyState === 1) {
+          try {
+            const wsAny = ws;
+            if (typeof wsAny.ping === "function") {
+              wsAny._pingTime = Date.now();
+              wsAny.ping();
+            }
+          } catch {
+          }
+        }
+      }
+    }, this.config.heartbeatInterval);
+  }
+  async performHealthChecks() {
+    const now = Date.now();
+    const unhealthy = [];
+    for (const [connectionId, metrics] of this.connectionMetrics) {
+      const ws = this.connections.get(connectionId);
+      if (!ws || ws.readyState !== 1) {
+        unhealthy.push(connectionId);
+        continue;
+      }
+      const timeSinceActivity = now - metrics.lastActivity.getTime();
+      if (timeSinceActivity > this.config.heartbeatInterval * 2) {
+        metrics.status = "disconnected";
+      }
+      if (metrics.errorCount > 10) {
+        unhealthy.push(connectionId);
+      }
+    }
+    for (const connectionId of unhealthy) {
+      const ws = this.connections.get(connectionId);
+      if (ws) {
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+      this.cleanupConnection(connectionId);
+    }
+  }
+  shutdown() {
+    if (this.healthCheckTimer) clearInterval(this.healthCheckTimer);
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    for (const [, ws] of this.connections) {
+      try {
+        ws.close();
+      } catch {
+      }
+    }
+    this.connections.clear();
+    this.connectionMetrics.clear();
+    this.connectionPools.clear();
+    this.messageQueues.clear();
+  }
+};
+
+// src/component/context.ts
+var _ctx = null;
+function setLiveComponentContext(ctx) {
+  _ctx = ctx;
+}
+function getLiveComponentContext() {
+  if (!_ctx) throw new Error("@fluxstack/live: LiveServer.start() must be called before using LiveComponents");
+  return _ctx;
+}
+
+// src/component/LiveComponent.ts
+var EMIT_OVERRIDE_KEY = /* @__PURE__ */ Symbol.for("fluxstack:emitOverride");
+var _liveDebugger = null;
+function _setLiveDebugger(dbg) {
+  _liveDebugger = dbg;
+}
+var LiveComponent = class _LiveComponent {
+  /** Component name for registry lookup - must be defined in subclasses */
+  static componentName;
+  /** Default state - must be defined in subclasses */
+  static defaultState;
+  /**
+   * Per-component logging control. Silent by default.
+   *
+   * @example
+   * static logging = true                           // all categories
+   * static logging = ['lifecycle', 'messages']      // specific categories
+   */
+  static logging;
+  /**
+   * Component-level auth configuration.
+   */
+  static auth;
+  /**
+   * Per-action auth configuration.
+   */
+  static actionAuth;
+  /**
+   * Data that survives HMR reloads.
+   */
+  static persistent;
+  /**
+   * When true, only ONE server-side instance exists for this component.
+   * All clients share the same state.
+   */
+  static singleton;
+  id;
+  _state;
+  state;
+  // Proxy wrapper
+  ws;
+  room;
+  userId;
+  broadcastToRoom = () => {
+  };
+  // Server-only private state (NEVER sent to client)
+  _privateState = {};
+  // Auth context (injected by registry during mount)
+  _authContext = ANONYMOUS_CONTEXT;
+  // Room event subscriptions (cleaned up on destroy)
+  roomEventUnsubscribers = [];
+  joinedRooms = /* @__PURE__ */ new Set();
+  // Room type for typed events (override in subclass)
+  roomType = "default";
+  // Cached room handles
+  roomHandles = /* @__PURE__ */ new Map();
+  // Guard against infinite recursion in onStateChange
+  _inStateChange = false;
+  // Singleton emit override
+  [EMIT_OVERRIDE_KEY] = null;
+  constructor(initialState, ws, options) {
+    this.id = this.generateId();
+    const ctor = this.constructor;
+    this._state = { ...ctor.defaultState, ...initialState };
+    this.state = this.createStateProxy(this._state);
+    this.ws = ws;
+    this.room = options?.room;
+    this.userId = options?.userId;
+    if (this.room) {
+      this.joinedRooms.add(this.room);
+      const ctx = getLiveComponentContext();
+      ctx.roomManager.joinRoom(this.id, this.room, this.ws);
+    }
+    this.createDirectStateAccessors();
+  }
+  // Create getters/setters for each state property directly on `this`
+  createDirectStateAccessors() {
+    const forbidden = /* @__PURE__ */ new Set([
+      ...Object.keys(this),
+      ...Object.getOwnPropertyNames(Object.getPrototypeOf(this)),
+      "state",
+      "_state",
+      "ws",
+      "id",
+      "room",
+      "userId",
+      "broadcastToRoom",
+      "$private",
+      "_privateState",
+      "$room",
+      "$rooms",
+      "roomType",
+      "roomHandles",
+      "joinedRooms",
+      "roomEventUnsubscribers"
+    ]);
+    for (const key of Object.keys(this._state)) {
+      if (!forbidden.has(key)) {
+        Object.defineProperty(this, key, {
+          get: () => this._state[key],
+          set: (value) => {
+            this.state[key] = value;
+          },
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+  }
+  // Create a Proxy that auto-emits STATE_DELTA on any mutation
+  createStateProxy(state) {
+    const self = this;
+    return new Proxy(state, {
+      set(target, prop, value) {
+        const oldValue = target[prop];
+        if (oldValue !== value) {
+          target[prop] = value;
+          const changes = { [prop]: value };
+          self.emit("STATE_DELTA", { delta: changes });
+          if (!self._inStateChange) {
+            self._inStateChange = true;
+            try {
+              self.onStateChange(changes);
+            } catch (err) {
+              console.error(`[${self.id}] onStateChange error:`, err?.message || err);
+            } finally {
+              self._inStateChange = false;
+            }
+          }
+          _liveDebugger?.trackStateChange(
+            self.id,
+            changes,
+            target,
+            "proxy"
+          );
+        }
+        return true;
+      },
+      get(target, prop) {
+        return target[prop];
+      }
+    });
+  }
+  // ========================================
+  // $private - Server-Only State
+  // ========================================
+  get $private() {
+    return this._privateState;
+  }
+  // ========================================
+  // $room - Unified Room System
+  // ========================================
+  get $room() {
+    const self = this;
+    const ctx = getLiveComponentContext();
+    const createHandle = (roomId) => {
+      if (this.roomHandles.has(roomId)) {
+        return this.roomHandles.get(roomId);
+      }
+      const handle = {
+        get id() {
+          return roomId;
+        },
+        get state() {
+          return ctx.roomManager.getRoomState(roomId);
+        },
+        join: (initialState) => {
+          if (self.joinedRooms.has(roomId)) return;
+          self.joinedRooms.add(roomId);
+          ctx.roomManager.joinRoom(self.id, roomId, self.ws, initialState);
+          try {
+            self.onRoomJoin(roomId);
+          } catch (err) {
+            console.error(`[${self.id}] onRoomJoin error:`, err?.message || err);
+          }
+        },
+        leave: () => {
+          if (!self.joinedRooms.has(roomId)) return;
+          self.joinedRooms.delete(roomId);
+          ctx.roomManager.leaveRoom(self.id, roomId);
+          try {
+            self.onRoomLeave(roomId);
+          } catch (err) {
+            console.error(`[${self.id}] onRoomLeave error:`, err?.message || err);
+          }
+        },
+        emit: (event, data) => {
+          return ctx.roomManager.emitToRoom(roomId, event, data, self.id);
+        },
+        on: (event, handler) => {
+          const unsubscribe = ctx.roomEvents.on(
+            "room",
+            roomId,
+            event,
+            self.id,
+            handler
+          );
+          self.roomEventUnsubscribers.push(unsubscribe);
+          return unsubscribe;
+        },
+        setState: (updates) => {
+          ctx.roomManager.setRoomState(roomId, updates, self.id);
+        }
+      };
+      this.roomHandles.set(roomId, handle);
+      return handle;
+    };
+    const proxyFn = ((roomId) => createHandle(roomId));
+    const defaultHandle = this.room ? createHandle(this.room) : null;
+    Object.defineProperties(proxyFn, {
+      id: { get: () => self.room },
+      state: { get: () => defaultHandle?.state ?? {} },
+      join: {
+        value: (initialState) => {
+          if (!defaultHandle) throw new Error("No default room set");
+          defaultHandle.join(initialState);
+        }
+      },
+      leave: {
+        value: () => {
+          if (!defaultHandle) throw new Error("No default room set");
+          defaultHandle.leave();
+        }
+      },
+      emit: {
+        value: (event, data) => {
+          if (!defaultHandle) throw new Error("No default room set");
+          return defaultHandle.emit(event, data);
+        }
+      },
+      on: {
+        value: (event, handler) => {
+          if (!defaultHandle) throw new Error("No default room set");
+          return defaultHandle.on(event, handler);
+        }
+      },
+      setState: {
+        value: (updates) => {
+          if (!defaultHandle) throw new Error("No default room set");
+          defaultHandle.setState(updates);
+        }
+      }
+    });
+    return proxyFn;
+  }
+  /**
+   * List of room IDs this component is participating in
+   */
+  get $rooms() {
+    return Array.from(this.joinedRooms);
+  }
+  // ========================================
+  // $auth - Authentication Context
+  // ========================================
+  get $auth() {
+    return this._authContext;
+  }
+  /** @internal */
+  setAuthContext(context) {
+    this._authContext = context;
+    if (context.authenticated && context.user?.id && !this.userId) {
+      this.userId = context.user.id;
+    }
+  }
+  // ========================================
+  // $persistent - HMR-Safe State
+  // ========================================
+  get $persistent() {
+    const ctor = this.constructor;
+    const name = ctor.componentName || ctor.name;
+    const key = `__fluxstack_persistent_${name}`;
+    if (!globalThis[key]) {
+      globalThis[key] = { ...ctor.persistent || {} };
+    }
+    return globalThis[key];
+  }
+  // ========================================
+  // Lifecycle Hooks
+  // ========================================
+  onConnect() {
+  }
+  onMount() {
+  }
+  onDisconnect() {
+  }
+  onDestroy() {
+  }
+  onStateChange(changes) {
+  }
+  onRoomJoin(roomId) {
+  }
+  onRoomLeave(roomId) {
+  }
+  onRehydrate(previousState) {
+  }
+  onAction(action, payload) {
+  }
+  onClientJoin(connectionId, connectionCount) {
+  }
+  onClientLeave(connectionId, connectionCount) {
+  }
+  // ========================================
+  // State Management
+  // ========================================
+  setState(updates) {
+    const newUpdates = typeof updates === "function" ? updates(this._state) : updates;
+    const actualChanges = {};
+    let hasChanges = false;
+    for (const key of Object.keys(newUpdates)) {
+      if (this._state[key] !== newUpdates[key]) {
+        actualChanges[key] = newUpdates[key];
+        hasChanges = true;
+      }
+    }
+    if (!hasChanges) return;
+    Object.assign(this._state, actualChanges);
+    this.emit("STATE_DELTA", { delta: actualChanges });
+    if (!this._inStateChange) {
+      this._inStateChange = true;
+      try {
+        this.onStateChange(actualChanges);
+      } catch (err) {
+        console.error(`[${this.id}] onStateChange error:`, err?.message || err);
+      } finally {
+        this._inStateChange = false;
+      }
+    }
+    _liveDebugger?.trackStateChange(
+      this.id,
+      actualChanges,
+      this._state,
+      "setState"
+    );
+  }
+  async setValue(payload) {
+    const { key, value } = payload;
+    const update = { [key]: value };
+    this.setState(update);
+    return { success: true, key, value };
+  }
+  // ========================================
+  // Action Security
+  // ========================================
+  static publicActions;
+  static BLOCKED_ACTIONS = /* @__PURE__ */ new Set([
+    "constructor",
+    "destroy",
+    "executeAction",
+    "getSerializableState",
+    "onMount",
+    "onDestroy",
+    "onConnect",
+    "onDisconnect",
+    "onStateChange",
+    "onRoomJoin",
+    "onRoomLeave",
+    "onRehydrate",
+    "onAction",
+    "onClientJoin",
+    "onClientLeave",
+    "setState",
+    "emit",
+    "broadcast",
+    "broadcastToRoom",
+    "createStateProxy",
+    "createDirectStateAccessors",
+    "generateId",
+    "setAuthContext",
+    "$auth",
+    "$private",
+    "_privateState",
+    "$persistent",
+    "_inStateChange",
+    "$room",
+    "$rooms",
+    "subscribeToRoom",
+    "unsubscribeFromRoom",
+    "emitRoomEvent",
+    "onRoomEvent",
+    "emitRoomEventWithState"
+  ]);
+  async executeAction(action, payload) {
+    const actionStart = Date.now();
+    try {
+      if (_LiveComponent.BLOCKED_ACTIONS.has(action)) {
+        throw new Error(`Action '${action}' is not callable`);
+      }
+      if (action.startsWith("_") || action.startsWith("#")) {
+        throw new Error(`Action '${action}' is not callable`);
+      }
+      const componentClass = this.constructor;
+      const publicActions = componentClass.publicActions;
+      if (!publicActions) {
+        console.warn(`[SECURITY] Component '${componentClass.componentName || componentClass.name}' has no publicActions defined. All remote actions are blocked.`);
+        throw new Error(`Action '${action}' is not callable - component has no publicActions defined`);
+      }
+      if (!publicActions.includes(action)) {
+        const methodExists = typeof this[action] === "function";
+        if (methodExists) {
+          const name = componentClass.componentName || componentClass.name;
+          throw new Error(
+            `Action '${action}' exists on '${name}' but is not listed in publicActions. Add it to: static publicActions = [..., '${action}']`
+          );
+        }
+        throw new Error(`Action '${action}' is not callable`);
+      }
+      const method = this[action];
+      if (typeof method !== "function") {
+        throw new Error(`Action '${action}' not found on component`);
+      }
+      if (Object.prototype.hasOwnProperty.call(Object.prototype, action)) {
+        throw new Error(`Action '${action}' is not callable`);
+      }
+      _liveDebugger?.trackActionCall(this.id, action, payload);
+      let hookResult;
+      try {
+        hookResult = await this.onAction(action, payload);
+      } catch (hookError) {
+        _liveDebugger?.trackActionError(this.id, action, hookError.message, Date.now() - actionStart);
+        this.emit("ERROR", {
+          action,
+          error: `Action '${action}' failed pre-validation`
+        });
+        throw hookError;
+      }
+      if (hookResult === false) {
+        _liveDebugger?.trackActionError(this.id, action, "Action cancelled", Date.now() - actionStart);
+        throw new Error(`Action '${action}' was cancelled`);
+      }
+      const result = await method.call(this, payload);
+      _liveDebugger?.trackActionResult(this.id, action, result, Date.now() - actionStart);
+      return result;
+    } catch (error) {
+      if (!error.message?.includes("was cancelled") && !error.message?.includes("pre-validation")) {
+        _liveDebugger?.trackActionError(this.id, action, error.message, Date.now() - actionStart);
+        this.emit("ERROR", {
+          action,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+  // ========================================
+  // Messaging
+  // ========================================
+  emit(type, payload) {
+    const override = this[EMIT_OVERRIDE_KEY];
+    if (override) {
+      override(type, payload);
+      return;
+    }
+    const message = {
+      type,
+      componentId: this.id,
+      payload,
+      timestamp: Date.now(),
+      userId: this.userId,
+      room: this.room
+    };
+    if (this.ws && this.ws.send) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+  broadcast(type, payload, excludeCurrentUser = false) {
+    if (!this.room) {
+      liveWarn("rooms", this.id, `[${this.id}] Cannot broadcast '${type}' - no room set`);
+      return;
+    }
+    const message = {
+      type,
+      payload,
+      room: this.room,
+      excludeUser: excludeCurrentUser ? this.userId : void 0
+    };
+    liveLog("rooms", this.id, `[${this.id}] Broadcasting '${type}' to room '${this.room}'`);
+    this.broadcastToRoom(message);
+  }
+  // ========================================
+  // Room Events - Internal Server Events
+  // ========================================
+  emitRoomEvent(event, data, notifySelf = false) {
+    if (!this.room) {
+      liveWarn("rooms", this.id, `[${this.id}] Cannot emit room event '${event}' - no room set`);
+      return 0;
+    }
+    const ctx = getLiveComponentContext();
+    const excludeId = notifySelf ? void 0 : this.id;
+    const notified = ctx.roomEvents.emit(this.roomType, this.room, event, data, excludeId);
+    liveLog("rooms", this.id, `[${this.id}] Room event '${event}' -> ${notified} components`);
+    _liveDebugger?.trackRoomEmit(this.id, this.room, event, data);
+    return notified;
+  }
+  onRoomEvent(event, handler) {
+    if (!this.room) {
+      liveWarn("rooms", this.id, `[${this.id}] Cannot subscribe to room event '${event}' - no room set`);
+      return;
+    }
+    const ctx = getLiveComponentContext();
+    const unsubscribe = ctx.roomEvents.on(
+      this.roomType,
+      this.room,
+      event,
+      this.id,
+      handler
+    );
+    this.roomEventUnsubscribers.push(unsubscribe);
+    liveLog("rooms", this.id, `[${this.id}] Subscribed to room event '${event}'`);
+  }
+  emitRoomEventWithState(event, data, stateUpdates) {
+    this.setState(stateUpdates);
+    return this.emitRoomEvent(event, data, false);
+  }
+  async subscribeToRoom(roomId) {
+    this.room = roomId;
+  }
+  async unsubscribeFromRoom() {
+    this.room = void 0;
+  }
+  // ========================================
+  // Internal
+  // ========================================
+  generateId() {
+    return `live-${crypto.randomUUID()}`;
+  }
+  destroy() {
+    try {
+      this.onDestroy();
+    } catch (err) {
+      console.error(`[${this.id}] onDestroy error:`, err?.message || err);
+    }
+    for (const unsubscribe of this.roomEventUnsubscribers) {
+      unsubscribe();
+    }
+    this.roomEventUnsubscribers = [];
+    const ctx = getLiveComponentContext();
+    for (const roomId of this.joinedRooms) {
+      ctx.roomManager.leaveRoom(this.id, roomId);
+    }
+    this.joinedRooms.clear();
+    this.roomHandles.clear();
+    this._privateState = {};
+    this.unsubscribeFromRoom();
+  }
+  getSerializableState() {
+    return this.state;
+  }
+};
+
+// src/component/ComponentRegistry.ts
+var ComponentRegistry = class {
+  components = /* @__PURE__ */ new Map();
+  definitions = /* @__PURE__ */ new Map();
+  metadata = /* @__PURE__ */ new Map();
+  rooms = /* @__PURE__ */ new Map();
+  wsConnections = /* @__PURE__ */ new Map();
+  autoDiscoveredComponents = /* @__PURE__ */ new Map();
+  healthCheckInterval;
+  singletons = /* @__PURE__ */ new Map();
+  authManager;
+  debugger;
+  stateSignature;
+  performanceMonitor;
+  constructor(deps) {
+    this.authManager = deps.authManager;
+    this.debugger = deps.debugger;
+    this.stateSignature = deps.stateSignature;
+    this.performanceMonitor = deps.performanceMonitor;
+    _setLiveDebugger(deps.debugger);
+    this.setupHealthMonitoring();
+  }
+  setupHealthMonitoring() {
+    this.healthCheckInterval = setInterval(() => this.performHealthChecks(), 3e4);
+  }
+  registerComponent(definition) {
+    this.definitions.set(definition.name, definition);
+    liveLog("lifecycle", null, `Registered component: ${definition.name}`);
+  }
+  registerComponentClass(name, componentClass) {
+    this.autoDiscoveredComponents.set(name, componentClass);
+  }
+  async autoDiscoverComponents(componentsPath) {
+    try {
+      const fs = await import('fs');
+      const path = await import('path');
+      if (!fs.existsSync(componentsPath)) return;
+      const files = fs.readdirSync(componentsPath);
+      for (const file of files) {
+        if (file.endsWith(".ts") || file.endsWith(".js")) {
+          try {
+            const fullPath = path.join(componentsPath, file);
+            const module = await import(fullPath);
+            Object.keys(module).forEach((exportName) => {
+              const exportedItem = module[exportName];
+              if (typeof exportedItem === "function" && exportedItem.prototype && this.isLiveComponentClass(exportedItem)) {
+                const componentName = exportedItem.componentName || exportName.replace(/Component$/, "");
+                this.registerComponentClass(componentName, exportedItem);
+                liveLog("lifecycle", null, `Auto-discovered component: ${componentName} (from ${file})`);
+              }
+            });
+          } catch {
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Auto-discovery failed:", error);
+    }
+  }
+  isLiveComponentClass(cls) {
+    try {
+      if (typeof cls.componentName === "string") return true;
+      if (cls.prototype && typeof cls.prototype.executeAction === "function" && typeof cls.prototype.setState === "function" && typeof cls.prototype.getSerializableState === "function") return true;
+      let prototype = cls.prototype;
+      while (prototype) {
+        const name = prototype.constructor.name;
+        if (name === "LiveComponent" || name === "_LiveComponent") return true;
+        prototype = Object.getPrototypeOf(prototype);
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async mountComponent(ws, componentName, props = {}, options) {
+    const startTime = Date.now();
+    try {
+      const definition = this.definitions.get(componentName);
+      let ComponentClass = null;
+      let initialState = {};
+      if (definition) {
+        ComponentClass = definition.component;
+        initialState = definition.initialState;
+      } else {
+        ComponentClass = this.autoDiscoveredComponents.get(componentName) ?? null;
+        if (!ComponentClass) {
+          const variations = [
+            componentName + "Component",
+            componentName.charAt(0).toUpperCase() + componentName.slice(1) + "Component",
+            componentName.charAt(0).toUpperCase() + componentName.slice(1)
+          ];
+          for (const variation of variations) {
+            ComponentClass = this.autoDiscoveredComponents.get(variation) ?? null;
+            if (ComponentClass) break;
+          }
+        }
+        if (!ComponentClass) throw new Error(`Component '${componentName}' not found`);
+        initialState = {};
+      }
+      const authContext = ws.data?.authContext || ANONYMOUS_CONTEXT;
+      const componentAuth = ComponentClass.auth;
+      const authResult = this.authManager.authorizeComponent(authContext, componentAuth);
+      if (!authResult.allowed) throw new Error(`AUTH_DENIED: ${authResult.reason}`);
+      const isSingleton = ComponentClass.singleton === true;
+      if (isSingleton) {
+        const existing = this.singletons.get(componentName);
+        if (existing) {
+          const connId = ws.data?.connectionId || `ws-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+          existing.connections.set(connId, ws);
+          this.ensureWsData(ws, options?.userId);
+          ws.data.components.set(existing.instance.id, existing.instance);
+          const signedState2 = await this.stateSignature.signState(existing.instance.id, {
+            ...existing.instance.getSerializableState(),
+            __componentName: componentName
+          }, 1, { compress: true, backup: true });
+          ws.send(JSON.stringify({
+            type: "STATE_UPDATE",
+            componentId: existing.instance.id,
+            payload: { state: existing.instance.getSerializableState(), signedState: signedState2 },
+            timestamp: Date.now()
+          }));
+          try {
+            existing.instance.onClientJoin(connId, existing.connections.size);
+          } catch {
+          }
+          return { componentId: existing.instance.id, initialState: existing.instance.getSerializableState(), signedState: signedState2 };
+        }
+      }
+      const component = new ComponentClass({ ...initialState, ...props }, ws, options);
+      component.setAuthContext(authContext);
+      component.broadcastToRoom = (message) => {
+        this.broadcastToRoom(message, component.id);
+      };
+      const metadata = this.createComponentMetadata(component.id, componentName, options?.version);
+      this.metadata.set(component.id, metadata);
+      this.components.set(component.id, component);
+      this.wsConnections.set(component.id, ws);
+      if (options?.room) this.subscribeToRoom(component.id, options.room);
+      this.ensureWsData(ws, options?.userId);
+      ws.data.components.set(component.id, component);
+      if (isSingleton) {
+        const connId = ws.data.connectionId || `ws-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const connections = /* @__PURE__ */ new Map();
+        connections.set(connId, ws);
+        this.singletons.set(componentName, { instance: component, connections });
+        component[EMIT_OVERRIDE_KEY] = (type, payload) => {
+          const message = {
+            type,
+            componentId: component.id,
+            payload,
+            timestamp: Date.now(),
+            userId: component.userId,
+            room: component.room
+          };
+          const serialized = JSON.stringify(message);
+          const singleton = this.singletons.get(componentName);
+          if (singleton) {
+            const dead = [];
+            for (const [cId, cWs] of singleton.connections) {
+              try {
+                cWs.send(serialized);
+              } catch {
+                dead.push(cId);
+              }
+            }
+            for (const cId of dead) singleton.connections.delete(cId);
+          }
+        };
+        try {
+          component.onClientJoin(connId, 1);
+        } catch {
+        }
+      }
+      metadata.state = "active";
+      const renderTime = Date.now() - startTime;
+      this.recordComponentMetrics(component.id, renderTime);
+      registerComponentLogging(component.id, ComponentClass.logging);
+      this.performanceMonitor.initializeComponent(component.id, componentName);
+      this.performanceMonitor.recordRenderTime(component.id, renderTime);
+      const signedState = await this.stateSignature.signState(component.id, {
+        ...component.getSerializableState(),
+        __componentName: componentName
+      }, 1, { compress: true, backup: true });
+      component.emit("STATE_UPDATE", {
+        state: component.getSerializableState(),
+        signedState
+      });
+      try {
+        component.onConnect();
+      } catch {
+      }
+      try {
+        await component.onMount();
+      } catch (err) {
+        ;
+        component.emit("ERROR", { action: "onMount", error: `Mount initialization failed: ${err?.message || err}` });
+      }
+      this.debugger.trackComponentMount(
+        component.id,
+        componentName,
+        component.getSerializableState(),
+        options?.room,
+        options?.debugLabel
+      );
+      return { componentId: component.id, initialState: component.getSerializableState(), signedState };
+    } catch (error) {
+      console.error(`Failed to mount component ${componentName}:`, error);
+      throw error;
+    }
+  }
+  async rehydrateComponent(componentId, componentName, signedState, ws, options) {
+    try {
+      const validation = await this.stateSignature.validateState(signedState);
+      if (!validation.valid) return { success: false, error: validation.error || "Invalid state signature" };
+      const definition = this.definitions.get(componentName);
+      let ComponentClass = null;
+      let initialState = {};
+      if (definition) {
+        ComponentClass = definition.component;
+        initialState = definition.initialState;
+      } else {
+        ComponentClass = this.autoDiscoveredComponents.get(componentName) ?? null;
+        if (!ComponentClass) {
+          const variations = [componentName + "Component", componentName.charAt(0).toUpperCase() + componentName.slice(1) + "Component", componentName.charAt(0).toUpperCase() + componentName.slice(1)];
+          for (const variation of variations) {
+            ComponentClass = this.autoDiscoveredComponents.get(variation) ?? null;
+            if (ComponentClass) break;
+          }
+        }
+        if (!ComponentClass) return { success: false, error: `Component '${componentName}' not found` };
+      }
+      const authContext = ws.data?.authContext || ANONYMOUS_CONTEXT;
+      const componentAuth = ComponentClass.auth;
+      const authResult = this.authManager.authorizeComponent(authContext, componentAuth);
+      if (!authResult.allowed) return { success: false, error: `AUTH_DENIED: ${authResult.reason}` };
+      const clientState = await this.stateSignature.extractData(signedState);
+      if (clientState.__componentName && clientState.__componentName !== componentName) {
+        return { success: false, error: "Component class mismatch - state tampering detected" };
+      }
+      const { __componentName, ...cleanState } = clientState;
+      const finalState = definition ? { ...initialState, ...cleanState } : cleanState;
+      const component = new ComponentClass(finalState, ws, options);
+      component.setAuthContext(authContext);
+      this.components.set(component.id, component);
+      this.wsConnections.set(component.id, ws);
+      if (options?.room) this.subscribeToRoom(component.id, options.room);
+      this.ensureWsData(ws, options?.userId);
+      ws.data.components.set(component.id, component);
+      registerComponentLogging(component.id, ComponentClass.logging);
+      const newSignedState = await this.stateSignature.signState(
+        component.id,
+        { ...component.getSerializableState(), __componentName: componentName },
+        signedState.version + 1
+      );
+      component.emit("STATE_REHYDRATED", {
+        state: component.getSerializableState(),
+        signedState: newSignedState,
+        oldComponentId: componentId,
+        newComponentId: component.id
+      });
+      try {
+        component.onConnect();
+      } catch {
+      }
+      try {
+        component.onRehydrate(clientState);
+      } catch {
+      }
+      try {
+        await component.onMount();
+      } catch {
+      }
+      return { success: true, newComponentId: component.id };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+  ensureWsData(ws, userId) {
+    if (!ws.data) {
+      ws.data = {
+        connectionId: `ws-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        components: /* @__PURE__ */ new Map(),
+        subscriptions: /* @__PURE__ */ new Set(),
+        connectedAt: /* @__PURE__ */ new Date(),
+        userId
+      };
+    }
+    if (!ws.data.components) ws.data.components = /* @__PURE__ */ new Map();
+  }
+  isSingletonComponent(componentId) {
+    for (const [, s] of this.singletons) if (s.instance.id === componentId) return true;
+    return false;
+  }
+  removeSingletonConnection(componentId, connId, context = "unmount") {
+    for (const [name, singleton] of this.singletons) {
+      if (singleton.instance.id !== componentId) continue;
+      if (connId) singleton.connections.delete(connId);
+      if (singleton.connections.size === 0) {
+        try {
+          singleton.instance.onDisconnect();
+        } catch {
+        }
+        this.cleanupComponent(componentId);
+        this.singletons.delete(name);
+      }
+      return true;
+    }
+    return false;
+  }
+  async unmountComponent(componentId, ws) {
+    const component = this.components.get(componentId);
+    if (!component) return;
+    if (ws) {
+      const connId = ws.data?.connectionId;
+      ws.data?.components?.delete(componentId);
+      if (this.isSingletonComponent(componentId)) {
+        const singleton = this.singletons.get(this.getSingletonName(componentId) || "");
+        const remaining = singleton ? singleton.connections.size - 1 : 0;
+        try {
+          component.onClientLeave(connId || "unknown", Math.max(0, remaining));
+        } catch {
+        }
+      }
+      if (this.removeSingletonConnection(componentId, connId, "unmount")) return;
+    } else {
+      if (this.removeSingletonConnection(componentId, void 0, "unmount")) return;
+    }
+    this.debugger.trackComponentUnmount(componentId);
+    component.destroy?.();
+    this.unsubscribeFromAllRooms(componentId);
+    this.components.delete(componentId);
+    this.wsConnections.delete(componentId);
+    unregisterComponentLogging(componentId);
+  }
+  getSingletonName(componentId) {
+    for (const [name, s] of this.singletons) {
+      if (s.instance.id === componentId) return name;
+    }
+    return null;
+  }
+  async executeAction(componentId, action, payload) {
+    const component = this.components.get(componentId);
+    if (!component) throw new Error(`COMPONENT_REHYDRATION_REQUIRED:${componentId}`);
+    const componentClass = component.constructor;
+    const actionAuthMap = componentClass.actionAuth;
+    const actionAuth = actionAuthMap?.[action];
+    if (actionAuth) {
+      const authContext = component.$auth || ANONYMOUS_CONTEXT;
+      const componentName = componentClass.componentName || componentClass.name;
+      const authResult = await this.authManager.authorizeAction(authContext, componentName, action, actionAuth);
+      if (!authResult.allowed) throw new Error(`AUTH_DENIED: ${authResult.reason}`);
+    }
+    return await component.executeAction?.(action, payload);
+  }
+  updateProperty(componentId, property, value) {
+    const component = this.components.get(componentId);
+    if (!component) throw new Error(`Component '${componentId}' not found`);
+    component.setState?.({ [property]: value });
+  }
+  subscribeToRoom(componentId, roomId) {
+    if (!this.rooms.has(roomId)) this.rooms.set(roomId, /* @__PURE__ */ new Set());
+    this.rooms.get(roomId).add(componentId);
+  }
+  unsubscribeFromRoom(componentId, roomId) {
+    const room = this.rooms.get(roomId);
+    if (room) {
+      room.delete(componentId);
+      if (room.size === 0) this.rooms.delete(roomId);
+    }
+  }
+  unsubscribeFromAllRooms(componentId) {
+    for (const [roomId, components] of Array.from(this.rooms.entries())) {
+      if (components.has(componentId)) this.unsubscribeFromRoom(componentId, roomId);
+    }
+  }
+  broadcastToRoom(message, senderComponentId) {
+    if (!message.room) return;
+    const roomComponents = this.rooms.get(message.room);
+    if (!roomComponents) return;
+    const broadcastMessage = {
+      type: "BROADCAST",
+      componentId: senderComponentId || "system",
+      payload: { type: message.type, data: message.payload },
+      timestamp: Date.now(),
+      room: message.room
+    };
+    for (const componentId of Array.from(roomComponents)) {
+      const component = this.components.get(componentId);
+      if (message.excludeUser && component?.userId === message.excludeUser) continue;
+      const ws = this.wsConnections.get(componentId);
+      if (ws && ws.send) ws.send(JSON.stringify(broadcastMessage));
+    }
+  }
+  async handleMessage(ws, message) {
+    try {
+      if (message.componentId) this.updateComponentActivity(message.componentId);
+      switch (message.type) {
+        case "COMPONENT_MOUNT":
+          const mountResult = await this.mountComponent(ws, message.payload.component, message.payload.props, {
+            room: message.payload.room,
+            userId: message.userId,
+            debugLabel: message.payload.debugLabel
+          });
+          return { success: true, result: mountResult };
+        case "COMPONENT_UNMOUNT":
+          await this.unmountComponent(message.componentId, ws);
+          return { success: true };
+        case "CALL_ACTION":
+          this.recordComponentMetrics(message.componentId, void 0, message.action);
+          const actionStart = Date.now();
+          try {
+            const actionResult = await this.executeAction(message.componentId, message.action, message.payload);
+            this.performanceMonitor.recordActionTime(message.componentId, message.action, Date.now() - actionStart);
+            if (message.expectResponse) return { success: true, result: actionResult };
+            return null;
+          } catch (error) {
+            this.performanceMonitor.recordActionTime(message.componentId, message.action, Date.now() - actionStart, error);
+            throw error;
+          }
+        case "PROPERTY_UPDATE":
+          this.updateProperty(message.componentId, message.property, message.payload.value);
+          return { success: true };
+        default:
+          return { success: false, error: "Unknown message type" };
+      }
+    } catch (error) {
+      if (message.componentId) this.recordComponentError(message.componentId, error);
+      return { success: false, error: error.message };
+    }
+  }
+  cleanupConnection(ws) {
+    if (!ws.data?.components) return;
+    const componentsToCleanup = Array.from(ws.data.components.keys());
+    const connId = ws.data.connectionId;
+    for (const componentId of componentsToCleanup) {
+      const component = this.components.get(componentId);
+      if (component && !this.isSingletonComponent(componentId)) {
+        try {
+          component.onDisconnect();
+        } catch {
+        }
+      }
+      if (!this.removeSingletonConnection(componentId, connId || void 0, "disconnect")) {
+        this.cleanupComponent(componentId);
+      }
+    }
+    ws.data.components.clear();
+  }
+  getStats() {
+    return {
+      components: this.components.size,
+      definitions: this.definitions.size,
+      rooms: this.rooms.size,
+      connections: this.wsConnections.size,
+      singletons: Object.fromEntries(
+        Array.from(this.singletons.entries()).map(([name, s]) => [name, { componentId: s.instance.id, connections: s.connections.size }])
+      ),
+      roomDetails: Object.fromEntries(
+        Array.from(this.rooms.entries()).map(([roomId, components]) => [roomId, components.size])
+      )
+    };
+  }
+  getRegisteredComponentNames() {
+    return [.../* @__PURE__ */ new Set([...this.definitions.keys(), ...this.autoDiscoveredComponents.keys()])];
+  }
+  getComponent(componentId) {
+    return this.components.get(componentId);
+  }
+  getRoomComponents(roomId) {
+    const componentIds = this.rooms.get(roomId) || /* @__PURE__ */ new Set();
+    return Array.from(componentIds).map((id) => this.components.get(id)).filter(Boolean);
+  }
+  createComponentMetadata(componentId, componentName, version = "1.0.0") {
+    return {
+      id: componentId,
+      name: componentName,
+      version,
+      mountedAt: /* @__PURE__ */ new Date(),
+      lastActivity: /* @__PURE__ */ new Date(),
+      state: "mounting",
+      healthStatus: "healthy",
+      dependencies: [],
+      services: /* @__PURE__ */ new Map(),
+      metrics: { renderCount: 0, actionCount: 0, errorCount: 0, averageRenderTime: 0, memoryUsage: 0 },
+      migrationHistory: []
+    };
+  }
+  updateComponentActivity(componentId) {
+    const metadata = this.metadata.get(componentId);
+    if (metadata) {
+      metadata.lastActivity = /* @__PURE__ */ new Date();
+      metadata.state = "active";
+      return true;
+    }
+    return false;
+  }
+  recordComponentMetrics(componentId, renderTime, action) {
+    const metadata = this.metadata.get(componentId);
+    if (!metadata) return;
+    if (renderTime) {
+      metadata.metrics.renderCount++;
+      metadata.metrics.averageRenderTime = (metadata.metrics.averageRenderTime * (metadata.metrics.renderCount - 1) + renderTime) / metadata.metrics.renderCount;
+      metadata.metrics.lastRenderTime = renderTime;
+    }
+    if (action) metadata.metrics.actionCount++;
+    this.updateComponentActivity(componentId);
+  }
+  recordComponentError(componentId, error) {
+    const metadata = this.metadata.get(componentId);
+    if (metadata) {
+      metadata.metrics.errorCount++;
+      metadata.healthStatus = metadata.metrics.errorCount > 5 ? "unhealthy" : "degraded";
+    }
+  }
+  async performHealthChecks() {
+    for (const [componentId, metadata] of this.metadata) {
+      if (!this.components.get(componentId)) continue;
+      if (metadata.metrics.errorCount > 10) metadata.healthStatus = "unhealthy";
+      else if (Date.now() - metadata.lastActivity.getTime() > 3e5) metadata.healthStatus = "degraded";
+    }
+  }
+  cleanupComponent(componentId) {
+    const component = this.components.get(componentId);
+    if (component) try {
+      component.destroy?.();
+    } catch {
+    }
+    this.performanceMonitor.removeComponent(componentId);
+    unregisterComponentLogging(componentId);
+    this.components.delete(componentId);
+    this.metadata.delete(componentId);
+    this.wsConnections.delete(componentId);
+    for (const [roomId, componentIds] of this.rooms) {
+      componentIds.delete(componentId);
+      if (componentIds.size === 0) this.rooms.delete(roomId);
+    }
+  }
+  cleanup() {
+    if (this.healthCheckInterval) clearInterval(this.healthCheckInterval);
+    this.singletons.clear();
+    for (const [componentId] of this.components) this.cleanupComponent(componentId);
+  }
+};
+
+// src/connection/RateLimiter.ts
+var ConnectionRateLimiter = class {
+  tokens;
+  lastRefill;
+  maxTokens;
+  refillRate;
+  // tokens per second
+  constructor(maxTokens = DEFAULT_RATE_LIMIT_MAX_TOKENS, refillRate = DEFAULT_RATE_LIMIT_REFILL_RATE) {
+    this.maxTokens = maxTokens;
+    this.tokens = maxTokens;
+    this.refillRate = refillRate;
+    this.lastRefill = Date.now();
+  }
+  tryConsume(count = 1) {
+    this.refill();
+    if (this.tokens >= count) {
+      this.tokens -= count;
+      return true;
+    }
+    return false;
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = (now - this.lastRefill) / 1e3;
+    this.tokens = Math.min(this.maxTokens, this.tokens + elapsed * this.refillRate);
+    this.lastRefill = now;
+  }
+};
+var RateLimiterRegistry = class {
+  limiters = /* @__PURE__ */ new Map();
+  maxTokens;
+  refillRate;
+  constructor(maxTokens = DEFAULT_RATE_LIMIT_MAX_TOKENS, refillRate = DEFAULT_RATE_LIMIT_REFILL_RATE) {
+    this.maxTokens = maxTokens;
+    this.refillRate = refillRate;
+  }
+  /**
+   * Get or create a rate limiter for a connection.
+   */
+  get(connectionId) {
+    let limiter = this.limiters.get(connectionId);
+    if (!limiter) {
+      limiter = new ConnectionRateLimiter(this.maxTokens, this.refillRate);
+      this.limiters.set(connectionId, limiter);
+    }
+    return limiter;
+  }
+  /**
+   * Remove a rate limiter for a disconnected connection.
+   */
+  remove(connectionId) {
+    this.limiters.delete(connectionId);
+  }
+};
+
+// src/protocol/binary.ts
+function encodeBinaryChunk(header, data) {
+  const headerJson = JSON.stringify(header);
+  const headerBuffer = Buffer.from(headerJson, "utf-8");
+  const result = Buffer.alloc(4 + headerBuffer.length + data.length);
+  result.writeUInt32LE(headerBuffer.length, 0);
+  headerBuffer.copy(result, 4);
+  Buffer.from(data).copy(result, 4 + headerBuffer.length);
+  return result;
+}
+function decodeBinaryChunk(raw) {
+  const buffer = raw instanceof ArrayBuffer ? Buffer.from(raw) : Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength);
+  const headerLength = buffer.readUInt32LE(0);
+  const headerJson = buffer.slice(4, 4 + headerLength).toString("utf-8");
+  const header = JSON.parse(headerJson);
+  const data = buffer.slice(4 + headerLength);
+  return { header, data };
+}
+
+// src/server/LiveServer.ts
+var LiveServer = class {
+  // Public singletons (accessible for transport adapters & advanced usage)
+  roomEvents;
+  roomManager;
+  debugger;
+  authManager;
+  stateSignature;
+  performanceMonitor;
+  fileUploadManager;
+  connectionManager;
+  registry;
+  rateLimiter;
+  transport;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.transport = options.transport;
+    this.roomEvents = new RoomEventBus();
+    this.roomManager = new LiveRoomManager(this.roomEvents);
+    this.debugger = new LiveDebugger(options.debug ?? false);
+    this.authManager = new LiveAuthManager();
+    this.stateSignature = new StateSignatureManager(options.stateSignature);
+    this.performanceMonitor = new PerformanceMonitor(options.performance);
+    this.fileUploadManager = new FileUploadManager(options.fileUpload);
+    this.connectionManager = new WebSocketConnectionManager(options.connection);
+    this.rateLimiter = new RateLimiterRegistry(options.rateLimitMaxTokens, options.rateLimitRefillRate);
+    this.registry = new ComponentRegistry({
+      authManager: this.authManager,
+      debugger: this.debugger,
+      stateSignature: this.stateSignature,
+      performanceMonitor: this.performanceMonitor
+    });
+    _setLoggerDebugger(this.debugger);
+    setLiveComponentContext({
+      roomEvents: this.roomEvents,
+      roomManager: this.roomManager,
+      debugger: this.debugger
+    });
+  }
+  /**
+   * Register an auth provider.
+   */
+  useAuth(provider) {
+    this.authManager.register(provider);
+    return this;
+  }
+  /**
+   * Start the LiveServer: register WS + HTTP handlers on the transport.
+   */
+  async start() {
+    if (this.options.componentsPath) {
+      await this.registry.autoDiscoverComponents(this.options.componentsPath);
+    }
+    const wsConfig = {
+      path: this.options.wsPath ?? DEFAULT_WS_PATH,
+      onOpen: (ws) => this.handleOpen(ws),
+      onMessage: (ws, message, isBinary) => this.handleMessage(ws, message, isBinary),
+      onClose: (ws, code, reason) => this.handleClose(ws, code, reason),
+      onError: (ws, error) => this.handleError(ws, error)
+    };
+    await this.transport.registerWebSocket(wsConfig);
+    if (this.options.httpPrefix !== false) {
+      const prefix = this.options.httpPrefix ?? "/api/live";
+      await this.transport.registerHttpRoutes(this.buildHttpRoutes(prefix));
+    }
+    if (this.transport.start) {
+      await this.transport.start();
+    }
+    liveLog("lifecycle", null, `LiveServer started (ws: ${wsConfig.path})`);
+  }
+  /**
+   * Graceful shutdown.
+   */
+  async shutdown() {
+    this.registry.cleanup();
+    this.connectionManager.shutdown();
+    this.fileUploadManager.shutdown();
+    this.stateSignature.shutdown();
+    if (this.transport.shutdown) await this.transport.shutdown();
+    liveLog("lifecycle", null, "LiveServer shut down");
+  }
+  // ===== WebSocket Handlers =====
+  handleOpen(ws) {
+    const connectionId = `ws-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    ws.data = {
+      connectionId,
+      components: /* @__PURE__ */ new Map(),
+      subscriptions: /* @__PURE__ */ new Set(),
+      connectedAt: /* @__PURE__ */ new Date()
+    };
+    this.connectionManager.registerConnection(ws, connectionId);
+    this.debugger.trackConnection(connectionId);
+    ws.send(JSON.stringify({
+      type: "CONNECTION_ESTABLISHED",
+      connectionId,
+      timestamp: Date.now()
+    }));
+    liveLog("websocket", null, `Connection opened: ${connectionId}`);
+  }
+  async handleMessage(ws, rawMessage, isBinary) {
+    const connectionId = ws.data?.connectionId;
+    if (connectionId) {
+      const limiter = this.rateLimiter.get(connectionId);
+      if (!limiter.tryConsume()) {
+        ws.send(JSON.stringify({ type: "ERROR", error: "Rate limit exceeded", timestamp: Date.now() }));
+        return;
+      }
+    }
+    if (isBinary && rawMessage instanceof ArrayBuffer) {
+      try {
+        const { header, data } = decodeBinaryChunk(rawMessage);
+        if (header.type === "FILE_UPLOAD_CHUNK") {
+          const chunkMessage = { ...header, data: "" };
+          const progress = await this.fileUploadManager.receiveChunk(chunkMessage, data);
+          if (progress) ws.send(JSON.stringify(progress));
+        }
+      } catch (error) {
+        ws.send(JSON.stringify({ type: "ERROR", error: error.message, timestamp: Date.now() }));
+      }
+      return;
+    }
+    let message;
+    try {
+      const str = typeof rawMessage === "string" ? rawMessage : new TextDecoder().decode(rawMessage);
+      message = JSON.parse(str);
+    } catch {
+      ws.send(JSON.stringify({ type: "ERROR", error: "Invalid JSON", timestamp: Date.now() }));
+      return;
+    }
+    try {
+      if (message.type === "AUTH") {
+        const authContext = await this.authManager.authenticate(message.payload || {});
+        if (ws.data) ws.data.authContext = authContext;
+        ws.send(JSON.stringify({
+          type: "AUTH_RESPONSE",
+          success: authContext.authenticated,
+          payload: authContext.authenticated ? { userId: authContext.user?.id } : { error: "Authentication failed" },
+          timestamp: Date.now()
+        }));
+        return;
+      }
+      if (message.type === "ROOM_JOIN" || message.type === "ROOM_LEAVE" || message.type === "ROOM_EMIT" || message.type === "ROOM_STATE_SET" || message.type === "ROOM_STATE_GET") {
+        await this.handleRoomMessage(ws, message);
+        return;
+      }
+      if (message.type === "FILE_UPLOAD_START") {
+        const result2 = await this.fileUploadManager.startUpload(message, ws.data?.userId);
+        ws.send(JSON.stringify({
+          type: "FILE_UPLOAD_START_RESPONSE",
+          componentId: message.componentId,
+          uploadId: message.payload?.uploadId,
+          success: result2.success,
+          error: result2.error,
+          requestId: message.requestId,
+          timestamp: Date.now()
+        }));
+        return;
+      }
+      if (message.type === "FILE_UPLOAD_CHUNK") {
+        const progress = await this.fileUploadManager.receiveChunk(message);
+        if (progress) ws.send(JSON.stringify(progress));
+        return;
+      }
+      if (message.type === "FILE_UPLOAD_COMPLETE") {
+        const result2 = await this.fileUploadManager.completeUpload(message);
+        ws.send(JSON.stringify(result2));
+        return;
+      }
+      if (message.type === "COMPONENT_REHYDRATE") {
+        const result2 = await this.registry.rehydrateComponent(
+          message.componentId,
+          message.payload.component,
+          message.payload.signedState,
+          ws,
+          { room: message.payload.room, userId: message.userId }
+        );
+        ws.send(JSON.stringify({
+          type: "COMPONENT_REHYDRATED",
+          componentId: message.componentId,
+          success: result2.success,
+          result: result2.success ? { newComponentId: result2.newComponentId } : void 0,
+          error: result2.error,
+          requestId: message.requestId,
+          timestamp: Date.now()
+        }));
+        return;
+      }
+      const result = await this.registry.handleMessage(ws, message);
+      if (result !== null) {
+        const response = {
+          type: message.type === "CALL_ACTION" ? "ACTION_RESPONSE" : "MESSAGE_RESPONSE",
+          originalType: message.type,
+          componentId: message.componentId,
+          success: result.success,
+          result: result.result,
+          error: result.error,
+          requestId: message.requestId,
+          responseId: message.responseId,
+          timestamp: Date.now()
+        };
+        ws.send(JSON.stringify(response));
+      }
+    } catch (error) {
+      ws.send(JSON.stringify({
+        type: "ERROR",
+        componentId: message.componentId,
+        error: error.message,
+        requestId: message.requestId,
+        timestamp: Date.now()
+      }));
+    }
+  }
+  handleClose(ws, code, reason) {
+    const connectionId = ws.data?.connectionId;
+    const componentCount = ws.data?.components?.size || 0;
+    this.registry.cleanupConnection(ws);
+    this.roomManager.cleanupComponent(connectionId || "");
+    if (connectionId) {
+      this.connectionManager.cleanupConnection(connectionId);
+      this.rateLimiter.remove(connectionId);
+    }
+    this.debugger.trackDisconnection(connectionId || "", componentCount);
+    liveLog("websocket", null, `Connection closed: ${connectionId} (${componentCount} components)`);
+  }
+  handleError(ws, error) {
+    console.error(`[LiveServer] WebSocket error:`, error.message);
+  }
+  // ===== Room Message Router =====
+  async handleRoomMessage(ws, message) {
+    const { componentId } = message;
+    const roomId = message.roomId || message.payload?.roomId;
+    switch (message.type) {
+      case "ROOM_JOIN": {
+        const result = this.roomManager.joinRoom(componentId, roomId, ws, message.payload?.initialState);
+        ws.send(JSON.stringify({
+          type: "ROOM_JOINED",
+          componentId,
+          payload: { roomId, state: result.state },
+          requestId: message.requestId,
+          timestamp: Date.now()
+        }));
+        break;
+      }
+      case "ROOM_LEAVE":
+        this.roomManager.leaveRoom(componentId, roomId);
+        ws.send(JSON.stringify({
+          type: "ROOM_LEFT",
+          componentId,
+          payload: { roomId },
+          requestId: message.requestId,
+          timestamp: Date.now()
+        }));
+        break;
+      case "ROOM_EMIT":
+        this.roomManager.emitToRoom(roomId, message.payload?.event, message.payload?.data, componentId);
+        break;
+      case "ROOM_STATE_SET":
+        this.roomManager.setRoomState(roomId, message.payload?.state, componentId);
+        break;
+      case "ROOM_STATE_GET": {
+        const state = this.roomManager.getRoomState(roomId);
+        ws.send(JSON.stringify({
+          type: "ROOM_STATE",
+          componentId,
+          payload: { roomId, state },
+          requestId: message.requestId,
+          timestamp: Date.now()
+        }));
+        break;
+      }
+    }
+  }
+  // ===== HTTP Monitoring Routes =====
+  buildHttpRoutes(prefix) {
+    return [
+      {
+        method: "GET",
+        path: `${prefix}/stats`,
+        handler: async () => ({
+          body: {
+            components: this.registry.getStats(),
+            rooms: this.roomManager.getStats(),
+            connections: this.connectionManager.getSystemStats(),
+            uploads: this.fileUploadManager.getStats(),
+            performance: this.performanceMonitor.getStats()
+          }
+        }),
+        metadata: { summary: "Live Components system statistics", tags: ["live"] }
+      },
+      {
+        method: "GET",
+        path: `${prefix}/components`,
+        handler: async () => ({
+          body: { names: this.registry.getRegisteredComponentNames() }
+        }),
+        metadata: { summary: "List registered component names", tags: ["live"] }
+      },
+      {
+        method: "POST",
+        path: `${prefix}/rooms/:roomId/messages`,
+        handler: async (req) => {
+          const roomId = req.params.roomId;
+          this.roomManager.emitToRoom(roomId, "message:new", req.body);
+          return { body: { success: true, roomId } };
+        },
+        metadata: { summary: "Send message to room via HTTP", tags: ["live", "rooms"] }
+      },
+      {
+        method: "POST",
+        path: `${prefix}/rooms/:roomId/emit`,
+        handler: async (req) => {
+          const roomId = req.params.roomId;
+          const { event, data } = req.body;
+          this.roomManager.emitToRoom(roomId, event, data);
+          return { body: { success: true, roomId, event } };
+        },
+        metadata: { summary: "Emit custom event to room via HTTP", tags: ["live", "rooms"] }
+      }
+    ];
+  }
+};
+
+// src/rooms/RoomStateManager.ts
+function createTypedRoomState() {
+  const rooms = /* @__PURE__ */ new Map();
+  const getKey = (type, roomId) => `${type}:${roomId}`;
+  return {
+    get(type, roomId, defaultState) {
+      const key = getKey(type, roomId);
+      const room = rooms.get(key);
+      if (room) return room.state;
+      rooms.set(key, { state: defaultState, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() });
+      return defaultState;
+    },
+    update(type, roomId, updates) {
+      const key = getKey(type, roomId);
+      const room = rooms.get(key);
+      if (room) {
+        room.state = { ...room.state, ...updates };
+        room.lastUpdate = Date.now();
+        return room.state;
+      }
+      const newState = updates;
+      rooms.set(key, { state: newState, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() });
+      return newState;
+    },
+    set(type, roomId, state) {
+      const key = getKey(type, roomId);
+      const room = rooms.get(key);
+      if (room) {
+        room.state = state;
+        room.lastUpdate = Date.now();
+      } else {
+        rooms.set(key, { state, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() });
+      }
+    },
+    join(type, roomId) {
+      const room = rooms.get(getKey(type, roomId));
+      if (room) room.componentCount++;
+    },
+    leave(type, roomId) {
+      const key = getKey(type, roomId);
+      const room = rooms.get(key);
+      if (room) {
+        room.componentCount--;
+        if (room.componentCount <= 0) {
+          setTimeout(() => {
+            const current = rooms.get(key);
+            if (current && current.componentCount <= 0) {
+              rooms.delete(key);
+            }
+          }, 5 * 60 * 1e3);
+        }
+      }
+    },
+    has(type, roomId) {
+      return rooms.has(getKey(type, roomId));
+    },
+    delete(type, roomId) {
+      return rooms.delete(getKey(type, roomId));
+    },
+    getStats() {
+      const roomStats = {};
+      for (const [key, info] of rooms) {
+        roomStats[key] = { componentCount: info.componentCount, stateKeys: Object.keys(info.state) };
+      }
+      return { totalRooms: rooms.size, rooms: roomStats };
+    }
+  };
+}
+var RoomStateManager = class {
+  rooms = /* @__PURE__ */ new Map();
+  get(roomId, defaultState) {
+    const room = this.rooms.get(roomId);
+    if (room) return room.state;
+    if (defaultState) {
+      this.rooms.set(roomId, { state: defaultState, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() });
+      return defaultState;
+    }
+    return {};
+  }
+  update(roomId, updates) {
+    const room = this.rooms.get(roomId);
+    if (room) {
+      room.state = { ...room.state, ...updates };
+      room.lastUpdate = Date.now();
+      return room.state;
+    }
+    const newState = updates;
+    this.rooms.set(roomId, { state: newState, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() });
+    return newState;
+  }
+  set(roomId, state) {
+    const room = this.rooms.get(roomId);
+    if (room) {
+      room.state = state;
+      room.lastUpdate = Date.now();
+    } else {
+      this.rooms.set(roomId, { state, componentCount: 0, createdAt: Date.now(), lastUpdate: Date.now() });
+    }
+  }
+  join(roomId) {
+    const room = this.rooms.get(roomId);
+    if (room) room.componentCount++;
+  }
+  leave(roomId) {
+    const room = this.rooms.get(roomId);
+    if (room) {
+      room.componentCount--;
+      if (room.componentCount <= 0) {
+        setTimeout(() => {
+          const current = this.rooms.get(roomId);
+          if (current && current.componentCount <= 0) {
+            this.rooms.delete(roomId);
+          }
+        }, 5 * 60 * 1e3);
+      }
+    }
+  }
+  has(roomId) {
+    return this.rooms.has(roomId);
+  }
+  delete(roomId) {
+    return this.rooms.delete(roomId);
+  }
+  getStats() {
+    const rooms = {};
+    for (const [roomId, info] of this.rooms) {
+      rooms[roomId] = { componentCount: info.componentCount, stateKeys: Object.keys(info.state) };
+    }
+    return { totalRooms: this.rooms.size, rooms };
+  }
+};
+
+export { ANONYMOUS_CONTEXT, AnonymousContext, AuthenticatedContext, ComponentRegistry, ConnectionRateLimiter, DEFAULT_CHUNK_SIZE, DEFAULT_WS_PATH, FileUploadManager, LiveAuthManager, LiveComponent, LiveDebugger, LiveRoomManager, LiveServer, PROTOCOL_VERSION, PerformanceMonitor, RateLimiterRegistry, RoomEventBus, RoomStateManager, StateSignatureManager, WebSocketConnectionManager, createTypedRoomEventBus, createTypedRoomState, decodeBinaryChunk, encodeBinaryChunk, getLiveComponentContext, liveLog, liveWarn, registerComponentLogging, setLiveComponentContext, unregisterComponentLogging };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map