@undefineds.co/xpod 0.3.53 → 0.3.54

package/dist/edge/reachability/TcpP2PSignalingSession.js

@@ -0,0 +1,699 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAW_TCP_HOLE_PUNCH_CAPABILITY = exports.RAW_TCP_HOLE_PUNCH_TRANSPORT = void 0;
+exports.createNodeRawTcpP2PConnectSocket = createNodeRawTcpP2PConnectSocket;
+exports.createRawTcpHolePunchCandidates = createRawTcpHolePunchCandidates;
+exports.createSignaledRawTcpP2PSession = createSignaledRawTcpP2PSession;
+exports.answerPendingRawTcpP2PSessionsOnce = answerPendingRawTcpP2PSessionsOnce;
+exports.acceptSignaledRawTcpP2PConnectionOnce = acceptSignaledRawTcpP2PConnectionOnce;
+exports.waitForRawTcpRemoteCandidates = waitForRawTcpRemoteCandidates;
+exports.connectSignaledRawTcpP2PTransport = connectSignaledRawTcpP2PTransport;
+exports.connectRawTcpP2PTransport = connectRawTcpP2PTransport;
+exports.filterRawTcpRemoteCandidates = filterRawTcpRemoteCandidates;
+exports.selectRawTcpP2PRoute = selectRawTcpP2PRoute;
+exports.isRawTcpHolePunchCandidate = isRawTcpHolePunchCandidate;
+const node_net_1 = require("node:net");
+const TcpP2PDataPlaneTransport_1 = require("./TcpP2PDataPlaneTransport");
+exports.RAW_TCP_HOLE_PUNCH_TRANSPORT = 'raw-tcp-hole-punch';
+exports.RAW_TCP_HOLE_PUNCH_CAPABILITY = 'tcp-punch';
+const DEFAULT_POLL_INTERVAL_MS = 1_000;
+const DEFAULT_WAIT_TIMEOUT_MS = 10_000;
+const DEFAULT_CONNECT_TIMEOUT_MS = 5_000;
+const DEFAULT_RAW_TCP_RETRY_INTERVAL_MS = 25;
+function createNodeRawTcpP2PConnectSocket(options = {}) {
+    return (attempt) => connectNodeRawTcpSocket(attempt, options);
+}
+const defaultNodeRawTcpP2PConnectSocket = createNodeRawTcpP2PConnectSocket();
+function createRawTcpHolePunchCandidates(options) {
+    const plan = options.plan ?? (0, TcpP2PDataPlaneTransport_1.computeTcpHolePunchPlan)(options.planOptions);
+    const createdAt = (options.createdAt ?? new Date()).toISOString();
+    const hostOrAddress = options.host ?? options.address;
+    const prefix = options.candidateIdPrefix ?? `${options.sourceId}_${plan.bucket}`;
+    return plan.ports.map((port, index) => ({
+        id: `${prefix}_${port}_${index}`,
+        role: options.role,
+        sourceId: options.sourceId,
+        createdAt,
+        protocol: 'tcp',
+        transport: exports.RAW_TCP_HOLE_PUNCH_TRANSPORT,
+        ...(options.host ? { host: options.host } : {}),
+        ...(options.address ? { address: options.address } : {}),
+        ...(hostOrAddress ? { url: `tcp-punch://${hostOrAddress}:${port}` } : {}),
+        port,
+        priority: options.priority ?? (100 - index),
+        metadata: {
+            provider: exports.RAW_TCP_HOLE_PUNCH_TRANSPORT,
+            bucket: plan.bucket,
+            boundary: plan.boundary,
+            rendezvousTimeSeconds: plan.rendezvousTimeSeconds,
+        },
+    }));
+}
+async function createSignaledRawTcpP2PSession(options) {
+    const plan = options.plan ?? (0, TcpP2PDataPlaneTransport_1.computeTcpHolePunchPlan)(options.planOptions);
+    const localCandidates = createRawTcpHolePunchCandidates({
+        role: 'client',
+        sourceId: options.clientId,
+        host: options.host,
+        address: options.address,
+        createdAt: options.createdAt,
+        priority: options.priority,
+        plan,
+        candidateIdPrefix: options.candidateIdPrefix,
+    });
+    const request = {
+        clientId: options.clientId,
+        capabilities: uniqueStrings([
+            exports.RAW_TCP_HOLE_PUNCH_CAPABILITY,
+            ...(options.capabilities ?? []),
+        ]),
+        candidates: localCandidates,
+    };
+    const session = await options.signaling.createP2PSession(request);
+    const effectiveLocalCandidates = localRawTcpCandidatesFromSessionOrFallback(session, localCandidates, 'client', options.clientId, plan.bucket);
+    return {
+        session,
+        plan,
+        localCandidates: effectiveLocalCandidates,
+        rawTcpRoute: selectRawTcpP2PRoute(session.nodeCandidates),
+    };
+}
+async function answerPendingRawTcpP2PSessionsOnce(options) {
+    const sessions = await options.signaling.listP2PSessions();
+    const answered = [];
+    for (const session of sessions) {
+        if (!selectRawTcpP2PRoute(session.nodeCandidates)) {
+            continue;
+        }
+        const plan = planFromRemoteCandidates(session.candidates, 'client');
+        if (!plan) {
+            continue;
+        }
+        if (hasRawTcpCandidate(session.candidates, 'node', options.sourceId, plan.bucket)) {
+            continue;
+        }
+        const candidates = createRawTcpHolePunchCandidates({
+            role: 'node',
+            sourceId: options.sourceId,
+            host: options.host,
+            address: options.address,
+            createdAt: options.createdAt,
+            priority: options.priority,
+            plan,
+            candidateIdPrefix: options.candidateIdPrefix,
+        });
+        answered.push(await options.signaling.addP2PCandidates(session.signalingUrl || session.sessionId, {
+            role: 'node',
+            sourceId: options.sourceId,
+            candidates,
+        }));
+    }
+    return answered;
+}
+async function acceptSignaledRawTcpP2PConnectionOnce(options) {
+    const sessions = await options.signaling.listP2PSessions();
+    for (const session of sessions) {
+        if (!selectRawTcpP2PRoute(session.nodeCandidates)) {
+            continue;
+        }
+        const plan = planFromRemoteCandidates(session.candidates, 'client');
+        if (!plan) {
+            continue;
+        }
+        const localCandidates = createRawTcpHolePunchCandidates({
+            role: 'node',
+            sourceId: options.sourceId,
+            host: options.host,
+            address: options.address,
+            createdAt: options.createdAt,
+            priority: options.priority,
+            plan,
+            candidateIdPrefix: options.candidateIdPrefix,
+        });
+        const answeredSession = hasRawTcpCandidate(session.candidates, 'node', options.sourceId, plan.bucket)
+            ? session
+            : await options.signaling.addP2PCandidates(session.signalingUrl || session.sessionId, {
+                role: 'node',
+                sourceId: options.sourceId,
+                candidates: localCandidates,
+            });
+        const remoteCandidates = filterRawTcpRemoteCandidates(answeredSession.candidates, 'node', options.sourceId, plan.bucket);
+        if (remoteCandidates.length === 0) {
+            continue;
+        }
+        const effectiveLocalCandidates = localRawTcpCandidatesFromSessionOrFallback(answeredSession, localCandidates, 'node', options.sourceId, plan.bucket);
+        const socket = await connectRawTcpP2PSocket({
+            localCandidates: effectiveLocalCandidates,
+            remoteCandidates,
+            connectTimeoutMs: options.connectTimeoutMs,
+            winnerSelectionWindowMs: options.winnerSelectionWindowMs,
+            localAddress: options.localAddress,
+            nowMs: options.nowMs,
+            sleepMs: options.sleepMs,
+            connectSocket: options.connectSocket,
+        });
+        return {
+            session: answeredSession,
+            plan,
+            localCandidates: effectiveLocalCandidates,
+            remoteCandidates,
+            socketHandle: (0, TcpP2PDataPlaneTransport_1.attachTcpP2PDataPlaneSocket)({ socket, handler: options.handler }),
+        };
+    }
+    return undefined;
+}
+async function waitForRawTcpRemoteCandidates(options) {
+    const startedAt = Date.now();
+    const timeoutMs = positiveInteger(options.timeoutMs, DEFAULT_WAIT_TIMEOUT_MS);
+    const pollIntervalMs = positiveInteger(options.pollIntervalMs, DEFAULT_POLL_INTERVAL_MS);
+    for (;;) {
+        const session = await options.signaling.getP2PSession(options.sessionIdOrUrl);
+        const candidates = filterRawTcpRemoteCandidates(session.candidates, options.localRole, options.localSourceId, options.bucket);
+        if (candidates.length > 0) {
+            return candidates;
+        }
+        if (Date.now() - startedAt >= timeoutMs) {
+            throw new Error(`Timed out waiting for raw TCP P2P candidates after ${timeoutMs}ms`);
+        }
+        await sleep(Math.min(pollIntervalMs, Math.max(1, timeoutMs - (Date.now() - startedAt))));
+    }
+}
+async function connectSignaledRawTcpP2PTransport(options) {
+    const signaled = await createSignaledRawTcpP2PSession(options);
+    const remoteCandidates = await waitForRawTcpRemoteCandidates({
+        signaling: options.signaling,
+        sessionIdOrUrl: signaled.session.signalingUrl || signaled.session.sessionId,
+        localRole: 'client',
+        localSourceId: options.clientId,
+        bucket: signaled.plan.bucket,
+        pollIntervalMs: options.pollIntervalMs,
+        timeoutMs: options.waitTimeoutMs,
+    });
+    const transport = await connectRawTcpP2PTransport({
+        localCandidates: signaled.localCandidates,
+        remoteCandidates,
+        connectTimeoutMs: options.connectTimeoutMs,
+        timeoutMs: options.timeoutMs,
+        winnerSelectionWindowMs: options.winnerSelectionWindowMs,
+        localAddress: options.localAddress,
+        nowMs: options.nowMs,
+        sleepMs: options.sleepMs,
+        connectSocket: options.connectSocket,
+    });
+    return {
+        ...signaled,
+        remoteCandidates,
+        transport,
+    };
+}
+async function connectRawTcpP2PTransport(options) {
+    const { attempt, socket } = await connectRawTcpP2PSocketAttempt(options);
+    return (0, TcpP2PDataPlaneTransport_1.createTcpP2PDataPlaneTransport)({
+        remoteHost: attempt.remoteHost,
+        remotePort: attempt.remotePort,
+        socket,
+        timeoutMs: options.timeoutMs,
+    });
+}
+async function connectRawTcpP2PSocket(options) {
+    const { socket } = await connectRawTcpP2PSocketAttempt(options);
+    return socket;
+}
+async function connectRawTcpP2PSocketAttempt(options) {
+    const pairs = candidatePairs(options.localCandidates, options.remoteCandidates);
+    if (pairs.length === 0) {
+        throw new Error('No compatible raw TCP P2P candidate pairs');
+    }
+    const errors = [];
+    const nowMs = options.nowMs ?? Date.now;
+    const sleepMs = options.sleepMs ?? sleep;
+    const connectSocket = options.connectSocket ?? defaultNodeRawTcpP2PConnectSocket;
+    const attempts = pairs.map(({ local, remote }) => createRawTcpConnectAttempt(local, remote, {
+        timeoutMs: positiveInteger(options.connectTimeoutMs, DEFAULT_CONNECT_TIMEOUT_MS),
+        localAddress: options.localAddress,
+    }));
+    try {
+        const { attempt, socket } = await connectFirstRawTcpAttempt(attempts, {
+            nowMs,
+            sleepMs,
+            connectSocket,
+            winnerSelectionWindowMs: nonNegativeInteger(options.winnerSelectionWindowMs, 0),
+        });
+        return { attempt, socket };
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+    }
+    throw new Error(`Failed to connect raw TCP P2P candidates: ${errors.join('; ')}`);
+}
+function filterRawTcpRemoteCandidates(candidates, localRole, localSourceId, bucket) {
+    return candidates.filter((candidate) => {
+        if (!isRawTcpHolePunchCandidate(candidate)) {
+            return false;
+        }
+        if (candidate.role === localRole && candidate.sourceId === localSourceId) {
+            return false;
+        }
+        if (bucket !== undefined && getNumericMetadata(candidate, 'bucket') !== bucket) {
+            return false;
+        }
+        return true;
+    });
+}
+function selectRawTcpP2PRoute(routes) {
+    return routes.find((route) => {
+        if (route.kind !== 'p2p') {
+            return false;
+        }
+        if (route.targetUrl.startsWith('tcp-punch://')) {
+            return true;
+        }
+        const protocols = isRecord(route.metadata?.protocols) ? route.metadata.protocols : undefined;
+        const rawTcp = isRecord(protocols?.[exports.RAW_TCP_HOLE_PUNCH_TRANSPORT])
+            ? protocols[exports.RAW_TCP_HOLE_PUNCH_TRANSPORT]
+            : undefined;
+        return rawTcp?.enabled === true;
+    });
+}
+function isRawTcpHolePunchCandidate(candidate) {
+    return candidate.protocol === 'tcp'
+        && candidate.transport === exports.RAW_TCP_HOLE_PUNCH_TRANSPORT
+        && getNumericMetadata(candidate, 'bucket') !== undefined
+        && getNumericMetadata(candidate, 'rendezvousTimeSeconds') !== undefined
+        && typeof candidate.port === 'number';
+}
+function localRawTcpCandidatesFromSessionOrFallback(session, fallback, role, sourceId, bucket) {
+    const signaledCandidates = session.candidates.filter((candidate) => candidate.role === role
+        && candidate.sourceId === sourceId
+        && isRawTcpHolePunchCandidate(candidate)
+        && getNumericMetadata(candidate, 'bucket') === bucket);
+    return signaledCandidates.length > 0 ? signaledCandidates : fallback;
+}
+function candidatePairs(localCandidates, remoteCandidates) {
+    const local = localCandidates.filter(isRawTcpHolePunchCandidate).sort(compareCandidatePriority);
+    const remote = remoteCandidates
+        .filter(isRawTcpHolePunchCandidate)
+        .filter((candidate) => candidateHost(candidate).length > 0)
+        .sort(compareCandidatePriority);
+    const result = [];
+    for (const localCandidate of local) {
+        const localBucket = getNumericMetadata(localCandidate, 'bucket');
+        for (const remoteCandidate of remote) {
+            if (localBucket === getNumericMetadata(remoteCandidate, 'bucket')) {
+                result.push({ local: localCandidate, remote: remoteCandidate });
+            }
+        }
+    }
+    return result;
+}
+function createRawTcpConnectAttempt(local, remote, options) {
+    const remoteHost = candidateHost(remote);
+    const remotePort = remote.port;
+    if (!remoteHost || !remotePort) {
+        throw new Error(`Remote raw TCP candidate ${remote.id} is missing host or port`);
+    }
+    const localRendezvousTimeSeconds = getNumericMetadata(local, 'rendezvousTimeSeconds') ?? 0;
+    const remoteRendezvousTimeSeconds = getNumericMetadata(remote, 'rendezvousTimeSeconds') ?? 0;
+    return {
+        local,
+        remote,
+        remoteHost,
+        remotePort,
+        localAddress: options.localAddress,
+        ...(local.port ? { localPort: local.port } : {}),
+        rendezvousTimeMs: Math.max(localRendezvousTimeSeconds, remoteRendezvousTimeSeconds) * 1_000,
+        timeoutMs: options.timeoutMs,
+    };
+}
+async function connectFirstRawTcpAttempt(attempts, options) {
+    return new Promise((resolve, reject) => {
+        const controllers = attempts.map(() => new AbortController());
+        const errors = [];
+        const successes = [];
+        let pending = attempts.length;
+        let settled = false;
+        let settleTimer;
+        const clearSettleTimer = () => {
+            if (settleTimer) {
+                clearTimeout(settleTimer);
+                settleTimer = undefined;
+            }
+        };
+        const finishReject = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearSettleTimer();
+            reject(error);
+        };
+        const finishWithWinner = () => {
+            if (settled) {
+                return;
+            }
+            if (successes.length === 0) {
+                finishReject(new Error(errors.join('; ')));
+                return;
+            }
+            settled = true;
+            clearSettleTimer();
+            const winner = selectRawTcpWinner(successes);
+            controllers.forEach((controller, index) => {
+                if (index !== winner.index) {
+                    controller.abort();
+                }
+            });
+            for (const success of successes) {
+                if (success !== winner) {
+                    success.socket.destroy();
+                }
+            }
+            resolve({ attempt: winner.attempt, socket: winner.socket });
+        };
+        const scheduleWinner = () => {
+            if (options.winnerSelectionWindowMs <= 0 || pending === 0) {
+                finishWithWinner();
+                return;
+            }
+            settleTimer ??= setTimeout(finishWithWinner, options.winnerSelectionWindowMs);
+        };
+        attempts.forEach((baseAttempt, index) => {
+            const controller = controllers[index];
+            const attempt = {
+                ...baseAttempt,
+                signal: controller.signal,
+            };
+            void runRawTcpConnectAttempt(attempt, options)
+                .then((socket) => {
+                if (settled) {
+                    socket.destroy();
+                    return;
+                }
+                successes.push({ attempt, socket, index });
+                pending -= 1;
+                scheduleWinner();
+            })
+                .catch((error) => {
+                if (settled) {
+                    return;
+                }
+                errors.push(error instanceof Error ? error.message : String(error));
+                pending -= 1;
+                if (pending === 0) {
+                    if (successes.length > 0) {
+                        finishWithWinner();
+                    }
+                    else {
+                        finishReject(new Error(errors.join('; ')));
+                    }
+                }
+            });
+        });
+    });
+}
+function selectRawTcpWinner(successes) {
+    return successes.slice().sort((left, right) => {
+        const keyCompare = rawTcpAttemptPairKey(left.attempt).localeCompare(rawTcpAttemptPairKey(right.attempt));
+        return keyCompare === 0 ? left.index - right.index : keyCompare;
+    })[0];
+}
+function rawTcpAttemptPairKey(attempt) {
+    const endpoints = [
+        rawTcpEndpointKey(attempt.local),
+        rawTcpEndpointKey(attempt.remote),
+    ].sort();
+    return endpoints.join('<->');
+}
+function rawTcpEndpointKey(candidate) {
+    return [
+        candidate.sourceId,
+        candidateHost(candidate),
+        String(candidate.port ?? ''),
+        candidate.id,
+    ].join('|');
+}
+async function runRawTcpConnectAttempt(attempt, options) {
+    await waitForRendezvous(attempt.rendezvousTimeMs, options.nowMs, options.sleepMs, attempt.signal);
+    return connectSocketWithTimeout(attempt, options.connectSocket);
+}
+async function waitForRendezvous(rendezvousTimeMs, nowMs, sleepMs, signal) {
+    const delayMs = rendezvousTimeMs - nowMs();
+    if (delayMs > 0) {
+        await abortableSleep(delayMs, sleepMs, signal);
+    }
+    if (signal?.aborted) {
+        throw new Error('Raw TCP candidate connect aborted');
+    }
+}
+async function connectSocketWithTimeout(attempt, connectSocket) {
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        const timeout = setTimeout(() => {
+            finishReject(new Error(`Raw TCP candidate connect timed out after ${attempt.timeoutMs}ms`));
+        }, attempt.timeoutMs);
+        const onAbort = () => {
+            finishReject(new Error('Raw TCP candidate connect aborted'));
+        };
+        const cleanup = () => {
+            clearTimeout(timeout);
+            attempt.signal?.removeEventListener('abort', onAbort);
+        };
+        const finishReject = (error) => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            cleanup();
+            reject(error);
+        };
+        attempt.signal?.addEventListener('abort', onAbort, { once: true });
+        if (attempt.signal?.aborted) {
+            finishReject(new Error('Raw TCP candidate connect aborted'));
+            return;
+        }
+        void connectSocket(attempt)
+            .then((socket) => {
+            if (finished) {
+                socket.destroy();
+                return;
+            }
+            finished = true;
+            cleanup();
+            resolve(socket);
+        })
+            .catch((error) => {
+            finishReject(error instanceof Error ? error : new Error(String(error)));
+        });
+    });
+}
+async function connectNodeRawTcpSocket(attempt, options) {
+    const startedAt = Date.now();
+    const retryIntervalMs = positiveInteger(options.retryIntervalMs, DEFAULT_RAW_TCP_RETRY_INTERVAL_MS);
+    let lastError;
+    for (;;) {
+        if (attempt.signal?.aborted) {
+            options.onEvent?.({ type: 'aborted', attempt });
+            throw new Error('Raw TCP candidate connect aborted');
+        }
+        const remainingMs = attempt.timeoutMs - (Date.now() - startedAt);
+        if (remainingMs <= 0) {
+            const error = new Error(`Raw TCP candidate connect timed out after ${attempt.timeoutMs}ms${lastError ? `: ${lastError.message}` : ''}`);
+            options.onEvent?.({ type: 'timeout', attempt, error });
+            throw error;
+        }
+        options.onEvent?.({ type: 'attempt', attempt, remainingMs });
+        try {
+            const socket = await connectRawTcpSocketOnce(attempt, remainingMs);
+            options.onEvent?.({ type: 'success', attempt, socket });
+            return socket;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt.signal?.aborted) {
+                options.onEvent?.({ type: 'aborted', attempt, error: lastError });
+                throw new Error('Raw TCP candidate connect aborted');
+            }
+            const remainingAfterFailureMs = attempt.timeoutMs - (Date.now() - startedAt);
+            const retryDelayMs = Math.min(retryIntervalMs, Math.max(0, remainingAfterFailureMs));
+            if (retryDelayMs <= 0) {
+                const timeoutError = new Error(`Raw TCP candidate connect timed out after ${attempt.timeoutMs}ms: ${lastError.message}`);
+                options.onEvent?.({ type: 'timeout', attempt, error: timeoutError });
+                throw timeoutError;
+            }
+            options.onEvent?.({
+                type: 'retry',
+                attempt,
+                error: lastError,
+                remainingMs: remainingAfterFailureMs,
+                retryDelayMs,
+            });
+            try {
+                await sleep(retryDelayMs, attempt.signal);
+            }
+            catch (sleepError) {
+                if (attempt.signal?.aborted) {
+                    options.onEvent?.({
+                        type: 'aborted',
+                        attempt,
+                        error: sleepError instanceof Error ? sleepError : new Error(String(sleepError)),
+                    });
+                }
+                throw sleepError;
+            }
+        }
+    }
+}
+async function connectRawTcpSocketOnce(attempt, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const connectOptions = {
+            host: attempt.remoteHost,
+            port: attempt.remotePort,
+            localAddress: attempt.localAddress,
+            ...(attempt.localPort ? { localPort: attempt.localPort } : {}),
+        };
+        const socket = (0, node_net_1.createConnection)(connectOptions);
+        const timeout = setTimeout(() => {
+            cleanup();
+            socket.destroy();
+            reject(new Error(`Raw TCP candidate connect attempt timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timeout);
+            socket.off('connect', onConnect);
+            socket.off('error', onError);
+            attempt.signal?.removeEventListener('abort', onAbort);
+        };
+        const onConnect = () => {
+            cleanup();
+            resolve(socket);
+        };
+        const onError = (error) => {
+            cleanup();
+            socket.destroy();
+            reject(error);
+        };
+        const onAbort = () => {
+            cleanup();
+            socket.destroy();
+            reject(new Error('Raw TCP candidate connect aborted'));
+        };
+        attempt.signal?.addEventListener('abort', onAbort, { once: true });
+        if (attempt.signal?.aborted) {
+            onAbort();
+            return;
+        }
+        socket.once('connect', onConnect);
+        socket.once('error', onError);
+    });
+}
+function candidateHost(candidate) {
+    return candidate.host ?? candidate.address ?? hostFromCandidateUrl(candidate.url) ?? '';
+}
+function hostFromCandidateUrl(value) {
+    if (!value) {
+        return undefined;
+    }
+    try {
+        return new URL(value).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+function compareCandidatePriority(left, right) {
+    return (right.priority ?? 0) - (left.priority ?? 0);
+}
+function planFromRemoteCandidates(candidates, role) {
+    const rawCandidates = candidates
+        .filter((candidate) => candidate.role === role)
+        .filter(isRawTcpHolePunchCandidate);
+    const first = rawCandidates[0];
+    if (!first) {
+        return undefined;
+    }
+    const bucket = getNumericMetadata(first, 'bucket');
+    const boundary = getNumericMetadata(first, 'boundary');
+    const rendezvousTimeSeconds = getNumericMetadata(first, 'rendezvousTimeSeconds');
+    if (bucket === undefined || boundary === undefined || rendezvousTimeSeconds === undefined) {
+        return undefined;
+    }
+    const ports = rawCandidates
+        .filter((candidate) => getNumericMetadata(candidate, 'bucket') === bucket)
+        .map((candidate) => candidate.port)
+        .filter((port) => typeof port === 'number' && Number.isInteger(port) && port > 0);
+    if (ports.length === 0) {
+        return undefined;
+    }
+    return {
+        bucket,
+        boundary,
+        rendezvousTimeSeconds,
+        ports: [...new Set(ports)].sort((a, b) => b - a),
+    };
+}
+function hasRawTcpCandidate(candidates, role, sourceId, bucket) {
+    return candidates.some((candidate) => candidate.role === role
+        && candidate.sourceId === sourceId
+        && isRawTcpHolePunchCandidate(candidate)
+        && getNumericMetadata(candidate, 'bucket') === bucket);
+}
+function getNumericMetadata(candidate, key) {
+    const value = candidate.metadata?.[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter((value) => value.trim().length > 0))];
+}
+function positiveInteger(value, fallback) {
+    return Number.isInteger(value) && value !== undefined && value > 0 ? value : fallback;
+}
+function nonNegativeInteger(value, fallback) {
+    return Number.isInteger(value) && value !== undefined && value >= 0 ? value : fallback;
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            cleanup();
+            reject(new Error('Raw TCP candidate connect aborted'));
+        };
+        const cleanup = () => {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', onAbort);
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        if (signal?.aborted) {
+            onAbort();
+        }
+    });
+}
+async function abortableSleep(ms, sleepMs, signal) {
+    if (!signal) {
+        await sleepMs(ms);
+        return;
+    }
+    if (signal.aborted) {
+        throw new Error('Raw TCP candidate connect aborted');
+    }
+    let removeAbortListener;
+    try {
+        await Promise.race([
+            sleepMs(ms, signal),
+            new Promise((_resolve, reject) => {
+                const onAbort = () => reject(new Error('Raw TCP candidate connect aborted'));
+                signal.addEventListener('abort', onAbort, { once: true });
+                removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+            }),
+        ]);
+    }
+    finally {
+        removeAbortListener?.();
+    }
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+//# sourceMappingURL=TcpP2PSignalingSession.js.map