@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/whep/WHEP.js

@@ -0,0 +1,426 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WHEP = void 0;
+exports.buildWHEPOptions = buildWHEPOptions;
+const node_crypto_1 = require("node:crypto");
+const core_1 = require("@lakutata/core");
+const di_1 = require("@lakutata/core/decorator/di");
+const ClusterTURN_js_1 = require("../cluster/ClusterTURN.js");
+const Endpoints_js_1 = require("../peer/Endpoints.js");
+const SFUAccess_js_1 = require("../sfu/SFUAccess.js");
+const WHEPDeniedException_js_1 = require("../exceptions/WHEPDeniedException.js");
+const WHEPLimitException_js_1 = require("../exceptions/WHEPLimitException.js");
+const WHEPOfferException_js_1 = require("../exceptions/WHEPOfferException.js");
+const WHEPSessionNotFoundException_js_1 = require("../exceptions/WHEPSessionNotFoundException.js");
+const log_js_1 = require("../lib/common/log.js");
+const log = (0, log_js_1.debug)('webrtc/whep');
+/**
+ * The topic of the requests ending a session on the node holding it
+ */
+const STOP_TOPIC = 'webrtc.whep.stop';
+/**
+ * How long a DELETE waits for the nodes of the cluster, in milliseconds
+ */
+const STOP_TIMEOUT = 2000;
+/**
+ * The topic of the requests applying a PATCH of a session on the node holding it
+ */
+const PATCH_TOPIC = 'webrtc.whep.patch';
+/**
+ * How long a PATCH waits for the nodes of the cluster (an ICE restart gathers candidates), in milliseconds
+ */
+const PATCH_TIMEOUT = 12000;
+/**
+ * The playback of WHEP: players (browsers, media players) play a stream with an HTTP POST of their offer, and receive
+ * the audio and the video of a member of a room of the media server ({@link SFU}): by default the stream published with
+ * WHIP into the room (the stream is the room unless `roomOf` says otherwise), else the first member publishing;
+ * `select` chooses another one. A viewer is not a member of the room: its connection goes to the server, which sends it
+ * the tracks of the member, from a key frame, and the ones of the next member when that one stops publishing. Its
+ * connection negotiates every codec it offers that the server has, so a stream published after it starts playing, with
+ * any of them, is sent too. The component emits `play` (the session) once it answers, and `stop` (the session) when it
+ * ends: the viewer deleted it, its connection failed or closed, or the application stopped.
+ *
+ * Register it as `whep` with {@link buildWHEPOptions} next to the media server, and add `WHEPController` to the
+ * controllers of the entrypoint, with an HTTP adapter reading the bodies of WHEP as text (its option
+ * `body: {text: ['application/sdp', 'application/trickle-ice-sdpfrag']}`). The answers carry all the candidates; a
+ * PATCH of a session gives it the candidates of its viewer (trickle ICE), or restarts ICE, as for WHIP.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints} from 'lakutata/com/entrypoint'
+ * import {expressHTTPEntrypoint} from 'lakutata/adapter/express'
+ * import {buildSFUOptions, buildSignalingOptions, buildWHEPOptions, buildWHIPOptions, WHEPController, WHIPController} from '@lakutata/webrtc'
+ *
+ * //OBS publishes to https://live.example.com/whip/concert, the browsers play https://live.example.com/whep/concert
+ * Application.run(() => ({
+ *     id: 'live.app',
+ *     name: 'Live',
+ *     components: {
+ *         signaling: buildSignalingOptions(),
+ *         sfu: buildSFUOptions({iceAdditionalHostAddresses: ['203.0.113.10'], icePortRange: [40000, 40999]}),
+ *         whip: buildWHIPOptions({sfu: 'sfu', authorize: ({token}): boolean => token === process.env.WHIP_TOKEN}),
+ *         whep: buildWHEPOptions({maxSessions: 500}),
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [WHIPController, WHEPController],
+ *             http: expressHTTPEntrypoint({port: 8080, body: {text: ['application/sdp', 'application/trickle-ice-sdpfrag']}})
+ *         })
+ *     },
+ *     bootstrap: ['sfu', 'entrypoint']
+ * }))
+ * ```
+ */
+let WHEP = class WHEP extends core_1.Component {
+    #sessions = new Map();
+    #legs = new Map();
+    //The entity tags of the ICE sessions of the sessions
+    #tags = new Map();
+    #clusterObject;
+    #unhandle;
+    /**
+     * Join the cluster: end the sessions of this node asked by the others.
+     * @protected
+     */
+    async init() {
+        if (!this.cluster)
+            return;
+        const cluster = await this.getObject(this.cluster);
+        this.#clusterObject = cluster;
+        const unhandle = [
+            cluster.handle(STOP_TOPIC, ({ id, stream }) => this.end(id, stream)),
+            cluster.handle(PATCH_TOPIC, async ({ id, fragment, stream, ifMatch }) => await this.#patchHere(id, fragment, stream, ifMatch) ?? null)
+        ];
+        this.#unhandle = () => unhandle.forEach((each) => each());
+    }
+    /**
+     * End the sessions.
+     * @protected
+     */
+    async destroy() {
+        this.#unhandle?.();
+        for (const id of [...this.#sessions.keys()])
+            this.end(id);
+    }
+    /**
+     * The sessions of this node.
+     */
+    get sessions() {
+        return [...this.#sessions.values()];
+    }
+    /**
+     * The origins the browsers may play from.
+     */
+    get allowedOrigin() {
+        return this.allowOrigin;
+    }
+    /**
+     * A session.
+     * @param id The id of the session.
+     * @returns The session, `undefined` when there is none of this id.
+     * @example
+     * ```typescript
+     * import type {WHEP, WHEPSession} from '@lakutata/webrtc'
+     *
+     * declare const whep: WHEP
+     * const session: WHEPSession | undefined = whep.session('0b7d…')
+     * ```
+     */
+    session(id) {
+        return this.#sessions.get(id);
+    }
+    /**
+     * Play a stream: answer the offer of its viewer, with all the candidates of the connection. `WHEPController` calls
+     * it for the POST requests.
+     * @param stream The stream.
+     * @param offer The SDP offer of the viewer.
+     * @param options The bearer token of the viewer, and the context of its request (for `authorize` and `roomOf`).
+     * @returns The session, and the answer.
+     * @throws {WHEPDeniedException} When `authorize` refuses the stream.
+     * @throws {WHEPLimitException} When there are `maxSessions` sessions already.
+     * @throws {WHEPOfferException} When the offer has no audio or video, the media server does not serve the room of
+     * the stream, or the connection refuses the offer.
+     * @example
+     * ```typescript
+     * import type {SignalingDescription, WHEP, WHEPSession} from '@lakutata/webrtc'
+     *
+     * declare const whep: WHEP
+     * declare const offer: SignalingDescription
+     * const {session, answer}: {session: WHEPSession, answer: SignalingDescription} = await whep.play('concert', offer)
+     * ```
+     */
+    async play(stream, offer, options = {}) {
+        const viewer = { stream: stream, token: options.token };
+        if (this.authorize && !(await this.authorize(viewer, options.context))) {
+            throw new WHEPDeniedException_js_1.WHEPDeniedException('The stream {stream} may not be played', { stream: stream });
+        }
+        if (this.maxSessions && this.#sessions.size >= this.maxSessions)
+            throw new WHEPLimitException_js_1.WHEPLimitException('There are {count} sessions already', { count: this.#sessions.size });
+        if (offer.type !== 'offer' || !/^m=(audio|video) /m.test(offer.sdp ?? ''))
+            throw new WHEPOfferException_js_1.WHEPOfferException('The offer has no audio and no video');
+        const room = this.roomOf ? await this.roomOf(viewer, options.context) : stream;
+        const sfu = await this.getObject(this.sfu);
+        const select = this.select ? (tracks) => {
+            try {
+                return this.select(viewer, tracks);
+            }
+            catch (error) {
+                log('select threw for a viewer of %s, which receives the default member: %s', stream, error);
+                return undefined;
+            }
+        } : undefined;
+        let played;
+        try {
+            played = await SFUAccess_js_1.sfuAccess.get(sfu).play(room, offer, select);
+        }
+        catch (error) {
+            throw new WHEPOfferException_js_1.WHEPOfferException('The offer is refused: {reason}', { reason: error.message });
+        }
+        const leg = played.leg;
+        const session = {
+            id: (0, node_crypto_1.randomUUID)(),
+            stream: stream,
+            room: room,
+            viewerId: played.viewerId,
+            get source() {
+                return leg.source();
+            }
+        };
+        this.#sessions.set(session.id, session);
+        this.#tags.set(session.id, (0, Endpoints_js_1.entityTag)());
+        this.#legs.set(session.id, leg);
+        leg.ended(() => this.end(session.id));
+        this.emit('play', session);
+        return { session: session, answer: leg.answer };
+    }
+    /**
+     * End a session: close its connection, and emit `stop` (on the node holding it). `WHEPController` calls it for the
+     * DELETE requests. With a cluster, a session of another node is ended there.
+     * @param id The id of the session.
+     * @param stream Only if it is a session of this stream.
+     * @returns Whether there was such a session.
+     * @example
+     * ```typescript
+     * import type {WHEP, WHEPSession} from '@lakutata/webrtc'
+     *
+     * declare const whep: WHEP
+     * //Stop the viewers of a stream on this node
+     * await Promise.all(whep.sessions.filter((session: WHEPSession): boolean => session.stream === 'concert').map((session: WHEPSession): Promise<boolean> => whep.stop(session.id)))
+     * ```
+     */
+    async stop(id, stream) {
+        if (this.#sessions.has(id) || !this.#clusterObject)
+            return this.end(id, stream);
+        const replies = await this.#clusterObject.requestAll(STOP_TOPIC, { id: id, stream: stream }, { timeout: STOP_TIMEOUT });
+        return replies.some((reply) => reply.result === true);
+    }
+    /**
+     * End a session of this node
+     * @param id The id of the session.
+     * @param stream Only if it is a session of this stream.
+     * @returns Whether there was such a session.
+     * @protected
+     */
+    end(id, stream) {
+        const session = this.#sessions.get(id);
+        if (!session || (stream !== undefined && session.stream !== stream))
+            return false;
+        this.#sessions.delete(id);
+        this.#tags.delete(id);
+        this.#legs.get(id)?.close();
+        this.#legs.delete(id);
+        this.emit('stop', session);
+        return true;
+    }
+    /**
+     * The entity tag of the ICE session of a session of this node (its `ETag`): a new one after each ICE restart.
+     * @param id The id of the session.
+     * @returns The tag, `undefined` when there is no session of this id.
+     * @example
+     * ```typescript
+     * import type {WHEP} from '@lakutata/webrtc'
+     *
+     * declare const whep: WHEP
+     * const tag: string | undefined = whep.entityTagOf('0b7d…')
+     * ```
+     */
+    entityTagOf(id) {
+        return this.#tags.get(id);
+    }
+    /**
+     * Apply a PATCH of a session (as RFC 9725, section 4.3 does for WHIP), on the node holding it: the candidates of
+     * its viewer (trickle ICE), or an ICE restart when its credentials changed, which needs `If-Match: *`.
+     * `WHEPController` calls it for the PATCH requests. With a cluster, a session of another node is patched there.
+     * @param id The id of the session.
+     * @param fragment The fragment of SDP of the request (`application/trickle-ice-sdpfrag`).
+     * @param options The stream the session must be of, and the `If-Match` of the request: `*` for any ICE session, or
+     * the entity tag of one, quoted.
+     * @returns The fragment of SDP answering an ICE restart (none for trickle ICE), and the entity tag of the ICE session;
+     * `stale` when the request is not applied: its `If-Match` is not the entity tag of the session, or its credentials
+     * changed without `If-Match: *` (a request sent again after a restart).
+     * @throws {WHEPSessionNotFoundException} When no node has a session of this id, or the session is not of this
+     * stream.
+     * @throws {WHEPOfferException} When the fragment has no ICE, or the connection refuses it.
+     * @example
+     * ```typescript
+     * import type {WHEP} from '@lakutata/webrtc'
+     *
+     * declare const whep: WHEP
+     * declare const fragment: string
+     * //An ICE restart
+     * const {fragment: answer, tag} = await whep.patch('0b7d…', fragment, {ifMatch: '*'})
+     * ```
+     */
+    async patch(id, fragment, options = {}) {
+        let outcome = await this.#patchHere(id, fragment, options.stream, options.ifMatch);
+        if (!outcome && this.#clusterObject) {
+            const replies = await this.#clusterObject.requestAll(PATCH_TOPIC, { id: id, fragment: fragment, ...options }, { timeout: PATCH_TIMEOUT });
+            outcome = replies.find((reply) => !!reply.result)?.result ?? undefined;
+        }
+        if (!outcome)
+            throw new WHEPSessionNotFoundException_js_1.WHEPSessionNotFoundException('There is no session {session}', { session: id });
+        if ('refused' in outcome)
+            throw new WHEPOfferException_js_1.WHEPOfferException('The ICE fragment is refused: {reason}', { reason: outcome.refused });
+        return outcome;
+    }
+    /**
+     * Apply a PATCH of a session of this node
+     * @param id
+     * @param fragment
+     * @param stream
+     * @param ifMatch
+     * @returns What it gives, or undefined when this node has no such session.
+     */
+    async #patchHere(id, fragment, stream, ifMatch) {
+        const leg = this.#legs.get(id);
+        const session = this.#sessions.get(id);
+        if (!session || !leg || (stream !== undefined && session.stream !== stream))
+            return undefined;
+        const tag = this.#tags.get(id) ?? '';
+        if (ifMatch !== undefined && ifMatch !== '*' && ifMatch !== `"${tag}"`)
+            return { tag: tag, stale: true };
+        let answer;
+        try {
+            //A restart only with If-Match: * (RFC 9725, section 4.3.2)
+            answer = await leg.patch(fragment, ifMatch === '*');
+        }
+        catch (error) {
+            return { refused: error.message };
+        }
+        if (answer === null)
+            return { tag: this.#tags.get(id) ?? '', stale: true };
+        if (answer !== undefined && this.#sessions.has(id))
+            this.#tags.set(id, (0, Endpoints_js_1.entityTag)());
+        return { ...answer === undefined ? {} : { fragment: answer }, tag: this.#tags.get(id) ?? '' };
+    }
+    /**
+     * The ICE servers given to a viewer, with new TURN credentials.
+     * @param stream The stream (the user of the TURN credentials).
+     * @returns The ICE servers.
+     * @example
+     * ```typescript
+     * import type {SignalingIceServer, WHEP} from '@lakutata/webrtc'
+     *
+     * declare const whep: WHEP
+     * const iceServers: SignalingIceServer[] = await whep.iceServersOf('concert')
+     * ```
+     */
+    async iceServersOf(stream) {
+        return (0, ClusterTURN_js_1.iceServersFor)(stream, {
+            turn: this.turn ? await this.getObject(this.turn) : undefined,
+            cluster: this.#clusterObject,
+            secret: this.turnSecret,
+            select: this.selectTURN,
+            iceServers: this.iceServers
+        }).iceServers;
+    }
+};
+exports.WHEP = WHEP;
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().optional().default('sfu')),
+    __metadata("design:type", String)
+], WHEP.prototype, "sfu", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function().optional()),
+    __metadata("design:type", Function)
+], WHEP.prototype, "roomOf", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function().optional()),
+    __metadata("design:type", Function)
+], WHEP.prototype, "select", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function().optional()),
+    __metadata("design:type", Function)
+], WHEP.prototype, "authorize", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], WHEP.prototype, "cluster", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], WHEP.prototype, "turn", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().min(1).optional()),
+    __metadata("design:type", String)
+], WHEP.prototype, "turnSecret", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function().optional()),
+    __metadata("design:type", Function)
+], WHEP.prototype, "selectTURN", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Array().items(core_1.DTO.Object({
+        urls: core_1.DTO.Alternatives(core_1.DTO.String(), core_1.DTO.Array().items(core_1.DTO.String())).required(),
+        username: core_1.DTO.String().optional(),
+        credential: core_1.DTO.String().optional()
+    })).optional().default([])),
+    __metadata("design:type", Array)
+], WHEP.prototype, "iceServers", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Number().integer().min(0).optional().default(100)),
+    __metadata("design:type", Number)
+], WHEP.prototype, "maxSessions", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().optional().default('*')),
+    __metadata("design:type", String)
+], WHEP.prototype, "allowOrigin", void 0);
+exports.WHEP = WHEP = __decorate([
+    (0, di_1.Singleton)()
+], WHEP);
+/**
+ * Build the options of a {@link WHEP} component, for the `components` of an application (named `whep`, the name
+ * `WHEPController` uses).
+ * @param options The media server, the rooms and the members played, who may play, the ICE servers given to the
+ * viewers, the limit of sessions (all optional).
+ * @returns The component options.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildSFUOptions, buildSignalingOptions, buildWHEPOptions} from '@lakutata/webrtc'
+ *
+ * Application.run(() => ({
+ *     id: 'live.app',
+ *     name: 'Live',
+ *     components: {
+ *         signaling: buildSignalingOptions(),
+ *         sfu: buildSFUOptions(),
+ *         //The viewers of /whep/stage-2 watch the room stage, its member host
+ *         whep: buildWHEPOptions({
+ *             roomOf: ({stream}): string => stream.split('-')[0],
+ *             select: (_viewer, tracks): string | undefined => tracks.find((track): boolean => track.peerId === 'host')?.peerId
+ *         })
+ *     },
+ *     bootstrap: ['sfu']
+ * }))
+ * ```
+ */
+function buildWHEPOptions(options = {}) {
+    return { class: WHEP, ...options };
+}

