@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/types/lib/ice/index.d.ts

@@ -0,0 +1,12 @@
+export { randomPort } from '../common/index.js';
+export * from './stun/const.js';
+export * from './stun/tcpFrame.js';
+export * from './stun/tcpProtocol.js';
+export * from './stun/message.js';
+export * from './stun/protocol.js';
+export * from './turn/protocol.js';
+export * from './candidate.js';
+export * from './ice.js';
+export * from './types/model.js';
+export * from './utils.js';
+export * from './iceBase.js';

package/dist/types/lib/ice/internal/selectAddresses.d.ts

@@ -0,0 +1,9 @@
+import type * as os from 'node:os';
+/**
+ * Interface 辞書から host 候補アドレスを選別する（package-private）。
+ * 公開 barrel (`src/index.ts`) からは export しない。
+ * テストは本 helper への依存注入で行う。
+ */
+export declare function selectAddressesFromInterfaces(interfaces: NodeJS.Dict<os.NetworkInterfaceInfo[] | undefined>, family: number, options: {
+    useLinkLocalAddress?: boolean;
+} | undefined, isLinkLocal: (info: os.NetworkInterfaceInfo) => boolean): string[];

package/dist/types/lib/ice/stun/attributes.d.ts

@@ -0,0 +1 @@
+export * from '../../turn/stun/attributes.js';

package/dist/types/lib/ice/stun/const.d.ts

@@ -0,0 +1,8 @@
+export * from '../../turn/stun/const.js';
+/**
+ * Response deadline for ICE connectivity checks over TCP (RFC 6544).
+ * Reliable transports send each STUN request once (RFC 5389 §7.2.2), so this
+ * single wait has to cover the TCP connect of an active candidate as well as
+ * the request/response round trip on a loaded host.
+ */
+export declare const TCP_CHECK_RESPONSE_TIMEOUT_MS = 3000;

package/dist/types/lib/ice/stun/message.d.ts

@@ -0,0 +1 @@
+export * from '../../turn/stun/message.js';

package/dist/types/lib/ice/stun/protocol.d.ts

@@ -0,0 +1,30 @@
+import { Event, UdpTransport } from '../imports/common.js';
+import type { Address, InterfaceAddresses } from '../../common/network.js';
+import type { Candidate } from '../candidate.js';
+import type { Protocol, TransactionRequestOptions } from '../types/model.js';
+import { type Message } from './message.js';
+import { Transaction } from './transaction.js';
+export declare class StunProtocol implements Protocol {
+    static readonly type = "stun";
+    readonly type = "stun";
+    transport: UdpTransport;
+    transactions: {
+        [key: string]: Transaction;
+    };
+    get transactionsKeys(): string[];
+    localCandidate?: Candidate;
+    sentMessage?: Message;
+    localIp?: string;
+    readonly onRequestReceived: Event<[Message, readonly [string, number], Buffer<ArrayBufferLike>]>;
+    readonly onDataReceived: Event<[Buffer<ArrayBufferLike>]>;
+    constructor();
+    connectionMade: (useIpv4: boolean, portRange?: [number, number], interfaceAddresses?: InterfaceAddresses) => Promise<void>;
+    private datagramReceived;
+    getExtraInfo(): Address;
+    sendStun(message: Message, addr: Address): Promise<void>;
+    sendData(data: Buffer, addr: Address): Promise<void>;
+    connectTo(addr: Address): void;
+    disconnect(): void;
+    request(request: Message, addr: Address, integrityKey?: Buffer, retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void): Promise<[Message, readonly [string, number]]>;
+    close(): Promise<void>;
+}

package/dist/types/lib/ice/stun/tcpFrame.d.ts

@@ -0,0 +1,5 @@
+export declare function encodeTcpFrame(data: Buffer): Buffer<ArrayBuffer>;
+export declare function splitTcpFrames(buffer: Buffer): {
+    frames: Buffer<ArrayBufferLike>[];
+    rest: Buffer<ArrayBufferLike>;
+};

package/dist/types/lib/ice/stun/tcpProtocol.d.ts

