@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/types/peer/Endpoints.d.ts

@@ -0,0 +1,75 @@
+import type { IncomingMessage } from 'node:http';
+import type { SignalingDescription, SignalingIceServer } from '../protocol/SignalingProtocol.js';
+import type { PeerConnection } from './PeerConnection.js';
+/**
+ * How long an answer of an HTTP endpoint (WHIP, WHEP) waits for the candidates of its connection at most, in
+ * milliseconds
+ */
+export declare const GATHERING_TIMEOUT: number;
+/**
+ * Wait for the candidates of a connection, all of them or for a time at most
+ * @param connection
+ * @param timeout
+ */
+export declare function gathered(connection: PeerConnection, timeout?: number): Promise<void>;
+/**
+ * The connection of a session of an HTTP endpoint (WHIP, WHEP) to its client, wherever it is (in a worker thread for a
+ * media server forwarding in some): the answer to the offer of the client, its PATCH requests, and the end of the
+ * session
+ */
+export interface EndpointLeg {
+    readonly answer: SignalingDescription;
+    patch(fragment: string, restart: boolean): Promise<string | undefined | null>;
+    ended(listener: () => void): void;
+    close(): void;
+}
+/**
+ * The bearer token of a request
+ * @param request
+ */
+export declare function bearerOf(request: IncomingMessage): string | undefined;
+/**
+ * The path of a request, without its query and its last slash
+ * @param request
+ */
+export declare function pathOf(request: IncomingMessage): string;
+/**
+ * A `Link` header of each ICE server (RFC 9725, section 4.6)
+ * @param iceServers
+ */
+export declare function linksOf(iceServers: SignalingIceServer[]): string[];
+/**
+ * The ICE of a fragment of SDP (RFC 8840): its credentials, and its candidates with the media they belong to
+ * @param fragment
+ */
+export declare function iceOf(fragment: string): {
+    ufrag?: string;
+    pwd?: string;
+    candidates: {
+        candidate: string;
+        sdpMid?: string;
+    }[];
+};
+/**
+ * Apply a PATCH of a session of an HTTP endpoint (RFC 9725, section 4.3) to its connection: the candidates of the
+ * client (trickle ICE), or an ICE restart when its credentials changed. The server answering the offer of the client,
+ * a restart is an offer of the client again, its credentials replaced, that the connection answers with new ones.
+ * @param connection
+ * @param fragment The fragment of SDP of the request (`application/trickle-ice-sdpfrag`).
+ * @param restart Whether the request may restart ICE (its `If-Match` is `*`): a fragment of other credentials without
+ * it is of an ICE session gone (a request sent again after a restart), not applied.
+ * @returns The fragment of the answer of a restart (its credentials, its candidates); none for trickle ICE; `null` for
+ * a fragment of an ICE session gone.
+ * @throws {Error} When the fragment has no ICE, or the connection refuses it.
+ */
+export declare function patchConnection(connection: PeerConnection, fragment: string, restart: boolean): Promise<string | undefined | null>;
+/**
+ * The fragment of SDP of the ICE of a description (RFC 8840): its credentials, and the candidates of its first media
+ * (the one the others are bundled on)
+ * @param sdp
+ */
+export declare function fragmentOf(sdp: string): string;
+/**
+ * A new entity tag of an ICE session (the `ETag` of a session of an HTTP endpoint)
+ */
+export declare function entityTag(): string;

package/dist/types/peer/EngineConfig.d.ts

@@ -0,0 +1,20 @@
+import type { RTCPeerConnectionConfig } from '../lib/peer/peerConnection.js';
+import type { SignalingIceServer } from '../protocol/SignalingProtocol.js';
+/**
+ * The options of a connection the engine is configured from, plain data (given to a worker thread as they are)
+ */
+export interface EngineOptions {
+    readonly iceServers: SignalingIceServer[];
+    readonly iceTransportPolicy: 'all' | 'relay';
+    readonly icePortRange?: [number, number];
+    readonly iceAdditionalHostAddresses?: string[];
+    readonly iceUseIpv4: boolean;
+    readonly iceUseIpv6: boolean;
+    readonly codecs: string[];
+    readonly headerExtensions: boolean;
+}
+/**
+ * The configuration of the connection of the engine of a connection
+ * @param options
+ */
+export declare function engineConfigOf(options: EngineOptions): RTCPeerConnectionConfig;

package/dist/types/peer/EngineConnection.d.ts

