@wetspace/wetrtc 3.0.2 → 4.0.0

package/dist/es/utils/types.d.ts

@@ -0,0 +1,46 @@
+/** 客户端事件 */
+export type WetRTCEvent = 'statechange' | 'track' | 'datachannel' | 'message' | 'error' | 'reconnecting' | 'stats';
+export type WetRTCEventMap = {
+    statechange: (state: string, prev: string) => void;
+    track: (ev: RTCTrackEvent) => void;
+    datachannel: (channel: RTCDataChannel) => void;
+    message: (data: unknown, channel: RTCDataChannel) => void;
+    error: (err: WetRTCError) => void;
+    reconnecting: (attempt: number, max: number) => void;
+    stats: (snapshot: import('../stats/types').StatsSnapshot) => void;
+};
+export type WetRTCErrorCode = 'SIGNAL_FAILED' | 'NEGOTIATION_FAILED' | 'ICE_FAILED' | 'MEDIA_FAILED' | 'DATA_FAILED' | 'RECONNECT_FAILED' | 'INTERNAL' | 'TIMEOUT';
+export interface WetRTCError {
+    code: WetRTCErrorCode;
+    message: string;
+    recoverable: boolean;
+}
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4
+}
+export interface Logger {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+export declare function createLogger(level?: LogLevel, prefix?: string): Logger;
+/** 定时器工具 */
+export declare function createTimer(callback: () => void, ms: number): IDisposable;
+import { IDisposable } from '../disposable';
+/** 退避计算 */
+export declare function backoffDelay(attempt: number, baseMs: number, maxMs: number, multiplier: number): number;
+/** 事件发射器（轻量，无依赖） */
+export declare class TypedEmitter<E extends Record<string, (...args: any[]) => void>> {
+    private handlers;
+    on<K extends keyof E>(event: K, handler: E[K]): () => void;
+    once<K extends keyof E>(event: K, handler: E[K]): void;
+    off<K extends keyof E>(event: K, handler: E[K]): void;
+    emit<K extends keyof E>(event: K, ...args: Parameters<E[K]>): void;
+    removeAll(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/es/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/utils/types.ts"],"names":[],"mappings":"AAEA,YAAY;AACZ,MAAM,MAAM,WAAW,GACnB,aAAa,GACb,OAAO,GACP,aAAa,GACb,SAAS,GACT,OAAO,GACP,cAAc,GACd,OAAO,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG;IAC3B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,KAAK,EAAE,CAAC,EAAE,EAAE,aAAa,KAAK,IAAI,CAAC;IACnC,WAAW,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAC/C,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAC1D,KAAK,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,IAAI,CAAC;IAClC,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACrD,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,gBAAgB,EAAE,aAAa,KAAK,IAAI,CAAC;CACnE,CAAC;AAEF,MAAM,MAAM,eAAe,GACvB,eAAe,GACf,oBAAoB,GACpB,YAAY,GACZ,cAAc,GACd,aAAa,GACb,kBAAkB,GAClB,UAAU,GACV,SAAS,CAAC;AAEd,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;CACtB;AAGD,oBAAY,QAAQ;IAClB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;IACT,IAAI,IAAI;CACT;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChC,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAC/B,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAC/B,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;CACjC;AAED,wBAAgB,YAAY,CAAC,KAAK,GAAE,QAAwB,EAAE,MAAM,SAAa,GAAG,MAAM,CAOzF;AAED,YAAY;AACZ,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,WAAW,CAGzE;AAED,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,WAAW;AACX,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,GACjB,MAAM,CAER;AAED,oBAAoB;AACpB,qBAAa,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;IAC1E,OAAO,CAAC,QAAQ,CAAqC;IAErD,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAQ1D,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAQtD,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAIrD,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAQlE,SAAS,IAAI,IAAI;CAGlB"}

package/dist/es/utils/types.js

@@ -0,0 +1,80 @@
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
+  return LogLevel2;
+})(LogLevel || {});
+function createLogger(level = 2 /* WARN */, prefix = "[WetRTC]") {
+  return {
+    debug(...args) {
+      if (level <= 0 /* DEBUG */)
+        console.debug(prefix, ...args);
+    },
+    info(...args) {
+      if (level <= 1 /* INFO */)
+        console.info(prefix, ...args);
+    },
+    warn(...args) {
+      if (level <= 2 /* WARN */)
+        console.warn(prefix, ...args);
+    },
+    error(...args) {
+      if (level <= 3 /* ERROR */)
+        console.error(prefix, ...args);
+    }
+  };
+}
+function createTimer(callback, ms) {
+  const id = setInterval(callback, ms);
+  return { dispose: () => clearInterval(id) };
+}
+function backoffDelay(attempt, baseMs, maxMs, multiplier) {
+  return Math.min(baseMs * Math.pow(multiplier, attempt - 1), maxMs);
+}
+class TypedEmitter {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    return () => this.handlers.get(event)?.delete(handler);
+  }
+  once(event, handler) {
+    const wrapper = (...args) => {
+      this.off(event, wrapper);
+      handler(...args);
+    };
+    this.on(event, wrapper);
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+  }
+  emit(event, ...args) {
+    const set = this.handlers.get(event);
+    if (!set)
+      return;
+    for (const fn of set) {
+      try {
+        fn(...args);
+      } catch {
+      }
+    }
+  }
+  removeAll() {
+    this.handlers.clear();
+  }
+}
+export {
+  LogLevel,
+  TypedEmitter,
+  backoffDelay,
+  createLogger,
+  createTimer
+};
+
+//# sourceMappingURL=types.js.map

