@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/esm/signaling/Signaling.js

@@ -0,0 +1,941 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Component, DTO } from '@lakutata/core';
+import { Configurable, Singleton } from '@lakutata/core/decorator/di';
+import { SIGNALING_PROTOCOL_VERSION, SignalingEvent } from '../protocol/SignalingProtocol.js';
+import { rendezvous } from '../cluster/Rendezvous.js';
+import { iceServersFor } from '../cluster/ClusterTURN.js';
+import { SignalingDeniedException } from '../exceptions/SignalingDeniedException.js';
+import { SignalingLimitException } from '../exceptions/SignalingLimitException.js';
+import { SignalingNotAMemberException } from '../exceptions/SignalingNotAMemberException.js';
+import { MEDIA_SERVER_ASSIGN_TOPIC, MEDIA_SERVER_SERVICE, mediaServers } from './MediaServers.js';
+/**
+ * The topics of the signaling on the cluster
+ */
+const TOPIC = {
+    membership: 'webrtc.signaling.membership',
+    snapshot: 'webrtc.signaling.snapshot',
+    deliver: 'webrtc.signaling.deliver',
+    admit: 'webrtc.signaling.admit'
+};
+/**
+ * How long a signal waits for the node of its receiver, and an admission for the node of its room, in milliseconds
+ */
+const CLUSTER_REQUEST_TIMEOUT = 2000;
+/**
+ * How long a place in a full room is held for a member admitted by the node of the room, until its join arrives
+ */
+const RESERVATION_TIMEOUT = 5000;
+/**
+ * The beginnings of the ids kept for the members the server adds itself
+ */
+const RESERVED_PREFIXES = ['sfu:', 'whip:'];
+/**
+ * Whether a join is later than another: by time, then by node id when at the same millisecond
+ * @param join
+ * @param other
+ */
+function later(join, other) {
+    return join.joinedAt !== other.joinedAt ? join.joinedAt > other.joinedAt : join.node > other.node;
+}
+/**
+ * A member as the other members see it, without the fields it does not have
+ * @param peerId
+ * @param metadata
+ * @param session
+ * @param role
+ * @param sfu
+ */
+function peerOf(peerId, metadata, session, role, sfu) {
+    return { peerId: peerId, metadata: metadata, session: session, ...role ? { role: role } : {}, ...sfu ? { sfu: sfu } : {} };
+}
+/**
+ * A member of this node in a room, as the node tells the others
+ * @param room
+ * @param member
+ */
+function recordOf(room, member) {
+    const sfu = member.sfus.get(room);
+    return { room: room, peerId: member.peerId, metadata: member.rooms.get(room), session: member.session, joinedAt: member.joinedAt.get(room) ?? 0, ...member.role ? { role: member.role } : {}, ...sfu ? { sfu: sfu } : {} };
+}
+/**
+ * The event a connection emits when its client goes away, if it is one of a known kind
+ * @param socket
+ */
+function disconnectionEventOf(socket) {
+    if (!socket || typeof socket !== 'object' || typeof socket.once !== 'function')
+        return undefined;
+    //A socket of Socket.IO: its handshake and its namespace
+    if ('handshake' in socket && 'nsp' in socket)
+        return 'disconnect';
+    //A WebSocket of ws: its state and its pings
+    if ('readyState' in socket && typeof socket.ping === 'function')
+        return 'close';
+    return undefined;
+}
+/**
+ * The signaling of WebRTC: rooms whose members exchange the descriptions and the candidates of their connections. A
+ * member is a client of the entrypoint (its `clientId`): it joins a room with `webrtc.join`, gets the members already
+ * in it and the ICE servers, sends its offers, answers and candidates to a member with `webrtc.signal`, and receives
+ * the events of the room (`webrtc:peer-joined`, `webrtc:peer-left`, `webrtc:signal`). The requests are served by
+ * {@link SignalingController}, over Socket.IO or JSON-RPC over WebSocket (the protocol is in the guide, for the clients
+ * of other languages).
+ *
+ * A member leaves its rooms when it asks, when its connection closes (Socket.IO, JSON-RPC over WebSocket), when an
+ * event cannot reach it any more, or, for the clients sending heartbeats (over the other transports), after three
+ * heartbeat intervals without a request. The signals are checked: only between members of the same room, of a limited
+ * size and rate.
+ *
+ * With a {@link Cluster} (its `cluster` option), the instances of the application share the rooms: each node tells the
+ * others who joins and leaves through it, a signal to a member of another node goes through that node, and the members
+ * of a node that stops or cannot be reached any more leave their rooms (`disconnected`). `maxPeers` is counted over the
+ * whole cluster, by the node each room falls to.
+ *
+ * Register it as `signaling` with {@link buildSignalingOptions}, and add {@link SignalingController} to the
+ * controllers of the entrypoint.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints} from 'lakutata/com/entrypoint'
+ * import {socketIOServiceEntrypoint} from 'lakutata/adapter/socket.io'
+ * import {buildSignalingOptions, buildTURNServerOptions, SignalingController} from '@lakutata/webrtc'
+ *
+ * Application.run(() => ({
+ *     id: 'meet.app',
+ *     name: 'Meet',
+ *     components: {
+ *         turn: buildTURNServerOptions({publicAddress: '203.0.113.10', secret: process.env.TURN_SECRET}),
+ *         //The members get the ICE servers of turn; only the users of the meeting may join its room
+ *         signaling: buildSignalingOptions({
+ *             turn: 'turn',
+ *             authorize: (peer, room): boolean => room === 'meeting' && peer.peerId.startsWith('user-')
+ *         }),
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [SignalingController],
+ *             service: socketIOServiceEntrypoint({port: 3000})
+ *         })
+ *     },
+ *     bootstrap: ['turn', 'entrypoint']
+ * }))
+ * ```
+ */
+let Signaling = class Signaling extends Component {
+    //The members connected to this node, by room
+    #rooms = new Map();
+    #members = new Map();
+    //The members connected to the other nodes of the cluster, by room
+    #remote = new Map();
+    //The number of the last change of each node applied here
+    #applied = new Map();
+    //The changes of the nodes received while their members are being fetched
+    #syncing = new Map();
+    //The places held in the full rooms falling to this node: by room, the members admitted and until when
+    #reservations = new Map();
+    #hooked = new WeakSet();
+    #detach = [];
+    #seq = 0;
+    #sweeper;
+    #entrypointObject;
+    #clusterObject;
+    /**
+     * Start the sweep of the members without heartbeats, and join the cluster.
+     * @protected
+     */
+    async init() {
+        this.#sweeper = setInterval(() => this.sweep(), this.heartbeatInterval);
+        this.#sweeper.unref();
+        if (this.cluster)
+            await this.attach(await this.getObject(this.cluster));
+    }
+    /**
+     * Stop the sweep, leave the cluster and forget the rooms.
+     * @protected
+     */
+    async destroy() {
+        clearInterval(this.#sweeper);
+        this.#detach.splice(0).forEach((detach) => detach());
+        this.#rooms.clear();
+        this.#members.clear();
+        this.#remote.clear();
+    }
+    /**
+     * The rooms and their members (of all the nodes, with a cluster).
+     * @returns For each room, the ids of its members.
+     * @example
+     * ```typescript
+     * import type {Signaling} from '@lakutata/webrtc'
+     *
+     * declare const signaling: Signaling
+     * //{meeting: ['alice', 'bob']}
+     * console.log(signaling.rooms())
+     * ```
+     */
+    rooms() {
+        const rooms = Object.fromEntries([...this.#rooms].map(([room, members]) => [room, [...members.keys()]]));
+        for (const [room, members] of this.#remote)
+            rooms[room] = [...rooms[room] ?? [], ...members.keys()];
+        return rooms;
+    }
+    /**
+     * Add a member to a room: the other members get `webrtc:peer-joined`. Joining a room again updates its metadata and
+     * its session.
+     * @param peerId The member's id (its client id).
+     * @param room The room.
+     * @param options Its metadata, its session, the context of its request.
+     * @returns The members already in the room, the ICE servers and how to keep the membership alive.
+     * @throws {SignalingDeniedException} When `authorize` refuses the room, or the id is kept for the members of the
+     * server (`sfu:`, `whip:`) and no role is given.
+     * @throws {SignalingLimitException} When the room is full, or the metadata is over `maxMessageSize`.
+     * @example
+     * ```typescript
+     * import type {Signaling, SignalingJoinResult} from '@lakutata/webrtc'
+     *
+     * declare const signaling: Signaling
+     * //A member added by the application itself (SignalingController does it for the clients)
+     * const result: SignalingJoinResult = await signaling.join('device-7', 'device-7', {metadata: {kind: 'camera'}})
+     * ```
+     */
+    async join(peerId, room, options = {}) {
+        const { metadata, session, context, role, receive } = options;
+        const size = metadata === undefined ? 0 : Buffer.byteLength(JSON.stringify(metadata));
+        if (size > this.maxMessageSize) {
+            throw new SignalingLimitException('Metadata of {size} bytes is over the limit of {limit}', { size: size, limit: this.maxMessageSize });
+        }
+        if (!role) {
+            //A client may not take the place of a member of the server
+            if (RESERVED_PREFIXES.some((prefix) => peerId.startsWith(prefix)) || this.#members.get(peerId)?.role || this.remoteRoleOf(peerId)) {
+                throw new SignalingDeniedException('The id {peerId} is kept for the members of the server', { peerId: peerId });
+            }
+            if (this.authorize && !(await this.authorize({ peerId: peerId, metadata: metadata, session: session }, room, context))) {
+                throw new SignalingDeniedException('The member {peerId} may not join the room {room}', { peerId: peerId, room: room });
+            }
+            if (this.maxPeers && !(await this.admit(room, peerId))) {
+                throw new SignalingLimitException('The room {room} is full ({maxPeers} members)', { room: room, maxPeers: this.maxPeers });
+            }
+        }
+        //The media server of the room joins it first
+        const sfu = role ? undefined : await this.mediaServerOf(room, peerId);
+        let members = this.#rooms.get(room);
+        if (!members) {
+            members = new Map();
+            this.#rooms.set(room, members);
+        }
+        const member = this.member(peerId, context);
+        if (session !== undefined)
+            member.session = session;
+        if (role)
+            member.role = role;
+        if (receive) {
+            member.receive = receive;
+            member.heartbeats = false;
+        }
+        const locals = [...members.values()].filter((other) => other.peerId !== peerId);
+        //Joining through this node, it is no longer a member through another one
+        const moved = this.forgetRemote(room, peerId);
+        const peers = [
+            ...locals.map((other) => peerOf(other.peerId, other.rooms.get(room), other.session, other.role, other.sfus.get(room))),
+            ...[...this.#remote.get(room)?.entries() ?? []].map(([id, other]) => peerOf(id, other.metadata, other.session, other.role, other.sfu))
+        ];
+        member.rooms.set(room, metadata);
+        if (sfu)
+            member.sfus.set(room, sfu);
+        else
+            member.sfus.delete(room);
+        //Later than its join through the other node, whatever the clocks of the nodes
+        member.joinedAt.set(room, Math.max(Date.now(), (moved?.joinedAt ?? 0) + 1));
+        members.set(peerId, member);
+        this.#reservations.get(room)?.delete(peerId);
+        this.announceChange({ kind: 'join', seq: 0, ...recordOf(room, member) });
+        const event = { room: room, ...peerOf(peerId, metadata, member.session, member.role, sfu) };
+        //The other nodes tell their own members
+        for (const other of locals)
+            await this.push(other.peerId, SignalingEvent.peerJoined, event);
+        const { iceServers, credentialTtl } = await this.iceServersOf(peerId);
+        return {
+            v: SIGNALING_PROTOCOL_VERSION,
+            peerId: peerId,
+            peers: peers,
+            iceServers: iceServers,
+            credentialTtl: credentialTtl,
+            heartbeatInterval: member.heartbeats ? this.heartbeatInterval : 0,
+            ...sfu ? { sfu: sfu } : {}
+        };
+    }
+    /**
+     * Send a description or a candidate to a member of a room, as `webrtc:signal` from the sender.
+     * @param peerId The sender's id.
+     * @param room The room both are in.
+     * @param to The receiver's id.
+     * @param signal The description (with the streams of the media server of the room, from it), or the candidate.
+     * @returns Whether the event reached the receiver.
+     * @throws {SignalingNotAMemberException} When the sender or the receiver is not in the room.
+     * @throws {SignalingLimitException} When the signal is too large, or the sender sends too many (a member of the
+     * server is not limited).
+     * @example
+     * ```typescript
+     * import type {Signaling} from '@lakutata/webrtc'
+     *
+     * declare const signaling: Signaling
+     * declare const offer: string
+     * const delivered: boolean = await signaling.signal('device-7', 'device-7', 'alice', {description: {type: 'offer', sdp: offer}})
+     * ```
+     */
+    async signal(peerId, room, to, signal) {
+        const members = this.#rooms.get(room);
+        const member = members?.get(peerId);
+        if (!members || !member)
+            throw new SignalingNotAMemberException('The member {peerId} is not in the room {room}', { peerId: peerId, room: room });
+        const remote = members.has(to) ? undefined : this.#remote.get(room)?.get(to);
+        if (!members.has(to) && !remote)
+            throw new SignalingNotAMemberException('The member {peerId} is not in the room {room}', { peerId: to, room: room });
+        //The members of the server send descriptions of all the media of the room, as often as the members publish
+        if (!member.role) {
+            const size = Buffer.byteLength(JSON.stringify(signal));
+            if (size > this.maxMessageSize) {
+                throw new SignalingLimitException('A signal of {size} bytes is over the limit of {limit}', { size: size, limit: this.maxMessageSize });
+            }
+            this.consume(member);
+        }
+        member.lastSeen = Date.now();
+        const event = { room: room, from: peerId, session: member.session };
+        if (signal.description)
+            event.description = signal.description;
+        if (signal.candidate !== undefined)
+            event.candidate = signal.candidate;
+        if (signal.streams)
+            event.streams = signal.streams;
+        if (!remote)
+            return await this.push(to, SignalingEvent.signal, event);
+        //Through the node of the receiver, unless it is known to be gone (its members leave with it)
+        const cluster = this.#clusterObject;
+        if (!cluster.nodes().some((node) => node.id === remote.node))
+            return false;
+        try {
+            return await cluster.request(remote.node, TOPIC.deliver, { to: to, event: event }, { timeout: CLUSTER_REQUEST_TIMEOUT }) === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Take a member out of a room: the other members get `webrtc:peer-left`.
+     * @param peerId The member's id.
+     * @param room The room.
+     * @returns Resolves once the other members are told.
+     * @example
+     * ```typescript
+     * import type {Signaling} from '@lakutata/webrtc'
+     *
+     * declare const signaling: Signaling
+     * await signaling.leave('device-7', 'device-7')
+     * ```
+     */
+    async leave(peerId, room) {
+        await this.remove(peerId, room, 'left');
+    }
+    /**
+     * Take a member out of all its rooms (its client went away).
+     * @param peerId The member's id.
+     * @returns Resolves once the other members are told.
+     * @example
+     * ```typescript
+     * import type {Signaling} from '@lakutata/webrtc'
+     *
+     * declare const signaling: Signaling
+     * await signaling.disconnect('device-7')
+     * ```
+     */
+    async disconnect(peerId) {
+        const member = this.#members.get(peerId);
+        if (!member)
+            return;
+        for (const room of [...member.rooms.keys()])
+            await this.remove(peerId, room, 'disconnected');
+    }
+    /**
+     * Note that a member's client is still there (`webrtc.heartbeat`, and any request).
+     * @param peerId The member's id.
+     * @example
+     * ```typescript
+     * import type {Signaling} from '@lakutata/webrtc'
+     *
+     * declare const signaling: Signaling
+     * signaling.heartbeat('device-7')
+     * ```
+     */
+    heartbeat(peerId) {
+        const member = this.#members.get(peerId);
+        if (member)
+            member.lastSeen = Date.now();
+    }
+    /**
+     * The ICE servers of a member, with new TURN credentials: the ones of `turn`, of the TURN servers of the cluster
+     * chosen for it, then the others.
+     * @param peerId The member's id (the user of the TURN credentials).
+     * @returns The ICE servers, and how long their credentials are valid in seconds (0 without TURN).
+     * @example
+     * ```typescript
+     * import type {Signaling, SignalingIceServer} from '@lakutata/webrtc'
+     *
+     * declare const signaling: Signaling
+     * const {iceServers} = await signaling.iceServersOf('device-7')
+     * ```
+     */
+    async iceServersOf(peerId) {
+        return iceServersFor(peerId, {
+            turn: this.turn ? await this.getObject(this.turn) : undefined,
+            cluster: this.#clusterObject,
+            secret: this.turnSecret,
+            select: this.selectTURN,
+            iceServers: this.iceServers
+        });
+    }
+    /**
+     * Take a member out of a room, telling the other members why.
+     * @param peerId The member's id.
+     * @param room The room.
+     * @param reason `left` when it asked, `disconnected` when its client went away.
+     * @returns Resolves once the other members are told.
+     * @protected
+     */
+    async remove(peerId, room, reason) {
+        const members = this.#rooms.get(room);
+        const member = members?.get(peerId);
+        if (!members || !member)
+            return;
+        this.forgetLocal(room, member);
+        this.announceChange({ kind: 'leave', seq: 0, room: room, peerId: peerId, reason: reason });
+        const event = { room: room, peerId: peerId, reason: reason };
+        for (const other of [...members.keys()])
+            await this.push(other, SignalingEvent.peerLeft, event);
+    }
+    /**
+     * Take a member of this node out of a room, without telling anyone
+     * @param room The room.
+     * @param member The member.
+     * @protected
+     */
+    forgetLocal(room, member) {
+        const members = this.#rooms.get(room);
+        if (members?.get(member.peerId) !== member)
+            return;
+        members.delete(member.peerId);
+        member.rooms.delete(room);
+        member.joinedAt.delete(room);
+        member.sfus.delete(room);
+        if (!members.size)
+            this.#rooms.delete(room);
+        if (!member.rooms.size && this.#members.get(member.peerId) === member)
+            this.#members.delete(member.peerId);
+    }
+    /**
+     * Take a member of another node out of a room, without telling anyone
+     * @param room The room.
+     * @param peerId The member's id.
+     * @param node Only if it is a member through this node.
+     * @returns The member taken out.
+     * @protected
+     */
+    forgetRemote(room, peerId, node) {
+        const members = this.#remote.get(room);
+        const remote = members?.get(peerId);
+        if (!members || !remote || (node !== undefined && remote.node !== node))
+            return undefined;
+        members.delete(peerId);
+        if (!members.size)
+            this.#remote.delete(room);
+        return remote;
+    }
+    /**
+     * Join the cluster: receive the changes of the other nodes, answer their requests, fetch their members when they
+     * come up or when changes of theirs were missed, and take out the members of the nodes going down
+     * @param cluster The cluster component.
+     * @protected
+     */
+    async attach(cluster) {
+        this.#clusterObject = cluster;
+        const onUp = (node) => void this.sync(node.id);
+        const onDown = (node) => void this.dropNode(node.id);
+        const onUpdate = (node) => {
+            //Its heartbeat comes after its changes: a later number than the one applied means changes were lost
+            const seq = node.services.signaling?.seq;
+            if (typeof seq === 'number' && !this.#syncing.has(node.id) && seq > (this.#applied.get(node.id) ?? -1))
+                void this.sync(node.id);
+        };
+        cluster.on('node-up', onUp);
+        cluster.on('node-down', onDown);
+        cluster.on('node-update', onUpdate);
+        this.#detach.push(() => cluster.off('node-up', onUp), () => cluster.off('node-down', onDown), () => cluster.off('node-update', onUpdate), cluster.subscribe(TOPIC.membership, (event, from) => void this.received(from, event)), cluster.handle(TOPIC.snapshot, () => this.snapshot()), cluster.handle(TOPIC.deliver, ({ to, event }) => this.deliver(to, event)), cluster.handle(TOPIC.admit, ({ room, peerId }) => this.reserve(room, peerId)), () => cluster.announce('signaling', undefined));
+        cluster.announce('signaling', { seq: this.#seq });
+        //The nodes found before
+        for (const node of cluster.nodes())
+            if (!node.local)
+                void this.sync(node.id);
+    }
+    /**
+     * Tell the other nodes of a change of the members of this node
+     * @param event The change, numbered here.
+     * @protected
+     */
+    announceChange(event) {
+        const cluster = this.#clusterObject;
+        if (!cluster)
+            return;
+        event.seq = ++this.#seq;
+        cluster.publish(TOPIC.membership, event);
+        cluster.announce('signaling', { seq: this.#seq });
+    }
+    /**
+     * The members of this node, for another node
+     * @protected
+     */
+    snapshot() {
+        const members = [];
+        for (const [room, locals] of this.#rooms) {
+            for (const member of locals.values()) {
+                members.push(recordOf(room, member));
+            }
+        }
+        return { seq: this.#seq, members: members };
+    }
+    /**
+     * Fetch the members of a node, replacing what this node knew of them; the changes received meanwhile are applied
+     * after
+     * @param node The id of the node.
+     * @protected
+     */
+    async sync(node) {
+        if (this.#syncing.has(node) || !this.#clusterObject)
+            return;
+        const queue = [];
+        this.#syncing.set(node, queue);
+        let snapshot;
+        try {
+            snapshot = await this.#clusterObject.request(node, TOPIC.snapshot, {});
+        }
+        catch {
+            //Gone, or not answering: fetched again at its next sign
+            if (this.#syncing.get(node) === queue)
+                this.#syncing.delete(node);
+            return;
+        }
+        //The node went down meanwhile
+        if (this.#syncing.get(node) !== queue)
+            return;
+        //The members it no longer has left, the new ones joined
+        const kept = new Set();
+        for (const record of snapshot.members) {
+            kept.add(JSON.stringify([record.room, record.peerId]));
+            const known = this.#remote.get(record.room)?.get(record.peerId);
+            if (known?.node === node && known.joinedAt === record.joinedAt && known.session === record.session && known.sfu === record.sfu)
+                continue;
+            await this.joinedRemote(node, record);
+        }
+        for (const [room, members] of [...this.#remote]) {
+            for (const [peerId, remote] of [...members]) {
+                if (remote.node === node && !kept.has(JSON.stringify([room, peerId])))
+                    await this.leftRemote(node, room, peerId, 'disconnected');
+            }
+        }
+        this.#applied.set(node, snapshot.seq);
+        //The changes received meanwhile, those coming while they are applied included
+        while (queue.length) {
+            if (this.#syncing.get(node) !== queue)
+                return;
+            const event = queue.shift();
+            const applied = this.#applied.get(node);
+            if (event.seq <= applied)
+                continue;
+            if (event.seq !== applied + 1) {
+                //Missed again: fetched again, with the changes after
+                this.#syncing.delete(node);
+                void this.sync(node);
+                return void this.#syncing.get(node)?.push(event, ...queue.splice(0));
+            }
+            this.#applied.set(node, event.seq);
+            await this.apply(node, event);
+        }
+        if (this.#syncing.get(node) === queue)
+            this.#syncing.delete(node);
+    }
+    /**
+     * Receive a change of another node, in its order: a change missed makes this node fetch its members
+     * @param node The id of the node.
+     * @param event The change.
+     * @protected
+     */
+    async received(node, event) {
+        const queue = this.#syncing.get(node);
+        if (queue)
+            return void queue.push(event);
+        const applied = this.#applied.get(node);
+        if (applied !== undefined && event.seq <= applied)
+            return;
+        if (applied === undefined || event.seq !== applied + 1) {
+            void this.sync(node);
+            return void this.#syncing.get(node)?.push(event);
+        }
+        this.#applied.set(node, event.seq);
+        await this.apply(node, event);
+    }
+    /**
+     * Apply a change of another node
+     * @param node The id of the node.
+     * @param event The change.
+     * @protected
+     */
+    async apply(node, event) {
+        switch (event.kind) {
+            case 'join':
+                return await this.joinedRemote(node, event);
+            case 'leave':
+                return await this.leftRemote(node, event.room, event.peerId, event.reason);
+            case 'yield':
+                return void this.forgetRemote(event.room, event.peerId, node);
+        }
+    }
+    /**
+     * A member joined a room through another node: of two nodes having it, the later join wins (the node of the earlier
+     * one gives it up); the members of this node in the room are told
+     * @param node The id of the node.
+     * @param record The member, its room and when it joined.
+     * @protected
+     */
+    async joinedRemote(node, record) {
+        const { room, peerId } = record;
+        const joined = { joinedAt: record.joinedAt, node: node };
+        const local = this.#rooms.get(room)?.get(peerId);
+        if (local && later({ joinedAt: local.joinedAt.get(room) ?? 0, node: this.#clusterObject.nodeId }, joined))
+            return;
+        const known = this.#remote.get(room)?.get(peerId);
+        if (known && known.node !== node && later(known, joined))
+            return;
+        if (local) {
+            this.forgetLocal(room, local);
+            this.announceChange({ kind: 'yield', seq: 0, room: room, peerId: peerId });
+        }
+        if (!this.#remote.has(room))
+            this.#remote.set(room, new Map());
+        this.#remote.get(room).set(peerId, { node: node, metadata: record.metadata, session: record.session, joinedAt: record.joinedAt, ...record.role ? { role: record.role } : {}, ...record.sfu ? { sfu: record.sfu } : {} });
+        this.#reservations.get(room)?.delete(peerId);
+        const event = { room: room, ...peerOf(peerId, record.metadata, record.session, record.role, record.sfu) };
+        for (const other of [...this.#rooms.get(room)?.keys() ?? []])
+            await this.push(other, SignalingEvent.peerJoined, event);
+    }
+    /**
+     * A member of another node left a room: the members of this node in the room are told
+     * @param node The id of the node.
+     * @param room The room.
+     * @param peerId The member's id.
+     * @param reason `left` when it asked, `disconnected` when its client or its node went away.
+     * @protected
+     */
+    async leftRemote(node, room, peerId, reason) {
+        if (!this.forgetRemote(room, peerId, node))
+            return;
+        const event = { room: room, peerId: peerId, reason: reason };
+        for (const other of [...this.#rooms.get(room)?.keys() ?? []])
+            await this.push(other, SignalingEvent.peerLeft, event);
+    }
+    /**
+     * A node went down: its members leave their rooms (`disconnected`)
+     * @param node The id of the node.
+     * @protected
+     */
+    async dropNode(node) {
+        this.#applied.delete(node);
+        this.#syncing.delete(node);
+        for (const [room, members] of [...this.#remote]) {
+            for (const [peerId, remote] of [...members]) {
+                if (remote.node === node)
+                    await this.leftRemote(node, room, peerId, 'disconnected');
+            }
+        }
+    }
+    /**
+     * Push a signal from another node to a member of this node
+     * @param to The receiver's id.
+     * @param event The signal.
+     * @protected
+     */
+    async deliver(to, event) {
+        if (!this.#rooms.get(event?.room)?.has(to))
+            return false;
+        return await this.push(to, SignalingEvent.signal, event);
+    }
+    /**
+     * Whether a member may join a room of `maxPeers` members at most: counted by this node without a cluster, by the
+     * node the room falls to with one (another one when that node does not answer)
+     * @param room The room.
+     * @param peerId The member's id.
+     * @protected
+     */
+    async admit(room, peerId) {
+        const cluster = this.#clusterObject;
+        if (!cluster) {
+            const members = this.#rooms.get(room);
+            return !members || members.has(peerId) || [...members.values()].filter((member) => !member.role).length < this.maxPeers;
+        }
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const owner = rendezvous(room, cluster.nodes().map((node) => node.id));
+            if (owner === cluster.nodeId)
+                return this.reserve(room, peerId);
+            try {
+                return await cluster.request(owner, TOPIC.admit, { room: room, peerId: peerId }, { timeout: CLUSTER_REQUEST_TIMEOUT }) === true;
+            }
+            catch {
+                //Gone or not answering: the room falls to another node once it is taken as gone
+            }
+        }
+        return this.reserve(room, peerId);
+    }
+    /**
+     * Hold a place for a member in a room falling to this node, if the room has one: its members of all the nodes and
+     * the places held count
+     * @param room The room.
+     * @param peerId The member's id.
+     * @protected
+     */
+    reserve(room, peerId) {
+        if (typeof room !== 'string' || typeof peerId !== 'string')
+            return false;
+        const now = Date.now();
+        const reservations = this.#reservations.get(room) ?? new Map();
+        for (const [id, expiresAt] of reservations)
+            if (expiresAt < now)
+                reservations.delete(id);
+        //The members of the server are not counted
+        const present = new Set([
+            ...[...this.#rooms.get(room)?.values() ?? []].filter((member) => !member.role).map((member) => member.peerId),
+            ...[...this.#remote.get(room)?.entries() ?? []].filter(([, member]) => !member.role).map(([id]) => id)
+        ]);
+        if (present.has(peerId))
+            return true;
+        for (const id of present)
+            reservations.delete(id);
+        if (!reservations.has(peerId) && present.size + reservations.size >= this.maxPeers) {
+            if (!reservations.size)
+                this.#reservations.delete(room);
+            return false;
+        }
+        reservations.set(peerId, now + RESERVATION_TIMEOUT);
+        this.#reservations.set(room, reservations);
+        return true;
+    }
+    /**
+     * The media server a member joining a room connects to: the one of this node, else, in a cluster, one of the media
+     * servers of the other nodes (the least loaded answering), which chooses as it would for a member of its own node
+     * @param room The room.
+     * @param peerId The member's id.
+     * @returns The id of the member of the media server, none for a room without one.
+     * @throws {SignalingLimitException} When no media server takes the member.
+     * @protected
+     */
+    async mediaServerOf(room, peerId) {
+        const local = mediaServers.get(this);
+        if (local)
+            return await local(room, peerId);
+        const cluster = this.#clusterObject;
+        if (!cluster)
+            return undefined;
+        const load = (node) => {
+            const announced = node.services[MEDIA_SERVER_SERVICE];
+            return announced.members + announced.viewers;
+        };
+        const servers = cluster.nodes()
+            .filter((node) => !node.local && !!node.services[MEDIA_SERVER_SERVICE])
+            .sort((a, b) => load(a) - load(b));
+        if (!servers.length)
+            return undefined;
+        for (const server of servers.slice(0, 2)) {
+            let reply;
+            try {
+                reply = await cluster.request(server.id, MEDIA_SERVER_ASSIGN_TOPIC, { room: room, peerId: peerId });
+            }
+            catch {
+                //Gone or not answering: the next one
+                continue;
+            }
+            //Full: it chose among all the media servers
+            if ('full' in reply)
+                break;
+            return reply.sfu ?? undefined;
+        }
+        throw new SignalingLimitException('No media server takes the member {peerId} in the room {room}', { peerId: peerId, room: room });
+    }
+    /**
+     * The role of a member of another node, in any room
+     * @param peerId The member's id.
+     * @protected
+     */
+    remoteRoleOf(peerId) {
+        for (const members of this.#remote.values()) {
+            const role = members.get(peerId)?.role;
+            if (role)
+                return role;
+        }
+        return undefined;
+    }
+    /**
+     * The member of a client, created on its first request; its Socket.IO socket, when its request came through one,
+     * takes it out of its rooms when it disconnects (unless the client reconnected through another socket first).
+     * @param peerId The member's id.
+     * @param context The context of its request.
+     * @returns The member.
+     * @protected
+     */
+    member(peerId, context) {
+        let member = this.#members.get(peerId);
+        if (!member) {
+            member = { peerId: peerId, rooms: new Map(), joinedAt: new Map(), heartbeats: true, lastSeen: Date.now(), tokens: this.maxMessagesPerSecond * 2, refilledAt: Date.now(), sfus: new Map() };
+            this.#members.set(peerId, member);
+        }
+        member.lastSeen = Date.now();
+        const socket = context?.socket;
+        const event = disconnectionEventOf(socket);
+        if (event) {
+            member.heartbeats = false;
+            member.socket = socket;
+            if (!this.#hooked.has(socket)) {
+                this.#hooked.add(socket);
+                socket.once(event, () => {
+                    if (this.#members.get(peerId)?.socket === socket)
+                        void this.disconnect(peerId).catch(() => undefined);
+                });
+            }
+        }
+        return member;
+    }
+    /**
+     * Take a token of the member's rate (refilled at maxMessagesPerSecond, up to twice as many).
+     * @param member The member.
+     * @throws {SignalingLimitException} When no token is left.
+     * @protected
+     */
+    consume(member) {
+        const now = Date.now();
+        member.tokens = Math.min(this.maxMessagesPerSecond * 2, member.tokens + (now - member.refilledAt) / 1000 * this.maxMessagesPerSecond);
+        member.refilledAt = now;
+        if (member.tokens < 1) {
+            throw new SignalingLimitException('The member {peerId} sends more than {rate} signals per second', { peerId: member.peerId, rate: this.maxMessagesPerSecond });
+        }
+        member.tokens--;
+    }
+    /**
+     * Push an event to a member; a member it cannot reach any more leaves its rooms.
+     * @param peerId The member's id.
+     * @param event The event.
+     * @param payload Its payload.
+     * @returns Whether the event reached the member.
+     * @protected
+     */
+    async push(peerId, event, payload) {
+        const receive = this.#members.get(peerId)?.receive;
+        if (receive) {
+            try {
+                receive(event, payload);
+            }
+            catch {
+                //The member of the application handles its own errors
+            }
+            return true;
+        }
+        this.#entrypointObject ??= await this.getObject(this.entrypoint);
+        const delivered = this.#entrypointObject.notify(peerId, event, payload);
+        if (!delivered)
+            setImmediate(() => void this.disconnect(peerId).catch(() => undefined));
+        return delivered;
+    }
+    /**
+     * Take out the members sending heartbeats that were not seen for three intervals.
+     * @protected
+     */
+    sweep() {
+        const limit = Date.now() - this.heartbeatInterval * 3;
+        for (const member of [...this.#members.values()]) {
+            if (member.heartbeats && member.lastSeen < limit)
+                void this.disconnect(member.peerId).catch(() => undefined);
+        }
+    }
+};
+__decorate([
+    Configurable(DTO.String().optional().default('entrypoint')),
+    __metadata("design:type", String)
+], Signaling.prototype, "entrypoint", void 0);
+__decorate([
+    Configurable(DTO.String().optional()),
+    __metadata("design:type", String)
+], Signaling.prototype, "cluster", void 0);
+__decorate([
+    Configurable(DTO.String().optional()),
+    __metadata("design:type", String)
+], Signaling.prototype, "turn", void 0);
+__decorate([
+    Configurable(DTO.String().min(1).optional()),
+    __metadata("design:type", String)
+], Signaling.prototype, "turnSecret", void 0);
+__decorate([
+    Configurable(DTO.Function().optional()),
+    __metadata("design:type", Function)
+], Signaling.prototype, "selectTURN", void 0);
+__decorate([
+    Configurable(DTO.Array().items(DTO.Object({
+        urls: DTO.Alternatives(DTO.String(), DTO.Array().items(DTO.String())).required(),
+        username: DTO.String().optional(),
+        credential: DTO.String().optional()
+    })).optional().default([])),
+    __metadata("design:type", Array)
+], Signaling.prototype, "iceServers", void 0);
+__decorate([
+    Configurable(DTO.Function().optional()),
+    __metadata("design:type", Function)
+], Signaling.prototype, "authorize", void 0);
+__decorate([
+    Configurable(DTO.Number().integer().min(0).optional().default(0)),
+    __metadata("design:type", Number)
+], Signaling.prototype, "maxPeers", void 0);
+__decorate([
+    Configurable(DTO.Number().integer().positive().optional().default(65536)),
+    __metadata("design:type", Number)
+], Signaling.prototype, "maxMessageSize", void 0);
+__decorate([
+    Configurable(DTO.Number().positive().optional().default(50)),
+    __metadata("design:type", Number)
+], Signaling.prototype, "maxMessagesPerSecond", void 0);
+__decorate([
+    Configurable(DTO.Number().integer().positive().optional().default(10000)),
+    __metadata("design:type", Number)
+], Signaling.prototype, "heartbeatInterval", void 0);
+Signaling = __decorate([
+    Singleton()
+], Signaling);
+export { Signaling };
+/**
+ * Build the options of a {@link Signaling} component, for the `components` of an application (named `signaling`, the
+ * name {@link SignalingController} uses).
+ * @param options The TURN server, the other ICE servers, who may join which room, the limits (all optional).
+ * @returns The component options.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildSignalingOptions} from '@lakutata/webrtc'
+ *
+ * Application.run(() => ({
+ *     id: 'meet.app',
+ *     name: 'Meet',
+ *     components: {
+ *         signaling: buildSignalingOptions({iceServers: [{urls: 'stun:stun.example.com:3478'}], maxPeers: 8})
+ *     }
+ * }))
+ * ```
+ */
+export function buildSignalingOptions(options = {}) {
+    return { class: Signaling, ...options };
+}