@marianmeres/webrtc 1.3.1 → 1.4.1

package/dist/webrtc-manager.js

@@ -1,32 +1,7 @@
 import { FSM } from "@marianmeres/fsm";
 import { PubSub } from "@marianmeres/pubsub";
-import { WebRtcState, WebRtcFsmEvent, } from "./types.js";
-/**
- * Default console-based logger that wraps console methods.
- * Returns string representation of the first argument for chaining.
- */
-const createDefaultLogger = () => ({
-    // deno-lint-ignore no-explicit-any
-    debug: (...args) => {
-        console.debug(...args);
-        return String(args[0] ?? "");
-    },
-    // deno-lint-ignore no-explicit-any
-    log: (...args) => {
-        console.log(...args);
-        return String(args[0] ?? "");
-    },
-    // deno-lint-ignore no-explicit-any
-    warn: (...args) => {
-        console.warn(...args);
-        return String(args[0] ?? "");
-    },
-    // deno-lint-ignore no-explicit-any
-    error: (...args) => {
-        console.error(...args);
-        return String(args[0] ?? "");
-    },
-});
+import { createClog, withNamespace } from "@marianmeres/clog";
+import { WebRTCState, WebRTCFsmEvent, } from "./types.js";
 /**
  * WebRTC connection manager with FSM-based lifecycle and event-driven architecture.
  *
@@ -42,7 +17,7 @@ const createDefaultLogger = () => ({
  *   enumerateDevices: () => navigator.mediaDevices.enumerateDevices(),
  * };
  *
- * const manager = new WebRtcManager(factory, {
+ * const manager = new WebRTCManager(factory, {
  *   peerConfig: { iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] },
  *   enableMicrophone: true,
  * });
@@ -53,8 +28,8 @@ const createDefaultLogger = () => ({
  * await manager.setLocalDescription(offer);
  * ```
  */
