@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/types/lib/peer/sdpManager.d.ts

@@ -0,0 +1,116 @@
+import type { RTCRtpTransceiver } from './media/index.js';
+import { type RTCRtpCodecParameters } from './media/parameters.js';
+import type { MediaDirection } from './media/rtpTransceiver.js';
+import { type BundlePolicy, GroupDescription, MediaDescription, SessionDescription } from './sdp.js';
+import type { RTCDtlsTransport } from './transport/dtls.js';
+import type { RTCSctpTransport } from './transport/sctp.js';
+export declare class SDPManager {
+    currentLocalDescription?: SessionDescription;
+    currentRemoteDescription?: SessionDescription;
+    pendingLocalDescription?: SessionDescription;
+    pendingRemoteDescription?: SessionDescription;
+    readonly cname: string;
+    readonly midSuffix: boolean;
+    readonly bundlePolicy?: BundlePolicy;
+    readonly mLineReuse: MLineReuse;
+    private seenMid;
+    constructor({ cname, midSuffix, bundlePolicy, mLineReuse }: {
+        cname: string;
+        midSuffix?: boolean;
+        bundlePolicy?: BundlePolicy;
+        mLineReuse?: MLineReuse;
+    });
+    get localDescription(): import("./sdp.js").RTCSessionDescription | undefined;
+    get remoteDescription(): import("./sdp.js").RTCSessionDescription | undefined;
+    /**@private */
+    get _localDescription(): SessionDescription | undefined;
+    /**@private */
+    get _remoteDescription(): SessionDescription | undefined;
+    get inactiveRemoteMedia(): MediaDescription | undefined;
+    /**
+   * MediaDescriptionをトランシーバー用に作成
+   */
+    createMediaDescriptionForTransceiver(transceiver: RTCRtpTransceiver, direction: MediaDirection): MediaDescription;
+    /**
+   * 拒否 / 停止した m-line を作成する (RFC 3264 §6 / RFC 8829 §5.3.1)。
+   * port は 0、proto と MID は元の m-line を保ち、fmt は少なくとも 1 token 残す。
+   */
+    createRejectedMediaDescription(source: {
+        kind: MediaDescription['kind'];
+        profile: string;
+        fmt: (string | number)[];
+        codecs: RTCRtpCodecParameters[];
+        mid?: string;
+    }, dtlsTransport?: RTCDtlsTransport): MediaDescription;
+    /**
+   * MediaDescriptionをSCTP用に作成
+   */
+    createMediaDescriptionForSctp(sctp: RTCSctpTransport): MediaDescription;
+    /**
+   * トランスポートの情報をMediaDescriptionに追加
+   */
+    addTransportDescription(media: MediaDescription, dtlsTransport: RTCDtlsTransport): void;
+    /**
+   * 一意のMIDを割り当て
+   */
+    allocateMid(type?: 'dc' | 'av' | ''): string;
+    parseSdp({ sdp, isLocal, signalingState, type }: {
+        sdp: string;
+        isLocal: boolean;
+        signalingState: string;
+        type: 'offer' | 'answer' | 'pranswer';
+    }): SessionDescription;
+    private validateDescription;
+    /**
+   * オファーSDPを構築
+   */
+    buildOfferSdp(transceivers: RTCRtpTransceiver[], sctpTransport: RTCSctpTransport | undefined): SessionDescription;
+    private liveTransportOr;
+    private findLiveDtlsTransport;
+    /**確定済み answer の BUNDLE tag (先頭 MID) */
+    get negotiatedBundleTag(): string | undefined;
+    /**
+   * アンサーSDPを構築
+   */
+    buildAnswerSdp({ transceivers, sctpTransport, signalingState }: {
+        transceivers: RTCRtpTransceiver[];
+        sctpTransport: RTCSctpTransport | undefined;
+        signalingState: string;
+    }): SessionDescription;
+    /**
+   * RFC 8843 §7.3: offered BUNDLE group の member のうち受け入れた MID だけで
+   * answer の group を作る。確立済みの tag は保持し、初回 answer で
+   * offerer-tagged を拒否した場合は受け入れた先頭 member を answerer-tagged にする。
+   * 全 member を拒否した group は省略する。
+   */
+    private buildAnswerBundleGroups;
+    /**
+   * remote answer / pranswer を適用する前の検証。
+   * 非ゼロ port の RTP m-line が pending local offer と共通 codec を持たなければ拒否する。
+   */
+    private assertRemoteAnswerCodecs;
+    /**
+   * 確立済み BUNDLE の transport を共有している m-line を、re-offer が
+   * group の外へ出したり別々の group に分割したりすることはできない
+   * (共有 transport を分割できない)。状態を変更する前に拒否する。
+   */
+    private assertBundlePreserved;
+    setLocalDescription(description: SessionDescription): void;
+    setRemoteDescription(sessionDescription: RTCSessionDescriptionInit, signalingState: string): SessionDescription | undefined;
+    rollbackLocalDescription(signalingState: string): void;
+    registerMid(mid: string): void;
+    get remoteIsBundled(): GroupDescription | undefined;
+    /**
+   * ローカルセッション記述を設定し、トランスポート情報を追加する
+   */
+    setLocal(description: SessionDescription, transceivers: RTCRtpTransceiver[], sctpTransport?: {
+        dtlsTransport: RTCDtlsTransport;
+        mid?: string;
+    }): void;
+}
+export type MLineReuse = 'compatible' | 'aggressive';
+export interface RTCSessionDescriptionInit {
+    sdp?: string;
+    type?: RTCSdpType;
+}
+export type RTCSdpType = 'answer' | 'offer' | 'pranswer' | 'rollback';

