@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/lib/ice/iceBase.d.ts

@@ -0,0 +1,214 @@
+import { Candidate } from './candidate.js';
+import type { MdnsLookup } from './dns/lookup.js';
+import type { Cancelable } from './helper.js';
+import { type Address, type Event, type InterfaceAddresses, type TlsConnectionOptions } from './imports/common.js';
+import { Message } from './stun/message.js';
+import type { Protocol } from './types/model.js';
+export interface IceConnection {
+    iceLite: boolean;
+    iceControlling: boolean;
+    localUsername: string;
+    localPassword: string;
+    remotePassword: string;
+    remoteUsername: string;
+    remoteIsLite: boolean;
+    checkList: CandidatePair[];
+    localCandidates: Candidate[];
+    remoteCandidates: Candidate[];
+    candidatePairs: CandidatePair[];
+    stunServer?: Address;
+    turnServer?: Address;
+    generation: number;
+    options: IceOptions;
+    remoteCandidatesEnd: boolean;
+    localCandidatesEnd: boolean;
+    state: IceState;
+    lookup?: MdnsLookup;
+    nominated?: CandidatePair;
+    readonly onData: Event<[Buffer]>;
+    readonly stateChanged: Event<[IceState]>;
+    readonly onIceCandidate: Event<[Candidate]>;
+    restart(): Promise<void>;
+    setIceServers(options: Partial<IceOptions>): void;
+    setRemoteParams(params: {
+        iceLite: boolean;
+        usernameFragment: string;
+        password: string;
+    }): void;
+    gatherCandidates(): Promise<void>;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    addRemoteCandidate(remoteCandidate: Candidate | undefined): Promise<void>;
+    send(data: Buffer): Promise<void>;
+    getDefaultCandidate(): Candidate | undefined;
+    resetNominatedPair(): void;
+}
+export interface CandidatePairStats {
+    packetsSent: number;
+    packetsReceived: number;
+    bytesSent: number;
+    bytesReceived: number;
+    rtt?: number;
+    totalRoundTripTime: number;
+    roundTripTimeMeasurements: number;
+    requestsReceived: number;
+    requestsSent: number;
+    responsesReceived: number;
+    responsesSent: number;
+    retransmissionsReceived: number;
+    retransmissionsSent: number;
+    consentRequestsSent: number;
+}
+export declare class CandidatePair implements CandidatePairStats {
+    protocol: Protocol;
+    remoteCandidate: Candidate;
+    iceControlling: boolean;
+    readonly id: string;
+    handle?: Cancelable<void>;
+    nominated: boolean;
+    remoteNominated: boolean;
+    private _state;
+    get state(): CandidatePairState;
+    packetsSent: number;
+    packetsReceived: number;
+    bytesSent: number;
+    bytesReceived: number;
+    rtt?: number;
+    totalRoundTripTime: number;
+    roundTripTimeMeasurements: number;
+    requestsReceived: number;
+    requestsSent: number;
+    responsesReceived: number;
+    responsesSent: number;
+    retransmissionsReceived: number;
+    retransmissionsSent: number;
+    consentRequestsSent: number;
+    private readonly requestTransactionIds;
+    toJSON(): {
+        protocol: string;
+        localCandidate: string;
+        remoteCandidate: string;
+    };
+    get json(): {
+        protocol: string;
+        localCandidate: string;
+        remoteCandidate: string;
+    };
+    constructor(protocol: Protocol, remoteCandidate: Candidate, iceControlling: boolean);
+    updateState(state: CandidatePairState): void;
+    get localCandidate(): Candidate;
+    get remoteAddr(): Address;
+    get component(): number;
+    get priority(): number;
+    get foundation(): string;
+    noteIncomingRequest(transactionId: string): boolean;
+}
+export declare const ICE_COMPLETED: 1;
+export declare const ICE_FAILED: 2;
+/** Basic consent check period in seconds (RFC 7675). Actual interval is 0.8–1.2× this. */
+export declare const CONSENT_INTERVAL = 5;
+/**
+ * @deprecated Consent expiry is based on {@link CONSENT_TIMEOUT} (30s after the
+ * last valid response), not a consecutive failure count. Kept for API compatibility.
+ */
+export declare const CONSENT_FAILURES = 6;
+/** RFC 7675: consent expires this many seconds after the last valid response. */
+export declare const CONSENT_TIMEOUT = 30;
+/**
+ * Default single-shot response wait for consent requests (ms) when RTT is unknown.
+ * Independent of retransmission count. Downstream ICE-lite peers typically
+ * answer in 150–300ms; 1s is a conservative default used by interop patches.
+ */
+export declare const CONSENT_RESPONSE_TIMEOUT = 1000;
+/** RFC 8445 §14.3: ICE RTO must not be less than 500ms. */
+export declare const CONSENT_RESPONSE_TIMEOUT_MIN = 500;
+/**
+ * Compute consent response wait from pair RTT (seconds).
+ * Uses 2×RTT + 200ms jitter margin, floored at {@link CONSENT_RESPONSE_TIMEOUT_MIN}.
+ * Falls back to {@link CONSENT_RESPONSE_TIMEOUT} when RTT is unavailable.
+ */
+export declare function consentResponseTimeoutMs(rttSeconds?: number): number;
+export declare enum CandidatePairState {
+    FROZEN = 0,
+    WAITING = 1,
+    IN_PROGRESS = 2,
+    SUCCEEDED = 3,
+    FAILED = 4
+}
+export type IceState = 'disconnected' | 'closed' | 'completed' | 'new' | 'connected' | 'failed';
+export interface IceOptions {
+    /** Advertise and operate as an ICE lite agent. */
+    iceLite: boolean;
+    useTcp: boolean;
+    /**
+   * Gather passive TCP host candidates (opens a listening TCP server per
+   * interface). Defaults to true. Send-only agents that never accept inbound
+   * connections can set this false to avoid the listener while still gathering
+   * active TCP candidates.
+   */
+    tcpPassive?: boolean;
+    /**
+   * Seconds to wait for server-reflexive candidates while gathering.
+   * Defaults to 5. Where UDP is blocked these STUN queries are never answered,
+   * so the wait always runs to the timeout; agents that must not stall on such
+   * networks can lower it.
+   */
+    stunGatherTimeout?: number;
+    /**
+   * Seconds to wait for a TURN TCP/TLS connection to be established.
+   * Defaults to 8.
+   */
+    turnConnectTimeout?: number;
+    stunServer?: Address;
+    turnServer?: Address;
+    turnUsername?: string;
+    turnPassword?: string;
+    turnTransport?: 'udp' | 'tcp' | 'tls';
+    /**
+   * More STUN servers, queried as stunServer is: each one that answers gives
+   * a server reflexive candidate (the same address only once).
+   */
+    stunServers?: Address[];
+    /**
+   * More TURN servers, used as turnServer is: one relay candidate per server.
+   * The entries of a host are the transports of one server, tried in order.
+   */
+    turnServers?: TurnServerOptions[];
+    turnTlsOptions?: TlsConnectionOptions;
+    /**
+   * Preferred IP family of the TURN/UDP socket, applied only when turnServer
+   * is a hostname. Ignored for an IP literal turnServer, whose own family
+   * always selects the socket. Defaults to 4.
+   */
+    turnUdpFamily?: 4 | 6;
+    forceTurn?: boolean;
+    localPasswordPrefix?: string;
+    useIpv4: boolean;
+    useIpv6: boolean;
+    useLinkLocalAddress?: boolean;
+    portRange?: [number, number];
+    interfaceAddresses?: InterfaceAddresses;
+    additionalHostAddresses?: string[];
+    filterStunResponse?: (message: Message, addr: Address, protocol: Protocol) => boolean;
+    filterCandidatePair?: (pair: CandidatePair) => boolean;
+}
+/** A TURN server, reached with one transport. */
+export interface TurnServerOptions {
+    address: Address;
+    username: string;
+    password: string;
+    /** UDP when undefined, with TCP when UDP fails. */
+    transport?: 'udp' | 'tcp' | 'tls';
+}
+export declare const defaultOptions: IceOptions;
+export declare function validateRemoteCandidate(candidate: Candidate): Candidate;
+export declare function sortCandidatePairs(pairs: {
+    localCandidate: Pick<Candidate, 'priority'>;
+    remoteCandidate: Pick<Candidate, 'priority'>;
+}[], iceControlling: boolean): {
+    localCandidate: Pick<Candidate, "priority">;
+    remoteCandidate: Pick<Candidate, "priority">;
+}[];
+export declare function candidatePairPriority(local: Pick<Candidate, 'priority'>, remote: Pick<Candidate, 'priority'>, iceControlling: boolean): number;
+export declare function serverReflexiveCandidate(protocol: Protocol, stunServer: Address): Promise<Candidate | undefined>;
+export declare function validateAddress(addr?: Address): Address | undefined;