package/dist/es/utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"mappings":"AAuCO,IAAK,WAAL,kBAAKA,cAAL;AACL,EAAAA,oBAAA,WAAQ,KAAR;AACA,EAAAA,oBAAA,UAAO,KAAP;AACA,EAAAA,oBAAA,UAAO,KAAP;AACA,EAAAA,oBAAA,WAAQ,KAAR;AACA,EAAAA,oBAAA,UAAO,KAAP;AALU,SAAAA;AAAA;AAeL,SAAS,aAAa,QAAkB,cAAe,SAAS,YAAoB;AACzF,SAAO;AAAA,IACL,SAAS,MAAM;AAAE,UAAI,SAAS;AAAgB,gBAAQ,MAAM,QAAQ,GAAG,IAAI;AAAA,IAAG;AAAA,IAC9E,QAAQ,MAAO;AAAE,UAAI,SAAS;AAAgB,gBAAQ,KAAK,QAAQ,GAAG,IAAI;AAAA,IAAG;AAAA,IAC7E,QAAQ,MAAO;AAAE,UAAI,SAAS;AAAgB,gBAAQ,KAAK,QAAQ,GAAG,IAAI;AAAA,IAAG;AAAA,IAC7E,SAAS,MAAM;AAAE,UAAI,SAAS;AAAgB,gBAAQ,MAAM,QAAQ,GAAG,IAAI;AAAA,IAAG;AAAA,EAChF;AACF;AAGO,SAAS,YAAY,UAAsB,IAAyB;AACzE,QAAM,KAAK,YAAY,UAAU,EAAE;AACnC,SAAO,EAAE,SAAS,MAAM,cAAc,EAAE,EAAE;AAC5C;AAKO,SAAS,aACd,SACA,QACA,OACA,YACQ;AACR,SAAO,KAAK,IAAI,SAAS,KAAK,IAAI,YAAY,UAAU,CAAC,GAAG,KAAK;AACnE;AAGO,MAAM,aAAiE;AAAA,EAAvE;AACL,SAAQ,WAAW,oBAAI,IAA4B;AAAA;AAAA,EAEnD,GAAsB,OAAU,SAA2B;AACzD,QAAI,CAAC,KAAK,SAAS,IAAI,KAAK,GAAG;AAC7B,WAAK,SAAS,IAAI,OAAO,oBAAI,IAAI,CAAC;AAAA,IACpC;AACA,SAAK,SAAS,IAAI,KAAK,EAAG,IAAI,OAAO;AACrC,WAAO,MAAM,KAAK,SAAS,IAAI,KAAK,GAAG,OAAO,OAAO;AAAA,EACvD;AAAA,EAEA,KAAwB,OAAU,SAAqB;AACrD,UAAM,UAAW,IAAI,SAAgB;AACnC,WAAK,IAAI,OAAO,OAAc;AAC9B,cAAQ,GAAG,IAAI;AAAA,IACjB;AACA,SAAK,GAAG,OAAO,OAAO;AAAA,EACxB;AAAA,EAEA,IAAuB,OAAU,SAAqB;AACpD,SAAK,SAAS,IAAI,KAAK,GAAG,OAAO,OAAO;AAAA,EAC1C;AAAA,EAEA,KAAwB,UAAa,MAA8B;AACjE,UAAM,MAAM,KAAK,SAAS,IAAI,KAAK;AACnC,QAAI,CAAC;AAAK;AACV,eAAW,MAAM,KAAK;AACpB,UAAI;AAAE,QAAC,GAAgB,GAAG,IAAI;AAAA,MAAG,QAAQ;AAAA,MAAgB;AAAA,IAC3D;AAAA,EACF;AAAA,EAEA,YAAkB;AAChB,SAAK,SAAS,MAAM;AAAA,EACtB;AACF","names":["LogLevel"],"ignoreList":[],"sources":["../../../src/utils/types.ts"],"sourcesContent":["// ── 事件与错误类型 ──\r\n\r\n/** 客户端事件 */\r\nexport type WetRTCEvent =\r\n  | 'statechange'\r\n  | 'track'\r\n  | 'datachannel'\r\n  | 'message'\r\n  | 'error'\r\n  | 'reconnecting'\r\n  | 'stats';\r\n\r\nexport type WetRTCEventMap = {\r\n  statechange: (state: string, prev: string) => void;\r\n  track: (ev: RTCTrackEvent) => void;\r\n  datachannel: (channel: RTCDataChannel) => void;\r\n  message: (data: unknown, channel: RTCDataChannel) => void;\r\n  error: (err: WetRTCError) => void;\r\n  reconnecting: (attempt: number, max: number) => void;\r\n  stats: (snapshot: import('../stats/types').StatsSnapshot) => void;\r\n};\r\n\r\nexport type WetRTCErrorCode =\r\n  | 'SIGNAL_FAILED'\r\n  | 'NEGOTIATION_FAILED'\r\n  | 'ICE_FAILED'\r\n  | 'MEDIA_FAILED'\r\n  | 'DATA_FAILED'\r\n  | 'RECONNECT_FAILED'\r\n  | 'INTERNAL'\r\n  | 'TIMEOUT';\r\n\r\nexport interface WetRTCError {\r\n  code: WetRTCErrorCode;\r\n  message: string;\r\n  recoverable: boolean;\r\n}\r\n\r\n// ── 日志 ──\r\nexport enum LogLevel {\r\n  DEBUG = 0,\r\n  INFO = 1,\r\n  WARN = 2,\r\n  ERROR = 3,\r\n  NONE = 4,\r\n}\r\n\r\nexport interface Logger {\r\n  debug(...args: unknown[]): void;\r\n  info(...args: unknown[]): void;\r\n  warn(...args: unknown[]): void;\r\n  error(...args: unknown[]): void;\r\n}\r\n\r\nexport function createLogger(level: LogLevel = LogLevel.WARN, prefix = '[WetRTC]'): Logger {\r\n  return {\r\n    debug(...args) { if (level <= LogLevel.DEBUG) console.debug(prefix, ...args); },\r\n    info(...args)  { if (level <= LogLevel.INFO)  console.info(prefix, ...args); },\r\n    warn(...args)  { if (level <= LogLevel.WARN)  console.warn(prefix, ...args); },\r\n    error(...args) { if (level <= LogLevel.ERROR) console.error(prefix, ...args); },\r\n  };\r\n}\r\n\r\n/** 定时器工具 */\r\nexport function createTimer(callback: () => void, ms: number): IDisposable {\r\n  const id = setInterval(callback, ms);\r\n  return { dispose: () => clearInterval(id) };\r\n}\r\n\r\nimport { IDisposable } from '../disposable';\r\n\r\n/** 退避计算 */\r\nexport function backoffDelay(\r\n  attempt: number,\r\n  baseMs: number,\r\n  maxMs: number,\r\n  multiplier: number,\r\n): number {\r\n  return Math.min(baseMs * Math.pow(multiplier, attempt - 1), maxMs);\r\n}\r\n\r\n/** 事件发射器（轻量，无依赖） */\r\nexport class TypedEmitter<E extends Record<string, (...args: any[]) => void>> {\r\n  private handlers = new Map<keyof E, Set<Function>>();\r\n\r\n  on<K extends keyof E>(event: K, handler: E[K]): () => void {\r\n    if (!this.handlers.has(event)) {\r\n      this.handlers.set(event, new Set());\r\n    }\r\n    this.handlers.get(event)!.add(handler);\r\n    return () => this.handlers.get(event)?.delete(handler);\r\n  }\r\n\r\n  once<K extends keyof E>(event: K, handler: E[K]): void {\r\n    const wrapper = ((...args: any[]) => {\r\n      this.off(event, wrapper as any);\r\n      handler(...args);\r\n    }) as E[K];\r\n    this.on(event, wrapper);\r\n  }\r\n\r\n  off<K extends keyof E>(event: K, handler: E[K]): void {\r\n    this.handlers.get(event)?.delete(handler);\r\n  }\r\n\r\n  emit<K extends keyof E>(event: K, ...args: Parameters<E[K]>): void {\r\n    const set = this.handlers.get(event);\r\n    if (!set) return;\r\n    for (const fn of set) {\r\n      try { (fn as Function)(...args); } catch { /* 吞掉监听器异常 */ }\r\n    }\r\n  }\r\n\r\n  removeAll(): void {\r\n    this.handlers.clear();\r\n  }\r\n}//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJtYXBwaW5ncyI6IiIsIm5hbWVzIjpbXSwiaWdub3JlTGlzdCI6W10sInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W119"]}