package/dist/cjs/whep/WHEPController.d.ts

@@ -0,0 +1,134 @@
+import { DTO } from '@lakutata/core';
+import { Controller, type HTTPContext } from '@lakutata/entrypoint';
+import type { WHEP } from './WHEP.js';
+/**
+ * The input of the requests to the endpoint of a stream
+ */
+declare class StreamDTO extends DTO {
+    stream: string;
+    body?: string;
+}
+/**
+ * The input of a PATCH of a session
+ */
+declare class PatchDTO extends DTO {
+    stream: string;
+    session: string;
+    body?: string;
+}
+/**
+ * The input of the requests to a session
+ */
+declare class SessionDTO extends DTO {
+    stream: string;
+    session: string;
+}
+/**
+ * The HTTP interface of WHEP for the {@link WHEP} component registered as `whep`: a player plays a stream with
+ * `POST /whep/:stream` (its SDP offer, receiving only, as `application/sdp`; its bearer token in the `Authorization`
+ * header), gets the answer with the URL of its session (`201 Created`, `Location`), and ends it with `DELETE` on that
+ * URL. It answers the CORS preflights (`OPTIONS`) of the browsers, `GET` with no content, and `PATCH` of a session
+ * (`application/trickle-ice-sdpfrag`): the candidates of the viewer (trickle ICE), or an ICE restart, whose answer has
+ * a new `ETag`. The URL of a session is the capability to end it: its id is random, and the DELETE and the PATCH are
+ * not authorized again.
+ *
+ * Add it to the controllers of an entrypoint whose HTTP adapter reads the bodies of WHEP as text (its option
+ * `body: {text: ['application/sdp', 'application/trickle-ice-sdpfrag']}`, without which Fastify refuses the PATCH
+ * requests with 415). Its routes are under `/whep`; a subclass with `@Prefix({route: …})` gives them another prefix.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints} from 'lakutata/com/entrypoint'
+ * import {Prefix} from 'lakutata/decorator/ctrl'
+ * import {expressHTTPEntrypoint} from 'lakutata/adapter/express'
+ * import {buildSFUOptions, buildSignalingOptions, buildWHEPOptions, WHEPController} from '@lakutata/webrtc'
+ *
+ * //The endpoints under /watch: POST /watch/:stream
+ * @Prefix({route: '/watch'})
+ * class WatchController extends WHEPController {
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'live.app',
+ *     name: 'Live',
+ *     components: {
+ *         signaling: buildSignalingOptions(),
+ *         sfu: buildSFUOptions(),
+ *         whep: buildWHEPOptions(),
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [WatchController],
+ *             http: expressHTTPEntrypoint({port: 8080, body: {text: ['application/sdp', 'application/trickle-ice-sdpfrag']}})
+ *         })
+ *     },
+ *     bootstrap: ['sfu', 'entrypoint']
+ * }))
+ * ```
+ */
+export declare class WHEPController extends Controller {
+    /**
+     * The WHEP component: the one registered as `whep`.
+     * @protected
+     */
+    protected whep(): Promise<WHEP>;
+    /**
+     * The HTTP context of the request
+     * @protected
+     */
+    protected http(): HTTPContext;
+    /**
+     * Set the CORS headers of the response
+     * @protected
+     */
+    protected allowOrigin(): Promise<void>;
+    /**
+     * Answer the CORS preflight of the endpoint of a stream.
+     * @returns Resolves once answered.
+     */
+    preflight(): Promise<void>;
+    /**
+     * Answer the CORS preflight of a session.
+     * @returns Resolves once answered.
+     */
+    sessionPreflight(): Promise<void>;
+    /**
+     * Answer a GET of the endpoint of a stream with no content, as for WHIP (RFC 9725, section 4.1).
+     * @returns Resolves once answered.
+     */
+    probe(): Promise<void>;
+    /**
+     * Answer a GET of a session with no content, as for WHIP (RFC 9725, section 4.1).
+     * @returns Resolves once answered.
+     */
+    sessionProbe(): Promise<void>;
+    /**
+     * Play a stream: answer the offer with `201 Created`, the answer, the URL of the session (`Location`) and the ICE
+     * servers (`Link`).
+     * @param input The stream, and the offer (the body).
+     * @returns Resolves once answered.
+     * @throws {WHEPMediaTypeException} When the body is not `application/sdp`.
+     * @throws {WHEPDeniedException} When `authorize` refuses the stream (with `WWW-Authenticate: Bearer`).
+     * @throws {WHEPLimitException} When the component has `maxSessions` sessions already.
+     * @throws {WHEPOfferException} When the offer cannot be answered.
+     */
+    play(input: StreamDTO): Promise<void>;
+    /**
+     * End a session.
+     * @param input The stream and the session.
+     * @returns Resolves once answered.
+     * @throws {WHEPSessionNotFoundException} When the stream has no such session.
+     */
+    stop(input: SessionDTO): Promise<void>;
+    /**
+     * Apply the candidates of the viewer (trickle ICE: `204 No Content`), or restart ICE when its credentials
+     * changed (`200 OK`, the fragment of the answer, and a new `ETag`), as RFC 9725 (section 4.3) does: an ICE restart
+     * needs `If-Match: *`. An `If-Match` other than `*` and the `ETag` of the session, and new credentials without
+     * `If-Match: *`, are answered with `412 Precondition Failed`.
+     * @param input The stream, the session, and the fragment of SDP (the body).
+     * @returns Resolves once answered.
+     * @throws {WHEPMediaTypeException} When the body is not `application/trickle-ice-sdpfrag`.
+     * @throws {WHEPSessionNotFoundException} When the stream has no such session on any node.
+     * @throws {WHEPOfferException} When the fragment has no ICE, or the connection refuses it.
+     */
+    patch(input: PatchDTO): Promise<void>;
+}
+export {};