package/dist/cjs/lib/ice/iceBase.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOptions = exports.CandidatePairState = exports.CONSENT_RESPONSE_TIMEOUT_MIN = exports.CONSENT_RESPONSE_TIMEOUT = exports.CONSENT_TIMEOUT = exports.CONSENT_FAILURES = exports.CONSENT_INTERVAL = exports.ICE_FAILED = exports.ICE_COMPLETED = exports.CandidatePair = void 0;
+exports.consentResponseTimeoutMs = consentResponseTimeoutMs;
+exports.validateRemoteCandidate = validateRemoteCandidate;
+exports.sortCandidatePairs = sortCandidatePairs;
+exports.candidatePairPriority = candidatePairPriority;
+exports.serverReflexiveCandidate = serverReflexiveCandidate;
+exports.validateAddress = validateAddress;
+const node_crypto_1 = require("node:crypto");
+const candidate_js_1 = require("./candidate.js");
+const common_js_1 = require("./imports/common.js");
+const const_js_1 = require("./stun/const.js");
+const message_js_1 = require("./stun/message.js");
+const log = (0, common_js_1.debug)('webrtc/ice/iceBase:log');
+class CandidatePair {
+    get state() {
+        return this._state;
+    }
+    toJSON() {
+        return this.json;
+    }
+    get json() {
+        return {
+            protocol: this.protocol.type,
+            localCandidate: this.localCandidate.toSdp(),
+            remoteCandidate: this.remoteCandidate.toSdp()
+        };
+    }
+    constructor(protocol, remoteCandidate, iceControlling) {
+        this.protocol = protocol;
+        this.remoteCandidate = remoteCandidate;
+        this.iceControlling = iceControlling;
+        this.id = (0, node_crypto_1.randomUUID)().toString();
+        this.nominated = false;
+        this.remoteNominated = false;
+        // 5.7.4.  Computing States
+        this._state = CandidatePairState.FROZEN;
+        // Statistics tracking
+        this.packetsSent = 0;
+        this.packetsReceived = 0;
+        this.bytesSent = 0;
+        this.bytesReceived = 0;
+        this.totalRoundTripTime = 0;
+        this.roundTripTimeMeasurements = 0;
+        this.requestsReceived = 0;
+        this.requestsSent = 0;
+        this.responsesReceived = 0;
+        this.responsesSent = 0;
+        this.retransmissionsReceived = 0;
+        this.retransmissionsSent = 0;
+        this.consentRequestsSent = 0;
+        this.requestTransactionIds = new Set();
+    }
+    updateState(state) {
+        this._state = state;
+    }
+    get localCandidate() {
+        if (!this.protocol.localCandidate) {
+            throw new Error('localCandidate not exist');
+        }
+        return this.protocol.localCandidate;
+    }
+    get remoteAddr() {
+        return [this.remoteCandidate.host, this.remoteCandidate.port];
+    }
+    get component() {
+        return this.localCandidate.component;
+    }
+    get priority() {
+        return candidatePairPriority(this.localCandidate, this.remoteCandidate, this.iceControlling);
+    }
+    get foundation() {
+        return this.localCandidate.foundation;
+    }
+    noteIncomingRequest(transactionId) {
+        const isRetransmission = this.requestTransactionIds.has(transactionId);
+        if (!isRetransmission) {
+            this.requestTransactionIds.add(transactionId);
+            return false;
+        }
+        this.retransmissionsReceived++;
+        return true;
+    }
+}
+exports.CandidatePair = CandidatePair;
+exports.ICE_COMPLETED = 1;
+exports.ICE_FAILED = 2;
+/** Basic consent check period in seconds (RFC 7675). Actual interval is 0.8–1.2× this. */
+exports.CONSENT_INTERVAL = 5;
+/**
+ * @deprecated Consent expiry is based on {@link CONSENT_TIMEOUT} (30s after the
+ * last valid response), not a consecutive failure count. Kept for API compatibility.
+ */
+exports.CONSENT_FAILURES = 6;
+/** RFC 7675: consent expires this many seconds after the last valid response. */
+exports.CONSENT_TIMEOUT = 30;
+/**
+ * Default single-shot response wait for consent requests (ms) when RTT is unknown.
+ * Independent of retransmission count. Downstream ICE-lite peers typically
+ * answer in 150–300ms; 1s is a conservative default used by interop patches.
+ */
+exports.CONSENT_RESPONSE_TIMEOUT = 1000;
+/** RFC 8445 §14.3: ICE RTO must not be less than 500ms. */
+exports.CONSENT_RESPONSE_TIMEOUT_MIN = 500;
+/**
+ * Compute consent response wait from pair RTT (seconds).
+ * Uses 2×RTT + 200ms jitter margin, floored at {@link CONSENT_RESPONSE_TIMEOUT_MIN}.
+ * Falls back to {@link CONSENT_RESPONSE_TIMEOUT} when RTT is unavailable.
+ */
+function consentResponseTimeoutMs(rttSeconds) {
+    if (rttSeconds === undefined ||
+        !Number.isFinite(rttSeconds) ||
+        rttSeconds <= 0) {
+        return exports.CONSENT_RESPONSE_TIMEOUT;
+    }
+    return Math.max(exports.CONSENT_RESPONSE_TIMEOUT_MIN, Math.round(rttSeconds * 1000 * 2 + 200));
+}
+var CandidatePairState;
+(function (CandidatePairState) {
+    CandidatePairState[CandidatePairState["FROZEN"] = 0] = "FROZEN";
+    CandidatePairState[CandidatePairState["WAITING"] = 1] = "WAITING";
+    CandidatePairState[CandidatePairState["IN_PROGRESS"] = 2] = "IN_PROGRESS";
+    CandidatePairState[CandidatePairState["SUCCEEDED"] = 3] = "SUCCEEDED";
+    CandidatePairState[CandidatePairState["FAILED"] = 4] = "FAILED";
+})(CandidatePairState || (exports.CandidatePairState = CandidatePairState = {}));
+exports.defaultOptions = {
+    iceLite: false,
+    useTcp: false,
+    useIpv4: true,
+    useIpv6: true
+};
+function validateRemoteCandidate(candidate) {
+    // """
+    // Check the remote candidate is supported.
+    // """
+    if (!['host', 'relay', 'srflx'].includes(candidate.type))
+        throw new Error(`Unexpected candidate type "${candidate.type}"`);
+    // ipaddress.ip_address(candidate.host)
+    return candidate;
+}
+function sortCandidatePairs(pairs, iceControlling) {
+    return pairs
+        .sort((a, b) => candidatePairPriority(a.localCandidate, a.remoteCandidate, iceControlling) -
+        candidatePairPriority(b.localCandidate, b.remoteCandidate, iceControlling))
+        .reverse();
+}
+// 5.7.2.  Computing Pair Priority and Ordering Pairs
+function candidatePairPriority(local, remote, iceControlling) {
+    const G = (iceControlling && local.priority) || remote.priority;
+    const D = (iceControlling && remote.priority) || local.priority;
+    return (1 << 32) * Math.min(G, D) + 2 * Math.max(G, D) + (G > D ? 1 : 0);
+}
+async function serverReflexiveCandidate(protocol, stunServer) {
+    // """
+    // Query STUN server to obtain a server-reflexive candidate.
+    // """
+    // # perform STUN query
+    const request = new message_js_1.Message(const_js_1.methods.BINDING, const_js_1.classes.REQUEST);
+    try {
+        const [response] = await protocol.request(request, stunServer);
+        const localCandidate = protocol.localCandidate;
+        if (!localCandidate) {
+            throw new Error('not exist');
+        }
+        const candidate = new candidate_js_1.Candidate((0, candidate_js_1.candidateFoundation)('srflx', localCandidate.transport, localCandidate.host, stunServer[0]), localCandidate.component, localCandidate.transport, (0, candidate_js_1.candidatePriority)('srflx', {
+            transport: localCandidate.transport,
+            tcptype: localCandidate.tcptype
+        }), response.getAttributeValue('XOR-MAPPED-ADDRESS')[0], response.getAttributeValue('XOR-MAPPED-ADDRESS')[1], 'srflx', localCandidate.host, localCandidate.port, localCandidate.tcptype);
+        return candidate;
+    }
+    catch (error) {
+        // todo fix
+        log('error serverReflexiveCandidate', error);
+    }
+}
+function validateAddress(addr) {
+    if (addr && Number.isNaN(addr[1])) {
+        return [addr[0], 443];
+    }
+    return addr;
+}