@@ -0,0 +1,57 @@
+import { type AddressInfo, type Socket } from 'node:net';
+import type { Candidate } from '../candidate.js';
+import { type Address, Event } from '../imports/common.js';
+import type { Protocol, TransactionRequestOptions } from '../types/model.js';
+import { type Message } from './message.js';
+import { Transaction } from './transaction.js';
+type SocketEntry = {
+    socket: Socket;
+    buffer: Buffer;
+    remoteAddr?: Address;
+};
+declare abstract class BaseTcpProtocol implements Protocol {
+    static readonly type = "tcp";
+    readonly type = "tcp";
+    transactions: {
+        [key: string]: Transaction;
+    };
+    localCandidate?: Candidate;
+    sentMessage?: Message;
+    localIp?: string;
+    readonly onRequestReceived: Event<[Message, readonly [string, number], Buffer<ArrayBufferLike>]>;
+    readonly onDataReceived: Event<[Buffer<ArrayBufferLike>]>;
+    /** The connection to this remote address was closed (by either side). */
+    readonly onConnectionClosed: Event<[readonly [string, number]]>;
+    protected readonly sockets: Map<string, SocketEntry>;
+    abstract connectionMade(...args: any[]): Promise<void>;
+    protected abstract getSocket(addr: Address): Promise<SocketEntry>;
+    protected rememberSocket(entry: SocketEntry): void;
+    /** Drop `entry` only if it is still the socket registered for its address. */
+    protected forgetSocket(entry: SocketEntry): boolean;
+    /** Registered socket for `addr`, discarding it if it is already closed. */
+    protected getOpenSocket(addr: Address): SocketEntry | undefined;
+    private dropSocket;
+    protected registerSocket(socket: Socket, remoteAddr?: Address): SocketEntry;
+    private handleFrame;
+    private sendFrame;
+    sendStun(message: Message, addr: Address): Promise<void>;
+    sendData(data: Buffer, addr: Address): Promise<void>;
+    request(request: Message, addr: Address, integrityKey?: Buffer, retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void): Promise<[Message, readonly [string, number]]>;
+    pruneForSelection(remoteAddr?: Address): Promise<void>;
+    get activeSocketCount(): number;
+    get address(): AddressInfo;
+    close(): Promise<void>;
+}
+export declare class TcpActiveProtocol extends BaseTcpProtocol {
+    private readonly pendingSockets;
+    connectionMade(localIp: string): Promise<void>;
+    protected getSocket(addr: Address): Promise<SocketEntry>;
+}
+export declare class TcpPassiveProtocol extends BaseTcpProtocol {
+    private server;
+    connectionMade(localIp: string, portRange?: [number, number]): Promise<void>;
+    protected getSocket(addr: Address): Promise<SocketEntry>;
+    get listeningPort(): number;
+    close(): Promise<void>;
+}
+export {};

package/dist/types/lib/ice/stun/transaction.d.ts