package/dist/types/lib/peer/secureTransportManager.d.ts

@@ -0,0 +1,96 @@
+import { Event } from './imports/common.js';
+import type { TransceiverManager } from './media/index.js';
+import type { RTCStats } from './media/stats.js';
+import type { PeerConfig } from './peerConnection.js';
+import type { SctpTransportManager } from './sctpManager.js';
+import type { SessionDescription } from './sdp.js';
+import { type DtlsKeys, RTCCertificate, RTCDtlsTransport } from './transport/dtls.js';
+import { IceCandidate, type IceGathererState, type RTCIceCandidate, type RTCIceCandidateInit, type RTCIceConnectionState, RTCIceTransport } from './transport/ice.js';
+import type { ConnectionState } from './types/domain.js';
+export declare class SecureTransportManager {
+    connectionState: ConnectionState;
+    iceConnectionState: RTCIceConnectionState;
+    iceGatheringState: IceGathererState;
+    certificate?: RTCCertificate;
+    readonly iceGatheringStateChange: Event<["new" | "complete" | "gathering"]>;
+    readonly iceConnectionStateChange: Event<["disconnected" | "connected" | "failed" | "closed" | "new" | "completed" | "checking"]>;
+    readonly onIceCandidate: Event<[IceCandidate | undefined]>;
+    readonly connectionStateChange: Event<["disconnected" | "connected" | "failed" | "closed" | "connecting" | "new"]>;
+    private config;
+    private transceiverManager;
+    private sctpManager;
+    constructor({ config, transceiverManager, sctpManager }: {
+        config: PeerConfig;
+        transceiverManager: TransceiverManager;
+        sctpManager: SctpTransportManager;
+    });
+    /**live な m-line (停止確定していない transceiver / SCTP) が使う transport */
+    get dtlsTransports(): RTCDtlsTransport[];
+    /**停止済み transceiver の transport も含めた全 transport */
+    private get allDtlsTransports();
+    private readonly createdTransports;
+    get iceTransports(): RTCIceTransport[];
+    setupCertificate(keys: DtlsKeys): void;
+    /**
+   * Resolve STUN/TURN options from the current PeerConfig.
+   * Always returns every server-related field (including undefined) so
+   * Connection.setIceServers can fully replace residual TURN credentials.
+   */
+    private resolveIceServerOptions;
+    /**
+   * Re-apply ICE servers from the current config to ICE transports that have
+   * not started gathering yet (`gatheringState === "new"`).
+   *
+   * JSEP (RFC 8829 §4.1.18) / ticket scope: server changes affect the next
+   * gathering phase. Once gathering has started or finished, leave the live
+   * Connection alone so existing candidates and TURN protocols are not
+   * disturbed. Used when TURN is learned after the gatherer was built
+   * (e.g. from a WHIP Link header) but before setLocalDescription gathers.
+   */
+    updateIceServers(): void;
+    createTransport({ inheritCredentials }?: {
+        inheritCredentials?: boolean | undefined;
+    }): RTCDtlsTransport;
+    /**
+   * sdpMid / sdpMLineIndex は ICE transport を所有する受け入れ済み m-line
+   * (BUNDLE なら tag) を呼び出し側で解決して渡す。
+   */
+    handleNewIceCandidate({ candidate, sdpMid, sdpMLineIndex }: {
+        candidate: IceCandidate;
+        sdpMid?: string;
+        sdpMLineIndex?: number;
+    }): IceCandidate;
+    addIceCandidate(sdp: SessionDescription, candidateMessage: RTCIceCandidate | RTCIceCandidateInit | null): Promise<{
+        kind: "end-of-candidates";
+        mediaIndices: number[];
+        candidate?: undefined;
+    } | {
+        kind: "candidate";
+        candidate: IceCandidate;
+        mediaIndices: number[];
+    }>;
+    private resolveCandidateMediaIndices;
+    private isRejectedMedia;
+    private getTransportByMid;
+    private getTransportByMLineIndex;
+    restartIce(): void;
+    setLocalRole({ type, role, roleOfTransport }: {
+        type: 'offer' | 'answer';
+        /**transport 個別の role がない場合に使う local description 先頭の role */
+        role: 'auto' | 'client' | 'server' | undefined;
+        /**local description でその transport を使う m-line の role */
+        roleOfTransport?: Map<RTCDtlsTransport, 'auto' | 'client' | 'server'>;
+    }): void;
+    private updateIceGatheringState;
+    updateIceConnectionState(): void;
+    /**
+   * 未収集 (gatheringState=new) の ICE transport だけ候補を収集する。
+   * 収集済み transport は gather() が何もしないので、確立済み BUNDLE の transport は再収集されず、
+   * BUNDLE group 外に新設した独立 transport だけが候補を収集する。
+   */
+    gatherCandidates(): Promise<void>;
+    setConnectionState(state: ConnectionState): void;
+    getStats(timestamp?: number): Promise<RTCStats[]>;
+    ensureCerts(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/types/lib/peer/transceiverManager.d.ts

@@ -0,0 +1,151 @@
+import { Event } from './imports/common.js';
+import { MediaStream, type MediaStreamTrack, type RTCRtpCodecParameters, type RTCRtpParameters, type RTCRtpReceiveParameters, RTCRtpReceiver, RTCRtpSender, RTCRtpTransceiver, type RtpRouter, type TransceiverOptions } from './media/index.js';
+import type { RTCStats } from './media/stats.js';
+import type { PeerConfig } from './peerConnection.js';
+import { type MediaDescription, type SessionDescription } from './sdp.js';
+import type { RTCDtlsTransport } from './transport/dtls.js';
+import type { Kind } from './types/domain.js';
+export declare class TransceiverManager {
+    private readonly cname;
+    private readonly config;
+    private readonly router;
+    private readonly transceivers;
+    private readonly watched;
+    private stableState;
+    private remoteOfferSnapshot?;
+    readonly onTransceiverAdded: Event<[RTCRtpTransceiver]>;
+    readonly onRemoteTransceiverAdded: Event<[RTCRtpTransceiver]>;
+    readonly onTrack: Event<[{
+        track: MediaStreamTrack;
+        transceiver: RTCRtpTransceiver;
+        streams: MediaStream[];
+    }]>;
+    readonly onNegotiationNeeded: Event<[]>;
+    constructor(cname: string, config: Required<PeerConfig>, router: RtpRouter);
+    getTransceivers(): RTCRtpTransceiver[];
+    getSenders(): RTCRtpSender[];
+    getReceivers(): RTCRtpReceiver[];
+    getTransceiverByMLineIndex(index: number): RTCRtpTransceiver | undefined;
+    pushTransceiver(t: RTCRtpTransceiver): void;
+    replaceTransceiver(t: RTCRtpTransceiver, index: number): void;
+    /**m-line から外れた transceiver の購読を解除する */
+    private unwatchTransceiver;
+    private watchTransceiver;
+    /**
+   * 拒否 / 停止の交渉が確定した port 0 の位置のうち、同じ kind で
+   * まだ他の transceiver が予約していないものを返す。
+   * stopping (未交渉) の位置は先取りしない。
+   */
+    private findReusableTransceiver;
+    /**旧 transceiver を m-line から外し、同じ位置に新しい transceiver を置く */
+    private takeOverMLine;
+    /**
+   * 既存の未関連付け transceiver を remote m-line の位置に関連付ける。
+   * 同じ位置に停止済みの旧 transceiver があれば m-line から外し、配列上でも置き換える。
+   * (旧 transceiver が位置を持ったままだと MID の割り当て先が重複する)
+   */
+    associateMLine(transceiver: RTCRtpTransceiver, mLineIndex: number): void;
+    /**
+   * remote offer が定義した位置のうち、関連付けられなかった未交渉 transceiver の予約を解除する。
+   * (remote が予約位置を別 kind や別 transceiver で再利用した場合、次の offer で末尾に追加させる)
+   */
+    releaseUnassociatedReservations(associated: Set<RTCRtpTransceiver>, mLineCount: number): void;
+    addTransceiver(trackOrKind: Kind | MediaStreamTrack, dtlsTransport?: RTCDtlsTransport, options?: Partial<TransceiverOptions>, { remoteMLineIndex }?: {
+        /**remote offer 起因で作る場合の m-line index。確定済み停止位置の自動再利用は行わない */
+        remoteMLineIndex?: number;
+    }): RTCRtpTransceiver;
+    /**
+     * Whether addTrack may give a track of a kind to a transceiver, rather than adding one
+     * @param transceiver
+     * @param kind
+     */
+    reusableForTrack(transceiver: RTCRtpTransceiver, kind: string): boolean;
+    /**
+     * Add a track: to a transceiver that may take it, else to a new one
+     * @param track
+     * @param streams
+     * @param chosen The transceiver chosen already (for a connection served in a worker thread, by the main thread): used
+     * if it may still take the track, else a new one is added, as for null
+     */
+    addTrack(track: MediaStreamTrack, streams?: MediaStream[], chosen?: RTCRtpTransceiver | null): RTCRtpTransceiver;
+    /**
+   * sender から track を外す。
+   * @returns 交渉が必要な変更をした場合 true (呼び出し側が negotiationneeded を要求する)
+   */
+    removeTrack(sender: RTCRtpSender): boolean;
+    assignTransceiverCodecs(transceiver: RTCRtpTransceiver): void;
+    private filterCodecsByDirection;
+    private validateTrackForTransceiver;
+    getLocalRtpParams(transceiver: RTCRtpTransceiver): RTCRtpParameters;
+    getRemoteRtpParams(media: MediaDescription, transceiver: RTCRtpTransceiver): RTCRtpReceiveParameters;
+    /**
+   * remote offer と local (source constraint + preferences) から
+   * answer 用の codec を再解決し、sender/receiver の codec 状態も
+   * 新しい negotiated codec に同期する。
+   * setCodecPreferences() による無効化後に createAnswer() から呼ばれる。
+   * direction / headerExtensions / onTrack は setRemoteDescription() 時の
+   * まま変えない (track イベントの重複発火を避ける)。
+   */
+    resyncAnswerCodecs(transceiver: RTCRtpTransceiver, remoteMedia: MediaDescription): void;
+    /**
+   * remote offer と local (source constraint + preferences) から
+   * answer 用の codec だけを再解決する (sender/receiver の同期なし)。
+   * setRemoteRTP() の交渉部分として使う。
+   */
+    private resolveRemoteCodecSet;
+    refreshAnswerCodecs(transceiver: RTCRtpTransceiver, remoteMedia: MediaDescription): void;
+    /**
+   * remote SDP の全 audio/video m-line の codec を副作用なしで解決する。
+   * transceiver の対応付けは本適用と同じ resolver を使い、検証と適用の判定をずらさない。
+   * - port 0、停止済み / 停止中の m-line は codec 解決をしない (空)
+   * - local capability と MIME が 1 つも一致しない m-line は空とし、
+   *   offer は setRemoteRTP() で拒否 (port 0 answer)、answer/pranswer は
+   *   SDPManager が InvalidAccessError とする (Issue #705)
+   * - source constraint / preference / pending offer との不一致は NotSupportedError
+   */
+    planRemoteRtpCodecs(remoteSdp: SessionDescription, findTransceiver: (remoteMedia: MediaDescription, index: number) => RTCRtpTransceiver | undefined): Map<number, RTCRtpCodecParameters[]>;
+    /**
+   * remote m-line を transceiver に適用する。
+   * codecs は planRemoteRtpCodecs() で検証済みの解決結果を渡す。
+   * codec が空、または remote port 0 の m-line は拒否として扱い、
+   * sender/receiver 準備・router 登録・onTrack・TWCC を行わない。
+   * @returns 受け入れた (RTP を流す) 場合 true
+   */
+    setRemoteRTP(transceiver: RTCRtpTransceiver, remoteMedia: MediaDescription, type: 'offer' | 'answer' | 'pranswer', mLineIndex: number, codecs: RTCRtpCodecParameters[]): boolean;
+    /**
+   * The signaling state is stable: the media ids and the m-line indexes of the transceivers are kept, given back when
+   * the next local offer is rolled back
+   */
+    markStable(): void;
+    /**
+   * A local offer is rolled back (JSEP 4.1.8.2): the transceivers it gave a media id and an m-line are associated as
+   * before it, the ones added since not at all (an offer of the other side then associates them by their own rules, not
+   * by the media id the rolled back offer gave them)
+   */
+    rollbackLocalOffer(): void;
+    /**
+   * remote offer 適用前の transceiver 対応を保存する。
+   * 同じ offer/answer 交換中に複数回呼ばれても最初の状態を保持する。
+   */
+    beginRemoteOffer(): void;
+    /**
+   * local answer の確定で、拒否予定の m-line を停止・解放する。
+   * remote SDP 起因の停止なので negotiationneeded は要求しない。
+   */
+    commitRemoteOffer(): void;
+    /**remote offer の rollback で transceiver 対応を元に戻す */
+    rollbackRemoteOffer(): void;
+    /**
+   * answer 確定後に、stopping のまま交渉対象になり得ない transceiver の停止を確定する。
+   * (MID が確定済み local description の非ゼロ m-line にない = offer から外れる)
+   * @param negotiatedMids 確定済み local description の非ゼロ port の MID
+   * @returns 次の自分の offer で port 0 を交渉すべき transceiver があるか
+   */
+    settleStoppingTransceivers(negotiatedMids: Set<string>): boolean;
+    collectStats(timestamp: number): RTCStats[];
+    getStatsRootIds(selector: MediaStreamTrack | null | undefined): string[];
+    /**
+   * 全トランシーバーのreceiver/senderのstopを呼ぶcloseメソッド
+   */
+    close(): void;
+}

package/dist/types/lib/peer/transport/dtls.d.ts

@@ -0,0 +1,95 @@
+import { Event } from '../imports/common.js';
+import { type DtlsSocket, type SignatureHash } from '../imports/dtls.js';
+import { type RtcpPacket, type RtpHeader, RtpPacket, SrtcpSession, type SrtpProfile, SrtpSession } from '../imports/rtp.js';
+import { type RTCStats } from '../media/stats.js';
+import { ReceiverTWCC } from '../media/receiver/receiverTwcc.js';
+import { SenderBandwidthEstimator } from '../media/sender/senderBWE.js';
+import type { DebugConfig } from '../peerConnection.js';
+import type { RTCIceTransport } from './ice.js';
+export interface DtlsTransportStats {
+    bytesSent: number;
+    bytesReceived: number;
+    packetsSent: number;
+    packetsReceived: number;
+}
+export declare class RTCDtlsTransport implements DtlsTransportStats {
+    #private;
+    readonly config: {
+        debug?: DebugConfig;
+    };
+    readonly iceTransport: RTCIceTransport;
+    localCertificate?: RTCCertificate | undefined;
+    private readonly srtpProfiles;
+    id: string;
+    state: DtlsState;
+    role: DtlsRole;
+    srtpStarted: boolean;
+    transportSequenceNumber: number;
+    /**The feedback of the packets received with a transport-wide sequence number (of all the streams)*/
+    readonly receiverTWCC: ReceiverTWCC;
+    /**The bandwidth estimated from the feedback of the packets sent with one*/
+    readonly senderBWE: SenderBandwidthEstimator;
+    bytesSent: number;
+    bytesReceived: number;
+    packetsSent: number;
+    packetsReceived: number;
+    dataReceiver: (buf: Buffer) => void;
+    dtls?: DtlsSocket;
+    srtp: SrtpSession;
+    srtcp: SrtcpSession;
+    readonly onStateChange: Event<["connected" | "failed" | "closed" | "connecting" | "new"]>;
+    readonly onRtcp: Event<[RtcpPacket]>;
+    readonly onRtp: Event<[RtpPacket]>;
+    private readonly events;
+    onstatechange?: () => void;
+    static localCertificate?: RTCCertificate;
+    static localCertificatePromise?: Promise<RTCCertificate>;
+    private remoteParameters?;
+    constructor(config: {
+        debug?: DebugConfig;
+    }, iceTransport: RTCIceTransport, localCertificate?: RTCCertificate | undefined, srtpProfiles?: SrtpProfile[]);
+    addEventListener: (type: string, listener: (...args: any[]) => void, options?: boolean | {
+        once?: boolean;
+    }) => void;
+    removeEventListener: (type: string, listener: (...args: any[]) => void) => void;
+    dispatchEvent: (event: globalThis.Event) => boolean;
+    get localParameters(): RTCDtlsParameters;
+    static SetupCertificate(): Promise<RTCCertificate>;
+    setRemoteParams(remoteParameters: RTCDtlsParameters): void;
+    start(): Promise<void>;
+    private verifyRemoteCertificateFingerprint;
+    updateSrtpSession(): void;
+    startSrtp(): void;
+    readonly sendData: (data: Buffer) => Promise<void>;
+    sendRtp(payload: Buffer, header: RtpHeader): Promise<number>;
+    sendRtcp(packets: RtcpPacket[]): Promise<number | undefined>;
+    private setState;
+    stop(): Promise<void>;
+    getStats(timestamp?: number): Promise<RTCStats[]>;
+}
+export declare const DtlsStates: readonly ["new", "connecting", "connected", "closed", "failed"];
+export type DtlsState = (typeof DtlsStates)[number];
+export type DtlsRole = 'auto' | 'server' | 'client';
+export declare class RTCCertificate {
+    certPem: string;
+    signatureHash: SignatureHash;
+    publicKey: string;
+    privateKey: string;
+    constructor(privateKeyPem: string, certPem: string, signatureHash: SignatureHash);
+    getFingerprints(): RTCDtlsFingerprint[];
+}
+export type DtlsKeys = {
+    certPem: string;
+    keyPem: string;
+    signatureHash: SignatureHash;
+};
+export declare class RTCDtlsFingerprint {
+    algorithm: string;
+    value: string;
+    constructor(algorithm: string, value: string);
+}
+export declare class RTCDtlsParameters {
+    fingerprints: RTCDtlsFingerprint[];
+    role: 'auto' | 'client' | 'server';
+    constructor(fingerprints: RTCDtlsFingerprint[] | undefined, role: 'auto' | 'client' | 'server');
+}

package/dist/types/lib/peer/transport/ice.d.ts

@@ -0,0 +1,143 @@
+import { Event } from '../imports/common.js';
+import { Candidate, type IceConnection, type IceOptions } from '../../ice/index.js';
+import { type RTCStats } from '../media/stats.js';
+/**
+ *                                          +------------+
+                                            |            |
+                                            |disconnected|
+                                            |            |
+                                            +------------+
+                                            ^           ^
+                                            |           |
++------+      +----------+      +-----------+      +----------+
+|      |      |          |      |           |      |          |
+| new  | ---> | checking | ---> | connected | ---> | completed|
+|      |      |          |      |           |      |          |
++------+      +----+-----+      +-----------+      +----------+
+                    |
+                    |
+                    v
+                +-------+
+                |       |
+                | failed|
+                |       |
+                +-------+
+ */
+export declare class RTCIceTransport {
+    private iceGather;
+    readonly id: string;
+    connection: IceConnection;
+    state: RTCIceConnectionState;
+    readonly component = "rtp";
+    iceRestarts: number;
+    private checking?;
+    private renominating;
+    private readonly events;
+    onstatechange?: () => void;
+    ongatheringstatechange?: () => void;
+    readonly onStateChange: Event<["disconnected" | "connected" | "failed" | "closed" | "new" | "completed" | "checking"]>;
+    readonly onIceCandidate: Event<[IceCandidate | undefined]>;
+    readonly onNegotiationNeeded: Event<[]>;
+    constructor(iceGather: RTCIceGatherer);
+    addEventListener: (type: string, listener: (...args: any[]) => void, options?: boolean | {
+        once?: boolean;
+    }) => void;
+    removeEventListener: (type: string, listener: (...args: any[]) => void) => void;
+    dispatchEvent: (event: globalThis.Event) => boolean;
+    get role(): "unknown" | "controlling" | "controlled";
+    get gatheringState(): "new" | "complete" | "gathering";
+    get localCandidates(): IceCandidate[];
+    get localParameters(): RTCIceParameters;
+    getRemoteCandidates(): RTCIceCandidate[];
+    getLocalCandidates(): RTCIceCandidate[];
+    getSelectedCandidatePair(): {
+        local: RTCIceCandidate;
+        remote: RTCIceCandidate;
+    } | null;
+    getLocalParameters(): RTCIceParameters;
+    getRemoteParameters(): RTCIceParameters | null;
+    private setState;
+    gather(): Promise<void>;
+    setIceServers(options: Partial<IceOptions>): void;
+    addRemoteCandidate: (candidate?: IceCandidate) => Promise<void>;
+    setRemoteParams(remoteParameters: RTCIceParameters, renomination?: boolean): void;
+    restart(): void;
+    start(): Promise<void>;
+    /**
+     * Run the checks of the ICE session
+     */
+    private check;
+    stop(): Promise<void>;
+    getStats(timestamp?: number, transportId?: string): Promise<RTCStats[]>;
+}
+export declare const IceTransportStates: readonly ["new", "checking", "connected", "completed", "disconnected", "failed", "closed"];
+export type RTCIceConnectionState = (typeof IceTransportStates)[number];
+export declare const IceGathererStates: readonly ["new", "gathering", "complete"];
+export type IceGathererState = (typeof IceGathererStates)[number];
+export declare class RTCIceGatherer {
+    private options;
+    onIceCandidate: (candidate: IceCandidate | undefined) => void;
+    gatheringState: IceGathererState;
+    readonly connection: IceConnection;
+    readonly onGatheringStateChange: Event<["new" | "complete" | "gathering"]>;
+    constructor(options?: Partial<IceOptions>);
+    gather(): Promise<void>;
+    setIceServers(options: Partial<IceOptions>): void;
+    /**
+   * Set gathering state and notify listeners.
+   * ICE restart must use this instead of writing gatheringState directly so
+   * SecureTransportManager can refresh its aggregate iceGatheringState.
+   */
+    setGatheringState(state: IceGathererState): void;
+    get localCandidates(): IceCandidate[];
+    get localParameters(): RTCIceParameters;
+    private setState;
+}
+export declare function candidateFromIce(c: Candidate): IceCandidate;
+export declare function candidateToIce(x: IceCandidate): Candidate;
+export interface RTCIceCandidateInit {
+    candidate?: string;
+    sdpMLineIndex?: number | null;
+    sdpMid?: string | null;
+    usernameFragment?: string | null;
+}
+export declare class RTCIceCandidate {
+    candidate: string;
+    sdpMid?: string;
+    sdpMLineIndex?: number;
+    usernameFragment?: string;
+    constructor(props: Partial<RTCIceCandidate>);
+    static fromSdp(sdp: string): RTCIceCandidate;
+    static isThis(o: any): true | undefined;
+    toJSON(): {
+        candidate: string;
+        sdpMid: string | undefined;
+        sdpMLineIndex: number | undefined;
+        usernameFragment: string | undefined;
+    };
+}
+export declare class IceCandidate {
+    component: number;
+    foundation: string;
+    ip: string;
+    port: number;
+    priority: number;
+    protocol: string;
+    type: string;
+    generation?: number | undefined;
+    ufrag?: string | undefined;
+    relatedAddress?: string;
+    relatedPort?: number;
+    sdpMid?: string;
+    sdpMLineIndex?: number;
+    tcpType?: string;
+    constructor(component: number, foundation: string, ip: string, port: number, priority: number, protocol: string, type: string, generation?: number | undefined, ufrag?: string | undefined);
+    toJSON(): RTCIceCandidate;
+    static fromJSON(data: RTCIceCandidate | RTCIceCandidateInit): IceCandidate | undefined;
+}
+export declare class RTCIceParameters {
+    iceLite: boolean;
+    usernameFragment: string;
+    password: string;
+    constructor(props?: Partial<RTCIceParameters>);
+}

package/dist/types/lib/peer/transport/sctp.d.ts

@@ -0,0 +1,56 @@
+import { Event } from '../imports/common.js';
+import { SCTP, type SCTPOptions } from '../../sctp/index.js';
+import { RTCDataChannel } from '../dataChannel.js';
+import type { RTCDtlsTransport } from './dtls.js';
+export declare const DEFAULT_MAX_MESSAGE_SIZE = 65536;
+export declare class RTCSctpTransport {
+    port: number;
+    maxMessageSize: number;
+    private readonly sctpOptions;
+    dtlsTransport: RTCDtlsTransport;
+    sctp: SCTP;
+    readonly onDataChannel: Event<[RTCDataChannel]>;
+    readonly id: string;
+    mid?: string;
+    mLineIndex?: number;
+    bundled: boolean;
+    dataChannels: {
+        [key: number]: RTCDataChannel;
+    };
+    remoteMaxMessageSize: number;
+    private dataChannelQueue;
+    private dataChannelId?;
+    private eventDisposer;
+    constructor(port?: number, maxMessageSize?: number, sctpOptions?: SCTPOptions);
+    get transport(): RTCDtlsTransport;
+    setDtlsTransport(dtlsTransport: RTCDtlsTransport): void;
+    /**
+     * Keep bytes received out of the receive window while the application holds them (see SCTP.holdReceived)
+     * @param bytes
+     */
+    holdReceived(bytes: number): void;
+    /**
+     * Give back bytes held to the receive window (see SCTP.releaseReceived)
+     * @param bytes
+     */
+    releaseReceived(bytes: number): void;
+    private get isServer();
+    channelByLabel(label: string): RTCDataChannel | undefined;
+    private datachannelReceive;
+    dataChannelAddNegotiated(channel: RTCDataChannel): void;
+    dataChannelOpen(channel: RTCDataChannel): void;
+    private dataChannelFlush;
+    private assertSendableMessageSize;
+    datachannelSend: (channel: RTCDataChannel, data: Buffer | string) => number;
+    getCapabilities(): RTCSctpCapabilities;
+    static getCapabilities(maxMessageSize?: number): RTCSctpCapabilities;
+    setRemoteMaxMessageSize(maxMessageSize?: number): void;
+    setRemotePort(port: number): void;
+    start(remotePort: number): Promise<void>;
+    stop(): Promise<void>;
+    dataChannelClose(channel: RTCDataChannel): void;
+}
+export declare class RTCSctpCapabilities {
+    maxMessageSize: number;
+    constructor(maxMessageSize: number);
+}

package/dist/types/lib/peer/types/domain.d.ts

@@ -0,0 +1,5 @@
+export type Kind = 'audio' | 'video' | 'application' | 'unknown';
+export declare const SignalingStates: readonly ["stable", "have-local-offer", "have-remote-offer", "have-local-pranswer", "have-remote-pranswer", "closed"];
+export type RTCSignalingState = (typeof SignalingStates)[number];
+export declare const ConnectionStates: readonly ["closed", "failed", "disconnected", "new", "connecting", "connected"];
+export type ConnectionState = (typeof ConnectionStates)[number];

package/dist/types/lib/peer/types/util.d.ts

@@ -0,0 +1,2 @@
+export type CallbackWithValue<T> = ((e: T) => void) | ((e: T) => Promise<void>) | null | undefined;
+export type Callback = (() => void) | (() => Promise<void>) | null | undefined;