@nolag/chat 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1091 @@
+'use strict';
+
+var jsSdk = require('@nolag/js-sdk');
+
+/**
+ * Tiny typed event emitter — framework-agnostic base for NoLagChat and ChatRoom.
+ *
+ * EventMap is a record of event name → tuple of handler arguments.
+ * e.g. { message: [ChatMessage]; typing: [{ users: ChatUser[] }] }
+ */
+class EventEmitter {
+    constructor() {
+        this._handlers = new Map();
+    }
+    /**
+     * Register an event handler.
+     */
+    on(event, handler) {
+        if (!this._handlers.has(event)) {
+            this._handlers.set(event, new Set());
+        }
+        this._handlers.get(event).add(handler);
+        return this;
+    }
+    /**
+     * Remove a specific handler, or all handlers for an event.
+     */
+    off(event, handler) {
+        if (handler) {
+            this._handlers.get(event)?.delete(handler);
+        }
+        else {
+            this._handlers.delete(event);
+        }
+        return this;
+    }
+    /**
+     * Remove all handlers for all events.
+     */
+    removeAllListeners() {
+        this._handlers.clear();
+        return this;
+    }
+    /**
+     * Emit an event to all registered handlers.
+     */
+    emit(event, ...args) {
+        const handlers = this._handlers.get(event);
+        if (!handlers)
+            return;
+        for (const handler of handlers) {
+            try {
+                handler(...args);
+            }
+            catch (e) {
+                console.error(`Error in ${String(event)} handler:`, e);
+            }
+        }
+    }
+    /**
+     * Returns the number of handlers registered for an event.
+     */
+    listenerCount(event) {
+        return this._handlers.get(event)?.size ?? 0;
+    }
+}
+
+/**
+ * Bounded, deduplicated message cache ordered by timestamp.
+ */
+class MessageStore {
+    constructor(maxSize) {
+        this._messages = [];
+        this._ids = new Set();
+        this._maxSize = maxSize;
+    }
+    /**
+     * Add a message. Returns true if the message was new (not a duplicate).
+     */
+    add(message) {
+        if (this._ids.has(message.id)) {
+            return false;
+        }
+        this._ids.add(message.id);
+        this._messages.push(message);
+        // Keep sorted by timestamp
+        if (this._messages.length > 1 &&
+            message.timestamp < this._messages[this._messages.length - 2].timestamp) {
+            this._messages.sort((a, b) => a.timestamp - b.timestamp);
+        }
+        // Trim if over capacity
+        while (this._messages.length > this._maxSize) {
+            const removed = this._messages.shift();
+            this._ids.delete(removed.id);
+        }
+        return true;
+    }
+    /**
+     * Get all messages in timestamp order.
+     */
+    getAll() {
+        return [...this._messages];
+    }
+    /**
+     * Get message count.
+     */
+    get size() {
+        return this._messages.length;
+    }
+    /**
+     * Check if a message ID exists.
+     */
+    has(id) {
+        return this._ids.has(id);
+    }
+    /**
+     * Clear all messages.
+     */
+    clear() {
+        this._messages = [];
+        this._ids.clear();
+    }
+}
+
+/**
+ * Maps actorTokenId ↔ ChatUser, filtering self.
+ */
+class PresenceManager {
+    constructor(localActorId) {
+        this._users = new Map();
+        this._actorToUserId = new Map();
+        this._localActorId = localActorId;
+    }
+    /**
+     * Add or update a user from presence data.
+     * Returns the ChatUser if it's a remote user, null if it's self.
+     */
+    addFromPresence(actorTokenId, presence, joinedAt) {
+        const isLocal = actorTokenId === this._localActorId;
+        // Skip self
+        if (isLocal)
+            return null;
+        const existing = this._actorToUserId.get(actorTokenId);
+        const userId = presence.userId || existing || actorTokenId;
+        const user = {
+            userId,
+            actorTokenId,
+            username: presence.username,
+            avatar: presence.avatar,
+            metadata: presence.metadata,
+            status: presence.status || 'online',
+            joinedAt: joinedAt || Date.now(),
+            isLocal: false,
+        };
+        this._users.set(userId, user);
+        this._actorToUserId.set(actorTokenId, userId);
+        return user;
+    }
+    /**
+     * Remove a user by actorTokenId.
+     * Returns the removed user, or null if not found / is self.
+     */
+    removeByActorId(actorTokenId) {
+        if (actorTokenId === this._localActorId)
+            return null;
+        const userId = this._actorToUserId.get(actorTokenId);
+        if (!userId)
+            return null;
+        const user = this._users.get(userId) || null;
+        this._users.delete(userId);
+        this._actorToUserId.delete(actorTokenId);
+        return user;
+    }
+    /**
+     * Get a user by userId.
+     */
+    getUser(userId) {
+        return this._users.get(userId);
+    }
+    /**
+     * Get a user by actorTokenId.
+     */
+    getUserByActorId(actorTokenId) {
+        const userId = this._actorToUserId.get(actorTokenId);
+        return userId ? this._users.get(userId) : undefined;
+    }
+    /**
+     * Get all remote users.
+     */
+    getAll() {
+        return Array.from(this._users.values());
+    }
+    /**
+     * Get the users Map (readonly view).
+     */
+    get users() {
+        return this._users;
+    }
+    /**
+     * Clear all tracked users.
+     */
+    clear() {
+        this._users.clear();
+        this._actorToUserId.clear();
+    }
+}
+
+/**
+ * Manages typing indicator state for both local (send) and remote (receive) sides.
+ *
+ * Send-side: debounced — calling startTyping() sends a signal, then auto-stops
+ * after a configurable timeout unless startTyping() is called again.
+ *
+ * Receive-side: per-user timeouts — if no typing signal arrives within the
+ * timeout window, the user is considered to have stopped typing.
+ */
+class TypingManager {
+    constructor(timeout) {
+        // Send-side
+        this._localTimer = null;
+        this._localTyping = false;
+        // Receive-side: userId → timeout
+        this._remoteTimers = new Map();
+        this._typingUserIds = new Set();
+        // Callbacks
+        this._onSend = null;
+        this._onChange = null;
+        this._timeout = timeout;
+    }
+    /**
+     * Set the callback invoked when a typing signal needs to be sent.
+     */
+    onSend(cb) {
+        this._onSend = cb;
+    }
+    /**
+     * Set the callback invoked when the set of typing users changes.
+     */
+    onChange(cb) {
+        this._onChange = cb;
+    }
+    /**
+     * Called by the local user when they are typing.
+     * Sends typing=true if not already sent, and (re)starts the auto-stop timer.
+     */
+    startTyping() {
+        if (!this._localTyping) {
+            this._localTyping = true;
+            this._onSend?.(true);
+        }
+        // Reset auto-stop timer
+        if (this._localTimer)
+            clearTimeout(this._localTimer);
+        this._localTimer = setTimeout(() => {
+            this.stopTyping();
+        }, this._timeout);
+    }
+    /**
+     * Called by the local user to explicitly stop typing.
+     */
+    stopTyping() {
+        if (!this._localTyping)
+            return;
+        this._localTyping = false;
+        if (this._localTimer) {
+            clearTimeout(this._localTimer);
+            this._localTimer = null;
+        }
+        this._onSend?.(false);
+    }
+    /**
+     * Handle a remote typing signal.
+     */
+    handleRemote(userId, typing) {
+        // Clear existing timer for this user
+        const existing = this._remoteTimers.get(userId);
+        if (existing)
+            clearTimeout(existing);
+        if (typing) {
+            this._typingUserIds.add(userId);
+            // Auto-expire if no follow-up
+            this._remoteTimers.set(userId, setTimeout(() => {
+                this._typingUserIds.delete(userId);
+                this._remoteTimers.delete(userId);
+                this._onChange?.();
+            }, this._timeout + 1000));
+        }
+        else {
+            this._typingUserIds.delete(userId);
+            this._remoteTimers.delete(userId);
+        }
+        this._onChange?.();
+    }
+    /**
+     * Get the set of currently-typing remote user IDs.
+     */
+    getTypingUserIds() {
+        return this._typingUserIds;
+    }
+    /**
+     * Whether the local user is currently typing.
+     */
+    get isLocalTyping() {
+        return this._localTyping;
+    }
+    /**
+     * Clean up all timers.
+     */
+    dispose() {
+        if (this._localTimer)
+            clearTimeout(this._localTimer);
+        for (const timer of this._remoteTimers.values()) {
+            clearTimeout(timer);
+        }
+        this._remoteTimers.clear();
+        this._typingUserIds.clear();
+        this._localTyping = false;
+        this._onSend = null;
+        this._onChange = null;
+    }
+}
+
+/**
+ * Generate a unique ID.
+ * Uses crypto.randomUUID when available, falls back to a simple random string.
+ */
+function generateId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    // Fallback for environments without crypto.randomUUID
+    return 'xxxx-xxxx-xxxx-xxxx'.replace(/x/g, () => Math.floor(Math.random() * 16).toString(16));
+}
+/**
+ * Create a debug logger that only logs when enabled.
+ */
+function createLogger(prefix, enabled) {
+    if (!enabled) {
+        return (..._args) => { };
+    }
+    return (...args) => {
+        console.log(`[${prefix}]`, ...args);
+    };
+}
+
+/** Default app name for room topic prefixes */
+const DEFAULT_APP_NAME = 'chat';
+/** Default typing indicator auto-stop timeout (ms) */
+const DEFAULT_TYPING_TIMEOUT = 3000;
+/** Default max messages kept per room */
+const DEFAULT_MAX_MESSAGE_CACHE = 500;
+/** Topic name for chat messages within a room */
+const TOPIC_MESSAGES = 'messages';
+/** Topic name for typing indicators within a room */
+const TOPIC_TYPING = '_typing';
+/** Lobby ID for global online presence */
+const LOBBY_ID = 'online';
+
+/**
+ * ChatRoom — a single chat room with messages, users, and typing indicators.
+ *
+ * Created via `NoLagChat.joinRoom(name)`. Do not instantiate directly.
+ */
+class ChatRoom extends EventEmitter {
+    /** @internal */
+    constructor(name, roomContext, localUser, options, log) {
+        super();
+        this._unreadCount = 0;
+        this._active = false;
+        this.name = name;
+        this._roomContext = roomContext;
+        this._localUser = localUser;
+        this._options = options;
+        this._log = log;
+        this._presenceManager = new PresenceManager(localUser.actorTokenId);
+        this._typingManager = new TypingManager(options.typingTimeout);
+        this._messageStore = new MessageStore(options.maxMessageCache);
+        // Wire typing send callback
+        this._typingManager.onSend((typing) => {
+            this._roomContext.emit(TOPIC_TYPING, {
+                userId: this._localUser.userId,
+                typing,
+            }, { echo: false });
+        });
+        // Wire typing change callback
+        this._typingManager.onChange(() => {
+            this.emit('typing', { users: this.typingUsers });
+        });
+    }
+    // ============ Public Properties ============
+    /** All remote users currently in this room */
+    get users() {
+        return this._presenceManager.users;
+    }
+    /** All messages in this room (timestamp order) */
+    get messages() {
+        return this._messageStore.getAll();
+    }
+    /** Users currently typing */
+    get typingUsers() {
+        const typingIds = this._typingManager.getTypingUserIds();
+        const users = [];
+        for (const userId of typingIds) {
+            const user = this._presenceManager.getUser(userId);
+            if (user)
+                users.push(user);
+        }
+        return users;
+    }
+    /** Number of unread messages (increments when room is not active) */
+    get unreadCount() {
+        return this._unreadCount;
+    }
+    /** Whether this room is the currently active (visible) room */
+    get active() {
+        return this._active;
+    }
+    /** Reset the unread count to zero */
+    markRead() {
+        if (this._unreadCount !== 0) {
+            this._unreadCount = 0;
+            this.emit('unreadChanged', { room: this.name, count: 0 });
+        }
+    }
+    // ============ Messaging ============
+    /**
+     * Send a text message to this room. Returns an optimistic ChatMessage.
+     */
+    sendMessage(text, options) {
+        const message = {
+            id: generateId(),
+            userId: this._localUser.userId,
+            username: this._localUser.username,
+            avatar: this._localUser.avatar,
+            text,
+            data: options?.data,
+            timestamp: Date.now(),
+            status: 'sending',
+            isReplay: false,
+        };
+        // Add to local store (optimistic)
+        this._messageStore.add(message);
+        this.emit('messageSent', message);
+        // Publish to room (echo: false prevents duplicate)
+        this._roomContext.emit(TOPIC_MESSAGES, {
+            id: message.id,
+            userId: message.userId,
+            username: message.username,
+            avatar: message.avatar,
+            text: message.text,
+            data: message.data,
+            timestamp: message.timestamp,
+        }, { echo: false });
+        // Mark as sent
+        message.status = 'sent';
+        // Stop typing on send
+        this._typingManager.stopTyping();
+        return message;
+    }
+    /**
+     * Get all messages (alias for the messages getter).
+     */
+    getMessages() {
+        return this._messageStore.getAll();
+    }
+    // ============ Typing ============
+    /**
+     * Signal that the local user is typing. Auto-stops after timeout.
+     */
+    startTyping() {
+        this._typingManager.startTyping();
+    }
+    /**
+     * Explicitly signal that the local user has stopped typing.
+     */
+    stopTyping() {
+        this._typingManager.stopTyping();
+    }
+    // ============ Users ============
+    /**
+     * Get all remote users in this room.
+     */
+    getUsers() {
+        return this._presenceManager.getAll();
+    }
+    /**
+     * Get a specific user by userId.
+     */
+    getUser(userId) {
+        return this._presenceManager.getUser(userId);
+    }
+    // ============ Internal (called by NoLagChat) ============
+    /** @internal Subscribe to message/typing topics and attach listeners (all rooms) */
+    _subscribe() {
+        this._log('Room subscribe:', this.name);
+        // Subscribe to topics
+        this._roomContext.subscribe(TOPIC_MESSAGES);
+        this._roomContext.subscribe(TOPIC_TYPING);
+        // Listen for messages
+        this._roomContext.on(TOPIC_MESSAGES, (data, meta) => {
+            this._handleIncomingMessage(data, meta);
+        });
+        // Listen for typing
+        this._roomContext.on(TOPIC_TYPING, (data) => {
+            const { userId, typing } = data;
+            if (userId !== this._localUser.userId) {
+                this._typingManager.handleRemote(userId, typing);
+            }
+        });
+    }
+    /** @internal Set presence and fetch room members (active room only) */
+    _activate() {
+        this._log('Room activate:', this.name);
+        this._active = true;
+        this._markRead();
+        // Set room presence
+        this._setPresence();
+        // Fetch existing users
+        this._roomContext.fetchPresence().then((actors) => {
+            this._log('Room presence fetched:', this.name, actors.length, 'actors');
+            for (const actor of actors) {
+                if (actor.presence) {
+                    const user = this._presenceManager.addFromPresence(actor.actorTokenId, actor.presence, actor.joinedAt);
+                    if (user) {
+                        this.emit('userJoined', user);
+                    }
+                }
+            }
+        }).catch((err) => {
+            this._log('Failed to fetch room presence:', err);
+        });
+    }
+    /** @internal Clear presence state but keep subscriptions alive */
+    _deactivate() {
+        this._log('Room deactivate:', this.name);
+        this._active = false;
+        this._presenceManager.clear();
+    }
+    /** @internal Handle a lobby presence:join event routed from NoLagChat */
+    _handlePresenceJoin(actorTokenId, presenceData) {
+        const user = this._presenceManager.addFromPresence(actorTokenId, presenceData);
+        if (user) {
+            this._log('User joined room:', this.name, user.username);
+            this.emit('userJoined', user);
+        }
+    }
+    /** @internal Handle a lobby presence:leave event routed from NoLagChat */
+    _handlePresenceLeave(actorTokenId) {
+        const user = this._presenceManager.removeByActorId(actorTokenId);
+        if (user) {
+            this._log('User left room:', this.name, user.username);
+            // Remove from typing
+            this._typingManager.handleRemote(user.userId, false);
+            this.emit('userLeft', user);
+        }
+    }
+    /** @internal Handle a lobby presence:update event routed from NoLagChat */
+    _handlePresenceUpdate(actorTokenId, presenceData) {
+        this._presenceManager.addFromPresence(actorTokenId, presenceData);
+    }
+    /** @internal Handle replay start event */
+    _handleReplayStart(count) {
+        this.emit('replayStart', { count });
+    }
+    /** @internal Handle replay end event */
+    _handleReplayEnd(replayed) {
+        this.emit('replayEnd', { replayed });
+    }
+    /** @internal Re-set presence after reconnect */
+    _updateLocalPresence() {
+        this._setPresence();
+    }
+    /** @internal Unsubscribe and clean up */
+    _cleanup() {
+        this._log('Room cleanup:', this.name);
+        this._roomContext.unsubscribe(TOPIC_MESSAGES);
+        this._roomContext.unsubscribe(TOPIC_TYPING);
+        this._roomContext.off(TOPIC_MESSAGES);
+        this._roomContext.off(TOPIC_TYPING);
+        this._typingManager.dispose();
+        this._messageStore.clear();
+        this._presenceManager.clear();
+        this.removeAllListeners();
+    }
+    // ============ Private ============
+    _handleIncomingMessage(data, meta) {
+        const msg = data;
+        const chatMessage = {
+            id: msg.id,
+            userId: msg.userId,
+            username: msg.username,
+            avatar: msg.avatar,
+            text: msg.text,
+            data: msg.data,
+            timestamp: msg.timestamp,
+            status: 'delivered',
+            isReplay: meta.isReplay ?? false,
+        };
+        if (this._messageStore.add(chatMessage)) {
+            this.emit('message', chatMessage);
+            // Track unread when not the active room
+            if (!this._active && !chatMessage.isReplay) {
+                this._unreadCount++;
+                this.emit('unreadChanged', { room: this.name, count: this._unreadCount });
+            }
+        }
+    }
+    _markRead() {
+        if (this._unreadCount !== 0) {
+            this._unreadCount = 0;
+            this.emit('unreadChanged', { room: this.name, count: 0 });
+        }
+    }
+    _setPresence() {
+        const presenceData = {
+            userId: this._localUser.userId,
+            username: this._localUser.username,
+            avatar: this._localUser.avatar,
+            status: this._localUser.status,
+            metadata: this._localUser.metadata,
+        };
+        this._roomContext.setPresence(presenceData);
+    }
+}
+
+/**
+ * NoLagChat — high-level chat SDK built on @nolag/js-sdk.
+ *
+ * Provides multi-room chat, presence (who's online), typing indicators,
+ * message replay, and user mapping — all framework-agnostic via events.
+ *
+ * @example
+ * ```typescript
+ * import { NoLagChat } from '@nolag/chat';
+ *
+ * const chat = new NoLagChat(token, { username: 'Alice' });
+ *
+ * chat.on('connected', () => console.log('Connected!'));
+ * chat.on('userOnline', (user) => console.log(user.username, 'is online'));
+ *
+ * await chat.connect();
+ *
+ * const room = chat.joinRoom('general');
+ * room.on('message', (msg) => console.log(msg.username + ':', msg.text));
+ * room.sendMessage('Hello!');
+ * ```
+ */
+class NoLagChat extends EventEmitter {
+    constructor(token, options) {
+        super();
+        this._client = null;
+        this._localUser = null;
+        this._rooms = new Map();
+        this._lobby = null;
+        this._onlineUsers = new Map();
+        this._actorToUserId = new Map();
+        this._activeRoom = null;
+        this._token = token;
+        this._userId = generateId();
+        this._options = {
+            username: options.username,
+            avatar: options.avatar,
+            metadata: options.metadata,
+            appName: options.appName ?? DEFAULT_APP_NAME,
+            url: options.url,
+            typingTimeout: options.typingTimeout ?? DEFAULT_TYPING_TIMEOUT,
+            maxMessageCache: options.maxMessageCache ?? DEFAULT_MAX_MESSAGE_CACHE,
+            debug: options.debug ?? false,
+            reconnect: options.reconnect ?? true,
+            rooms: options.rooms ?? [],
+        };
+        this._log = createLogger('NoLagChat', this._options.debug);
+    }
+    // ============ Public Properties ============
+    /** Whether the underlying connection is established */
+    get connected() {
+        return this._client?.connected ?? false;
+    }
+    /** The local user's info (available after connect) */
+    get localUser() {
+        return this._localUser;
+    }
+    /** All currently joined rooms */
+    get rooms() {
+        return this._rooms;
+    }
+    // ============ Lifecycle ============
+    /**
+     * Connect to NoLag and set up global presence.
+     */
+    async connect() {
+        this._log('Connecting...');
+        const clientOptions = {
+            debug: this._options.debug,
+            reconnect: this._options.reconnect,
+        };
+        if (this._options.url) {
+            clientOptions.url = this._options.url;
+        }
+        this._client = jsSdk.NoLag(this._token, clientOptions);
+        // Wire client lifecycle events
+        // Note: we emit 'connected' after _localUser and lobby are ready (below),
+        // not here, so that joinRoom() works inside the connected handler.
+        this._client.on('connect', () => {
+            this._log('Connected');
+            // On reconnect, the SDK fires 'connect' after the connection is
+            // re-established.  Restore rooms here (not in 'reconnect') so that
+            // presence updates and lobby fetches go over a live socket.
+            if (this._rooms.size > 0) {
+                this._log('Reconnected — restoring rooms...');
+                this._restoreRooms();
+                this.emit('reconnected');
+            }
+        });
+        this._client.on('disconnect', (reason) => {
+            this._log('Disconnected:', reason);
+            this.emit('disconnected', reason);
+        });
+        this._client.on('reconnect', () => {
+            this._log('Reconnecting...');
+        });
+        this._client.on('error', (error) => {
+            this._log('Error:', error);
+            this.emit('error', error);
+        });
+        // Wire replay events
+        this._client.on('replay:start', (data) => {
+            const event = data;
+            for (const room of this._rooms.values()) {
+                room._handleReplayStart(event.count);
+            }
+        });
+        this._client.on('replay:end', (data) => {
+            const event = data;
+            for (const room of this._rooms.values()) {
+                room._handleReplayEnd(event.replayed);
+            }
+        });
+        // Connect
+        await this._client.connect();
+        // Wire room-level presence events (these arrive as client-level events)
+        this._client.on('presence:join', (data) => {
+            this._handleRoomPresenceJoin(data);
+        });
+        this._client.on('presence:leave', (data) => {
+            this._handleRoomPresenceLeave(data);
+        });
+        this._client.on('presence:update', (data) => {
+            this._handleRoomPresenceUpdate(data);
+        });
+        // Create local user
+        this._localUser = {
+            userId: this._userId,
+            actorTokenId: this._client.actorId,
+            username: this._options.username,
+            avatar: this._options.avatar,
+            metadata: this._options.metadata,
+            status: 'online',
+            joinedAt: Date.now(),
+            isLocal: true,
+        };
+        this._log('Local user:', this._localUser.userId, '→', this._localUser.actorTokenId);
+        // Set up lobby for global presence
+        await this._setupLobby();
+        // Pre-subscribe to all configured rooms (messages only, no presence)
+        for (const roomName of this._options.rooms) {
+            this._subscribeRoom(roomName);
+        }
+        // Emit connected now that _localUser and lobby are ready,
+        // so handlers can safely call joinRoom().
+        this.emit('connected');
+        // Deferred lobby refetch: the initial lobby snapshot is taken before
+        // rooms are joined and presence is set.  When multiple tabs connect
+        // simultaneously, one tab may get its snapshot before the other has
+        // set presence — causing a missed user.  A short-delay refetch
+        // catches anyone who joined during the setup window.
+        setTimeout(() => {
+            if (this._lobby && this._client?.connected) {
+                this._lobby.fetchPresence().then((state) => {
+                    this._hydrateOnlineUsers(state);
+                }).catch(() => { });
+            }
+        }, 2000);
+    }
+    /**
+     * Disconnect from NoLag and clean up all rooms.
+     */
+    disconnect() {
+        this._log('Disconnecting...');
+        // Clean up rooms
+        for (const name of [...this._rooms.keys()]) {
+            this.leaveRoom(name);
+        }
+        // Unsubscribe from lobby
+        this._lobby?.unsubscribe();
+        this._lobby = null;
+        // Disconnect client
+        this._client?.disconnect();
+        this._client = null;
+        // Clear state
+        this._onlineUsers.clear();
+        this._actorToUserId.clear();
+        this._localUser = null;
+    }
+    // ============ Room Management ============
+    /**
+     * Join (activate) a chat room. Deactivates the previous active room.
+     * If the room was pre-subscribed via the `rooms` option, activates it.
+     * Otherwise creates, subscribes, and activates it.
+     */
+    joinRoom(name) {
+        if (!this._client || !this._localUser) {
+            throw new Error('Not connected — call connect() first');
+        }
+        // Deactivate the current active room
+        if (this._activeRoom && this._activeRoom !== name) {
+            const prev = this._rooms.get(this._activeRoom);
+            if (prev)
+                prev._deactivate();
+        }
+        // Get or create the room
+        let room = this._rooms.get(name);
+        if (!room) {
+            room = this._subscribeRoom(name);
+        }
+        this._activeRoom = name;
+        room._activate();
+        return room;
+    }
+    /**
+     * Leave a chat room. Fully unsubscribes and removes it.
+     */
+    leaveRoom(name) {
+        const room = this._rooms.get(name);
+        if (!room)
+            return;
+        this._log('Leaving room:', name);
+        room._cleanup();
+        this._rooms.delete(name);
+        if (this._activeRoom === name) {
+            this._activeRoom = null;
+        }
+    }
+    /**
+     * Get all joined rooms.
+     */
+    getRooms() {
+        return Array.from(this._rooms.values());
+    }
+    // ============ Global Presence ============
+    /**
+     * Get all users currently online across all rooms.
+     */
+    getOnlineUsers() {
+        return Array.from(this._onlineUsers.values());
+    }
+    /**
+     * Update the local user's online status.
+     */
+    setStatus(status) {
+        if (this._localUser) {
+            this._localUser.status = status;
+        }
+        // Re-set presence only on the active room
+        if (this._activeRoom) {
+            const activeRoom = this._rooms.get(this._activeRoom);
+            if (activeRoom)
+                activeRoom._updateLocalPresence();
+        }
+    }
+    // ============ Profile ============
+    /**
+     * Update the local user's profile info (broadcast to all rooms).
+     */
+    updateProfile(updates) {
+        if (!this._localUser)
+            return;
+        if (updates.username !== undefined) {
+            this._localUser.username = updates.username;
+            this._options.username = updates.username;
+        }
+        if (updates.avatar !== undefined) {
+            this._localUser.avatar = updates.avatar;
+            this._options.avatar = updates.avatar;
+        }
+        if (updates.metadata !== undefined) {
+            this._localUser.metadata = { ...this._localUser.metadata, ...updates.metadata };
+            this._options.metadata = this._localUser.metadata;
+        }
+        // Re-set presence only on the active room
+        if (this._activeRoom) {
+            const activeRoom = this._rooms.get(this._activeRoom);
+            if (activeRoom)
+                activeRoom._updateLocalPresence();
+        }
+    }
+    // ============ Private: Room Setup ============
+    _subscribeRoom(name) {
+        if (!this._client || !this._localUser) {
+            throw new Error('Not connected — call connect() first');
+        }
+        this._log('Subscribing room:', name);
+        const roomContext = this._client.setApp(this._options.appName).setRoom(name);
+        const room = new ChatRoom(name, roomContext, this._localUser, this._options, createLogger(`ChatRoom:${name}`, this._options.debug));
+        this._rooms.set(name, room);
+        room._subscribe();
+        return room;
+    }
+    // ============ Private: Room Presence → Active Room ============
+    _handleRoomPresenceJoin(data) {
+        if (data.actorTokenId === this._localUser?.actorTokenId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.userId)
+            return;
+        // Track as online user
+        const user = this._presenceToUser(data.actorTokenId, presenceData);
+        this._actorToUserId.set(data.actorTokenId, user.userId);
+        if (!this._onlineUsers.has(user.userId)) {
+            this._onlineUsers.set(user.userId, user);
+            this.emit('userOnline', user);
+        }
+        const room = this._activeRoom ? this._rooms.get(this._activeRoom) : undefined;
+        if (room) {
+            room._handlePresenceJoin(data.actorTokenId, presenceData);
+        }
+    }
+    _handleRoomPresenceLeave(data) {
+        if (data.actorTokenId === this._localUser?.actorTokenId)
+            return;
+        // Room leave ≠ offline — user may still be in another room.
+        // Lobby leave handles actual offline status.
+        const room = this._activeRoom ? this._rooms.get(this._activeRoom) : undefined;
+        if (room) {
+            room._handlePresenceLeave(data.actorTokenId);
+        }
+    }
+    _handleRoomPresenceUpdate(data) {
+        if (data.actorTokenId === this._localUser?.actorTokenId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.userId)
+            return;
+        // Update online user info if we already track them
+        if (this._onlineUsers.has(presenceData.userId)) {
+            const user = this._presenceToUser(data.actorTokenId, presenceData);
+            this._onlineUsers.set(user.userId, user);
+            this.emit('userUpdated', user);
+        }
+        const room = this._activeRoom ? this._rooms.get(this._activeRoom) : undefined;
+        if (room) {
+            room._handlePresenceUpdate(data.actorTokenId, presenceData);
+        }
+    }
+    // ============ Private: Lobby ============
+    async _setupLobby() {
+        if (!this._client)
+            return;
+        this._lobby = this._client.setApp(this._options.appName).setLobby(LOBBY_ID);
+        // Register on the client's generic lobby events (lobbyPresence:join/leave/update)
+        // instead of lobby.on(), because the server sends presence events with the
+        // server-assigned lobby UUID, while lobby.on() listens on the client-provided
+        // lobby name — the keys never match.
+        const lobbyHandler = (type) => (data) => {
+            const event = data;
+            if (type === 'join')
+                this._handleLobbyJoin(event);
+            else if (type === 'leave')
+                this._handleLobbyLeave(event);
+            else
+                this._handleLobbyUpdate(event);
+        };
+        this._client.on('lobbyPresence:join', lobbyHandler('join'));
+        this._client.on('lobbyPresence:leave', lobbyHandler('leave'));
+        this._client.on('lobbyPresence:update', lobbyHandler('update'));
+        try {
+            const initialState = await this._lobby.subscribe();
+            this._hydrateOnlineUsers(initialState);
+            this._log('Lobby subscribed, online users:', this._onlineUsers.size);
+        }
+        catch (err) {
+            this._log('Lobby subscription failed:', err);
+        }
+    }
+    _handleLobbyJoin(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localUser?.actorTokenId)
+            return;
+        const presenceData = data;
+        if (!presenceData.userId)
+            return;
+        const user = this._presenceToUser(actorId, presenceData);
+        this._actorToUserId.set(actorId, user.userId);
+        if (!this._onlineUsers.has(user.userId)) {
+            this._onlineUsers.set(user.userId, user);
+            this.emit('userOnline', user);
+        }
+    }
+    _handleLobbyLeave(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localUser?.actorTokenId)
+            return;
+        const presenceData = data;
+        const userId = presenceData?.userId
+            || this._actorToUserId.get(actorId)
+            || this._findUserIdByActorId(actorId);
+        if (userId) {
+            const user = this._onlineUsers.get(userId);
+            if (user) {
+                this._onlineUsers.delete(userId);
+                this._actorToUserId.delete(actorId);
+                this.emit('userOffline', user);
+            }
+        }
+    }
+    _handleLobbyUpdate(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localUser?.actorTokenId)
+            return;
+        const presenceData = data;
+        if (!presenceData.userId)
+            return;
+        const user = this._presenceToUser(actorId, presenceData);
+        this._onlineUsers.set(user.userId, user);
+        this.emit('userUpdated', user);
+    }
+    _hydrateOnlineUsers(state) {
+        // state = { roomId: { actorId: actorRecord } }
+        // actorRecord from the server is { actorTokenId, presence: ChatPresenceData, joinedAt }
+        for (const roomId of Object.keys(state)) {
+            const roomPresence = state[roomId];
+            for (const actorId of Object.keys(roomPresence)) {
+                if (actorId === this._localUser?.actorTokenId)
+                    continue;
+                const raw = roomPresence[actorId];
+                // Server returns full actor records with presence nested under .presence
+                const presenceData = (raw?.presence ?? raw);
+                if (presenceData?.userId) {
+                    const user = this._presenceToUser(actorId, presenceData);
+                    this._actorToUserId.set(actorId, user.userId);
+                    if (!this._onlineUsers.has(user.userId)) {
+                        this._onlineUsers.set(user.userId, user);
+                        this.emit('userOnline', user);
+                    }
+                }
+            }
+        }
+    }
+    // ============ Private: Helpers ============
+    _presenceToUser(actorTokenId, data) {
+        return {
+            userId: data.userId,
+            actorTokenId,
+            username: data.username,
+            avatar: data.avatar,
+            metadata: data.metadata,
+            status: data.status || 'online',
+            joinedAt: Date.now(),
+            isLocal: false,
+        };
+    }
+    _findUserIdByActorId(actorTokenId) {
+        for (const user of this._onlineUsers.values()) {
+            if (user.actorTokenId === actorTokenId)
+                return user.userId;
+        }
+        return undefined;
+    }
+    _restoreRooms() {
+        // On reconnect, js-sdk auto-restores subscriptions.
+        // Re-set presence only on the active room.
+        if (this._activeRoom) {
+            const activeRoom = this._rooms.get(this._activeRoom);
+            if (activeRoom)
+                activeRoom._updateLocalPresence();
+        }
+        // Re-fetch lobby presence
+        this._lobby?.fetchPresence().then((state) => {
+            this._onlineUsers.clear();
+            this._actorToUserId.clear();
+            this._hydrateOnlineUsers(state);
+        }).catch((err) => {
+            this._log('Failed to re-fetch lobby presence:', err);
+        });
+    }
+}
+
+exports.ChatRoom = ChatRoom;
+exports.EventEmitter = EventEmitter;
+exports.NoLagChat = NoLagChat;
+//# sourceMappingURL=index.cjs.map