dialogue-ts 0.0.1

package/dist/src/index.js

@@ -0,0 +1,1389 @@
+// src/create-dialogue.ts
+import { Hono } from "hono";
+import { Err as Err3 } from "slang-ts";
+
+// src/history.ts
+function createHistoryManager(config = {}) {
+  const store = /* @__PURE__ */ new Map();
+  function ensureRoomEvent(roomId, eventName) {
+    let roomHistory = store.get(roomId);
+    if (!roomHistory) {
+      roomHistory = /* @__PURE__ */ new Map();
+      store.set(roomId, roomHistory);
+    }
+    let eventHistory = roomHistory.get(eventName);
+    if (!eventHistory) {
+      eventHistory = [];
+      roomHistory.set(eventName, eventHistory);
+    }
+    return eventHistory;
+  }
+  return {
+    push(roomId, eventName, event, limit) {
+      const events = ensureRoomEvent(roomId, eventName);
+      events.push(event);
+      if (events.length > limit) {
+        const evictCount = events.length - limit;
+        const evicted = events.splice(0, evictCount);
+        if (config.onCleanup && evicted.length > 0) {
+          config.onCleanup(roomId, eventName, evicted);
+        }
+      }
+    },
+    get(roomId, eventName, start, end) {
+      const roomHistory = store.get(roomId);
+      if (!roomHistory) {
+        return [];
+      }
+      const events = roomHistory.get(eventName);
+      if (!events || events.length === 0) {
+        return [];
+      }
+      const len = events.length;
+      const actualStart = Math.max(0, len - end);
+      const actualEnd = len - start;
+      if (actualStart >= actualEnd) {
+        return [];
+      }
+      return events.slice(actualStart, actualEnd).reverse();
+    },
+    getAll(roomId, limit) {
+      const roomHistory = store.get(roomId);
+      if (!roomHistory) {
+        return [];
+      }
+      const allEvents = [];
+      for (const events of roomHistory.values()) {
+        allEvents.push(...events);
+      }
+      allEvents.sort((a, b) => b.timestamp - a.timestamp);
+      if (limit !== void 0 && limit > 0) {
+        return allEvents.slice(0, limit);
+      }
+      return allEvents;
+    },
+    count(roomId, eventName) {
+      const roomHistory = store.get(roomId);
+      if (!roomHistory) {
+        return 0;
+      }
+      const events = roomHistory.get(eventName);
+      return events?.length ?? 0;
+    },
+    clearRoom(roomId) {
+      const roomHistory = store.get(roomId);
+      if (!roomHistory) {
+        return;
+      }
+      if (config.onCleanup) {
+        for (const [eventName, events] of roomHistory.entries()) {
+          if (events.length > 0) {
+            config.onCleanup(roomId, eventName, events);
+          }
+        }
+      }
+      store.delete(roomId);
+    },
+    getEventNames(roomId) {
+      const roomHistory = store.get(roomId);
+      if (!roomHistory) {
+        return [];
+      }
+      return Array.from(roomHistory.keys());
+    }
+  };
+}
+
+// src/logger.ts
+function createDefaultLogger() {
+  return {
+    debug(entry) {
+      if (process.env.NODE_ENV === "development" || process.env.DEBUG) {
+        console.debug("[Dialogue] [DEBUG]", entry);
+      }
+    },
+    info(entry) {
+      console.info("[Dialogue] [INFO]", entry);
+    },
+    warn(entry) {
+      console.warn("[Dialogue] [WARN]", entry);
+    },
+    error(entry) {
+      console.error("[Dialogue] [ERROR]", entry);
+    }
+  };
+}
+function createSilentLogger() {
+  const noop = () => {
+  };
+  return {
+    debug: noop,
+    info: noop,
+    warn: noop,
+    error: noop
+  };
+}
+
+// src/server.ts
+import { Server as BunEngine } from "@socket.io/bun-engine";
+import { cors as honoCors } from "hono/cors";
+import { Server } from "socket.io";
+
+// src/client-handler.ts
+import { nanoid } from "nanoid";
+var WILDCARD = "*";
+function createConnectedClient(socket, userId, meta, roomManager, logger) {
+  const id = nanoid();
+  const joinedRooms = /* @__PURE__ */ new Set();
+  const subscriptions = /* @__PURE__ */ new Map();
+  const client = {
+    id,
+    userId,
+    socket,
+    meta,
+    join(roomId) {
+      const room = roomManager.get(roomId);
+      if (!room) {
+        logger.warn({
+          message: `Room '${roomId}' does not exist`,
+          atFunction: "client.join",
+          data: { roomId, clientId: id }
+        });
+        return;
+      }
+      if (joinedRooms.has(roomId)) {
+        socket.emit("dialogue:joined", { roomId, roomName: room.name });
+        return;
+      }
+      const added = roomManager.addParticipant(roomId, client);
+      if (!added) {
+        logger.warn({
+          message: `Room '${roomId}' is full`,
+          atFunction: "client.join",
+          data: { roomId, clientId: id }
+        });
+        socket.emit("dialogue:error", {
+          code: "ROOM_FULL",
+          message: `Room '${roomId}' is at capacity`
+        });
+        return;
+      }
+      joinedRooms.add(roomId);
+      subscriptions.set(roomId, /* @__PURE__ */ new Set());
+      for (const eventName of room.defaultSubscriptions) {
+        this.subscribe(roomId, eventName);
+      }
+      socket.emit("dialogue:joined", { roomId, roomName: room.name });
+    },
+    leave(roomId) {
+      if (!joinedRooms.has(roomId)) {
+        return;
+      }
+      roomManager.removeParticipant(roomId, id);
+      joinedRooms.delete(roomId);
+      subscriptions.delete(roomId);
+      socket.emit("dialogue:left", { roomId });
+    },
+    subscribe(roomId, eventName) {
+      if (!joinedRooms.has(roomId)) {
+        logger.warn({
+          message: `Cannot subscribe to '${eventName}' - not in room '${roomId}'`,
+          atFunction: "client.subscribe",
+          data: { roomId, eventName, clientId: id }
+        });
+        return;
+      }
+      const roomSubs = subscriptions.get(roomId);
+      if (roomSubs) {
+        roomSubs.add(eventName);
+      }
+    },
+    subscribeAll(roomId) {
+      this.subscribe(roomId, WILDCARD);
+    },
+    unsubscribe(roomId, eventName) {
+      const roomSubs = subscriptions.get(roomId);
+      if (roomSubs) {
+        roomSubs.delete(eventName);
+      }
+    },
+    rooms() {
+      return Array.from(joinedRooms);
+    },
+    subscriptions(roomId) {
+      const roomSubs = subscriptions.get(roomId);
+      return roomSubs ? Array.from(roomSubs) : [];
+    },
+    send(event, data) {
+      socket.emit(event, data);
+    },
+    disconnect() {
+      for (const roomId of joinedRooms) {
+        roomManager.removeParticipant(roomId, id);
+      }
+      joinedRooms.clear();
+      subscriptions.clear();
+      socket.disconnect(true);
+    }
+  };
+  return client;
+}
+function extractUserFromSocket(socket) {
+  const auth = socket.handshake.auth;
+  let userId = socket.id;
+  if (typeof auth.userId === "string") {
+    userId = auth.userId;
+  } else if (typeof auth.token === "string") {
+    userId = auth.token;
+  }
+  const meta = {};
+  if (typeof auth.role === "string") {
+    meta.role = auth.role;
+  }
+  for (const [key, value] of Object.entries(auth)) {
+    if (key !== "userId" && key !== "token") {
+      meta[key] = value;
+    }
+  }
+  return { userId, meta };
+}
+
+// src/rate-limiter.ts
+function createRateLimiter(config) {
+  const entries = /* @__PURE__ */ new Map();
+  const cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of entries) {
+      if (now >= entry.resetAt) {
+        entries.delete(key);
+      }
+    }
+  }, config.windowMs);
+  cleanupInterval.unref?.();
+  return {
+    isAllowed(key) {
+      const now = Date.now();
+      const entry = entries.get(key);
+      if (!entry || now >= entry.resetAt) {
+        entries.set(key, {
+          count: 1,
+          resetAt: now + config.windowMs
+        });
+        return true;
+      }
+      if (entry.count >= config.maxRequests) {
+        return false;
+      }
+      entry.count++;
+      return true;
+    },
+    remaining(key) {
+      const now = Date.now();
+      const entry = entries.get(key);
+      if (!entry || now >= entry.resetAt) {
+        return config.maxRequests;
+      }
+      return Math.max(0, config.maxRequests - entry.count);
+    },
+    clear() {
+      entries.clear();
+    }
+  };
+}
+
+// src/room.ts
+import { Err as Err2, Ok as Ok2 } from "slang-ts";
+
+// src/define-event.ts
+import { Err, Ok } from "slang-ts";
+function defineEvent(name, options) {
+  const definition = {
+    name,
+    description: options?.description,
+    schema: options?.schema,
+    history: options?.history
+  };
+  return Object.freeze(definition);
+}
+function validateEventData(event, data) {
+  if (!event.schema) {
+    return Ok(data);
+  }
+  const result = event.schema.safeParse(data);
+  if (result.success) {
+    return Ok(result.data);
+  }
+  const errorMessages = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+  return Err(`Event '${event.name}' validation failed: ${errorMessages}`);
+}
+function isEventAllowed(eventName, allowedEvents) {
+  if (allowedEvents.length === 0) {
+    return false;
+  }
+  return allowedEvents.some((e) => e.name === "*" || e.name === eventName);
+}
+function getEventByName(eventName, events) {
+  return events.find((e) => e.name === eventName);
+}
+
+// src/room.ts
+var WILDCARD2 = "*";
+function isParticipantSubscribed(participant, roomId, eventName) {
+  const subs = participant.subscriptions(roomId);
+  return subs.includes(eventName) || subs.includes(WILDCARD2);
+}
+function createRoom(id, config, _io, logger, historyManager, hooks, externalParticipants, getContext) {
+  const participants = externalParticipants ?? /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Map();
+  function handlePostBroadcast(eventName, message) {
+    const eventDef = getEventByName(eventName, config.events);
+    if (eventDef?.history?.enabled && historyManager) {
+      historyManager.push(id, eventName, message, eventDef.history.limit);
+    }
+    if (hooks?.events?.onTriggered) {
+      Promise.resolve(hooks.events.onTriggered(id, message)).catch((err) => {
+        logger.error({
+          message: `Error in onTriggered hook for '${eventName}'`,
+          atFunction: "room.trigger.onTriggered",
+          data: err
+        });
+      });
+    }
+    const handlers = eventHandlers.get(eventName);
+    if (handlers) {
+      for (const handler of handlers) {
+        Promise.resolve(handler(message)).catch((err) => {
+          logger.error({
+            message: `Error in event handler for '${eventName}'`,
+            atFunction: "room.trigger.handler",
+            data: err
+          });
+        });
+      }
+    }
+  }
+  const room = {
+    id,
+    name: config.name,
+    description: config.description,
+    maxSize: config.maxSize,
+    events: config.events,
+    defaultSubscriptions: config.defaultSubscriptions ?? [],
+    createdById: config.createdById,
+    trigger(event, data, from, meta) {
+      if (!isEventAllowed(event.name, config.events)) {
+        const errorMsg = `Event '${event.name}' is not allowed in room '${id}'`;
+        logger.warn({
+          message: errorMsg,
+          atFunction: "room.trigger",
+          data: { eventName: event.name, roomId: id }
+        });
+        return Err2(errorMsg);
+      }
+      const eventDef = getEventByName(event.name, config.events) ?? event;
+      const validation = validateEventData(eventDef, data);
+      if (validation.isErr) {
+        logger.warn({
+          message: validation.error,
+          atFunction: "room.trigger",
+          data: {
+            eventName: event.name,
+            roomId: id,
+            validationError: validation.error
+          }
+        });
+        return Err2(validation.error);
+      }
+      const message = {
+        event: event.name,
+        roomId: id,
+        data: validation.value,
+        from: from ?? "system",
+        timestamp: Date.now(),
+        ...meta && { meta }
+      };
+      let finalMessage = message;
+      if (hooks?.events?.beforeEach && getContext) {
+        const context = getContext();
+        const hookResult = hooks.events.beforeEach({
+          context,
+          roomId: id,
+          message,
+          from: message.from
+        });
+        if (hookResult.isErr) {
+          logger.debug({
+            message: `Event '${event.name}' blocked by beforeEach: ${hookResult.error}`,
+            atFunction: "room.trigger.beforeEach",
+            data: {
+              eventName: event.name,
+              roomId: id,
+              reason: hookResult.error
+            }
+          });
+          return Err2(hookResult.error);
+        }
+        finalMessage = hookResult.value;
+      }
+      let recipientCount = 0;
+      for (const [, participant] of participants) {
+        if (isParticipantSubscribed(participant, id, event.name)) {
+          participant.socket.emit("dialogue:event", finalMessage);
+          recipientCount++;
+        }
+      }
+      handlePostBroadcast(event.name, finalMessage);
+      if (hooks?.events?.afterEach && getContext) {
+        const context = getContext();
+        hooks.events.afterEach({
+          context,
+          roomId: id,
+          message: finalMessage,
+          recipientCount
+        });
+      }
+      return Ok2(void 0);
+    },
+    on(event, handler) {
+      let handlers = eventHandlers.get(event.name);
+      if (!handlers) {
+        handlers = /* @__PURE__ */ new Set();
+        eventHandlers.set(event.name, handlers);
+      }
+      handlers.add(handler);
+      return () => {
+        handlers?.delete(handler);
+        if (handlers?.size === 0) {
+          eventHandlers.delete(event.name);
+        }
+      };
+    },
+    size() {
+      return participants.size;
+    },
+    isFull() {
+      if (config.maxSize === void 0) {
+        return false;
+      }
+      return participants.size >= config.maxSize;
+    },
+    participants() {
+      return Array.from(participants.values());
+    },
+    async history(eventName, start, end) {
+      if (!historyManager) {
+        return [];
+      }
+      const inMemoryEvents = historyManager.get(id, eventName, start, end);
+      const inMemoryCount = historyManager.count(id, eventName);
+      if (inMemoryEvents.length >= end - start || !hooks?.events?.onLoad) {
+        return inMemoryEvents;
+      }
+      const missingStart = Math.max(start, inMemoryCount);
+      const missingEnd = end;
+      if (missingStart >= missingEnd) {
+        return inMemoryEvents;
+      }
+      try {
+        const externalEvents = await hooks.events.onLoad(
+          id,
+          eventName,
+          missingStart - inMemoryCount,
+          missingEnd - inMemoryCount
+        );
+        return [...inMemoryEvents, ...externalEvents];
+      } catch (err) {
+        logger.error({
+          message: `Error loading history for '${eventName}'`,
+          atFunction: "room.history.onLoad",
+          data: err
+        });
+        return inMemoryEvents;
+      }
+    }
+  };
+  return room;
+}
+function addParticipantToRoom(room, client, participants) {
+  if (room.maxSize !== void 0 && participants.size >= room.maxSize) {
+    return false;
+  }
+  participants.set(client.id, client);
+  client.socket.join(room.id);
+  return true;
+}
+function removeParticipantFromRoom(room, clientId, participants) {
+  const client = participants.get(clientId);
+  if (client) {
+    client.socket.leave(room.id);
+    participants.delete(clientId);
+  }
+}
+function createRoomManager(io, logger, historyManager, hooks, getContext) {
+  const rooms = /* @__PURE__ */ new Map();
+  const roomParticipants = /* @__PURE__ */ new Map();
+  return {
+    /**
+     * Registers a room from config
+     */
+    register(id, config) {
+      const participantsMap = /* @__PURE__ */ new Map();
+      roomParticipants.set(id, participantsMap);
+      const room = createRoom(
+        id,
+        config,
+        io,
+        logger,
+        historyManager,
+        hooks,
+        participantsMap,
+        getContext
+      );
+      rooms.set(id, room);
+      if (hooks?.rooms?.onCreated) {
+        Promise.resolve(hooks.rooms.onCreated(room)).catch((err) => {
+          logger.error({
+            message: `Error in onCreated hook for room '${id}'`,
+            atFunction: "roomManager.register.onCreated",
+            data: err
+          });
+        });
+      }
+      return room;
+    },
+    /**
+     * Gets a room by ID
+     */
+    get(id) {
+      return rooms.get(id) ?? null;
+    },
+    /**
+     * Gets all rooms
+     */
+    all() {
+      return Array.from(rooms.values());
+    },
+    /**
+     * Adds a participant to a room
+     */
+    addParticipant(roomId, client) {
+      const room = rooms.get(roomId);
+      const participants = roomParticipants.get(roomId);
+      if (!(room && participants)) {
+        return false;
+      }
+      return addParticipantToRoom(room, client, participants);
+    },
+    /**
+     * Removes a participant from a room
+     */
+    removeParticipant(roomId, clientId) {
+      const room = rooms.get(roomId);
+      const participants = roomParticipants.get(roomId);
+      if (room && participants) {
+        removeParticipantFromRoom(room, clientId, participants);
+      }
+    },
+    /**
+     * Removes a client from all rooms
+     */
+    removeFromAllRooms(clientId) {
+      for (const [roomId] of rooms) {
+        this.removeParticipant(roomId, clientId);
+      }
+    },
+    /**
+     * Gets participants for a room
+     */
+    getParticipants(roomId) {
+      const participants = roomParticipants.get(roomId);
+      return participants ? Array.from(participants.values()) : [];
+    },
+    /**
+     * Gets room size
+     */
+    getRoomSize(roomId) {
+      return roomParticipants.get(roomId)?.size ?? 0;
+    },
+    /**
+     * Unregisters (deletes) a room by ID.
+     * Removes all participants and cleans up resources.
+     * @returns true if room was deleted, false if it didn't exist
+     */
+    unregister(id) {
+      const room = rooms.get(id);
+      if (!room) {
+        return false;
+      }
+      const participants = roomParticipants.get(id);
+      if (participants) {
+        for (const client of participants.values()) {
+          client.socket.leave(id);
+        }
+        participants.clear();
+      }
+      if (historyManager) {
+        historyManager.clearRoom(id);
+      }
+      io.to(id).emit("dialogue:roomDeleted", { roomId: id });
+      rooms.delete(id);
+      roomParticipants.delete(id);
+      logger.info({
+        message: `Room '${id}' deleted`,
+        atFunction: "roomManager.unregister",
+        data: { roomId: id }
+      });
+      if (hooks?.rooms?.onDeleted) {
+        Promise.resolve(hooks.rooms.onDeleted(id)).catch((err) => {
+          logger.error({
+            message: `Error in onDeleted hook for room '${id}'`,
+            atFunction: "roomManager.unregister.onDeleted",
+            data: err
+          });
+        });
+      }
+      return true;
+    }
+  };
+}
+
+// src/server.ts
+function buildCorsOptions(cors) {
+  if (cors === void 0 || cors === true) {
+    return {
+      origin: true,
+      methods: ["GET", "POST"],
+      credentials: true
+    };
+  }
+  if (cors === false) {
+    return { origin: false };
+  }
+  return {
+    origin: cors.origin,
+    methods: cors.methods ?? ["GET", "POST"],
+    credentials: cors.credentials ?? true
+  };
+}
+function buildHonoCorsOptions(cors) {
+  if (cors === void 0 || cors === true) {
+    return {
+      origin: "*",
+      allowMethods: ["GET", "POST", "OPTIONS"],
+      credentials: true
+    };
+  }
+  if (cors === false) {
+    return {
+      origin: () => void 0,
+      allowMethods: ["GET", "POST"],
+      credentials: false
+    };
+  }
+  const originValue = cors.origin;
+  let resolvedOrigin;
+  if (originValue === true) {
+    resolvedOrigin = "*";
+  } else if (originValue === false) {
+    resolvedOrigin = () => void 0;
+  } else {
+    resolvedOrigin = originValue;
+  }
+  return {
+    origin: resolvedOrigin,
+    allowMethods: cors.methods ?? ["GET", "POST", "OPTIONS"],
+    credentials: cors.credentials ?? true
+  };
+}
+function addCorsHeaders(response, request, corsConfig) {
+  const origin = request.headers.get("Origin");
+  if (!origin) {
+    return response;
+  }
+  const headers = new Headers(response.headers);
+  if (corsConfig === void 0 || corsConfig === true) {
+    headers.set("Access-Control-Allow-Origin", origin);
+    headers.set("Access-Control-Allow-Credentials", "true");
+  } else if (corsConfig === false) {
+    return response;
+  } else {
+    const allowedOrigin = corsConfig.origin;
+    if (allowedOrigin === true) {
+      headers.set("Access-Control-Allow-Origin", origin);
+    } else if (typeof allowedOrigin === "string" && allowedOrigin === origin) {
+      headers.set("Access-Control-Allow-Origin", origin);
+    } else if (Array.isArray(allowedOrigin) && allowedOrigin.includes(origin)) {
+      headers.set("Access-Control-Allow-Origin", origin);
+    }
+    if (corsConfig.credentials !== false) {
+      headers.set("Access-Control-Allow-Credentials", "true");
+    }
+  }
+  headers.set("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  headers.set("Access-Control-Allow-Headers", "Content-Type");
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function sendHistoryOnJoin(socket, roomId, roomConfig, historyManager) {
+  if (!(roomConfig?.syncHistoryOnJoin && historyManager)) {
+    return;
+  }
+  const limit = typeof roomConfig.syncHistoryOnJoin === "number" ? roomConfig.syncHistoryOnJoin : void 0;
+  const historyEvents = historyManager.getAll(roomId, limit);
+  if (historyEvents.length > 0) {
+    socket.emit("dialogue:history", {
+      roomId,
+      events: historyEvents
+    });
+  }
+}
+function createDialogueContext(io, connectedClients, roomManager) {
+  const clientsRecord = {};
+  for (const [id, client] of connectedClients.entries()) {
+    clientsRecord[id] = client;
+  }
+  const roomsRecord = {};
+  for (const room of roomManager.all()) {
+    roomsRecord[room.id] = room;
+  }
+  return {
+    io,
+    clients: clientsRecord,
+    rooms: roomsRecord
+  };
+}
+function setupServer(app, config, historyManager) {
+  const logger = config.logger ?? createDefaultLogger();
+  const hooks = config.hooks;
+  const connectedClients = /* @__PURE__ */ new Map();
+  const userIdToSocketIds = /* @__PURE__ */ new Map();
+  const corsOptions = buildCorsOptions(config.cors);
+  const honoCorsOptions = buildHonoCorsOptions(config.cors);
+  app.use("*", honoCors(honoCorsOptions));
+  const io = new Server({ cors: corsOptions });
+  const engine = new BunEngine();
+  io.bind(engine);
+  const getContextForHooks = () => {
+    return createDialogueContext(io, connectedClients, roomManager);
+  };
+  const roomManager = createRoomManager(
+    io,
+    logger,
+    historyManager,
+    hooks,
+    getContextForHooks
+  );
+  const historyRateLimiter = createRateLimiter({
+    maxRequests: 20,
+    windowMs: 6e4
+  });
+  for (const [roomId, roomConfig] of Object.entries(config.rooms)) {
+    roomManager.register(roomId, roomConfig);
+  }
+  if (hooks?.socket?.authenticate) {
+    const authenticateHook = hooks.socket.authenticate;
+    io.use(async (socket, next) => {
+      const authData = socket.handshake.auth;
+      const context = createDialogueContext(io, connectedClients, roomManager);
+      try {
+        const result = await Promise.resolve(
+          authenticateHook({
+            context,
+            clientSocket: socket,
+            authData
+          })
+        );
+        if (result.isErr) {
+          logger.warn({
+            message: `Authentication rejected: ${result.error}`,
+            atFunction: "setupServer.authenticate",
+            data: { socketId: socket.id }
+          });
+          return next(new Error(result.error));
+        }
+        socket.data = {
+          ...socket.data,
+          authenticatedAuthData: result.value
+        };
+        return next();
+      } catch (err) {
+        logger.error({
+          message: "Error in authenticate hook",
+          atFunction: "setupServer.authenticate",
+          data: err
+        });
+        return next(new Error("Authentication failed"));
+      }
+    });
+  }
+  io.on("connection", (socket) => {
+    let userId;
+    let meta;
+    let authData;
+    if (socket.data?.authenticatedAuthData) {
+      authData = socket.data.authenticatedAuthData;
+      userId = authData.jwt.sub;
+      meta = {};
+    } else {
+      const extracted = extractUserFromSocket(socket);
+      userId = extracted.userId;
+      meta = extracted.meta;
+    }
+    const client = createConnectedClient(
+      socket,
+      userId,
+      meta,
+      roomManager,
+      logger
+    );
+    if (authData) {
+      client.auth = authData;
+    }
+    connectedClients.set(socket.id, client);
+    const userSockets = userIdToSocketIds.get(client.userId) ?? /* @__PURE__ */ new Set();
+    userSockets.add(socket.id);
+    userIdToSocketIds.set(client.userId, userSockets);
+    socket.emit("dialogue:connected", {
+      clientId: client.id,
+      userId: client.userId
+    });
+    if (hooks?.clients?.onConnected) {
+      Promise.resolve(hooks.clients.onConnected(client)).catch((err) => {
+        logger.error({
+          message: "Error in onConnected hook",
+          atFunction: "setupServer.onConnected",
+          data: err
+        });
+      });
+    }
+    socket.on("dialogue:join", (data) => {
+      if (typeof data?.roomId !== "string") {
+        return;
+      }
+      const room = roomManager.get(data.roomId);
+      if (!room) {
+        socket.emit("dialogue:error", {
+          code: "ROOM_NOT_FOUND",
+          message: `Room '${data.roomId}' does not exist`
+        });
+        return;
+      }
+      if (hooks?.clients?.beforeJoin) {
+        const context = createDialogueContext(
+          io,
+          connectedClients,
+          roomManager
+        );
+        const joinResult = hooks.clients.beforeJoin({
+          context,
+          client,
+          roomId: data.roomId,
+          room
+        });
+        if (joinResult.isErr) {
+          logger.warn({
+            message: `Join denied for room '${data.roomId}': ${joinResult.error}`,
+            atFunction: "setupServer.beforeJoin",
+            data: {
+              roomId: data.roomId,
+              clientId: client.id,
+              reason: joinResult.error
+            }
+          });
+          socket.emit("dialogue:error", {
+            code: "JOIN_DENIED",
+            message: joinResult.error
+          });
+          return;
+        }
+      }
+      client.join(data.roomId);
+      if (hooks?.clients?.onJoined) {
+        Promise.resolve(hooks.clients.onJoined(client, data.roomId)).catch(
+          (err) => {
+            logger.error({
+              message: "Error in onJoined hook",
+              atFunction: "setupServer.onJoined",
+              data: err
+            });
+          }
+        );
+      }
+      sendHistoryOnJoin(
+        socket,
+        data.roomId,
+        config.rooms[data.roomId],
+        historyManager
+      );
+    });
+    socket.on("dialogue:leave", (data) => {
+      if (typeof data?.roomId === "string") {
+        client.leave(data.roomId);
+        if (hooks?.clients?.onLeft) {
+          Promise.resolve(hooks.clients.onLeft(client, data.roomId)).catch(
+            (err) => {
+              logger.error({
+                message: "Error in onLeft hook",
+                atFunction: "setupServer.onLeft",
+                data: err
+              });
+            }
+          );
+        }
+      }
+    });
+    socket.on(
+      "dialogue:subscribe",
+      (data) => {
+        if (typeof data?.roomId === "string" && typeof data?.eventName === "string") {
+          client.subscribe(data.roomId, data.eventName);
+        }
+      }
+    );
+    socket.on("dialogue:subscribeAll", (data) => {
+      if (typeof data?.roomId === "string") {
+        client.subscribeAll(data.roomId);
+      }
+    });
+    socket.on(
+      "dialogue:unsubscribe",
+      (data) => {
+        if (typeof data?.roomId === "string" && typeof data?.eventName === "string") {
+          client.unsubscribe(data.roomId, data.eventName);
+        }
+      }
+    );
+    socket.on(
+      "dialogue:getHistory",
+      async (data) => {
+        if (!historyRateLimiter.isAllowed(socket.id)) {
+          socket.emit("dialogue:error", {
+            code: "RATE_LIMITED",
+            message: "Too many history requests. Please wait before trying again."
+          });
+          return;
+        }
+        if (typeof data?.roomId !== "string") {
+          socket.emit("dialogue:error", {
+            code: "INVALID_REQUEST",
+            message: "roomId is required"
+          });
+          return;
+        }
+        const room = roomManager.get(data.roomId);
+        if (!room) {
+          socket.emit("dialogue:error", {
+            code: "ROOM_NOT_FOUND",
+            message: `Room '${data.roomId}' does not exist`
+          });
+          return;
+        }
+        const start = data.start ?? 0;
+        const end = data.end ?? 50;
+        if (!data.eventName) {
+          socket.emit("dialogue:historyResponse", {
+            roomId: data.roomId,
+            eventName: null,
+            events: [],
+            start,
+            end
+          });
+          return;
+        }
+        const events = await room.history(data.eventName, start, end);
+        socket.emit("dialogue:historyResponse", {
+          roomId: data.roomId,
+          eventName: data.eventName,
+          events,
+          start,
+          end
+        });
+      }
+    );
+    socket.on(
+      "dialogue:trigger",
+      (data) => {
+        if (typeof data?.roomId !== "string" || typeof data?.event !== "string") {
+          return;
+        }
+        const room = roomManager.get(data.roomId);
+        if (!room) {
+          socket.emit("dialogue:error", {
+            code: "ROOM_NOT_FOUND",
+            message: `Room '${data.roomId}' does not exist`
+          });
+          return;
+        }
+        const eventDef = room.events.find((e) => e.name === data.event);
+        const hasWildcard = room.events.some((e) => e.name === "*");
+        if (!(eventDef || hasWildcard)) {
+          socket.emit("dialogue:error", {
+            code: "EVENT_NOT_ALLOWED",
+            message: `Event '${data.event}' is not allowed in room '${data.roomId}'`
+          });
+          return;
+        }
+        const triggerEvent = eventDef ?? { name: data.event };
+        const result = room.trigger(
+          triggerEvent,
+          data.data,
+          client.userId,
+          data.meta
+        );
+        if (result.isErr) {
+          socket.emit("dialogue:error", {
+            code: "VALIDATION_FAILED",
+            message: result.error
+          });
+        }
+      }
+    );
+    socket.on("dialogue:listRooms", () => {
+      const rooms = roomManager.all().map((room) => ({
+        id: room.id,
+        name: room.name,
+        description: room.description,
+        size: roomManager.getRoomSize(room.id),
+        maxSize: room.maxSize
+      }));
+      socket.emit("dialogue:rooms", rooms);
+    });
+    socket.on(
+      "dialogue:createRoom",
+      (data) => {
+        if (typeof data?.id !== "string" || typeof data?.name !== "string") {
+          socket.emit("dialogue:error", {
+            code: "INVALID_REQUEST",
+            message: "Room id and name are required"
+          });
+          return;
+        }
+        if (roomManager.get(data.id)) {
+          socket.emit("dialogue:error", {
+            code: "ROOM_EXISTS",
+            message: `Room '${data.id}' already exists`
+          });
+          return;
+        }
+        const room = roomManager.register(data.id, {
+          name: data.name,
+          description: data.description,
+          maxSize: data.maxSize,
+          events: [],
+          createdById: client.userId
+        });
+        socket.emit("dialogue:roomCreated", {
+          id: room.id,
+          name: room.name,
+          description: room.description,
+          maxSize: room.maxSize,
+          createdById: room.createdById
+        });
+        socket.broadcast.emit("dialogue:roomCreated", {
+          id: room.id,
+          name: room.name,
+          description: room.description,
+          maxSize: room.maxSize,
+          createdById: room.createdById
+        });
+        logger.info({
+          message: `Room '${data.id}' created by ${client.userId}`,
+          atFunction: "setupServer.createRoom",
+          data: { roomId: data.id, createdBy: client.userId }
+        });
+      }
+    );
+    socket.on("dialogue:deleteRoom", (data) => {
+      if (typeof data?.roomId !== "string") {
+        return;
+      }
+      const room = roomManager.get(data.roomId);
+      if (!room) {
+        socket.emit("dialogue:error", {
+          code: "ROOM_NOT_FOUND",
+          message: `Room '${data.roomId}' does not exist`
+        });
+        return;
+      }
+      if (room.createdById && room.createdById !== client.userId) {
+        socket.emit("dialogue:error", {
+          code: "PERMISSION_DENIED",
+          message: "Only the room creator can delete this room"
+        });
+        return;
+      }
+      const deleted = roomManager.unregister(data.roomId);
+      if (deleted) {
+        io.emit("dialogue:roomDeleted", { roomId: data.roomId });
+        logger.info({
+          message: `Room '${data.roomId}' deleted by ${client.userId}`,
+          atFunction: "setupServer.deleteRoom",
+          data: { roomId: data.roomId, deletedBy: client.userId }
+        });
+      }
+    });
+    socket.on("disconnect", () => {
+      if (hooks?.clients?.onDisconnected) {
+        Promise.resolve(hooks.clients.onDisconnected(client)).catch((err) => {
+          logger.error({
+            message: "Error in onDisconnected hook",
+            atFunction: "setupServer.onDisconnected",
+            data: err
+          });
+        });
+      }
+      roomManager.removeFromAllRooms(client.id);
+      connectedClients.delete(socket.id);
+      const userSockets2 = userIdToSocketIds.get(client.userId);
+      if (userSockets2) {
+        userSockets2.delete(socket.id);
+        if (userSockets2.size === 0) {
+          userIdToSocketIds.delete(client.userId);
+        }
+      }
+    });
+  });
+  const { websocket } = engine.handler();
+  const port = config.port ?? 3e3;
+  let bunServer = null;
+  return {
+    io,
+    engine,
+    roomManager,
+    start() {
+      bunServer = Bun.serve({
+        port,
+        idleTimeout: 30,
+        async fetch(req, server) {
+          const url = new URL(req.url);
+          if (url.pathname.startsWith("/socket.io")) {
+            if (req.method === "OPTIONS") {
+              return addCorsHeaders(
+                new Response(null, { status: 204 }),
+                req,
+                config.cors
+              );
+            }
+            const response = await engine.handleRequest(req, server);
+            return addCorsHeaders(response, req, config.cors);
+          }
+          return app.fetch(req);
+        },
+        websocket
+      });
+      logger.info({
+        message: `Server running on http://localhost:${port}`,
+        atFunction: "setupServer.start",
+        data: { port }
+      });
+      return Promise.resolve();
+    },
+    stop() {
+      if (bunServer) {
+        bunServer.stop();
+        bunServer = null;
+      }
+      for (const client of connectedClients.values()) {
+        client.disconnect();
+      }
+      connectedClients.clear();
+      userIdToSocketIds.clear();
+      io.close();
+      logger.info({
+        message: "Server stopped",
+        atFunction: "setupServer.stop",
+        data: null
+      });
+      return Promise.resolve();
+    },
+    /**
+     * Gets a connected client by socket ID
+     */
+    getConnectedClient(socketId) {
+      return connectedClients.get(socketId);
+    },
+    /**
+     * Gets all connected clients
+     */
+    getAllConnectedClients() {
+      return Array.from(connectedClients.values());
+    },
+    /**
+     * Gets all connected clients for a specific user ID.
+     * Returns array since a user may have multiple connections.
+     */
+    getClientsByUserId(userId) {
+      const socketIds = userIdToSocketIds.get(userId);
+      if (!socketIds) {
+        return [];
+      }
+      const clients = [];
+      for (const socketId of socketIds) {
+        const client = connectedClients.get(socketId);
+        if (client) {
+          clients.push(client);
+        }
+      }
+      return clients;
+    },
+    /**
+     * Gets all room IDs that a user is currently in.
+     * Aggregates rooms across all connections for this user.
+     */
+    getClientRooms(userId) {
+      const clients = this.getClientsByUserId(userId);
+      const roomSet = /* @__PURE__ */ new Set();
+      for (const client of clients) {
+        for (const roomId of client.rooms()) {
+          roomSet.add(roomId);
+        }
+      }
+      return Array.from(roomSet);
+    },
+    /**
+     * Checks if a user is in a specific room (any of their connections)
+     */
+    isUserInRoom(userId, roomId) {
+      const clients = this.getClientsByUserId(userId);
+      return clients.some((client) => client.rooms().includes(roomId));
+    }
+  };
+}
+
+// src/create-dialogue.ts
+function createDialogue(config) {
+  const app = config.app ?? new Hono();
+  const logger = config.logger ?? createDefaultLogger();
+  const historyManager = createHistoryManager({
+    onCleanup: config.hooks?.events?.onCleanup,
+    onLoad: config.hooks?.events?.onLoad
+  });
+  const {
+    io,
+    roomManager,
+    start,
+    stop,
+    getConnectedClient: _getConnectedClient,
+    getAllConnectedClients,
+    getClientsByUserId,
+    getClientRooms: getClientRoomIds,
+    isUserInRoom
+  } = setupServer(app, config, historyManager);
+  const dialogue = {
+    app,
+    io,
+    trigger(roomId, event, data, from, meta) {
+      const room = roomManager.get(roomId);
+      if (!room) {
+        const errorMsg = `Room '${roomId}' does not exist`;
+        logger.warn({
+          message: errorMsg,
+          atFunction: "dialogue.trigger",
+          data: { roomId, eventName: event.name }
+        });
+        return Err3(errorMsg);
+      }
+      return room.trigger(event, data, from, meta);
+    },
+    on(roomId, event, handler) {
+      const room = roomManager.get(roomId);
+      if (!room) {
+        logger.warn({
+          message: `Room '${roomId}' does not exist`,
+          atFunction: "dialogue.on",
+          data: { roomId, eventName: event.name }
+        });
+        return () => {
+        };
+      }
+      return room.on(event, handler);
+    },
+    room(id) {
+      return roomManager.get(id);
+    },
+    rooms() {
+      return roomManager.all();
+    },
+    createRoom(id, config2) {
+      if (roomManager.get(id)) {
+        logger.warn({
+          message: `Room '${id}' already exists`,
+          atFunction: "dialogue.createRoom",
+          data: { roomId: id }
+        });
+        return null;
+      }
+      const room = roomManager.register(id, config2);
+      io.emit("dialogue:roomCreated", {
+        id: room.id,
+        name: room.name,
+        description: room.description,
+        maxSize: room.maxSize
+      });
+      logger.info({
+        message: `Room '${id}' created`,
+        atFunction: "dialogue.createRoom",
+        data: { roomId: id, roomName: config2.name }
+      });
+      return room;
+    },
+    deleteRoom(id) {
+      const deleted = roomManager.unregister(id);
+      if (deleted) {
+        io.emit("dialogue:roomDeleted", { roomId: id });
+      }
+      return deleted;
+    },
+    getClients(userId) {
+      return getClientsByUserId(userId);
+    },
+    getAllClients() {
+      return getAllConnectedClients();
+    },
+    getClientRooms(userId) {
+      const roomIds = getClientRoomIds(userId);
+      const clients = getClientsByUserId(userId);
+      return {
+        ids: roomIds,
+        forAll(callback) {
+          for (const roomId of roomIds) {
+            callback(roomId);
+          }
+        },
+        leaveAll(callback) {
+          if (callback) {
+            for (const roomId of roomIds) {
+              callback(roomId);
+            }
+          }
+          for (const client of clients) {
+            for (const roomId of client.rooms()) {
+              client.leave(roomId);
+            }
+          }
+        }
+      };
+    },
+    isInRoom(userId, roomId) {
+      return isUserInRoom(userId, roomId);
+    },
+    start,
+    stop
+  };
+  return dialogue;
+}
+export {
+  createDefaultLogger,
+  createDialogue,
+  createHistoryManager,
+  createRateLimiter,
+  createSilentLogger,
+  defineEvent,
+  getEventByName,
+  isEventAllowed,
+  validateEventData
+};
+//# sourceMappingURL=index.js.map