@marianmeres/webrtc 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marian Meres
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,408 @@
+# @marianmeres/webrtc
+
+> **Full Disclosure:** This code was written by Claude (Anthropic's AI). The human (that is @marianmeres) just asked nicely, occasionally said "thanks", and went through about 47 iterations of "could you improve this", "what about that", and "make it more Svelte-friendly". To be fair, the prompt engineering was top-notch. So if you find bugs, we'll split the blame 50/50. If it works perfectly, Claude gets 95% of the credit and @marianmeres gets the remaining 5% for excellent taste in asking the right questions. 🤖
+
+A lightweight, framework-agnostic WebRTC manager with state machine-based lifecycle management and event-driven architecture.
+
+## Features
+
+- **State Machine-based**: Clean state transitions (IDLE → INITIALIZING → CONNECTING → CONNECTED)
+- **Event-driven**: Subscribe to specific events or overall state changes
+- **Svelte Store Compatible**: Works seamlessly with Svelte's reactive `$` syntax
+- **Audio Management**: Microphone enable/disable, device switching, device change detection
+- **Data Channels**: Easy creation and management of RTCDataChannels
+- **Auto-reconnection**: Optional automatic reconnection with exponential backoff
+- **TypeScript**: Full type safety and excellent IDE support
+
+## Installation
+
+```bash
+npm install @marianmeres/webrtc
+```
+
+## High-Level Overview
+
+The `WebRtcManager` class handles the complete WebRTC connection lifecycle:
+
+1. **Initialization**: Sets up RTCPeerConnection, media streams, and data channels
+2. **Connection Management**: Handles state transitions, reconnection, and cleanup
+3. **Signaling**: Provides methods for offer/answer exchange and ICE candidate handling
+4. **Media Control**: Manages local/remote streams and microphone switching
+5. **Events**: Emits events for all important state changes
+
+The manager doesn't handle the signaling transport layer - you're responsible for sending/receiving offers, answers, and ICE candidates through your own signaling mechanism (WebSocket, HTTP, etc.).
+
+## Core API
+
+### Constructor
+
+```typescript
+const manager = new WebRtcManager(factory, config);
+```
+
+- `factory`: Object implementing `WebRtcFactory` interface (provides `createPeerConnection`, `getUserMedia`, `enumerateDevices`)
+- `config`: Optional configuration object
+
+**Configuration Options:**
+- `peerConfig`: RTCConfiguration (ICE servers, etc.)
+- `enableMicrophone`: Enable microphone on initialization (default: false)
+- `dataChannelLabel`: Create a default data channel with this label
+- `autoReconnect`: Enable automatic reconnection (default: false)
+- `maxReconnectAttempts`: Max reconnection attempts (default: 5)
+- `reconnectDelay`: Initial reconnection delay in ms (default: 1000)
+- `debug`: Enable debug logging (default: false)
+
+### State and Properties
+
+```typescript
+manager.state                 // Current WebRtcState
+manager.localStream           // MediaStream | null
+manager.remoteStream          // MediaStream | null
+manager.dataChannels          // ReadonlyMap<string, RTCDataChannel>
+manager.peerConnection        // RTCPeerConnection | null
+```
+
+### Lifecycle Methods
+
+```typescript
+await manager.initialize()    // Initialize peer connection
+await manager.connect()       // Transition to CONNECTING state
+manager.disconnect()          // Disconnect and cleanup
+manager.reset()               // Reset to IDLE state
+```
+
+### Audio Methods
+
+```typescript
+await manager.enableMicrophone(true)           // Enable/disable microphone
+await manager.switchMicrophone(deviceId)       // Switch to different audio input
+await manager.getAudioInputDevices()           // Get available audio inputs
+```
+
+### Signaling Methods
+
+```typescript
+const offer = await manager.createOffer()
+const answer = await manager.createAnswer()
+await manager.setLocalDescription(offer)
+await manager.setRemoteDescription(answer)
+await manager.addIceCandidate(candidate)
+await manager.iceRestart()                     // Trigger ICE restart
+```
+
+### Data Channel Methods
+
+```typescript
+const dc = manager.createDataChannel(label, options)
+const dc = manager.getDataChannel(label)
+manager.sendData(label, data)                  // Returns boolean
+```
+
+### Event Subscription
+
+```typescript
+// Subscribe to specific event
+const unsub = manager.on(WebRtcManager.EVENT_STATE_CHANGE, (state) => {
+  console.log('State changed:', state);
+});
+
+// Subscribe to overall state (Svelte store compatible)
+const unsub = manager.subscribe((state) => {
+  console.log('Overall state:', state);
+  // state = { state, localStream, remoteStream, dataChannels, peerConnection }
+});
+```
+
+**Available Event Constants:**
+- `EVENT_STATE_CHANGE`
+- `EVENT_LOCAL_STREAM`
+- `EVENT_REMOTE_STREAM`
+- `EVENT_DATA_CHANNEL_OPEN`
+- `EVENT_DATA_CHANNEL_MESSAGE`
+- `EVENT_DATA_CHANNEL_CLOSE`
+- `EVENT_ICE_CANDIDATE`
+- `EVENT_RECONNECTING`
+- `EVENT_RECONNECT_FAILED`
+- `EVENT_DEVICE_CHANGED`
+- `EVENT_MICROPHONE_FAILED`
+- `EVENT_ERROR`
+
+## Examples
+
+### Basic Usage (Vanilla JavaScript)
+
+```typescript
+import { WebRtcManager, WebRtcState } from '@marianmeres/webrtc';
+
+// Create factory (browser implementation)
+const factory = {
+  createPeerConnection: (config) => new RTCPeerConnection(config),
+  getUserMedia: (constraints) => navigator.mediaDevices.getUserMedia(constraints),
+  enumerateDevices: () => navigator.mediaDevices.enumerateDevices(),
+};
+
+// Create manager
+const manager = new WebRtcManager(factory, {
+  peerConfig: {
+    iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+  },
+  enableMicrophone: true,
+  autoReconnect: true,
+});
+
+// Subscribe to events
+manager.on(WebRtcManager.EVENT_ICE_CANDIDATE, (candidate) => {
+  // Send candidate to remote peer via your signaling channel
+  signalingChannel.send({ type: 'candidate', candidate });
+});
+
+manager.on(WebRtcManager.EVENT_REMOTE_STREAM, (stream) => {
+  // Attach remote stream to audio element
+  audioElement.srcObject = stream;
+});
+
+// Initialize and create offer
+await manager.initialize();
+await manager.connect();
+const offer = await manager.createOffer();
+await manager.setLocalDescription(offer);
+
+// Send offer to remote peer via your signaling channel
+signalingChannel.send({ type: 'offer', offer });
+
+// Handle incoming signaling messages
+signalingChannel.onmessage = async (msg) => {
+  if (msg.type === 'answer') {
+    await manager.setRemoteDescription(msg.answer);
+  } else if (msg.type === 'candidate') {
+    await manager.addIceCandidate(msg.candidate);
+  }
+};
+```
+
+### Svelte 5 Integration
+
+```svelte
+<script>
+  import { WebRtcManager, WebRtcState } from '@marianmeres/webrtc';
+  import { onMount } from 'svelte';
+
+  const factory = {
+    createPeerConnection: (config) => new RTCPeerConnection(config),
+    getUserMedia: (constraints) => navigator.mediaDevices.getUserMedia(constraints),
+    enumerateDevices: () => navigator.mediaDevices.enumerateDevices(),
+  };
+
+  const manager = new WebRtcManager(factory, {
+    peerConfig: {
+      iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+    },
+    enableMicrophone: true,
+  });
+
+  // Subscribe to overall state (Svelte store compatible!)
+  const managerState = $derived(manager.subscribe((state) => state));
+
+  // Or use individual event subscriptions
+  let devices = $state([]);
+
+  onMount(() => {
+    const unsubDevices = manager.on(
+      WebRtcManager.EVENT_DEVICE_CHANGED,
+      (devs) => devices = devs
+    );
+
+    return () => {
+      unsubDevices();
+      manager.disconnect();
+    };
+  });
+
+  async function startCall() {
+    await manager.initialize();
+    await manager.connect();
+    const offer = await manager.createOffer();
+    await manager.setLocalDescription(offer);
+    // Send offer via your signaling channel
+  }
+
+  async function switchMic(deviceId) {
+    await manager.switchMicrophone(deviceId);
+  }
+</script>
+
+<div>
+  <p>State: {$managerState.state}</p>
+  <p>Microphone: {$managerState.localStream ? 'Enabled' : 'Disabled'}</p>
+
+  <button onclick={startCall}>Start Call</button>
+
+  <select onchange={(e) => switchMic(e.target.value)}>
+    {#each devices as device}
+      <option value={device.deviceId}>{device.label}</option>
+    {/each}
+  </select>
+
+  <audio bind:this={remoteAudio} autoplay></audio>
+</div>
+```
+
+### Complete Peer-to-Peer Example
+
+```typescript
+import { WebRtcManager } from '@marianmores/webrtc';
+
+class P2PConnection {
+  manager: WebRtcManager;
+  signalingChannel: WebSocket;
+
+  constructor(signalingUrl: string) {
+    this.manager = new WebRtcManager(
+      {
+        createPeerConnection: (config) => new RTCPeerConnection(config),
+        getUserMedia: (constraints) => navigator.mediaDevices.getUserMedia(constraints),
+        enumerateDevices: () => navigator.mediaDevices.enumerateDevices(),
+      },
+      {
+        peerConfig: {
+          iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+        },
+        enableMicrophone: true,
+        dataChannelLabel: 'chat',
+        autoReconnect: true,
+      }
+    );
+
+    this.signalingChannel = new WebSocket(signalingUrl);
+    this.setupSignaling();
+    this.setupManagerEvents();
+  }
+
+  setupSignaling() {
+    this.signalingChannel.onmessage = async (event) => {
+      const msg = JSON.parse(event.data);
+
+      switch (msg.type) {
+        case 'offer':
+          await this.handleOffer(msg.offer);
+          break;
+        case 'answer':
+          await this.manager.setRemoteDescription(msg.answer);
+          break;
+        case 'candidate':
+          await this.manager.addIceCandidate(msg.candidate);
+          break;
+      }
+    };
+  }
+
+  setupManagerEvents() {
+    // Send ICE candidates to remote peer
+    this.manager.on(WebRtcManager.EVENT_ICE_CANDIDATE, (candidate) => {
+      this.signalingChannel.send(JSON.stringify({
+        type: 'candidate',
+        candidate,
+      }));
+    });
+
+    // Handle remote audio stream
+    this.manager.on(WebRtcManager.EVENT_REMOTE_STREAM, (stream) => {
+      const audio = document.getElementById('remote-audio') as HTMLAudioElement;
+      audio.srcObject = stream;
+    });
+
+    // Handle data channel messages
+    this.manager.on(WebRtcManager.EVENT_DATA_CHANNEL_MESSAGE, ({ data }) => {
+      console.log('Received message:', data);
+    });
+
+    // Handle reconnection
+    this.manager.on(WebRtcManager.EVENT_RECONNECTING, ({ attempt, strategy }) => {
+      console.log(`Reconnecting (attempt ${attempt}, strategy: ${strategy})`);
+      if (strategy === 'full') {
+        // For full reconnection, we need to re-do the signaling handshake
+        this.createOffer();
+      }
+    });
+  }
+
+  async createOffer() {
+    await this.manager.initialize();
+    await this.manager.connect();
+    const offer = await this.manager.createOffer();
+    await this.manager.setLocalDescription(offer);
+
+    this.signalingChannel.send(JSON.stringify({
+      type: 'offer',
+      offer,
+    }));
+  }
+
+  async handleOffer(offer: RTCSessionDescriptionInit) {
+    await this.manager.initialize();
+    await this.manager.setRemoteDescription(offer);
+    const answer = await this.manager.createAnswer();
+    await this.manager.setLocalDescription(answer);
+
+    this.signalingChannel.send(JSON.stringify({
+      type: 'answer',
+      answer,
+    }));
+  }
+
+  sendMessage(text: string) {
+    this.manager.sendData('chat', text);
+  }
+
+  disconnect() {
+    this.manager.disconnect();
+    this.signalingChannel.close();
+  }
+}
+
+// Usage
+const connection = new P2PConnection('wss://your-signaling-server.com');
+await connection.createOffer();
+connection.sendMessage('Hello!');
+```
+
+## State Machine
+
+The manager uses a finite state machine with the following states:
+
+![State Diagram](states.png "State Diagram")
+
+## Testing
+
+The project includes two types of tests:
+
+### Unit Tests (Deno)
+
+Mock-based tests for the manager's logic and state transitions:
+
+```bash
+deno task test
+```
+
+### Browser Integration Tests
+
+Real peer-to-peer connection tests running in a browser environment:
+
+```bash
+deno task test:browser
+```
+
+This builds the test bundle and starts a local server. Open the provided URL in your browser to run the tests interactively.
+
+The browser tests verify:
+- Actual P2P connections between peers
+- Data channel message exchange
+- ICE candidate exchange
+- Connection state transitions
+- Resource cleanup
+
+See [tests/browser/README.md](tests/browser/README.md) for more details.
+
+## License
+
+MIT

package/dist/mod.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./webrtc-manager.js";

package/dist/mod.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./webrtc-manager.js";

package/dist/types.d.ts

@@ -0,0 +1,70 @@
+export interface WebRtcManagerConfig {
+    /** Initial peer configuration (ICE servers, etc.) */
+    peerConfig?: RTCConfiguration;
+    /** Whether to enable microphone initially. Defaults to false. */
+    enableMicrophone?: boolean;
+    /** Label for the default data channel. If provided, a data channel will be created on connect. */
+    dataChannelLabel?: string;
+    /** Enable automatic reconnection on connection failure. Defaults to false. */
+    autoReconnect?: boolean;
+    /** Maximum number of reconnection attempts. Defaults to 5. */
+    maxReconnectAttempts?: number;
+    /** Initial reconnection delay in ms. Doubles with each attempt. Defaults to 1000. */
+    reconnectDelay?: number;
+    /** Debug mode for logging */
+    debug?: boolean;
+}
+export interface WebRtcFactory {
+    createPeerConnection(config?: RTCConfiguration): RTCPeerConnection;
+    getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>;
+    enumerateDevices(): Promise<MediaDeviceInfo[]>;
+}
+export declare enum WebRtcState {
+    IDLE = "IDLE",
+    INITIALIZING = "INITIALIZING",
+    CONNECTING = "CONNECTING",
+    CONNECTED = "CONNECTED",
+    RECONNECTING = "RECONNECTING",
+    DISCONNECTED = "DISCONNECTED",
+    ERROR = "ERROR"
+}
+export declare enum WebRtcFsmEvent {
+    INIT = "initialize",
+    CONNECT = "connect",
+    CONNECTED = "connected",
+    RECONNECTING = "reconnecting",
+    DISCONNECT = "disconnect",
+    ERROR = "error",
+    RESET = "reset"
+}
+export interface WebRtcEvents {
+    state_change: WebRtcState;
+    local_stream: MediaStream | null;
+    remote_stream: MediaStream | null;
+    data_channel_open: RTCDataChannel;
+    data_channel_message: {
+        channel: RTCDataChannel;
+        data: any;
+    };
+    data_channel_close: RTCDataChannel;
+    ice_candidate: RTCIceCandidate | null;
+    /**
+     * Emitted when reconnection is being attempted.
+     * For 'full' strategy reconnections, consumers should listen for this event
+     * and re-establish signaling (create new offer/answer exchange).
+     * The manager will call connect() but cannot handle the signaling automatically.
+     */
+    reconnecting: {
+        attempt: number;
+        strategy: "ice-restart" | "full";
+    };
+    reconnect_failed: {
+        attempts: number;
+    };
+    device_changed: MediaDeviceInfo[];
+    microphone_failed: {
+        error?: any;
+        reason?: string;
+    };
+    error: Error;
+}

package/dist/types.js

@@ -0,0 +1,20 @@
+export var WebRtcState;
+(function (WebRtcState) {
+    WebRtcState["IDLE"] = "IDLE";
+    WebRtcState["INITIALIZING"] = "INITIALIZING";
+    WebRtcState["CONNECTING"] = "CONNECTING";
+    WebRtcState["CONNECTED"] = "CONNECTED";
+    WebRtcState["RECONNECTING"] = "RECONNECTING";
+    WebRtcState["DISCONNECTED"] = "DISCONNECTED";
+    WebRtcState["ERROR"] = "ERROR";
+})(WebRtcState || (WebRtcState = {}));
+export var WebRtcFsmEvent;
+(function (WebRtcFsmEvent) {
+    WebRtcFsmEvent["INIT"] = "initialize";
+    WebRtcFsmEvent["CONNECT"] = "connect";
+    WebRtcFsmEvent["CONNECTED"] = "connected";
+    WebRtcFsmEvent["RECONNECTING"] = "reconnecting";
+    WebRtcFsmEvent["DISCONNECT"] = "disconnect";
+    WebRtcFsmEvent["ERROR"] = "error";
+    WebRtcFsmEvent["RESET"] = "reset";
+})(WebRtcFsmEvent || (WebRtcFsmEvent = {}));

package/dist/webrtc-manager.d.ts

@@ -0,0 +1,158 @@
+import { type WebRtcFactory, type WebRtcManagerConfig, WebRtcState, type WebRtcEvents } from "./types.js";
+export declare class WebRtcManager {
+    #private;
+    static readonly EVENT_STATE_CHANGE = "state_change";
+    static readonly EVENT_LOCAL_STREAM = "local_stream";
+    static readonly EVENT_REMOTE_STREAM = "remote_stream";
+    static readonly EVENT_DATA_CHANNEL_OPEN = "data_channel_open";
+    static readonly EVENT_DATA_CHANNEL_MESSAGE = "data_channel_message";
+    static readonly EVENT_DATA_CHANNEL_CLOSE = "data_channel_close";
+    static readonly EVENT_ICE_CANDIDATE = "ice_candidate";
+    static readonly EVENT_RECONNECTING = "reconnecting";
+    static readonly EVENT_RECONNECT_FAILED = "reconnect_failed";
+    static readonly EVENT_DEVICE_CHANGED = "device_changed";
+    static readonly EVENT_MICROPHONE_FAILED = "microphone_failed";
+    static readonly EVENT_ERROR = "error";
+    constructor(factory: WebRtcFactory, config?: WebRtcManagerConfig);
+    /** Returns the current state of the WebRTC connection. */
+    get state(): WebRtcState;
+    /** Returns a readonly map of all active data channels indexed by label. */
+    get dataChannels(): ReadonlyMap<string, RTCDataChannel>;
+    /** Returns the local media stream, or null if not initialized. */
+    get localStream(): MediaStream | null;
+    /** Returns the remote media stream, or null if not connected. */
+    get remoteStream(): MediaStream | null;
+    /** Returns the underlying RTCPeerConnection, or null if not initialized. */
+    get peerConnection(): RTCPeerConnection | null;
+    /** Returns a Mermaid diagram representation of the FSM state machine. */
+    toMermaid(): string;
+    /**
+     * Subscribe to a specific WebRTC event.
+     * @returns Unsubscribe function to remove the event listener.
+     */
+    on(event: keyof WebRtcEvents, handler: (data: any) => void): () => void;
+    /**
+     * Subscribe to the overall state of the WebRTC manager.
+     * Compatible with Svelte stores - immediately calls handler with current state,
+     * then notifies on any changes to state, streams, or data channels.
+     * @param handler - Callback that receives the overall state object
+     * @returns Unsubscribe function to remove the event listener.
+     */
+    subscribe(handler: (state: {
+        state: WebRtcState;
+        localStream: MediaStream | null;
+        remoteStream: MediaStream | null;
+        dataChannels: ReadonlyMap<string, RTCDataChannel>;
+        peerConnection: RTCPeerConnection | null;
+    }) => void): () => void;
+    /**
+     * Retrieves all available audio input devices.
+     * @returns Array of audio input devices, or empty array on error.
+     */
+    getAudioInputDevices(): Promise<MediaDeviceInfo[]>;
+    /**
+     * Switches the active microphone to a different audio input device.
+     * @param deviceId - The device ID of the audio input to switch to.
+     * @returns True if the switch was successful, false otherwise.
+     */
+    switchMicrophone(deviceId: string): Promise<boolean>;
+    /**
+     * Initializes the WebRTC peer connection and sets up media tracks.
+     * Must be called before creating offers or answers. Can only be called from IDLE state.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Transitions to the CONNECTING state. Automatically initializes if needed.
+     * If disconnected, reinitializes the peer connection.
+     */
+    connect(): Promise<void>;
+    /**
+     * Enables or disables the microphone and adds/removes audio tracks to the peer connection.
+     * @param enable - True to enable microphone, false to disable.
+     * @returns True if successful, false if failed to get user media.
+     */
+    enableMicrophone(enable: boolean): Promise<boolean>;
+    /**
+     * Disconnects the peer connection and cleans up all resources.
+     * Transitions to DISCONNECTED state.
+     */
+    disconnect(): void;
+    /**
+     * Resets the manager to IDLE state from any state.
+     * Cleans up all resources and allows reinitialization.
+     */
+    reset(): void;
+    /**
+     * Creates a new data channel with the specified label.
+     * Returns existing channel if one with the same label already exists.
+     * @param label - The label for the data channel.
+     * @param options - Optional RTCDataChannelInit configuration.
+     * @returns The created data channel, or null if peer connection not initialized.
+     */
+    createDataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel | null;
+    /**
+     * Retrieves an existing data channel by label.
+     * @param label - The label of the data channel to retrieve.
+     * @returns The data channel if found, undefined otherwise.
+     */
+    getDataChannel(label: string): RTCDataChannel | undefined;
+    /**
+     * Sends data through a data channel identified by label.
+     * Checks that the channel exists and is in open state before sending.
+     * @param label - The label of the data channel to send through.
+     * @param data - The data to send (string, Blob, or ArrayBuffer).
+     * @returns True if data was sent successfully, false otherwise.
+     */
+    sendData(label: string, data: string | Blob | ArrayBuffer | ArrayBufferView<ArrayBuffer>): boolean;
+    /**
+     * Creates an SDP offer for initiating a WebRTC connection.
+     * @param options - Optional offer configuration.
+     * @returns The offer SDP, or null if peer connection not initialized.
+     */
+    createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit | null>;
+    /**
+     * Creates an SDP answer in response to a received offer.
+     * @param options - Optional answer configuration.
+     * @returns The answer SDP, or null if peer connection not initialized.
+     */
+    createAnswer(options?: RTCAnswerOptions): Promise<RTCSessionDescriptionInit | null>;
+    /**
+     * Sets the local description for the peer connection.
+     * @param description - The SDP description (offer or answer).
+     * @returns True if successful, false otherwise.
+     */
+    setLocalDescription(description: RTCSessionDescriptionInit): Promise<boolean>;
+    /**
+     * Sets the remote description received from the peer.
+     * @param description - The remote SDP description.
+     * @returns True if successful, false otherwise.
+     */
+    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<boolean>;
+    /**
+     * Adds an ICE candidate received from the remote peer.
+     * @param candidate - The ICE candidate to add, or null for end-of-candidates.
+     * @returns True if successful, false otherwise.
+     */
+    addIceCandidate(candidate: RTCIceCandidateInit | null): Promise<boolean>;
+    /**
+     * Performs an ICE restart to recover from connection issues.
+     * Creates a new offer with iceRestart flag and sets it as local description.
+     * @returns True if successful, false otherwise.
+     */
+    iceRestart(): Promise<boolean>;
+    /**
+     * Returns the current local session description.
+     * @returns The local description, or null if not set.
+     */
+    getLocalDescription(): RTCSessionDescription | null;
+    /**
+     * Returns the current remote session description.
+     * @returns The remote description, or null if not set.
+     */
+    getRemoteDescription(): RTCSessionDescription | null;
+    /**
+     * Retrieves WebRTC statistics for the peer connection.
+     * @returns Stats report, or null if peer connection not initialized.
+     */
+    getStats(): Promise<RTCStatsReport | null>;
+}