@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/transport/multiplexer.js

@@ -0,0 +1,323 @@
+import { decodeDshEnvelope, encodeDshEnvelope } from './dsh-envelope.js';
+import { createDshTransportDebugLogger } from './debug.js';
+const DEFAULT_SCOPE = { hostId: 'unknown', kind: 'remote' };
+/** DSH Envelope 层多路复用器；逻辑 API 保持 rpc/openStream，物理线路只发送二进制 Envelope。 */
+export class DshTunnelMultiplexer {
+    carrier;
+    pending = new Map();
+    streams = new Map();
+    sequence = 0;
+    nextId = 0;
+    disposed = false;
+    unsubscribe;
+    idPrefix;
+    flowControl;
+    generation;
+    hostScope;
+    session;
+    requireSessionReady;
+    debug;
+    constructor(carrier, options = {}) {
+        this.carrier = carrier;
+        this.idPrefix = options.idPrefix ?? 'g0';
+        this.flowControl = options.flowControl;
+        this.generation = options.generation ?? this.idPrefix.replace(/^g/u, '');
+        this.hostScope = options.hostScope ?? DEFAULT_SCOPE;
+        this.session = options.session;
+        this.requireSessionReady = options.requireSessionReady ?? options.session !== undefined;
+        this.debug = options.debug ?? createDshTransportDebugLogger({ component: 'multiplexer' });
+        this.unsubscribe = carrier.subscribe((data) => this.receive(data));
+    }
+    request(channel, payload, signal) {
+        return this.requestOperation(channel, channel === 'fetch' ? 'web.request' : 'rpc.request', payload, signal);
+    }
+    requestOperation(channel, operation, payload, signal) {
+        this.ensureOpen();
+        const id = `${this.idPrefix}_req_${this.nextRequestId()}`;
+        return new Promise((resolve, reject) => {
+            const abort = () => {
+                if (!this.pending.delete(id))
+                    return;
+                if (!this.disposed && this.carrier.state === 'open') {
+                    try {
+                        this.send({ streamId: id, channel: mapChannel(channel), type: 'stream.cancel', meta: { reason: String(signal?.reason ?? 'cancelled') } });
+                    }
+                    catch { /* 取消尽力而为 */ }
+                }
+                reject(signal?.reason instanceof Error ? signal.reason : new Error('请求已取消'));
+            };
+            if (signal?.aborted)
+                return abort();
+            signal?.addEventListener('abort', abort, { once: true });
+            this.pending.set(id, {
+                resolve: (value) => { signal?.removeEventListener('abort', abort); resolve(value); },
+                reject: (error) => { signal?.removeEventListener('abort', abort); reject(error); },
+                accepted: false,
+            });
+            try {
+                this.debug.log('request.send', { channel, operation, streamId: id, generation: this.generation, hostId: this.hostScope.hostId, bodyBytes: encodeJson(payload).byteLength });
+                this.send({
+                    streamId: id,
+                    channel: mapChannel(channel),
+                    type: 'stream.open',
+                    meta: { operation, encoding: 'json' },
+                    body: encodeJson(payload),
+                });
+            }
+            catch (error) {
+                this.pending.delete(id);
+                signal?.removeEventListener('abort', abort);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    openStream(payload, signal) {
+        return this.openStreamOperation('rpc', 'rpc.stream', payload, signal);
+    }
+    openStreamOperation(channel, operation, payload, signal) {
+        return this.openStreamOperationWithId(channel, operation, payload, signal).stream;
+    }
+    openStreamOperationWithId(channel, operation, payload, signal) {
+        this.ensureOpen();
+        if (signal?.aborted)
+            return { streamId: '', stream: this.closedStream() };
+        const id = `${this.idPrefix}_stream_${this.nextRequestId()}`;
+        const state = { queue: [], queuedBytes: 0, waiters: [], closed: false, removeAbort: undefined };
+        this.streams.set(id, state);
+        const cancel = () => {
+            if (state.closed)
+                return;
+            state.closed = true;
+            if (!this.disposed && this.carrier.state === 'open') {
+                try {
+                    this.send({ streamId: id, channel, type: 'stream.cancel', meta: {} });
+                }
+                catch { /* 关闭路径尽力而为 */ }
+            }
+            this.finishStream(id, state);
+        };
+        if (signal) {
+            signal.addEventListener('abort', cancel, { once: true });
+            state.removeAbort = () => signal.removeEventListener('abort', cancel);
+        }
+        try {
+            this.send({ streamId: id, channel, type: 'stream.open', meta: { operation, encoding: 'json' }, body: encodeJson(payload) });
+        }
+        catch (error) {
+            state.error = error instanceof Error ? error : new Error(String(error));
+            this.finishStream(id, state);
+        }
+        const stream = { [Symbol.asyncIterator]: () => ({
+                next: async () => {
+                    if (state.error)
+                        throw state.error;
+                    if (state.queue.length > 0) {
+                        state.queuedBytes = 0;
+                        return { done: false, value: state.queue.shift() };
+                    }
+                    if (state.closed)
+                        return { done: true, value: undefined };
+                    return new Promise((resolve, reject) => state.waiters.push({ resolve: (result) => resolve({ done: result.done === true, value: result.value }), reject }));
+                },
+                return: async () => { cancel(); return { done: true, value: undefined }; },
+            }) };
+        return { streamId: id, stream };
+    }
+    sendStreamMessage(streamId, channel, type, meta = {}, body) {
+        this.ensureOpen();
+        this.send({ streamId, channel, type, meta, ...(body === undefined ? {} : { body }) });
+    }
+    closeStream(streamId, channel = 'web') {
+        if (this.disposed || this.carrier.state !== 'open')
+            return;
+        try {
+            this.sendStreamMessage(streamId, channel, 'stream.cancel', {});
+        }
+        catch { /* 关闭路径尽力而为 */ }
+    }
+    close(error = new Error('Transport 已关闭')) {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.unsubscribe();
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+        for (const [id, stream] of this.streams) {
+            stream.error = error;
+            this.finishStream(id, stream);
+        }
+    }
+    invalidate(error = new Error('Transport generation 已过期')) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+        for (const [id, stream] of this.streams) {
+            stream.error = error;
+            this.finishStream(id, stream);
+        }
+    }
+    /** 替换物理 carrier；逻辑请求已在 invalidate 中失败，后续请求使用新线路。 */
+    replaceCarrier(carrier) {
+        if (this.disposed)
+            throw new Error('Transport 已关闭');
+        this.unsubscribe();
+        this.carrier = carrier;
+        this.unsubscribe = carrier.subscribe((data) => this.receive(data));
+    }
+    setSession(session) {
+        this.session = session;
+    }
+    rotateGeneration(idPrefix, error = new Error('Transport generation 已过期')) {
+        this.invalidate(error);
+        this.idPrefix = idPrefix;
+        this.generation = idPrefix.replace(/^g/u, '');
+    }
+    receive(data) {
+        let envelope;
+        try {
+            if (typeof data === 'string') {
+                const legacy = JSON.parse(data);
+                envelope = legacyEnvelope(legacy);
+            }
+            else {
+                const options = this.flowControl?.maxFrameBytes === undefined ? {} : { maxBytes: this.flowControl.maxFrameBytes };
+                envelope = decodeDshEnvelope(data, options);
+            }
+        }
+        catch (error) {
+            this.debug.log('envelope.decode.error', { bytes: typeof data === 'string' ? data.length : data.byteLength, error: error instanceof Error ? error.message : String(error) });
+            this.close(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        this.debug.log('envelope.receive', envelopeDebugFields(envelope, typeof data === 'string' ? new TextEncoder().encode(data).byteLength : data.byteLength));
+        if (envelope.generation !== this.generation || envelope.hostScope.hostId !== this.hostScope.hostId || envelope.hostScope.kind !== this.hostScope.kind) {
+            this.debug.log('envelope.scope.drop', { expectedGeneration: this.generation, expectedHostId: this.hostScope.hostId, expectedHostKind: this.hostScope.kind, ...envelopeDebugFields(envelope, undefined) });
+            return;
+        }
+        this.flowControl?.onReceive?.(typeof data === 'string' ? new TextEncoder().encode(data).byteLength : data.byteLength, envelope);
+        const state = this.streams.get(envelope.streamId);
+        const pending = this.pending.get(envelope.streamId);
+        if (state)
+            return this.receiveStream(envelope, state);
+        if (!pending)
+            return;
+        if (envelope.type === 'stream.accepted') {
+            pending.accepted = true;
+            return;
+        }
+        if (envelope.type.endsWith('.response')) {
+            this.pending.delete(envelope.streamId);
+            pending.resolve(decodePayload(envelope));
+        }
+        else if (envelope.type === 'stream.close') {
+            this.pending.delete(envelope.streamId);
+            pending.resolve(decodePayload(envelope));
+        }
+        else if (envelope.type === 'stream.error' || envelope.type.endsWith('.error')) {
+            this.pending.delete(envelope.streamId);
+            pending.reject(new Error(typeof envelope.meta.detail === 'string' ? envelope.meta.detail : '远端请求失败'));
+        }
+    }
+    receiveStream(envelope, state) {
+        if (envelope.type === 'stream.accepted')
+            return;
+        if (envelope.type === 'stream.error' || envelope.type.endsWith('.error')) {
+            state.error = new Error(typeof envelope.meta.detail === 'string' ? envelope.meta.detail : '远端流失败');
+            this.finishStream(envelope.streamId, state);
+            return;
+        }
+        if (envelope.type === 'stream.close' || envelope.flags?.endOfStream) {
+            this.finishStream(envelope.streamId, state);
+            return;
+        }
+        if (envelope.type === 'stream.window')
+            return;
+        const value = decodePayload(envelope);
+        state.queuedBytes += envelope.body?.byteLength ?? 0;
+        if (state.queuedBytes > (this.flowControl?.maxQueueBytes ?? 4 * 1024 * 1024)) {
+            state.error = new Error('Transport 队列超过上限');
+            this.finishStream(envelope.streamId, state);
+            return;
+        }
+        if (state.waiters.length > 0)
+            state.waiters.shift()?.resolve({ done: false, value });
+        else
+            state.queue.push(value);
+    }
+    finishStream(id, state) {
+        state.closed = true;
+        state.removeAbort?.();
+        state.removeAbort = undefined;
+        this.streams.delete(id);
+        for (const waiter of state.waiters.splice(0))
+            state.error ? waiter.reject(state.error) : waiter.resolve({ done: true, value: undefined });
+    }
+    send(input) {
+        const envelope = { version: 1, messageId: `${this.idPrefix}_m_${this.nextSequence()}`, streamId: input.streamId, channel: input.channel, type: input.type, sequence: this.nextSequence(), generation: this.generation, hostScope: this.hostScope, meta: input.meta ?? {}, ...(input.body === undefined ? {} : { body: input.body }), ...(input.flags === undefined ? {} : { flags: input.flags }) };
+        const encoded = encodeDshEnvelope(envelope, this.flowControl?.maxFrameBytes === undefined ? {} : { maxBytes: this.flowControl.maxFrameBytes });
+        if (this.flowControl?.canSend && !this.flowControl.canSend(encoded.byteLength, envelope))
+            throw new Error('Transport 背压窗口不足');
+        const pending = this.carrier.send(encoded);
+        this.debug.log('envelope.send', envelopeDebugFields(envelope, encoded.byteLength));
+        if (pending && typeof pending.catch === 'function') {
+            void pending.catch((error) => this.close(error instanceof Error ? error : new Error(String(error))));
+        }
+        this.flowControl?.onSend?.(encoded.byteLength, envelope);
+    }
+    nextSequence() { if (this.sequence >= Number.MAX_SAFE_INTEGER)
+        throw new Error('DSH Envelope sequence 已耗尽'); return ++this.sequence; }
+    nextRequestId() { if (this.nextId >= Number.MAX_SAFE_INTEGER)
+        throw new Error('Transport request id 已耗尽'); return ++this.nextId; }
+    closedStream(error) { return { [Symbol.asyncIterator]: () => ({ next: async () => error ? Promise.reject(error) : ({ done: true, value: undefined }) }) }; }
+    ensureOpen() { if (this.disposed || this.carrier.state !== 'open')
+        throw new Error('Transport 尚未 ready'); if (this.requireSessionReady && !this.session?.ready)
+        throw new Error('SESSION_NOT_READY'); }
+}
+function envelopeDebugFields(envelope, bytes) {
+    return {
+        type: envelope.type,
+        channel: envelope.channel,
+        streamId: envelope.streamId,
+        sequence: envelope.sequence,
+        generation: envelope.generation,
+        hostId: envelope.hostScope.hostId,
+        hostKind: envelope.hostScope.kind,
+        operation: typeof envelope.meta.operation === 'string' ? envelope.meta.operation : undefined,
+        bodyBytes: envelope.body?.byteLength ?? 0,
+        ...(bytes === undefined ? {} : { frameBytes: bytes }),
+    };
+}
+function mapChannel(channel) { return channel === 'fetch' || channel === 'web' ? 'web' : channel === 'control' ? 'session' : 'rpc'; }
+function encodeJson(value) { return new TextEncoder().encode(JSON.stringify(value === undefined ? null : value)); }
+function decodePayload(envelope) {
+    if (envelope.meta.encoding === 'json' && envelope.body) {
+        try {
+            return JSON.parse(new TextDecoder().decode(envelope.body));
+        }
+        catch {
+            return envelope.body;
+        }
+    }
+    if (envelope.meta.encoding === 'text' && envelope.body)
+        return new TextDecoder().decode(envelope.body);
+    return envelope.body ?? envelope.meta.payload;
+}
+function legacyEnvelope(value) {
+    if (typeof value.id !== 'string' || typeof value.kind !== 'string' || !Number.isSafeInteger(value.sequence))
+        throw new Error('Tunnel Frame 无效');
+    const channel = value.channel === 'fetch' ? 'web' : value.channel === 'control' ? 'session' : 'rpc';
+    return {
+        version: 1,
+        messageId: value.id,
+        streamId: value.id,
+        channel,
+        type: `${value.channel}.${value.kind}`,
+        sequence: value.sequence,
+        generation: '1',
+        hostScope: { hostId: 'unknown', kind: 'remote' },
+        meta: { encoding: 'json', ...(value.payload === undefined ? {} : { payload: value.payload }) },
+        ...(value.payload === undefined ? {} : { body: new TextEncoder().encode(JSON.stringify(value.payload)) }),
+    };
+}
+//# sourceMappingURL=multiplexer.js.map

package/data/build/dist/transport/webrtc-client.d.ts

@@ -0,0 +1,65 @@
+import type { RelayIceServer, RelaySignalingTicketResponse } from '../shared/index.js';
+import { type CodingNsCarrier, type DataChannelLike } from './carrier.js';
+import { type DshTransportDebugLogger } from './debug.js';
+export interface SignalingSocketLike {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'message' | 'close' | 'error', listener: (event: Event) => void): void;
+    removeEventListener(type: 'message' | 'close' | 'error', listener: (event: Event) => void): void;
+}
+export interface PeerConnectionLike {
+    createDataChannel(label: string): DataChannelLike;
+    createOffer(): Promise<{
+        type: 'offer';
+        sdp?: string;
+    }>;
+    setLocalDescription(description: {
+        type: string;
+        sdp?: string;
+    }): Promise<void>;
+    setRemoteDescription(description: {
+        type: string;
+        sdp: string;
+    }): Promise<void>;
+    addIceCandidate(candidate: {
+        candidate: string;
+        sdpMid: string | null;
+    }): Promise<void>;
+    close(): void;
+    onicecandidate: ((event: {
+        candidate: {
+            candidate: string;
+            sdpMid: string | null;
+        } | null;
+    }) => void) | null;
+    addEventListener?(type: string, listener: (event: Event) => void): void;
+    removeEventListener?(type: string, listener: (event: Event) => void): void;
+}
+export interface WebRtcClientConnectorOptions {
+    signalingTicket: RelaySignalingTicketResponse;
+    signalingSocketFactory(url: string): Promise<SignalingSocketLike> | SignalingSocketLike;
+    peerConnectionFactory(options: {
+        iceServers: RelayIceServer[];
+        iceTransportPolicy: 'all' | 'relay';
+    }): PeerConnectionLike;
+    channelLabel?: string;
+    timeoutMs?: number;
+    heartbeatIntervalMs?: number;
+    debug?: DshTransportDebugLogger;
+}
+export interface WebRtcClientConnection {
+    carrier: CodingNsCarrier;
+    peerConnection: PeerConnectionLike;
+    signaling: SignalingSocketLike;
+    onClosed(listener: (error?: Error) => void): () => void;
+    close(): Promise<void>;
+}
+/** 客户端发起 offer，校验 Host fingerprint 后返回 DataChannel Carrier。 */
+export declare function connectWebRtcClient(options: WebRtcClientConnectorOptions): Promise<WebRtcClientConnection>;
+export declare function createSignalingUrl(baseUrl: string, ticket: string): string;
+export declare function waitForSignalingRegistered(socket: SignalingSocketLike, timeoutMs: number, cleanup?: Array<() => void>): Promise<void>;
+/** Relay 只有在 Host 在线后才接受客户端 offer，避免过早发送被 HOST_NOT_CONNECTED 拒绝。 */
+export declare function waitForPeerReady(socket: SignalingSocketLike, timeoutMs: number, cleanup?: Array<() => void>): Promise<void>;
+export declare function extractDtlsFingerprint(sdp: string): string | null;
+export declare function assertDtlsFingerprint(expected: string, sdp: string): void;
+//# sourceMappingURL=webrtc-client.d.ts.map

package/data/build/dist/transport/webrtc-client.js

@@ -0,0 +1,255 @@
+import { createDataChannelCarrier, TUNNEL_DATA_CHANNEL_LABEL } from './carrier.js';
+import { encodeFrame } from './frame.js';
+import { createDshTransportDebugLogger } from './debug.js';
+/** 客户端发起 offer，校验 Host fingerprint 后返回 DataChannel Carrier。 */
+export async function connectWebRtcClient(options) {
+    const ticket = options.signalingTicket;
+    const debug = options.debug ?? createDshTransportDebugLogger({ side: 'h5', component: 'webrtc-client' });
+    const signalingUrl = createSignalingUrl(ticket.signalingBaseUrl, ticket.ticket);
+    debug.log('signaling.connect', { signalingBaseUrl: ticket.signalingBaseUrl });
+    const signaling = await options.signalingSocketFactory(signalingUrl);
+    const cleanupListeners = [];
+    // 真实 WebSocket 暴露 readyState；测试注入的最小 socket 可能没有该字段。
+    // 生产路径严格等待 registered，旧的纯协议 fake 仍可直接进入 offer 流程。
+    if ('readyState' in signaling) {
+        await waitForSignalingRegistered(signaling, options.timeoutMs ?? 15_000, cleanupListeners);
+        await waitForPeerReady(signaling, options.timeoutMs ?? 15_000, cleanupListeners);
+    }
+    const heartbeat = options.heartbeatIntervalMs === 0 ? null : setInterval(() => {
+        try {
+            signaling.send(JSON.stringify({ type: 'ping', at: new Date().toISOString() }));
+        }
+        catch { /* 断线由 close 事件处理 */ }
+    }, options.heartbeatIntervalMs ?? 20_000);
+    cleanupListeners.push(() => { if (heartbeat)
+        clearInterval(heartbeat); });
+    const peerConnection = options.peerConnectionFactory({
+        iceServers: ticket.iceServers,
+        iceTransportPolicy: ticket.iceTransportPolicy,
+    });
+    // Relay Tunnel 的标签属于线协议，不能由调用方改写。
+    const channel = peerConnection.createDataChannel(TUNNEL_DATA_CHANNEL_LABEL);
+    const carrier = createDataChannelCarrier(channel, { ...(options.debug ? { debug: options.debug } : {}) });
+    let closed = false;
+    let closeNotified = false;
+    const closeListeners = new Set();
+    const notifyClosed = (error) => {
+        if (closeNotified)
+            return;
+        closeNotified = true;
+        debug.log('webrtc.connection.closed', { reason: error?.message ?? 'closed' });
+        for (const listener of [...closeListeners])
+            listener(error);
+        closeListeners.clear();
+    };
+    const onSignalingClose = () => notifyClosed(new Error('Relay signaling closed'));
+    const onSignalingError = () => notifyClosed(new Error('Relay signaling error'));
+    const onPeerState = () => {
+        const state = peerConnection;
+        const value = state.connectionState ?? state.iceConnectionState;
+        debug.log('webrtc.peer.state', { state: value ?? 'unknown' });
+        if (value === 'failed' || value === 'disconnected' || value === 'closed')
+            notifyClosed(new Error(`PeerConnection ${value}`));
+    };
+    signaling.addEventListener('close', onSignalingClose);
+    signaling.addEventListener('error', onSignalingError);
+    peerConnection.addEventListener?.('connectionstatechange', onPeerState);
+    peerConnection.addEventListener?.('iceconnectionstatechange', onPeerState);
+    const carrierClosed = (reason) => notifyClosed(new Error(reason ?? 'DataChannel closed'));
+    carrier.onClosed?.(carrierClosed);
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        notifyClosed(new Error('client closed'));
+        signaling.removeEventListener('close', onSignalingClose);
+        signaling.removeEventListener('error', onSignalingError);
+        peerConnection.removeEventListener?.('connectionstatechange', onPeerState);
+        peerConnection.removeEventListener?.('iceconnectionstatechange', onPeerState);
+        for (const cleanup of cleanupListeners.splice(0))
+            cleanup();
+        await carrier.close();
+        peerConnection.close();
+        signaling.close(1000, 'client closed');
+    };
+    try {
+        const answerPromise = waitForAnswer(signaling, options.timeoutMs ?? 15_000, cleanupListeners);
+        peerConnection.onicecandidate = (event) => {
+            if (!event.candidate)
+                return;
+            signaling.send(JSON.stringify({
+                type: 'candidate',
+                candidate: event.candidate.candidate,
+                mid: event.candidate.sdpMid,
+            }));
+        };
+        const offer = await peerConnection.createOffer();
+        await peerConnection.setLocalDescription(offer);
+        signaling.send(JSON.stringify({ type: 'offer', sdp: offer.sdp ?? '' }));
+        debug.log('signaling.offer.sent', { sdpBytes: offer.sdp?.length ?? 0 });
+        const answer = await answerPromise;
+        assertDtlsFingerprint(ticket.hostDtlsFingerprint, answer.sdp);
+        await peerConnection.setRemoteDescription({ type: 'answer', sdp: answer.sdp });
+        for (const candidate of answer.candidates)
+            await peerConnection.addIceCandidate(candidate);
+        await waitForOpen(channel, options.timeoutMs ?? 15_000, cleanupListeners);
+        await carrier.send(encodeFrame({ type: 'hello', clientContext: null, protocolVersion: '1' }));
+        debug.log('webrtc.connected', { channelLabel: TUNNEL_DATA_CHANNEL_LABEL });
+        return { carrier, peerConnection, signaling, onClosed: (listener) => { if (closeNotified) {
+                listener(new Error('connection closed'));
+                return () => undefined;
+            } closeListeners.add(listener); return () => closeListeners.delete(listener); }, close };
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+}
+export function createSignalingUrl(baseUrl, ticket) {
+    const base = new URL(ensureWebSocketProtocol(baseUrl));
+    const pathname = base.pathname.endsWith('/') ? base.pathname : `${base.pathname}/`;
+    const url = new URL('signal', `${base.origin}${pathname}`);
+    url.searchParams.set('ticket', ticket);
+    return url.toString();
+}
+export function waitForSignalingRegistered(socket, timeoutMs, cleanup = []) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { remove(); reject(new Error('等待 Relay registered 超时')); }, timeoutMs);
+        const onMessage = (event) => {
+            const raw = event.data;
+            if (typeof raw !== 'string')
+                return;
+            try {
+                const message = JSON.parse(raw);
+                if (message.type === 'error') {
+                    clearTimeout(timer);
+                    remove();
+                    const code = message.errorCode?.trim() || 'RELAY_ERROR';
+                    const detail = message.detail?.trim();
+                    reject(new Error(detail ? `Relay ${code}: ${detail}` : `Relay ${code}`));
+                    return;
+                }
+                if (message.type !== 'registered')
+                    return;
+                clearTimeout(timer);
+                remove();
+                resolve();
+            }
+            catch { /* 忽略非 JSON 信令 */ }
+        };
+        const onClose = () => { clearTimeout(timer); remove(); reject(new Error('信令连接在 registered 前关闭')); };
+        const remove = () => { socket.removeEventListener('message', onMessage); socket.removeEventListener('close', onClose); };
+        socket.addEventListener('message', onMessage);
+        socket.addEventListener('close', onClose);
+        cleanup.push(remove);
+    });
+}
+/** Relay 只有在 Host 在线后才接受客户端 offer，避免过早发送被 HOST_NOT_CONNECTED 拒绝。 */
+export function waitForPeerReady(socket, timeoutMs, cleanup = []) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { remove(); reject(new Error('等待 Relay peer-ready 超时')); }, timeoutMs);
+        const onMessage = (event) => {
+            const raw = event.data;
+            if (typeof raw !== 'string')
+                return;
+            try {
+                const message = JSON.parse(raw);
+                if (message.type === 'peer-ready') {
+                    clearTimeout(timer);
+                    remove();
+                    resolve();
+                }
+                else if (message.type === 'error') {
+                    clearTimeout(timer);
+                    remove();
+                    reject(new Error('Relay 拒绝 peer-ready'));
+                }
+            }
+            catch { /* 忽略非 JSON 信令 */ }
+        };
+        const onClose = () => { clearTimeout(timer); remove(); reject(new Error('信令连接在 peer-ready 前关闭')); };
+        const remove = () => { socket.removeEventListener('message', onMessage); socket.removeEventListener('close', onClose); };
+        socket.addEventListener('message', onMessage);
+        socket.addEventListener('close', onClose);
+        cleanup.push(remove);
+    });
+}
+export function extractDtlsFingerprint(sdp) {
+    const match = sdp.match(/^a=fingerprint:([^\r\n]+)$/mu);
+    return match?.[1] ? normalizeFingerprint(match[1]) : null;
+}
+export function assertDtlsFingerprint(expected, sdp) {
+    const actual = extractDtlsFingerprint(sdp);
+    if (!actual || actual !== normalizeFingerprint(expected)) {
+        throw new Error('Host DTLS fingerprint 校验失败');
+    }
+}
+function waitForAnswer(socket, timeoutMs, cleanup) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('等待 Host answer 超时')), timeoutMs);
+        const candidates = [];
+        const onMessage = (event) => {
+            const raw = event.data;
+            if (typeof raw !== 'string')
+                return;
+            let message;
+            try {
+                message = JSON.parse(raw);
+            }
+            catch {
+                return;
+            }
+            if (message.type === 'answer') {
+                clearTimeout(timer);
+                remove();
+                resolve({ sdp: message.sdp, candidates });
+            }
+            else if (message.type === 'candidate') {
+                candidates.push({ candidate: message.candidate, sdpMid: message.mid });
+            }
+            else if (message.type === 'error') {
+                clearTimeout(timer);
+                remove();
+                reject(new Error(`${message.errorCode}: ${message.detail}`));
+            }
+        };
+        const onClose = () => { clearTimeout(timer); remove(); reject(new Error('信令连接已关闭')); };
+        const remove = () => {
+            socket.removeEventListener('message', onMessage);
+            socket.removeEventListener('close', onClose);
+        };
+        socket.addEventListener('message', onMessage);
+        socket.addEventListener('close', onClose);
+        cleanup.push(remove);
+    });
+}
+function waitForOpen(channel, timeoutMs, cleanup) {
+    if (channel.readyState === 'open')
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { remove(); reject(new Error('等待 DataChannel open 超时')); }, timeoutMs);
+        const onOpen = () => { clearTimeout(timer); remove(); resolve(); };
+        const onClose = () => { clearTimeout(timer); remove(); reject(new Error('DataChannel 在 ready 前关闭')); };
+        const remove = () => {
+            channel.removeEventListener('open', onOpen);
+            channel.removeEventListener('close', onClose);
+        };
+        channel.addEventListener('open', onOpen);
+        channel.addEventListener('close', onClose);
+        cleanup.push(remove);
+    });
+}
+function normalizeFingerprint(value) {
+    return value.trim().replace(/^[a-z0-9-]+(?:\s+|:)+/iu, '').replace(/[^0-9a-f]/giu, '').toLowerCase();
+}
+function ensureWebSocketProtocol(value) {
+    const url = new URL(value);
+    if (url.protocol === 'http:')
+        url.protocol = 'ws:';
+    if (url.protocol === 'https:')
+        url.protocol = 'wss:';
+    if (url.protocol !== 'ws:' && url.protocol !== 'wss:')
+        throw new Error('Relay URL 必须使用 HTTP(S) 或 WS(S)');
+    return url.toString();
+}
+//# sourceMappingURL=webrtc-client.js.map