-export class WebRtcManager {
-    /** Event emitted when connection state changes. Payload: {@link WebRtcState} */
+export class WebRTCManager {
+    /** Event emitted when connection state changes. Payload: {@link WebRTCState} */
     static EVENT_STATE_CHANGE = "state_change";
     /** Event emitted when local media stream changes. Payload: `MediaStream | null` */
     static EVENT_LOCAL_STREAM = "local_stream";
@@ -96,12 +71,12 @@ export class WebRtcManager {
      * @example
      * ```typescript
      * // With type parameter for full type safety:
-     * const manager = new WebRtcManager<{ audioStream: MediaStream; sessionId: string }>(factory);
+     * const manager = new WebRTCManager<{ audioStream: MediaStream; sessionId: string }>(factory);
      * manager.context = { audioStream: myStream, sessionId: '123' };
      * manager.context.audioStream; // typed as MediaStream
      *
      * // Without type parameter (backwards compatible):
-     * const manager = new WebRtcManager(factory);
+     * const manager = new WebRTCManager(factory);
      * manager.context = { anything: 'goes' };
      * ```
      */
@@ -110,57 +85,57 @@ export class WebRtcManager {
     #fullReconnectTimeoutTimer = null;
     #deviceChangeHandler = null;
     /**
-     * Creates a new WebRtcManager instance.
+     * Creates a new WebRTCManager instance.
      * @param factory - Factory object providing WebRTC primitives (peer connection, media, devices).
      * @param config - Optional configuration for the manager.
      */
     constructor(factory, config = {}) {
         this.#factory = factory;
         this.#config = config;
-        this.#logger = config.logger ?? createDefaultLogger();
+        this.#logger = withNamespace(config.logger ?? createClog(), "WebRTCManager");
         this.#pubsub = new PubSub();
         // Initialize FSM
         this.#fsm = new FSM({
-            initial: WebRtcState.IDLE,
+            initial: WebRTCState.IDLE,
             states: {
-                [WebRtcState.IDLE]: {
-                    on: { [WebRtcFsmEvent.INIT]: WebRtcState.INITIALIZING },
+                [WebRTCState.IDLE]: {
+                    on: { [WebRTCFsmEvent.INIT]: WebRTCState.INITIALIZING },
                 },
-                [WebRtcState.INITIALIZING]: {
+                [WebRTCState.INITIALIZING]: {
                     on: {
-                        [WebRtcFsmEvent.CONNECT]: WebRtcState.CONNECTING,
-                        [WebRtcFsmEvent.ERROR]: WebRtcState.ERROR,
+                        [WebRTCFsmEvent.CONNECT]: WebRTCState.CONNECTING,
+                        [WebRTCFsmEvent.ERROR]: WebRTCState.ERROR,
                     },
                 },
-                [WebRtcState.CONNECTING]: {
+                [WebRTCState.CONNECTING]: {
                     on: {
-                        [WebRtcFsmEvent.CONNECTED]: WebRtcState.CONNECTED,
-                        [WebRtcFsmEvent.DISCONNECT]: WebRtcState.DISCONNECTED,
-                        [WebRtcFsmEvent.ERROR]: WebRtcState.ERROR,
+                        [WebRTCFsmEvent.CONNECTED]: WebRTCState.CONNECTED,
+                        [WebRTCFsmEvent.DISCONNECT]: WebRTCState.DISCONNECTED,
+                        [WebRTCFsmEvent.ERROR]: WebRTCState.ERROR,
                     },
                 },
-                [WebRtcState.CONNECTED]: {
+                [WebRTCState.CONNECTED]: {
                     on: {
-                        [WebRtcFsmEvent.DISCONNECT]: WebRtcState.DISCONNECTED,
-                        [WebRtcFsmEvent.ERROR]: WebRtcState.ERROR,
+                        [WebRTCFsmEvent.DISCONNECT]: WebRTCState.DISCONNECTED,
+                        [WebRTCFsmEvent.ERROR]: WebRTCState.ERROR,
                     },
                 },
-                [WebRtcState.RECONNECTING]: {
+                [WebRTCState.RECONNECTING]: {
                     on: {
-                        [WebRtcFsmEvent.CONNECT]: WebRtcState.CONNECTING,
-                        [WebRtcFsmEvent.DISCONNECT]: WebRtcState.DISCONNECTED,
-                        [WebRtcFsmEvent.RESET]: WebRtcState.IDLE,
+                        [WebRTCFsmEvent.CONNECT]: WebRTCState.CONNECTING,
+                        [WebRTCFsmEvent.DISCONNECT]: WebRTCState.DISCONNECTED,
+                        [WebRTCFsmEvent.RESET]: WebRTCState.IDLE,
                     },
                 },
-                [WebRtcState.DISCONNECTED]: {
+                [WebRTCState.DISCONNECTED]: {
                     on: {
-                        [WebRtcFsmEvent.CONNECT]: WebRtcState.CONNECTING,
-                        [WebRtcFsmEvent.RECONNECTING]: WebRtcState.RECONNECTING,
-                        [WebRtcFsmEvent.RESET]: WebRtcState.IDLE,
+                        [WebRTCFsmEvent.CONNECT]: WebRTCState.CONNECTING,
+                        [WebRTCFsmEvent.RECONNECTING]: WebRTCState.RECONNECTING,
+                        [WebRTCFsmEvent.RESET]: WebRTCState.IDLE,
                     },
                 },
-                [WebRtcState.ERROR]: {
-                    on: { [WebRtcFsmEvent.RESET]: WebRtcState.IDLE },
+                [WebRTCState.ERROR]: {
+                    on: { [WebRTCFsmEvent.RESET]: WebRTCState.IDLE },
                 },
             },
         });
@@ -220,11 +195,11 @@ export class WebRtcManager {
         handler(getCurrentState());
         // Subscribe to relevant events that affect the overall state
         const unsubscribers = [
-            this.#pubsub.subscribe(WebRtcManager.EVENT_STATE_CHANGE, () => handler(getCurrentState())),
-            this.#pubsub.subscribe(WebRtcManager.EVENT_LOCAL_STREAM, () => handler(getCurrentState())),
-            this.#pubsub.subscribe(WebRtcManager.EVENT_REMOTE_STREAM, () => handler(getCurrentState())),
-            this.#pubsub.subscribe(WebRtcManager.EVENT_DATA_CHANNEL_OPEN, () => handler(getCurrentState())),
-            this.#pubsub.subscribe(WebRtcManager.EVENT_DATA_CHANNEL_CLOSE, () => handler(getCurrentState())),
+            this.#pubsub.subscribe(WebRTCManager.EVENT_STATE_CHANGE, () => handler(getCurrentState())),
+            this.#pubsub.subscribe(WebRTCManager.EVENT_LOCAL_STREAM, () => handler(getCurrentState())),
+            this.#pubsub.subscribe(WebRTCManager.EVENT_REMOTE_STREAM, () => handler(getCurrentState())),
+            this.#pubsub.subscribe(WebRTCManager.EVENT_DATA_CHANNEL_OPEN, () => handler(getCurrentState())),
+            this.#pubsub.subscribe(WebRTCManager.EVENT_DATA_CHANNEL_CLOSE, () => handler(getCurrentState())),
         ];
         // Return combined unsubscribe function
         return () => {
@@ -284,7 +259,7 @@ export class WebRtcManager {
             this.#localStream.getAudioTracks().forEach((track) => track.stop());
             // Update local stream reference
             this.#localStream = newStream;
-            this.#pubsub.publish(WebRtcManager.EVENT_LOCAL_STREAM, newStream);
+            this.#pubsub.publish(WebRTCManager.EVENT_LOCAL_STREAM, newStream);
             return true;
         }
         catch (e) {
@@ -298,23 +273,23 @@ export class WebRtcManager {
      * Must be called before creating offers or answers. Can only be called from IDLE state.
      */
     async initialize() {
-        if (this.state !== WebRtcState.IDLE) {
-            this.#logDebug("initialize() called but state is not IDLE:", this.state);
+        if (this.state !== WebRTCState.IDLE) {
+            this.#logger.debug("initialize() called but state is not IDLE:", this.state);
             return;
         }
-        this.#logDebug("Initializing...");
-        this.#dispatch(WebRtcFsmEvent.INIT);
+        this.#logger.debug("Initializing...");
+        this.#dispatch(WebRTCFsmEvent.INIT);
         try {
             this.#pc = this.#factory.createPeerConnection(this.#config.peerConfig);
-            this.#logDebug("Peer connection created");
+            this.#logger.debug("Peer connection created");
             this.#setupPcListeners();
             // Setup device change detection now that we have a connection
             this.#setupDeviceChangeListener();
             if (this.#config.enableMicrophone) {
-                this.#logDebug("Enabling microphone (config enabled)");
+                this.#logger.debug("Enabling microphone (config enabled)");
                 const success = await this.enableMicrophone(true);
                 if (!success) {
-                    this.#pubsub.publish(WebRtcManager.EVENT_MICROPHONE_FAILED, {
+                    this.#pubsub.publish(WebRTCManager.EVENT_MICROPHONE_FAILED, {
                         reason: "Failed to enable microphone during initialization",
                     });
                 }
@@ -323,13 +298,13 @@ export class WebRtcManager {
                 // Always setup to receive audio, even if we don't enable microphone
                 // This ensures the SDP includes audio media line
                 this.#pc.addTransceiver("audio", { direction: "recvonly" });
-                this.#logDebug("Added recvonly audio transceiver");
+                this.#logger.debug("Added recvonly audio transceiver");
             }
             if (this.#config.dataChannelLabel) {
-                this.#logDebug("Creating default data channel:", this.#config.dataChannelLabel);
+                this.#logger.debug("Creating default data channel:", this.#config.dataChannelLabel);
                 this.createDataChannel(this.#config.dataChannelLabel);
             }
-            this.#logDebug("Initialization complete");
+            this.#logger.debug("Initialization complete");
         }
         catch (e) {
             this.#logError(e);
@@ -341,30 +316,30 @@ export class WebRtcManager {
      * If disconnected, reinitializes the peer connection.
      */
     async connect() {
-        this.#logDebug("connect() called, current state:", this.state);
+        this.#logger.debug("connect() called, current state:", this.state);
         // Initialize if needed
-        if (this.state === WebRtcState.IDLE) {
-            this.#logDebug("State is IDLE, initializing first");
+        if (this.state === WebRTCState.IDLE) {
+            this.#logger.debug("State is IDLE, initializing first");
             await this.initialize();
         }
         // Reinitialize if disconnected (PeerConnection was closed)
-        if (this.state === WebRtcState.DISCONNECTED) {
-            this.#logDebug("State is DISCONNECTED, reinitializing");
+        if (this.state === WebRTCState.DISCONNECTED) {
+            this.#logger.debug("State is DISCONNECTED, reinitializing");
             // Clean up old connection
             this.#cleanup();
             // Reset to IDLE and reinitialize
-            this.#fsm.transition(WebRtcFsmEvent.RESET);
+            this.#fsm.transition(WebRTCFsmEvent.RESET);
             await this.initialize();
             // Stay in INITIALIZING state - caller needs to create offer/answer
             return;
         }
-        if (this.state === WebRtcState.CONNECTED ||
-            this.state === WebRtcState.CONNECTING) {
-            this.#logDebug("Already connected or connecting, skipping");
+        if (this.state === WebRTCState.CONNECTED ||
+            this.state === WebRTCState.CONNECTING) {
+            this.#logger.debug("Already connected or connecting, skipping");
             return;
         }
-        this.#logDebug("Transitioning to CONNECTING");
-        this.#dispatch(WebRtcFsmEvent.CONNECT);
+        this.#logger.debug("Transitioning to CONNECTING");
+        this.#dispatch(WebRTCFsmEvent.CONNECT);
     }
     /**
      * Enables or disables the microphone and adds/removes audio tracks to the peer connection.
@@ -372,21 +347,21 @@ export class WebRtcManager {
      * @returns True if successful, false if failed to get user media.
      */
     async enableMicrophone(enable) {
-        this.#logDebug("enableMicrophone() called:", enable);
+        this.#logger.debug("enableMicrophone() called:", enable);
         if (enable) {
             if (this.#localStream) {
-                this.#logDebug("Microphone already enabled");
+                this.#logger.debug("Microphone already enabled");
                 return true;
             }
             try {
-                this.#logDebug("Requesting user media...");
+                this.#logger.debug("Requesting user media...");
                 const stream = await this.#factory.getUserMedia({
                     audio: true,
                     video: false,
                 });
-                this.#logDebug("User media obtained, tracks:", stream.getAudioTracks().length);
+                this.#logger.debug("User media obtained, tracks:", stream.getAudioTracks().length);
                 this.#localStream = stream;
-                this.#pubsub.publish(WebRtcManager.EVENT_LOCAL_STREAM, stream);
+                this.#pubsub.publish(WebRTCManager.EVENT_LOCAL_STREAM, stream);
                 if (this.#pc) {
                     // Check if we have an existing audio transceiver
                     const transceivers = this.#pc.getTransceivers();
@@ -397,22 +372,22 @@ export class WebRtcManager {
                         await audioTransceiver.sender.replaceTrack(track);
                         // Update direction to sendrecv
                         audioTransceiver.direction = "sendrecv";
-                        this.#logDebug("Replaced track in existing transceiver");
+                        this.#logger.debug("Replaced track in existing transceiver");
                     }
                     else {
                         // Add track normally
                         stream.getTracks().forEach((track) => {
                             this.#pc.addTrack(track, stream);
                         });
-                        this.#logDebug("Added tracks to peer connection");
+                        this.#logger.debug("Added tracks to peer connection");
                     }
                 }
-                this.#logDebug("Microphone enabled successfully");
+                this.#logger.debug("Microphone enabled successfully");
                 return true;
             }
             catch (e) {
                 this.#logError("Failed to get user media:", e);
-                this.#pubsub.publish(WebRtcManager.EVENT_MICROPHONE_FAILED, {
+                this.#pubsub.publish(WebRTCManager.EVENT_MICROPHONE_FAILED, {
                     error: e,
                 });
                 return false;
@@ -420,10 +395,10 @@ export class WebRtcManager {
         }
         else {
             if (!this.#localStream) {
-                this.#logDebug("Microphone already disabled");
+                this.#logger.debug("Microphone already disabled");
                 return true;
             }
-            this.#logDebug("Disabling microphone...");
+            this.#logger.debug("Disabling microphone...");
             this.#localStream.getTracks().forEach((track) => {
                 track.stop();
                 // Remove from PC if needed, or just stop sending
@@ -436,8 +411,8 @@ export class WebRtcManager {
                 }
             });
             this.#localStream = null;
-            this.#pubsub.publish(WebRtcManager.EVENT_LOCAL_STREAM, null);
-            this.#logDebug("Microphone disabled");
+            this.#pubsub.publish(WebRTCManager.EVENT_LOCAL_STREAM, null);
+            this.#logger.debug("Microphone disabled");
             return true;
         }
     }
@@ -446,32 +421,32 @@ export class WebRtcManager {
      * Transitions to DISCONNECTED state.
      */
     disconnect() {
-        this.#logDebug("disconnect() called");
+        this.#logger.debug("disconnect() called");
         this.#cleanup();
-        this.#dispatch(WebRtcFsmEvent.DISCONNECT);
+        this.#dispatch(WebRTCFsmEvent.DISCONNECT);
     }
     /**
      * Resets the manager to IDLE state from any state.
      * Cleans up all resources and allows reinitialization.
      */
     reset() {
-        this.#logDebug("reset() called, current state:", this.state);
+        this.#logger.debug("reset() called, current state:", this.state);
         this.#cleanup();
         // Reset from any non-IDLE state
-        if (this.state !== WebRtcState.IDLE) {
+        if (this.state !== WebRTCState.IDLE) {
             // Force transition to DISCONNECTED first if needed, then to IDLE
-            if (this.state === WebRtcState.ERROR ||
-                this.state === WebRtcState.DISCONNECTED ||
-                this.state === WebRtcState.RECONNECTING) {
-                this.#dispatch(WebRtcFsmEvent.RESET);
+            if (this.state === WebRTCState.ERROR ||
+                this.state === WebRTCState.DISCONNECTED ||
+                this.state === WebRTCState.RECONNECTING) {
+                this.#dispatch(WebRTCFsmEvent.RESET);
             }
             else {
                 // For other states, go through DISCONNECTED first
-                this.#dispatch(WebRtcFsmEvent.DISCONNECT);
-                this.#dispatch(WebRtcFsmEvent.RESET);
+                this.#dispatch(WebRTCFsmEvent.DISCONNECT);
+                this.#dispatch(WebRTCFsmEvent.RESET);
             }
         }
-        this.#logDebug("Reset complete, state:", this.state);
+        this.#logger.debug("Reset complete, state:", this.state);
     }
     /**
      * Creates a new data channel with the specified label.
@@ -481,20 +456,20 @@ export class WebRtcManager {
      * @returns The created data channel, or null if peer connection not initialized.
      */
     createDataChannel(label, options) {
-        this.#logDebug("createDataChannel() called:", label);
+        this.#logger.debug("createDataChannel() called:", label);
         if (!this.#pc) {
-            this.#logDebug("Cannot create data channel: peer connection not initialized");
+            this.#logger.debug("Cannot create data channel: peer connection not initialized");
             return null;
         }
         if (this.#dataChannels.has(label)) {
-            this.#logDebug("Returning existing data channel:", label);
+            this.#logger.debug("Returning existing data channel:", label);
             return this.#dataChannels.get(label);
         }
         try {
             const dc = this.#pc.createDataChannel(label, options);
             this.#setupDataChannelListeners(dc);
             this.#dataChannels.set(label, dc);
-            this.#logDebug("Data channel created:", label);
+            this.#logger.debug("Data channel created:", label);
             return dc;
         }
         catch (e) {
@@ -521,11 +496,11 @@ export class WebRtcManager {
     sendData(label, data) {
         const channel = this.#dataChannels.get(label);
         if (!channel) {
-            this.#logDebug(`Data channel '${label}' not found`);
+            this.#logger.debug(`Data channel '${label}' not found`);
             return false;
         }
         if (channel.readyState !== "open") {
-            this.#logDebug(`Data channel '${label}' is not open (state: ${channel.readyState})`);
+            this.#logger.debug(`Data channel '${label}' is not open (state: ${channel.readyState})`);
             return false;
         }
         try {
@@ -546,14 +521,14 @@ export class WebRtcManager {
      * @returns The offer SDP, or null if peer connection not initialized.
      */
     async createOffer(options) {
-        this.#logDebug("createOffer() called");
+        this.#logger.debug("createOffer() called");
         if (!this.#pc) {
-            this.#logDebug("Cannot create offer: peer connection not initialized");
+            this.#logger.debug("Cannot create offer: peer connection not initialized");
             return null;
         }
         try {
             const offer = await this.#pc.createOffer(options);
-            this.#logDebug("Offer created:", offer.type);
+            this.#logger.debug("Offer created:", offer.type);
             return offer;
         }
         catch (e) {
@@ -568,14 +543,14 @@ export class WebRtcManager {
      * @returns The answer SDP, or null if peer connection not initialized.
      */
     async createAnswer(options) {
-        this.#logDebug("createAnswer() called");
+        this.#logger.debug("createAnswer() called");
         if (!this.#pc) {
-            this.#logDebug("Cannot create answer: peer connection not initialized");
+            this.#logger.debug("Cannot create answer: peer connection not initialized");
             return null;
         }
         try {
             const answer = await this.#pc.createAnswer(options);
-            this.#logDebug("Answer created:", answer.type);
+            this.#logger.debug("Answer created:", answer.type);
             return answer;
         }
         catch (e) {
@@ -590,14 +565,14 @@ export class WebRtcManager {
      * @returns True if successful, false otherwise.
      */
     async setLocalDescription(description) {
-        this.#logDebug("setLocalDescription() called:", description.type);
+        this.#logger.debug("setLocalDescription() called:", description.type);
         if (!this.#pc) {
-            this.#logDebug("Cannot set local description: peer connection not initialized");
+            this.#logger.debug("Cannot set local description: peer connection not initialized");
             return false;
         }
         try {
             await this.#pc.setLocalDescription(description);
-            this.#logDebug("Local description set successfully");
+            this.#logger.debug("Local description set successfully");
             return true;
         }
         catch (e) {
@@ -612,14 +587,14 @@ export class WebRtcManager {
      * @returns True if successful, false otherwise.
      */
     async setRemoteDescription(description) {
-        this.#logDebug("setRemoteDescription() called:", description.type);
+        this.#logger.debug("setRemoteDescription() called:", description.type);
         if (!this.#pc) {
-            this.#logDebug("Cannot set remote description: peer connection not initialized");
+            this.#logger.debug("Cannot set remote description: peer connection not initialized");
             return false;
         }
         try {
             await this.#pc.setRemoteDescription(description);
-            this.#logDebug("Remote description set successfully");
+            this.#logger.debug("Remote description set successfully");
             return true;
         }
         catch (e) {
@@ -634,15 +609,15 @@ export class WebRtcManager {
      * @returns True if successful, false otherwise.
      */
     async addIceCandidate(candidate) {
-        this.#logDebug("addIceCandidate() called:", candidate ? "candidate" : "null (end-of-candidates)");
+        this.#logger.debug("addIceCandidate() called:", candidate ? "candidate" : "null (end-of-candidates)");
         if (!this.#pc) {
-            this.#logDebug("Cannot add ICE candidate: peer connection not initialized");
+            this.#logger.debug("Cannot add ICE candidate: peer connection not initialized");
             return false;
         }
         try {
             if (candidate) {
                 await this.#pc.addIceCandidate(candidate);
-                this.#logDebug("ICE candidate added");
+                this.#logger.debug("ICE candidate added");
             }
             return true;
         }
@@ -658,15 +633,15 @@ export class WebRtcManager {
      * @returns True if successful, false otherwise.
      */
     async iceRestart() {
-        this.#logDebug("iceRestart() called");
+        this.#logger.debug("iceRestart() called");
         if (!this.#pc) {
-            this.#logDebug("Cannot perform ICE restart: peer connection not initialized");
+            this.#logger.debug("Cannot perform ICE restart: peer connection not initialized");
             return false;
         }
         try {
             const offer = await this.#pc.createOffer({ iceRestart: true });
             await this.#pc.setLocalDescription(offer);
-            this.#logDebug("ICE restart initiated");
+            this.#logger.debug("ICE restart initiated");
             return true;
         }
         catch (e) {
@@ -688,10 +663,10 @@ export class WebRtcManager {
         }
         const pc = this.#pc;
         if (pc.iceGatheringState === "complete") {
-            this.#logDebug("ICE gathering already complete");
+            this.#logger.debug("ICE gathering already complete");
             return Promise.resolve();
         }
-        this.#logDebug("Waiting for ICE gathering to complete...");
+        this.#logger.debug("Waiting for ICE gathering to complete...");
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 cleanup();
@@ -704,7 +679,7 @@ export class WebRtcManager {
             };
             const checkState = () => {
                 if (pc.iceGatheringState === "complete") {
-                    this.#logDebug("ICE gathering complete (via state change)");
+                    this.#logger.debug("ICE gathering complete (via state change)");
                     cleanup();
                     resolve();
                 }
@@ -712,7 +687,7 @@ export class WebRtcManager {
             const handleCandidate = (event) => {
                 onCandidate?.(event.candidate);
                 if (event.candidate === null) {
-                    this.#logDebug("ICE gathering complete (null candidate)");
+                    this.#logger.debug("ICE gathering complete (null candidate)");
                     cleanup();
                     resolve();
                 }
@@ -757,54 +732,48 @@ export class WebRtcManager {
         this.#fsm.transition(event);
         const newState = this.#fsm.state;
         if (oldState !== newState) {
-            this.#logDebug("State transition:", oldState, "->", newState, "(event:", event + ")");
-            this.#pubsub.publish(WebRtcManager.EVENT_STATE_CHANGE, newState);
-        }
-    }
-    // deno-lint-ignore no-explicit-any
-    #logDebug(...args) {
-        if (this.#config.debug) {
-            this.#logger.debug("[WebRtcManager]", ...args);
+            this.#logger.debug("State transition:", oldState, "->", newState, "(event:", event + ")");
+            this.#pubsub.publish(WebRTCManager.EVENT_STATE_CHANGE, newState);
         }
     }
     // deno-lint-ignore no-explicit-any
     #log(...args) {
-        this.#logger.log("[WebRtcManager]", ...args);
+        this.#logger.log(...args);
     }
     // deno-lint-ignore no-explicit-any
     #logWarn(...args) {
-        this.#logger.warn("[WebRtcManager]", ...args);
+        this.#logger.warn(...args);
     }
     // deno-lint-ignore no-explicit-any
     #logError(...args) {
-        this.#logger.error("[WebRtcManager]", ...args);
+        this.#logger.error(...args);
     }
     // deno-lint-ignore no-explicit-any
     #handleError(error) {
-        this.#dispatch(WebRtcFsmEvent.ERROR);
-        this.#pubsub.publish(WebRtcManager.EVENT_ERROR, error);
+        this.#dispatch(WebRTCFsmEvent.ERROR);
+        this.#pubsub.publish(WebRTCManager.EVENT_ERROR, error);
     }
     #setupPcListeners() {
         if (!this.#pc)
             return;
-        this.#logDebug("Setting up peer connection listeners");
+        this.#logger.debug("Setting up peer connection listeners");
         this.#pc.onconnectionstatechange = () => {
             const state = this.#pc.connectionState;
-            this.#logDebug("Connection state changed:", state);
+            this.#logger.debug("Connection state changed:", state);
             if (state === "connected") {
                 // Only dispatch if in CONNECTING state (FSM can handle CONNECTED event)
                 // This guards against late connection success after user has disconnected
-                if (this.state === WebRtcState.CONNECTING) {
+                if (this.state === WebRTCState.CONNECTING) {
                     // Connection successful - reset reconnect attempts and clear any pending timeout
                     this.#reconnectAttempts = 0;
                     if (this.#fullReconnectTimeoutTimer !== null) {
                         clearTimeout(this.#fullReconnectTimeoutTimer);
                         this.#fullReconnectTimeoutTimer = null;
                     }
-                    this.#dispatch(WebRtcFsmEvent.CONNECTED);
+                    this.#dispatch(WebRTCFsmEvent.CONNECTED);
                 }
                 else {
-                    this.#logDebug(`Ignoring late connection success (current state: ${this.state})`);
+                    this.#logger.debug(`Ignoring late connection success (current state: ${this.state})`);
                 }
             }
             else if (state === "failed") {
@@ -813,33 +782,33 @@ export class WebRtcManager {
             }
             else if (state === "disconnected" || state === "closed") {
                 // Only dispatch if not already in a terminal state
-                if (this.state !== WebRtcState.DISCONNECTED &&
-                    this.state !== WebRtcState.ERROR &&
-                    this.state !== WebRtcState.IDLE) {
-                    this.#dispatch(WebRtcFsmEvent.DISCONNECT);
+                if (this.state !== WebRTCState.DISCONNECTED &&
+                    this.state !== WebRTCState.ERROR &&
+                    this.state !== WebRTCState.IDLE) {
+                    this.#dispatch(WebRTCFsmEvent.DISCONNECT);
                 }
             }
         };
         this.#pc.ontrack = (event) => {
-            this.#logDebug("Remote track received:", event.track.kind);
+            this.#logger.debug("Remote track received:", event.track.kind);
             if (event.streams && event.streams[0]) {
                 this.#remoteStream = event.streams[0];
-                this.#pubsub.publish(WebRtcManager.EVENT_REMOTE_STREAM, this.#remoteStream);
+                this.#pubsub.publish(WebRTCManager.EVENT_REMOTE_STREAM, this.#remoteStream);
             }
         };
         this.#pc.ondatachannel = (event) => {
             const dc = event.channel;
-            this.#logDebug("Remote data channel received:", dc.label);
+            this.#logger.debug("Remote data channel received:", dc.label);
             this.#setupDataChannelListeners(dc);
             this.#dataChannels.set(dc.label, dc);
         };
         this.#pc.onicecandidate = (event) => {
-            this.#logDebug("ICE candidate generated:", event.candidate ? "candidate" : "null (gathering complete)");
-            this.#pubsub.publish(WebRtcManager.EVENT_ICE_CANDIDATE, event.candidate);
+            this.#logger.debug("ICE candidate generated:", event.candidate ? "candidate" : "null (gathering complete)");
+            this.#pubsub.publish(WebRTCManager.EVENT_ICE_CANDIDATE, event.candidate);
         };
     }
     #cleanup() {
-        this.#logDebug("Cleanup started");
+        this.#logger.debug("Cleanup started");
         // Clear any pending reconnect timers
         if (this.#reconnectTimer !== null) {
             clearTimeout(this.#reconnectTimer);
@@ -864,41 +833,41 @@ export class WebRtcManager {
         });
         this.#dataChannels.clear();
         if (dcCount > 0) {
-            this.#logDebug("Closed", dcCount, "data channel(s)");
+            this.#logger.debug("Closed", dcCount, "data channel(s)");
         }
         // Stop local stream tracks
         if (this.#localStream) {
             this.#localStream.getTracks().forEach((track) => track.stop());
             this.#localStream = null;
-            this.#logDebug("Local stream stopped");
+            this.#logger.debug("Local stream stopped");
         }
         // Close peer connection
         if (this.#pc) {
             this.#pc.close();
             this.#pc = null;
-            this.#logDebug("Peer connection closed");
+            this.#logger.debug("Peer connection closed");
         }
         this.#remoteStream = null;
-        this.#logDebug("Cleanup complete");
+        this.#logger.debug("Cleanup complete");
     }
     #handleConnectionFailure() {
-        this.#logDebug("Handling connection failure");
+        this.#logger.debug("Handling connection failure");
         // Only dispatch DISCONNECT if not already in a terminal state
-        if (this.state !== WebRtcState.DISCONNECTED &&
-            this.state !== WebRtcState.ERROR &&
-            this.state !== WebRtcState.IDLE) {
-            this.#dispatch(WebRtcFsmEvent.DISCONNECT);
+        if (this.state !== WebRTCState.DISCONNECTED &&
+            this.state !== WebRTCState.ERROR &&
+            this.state !== WebRTCState.IDLE) {
+            this.#dispatch(WebRTCFsmEvent.DISCONNECT);
         }
         // Check if auto-reconnect is enabled
         if (!this.#config.autoReconnect) {
-            this.#logDebug("Auto-reconnect disabled, not attempting reconnection");
+            this.#logger.debug("Auto-reconnect disabled, not attempting reconnection");
             return;
         }
         const maxAttempts = this.#config.maxReconnectAttempts ?? 5;
         // Check if we've exceeded max attempts
         if (this.#reconnectAttempts >= maxAttempts) {
-            this.#logDebug("Max reconnection attempts reached:", maxAttempts);
-            this.#pubsub.publish(WebRtcManager.EVENT_RECONNECT_FAILED, {
+            this.#logger.debug("Max reconnection attempts reached:", maxAttempts);
+            this.#pubsub.publish(WebRTCManager.EVENT_RECONNECT_FAILED, {
                 attempts: this.#reconnectAttempts,
             });
             return;
@@ -914,12 +883,12 @@ export class WebRtcManager {
                 strategy,
             });
             if (!shouldProceed) {
-                this.#logDebug("Reconnection suppressed by shouldReconnect callback");
+                this.#logger.debug("Reconnection suppressed by shouldReconnect callback");
                 return;
             }
         }
         // Transition to RECONNECTING state
-        this.#dispatch(WebRtcFsmEvent.RECONNECTING);
+        this.#dispatch(WebRTCFsmEvent.RECONNECTING);
         // Attempt reconnection with exponential backoff
         this.#attemptReconnect();
     }
@@ -929,12 +898,12 @@ export class WebRtcManager {
         const delay = baseDelay * Math.pow(2, this.#reconnectAttempts - 1);
         // Try ICE restart first (attempts 1-2), then full reconnect
         const strategy = this.#reconnectAttempts <= 2 ? "ice-restart" : "full";
-        this.#logDebug("Attempting reconnection:", {
+        this.#logger.debug("Attempting reconnection:", {
             attempt: this.#reconnectAttempts,
             strategy,
             delay: delay + "ms",
         });
-        this.#pubsub.publish(WebRtcManager.EVENT_RECONNECTING, {
+        this.#pubsub.publish(WebRTCManager.EVENT_RECONNECTING, {
             attempt: this.#reconnectAttempts,
             strategy,
         });
@@ -958,7 +927,7 @@ export class WebRtcManager {
                 try {
                     // Clean up old connection and reset to IDLE so connect() creates a new PC
                     this.#cleanup();
-                    this.#dispatch(WebRtcFsmEvent.RESET);
+                    this.#dispatch(WebRTCFsmEvent.RESET);
                     await this.connect();
                     // Start timeout for full reconnection - if connection doesn't succeed
                     // within the timeout, treat it as a failure
@@ -966,8 +935,8 @@ export class WebRtcManager {
                     this.#fullReconnectTimeoutTimer = setTimeout(() => {
                         this.#fullReconnectTimeoutTimer = null;
                         // Only trigger failure if still not connected
-                        if (this.state !== WebRtcState.CONNECTED) {
-                            this.#logDebug("Full reconnection timeout reached, connection not established");
+                        if (this.state !== WebRTCState.CONNECTED) {
+                            this.#logger.debug("Full reconnection timeout reached, connection not established");
                             this.#handleConnectionFailure();
                         }
                     }, timeout);
@@ -991,7 +960,7 @@ export class WebRtcManager {
         this.#deviceChangeHandler = async () => {
             try {
                 const devices = await this.getAudioInputDevices();
-                this.#pubsub.publish(WebRtcManager.EVENT_DEVICE_CHANGED, devices);
+                this.#pubsub.publish(WebRTCManager.EVENT_DEVICE_CHANGED, devices);
             }
             catch (e) {
                 this.#logError("Error handling device change:", e);
@@ -1001,16 +970,16 @@ export class WebRtcManager {
     }
     #setupDataChannelListeners(dc) {
         dc.onopen = () => {
-            this.#pubsub.publish(WebRtcManager.EVENT_DATA_CHANNEL_OPEN, dc);
+            this.#pubsub.publish(WebRTCManager.EVENT_DATA_CHANNEL_OPEN, dc);
         };
         dc.onmessage = (event) => {
-            this.#pubsub.publish(WebRtcManager.EVENT_DATA_CHANNEL_MESSAGE, {
+            this.#pubsub.publish(WebRTCManager.EVENT_DATA_CHANNEL_MESSAGE, {
                 channel: dc,
                 data: event.data,
             });
         };
         dc.onclose = () => {
-            this.#pubsub.publish(WebRtcManager.EVENT_DATA_CHANNEL_CLOSE, dc);
+            this.#pubsub.publish(WebRTCManager.EVENT_DATA_CHANNEL_CLOSE, dc);
             this.#dataChannels.delete(dc.label);
         };
         // deno-lint-ignore no-explicit-any
@@ -1019,7 +988,7 @@ export class WebRtcManager {
             const isUserAbort = error?.error?.message?.includes("User-Initiated Abort");
             if (!isUserAbort) {
                 this.#logError("Data channel error:", error);
-                this.#pubsub.publish(WebRtcManager.EVENT_ERROR, error);
+                this.#pubsub.publish(WebRTCManager.EVENT_ERROR, error);
             }
         };
     }