package/dist/es/wetrtc.d.ts

@@ -0,0 +1,92 @@
+import { ConnectionStateMachine } from './fsm';
+import type { ConnectionState } from './fsm';
+import { type IDisposable } from './disposable';
+import type { SignalConfig } from './signal/signal-manager';
+import { MediaManager } from './media/media-manager';
+import type { DisplayMediaOptions } from './media/types';
+import { type VideoEncodingOptions } from './media/video-encoding';
+import { type AudioEncodingOptions } from './media/audio-encoding';
+import { type PreferredVideoCodec, type PreferredAudioCodec } from './media/codec-preference';
+import { DataManager } from './data/data-manager';
+import type { DataChannelConfig } from './data/types';
+import { StatsMonitor } from './stats/stats-monitor';
+import type { SignalChannel } from './signal/types';
+import type { WetRTCEvent, WetRTCEventMap, WetRTCError, WetRTCErrorCode } from './utils/types';
+export type { ConnectionState };
+export type { WetRTCEvent, WetRTCEventMap, WetRTCError, WetRTCErrorCode };
+export type { SignalChannel };
+export type { VideoEncodingOptions } from './media/video-encoding';
+export type { AudioEncodingOptions } from './media/audio-encoding';
+export type { PreferredVideoCodec, PreferredAudioCodec } from './media/codec-preference';
+export interface WetRTCConfig {
+    signal: SignalChannel;
+    direction?: 'sendonly' | 'recvonly' | 'sendrecv';
+    iceServers?: RTCIceServer[];
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    polite?: boolean;
+    /** 是否主动发起 SDP 协商；默认 sendonly/sendrecv 为 true，recvonly 为 false */
+    initiator?: boolean;
+    dataChannels?: DataChannelConfig[];
+    signalConfig?: SignalConfig;
+    statsInterval?: number;
+    logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'none';
+    reconnect?: false | {
+        maxAttempts?: number;
+        baseDelay?: number;
+        maxDelay?: number;
+        backoffMultiplier?: number;
+    };
+    /** 发送端视频编码低延迟参数（屏幕共享场景） */
+    videoEncoding?: VideoEncodingOptions;
+    /** 视频编解码器偏好；h264 优先使用 H.264（Electron/Chrome 下通常走硬件编码） */
+    preferredVideoCodec?: PreferredVideoCodec;
+    /** 发送端音频编码参数（码率、优先级等） */
+    audioEncoding?: AudioEncodingOptions;
+    /** 音频编解码器偏好；opus 优先使用 Opus（WebRTC 默认语音编解码器） */
+    preferredAudioCodec?: PreferredAudioCodec;
+}
+export declare class WetRTC implements IDisposable {
+    readonly fsm: ConnectionStateMachine;
+    readonly media: MediaManager;
+    readonly data: DataManager;
+    readonly stats: StatsMonitor;
+    private events;
+    private disposables;
+    private logger;
+    private pc;
+    private signalManager;
+    private config;
+    private reconnectAttempt;
+    private pcListenerCleanup;
+    private reconnecting;
+    private reconnectTimer;
+    private screenStream;
+    constructor(config: WetRTCConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    dispose(): void;
+    on<E extends WetRTCEvent>(event: E, handler: WetRTCEventMap[E]): () => void;
+    once<E extends WetRTCEvent>(event: E, handler: WetRTCEventMap[E]): void;
+    off<E extends WetRTCEvent>(event: E, handler: WetRTCEventMap[E]): void;
+    get state(): ConnectionState;
+    get peerConnection(): RTCPeerConnection | null;
+    addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+    removeTrack(track: MediaStreamTrack): void;
+    replaceTrack(oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack): Promise<void>;
+    shareScreen(options?: DisplayMediaOptions): Promise<MediaStream>;
+    stopScreenShare(): void;
+    switchCamera(deviceId?: string): Promise<MediaStream>;
+    replaceVideoTrack(track: MediaStreamTrack): Promise<void>;
+    private rebindPeerConnection;
+    private attachPcListeners;
+    private restoreLocalTracks;
+    private addTrackToPeerConnection;
+    private scheduleReconnect;
+    private cancelReconnect;
+    private ensureTransceivers;
+    private doConnect;
+    private createPeerConnection;
+    private normalizeConfig;
+    private emitError;
+}
+//# sourceMappingURL=wetrtc.d.ts.map

package/dist/es/wetrtc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wetrtc.d.ts","sourceRoot":"","sources":["../../src/wetrtc.ts"],"names":[],"mappings":"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"}

package/dist/es/wetrtc.js

@@ -0,0 +1,403 @@
+import { ConnectionStateMachine } from "./fsm";
+import { DisposableStack } from "./disposable";
+import { SignalManager } from "./signal/signal-manager";
+import { MediaManager } from "./media/media-manager";
+import {
+  applyVideoEncodingToConnection,
+  applyVideoSenderEncoding,
+  applyVideoTrackContentHint
+} from "./media/video-encoding";
+import {
+  applyAudioEncodingToConnection,
+  applyAudioSenderEncoding
+} from "./media/audio-encoding";
+import {
+  applyH264CodecPreference,
+  applyH264CodecPreferences,
+  applyOpusCodecPreference,
+  applyOpusCodecPreferences
+} from "./media/codec-preference";
+import { DataManager } from "./data/data-manager";
+import { StatsMonitor } from "./stats/stats-monitor";
+import { TypedEmitter, createLogger } from "./utils/types";
+const DEFAULT_ICE_SERVERS = [
+  { urls: "stun:stun.l.google.com:19302" }
+];
+const DEFAULT_RECONNECT = {
+  maxAttempts: 5,
+  baseDelay: 1e3,
+  maxDelay: 3e4,
+  backoffMultiplier: 2
+};
+class WetRTC {
+  constructor(config) {
+    this.events = new TypedEmitter();
+    this.disposables = new DisposableStack();
+    this.pc = null;
+    this.reconnectAttempt = 0;
+    this.pcListenerCleanup = null;
+    this.reconnecting = false;
+    this.reconnectTimer = null;
+    this.screenStream = null;
+    this.config = this.normalizeConfig(config);
+    this.logger = createLogger(
+      config.logLevel === "debug" ? 0 : config.logLevel === "info" ? 1 : config.logLevel === "none" ? 4 : 2
+    );
+    this.fsm = new ConnectionStateMachine();
+    this.media = new MediaManager();
+    this.pc = this.createPeerConnection();
+    this.data = new DataManager(this.pc);
+    this.stats = new StatsMonitor(this.pc, {
+      interval: this.config.statsInterval || void 0
+    });
+    this.fsm.onChange((newState, prev) => {
+      this.events.emit("statechange", newState, prev);
+    });
+    this.signalManager = new SignalManager(
+      this.config.signal,
+      this.pc,
+      this.fsm,
+      this.config.polite,
+      this.config.signalConfig
+    );
+    this.attachPcListeners(this.pc);
+    if (this.config.dataChannels.length > 0) {
+      this.data.configureChannels(this.config.dataChannels);
+    }
+    this.data.onMessage((data, label) => {
+      const channel = label ? this.data.getChannel(label) : void 0;
+      this.events.emit("message", data, channel);
+    });
+    this.stats.onStats((snapshot) => {
+      this.events.emit("stats", snapshot);
+    });
+    this.disposables.push(this.fsm);
+    this.disposables.push(this.media);
+    this.disposables.push(this.data);
+    this.disposables.push(this.stats);
+    this.logger.info("WetRTC initialized", { direction: this.config.direction });
+  }
+  async connect() {
+    if (!this.fsm.is("idle", "failed")) {
+      throw new Error(`Cannot connect in state "${this.fsm.state}"`);
+    }
+    this.reconnectAttempt = 0;
+    return this.doConnect();
+  }
+  async disconnect() {
+    this.logger.info("Disconnecting");
+    this.stats.stop();
+    this.cancelReconnect();
+    try {
+      await this.config.signal.send({ type: "bye" });
+    } catch (err) {
+      this.logger.warn("Failed to send bye:", err);
+    }
+    this.rebindPeerConnection();
+    this.fsm.force("idle");
+  }
+  dispose() {
+    this.logger.info("Disposing WetRTC");
+    this.stats.stop();
+    this.cancelReconnect();
+    this.screenStream?.getTracks().forEach((track) => track.stop());
+    this.screenStream = null;
+    this.pcListenerCleanup?.();
+    this.pcListenerCleanup = null;
+    this.signalManager.dispose();
+    this.pc?.close();
+    this.pc = null;
+    this.disposables.dispose();
+    this.events.removeAll();
+    this.fsm.force("disposed");
+  }
+  on(event, handler) {
+    return this.events.on(event, handler);
+  }
+  once(event, handler) {
+    this.events.once(event, handler);
+  }
+  off(event, handler) {
+    this.events.off(event, handler);
+  }
+  get state() {
+    return this.fsm.state;
+  }
+  get peerConnection() {
+    return this.pc;
+  }
+  addTrack(track, stream) {
+    if (track.kind === "video" && this.config.videoEncoding) {
+      applyVideoTrackContentHint(
+        track,
+        this.config.videoEncoding.contentHint ?? "motion"
+      );
+    }
+    this.media.addTrack(track, stream);
+    this.addTrackToPeerConnection(track, stream);
+  }
+  removeTrack(track) {
+    const sender = this.pc?.getSenders().find((s) => s.track === track);
+    if (sender) {
+      this.pc?.removeTrack(sender);
+    }
+    this.media.removeTrack(track);
+  }
+  async replaceTrack(oldTrack, newTrack) {
+    const sender = this.pc?.getSenders().find((s) => s.track === oldTrack);
+    if (sender) {
+      await sender.replaceTrack(newTrack);
+    }
+    this.media.replaceTrack(oldTrack, newTrack);
+  }
+  async shareScreen(options) {
+    try {
+      const stream = await this.media.getDisplayMedia(options);
+      this.screenStream = stream;
+      for (const track of stream.getTracks()) {
+        this.addTrack(track, stream);
+      }
+      stream.getVideoTracks()[0]?.addEventListener("ended", () => {
+        this.stopScreenShare();
+      }, { once: true });
+      return stream;
+    } catch (err) {
+      this.emitError("MEDIA_FAILED", err.message, true);
+      throw err;
+    }
+  }
+  stopScreenShare() {
+    if (!this.screenStream)
+      return;
+    for (const track of this.screenStream.getTracks()) {
+      this.removeTrack(track);
+    }
+    this.screenStream = null;
+  }
+  async switchCamera(deviceId) {
+    const stream = await this.media.getUserMedia({
+      video: deviceId ? { deviceId: { exact: deviceId } } : true,
+      audio: false
+    });
+    const nextVideo = stream.getVideoTracks()[0];
+    const currentVideo = this.media.getLocalTracks("video")[0];
+    if (currentVideo && nextVideo) {
+      await this.replaceVideoTrack(nextVideo);
+    } else if (nextVideo) {
+      this.addTrack(nextVideo, stream);
+    }
+    return stream;
+  }
+  async replaceVideoTrack(track) {
+    const current = this.media.getLocalTracks("video")[0];
+    if (!current) {
+      const stream = new MediaStream([track]);
+      this.addTrack(track, stream);
+      return;
+    }
+    await this.replaceTrack(current, track);
+  }
+  // ── private ──
+  rebindPeerConnection() {
+    this.pcListenerCleanup?.();
+    this.pc?.close();
+    const pc = this.createPeerConnection();
+    this.pc = pc;
+    this.signalManager.setPeerConnection(pc);
+    this.data.setPeerConnection(pc);
+    this.stats.setPeerConnection(pc);
+    this.attachPcListeners(pc);
+    this.restoreLocalTracks(pc);
+    if (this.config.dataChannels.length > 0) {
+      this.data.configureChannels(this.config.dataChannels);
+    }
+    return pc;
+  }
+  attachPcListeners(pc) {
+    const onTrack = (ev) => {
+      if (ev.streams[0]) {
+        this.media.addRemoteStream(ev.streams[0]);
+      }
+      this.events.emit("track", ev);
+    };
+    const onDataChannel = (ev) => {
+      this.data.registerRemoteChannel(ev);
+      this.events.emit("datachannel", ev.channel);
+    };
+    const onIceDisconnected = () => {
+      if (this.pc !== pc)
+        return;
+      if (pc.iceConnectionState === "disconnected" && this.config.reconnect !== false) {
+        this.scheduleReconnect();
+      }
+    };
+    const onConnectionStateChange = () => {
+      if (this.pc !== pc || pc.connectionState !== "connected")
+        return;
+      if (this.config.videoEncoding) {
+        void applyVideoEncodingToConnection(pc, this.config.videoEncoding);
+      }
+      if (this.config.audioEncoding) {
+        void applyAudioEncodingToConnection(pc, this.config.audioEncoding);
+      }
+    };
+    pc.addEventListener("track", onTrack);
+    pc.addEventListener("datachannel", onDataChannel);
+    pc.addEventListener("iceconnectionstatechange", onIceDisconnected);
+    pc.addEventListener("connectionstatechange", onConnectionStateChange);
+    this.pcListenerCleanup = () => {
+      pc.removeEventListener("track", onTrack);
+      pc.removeEventListener("datachannel", onDataChannel);
+      pc.removeEventListener("iceconnectionstatechange", onIceDisconnected);
+      pc.removeEventListener("connectionstatechange", onConnectionStateChange);
+    };
+  }
+  restoreLocalTracks(pc) {
+    const stream = this.media.getLocalStream();
+    if (!stream)
+      return;
+    for (const track of this.media.getLocalTracks()) {
+      this.addTrackToPeerConnection(track, stream, pc);
+    }
+  }
+  addTrackToPeerConnection(track, stream, pc = this.pc) {
+    if (!pc)
+      return;
+    const sender = pc.addTrack(track, stream);
+    const transceiver = pc.getTransceivers().find((t) => t.sender === sender);
+    if (!transceiver)
+      return;
+    if (this.config.direction === "sendonly") {
+      transceiver.direction = "sendonly";
+    } else if (this.config.direction === "sendrecv") {
+      transceiver.direction = "sendrecv";
+    }
+    if (track.kind === "video" && this.config.videoEncoding) {
+      void applyVideoSenderEncoding(sender, this.config.videoEncoding);
+    }
+    if (track.kind === "audio" && this.config.audioEncoding) {
+      void applyAudioSenderEncoding(sender, this.config.audioEncoding);
+    }
+    if (track.kind === "video" && this.config.preferredVideoCodec === "h264") {
+      applyH264CodecPreference(transceiver);
+    }
+    if (track.kind === "audio" && this.config.preferredAudioCodec === "opus") {
+      applyOpusCodecPreference(transceiver);
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnecting)
+      return;
+    const { maxAttempts = 5, baseDelay = 1e3, maxDelay = 3e4, backoffMultiplier = 2 } = this.config.reconnect === false ? DEFAULT_RECONNECT : this.config.reconnect;
+    if (this.reconnectAttempt >= maxAttempts) {
+      this.logger.error("Max reconnect attempts reached");
+      this.fsm.transition("failed");
+      this.emitError("RECONNECT_FAILED", "Max reconnect attempts reached", false);
+      return;
+    }
+    this.reconnecting = true;
+    this.reconnectAttempt++;
+    const delay = Math.min(
+      baseDelay * Math.pow(backoffMultiplier, this.reconnectAttempt - 1),
+      maxDelay
+    );
+    this.logger.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt}/${maxAttempts})`);
+    this.events.emit("reconnecting", this.reconnectAttempt, maxAttempts);
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        this.stats.stop();
+        this.rebindPeerConnection();
+        this.fsm.force("idle");
+        await this.doConnect();
+        this.reconnecting = false;
+        this.reconnectTimer = null;
+      } catch {
+        this.reconnecting = false;
+        this.reconnectTimer = null;
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  cancelReconnect() {
+    this.reconnecting = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  ensureTransceivers() {
+    if (!this.pc || this.config.direction !== "recvonly")
+      return;
+    if (this.pc.getTransceivers().length > 0)
+      return;
+    const videoTransceiver = this.pc.addTransceiver("video", { direction: "recvonly" });
+    const audioTransceiver = this.pc.addTransceiver("audio", { direction: "recvonly" });
+    if (this.config.preferredVideoCodec === "h264") {
+      applyH264CodecPreference(videoTransceiver);
+    }
+    if (this.config.preferredAudioCodec === "opus") {
+      applyOpusCodecPreference(audioTransceiver);
+    }
+  }
+  async doConnect() {
+    try {
+      this.fsm.transition("signaling");
+      this.stats.start();
+      this.ensureTransceivers();
+      if (this.config.preferredVideoCodec === "h264" && this.pc) {
+        applyH264CodecPreferences(this.pc);
+      }
+      if (this.config.preferredAudioCodec === "opus" && this.pc) {
+        applyOpusCodecPreferences(this.pc);
+      }
+      if (this.config.initiator) {
+        this.data.initConfiguredChannels();
+        await this.signalManager.createOffer();
+      } else {
+        this.logger.info("Waiting for remote offer (passive)");
+      }
+    } catch (err) {
+      this.emitError("NEGOTIATION_FAILED", err.message, true);
+      throw err;
+    }
+  }
+  createPeerConnection() {
+    const config = {
+      iceServers: this.config.iceServers
+    };
+    if (this.config.iceTransportPolicy) {
+      config.iceTransportPolicy = this.config.iceTransportPolicy;
+    }
+    return new RTCPeerConnection(config);
+  }
+  normalizeConfig(config) {
+    return {
+      signal: config.signal,
+      direction: config.direction ?? "sendrecv",
+      iceServers: config.iceServers ?? DEFAULT_ICE_SERVERS,
+      iceTransportPolicy: config.iceTransportPolicy,
+      polite: config.polite ?? config.direction === "sendonly",
+      initiator: config.initiator ?? config.direction !== "recvonly",
+      dataChannels: config.dataChannels ?? [],
+      signalConfig: config.signalConfig ?? {},
+      reconnect: config.reconnect === false ? false : { ...DEFAULT_RECONNECT, ...config.reconnect },
+      statsInterval: config.statsInterval ?? 2e3,
+      videoEncoding: config.videoEncoding,
+      preferredVideoCodec: config.preferredVideoCodec ?? "auto",
+      audioEncoding: config.audioEncoding,
+      preferredAudioCodec: config.preferredAudioCodec ?? "auto"
+    };
+  }
+  emitError(code, message, recoverable) {
+    this.events.emit("error", {
+      code,
+      message: `[WetRTC] ${code}: ${message}`,
+      recoverable
+    });
+  }
+}
+export {
+  WetRTC
+};
+
+//# sourceMappingURL=wetrtc.js.map