@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/esm/sfu/SFURoom.js

@@ -0,0 +1,1296 @@
+import { RTCRtpCodecParameters } from '../lib/peer/media/parameters.js';
+import { engineChannelOf, engineConnectionOf } from '../peer/EngineConnection.js';
+import { engineTrackOf, relayedTrack } from '../peer/MediaTrack.js';
+import { gathered, patchConnection } from '../peer/Endpoints.js';
+import { engineSenderOf } from '../peer/RtpTransceiver.js';
+import { SignalingControlChannel, SignalingEvent } from '../protocol/SignalingProtocol.js';
+import { Peer } from '../shared/Peer.js';
+/**
+ * The key of a track: its member and its id
+ * @param peerId
+ * @param trackId
+ */
+function trackKey(peerId, trackId) {
+    return JSON.stringify([peerId, trackId]);
+}
+/**
+ * How long a channel to a member not known yet waits for it (its joining on its way through the cluster), in
+ * milliseconds
+ */
+const UNKNOWN_MEMBER_TIMEOUT = 5000;
+/**
+ * How long a member joining waits for the answers of select for the tracks already published, in milliseconds, so the
+ * first offer carries them (select asked in the main thread from a worker thread); an answer coming later is applied in
+ * an offer of its own
+ */
+const FIRST_OFFER_SELECT_WAIT = 1000;
+/**
+ * The members a channel from the media server of another node goes from and to: its protocol, `["from","to"]`
+ * @param protocol
+ */
+function routeOf(protocol) {
+    try {
+        const route = JSON.parse(protocol);
+        return Array.isArray(route) && route.length === 2 && route.every((id) => typeof id === 'string') ? route : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The bytes a channel relayed to a member may have waiting to be sent: past them, the messages wait at the server, out
+ * of the receive window of the member sending them (which waits then), until the channel sends half of them
+ */
+const RELAY_HIGH_WATER_MARK = 1024 * 1024;
+/**
+ * Relay the messages of a channel to another one, as fast as the other one sends them: the messages of a reliable
+ * channel wait at the server while the other one is not open or has too much to send, held out of the receive window
+ * of the connection they come from (its sender waits once the window is closed); the ones of an unreliable channel are
+ * dropped then, once the other one is open or past RELAY_HIGH_WATER_MARK waiting
+ * @param source
+ * @param target
+ * @param early The messages the source got before.
+ */
+function relay(source, target, early = []) {
+    const transport = engineChannelOf(source).sctp;
+    const reliable = source.maxRetransmits === null && source.maxPacketLifeTime === null;
+    const waiting = [];
+    let held = 0;
+    let queued = 0;
+    target.bufferedAmountLowThreshold = RELAY_HIGH_WATER_MARK / 2;
+    const drain = () => {
+        while (waiting.length && target.readyState === 'open' && target.bufferedAmount < RELAY_HIGH_WATER_MARK) {
+            const { data, size } = waiting.shift();
+            queued -= size;
+            target.send(data);
+            if (reliable) {
+                held -= size;
+                transport.releaseReceived(size);
+            }
+        }
+    };
+    const relayed = (data) => {
+        const message = typeof data === 'string' || Buffer.isBuffer(data) ? data : Buffer.from(data);
+        if (target.readyState === 'closing' || target.readyState === 'closed')
+            return;
+        if (!waiting.length && target.readyState === 'open' && target.bufferedAmount < RELAY_HIGH_WATER_MARK)
+            return target.send(message);
+        const size = typeof message === 'string' ? Buffer.byteLength(message) : message.length;
+        if (!reliable && (target.readyState === 'open' || queued + size > RELAY_HIGH_WATER_MARK))
+            return;
+        waiting.push({ data: message, size: size });
+        queued += size;
+        if (reliable) {
+            held += size;
+            transport.holdReceived(size);
+        }
+    };
+    early.forEach(relayed);
+    source.on('message', relayed);
+    target.on('open', drain);
+    target.on('bufferedamountlow', drain);
+    //The window held is given back when the other side is gone
+    target.on('close', () => {
+        waiting.length = 0;
+        queued = 0;
+        if (held)
+            transport.releaseReceived(held);
+        held = 0;
+    });
+}
+/**
+ * The transceiver of the engine of a transceiver
+ * @param connection
+ * @param transceiver
+ */
+function engineTransceiverOf(connection, transceiver) {
+    const engine = engineConnectionOf(connection);
+    return transceiver.mid === null ? undefined : engine.getTransceivers().find((each) => each.mid === transceiver.mid);
+}
+/**
+ * The part of a room on the media server: a connection to each member (the server never gives up its offers), the
+ * tracks they publish, forwarded to the others the server selects for them
+ */
+export class SFURoom {
+    #host;
+    #members = new Map();
+    #viewers = new Map();
+    #publications = new Set();
+    //The transports whose bandwidth is watched
+    #watched = new WeakSet();
+    //The clients connected to the media servers of other nodes, and the id of their server
+    #elsewhere = new Map();
+    //What select answered for each member (by its id) and each track of the other nodes (by key)
+    #selected = new Map();
+    //The tracks of other nodes read here, by key
+    #reads = new Map();
+    //The channels to members not known yet
+    #waiting = new Set();
+    #closed = false;
+    /**
+     * Create the part of a room, and join it.
+     * @param host The media server.
+     * @param name The room.
+     */
+    constructor(host, name) {
+        this.#host = host;
+        this.name = name;
+        this.ready = this.#join();
+    }
+    /**
+     * Whether the room has no member and no viewer left.
+     */
+    get empty() {
+        return !this.members.length && !this.#viewers.size;
+    }
+    /**
+     * The number of the viewers of WHEP.
+     */
+    get viewers() {
+        return this.#viewers.size;
+    }
+    /**
+     * Whether the server left the room.
+     */
+    get closed() {
+        return this.#closed;
+    }
+    /**
+     * The ids of the members of this node (the media servers of the other nodes are not counted).
+     */
+    get members() {
+        return [...this.#members.values()].filter((member) => !member.cascade).map((member) => member.id);
+    }
+    /**
+     * The tracks the members of this node publish.
+     */
+    get tracks() {
+        return [...this.#publications].filter((publication) => !publication.remote).map((publication) => publication.track);
+    }
+    /**
+     * A track published in the room: received from its member, or from the media server of its node while it is read.
+     * @param peerId The member.
+     * @param trackId The id of the track.
+     * @returns The track, or undefined when it is not published.
+     */
+    track(peerId, trackId) {
+        for (const publication of this.#publications) {
+            if (!publication.remote && publication.track.peerId === peerId && publication.track.id === trackId)
+                return publication.media;
+        }
+        const key = trackKey(peerId, trackId);
+        const offered = this.#offered(key);
+        if (!offered)
+            return undefined;
+        let read = this.#reads.get(key);
+        if (!read) {
+            const codec = offered.codec ?? { mimeType: offered.track.codec, clockRate: offered.track.kind === 'audio' ? 48000 : 90000 };
+            const relayed = relayedTrack(offered.track.kind, new RTCRtpCodecParameters(codec), trackId, {
+                requestKeyFrame: () => this.#remotePublication(key)?.media.requestKeyFrame(),
+                wanted: (wanted) => {
+                    const current = this.#reads.get(key);
+                    if (!current)
+                        return;
+                    current.wanted = wanted;
+                    this.#pipe(key);
+                    this.#tellWants();
+                }
+            });
+            read = { track: relayed.track, receive: relayed.receive, wanted: false };
+            this.#reads.set(key, read);
+        }
+        return read.track;
+    }
+    /**
+     * The connections to the media servers of the other nodes: the tracks sent on each, the ones received (for the
+     * tests).
+     * @returns By the id of the member of each server.
+     */
+    cascades() {
+        return Object.fromEntries([...this.#members.values()].filter((member) => !!member.cascade).map((member) => [member.id, { sends: member.subscriptions.size, receives: member.publications.size }]));
+    }
+    /**
+     * Leave the room: the connections to the members are closed.
+     * @returns Resolves once the signaling is told.
+     */
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        for (const member of [...this.#members.values()])
+            this.#remove(member);
+        for (const viewer of [...this.#viewers.values()])
+            this.#stop(viewer);
+        for (const key of [...this.#reads.keys()])
+            this.#endRead(key);
+        for (const opening of [...this.#waiting])
+            opening.channel.close();
+        await this.#host.signaling.leave(this.#host.id, this.name).catch(() => undefined);
+    }
+    /**
+     * A viewer of WHEP: the connection answering its offer sends it an audio and a video track of a member of the room
+     * (its source), once and as long as there is one, from a key frame. Its media negotiate every codec it offers that
+     * the server has, so a source publishing later with any of them is sent too.
+     * @param id The id of the viewer.
+     * @param offer The offer of the viewer.
+     * @param select Chooses its source among the members publishing; the newest stream of WHIP, else the first member
+     * publishing, without it.
+     * @returns The connection, its answer with all its candidates, and its source now.
+     */
+    async play(id, offer, select) {
+        const connection = await this.#host.connect();
+        const ended = [];
+        let closed = false;
+        const leg = {
+            connection: connection,
+            ready: Promise.resolve(),
+            get closed() {
+                return closed;
+            },
+            close: () => {
+                if (closed)
+                    return;
+                closed = true;
+                connection.close();
+                for (const listener of ended.splice(0))
+                    listener();
+            }
+        };
+        const viewer = { id: id, leg: leg, transceivers: new Map(), attached: new Map(), select: select, feeding: Promise.resolve() };
+        connection.on('connectionstatechange', (state) => {
+            if (state === 'failed' || state === 'closed')
+                this.#stop(viewer);
+        });
+        try {
+            await connection.setRemoteDescription(offer);
+            //The first media of each kind sends; no track before the answer, which keeps all the codecs
+            for (const transceiver of connection.getTransceivers()) {
+                if (viewer.transceivers.has(transceiver.kind))
+                    continue;
+                viewer.transceivers.set(transceiver.kind, transceiver);
+                transceiver.direction = 'sendonly';
+            }
+            if (!viewer.transceivers.size)
+                throw new Error('The offer has no audio and no video');
+            await connection.setLocalDescription();
+            await gathered(connection);
+            if (closed)
+                throw new Error(`The connection is ${connection.connectionState}`);
+        }
+        catch (error) {
+            leg.close();
+            throw error;
+        }
+        this.#viewers.set(id, viewer);
+        this.#host.changed?.(this);
+        await this.#feed(viewer);
+        return {
+            answer: connection.localDescription,
+            patch: (fragment, restart) => patchConnection(connection, fragment, restart),
+            ended: (listener) => closed ? listener() : ended.push(listener),
+            close: () => this.#stop(viewer),
+            source: () => viewer.source
+        };
+    }
+    /**
+     * Send a viewer the tracks of its source, after the changes before
+     * @param viewer
+     */
+    #feed(viewer) {
+        viewer.feeding = viewer.feeding.then(() => this.#refeed(viewer)).catch(() => undefined);
+        return viewer.feeding;
+    }
+    /**
+     * Send a viewer the tracks of its source: chosen again, as the tracks of the room change
+     * @param viewer
+     */
+    async #refeed(viewer) {
+        if (viewer.leg.closed)
+            return;
+        //The tracks of the members of this node, then the ones of the other nodes
+        const tracks = [...this.tracks, ...[...this.#offeredTracks()].map((offered) => offered.track)];
+        const selected = viewer.select ? await viewer.select(tracks) : undefined;
+        if (viewer.leg.closed)
+            return;
+        const publishers = [...new Set(tracks.map((track) => track.peerId))];
+        const chosen = selected
+            ?? publishers.filter((id) => id.startsWith('whip:')).at(-1)
+            ?? publishers[0];
+        const before = viewer.source;
+        viewer.source = chosen !== undefined && publishers.includes(chosen) ? chosen : undefined;
+        if (viewer.source !== before) {
+            this.#host.sourced?.(viewer.id, viewer.source);
+            //The tracks of a source of another node come from that node
+            this.#tellWants();
+        }
+        for (const [kind, transceiver] of viewer.transceivers) {
+            const publication = viewer.source === undefined
+                ? undefined
+                : [...this.#publications].find((each) => each.track.peerId === viewer.source && each.track.kind === kind);
+            if (viewer.attached.get(kind) === publication)
+                continue;
+            viewer.attached.delete(kind);
+            try {
+                await transceiver.sender.replaceTrack(publication?.media ?? null);
+            }
+            catch {
+                //Of a codec the viewer does not have
+                this.#host.emit('unsupported', this.name, viewer.id, publication.track);
+                await transceiver.sender.replaceTrack(null).catch(() => undefined);
+                continue;
+            }
+            if (!publication)
+                continue;
+            viewer.attached.set(kind, publication);
+            if (kind === 'video')
+                publication.media.requestKeyFrame();
+        }
+    }
+    /**
+     * A viewer stopped: its connection is closed
+     * @param viewer
+     */
+    #stop(viewer) {
+        if (this.#viewers.get(viewer.id) !== viewer)
+            return viewer.leg.close();
+        this.#viewers.delete(viewer.id);
+        viewer.leg.close();
+        if (!this.#closed)
+            this.#host.changed?.(this);
+        if (!this.#closed && this.empty)
+            this.#host.emptied(this);
+    }
+    /**
+     * A stream published with WHIP joins the room: a member (of role `whip`) whose connection answers the offer of the
+     * publisher, publishing its tracks and receiving nothing
+     * @param id The id of the member.
+     * @param offer The offer of the publisher.
+     * @returns The connection, its answer with all its candidates.
+     */
+    async publish(id, offer) {
+        const connection = await this.#host.connect();
+        const ended = [];
+        let closed = false;
+        const leg = {
+            connection: connection,
+            ready: Promise.resolve(),
+            get closed() {
+                return closed;
+            },
+            close: () => {
+                if (closed)
+                    return;
+                closed = true;
+                connection.close();
+                for (const listener of ended.splice(0))
+                    listener();
+            }
+        };
+        const member = {
+            id: id,
+            leg: leg,
+            metadata: undefined,
+            publications: new Map(),
+            subscriptions: new Map(),
+            streams: new Map(),
+            streamIds: new Map(),
+            transceivers: new Set()
+        };
+        this.#members.set(id, member);
+        this.#host.changed?.(this);
+        connection.addEventListener('track', (event) => this.#published(member, event));
+        connection.on('connectionstatechange', (state) => {
+            if (state === 'failed' || state === 'closed')
+                this.#remove(member);
+        });
+        //Negotiated again for an ICE restart (a PATCH)
+        connection.on('signalingstatechange', (state) => {
+            if (state === 'stable')
+                setImmediate(() => this.#negotiated(member));
+        });
+        try {
+            await connection.setRemoteDescription(offer);
+            await connection.setLocalDescription();
+            await gathered(connection);
+            if (closed)
+                throw new Error(`The connection is ${connection.connectionState}`);
+            await this.#host.signaling.join(id, this.name, { role: 'whip', receive: () => undefined });
+        }
+        catch (error) {
+            this.#remove(member);
+            throw error;
+        }
+        return {
+            answer: connection.localDescription,
+            patch: (fragment, restart) => patchConnection(connection, fragment, restart),
+            ended: (listener) => closed ? listener() : ended.push(listener),
+            close: () => this.#remove(member)
+        };
+    }
+    /**
+     * Join the room, with the members already in it
+     */
+    async #join() {
+        const result = await this.#host.signaling.join(this.#host.id, this.name, {
+            role: 'sfu',
+            receive: (event, payload) => this.#receive(event, payload)
+        });
+        for (const peer of result.peers) {
+            if (this.#serves(peer))
+                this.#add(peer.peerId, peer.metadata, peer.session);
+            else
+                this.#elsewhereJoined(peer);
+        }
+    }
+    /**
+     * A member of the room this server does not serve: the media server of another node (connected to), or a client of
+     * one
+     * @param peer
+     */
+    #elsewhereJoined(peer) {
+        if (peer.role === 'sfu') {
+            if (peer.peerId !== this.#host.id && !this.#members.has(peer.peerId))
+                this.#cascade(peer.peerId);
+        }
+        else if (!peer.role && peer.sfu) {
+            this.#elsewhere.set(peer.peerId, peer.sfu);
+        }
+        this.#unwait();
+    }
+    /**
+     * Whether the server serves a member: a client connected to it (the media server of another node serves the
+     * others)
+     * @param peer
+     */
+    #serves(peer) {
+        return !peer.role && peer.sfu === this.#host.id;
+    }
+    /**
+     * An event of the room
+     * @param event
+     * @param payload
+     */
+    #receive(event, payload) {
+        if (this.#closed)
+            return;
+        switch (event) {
+            case SignalingEvent.peerJoined: {
+                const joined = payload;
+                const member = this.#members.get(joined.peerId);
+                if (!this.#serves(joined)) {
+                    //A client joining again through the media server of another node
+                    if (!joined.role && member?.peer)
+                        this.#remove(member);
+                    this.#elsewhereJoined(joined);
+                    return;
+                }
+                this.#elsewhere.delete(joined.peerId);
+                //A new client behind the same id: its old connection is useless
+                if (member && joined.session !== undefined && member.session !== joined.session)
+                    this.#remove(member);
+                if (member && this.#members.get(joined.peerId) === member) {
+                    const changed = JSON.stringify(member.metadata) !== JSON.stringify(joined.metadata);
+                    member.metadata = joined.metadata;
+                    if (changed)
+                        this.#reselect(member);
+                    return;
+                }
+                this.#add(joined.peerId, joined.metadata, joined.session);
+                return;
+            }
+            case SignalingEvent.peerLeft: {
+                const peerId = payload.peerId;
+                this.#elsewhere.delete(peerId);
+                const member = this.#members.get(peerId);
+                if (member)
+                    this.#remove(member);
+                return;
+            }
+            case SignalingEvent.signal: {
+                const signal = payload;
+                let member = this.#members.get(signal.from);
+                if (!member) {
+                    //A client of another media server (a signal still on its way when it moved) is not taken
+                    if (this.#elsewhere.has(signal.from))
+                        return;
+                    member = signal.from.startsWith('sfu:') ? this.#cascade(signal.from) : this.#add(signal.from, undefined, signal.session);
+                }
+                //The streams of the media server of another node: the members they come from
+                if (member.cascade)
+                    for (const stream of signal.streams ?? [])
+                        member.cascade.received.set(stream.id, stream);
+                const received = {};
+                if (signal.description)
+                    received.description = signal.description;
+                if (signal.candidate)
+                    received.candidate = signal.candidate;
+                member.peer?.receive(received);
+                return;
+            }
+        }
+    }
+    /**
+     * Connect to a member, and send it the tracks published
+     * @param id
+     * @param metadata
+     * @param session
+     */
+    #add(id, metadata, session) {
+        const host = {
+            localId: this.#host.id,
+            create: () => this.#host.connect(),
+            send: (to, signal) => this.#signal(member, signal),
+            signalingUp: true,
+            closed: () => undefined,
+            polite: false
+        };
+        const peer = new Peer(host, id, metadata, session);
+        const member = {
+            id: id,
+            leg: peer,
+            peer: peer,
+            metadata: metadata,
+            session: session,
+            publications: new Map(),
+            subscriptions: new Map(),
+            streams: new Map(),
+            streamIds: new Map(),
+            transceivers: new Set()
+        };
+        this.#members.set(id, member);
+        this.#host.changed?.(this);
+        //The tracks of the other nodes it may receive
+        this.#evaluate();
+        this.#unwait();
+        //A failed negotiation is the member's (it left meanwhile, it sent a wrong description)
+        peer.on('error', () => undefined);
+        peer.on('track', (event) => this.#published(member, event));
+        peer.on('datachannel', (channel) => this.#opened(member, channel));
+        peer.ready.then(async () => {
+            if (peer.closed)
+                return;
+            const connection = peer.connection;
+            //Once the negotiation applied the directions
+            connection.on('signalingstatechange', (state) => {
+                if (state === 'stable')
+                    setImmediate(() => this.#negotiated(member));
+            });
+            connection.on('connectionstatechange', (state) => {
+                if (state === 'connected')
+                    this.#watchBandwidth(member);
+            });
+            //select asked first for the tracks already published, its answers awaited a moment: the control channel and
+            //the tracks selected are then added at once, and the first offer carries them all
+            const metadata = member.metadata;
+            const answers = new Map([...this.#publications].map((publication) => [publication, this.#ask(member, publication)]));
+            //Waiting only for answers to come: otherwise the first offer goes as soon as before
+            const settled = [...answers.values()].some((answer) => answer instanceof Promise)
+                ? await this.#settle(answers)
+                : new Map();
+            if (peer.closed || this.#members.get(member.id) !== member)
+                return;
+            const control = connection.createDataChannel(SignalingControlChannel.label, { negotiated: true, id: SignalingControlChannel.id });
+            control.on('message', (data) => this.#controlled(member, data));
+            member.control = control;
+            //The tracks published meanwhile were offered as they came; when the metadata changed meanwhile (a change
+            //before the connection is up is not reselected), select is asked again
+            for (const [publication, answer] of answers) {
+                if (!this.#publications.has(publication))
+                    continue;
+                if (member.metadata === metadata)
+                    this.#offer(member, publication, settled.get(publication) ?? answer);
+                else
+                    this.#offer(member, publication);
+            }
+        }, () => this.#remove(member));
+        return member;
+    }
+    /**
+     * A member opened a channel to another one (its protocol): the server opens the same channel to the other one (its
+     * protocol the id of the first one), and relays their messages
+     * @param member
+     * @param channel
+     */
+    #opened(member, channel) {
+        let source = member.id;
+        let target = channel.protocol;
+        if (member.cascade) {
+            //From the media server of another node: its protocol has the member it comes from and the one it goes to
+            const route = routeOf(channel.protocol);
+            if (!route)
+                return channel.close();
+            [source, target] = route;
+        }
+        //Its first messages may come with its opening, before the other side is there
+        const early = [];
+        const keep = (data) => early.push(data);
+        channel.on('message', keep);
+        this.#route({ member: member, channel: channel, source: source, target: target, early: early, keep: keep });
+    }
+    /**
+     * Relay a channel to its other member: on the connection to it, the protocol the id of the member it comes from;
+     * on the connection to the media server of its node, the protocol both of them (from a member of this node only:
+     * a channel goes through two servers at most). A channel to a member not known yet waits for it.
+     * @param opening
+     */
+    #route(opening) {
+        const { member, channel, source, target, early, keep } = opening;
+        if (channel.readyState === 'closing' || channel.readyState === 'closed')
+            return;
+        const local = this.#members.get(target);
+        let other;
+        let protocol;
+        //Not to a media server
+        if (local?.cascade || target.startsWith('sfu:'))
+            return channel.close();
+        if (local) {
+            //Not to a stream published with WHIP: it has no data channels
+            if (local === member || !local.peer || local.leg.closed)
+                return channel.close();
+            other = local;
+            protocol = source;
+        }
+        else {
+            const server = this.#elsewhere.get(target);
+            if (member.cascade && server !== undefined)
+                return channel.close();
+            other = member.cascade || server === undefined ? undefined : this.#members.get(server);
+            protocol = JSON.stringify([source, target]);
+        }
+        if (!other)
+            return this.#wait(opening);
+        const relayTo = other;
+        relayTo.leg.ready
+            .then(() => relayTo.cascade ? relayTo.peer.negotiated : undefined)
+            .then(() => {
+            channel.off('message', keep);
+            if (relayTo.leg.closed || channel.readyState === 'closed')
+                return channel.close();
+            const relayed = relayTo.leg.connection.createDataChannel(channel.label, {
+                protocol: protocol,
+                ordered: channel.ordered,
+                ...channel.maxRetransmits !== null ? { maxRetransmits: channel.maxRetransmits } : {},
+                ...channel.maxPacketLifeTime !== null ? { maxPacketLifeTime: channel.maxPacketLifeTime } : {}
+            });
+            relay(channel, relayed, early);
+            relay(relayed, channel);
+            channel.on('close', () => relayed.close());
+            relayed.on('close', () => channel.close());
+        }, () => channel.close());
+    }
+    /**
+     * A channel to a member not known yet waits for it, UNKNOWN_MEMBER_TIMEOUT at most
+     * @param opening
+     */
+    #wait(opening) {
+        if (this.#waiting.has(opening))
+            return;
+        this.#waiting.add(opening);
+        opening.timer = setTimeout(() => {
+            this.#waiting.delete(opening);
+            opening.channel.close();
+        }, UNKNOWN_MEMBER_TIMEOUT);
+        opening.timer.unref();
+        opening.channel.on('close', () => {
+            clearTimeout(opening.timer);
+            this.#waiting.delete(opening);
+        });
+    }
+    /**
+     * A member, or the media server of another node, is known: the channels waiting are relayed if they can be
+     */
+    #unwait() {
+        for (const opening of [...this.#waiting]) {
+            const known = this.#members.has(opening.target) || this.#members.has(this.#elsewhere.get(opening.target) ?? '');
+            if (!known)
+                continue;
+            this.#waiting.delete(opening);
+            clearTimeout(opening.timer);
+            this.#route(opening);
+        }
+    }
+    /**
+     * Close the connection to a member: its tracks are unpublished
+     * @param member
+     */
+    #remove(member) {
+        if (this.#members.get(member.id) !== member)
+            return;
+        this.#members.delete(member.id);
+        for (const publication of [...member.publications.values()])
+            this.#unpublished(publication);
+        member.leg.close();
+        //A stream published with WHIP leaves the signaling (before the server, when it was the last one)
+        if (!member.peer)
+            this.#host.signaling.leave(member.id, this.name).catch(() => undefined);
+        if (member.cascade) {
+            //Its tracks are not offered any more, its members are not reached any more
+            for (const key of member.cascade.offered.keys())
+                this.#endRead(key);
+            for (const opening of [...this.#waiting])
+                if (this.#elsewhere.get(opening.target) === member.id)
+                    opening.channel.close();
+            if (!this.#closed)
+                this.#knownChanged();
+        }
+        else {
+            this.#selected.delete(member.id);
+            if (!this.#closed)
+                this.#tellWants();
+        }
+        if (!this.#closed)
+            this.#host.changed?.(this);
+        if (!this.#closed && this.empty)
+            this.#host.emptied(this);
+    }
+    /**
+     * Send a signal to a member: a description carries the streams sent to it
+     * @param member
+     * @param signal
+     */
+    async #signal(member, signal) {
+        await this.#host.signaling.signal(this.#host.id, this.name, member.id, {
+            ...signal,
+            ...signal.description ? { streams: [...member.streams.values()] } : {}
+        });
+    }
+    /**
+     * Send a track published to a member, if the server selects it for the member
+     * @param member
+     * @param publication
+     */
+    #offer(member, publication, answer = this.#ask(member, publication)) {
+        //A stream published with WHIP receives nothing
+        if (member === publication.publisher || !member.peer || member.leg.closed)
+            return;
+        //The media server of another node: the tracks of the members of this node it wants
+        if (member.cascade) {
+            if (!publication.remote && member.cascade.wanted.has(trackKey(publication.track.peerId, publication.track.id)))
+                this.#subscribe(member, publication).catch(() => undefined);
+            return;
+        }
+        const selected = answer;
+        if (selected === undefined)
+            return;
+        if (typeof selected === 'boolean') {
+            if (selected)
+                this.#subscribe(member, publication).catch(() => undefined);
+            return;
+        }
+        //Chosen elsewhere: the member and the track may be gone meanwhile
+        selected.then((selected) => selected
+            && this.#members.get(member.id) === member
+            && !member.leg.closed
+            && this.#publications.has(publication)
+            ? this.#subscribe(member, publication)
+            : undefined).catch(() => undefined);
+    }
+    /**
+     * Ask select whether a member receives a track published: undefined for the members select is not asked for (the
+     * publisher, the media servers of the other nodes, a member whose connection is closed)
+     * @param member
+     * @param publication
+     */
+    #ask(member, publication) {
+        if (member === publication.publisher || !member.peer || member.leg.closed || member.cascade)
+            return undefined;
+        return this.#host.select({ peerId: member.id, metadata: member.metadata, session: member.session }, publication.track);
+    }
+    /**
+     * Wait for the answers of select given as promises, FIRST_OFFER_SELECT_WAIT at most
+     * @param answers
+     * @returns The answers that came, a failed one as false
+     */
+    async #settle(answers) {
+        const settled = new Map();
+        const waiting = [];
+        for (const [publication, answer] of answers) {
+            if (answer instanceof Promise)
+                waiting.push(answer.then((selected) => void settled.set(publication, selected), () => void settled.set(publication, false)));
+        }
+        if (!waiting.length)
+            return settled;
+        let timer;
+        await Promise.race([Promise.all(waiting), new Promise((resolve) => {
+                timer = setTimeout(resolve, FIRST_OFFER_SELECT_WAIT);
+            })]);
+        clearTimeout(timer);
+        return settled;
+    }
+    /**
+     * A member publishes a track: the members selected for it receive it
+     * @param member
+     * @param event
+     */
+    #published(member, event) {
+        //A transceiver of the member receiving again: the track it received before ended
+        const previous = member.publications.get(event.transceiver);
+        if (previous)
+            this.#unpublished(previous);
+        const engine = engineTransceiverOf(member.leg.connection, event.transceiver);
+        let peerId = member.id;
+        let stream = event.streams[0]?.id ?? '';
+        if (member.cascade) {
+            //A track of a member of another node: its member and its stream are the ones of the streams of its server
+            const origin = member.cascade.received.get(stream);
+            if (!origin)
+                return;
+            peerId = origin.peerId;
+            stream = origin.stream;
+        }
+        const track = {
+            room: this.name,
+            peerId: peerId,
+            id: engine?.receiver.remoteTrackId ?? event.transceiver.mid ?? event.track.id,
+            kind: event.track.kind,
+            codec: event.track.codec ?? '',
+            stream: stream
+        };
+        const publication = { track: track, media: event.track, transceiver: event.transceiver, publisher: member, remote: !!member.cascade };
+        member.publications.set(event.transceiver, publication);
+        this.#publications.add(publication);
+        if (publication.remote) {
+            this.#pipe(trackKey(track.peerId, track.id));
+        }
+        else {
+            this.#host.emit('publish', track);
+            this.#tellTracks();
+        }
+        for (const other of this.#members.values())
+            this.#offer(other, publication);
+        for (const viewer of this.#viewers.values())
+            void this.#feed(viewer);
+    }
+    /**
+     * A track is not published any more: the members receiving it stop
+     * @param publication
+     */
+    #unpublished(publication) {
+        if (!this.#publications.delete(publication))
+            return;
+        if (publication.publisher.publications.get(publication.transceiver) === publication)
+            publication.publisher.publications.delete(publication.transceiver);
+        for (const member of this.#members.values())
+            this.#unsubscribe(member, publication);
+        if (publication.remote) {
+            this.#pipe(trackKey(publication.track.peerId, publication.track.id));
+        }
+        else {
+            this.#host.emit('unpublish', publication.track);
+            this.#tellTracks();
+        }
+        for (const viewer of this.#viewers.values())
+            void this.#feed(viewer);
+    }
+    /**
+     * Send a track to a member: on a transceiver of a track sent before, of the same codec, else on a new one
+     * @param member
+     * @param publication
+     */
+    async #subscribe(member, publication) {
+        if (member.subscriptions.has(publication))
+            return;
+        const connection = member.leg.connection;
+        const stream = this.#streamOf(member, publication.track);
+        const taken = new Set([...member.subscriptions.values()].map((subscription) => subscription.transceiver));
+        const reusable = connection.getTransceivers().find((transceiver) => member.transceivers.has(transceiver)
+            && !taken.has(transceiver)
+            && !transceiver.sender.track
+            && transceiver.direction === 'inactive'
+            && transceiver.currentDirection === 'inactive'
+            && transceiver.kind === publication.track.kind
+            && engineTransceiverOf(connection, transceiver)?.sender.codec?.mimeType.toLowerCase() === publication.track.codec.toLowerCase());
+        if (!reusable) {
+            const transceiver = connection.addTransceiver(publication.media, { direction: 'sendonly', streams: [stream] });
+            //The media server of another node takes the id of the track from its MSID, before it is negotiated
+            if (member.cascade)
+                engineSenderOf(transceiver.sender).trackId = publication.track.id;
+            member.transceivers.add(transceiver);
+            member.subscriptions.set(publication, { transceiver: transceiver, started: false, paused: false });
+            return;
+        }
+        member.subscriptions.set(publication, { transceiver: reusable, started: false, paused: false });
+        if (member.cascade)
+            engineSenderOf(reusable.sender).trackId = publication.track.id;
+        await reusable.sender.replaceTrack(publication.media);
+        reusable.sender.setStreams(stream);
+        reusable.direction = 'sendonly';
+    }
+    /**
+     * Stop sending a track to a member: its transceiver stays, inactive, for the next one
+     * @param member
+     * @param publication
+     */
+    #unsubscribe(member, publication) {
+        const subscription = member.subscriptions.get(publication);
+        if (!subscription)
+            return;
+        member.subscriptions.delete(publication);
+        if (member.leg.closed)
+            return;
+        try {
+            subscription.transceiver.direction = 'inactive';
+            subscription.transceiver.sender.replaceTrack(null).catch(() => undefined);
+        }
+        catch {
+            //Stopped already
+        }
+    }
+    /**
+     * The id of the stream of a track on the connection of a member: short (at most 64 characters in an MSID), the
+     * same for the tracks of a stream of a member
+     * @param member
+     * @param track
+     */
+    #streamOf(member, track) {
+        const key = JSON.stringify([track.peerId, track.stream || track.id]);
+        let id = member.streamIds.get(key);
+        if (!id) {
+            id = `s${member.streamIds.size + 1}`;
+            member.streamIds.set(key, id);
+            member.streams.set(id, { id: id, peerId: track.peerId, stream: track.stream });
+        }
+        return id;
+    }
+    /**
+     * A negotiation with a member completed: the tracks it stopped sending are unpublished, the ones it refused (no
+     * codec in common) are given up, and the ones it starts receiving begin with a key frame
+     * @param member
+     */
+    #negotiated(member) {
+        if (member.leg.closed || member.leg.connection.signalingState !== 'stable')
+            return;
+        for (const publication of [...member.publications.values()]) {
+            const direction = publication.transceiver.currentDirection;
+            if (direction === 'inactive' || direction === 'sendonly' || direction === 'stopped')
+                this.#unpublished(publication);
+        }
+        for (const [publication, subscription] of [...member.subscriptions]) {
+            const direction = subscription.transceiver.currentDirection;
+            if (direction === 'stopped') {
+                member.subscriptions.delete(publication);
+                this.#host.emit('unsupported', this.name, member.id, publication.track);
+            }
+            else if (!subscription.started && (direction === 'sendonly' || direction === 'sendrecv')) {
+                subscription.started = true;
+                if (publication.track.kind === 'video')
+                    publication.media.requestKeyFrame();
+            }
+        }
+    }
+    /**
+     * A message of a member on its control channel: pause or resume a track it receives
+     * @param member
+     * @param data
+     */
+    #controlled(member, data) {
+        let message;
+        try {
+            message = JSON.parse(typeof data === 'string' ? data : Buffer.from(data).toString());
+        }
+        catch {
+            return;
+        }
+        if (member.cascade)
+            return this.#cascaded(member, member.cascade, message);
+        if (message?.type !== 'pause' && message?.type !== 'resume')
+            return;
+        for (const [publication, subscription] of member.subscriptions) {
+            if (subscription.transceiver.mid !== message.mid)
+                continue;
+            const paused = message.type === 'pause';
+            if (subscription.paused === paused)
+                return;
+            subscription.paused = paused;
+            subscription.transceiver.sender.replaceTrack(paused ? null : publication.media).catch(() => undefined);
+            if (!paused && publication.track.kind === 'video')
+                publication.media.requestKeyFrame();
+            return;
+        }
+    }
+    /**
+     * Connect to the media server of another node in the room: the one of the lower id offers first and does not give
+     * up its offers; their control channel carries the tracks of each node and the ones each wants of the other
+     * @param id The id of the member of that server.
+     */
+    #cascade(id) {
+        const peerHost = {
+            localId: this.#host.id,
+            create: () => this.#host.connect(),
+            send: (_to, signal) => this.#signal(member, signal),
+            signalingUp: true,
+            closed: () => undefined,
+            polite: this.#host.id > id
+        };
+        const peer = new Peer(peerHost, id, undefined, undefined);
+        const cascade = { offered: new Map(), wanted: new Set(), received: new Map() };
+        const member = {
+            id: id,
+            leg: peer,
+            peer: peer,
+            metadata: undefined,
+            publications: new Map(),
+            subscriptions: new Map(),
+            streams: new Map(),
+            streamIds: new Map(),
+            transceivers: new Set(),
+            cascade: cascade
+        };
+        this.#members.set(id, member);
+        this.#unwait();
+        peer.on('error', () => undefined);
+        peer.on('track', (event) => this.#published(member, event));
+        peer.on('datachannel', (channel) => this.#opened(member, channel));
+        //The polite side waits for the first offer of the other one
+        peer.ready.then(() => peer.polite ? peer.negotiated : undefined).then(() => {
+            if (peer.closed)
+                return;
+            const connection = peer.connection;
+            connection.on('signalingstatechange', (state) => {
+                if (state === 'stable')
+                    setImmediate(() => this.#negotiated(member));
+            });
+            const control = connection.createDataChannel(SignalingControlChannel.label, { negotiated: true, id: SignalingControlChannel.id });
+            control.on('message', (data) => this.#controlled(member, data));
+            //What it was told before is lost with a channel not open
+            control.on('open', () => {
+                cascade.toldTracks = undefined;
+                cascade.toldWants = undefined;
+                this.#tellTracks();
+                this.#tellWants();
+            });
+            member.control = control;
+        }, () => this.#remove(member));
+        return member;
+    }
+    /**
+     * A message of the media server of another node
+     * @param member
+     * @param cascade
+     * @param message
+     */
+    #cascaded(member, cascade, message) {
+        if (!cascade.heard) {
+            cascade.heard = true;
+            cascade.toldTracks = undefined;
+            cascade.toldWants = undefined;
+            this.#tellTracks();
+            this.#tellWants();
+        }
+        if (message?.type === 'tracks' && Array.isArray(message.tracks)) {
+            const before = cascade.offered;
+            cascade.offered = new Map(message.tracks
+                .filter((offered) => typeof offered?.track?.peerId === 'string' && typeof offered.track.id === 'string')
+                .map((offered) => [trackKey(offered.track.peerId, offered.track.id), { track: { ...offered.track, room: this.name }, ...offered.codec ? { codec: offered.codec } : {} }]));
+            for (const key of before.keys())
+                if (!cascade.offered.has(key))
+                    this.#endRead(key);
+            this.#knownChanged();
+            this.#evaluate();
+            for (const viewer of this.#viewers.values())
+                void this.#feed(viewer);
+        }
+        else if (message?.type === 'want' && Array.isArray(message.keys)) {
+            cascade.wanted = new Set(message.keys.filter((key) => typeof key === 'string'));
+            for (const publication of [...this.#publications]) {
+                if (publication.remote)
+                    continue;
+                if (cascade.wanted.has(trackKey(publication.track.peerId, publication.track.id)))
+                    this.#offer(member, publication);
+                else
+                    this.#unsubscribe(member, publication);
+            }
+        }
+    }
+    /**
+     * The tracks the media servers of the other nodes offer
+     */
+    *#offeredTracks() {
+        for (const member of this.#members.values())
+            if (member.cascade)
+                yield* member.cascade.offered.values();
+    }
+    /**
+     * A track another node offers
+     * @param key
+     */
+    #offered(key) {
+        for (const member of this.#members.values()) {
+            const offered = member.cascade?.offered.get(key);
+            if (offered)
+                return offered;
+        }
+        return undefined;
+    }
+    /**
+     * A track of another node received here
+     * @param key
+     */
+    #remotePublication(key) {
+        for (const publication of this.#publications) {
+            if (publication.remote && trackKey(publication.track.peerId, publication.track.id) === key)
+                return publication;
+        }
+        return undefined;
+    }
+    /**
+     * The tracks the other nodes offer changed: the thread forwarding the room tells the main thread
+     */
+    #knownChanged() {
+        this.#host.known?.(this, [...this.#offeredTracks()]);
+    }
+    /**
+     * Tell the media servers of the other nodes the tracks of the members of this node
+     */
+    #tellTracks() {
+        const tracks = [...this.#publications].filter((publication) => !publication.remote).map((publication) => {
+            const codec = engineTrackOf(publication.media).codec;
+            return { track: publication.track, ...codec ? { codec: { payloadType: codec.payloadType, mimeType: codec.mimeType, clockRate: codec.clockRate, channels: codec.channels, parameters: codec.parameters } } : {} };
+        });
+        const told = JSON.stringify({ type: 'tracks', tracks: tracks });
+        for (const member of this.#members.values()) {
+            if (!member.cascade || member.control?.readyState !== 'open' || member.cascade.toldTracks === told)
+                continue;
+            member.cascade.toldTracks = told;
+            member.control.send(told);
+        }
+    }
+    /**
+     * Tell the media servers of the other nodes the tracks of theirs this node wants: the ones a member of this node is
+     * selected for, the ones of the source of a viewer, the ones read here
+     */
+    #tellWants() {
+        if (this.#closed)
+            return;
+        const sources = new Set([...this.#viewers.values()].map((viewer) => viewer.source).filter((source) => source !== undefined));
+        for (const member of this.#members.values()) {
+            const cascade = member.cascade;
+            if (!cascade || member.control?.readyState !== 'open')
+                continue;
+            const keys = [];
+            for (const [key, { track }] of cascade.offered) {
+                const selected = [...this.#members.values()].some((each) => !!each.peer && !each.cascade && !each.leg.closed && each.id !== track.peerId && this.#selected.get(each.id)?.get(key) === true);
+                if (selected || sources.has(track.peerId) || this.#reads.get(key)?.wanted)
+                    keys.push(key);
+            }
+            const told = JSON.stringify({ type: 'want', keys: keys.sort() });
+            if (cascade.toldWants === told)
+                continue;
+            cascade.toldWants = told;
+            member.control.send(told);
+        }
+    }
+    /**
+     * The metadata of a member changed: select is asked again for it, the tracks it receives follow the answers (and
+     * the tracks of the other nodes this node wants)
+     * @param member
+     */
+    #reselect(member) {
+        if (!member.peer || member.cascade)
+            return;
+        this.#selected.delete(member.id);
+        this.#evaluate();
+        //Before its connection is up, it gets the tracks as it comes
+        if (!member.control)
+            return;
+        const subscriber = { peerId: member.id, metadata: member.metadata, session: member.session };
+        for (const publication of [...this.#publications]) {
+            if (publication.publisher === member)
+                continue;
+            const apply = (selected) => {
+                if (this.#members.get(member.id) !== member || member.leg.closed || !this.#publications.has(publication))
+                    return;
+                if (selected)
+                    this.#subscribe(member, publication).catch(() => undefined);
+                else
+                    this.#unsubscribe(member, publication);
+            };
+            const answer = this.#host.select(subscriber, publication.track);
+            if (typeof answer === 'boolean')
+                apply(answer);
+            else
+                answer.then(apply, () => undefined);
+        }
+    }
+    /**
+     * Ask select for the members of this node and the tracks of the other nodes not asked yet; the tracks wanted follow
+     * the answers
+     */
+    #evaluate() {
+        for (const member of this.#members.values()) {
+            if (!member.peer || member.cascade)
+                continue;
+            let selected = this.#selected.get(member.id);
+            if (!selected) {
+                selected = new Map();
+                this.#selected.set(member.id, selected);
+            }
+            const answers = selected;
+            for (const offered of this.#offeredTracks()) {
+                const key = trackKey(offered.track.peerId, offered.track.id);
+                if (answers.has(key) || offered.track.peerId === member.id)
+                    continue;
+                const answer = this.#host.select({ peerId: member.id, metadata: member.metadata, session: member.session }, offered.track);
+                if (typeof answer === 'boolean') {
+                    answers.set(key, answer);
+                    continue;
+                }
+                //Not wanted until it answers
+                answers.set(key, false);
+                answer.then((yes) => {
+                    if (!yes || this.#selected.get(member.id) !== answers)
+                        return;
+                    answers.set(key, true);
+                    this.#tellWants();
+                }, () => undefined);
+            }
+        }
+        this.#tellWants();
+    }
+    /**
+     * Give a track of another node read here its packets, while it is read and received
+     * @param key
+     */
+    #pipe(key) {
+        const read = this.#reads.get(key);
+        if (!read)
+            return;
+        const source = read.wanted ? this.#remotePublication(key) : undefined;
+        if (read.source === source)
+            return;
+        read.unpipe?.();
+        read.unpipe = undefined;
+        read.source = source;
+        if (!source)
+            return;
+        read.unpipe = engineTrackOf(source.media).onReceiveRtp.subscribe((packet, extensions) => read.receive(packet, extensions)).unSubscribe;
+        if (source.track.kind === 'video')
+            source.media.requestKeyFrame();
+    }
+    /**
+     * A track of another node is not offered any more: the track read here ends
+     * @param key
+     */
+    #endRead(key) {
+        const read = this.#reads.get(key);
+        if (!read)
+            return;
+        this.#reads.delete(key);
+        read.unpipe?.();
+        read.track.stop();
+    }
+    /**
+     * Tell the application when the bandwidth to a member is too low, and when it is enough again
+     * @param member
+     */
+    #watchBandwidth(member) {
+        const transport = engineConnectionOf(member.leg.connection).dtlsTransports[0];
+        if (!transport || this.#watched.has(transport))
+            return;
+        this.#watched.add(transport);
+        transport.senderBWE.onCongestion.subscribe((congested) => {
+            if (!member.leg.closed)
+                this.#host.emit('congestion', this.name, member.id, congested, transport.senderBWE.availableBitrate);
+        });
+    }
+}