@@ -0,0 +1,22 @@
+import type { RTCDataChannel } from '../lib/peer/dataChannel.js';
+import type { RTCPeerConnection } from '../lib/peer/peerConnection.js';
+import type { PeerChannel } from './PeerChannel.js';
+import type { PeerConnection } from './PeerConnection.js';
+/**
+ * The connections of the engine of the connections
+ */
+export declare const engineConnections: WeakMap<PeerConnection, RTCPeerConnection>;
+/**
+ * The connection of the engine of a connection: its transports, its senders and receivers
+ * @param connection
+ */
+export declare function engineConnectionOf(connection: PeerConnection): RTCPeerConnection;
+/**
+ * The channels of the engine of the channels
+ */
+export declare const engineChannels: WeakMap<PeerChannel, RTCDataChannel>;
+/**
+ * The channel of the engine of a channel: its SCTP transport
+ * @param channel
+ */
+export declare function engineChannelOf(channel: PeerChannel): RTCDataChannel;

package/dist/types/peer/Events.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The options of `addEventListener`.
+ */
+export interface ListenerOptions {
+    /**
+     * Remove the listener after its first call.
+     */
+    once?: boolean;
+    /**
+     * Remove the listener when the signal aborts.
+     */
+    signal?: AbortSignal;
+    /**
+     * Unused (no capture phase), as in `EventTarget` of Node.js.
+     */
+    capture?: boolean;
+}
+/**
+ * A listener of the `on…` properties and of `addEventListener`.
+ */
+export type DOMEventListener = (event: any) => void;
+/**
+ * The events of an object, in the two styles of the peer connections and of the channels: the W3C style
+ * (`addEventListener`, the `on…` properties, given an event object) and the Node.js style (`on`, given the value of the
+ * event)
+ */
+export declare class Events {
+    #private;
+    /**
+     * The events of an object
+     * @param owner
+     */
+    constructor(owner: object);
+    /**
+     * Fire an event: the listeners of the W3C style get an event object holding the given properties, the ones of the
+     * Node.js style get the arguments
+     * @param type
+     * @param properties
+     * @param args
+     */
+    fire(type: string, properties: Record<string, unknown>, ...args: unknown[]): void;
+    /**
+     * Dispatch an event given: the listeners of the W3C style get it, the ones of the Node.js style the arguments
+     * @param event
+     * @param args
+     */
+    dispatch(event: Event, ...args: unknown[]): boolean;
+    addEventListener(type: string, listener: DOMEventListener, options?: boolean | ListenerOptions): void;
+    removeEventListener(type: string, listener: DOMEventListener, options?: boolean | ListenerOptions): void;
+    on(type: string, listener: (...args: any[]) => void): void;
+    once(type: string, listener: (...args: any[]) => void): void;
+    off(type: string, listener: (...args: any[]) => void): void;
+    handler(type: string): DOMEventListener | null;
+    setHandler(type: string, handler: DOMEventListener | null): void;
+}

package/dist/types/peer/MediaCodecs.d.ts

@@ -0,0 +1,27 @@
+import type { RTCRtpCodecParameters } from '../lib/peer/media/parameters.js';
+/**
+ * The MIME types of the codecs supported
+ */
+export declare const SUPPORTED_CODECS: string[];
+/**
+ * The codecs offered by default, in the order of preference: the ones of the browsers, VP8 first as Chrome does
+ */
+export declare const DEFAULT_CODECS: string[];
+/**
+ * The MIME type of a codec as written in SUPPORTED_CODECS (`video/H264`, `audio/opus`), whatever its case
+ * @param mimeType
+ */
+export declare function canonicalCodec(mimeType: string): string;
+/**
+ * The codec of the engine of a MIME type
+ * @param mimeType
+ */
+export declare function engineCodecOf(mimeType: string): RTCRtpCodecParameters;
+/**
+ * The codecs of the engine of a list of MIME types, by kind
+ * @param mimeTypes
+ */
+export declare function engineCodecsOf(mimeTypes: string[]): {
+    audio: RTCRtpCodecParameters[];
+    video: RTCRtpCodecParameters[];
+};

package/dist/types/peer/MediaTrack.d.ts

