@principal-ai/control-tower-core 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,1205 +1,9 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  TypedEventEmitter: () => TypedEventEmitter,
-  ServerBuilder: () => ServerBuilder,
-  RoomManager: () => RoomManager,
-  MockTransportAdapter: () => MockTransportAdapter,
-  MockStorageAdapter: () => MockStorageAdapter,
-  MockAuthAdapter: () => MockAuthAdapter,
-  LockManager: () => LockManager,
-  ClientBuilder: () => ClientBuilder,
-  BaseServer: () => BaseServer,
-  BaseClient: () => BaseClient
-});
-module.exports = __toCommonJS(exports_src);
-// 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 = {
-    locks: new Map,
-    queue: new Map,
-    userLocks: new Map
-  };
-}
-// 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;
-  constructor(options) {
-    this.simulateLatency = options?.simulateLatency ?? 0;
-    this.shouldFailConnection = options?.shouldFailConnection ?? false;
-  }
-  async connect(url, _options) {
-    if (this.shouldFailConnection) {
-      this.state = "disconnected";
-      const error = new Error("Mock connection failed");
-      this.errorHandlers.forEach((handler) => handler(error));
-      throw error;
-    }
-    this.state = "connecting";
-    this.connectedUrl = url;
-    if (this.simulateLatency > 0) {
-      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
-    }
-    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));
-    }
-    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");
-    }
-    if (this.simulateLatency > 0) {
-      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
-    }
-    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;
-  }
-  isConnected() {
-    return this.state === "connected";
-  }
-  simulateMessage(message) {
-    if (this.state !== "connected") {
-      throw new Error("Cannot simulate message when not connected");
-    }
-    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];
-  }
-  clearMessageQueue() {
-    this.messageQueue = [];
-  }
-  getConnectedUrl() {
-    return this.connectedUrl;
-  }
-}
-// 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;
-    }
-    return true;
-  }
-  async scan(pattern) {
-    await this.simulateDelay();
-    if (this.shouldFailOperations) {
-      throw new Error("Mock storage operation failed");
-    }
-    const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".").replace(/\[!/g, "[^").replace(/\[/g, "[").replace(/\]/g, "]");
-    const regex = new RegExp(`^${regexPattern}$`);
-    const keys = [];
-    for (const [key, item] of this.storage.entries()) {
-      if (item.expiresAt && item.expiresAt < Date.now()) {
-        this.storage.delete(key);
-        continue;
-      }
-      if (regex.test(key)) {
-        keys.push(key);
-      }
-    }
-    return keys;
-  }
-  async clear() {
-    await this.simulateDelay();
-    if (this.shouldFailOperations) {
-      throw new Error("Mock storage operation failed");
-    }
-    this.storage.clear();
-  }
-  async transaction(operations) {
-    await this.simulateDelay();
-    if (this.shouldFailOperations) {
-      throw new Error("Mock storage operation failed");
-    }
-    const results = [];
-    const rollback = [];
-    try {
-      for (const op of operations) {
-        switch (op.type) {
-          case "get": {
-            const value = await this.get(op.key);
-            results.push(value);
-            break;
-          }
-          case "set": {
-            const oldValue = await this.get(op.key);
-            await this.set(op.key, op.value, op.ttl);
-            rollback.push(() => {
-              if (oldValue !== null) {
-                this.storage.set(op.key, { value: oldValue });
-              } else {
-                this.storage.delete(op.key);
-              }
-            });
-            results.push(true);
-            break;
-          }
-          case "delete": {
-            const oldValue = await this.get(op.key);
-            await this.delete(op.key);
-            rollback.push(() => {
-              if (oldValue !== null) {
-                this.storage.set(op.key, { value: oldValue });
-              }
-            });
-            results.push(true);
-            break;
-          }
-          case "exists": {
-            const exists = await this.exists(op.key);
-            results.push(exists);
-            break;
-          }
-        }
-      }
-      return results;
-    } catch (error) {
-      for (const rollbackFn of rollback.reverse()) {
-        rollbackFn();
-      }
-      throw error;
-    }
-  }
-  async simulateDelay() {
-    if (this.simulateLatency > 0) {
-      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
-    }
-  }
-  getSize() {
-    return this.storage.size;
-  }
-  getRawStorage() {
-    return new Map(this.storage);
-  }
-  setFailOperations(fail) {
-    this.shouldFailOperations = fail;
-  }
-}
-// src/adapters/mock/MockAuthAdapter.ts
-class MockAuthAdapter {
-  tokens = new Map;
-  revokedTokens = new Set;
-  users = new Map;
-  simulateLatency = 0;
-  shouldFailAuth = false;
-  tokenCounter = 0;
-  constructor(options) {
-    this.simulateLatency = options?.simulateLatency ?? 0;
-    this.shouldFailAuth = options?.shouldFailAuth ?? false;
-    this.addUser("testuser", "password123", {
-      userId: "user-1",
-      email: "test@example.com",
-      username: "testuser",
-      permissions: ["read", "write"]
-    });
-    this.addUser("admin", "admin123", {
-      userId: "user-admin",
-      email: "admin@example.com",
-      username: "admin",
-      permissions: ["read", "write", "admin"]
-    });
-  }
-  async validateToken(token) {
-    await this.simulateDelay();
-    if (this.shouldFailAuth) {
-      throw new Error("Mock auth validation failed");
-    }
-    if (this.revokedTokens.has(token)) {
-      throw new Error("Token has been revoked");
-    }
-    const payload = this.tokens.get(token);
-    if (!payload) {
-      throw new Error("Invalid token");
-    }
-    if (payload.expiresAt && payload.expiresAt < Date.now()) {
-      this.tokens.delete(token);
-      throw new Error("Token expired");
-    }
-    return payload;
-  }
-  async generateToken(payload) {
-    await this.simulateDelay();
-    if (this.shouldFailAuth) {
-      throw new Error("Mock token generation failed");
-    }
-    const token = `mock-token-${++this.tokenCounter}`;
-    const expiresAt = payload.expiresAt ?? Date.now() + 3600000;
-    this.tokens.set(token, { ...payload, expiresAt });
-    return token;
-  }
-  async refreshToken(token) {
-    await this.simulateDelay();
-    if (this.shouldFailAuth) {
-      throw new Error("Mock token refresh failed");
-    }
-    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);
-  }
-  async authenticate(credentials) {
-    await this.simulateDelay();
-    if (this.shouldFailAuth) {
-      throw new Error("Mock authentication failed");
-    }
-    switch (credentials.type) {
-      case "password": {
-        if (!credentials.username || !credentials.password) {
-          throw new Error("Username and password required");
-        }
-        const user = this.users.get(credentials.username);
-        if (!user || user.password !== credentials.password) {
-          throw new Error("Invalid credentials");
-        }
-        const token = await this.generateToken(user.payload);
-        const refreshToken = `refresh-${token}`;
-        this.tokens.set(refreshToken, user.payload);
-        return {
-          token,
-          refreshToken,
-          user: user.payload,
-          expiresIn: 3600
-        };
-      }
-      case "token": {
-        if (!credentials.token) {
-          throw new Error("Token required");
-        }
-        const payload = await this.validateToken(credentials.token);
-        return {
-          token: credentials.token,
-          user: payload,
-          expiresIn: 3600
-        };
-      }
-      case "oauth": {
-        if (!credentials.code) {
-          throw new Error("OAuth code required");
-        }
-        const payload = {
-          userId: `oauth-user-${Date.now()}`,
-          email: "oauth@example.com",
-          username: "oauthuser",
-          permissions: ["read", "write"]
-        };
-        const token = await this.generateToken(payload);
-        return {
-          token,
-          user: payload,
-          expiresIn: 3600
-        };
-      }
-      default:
-        throw new Error("Unsupported credential type");
-    }
-  }
-  async simulateDelay() {
-    if (this.simulateLatency > 0) {
-      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
-    }
-  }
-  addUser(username, password, payload) {
-    this.users.set(username, { password, payload });
-  }
-  removeUser(username) {
-    this.users.delete(username);
-  }
-  getTokenCount() {
-    return this.tokens.size;
-  }
-  getRevokedTokenCount() {
-    return this.revokedTokens.size;
-  }
-  clearTokens() {
-    this.tokens.clear();
-    this.revokedTokens.clear();
-  }
-  setFailAuth(fail) {
-    this.shouldFailAuth = fail;
-  }
-}
-// src/client/BaseClient.ts
-class BaseClient extends TypedEventEmitter {
-  transport;
-  auth;
-  storage;
-  config;
-  connectionState = "disconnected";
-  currentRoomId = null;
-  currentRoomState = null;
-  authToken = null;
-  userId = null;
-  reconnectAttempts = 0;
-  reconnectTimer = null;
-  lastConnectionUrl = null;
-  lastCredentials = null;
-  constructor(config) {
-    super();
-    this.config = config;
-    this.transport = config.transport;
-    this.auth = config.auth;
-    this.storage = config.storage;
-    this.transport.onMessage(this.handleMessage.bind(this));
-    this.transport.onError(this.handleError.bind(this));
-    this.transport.onClose(this.handleClose.bind(this));
-  }
-  async connect(url, credentials) {
-    if (this.connectionState !== "disconnected") {
-      throw new Error("Client is already connected or connecting");
-    }
-    this.connectionState = "connecting";
-    this.lastConnectionUrl = url;
-    this.lastCredentials = credentials || null;
-    try {
-      if (credentials && this.auth) {
-        const authResult = await this.auth.authenticate(credentials);
-        this.authToken = authResult.token;
-        this.userId = authResult.user.userId;
-      }
-      const options = {
-        url,
-        reconnect: false,
-        ...this.config.reconnection
-      };
-      await this.transport.connect(url, options);
-      this.connectionState = "connected";
-      await this.emit("connected", { url });
-    } catch (error) {
-      this.connectionState = "disconnected";
-      await this.emit("error", { error });
-      throw error;
-    }
-  }
-  async disconnect() {
-    if (this.connectionState === "disconnected") {
-      return;
-    }
-    this.connectionState = "disconnecting";
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.currentRoomId) {
-      await this.leaveRoom();
-    }
-    try {
-      await this.transport.disconnect();
-    } finally {
-      this.connectionState = "disconnected";
-      this.currentRoomId = null;
-      this.currentRoomState = null;
-      this.authToken = null;
-      this.userId = null;
-      this.reconnectAttempts = 0;
-      await this.emit("disconnected", { code: 1000, reason: "Client disconnected" });
-    }
-  }
-  async reconnect() {
-    if (!this.lastConnectionUrl) {
-      throw new Error("No previous connection to reconnect to");
-    }
-    if (this.connectionState !== "disconnected") {
-      await this.disconnect();
-    }
-    await this.connect(this.lastConnectionUrl, this.lastCredentials || undefined);
-  }
-  async joinRoom(roomId) {
-    if (this.connectionState !== "connected") {
-      throw new Error("Client must be connected to join a room");
-    }
-    if (this.currentRoomId) {
-      await this.leaveRoom();
-    }
-    const message = {
-      id: this.generateId(),
-      type: "join_room",
-      payload: { roomId, token: this.authToken },
-      timestamp: Date.now()
-    };
-    await this.transport.send(message);
-  }
-  async leaveRoom() {
-    if (!this.currentRoomId) {
-      return;
-    }
-    const message = {
-      id: this.generateId(),
-      type: "leave_room",
-      payload: { roomId: this.currentRoomId },
-      timestamp: Date.now()
-    };
-    await this.transport.send(message);
-    this.currentRoomId = null;
-    this.currentRoomState = null;
-  }
-  async broadcast(event) {
-    if (this.connectionState !== "connected" || !this.currentRoomId) {
-      throw new Error("Client must be connected and in a room to broadcast events");
-    }
-    const message = {
-      id: this.generateId(),
-      type: "broadcast_event",
-      payload: { event, roomId: this.currentRoomId },
-      timestamp: Date.now()
-    };
-    await this.transport.send(message);
-  }
-  async requestLock(request) {
-    if (this.connectionState !== "connected" || !this.currentRoomId) {
-      throw new Error("Client must be connected and in a room to request locks");
-    }
-    const message = {
-      id: this.generateId(),
-      type: "request_lock",
-      payload: { request, roomId: this.currentRoomId },
-      timestamp: Date.now()
-    };
-    await this.transport.send(message);
-  }
-  async releaseLock(lockId) {
-    if (this.connectionState !== "connected" || !this.currentRoomId) {
-      throw new Error("Client must be connected and in a room to release locks");
-    }
-    const message = {
-      id: this.generateId(),
-      type: "release_lock",
-      payload: { lockId, roomId: this.currentRoomId },
-      timestamp: Date.now()
-    };
-    await this.transport.send(message);
-  }
-  getConnectionState() {
-    return this.connectionState;
-  }
-  getRoomState() {
-    return this.currentRoomState;
-  }
-  getPresence() {
-    return this.currentRoomState ? Array.from(this.currentRoomState.users.values()) : [];
-  }
-  getCurrentRoomId() {
-    return this.currentRoomId;
-  }
-  getUserId() {
-    return this.userId;
-  }
-  async handleMessage(message) {
-    try {
-      switch (message.type) {
-        case "room_joined":
-          await this.handleRoomJoined(message.payload);
-          break;
-        case "room_left":
-          await this.handleRoomLeft(message.payload);
-          break;
-        case "event_broadcast":
-          await this.handleEventBroadcast(message.payload);
-          break;
-        case "lock_acquired":
-          await this.handleLockAcquired(message.payload);
-          break;
-        case "lock_released":
-          await this.handleLockReleased(message.payload);
-          break;
-        case "lock_denied":
-          await this.handleLockDenied(message.payload);
-          break;
-        case "presence_updated":
-          await this.handlePresenceUpdated(message.payload);
-          break;
-        case "error":
-          await this.handleServerError(message.payload);
-          break;
-      }
-    } catch (error) {
-      await this.emit("error", { error });
-    }
-  }
-  async handleError(error) {
-    await this.emit("error", { error });
-  }
-  async handleClose(code, reason) {
-    const wasConnected = this.connectionState === "connected";
-    this.connectionState = "disconnected";
-    if (wasConnected) {
-      await this.emit("disconnected", { code, reason });
-      if (this.config.reconnection?.enabled && this.lastConnectionUrl) {
-        this.scheduleReconnect();
-      }
-    }
-  }
-  async handleRoomJoined(payload) {
-    this.currentRoomId = payload.roomId;
-    this.currentRoomState = payload.state;
-    await this.emit("room_joined", payload);
-  }
-  async handleRoomLeft(payload) {
-    if (this.currentRoomId === payload.roomId) {
-      this.currentRoomId = null;
-      this.currentRoomState = null;
-    }
-    await this.emit("room_left", payload);
-  }
-  async handleEventBroadcast(payload) {
-    await this.emit("event_received", payload);
-  }
-  async handleLockAcquired(payload) {
-    await this.emit("lock_acquired", payload);
-  }
-  async handleLockReleased(payload) {
-    await this.emit("lock_released", payload);
-  }
-  async handleLockDenied(payload) {
-    await this.emit("lock_denied", payload);
-  }
-  async handlePresenceUpdated(payload) {
-    if (this.currentRoomState) {
-      this.currentRoomState.users = new Map(payload.users.map((user) => [user.id, user]));
-    }
-    await this.emit("presence_updated", payload);
-  }
-  async handleServerError(payload) {
-    const error = new Error(payload.error);
-    await this.emit("error", { error });
-  }
-  async scheduleReconnect() {
-    if (!this.config.reconnection || this.reconnectAttempts >= this.config.reconnection.maxAttempts) {
-      return;
-    }
-    const delay = Math.min(this.config.reconnection.initialDelay * Math.pow(this.config.reconnection.backoffFactor, this.reconnectAttempts), this.config.reconnection.maxDelay);
-    this.reconnectAttempts++;
-    await this.emit("reconnecting", { attempt: this.reconnectAttempts, delay });
-    this.reconnectTimer = setTimeout(async () => {
-      try {
-        await this.reconnect();
-        this.reconnectAttempts = 0;
-        await this.emit("reconnected", { url: this.lastConnectionUrl });
-      } catch {
-        this.scheduleReconnect();
-      }
-    }, delay);
-  }
-  generateId() {
-    return Math.random().toString(36).substring(2) + Date.now().toString(36);
-  }
-}
-// src/client/ClientBuilder.ts
-class ClientBuilder {
-  transport;
-  auth;
-  storage;
-  reconnection;
-  withTransport(transport) {
-    this.transport = transport;
-    return this;
-  }
-  withAuth(auth) {
-    this.auth = auth;
-    return this;
-  }
-  withStorage(storage) {
-    this.storage = storage;
-    return this;
-  }
-  withReconnection(config) {
-    this.reconnection = config;
-    return this;
-  }
-  build() {
-    if (!this.transport) {
-      throw new Error("Transport adapter is required");
-    }
-    const config = {
-      transport: this.transport,
-      auth: this.auth,
-      storage: this.storage,
-      reconnection: this.reconnection || {
-        enabled: true,
-        maxAttempts: 5,
-        initialDelay: 1000,
-        maxDelay: 30000,
-        backoffFactor: 2
-      }
-    };
-    return new BaseClient(config);
-  }
-}
-// src/server/BaseServer.ts
-class BaseServer extends TypedEventEmitter {
-  transport;
-  auth;
-  storage;
-  roomManager;
-  lockManager;
-  config;
-  clients = new Map;
-  clientMessageHandlers = new Map;
-  running = false;
-  constructor(config) {
-    super();
-    this.config = config;
-    this.transport = config.transport;
-    this.auth = config.auth;
-    this.storage = config.storage;
-    this.roomManager = config.roomManager;
-    this.lockManager = config.lockManager;
-    this.transport.onMessage(this.handleTransportMessage.bind(this));
-    this.transport.onError(this.handleTransportError.bind(this));
-    this.transport.onClose(this.handleTransportClose.bind(this));
-  }
-  async start(port) {
-    if (this.running) {
-      throw new Error("Server is already running");
-    }
-    try {
-      await this.transport.connect(`ws://localhost:${port}`, { url: `ws://localhost:${port}` });
-      this.running = true;
-      await this.emit("started", { port });
-    } catch (error) {
-      await this.emit("error", { error, context: "server_start" });
-      throw error;
-    }
-  }
-  async stop() {
-    if (!this.running) {
-      return;
-    }
-    this.running = false;
-    for (const [clientId] of Array.from(this.clients)) {
-      await this.disconnectClient(clientId, "Server shutting down");
-    }
-    try {
-      await this.transport.disconnect();
-    } catch (error) {
-      await this.emit("error", { error, context: "server_stop" });
-    }
-    this.clients.clear();
-    this.clientMessageHandlers.clear();
-    await this.emit("stopped", {});
-  }
-  async handleTransportMessage(message) {
-    const payload = message.payload;
-    const { clientId, ...clientMessage } = payload;
-    const clientMsg = {
-      id: message.id,
-      type: message.type,
-      payload: clientMessage,
-      timestamp: message.timestamp
-    };
-    if (!clientId) {
-      await this.emit("error", {
-        error: new Error("Message missing clientId"),
-        context: "transport_message"
-      });
-      return;
-    }
-    const handler = this.clientMessageHandlers.get(clientId);
-    if (handler) {
-      await handler(clientMsg);
-    } else {
-      await this.emit("error", {
-        error: new Error(`No handler for client ${clientId}`),
-        context: "transport_message"
-      });
-    }
-  }
-  async handleTransportError(error) {
-    await this.emit("error", { error, context: "transport" });
-  }
-  async handleTransportClose(_code, _reason) {
-    if (this.running) {
-      await this.stop();
-    }
-  }
-  async addClient(clientId) {
-    const client = {
-      id: clientId,
-      userId: "",
-      roomId: null,
-      authenticated: false,
-      connectedAt: Date.now()
-    };
-    this.clients.set(clientId, client);
-    this.clientMessageHandlers.set(clientId, this.createClientMessageHandler(clientId));
-    await this.emit("client_connected", { client });
-  }
-  async disconnectClient(clientId, reason) {
-    const client = this.clients.get(clientId);
-    if (!client) {
-      return;
-    }
-    if (client.roomId) {
-      await this.roomManager.leaveRoom(client.roomId, client.userId);
-      await this.emit("client_left_room", { clientId, roomId: client.roomId });
-    }
-    await this.lockManager.releaseUserLocks(client.userId);
-    this.clients.delete(clientId);
-    this.clientMessageHandlers.delete(clientId);
-    await this.emit("client_disconnected", { clientId, reason });
-  }
-  createClientMessageHandler(clientId) {
-    return async (message) => {
-      try {
-        const client = this.clients.get(clientId);
-        if (!client) {
-          return;
-        }
-        switch (message.type) {
-          case "authenticate":
-            await this.handleAuthenticate(clientId, message.payload);
-            break;
-          case "join_room":
-            await this.handleJoinRoom(clientId, message.payload);
-            break;
-          case "leave_room":
-            await this.handleLeaveRoom(clientId);
-            break;
-          case "broadcast_event":
-            await this.handleBroadcastEvent(clientId, message.payload);
-            break;
-          case "request_lock":
-            await this.handleLockRequest(clientId, message.payload);
-            break;
-          case "release_lock":
-            await this.handleLockRelease(clientId, message.payload);
-            break;
-          case "ping":
-            await this.sendToClient(clientId, { type: "pong", timestamp: Date.now() });
-            break;
-          default:
-            await this.sendToClient(clientId, {
-              type: "error",
-              error: `Unknown message type: ${message.type}`
-            });
-        }
-      } catch (error) {
-        await this.sendToClient(clientId, {
-          type: "error",
-          error: error.message
-        });
-        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" });
-      return;
-    }
-    try {
-      const tokenPayload = await this.auth.validateToken(payload.token);
-      const client = this.clients.get(clientId);
-      if (client) {
-        client.userId = tokenPayload.userId;
-        client.authenticated = true;
-        await this.emit("client_authenticated", { clientId, userId: tokenPayload.userId });
-      }
-      await this.sendToClient(clientId, { type: "auth_result", success: true });
-    } catch (error) {
-      await this.sendToClient(clientId, { type: "auth_result", success: false, error: error.message });
-    }
-  }
-  async handleJoinRoom(clientId, payload) {
-    const client = this.clients.get(clientId);
-    if (!client) {
-      return;
-    }
-    if (payload.token && !client.authenticated) {
-      await this.handleAuthenticate(clientId, { token: payload.token });
-    }
-    if (!client.authenticated) {
-      await this.sendToClient(clientId, { type: "error", error: "Authentication required to join room" });
-      return;
-    }
-    try {
-      if (client.roomId) {
-        await this.roomManager.leaveRoom(client.roomId, client.userId);
-        await this.emit("client_left_room", { clientId, roomId: client.roomId });
-      }
-      let roomState = await this.roomManager.getRoomState(payload.roomId);
-      if (!roomState) {
-        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 });
-      }
-      if (!roomState) {
-        throw new Error("Failed to create or get room state");
-      }
-      const user = {
-        id: client.userId,
-        username: client.userId,
-        status: "online",
-        joinedAt: Date.now(),
-        lastActivity: Date.now(),
-        permissions: roomState.room.permissions || ["read", "write"]
-      };
-      await this.roomManager.joinRoom(payload.roomId, user);
-      client.roomId = payload.roomId;
-      await this.emit("client_joined_room", { clientId, roomId: payload.roomId });
-      await this.sendToClient(clientId, {
-        type: "room_joined",
-        roomId: payload.roomId,
-        state: roomState
-      });
-      const history = await this.roomManager.getEventHistory(payload.roomId, 50);
-      if (history.length > 0) {
-        await this.sendToClient(clientId, {
-          type: "event_history",
-          events: history
-        });
-      }
-    } catch (error) {
-      await this.sendToClient(clientId, { type: "error", error: error.message });
-    }
-  }
-  async handleLeaveRoom(clientId) {
-    const client = this.clients.get(clientId);
-    if (!client || !client.roomId) {
-      return;
-    }
-    const roomId = client.roomId;
-    await this.roomManager.leaveRoom(roomId, client.userId);
-    client.roomId = null;
-    await this.emit("client_left_room", { clientId, roomId });
-    await this.sendToClient(clientId, { type: "room_left", roomId });
-  }
-  async handleBroadcastEvent(clientId, payload) {
-    const client = this.clients.get(clientId);
-    if (!client || client.roomId !== payload.roomId) {
-      await this.sendToClient(clientId, { type: "error", error: "Not in specified room" });
-      return;
-    }
-    const enrichedEvent = {
-      ...payload.event,
-      metadata: {
-        ...payload.event.metadata,
-        userId: client.userId,
-        timestamp: Date.now(),
-        roomId: payload.roomId
-      }
-    };
-    await this.roomManager.addEventToHistory(payload.roomId, enrichedEvent);
-    await this.roomManager.broadcastToRoom(payload.roomId, enrichedEvent, client.userId);
-    await this.emit("event_broadcast", {
-      roomId: payload.roomId,
-      event: enrichedEvent,
-      fromClientId: clientId
-    });
-  }
-  async handleLockRequest(clientId, payload) {
-    const client = this.clients.get(clientId);
-    if (!client || client.roomId !== payload.roomId) {
-      await this.sendToClient(clientId, { type: "error", error: "Not in specified room" });
-      return;
-    }
-    try {
-      const lock = await this.lockManager.acquireLock(client.userId, client.userId, payload.request);
-      await this.emit("lock_acquired", { lock, clientId });
-      await this.sendToClient(clientId, { type: "lock_acquired", lock });
-      await this.roomManager.broadcastToRoom(payload.roomId, {
-        id: this.generateId(),
-        type: "lock_status",
-        timestamp: Date.now(),
-        userId: client.userId,
-        roomId: payload.roomId,
-        data: { lock, action: "acquired" },
-        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 });
-    }
-  }
-  async handleLockRelease(clientId, payload) {
-    const client = this.clients.get(clientId);
-    if (!client) {
-      return;
-    }
-    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 });
-      if (client.roomId) {
-        await this.roomManager.broadcastToRoom(client.roomId, {
-          id: this.generateId(),
-          type: "lock_status",
-          timestamp: Date.now(),
-          userId: client.userId,
-          roomId: client.roomId,
-          data: { lockId: payload.lockId, action: "released" },
-          metadata: { userId: client.userId, timestamp: Date.now(), roomId: client.roomId }
-        });
-      }
-    } catch (error) {
-      await this.sendToClient(clientId, { type: "error", error: error.message });
-    }
-  }
-  async sendToClient(clientId, message) {
-    const transportMessage = {
-      id: this.generateId(),
-      type: "server_message",
-      payload: { clientId, ...message },
-      timestamp: Date.now()
-    };
-    await this.transport.send(transportMessage);
-  }
-  generateId() {
-    return Math.random().toString(36).substring(2) + Date.now().toString(36);
-  }
-  async createRoom(roomId, config) {
-    const room = await this.roomManager.createRoom(roomId, config);
-    await this.emit("room_created", { room });
-    return room;
-  }
-  async deleteRoom(roomId) {
-    await this.roomManager.deleteRoom(roomId);
-    await this.emit("room_deleted", { roomId });
-  }
-  getConnectedClients() {
-    return Array.from(this.clients.values());
-  }
-  getClient(clientId) {
-    return this.clients.get(clientId) || null;
-  }
-  isRunning() {
-    return this.running;
-  }
-}
-// src/server/ServerBuilder.ts
-class ServerBuilder {
-  transport;
-  auth;
-  storage;
-  roomManager;
-  lockManager;
-  defaultRoomConfig;
-  withTransport(transport) {
-    this.transport = transport;
-    return this;
-  }
-  withAuth(auth) {
-    this.auth = auth;
-    return this;
-  }
-  withStorage(storage) {
-    this.storage = storage;
-    return this;
-  }
-  withRoomManager(roomManager) {
-    this.roomManager = roomManager;
-    return this;
-  }
-  withLockManager(lockManager) {
-    this.lockManager = lockManager;
-    return this;
-  }
-  withDefaultRoomConfig(config) {
-    this.defaultRoomConfig = config;
-    return this;
-  }
-  build() {
-    if (!this.transport) {
-      throw new Error("Transport adapter is required");
-    }
-    if (!this.roomManager) {
-      throw new Error("Room manager is required");
-    }
-    if (!this.lockManager) {
-      throw new Error("Lock manager is required");
-    }
-    const config = {
-      transport: this.transport,
-      auth: this.auth,
-      storage: this.storage,
-      roomManager: this.roomManager,
-      lockManager: this.lockManager,
-      defaultRoomConfig: this.defaultRoomConfig || {
-        maxUsers: 50,
-        maxHistory: 100,
-        permissions: ["read", "write"]
-      }
-    };
-    return new BaseServer(config);
-  }
-}
-
-//# debugId=3AB78025BA51886B64756E2164756E21
+// Abstractions
+export { TypedEventEmitter, RoomManager, LockManager, DefaultRoomManager, DefaultLockManager } from './abstractions';
+// Adapters
+export { MockTransportAdapter, MockStorageAdapter, MockAuthAdapter } from './adapters/mock';
+export { WebSocketTransportAdapter } from './adapters/websocket';
+// Client
+export { BaseClient, ClientBuilder } from './client';
+// Server
+export { BaseServer, ServerBuilder } from './server';