@principal-ai/control-tower-core 0.1.24 → 0.2.0

package/dist/index.mjs

@@ -1345,7 +1345,7 @@ var require_event_target = __commonJS((exports, module) => {
   var kType = Symbol("kType");
   var kWasClean = Symbol("kWasClean");
 
-  class Event2 {
+  class Event {
     constructor(type) {
       this[kTarget] = null;
       this[kType] = type;
@@ -1357,10 +1357,10 @@ var require_event_target = __commonJS((exports, module) => {
       return this[kType];
     }
   }
-  Object.defineProperty(Event2.prototype, "target", { enumerable: true });
-  Object.defineProperty(Event2.prototype, "type", { enumerable: true });
+  Object.defineProperty(Event.prototype, "target", { enumerable: true });
+  Object.defineProperty(Event.prototype, "type", { enumerable: true });
 
-  class CloseEvent extends Event2 {
+  class CloseEvent extends Event {
     constructor(type, options = {}) {
       super(type);
       this[kCode] = options.code === undefined ? 0 : options.code;
@@ -1381,7 +1381,7 @@ var require_event_target = __commonJS((exports, module) => {
   Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
   Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
 
-  class ErrorEvent extends Event2 {
+  class ErrorEvent extends Event {
     constructor(type, options = {}) {
       super(type);
       this[kError] = options.error === undefined ? null : options.error;
@@ -1397,7 +1397,7 @@ var require_event_target = __commonJS((exports, module) => {
   Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true });
   Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true });
 
-  class MessageEvent extends Event2 {
+  class MessageEvent extends Event {
     constructor(type, options = {}) {
       super(type);
       this[kData] = options.data === undefined ? null : options.data;
@@ -1444,7 +1444,7 @@ var require_event_target = __commonJS((exports, module) => {
         };
       } else if (type === "open") {
         wrapper = function onOpen() {
-          const event = new Event2("open");
+          const event = new Event("open");
           event[kTarget] = this;
           callListener(handler, this, event);
         };
@@ -1471,7 +1471,7 @@ var require_event_target = __commonJS((exports, module) => {
   module.exports = {
     CloseEvent,
     ErrorEvent,
-    Event: Event2,
+    Event,
     EventTarget,
     MessageEvent
   };
@@ -1684,7 +1684,7 @@ var require_websocket = __commonJS((exports, module) => {
   var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
   var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
 
-  class WebSocket extends EventEmitter {
+  class WebSocket2 extends EventEmitter {
     constructor(address, protocols, options) {
       super();
       this._binaryType = BINARY_TYPES[0];
@@ -1697,7 +1697,7 @@ var require_websocket = __commonJS((exports, module) => {
       this._extensions = {};
       this._paused = false;
       this._protocol = "";
-      this._readyState = WebSocket.CONNECTING;
+      this._readyState = WebSocket2.CONNECTING;
       this._receiver = null;
       this._sender = null;
       this._socket = null;
@@ -1796,12 +1796,12 @@ var require_websocket = __commonJS((exports, module) => {
       socket.on("data", socketOnData);
       socket.on("end", socketOnEnd);
       socket.on("error", socketOnError);
-      this._readyState = WebSocket.OPEN;
+      this._readyState = WebSocket2.OPEN;
       this.emit("open");
     }
     emitClose() {
       if (!this._socket) {
-        this._readyState = WebSocket.CLOSED;
+        this._readyState = WebSocket2.CLOSED;
         this.emit("close", this._closeCode, this._closeMessage);
         return;
       }
@@ -1809,24 +1809,24 @@ var require_websocket = __commonJS((exports, module) => {
         this._extensions[PerMessageDeflate.extensionName].cleanup();
       }
       this._receiver.removeAllListeners();
-      this._readyState = WebSocket.CLOSED;
+      this._readyState = WebSocket2.CLOSED;
       this.emit("close", this._closeCode, this._closeMessage);
     }
     close(code, data) {
-      if (this.readyState === WebSocket.CLOSED)
+      if (this.readyState === WebSocket2.CLOSED)
         return;
-      if (this.readyState === WebSocket.CONNECTING) {
+      if (this.readyState === WebSocket2.CONNECTING) {
         const msg = "WebSocket was closed before the connection was established";
         abortHandshake(this, this._req, msg);
         return;
       }
-      if (this.readyState === WebSocket.CLOSING) {
+      if (this.readyState === WebSocket2.CLOSING) {
         if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
           this._socket.end();
         }
         return;
       }
-      this._readyState = WebSocket.CLOSING;
+      this._readyState = WebSocket2.CLOSING;
       this._sender.close(code, data, !this._isServer, (err) => {
         if (err)
           return;
@@ -1838,14 +1838,14 @@ var require_websocket = __commonJS((exports, module) => {
       setCloseTimer(this);
     }
     pause() {
-      if (this.readyState === WebSocket.CONNECTING || this.readyState === WebSocket.CLOSED) {
+      if (this.readyState === WebSocket2.CONNECTING || this.readyState === WebSocket2.CLOSED) {
         return;
       }
       this._paused = true;
       this._socket.pause();
     }
     ping(data, mask, cb) {
-      if (this.readyState === WebSocket.CONNECTING) {
+      if (this.readyState === WebSocket2.CONNECTING) {
         throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
       }
       if (typeof data === "function") {
@@ -1857,7 +1857,7 @@ var require_websocket = __commonJS((exports, module) => {
       }
       if (typeof data === "number")
         data = data.toString();
-      if (this.readyState !== WebSocket.OPEN) {
+      if (this.readyState !== WebSocket2.OPEN) {
         sendAfterClose(this, data, cb);
         return;
       }
@@ -1866,7 +1866,7 @@ var require_websocket = __commonJS((exports, module) => {
       this._sender.ping(data || EMPTY_BUFFER, mask, cb);
     }
     pong(data, mask, cb) {
-      if (this.readyState === WebSocket.CONNECTING) {
+      if (this.readyState === WebSocket2.CONNECTING) {
         throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
       }
       if (typeof data === "function") {
@@ -1878,7 +1878,7 @@ var require_websocket = __commonJS((exports, module) => {
       }
       if (typeof data === "number")
         data = data.toString();
-      if (this.readyState !== WebSocket.OPEN) {
+      if (this.readyState !== WebSocket2.OPEN) {
         sendAfterClose(this, data, cb);
         return;
       }
@@ -1887,7 +1887,7 @@ var require_websocket = __commonJS((exports, module) => {
       this._sender.pong(data || EMPTY_BUFFER, mask, cb);
     }
     resume() {
-      if (this.readyState === WebSocket.CONNECTING || this.readyState === WebSocket.CLOSED) {
+      if (this.readyState === WebSocket2.CONNECTING || this.readyState === WebSocket2.CLOSED) {
         return;
       }
       this._paused = false;
@@ -1895,7 +1895,7 @@ var require_websocket = __commonJS((exports, module) => {
         this._socket.resume();
     }
     send(data, options, cb) {
-      if (this.readyState === WebSocket.CONNECTING) {
+      if (this.readyState === WebSocket2.CONNECTING) {
         throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
       }
       if (typeof options === "function") {
@@ -1904,7 +1904,7 @@ var require_websocket = __commonJS((exports, module) => {
       }
       if (typeof data === "number")
         data = data.toString();
-      if (this.readyState !== WebSocket.OPEN) {
+      if (this.readyState !== WebSocket2.OPEN) {
         sendAfterClose(this, data, cb);
         return;
       }
@@ -1921,48 +1921,48 @@ var require_websocket = __commonJS((exports, module) => {
       this._sender.send(data || EMPTY_BUFFER, opts, cb);
     }
     terminate() {
-      if (this.readyState === WebSocket.CLOSED)
+      if (this.readyState === WebSocket2.CLOSED)
         return;
-      if (this.readyState === WebSocket.CONNECTING) {
+      if (this.readyState === WebSocket2.CONNECTING) {
         const msg = "WebSocket was closed before the connection was established";
         abortHandshake(this, this._req, msg);
         return;
       }
       if (this._socket) {
-        this._readyState = WebSocket.CLOSING;
+        this._readyState = WebSocket2.CLOSING;
         this._socket.destroy();
       }
     }
   }
-  Object.defineProperty(WebSocket, "CONNECTING", {
+  Object.defineProperty(WebSocket2, "CONNECTING", {
     enumerable: true,
     value: readyStates.indexOf("CONNECTING")
   });
-  Object.defineProperty(WebSocket.prototype, "CONNECTING", {
+  Object.defineProperty(WebSocket2.prototype, "CONNECTING", {
     enumerable: true,
     value: readyStates.indexOf("CONNECTING")
   });
-  Object.defineProperty(WebSocket, "OPEN", {
+  Object.defineProperty(WebSocket2, "OPEN", {
     enumerable: true,
     value: readyStates.indexOf("OPEN")
   });
-  Object.defineProperty(WebSocket.prototype, "OPEN", {
+  Object.defineProperty(WebSocket2.prototype, "OPEN", {
     enumerable: true,
     value: readyStates.indexOf("OPEN")
   });
-  Object.defineProperty(WebSocket, "CLOSING", {
+  Object.defineProperty(WebSocket2, "CLOSING", {
     enumerable: true,
     value: readyStates.indexOf("CLOSING")
   });
-  Object.defineProperty(WebSocket.prototype, "CLOSING", {
+  Object.defineProperty(WebSocket2.prototype, "CLOSING", {
     enumerable: true,
     value: readyStates.indexOf("CLOSING")
   });
-  Object.defineProperty(WebSocket, "CLOSED", {
+  Object.defineProperty(WebSocket2, "CLOSED", {
     enumerable: true,
     value: readyStates.indexOf("CLOSED")
   });
-  Object.defineProperty(WebSocket.prototype, "CLOSED", {
+  Object.defineProperty(WebSocket2.prototype, "CLOSED", {
     enumerable: true,
     value: readyStates.indexOf("CLOSED")
   });
@@ -1975,10 +1975,10 @@ var require_websocket = __commonJS((exports, module) => {
     "readyState",
     "url"
   ].forEach((property) => {
-    Object.defineProperty(WebSocket.prototype, property, { enumerable: true });
+    Object.defineProperty(WebSocket2.prototype, property, { enumerable: true });
   });
   ["open", "error", "close", "message"].forEach((method) => {
-    Object.defineProperty(WebSocket.prototype, `on${method}`, {
+    Object.defineProperty(WebSocket2.prototype, `on${method}`, {
       enumerable: true,
       get() {
         for (const listener of this.listeners(method)) {
@@ -2002,9 +2002,9 @@ var require_websocket = __commonJS((exports, module) => {
       }
     });
   });
-  WebSocket.prototype.addEventListener = addEventListener;
-  WebSocket.prototype.removeEventListener = removeEventListener;
-  module.exports = WebSocket;
+  WebSocket2.prototype.addEventListener = addEventListener;
+  WebSocket2.prototype.removeEventListener = removeEventListener;
+  module.exports = WebSocket2;
   function initAsClient(websocket, address, protocols, options) {
     const opts = {
       allowSynchronousEvents: true,
@@ -2180,7 +2180,7 @@ var require_websocket = __commonJS((exports, module) => {
     });
     req.on("upgrade", (res, socket, head) => {
       websocket.emit("upgrade", res);
-      if (websocket.readyState !== WebSocket.CONNECTING)
+      if (websocket.readyState !== WebSocket2.CONNECTING)
         return;
       req = websocket._req = null;
       const upgrade = res.headers.upgrade;
@@ -2254,7 +2254,7 @@ var require_websocket = __commonJS((exports, module) => {
     }
   }
   function emitErrorAndClose(websocket, err) {
-    websocket._readyState = WebSocket.CLOSING;
+    websocket._readyState = WebSocket2.CLOSING;
     websocket._errorEmitted = true;
     websocket.emit("error", err);
     websocket.emitClose();
@@ -2271,7 +2271,7 @@ var require_websocket = __commonJS((exports, module) => {
     return tls.connect(options);
   }
   function abortHandshake(websocket, stream, message) {
-    websocket._readyState = WebSocket.CLOSING;
+    websocket._readyState = WebSocket2.CLOSING;
     const err = new Error(message);
     Error.captureStackTrace(err, abortHandshake);
     if (stream.setHeader) {
@@ -2351,10 +2351,10 @@ var require_websocket = __commonJS((exports, module) => {
   }
   function senderOnError(err) {
     const websocket = this[kWebSocket];
-    if (websocket.readyState === WebSocket.CLOSED)
+    if (websocket.readyState === WebSocket2.CLOSED)
       return;
-    if (websocket.readyState === WebSocket.OPEN) {
-      websocket._readyState = WebSocket.CLOSING;
+    if (websocket.readyState === WebSocket2.OPEN) {
+      websocket._readyState = WebSocket2.CLOSING;
       setCloseTimer(websocket);
     }
     this._socket.end();
@@ -2371,7 +2371,7 @@ var require_websocket = __commonJS((exports, module) => {
     this.removeListener("close", socketOnClose);
     this.removeListener("data", socketOnData);
     this.removeListener("end", socketOnEnd);
-    websocket._readyState = WebSocket.CLOSING;
+    websocket._readyState = WebSocket2.CLOSING;
     let chunk;
     if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
       websocket._receiver.write(chunk);
@@ -2393,7 +2393,7 @@ var require_websocket = __commonJS((exports, module) => {
   }
   function socketOnEnd() {
     const websocket = this[kWebSocket];
-    websocket._readyState = WebSocket.CLOSING;
+    websocket._readyState = WebSocket2.CLOSING;
     websocket._receiver.end();
     this.end();
   }
@@ -2402,7 +2402,7 @@ var require_websocket = __commonJS((exports, module) => {
     this.removeListener("error", socketOnError);
     this.on("error", NOOP);
     if (websocket) {
-      websocket._readyState = WebSocket.CLOSING;
+      websocket._readyState = WebSocket2.CLOSING;
       this.destroy();
     }
   }
@@ -2410,7 +2410,7 @@ var require_websocket = __commonJS((exports, module) => {
 
 // node_modules/ws/lib/stream.js
 var require_stream = __commonJS((exports, module) => {
-  var WebSocket = require_websocket();
+  var WebSocket2 = require_websocket();
   var { Duplex } = __require("stream");
   function emitClose(stream) {
     stream.emit("close");
@@ -2565,7 +2565,7 @@ var require_websocket_server = __commonJS((exports, module) => {
   var extension = require_extension();
   var PerMessageDeflate = require_permessage_deflate();
   var subprotocol = require_subprotocol();
-  var WebSocket = require_websocket();
+  var WebSocket2 = require_websocket();
   var { GUID, kWebSocket } = require_constants();
   var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
   var RUNNING = 0;
@@ -2590,7 +2590,7 @@ var require_websocket_server = __commonJS((exports, module) => {
         host: null,
         path: null,
         port: null,
-        WebSocket,
+        WebSocket: WebSocket2,
         ...options
       };
       if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) {
@@ -2856,103 +2856,6 @@ var require_websocket_server = __commonJS((exports, module) => {
     }
   }
 });
-// src/types/room.ts
-function serializeRoomState(state) {
-  return {
-    room: state.room,
-    users: Object.fromEntries(state.users),
-    eventHistory: state.eventHistory,
-    locks: Object.fromEntries(state.locks)
-  };
-}
-function deserializeRoomState(serialized) {
-  return {
-    room: serialized.room,
-    users: new Map(Object.entries(serialized.users)),
-    eventHistory: serialized.eventHistory,
-    locks: new Map(Object.entries(serialized.locks))
-  };
-}
-// src/types/experimental.ts
-class ExperimentalFeatureError extends Error {
-  feature;
-  configKey;
-  constructor(feature, configKey) {
-    super(`Experimental feature '${feature}' is not enabled.
-
-` + `To enable, set '${String(configKey)}: true' in your server configuration:
-
-` + `  const server = new ServerBuilder()
-` + `    .withExperimentalFeatures({ ${String(configKey)}: true })
-` + `    .build();
-
-` + `⚠️  WARNING: Experimental APIs are for development only.
-` + `For production use, submit a feature request:
-` + `https://github.com/your-org/control-tower-core/issues/new
-
-` + `See docs/EXPERIMENTAL_BROADCAST.md for details.`);
-    this.feature = feature;
-    this.configKey = configKey;
-    this.name = "ExperimentalFeatureError";
-  }
-}
-// src/abstractions/EventEmitter.ts
-class TypedEventEmitter {
-  listeners = new Map;
-  onceListeners = new Map;
-  on(event, listener) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, new Set);
-    }
-    this.listeners.get(event).add(listener);
-    return () => this.off(event, listener);
-  }
-  once(event, listener) {
-    if (!this.onceListeners.has(event)) {
-      this.onceListeners.set(event, new Set);
-    }
-    this.onceListeners.get(event).add(listener);
-    return () => this.off(event, listener);
-  }
-  off(event, listener) {
-    this.listeners.get(event)?.delete(listener);
-    this.onceListeners.get(event)?.delete(listener);
-  }
-  async emit(event, data) {
-    const listeners = this.listeners.get(event);
-    const onceListeners = this.onceListeners.get(event);
-    if (onceListeners) {
-      const listenersToCall = Array.from(onceListeners);
-      this.onceListeners.delete(event);
-      for (const listener of listenersToCall) {
-        await listener(data);
-      }
-    }
-    if (listeners) {
-      for (const listener of Array.from(listeners)) {
-        await listener(data);
-      }
-    }
-  }
-  removeAllListeners(event) {
-    if (event) {
-      this.listeners.delete(event);
-      this.onceListeners.delete(event);
-    } else {
-      this.listeners.clear();
-      this.onceListeners.clear();
-    }
-  }
-  listenerCount(event) {
-    const regular = this.listeners.get(event)?.size ?? 0;
-    const once = this.onceListeners.get(event)?.size ?? 0;
-    return regular + once;
-  }
-}
-// src/abstractions/RoomManager.ts
-class RoomManager {
-  rooms = new Map;
-}
 // src/abstractions/LockManager.ts
 class LockManager {
   lockState = {
@@ -2961,98 +2864,18 @@ class LockManager {
     userLocks: new Map
   };
 }
-// src/abstractions/DefaultRoomManager.ts
-class DefaultRoomManager extends RoomManager {
-  async createRoom(id, config) {
-    const room = {
-      id,
-      name: config.name || id,
-      createdAt: Date.now(),
-      maxUsers: config.maxUsers,
-      maxHistory: config.maxHistory,
-      permissions: config.permissions,
-      metadata: config.metadata || {}
-    };
-    const roomState = {
-      room,
-      users: new Map,
-      eventHistory: [],
-      locks: new Map
-    };
-    this.rooms.set(id, roomState);
-    return room;
-  }
-  async deleteRoom(id) {
-    this.rooms.delete(id);
-  }
-  async joinRoom(roomId, user) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      throw new Error(`Room ${roomId} not found`);
-    }
-    if (roomState.room.maxUsers && roomState.users.size >= roomState.room.maxUsers) {
-      throw new Error(`Room ${roomId} is full`);
-    }
-    roomState.users.set(user.id, user);
-  }
-  async leaveRoom(roomId, userId) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      return;
-    }
-    roomState.users.delete(userId);
-  }
-  async broadcastToRoom(roomId, event, _excludeUserId) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      throw new Error(`Room ${roomId} not found`);
-    }
-    await this.addEventToHistory(roomId, event);
-  }
-  async getRoomState(roomId) {
-    return this.rooms.get(roomId) || null;
-  }
-  async getUsersInRoom(roomId) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      return [];
-    }
-    return Array.from(roomState.users.values());
-  }
-  async addEventToHistory(roomId, event) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      throw new Error(`Room ${roomId} not found`);
-    }
-    roomState.eventHistory.push(event);
-    if (roomState.room.maxHistory && roomState.eventHistory.length > roomState.room.maxHistory) {
-      roomState.eventHistory = roomState.eventHistory.slice(-roomState.room.maxHistory);
-    }
-  }
-  async getEventHistory(roomId, limit) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      return [];
-    }
-    const history = roomState.eventHistory;
-    return limit ? history.slice(-limit) : history;
-  }
-  async updateUserStatus(roomId, userId, status) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      throw new Error(`Room ${roomId} not found`);
-    }
-    const user = roomState.users.get(userId);
-    if (user) {
-      user.status = status;
-      user.lastActivity = Date.now();
-    }
-  }
-}
+
 // src/abstractions/DefaultLockManager.ts
 class DefaultLockManager extends LockManager {
   async acquireLock(userId, username, request) {
-    const { path, type = "file", priority = "normal", ttl, branch, metadata } = request;
+    const {
+      path,
+      type = "file",
+      priority = "normal",
+      ttl,
+      branch,
+      metadata
+    } = request;
     const userLocks = this.lockState.userLocks.get(userId) || new Set;
     if (userLocks.has(path)) {
       throw new Error(`User ${username} already has a lock on ${path}`);
@@ -3225,6 +3048,7 @@ class PresenceManager {
     return now - device.lastActivity > timeout;
   }
 }
+
 // src/abstractions/DefaultPresenceManager.ts
 class DefaultPresenceManager extends PresenceManager {
   userPresences = new Map;
@@ -3550,211 +3374,765 @@ class DefaultPresenceManager extends PresenceManager {
     return this.userPresences.size + this.gracePeriodEntries.size;
   }
 }
-// src/adapters/mock/MockTransportAdapter.ts
-class MockTransportAdapter {
-  state = "disconnected";
-  messageHandlers = new Set;
-  errorHandlers = new Set;
-  closeHandlers = new Set;
-  messageQueue = [];
-  simulateLatency = 0;
-  shouldFailConnection = false;
-  connectedUrl = null;
-  connectionAttempts = 0;
-  constructor(options) {
-    this.simulateLatency = options?.simulateLatency ?? 0;
-    this.shouldFailConnection = options?.shouldFailConnection ?? false;
+// src/abstractions/RoomManager.ts
+class RoomManager {
+  rooms = new Map;
+}
+
+// src/abstractions/DefaultRoomManager.ts
+class DefaultRoomManager extends RoomManager {
+  async createRoom(id, config) {
+    const room = {
+      id,
+      name: config.name || id,
+      createdAt: Date.now(),
+      maxUsers: config.maxUsers,
+      maxHistory: config.maxHistory,
+      permissions: config.permissions,
+      metadata: config.metadata || {}
+    };
+    const roomState = {
+      room,
+      users: new Map,
+      eventHistory: [],
+      locks: new Map
+    };
+    this.rooms.set(id, roomState);
+    return room;
   }
-  async connect(url, _options) {
-    this.connectionAttempts++;
-    if (this.shouldFailConnection) {
-      this.state = "disconnected";
-      const error = new Error("Mock connection failed");
-      this.errorHandlers.forEach((handler) => handler(error));
-      throw error;
+  async deleteRoom(id) {
+    this.rooms.delete(id);
+  }
+  async joinRoom(roomId, user) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
     }
-    this.state = "connecting";
-    this.connectedUrl = url;
-    if (this.simulateLatency > 0) {
-      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
+    if (roomState.room.maxUsers && roomState.users.size >= roomState.room.maxUsers) {
+      throw new Error(`Room ${roomId} is full`);
     }
-    this.state = "connected";
+    roomState.users.set(user.id, user);
   }
-  async disconnect() {
-    if (this.state === "disconnected")
+  async leaveRoom(roomId, userId) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
       return;
-    this.state = "disconnecting";
-    if (this.simulateLatency > 0) {
-      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency / 2));
     }
-    this.state = "disconnected";
-    this.connectedUrl = null;
-    this.closeHandlers.forEach((handler) => handler(1000, "Normal closure"));
-    this.messageQueue = [];
+    roomState.users.delete(userId);
   }
-  async send(message) {
-    if (this.state !== "connected") {
-      throw new Error("Not connected");
-    }
-    if (this.simulateLatency > 0) {
-      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
+  async broadcastToRoom(roomId, event, _excludeUserId) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
     }
-    this.messageQueue.push(message);
-  }
-  onMessage(handler) {
-    this.messageHandlers.add(handler);
-  }
-  onError(handler) {
-    this.errorHandlers.add(handler);
-  }
-  onClose(handler) {
-    this.closeHandlers.add(handler);
-  }
-  getState() {
-    return this.state;
+    await this.addEventToHistory(roomId, event);
   }
-  isConnected() {
-    return this.state === "connected";
+  async getRoomState(roomId) {
+    return this.rooms.get(roomId) || null;
   }
-  simulateMessage(message, bypassConnectionCheck = false) {
-    if (!bypassConnectionCheck && this.state !== "connected") {
-      throw new Error("Cannot simulate message when not connected");
+  async getUsersInRoom(roomId) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      return [];
     }
-    this.messageHandlers.forEach((handler) => handler(message));
-  }
-  simulateError(error) {
-    this.errorHandlers.forEach((handler) => handler(error));
-  }
-  simulateClose(code, reason) {
-    this.state = "disconnected";
-    this.closeHandlers.forEach((handler) => handler(code, reason));
-  }
-  getMessageQueue() {
-    return [...this.messageQueue];
+    return Array.from(roomState.users.values());
   }
-  clearMessageQueue() {
-    this.messageQueue = [];
+  async addEventToHistory(roomId, event) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    roomState.eventHistory.push(event);
+    if (roomState.room.maxHistory && roomState.eventHistory.length > roomState.room.maxHistory) {
+      roomState.eventHistory = roomState.eventHistory.slice(-roomState.room.maxHistory);
+    }
   }
-  getConnectedUrl() {
-    return this.connectedUrl;
+  async getEventHistory(roomId, limit) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      return [];
+    }
+    const history = roomState.eventHistory;
+    return limit ? history.slice(-limit) : history;
   }
-  getConnectionAttempts() {
-    return this.connectionAttempts;
+  async updateUserStatus(roomId, userId, status) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    const user = roomState.users.get(userId);
+    if (user) {
+      user.status = status;
+      user.lastActivity = Date.now();
+    }
   }
-  resetConnectionAttempts() {
-    this.connectionAttempts = 0;
+}
+// src/abstractions/EventEmitter.ts
+class TypedEventEmitter {
+  listeners = new Map;
+  onceListeners = new Map;
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set);
+    }
+    this.listeners.get(event).add(listener);
+    return () => this.off(event, listener);
   }
-  async simulateConnection(clientId, options = {}) {
-    if (this.state !== "connected") {
-      this.state = "connected";
+  once(event, listener) {
+    if (!this.onceListeners.has(event)) {
+      this.onceListeners.set(event, new Set);
     }
-    const message = {
-      id: `conn-${clientId}`,
-      type: "connection",
-      payload: {
-        clientId,
-        authenticated: options.authenticated ?? false,
-        userId: options.userId,
-        metadata: options.metadata
-      },
-      timestamp: Date.now()
-    };
-    this.simulateMessage(message, true);
+    this.onceListeners.get(event).add(listener);
+    return () => this.off(event, listener);
   }
-  async simulateDisconnect(clientId, reason = "Normal closure") {
-    const message = {
-      id: `disconnect-${clientId}`,
-      type: "disconnect",
-      payload: {
-        clientId,
-        reason
-      },
-      timestamp: Date.now()
-    };
-    this.simulateMessage(message, true);
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+    this.onceListeners.get(event)?.delete(listener);
   }
-  async simulateClientMessage(clientId, messageType, messagePayload = {}) {
-    const message = {
-      id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      type: "server_message",
-      payload: {
-        clientId,
-        type: messageType,
-        ...messagePayload
-      },
-      timestamp: Date.now()
-    };
-    this.simulateMessage(message, true);
+  async emit(event, data) {
+    const listeners = this.listeners.get(event);
+    const onceListeners = this.onceListeners.get(event);
+    if (onceListeners) {
+      const listenersToCall = Array.from(onceListeners);
+      this.onceListeners.delete(event);
+      for (const listener of listenersToCall) {
+        await listener(data);
+      }
+    }
+    if (listeners) {
+      for (const listener of Array.from(listeners)) {
+        await listener(data);
+      }
+    }
   }
-  getSentMessages(clientId) {
-    return this.messageQueue.filter((msg) => {
-      const payload = msg.payload;
-      return payload?.clientId === clientId;
-    }).map((msg) => {
-      const { clientId: _, ...rest } = msg.payload;
-      return rest;
-    });
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+      this.onceListeners.delete(event);
+    } else {
+      this.listeners.clear();
+      this.onceListeners.clear();
+    }
   }
-  simulateIncomingMessage(message) {
-    const fullMessage = {
-      id: message.id || `msg-${Date.now()}`,
-      type: message.type,
-      payload: message.payload || {},
-      timestamp: message.timestamp || Date.now()
-    };
-    this.messageHandlers.forEach((handler) => handler(fullMessage));
+  listenerCount(event) {
+    const regular = this.listeners.get(event)?.size ?? 0;
+    const once = this.onceListeners.get(event)?.size ?? 0;
+    return regular + once;
   }
 }
-// src/adapters/mock/MockStorageAdapter.ts
-class MockStorageAdapter {
-  storage = new Map;
+// src/adapters/mock/MockAuthAdapter.ts
+class MockAuthAdapter {
+  tokens = new Map;
+  revokedTokens = new Set;
   simulateLatency = 0;
-  shouldFailOperations = false;
+  shouldFailAuth = false;
+  tokenCounter = 0;
+  currentToken = null;
   constructor(options) {
     this.simulateLatency = options?.simulateLatency ?? 0;
-    this.shouldFailOperations = options?.shouldFailOperations ?? false;
+    this.shouldFailAuth = options?.shouldFailAuth ?? false;
   }
-  async get(key) {
+  async validateToken(token) {
     await this.simulateDelay();
-    if (this.shouldFailOperations) {
-      throw new Error("Mock storage operation failed");
+    if (this.shouldFailAuth) {
+      throw new Error("Mock auth validation failed");
     }
-    const item = this.storage.get(key);
-    if (!item)
-      return null;
-    if (item.expiresAt && item.expiresAt < Date.now()) {
-      this.storage.delete(key);
-      return null;
+    if (this.revokedTokens.has(token)) {
+      throw new Error("Token has been revoked");
     }
-    return item.value;
-  }
-  async set(key, value, ttl) {
-    await this.simulateDelay();
-    if (this.shouldFailOperations) {
-      throw new Error("Mock storage operation failed");
+    const payload = this.tokens.get(token);
+    if (!payload) {
+      throw new Error("Invalid token");
     }
-    const item = {
-      value,
-      expiresAt: ttl ? Date.now() + ttl : undefined
-    };
-    this.storage.set(key, item);
+    if (payload.expiresAt && payload.expiresAt < Date.now()) {
+      this.tokens.delete(token);
+      throw new Error("Token expired");
+    }
+    return payload;
   }
-  async delete(key) {
+  async generateToken(payload) {
     await this.simulateDelay();
-    if (this.shouldFailOperations) {
-      throw new Error("Mock storage operation failed");
+    if (this.shouldFailAuth) {
+      throw new Error("Mock token generation failed");
     }
-    this.storage.delete(key);
+    const token = `mock-token-${++this.tokenCounter}`;
+    const expiresAt = payload.expiresAt ?? Date.now() + 3600000;
+    this.tokens.set(token, { ...payload, expiresAt });
+    return token;
   }
-  async exists(key) {
+  async refreshToken(token) {
     await this.simulateDelay();
-    if (this.shouldFailOperations) {
-      throw new Error("Mock storage operation failed");
+    if (this.shouldFailAuth) {
+      throw new Error("Mock token refresh failed");
     }
-    const item = this.storage.get(key);
-    if (!item)
-      return false;
-    if (item.expiresAt && item.expiresAt < Date.now()) {
+    const payload = await this.validateToken(token);
+    await this.revokeToken(token);
+    const newPayload = {
+      ...payload,
+      expiresAt: Date.now() + 3600000
+    };
+    return this.generateToken(newPayload);
+  }
+  async revokeToken(token) {
+    await this.simulateDelay();
+    if (this.shouldFailAuth) {
+      throw new Error("Mock token revocation failed");
+    }
+    this.tokens.delete(token);
+    this.revokedTokens.add(token);
+  }
+  getCurrentToken() {
+    return this.currentToken;
+  }
+  isAuthRequired() {
+    return false;
+  }
+  getAuthTimeout() {
+    return 1e4;
+  }
+  async simulateDelay() {
+    if (this.simulateLatency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
+    }
+  }
+  async createTestToken(userId, options) {
+    const payload = {
+      userId,
+      permissions: options?.permissions ?? ["read", "write"],
+      metadata: options?.metadata,
+      expiresAt: options?.expiresIn ? Date.now() + options.expiresIn : undefined
+    };
+    const token = await this.generateToken(payload);
+    this.currentToken = token;
+    return token;
+  }
+  getTokenCount() {
+    return this.tokens.size;
+  }
+  getRevokedTokenCount() {
+    return this.revokedTokens.size;
+  }
+  clearTokens() {
+    this.tokens.clear();
+    this.revokedTokens.clear();
+    this.currentToken = null;
+  }
+  setFailAuth(fail) {
+    this.shouldFailAuth = fail;
+  }
+  setCurrentToken(token) {
+    this.currentToken = token;
+  }
+}
+// src/adapters/mock/MockRTCDataChannel.ts
+class MockRTCDataChannel {
+  label;
+  ordered;
+  id;
+  _readyState = "connecting";
+  _bufferedAmount = 0;
+  _linkedChannel = null;
+  messageQueue = [];
+  config;
+  static channelIdCounter = 0;
+  onopen = null;
+  onclose = null;
+  onerror = null;
+  onmessage = null;
+  onbufferedamountlow = null;
+  bufferedAmountLowThreshold = 0;
+  constructor(label, options, config) {
+    this.label = label;
+    this.ordered = options?.ordered ?? true;
+    this.id = options?.id ?? MockRTCDataChannel.channelIdCounter++;
+    this.config = {
+      simulateLatency: config?.simulateLatency ?? 1,
+      maxMessageSize: config?.maxMessageSize ?? 262144
+    };
+  }
+  get readyState() {
+    return this._readyState;
+  }
+  get bufferedAmount() {
+    return this._bufferedAmount;
+  }
+  send(data) {
+    if (this._readyState !== "open") {
+      throw new Error(`Cannot send on channel in state: ${this._readyState}`);
+    }
+    const size = typeof data === "string" ? data.length : data.byteLength;
+    if (size > this.config.maxMessageSize) {
+      throw new Error(`Message size ${size} exceeds maximum ${this.config.maxMessageSize}`);
+    }
+    this._bufferedAmount += size;
+    if (this._linkedChannel && this._linkedChannel._readyState === "open") {
+      setTimeout(() => {
+        this._bufferedAmount -= size;
+        if (this._bufferedAmount <= this.bufferedAmountLowThreshold) {
+          this.onbufferedamountlow?.();
+        }
+        this._linkedChannel?.onmessage?.({ data });
+      }, this.config.simulateLatency);
+    } else {
+      this.messageQueue.push(data);
+    }
+  }
+  close() {
+    if (this._readyState === "closed" || this._readyState === "closing") {
+      return;
+    }
+    this._readyState = "closing";
+    setTimeout(() => {
+      this._readyState = "closed";
+      this.onclose?.();
+      if (this._linkedChannel && this._linkedChannel._readyState !== "closed") {
+        this._linkedChannel._handleRemoteClose();
+      }
+    }, this.config.simulateLatency);
+  }
+  _linkChannel(channel) {
+    this._linkedChannel = channel;
+    if (this._readyState === "open" && channel._readyState === "open") {
+      this._flushQueue();
+    }
+  }
+  _open() {
+    if (this._readyState === "connecting") {
+      this._readyState = "open";
+      this.onopen?.();
+      if (this._linkedChannel?._readyState === "open") {
+        this._flushQueue();
+      }
+    }
+  }
+  _handleRemoteClose() {
+    if (this._readyState !== "closed" && this._readyState !== "closing") {
+      this._readyState = "closed";
+      this.onclose?.();
+    }
+  }
+  _getLinkedChannel() {
+    return this._linkedChannel;
+  }
+  _flushQueue() {
+    for (const data of this.messageQueue) {
+      const size = typeof data === "string" ? data.length : data.byteLength;
+      setTimeout(() => {
+        this._bufferedAmount -= size;
+        this._linkedChannel?.onmessage?.({ data });
+      }, this.config.simulateLatency);
+    }
+    this.messageQueue = [];
+  }
+  static resetIdCounter() {
+    MockRTCDataChannel.channelIdCounter = 0;
+  }
+}
+// src/adapters/mock/MockRTCPeerConnection.ts
+class MockRTCPeerConnection {
+  _signalingState = "stable";
+  _iceConnectionState = "new";
+  _iceGatheringState = "new";
+  _connectionState = "new";
+  _localDescription = null;
+  _remoteDescription = null;
+  _pendingLocalDescription = null;
+  _pendingRemoteDescription = null;
+  _localCandidates = [];
+  _remoteCandidates = [];
+  _pendingRemoteCandidates = [];
+  _dataChannels = new Map;
+  onicecandidate = null;
+  onicecandidateerror = null;
+  oniceconnectionstatechange = null;
+  onicegatheringstatechange = null;
+  onconnectionstatechange = null;
+  onsignalingstatechange = null;
+  ondatachannel = null;
+  onnegotiationneeded = null;
+  _linkedPeer = null;
+  config;
+  offerCounter = 0;
+  iceUfrag;
+  icePwd;
+  constructor(config) {
+    this.config = {
+      simulateLatency: config?.simulateLatency ?? 10,
+      iceFailureProbability: config?.iceFailureProbability ?? 0,
+      iceGatheringTime: config?.iceGatheringTime ?? 50,
+      autoGenerateIceCandidates: config?.autoGenerateIceCandidates ?? true,
+      iceCandidateCount: config?.iceCandidateCount ?? 3,
+      dataChannelConfig: config?.dataChannelConfig
+    };
+    this.iceUfrag = "mock" + Math.random().toString(36).substring(2, 6);
+    this.icePwd = "mock" + Math.random().toString(36).substring(2, 26);
+  }
+  get signalingState() {
+    return this._signalingState;
+  }
+  get iceConnectionState() {
+    return this._iceConnectionState;
+  }
+  get iceGatheringState() {
+    return this._iceGatheringState;
+  }
+  get connectionState() {
+    return this._connectionState;
+  }
+  get localDescription() {
+    return this._localDescription;
+  }
+  get remoteDescription() {
+    return this._remoteDescription;
+  }
+  get pendingLocalDescription() {
+    return this._pendingLocalDescription;
+  }
+  get pendingRemoteDescription() {
+    return this._pendingRemoteDescription;
+  }
+  get currentLocalDescription() {
+    return this._localDescription;
+  }
+  get currentRemoteDescription() {
+    return this._remoteDescription;
+  }
+  static createLinkedPair(configA, configB) {
+    const peerA = new MockRTCPeerConnection(configA);
+    const peerB = new MockRTCPeerConnection(configB);
+    peerA._linkedPeer = peerB;
+    peerB._linkedPeer = peerA;
+    return [peerA, peerB];
+  }
+  async createOffer() {
+    if (this._signalingState === "closed") {
+      throw new Error("Cannot create offer on closed connection");
+    }
+    await this.simulateDelay();
+    this.offerCounter++;
+    const sdp = this.generateMockSDP("offer");
+    return {
+      type: "offer",
+      sdp
+    };
+  }
+  async createAnswer() {
+    if (this._signalingState !== "have-remote-offer") {
+      throw new Error(`Cannot create answer in signaling state: ${this._signalingState}`);
+    }
+    await this.simulateDelay();
+    const sdp = this.generateMockSDP("answer");
+    return {
+      type: "answer",
+      sdp
+    };
+  }
+  async setLocalDescription(description) {
+    if (this._signalingState === "closed") {
+      throw new Error("Cannot set local description on closed connection");
+    }
+    await this.simulateDelay();
+    if (!description) {
+      if (this._signalingState === "have-remote-offer") {
+        description = await this.createAnswer();
+      } else {
+        description = await this.createOffer();
+      }
+    }
+    this._localDescription = description;
+    this._pendingLocalDescription = null;
+    if (description.type === "offer") {
+      this._signalingState = "have-local-offer";
+    } else if (description.type === "answer") {
+      this._signalingState = "stable";
+      this.startIceConnection();
+    }
+    this.onsignalingstatechange?.();
+    if (this.config.autoGenerateIceCandidates) {
+      this.startIceGathering();
+    }
+  }
+  async setRemoteDescription(description) {
+    if (this._signalingState === "closed") {
+      throw new Error("Cannot set remote description on closed connection");
+    }
+    await this.simulateDelay();
+    this._remoteDescription = description;
+    this._pendingRemoteDescription = null;
+    if (description.type === "offer") {
+      this._signalingState = "have-remote-offer";
+    } else if (description.type === "answer") {
+      this._signalingState = "stable";
+      this.startIceConnection();
+    }
+    this.onsignalingstatechange?.();
+    for (const candidate of this._pendingRemoteCandidates) {
+      this._remoteCandidates.push(candidate);
+    }
+    this._pendingRemoteCandidates = [];
+    if (description.type === "offer" && this._linkedPeer) {
+      this.receiveDataChannelsFromPeer();
+    }
+  }
+  async addIceCandidate(candidate) {
+    if (this._signalingState === "closed") {
+      throw new Error("Cannot add ICE candidate on closed connection");
+    }
+    if (!candidate) {
+      return;
+    }
+    if (!this._remoteDescription) {
+      this._pendingRemoteCandidates.push(candidate);
+      return;
+    }
+    await this.simulateDelay();
+    this._remoteCandidates.push(candidate);
+    if (this._iceConnectionState === "new") {
+      this._iceConnectionState = "checking";
+      this.oniceconnectionstatechange?.();
+    }
+  }
+  createDataChannel(label, options) {
+    if (this._signalingState === "closed") {
+      throw new Error("Cannot create data channel on closed connection");
+    }
+    const channel = new MockRTCDataChannel(label, options, this.config.dataChannelConfig);
+    this._dataChannels.set(label, channel);
+    setTimeout(() => {
+      this.onnegotiationneeded?.();
+    }, 0);
+    return channel;
+  }
+  close() {
+    if (this._signalingState === "closed") {
+      return;
+    }
+    this._signalingState = "closed";
+    this._iceConnectionState = "closed";
+    this._connectionState = "closed";
+    for (const channel of this._dataChannels.values()) {
+      channel.close();
+    }
+    this._dataChannels.clear();
+    this.onsignalingstatechange?.();
+    this.oniceconnectionstatechange?.();
+    this.onconnectionstatechange?.();
+  }
+  async getStats() {
+    return new Map([
+      [
+        "peer-connection",
+        {
+          type: "peer-connection",
+          timestamp: Date.now(),
+          dataChannelsOpened: this._dataChannels.size,
+          localCandidates: this._localCandidates.length,
+          remoteCandidates: this._remoteCandidates.length,
+          signalingState: this._signalingState,
+          iceConnectionState: this._iceConnectionState,
+          connectionState: this._connectionState
+        }
+      ]
+    ]);
+  }
+  restartIce() {
+    this.iceUfrag = "mock" + Math.random().toString(36).substring(2, 6);
+    this.icePwd = "mock" + Math.random().toString(36).substring(2, 26);
+    this._localCandidates = [];
+    this._remoteCandidates = [];
+    this._iceGatheringState = "new";
+    this._iceConnectionState = "new";
+    this.onicegatheringstatechange?.();
+    this.oniceconnectionstatechange?.();
+  }
+  getDataChannels() {
+    return new Map(this._dataChannels);
+  }
+  getLocalCandidates() {
+    return [...this._localCandidates];
+  }
+  getRemoteCandidates() {
+    return [...this._remoteCandidates];
+  }
+  getLinkedPeer() {
+    return this._linkedPeer;
+  }
+  _forceConnected() {
+    this._iceConnectionState = "connected";
+    this._connectionState = "connected";
+    this.oniceconnectionstatechange?.();
+    this.onconnectionstatechange?.();
+    for (const channel of this._dataChannels.values()) {
+      channel._open();
+    }
+  }
+  async simulateDelay() {
+    if (this.config.simulateLatency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.config.simulateLatency));
+    }
+  }
+  generateMockSDP(type) {
+    const sessionId = Date.now();
+    const version = this.offerCounter;
+    const lines = [
+      "v=0",
+      `o=- ${sessionId} ${version} IN IP4 127.0.0.1`,
+      "s=-",
+      "t=0 0",
+      "a=group:BUNDLE 0",
+      "a=extmap-allow-mixed",
+      "a=msid-semantic: WMS",
+      "m=application 9 UDP/DTLS/SCTP webrtc-datachannel",
+      "c=IN IP4 0.0.0.0",
+      `a=ice-ufrag:${this.iceUfrag}`,
+      `a=ice-pwd:${this.icePwd}`,
+      "a=ice-options:trickle",
+      "a=fingerprint:sha-256 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00",
+      type === "offer" ? "a=setup:actpass" : "a=setup:active",
+      "a=mid:0",
+      "a=sctp-port:5000",
+      "a=max-message-size:262144"
+    ];
+    return lines.join(`\r
+`) + `\r
+`;
+  }
+  startIceGathering() {
+    if (this._iceGatheringState !== "new") {
+      return;
+    }
+    this._iceGatheringState = "gathering";
+    this.onicegatheringstatechange?.();
+    const candidateDelay = this.config.iceGatheringTime / this.config.iceCandidateCount;
+    for (let i = 0;i < this.config.iceCandidateCount; i++) {
+      setTimeout(() => {
+        if (this._signalingState === "closed")
+          return;
+        if (Math.random() < this.config.iceFailureProbability) {
+          this.onicecandidateerror?.({
+            errorCode: 701,
+            errorText: "Simulated ICE failure"
+          });
+          return;
+        }
+        const candidate = {
+          candidate: `candidate:${i} 1 udp ${2000000000 - i * 100} 192.168.1.${100 + i} ${50000 + i} typ host generation 0 ufrag ${this.iceUfrag}`,
+          sdpMid: "0",
+          sdpMLineIndex: 0,
+          usernameFragment: this.iceUfrag
+        };
+        this._localCandidates.push(candidate);
+        this.onicecandidate?.({ candidate });
+        if (i === this.config.iceCandidateCount - 1) {
+          setTimeout(() => {
+            if (this._signalingState === "closed")
+              return;
+            this._iceGatheringState = "complete";
+            this.onicegatheringstatechange?.();
+            this.onicecandidate?.({ candidate: null });
+          }, this.config.simulateLatency);
+        }
+      }, candidateDelay * i);
+    }
+  }
+  startIceConnection() {
+    this._iceConnectionState = "checking";
+    this._connectionState = "connecting";
+    this.oniceconnectionstatechange?.();
+    this.onconnectionstatechange?.();
+    setTimeout(() => {
+      if (this._signalingState === "closed")
+        return;
+      this._iceConnectionState = "connected";
+      this._connectionState = "connected";
+      this.oniceconnectionstatechange?.();
+      this.onconnectionstatechange?.();
+      this.openDataChannels();
+    }, this.config.iceGatheringTime + this.config.simulateLatency);
+  }
+  openDataChannels() {
+    for (const channel of this._dataChannels.values()) {
+      channel._open();
+    }
+    if (this._linkedPeer) {
+      for (const [label, localChannel] of this._dataChannels) {
+        const remoteChannel = this._linkedPeer._dataChannels.get(label);
+        if (remoteChannel) {
+          localChannel._linkChannel(remoteChannel);
+          remoteChannel._linkChannel(localChannel);
+        }
+      }
+      for (const channel of this._linkedPeer._dataChannels.values()) {
+        if (channel.readyState === "connecting") {
+          channel._open();
+        }
+      }
+    }
+  }
+  receiveDataChannelsFromPeer() {
+    if (!this._linkedPeer)
+      return;
+    for (const [label, peerChannel] of this._linkedPeer._dataChannels) {
+      if (!this._dataChannels.has(label)) {
+        const localChannel = new MockRTCDataChannel(label, { ordered: peerChannel.ordered, id: peerChannel.id }, this.config.dataChannelConfig);
+        this._dataChannels.set(label, localChannel);
+        localChannel._linkChannel(peerChannel);
+        peerChannel._linkChannel(localChannel);
+        this.ondatachannel?.({ channel: localChannel });
+      }
+    }
+  }
+}
+// src/adapters/mock/MockStorageAdapter.ts
+class MockStorageAdapter {
+  storage = new Map;
+  simulateLatency = 0;
+  shouldFailOperations = false;
+  constructor(options) {
+    this.simulateLatency = options?.simulateLatency ?? 0;
+    this.shouldFailOperations = options?.shouldFailOperations ?? false;
+  }
+  async get(key) {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    const item = this.storage.get(key);
+    if (!item)
+      return null;
+    if (item.expiresAt && item.expiresAt < Date.now()) {
+      this.storage.delete(key);
+      return null;
+    }
+    return item.value;
+  }
+  async set(key, value, ttl) {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    const item = {
+      value,
+      expiresAt: ttl ? Date.now() + ttl : undefined
+    };
+    this.storage.set(key, item);
+  }
+  async delete(key) {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    this.storage.delete(key);
+  }
+  async exists(key) {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    const item = this.storage.get(key);
+    if (!item)
+      return false;
+    if (item.expiresAt && item.expiresAt < Date.now()) {
       this.storage.delete(key);
       return false;
     }
@@ -3855,117 +4233,645 @@ class MockStorageAdapter {
     this.shouldFailOperations = fail;
   }
 }
-// src/adapters/mock/MockAuthAdapter.ts
-class MockAuthAdapter {
-  tokens = new Map;
-  revokedTokens = new Set;
+// src/adapters/mock/MockTransportAdapter.ts
+class MockTransportAdapter {
+  state = "disconnected";
+  messageHandlers = new Set;
+  errorHandlers = new Set;
+  closeHandlers = new Set;
+  messageQueue = [];
   simulateLatency = 0;
-  shouldFailAuth = false;
-  tokenCounter = 0;
-  currentToken = null;
+  shouldFailConnection = false;
+  connectedUrl = null;
+  connectionAttempts = 0;
   constructor(options) {
     this.simulateLatency = options?.simulateLatency ?? 0;
-    this.shouldFailAuth = options?.shouldFailAuth ?? false;
+    this.shouldFailConnection = options?.shouldFailConnection ?? false;
   }
-  async validateToken(token) {
-    await this.simulateDelay();
-    if (this.shouldFailAuth) {
-      throw new Error("Mock auth validation failed");
+  async connect(url, _options) {
+    this.connectionAttempts++;
+    if (this.shouldFailConnection) {
+      this.state = "disconnected";
+      const error = new Error("Mock connection failed");
+      this.errorHandlers.forEach((handler) => handler(error));
+      throw error;
     }
-    if (this.revokedTokens.has(token)) {
-      throw new Error("Token has been revoked");
+    this.state = "connecting";
+    this.connectedUrl = url;
+    if (this.simulateLatency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
     }
-    const payload = this.tokens.get(token);
-    if (!payload) {
-      throw new Error("Invalid token");
+    this.state = "connected";
+  }
+  async disconnect() {
+    if (this.state === "disconnected")
+      return;
+    this.state = "disconnecting";
+    if (this.simulateLatency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency / 2));
     }
-    if (payload.expiresAt && payload.expiresAt < Date.now()) {
-      this.tokens.delete(token);
-      throw new Error("Token expired");
+    this.state = "disconnected";
+    this.connectedUrl = null;
+    this.closeHandlers.forEach((handler) => handler(1000, "Normal closure"));
+    this.messageQueue = [];
+  }
+  async send(message) {
+    if (this.state !== "connected") {
+      throw new Error("Not connected");
     }
-    return payload;
+    if (this.simulateLatency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
+    }
+    this.messageQueue.push(message);
   }
-  async generateToken(payload) {
-    await this.simulateDelay();
-    if (this.shouldFailAuth) {
-      throw new Error("Mock token generation failed");
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+  }
+  onError(handler) {
+    this.errorHandlers.add(handler);
+  }
+  onClose(handler) {
+    this.closeHandlers.add(handler);
+  }
+  getState() {
+    return this.state;
+  }
+  isConnected() {
+    return this.state === "connected";
+  }
+  simulateMessage(message, bypassConnectionCheck = false) {
+    if (!bypassConnectionCheck && this.state !== "connected") {
+      throw new Error("Cannot simulate message when not connected");
     }
-    const token = `mock-token-${++this.tokenCounter}`;
-    const expiresAt = payload.expiresAt ?? Date.now() + 3600000;
-    this.tokens.set(token, { ...payload, expiresAt });
-    return token;
+    this.messageHandlers.forEach((handler) => handler(message));
   }
-  async refreshToken(token) {
-    await this.simulateDelay();
-    if (this.shouldFailAuth) {
-      throw new Error("Mock token refresh failed");
+  simulateError(error) {
+    this.errorHandlers.forEach((handler) => handler(error));
+  }
+  simulateClose(code, reason) {
+    this.state = "disconnected";
+    this.closeHandlers.forEach((handler) => handler(code, reason));
+  }
+  getMessageQueue() {
+    return [...this.messageQueue];
+  }
+  clearMessageQueue() {
+    this.messageQueue = [];
+  }
+  getConnectedUrl() {
+    return this.connectedUrl;
+  }
+  getConnectionAttempts() {
+    return this.connectionAttempts;
+  }
+  resetConnectionAttempts() {
+    this.connectionAttempts = 0;
+  }
+  async simulateConnection(clientId, options = {}) {
+    if (this.state !== "connected") {
+      this.state = "connected";
+    }
+    const message = {
+      id: `conn-${clientId}`,
+      type: "connection",
+      payload: {
+        clientId,
+        authenticated: options.authenticated ?? false,
+        userId: options.userId,
+        metadata: options.metadata
+      },
+      timestamp: Date.now()
+    };
+    this.simulateMessage(message, true);
+  }
+  async simulateDisconnect(clientId, reason = "Normal closure") {
+    const message = {
+      id: `disconnect-${clientId}`,
+      type: "disconnect",
+      payload: {
+        clientId,
+        reason
+      },
+      timestamp: Date.now()
+    };
+    this.simulateMessage(message, true);
+  }
+  async simulateClientMessage(clientId, messageType, messagePayload = {}) {
+    const message = {
+      id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      type: "server_message",
+      payload: {
+        clientId,
+        type: messageType,
+        ...messagePayload
+      },
+      timestamp: Date.now()
+    };
+    this.simulateMessage(message, true);
+  }
+  getSentMessages(clientId) {
+    return this.messageQueue.filter((msg) => {
+      const payload = msg.payload;
+      return payload?.clientId === clientId;
+    }).map((msg) => {
+      const { clientId: _, ...rest } = msg.payload;
+      return rest;
+    });
+  }
+  simulateIncomingMessage(message) {
+    const fullMessage = {
+      id: message.id || `msg-${Date.now()}`,
+      type: message.type,
+      payload: message.payload || {},
+      timestamp: message.timestamp || Date.now()
+    };
+    this.messageHandlers.forEach((handler) => handler(fullMessage));
+  }
+}
+// src/adapters/webrtc/WebRTCSignalingAdapter.ts
+class WebRTCSignalingAdapter {
+  client;
+  config;
+  peers = new Map;
+  eventUnsubscribers = [];
+  onPeerConnected = null;
+  onPeerDisconnected = null;
+  onPeerMessage = null;
+  onError = null;
+  onStateChange = null;
+  constructor(client, config) {
+    this.client = client;
+    this.config = {
+      useMock: config?.useMock ?? true,
+      iceServers: config?.iceServers,
+      mockConfig: config?.mockConfig,
+      dataChannelLabel: config?.dataChannelLabel ?? "data",
+      orderedDelivery: config?.orderedDelivery ?? true
+    };
+    this.setupSignalingListeners();
+  }
+  async connectToPeer(peerId) {
+    if (this.peers.has(peerId)) {
+      throw new Error(`Already connected or connecting to peer: ${peerId}`);
+    }
+    const connection = this.createPeerConnection();
+    const peerState = {
+      peerId,
+      connection,
+      dataChannel: null,
+      state: "new",
+      createdAt: Date.now()
+    };
+    this.peers.set(peerId, peerState);
+    this.setupConnectionHandlers(peerState);
+    const dataChannel = connection.createDataChannel(this.config.dataChannelLabel, {
+      ordered: this.config.orderedDelivery
+    });
+    peerState.dataChannel = dataChannel;
+    this.setupDataChannelHandlers(peerState, dataChannel);
+    this.updatePeerState(peerState, "connecting");
+    const offer = await connection.createOffer();
+    await connection.setLocalDescription(offer);
+    await this.sendSignal(peerId, "webrtc:offer", {
+      sdp: offer.sdp,
+      type: offer.type
+    });
+  }
+  disconnectFromPeer(peerId) {
+    const peer = this.peers.get(peerId);
+    if (!peer)
+      return;
+    this.sendSignal(peerId, "webrtc:disconnect", {}).catch(() => {});
+    peer.dataChannel?.close();
+    peer.connection.close();
+    this.updatePeerState(peer, "disconnected");
+    this.peers.delete(peerId);
+    this.onPeerDisconnected?.(peerId);
+  }
+  sendToPeer(peerId, data) {
+    const peer = this.peers.get(peerId);
+    if (!peer || !peer.dataChannel) {
+      throw new Error(`No data channel to peer: ${peerId}`);
+    }
+    if (peer.dataChannel.readyState !== "open") {
+      throw new Error(`Data channel not open for peer: ${peerId} (state: ${peer.dataChannel.readyState})`);
+    }
+    peer.dataChannel.send(data);
+  }
+  broadcastToPeers(data) {
+    for (const peerId of this.getConnectedPeers()) {
+      try {
+        this.sendToPeer(peerId, data);
+      } catch (error) {
+        console.warn(`Failed to send to peer ${peerId}:`, error);
+      }
+    }
+  }
+  getConnectedPeers() {
+    return Array.from(this.peers.entries()).filter(([_, peer]) => peer.state === "connected").map(([peerId]) => peerId);
+  }
+  getAllPeers() {
+    return Array.from(this.peers.keys());
+  }
+  getPeerState(peerId) {
+    return this.peers.get(peerId)?.state ?? null;
+  }
+  getPeerInfo(peerId) {
+    return this.peers.get(peerId) ?? null;
+  }
+  isConnectedToPeer(peerId) {
+    return this.peers.get(peerId)?.state === "connected";
+  }
+  dispose() {
+    for (const peerId of this.getAllPeers()) {
+      this.disconnectFromPeer(peerId);
+    }
+    for (const unsubscribe of this.eventUnsubscribers) {
+      unsubscribe();
+    }
+    this.eventUnsubscribers = [];
+  }
+  createPeerConnection() {
+    if (this.config.useMock) {
+      return new MockRTCPeerConnection(this.config.mockConfig);
+    } else {
+      throw new Error("Real WebRTC not yet implemented. Use useMock: true");
+    }
+  }
+  setupSignalingListeners() {
+    const unsubscribe = this.client.on("event_received", ({ event }) => {
+      this.handleSignalingMessage(event).catch((error) => {
+        console.error("Error handling signaling message:", error);
+      });
+    });
+    this.eventUnsubscribers.push(unsubscribe);
+  }
+  async handleSignalingMessage(event) {
+    const eventAny = event;
+    const type = eventAny.type;
+    const fromUserId = eventAny.metadata?.userId;
+    const myUserId = this.client.getUserId();
+    if (!fromUserId || fromUserId === myUserId) {
+      return;
+    }
+    const data = eventAny.data;
+    const targetPeerId = data?.targetPeerId;
+    if (targetPeerId && targetPeerId !== myUserId) {
+      return;
+    }
+    switch (type) {
+      case "webrtc:offer":
+        await this.handleOffer(fromUserId, data ?? {});
+        break;
+      case "webrtc:answer":
+        await this.handleAnswer(fromUserId, data ?? {});
+        break;
+      case "webrtc:ice_candidate":
+        await this.handleIceCandidate(fromUserId, data ?? {});
+        break;
+      case "webrtc:disconnect":
+        this.handlePeerDisconnect(fromUserId);
+        break;
+    }
+  }
+  async handleOffer(peerId, data) {
+    if (this.peers.has(peerId)) {
+      console.warn(`Received offer from peer ${peerId} but already have a connection`);
+      return;
+    }
+    const connection = this.createPeerConnection();
+    const peerState = {
+      peerId,
+      connection,
+      dataChannel: null,
+      state: "connecting",
+      createdAt: Date.now()
+    };
+    this.peers.set(peerId, peerState);
+    this.setupConnectionHandlers(peerState);
+    connection.ondatachannel = (event) => {
+      peerState.dataChannel = event.channel;
+      this.setupDataChannelHandlers(peerState, event.channel);
+    };
+    await connection.setRemoteDescription({
+      type: "offer",
+      sdp: data.sdp
+    });
+    const answer = await connection.createAnswer();
+    await connection.setLocalDescription(answer);
+    await this.sendSignal(peerId, "webrtc:answer", {
+      sdp: answer.sdp,
+      type: answer.type
+    });
+  }
+  async handleAnswer(peerId, data) {
+    const peer = this.peers.get(peerId);
+    if (!peer) {
+      console.warn(`Received answer from unknown peer: ${peerId}`);
+      return;
+    }
+    await peer.connection.setRemoteDescription({
+      type: "answer",
+      sdp: data.sdp
+    });
+  }
+  async handleIceCandidate(peerId, data) {
+    const peer = this.peers.get(peerId);
+    if (!peer) {
+      console.warn(`Received ICE candidate from unknown peer: ${peerId}`);
+      return;
+    }
+    const candidate = data.candidate;
+    if (candidate) {
+      await peer.connection.addIceCandidate(candidate);
+    }
+  }
+  handlePeerDisconnect(peerId) {
+    const peer = this.peers.get(peerId);
+    if (!peer)
+      return;
+    peer.dataChannel?.close();
+    peer.connection.close();
+    this.updatePeerState(peer, "disconnected");
+    this.peers.delete(peerId);
+    this.onPeerDisconnected?.(peerId);
+  }
+  setupConnectionHandlers(peer) {
+    const connection = peer.connection;
+    connection.onicecandidate = (event) => {
+      if (event.candidate) {
+        this.sendSignal(peer.peerId, "webrtc:ice_candidate", {
+          candidate: event.candidate
+        }).catch((error) => {
+          console.error("Failed to send ICE candidate:", error);
+        });
+      }
+    };
+    connection.onconnectionstatechange = () => {
+      const state = connection.connectionState;
+      if (state === "connected") {
+        peer.connectedAt = Date.now();
+        this.updatePeerState(peer, "connected");
+      } else if (state === "disconnected" || state === "closed") {
+        this.updatePeerState(peer, "disconnected");
+        this.peers.delete(peer.peerId);
+        this.onPeerDisconnected?.(peer.peerId);
+      } else if (state === "failed") {
+        this.updatePeerState(peer, "failed");
+        this.onError?.(peer.peerId, new Error("Connection failed"));
+      }
+    };
+    connection.oniceconnectionstatechange = () => {
+      if (connection.iceConnectionState === "failed") {
+        this.updatePeerState(peer, "failed");
+        this.onError?.(peer.peerId, new Error("ICE connection failed"));
+      }
+    };
+  }
+  setupDataChannelHandlers(peer, channel) {
+    channel.onopen = () => {
+      this.updatePeerState(peer, "connected");
+      peer.connectedAt = Date.now();
+      this.onPeerConnected?.(peer.peerId, channel);
+    };
+    channel.onclose = () => {
+      if (peer.state === "connected") {
+        this.updatePeerState(peer, "disconnected");
+        this.onPeerDisconnected?.(peer.peerId);
+      }
+    };
+    channel.onerror = (event) => {
+      this.onError?.(peer.peerId, event.error);
+    };
+    channel.onmessage = (event) => {
+      this.onPeerMessage?.(peer.peerId, event.data);
+    };
+  }
+  updatePeerState(peer, state) {
+    const oldState = peer.state;
+    peer.state = state;
+    if (oldState !== state) {
+      this.onStateChange?.(peer.peerId, state);
+    }
+  }
+  async sendSignal(peerId, type, data) {
+    const myUserId = this.client.getUserId();
+    const roomId = this.client.getCurrentRoomId();
+    if (!roomId) {
+      throw new Error("Cannot send WebRTC signal: not in a room");
+    }
+    const signalEvent = {
+      id: `webrtc-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+      type,
+      timestamp: Date.now(),
+      userId: myUserId || "",
+      roomId,
+      data: {
+        ...data,
+        targetPeerId: peerId
+      },
+      metadata: {
+        userId: myUserId,
+        timestamp: Date.now(),
+        roomId
+      }
+    };
+    await this.client.broadcast(signalEvent);
+  }
+}
+// node_modules/ws/wrapper.mjs
+var import_stream = __toESM(require_stream(), 1);
+var import_receiver = __toESM(require_receiver(), 1);
+var import_sender = __toESM(require_sender(), 1);
+var import_websocket = __toESM(require_websocket(), 1);
+var import_websocket_server = __toESM(require_websocket_server(), 1);
+
+// src/adapters/websocket/WebSocketClientTransportAdapter.ts
+class WebSocketClientTransportAdapter {
+  ws;
+  state = "disconnected";
+  messageHandlers = new Set;
+  errorHandlers = new Set;
+  closeHandlers = new Set;
+  config;
+  heartbeatTimer;
+  connectionTimer;
+  constructor(config) {
+    this.config = {
+      headers: config?.headers ?? {},
+      connectionTimeout: config?.connectionTimeout ?? 30000,
+      enableHeartbeat: config?.enableHeartbeat ?? true,
+      heartbeatInterval: config?.heartbeatInterval ?? 30000
+    };
+  }
+  async connect(url, options) {
+    if (this.state === "connected" || this.state === "connecting") {
+      throw new Error("Already connected or connecting");
+    }
+    this.state = "connecting";
+    return new Promise((resolve, reject) => {
+      try {
+        const wsOptions = {};
+        if (Object.keys(this.config.headers).length > 0) {
+          wsOptions.headers = this.config.headers;
+        }
+        this.ws = new import_websocket.default(url, wsOptions);
+        this.connectionTimer = setTimeout(() => {
+          if (this.state === "connecting") {
+            this.ws?.terminate();
+            this.state = "disconnected";
+            const error = new Error("Connection timeout");
+            this.errorHandlers.forEach((handler) => handler(error));
+            reject(error);
+          }
+        }, this.config.connectionTimeout);
+        this.ws.on("open", () => {
+          if (this.connectionTimer) {
+            clearTimeout(this.connectionTimer);
+            this.connectionTimer = undefined;
+          }
+          this.state = "connected";
+          if (this.config.enableHeartbeat) {
+            this.startHeartbeat();
+          }
+          resolve();
+        });
+        this.ws.on("message", (data) => {
+          try {
+            const message = JSON.parse(data.toString());
+            this.messageHandlers.forEach((handler) => handler(message));
+          } catch (error) {
+            this.errorHandlers.forEach((handler) => handler(error));
+          }
+        });
+        this.ws.on("error", (error) => {
+          if (this.connectionTimer) {
+            clearTimeout(this.connectionTimer);
+            this.connectionTimer = undefined;
+          }
+          this.errorHandlers.forEach((handler) => handler(error));
+          if (this.state === "connecting") {
+            this.state = "disconnected";
+            reject(error);
+          }
+        });
+        this.ws.on("close", (code, reason) => {
+          if (this.connectionTimer) {
+            clearTimeout(this.connectionTimer);
+            this.connectionTimer = undefined;
+          }
+          this.stopHeartbeat();
+          const wasConnected = this.state === "connected";
+          this.state = "disconnected";
+          if (wasConnected) {
+            this.closeHandlers.forEach((handler) => handler(code, reason.toString()));
+          }
+        });
+        if (this.config.enableHeartbeat) {
+          this.ws.on("pong", () => {});
+        }
+      } catch (error) {
+        if (this.connectionTimer) {
+          clearTimeout(this.connectionTimer);
+          this.connectionTimer = undefined;
+        }
+        this.state = "disconnected";
+        reject(error);
+      }
+    });
+  }
+  async disconnect() {
+    if (this.state === "disconnected") {
+      return;
+    }
+    this.state = "disconnecting";
+    this.stopHeartbeat();
+    if (this.connectionTimer) {
+      clearTimeout(this.connectionTimer);
+      this.connectionTimer = undefined;
+    }
+    if (this.ws) {
+      this.ws.close(1000, "Client disconnecting");
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          this.ws?.terminate();
+          resolve();
+        }, 5000);
+        const onClose = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+        this.ws?.once("close", onClose);
+      });
+      this.ws = undefined;
     }
-    const payload = await this.validateToken(token);
-    await this.revokeToken(token);
-    const newPayload = {
-      ...payload,
-      expiresAt: Date.now() + 3600000
-    };
-    return this.generateToken(newPayload);
+    this.state = "disconnected";
   }
-  async revokeToken(token) {
-    await this.simulateDelay();
-    if (this.shouldFailAuth) {
-      throw new Error("Mock token revocation failed");
+  async send(message) {
+    if (this.state !== "connected") {
+      throw new Error("Not connected");
+    }
+    if (!this.ws || this.ws.readyState !== import_websocket.default.OPEN) {
+      throw new Error("WebSocket connection is not open");
+    }
+    try {
+      const data = JSON.stringify(message);
+      this.ws.send(data);
+    } catch (error) {
+      this.errorHandlers.forEach((handler) => handler(error));
+      throw error;
     }
-    this.tokens.delete(token);
-    this.revokedTokens.add(token);
   }
-  getCurrentToken() {
-    return this.currentToken;
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
   }
-  isAuthRequired() {
-    return false;
+  onError(handler) {
+    this.errorHandlers.add(handler);
   }
-  getAuthTimeout() {
-    return 1e4;
+  onClose(handler) {
+    this.closeHandlers.add(handler);
   }
-  async simulateDelay() {
-    if (this.simulateLatency > 0) {
-      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
-    }
+  getState() {
+    return this.state;
   }
-  async createTestToken(userId, options) {
-    const payload = {
-      userId,
-      permissions: options?.permissions ?? ["read", "write"],
-      metadata: options?.metadata,
-      expiresAt: options?.expiresIn ? Date.now() + options.expiresIn : undefined
-    };
-    const token = await this.generateToken(payload);
-    this.currentToken = token;
-    return token;
+  isConnected() {
+    return this.state === "connected" && this.ws?.readyState === import_websocket.default.OPEN;
   }
-  getTokenCount() {
-    return this.tokens.size;
+  getWebSocket() {
+    return this.ws;
   }
-  getRevokedTokenCount() {
-    return this.revokedTokens.size;
+  setHeaders(headers) {
+    if (this.state !== "disconnected") {
+      throw new Error("Cannot set headers while connected");
+    }
+    this.config.headers = { ...this.config.headers, ...headers };
   }
-  clearTokens() {
-    this.tokens.clear();
-    this.revokedTokens.clear();
-    this.currentToken = null;
+  setAuthToken(token) {
+    this.setHeaders({ Authorization: `Bearer ${token}` });
   }
-  setFailAuth(fail) {
-    this.shouldFailAuth = fail;
+  startHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws && this.ws.readyState === import_websocket.default.OPEN) {
+        const heartbeatMessage = {
+          id: `heartbeat-${Date.now()}`,
+          type: "heartbeat",
+          payload: { timestamp: Date.now() },
+          timestamp: Date.now()
+        };
+        this.ws.send(JSON.stringify(heartbeatMessage));
+      }
+    }, this.config.heartbeatInterval);
   }
-  setCurrentToken(token) {
-    this.currentToken = token;
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = undefined;
+    }
   }
 }
-// node_modules/ws/wrapper.mjs
-var import_stream = __toESM(require_stream(), 1);
-var import_receiver = __toESM(require_receiver(), 1);
-var import_sender = __toESM(require_sender(), 1);
-var import_websocket = __toESM(require_websocket(), 1);
-var import_websocket_server = __toESM(require_websocket_server(), 1);
-
 // src/adapters/websocket/WebSocketServerTransportAdapter.ts
 class WebSocketServerTransportAdapter {
   state = "disconnected";
@@ -4325,8 +5231,8 @@ class WebSocketServerTransportAdapter {
     return Math.random().toString(36).substring(2) + Date.now().toString(36);
   }
 }
-// src/adapters/websocket/WebSocketClientTransportAdapter.ts
-class WebSocketClientTransportAdapter {
+// src/adapters/websocket/BrowserWebSocketTransportAdapter.ts
+class BrowserWebSocketTransportAdapter {
   ws;
   state = "disconnected";
   messageHandlers = new Set;
@@ -4335,36 +5241,38 @@ class WebSocketClientTransportAdapter {
   config;
   heartbeatTimer;
   connectionTimer;
+  authToken;
   constructor(config) {
     this.config = {
-      headers: config?.headers ?? {},
       connectionTimeout: config?.connectionTimeout ?? 30000,
       enableHeartbeat: config?.enableHeartbeat ?? true,
-      heartbeatInterval: config?.heartbeatInterval ?? 30000
+      heartbeatInterval: config?.heartbeatInterval ?? 30000,
+      authToken: config?.authToken
     };
+    this.authToken = config?.authToken;
   }
-  async connect(url, options) {
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  async connect(url, _options) {
     if (this.state === "connected" || this.state === "connecting") {
       throw new Error("Already connected or connecting");
     }
     this.state = "connecting";
     return new Promise((resolve, reject) => {
       try {
-        const wsOptions = {};
-        if (Object.keys(this.config.headers).length > 0) {
-          wsOptions.headers = this.config.headers;
-        }
-        this.ws = new import_websocket.default(url, wsOptions);
-        this.connectionTimer = setTimeout(() => {
+        const wsUrl = this.authToken ? `${url}${url.includes("?") ? "&" : "?"}token=${encodeURIComponent(this.authToken)}` : url;
+        this.ws = new WebSocket(wsUrl);
+        this.connectionTimer = window.setTimeout(() => {
           if (this.state === "connecting") {
-            this.ws?.terminate();
+            this.ws?.close();
             this.state = "disconnected";
             const error = new Error("Connection timeout");
             this.errorHandlers.forEach((handler) => handler(error));
             reject(error);
           }
         }, this.config.connectionTimeout);
-        this.ws.on("open", () => {
+        this.ws.onopen = () => {
           if (this.connectionTimer) {
             clearTimeout(this.connectionTimer);
             this.connectionTimer = undefined;
@@ -4374,41 +5282,44 @@ class WebSocketClientTransportAdapter {
             this.startHeartbeat();
           }
           resolve();
-        });
-        this.ws.on("message", (data) => {
+        };
+        this.ws.onmessage = (event) => {
           try {
-            const message = JSON.parse(data.toString());
+            const message = JSON.parse(event.data);
             this.messageHandlers.forEach((handler) => handler(message));
           } catch (error) {
-            this.errorHandlers.forEach((handler) => handler(error));
+            const err = new Error(`Failed to parse message: ${error}`);
+            this.errorHandlers.forEach((handler) => handler(err));
           }
-        });
-        this.ws.on("error", (error) => {
+        };
+        this.ws.onerror = (_event) => {
           if (this.connectionTimer) {
             clearTimeout(this.connectionTimer);
             this.connectionTimer = undefined;
           }
+          const error = new Error("WebSocket error occurred");
           this.errorHandlers.forEach((handler) => handler(error));
           if (this.state === "connecting") {
             this.state = "disconnected";
             reject(error);
           }
-        });
-        this.ws.on("close", (code, reason) => {
+        };
+        this.ws.onclose = (event) => {
           if (this.connectionTimer) {
             clearTimeout(this.connectionTimer);
             this.connectionTimer = undefined;
           }
           this.stopHeartbeat();
           const wasConnected = this.state === "connected";
+          const wasConnecting = this.state === "connecting";
           this.state = "disconnected";
           if (wasConnected) {
-            this.closeHandlers.forEach((handler) => handler(code, reason.toString()));
+            this.closeHandlers.forEach((handler) => handler(event.code, event.reason || "Connection closed"));
           }
-        });
-        if (this.config.enableHeartbeat) {
-          this.ws.on("pong", () => {});
-        }
+          if (wasConnecting) {
+            reject(new Error(`Connection closed: ${event.reason}`));
+          }
+        };
       } catch (error) {
         if (this.connectionTimer) {
           clearTimeout(this.connectionTimer);
@@ -4433,14 +5344,18 @@ class WebSocketClientTransportAdapter {
       this.ws.close(1000, "Client disconnecting");
       await new Promise((resolve) => {
         const timeout = setTimeout(() => {
-          this.ws?.terminate();
           resolve();
         }, 5000);
         const onClose = () => {
           clearTimeout(timeout);
           resolve();
         };
-        this.ws?.once("close", onClose);
+        if (this.ws) {
+          this.ws.addEventListener("close", onClose, { once: true });
+        } else {
+          clearTimeout(timeout);
+          resolve();
+        }
       });
       this.ws = undefined;
     }
@@ -4450,7 +5365,7 @@ class WebSocketClientTransportAdapter {
     if (this.state !== "connected") {
       throw new Error("Not connected");
     }
-    if (!this.ws || this.ws.readyState !== import_websocket.default.OPEN) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       throw new Error("WebSocket connection is not open");
     }
     try {
@@ -4474,26 +5389,17 @@ class WebSocketClientTransportAdapter {
     return this.state;
   }
   isConnected() {
-    return this.state === "connected" && this.ws?.readyState === import_websocket.default.OPEN;
+    return this.state === "connected" && this.ws?.readyState === WebSocket.OPEN;
   }
   getWebSocket() {
     return this.ws;
   }
-  setHeaders(headers) {
-    if (this.state !== "disconnected") {
-      throw new Error("Cannot set headers while connected");
-    }
-    this.config.headers = { ...this.config.headers, ...headers };
-  }
-  setAuthToken(token) {
-    this.setHeaders({ Authorization: `Bearer ${token}` });
-  }
   startHeartbeat() {
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
     }
-    this.heartbeatTimer = setInterval(() => {
-      if (this.ws && this.ws.readyState === import_websocket.default.OPEN) {
+    this.heartbeatTimer = window.setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
         const heartbeatMessage = {
           id: `heartbeat-${Date.now()}`,
           type: "heartbeat",
@@ -4511,6 +5417,24 @@ class WebSocketClientTransportAdapter {
     }
   }
 }
+// src/types/room.ts
+function serializeRoomState(state) {
+  return {
+    room: state.room,
+    users: Object.fromEntries(state.users),
+    eventHistory: state.eventHistory,
+    locks: Object.fromEntries(state.locks)
+  };
+}
+function deserializeRoomState(serialized) {
+  return {
+    room: serialized.room,
+    users: new Map(Object.entries(serialized.users)),
+    eventHistory: serialized.eventHistory,
+    locks: new Map(Object.entries(serialized.locks))
+  };
+}
+
 // src/client/BaseClient.ts
 class BaseClient extends TypedEventEmitter {
   transport;
@@ -4595,7 +5519,10 @@ class BaseClient extends TypedEventEmitter {
       this.authToken = null;
       this.userId = null;
       this.reconnectAttempts = 0;
-      await this.emit("disconnected", { code: 1000, reason: "Client disconnected" });
+      await this.emit("disconnected", {
+        code: 1000,
+        reason: "Client disconnected"
+      });
     }
   }
   async reconnect() {
@@ -4764,14 +5691,19 @@ class BaseClient extends TypedEventEmitter {
       }
       await this.emit("authenticated", { userId: this.userId || "" });
     } else {
-      await this.emit("authentication_failed", { error: payload.error || "Authentication failed" });
+      await this.emit("authentication_failed", {
+        error: payload.error || "Authentication failed"
+      });
     }
   }
   async handleRoomJoined(payload) {
     this.currentRoomId = payload.roomId;
     const roomState = deserializeRoomState(payload.state);
     this.currentRoomState = roomState;
-    await this.emit("room_joined", { roomId: payload.roomId, state: roomState });
+    await this.emit("room_joined", {
+      roomId: payload.roomId,
+      state: roomState
+    });
   }
   async handleRoomLeft(payload) {
     if (this.currentRoomId === payload.roomId) {
@@ -4965,6 +5897,30 @@ class PresenceClient extends TypedEventEmitter {
     });
   }
 }
+// src/types/experimental.ts
+class ExperimentalFeatureError extends Error {
+  feature;
+  configKey;
+  constructor(feature, configKey) {
+    super(`Experimental feature '${feature}' is not enabled.
+
+` + `To enable, set '${String(configKey)}: true' in your server configuration:
+
+` + `  const server = new ServerBuilder()
+` + `    .withExperimentalFeatures({ ${String(configKey)}: true })
+` + `    .build();
+
+` + `⚠️  WARNING: Experimental APIs are for development only.
+` + `For production use, submit a feature request:
+` + `https://github.com/your-org/control-tower-core/issues/new
+
+` + `See docs/EXPERIMENTAL_BROADCAST.md for details.`);
+    this.feature = feature;
+    this.configKey = configKey;
+    this.name = "ExperimentalFeatureError";
+  }
+}
+
 // src/server/ExperimentalAPI.ts
 class ExperimentalAPI {
   config;
@@ -5198,12 +6154,17 @@ class BaseServer extends TypedEventEmitter {
       throw new Error("Server is already running");
     }
     try {
-      await this.transport.connect(`ws://localhost:${port}`, { url: `ws://localhost:${port}` });
+      await this.transport.connect(`ws://localhost:${port}`, {
+        url: `ws://localhost:${port}`
+      });
       this.running = true;
       this.initialized = true;
       await this.emit("started", { port });
     } catch (error) {
-      await this.emit("error", { error, context: "server_start" });
+      await this.emit("error", {
+        error,
+        context: "server_start"
+      });
       throw error;
     }
   }
@@ -5235,7 +6196,10 @@ class BaseServer extends TypedEventEmitter {
       this.initialized = true;
       await this.emit("started", { port: 0 });
     } catch (error) {
-      await this.emit("error", { error, context: "server_initialize" });
+      await this.emit("error", {
+        error,
+        context: "server_initialize"
+      });
       throw error;
     }
   }
@@ -5251,7 +6215,10 @@ class BaseServer extends TypedEventEmitter {
     try {
       await this.transport.disconnect();
     } catch (error) {
-      await this.emit("error", { error, context: "server_stop" });
+      await this.emit("error", {
+        error,
+        context: "server_stop"
+      });
     }
     this.clients.clear();
     this.clientMessageHandlers.clear();
@@ -5478,10 +6445,16 @@ class BaseServer extends TypedEventEmitter {
             await this.handleLockRelease(clientId, message.payload);
             break;
           case "ping":
-            await this.sendToClient(clientId, { type: "pong", timestamp: Date.now() });
+            await this.sendToClient(clientId, {
+              type: "pong",
+              timestamp: Date.now()
+            });
             break;
           case "heartbeat":
-            await this.sendToClient(clientId, { type: "heartbeat_ack", timestamp: Date.now() });
+            await this.sendToClient(clientId, {
+              type: "heartbeat_ack",
+              timestamp: Date.now()
+            });
             break;
           default:
             await this.sendToClient(clientId, {
@@ -5494,13 +6467,20 @@ class BaseServer extends TypedEventEmitter {
           type: "error",
           error: error.message
         });
-        await this.emit("error", { error, context: `client_${clientId}` });
+        await this.emit("error", {
+          error,
+          context: `client_${clientId}`
+        });
       }
     };
   }
   async handleAuthenticate(clientId, payload) {
     if (!this.auth) {
-      await this.sendToClient(clientId, { type: "auth_result", success: false, error: "Authentication not configured" });
+      await this.sendToClient(clientId, {
+        type: "auth_result",
+        success: false,
+        error: "Authentication not configured"
+      });
       return;
     }
     try {
@@ -5509,15 +6489,28 @@ class BaseServer extends TypedEventEmitter {
       if (client) {
         client.userId = tokenPayload.userId;
         client.authenticated = true;
+        this.clientUserMap.set(clientId, tokenPayload.userId);
+        if (!this.userClientMap.has(tokenPayload.userId)) {
+          this.userClientMap.set(tokenPayload.userId, new Set);
+        }
+        this.userClientMap.get(tokenPayload.userId).add(clientId);
         await this.emit("client_authenticated", {
           clientId,
           userId: tokenPayload.userId,
           metadata: tokenPayload.metadata
         });
       }
-      await this.sendToClient(clientId, { type: "auth_result", success: true, userId: tokenPayload.userId });
+      await this.sendToClient(clientId, {
+        type: "auth_result",
+        success: true,
+        userId: tokenPayload.userId
+      });
     } catch (error) {
-      await this.sendToClient(clientId, { type: "auth_result", success: false, error: error.message });
+      await this.sendToClient(clientId, {
+        type: "auth_result",
+        success: false,
+        error: error.message
+      });
     }
   }
   async handleJoinRoom(clientId, payload) {
@@ -5529,17 +6522,26 @@ class BaseServer extends TypedEventEmitter {
       await this.handleAuthenticate(clientId, { token: payload.token });
     }
     if (!client.authenticated) {
-      await this.sendToClient(clientId, { type: "error", error: "Authentication required to join room" });
+      await this.sendToClient(clientId, {
+        type: "error",
+        error: "Authentication required to join room"
+      });
       return;
     }
     try {
       if (client.roomIds.has(payload.roomId)) {
-        await this.sendToClient(clientId, { type: "error", error: "Already in this room" });
+        await this.sendToClient(clientId, {
+          type: "error",
+          error: "Already in this room"
+        });
         return;
       }
       let roomState = await this.roomManager.getRoomState(payload.roomId);
       if (!roomState) {
-        const roomConfig = { ...this.config.defaultRoomConfig, id: payload.roomId };
+        const roomConfig = {
+          ...this.config.defaultRoomConfig,
+          id: payload.roomId
+        };
         const room = await this.roomManager.createRoom(payload.roomId, roomConfig);
         roomState = await this.roomManager.getRoomState(payload.roomId);
         await this.emit("room_created", { room });
@@ -5557,7 +6559,10 @@ class BaseServer extends TypedEventEmitter {
       };
       await this.roomManager.joinRoom(payload.roomId, user);
       client.roomIds.add(payload.roomId);
-      await this.emit("client_joined_room", { clientId, roomId: payload.roomId });
+      await this.emit("client_joined_room", {
+        clientId,
+        roomId: payload.roomId
+      });
       const updatedRoomState = await this.roomManager.getRoomState(payload.roomId);
       if (!updatedRoomState) {
         throw new Error("Failed to get updated room state after joining");
@@ -5576,7 +6581,10 @@ class BaseServer extends TypedEventEmitter {
         });
       }
     } catch (error) {
-      await this.sendToClient(clientId, { type: "error", error: error.message });
+      await this.sendToClient(clientId, {
+        type: "error",
+        error: error.message
+      });
     }
   }
   async handleLeaveRoom(clientId, payload) {
@@ -5601,7 +6609,10 @@ class BaseServer extends TypedEventEmitter {
   async handleBroadcastEvent(clientId, payload) {
     const client = this.clients.get(clientId);
     if (!client || !client.roomIds.has(payload.roomId)) {
-      await this.sendToClient(clientId, { type: "error", error: "Not in specified room" });
+      await this.sendToClient(clientId, {
+        type: "error",
+        error: "Not in specified room"
+      });
       return;
     }
     const enrichedEvent = {
@@ -5624,7 +6635,10 @@ class BaseServer extends TypedEventEmitter {
   async handleLockRequest(clientId, payload) {
     const client = this.clients.get(clientId);
     if (!client || !client.roomIds.has(payload.roomId)) {
-      await this.sendToClient(clientId, { type: "error", error: "Not in specified room" });
+      await this.sendToClient(clientId, {
+        type: "error",
+        error: "Not in specified room"
+      });
       return;
     }
     try {
@@ -5638,10 +6652,18 @@ class BaseServer extends TypedEventEmitter {
         userId: client.userId,
         roomId: payload.roomId,
         data: { lock, action: "acquired" },
-        metadata: { userId: client.userId, timestamp: Date.now(), roomId: payload.roomId }
+        metadata: {
+          userId: client.userId,
+          timestamp: Date.now(),
+          roomId: payload.roomId
+        }
       });
     } catch (error) {
-      await this.sendToClient(clientId, { type: "lock_denied", request: payload.request, reason: error.message });
+      await this.sendToClient(clientId, {
+        type: "lock_denied",
+        request: payload.request,
+        reason: error.message
+      });
     }
   }
   async handleLockRelease(clientId, payload) {
@@ -5652,7 +6674,10 @@ class BaseServer extends TypedEventEmitter {
     try {
       await this.lockManager.releaseLock(payload.lockId);
       await this.emit("lock_released", { lockId: payload.lockId, clientId });
-      await this.sendToClient(clientId, { type: "lock_released", lockId: payload.lockId });
+      await this.sendToClient(clientId, {
+        type: "lock_released",
+        lockId: payload.lockId
+      });
       for (const roomId of client.roomIds) {
         await this.roomManager.broadcastToRoom(roomId, {
           id: this.generateId(),
@@ -5665,7 +6690,10 @@ class BaseServer extends TypedEventEmitter {
         });
       }
     } catch (error) {
-      await this.sendToClient(clientId, { type: "error", error: error.message });
+      await this.sendToClient(clientId, {
+        type: "error",
+        error: error.message
+      });
     }
   }
   async sendToClient(clientId, message) {
@@ -5871,6 +6899,7 @@ class ServerBuilder {
 export {
   WebSocketServerTransportAdapter,
   WebSocketClientTransportAdapter,
+  WebRTCSignalingAdapter,
   TypedEventEmitter,
   ServerBuilder,
   RoomManager,
@@ -5878,6 +6907,8 @@ export {
   PresenceClient,
   MockTransportAdapter,
   MockStorageAdapter,
+  MockRTCPeerConnection,
+  MockRTCDataChannel,
   MockAuthAdapter,
   LockManager,
   ExperimentalFeatureError,
@@ -5886,8 +6917,9 @@ export {
   DefaultPresenceManager,
   DefaultLockManager,
   ClientBuilder,
+  BrowserWebSocketTransportAdapter,
   BaseServer,
   BaseClient
 };
 
-//# debugId=144E7B07131D042564756E2164756E21
+//# debugId=94389897A03B4D7064756E2164756E21