@@ -0,0 +1,212 @@
+import type { RTCRtpCodecParameters } from '../lib/peer/media/parameters.js';
+import type { RTCRtpReceiver } from '../lib/peer/media/rtpReceiver.js';
+import { MediaStreamTrack } from '../lib/peer/media/track.js';
+import type { Extensions, RtpPacket as EngineRtpPacket } from '../lib/rtp/index.js';
+import { RtpPacket } from './RtpPacket.js';
+/**
+ * The kind of a track.
+ */
+export type MediaKind = 'audio' | 'video';
+/**
+ * The options of a {@link MediaTrack} to send.
+ */
+export interface MediaTrackOptions {
+    /**
+     * The codec of the packets written to the track, as a MIME type: `audio/opus`, `audio/PCMU`, `video/VP8`,
+     * `video/VP9` or `video/H264`. The connections sending the track negotiate this one; the other peer must support it.
+     * @default the codec the connection negotiates (the packets written must then be of that codec)
+     */
+    codec?: string;
+    /**
+     * The id of the track.
+     * @default a random UUID
+     */
+    id?: string;
+}
+/**
+ * The events of a {@link MediaTrack}, with the arguments of their listeners.
+ */
+export type MediaTrackEvents = {
+    /**
+     * A packet received from the other peer (a received track).
+     */
+    rtp: [packet: RtpPacket];
+    /**
+     * A peer the track is sent to asks for a key frame: the encoder writing to the track should make one (a received
+     * track sent on, to another connection, asks its own sender itself).
+     */
+    keyframerequest: [];
+    /**
+     * The track ended: stopped, or its connection closed.
+     */
+    ended: [];
+};
+/**
+ * An audio or video track of a {@link PeerConnection}: the RTP packets of encoded audio or video. Node.js captures and
+ * encodes nothing: a track to send gets the packets of an encoder (ffmpeg, GStreamer sending RTP to a UDP port) with
+ * `writeRtp()`, a received track gives the packets of the other peer (its `rtp` event), to record, to decode, or to send
+ * on: a received track added to another connection forwards its packets there.
+ *
+ * Create one to send with `new MediaTrack(kind, options)`, and add it with `PeerConnection.addTrack()`; the received
+ * ones come with the `track` event of the connection. Its events are in the Node.js style (`on`).
+ * @example
+ * ```typescript
+ * import {createSocket, type Socket} from 'node:dgram'
+ * import {MediaTrack, type PeerConnection} from '@lakutata/webrtc'
+ *
+ * declare const connection: PeerConnection
+ * //ffmpeg -re -i camera.mp4 -an -c:v libx264 -profile:v baseline -pix_fmt yuv420p -tune zerolatency -g 30
+ * //       -bsf:v dump_extra=freq=keyframe -f rtp rtp://127.0.0.1:5004
+ * const video: MediaTrack = new MediaTrack('video', {codec: 'video/H264'})
+ * connection.addTrack(video, 'camera')
+ * const socket: Socket = createSocket('udp4')
+ * socket.on('message', (datagram: Buffer): void => video.writeRtp(datagram))
+ * socket.bind(5004)
+ * ```
+ */
+export declare class MediaTrack {
+    #private;
+    /**
+     * Create a track to send.
+     * @param kind `audio` or `video`.
+     * @param options The codec of the packets written, the id.
+     */
+    constructor(kind: MediaKind, options?: MediaTrackOptions);
+    /**
+     * The id of the track.
+     */
+    get id(): string;
+    /**
+     * `audio` or `video`.
+     */
+    get kind(): MediaKind;
+    /**
+     * Whether the track was received from the other peer.
+     */
+    get remote(): boolean;
+    /**
+     * `live`, or `ended` once stopped.
+     */
+    get readyState(): 'live' | 'ended';
+    /**
+     * The MIME type of the codec of the packets: the one negotiated, the one given to a track to send; `undefined` until
+     * known.
+     */
+    get codec(): string | undefined;
+    /**
+     * Send a packet to the peers the track is added to. The synchronization source and the payload type are the ones of
+     * each connection, the sequence numbers and the timestamps go on from the ones written before.
+     * @param packet A packet, or the bytes of one.
+     * @throws {Error} When the track was received (it is not sent from here).
+     * @example
+     * ```typescript
+     * import {MediaTrack, RtpPacket} from '@lakutata/webrtc'
+     *
+     * declare const opusFrame: Buffer
+     * const audio: MediaTrack = new MediaTrack('audio', {codec: 'audio/opus'})
+     * audio.writeRtp(new RtpPacket({payloadType: 111, sequenceNumber: 1, timestamp: 960, payload: opusFrame}))
+     * ```
+     */
+    writeRtp(packet: RtpPacket | Uint8Array): void;
+    /**
+     * Ask the other peer for a key frame (a picture loss indication), for the packets of a received video track to be
+     * decodable from now on: when they start to be recorded or decoded. Nothing is sent for a track to send.
+     * @example
+     * ```typescript
+     * import type {MediaTrack} from '@lakutata/webrtc'
+     *
+     * declare const received: MediaTrack
+     * //The recording starts: from a key frame
+     * received.requestKeyFrame()
+     * ```
+     */
+    requestKeyFrame(): void;
+    /**
+     * Stop the track: it is sent no more, and receives no more.
+     * @example
+     * ```typescript
+     * import type {MediaTrack} from '@lakutata/webrtc'
+     *
+     * declare const video: MediaTrack
+     * video.stop()
+     * ```
+     */
+    stop(): void;
+    /**
+     * Add a listener of an event.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns The track.
+     * @example
+     * ```typescript
+     * import type {MediaTrack, RtpPacket} from '@lakutata/webrtc'
+     *
+     * declare const received: MediaTrack
+     * received.on('rtp', (packet: RtpPacket): void => console.log(packet.sequenceNumber, packet.payload.length))
+     * ```
+     */
+    on<Event extends keyof MediaTrackEvents>(event: Event, listener: (...args: MediaTrackEvents[Event]) => void): this;
+    /**
+     * Add a listener of the next emission of an event.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns The track.
+     * @example
+     * ```typescript
+     * import type {MediaTrack} from '@lakutata/webrtc'
+     *
+     * declare const received: MediaTrack
+     * received.once('ended', (): void => console.log('the track ended'))
+     * ```
+     */
+    once<Event extends keyof MediaTrackEvents>(event: Event, listener: (...args: MediaTrackEvents[Event]) => void): this;
+    /**
+     * Remove a listener added with `on` or `once`.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns The track.
+     * @example
+     * ```typescript
+     * import type {MediaTrack, RtpPacket} from '@lakutata/webrtc'
+     *
+     * declare const received: MediaTrack
+     * const listener = (packet: RtpPacket): void => console.log(packet.timestamp)
+     * received.on('rtp', listener)
+     * received.off('rtp', listener)
+     * ```
+     */
+    off<Event extends keyof MediaTrackEvents>(event: Event, listener: (...args: MediaTrackEvents[Event]) => void): this;
+}
+/**
+ * The track of a track of the engine, created once
+ * @param track
+ * @param receiver The receiver of a received track
+ */
+export declare function trackOf(track: MediaStreamTrack, receiver?: RTCRtpReceiver): MediaTrack;
+/**
+ * The track of the engine of a track
+ * @param track
+ */
+export declare function engineTrackOf(track: MediaTrack): MediaStreamTrack;
+/**
+ * A peer the track is sent to asks for a key frame: a received track asks its own sender (at most every
+ * KEY_FRAME_REQUEST_INTERVAL)
+ * @param track
+ */
+export declare function keyFrameRequested(track: MediaTrack): void;
+/**
+ * A received track whose packets come from elsewhere (a track of a room of the media server forwarded in a worker
+ * thread): it is read and sent on like the others, its key frame requests go back where its packets come from, which is
+ * told whether they are wanted (read, or sent on) as this changes
+ * @param kind
+ * @param codec The codec of its packets, once known.
+ * @param id The id of the track where the packets come from (a random one without it).
+ * @param source Asks for a key frame; is told whether the packets are wanted.
+ */
+export declare function relayedTrack(kind: MediaKind, codec: RTCRtpCodecParameters | undefined, id: string | undefined, source: {
+    requestKeyFrame(): void;
+    wanted(wanted: boolean): void;
+}): {
+    track: MediaTrack;
+    receive(packet: EngineRtpPacket, extensions?: Extensions): void;
+};

