@voltkit-rtc/client 0.2.0

package/dist/esm/index.js

@@ -0,0 +1,785 @@
+/**
+ * Thin client SDK over the orchestrator's signaling protocol.
+ *
+ * The point of shipping this is that consuming projects never touch
+ * mediasoup-client directly -- otherwise every project re-implements transport
+ * setup, consumer resume ordering and reconnection, each slightly wrong.
+ */
+import { Device } from 'mediasoup-client';
+import { MusicSource } from './music.js';
+export { BroadcastPublisher, WhipError, whipEnd, whipOffer } from './broadcast.js';
+export { AudioMixer, MusicSource } from './music.js';
+export { ChatClient, ChatRpcError } from './chat.js';
+const defaultSource = (kind) => (kind === 'audio' ? 'mic' : 'camera');
+/** An error returned by the server, carrying its machine-readable code. */
+export class RpcError extends Error {
+    code;
+    constructor(code, message) {
+        super(`${code}: ${message}`);
+        this.code = code;
+        this.name = 'RpcError';
+    }
+}
+/**
+ * Failures that reconnecting cannot fix. A room that has ended is not coming
+ * back, and a token that is wrong will be wrong next time too -- retrying
+ * these just floods the log and burns the attempt budget that a genuine
+ * network blip needs.
+ */
+const TERMINAL_JOIN_ERRORS = new Set([
+    'no-room',
+    'room-ended',
+    'wrong-tenant',
+    'bad-token',
+    'no-token',
+    'forbidden',
+    // The account cannot use the service until it is topped up or restored.
+    'quota-exhausted',
+    'daily-limit-reached',
+    'monthly-limit-reached',
+    'tenant-suspended',
+]);
+const RPC_TIMEOUT_MS = 15_000;
+const MAX_RECONNECT_ATTEMPTS = 8;
+/** Server close code meaning "another socket took over this identity". */
+const CLOSE_REPLACED = 4001;
+/** The server ended the session on purpose and said why first: do not reconnect. */
+const CLOSE_ENDED = 4003;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export class StreamClient {
+    wsUrl;
+    ws = null;
+    device = null;
+    sendTransport = null;
+    recvTransport = null;
+    // In-flight creations. Two `newProducer` events arriving back to back (a peer
+    // publishing audio and video) both call ensureRecvTransport before either
+    // await resolves, so a plain null check creates two transports -- and the
+    // server only remembers the last one, rejecting consumes on the first.
+    sendTransportPending = null;
+    recvTransportPending = null;
+    pending = new Map();
+    listeners = new Map();
+    consumers = new Map();
+    producers = new Map();
+    nextId = 1;
+    token;
+    joinResult = null;
+    localStream = null;
+    // A reconnect tears down every transport and producer. Without remembering
+    // that this client was publishing -- and what it was publishing with -- a
+    // broadcaster that reconnects rejoins silently, which is worse than being
+    // disconnected: the room looks healthy and shows nothing.
+    wasPublishing = false;
+    publishConstraints = null;
+    /** In-app music being published, kept across reconnects so it can be published again. */
+    music = null;
+    musicProducerId = null;
+    /** What each remote producer carries, so a pause can say "music" rather than just "audio". */
+    remoteSources = new Map();
+    closedByUs = false;
+    reconnecting = false;
+    reconnectAttempt = 0;
+    constructor(wsUrl, token) {
+        this.wsUrl = wsUrl;
+        this.token = token;
+    }
+    on(event, fn) {
+        let set = this.listeners.get(event);
+        if (!set) {
+            set = new Set();
+            this.listeners.set(event, set);
+        }
+        set.add(fn);
+        return () => set.delete(fn);
+    }
+    emit(event, ...args) {
+        for (const fn of this.listeners.get(event) ?? []) {
+            try {
+                fn(...args);
+            }
+            catch (err) {
+                console.error(`listener for ${event} threw`, err);
+            }
+        }
+    }
+    // ------------------------------------------------------------- connection
+    async connect() {
+        await this.openSocket();
+        const result = (await this.rpc('join', { token: this.token }));
+        this.joinResult = result;
+        this.device = new Device();
+        await this.device.load({ routerRtpCapabilities: result.routerRtpCapabilities });
+        this.emit('joined', result);
+        // Subscribe to everything already publishing before we announce readiness.
+        for (const p of result.producers) {
+            await this.consume(p).catch((err) => this.emit('error', err));
+        }
+        // Restore our own broadcast. This is what makes an origin failover
+        // survivable for the host: it reconnects onto the new origin and the
+        // stream comes back on its own.
+        if (this.wasPublishing && (result.role === 'host' || result.role === 'cohost')) {
+            await this.republish().catch((err) => this.emit('error', err));
+        }
+        return result;
+    }
+    openSocket() {
+        // Abandon any previous socket first. Its close handler checks identity
+        // against `this.ws`, so once it is detached it can no longer trigger a
+        // reconnect -- which is what let multiple reconnect chains pile up.
+        this.detachSocket();
+        return new Promise((resolve, reject) => {
+            const url = new URL(this.wsUrl);
+            url.searchParams.set('token', this.token);
+            const ws = new WebSocket(url.toString());
+            this.ws = ws;
+            const onOpen = () => {
+                this.reconnectAttempt = 0;
+                this.emit('connected');
+                resolve();
+            };
+            const onError = () => reject(new Error('websocket failed to open'));
+            ws.addEventListener('open', onOpen, { once: true });
+            ws.addEventListener('error', onError, { once: true });
+            ws.addEventListener('message', (ev) => {
+                if (this.ws === ws)
+                    this.onMessage(ev.data);
+            });
+            ws.addEventListener('close', (ev) => {
+                ws.removeEventListener('error', onError);
+                // Only the socket we currently consider ours may drive reconnection.
+                if (this.ws !== ws)
+                    return;
+                this.ws = null;
+                this.failAllPending(new Error(`socket closed (${ev.code})`));
+                this.emit('disconnected', ev.reason || String(ev.code));
+                if (this.closedByUs)
+                    return;
+                if (ev.code === CLOSE_REPLACED) {
+                    // Another session for this identity is live. Reconnecting would
+                    // displace it, and it would displace us right back, forever.
+                    this.emit('error', new Error('this identity connected from somewhere else'));
+                    this.closedByUs = true;
+                    this.emit('closed', 'replaced');
+                    return;
+                }
+                if (ev.code === CLOSE_ENDED) {
+                    // Normally roomClosed has already ended the session; this covers a
+                    // close that arrived without it.
+                    this.closedByUs = true;
+                    this.emit('closed', 'room-closed');
+                    return;
+                }
+                void this.scheduleReconnect();
+            });
+        });
+    }
+    detachSocket() {
+        const ws = this.ws;
+        this.ws = null;
+        if (ws && ws.readyState <= WebSocket.OPEN) {
+            try {
+                ws.close(1000, 'superseded');
+            }
+            catch {
+                /* already closing */
+            }
+        }
+    }
+    /**
+     * Reconnection is mandatory, not optional: nodes get drained, relays die and
+     * promotions move you to a different node. Always re-ask the orchestrator
+     * where to connect -- never assume the same node.
+     */
+    async scheduleReconnect() {
+        // Single-flight. The previous version recursed from its own catch block
+        // while the failed socket's close handler started a second chain, so each
+        // failure doubled the number of chains until the server was being hammered.
+        if (this.reconnecting || this.closedByUs)
+            return;
+        this.reconnecting = true;
+        try {
+            while (!this.closedByUs) {
+                this.reconnectAttempt += 1;
+                if (this.reconnectAttempt > MAX_RECONNECT_ATTEMPTS) {
+                    this.emit('error', new Error(`gave up after ${MAX_RECONNECT_ATTEMPTS} reconnect attempts`));
+                    this.closedByUs = true;
+                    this.emit('closed', 'gave-up');
+                    return;
+                }
+                const backoff = Math.min(500 * 2 ** (this.reconnectAttempt - 1), 15_000);
+                await sleep(backoff + Math.random() * 400);
+                if (this.closedByUs)
+                    return;
+                try {
+                    this.teardownMedia();
+                    await this.connect();
+                    return; // connect() resets the attempt counter once the socket opens
+                }
+                catch (err) {
+                    this.emit('error', err);
+                    // Stop on failures a retry cannot resolve. Hammering a room that has
+                    // ended produces one error per attempt forever and drowns out
+                    // whatever actually went wrong.
+                    if (err instanceof RpcError && TERMINAL_JOIN_ERRORS.has(err.code)) {
+                        this.closedByUs = true;
+                        this.emit('closed', 'gave-up');
+                        return;
+                    }
+                }
+            }
+        }
+        finally {
+            this.reconnecting = false;
+        }
+    }
+    close() {
+        // Only an app closing a live session is 'left'; kicked, room-closed and the
+        // others have already reported themselves and set closedByUs.
+        const wasOpen = !this.closedByUs;
+        this.closedByUs = true;
+        this.wasPublishing = false;
+        this.teardownMedia();
+        // Producers no longer stop their tracks, so releasing the camera and
+        // microphone is ours to do -- otherwise the device light stays on.
+        this.localStream?.getTracks().forEach((t) => t.stop());
+        this.localStream = null;
+        const ws = this.ws;
+        this.ws = null;
+        ws?.close(1000, 'client closed');
+        if (wasOpen)
+            this.emit('closed', 'left');
+    }
+    teardownMedia() {
+        for (const c of this.consumers.values())
+            c.close();
+        this.consumers.clear();
+        for (const p of this.producers.values())
+            p.close();
+        this.producers.clear();
+        this.musicProducerId = null;
+        this.sendTransport?.close();
+        this.recvTransport?.close();
+        this.sendTransport = null;
+        this.recvTransport = null;
+        this.sendTransportPending = null;
+        this.recvTransportPending = null;
+        this.device = null;
+    }
+    /** Everything currently known about the room, for rendering. */
+    get info() {
+        return this.joinResult;
+    }
+    // -------------------------------------------------------------------- rpc
+    rpc(method, params = {}) {
+        return new Promise((resolve, reject) => {
+            if (this.ws?.readyState !== WebSocket.OPEN) {
+                reject(new Error('socket is not open'));
+                return;
+            }
+            const id = this.nextId++;
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`${method} timed out`));
+            }, RPC_TIMEOUT_MS);
+            this.pending.set(id, { resolve, reject, timer });
+            this.ws.send(JSON.stringify({ id, method, params }));
+        });
+    }
+    failAllPending(err) {
+        for (const p of this.pending.values()) {
+            clearTimeout(p.timer);
+            p.reject(err);
+        }
+        this.pending.clear();
+    }
+    onMessage(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (typeof msg.id === 'number') {
+            const p = this.pending.get(msg.id);
+            if (!p)
+                return;
+            clearTimeout(p.timer);
+            this.pending.delete(msg.id);
+            if (msg.ok)
+                p.resolve(msg.result);
+            else {
+                const e = msg.error;
+                p.reject(new RpcError(e?.code ?? 'error', e?.message ?? 'unknown'));
+            }
+            return;
+        }
+        if (typeof msg.event === 'string')
+            void this.onEvent(msg.event, msg.data);
+    }
+    async onEvent(event, data) {
+        const d = (data ?? {});
+        switch (event) {
+            case 'newProducer':
+                await this.consume(data).catch((err) => this.emit('error', err));
+                break;
+            case 'producerClosed': {
+                const { producerId, identity } = data;
+                const consumer = this.consumers.get(producerId);
+                if (!consumer)
+                    break; // never consumed it, or already cleaned up
+                consumer.close();
+                this.consumers.delete(producerId);
+                this.remoteSources.delete(producerId);
+                this.emit('trackEnded', { producerId, identity });
+                break;
+            }
+            case 'producerPaused': {
+                const p = data;
+                this.emit('trackMuted', {
+                    identity: p.identity,
+                    kind: p.kind,
+                    source: this.remoteSources.get(p.producerId) ?? defaultSource(p.kind),
+                    producerId: p.producerId,
+                    paused: p.paused,
+                });
+                break;
+            }
+            case 'participantJoined':
+                this.emit('participantJoined', data);
+                break;
+            case 'participantLeft':
+                this.emit('participantLeft', data);
+                break;
+            case 'roleChanged': {
+                const e = data;
+                this.emit('roleChanged', e);
+                // Demoted: the server has already closed our producers. Release the
+                // camera and microphone too, instead of capturing for nobody.
+                const canPublish = e.role === 'host' || e.role === 'cohost';
+                if (e.identity === this.joinResult?.identity && !canPublish && this.producers.size > 0) {
+                    void this.unpublish().catch(() => undefined);
+                }
+                break;
+            }
+            case 'handRaised':
+            case 'handLowered':
+                this.emit('handRaised', data);
+                break;
+            case 'forceMuted': {
+                // The server has already paused that kind (an audio mute includes
+                // in-app music: it travels as audio). Reflect it locally; a release
+                // changes nothing here -- switching back on is the user's choice.
+                const e = data;
+                if (e.paused) {
+                    for (const p of this.producers.values()) {
+                        if (!e.kind || p.kind === e.kind)
+                            p.pause();
+                    }
+                    this.emitLocalMedia();
+                }
+                this.emit('forceMuted', e);
+                break;
+            }
+            case 'tokenRefreshed': {
+                // A room outlives its join token many times over. The server hands us a
+                // fresh one periodically so a reconnect at any point still works --
+                // without this, any disconnect after the token's lifetime is terminal.
+                const e = data;
+                if (e.token)
+                    this.token = e.token;
+                break;
+            }
+            case 'mustReconnect': {
+                const e = data;
+                // A promotion hands us a fresh token carrying the new role.
+                if (e.token)
+                    this.token = e.token;
+                this.emit('mustReconnect', e);
+                if (e.retry) {
+                    this.teardownMedia();
+                    this.ws?.close(1000, 'reassigned');
+                }
+                break;
+            }
+            case 'streamInterrupted':
+                // Our node survived a failover; the origin did not. Stay connected --
+                // pictures come back when the host republishes and the pipe rebuilds.
+                this.emit('streamInterrupted', d);
+                break;
+            case 'usageLimit':
+                this.emit('usageLimit', d);
+                break;
+            case 'roomClosed':
+                this.closedByUs = true;
+                this.emit('roomClosed', d);
+                this.emit('closed', 'room-closed');
+                this.close();
+                break;
+            case 'kicked':
+                this.closedByUs = true;
+                this.emit('kicked', d);
+                this.emit('closed', 'kicked');
+                this.close();
+                break;
+            case 'message':
+                this.emit('message', data);
+                break;
+            case 'messageDeleted':
+                this.emit('messageDeleted', data);
+                break;
+            case 'chatMuted':
+                this.emit('chatMuted', data);
+                break;
+            case 'typing':
+                this.emit('typing', data);
+                break;
+            default:
+                break;
+        }
+    }
+    // ------------------------------------------------------------------ media
+    ensureSendTransport() {
+        if (this.sendTransport)
+            return Promise.resolve(this.sendTransport);
+        if (this.sendTransportPending)
+            return this.sendTransportPending;
+        this.sendTransportPending = this.createSendTransport().finally(() => {
+            this.sendTransportPending = null;
+        });
+        return this.sendTransportPending;
+    }
+    async createSendTransport() {
+        if (!this.device)
+            throw new Error('not connected');
+        const params = (await this.rpc('createTransport', { direction: 'send' }));
+        const transport = this.device.createSendTransport({
+            ...params,
+            iceServers: this.joinResult?.iceServers,
+        });
+        transport.on('connect', ({ dtlsParameters }, ok, fail) => {
+            this.rpc('connectTransport', { transportId: transport.id, dtlsParameters })
+                .then(() => ok())
+                .catch(fail);
+        });
+        transport.on('produce', ({ kind, rtpParameters, appData }, ok, fail) => {
+            this.rpc('produce', { transportId: transport.id, kind, rtpParameters, appData, source: appData.source })
+                .then((res) => ok({ id: res.producerId }))
+                .catch(fail);
+        });
+        this.sendTransport = transport;
+        return transport;
+    }
+    ensureRecvTransport() {
+        if (this.recvTransport)
+            return Promise.resolve(this.recvTransport);
+        if (this.recvTransportPending)
+            return this.recvTransportPending;
+        this.recvTransportPending = this.createRecvTransport().finally(() => {
+            this.recvTransportPending = null;
+        });
+        return this.recvTransportPending;
+    }
+    async createRecvTransport() {
+        if (!this.device)
+            throw new Error('not connected');
+        const params = (await this.rpc('createTransport', { direction: 'recv' }));
+        const transport = this.device.createRecvTransport({
+            ...params,
+            iceServers: this.joinResult?.iceServers,
+        });
+        transport.on('connect', ({ dtlsParameters }, ok, fail) => {
+            this.rpc('connectTransport', { transportId: transport.id, dtlsParameters })
+                .then(() => ok())
+                .catch(fail);
+        });
+        this.recvTransport = transport;
+        return transport;
+    }
+    /**
+     * Publish local camera + mic. Only host/cohost may; others get a server error.
+     *
+     * Pass the constraints used to obtain the stream and they will be reused to
+     * reacquire the devices if a reconnect finds the tracks have ended.
+     */
+    async publish(stream, constraints) {
+        const transport = await this.ensureSendTransport();
+        this.localStream = stream;
+        this.wasPublishing = true;
+        if (constraints)
+            this.publishConstraints = constraints;
+        const audio = stream.getAudioTracks()[0];
+        if (audio) {
+            const producer = await transport.produce({
+                track: audio,
+                // Keep the track alive when the producer closes: a reconnect closes
+                // every producer, and a stopped track cannot be republished.
+                stopTracks: false,
+                codecOptions: { opusStereo: true, opusDtx: true, opusFec: true },
+                appData: { source: 'mic' },
+            });
+            this.producers.set(producer.id, producer);
+        }
+        const video = stream.getVideoTracks()[0];
+        if (video) {
+            // Simulcast from day one: retrofitting it later is genuinely annoying,
+            // and it is what lets one node serve far more viewers.
+            const producer = await transport.produce({
+                track: video,
+                stopTracks: false,
+                encodings: [
+                    { rid: 'q', scaleResolutionDownBy: 4, maxBitrate: 200_000, scalabilityMode: 'L1T3' },
+                    { rid: 'h', scaleResolutionDownBy: 2, maxBitrate: 600_000, scalabilityMode: 'L1T3' },
+                    { rid: 'f', scaleResolutionDownBy: 1, maxBitrate: 1_800_000, scalabilityMode: 'L1T3' },
+                ],
+                codecOptions: { videoGoogleStartBitrate: 1000 },
+                appData: { source: 'camera' },
+            });
+            this.producers.set(producer.id, producer);
+        }
+    }
+    /**
+     * Re-establish this client's broadcast after a reconnect.
+     *
+     * Reuses the existing tracks when they are still live -- the common case, and
+     * it avoids a second camera permission prompt. Only reacquires the devices
+     * when the tracks have genuinely ended.
+     */
+    async republish() {
+        // Music is not a device and cannot be "gone": publish it again whatever
+        // happens to the camera and microphone below.
+        if (this.music)
+            await this.produceMusic(this.music).catch((err) => this.emit('error', err));
+        let stream = this.localStream;
+        if (!stream && !this.publishConstraints)
+            return; // music was all that was being published
+        const live = stream?.getTracks().some((t) => t.readyState === 'live') ?? false;
+        if (!live) {
+            if (!this.publishConstraints) {
+                this.emit('error', new Error('cannot restore the broadcast: the devices are gone'));
+                return;
+            }
+            stream = await navigator.mediaDevices.getUserMedia(this.publishConstraints);
+            this.localStream = stream;
+            this.emit('localStreamChanged', stream);
+        }
+        if (!stream)
+            return;
+        await this.publish(stream);
+    }
+    // ------------------------------------------------------------------ music
+    /**
+     * Publish music playing inside the page, as its own track.
+     *
+     * The audience gets it clean -- it never passes through the microphone --
+     * and it has its own switch: `setMusicEnabled(false)` silences the music and
+     * leaves the host talking, `setMicEnabled(false)` does the opposite.
+     *
+     * Call it from a click. Browsers will not start audio processing for a page
+     * the user has not interacted with.
+     */
+    async publishMusic(input, options) {
+        if (this.music)
+            await this.stopMusic();
+        const music = new MusicSource(input, options);
+        try {
+            await this.produceMusic(music);
+        }
+        catch (err) {
+            music.close();
+            throw err;
+        }
+        this.music = music;
+        this.wasPublishing = true;
+        this.emitLocalMedia();
+    }
+    async produceMusic(music) {
+        const transport = await this.ensureSendTransport();
+        const producer = await transport.produce({
+            track: music.track,
+            stopTracks: false,
+            // Music, not speech. Stereo, no silence suppression (it would chop the
+            // quiet parts of a song), and enough bitrate that it sounds like music.
+            codecOptions: { opusStereo: true, opusDtx: false, opusFec: true, opusMaxAverageBitrate: 128_000 },
+            appData: { source: 'music' },
+        });
+        this.producers.set(producer.id, producer);
+        this.musicProducerId = producer.id;
+    }
+    /** True while music is published, whether or not it is switched on. */
+    get musicPublishing() {
+        return this.music !== null;
+    }
+    get musicEnabled() {
+        const producer = this.musicProducerId ? this.producers.get(this.musicProducerId) : undefined;
+        return producer ? !producer.paused : false;
+    }
+    /** 0 to 1, for the audience. The host's own listening level is the element's. */
+    setMusicVolume(volume) {
+        this.music?.setVolume(volume);
+    }
+    /** Switch the music off or on for the audience. The microphone is untouched. */
+    async setMusicEnabled(enabled) {
+        const producer = this.musicProducerId ? this.producers.get(this.musicProducerId) : undefined;
+        if (!producer)
+            return;
+        if (enabled)
+            producer.resume();
+        else
+            producer.pause();
+        await this.rpc('pauseProducer', { producerId: producer.id, paused: !enabled });
+        this.emitLocalMedia();
+    }
+    /** Stop publishing music. The element or stream it came from is left as it was. */
+    async stopMusic() {
+        const id = this.musicProducerId;
+        this.musicProducerId = null;
+        this.music?.close();
+        this.music = null;
+        if (id) {
+            this.producers.get(id)?.close();
+            this.producers.delete(id);
+            await this.rpc('closeProducer', { producerId: id }).catch(() => undefined);
+        }
+        this.emitLocalMedia();
+    }
+    emitLocalMedia() {
+        this.emit('localMediaChanged', {
+            micEnabled: this.micEnabled,
+            camEnabled: this.camEnabled,
+            musicEnabled: this.musicEnabled,
+        });
+    }
+    async consume(remote) {
+        if (!this.device)
+            throw new Error('not connected');
+        if (this.consumers.has(remote.producerId))
+            return;
+        // Your own camera is already local; pulling it back off the SFU wastes a
+        // consumer and shows you a delayed copy of yourself.
+        if (remote.identity === this.joinResult?.identity)
+            return;
+        const transport = await this.ensureRecvTransport();
+        const params = (await this.rpc('consume', {
+            transportId: transport.id,
+            producerId: remote.producerId,
+            rtpCapabilities: this.device.rtpCapabilities,
+        }));
+        const consumer = await transport.consume(params);
+        this.consumers.set(remote.producerId, consumer);
+        // The server created it paused. Resume only now that our end exists,
+        // otherwise the first frames arrive before there is anything to decode them.
+        await this.rpc('resumeConsumer', { consumerId: consumer.id });
+        const kind = consumer.kind;
+        const source = remote.source ?? defaultSource(kind);
+        this.remoteSources.set(remote.producerId, source);
+        this.emit('track', {
+            identity: remote.identity,
+            kind,
+            track: consumer.track,
+            producerId: remote.producerId,
+            source,
+        });
+    }
+    // ------------------------------------------------------------- moderation
+    // ------------------------------------------------------------ local media
+    /** True once this client has at least one live producer. */
+    get publishing() {
+        return this.producers.size > 0;
+    }
+    get micEnabled() {
+        return this.trackEnabled('audio');
+    }
+    get camEnabled() {
+        return this.trackEnabled('video');
+    }
+    trackEnabled(kind) {
+        for (const p of this.producers.values()) {
+            if (p.kind === kind && p.id !== this.musicProducerId)
+                return !p.paused;
+        }
+        return false;
+    }
+    /**
+     * Pausing the producer stops RTP at the source, so it costs nothing on the
+     * SFU and every viewer is told. Muting only the local track would keep
+     * sending silence and leave viewers showing you as unmuted.
+     */
+    async setMicEnabled(enabled) {
+        await this.setKindEnabled('audio', enabled);
+    }
+    async setCamEnabled(enabled) {
+        await this.setKindEnabled('video', enabled);
+    }
+    async setKindEnabled(kind, enabled) {
+        for (const producer of this.producers.values()) {
+            // The music has its own switch. Muting the microphone must not stop the song.
+            if (producer.kind !== kind || producer.id === this.musicProducerId)
+                continue;
+            if (enabled)
+                producer.resume();
+            else
+                producer.pause();
+            await this.rpc('pauseProducer', { producerId: producer.id, paused: !enabled });
+        }
+        this.emitLocalMedia();
+    }
+    /** Stop publishing entirely and release the local devices. */
+    async unpublish() {
+        const ids = [...this.producers.keys()];
+        for (const producer of this.producers.values())
+            producer.close();
+        this.producers.clear();
+        for (const id of ids) {
+            await this.rpc('closeProducer', { producerId: id }).catch(() => undefined);
+        }
+        this.localStream?.getTracks().forEach((t) => t.stop());
+        this.localStream = null;
+        this.music?.close();
+        this.music = null;
+        this.musicProducerId = null;
+        this.wasPublishing = false;
+        this.emit('localStreamChanged', null);
+        this.emit('localMediaChanged', { micEnabled: false, camEnabled: false, musicEnabled: false });
+    }
+    get local() {
+        return this.localStream;
+    }
+    // ------------------------------------------------------------- moderation
+    raiseHand() { return this.rpc('raiseHand'); }
+    lowerHand() { return this.rpc('lowerHand'); }
+    muteParticipant(identity) { return this.rpc('requestMute', { identity }); }
+    /**
+     * Moderating roles: switch someone's microphone (`audio`), camera (`video`)
+     * or both (no kind) off at the server, where they cannot switch it back on.
+     * `paused: false` releases it; they then turn it on themselves.
+     */
+    forceMute(identity, kind, paused = true) {
+        return this.rpc('forceMute', { identity, kind: kind ?? '', paused });
+    }
+    promote(identity, role) { return this.rpc('promote', { identity, role }); }
+    kick(identity, reason) { return this.rpc('kick', { identity, reason }); }
+    endRoom() { return this.rpc('endRoom'); }
+    getRoomState() { return this.rpc('getRoomState'); }
+    // ------------------------------------------------------------------- chat
+    //
+    // The room's chat rides this same socket. Someone on a chat-only socket
+    // (ChatClient) for the same channel is in the same conversation.
+    sendMessage(text, opts = {}) {
+        return this.rpc('sendMessage', { text, ...opts });
+    }
+    /** Older messages, oldest first. Pass the oldest id you hold as `before`. */
+    async getMessages(opts = {}) {
+        const res = (await this.rpc('getMessages', opts));
+        return res.messages;
+    }
+    /** Your own message, or anyone's if you are a moderator. */
+    deleteMessage(messageId) { return this.rpc('deleteMessage', { messageId }); }
+    /** Moderators only. A mute outlasts the muted socket reconnecting. */
+    muteChat(identity, muted = true) { return this.rpc('muteChat', { identity, muted }); }
+    /** Advisory, and throttled by the server; safe to call on every keystroke. */
+    setTyping(typing) { return this.rpc('setTyping', { typing }); }
+    getChatState() { return this.rpc('getChatState'); }
+}
+//# sourceMappingURL=index.js.map