package/dist/cjs/lib/ice/imports/common.d.ts

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

package/dist/cjs/lib/ice/imports/common.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../common/index.js"), exports);

package/dist/cjs/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/cjs/lib/ice/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomPort = void 0;
+var index_js_1 = require("../common/index.js");
+Object.defineProperty(exports, "randomPort", { enumerable: true, get: function () { return index_js_1.randomPort; } });
+__exportStar(require("./stun/const.js"), exports);
+__exportStar(require("./stun/tcpFrame.js"), exports);
+__exportStar(require("./stun/tcpProtocol.js"), exports);
+__exportStar(require("./stun/message.js"), exports);
+__exportStar(require("./stun/protocol.js"), exports);
+__exportStar(require("./turn/protocol.js"), exports);
+__exportStar(require("./candidate.js"), exports);
+__exportStar(require("./ice.js"), exports);
+__exportStar(require("./types/model.js"), exports);
+__exportStar(require("./utils.js"), exports);
+__exportStar(require("./iceBase.js"), exports);

package/dist/cjs/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/cjs/lib/ice/internal/selectAddresses.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectAddressesFromInterfaces = selectAddressesFromInterfaces;
+const common_js_1 = require("../imports/common.js");
+/**
+ * Interface 辞書から host 候補アドレスを選別する（package-private）。
+ * 公開 barrel (`src/index.ts`) からは export しない。
+ * テストは本 helper への依存注入で行う。
+ */
+function selectAddressesFromInterfaces(interfaces, family, options = {}, isLinkLocal) {
+    // https://chromium.googlesource.com/external/webrtc/+/master/rtc_base/network.cc#236
+    const costlyNetworks = ['ipsec', 'tun', 'utun', 'tap'];
+    const banNetworks = ['vmnet', 'veth'];
+    const { useLinkLocalAddress } = options;
+    const all = Object.keys(interfaces)
+        .map((nic) => {
+        for (const word of [...costlyNetworks, ...banNetworks]) {
+            if (nic.startsWith(word)) {
+                return {
+                    nic,
+                    addresses: []
+                };
+            }
+        }
+        const addresses = (interfaces[nic] ?? []).filter((details) => (0, common_js_1.normalizeFamilyNodeV18)(details.family) === family &&
+            !details.internal &&
+            (useLinkLocalAddress ? true : !isLinkLocal(details)));
+        return {
+            nic,
+            addresses: addresses.map((address) => address.address)
+        };
+    })
+        .filter((address) => !!address);
+    // os.networkInterfaces doesn't actually return addresses in a good order.
+    // have seen instances where en0 (ethernet) is after en1 (wlan), etc.
+    // eth0 > eth1
+    all.sort((a, b) => a.nic.localeCompare(b.nic));
+    return Object.values(all).flatMap((entry) => entry.addresses);
+}

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

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

package/dist/cjs/lib/ice/stun/attributes.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../turn/stun/attributes.js"), exports);

package/dist/cjs/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/cjs/lib/ice/stun/const.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCP_CHECK_RESPONSE_TIMEOUT_MS = void 0;
+__exportStar(require("../../turn/stun/const.js"), exports);
+/**
+ * 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.
+ */
+exports.TCP_CHECK_RESPONSE_TIMEOUT_MS = 3000;

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

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

package/dist/cjs/lib/ice/stun/message.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../turn/stun/message.js"), exports);

package/dist/cjs/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>;
+}