package/dist/types/peer/PeerChannel.d.ts

@@ -0,0 +1,248 @@
+import type { RTCDataChannel } from '../lib/peer/dataChannel.js';
+import { type DOMEventListener, type ListenerOptions } from './Events.js';
+/**
+ * The events of a {@link PeerChannel}, with the arguments of their listeners in the Node.js style (`on`).
+ */
+export type PeerChannelEvents = {
+    /**
+     * The channel is open: messages may be sent.
+     */
+    open: [];
+    /**
+     * The channel is closing.
+     */
+    closing: [];
+    /**
+     * The channel is closed.
+     */
+    close: [];
+    /**
+     * A message: a string, or a `Buffer` (an `ArrayBuffer` when `binaryType` is `'arraybuffer'`).
+     */
+    message: [data: string | Buffer | ArrayBuffer];
+    /**
+     * The data waiting to be sent fell to `bufferedAmountLowThreshold`.
+     */
+    bufferedamountlow: [];
+    /**
+     * An error of the channel.
+     */
+    error: [error: Error];
+};
+/**
+ * A data channel of a {@link PeerConnection}, as `RTCDataChannel` of the browsers: `send()`, `close()`, the same
+ * properties and events (`addEventListener`, the `on…` properties). Its events may be listened to in the Node.js style
+ * too: `on('message', (data) => …)` gets the message itself. A binary message is a `Buffer`, or an `ArrayBuffer` when
+ * `binaryType` is `'arraybuffer'`.
+ *
+ * It is created by `PeerConnection.createDataChannel()`, or by the other peer (the `datachannel` event).
+ * @example
+ * ```typescript
+ * import type {PeerChannel, PeerConnection} from '@lakutata/webrtc'
+ *
+ * declare const connection: PeerConnection
+ * const channel: PeerChannel = connection.createDataChannel('chat')
+ * channel.on('open', (): void => channel.send('hello'))
+ * channel.on('message', (data: string | Buffer | ArrayBuffer): void => console.log(data.toString()))
+ * ```
+ */
+export declare class PeerChannel {
+    #private;
+    /**
+     * Wrap a channel of the engine
+     * @param channel
+     * @internal
+     */
+    constructor(channel: RTCDataChannel);
+    /**
+     * The label of the channel.
+     */
+    get label(): string;
+    /**
+     * The id of the channel (its SCTP stream); `null` until the connection decides it.
+     */
+    get id(): number | null;
+    /**
+     * The subprotocol.
+     */
+    get protocol(): string;
+    /**
+     * Whether the messages arrive in order.
+     */
+    get ordered(): boolean;
+    /**
+     * How many times a message is sent again at most; `null` for a reliable channel.
+     */
+    get maxRetransmits(): number | null;
+    /**
+     * How long a message is sent again at most, in milliseconds; `null` for a reliable channel.
+     */
+    get maxPacketLifeTime(): number | null;
+    /**
+     * Whether both peers created the channel themselves.
+     */
+    get negotiated(): boolean;
+    /**
+     * `connecting`, `open`, `closing` or `closed`.
+     */
+    get readyState(): 'connecting' | 'open' | 'closing' | 'closed';
+    /**
+     * The bytes sent but not handed to the network yet: wait for `bufferedamountlow` when it grows, to send a large
+     * amount of data without holding it all in memory.
+     */
+    get bufferedAmount(): number;
+    /**
+     * The value of `bufferedAmount` at which `bufferedamountlow` fires.
+     */
+    get bufferedAmountLowThreshold(): number;
+    set bufferedAmountLowThreshold(value: number);
+    /**
+     * The type of the binary messages received: `'nodebuffer'` (a `Buffer`, by default) or `'arraybuffer'`.
+     */
+    get binaryType(): 'nodebuffer' | 'arraybuffer';
+    set binaryType(value: 'nodebuffer' | 'arraybuffer');
+    /**
+     * The listener of `open`, given the event.
+     */
+    get onopen(): DOMEventListener | null;
+    set onopen(listener: DOMEventListener | null);
+    /**
+     * The listener of `message`, given a `MessageEvent` whose `data` is the message.
+     */
+    get onmessage(): DOMEventListener | null;
+    set onmessage(listener: DOMEventListener | null);
+    /**
+     * The listener of `closing`, given the event.
+     */
+    get onclosing(): DOMEventListener | null;
+    set onclosing(listener: DOMEventListener | null);
+    /**
+     * The listener of `close`, given the event.
+     */
+    get onclose(): DOMEventListener | null;
+    set onclose(listener: DOMEventListener | null);
+    /**
+     * The listener of `bufferedamountlow`, given the event.
+     */
+    get onbufferedamountlow(): DOMEventListener | null;
+    set onbufferedamountlow(listener: DOMEventListener | null);
+    /**
+     * The listener of `error`, given an event whose `error` is the error.
+     */
+    get onerror(): DOMEventListener | null;
+    set onerror(listener: DOMEventListener | null);
+    /**
+     * Send a message: a string, or binary data.
+     * @param data The message; its size may not exceed the maximum of the other peer (`PeerConnection.sctp.maxMessageSize`).
+     * @throws {DOMException} When the channel is not open (`InvalidStateError`).
+     * @example
+     * ```typescript
+     * import type {PeerChannel} from '@lakutata/webrtc'
+     *
+     * declare const channel: PeerChannel
+     * channel.send(JSON.stringify({x: 1, y: 2}))
+     * channel.send(new Uint8Array([1, 2, 3]))
+     * ```
+     */
+    send(data: string | ArrayBuffer | ArrayBufferView): void;
+    /**
+     * Close the channel; the messages sent before are delivered first.
+     * @example
+     * ```typescript
+     * import type {PeerChannel} from '@lakutata/webrtc'
+     *
+     * declare const channel: PeerChannel
+     * channel.close()
+     * ```
+     */
+    close(): void;
+    /**
+     * Add a listener of an event, given an event object (the W3C style).
+     * @param type The event: `open`, `message`, `closing`, `close`, `bufferedamountlow`, `error`.
+     * @param listener The listener.
+     * @param options `once`, `signal`.
+     * @example
+     * ```typescript
+     * import type {PeerChannel} from '@lakutata/webrtc'
+     *
+     * declare const channel: PeerChannel
+     * channel.addEventListener('message', (event: MessageEvent): void => console.log(event.data))
+     * ```
+     */
+    addEventListener(type: string, listener: DOMEventListener, options?: boolean | ListenerOptions): void;
+    /**
+     * Remove a listener added with `addEventListener`.
+     * @param type The event.
+     * @param listener The listener.
+     * @param options `capture`.
+     * @example
+     * ```typescript
+     * import type {PeerChannel} from '@lakutata/webrtc'
+     *
+     * declare const channel: PeerChannel
+     * const listener = (event: MessageEvent): void => console.log(event.data)
+     * channel.addEventListener('message', listener)
+     * channel.removeEventListener('message', listener)
+     * ```
+     */
+    removeEventListener(type: string, listener: DOMEventListener, options?: boolean | ListenerOptions): void;
+    /**
+     * Dispatch an event to the listeners, as `EventTarget.dispatchEvent()`: the ones of the W3C style get it, the ones
+     * of the Node.js style its value (the data of a `MessageEvent`).
+     * @param event The event.
+     * @returns Whether no listener called `preventDefault()`.
+     * @example
+     * ```typescript
+     * import type {PeerChannel} from '@lakutata/webrtc'
+     *
+     * declare const channel: PeerChannel
+     * //A message given again to the listeners
+     * channel.dispatchEvent(new MessageEvent('message', {data: 'again'}))
+     * ```
+     */
+    dispatchEvent(event: Event): boolean;
+    /**
+     * Add a listener of an event, given the value of the event (the Node.js style).
+     * @param event The event.
+     * @param listener The listener: given the message for `message`, the error for `error`.
+     * @returns The channel.
+     * @example
+     * ```typescript
+     * import type {PeerChannel} from '@lakutata/webrtc'
+     *
+     * declare const channel: PeerChannel
+     * channel.on('message', (data: string | Buffer | ArrayBuffer): void => console.log(data))
+     * ```
+     */
+    on<Event extends keyof PeerChannelEvents>(event: Event, listener: (...args: PeerChannelEvents[Event]) => void): this;
+    /**
+     * Add a listener of the next emission of an event, given the value of the event.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns The channel.
+     * @example
+     * ```typescript
+     * import type {PeerChannel} from '@lakutata/webrtc'
+     *
+     * declare const channel: PeerChannel
+     * channel.once('open', (): void => channel.send('first'))
+     * ```
+     */
+    once<Event extends keyof PeerChannelEvents>(event: Event, listener: (...args: PeerChannelEvents[Event]) => void): this;
+    /**
+     * Remove a listener added with `on` or `once`.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns The channel.
+     * @example
+     * ```typescript
+     * import type {PeerChannel} from '@lakutata/webrtc'
+     *
+     * declare const channel: PeerChannel
+     * const listener = (): void => console.log('closed')
+     * channel.on('close', listener)
+     * channel.off('close', listener)
+     * ```
+     */
+    off<Event extends keyof PeerChannelEvents>(event: Event, listener: (...args: PeerChannelEvents[Event]) => void): this;
+}