@@ -0,0 +1,75 @@
+import { type Address } from '../imports/common.js';
+import type { Protocol, TransactionRequestOptions } from '../types/model.js';
+import type { Message } from './message.js';
+/**
+ * Resolve a request target to a concrete IP before creating a Transaction so
+ * response source-address checks match the UDP peer address (hostname ≠ IP).
+ *
+ * `family` is the family of the socket that will carry the request: a
+ * hostname resolves only in that family, and an IP literal of the other
+ * family throws AddressFamilyMismatch instead of retransmitting into a send
+ * that cannot succeed. Family 0 means unknown: no preference, no check.
+ */
+export declare function resolveRequestAddress(addr: Address, family?: 0 | 4 | 6): Promise<Address>;
+/**
+ * Normalize legacy positional args and the options-object form into one shape.
+ * Existing callers pass `(retransmissions?, onRequestSent?)`.
+ */
+export declare function normalizeTransactionOptions(retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void): TransactionRequestOptions;
+/**
+ * Compare ICE transport addresses (host, port).
+ * IPv6 literals are compared in canonical form because the socket reports
+ * `::1` even when the peer was configured as `0:0:0:0:0:0:0:1`.
+ */
+export declare function addressEquals(a: Address, b: Address): boolean;
+export declare class Transaction {
+    private request;
+    private addr;
+    private protocol;
+    private timeoutDelay;
+    ended: boolean;
+    private tries;
+    private readonly triesMax;
+    private readonly onResponse;
+    private readonly onRequestSent?;
+    private readonly signal?;
+    private readonly failOnSendError;
+    /** Remote address this transaction was sent to; responses must match. */
+    readonly expectedAddr: Address;
+    /**
+   * When set, protocol layers re-parse the wire response with this key so
+   * MESSAGE-INTEGRITY failures are rejected before responseReceived.
+   */
+    readonly integrityKey?: Buffer;
+    private waitTimer?;
+    private waitResolve?;
+    private onAbort?;
+    constructor(request: Message, addr: Address, protocol: Protocol, retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void);
+    /**
+   * Accept a matching authenticated non-error response from the expected
+   * remote address. Wrong address, missing MESSAGE-INTEGRITY (when required),
+   * or non-success class is rejected without completing the transaction
+   * (wrong address / unauthenticated responses are ignored so we keep waiting).
+   */
+    responseReceived: (message: Message, addr: Address) => void;
+    run: () => Promise<[Message, readonly [string, number]]>;
+    private attachAbortListener;
+    private failWithTimeout;
+    private fail;
+    private clearWait;
+    private wait;
+    private retry;
+    cancel(): void;
+}
+/**
+ * Whether an error response is a challenge of long-term credentials: a 401
+ * or 438 (Stale Nonce) with a new NONCE. A server cannot protect it with the
+ * key of the nonce it rejects, so it comes without MESSAGE-INTEGRITY and the
+ * client retries with the new nonce (RFC 8489, section 9.2.5).
+ */
+export declare function isChallenge(message: Message): boolean;
+/**
+ * Build Transaction options for Protocol.request, folding integrityKey into
+ * options so response path can re-verify MESSAGE-INTEGRITY.
+ */
+export declare function buildTransactionOptions(integrityKey: Buffer | undefined, retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void): TransactionRequestOptions;

package/dist/types/lib/ice/turn/frame.d.ts

@@ -0,0 +1 @@
+export * from '../../turn/turn/frame.js';

package/dist/types/lib/ice/turn/protocol.d.ts

