@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/esm/sfu/SFU.js

@@ -0,0 +1,759 @@
+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 { randomUUID } from 'node:crypto';
+import { Component, DTO } from '@lakutata/core';
+import { Configurable, Singleton } from '@lakutata/core/decorator/di';
+import { SignalingLimitException } from '../exceptions/SignalingLimitException.js';
+import { debug } from '../lib/common/log.js';
+import { SUPPORTED_CODECS } from '../peer/MediaCodecs.js';
+import { PeerConnection } from '../peer/PeerConnection.js';
+import { MEDIA_SERVER_ASSIGN_TOPIC, MEDIA_SERVER_SERVICE, mediaServers } from '../signaling/MediaServers.js';
+import { sfuAccess, sfuRooms, sfuWorkers } from './SFUAccess.js';
+import { ClusterLeg, LEG_TIMEOUT, SFU_TOPICS } from './SFUClusterLeg.js';
+import { SFURoom } from './SFURoom.js';
+import { SFUWorkers } from './SFUWorkers.js';
+/**
+ * A node refused what it was asked to take (its offer, its room): the other nodes are not asked
+ */
+class Refused extends Error {
+}
+const log = debug('webrtc/sfu');
+/**
+ * How often a media server announces its load on the cluster, in milliseconds
+ */
+const ANNOUNCE_INTERVAL = 1000;
+/**
+ * How long a node remembers a leg the node of its session stopped waiting for, in milliseconds
+ */
+const GIVEN_UP_TIME = 60000;
+/**
+ * How many nodes are tried for a member at most
+ */
+const MAX_PLACEMENT_ATTEMPTS = 3;
+/**
+ * The media server of the rooms of a {@link Signaling} (a selective forwarding unit): each member connects to the
+ * server only, publishes its tracks once, and receives the tracks of the others from the server, which forwards their
+ * packets without decoding them. A room of many members then costs each of them one connection and one upload, instead
+ * of one of each per other member.
+ *
+ * The server is a member of each room it serves (its id starts with `sfu:`, its role is `sfu`); the clients of this
+ * package (`SignalingClient`, `SignalingConnection` of `./client`) connect to it by themselves, and their rooms and
+ * peers work as without it: `room.publish()` sends a track to every member, each peer emits the tracks of its member,
+ * and a data channel to a member goes through the server, which relays its messages (unlike between two members, the
+ * server sees them; with a cluster, the servers of both members relay them). The key frame requests of the members go
+ * to the publisher, at most every 500 ms; the lost packets are sent again by the server; the bandwidth of each
+ * connection is estimated from the transport-wide feedback. A member receiving the messages of a channel slower than
+ * they are sent makes the sender wait, without the server keeping more than a few megabytes of them.
+ *
+ * Events: `publish` and `unpublish` (an {@link SFUTrack}) when a member of this node starts and stops publishing a
+ * track (with a cluster, they are emitted on the node of the member only), `unsupported` (the room, the id of the
+ * member or of the viewer of WHEP, the track) when a member or a viewer does not support the codec of a track it should
+ * receive, `congestion` (the room, the id of the member, whether it is congested, the bit rate estimated in bits per
+ * second) when the bandwidth to a member is too low, and when it is enough again.
+ *
+ * Register it with {@link buildSFUOptions}, and bootstrap it: it attaches itself to the signaling when it starts.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints} from 'lakutata/com/entrypoint'
+ * import {socketIOServiceEntrypoint} from 'lakutata/adapter/socket.io'
+ * import {buildSFUOptions, buildSignalingOptions, SignalingController} from '@lakutata/webrtc'
+ *
+ * Application.run(() => ({
+ *     id: 'meet.app',
+ *     name: 'Meet',
+ *     components: {
+ *         signaling: buildSignalingOptions(),
+ *         //The meetings go through the server; the other rooms stay peer to peer
+ *         sfu: buildSFUOptions({
+ *             serves: (room: string): boolean => room.startsWith('meeting-'),
+ *             iceAdditionalHostAddresses: ['203.0.113.10'],
+ *             icePortRange: [40000, 40999]
+ *         }),
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [SignalingController],
+ *             service: socketIOServiceEntrypoint({port: 3000})
+ *         })
+ *     },
+ *     bootstrap: ['sfu', 'entrypoint']
+ * }))
+ * ```
+ */
+let SFU = class SFU extends Component {
+    #rooms = new Map();
+    #workers;
+    //The rooms being left: a room joined again waits for it
+    #leaving = new Map();
+    #id = `sfu:${randomUUID()}`;
+    #signalingObject;
+    #clusterObject;
+    //Announces the load of the server on the cluster
+    #announcer;
+    //The legs of the sessions of WHIP and WHEP of this node on other nodes, the legs of this node for the sessions of
+    //other nodes, the choices of source of the viewers of this node on other nodes (by the ids of the legs)
+    #clusterLegs = new Map();
+    #servedLegs = new Map();
+    #choosers = new Map();
+    //The legs the node of their session gave up before they were taken (its request timed out), until when
+    #givenUp = new Map();
+    #detach = [];
+    /**
+     * Attach the server to the signaling.
+     * @protected
+     */
+    async init() {
+        sfuRooms.set(this, this.#rooms);
+        this.#signalingObject = await this.getObject(this.signaling);
+        if (this.cluster) {
+            const cluster = await this.getObject(this.cluster);
+            this.#clusterObject = cluster;
+            //One member of the server in each room, the same in all of them: the one of this node
+            this.#id = `sfu:${cluster.nodeId}`;
+            const down = (node) => this.#nodeDown(node.id);
+            cluster.on('node-down', down);
+            this.#detach.push(cluster.handle(MEDIA_SERVER_ASSIGN_TOPIC, ({ room, peerId }) => this.#reply(() => this.assign(room, peerId))), cluster.handle(SFU_TOPICS.serve, ({ room, peerId, kind }) => this.#reply(async () => {
+                if (this.serves && !this.serves(room))
+                    return undefined;
+                await this.#serveLocal(room, peerId, kind);
+                return this.#id;
+            })), 
+            //The legs of the sessions of other nodes
+            cluster.handle(SFU_TOPICS.publish, ({ room, peerId, offer }, from) => this.#takeLeg(from, room, peerId, () => this.#publishLocal(room, peerId, offer))), cluster.handle(SFU_TOPICS.play, ({ room, viewerId, offer, select }, from) => this.#takeLeg(from, room, viewerId, () => this.#playLocal(room, viewerId, offer, select
+                ? async (tracks) => await cluster.request(from, SFU_TOPICS.choose, { id: viewerId, tracks: tracks }) ?? undefined
+                : undefined))), cluster.handle(SFU_TOPICS.patch, async ({ id, fragment, restart }) => {
+                const served = this.#servedLegs.get(id);
+                if (!served)
+                    throw new Error('There is no such session');
+                const answer = await served.leg.patch(fragment, restart);
+                return answer === null ? { stale: true } : answer === undefined ? {} : { fragment: answer };
+            }), cluster.handle(SFU_TOPICS.end, ({ id }) => {
+                const served = this.#servedLegs.get(id);
+                if (served)
+                    served.leg.close();
+                else
+                    this.#giveUp(id);
+                return true;
+            }), 
+            //The legs of the sessions of this node on other nodes
+            cluster.handle(SFU_TOPICS.ended, ({ id }) => {
+                this.#clusterLegs.get(id)?.end();
+                return true;
+            }), cluster.handle(SFU_TOPICS.source, ({ id, source }) => {
+                this.#clusterLegs.get(id)?.sourced(source ?? undefined);
+                return true;
+            }), cluster.handle(SFU_TOPICS.choose, async ({ id, tracks }) => await this.#choosers.get(id)?.(tracks) ?? null), () => cluster.off('node-down', down), () => cluster.announce(MEDIA_SERVER_SERVICE, undefined));
+            this.#announce();
+            this.#announcer = setInterval(() => this.#announce(), ANNOUNCE_INTERVAL);
+            this.#announcer.unref();
+        }
+        if (this.workers)
+            await this.#startWorkers();
+        mediaServers.set(this.#signalingObject, (room, peerId) => this.assign(room, peerId));
+        sfuAccess.set(this, {
+            publish: async (room, offer) => {
+                //Its own id: the id of the session is the credential of its publisher
+                const peerId = `whip:${randomUUID()}`;
+                if (this.serves && !this.serves(room))
+                    throw new Error(`The media server does not serve the room ${room}`);
+                const cluster = this.#clusterObject;
+                if (!cluster)
+                    return { peerId: peerId, leg: await this.#publishLocal(room, peerId, offer) };
+                return {
+                    peerId: peerId,
+                    leg: await this.#placeOn({ room: room, peerId: peerId, kind: 'whip' }, cluster, () => this.#publishLocal(room, peerId, offer), async (node) => {
+                        const reply = await this.#requestLeg(cluster, node, peerId, SFU_TOPICS.publish, { room: room, peerId: peerId, offer: offer });
+                        return this.#legOf(node, peerId, reply);
+                    })
+                };
+            },
+            play: async (room, offer, select) => {
+                const viewerId = `whep:${randomUUID()}`;
+                if (this.serves && !this.serves(room))
+                    throw new Error(`The media server does not serve the room ${room}`);
+                const cluster = this.#clusterObject;
+                if (!cluster)
+                    return { viewerId: viewerId, leg: await this.#playLocal(room, viewerId, offer, select) };
+                //Its source chosen here, where the session is, wherever its connection is
+                if (select)
+                    this.#choosers.set(viewerId, select);
+                try {
+                    return {
+                        viewerId: viewerId,
+                        leg: await this.#placeOn({ room: room, peerId: viewerId, kind: 'viewer' }, cluster, () => this.#playLocal(room, viewerId, offer, select), async (node) => {
+                            const reply = await this.#requestLeg(cluster, node, viewerId, SFU_TOPICS.play, { room: room, viewerId: viewerId, offer: offer, select: !!select });
+                            const leg = this.#legOf(node, viewerId, reply);
+                            if (leg !== 'full')
+                                leg.ended(() => this.#choosers.delete(viewerId));
+                            return leg;
+                        })
+                    };
+                }
+                finally {
+                    //A choice of a viewer on another node only
+                    const leg = this.#clusterLegs.get(viewerId);
+                    if (!leg)
+                        this.#choosers.delete(viewerId);
+                }
+            }
+        });
+    }
+    /**
+     * Detach the server, and leave the rooms.
+     * @protected
+     */
+    async destroy() {
+        if (this.#signalingObject && mediaServers.get(this.#signalingObject))
+            mediaServers.delete(this.#signalingObject);
+        clearInterval(this.#announcer);
+        for (const detach of this.#detach.splice(0))
+            detach();
+        for (const leg of [...this.#clusterLegs.values()])
+            leg.close();
+        for (const { leg } of [...this.#servedLegs.values()])
+            leg.close();
+        const rooms = [...this.#rooms.values()];
+        this.#rooms.clear();
+        await Promise.all(rooms.map((room) => room.close()));
+        await this.#workers?.stop();
+    }
+    /**
+     * The rooms the server is in, with their members on this node, the tracks these members publish and the number of
+     * viewers of WHEP on this node; with a cluster, each node reports its own. With `workers`, each thread reports its
+     * rooms: a change made in a thread (a session of WHEP ending) shows here a moment later.
+     * @returns For each room, the ids of its members, its tracks and its viewers.
+     * @example
+     * ```typescript
+     * import type {SFU} from '@lakutata/webrtc'
+     *
+     * declare const sfu: SFU
+     * for (const [room, {members, tracks}] of Object.entries(sfu.rooms())) console.log(room, members.length, tracks.length)
+     * ```
+     */
+    rooms() {
+        return Object.fromEntries([...this.#rooms].map(([name, room]) => [name, { members: [...room.members], tracks: room.tracks, viewers: room.viewers }]));
+    }
+    /**
+     * A track published in a room, to read its packets (to record them) or to send it on another connection. With a
+     * cluster, a track of a member of another node is received from that node while it is read here.
+     * @param room The room.
+     * @param peerId The member publishing it.
+     * @param trackId The id of the track ({@link SFUTrack.id}).
+     * @returns The track, or undefined when it is not published.
+     * @example
+     * ```typescript
+     * import type {RtpPacket, SFU, SFUTrack} from '@lakutata/webrtc'
+     *
+     * declare const sfu: SFU
+     * //Record the audio of the members of the room
+     * sfu.on('publish', (track: SFUTrack): void => {
+     *     if (track.kind === 'audio') sfu.track(track.room, track.peerId, track.id)?.on('rtp', (packet: RtpPacket): void => console.log(packet.timestamp))
+     * })
+     * ```
+     */
+    track(room, peerId, trackId) {
+        return this.#rooms.get(room)?.track(peerId, trackId);
+    }
+    /**
+     * Give a member joining a room a media server, once the server is in the room: this one, or with a cluster the one
+     * of the node chosen (`selectSFU`)
+     * @param room The room.
+     * @param peerId The id of the member.
+     * @param kind A member, a stream of WHIP, or a viewer of WHEP (`maxMembers` does not count the viewers).
+     * @returns The id of the member of the server, or undefined for a room the servers do not serve.
+     * @throws {SignalingLimitException} When no media server takes the member.
+     * @protected
+     */
+    async assign(room, peerId, kind = 'member') {
+        if (this.serves && !this.serves(room))
+            return undefined;
+        if (!this.#clusterObject) {
+            await this.#serveLocal(room, peerId, kind);
+            return this.#id;
+        }
+        return await this.#place({ room: room, peerId: peerId, kind: kind }, this.#clusterObject);
+    }
+    /**
+     * Give a member the media server of a node of the cluster: the one chosen, else the default choice, the next one
+     * when it is full or does not answer
+     * @param placement
+     * @param cluster
+     */
+    async #place(placement, cluster) {
+        return await this.#placeOn(placement, cluster, async () => {
+            await this.#serveLocal(placement.room, placement.peerId, placement.kind);
+            return this.#id;
+        }, async (node) => {
+            const reply = await cluster.request(node, SFU_TOPICS.serve, placement);
+            return 'full' in reply ? 'full' : reply.sfu ?? undefined;
+        });
+    }
+    /**
+     * Take something in a room on a node: the nodes are tried in the order of the choice, the next one when one is full
+     * or does not answer
+     * @param placement What joins the room.
+     * @param cluster
+     * @param local Takes it on this node.
+     * @param remote Asks another node to take it.
+     * @throws {SignalingLimitException} When no node takes it.
+     * @throws {Error} When a node refuses it (its room, its offer).
+     */
+    async #placeOn(placement, cluster, local, remote) {
+        for (const node of (await this.#candidates(placement, cluster)).slice(0, MAX_PLACEMENT_ATTEMPTS)) {
+            if (node.local) {
+                try {
+                    return await local();
+                }
+                catch (error) {
+                    if (error instanceof SignalingLimitException)
+                        continue;
+                    throw error;
+                }
+            }
+            let result;
+            try {
+                result = await remote(node.id);
+            }
+            catch (error) {
+                if (error instanceof Refused)
+                    throw error;
+                //Gone or not answering
+                continue;
+            }
+            if (result !== 'full')
+                return result;
+        }
+        throw new SignalingLimitException('No media server takes the member {peerId} in the room {room}', { peerId: placement.peerId, room: placement.room });
+    }
+    /**
+     * The nodes a member may be given, in the order they are tried: the one selectSFU chooses, then for a room some
+     * nodes have, the least loaded of them that is not full, for a new room this node when it is not full, then the least
+     * loaded of the others, the ones full at last
+     * @param placement
+     * @param cluster
+     */
+    async #candidates(placement, cluster) {
+        //The nodes with members of the room: their members of the server are in it
+        const serving = new Set((this.#signalingObject.rooms()[placement.room] ?? [])
+            .filter((id) => id.startsWith('sfu:'))
+            .map((id) => id.slice('sfu:'.length)));
+        const nodes = cluster.nodes()
+            .filter((node) => node.local || !!node.services[MEDIA_SERVER_SERVICE])
+            .map((node) => {
+            const load = node.local ? this.#load() : node.services[MEDIA_SERVER_SERVICE];
+            return { id: node.id, labels: node.labels, local: node.local, members: load.members, viewers: load.viewers, maxMembers: load.maxMembers, serving: serving.has(node.id) };
+        });
+        const full = (node) => placement.kind !== 'viewer' && node.maxMembers > 0 && node.members >= node.maxMembers;
+        const byLoad = (a, b) => a.members + a.viewers - b.members - b.viewers || a.id.localeCompare(b.id);
+        const order = [];
+        const add = (candidates) => {
+            for (const node of candidates)
+                if (!order.includes(node))
+                    order.push(node);
+        };
+        const chosen = this.selectSFU ? await this.selectSFU({ ...placement }, nodes.map((node) => ({ ...node }))) : undefined;
+        if (chosen !== undefined)
+            add(nodes.filter((node) => node.id === chosen));
+        //A room stays on the fewest nodes: the members of a room are forwarded between its nodes
+        if (serving.size)
+            add(nodes.filter((node) => node.serving && !full(node)).sort(byLoad));
+        else
+            add(nodes.filter((node) => node.local && !full(node)));
+        add(nodes.filter((node) => !full(node)).sort(byLoad));
+        //Full as they announced it a moment ago
+        add(nodes.filter(full).sort(byLoad));
+        return order;
+    }
+    /**
+     * A stream published with WHIP joins a room of this server
+     * @param room
+     * @param peerId
+     * @param offer
+     */
+    async #publishLocal(room, peerId, offer) {
+        await this.#serveLocal(room, peerId, 'whip');
+        return await this.#rooms.get(room).publish(peerId, offer);
+    }
+    /**
+     * A viewer of WHEP plays a room of this server
+     * @param room
+     * @param viewerId
+     * @param offer
+     * @param select
+     */
+    async #playLocal(room, viewerId, offer, select) {
+        await this.#serveLocal(room, viewerId, 'viewer');
+        return await this.#rooms.get(room).play(viewerId, offer, select);
+    }
+    /**
+     * Take a stream of WHIP or a viewer of WHEP of a session of another node: its node is told when its connection
+     * ends, and when the source of a viewer changes
+     * @param node The node of the session.
+     * @param room
+     * @param id The id of the leg.
+     * @param take Takes it in the room.
+     */
+    async #takeLeg(node, room, id, take) {
+        if (this.serves && !this.serves(room))
+            return { refused: `The media server does not serve the room ${room}` };
+        let leg;
+        try {
+            leg = await take();
+        }
+        catch (error) {
+            if (error instanceof SignalingLimitException)
+                return { full: true };
+            return { refused: error.message };
+        }
+        //The node of its session stopped waiting for it meanwhile
+        if (this.#givenUp.delete(id)) {
+            leg.close();
+            return { refused: 'The session was given up' };
+        }
+        this.#servedLegs.set(id, { leg: leg, node: node });
+        leg.ended(() => {
+            if (this.#servedLegs.get(id)?.leg !== leg)
+                return;
+            this.#servedLegs.delete(id);
+            this.#clusterObject?.request(node, SFU_TOPICS.ended, { id: id }).catch(() => undefined);
+        });
+        return { answer: leg.answer, ...leg.source ? { source: leg.source() ?? null } : {} };
+    }
+    /**
+     * Ask another node to take a stream of WHIP or a viewer of WHEP; when it does not answer in time, it is told to
+     * close the leg if it takes it later
+     * @param cluster
+     * @param node
+     * @param id The id of the leg.
+     * @param topic
+     * @param message
+     */
+    async #requestLeg(cluster, node, id, topic, message) {
+        try {
+            return await cluster.request(node, topic, message, { timeout: LEG_TIMEOUT });
+        }
+        catch (error) {
+            cluster.request(node, SFU_TOPICS.end, { id: id }).catch(() => undefined);
+            throw error;
+        }
+    }
+    /**
+     * The leg of a session of this node on another node, from its answer
+     * @param node
+     * @param id
+     * @param reply
+     * @throws {Refused} When the node refused it.
+     */
+    #legOf(node, id, reply) {
+        if ('full' in reply)
+            return 'full';
+        if ('refused' in reply)
+            throw new Refused(reply.refused);
+        const cluster = this.#clusterObject;
+        const link = {
+            legs: this.#clusterLegs,
+            request: (to, topic, message) => cluster.request(to, topic, message, { timeout: LEG_TIMEOUT })
+        };
+        return new ClusterLeg(link, node, id, reply.answer, reply.source ?? undefined);
+    }
+    /**
+     * The source of a viewer of WHEP of this server changed: the node of its session is told, if it is another one
+     * @param viewerId
+     * @param source
+     */
+    #sourced(viewerId, source) {
+        const served = this.#servedLegs.get(viewerId);
+        if (served)
+            this.#clusterObject?.request(served.node, SFU_TOPICS.source, { id: viewerId, source: source ?? null }).catch(() => undefined);
+    }
+    /**
+     * The node of the session of a leg not taken yet stopped waiting for it: the leg is closed once taken (the ones of
+     * the last minute are kept)
+     * @param id
+     */
+    #giveUp(id) {
+        const now = Date.now();
+        for (const [each, until] of this.#givenUp)
+            if (until < now)
+                this.#givenUp.delete(each);
+        this.#givenUp.set(id, now + GIVEN_UP_TIME);
+    }
+    /**
+     * A node went down: the legs of the sessions of this node on it are gone, the legs of its sessions here are closed
+     * @param node
+     */
+    #nodeDown(node) {
+        for (const leg of [...this.#clusterLegs.values()])
+            if (leg.node === node)
+                leg.end();
+        for (const { leg, node: owner } of [...this.#servedLegs.values()])
+            if (owner === node)
+                leg.close();
+    }
+    /**
+     * Take a member in a room of this server
+     * @param room
+     * @param peerId
+     * @param kind
+     */
+    async #serveLocal(room, peerId, kind) {
+        const count = this.#load().members;
+        if (kind !== 'viewer' && this.maxMembers && count >= this.maxMembers && !this.#rooms.get(room)?.members.includes(peerId)) {
+            throw new SignalingLimitException('The media server has {count} members already', { count: count });
+        }
+        await this.#serve(room);
+    }
+    /**
+     * The members and the viewers of the server
+     */
+    #load() {
+        let members = 0;
+        let viewers = 0;
+        for (const room of this.#rooms.values()) {
+            members += room.members.length;
+            viewers += room.viewers;
+        }
+        return { members: members, viewers: viewers, maxMembers: this.maxMembers };
+    }
+    /**
+     * Tell the other nodes the load of the server
+     */
+    #announce() {
+        this.#clusterObject?.announce(MEDIA_SERVER_SERVICE, this.#load());
+    }
+    /**
+     * Answer a request of another node for a member
+     * @param assign Gives the member a media server.
+     */
+    async #reply(assign) {
+        try {
+            return { sfu: await assign() ?? null };
+        }
+        catch (error) {
+            if (error instanceof SignalingLimitException)
+                return { full: true };
+            throw error;
+        }
+    }
+    /**
+     * Join a room; one being left is joined again once it is left
+     * @param room
+     */
+    async #serve(room) {
+        await this.#leaving.get(room);
+        let served = this.#rooms.get(room);
+        if (!served || served.closed) {
+            served = this.#workers ? this.#workers.room(room) : new SFURoom(this.#host(), room);
+            this.#rooms.set(room, served);
+        }
+        try {
+            await served.ready;
+        }
+        catch (error) {
+            if (this.#rooms.get(room) === served)
+                this.#rooms.delete(room);
+            throw error;
+        }
+    }
+    /**
+     * Start the worker threads, each with its part of the ports
+     */
+    async #startWorkers() {
+        const ranges = Array.from({ length: this.workers }, (_, index) => {
+            if (!this.icePortRange)
+                return undefined;
+            const [first, last] = this.icePortRange;
+            const size = last - first + 1;
+            if (size < this.workers)
+                throw new RangeError(`The ICE port range has ${size} ports, fewer than the ${this.workers} worker threads`);
+            return [first + Math.floor(index * size / this.workers), first + Math.floor((index + 1) * size / this.workers) - 1];
+        });
+        const sfu = this;
+        this.#workers = new SFUWorkers({
+            id: this.#id,
+            get signaling() {
+                return sfu.#signalingObject;
+            },
+            select: this.select ? (subscriber, track) => this.#selects(subscriber, track) : undefined,
+            emit: (event, ...args) => this.emit(event, ...args),
+            emptied: (room) => this.#leave(room),
+            lost: (room) => this.#lost(room),
+            sourced: (viewerId, source) => this.#sourced(viewerId, source),
+            ...this.workerResourceLimits ? { resourceLimits: this.workerResourceLimits } : {}
+        }, ranges.map((range, thread) => ({
+            thread: thread,
+            connection: {
+                headerExtensions: true,
+                ...this.codecs ? { codecs: this.codecs } : {},
+                ...range ? { icePortRange: range } : {},
+                ...this.iceAdditionalHostAddresses ? { iceAdditionalHostAddresses: this.iceAdditionalHostAddresses } : {}
+            },
+            select: !!this.select
+        })));
+        try {
+            await this.#workers.ready;
+        }
+        catch (error) {
+            await this.#workers.stop();
+            this.#workers = undefined;
+            throw error;
+        }
+        sfuWorkers.set(this, this.#workers);
+    }
+    /**
+     * Whether a member receives a track: the answer of select, no when it throws
+     * @param subscriber
+     * @param track
+     */
+    #selects(subscriber, track) {
+        if (!this.select)
+            return true;
+        try {
+            return this.select(subscriber, track);
+        }
+        catch (error) {
+            log('select threw for %s and the track %s of %s, which it does not receive: %s', subscriber.peerId, track.id, track.peerId, error);
+            return false;
+        }
+    }
+    /**
+     * What the rooms need of the server
+     * @protected
+     */
+    #host() {
+        const sfu = this;
+        return {
+            id: this.#id,
+            get signaling() {
+                return sfu.#signalingObject;
+            },
+            connect: () => this.getObject(PeerConnection, {
+                headerExtensions: true,
+                ...this.codecs ? { codecs: this.codecs } : {},
+                ...this.icePortRange ? { icePortRange: this.icePortRange } : {},
+                ...this.iceAdditionalHostAddresses ? { iceAdditionalHostAddresses: this.iceAdditionalHostAddresses } : {}
+            }),
+            select: (subscriber, track) => this.#selects(subscriber, track),
+            emit: (event, ...args) => this.emit(event, ...args),
+            emptied: (room) => this.#leave(room),
+            sourced: (viewerId, source) => this.#sourced(viewerId, source)
+        };
+    }
+    /**
+     * The worker thread of a room stopped: the server and the streams of WHIP leave the room, and the server joins it
+     * again (in another thread) when it has members, which connect to it again
+     * @param room
+     */
+    #lost(room) {
+        if (this.#rooms.get(room.name) === room)
+            this.#rooms.delete(room.name);
+        const left = [this.#id, ...room.members.filter((id) => id.startsWith('whip:'))];
+        const leaving = Promise.all(left.map((id) => this.#signalingObject.leave(id, room.name).catch(() => undefined))).then(() => {
+            if (this.#leaving.get(room.name) === leaving)
+                this.#leaving.delete(room.name);
+        });
+        this.#leaving.set(room.name, leaving);
+        leaving.then(() => {
+            const members = this.#signalingObject.rooms()[room.name] ?? [];
+            return members.some((id) => !id.startsWith('sfu:') && !id.startsWith('whip:')) ? this.#serve(room.name) : undefined;
+        }).catch(() => undefined);
+    }
+    /**
+     * Leave a room without members
+     * @param room
+     */
+    #leave(room) {
+        if (this.#rooms.get(room.name) !== room)
+            return;
+        this.#rooms.delete(room.name);
+        const leaving = room.close().finally(() => {
+            if (this.#leaving.get(room.name) === leaving)
+                this.#leaving.delete(room.name);
+        });
+        this.#leaving.set(room.name, leaving);
+    }
+};
+__decorate([
+    Configurable(DTO.String().optional().default('signaling')),
+    __metadata("design:type", String)
+], SFU.prototype, "signaling", void 0);
+__decorate([
+    Configurable(DTO.String().optional()),
+    __metadata("design:type", String)
+], SFU.prototype, "cluster", void 0);
+__decorate([
+    Configurable(DTO.Function().optional()),
+    __metadata("design:type", Function)
+], SFU.prototype, "selectSFU", void 0);
+__decorate([
+    Configurable(DTO.Function().optional()),
+    __metadata("design:type", Function)
+], SFU.prototype, "serves", void 0);
+__decorate([
+    Configurable(DTO.Array().items(DTO.String().valid(...SUPPORTED_CODECS).insensitive()).optional()),
+    __metadata("design:type", Array)
+], SFU.prototype, "codecs", void 0);
+__decorate([
+    Configurable(DTO.Array().items(DTO.Number().port()).length(2).optional()),
+    __metadata("design:type", Array)
+], SFU.prototype, "icePortRange", void 0);
+__decorate([
+    Configurable(DTO.Array().items(DTO.String()).optional()),
+    __metadata("design:type", Array)
+], SFU.prototype, "iceAdditionalHostAddresses", void 0);
+__decorate([
+    Configurable(DTO.Number().integer().min(0).optional().default(0)),
+    __metadata("design:type", Number)
+], SFU.prototype, "maxMembers", void 0);
+__decorate([
+    Configurable(DTO.Function().optional()),
+    __metadata("design:type", Function)
+], SFU.prototype, "select", void 0);
+__decorate([
+    Configurable(DTO.Number().integer().min(0).optional().default(0)),
+    __metadata("design:type", Number)
+], SFU.prototype, "workers", void 0);
+__decorate([
+    Configurable(DTO.Object({
+        maxYoungGenerationSizeMb: DTO.Number().positive().optional(),
+        maxOldGenerationSizeMb: DTO.Number().positive().optional(),
+        codeRangeSizeMb: DTO.Number().positive().optional(),
+        stackSizeMb: DTO.Number().positive().optional()
+    }).optional()),
+    __metadata("design:type", Object)
+], SFU.prototype, "workerResourceLimits", void 0);
+SFU = __decorate([
+    Singleton()
+], SFU);
+export { SFU };
+/**
+ * Build the options of a {@link SFU} component, for the `components` of an application.
+ * @param options The signaling, the rooms served, the codecs, the ports, the limits, the selection of the tracks (all
+ * optional).
+ * @returns The component options.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildSFUOptions, buildSignalingOptions} from '@lakutata/webrtc'
+ *
+ * Application.run(() => ({
+ *     id: 'meet.app',
+ *     name: 'Meet',
+ *     components: {
+ *         signaling: buildSignalingOptions(),
+ *         //The members whose metadata says they only listen receive the audio only
+ *         sfu: buildSFUOptions({select: (subscriber, track): boolean => track.kind === 'audio' || (subscriber.metadata as {listener?: boolean})?.listener !== true})
+ *     },
+ *     bootstrap: ['sfu']
+ * }))
+ * ```
+ */
+export function buildSFUOptions(options = {}) {
+    return { class: SFU, ...options };
+}