@nolag/signal 1.0.0 → 1.2.0

package/dist/react-native.js

@@ -0,0 +1,932 @@
+/**
+ * Tiny typed event emitter — framework-agnostic base for NoLag SDKs.
+ *
+ * EventMap is a record of event name → tuple of handler arguments.
+ */
+class EventEmitter {
+    constructor() {
+        this._handlers = new Map();
+    }
+    on(event, handler) {
+        if (!this._handlers.has(event)) {
+            this._handlers.set(event, new Set());
+        }
+        this._handlers.get(event).add(handler);
+        return this;
+    }
+    off(event, handler) {
+        if (handler) {
+            this._handlers.get(event)?.delete(handler);
+        }
+        else {
+            this._handlers.delete(event);
+        }
+        return this;
+    }
+    removeAllListeners() {
+        this._handlers.clear();
+        return this;
+    }
+    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);
+            }
+        }
+    }
+    listenerCount(event) {
+        return this._handlers.get(event)?.size ?? 0;
+    }
+}
+
+/**
+ * Maps actorTokenId ↔ Peer, filtering self.
+ */
+class PeerManager {
+    constructor(localActorId) {
+        this._peers = new Map();
+        this._actorToPeerId = new Map();
+        this._localActorId = localActorId;
+    }
+    /**
+     * Add or update a peer from presence data.
+     * Returns the Peer if it's a remote peer, null if it's self.
+     */
+    addFromPresence(actorTokenId, presence, joinedAt) {
+        const isLocal = actorTokenId === this._localActorId;
+        // Skip self
+        if (isLocal)
+            return null;
+        const existing = this._actorToPeerId.get(actorTokenId);
+        const peerId = presence.peerId || existing || actorTokenId;
+        const peer = {
+            peerId,
+            actorTokenId,
+            connectionState: 'new',
+            metadata: presence.metadata,
+            joinedAt: joinedAt || Date.now(),
+            isLocal: false,
+        };
+        this._peers.set(peerId, peer);
+        this._actorToPeerId.set(actorTokenId, peerId);
+        return peer;
+    }
+    /**
+     * Remove a peer by actorTokenId.
+     * Returns the removed peer, or null if not found / is self.
+     */
+    removeByActorId(actorTokenId) {
+        if (actorTokenId === this._localActorId)
+            return null;
+        const peerId = this._actorToPeerId.get(actorTokenId);
+        if (!peerId)
+            return null;
+        const peer = this._peers.get(peerId) || null;
+        this._peers.delete(peerId);
+        this._actorToPeerId.delete(actorTokenId);
+        return peer;
+    }
+    /**
+     * Get a peer by peerId.
+     */
+    getPeer(peerId) {
+        return this._peers.get(peerId);
+    }
+    /**
+     * Get a peer by actorTokenId.
+     */
+    getPeerByActorId(actorTokenId) {
+        const peerId = this._actorToPeerId.get(actorTokenId);
+        return peerId ? this._peers.get(peerId) : undefined;
+    }
+    /**
+     * Get all remote peers.
+     */
+    getAll() {
+        return Array.from(this._peers.values());
+    }
+    /**
+     * Get the peers Map (readonly view).
+     */
+    get peers() {
+        return this._peers;
+    }
+    /**
+     * Clear all tracked peers.
+     */
+    clear() {
+        this._peers.clear();
+        this._actorToPeerId.clear();
+    }
+}
+
+function generateId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return 'xxxx-xxxx-xxxx-xxxx'.replace(/x/g, () => Math.floor(Math.random() * 16).toString(16));
+}
+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 NoLag signal SDK */
+const DEFAULT_APP_NAME = 'signal';
+/** Topic name for signaling messages within a room */
+const TOPIC_SIGNALING = 'signaling';
+/** 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;
+
+/**
+ * SignalRoom — a single signaling room for WebRTC peer discovery and exchange.
+ *
+ * Created via `NoLagSignal.joinRoom(name)`. Do not instantiate directly.
+ */
+class SignalRoom extends EventEmitter {
+    /** @internal */
+    constructor(name, roomContext, localPeer, options, log, isConnected) {
+        super();
+        // Stored topic handler ref — cleanup removes exactly this, never all
+        // handlers for a topic (the client may be shared with other consumers).
+        this._onSignalingRef = null;
+        /** Filter values applied to the signaling subscription. */
+        this._filters = [];
+        this.name = name;
+        this._roomContext = roomContext;
+        this._localPeer = localPeer;
+        this._options = options;
+        this._log = log;
+        this._isConnected = isConnected;
+        this._peerManager = new PeerManager(localPeer.actorTokenId);
+    }
+    // ============ Public Properties ============
+    /** All remote peers currently in this room */
+    get peers() {
+        return this._peerManager.peers;
+    }
+    // ============ Signaling ============
+    /**
+     * Send an SDP offer to a specific peer.
+     */
+    sendOffer(toPeerId, offer, opts) {
+        this.signal(toPeerId, 'offer', offer, opts);
+    }
+    /**
+     * Send an SDP answer to a specific peer.
+     */
+    sendAnswer(toPeerId, answer, opts) {
+        this.signal(toPeerId, 'answer', answer, opts);
+    }
+    /**
+     * Send an ICE candidate to a specific peer.
+     */
+    sendIceCandidate(toPeerId, candidate, opts) {
+        this.signal(toPeerId, 'ice-candidate', candidate, opts);
+    }
+    /**
+     * Send a bye signal to a specific peer (graceful close).
+     */
+    sendBye(toPeerId, opts) {
+        this.signal(toPeerId, 'bye', {}, opts);
+    }
+    /**
+     * Send a generic signal message to a specific peer.
+     *
+     * By default this broadcasts to the room and peers discard messages not
+     * addressed to them. Pass `{ filter: toPeerId }` to have the server do the
+     * addressing instead, so the signal is only delivered to that peer.
+     */
+    signal(toPeerId, type, payload, opts) {
+        const message = {
+            id: generateId(),
+            type,
+            fromPeerId: this._localPeer.peerId,
+            toPeerId,
+            payload,
+            timestamp: Date.now(),
+        };
+        this._log('Sending signal:', type, '→', toPeerId);
+        this._roomContext.emit(TOPIC_SIGNALING, message, { echo: false, ...filterEmitOptions(opts) });
+    }
+    // ============ Filters ============
+    /** This peer's own id — the value to filter on to receive directed signals. */
+    get localPeerId() {
+        return this._localPeer.peerId;
+    }
+    /** The filter values currently applied to this room's signaling. */
+    get filters() {
+        return [...this._filters];
+    }
+    /**
+     * Replace this room's signaling filters — only signals published with one of
+     * these values are delivered. Set your own peerId to receive only signals
+     * addressed to you, and send with `{ filter: toPeerId }` so the server does
+     * the addressing rather than every peer discarding other peers' traffic.
+     *
+     * A filtered peer stops receiving unfiltered room broadcasts, so switch the
+     * whole room over together. Passing an empty array restores the wildcard
+     * subscription, which receives everything.
+     *
+     * @example
+     * ```ts
+     * room.setFilters([room.localPeerId]);  // only signals addressed to me
+     * room.setFilters([]);                  // back to room broadcast
+     * ```
+     */
+    setFilters(values) {
+        this._filters = [...values];
+        // The core types filters as `string[]`, but both its implementation and
+        // the wire protocol accept AND groups (nested arrays).
+        this._roomContext.setFilters(TOPIC_SIGNALING, this._filters);
+    }
+    /** 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));
+    }
+    // ============ Peers ============
+    /**
+     * Get all remote peers in this room.
+     */
+    getPeers() {
+        return this._peerManager.getAll();
+    }
+    /**
+     * Get a specific peer by peerId.
+     */
+    getPeer(peerId) {
+        return this._peerManager.getPeer(peerId);
+    }
+    // ============ Internal (called by NoLagSignal) ============
+    /** @internal Subscribe to signaling topic and attach listeners */
+    _subscribe(filters) {
+        this._log('Room subscribe:', this.name);
+        this._filters = filters ? [...filters] : [];
+        if (this._filters.length > 0) {
+            this._roomContext.subscribe(TOPIC_SIGNALING, { filters: this._filters });
+        }
+        else {
+            this._roomContext.subscribe(TOPIC_SIGNALING);
+        }
+        // Listen for signals (ref stored for handler-specific removal)
+        this._onSignalingRef = (data) => {
+            this._handleIncomingSignal(data);
+        };
+        this._roomContext.on(TOPIC_SIGNALING, this._onSignalingRef);
+    }
+    /** @internal Set presence and fetch room members */
+    _activate() {
+        this._log('Room activate:', this.name);
+        this._setPresence();
+        this._roomContext.fetchPresence().then((actors) => {
+            this._log('Room presence fetched:', this.name, actors.length, 'actors');
+            for (const actor of actors) {
+                if (actor.presence) {
+                    const peer = this._peerManager.addFromPresence(actor.actorTokenId, actor.presence, actor.joinedAt);
+                    if (peer) {
+                        this.emit('peerJoined', peer);
+                    }
+                }
+            }
+        }).catch((err) => {
+            this._log('Failed to fetch room presence:', err);
+        });
+    }
+    /** @internal Re-set presence after reconnect */
+    _updateLocalPresence() {
+        this._setPresence();
+    }
+    /** @internal Handle a presence:join event */
+    _handlePresenceJoin(actorTokenId, presenceData) {
+        const peer = this._peerManager.addFromPresence(actorTokenId, presenceData);
+        if (peer) {
+            this._log('Peer joined room:', this.name, peer.peerId);
+            this.emit('peerJoined', peer);
+        }
+    }
+    /** @internal Handle a presence:leave event */
+    _handlePresenceLeave(actorTokenId) {
+        const peer = this._peerManager.removeByActorId(actorTokenId);
+        if (peer) {
+            this._log('Peer left room:', this.name, peer.peerId);
+            this.emit('peerLeft', peer);
+        }
+    }
+    /** @internal Handle a presence:update event */
+    _handlePresenceUpdate(actorTokenId, presenceData) {
+        this._peerManager.addFromPresence(actorTokenId, presenceData);
+    }
+    /** @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_SIGNALING);
+        }
+        // Handler-specific removal only: the client may be shared, and a bare
+        // off(topic) would strip other consumers' handlers too.
+        if (this._onSignalingRef)
+            this._roomContext.off(TOPIC_SIGNALING, this._onSignalingRef);
+        this._onSignalingRef = null;
+        this._peerManager.clear();
+        this.removeAllListeners();
+    }
+    // ============ Private ============
+    _handleIncomingSignal(data) {
+        const message = data;
+        // Only process messages targeted at this peer
+        if (message.toPeerId !== this._localPeer.peerId)
+            return;
+        this._log('Received signal:', message.type, 'from', message.fromPeerId);
+        this.emit('signal', message);
+    }
+    _setPresence() {
+        const presenceData = {
+            peerId: this._localPeer.peerId,
+            metadata: this._localPeer.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);
+    }
+}
+
+/**
+ * NoLagSignal — high-level WebRTC signaling SDK built on @nolag/js-sdk.
+ *
+ * Provides peer discovery, offer/answer/ICE exchange, and global presence
+ * tracking — 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 { NoLagSignal } from '@nolag/signal';
+ *
+ * const client = NoLag(async () => (await (await fetch('/api/nolag-token')).json()).token);
+ * const signal = new NoLagSignal({ client, appName: 'my-signal' });
+ *
+ * signal.on('peerOnline', (peer) => console.log(peer.peerId, 'is online'));
+ *
+ * await client.connect();   // the app owns the connection
+ * await signal.ready();     // wrapper setup done (identity, lobby)
+ *
+ * const room = signal.joinRoom('call-room');
+ * room.on('signal', (msg) => {
+ *   if (msg.type === 'offer') handleOffer(msg);
+ * });
+ * room.sendOffer(remotePeerId, offer);
+ *
+ * signal.detach();          // wrapper releases its handlers and topics
+ * client.disconnect();      // the app closes the socket
+ * ```
+ */
+class NoLagSignal extends EventEmitter {
+    constructor(options) {
+        super();
+        this._localPeer = null;
+        this._rooms = new Map();
+        this._lobby = null;
+        this._onlinePeers = new Map();
+        this._actorToPeerId = new Map();
+        // 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._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('NoLagSignal requires an injected NoLag client: new NoLagSignal({ client, ... })');
+        }
+        this._client = options.client;
+        this._peerId = generateId();
+        this._options = {
+            metadata: options.metadata,
+            appName: options.appName ?? DEFAULT_APP_NAME,
+            debug: options.debug ?? false,
+        };
+        this._log = createLogger('NoLagSignal', 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, 'NoLagSignal');
+        // 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('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 peer's info (available after ready) */
+    get localPeer() {
+        return this._localPeer;
+    }
+    /** All currently joined rooms */
+    get rooms() {
+        return this._rooms;
+    }
+    // ============ Lifecycle ============
+    /**
+     * Resolves once the wrapper's first setup completed (identity and lobby
+     * 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 signaling
+     * 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('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);
+        }
+        // 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._onlinePeers.clear();
+        this._actorToPeerId.clear();
+        this._localPeer = null;
+        releaseWrapper(this._client, this._options.appName);
+        if (!this._isReady) {
+            this._readyReject(new Error('NoLagSignal 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._localPeer) {
+            this._localPeer = {
+                peerId: this._peerId,
+                actorTokenId: this._client.actorId,
+                connectionState: 'new',
+                metadata: this._options.metadata,
+                joinedAt: Date.now(),
+                isLocal: true,
+            };
+            this._log('Local peer:', this._localPeer.peerId, '→', this._localPeer.actorTokenId);
+        }
+        else {
+            this._localPeer.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._diffHydrateOnlinePeers(state);
+            this._log('Lobby subscribed, online peers:', this._onlinePeers.size);
+        }
+        catch (err) {
+            if (stale())
+                return;
+            this._log('Lobby subscription failed:', err);
+        }
+        if (this._isReady) {
+            // Server auto-restored topic subscriptions; only room-scoped presence
+            // needs re-applying (the core does not restore it).
+            for (const room of this._rooms.values()) {
+                room._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 peers 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._diffHydrateOnlinePeers(state);
+            })
+                .catch(() => {
+                /* best-effort */
+            });
+        }, LOBBY_REFRESH_DELAY_MS);
+    }
+    // ============ Room Management ============
+    /**
+     * Join a signaling room. Creates, subscribes, and activates it.
+     * Returns an existing room if already joined.
+     */
+    joinRoom(name, opts) {
+        this._assertUsable();
+        let room = this._rooms.get(name);
+        if (!room) {
+            room = this._subscribeRoom(name, opts?.filters);
+            room._activate();
+        }
+        else if (opts?.filters) {
+            // Already joined — re-point its filters rather than ignoring them.
+            room.setFilters(opts.filters);
+        }
+        return room;
+    }
+    /**
+     * Leave a signaling 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);
+    }
+    /**
+     * Get all joined rooms.
+     */
+    getRooms() {
+        return Array.from(this._rooms.values());
+    }
+    // ============ Global Presence ============
+    /**
+     * Get all peers currently online across all rooms.
+     */
+    getOnlinePeers() {
+        return Array.from(this._onlinePeers.values());
+    }
+    // ============ Private: Guards ============
+    _assertUsable() {
+        if (this._detached) {
+            throw new Error('NoLagSignal has been detached — construct a new instance');
+        }
+        if (!this._isReady || !this._localPeer) {
+            throw new Error('NoLagSignal not ready — await ready() or the "connected" event');
+        }
+    }
+    // ============ Private: Room Setup ============
+    _subscribeRoom(name, filters) {
+        this._log('Subscribing room:', name);
+        const roomContext = this._client.setApp(this._options.appName).setRoom(name);
+        const room = new SignalRoom(name, roomContext, this._localPeer, this._options, createLogger(`SignalRoom:${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 ============
+    _handleRoomPresenceJoin(data) {
+        if (data.actorTokenId === this._localPeer?.actorTokenId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.peerId || this._foreignScope(presenceData))
+            return;
+        const peer = this._presenceToPeer(data.actorTokenId, presenceData);
+        this._actorToPeerId.set(data.actorTokenId, peer.peerId);
+        if (!this._onlinePeers.has(peer.peerId)) {
+            this._onlinePeers.set(peer.peerId, peer);
+            this.emit('peerOnline', peer);
+        }
+        // Route to all rooms
+        for (const room of this._rooms.values()) {
+            room._handlePresenceJoin(data.actorTokenId, presenceData);
+        }
+    }
+    _handleRoomPresenceLeave(data) {
+        if (data.actorTokenId === this._localPeer?.actorTokenId)
+            return;
+        // Route to all rooms
+        for (const room of this._rooms.values()) {
+            room._handlePresenceLeave(data.actorTokenId);
+        }
+    }
+    _handleRoomPresenceUpdate(data) {
+        if (data.actorTokenId === this._localPeer?.actorTokenId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.peerId || this._foreignScope(presenceData))
+            return;
+        if (this._onlinePeers.has(presenceData.peerId)) {
+            const peer = this._presenceToPeer(data.actorTokenId, presenceData);
+            this._onlinePeers.set(peer.peerId, peer);
+        }
+        // Route to all rooms
+        for (const room of this._rooms.values()) {
+            room._handlePresenceUpdate(data.actorTokenId, presenceData);
+        }
+    }
+    // ============ Private: Lobby ============
+    _handleLobbyJoin(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localPeer?.actorTokenId)
+            return;
+        const presenceData = data;
+        if (!presenceData.peerId || this._foreignScope(presenceData))
+            return;
+        const peer = this._presenceToPeer(actorId, presenceData);
+        this._actorToPeerId.set(actorId, peer.peerId);
+        if (!this._onlinePeers.has(peer.peerId)) {
+            this._onlinePeers.set(peer.peerId, peer);
+            this.emit('peerOnline', peer);
+        }
+    }
+    _handleLobbyLeave(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localPeer?.actorTokenId)
+            return;
+        const presenceData = data;
+        if (this._foreignScope(presenceData))
+            return;
+        const peerId = presenceData?.peerId
+            || this._actorToPeerId.get(actorId)
+            || this._findPeerIdByActorId(actorId);
+        if (peerId) {
+            const peer = this._onlinePeers.get(peerId);
+            if (peer) {
+                this._onlinePeers.delete(peerId);
+                this._actorToPeerId.delete(actorId);
+                this.emit('peerOffline', peer);
+            }
+        }
+    }
+    _handleLobbyUpdate(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localPeer?.actorTokenId)
+            return;
+        const presenceData = data;
+        if (!presenceData.peerId || this._foreignScope(presenceData))
+            return;
+        const peer = this._presenceToPeer(actorId, presenceData);
+        this._onlinePeers.set(peer.peerId, peer);
+    }
+    /**
+     * Reconcile the online-peer map against a fresh lobby snapshot, emitting
+     * only the deltas (peerOffline for vanished, peerOnline for new). One path
+     * for initial hydration, reconnect restore, and the deferred refetch.
+     */
+    _diffHydrateOnlinePeers(state) {
+        // Build the fresh peer 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._localPeer?.actorTokenId)
+                    continue;
+                const raw = roomPresence[actorId];
+                // Server returns full actor records with presence nested under .presence
+                const presenceData = (raw?.presence ?? raw);
+                if (presenceData?.peerId && !this._foreignScope(presenceData)) {
+                    if (!fresh.has(presenceData.peerId)) {
+                        fresh.set(presenceData.peerId, this._presenceToPeer(actorId, presenceData));
+                    }
+                    freshActors.set(actorId, presenceData.peerId);
+                }
+            }
+        }
+        // Vanished peers
+        for (const [peerId, peer] of [...this._onlinePeers]) {
+            if (!fresh.has(peerId)) {
+                this._onlinePeers.delete(peerId);
+                for (const [actorId, mappedPeerId] of [...this._actorToPeerId]) {
+                    if (mappedPeerId === peerId)
+                        this._actorToPeerId.delete(actorId);
+                }
+                this.emit('peerOffline', peer);
+            }
+        }
+        // New peers
+        for (const [peerId, peer] of fresh) {
+            if (!this._onlinePeers.has(peerId)) {
+                this._onlinePeers.set(peerId, peer);
+                this.emit('peerOnline', peer);
+            }
+        }
+        for (const [actorId, peerId] of freshActors) {
+            this._actorToPeerId.set(actorId, peerId);
+        }
+    }
+    // ============ Private: Helpers ============
+    _presenceToPeer(actorTokenId, data) {
+        return {
+            peerId: data.peerId,
+            actorTokenId,
+            connectionState: 'new',
+            metadata: data.metadata,
+            joinedAt: Date.now(),
+            isLocal: false,
+        };
+    }
+    _findPeerIdByActorId(actorTokenId) {
+        for (const peer of this._onlinePeers.values()) {
+            if (peer.actorTokenId === actorTokenId)
+                return peer.peerId;
+        }
+        return undefined;
+    }
+}
+
+export { EventEmitter, NoLagSignal, SignalRoom };
+//# sourceMappingURL=react-native.js.map