@@ -0,0 +1,170 @@
+import type { Candidate } from '../candidate.js';
+import { type Address, Event, type InterfaceAddresses, type TlsConnectionOptions, type Transport } from '../imports/common.js';
+import { Message } from '../stun/message.js';
+import { Transaction } from '../stun/transaction.js';
+import type { Protocol, TransactionRequestOptions } from '../types/model.js';
+/** Channel binding state for a single peer transport address. */
+export interface TurnChannel {
+    number: number;
+    address: Address;
+    /** Unix seconds when this channel should be refreshed. */
+    refreshAt: number;
+}
+export declare class StunOverTurnProtocol implements Protocol {
+    turn: TurnProtocol;
+    static type: string;
+    readonly type: string;
+    localCandidate: Candidate;
+    private disposer;
+    onRequestReceived: Event<[Message, Address, Buffer]>;
+    onDataReceived: Event<[Buffer]>;
+    constructor(turn: TurnProtocol);
+    private handleStunMessage;
+    request(request: Message, addr: Address, integrityKey?: Buffer, retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void): Promise<[Message, readonly [string, number]]>;
+    connectionMade(): Promise<void>;
+    sendData(data: Buffer, addr: Address): Promise<void>;
+    sendStun(message: Message, addr: Address): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class TurnProtocol implements Protocol {
+    /** TURN server as configured; the host may be a hostname. */
+    server: Address;
+    username: string;
+    password: string;
+    lifetime: number;
+    transport: Transport;
+    options: {
+        /**sec */
+        channelRefreshTime?: number;
+    };
+    static type: string;
+    readonly type: string;
+    readonly onData: Event<[Buffer<ArrayBufferLike>, readonly [string, number]]>;
+    onRequestReceived: Event<[Message, Address, Buffer]>;
+    onDataReceived: Event<[Buffer]>;
+    integrityKey?: Buffer;
+    nonce?: Buffer;
+    realm?: string;
+    relayedAddress: Address;
+    mappedAddress: Address;
+    localCandidate: Candidate;
+    transactions: {
+        [hexId: string]: Transaction;
+    };
+    /**When the allocation expires unless refreshed (ms since epoch), 0 when there is none */
+    private expiresAt;
+    private refreshHandle?;
+    private channelNumber;
+    private channelByAddr;
+    private addrByChannel;
+    /**sec */
+    private channelRefreshTime;
+    /**
+   * Serializes ChannelBind requests so allocation-wide auth state
+   * (nonce/realm/integrityKey) is not updated concurrently. Rejections
+   * must not poison this tail — see channelBindQueue assignment sites.
+   */
+    private channelBindQueue;
+    /** In-flight ChannelBind per peer transport address (dedupe concurrent). */
+    private channelBindingByAddr;
+    private tcpBuffer;
+    /** Permission cache keyed by peer IP only (RFC 8656). */
+    private permissionByAddr;
+    /**
+   * Serializes CreatePermission requests (auth state race avoidance).
+   * Rejections must not poison this tail.
+   */
+    private permissionQueue;
+    /** In-flight CreatePermission per peer IP (dedupe concurrent). */
+    private creatingPermissionByAddr;
+    /** Concrete TURN server address the allocation lives on, once selected. */
+    private pinnedServerEndpoint?;
+    private serverEndpointSelection?;
+    constructor(
+    /** TURN server as configured; the host may be a hostname. */
+    server: Address, username: string, password: string, lifetime: number, transport: Transport, options?: {
+        /**sec */
+        channelRefreshTime?: number;
+    });
+    connectionMade(): Promise<void>;
+    private handleChannelData;
+    private handleSTUNMessage;
+    private dataReceived;
+    private send;
+    private createPermission;
+    private refresh;
+    request(request: Message, addr: Address, _integrityKey?: Buffer, retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void): Promise<[Message, Address]>;
+    /**
+   * The concrete TURN server address, selected on the first request and
+   * pinned for the rest of the allocation, so a later DNS answer can never
+   * move REFRESH, CREATE_PERMISSION, CHANNEL_BIND or data to another server.
+   */
+    get serverEndpoint(): Address | undefined;
+    /**
+   * Address a request to `addr` is sent to, and the address its response
+   * must come from. A stream carries every request to the peer it is
+   * connected to, so it always uses the server endpoint.
+   */
+    private resolveRequestTarget;
+    private serverDestination;
+    private selectServerEndpoint;
+    /**
+   * UDP: resolve the configured server in the bound socket's family; a udp4
+   * socket cannot send to an IPv6 answer. TCP/TLS: use the peer the socket
+   * actually connected to. Looking the hostname up again could return a
+   * different A/AAAA record, and responses from the real peer would then be
+   * dropped as coming from an unexpected address.
+   */
+    private resolveServerEndpoint;
+    requestWithRetry(request: Message, addr: Address, signal?: AbortSignal): Promise<[Message, Address]>;
+    sendData(data: Buffer, addr: Address): Promise<void>;
+    /**
+   * Ensure a CreatePermission exists for the peer IP.
+   * Peer failures are isolated: a rejection for peer A does not poison peer B.
+   */
+    getPermission(addr: Address): Promise<void>;
+    /**
+   * Ensure a ChannelBind exists for the peer transport address.
+   * Peer failures are isolated; concurrent same-peer calls share one Promise.
+   */
+    getChannel(addr: Address): Promise<TurnChannel>;
+    /**
+   * Create or refresh a channel for addr. Provisional mapping is installed
+   * before the request so early ChannelData can be decoded; only a failed
+   * *initial* bind rolls the mapping back. Failed channel numbers are never
+   * reused.
+   */
+    private ensureChannel;
+    private channelBind;
+    sendStun(message: Message, addr: Address): Promise<void>;
+    /**
+   * Refresh the allocation now.
+   * @returns Whether the server still has it.
+   */
+    refreshAllocation(): Promise<boolean>;
+    close(): Promise<void>;
+}
+export interface TurnClientConfig {
+    address: Address;
+    username: string;
+    password: string;
+}
+export interface TurnClientOptions {
+    lifetime?: number;
+    ssl?: boolean;
+    transport?: 'udp' | 'tcp' | 'tls';
+    tlsOptions?: TlsConnectionOptions;
+    portRange?: [number, number];
+    interfaceAddresses?: InterfaceAddresses;
+    /** Maximum time to wait for TCP/TLS connection establishment, in milliseconds. */
+    connectTimeoutMs?: number;
+    /**
+   * Preferred IP family of the UDP socket, applied only when the server
+   * address is a hostname. Ignored for an IP literal server address, whose
+   * own family always selects the socket. Defaults to 4.
+   */
+    udpFamily?: 4 | 6;
+}
+export declare function createTurnClient({ address, username, password }: TurnClientConfig, { lifetime, portRange, interfaceAddresses, ssl, tlsOptions, transport: transportType, connectTimeoutMs, udpFamily }?: TurnClientOptions): Promise<TurnProtocol>;
+export declare function createStunOverTurnClient(config: TurnClientConfig, options?: TurnClientOptions): Promise<StunOverTurnProtocol>;
+export declare function makeIntegrityKey(username: string, realm: string, password: string): NonSharedBuffer;

package/dist/types/lib/ice/types/model.d.ts

@@ -0,0 +1,56 @@
+import type { Candidate } from '../candidate.js';
+import type { Address, Event } from '../imports/common.js';
+import type { Message } from '../stun/message.js';
+/**
+ * Options for a STUN transaction / Protocol.request.
+ * Retransmission count and response wait deadline are independent
+ * so consent freshness (retransmissions: 0, longer timeout) can be expressed.
+ */
+export interface TransactionRequestOptions {
+    /** Number of retransmissions after the initial send. 0 = send once. */
+    retransmissions?: number;
+    /**
+   * Initial response wait deadline in milliseconds.
+   * Doubled after each retransmission when retransmissions > 0.
+   * Defaults to RETRY_RTO when omitted.
+   */
+    responseTimeout?: number;
+    /** Called for each wire send (attempt 0 is the initial transmission). */
+    onRequestSent?: (attempt: number) => void;
+    /** Abort the outstanding transaction (e.g. consent lifecycle teardown). */
+    signal?: AbortSignal;
+    /**
+   * Fail the transaction as soon as the request cannot be sent instead of
+   * waiting for the response timeout. Used on reliable transports (TCP),
+   * where a send error means the connection itself is unusable.
+   */
+    failOnSendError?: boolean;
+    /**
+   * When set, responses must include MESSAGE-INTEGRITY and pass HMAC
+   * verification (protocol re-parses the wire bytes with this key; the
+   * transaction also rejects unsigned Messages as defense-in-depth).
+   * Unsigned or forged responses must not complete the transaction.
+   */
+    integrityKey?: Buffer;
+}
+export interface Protocol {
+    type: string;
+    onRequestReceived: Event<[Message, Address, Buffer]>;
+    onDataReceived: Event<[Buffer]>;
+    /** Connection-oriented protocols: the connection to this remote address is gone. */
+    onConnectionClosed?: Event<[Address]>;
+    request: (message: Message, addr: Address, integrityKey?: Buffer, retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void) => Promise<[Message, Address]>;
+    close: () => Promise<void>;
+    connectionMade: (...args: any) => Promise<void>;
+    sendStun: (message: Message, addr: Address) => Promise<void>;
+    sendData: (data: Buffer, addr: Address) => Promise<void>;
+    /** A socket of its own: send only to the address of the pair selected, once a packet comes from it. */
+    connectTo?: (addr: Address) => void;
+    /** A socket of its own: send to any address again. */
+    disconnect?: () => void;
+    localCandidate?: Candidate;
+    sentMessage?: Message;
+    responseAddr?: Address;
+    responseMessage?: string;
+    localIp?: string;
+}

package/dist/types/lib/ice/utils.d.ts

@@ -0,0 +1,13 @@
+import * as os from 'node:os';
+import { type Address, type InterfaceAddresses } from './imports/common.js';
+export declare function getGlobalIp(stunServer: Address, interfaceAddresses?: InterfaceAddresses): Promise<string>;
+export declare function isLinkLocalAddress(info: os.NetworkInterfaceInfo): boolean;
+export declare function nodeIpAddress(family: number, { useLinkLocalAddress }?: {
+    /** such as google cloud run */
+    useLinkLocalAddress?: boolean;
+}): string[];
+export declare function getHostAddresses(useIpv4: boolean, useIpv6: boolean, options?: {
+    /** such as google cloud run */
+    useLinkLocalAddress?: boolean;
+}): string[];
+export declare const url2Address: (url?: string) => readonly [string, number] | undefined;

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

@@ -0,0 +1,36 @@
+import { type HashAlgorithms, SignatureAlgorithm } from './imports/dtls.js';
+import type { DtlsRole } from './transport/dtls.js';
+export declare const DATA_CHANNEL_ACK = 2;
+export declare const DATA_CHANNEL_OPEN = 3;
+export declare const DATA_CHANNEL_RELIABLE = 0;
+export declare const DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT = 1;
+export declare const DATA_CHANNEL_PARTIAL_RELIABLE_TIMED = 2;
+export declare const DATA_CHANNEL_RELIABLE_UNORDERED = 128;
+export declare const DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT_UNORDERED = 129;
+export declare const DATA_CHANNEL_PARTIAL_RELIABLE_TIMED_UNORDERED = 130;
+export declare const WEBRTC_DCEP = 50;
+export declare const WEBRTC_STRING = 51;
+export declare const WEBRTC_BINARY = 53;
+export declare const WEBRTC_STRING_EMPTY = 56;
+export declare const WEBRTC_BINARY_EMPTY = 57;
+export declare const DISCARD_HOST = "0.0.0.0";
+export declare const DISCARD_PORT = 9;
+export declare const MEDIA_KINDS: string[];
+export declare const DIRECTIONS: string[];
+export declare const DTLS_ROLE_SETUP: {
+    auto: string;
+    client: string;
+    server: string;
+};
+export declare const DTLS_SETUP_ROLE: {
+    [key: string]: DtlsRole;
+};
+export declare const FMTP_INT_PARAMETERS: string[];
+export declare const SSRC_INFO_ATTRS: string[];
+export declare const SRTP_PROFILE: {
+    readonly SRTP_AES128_CM_HMAC_SHA1_80: 1;
+    readonly SRTP_AEAD_AES_128_GCM: 7;
+};
+export declare const SenderDirections: string[];
+export declare const ReceiverDirection: string[];
+export { type HashAlgorithms, SignatureAlgorithm };

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

@@ -0,0 +1,69 @@
+import { Event } from './imports/common.js';
+import { EventTarget } from './helper.js';
+import type { RTCSctpTransport } from './transport/sctp.js';
+import type { Callback, CallbackWithValue } from './types/util.js';
+export interface DataChannelStats {
+    messagesSent: number;
+    bytesSent: number;
+    messagesReceived: number;
+    bytesReceived: number;
+}
+export declare function getDataChannelMessageSize(data: Buffer | string): number;
+export declare class RTCDataChannel extends EventTarget implements DataChannelStats {
+    readonly sctp: RTCSctpTransport;
+    private readonly parameters;
+    readonly sendOpen: boolean;
+    readonly statsId: string;
+    readonly stateChange: Event<[DCState]>;
+    readonly stateChanged: Event<[DCState]>;
+    readonly onMessage: Event<[string | Buffer<ArrayBufferLike>]>;
+    readonly error: Event<[Error]>;
+    readonly bufferedAmountLow: Event<any[]>;
+    /**the amount buffered changed (a message queued, or sent): read by a worker thread serving the channel */
+    readonly bufferedAmountChanged: Event<any[]>;
+    onopen?: Callback;
+    onclose?: Callback;
+    onclosing?: Callback;
+    onmessage?: CallbackWithValue<MessageEvent>;
+    onerror?: CallbackWithValue<RTCErrorEvent>;
+    isCreatedByRemote: boolean;
+    id: number;
+    readyState: DCState;
+    bufferedAmount: number;
+    private _bufferedAmountLowThreshold;
+    messagesSent: number;
+    bytesSent: number;
+    messagesReceived: number;
+    bytesReceived: number;
+    constructor(sctp: RTCSctpTransport, parameters: RTCDataChannelParameters, sendOpen?: boolean);
+    get ordered(): boolean;
+    get maxRetransmits(): number | null;
+    get maxPacketLifeTime(): number | null;
+    get label(): string;
+    get protocol(): string;
+    get negotiated(): boolean;
+    get bufferedAmountLowThreshold(): number;
+    set bufferedAmountLowThreshold(value: number);
+    setId(id: number): void;
+    setReadyState(state: DCState): void;
+    addBufferedAmount(amount: number): void;
+    send(data: Buffer | string): void;
+    close(): void;
+}
+export type DCState = 'open' | 'closed' | 'connecting' | 'closing';
+export declare class RTCDataChannelParameters {
+    label: string;
+    maxPacketLifeTime?: number;
+    maxRetransmits?: number;
+    ordered: boolean;
+    protocol: string;
+    negotiated: boolean;
+    id: number;
+    constructor(props?: Partial<RTCDataChannelParameters>);
+}
+export interface MessageEvent {
+    data: string | Buffer;
+}
+export interface RTCErrorEvent {
+    error: any;
+}

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

@@ -0,0 +1,11 @@
+export type WebRtcDomExceptionName = 'AbortError' | 'InvalidAccessError' | 'InvalidModificationError' | 'InvalidStateError' | 'NotAllowedError' | 'NotFoundError' | 'NotReadableError' | 'NotSupportedError' | 'OperationError';
+export declare function createWebRtcDomException(name: WebRtcDomExceptionName, message?: string): DOMException;
+export declare function createWebRtcTypeError(message: string): TypeError;
+/**
+ * Media Capture and Streams `OverconstrainedError`.
+ * WPT `overconstrainederror.html` requires a DOMException subclass with `constraint`.
+ */
+export declare class OverconstrainedError extends DOMException {
+    readonly constraint: string;
+    constructor(constraint: string, message?: string);
+}

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

@@ -0,0 +1,20 @@
+import { EventEmitter } from 'node:events';
+export declare function enumerate<T>(arr: T[]): [number, T][];
+export declare function divide(from: string, split: string): [string, string];
+export declare class PromiseQueue {
+    queue: {
+        promise: () => Promise<any>;
+        done: () => void;
+    }[];
+    running: boolean;
+    push: (promise: () => Promise<any>) => Promise<void>;
+    private run;
+}
+export declare class EventTarget extends EventEmitter {
+    emit(type: string | symbol, ...args: any[]): boolean;
+    addEventListener: (type: string, listener: (...args: any[]) => void, options?: boolean | {
+        once?: boolean;
+    }) => void;
+    removeEventListener: (type: string, listener: (...args: any[]) => void) => void;
+    dispatchEvent: (event: Event) => boolean;
+}

package/dist/types/lib/peer/imports/common.d.ts

@@ -0,0 +1 @@
+export * from '../../common/index.js';

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

@@ -0,0 +1 @@
+export * from '../../dtls/index.js';

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

@@ -0,0 +1 @@
+export * from '../../ice/index.js';

package/dist/types/lib/peer/imports/rtp.d.ts

@@ -0,0 +1 @@
+export * from '../../rtp/index.js';

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

@@ -0,0 +1,14 @@
+export * from './imports/common.js';
+export * from './imports/dtls.js';
+export * from './imports/ice.js';
+export * from './imports/rtp.js';
+export * from './dataChannel.js';
+export * from './media/index.js';
+export * from './peerConnection.js';
+export * from './sdp.js';
+export * from './transport/dtls.js';
+export * from './transport/ice.js';
+export * from './transport/sctp.js';
+export * from './types/domain.js';
+export * from './utils.js';
+export * from './sdpManager.js';

package/dist/types/lib/peer/media/codec.d.ts

@@ -0,0 +1,15 @@
+import { RTCRtpCodecParameters } from './parameters.js';
+export declare const useH264: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare const useVP8: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare const useVP9: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare const useAV1X: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare const useOPUS: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare const usePCMU: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare function defaultCodecs(): {
+    audio: RTCRtpCodecParameters[];
+    video: RTCRtpCodecParameters[];
+};
+export declare function cloneCodecParameters(codec: RTCRtpCodecParameters): RTCRtpCodecParameters;
+export declare const supportedCodecs: string[];
+export declare const supportedVideoCodecs: string[];
+export declare const supportedAudioCodecs: string[];