@nolag/chat 1.0.0 → 1.2.0

package/dist/react-native.js

@@ -0,0 +1,1579 @@
+/**
+ * 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);
+    }
+    /**
+     * Get a message by ID. Returns the live reference (mutating it mutates the
+     * stored message), or undefined if not present.
+     */
+    get(id) {
+        if (!this._ids.has(id))
+            return undefined;
+        return this._messages.find((m) => m.id === 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);
+    };
+}
+// ============ Filters ============
+/**
+ * Build the filter fragment of an emit options object.
+ *
+ * `filter` wins over `filters`: a publish is routed to exactly one topic, so
+ * honouring both would silently drop one of them.
+ */
+function filterEmitOptions(opts) {
+    if (opts?.filter)
+        return { filter: opts.filter };
+    if (opts?.filters && opts.filters.length > 0)
+        return { filters: opts.filters };
+    return {};
+}
+/**
+ * Merge OR terms into an existing filter set. AND groups (nested arrays) are
+ * preserved as-is — only plain string terms are deduplicated.
+ */
+function mergeFilters(existing, add) {
+    const simple = new Set();
+    const groups = [];
+    for (const f of existing) {
+        if (typeof f === 'string')
+            simple.add(f);
+        else
+            groups.push(f);
+    }
+    for (const v of add)
+        simple.add(v);
+    return [...simple, ...groups];
+}
+/**
+ * Drop OR terms from a filter set. AND groups are left untouched — remove
+ * those by calling `setFilters` with the set you want.
+ */
+function withoutFilters(existing, remove) {
+    const drop = new Set(remove);
+    return existing.filter((f) => typeof f !== 'string' || !drop.has(f));
+}
+// ============ Wrapper registry ============
+// One wrapper instance per (client, appName): two wrappers sharing an app on
+// one connection would collide on topics, presence and the online lobby.
+// Warn (not throw): HMR and tests legitimately construct before disposing.
+const wrapperRegistry = new WeakMap();
+/** Register a wrapper against a client + appName; warns on collision. */
+function registerWrapper(client, appName, wrapperName) {
+    let apps = wrapperRegistry.get(client);
+    if (!apps) {
+        apps = new Map();
+        wrapperRegistry.set(client, apps);
+    }
+    const existing = apps.get(appName);
+    if (existing) {
+        console.warn(`[${wrapperName}] Another wrapper (${existing}) is already attached to this client for app "${appName}". ` +
+            `Use one wrapper per (client, app) — detach the other instance first.`);
+    }
+    apps.set(appName, wrapperName);
+}
+/** Release a wrapper's (client, appName) registration on detach. */
+function releaseWrapper(client, appName) {
+    wrapperRegistry.get(client)?.delete(appName);
+}
+
+/** 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';
+/** Topic name for live streamed message chunks within a room (ephemeral) */
+const TOPIC_STREAM = '_stream';
+/** Default coalesce/flush interval for streamed token chunks (ms) */
+const DEFAULT_STREAM_FLUSH_MS = 60;
+/** Lobby ID for global online presence */
+const LOBBY_ID = 'online';
+/** Delay before the post-setup lobby presence refetch (catches simultaneous joiners) */
+const LOBBY_REFRESH_DELAY_MS = 2000;
+
+/**
+ * Producer-side controller for an outgoing streamed message.
+ *
+ * `append()` updates the local message immediately and buffers the token; a
+ * timer flushes buffered tokens as a single network delta at most every
+ * `flushIntervalMs`, so a token-per-character source doesn't flood the broker.
+ */
+class MessageStreamController {
+    constructor(message, _flushIntervalMs, _hooks) {
+        this._flushIntervalMs = _flushIntervalMs;
+        this._hooks = _hooks;
+        this._buffer = '';
+        this._flushTimer = null;
+        this._closed = false;
+        this.message = message;
+        // Announce the stream so receivers can render a live placeholder at once.
+        this._hooks.publishStream({
+            type: 'start',
+            id: message.id,
+            userId: message.userId,
+            username: message.username,
+            avatar: message.avatar,
+            timestamp: message.timestamp,
+        });
+        this._hooks.emitStart(message);
+    }
+    append(text) {
+        if (this._closed || !text)
+            return;
+        this.message.text += text;
+        this._buffer += text;
+        this._hooks.emitChunk(this.message, text);
+        if (!this._flushTimer) {
+            this._flushTimer = setTimeout(() => this._flush(), this._flushIntervalMs);
+        }
+    }
+    complete() {
+        if (this._closed)
+            return this.message;
+        this._flush(); // send any buffered tokens
+        this._closed = true;
+        this._clearTimer();
+        this.message.status = 'sent';
+        this._hooks.publishFinal(this.message); // persisted final → finalizes receivers
+        this._hooks.emitEnd(this.message);
+        return this.message;
+    }
+    abort(error) {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this._clearTimer();
+        this._buffer = '';
+        this.message.status = 'aborted';
+        this._hooks.publishStream({ type: 'abort', id: this.message.id, error });
+        this._hooks.emitAbort(this.message, error);
+    }
+    _flush() {
+        this._clearTimer();
+        if (this._buffer) {
+            this._hooks.publishStream({
+                type: 'delta',
+                id: this.message.id,
+                text: this._buffer,
+            });
+            this._buffer = '';
+        }
+    }
+    _clearTimer() {
+        if (this._flushTimer) {
+            clearTimeout(this._flushTimer);
+            this._flushTimer = null;
+        }
+    }
+}
+
+/**
+ * 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, isConnected) {
+        super();
+        this._unreadCount = 0;
+        this._active = false;
+        this._filters = [];
+        // Stored topic handler refs — cleanup removes exactly these, never all
+        // handlers for a topic (the client may be shared with other consumers).
+        this._onMessagesRef = null;
+        this._onTypingRef = null;
+        this._onStreamRef = null;
+        this.name = name;
+        this._roomContext = roomContext;
+        this._localUser = localUser;
+        this._options = options;
+        this._log = log;
+        this._isConnected = isConnected;
+        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 });
+        }
+    }
+    // ============ Filters ============
+    /** The filter values currently applied to this room's messages. */
+    get filters() {
+        return [...this._filters];
+    }
+    /**
+     * Replace this room's message filters — only messages published with one of
+     * these values are delivered. Applies to live streams as well as finalized
+     * messages, so a filtered stream reaches the same audience as its final
+     * message.
+     *
+     * Passing an empty array clears filtering and restores the wildcard
+     * subscription, which receives everything on the topic.
+     *
+     * @example
+     * ```ts
+     * room.setFilters(['alice', 'bob']);      // alice OR bob
+     * room.setFilters([['alice', 'admin']]);  // alice AND admin
+     * room.setFilters([]);                    // everything
+     * ```
+     */
+    setFilters(values) {
+        this._filters = [...values];
+        this._applyFilters(TOPIC_MESSAGES);
+        this._applyFilters(TOPIC_STREAM);
+    }
+    /** Add filter values to the existing set. Existing AND groups are kept. */
+    addFilters(values) {
+        this.setFilters(mergeFilters(this._filters, values));
+    }
+    /**
+     * Remove filter values from the existing set. Removing the last value
+     * restores the wildcard subscription.
+     */
+    removeFilters(values) {
+        this.setFilters(withoutFilters(this._filters, values));
+    }
+    /** @internal Push the current filter set to one topic. */
+    _applyFilters(topic) {
+        // The core types filters as `string[]`, but both its implementation and
+        // the wire protocol accept AND groups (nested arrays).
+        this._roomContext.setFilters(topic, this._filters);
+    }
+    // ============ 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._publishFinalMessage(message, filterEmitOptions(options));
+        // Mark as sent
+        message.status = 'sent';
+        // Stop typing on send
+        this._typingManager.stopTyping();
+        return message;
+    }
+    // ============ Streaming ============
+    /**
+     * Begin a streamed message (e.g. an AI response). Returns a handle you append
+     * tokens to. Receivers see the message appear and grow live; on `complete()`
+     * the full message is persisted like a normal message.
+     *
+     * @example
+     * ```ts
+     * const stream = room.startStream();
+     * for await (const token of llm) stream.append(token);
+     * stream.complete();
+     * ```
+     */
+    startStream(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: 'streaming',
+            isReplay: false,
+        };
+        // Optimistic: appears in room.messages and grows as tokens arrive.
+        this._messageStore.add(message);
+        this._typingManager.stopTyping();
+        // Deltas and the final message carry the same filter, so subscribers who
+        // see the stream grow are exactly those who end up with the message.
+        const filterOpts = filterEmitOptions(options);
+        return new MessageStreamController(message, options?.flushIntervalMs ?? DEFAULT_STREAM_FLUSH_MS, {
+            publishStream: (payload) => this._roomContext.emit(TOPIC_STREAM, payload, { echo: false, ...filterOpts }),
+            publishFinal: (m) => this._publishFinalMessage(m, filterOpts),
+            emitStart: (m) => this.emit('streamStart', m),
+            emitChunk: (m, delta) => this.emit('streamChunk', { message: m, delta }),
+            emitEnd: (m) => this.emit('streamEnd', m),
+            emitAbort: (m, error) => this.emit('streamAbort', { message: m, error }),
+        });
+    }
+    /**
+     * Stream a message from a token source (sync or async iterable) — drops in
+     * for an LLM stream. Appends each chunk, finalizes on completion, and aborts
+     * (re-throwing) if the source errors.
+     *
+     * @example
+     * ```ts
+     * // OpenAI / Anthropic style streams yield text chunks
+     * await room.streamMessage(tokenIterable);
+     * ```
+     */
+    async streamMessage(source, options) {
+        const stream = this.startStream(options);
+        try {
+            for await (const chunk of source) {
+                stream.append(chunk);
+            }
+            return stream.complete();
+        }
+        catch (err) {
+            stream.abort(err instanceof Error ? err.message : String(err));
+            throw err;
+        }
+    }
+    /** @internal Publish a final message on the persisted `messages` topic. */
+    _publishFinalMessage(message, filterOpts = {}) {
+        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, ...filterOpts });
+    }
+    /**
+     * 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(filters) {
+        this._log('Room subscribe:', this.name, filters?.length ? `filters: ${filters.length}` : '');
+        this._filters = filters ? [...filters] : [];
+        // Subscribe to topics. Typing stays unfiltered: it is ephemeral, room-wide
+        // and already keyed by userId in the payload.
+        if (this._filters.length > 0) {
+            const opts = { filters: this._filters };
+            this._roomContext.subscribe(TOPIC_MESSAGES, opts);
+            this._roomContext.subscribe(TOPIC_STREAM, opts);
+        }
+        else {
+            this._roomContext.subscribe(TOPIC_MESSAGES);
+            this._roomContext.subscribe(TOPIC_STREAM);
+        }
+        this._roomContext.subscribe(TOPIC_TYPING);
+        // Listen for messages (refs stored for handler-specific removal)
+        this._onMessagesRef = (data, meta) => {
+            this._handleIncomingMessage(data, meta);
+        };
+        this._roomContext.on(TOPIC_MESSAGES, this._onMessagesRef);
+        // Listen for typing
+        this._onTypingRef = (data) => {
+            const { userId, typing } = data;
+            if (userId !== this._localUser.userId) {
+                this._typingManager.handleRemote(userId, typing);
+            }
+        };
+        this._roomContext.on(TOPIC_TYPING, this._onTypingRef);
+        // Listen for live streamed messages (start / delta / abort)
+        this._onStreamRef = (data) => {
+            this._handleStreamEvent(data);
+        };
+        this._roomContext.on(TOPIC_STREAM, this._onStreamRef);
+    }
+    /** @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);
+        // Server unsubscribes need a live socket; skip when disconnected
+        // (best-effort — the core would no-op with an error callback anyway).
+        if (this._isConnected()) {
+            this._roomContext.unsubscribe(TOPIC_MESSAGES);
+            this._roomContext.unsubscribe(TOPIC_TYPING);
+            this._roomContext.unsubscribe(TOPIC_STREAM);
+        }
+        // Handler-specific removal only: the client may be shared, and a bare
+        // off(topic) would strip other consumers' handlers too.
+        if (this._onMessagesRef)
+            this._roomContext.off(TOPIC_MESSAGES, this._onMessagesRef);
+        if (this._onTypingRef)
+            this._roomContext.off(TOPIC_TYPING, this._onTypingRef);
+        if (this._onStreamRef)
+            this._roomContext.off(TOPIC_STREAM, this._onStreamRef);
+        this._onMessagesRef = null;
+        this._onTypingRef = null;
+        this._onStreamRef = null;
+        this._typingManager.dispose();
+        this._messageStore.clear();
+        this._presenceManager.clear();
+        this.removeAllListeners();
+    }
+    // ============ Private ============
+    _handleIncomingMessage(data, meta) {
+        const msg = data;
+        const id = msg.id;
+        // If this is the persisted final for a message we streamed live, finalize
+        // the existing placeholder in place (authoritative text) rather than adding
+        // a duplicate. This also catches a late delta race — the final wins.
+        const streaming = this._messageStore.get(id);
+        if (streaming && streaming.status === 'streaming') {
+            streaming.text = msg.text;
+            streaming.data = msg.data;
+            streaming.status = 'delivered';
+            this.emit('streamEnd', streaming);
+            this.emit('message', streaming);
+            if (!this._active && !streaming.isReplay) {
+                this._unreadCount++;
+                this.emit('unreadChanged', { room: this.name, count: this._unreadCount });
+            }
+            return;
+        }
+        const chatMessage = {
+            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 });
+            }
+        }
+    }
+    /** Handle an incoming live stream control payload (start / delta / abort). */
+    _handleStreamEvent(data) {
+        const evt = data;
+        if (!evt || !evt.id)
+            return;
+        switch (evt.type) {
+            case 'start': {
+                // Ignore our own (echo:false should prevent it, but be safe).
+                if (evt.userId === this._localUser.userId)
+                    return;
+                const message = {
+                    id: evt.id,
+                    userId: evt.userId,
+                    username: evt.username,
+                    avatar: evt.avatar,
+                    text: '',
+                    timestamp: evt.timestamp,
+                    status: 'streaming',
+                    isReplay: false,
+                };
+                if (this._messageStore.add(message)) {
+                    this.emit('streamStart', message);
+                }
+                break;
+            }
+            case 'delta': {
+                const message = this._messageStore.get(evt.id);
+                if (message && message.status === 'streaming') {
+                    message.text += evt.text;
+                    this.emit('streamChunk', { message, delta: evt.text });
+                }
+                break;
+            }
+            case 'abort': {
+                const message = this._messageStore.get(evt.id);
+                if (message && message.status === 'streaming') {
+                    message.status = 'aborted';
+                    this.emit('streamAbort', { message, error: evt.error });
+                }
+                break;
+            }
+        }
+    }
+    _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,
+            // Scope tag: on a shared client, other apps' wrappers filter our
+            // presence out by this (and we filter theirs).
+            __scope: this._options.appName,
+        };
+        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.
+ *
+ * The wrapper NEVER manages the connection. The app owns one core NoLag
+ * client (shared by any number of wrappers on distinct apps) and the
+ * wrapper attaches to it at construction and releases it via `detach()`.
+ *
+ * @example
+ * ```typescript
+ * import { NoLag } from '@nolag/js-sdk';
+ * import { NoLagChat } from '@nolag/chat';
+ *
+ * const client = NoLag(async () => (await (await fetch('/api/nolag-token')).json()).token);
+ * const chat = new NoLagChat({ client, appName: 'my-chat', username: 'Alice' });
+ *
+ * chat.on('userOnline', (user) => console.log(user.username, 'is online'));
+ *
+ * await client.connect();   // the app owns the connection
+ * await chat.ready();       // wrapper setup done (identity, lobby, rooms)
+ *
+ * const room = chat.joinRoom('general');
+ * room.on('message', (msg) => console.log(msg.username + ':', msg.text));
+ * room.sendMessage('Hello!');
+ *
+ * chat.detach();            // wrapper releases its handlers and topics
+ * client.disconnect();      // the app closes the socket
+ * ```
+ */
+class NoLagChat extends EventEmitter {
+    constructor(options) {
+        super();
+        this._localUser = null;
+        this._rooms = new Map();
+        this._lobby = null;
+        this._onlineUsers = new Map();
+        this._actorToUserId = new Map();
+        this._activeRoom = null;
+        // Lifecycle: one setup run per connection epoch; detach is terminal.
+        this._epoch = 0;
+        this._detached = false;
+        this._isReady = false;
+        this._lobbyRefreshTimer = null;
+        // Stored client handler refs. INVARIANT: every client.on() below has a
+        // matching client.off() in detach() — never bare off(event), never inline
+        // closures on the client.
+        this._onConnectRef = () => this._onConnect();
+        this._onDisconnectRef = (reason) => {
+            this._log('Disconnected:', reason);
+            this.emit('disconnected', reason);
+        };
+        this._onReconnectRef = () => {
+            this._log('Reconnecting...');
+            this.emit('reconnecting');
+        };
+        this._onErrorRef = (error) => {
+            this._log('Error:', error);
+            this.emit('error', error);
+        };
+        this._onReplayStartRef = (data) => {
+            const event = data;
+            for (const room of this._rooms.values()) {
+                room._handleReplayStart(event.count);
+            }
+        };
+        this._onReplayEndRef = (data) => {
+            const event = data;
+            for (const room of this._rooms.values()) {
+                room._handleReplayEnd(event.replayed);
+            }
+        };
+        this._onPresenceJoinRef = (data) => this._handleRoomPresenceJoin(data);
+        this._onPresenceLeaveRef = (data) => this._handleRoomPresenceLeave(data);
+        this._onPresenceUpdateRef = (data) => this._handleRoomPresenceUpdate(data);
+        this._onLobbyJoinRef = (data) => this._handleLobbyJoin(data);
+        this._onLobbyLeaveRef = (data) => this._handleLobbyLeave(data);
+        this._onLobbyUpdateRef = (data) => this._handleLobbyUpdate(data);
+        if (!options?.client) {
+            throw new TypeError('NoLagChat requires an injected NoLag client: new NoLagChat({ client, username, ... })');
+        }
+        this._client = options.client;
+        this._userId = generateId();
+        this._options = {
+            username: options.username,
+            avatar: options.avatar,
+            metadata: options.metadata,
+            appName: options.appName ?? DEFAULT_APP_NAME,
+            typingTimeout: options.typingTimeout ?? DEFAULT_TYPING_TIMEOUT,
+            maxMessageCache: options.maxMessageCache ?? DEFAULT_MAX_MESSAGE_CACHE,
+            debug: options.debug ?? false,
+            rooms: options.rooms ?? [],
+        };
+        this._log = createLogger('NoLagChat', this._options.debug);
+        this._readyPromise = new Promise((resolve, reject) => {
+            this._readyResolve = resolve;
+            this._readyReject = reject;
+        });
+        // ready() rejection is only meaningful to callers that await it
+        this._readyPromise.catch(() => { });
+        registerWrapper(this._client, this._options.appName, 'NoLagChat');
+        // Construction = attach: wire everything now, with stored refs.
+        this._client.on('connect', this._onConnectRef);
+        this._client.on('disconnect', this._onDisconnectRef);
+        this._client.on('reconnect', this._onReconnectRef);
+        this._client.on('error', this._onErrorRef);
+        this._client.on('replay:start', this._onReplayStartRef);
+        this._client.on('replay:end', this._onReplayEndRef);
+        this._client.on('presence:join', this._onPresenceJoinRef);
+        this._client.on('presence:leave', this._onPresenceLeaveRef);
+        this._client.on('presence:update', this._onPresenceUpdateRef);
+        this._client.on('lobbyPresence:join', this._onLobbyJoinRef);
+        this._client.on('lobbyPresence:leave', this._onLobbyLeaveRef);
+        this._client.on('lobbyPresence:update', this._onLobbyUpdateRef);
+        // Attach-to-connected: if the client is already authenticated, run setup.
+        // The microtask lets the caller wire wrapper event handlers synchronously
+        // first; a racing real 'connect' event wins via the epoch guard.
+        queueMicrotask(() => {
+            if (this._epoch === 0 && !this._detached && this._client.connected) {
+                this._onConnect();
+            }
+        });
+    }
+    // ============ Public Properties ============
+    /** Whether the underlying connection is established (connected ≠ ready) */
+    get connected() {
+        return !this._detached && this._client.connected;
+    }
+    /** The injected core client (owned by the app, not the wrapper) */
+    get client() {
+        return this._client;
+    }
+    /** The local user's info (available after ready) */
+    get localUser() {
+        return this._localUser;
+    }
+    /** All currently joined rooms */
+    get rooms() {
+        return this._rooms;
+    }
+    // ============ Lifecycle ============
+    /**
+     * Resolves once the wrapper's first setup completed (identity, lobby and
+     * configured rooms ready — equivalently, once 'connected' has fired).
+     * Rejects only if detach() is called before that. Client auth failures
+     * surface via the app's own `await client.connect()`, not here.
+     */
+    ready() {
+        return this._readyPromise;
+    }
+    /**
+     * Detach from the client: remove every handler this wrapper added,
+     * unsubscribe its topics and lobby (when connected), clear state.
+     * Terminal and idempotent; never touches the socket. To use chat again,
+     * construct a new instance.
+     */
+    detach() {
+        if (this._detached)
+            return;
+        this._log('Detaching...');
+        this._detached = true;
+        this._epoch++; // aborts any in-flight setup at its next checkpoint
+        if (this._lobbyRefreshTimer) {
+            clearTimeout(this._lobbyRefreshTimer);
+            this._lobbyRefreshTimer = null;
+        }
+        // Remove all client handlers by stored ref
+        this._client.off('connect', this._onConnectRef);
+        this._client.off('disconnect', this._onDisconnectRef);
+        this._client.off('reconnect', this._onReconnectRef);
+        this._client.off('error', this._onErrorRef);
+        this._client.off('replay:start', this._onReplayStartRef);
+        this._client.off('replay:end', this._onReplayEndRef);
+        this._client.off('presence:join', this._onPresenceJoinRef);
+        this._client.off('presence:leave', this._onPresenceLeaveRef);
+        this._client.off('presence:update', this._onPresenceUpdateRef);
+        this._client.off('lobbyPresence:join', this._onLobbyJoinRef);
+        this._client.off('lobbyPresence:leave', this._onLobbyLeaveRef);
+        this._client.off('lobbyPresence:update', this._onLobbyUpdateRef);
+        // Rooms: handler-specific off + connected-gated server unsubscribe
+        for (const name of [...this._rooms.keys()]) {
+            this._rooms.get(name)._cleanup();
+            this._rooms.delete(name);
+        }
+        this._activeRoom = null;
+        // Lobby: server unsubscribe is best-effort and needs a live socket
+        if (this._lobby && this._client.connected) {
+            try {
+                this._lobby.unsubscribe();
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        this._lobby = null;
+        this._onlineUsers.clear();
+        this._actorToUserId.clear();
+        this._localUser = null;
+        releaseWrapper(this._client, this._options.appName);
+        if (!this._isReady) {
+            this._readyReject(new Error('NoLagChat detached before ready'));
+        }
+    }
+    // ============ Private: Epoch Setup ============
+    _onConnect() {
+        this._epoch++;
+        void this._runSetup(this._epoch);
+    }
+    /**
+     * One setup pass per connection epoch. Serves both initial setup (epoch 1)
+     * and reconnect restore (epoch > 1). Aborts silently whenever a newer
+     * epoch started or the wrapper detached — checked after every await.
+     */
+    async _runSetup(epoch) {
+        const stale = () => epoch !== this._epoch || this._detached;
+        this._log(this._isReady ? 'Restoring after reconnect...' : 'Setting up...');
+        // Identity (client.actorId is guaranteed post-auth)
+        if (!this._localUser) {
+            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);
+        }
+        else {
+            this._localUser.actorTokenId = this._client.actorId;
+        }
+        // Lobby: subscribe every epoch (idempotent server-side) and diff-hydrate
+        // from the returned snapshot — one path for setup and restore.
+        if (!this._lobby) {
+            this._lobby = this._client.setApp(this._options.appName).setLobby(LOBBY_ID);
+        }
+        try {
+            const state = await this._lobby.subscribe();
+            if (stale())
+                return;
+            this._diffHydrateOnlineUsers(state);
+            this._log('Lobby subscribed, online users:', this._onlineUsers.size);
+        }
+        catch (err) {
+            if (stale())
+                return;
+            this._log('Lobby subscription failed:', err);
+        }
+        if (!this._isReady) {
+            // First successful setup: pre-subscribe configured rooms
+            // (messages only, no presence)
+            for (const roomName of this._options.rooms) {
+                this._subscribeRoomInternal(roomName);
+            }
+        }
+        else if (this._activeRoom) {
+            // Server auto-restored topic subscriptions; only room-scoped presence
+            // needs re-applying (the core does not restore it).
+            this._rooms.get(this._activeRoom)?._updateLocalPresence();
+        }
+        if (stale())
+            return;
+        // Ready keys on the first setup that COMPLETES, not on epoch 1: an
+        // epoch aborted by a racing reconnect must not strand ready().
+        if (!this._isReady) {
+            this._isReady = true;
+            this._readyResolve();
+            this.emit('connected');
+        }
+        else {
+            this.emit('reconnected');
+        }
+        // Deferred lobby refetch: catches users who joined during the setup
+        // window (e.g. simultaneous multi-tab connects).
+        this._scheduleLobbyRefresh(epoch);
+    }
+    _scheduleLobbyRefresh(epoch) {
+        if (this._lobbyRefreshTimer)
+            clearTimeout(this._lobbyRefreshTimer);
+        this._lobbyRefreshTimer = setTimeout(() => {
+            this._lobbyRefreshTimer = null;
+            if (epoch !== this._epoch || this._detached || !this._client.connected || !this._lobby) {
+                return;
+            }
+            this._lobby
+                .fetchPresence()
+                .then((state) => {
+                if (epoch !== this._epoch || this._detached)
+                    return;
+                this._diffHydrateOnlineUsers(state);
+            })
+                .catch(() => {
+                /* best-effort */
+            });
+        }, LOBBY_REFRESH_DELAY_MS);
+    }
+    // ============ 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, opts) {
+        this._assertUsable();
+        // 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._subscribeRoomInternal(name, opts?.filters);
+        }
+        else if (opts?.filters) {
+            // Already subscribed (pre-subscribed via the `rooms` option, or an
+            // earlier join). Re-point its filters rather than ignoring them.
+            room.setFilters(opts.filters);
+        }
+        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: Guards ============
+    _assertUsable() {
+        if (this._detached) {
+            throw new Error('NoLagChat has been detached — construct a new instance');
+        }
+        if (!this._isReady || !this._localUser) {
+            throw new Error('NoLagChat not ready — await ready() or the "connected" event');
+        }
+    }
+    // ============ Private: Room Setup ============
+    _subscribeRoomInternal(name, filters) {
+        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._client.connected);
+        this._rooms.set(name, room);
+        room._subscribe(filters);
+        return room;
+    }
+    // ============ Private: Scope Filtering ============
+    /**
+     * On a shared client, presence events from other apps' wrappers arrive on
+     * the same connection-level events. Wrappers stamp their presence with a
+     * `__scope` (their appName); a mismatched tag means another app's data.
+     * Untagged presence is accepted (older peers in this same app).
+     */
+    _foreignScope(data) {
+        const scope = data?.__scope;
+        return typeof scope === 'string' && scope !== this._options.appName;
+    }
+    // ============ Private: Room Presence → Active Room ============
+    _handleRoomPresenceJoin(data) {
+        if (data.actorTokenId === this._localUser?.actorTokenId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.userId || this._foreignScope(presenceData))
+            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 || this._foreignScope(presenceData))
+            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 ============
+    _handleLobbyJoin(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localUser?.actorTokenId)
+            return;
+        const presenceData = data;
+        if (!presenceData.userId || this._foreignScope(presenceData))
+            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;
+        if (this._foreignScope(presenceData))
+            return;
+        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 || this._foreignScope(presenceData))
+            return;
+        const user = this._presenceToUser(actorId, presenceData);
+        this._onlineUsers.set(user.userId, user);
+        this.emit('userUpdated', user);
+    }
+    /**
+     * Reconcile the online-user map against a fresh lobby snapshot, emitting
+     * only the deltas (userOffline for vanished, userOnline for new,
+     * userUpdated for changed). One path for initial hydration, reconnect
+     * restore, and the deferred refetch.
+     */
+    _diffHydrateOnlineUsers(state) {
+        // Build the fresh user set from the snapshot
+        const fresh = new Map();
+        const freshActors = new Map();
+        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 && !this._foreignScope(presenceData)) {
+                    if (!fresh.has(presenceData.userId)) {
+                        fresh.set(presenceData.userId, this._presenceToUser(actorId, presenceData));
+                    }
+                    freshActors.set(actorId, presenceData.userId);
+                }
+            }
+        }
+        // Vanished users
+        for (const [userId, user] of [...this._onlineUsers]) {
+            if (!fresh.has(userId)) {
+                this._onlineUsers.delete(userId);
+                for (const [actorId, mappedUserId] of [...this._actorToUserId]) {
+                    if (mappedUserId === userId)
+                        this._actorToUserId.delete(actorId);
+                }
+                this.emit('userOffline', user);
+            }
+        }
+        // New and changed users
+        for (const [userId, user] of fresh) {
+            const prev = this._onlineUsers.get(userId);
+            if (!prev) {
+                this._onlineUsers.set(userId, user);
+                this.emit('userOnline', user);
+            }
+            else if (prev.username !== user.username ||
+                prev.avatar !== user.avatar ||
+                prev.status !== user.status) {
+                this._onlineUsers.set(userId, user);
+                this.emit('userUpdated', user);
+            }
+        }
+        for (const [actorId, userId] of freshActors) {
+            this._actorToUserId.set(actorId, userId);
+        }
+    }
+    // ============ 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;
+    }
+}
+
+export { ChatRoom, EventEmitter, NoLagChat };
+//# sourceMappingURL=react-native.js.map