@stormstreaming/stormstreamer 1.0.0-rc.1 → 1.0.0

package/dist/amd/index.js

@@ -4,8 +4,8 @@
  * contact@stormstreaming.com
  * https://stormstreaming.com
  *
- * Version: 1.0.0-rc.1
- * Version: 11/17/2025, 10:30:25 AM
+ * Version: 1.0.0
+ * Version: 2/7/2026, 6:37:17 PM
  *
  * LEGAL NOTICE:
  * This software is subject to the terms and conditions defined in
@@ -3672,13 +3672,13 @@
         this._lastEventTime = 0;
         this.THROTTLE_INTERVAL = 100; // ms between updates
         this._isMonitoring = false;
-        // POPRAWKA: Dodane pole do przechowywania ID animacji
         this._animationFrameId = null;
-        // Moving average variables for smoothing
-        this._instant = 0.0;
-        this._slow = 0.0;
+        // Peak levels for VU meter
+        this._instant = 0.0; // Current peak (fast)
+        this._slow = 0.0; // Peak hold with decay
+        // Decay rate for peak hold (0.95 = slow decay, 0.8 = fast decay)
+        this.PEAK_DECAY = 0.92;
         this._main = main;
-        console.log('SoundMeter: Created new instance');
       }
       attach(stream) {
         if (!stream.getAudioTracks().length) {
@@ -3693,30 +3693,24 @@
           this._microphone = this._audioContext.createMediaStreamSource(stream);
           this._analyser = this._audioContext.createAnalyser();
           this._analyser.fftSize = 2048;
-          this._analyser.smoothingTimeConstant = 0.3;
           // Connect nodes
           this._microphone.connect(this._analyser);
           // Start monitoring
           this.startMonitoring();
         } catch (error) {
           console.error('SoundMeter: Error during attach:', error);
-          this.detach(); // Cleanup on error
+          this.detach();
         }
       }
-
       detach() {
-        // POPRAWKA: Zabezpieczenie przed wielokrotnym wywołaniem
         if (!this._audioContext && !this._analyser && !this._microphone) {
-          return; // Już wyczyszczone
+          return;
         }
-        // Stop monitoring first
         this._isMonitoring = false;
-        // POPRAWKA: Anulowanie requestAnimationFrame
         if (this._animationFrameId !== null) {
           cancelAnimationFrame(this._animationFrameId);
           this._animationFrameId = null;
         }
-        // Disconnect and cleanup nodes in reverse order
         if (this._microphone) {
           try {
             this._microphone.disconnect();
@@ -3735,13 +3729,9 @@
         }
         if (this._audioContext) {
           try {
-            // POPRAWKA: Sprawdzenie przed użyciem w Promise
             if (this._audioContext.state !== 'closed') {
-              // Zapisz referencję przed asynchroniczną operacją
               const audioContextRef = this._audioContext;
-              // Najpierw ustaw na null, żeby uniknąć podwójnego wywołania
               this._audioContext = null;
-              // Teraz bezpiecznie zamknij
               audioContextRef.suspend().then(() => audioContextRef.close()).catch(e => {
                 console.warn('SoundMeter: Error closing audio context:', e);
               });
@@ -3765,28 +3755,29 @@
         this._isMonitoring = true;
         const dataArray = new Float32Array(this._analyser.frequencyBinCount);
         const analyze = () => {
-          // POPRAWKA: Dodatkowe sprawdzenie przed kontynuacją
           if (!this._analyser || !this._isMonitoring || !this._audioContext) {
             this._animationFrameId = null;
             return;
           }
           const now = Date.now();
           try {
-            // Read time-domain data
             this._analyser.getFloatTimeDomainData(dataArray);
-            // Calculate levels
-            let sum = 0.0;
-            let clipcount = 0;
+            // Peak detection - find maximum amplitude
+            let peak = 0.0;
             for (let i = 0; i < dataArray.length; ++i) {
-              const amplitude = dataArray[i];
-              sum += amplitude * amplitude;
-              if (Math.abs(amplitude) > 0.99) {
-                clipcount += 1;
+              const amplitude = Math.abs(dataArray[i]);
+              if (amplitude > peak) {
+                peak = amplitude;
               }
             }
-            // Update metrics
-            this._instant = Math.sqrt(sum / dataArray.length);
-            this._slow = 0.05 * this._instant + 0.95 * this._slow;
+            // Instant = current peak (clamped to 1.0)
+            this._instant = Math.min(1.0, peak);
+            // Slow = peak hold with decay (classic VU meter behavior)
+            if (this._instant > this._slow) {
+              this._slow = this._instant;
+            } else {
+              this._slow *= this.PEAK_DECAY;
+            }
             // Throttle event dispatch
             if (now - this._lastEventTime >= this.THROTTLE_INTERVAL) {
               this._lastEventTime = now;
@@ -3802,17 +3793,13 @@
             this._animationFrameId = null;
             return;
           }
-          // Schedule next analysis only if still monitoring
           if (this._isMonitoring) {
             this._animationFrameId = requestAnimationFrame(analyze);
           }
         };
-        // Start analysis loop
         this._animationFrameId = requestAnimationFrame(analyze);
       }
-      // POPRAWKA: Dodana metoda destroy
       destroy() {
-        console.log('SoundMeter: Destroying instance');
         this.detach();
       }
     }
@@ -4331,7 +4318,7 @@
        * @param config
        */
       constructor(main) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         /**
          * Whenever current window is active or not
          * @private
@@ -4345,7 +4332,7 @@
           'iceServers': []
         };
         /**
-         * Whenever microphone is currenly muted
+         * Whenever microphone is currently muted
          * @private
          */
         this._isMicrophoneMuted = false;
@@ -4355,7 +4342,7 @@
          */
         this._pendingMicrophoneState = null;
         /**
-         * Whenever we have cheched for permissions
+         * Whenever we have checked for permissions
          * @private
          */
         this._permissionChecked = false;
@@ -4418,58 +4405,83 @@
         this._currentOrientation = ((_a = window.screen.orientation) === null || _a === void 0 ? void 0 : _a.type) || '';
         this._statusTimer = null;
         this._debug = false;
-        // NOWE POLA DLA ANULOWANIA OPERACJI
+        // FIELDS FOR OPERATION CANCELLATION
         this._deviceChangeHandler = null;
         this._orientationChangeHandler = null;
-        this._isDestroying = false;
+        /**
+         * CRITICAL: This flag is checked after EVERY async operation
+         * Set to true immediately when destroy() is called
+         * @private
+         */
+        this._isDestroyed = false;
         this._cameraAbortController = null;
         this._microphoneAbortController = null;
         this._startCameraAbortController = null;
         this._switchingCamera = false;
         this._switchingMicrophone = false;
         this._firstPublish = true;
+        /**
+         * Counter for tracking active media streams (for debugging)
+         * @private
+         */
+        this._activeStreamCount = 0;
+        /**
+         * Permission status objects that need cleanup
+         * @private
+         */
+        this._cameraPermissionStatus = null;
+        this._microphonePermissionStatus = null;
+        /**
+         * Bound handlers for permission changes (needed for removal)
+         * @private
+         */
+        this._boundCameraPermissionHandler = null;
+        this._boundMicrophonePermissionHandler = null;
         /**
          * Handles device state changes and initiates publishing if appropriate
          * @private
          */
         this.onDeviceStateChange = event => {
           var _a;
+          if (this._isDestroyed) return;
           const usedStreamKey = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey;
           if (event.state == exports.InputDevicesState.READY && usedStreamKey != null) {
             this.publish(usedStreamKey);
           }
         };
         /**
-         * This method is responsible for handing orientation changes for mobile devices
+         * Handles orientation changes for mobile devices
          */
         this.handleOrientationChange = () => __awaiter(this, void 0, void 0, function* () {
-          var _d, _e;
-          if (this._isDestroying) return;
-          // Dajemy chwilę na ustabilizowanie się orientacji
+          var _e, _f;
+          if (this._isDestroyed) return;
           yield new Promise(resolve => setTimeout(resolve, 500));
-          const newOrientation = ((_d = window.screen.orientation) === null || _d === void 0 ? void 0 : _d.type) || '';
+          if (this._isDestroyed) return;
+          const newOrientation = ((_e = window.screen.orientation) === null || _e === void 0 ? void 0 : _e.type) || '';
           if (this._currentOrientation !== newOrientation) {
             this._logger.info(this, `Orientation changed from ${this._currentOrientation} to ${newOrientation}`);
             this._currentOrientation = newOrientation;
-            // Zapamiętaj aktualny stream key i stan publikacji
-            const streamKey = (_e = this._main.getConfigManager()) === null || _e === void 0 ? void 0 : _e.getStreamData().streamKey;
+            const streamKey = (_f = this._main.getConfigManager()) === null || _f === void 0 ? void 0 : _f.getStreamData().streamKey;
             this._publishState === exports.PublishState.PUBLISHED;
-            // Zamknij istniejące połączenie i stream
             this.closeWebRTCConnection();
             if (this._stream) {
+              this._logger.info(this, "📹 [RELEASE] handleOrientationChange() - releasing stream for orientation change");
               this._stream.getTracks().forEach(track => {
                 track.stop();
+                this._logger.info(this, `📹 [RELEASE] handleOrientationChange() - stopped track: ${track.kind}`);
               });
               this._stream = null;
+              this._activeStreamCount--;
             }
-            // Rozpocznij wszystko od nowa
+            if (this._isDestroyed) return;
             try {
               yield this.startCamera();
-              // Jeśli stream był opublikowany, publikujemy ponownie
-              if (streamKey && !this._isDestroying) {
+              if (this._isDestroyed) return;
+              if (streamKey) {
                 this.publish(streamKey);
               }
             } catch (error) {
+              if (this._isDestroyed) return;
               this._logger.error(this, "Error restarting stream after orientation change: " + JSON.stringify(error));
               this.setInputDeviceState(exports.InputDevicesState.INVALID);
             }
@@ -4478,10 +4490,8 @@
         this.onServerDisconnect = () => {
           // Implementation
         };
-        /**
-         * Method for handling a situation when a given streamKey is already in use.
-         */
         this.onStreamKeyTaken = () => {
+          if (this._isDestroyed) return;
           if (this._restartTimer != null) {
             clearInterval(this._restartTimer);
             this._restartTimerCount = 0;
@@ -4490,6 +4500,10 @@
           this.setPublishState(exports.PublishState.ERROR);
           this._restartTimer = setInterval(() => {
             var _a, _b;
+            if (this._isDestroyed) {
+              if (this._restartTimer) clearInterval(this._restartTimer);
+              return;
+            }
             if (this._restartTimer != null) {
               if (this._restartTimerCount < this._restartTimerMaxCount) {
                 this._logger.info(this, "WebRTCStreamer :: StreamKeyTaken Interval: " + this._restartTimerCount + "/" + this._restartTimerMaxCount);
@@ -4500,41 +4514,37 @@
                 this._restartTimerCount = 0;
                 const streamData = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData();
                 const streamKey = streamData === null || streamData === void 0 ? void 0 : streamData.streamKey;
-                if (streamKey != null) {
-                  const prevStreamKey = streamKey;
-                  this.publish(prevStreamKey);
+                if (streamKey != null && !this._isDestroyed) {
+                  this.publish(streamKey);
                 }
               }
-              const usedStreamKey = (_b = this._main.getConfigManager().getStreamData().streamKey) !== null && _b !== void 0 ? _b : "unknown";
-              this._main.dispatchEvent("streamKeyInUseInterval", {
-                ref: this._main,
-                streamKey: usedStreamKey,
-                count: this._restartTimerCount,
-                maxCount: this._restartTimerMaxCount
-              });
+              if (!this._isDestroyed) {
+                const usedStreamKey = (_b = this._main.getConfigManager().getStreamData().streamKey) !== null && _b !== void 0 ? _b : "unknown";
+                this._main.dispatchEvent("streamKeyInUseInterval", {
+                  ref: this._main,
+                  streamKey: usedStreamKey,
+                  count: this._restartTimerCount,
+                  maxCount: this._restartTimerMaxCount
+                });
+              }
             }
           }, 1000);
         };
         //------------------------------------------------------------------------//
         // NETWORK AND RTC
         //------------------------------------------------------------------------//
-        /**
-         * Method fires once a connection with wowza is established. It's the main connection where we exchange
-         * ice-candidates and SDP. We'll start setting up peer connections.
-         */
         this.onServerConnect = () => {
+          if (this._isDestroyed) return;
           if (this._peerConnection) {
             this.closeWebRTCConnection();
           }
           this._peerConnection = new RTCPeerConnection(this._peerConnectionConfig);
-          // Najpierw dodaj tracki
           if (this._stream) {
             let localTracks = this._stream.getTracks();
             for (let localTrack in localTracks) {
               this._peerConnection.addTrack(localTracks[localTrack], this._stream);
             }
           }
-          // Potem dodaj event handlery
           this._peerConnection.onicecandidate = event => {
             this.onIceCandidate(event);
           };
@@ -4542,26 +4552,29 @@
             this.onConnectionStateChange(event);
           };
           this._peerConnection.onnegotiationneeded = event => __awaiter(this, void 0, void 0, function* () {
-            if (this._peerConnection) {
+            if (this._peerConnection && !this._isDestroyed) {
               try {
                 const description = yield this._peerConnection.createOffer();
-                yield this.onDescriptionSuccess(description);
+                if (!this._isDestroyed) {
+                  yield this.onDescriptionSuccess(description);
+                }
               } catch (error) {
                 this.onDescriptionError(error);
-                console.error('Error creating offer:', error);
               }
             }
           });
           this.createStatusConnection();
         };
-        /**
-         * Method fires once a status connection is established. We'll set an interval for monitoring stream status.
-         */
         this.onStatusServerConnect = () => {
+          if (this._isDestroyed) return;
           const usedStreamKey = this._main.getConfigManager().getStreamData().streamKey;
           if (this._statusTimer == null) {
             if (this._statusConnection != null && usedStreamKey != null) {
               this._statusTimer = setInterval(() => {
+                if (this._isDestroyed) {
+                  if (this._statusTimer) clearInterval(this._statusTimer);
+                  return;
+                }
                 this.requestStatusData();
               }, 1000);
             }
@@ -4569,27 +4582,22 @@
         };
         this.requestStatusData = () => {
           var _a;
+          if (this._isDestroyed) return;
           (_a = this._statusConnection) === null || _a === void 0 ? void 0 : _a.sendData('{"packetID":"STREAM_STATUS", "streamKey": "' + this._fullStreamName + '"}');
         };
-        /**
-         * If for some reason the status connection is disconnected we have to clean the interval
-         */
         this.onStatusServerDisconnect = () => {
           if (this._statusTimer != null) clearInterval(this._statusTimer);
           this._statusTimer = null;
         };
-        /**
-         * This event fires whenever "STREAM_STATUS_RESPONSE" packet form status connection reports stream status along some stream data. This gives
-         * us an insight into whenever our stream is ok (works) or not.
-         * @param event
-         */
         this.onStreamStatsUpdate = event => {
+          if (this._isDestroyed) return;
           const update = event.streamStatus;
           if (this._publishState == exports.PublishState.PUBLISHED && update.publishState != exports.PublishState.PUBLISHED) this.setPublishState(exports.PublishState.UNPUBLISHED);
           if (this._publishState == exports.PublishState.CONNECTED && update.publishState == exports.PublishState.PUBLISHED) this.setPublishState(exports.PublishState.PUBLISHED);
         };
         this.onDescriptionSuccess = description => {
           var _a, _b, _c;
+          if (this._isDestroyed) return;
           this._fullStreamName = ((_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey) + "_" + new Date().getTime();
           const streamInfo = {
             applicationName: (_c = (_b = this._main.getNetworkController()) === null || _b === void 0 ? void 0 : _b.getConnection().getCurrentServer()) === null || _c === void 0 ? void 0 : _c.getApplication(),
@@ -4603,22 +4611,19 @@
             videoCodec: "42e01f",
             audioCodec: "opus"
           });
-          if (this._peerConnection) {
+          if (this._peerConnection && !this._isDestroyed) {
             this._peerConnection.setLocalDescription(description).then(() => {
               var _a;
+              if (this._isDestroyed) return;
               (_a = this._main.getNetworkController()) === null || _a === void 0 ? void 0 : _a.sendMessage('{"direction":"publish", "command":"sendOffer", "streamInfo":' + JSON.stringify(streamInfo) + ', "sdp":' + JSON.stringify(description) + '}');
             }).catch(error => {
               console.log(error);
-              //this.onWebRTCError(error, self);
             });
           }
         };
         //------------------------------------------------------------------------//
         // BLUR & FOCUS
         //------------------------------------------------------------------------//
-        /**
-         * Methods handles visibility change events
-         */
         this.visibilityChange = () => {
           if (document.visibilityState === 'hidden') {
             this.onWindowBlur();
@@ -4626,18 +4631,12 @@
             this.onWindowFocus();
           }
         };
-        /**
-         * Reacts to browser changing visibility of the document (or blur)
-         */
         this.onWindowBlur = () => {
           if (this._isWindowActive) {
             this._logger.warning(this, "Player window is no longer in focus!");
           }
           this._isWindowActive = false;
         };
-        /**
-         * Reacts to browser changing visibility of the document (or focus)
-         */
         this.onWindowFocus = () => {
           if (!this._isWindowActive) {
             this._logger.info(this, "Player window is focused again!");
@@ -4649,38 +4648,76 @@
         this._mungeSDP = new MungeSDP();
         this._soundMeter = new SoundMeter(this._main);
         this._debug = (_c = (_b = this._main.getConfigManager()) === null || _b === void 0 ? void 0 : _b.getSettingsData().getDebugData().streamerControllerDebug) !== null && _c !== void 0 ? _c : this._debug;
+        // Restore saved microphone mute state
+        const savedMuteState = (_d = this._main.getStorageManager()) === null || _d === void 0 ? void 0 : _d.getField("microphoneMuted");
+        if (savedMuteState !== null) {
+          this._isMicrophoneMuted = savedMuteState === "true";
+          this._logger.info(this, `📹 [INIT] Restored microphone mute state: ${this._isMicrophoneMuted}`);
+        }
         // Start initialization process
         this.initialize();
       }
       //------------------------------------------------------------------------//
+      // HELPER: Check if destroyed
+      //------------------------------------------------------------------------//
+      /**
+       * Helper method to check if instance is destroyed
+       * Call this after EVERY await!
+       * @private
+       */
+      isDestroyedCheck(context) {
+        var _a;
+        if (this._isDestroyed) {
+          if (context) {
+            (_a = this._logger) === null || _a === void 0 ? void 0 : _a.info(this, `📹 [ABORT] ${context} - instance destroyed, aborting`);
+          }
+          return true;
+        }
+        return false;
+      }
+      //------------------------------------------------------------------------//
       // MAIN METHODS
       //------------------------------------------------------------------------//
       /**
        * Initializes the PlaybackController by setting up event listeners and device handling
-       * This method orchestrates the initialization process by first checking device availability
-       * and permissions, then setting up necessary event listeners and configurations
        * @private
        */
       initialize() {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+          this._logger.info(this, "📹 [INIT] initialize() - starting initialization");
           try {
+            if (this.isDestroyedCheck("initialize start")) return;
             yield this.initializeDevices();
+            if (this.isDestroyedCheck("after initializeDevices")) return;
             this.setupEventListeners();
+            if (this.isDestroyedCheck("after setupEventListeners")) return;
             this.initializeStream();
+            if (this.isDestroyedCheck("after initializeStream")) return;
             this.setupOrientationListener();
-            this.setupPermissionListeners();
+            yield this.setupPermissionListeners();
+            if (this.isDestroyedCheck("after setupPermissionListeners")) return;
             this.setupDeviceChangeListener();
+            if (this.isDestroyedCheck("before network init")) return;
             if ((_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getSettingsData().autoConnect) {
               this._logger.info(this, "Initializing NetworkController (autoConnect is true)");
               (_b = this._main.getNetworkController()) === null || _b === void 0 ? void 0 : _b.initialize();
             } else {
               this._logger.warning(this, "Warning - autoConnect is set to false, switching to standby mode!");
             }
+            this._logger.success(this, "📹 [INIT] initialize() - completed successfully");
           } catch (error) {
+            if (this._isDestroyed) {
+              this._logger.warning(this, "📹 [INIT] initialize() - aborted by destroy()");
+              return;
+            }
             this._logger.error(this, "Initialization failed: " + JSON.stringify(error));
             this.setInputDeviceState(exports.InputDevicesState.INVALID);
           }
+          this._main.dispatchEvent("microphoneStateChange", {
+            ref: this._main,
+            isMuted: this._isMicrophoneMuted
+          });
         });
       }
       /**
@@ -4688,6 +4725,7 @@
        * @private
        */
       setupEventListeners() {
+        if (this._isDestroyed) return;
         this._main.addEventListener("serverConnect", this.onServerConnect, false);
         this._main.addEventListener("serverDisconnect", this.onServerDisconnect, false);
         this._main.addEventListener("streamKeyInUse", this.onStreamKeyTaken, false);
@@ -4706,19 +4744,38 @@
       initializeDevices() {
         return __awaiter(this, void 0, void 0, function* () {
           try {
+            this._logger.info(this, "📹 [ACQUIRE] initializeDevices() - requesting test getUserMedia for permissions");
+            if (this.isDestroyedCheck("initializeDevices before getUserMedia")) return;
             // Request initial device permissions
             const stream = yield navigator.mediaDevices.getUserMedia({
               video: true,
               audio: true
             });
+            // CRITICAL: Check IMMEDIATELY after getUserMedia returns
+            if (this._isDestroyed) {
+              this._logger.warning(this, "📹 [RELEASE] initializeDevices() - destroyed during getUserMedia, releasing orphan stream");
+              stream.getTracks().forEach(track => {
+                track.stop();
+                this._logger.info(this, `📹 [RELEASE] initializeDevices() - stopped orphan track: ${track.kind}, id: ${track.id}`);
+              });
+              return;
+            }
+            this._logger.info(this, "📹 [RELEASE] initializeDevices() - stopping test stream immediately");
             // Stop the test stream
-            stream.getTracks().forEach(track => track.stop());
+            stream.getTracks().forEach(track => {
+              track.stop();
+              this._logger.info(this, `📹 [RELEASE] initializeDevices() - stopped track: ${track.kind}, id: ${track.id}`);
+            });
+            if (this.isDestroyedCheck("initializeDevices before grabDevices")) return;
             // Initialize device lists
             yield this.grabDevices();
           } catch (error) {
+            if (this._isDestroyed) return;
             console.log(error);
             this._logger.error(this, "Error initializing devices: " + JSON.stringify(error));
-            yield this.grabDevices();
+            if (!this._isDestroyed) {
+              yield this.grabDevices();
+            }
           }
         });
       }
@@ -4727,38 +4784,73 @@
        * @private
        */
       initializeStream() {
+        if (this._isDestroyed) return;
         if (this._selectedCamera || this._selectedMicrophone) {
           this.startCamera();
         }
       }
+      /**
+       * Sets up permission listeners with proper cleanup tracking
+       * @private
+       */
       setupPermissionListeners() {
-        const cameraQuery = {
-          name: 'camera'
-        };
-        const microphoneQuery = {
-          name: 'microphone'
-        };
-        navigator.permissions.query(cameraQuery).then(permissionStatus => {
-          permissionStatus.onchange = () => {
-            this._permissionChecked = false;
-            this.handlePermissionChange('camera', permissionStatus.state);
-          };
-        });
-        navigator.permissions.query(microphoneQuery).then(permissionStatus => {
-          permissionStatus.onchange = () => {
-            this._permissionChecked = false;
-            this.handlePermissionChange('microphone', permissionStatus.state);
-          };
+        return __awaiter(this, void 0, void 0, function* () {
+          if (this._isDestroyed) return;
+          try {
+            const cameraQuery = {
+              name: 'camera'
+            };
+            const microphoneQuery = {
+              name: 'microphone'
+            };
+            // Camera permission
+            this._cameraPermissionStatus = yield navigator.permissions.query(cameraQuery);
+            if (this._isDestroyed) return;
+            this._boundCameraPermissionHandler = () => {
+              if (this._isDestroyed) return;
+              this._permissionChecked = false;
+              this.handlePermissionChange('camera', this._cameraPermissionStatus.state);
+            };
+            this._cameraPermissionStatus.addEventListener('change', this._boundCameraPermissionHandler);
+            // Microphone permission
+            this._microphonePermissionStatus = yield navigator.permissions.query(microphoneQuery);
+            if (this._isDestroyed) return;
+            this._boundMicrophonePermissionHandler = () => {
+              if (this._isDestroyed) return;
+              this._permissionChecked = false;
+              this.handlePermissionChange('microphone', this._microphonePermissionStatus.state);
+            };
+            this._microphonePermissionStatus.addEventListener('change', this._boundMicrophonePermissionHandler);
+          } catch (error) {
+            this._logger.warning(this, "Could not set up permission listeners: " + error);
+          }
         });
       }
+      /**
+       * Removes permission listeners
+       * @private
+       */
+      removePermissionListeners() {
+        if (this._cameraPermissionStatus && this._boundCameraPermissionHandler) {
+          this._cameraPermissionStatus.removeEventListener('change', this._boundCameraPermissionHandler);
+          this._cameraPermissionStatus = null;
+          this._boundCameraPermissionHandler = null;
+        }
+        if (this._microphonePermissionStatus && this._boundMicrophonePermissionHandler) {
+          this._microphonePermissionStatus.removeEventListener('change', this._boundMicrophonePermissionHandler);
+          this._microphonePermissionStatus = null;
+          this._boundMicrophonePermissionHandler = null;
+        }
+      }
       /**
        * Sets up event listener for device changes and handles them appropriately
        * @private
        */
       setupDeviceChangeListener() {
+        if (this._isDestroyed) return;
         this._deviceChangeHandler = () => __awaiter(this, void 0, void 0, function* () {
           var _a;
-          if (this._isDestroying) return;
+          if (this._isDestroyed) return;
           if (this._publishState === exports.PublishState.PUBLISHED) {
             this._logger.info(this, "Device change detected, but already publish - no restarting streamer");
             return;
@@ -4769,37 +4861,49 @@
           try {
             this.stop();
             yield new Promise(resolve => setTimeout(resolve, 500));
-            if (!this._isDestroying) {
-              yield this.start();
-              if (wasPublishing && streamKey && !this._isDestroying) {
-                this._logger.info(this, "Resuming publishing after device change");
-                if (this.isStreamReady(true, true)) {
-                  this.publish(streamKey);
-                } else {
-                  this._logger.warning(this, "Cannot resume publishing - stream not ready after device change");
-                  this._main.dispatchEvent("inputDeviceError", {
-                    ref: this._main
-                  });
-                }
+            if (this._isDestroyed) return;
+            yield this.start();
+            if (this._isDestroyed) return;
+            if (wasPublishing && streamKey) {
+              this._logger.info(this, "Resuming publishing after device change");
+              if (this.isStreamReady(true, true)) {
+                this.publish(streamKey);
+              } else {
+                this._logger.warning(this, "Cannot resume publishing - stream not ready after device change");
+                this._main.dispatchEvent("inputDeviceError", {
+                  ref: this._main
+                });
               }
             }
             this._logger.success(this, "Successfully handled device change");
           } catch (error) {
+            if (this._isDestroyed) return;
             this._logger.error(this, "Error handling device change: " + JSON.stringify(error));
             this.setInputDeviceState(exports.InputDevicesState.INVALID);
           }
         });
         navigator.mediaDevices.addEventListener('devicechange', this._deviceChangeHandler);
       }
+      /**
+       * Handles permission changes for camera or microphone
+       * @private
+       */
       handlePermissionChange(device, state) {
         return __awaiter(this, void 0, void 0, function* () {
+          if (this._isDestroyed) return;
+          this._logger.info(this, `📹 [PERMISSION] handlePermissionChange() - device: ${device}, state: ${state}`);
           if (state === 'denied') {
             this.setInputDeviceState(exports.InputDevicesState.INVALID);
-            if (this._publishState == exports.PublishState.CONNECTED) {
-              this.closeStream();
+            // Stop the media stream AND WebRTC
+            if (this._publishState == exports.PublishState.CONNECTED || this._stream) {
+              this._logger.info(this, "📹 [RELEASE] handlePermissionChange() - permission denied, stopping all streams");
+              this.stopCameraStream();
+              this.closeWebRTCConnection();
             }
           }
+          if (this._isDestroyed) return;
           yield this.grabDevices();
+          if (this._isDestroyed) return;
           if (state === 'granted') {
             yield this.startCamera();
           }
@@ -4809,7 +4913,17 @@
        * Handles successful camera stream initialization
        */
       onCameraStreamSuccess(stream) {
-        this._logger.success(this, "Camera stream successfully retrieved");
+        var _a, _b;
+        // CRITICAL: Check if we were destroyed while waiting
+        if (this._isDestroyed) {
+          this._logger.warning(this, "📹 [RELEASE] onCameraStreamSuccess() - destroyed, releasing stream immediately");
+          stream.getTracks().forEach(track => {
+            track.stop();
+          });
+          return;
+        }
+        this._activeStreamCount++;
+        this._logger.success(this, `📹 [ACQUIRED] onCameraStreamSuccess() - stream acquired, id: ${stream.id}, active streams: ${this._activeStreamCount}`);
         // Get actual stream dimensions
         const videoTrack = stream.getVideoTracks()[0];
         const audioTrack = stream.getAudioTracks()[0];
@@ -4818,7 +4932,6 @@
           const settings = videoTrack.getSettings();
           let width = settings.width;
           let height = settings.height;
-          // Na urządzeniach mobilnych potrzebujemy skorygować wymiary
           const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
           if (isMobile) {
             if (width > height && window.innerWidth < window.innerHeight || width < height && window.innerWidth > window.innerHeight) {
@@ -4828,12 +4941,10 @@
           streamData.streamWidth = width;
           streamData.streamHeight = height;
           streamData.videoTrackPresent = true;
-          // Obliczanie proporcji i konwersja na string
           const gcd = (a, b) => b ? gcd(b, a % b) : a;
           const divisor = gcd(width, height);
           const widthRatio = width / divisor;
           const heightRatio = height / divisor;
-          // Sprawdzamy typowe proporcje z pewną tolerancją
           const ratio = width / height;
           let aspectRatioString = `${widthRatio}:${heightRatio}`;
           if (Math.abs(ratio - 16 / 9) < 0.1) {
@@ -4842,11 +4953,22 @@
             aspectRatioString = width > height ? "4:3" : "3:4";
           }
           streamData.aspectRatio = aspectRatioString;
+          this._logger.info(this, `📹 [INFO] Video track - id: ${videoTrack.id}, enabled: ${videoTrack.enabled}, readyState: ${videoTrack.readyState}`);
         } else {
           streamData.videoTrackPresent = false;
         }
+        if (audioTrack) {
+          this._logger.info(this, `📹 [INFO] Audio track - id: ${audioTrack.id}, enabled: ${audioTrack.enabled}, readyState: ${audioTrack.readyState}`);
+        }
         streamData.audioTrackPresent = !!audioTrack;
         this._logger.info(this, `Publish MetaData :: Resolution: ${streamData.streamWidth}x${streamData.streamHeight} | ` + `Aspect ratio: ${streamData.aspectRatio}, ` + `Video track: ${streamData.videoTrackPresent} | Audio track: ${streamData.audioTrackPresent}`);
+        // Double-check we weren't destroyed during setup
+        if (this._isDestroyed) {
+          this._logger.warning(this, "📹 [RELEASE] onCameraStreamSuccess() - destroyed during setup, releasing");
+          stream.getTracks().forEach(track => track.stop());
+          this._activeStreamCount--;
+          return;
+        }
         // Dispatch event with stream data
         this._main.dispatchEvent("publishMetadataUpdate", {
           ref: this._main,
@@ -4865,7 +4987,7 @@
         if (this._cameraList == null || this._microphoneList == null) {
           this.grabDevices();
         }
-        const videoElement = this._main.getStageController().getScreenElement().getVideoElement();
+        const videoElement = (_b = (_a = this._main.getStageController()) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getVideoElement();
         if (videoElement) {
           videoElement.srcObject = stream;
           videoElement.autoplay = true;
@@ -4881,6 +5003,7 @@
        */
       initializeWebRTC() {
         var _a;
+        if (this._isDestroyed) return;
         if (!this._stream) {
           this._logger.error(this, "Cannot initialize WebRTC - no camera stream available");
           return;
@@ -4894,12 +5017,10 @@
         }
       }
       /**
-       * Modified publish method to handle both camera and WebRTC
-       *
-       * @param streamKey - klucz streamu
-       * @returns {boolean} - true jeśli udało się rozpocząć publikowanie
+       * Publish method
        */
       publish(streamKey) {
+        if (this._isDestroyed) return false;
         if (this._debug) this._logger.decoratedLog("Publishing: " + streamKey, "dark-red");
         this._logger.info(this, "Publish: " + streamKey);
         if (this._statusTimer != null) clearInterval(this._statusTimer);
@@ -4920,8 +5041,12 @@
         this._firstPublish = false;
         return true;
       }
+      /**
+       * Stops publishing and cleans up WebRTC connection
+       */
       unpublish() {
         if (this._debug) this._logger.decoratedLog("Unpublish", "dark-red");
+        this._logger.info(this, "📹 [UNPUBLISH] unpublish() - stopping WebRTC but keeping camera preview");
         if (this._statusConnection != null) {
           this._statusConnection.destroy();
           this._statusConnection = null;
@@ -4935,13 +5060,23 @@
         this._main.dispatchEvent("unpublish", {
           ref: this._main
         });
-        this.closeStream();
+        this.closeWebRTCConnection();
+        this.setPublishState(exports.PublishState.UNPUBLISHED);
+      }
+      /**
+       * Stops publishing AND releases camera/microphone
+       */
+      unpublishAndRelease() {
+        this._logger.info(this, "📹 [UNPUBLISH+RELEASE] unpublishAndRelease() - stopping everything");
+        this.unpublish();
+        this.stopCameraStream();
       }
       /**
-       * This method
+       * Sets up orientation listener
        * @private
        */
       setupOrientationListener() {
+        if (this._isDestroyed) return;
         this._orientationChangeHandler = this.handleOrientationChange;
         if (window.screen && window.screen.orientation) {
           window.screen.orientation.addEventListener('change', this._orientationChangeHandler);
@@ -4953,21 +5088,20 @@
       // USER MEDIA
       //------------------------------------------------------------------------//
       /**
-       * Error on trying to grab video stream (it usually means that browser does not support WebRTC streaming)
-       *
-       * @param error
+       * Error handler for getUserMedia
        */
       onUserMediaError(error) {
         return __awaiter(this, void 0, void 0, function* () {
+          if (this._isDestroyed) return;
+          this._logger.error(this, `📹 [ERROR] onUserMediaError() - ${error.name}: ${error.message}`);
           yield this.grabDevices();
-          // Dodatkowa obsługa specyficznych błędów getUserMedia, jeśli potrzebna
           if (error.name === "OverconstrainedError") {
             this._logger.warning(this, "Device constraints not satisfied");
           }
         });
       }
       /**
-       * This method is used for checking individual access to output devices
+       * Checks individual device access
        * @private
        */
       checkIndividualDeviceAccess() {
@@ -4982,44 +5116,47 @@
               available: false
             }
           };
-          // Sprawdzamy fizyczną dostępność urządzeń
+          if (this._isDestroyed) return results;
           try {
             const devices = yield navigator.mediaDevices.enumerateDevices();
+            if (this._isDestroyed) return results;
             results.camera.available = devices.some(device => device.kind === 'videoinput');
             results.microphone.available = devices.some(device => device.kind === 'audioinput');
-            // Sprawdzamy czy mamy etykiety urządzeń - ich brak może oznaczać brak uprawnień
             const hasLabels = devices.some(device => device.label !== '');
             if (!hasLabels) {
-              // Jeśli nie mamy etykiet, wymuszamy pytanie o uprawnienia
+              this._logger.info(this, "📹 [ACQUIRE] checkIndividualDeviceAccess() - no labels, requesting permissions");
+              if (this._isDestroyed) return results;
               try {
                 const stream = yield navigator.mediaDevices.getUserMedia({
                   video: results.camera.available,
                   audio: results.microphone.available
                 });
-                // Jeśli udało się uzyskać strumień, mamy uprawnienia
+                // CRITICAL: Check IMMEDIATELY after getUserMedia
+                if (this._isDestroyed) {
+                  this._logger.warning(this, "📹 [RELEASE] checkIndividualDeviceAccess() - destroyed, releasing orphan stream");
+                  stream.getTracks().forEach(track => track.stop());
+                  return results;
+                }
                 results.camera.allowed = stream.getVideoTracks().length > 0;
                 results.microphone.allowed = stream.getAudioTracks().length > 0;
-                // Zatrzymujemy strumień testowy
-                stream.getTracks().forEach(track => track.stop());
-                // Aktualizujemy listę urządzeń po uzyskaniu uprawnień
+                this._logger.info(this, "📹 [RELEASE] checkIndividualDeviceAccess() - stopping test stream");
+                stream.getTracks().forEach(track => {
+                  track.stop();
+                  this._logger.info(this, `📹 [RELEASE] checkIndividualDeviceAccess() - stopped track: ${track.kind}`);
+                });
+                if (this._isDestroyed) return results;
                 yield this.grabDevices();
               } catch (error) {
                 console.error('Error requesting permissions:', error);
-                // Nie udało się uzyskać uprawnień
                 results.camera.allowed = false;
                 results.microphone.allowed = false;
               }
             } else {
-              // Jeśli mamy etykiety, prawdopodobnie mamy już uprawnienia
               results.camera.allowed = devices.some(device => device.kind === 'videoinput' && device.label !== '');
               results.microphone.allowed = devices.some(device => device.kind === 'audioinput' && device.label !== '');
             }
           } catch (error) {
             console.error('Error checking devices:', error);
-            results.camera.available = false;
-            results.microphone.available = false;
-            results.camera.allowed = false;
-            results.microphone.allowed = false;
           }
           return results;
         });
@@ -5028,21 +5165,18 @@
       // SOCKETS & SDP
       //------------------------------------------------------------------------//
       /**
-       * This method handles basic SDP/ICE-Candidate exchange with a Wowza Server
-       *
-       * @param data
+       * Handles SDP/ICE-Candidate exchange
        */
       onSocketMessage(data) {
         var _a;
+        if (this._isDestroyed) return;
         let msgJSON = JSON.parse(data);
         let msgStatus = Number(msgJSON["status"]);
         switch (msgStatus) {
           case 200:
-            // OK
             this._logger.info(this, "SDP Exchange Successful");
             let sdpData = msgJSON['sdp'];
-            if (sdpData !== undefined) {
-              // @ts-ignore
+            if (sdpData !== undefined && this._peerConnection) {
               this._peerConnection.setRemoteDescription(new RTCSessionDescription(sdpData), () => {}, () => {});
             }
             let iceCandidates = msgJSON['iceCandidates'];
@@ -5053,7 +5187,6 @@
             }
             break;
           case 503:
-            // NOT OK
             this._logger.error(this, "StreamKey already use");
             const usedStreamKey = (_a = this._main.getConfigManager().getStreamData().streamKey) !== null && _a !== void 0 ? _a : "unknown";
             this._main.dispatchEvent("streamKeyInUse", {
@@ -5067,14 +5200,8 @@
       //------------------------------------------------------------------------//
       // EVENTS
       //------------------------------------------------------------------------//
-      /**
-       * Recives events related to peerConnection (change of state)
-       *
-       * @param event event with its data
-       * @param thisRef reference to player classonConnectionStateChange
-       * @private
-       */
       onConnectionStateChange(event) {
+        if (this._isDestroyed) return;
         this._logger.info(this, "Connection State Change: " + JSON.stringify(event));
         if (event !== null) {
           switch (event.currentTarget.connectionState) {
@@ -5105,16 +5232,16 @@
       // DEVICES
       //------------------------------------------------------------------------//
       /**
-       * Returns list od devices (cameras, microphones) available for user's device
+       * Grabs available devices
        */
       grabDevices() {
         return __awaiter(this, void 0, void 0, function* () {
+          if (this._isDestroyed) return;
           try {
             const deviceAccess = yield this.checkIndividualDeviceAccess();
+            if (this._isDestroyed) return;
             this._cameraList = new InputDeviceList();
             this._microphoneList = new InputDeviceList();
-            // Wysyłamy eventy tylko jeśli nie sprawdzaliśmy wcześniej uprawnień
-            // lub jeśli zmienił się stan uprawnień (resetowana flaga)
             if (!this._permissionChecked) {
               if (!deviceAccess.camera.allowed) {
                 this._main.dispatchEvent("cameraAccessDenied", {
@@ -5143,8 +5270,9 @@
                 this.setInputDeviceState(exports.InputDevicesState.INVALID);
               }
             }
-            // Wypełnianie list dostępnymi urządzeniami
+            if (this._isDestroyed) return;
             const devices = yield navigator.mediaDevices.enumerateDevices();
+            if (this._isDestroyed) return;
             for (const device of devices) {
               if (device.deviceId && device.label) {
                 if (device.kind === 'videoinput' && deviceAccess.camera.allowed) {
@@ -5156,8 +5284,8 @@
                 }
               }
             }
+            if (this._isDestroyed) return;
             try {
-              // Aktualizacja wybranych urządzeń
               if (deviceAccess.camera.allowed) {
                 this._selectedCamera = this.pickCamera();
               }
@@ -5167,38 +5295,41 @@
             } catch (error) {
               console.log(error);
               this.setInputDeviceState(exports.InputDevicesState.INVALID);
-              this._logger.error(this, "Errror on grab devices: " + JSON.stringify(error));
+              this._logger.error(this, "Error on grab devices: " + JSON.stringify(error));
+            }
+            if (!this._isDestroyed) {
+              this._main.dispatchEvent("deviceListUpdate", {
+                ref: this._main,
+                cameraList: this._cameraList.getArray(),
+                microphoneList: this._microphoneList.getArray()
+              });
             }
-            // Zawsze wysyłamy aktualizację list urządzeń
-            this._main.dispatchEvent("deviceListUpdate", {
-              ref: this._main,
-              cameraList: this._cameraList.getArray(),
-              microphoneList: this._microphoneList.getArray()
-            });
             this._permissionChecked = true;
           } catch (error) {
+            if (this._isDestroyed) return;
             console.error("Error in grabDevices:", error);
             this._cameraList = new InputDeviceList();
             this._microphoneList = new InputDeviceList();
-            this._main.dispatchEvent("deviceListUpdate", {
-              ref: this._main,
-              cameraList: this._cameraList.getArray(),
-              microphoneList: this._microphoneList.getArray()
-            });
-            this._main.dispatchEvent("inputDeviceError", {
-              ref: this._main
-            });
+            if (!this._isDestroyed) {
+              this._main.dispatchEvent("deviceListUpdate", {
+                ref: this._main,
+                cameraList: this._cameraList.getArray(),
+                microphoneList: this._microphoneList.getArray()
+              });
+              this._main.dispatchEvent("inputDeviceError", {
+                ref: this._main
+              });
+            }
           }
         });
       }
       /**
-       * Selects camera based on camera device ID with abort support
-       * @param cameraID
+       * Selects camera by ID
        */
       selectCamera(cameraID) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-          // Anuluj poprzednie przełączanie kamery
+          if (this._isDestroyed) return;
           if (this._cameraAbortController) {
             this._cameraAbortController.abort();
           }
@@ -5206,13 +5337,13 @@
           const signal = this._cameraAbortController.signal;
           try {
             this._switchingCamera = true;
+            this._logger.info(this, `📹 [SWITCH] selectCamera() - switching to camera: ${cameraID}`);
             for (let i = 0; i < this._cameraList.getSize(); i++) {
               this._cameraList.get(i).isSelected = false;
             }
             this._selectedCamera = null;
             this.setInputDeviceState(exports.InputDevicesState.UPDATING);
             this.setCameraState(exports.DeviceState.NOT_INITIALIZED);
-            // Zapamiętaj aktualny stream key i stan publikacji
             const streamKey = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey;
             const wasPublished = this._publishState === exports.PublishState.CONNECTED;
             let found = false;
@@ -5230,14 +5361,11 @@
               cameraList: this._cameraList.getArray(),
               microphoneList: this._microphoneList.getArray()
             });
-            if (signal.aborted) return;
+            if (signal.aborted || this._isDestroyed) return;
             this.stopCameraStream();
             if (this._selectedCamera != null) {
-              // Update constraints with new device
               this._constraints.video.deviceId = this._selectedCamera.id;
-              // Sprawdź czy nie anulowano
-              if (signal.aborted) return;
-              // Poczekaj z możliwością anulowania
+              if (signal.aborted || this._isDestroyed) return;
               yield new Promise((resolve, reject) => {
                 const timeout = setTimeout(resolve, 500);
                 signal.addEventListener('abort', () => {
@@ -5245,20 +5373,20 @@
                   reject(new Error('Aborted'));
                 });
               });
-              if (signal.aborted) return;
-              // Restart camera stream
+              if (signal.aborted || this._isDestroyed) return;
               yield this.startCamera();
+              if (this._isDestroyed) return;
               this.setCameraState(exports.DeviceState.ENABLED);
               if (this._cameraState == exports.DeviceState.ENABLED && this._microphoneState == exports.DeviceState.ENABLED) this.setInputDeviceState(exports.InputDevicesState.READY);else this.setInputDeviceState(exports.InputDevicesState.INVALID);
-              if (wasPublished && streamKey && !signal.aborted) {
+              if (wasPublished && streamKey && !signal.aborted && !this._isDestroyed) {
                 this.publish(streamKey);
               }
             } else {
               this.setInputDeviceState(exports.InputDevicesState.INVALID);
             }
           } catch (error) {
-            if (error.message !== 'Aborted') {
-              this._logger.error(this, 'Error switching camera: ' + error);
+            if (error.message !== 'Aborted' && !this._isDestroyed) {
+              this._logger.error(this, '📹 [ERROR] selectCamera() - Error switching camera: ' + error);
               this.setInputDeviceState(exports.InputDevicesState.INVALID);
             }
           } finally {
@@ -5270,13 +5398,12 @@
         });
       }
       /**
-       * Method tries to select (change) microphone based on its system ID with abort support
-       * @param micID
+       * Selects microphone by ID
        */
       selectMicrophone(micID) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-          // Anuluj poprzednie przełączanie mikrofonu
+          if (this._isDestroyed) return;
           if (this._microphoneAbortController) {
             this._microphoneAbortController.abort();
           }
@@ -5284,17 +5411,15 @@
           const signal = this._microphoneAbortController.signal;
           try {
             this._switchingMicrophone = true;
+            this._logger.info(this, `📹 [SWITCH] selectMicrophone() - switching to microphone: ${micID}`);
             for (let i = 0; i < this._microphoneList.getSize(); i++) {
               this._microphoneList.get(i).isSelected = false;
             }
             this._selectedMicrophone = null;
             this.setInputDeviceState(exports.InputDevicesState.UPDATING);
             this.setMicrophoneState(exports.DeviceState.NOT_INITIALIZED);
-            this._logger.info(this, "Selecting microphone: " + micID);
-            // Zapamiętaj aktualny stream key i stan publikacji
             const streamKey = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey;
             const wasPublished = this._publishState === exports.PublishState.CONNECTED;
-            // Znajdź i zapisz wybrany mikrofon
             for (let i = 0; i < this._microphoneList.getSize(); i++) {
               if (this._microphoneList.get(i).id == micID) {
                 this._selectedMicrophone = this._microphoneList.get(i);
@@ -5303,26 +5428,23 @@
                 break;
               }
             }
-            // Zawsze wysyłamy aktualizację list urządzeń
             this._main.dispatchEvent("deviceListUpdate", {
               ref: this._main,
               cameraList: this._cameraList.getArray(),
               microphoneList: this._microphoneList.getArray()
             });
-            if (signal.aborted) return;
-            // Odłącz SoundMeter przed zmianą strumienia
+            if (signal.aborted || this._isDestroyed) return;
             this._soundMeter.detach();
-            // Zamknij istniejące połączenie WebRTC
             this.closeWebRTCConnection();
-            // Zatrzymaj obecny strumień
             if (this._stream) {
+              this._logger.info(this, "📹 [RELEASE] selectMicrophone() - stopping current stream");
               this._stream.getTracks().forEach(track => {
                 track.stop();
               });
               this._stream = null;
+              this._activeStreamCount--;
             }
-            if (signal.aborted) return;
-            // Poczekaj z możliwością anulowania
+            if (signal.aborted || this._isDestroyed) return;
             yield new Promise((resolve, reject) => {
               const timeout = setTimeout(resolve, 500);
               signal.addEventListener('abort', () => {
@@ -5330,21 +5452,20 @@
                 reject(new Error('Aborted'));
               });
             });
-            if (signal.aborted) return;
-            // Rozpocznij wszystko od nowa
+            if (signal.aborted || this._isDestroyed) return;
             yield this.startCamera();
+            if (this._isDestroyed) return;
             this.setMicrophoneState(exports.DeviceState.ENABLED);
             if (this._cameraState == exports.DeviceState.ENABLED && this._microphoneState == exports.DeviceState.ENABLED) {
               this.setInputDeviceState(exports.InputDevicesState.READY);
             } else {
               this.setInputDeviceState(exports.InputDevicesState.INVALID);
             }
-            // Jeśli stream był opublikowany, publikujemy ponownie
-            if (wasPublished && streamKey && !signal.aborted) {
+            if (wasPublished && streamKey && !signal.aborted && !this._isDestroyed) {
               this.publish(streamKey);
             }
           } catch (error) {
-            if (error.message !== 'Aborted') {
+            if (error.message !== 'Aborted' && !this._isDestroyed) {
               console.error("Error changing microphone:", error);
               this._main.dispatchEvent("inputDeviceError", {
                 ref: this._main
@@ -5360,23 +5481,29 @@
         });
       }
       /**
-       * This method tries to start a camera with abort support
+       * Starts camera with abort support
        * @private
        */
       startCamera() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-          // Anuluj poprzednie uruchamianie kamery
+          if (this._isDestroyed) {
+            this._logger.warning(this, "📹 [ACQUIRE] startCamera() - aborted, instance is destroyed");
+            return;
+          }
           if (this._startCameraAbortController) {
             this._startCameraAbortController.abort();
           }
           this._startCameraAbortController = new AbortController();
           const signal = this._startCameraAbortController.signal;
+          // Release existing stream first
           if (this._stream) {
+            this._logger.info(this, "📹 [RELEASE] startCamera() - releasing existing stream before acquiring new one");
             this._stream.getTracks().forEach(track => {
               track.stop();
             });
             this._stream = null;
+            this._activeStreamCount--;
           }
           try {
             const constraints = {
@@ -5391,18 +5518,24 @@
                 }
               } : false
             };
-            if (signal.aborted) return;
+            if (signal.aborted || this._isDestroyed) return;
+            this._logger.info(this, `📹 [ACQUIRE] startCamera() - requesting getUserMedia`);
             try {
               const stream = yield navigator.mediaDevices.getUserMedia(constraints);
-              if (signal.aborted) {
-                // Jeśli anulowano, zatrzymaj nowo utworzony strumień
-                stream.getTracks().forEach(track => track.stop());
+              // CRITICAL: Check IMMEDIATELY after getUserMedia returns
+              if (signal.aborted || this._isDestroyed) {
+                this._logger.warning(this, "📹 [RELEASE] startCamera() - destroyed during getUserMedia, releasing orphan stream");
+                stream.getTracks().forEach(track => {
+                  track.stop();
+                  this._logger.info(this, `📹 [RELEASE] startCamera() - stopped orphan track: ${track.kind}, id: ${track.id}`);
+                });
                 return;
               }
               this._stream = stream;
               this.onCameraStreamSuccess(this._stream);
             } catch (error) {
-              if (signal.aborted) return;
+              if (signal.aborted || this._isDestroyed) return;
+              this._logger.error(this, `📹 [ERROR] startCamera() - getUserMedia failed: ${error.name}: ${error.message}`);
               if (constraints.video) {
                 this.onUserMediaError({
                   name: error.name || 'Error',
@@ -5420,6 +5553,7 @@
             }
             if (this._cameraState == exports.DeviceState.ENABLED && this._microphoneState == exports.DeviceState.ENABLED) this.setInputDeviceState(exports.InputDevicesState.READY);
           } catch (error) {
+            if (this._isDestroyed) return;
             console.error("Error in startCamera:", error);
             yield this.grabDevices();
           } finally {
@@ -5433,15 +5567,14 @@
        * Updates WebRTC connection with new stream
        */
       updateWebRTCStream() {
+        if (this._isDestroyed) return;
         if (!this._peerConnection || !this._stream) {
           return;
         }
-        // Remove all existing tracks from the peer connection
         const senders = this._peerConnection.getSenders();
         senders.forEach(sender => {
           if (this._peerConnection) this._peerConnection.removeTrack(sender);
         });
-        // Add new tracks
         this._stream.getTracks().forEach(track => {
           if (this._stream != null && this._peerConnection) {
             this._peerConnection.addTrack(track, this._stream);
@@ -5449,32 +5582,24 @@
         });
       }
       /**
-       * Modified closeStream to handle both camera and WebRTC completely
-       */
-      closeStream() {
-        if (this._peerConnection !== undefined && this._peerConnection !== null) this._peerConnection.close();
-        this.setPublishState(exports.PublishState.UNPUBLISHED);
-      }
-      /**
-       * This method selects a camera based on previous uses or saved IDs
+       * Picks camera based on saved ID or defaults
        * @private
        */
       pickCamera() {
         var _a, _b, _c, _d, _e, _f;
+        if (this._isDestroyed) return null;
         for (let i = 0; i < this._cameraList.getSize(); i++) {
           this._cameraList.get(i).isSelected = false;
         }
         let savedCameraID = (_b = (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.getField("cameraID")) !== null && _b !== void 0 ? _b : null;
         if (this._cameraList.getSize() > 0) {
           if (savedCameraID) {
-            // Szukamy zapisanej kamery
             let found = false;
             for (let i = 0; i < this._cameraList.getSize(); i++) {
               if (this._cameraList.get(i).id === savedCameraID) {
                 this._selectedCamera = this._cameraList.get(i);
                 this._selectedCamera.isSelected = true;
                 this.setCameraState(exports.DeviceState.ENABLED);
-                // Ustaw deviceId w constraints
                 found = true;
                 this._constraints.video.deviceId = this._selectedCamera.id;
                 break;
@@ -5491,10 +5616,8 @@
                 this._logger.info(this, "Canceling Publish!");
                 this._main.getConfigManager().getStreamData().streamKey = null;
               }
-              return null;
             }
           }
-          // Jeśli nie znaleziono zapisanej kamery, używamy pierwszej
           if (!this._selectedCamera) {
             this._main.dispatchEvent("savedCameraNotFound", {
               ref: this._main,
@@ -5517,19 +5640,22 @@
             }
           }
         }
-        this._main.dispatchEvent("deviceListUpdate", {
-          ref: this._main,
-          cameraList: this._cameraList.getArray(),
-          microphoneList: this._microphoneList.getArray()
-        });
+        if (!this._isDestroyed) {
+          this._main.dispatchEvent("deviceListUpdate", {
+            ref: this._main,
+            cameraList: this._cameraList.getArray(),
+            microphoneList: this._microphoneList.getArray()
+          });
+        }
         return this._selectedCamera;
       }
       /**
-       * This method selects a microphone based on previous uses or saved IDs
+       * Picks microphone based on saved ID or defaults
        * @private
        */
       pickMicrophone() {
         var _a, _b, _c, _d, _e, _f;
+        if (this._isDestroyed) return null;
         for (let i = 0; i < this._microphoneList.getSize(); i++) {
           this._microphoneList.get(i).isSelected = false;
         }
@@ -5556,7 +5682,6 @@
                 this._logger.info(this, "Canceling Publish!");
                 this._main.getConfigManager().getStreamData().streamKey = null;
               }
-              return null;
             }
           }
           if (!this._selectedMicrophone) {
@@ -5585,73 +5710,43 @@
         }
         return this._selectedMicrophone;
       }
-      /**
-       * Cleans all saved cameras and microphones IDs.
-       */
       clearSavedDevices() {
         var _a, _b;
         (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.removeField("cameraID");
         (_b = this._main.getStorageManager()) === null || _b === void 0 ? void 0 : _b.removeField("microphoneID");
       }
-      /**
-       * Messes up camera's and microphone's id (for testing only)
-       */
       messSavedDevices() {
         var _a, _b;
         (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.saveField("cameraID", "a");
         (_b = this._main.getStorageManager()) === null || _b === void 0 ? void 0 : _b.saveField("microphoneID", "b");
       }
-      /**
-       * Handles microphone muting state
-       * @param microphoneState true to unmute, false to mute
-       */
       muteMicrophone(shouldMute) {
+        var _a;
+        if (this._isDestroyed) return;
         if (this._isMicrophoneMuted === shouldMute) {
-          // State hasn't changed, no need to do anything
           return;
         }
         this._isMicrophoneMuted = shouldMute;
+        (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.saveField("microphoneMuted", shouldMute ? "true" : "false");
         if (this._stream) {
-          this.applyMicrophoneState(!shouldMute); // Odwracamy wartość dla track.enabled
+          this.applyMicrophoneState(!shouldMute);
         } else {
-          // Store the desired state to be applied when stream becomes available
-          this._pendingMicrophoneState = !shouldMute; // Odwracamy wartość dla przyszłego track.enabled
-          this._logger.info(this, `WebRTCStreamer :: Stream not yet available, storing microphone state (muted: ${shouldMute})`);
+          this._pendingMicrophoneState = !shouldMute;
         }
-        // Always dispatch the event to keep UI in sync
         this._main.dispatchEvent("microphoneStateChange", {
           ref: this._main,
           isMuted: this._isMicrophoneMuted
         });
       }
-      /**
-       * Applies the microphone state to the actual stream tracks
-       * @param enabled true to enable tracks, false to disable
-       * @private
-       */
       applyMicrophoneState(enabled) {
-        if (!this._stream) {
-          this._logger.warning(this, "WebRTCStreamer :: Cannot apply microphone state - stream not available");
-          return;
-        }
+        if (!this._stream) return;
         const audioTracks = this._stream.getAudioTracks();
         if (audioTracks && audioTracks.length > 0) {
-          this._logger.success(this, `WebRTCStreamer :: ${enabled ? 'Unmuting' : 'Muting'} microphone`);
           audioTracks.forEach(track => track.enabled = enabled);
-        } else {
-          this._logger.warning(this, "WebRTCStreamer :: No audio tracks found in stream");
         }
       }
-      /**
-       * This methods is a final check whenever we're ready to publish a stream
-       * @param requireVideo - whenever video track is required
-       * @param requireAudio - whenever audio track is required
-       * @returns {boolean} true if stream is ready for publishing
-       */
       isStreamReady(requireVideo = true, requireAudio = true) {
-        if (!this._stream) {
-          return false;
-        }
+        if (!this._stream) return false;
         const videoTracks = this._stream.getVideoTracks();
         const audioTracks = this._stream.getAudioTracks();
         const videoReady = !requireVideo || videoTracks.length > 0 && videoTracks[0].readyState === 'live';
@@ -5660,51 +5755,18 @@
       }
       closeWebRTCConnection() {
         if (this._peerConnection) {
-          this._peerConnection.close();
+          this._logger.info(this, "📡 [WEBRTC] closeWebRTCConnection() - closing peer connection");
+          this._peerConnection.onicecandidate = null;
+          this._peerConnection.onconnectionstatechange = null;
+          this._peerConnection.onnegotiationneeded = null;
+          try {
+            this._peerConnection.close();
+          } catch (e) {
+            // Ignore
+          }
           this._peerConnection = null;
         }
       }
-      // Asynchroniczna wersja do użycia w destroy
-      closeWebRTCConnectionAsync() {
-        return __awaiter(this, void 0, void 0, function* () {
-          if (this._peerConnection) {
-            try {
-              // Usuń event handlery
-              this._peerConnection.onicecandidate = null;
-              this._peerConnection.onconnectionstatechange = null;
-              this._peerConnection.onnegotiationneeded = null;
-              this._peerConnection.oniceconnectionstatechange = null;
-              this._peerConnection.onicegatheringstatechange = null;
-              this._peerConnection.onsignalingstatechange = null;
-              this._peerConnection.ontrack = null;
-              // Zatrzymaj wszystkie transceivery
-              const transceivers = this._peerConnection.getTransceivers();
-              for (const transceiver of transceivers) {
-                if (transceiver.stop) {
-                  transceiver.stop();
-                }
-              }
-              // Usuń wszystkie tracks
-              const senders = this._peerConnection.getSenders();
-              for (const sender of senders) {
-                if (sender.track) {
-                  sender.track.enabled = false;
-                  sender.track.stop();
-                }
-                this._peerConnection.removeTrack(sender);
-              }
-              // Zamknij połączenie
-              this._peerConnection.close();
-              // Poczekaj na zamknięcie
-              yield new Promise(resolve => setTimeout(resolve, 100));
-            } catch (e) {
-              this._logger.error(this, 'Error closing peer connection: ' + e);
-            } finally {
-              this._peerConnection = null;
-            }
-          }
-        });
-      }
       onDescriptionError(error) {
         this._logger.info(this, "WebRTCStreamer :: onDescriptionError: " + JSON.stringify(error));
       }
@@ -5716,6 +5778,7 @@
       //------------------------------------------------------------------------//
       createStatusConnection() {
         var _a, _b, _c;
+        if (this._isDestroyed) return;
         const serverItem = (_c = (_b = (_a = this._main) === null || _a === void 0 ? void 0 : _a.getNetworkController()) === null || _b === void 0 ? void 0 : _b.getConnection()) === null || _c === void 0 ? void 0 : _c.getCurrentServer();
         if (!serverItem) return;
         if (this._statusConnection) {
@@ -5736,6 +5799,7 @@
       }
       setPublishState(newState) {
         if (this._publishState == newState) return;
+        if (this._isDestroyed) return;
         if (this._debug) this._logger.decoratedLog("Publish State: " + newState, "dark-blue");
         this._logger.info(this, "Publish State: " + newState);
         if (newState == exports.PublishState.PUBLISHED) this._publishTime = new Date().getTime();
@@ -5748,9 +5812,9 @@
       getPublishTime() {
         return this._publishState == exports.PublishState.PUBLISHED ? this._publishTime : 0;
       }
-      // DEVICE STATE
       setInputDeviceState(newState) {
         if (this._inputDeviceState == newState) return;
+        if (this._isDestroyed) return;
         this._inputDeviceState = newState;
         this._main.dispatchEvent("deviceStateChange", {
           ref: this._main,
@@ -5762,9 +5826,9 @@
       getInputDeviceState() {
         return this._inputDeviceState;
       }
-      // CAMERA STATE
       setCameraState(newState) {
         if (this._cameraState == newState) return;
+        if (this._isDestroyed) return;
         this._cameraState = newState;
         this._main.dispatchEvent("cameraDeviceStateChange", {
           ref: this._main,
@@ -5775,9 +5839,9 @@
       getCameraState() {
         return this._cameraState;
       }
-      // MICROPHONE STATE
       setMicrophoneState(newState) {
         if (this._microphoneState == newState) return;
+        if (this._isDestroyed) return;
         this._microphoneState = newState;
         this._main.dispatchEvent("microphoneDeviceStateChange", {
           ref: this._main,
@@ -5798,108 +5862,70 @@
         return this._publishState;
       }
       //------------------------------------------------------------------------//
+      // DEBUG
+      //------------------------------------------------------------------------//
+      debugMediaState() {
+        var _a, _b;
+        console.group("🎥 Media Debug State");
+        console.log("=== STREAM INFO ===");
+        console.log("this._stream:", this._stream);
+        console.log("Active stream count:", this._activeStreamCount);
+        console.log("Is destroyed:", this._isDestroyed);
+        if (this._stream) {
+          console.log("Stream ID:", this._stream.id);
+          console.log("Stream active:", this._stream.active);
+          console.log("--- Video Tracks ---");
+          this._stream.getVideoTracks().forEach((track, index) => {
+            console.log(`  Track ${index}:`, {
+              id: track.id,
+              enabled: track.enabled,
+              readyState: track.readyState,
+              muted: track.muted
+            });
+          });
+          console.log("--- Audio Tracks ---");
+          this._stream.getAudioTracks().forEach((track, index) => {
+            console.log(`  Track ${index}:`, {
+              id: track.id,
+              enabled: track.enabled,
+              readyState: track.readyState,
+              muted: track.muted
+            });
+          });
+        }
+        console.log("=== VIDEO ELEMENT ===");
+        const videoElement = (_b = (_a = this._main.getStageController()) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getVideoElement();
+        if ((videoElement === null || videoElement === void 0 ? void 0 : videoElement.srcObject) instanceof MediaStream) {
+          const srcStream = videoElement.srcObject;
+          console.log("Video srcObject stream ID:", srcStream.id);
+          console.log("Video srcObject active:", srcStream.active);
+          console.log("Same as this._stream:", srcStream === this._stream);
+        }
+        console.groupEnd();
+      }
+      //------------------------------------------------------------------------//
       // DESTROY & DELETE
       //------------------------------------------------------------------------//
-      /**
-       * Method used to stop camera from streaming
-       * @private
-       */
       stopCameraStream() {
         var _a, _b;
         if (this._stream) {
-          this._stream.getTracks().forEach(track => track.stop());
+          this._logger.info(this, `📹 [RELEASE] stopCameraStream() - stopping stream, id: ${this._stream.id}`);
+          this._stream.getTracks().forEach(track => {
+            this._logger.info(this, `📹 [RELEASE] stopCameraStream() - stopping track: ${track.kind}, id: ${track.id}`);
+            track.stop();
+          });
           const videoElement = (_b = (_a = this._main.getStageController()) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getVideoElement();
           if (videoElement) {
             videoElement.srcObject = null;
           }
           this._soundMeter.detach();
           this._stream = null;
+          this._activeStreamCount--;
+          this._logger.info(this, `📹 [RELEASE] stopCameraStream() - complete, active streams: ${this._activeStreamCount}`);
         }
       }
-      /**
-       * Ulepszona metoda czyszczenia strumienia
-       * @private
-       */
-      cleanupMediaStream(stream) {
-        return __awaiter(this, void 0, void 0, function* () {
-          if (!stream) return;
-          const tracks = stream.getTracks();
-          for (const track of tracks) {
-            try {
-              // Usuń wszystkie event listenery
-              track.onended = null;
-              track.onmute = null;
-              track.onunmute = null;
-              // Wyłącz track
-              track.enabled = false;
-              // Zatrzymaj track
-              track.stop();
-              this._logger.info(this, `Track ${track.kind} stopped. ReadyState: ${track.readyState}`);
-            } catch (e) {
-              this._logger.error(this, `Error stopping track: ${e}`);
-            }
-          }
-          // Poczekaj na cleanup
-          yield new Promise(resolve => setTimeout(resolve, 50));
-        });
-      }
-      /**
-       * Method stops streaming for all streams with proper cleanup
-       * @private
-       */
-      forceStopAllStreams() {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-          this._logger.info(this, "Force stopping all streams...");
-          // 1. Odłączenie i zniszczenie SoundMeter
-          if (this._soundMeter) {
-            try {
-              this._soundMeter.destroy();
-            } catch (e) {
-              this._logger.error(this, 'Error destroying SoundMeter: ' + e);
-            }
-          }
-          // 2. Zatrzymanie głównego strumienia
-          if (this._stream) {
-            yield this.cleanupMediaStream(this._stream);
-            this._stream = null;
-          }
-          // 3. Czyszczenie elementu video
-          try {
-            const videoElement = (_b = (_a = this._main.getStageController()) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getVideoElement();
-            if (videoElement) {
-              // Zatrzymaj strumień w elemencie video
-              if (videoElement.srcObject instanceof MediaStream) {
-                yield this.cleanupMediaStream(videoElement.srcObject);
-              }
-              // Wyczyść element video
-              videoElement.pause();
-              videoElement.removeAttribute('src');
-              videoElement.srcObject = null;
-              videoElement.load();
-              // Usuń event listenery
-              videoElement.onloadedmetadata = null;
-              videoElement.onloadeddata = null;
-              videoElement.oncanplay = null;
-              videoElement.onerror = null;
-            }
-          } catch (e) {
-            this._logger.error(this, 'Error cleaning video element: ' + e);
-          }
-          // 4. Zamknięcie WebRTC
-          yield this.closeWebRTCConnectionAsync();
-          // 5. Resetuj zmienne
-          this._selectedCamera = null;
-          this._selectedMicrophone = null;
-          this._pendingMicrophoneState = null;
-          this._logger.info(this, "Force stop all streams completed");
-        });
-      }
-      /**
-       * Stops all streaming operations and cleans up resources
-       */
       stop() {
-        // Anuluj wszystkie aktywne operacje
+        this._logger.info(this, "📹 [STOP] stop() - stopping all operations");
         if (this._cameraAbortController) {
           this._cameraAbortController.abort();
           this._cameraAbortController = null;
@@ -5912,7 +5938,6 @@
           this._startCameraAbortController.abort();
           this._startCameraAbortController = null;
         }
-        // Stop status connection and clear timer
         if (this._statusConnection) {
           this._statusConnection.destroy();
           this._statusConnection = null;
@@ -5922,16 +5947,12 @@
           this._statusTimer = null;
         }
         this._main.getConfigManager().getStreamData().streamKey = null;
-        // Close WebRTC connection
         this.closeWebRTCConnection();
-        // Stop all media streams
         this.stopCameraStream();
-        // Reset states
         this.setPublishState(exports.PublishState.STOPPED);
         this.setInputDeviceState(exports.InputDevicesState.STOPPED);
         this.setCameraState(exports.DeviceState.STOPPED);
         this.setMicrophoneState(exports.DeviceState.STOPPED);
-        // Clear restart timer if exists
         if (this._restartTimer) {
           clearInterval(this._restartTimer);
           this._restartTimer = null;
@@ -5939,127 +5960,140 @@
         this._restartTimerCount = 0;
         clearTimeout(this._publishTimer);
       }
-      /**
-       * Reinitializes the streaming setup
-       */
       start() {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
+          if (this._isDestroyed) return;
+          this._logger.info(this, "📹 [START] start() - reinitializing streaming");
           try {
-            // Reset states
             this._publishState = exports.PublishState.NOT_INITIALIZED;
             this._inputDeviceState = exports.InputDevicesState.NOT_INITIALIZED;
             this._cameraState = exports.DeviceState.NOT_INITIALIZED;
             this._microphoneState = exports.DeviceState.NOT_INITIALIZED;
-            // Reinitialize devices and stream
             yield this.initializeDevices();
+            if (this._isDestroyed) return;
             yield this.startCamera();
-            // If autoConnect is enabled, initialize network
+            if (this._isDestroyed) return;
             if ((_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getSettingsData().autoConnect) {
               (_b = this._main.getNetworkController()) === null || _b === void 0 ? void 0 : _b.initialize();
             }
-            // Reinitialize status connection if needed
             if ((_c = this._main.getConfigManager()) === null || _c === void 0 ? void 0 : _c.getStreamData().streamKey) {
               this.createStatusConnection();
             }
           } catch (error) {
-            this._logger.error(this, "Start failed: " + JSON.stringify(error));
+            if (this._isDestroyed) return;
+            this._logger.error(this, "📹 [START] start() - failed: " + JSON.stringify(error));
             this.setInputDeviceState(exports.InputDevicesState.INVALID);
             throw error;
           }
         });
       }
       /**
-       * Method used for destroying everything (one-time use) with proper cleanup
+       * SYNCHRONOUS destroy - sets flag immediately, cleanup happens in background
+       * This ensures that even if called without await, all async operations will abort
        */
       destroy() {
-        return __awaiter(this, void 0, void 0, function* () {
-          this._logger.info(this, "Starting StreamerController destroy...");
-          this._isDestroying = true;
-          try {
-            // 1. Anuluj wszystkie aktywne operacje
-            if (this._cameraAbortController) {
-              this._cameraAbortController.abort();
-              this._cameraAbortController = null;
-            }
-            if (this._microphoneAbortController) {
-              this._microphoneAbortController.abort();
-              this._microphoneAbortController = null;
-            }
-            if (this._startCameraAbortController) {
-              this._startCameraAbortController.abort();
-              this._startCameraAbortController = null;
-            }
-            // 2. Zatrzymaj timery
-            if (this._statusTimer != null) {
-              clearInterval(this._statusTimer);
-              this._statusTimer = null;
-            }
-            if (this._restartTimer != null) {
-              clearInterval(this._restartTimer);
-              this._restartTimer = null;
-            }
-            clearTimeout(this._publishTimer);
-            // 3. Usuń event listenery urządzeń
-            if (this._deviceChangeHandler) {
-              navigator.mediaDevices.removeEventListener('devicechange', this._deviceChangeHandler);
-              this._deviceChangeHandler = null;
-            }
-            // 4. Usuń event listenery orientacji
-            if (this._orientationChangeHandler) {
-              if (window.screen && window.screen.orientation) {
-                window.screen.orientation.removeEventListener('change', this._orientationChangeHandler);
-              } else {
-                window.removeEventListener('orientationchange', this._orientationChangeHandler);
-              }
-              this._orientationChangeHandler = null;
-            }
-            // 5. Usuń pozostałe event listenery
-            try {
-              this._main.removeEventListener("serverConnect", this.onServerConnect);
-              this._main.removeEventListener("serverDisconnect", this.onServerDisconnect);
-              this._main.removeEventListener("streamKeyInUse", this.onStreamKeyTaken);
-              this._main.removeEventListener("statusServerConnect", this.onStatusServerConnect);
-              this._main.removeEventListener("statusServerDisconnect", this.onStatusServerDisconnect);
-              this._main.removeEventListener("streamStatusUpdate", this.onStreamStatsUpdate);
-              this._main.removeEventListener("deviceStateChange", this.onDeviceStateChange);
-              document.removeEventListener("visibilitychange", this.visibilityChange);
-              window.removeEventListener("blur", this.onWindowBlur);
-              window.removeEventListener("focus", this.onWindowFocus);
-            } catch (e) {
-              this._logger.error(this, 'Error removing event listeners: ' + e);
-            }
-            // 6. Zniszcz status connection
-            if (this._statusConnection) {
-              this._statusConnection.destroy();
-              this._statusConnection = null;
-            }
-            // 7. Zatrzymaj wszystkie strumienie
-            yield this.forceStopAllStreams();
-            // 8. Resetuj stany
-            this._permissionChecked = false;
-            this._isWindowActive = false;
-            this._isMicrophoneMuted = false;
-            this._publishState = exports.PublishState.NOT_INITIALIZED;
-            this._inputDeviceState = exports.InputDevicesState.NOT_INITIALIZED;
-            this._cameraState = exports.DeviceState.NOT_INITIALIZED;
-            this._microphoneState = exports.DeviceState.NOT_INITIALIZED;
-            this._switchingCamera = false;
-            this._switchingMicrophone = false;
-            // 9. Wyczyść listy urządzeń
-            if (this._cameraList) {
-              this._cameraList = new InputDeviceList();
-            }
-            if (this._microphoneList) {
-              this._microphoneList = new InputDeviceList();
+        var _a, _b, _c, _d;
+        // Prevent double destroy
+        if (this._isDestroyed) {
+          (_a = this._logger) === null || _a === void 0 ? void 0 : _a.warning(this, "🔴 [DESTROY] Already destroyed, skipping");
+          return;
+        }
+        this._logger.info(this, "🔴 [DESTROY] Starting StreamerController destroy (sync)...");
+        // CRITICAL: Set flag IMMEDIATELY - this will cause all pending async operations to abort
+        this._isDestroyed = true;
+        // Cancel all abort controllers immediately
+        if (this._cameraAbortController) {
+          this._cameraAbortController.abort();
+          this._cameraAbortController = null;
+        }
+        if (this._microphoneAbortController) {
+          this._microphoneAbortController.abort();
+          this._microphoneAbortController = null;
+        }
+        if (this._startCameraAbortController) {
+          this._startCameraAbortController.abort();
+          this._startCameraAbortController = null;
+        }
+        // Stop all timers immediately
+        if (this._statusTimer != null) {
+          clearInterval(this._statusTimer);
+          this._statusTimer = null;
+        }
+        if (this._restartTimer != null) {
+          clearInterval(this._restartTimer);
+          this._restartTimer = null;
+        }
+        clearTimeout(this._publishTimer);
+        // Remove permission listeners
+        this.removePermissionListeners();
+        // Remove device change listener
+        if (this._deviceChangeHandler) {
+          navigator.mediaDevices.removeEventListener('devicechange', this._deviceChangeHandler);
+          this._deviceChangeHandler = null;
+        }
+        // Remove orientation listener
+        if (this._orientationChangeHandler) {
+          if (window.screen && window.screen.orientation) {
+            window.screen.orientation.removeEventListener('change', this._orientationChangeHandler);
+          } else {
+            window.removeEventListener('orientationchange', this._orientationChangeHandler);
+          }
+          this._orientationChangeHandler = null;
+        }
+        // Remove event listeners
+        try {
+          this._main.removeEventListener("serverConnect", this.onServerConnect);
+          this._main.removeEventListener("serverDisconnect", this.onServerDisconnect);
+          this._main.removeEventListener("streamKeyInUse", this.onStreamKeyTaken);
+          this._main.removeEventListener("statusServerConnect", this.onStatusServerConnect);
+          this._main.removeEventListener("statusServerDisconnect", this.onStatusServerDisconnect);
+          this._main.removeEventListener("streamStatusUpdate", this.onStreamStatsUpdate);
+          this._main.removeEventListener("deviceStateChange", this.onDeviceStateChange);
+          document.removeEventListener("visibilitychange", this.visibilityChange);
+          window.removeEventListener("blur", this.onWindowBlur);
+          window.removeEventListener("focus", this.onWindowFocus);
+        } catch (e) {
+          // Ignore errors
+        }
+        // Destroy status connection
+        if (this._statusConnection) {
+          this._statusConnection.destroy();
+          this._statusConnection = null;
+        }
+        // Close WebRTC
+        this.closeWebRTCConnection();
+        // Stop camera stream
+        if (this._stream) {
+          this._logger.info(this, "📹 [FORCE_STOP] Stopping main stream");
+          this._stream.getTracks().forEach(track => {
+            track.stop();
+          });
+          this._stream = null;
+        }
+        // Clean video element
+        try {
+          const videoElement = (_c = (_b = this._main.getStageController()) === null || _b === void 0 ? void 0 : _b.getScreenElement()) === null || _c === void 0 ? void 0 : _c.getVideoElement();
+          if (videoElement) {
+            if (videoElement.srcObject instanceof MediaStream) {
+              videoElement.srcObject.getTracks().forEach(track => track.stop());
             }
-            this._logger.success(this, "StreamerController successfully destroyed");
-          } catch (error) {
-            this._logger.error(this, "Error during destroy: " + error);
-          } finally {
-            this._isDestroying = false;
+            videoElement.srcObject = null;
           }
-        });
+        } catch (e) {
+          // Ignore
+        }
+        // Destroy sound meter
+        try {
+          (_d = this._soundMeter) === null || _d === void 0 ? void 0 : _d.destroy();
+        } catch (e) {
+          // Ignore
+        }
+        // Reset variables
+        this._selectedCamera = null;
+        this._selectedMicrophone = null;
+        this._activeStreamCount = 0;
+        this._logger.success(this, "🔴 [DESTROY] StreamerController destroyed (sync)");
       }
     }
 
@@ -6671,52 +6705,19 @@
      * Main class of the player. The player itself has no GUI, but can be controlled via provided API.
      */
     class StormStreamer extends EventDispatcher {
-      //------------------------------------------------------------------------//
-      // CONSTRUCTOR
-      //------------------------------------------------------------------------//
-      /**
-       * Constructor - creates a new StormStreamer instance
-       *
-       * @param streamConfig - Configuration object for the streamer
-       * @param autoInitialize - Whether to automatically initialize the streamer after creation
-       */
       constructor(streamConfig, autoInitialize = false) {
         super();
-        /**
-         * Indicates whether the streamer object is in development mode (provides more debug options)
-         * @private
-         */
         this.DEV_MODE = true;
-        /**
-         * Version of this streamer in SemVer format (Major.Minor.Patch).
-         * @private
-         */
-        this.STREAMER_VERSION = "1.0.0-rc.1";
-        /**
-         * Compile date for this streamer
-         * @private
-         */
-        this.COMPILE_DATE = "11/17/2025, 10:30:23 AM";
-        /**
-         * Defines from which branch this streamer comes from e.g. "Main", "Experimental"
-         * @private
-         */
+        this.STREAMER_VERSION = "1.0.0";
+        this.COMPILE_DATE = "2/7/2026, 6:37:16 PM";
         this.STREAMER_BRANCH = "Experimental";
-        /**
-         * Defines number of streamer protocol that is required on server-side
-         * @private
-         */
         this.STREAMER_PROTOCOL_VERSION = 1;
-        /**
-         * Indicates whether streamer was initialized or not
-         * @private
-         */
         this._initialized = false;
+        this._isDestroyed = false;
         if (typeof window === 'undefined' || !window.document || !window.document.createElement) {
           console.error(`StormStreamer Creation Error - No "window" element in the provided context!`);
           return;
         }
-        // WINDOW.StormStreamerArray
         if (this.DEV_MODE && !('StormStreamerArray' in window)) {
           window.StormStreamerArray = [];
         }
@@ -6726,17 +6727,13 @@
         this.setStreamConfig(streamConfig);
         if (autoInitialize) this.initialize();
       }
-      /**
-       * Initializes the streamer object. From this point, a connection to the server is established and authentication occurs.
-       * It is recommended to add all event listeners before calling this method to ensure they can be properly captured.
-       */
       initialize() {
-        if (this._isRemoved) return;
-        if (this._configManager == null) throw Error("Stream Config was not provided for this streamer! A properly configured object must be provided through the constructor or via the setConfig method before using the initialize() method.");
-        this._storageManager = new StorageManager(this); // Storing user data
-        this._stageController = new StageController(this); // Visual elements like VideoElement
-        this._networkController = new NetworkController(this); // Networking and connection with a server
-        this._streamerController = new StreamerController(this); // Video Playback
+        if (this._isRemoved || this._isDestroyed) return;
+        if (this._configManager == null) throw Error("Stream Config was not provided for this streamer!");
+        this._storageManager = new StorageManager(this);
+        this._stageController = new StageController(this);
+        this._networkController = new NetworkController(this);
+        this._streamerController = new StreamerController(this);
         this._statsController = new StatsController(this);
         this._graphs = [];
         this._initialized = true;
@@ -6744,16 +6741,8 @@
           ref: this
         });
       }
-      /**
-       * Sets stream config for the streamer (or overwrites an existing one).
-       *
-       * @param streamConfig - New configuration object for the streamer
-       */
       setStreamConfig(streamConfig) {
-        if (this._isRemoved) return;
-        /**
-         * In case the original streamConfig is modified elsewhere we have to create a separate copy and store it ourselves
-         */
+        if (this._isRemoved || this._isDestroyed) return;
         const copiedStreamConfig = JSON.parse(JSON.stringify(streamConfig));
         if (this._configManager == null) {
           this._configManager = new ConfigManager(copiedStreamConfig);
@@ -6778,290 +6767,133 @@
           });
         }
       }
-      //------------------------------------------------------------------------//
       // PLAYBACK / STREAMING
-      //------------------------------------------------------------------------//
-      /**
-       * Returns true if this streamer instance is currently connected to a Storm Server/Cloud instance.
-       *
-       * @returns Boolean indicating connection status
-       */
       isConnected() {
         var _a, _b;
         return (_b = (_a = this._networkController) === null || _a === void 0 ? void 0 : _a.getConnection().isConnectionActive()) !== null && _b !== void 0 ? _b : false;
       }
-      /**
-       * Mutes the streamer's video object. Audio output will be silenced.
-       */
       mute() {
-        if (this._stageController != null) {
-          if (this._stageController.getScreenElement() != null) {
-            this._stageController.getScreenElement().setMuted(true);
-            return;
-          }
+        var _a;
+        if (((_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) != null) {
+          this._stageController.getScreenElement().setMuted(true);
+          return;
         }
         this._configManager.getSettingsData().getAudioData().muted = true;
       }
-      /**
-       * Unmutes the streamer's video object. Audio output will be restored.
-       */
       unmute() {
-        if (this._stageController != null) {
-          if (this._stageController.getScreenElement() != null) {
-            this._stageController.getScreenElement().setMuted(false);
-            return;
-          }
+        var _a;
+        if (((_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) != null) {
+          this._stageController.getScreenElement().setMuted(false);
+          return;
         }
         this._configManager.getSettingsData().getAudioData().muted = false;
       }
-      /**
-       * Checks whether the streamer audio is currently muted.
-       *
-       * @returns Boolean indicating mute status
-       */
       isMute() {
         var _a, _b, _c, _d;
         return (_d = (_c = (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getIfMuted()) !== null && _c !== void 0 ? _c : this._configManager.getSettingsData().getAudioData().muted) !== null && _d !== void 0 ? _d : false;
       }
-      /**
-       * Toggles between mute and unmute states. Returns the new mute state.
-       *
-       * @returns New mute state (true = muted, false = unmuted)
-       */
       toggleMute() {
         const isMuted = this.isMute();
-        if (isMuted) {
-          this.unmute();
-        } else {
-          this.mute();
-        }
+        if (isMuted) this.unmute();else this.mute();
         return !isMuted;
       }
-      /**
-       * Sets new volume for the streamer (0-100). Once the method is performed, the volumeChange event will be triggered.
-       * If the video was muted prior to the volume change, it will be automatically unmuted.
-       *
-       * @param newVolume - Volume level (0-100)
-       */
       setVolume(newVolume) {
         var _a, _b;
-        if (((_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.setVolume(newVolume)) !== undefined) {
-          return;
-        }
+        if (((_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.setVolume(newVolume)) !== undefined) return;
         this._configManager.getSettingsData().getAudioData().startVolume = newVolume;
       }
-      /**
-       * Returns current streamer volume (0-100).
-       *
-       * @returns Current volume level
-       */
       getVolume() {
         var _a, _b, _c;
         return (_c = (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getVolume()) !== null && _c !== void 0 ? _c : this._configManager.getSettingsData().getAudioData().startVolume;
       }
-      /**
-       * Returns the list of available camera devices.
-       *
-       * @returns Array of camera input devices
-       */
       getCameraList() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getCameraList()) !== null && _b !== void 0 ? _b : [];
       }
-      /**
-       * Returns the list of available microphone devices.
-       *
-       * @returns Array of microphone input devices
-       */
       getMicrophoneList() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getMicrophoneList()) !== null && _b !== void 0 ? _b : [];
       }
-      /**
-       * Sets the active camera device by ID.
-       *
-       * @param cameraID - ID of the camera device to use
-       */
       setCamera(cameraID) {
         var _a;
         (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.selectCamera(cameraID);
       }
-      /**
-       * Sets the active microphone device by ID.
-       *
-       * @param microphoneID - ID of the microphone device to use
-       */
       setMicrophone(microphoneID) {
         var _a;
         (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.selectMicrophone(microphoneID);
       }
-      /**
-       * Returns the currently active camera device.
-       *
-       * @returns Current camera device or null if none is active
-       */
       getCurrentCamera() {
-        return this._streamerController.getCurrentCamera();
+        var _a, _b;
+        return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getCurrentCamera()) !== null && _b !== void 0 ? _b : null;
       }
-      /**
-       * Returns the currently active microphone device.
-       *
-       * @returns Current microphone device or null if none is active
-       */
       getCurrentMicrophone() {
-        return this._streamerController.getCurrentMicrophone();
+        var _a, _b;
+        return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getCurrentMicrophone()) !== null && _b !== void 0 ? _b : null;
       }
-      /**
-       * Mutes or unmutes the microphone.
-       *
-       * @param microphoneState - True to mute, false to unmute
-       */
       muteMicrophone(microphoneState) {
         var _a;
         (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.muteMicrophone(microphoneState);
       }
-      /**
-       * Checks if the microphone is currently muted.
-       *
-       * @returns Boolean indicating if microphone is muted
-       */
       isMicrophoneMuted() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.isMicrophoneMuted()) !== null && _b !== void 0 ? _b : false;
       }
-      /**
-       * Returns the current publishing state of the streamer.
-       *
-       * @returns Current publishing state
-       */
       getPublishState() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getPublishState()) !== null && _b !== void 0 ? _b : exports.PublishState.NOT_INITIALIZED;
       }
-      /**
-       * Returns the total time the stream has been publishing in milliseconds.
-       *
-       * @returns Publishing time in milliseconds
-       */
       getPublishTime() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getPublishTime()) !== null && _b !== void 0 ? _b : 0;
       }
-      /**
-       * Starts publishing a stream with the given stream key.
-       *
-       * @param streamKey - Key identifying the stream to publish
-       * @returns Boolean indicating if publishing was successfully initiated
-       */
       publish(streamKey) {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.publish(streamKey)) !== null && _b !== void 0 ? _b : false;
       }
-      /**
-       * Stops publishing the current stream.
-       */
       unpublish() {
         var _a;
-        console.log("kutas 1");
         (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.unpublish();
       }
-      /**
-       * Returns the current state of input devices (camera and microphone).
-       *
-       * @returns Current state of input devices
-       */
       getInputDevicesState() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getInputDeviceState()) !== null && _b !== void 0 ? _b : exports.InputDevicesState.NOT_INITIALIZED;
       }
-      /**
-       * Returns the current state of the camera device.
-       *
-       * @returns Current camera device state
-       */
       getCameraState() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getCameraState()) !== null && _b !== void 0 ? _b : exports.DeviceState.NOT_INITIALIZED;
       }
-      /**
-       * Returns the current state of the microphone device.
-       *
-       * @returns Current microphone device state
-       */
       getMicrophoneState() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getMicrophoneState()) !== null && _b !== void 0 ? _b : exports.DeviceState.NOT_INITIALIZED;
       }
-      /**
-       * Clears saved device preferences from storage.
-       */
       clearSavedDevices() {
         var _a;
-        return (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.clearSavedDevices();
+        (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.clearSavedDevices();
       }
-      /**
-       * Randomizes saved device preferences (for testing purposes).
-       */
       messSavedDevices() {
         var _a;
-        return (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.messSavedDevices();
+        (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.messSavedDevices();
       }
-      /**
-       * Checks if the stream is ready for publishing.
-       *
-       * @returns Boolean indicating if stream is ready
-       */
       isStreamReady() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.isStreamReady()) !== null && _b !== void 0 ? _b : false;
       }
-      //------------------------------------------------------------------------//
       // CONTAINER
-      //------------------------------------------------------------------------//
-      /**
-       * Attaches the streamer to a new parent container using either a container ID (string) or a reference to an HTMLElement.
-       * If the instance is already attached, it will be moved to a new parent.
-       *
-       * @param container - Container ID (string) or HTMLElement reference
-       * @returns Boolean indicating if attachment was successful
-       */
       attachToContainer(container) {
         var _a, _b;
-        let result = false;
         if (this._initialized) return (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.attachToParent(container)) !== null && _b !== void 0 ? _b : false;
-        return result;
+        return false;
       }
-      /**
-       * Detaches the streamer from the current parent element, if possible.
-       *
-       * @returns Boolean indicating if detachment was successful
-       */
       detachFromContainer() {
         var _a, _b;
-        let result = false;
         if (this._initialized) return (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.detachFromParent()) !== null && _b !== void 0 ? _b : false;
-        return result;
+        return false;
       }
-      /**
-       * Returns the current parent element of the streamer, or null if none exists.
-       *
-       * @returns Current container element or null
-       */
       getContainer() {
         var _a, _b;
         return (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getParentElement()) !== null && _b !== void 0 ? _b : null;
       }
-      //------------------------------------------------------------------------//
       // SIZE & RESIZE
-      //------------------------------------------------------------------------//
-      /**
-       * Sets a new width and height for the streamer. The values can be given as a number (in which case they are
-       * treated as the number of pixels), or as a string ending with "px" (this will also be the number of pixels) or "%",
-       * where the number is treated as a percentage of the parent container's value.
-       *
-       * @param width - Can be provided as number or a string with "%" or "px" suffix
-       * @param height - Can be provided as number or a string with "%" or "px" suffix
-       */
       setSize(width, height) {
         if (this._initialized) this._stageController.setSize(width, height);else {
           const parsedWidth = NumberUtilities.parseValue(width);
@@ -7072,13 +6904,6 @@
           this._configManager.getSettingsData().getVideoData().videoHeightInPixels = parsedHeight.isPixels;
         }
       }
-      /**
-       * Sets a new width for the streamer. The value can be given as a number (in which case it is treated as the
-       * number of pixels), or as a string ending with "px" (this will also be the number of pixels) or "%", where the
-       * number is treated as a percentage of the parent container's value.
-       *
-       * @param width - Can be provided as number or a string with "%" or "px" suffix
-       */
       setWidth(width) {
         if (this._initialized) this._stageController.setWidth(width);else {
           const parsedWidth = NumberUtilities.parseValue(width);
@@ -7086,13 +6911,6 @@
           this._configManager.getSettingsData().getVideoData().videoWidthInPixels = parsedWidth.isPixels;
         }
       }
-      /**
-       * Sets a new height for the streamer. The value can be given as a number (in which case it is treated as the
-       * number of pixels), or as a string ending with "px" (this will also be the number of pixels) or "%", where the
-       * number is treated as a percentage of the parent container's value.
-       *
-       * @param height - Can be provided as number or a string with "%" or "px" suffix
-       */
       setHeight(height) {
         if (this._initialized) this._stageController.setHeight(height);else {
           const parsedHeight = NumberUtilities.parseValue(height);
@@ -7100,66 +6918,26 @@
           this._configManager.getSettingsData().getVideoData().videoHeightInPixels = parsedHeight.isPixels;
         }
       }
-      /**
-       * Returns current streamer width in pixels.
-       *
-       * @returns Current width in pixels
-       */
       getWidth() {
-        if (this._initialized) return this._stageController.getContainerWidth();else {
-          if (this._configManager.getSettingsData().getVideoData().videoWidthInPixels) return this._configManager.getSettingsData().getVideoData().videoWidthValue;
-        }
+        if (this._initialized) return this._stageController.getContainerWidth();
+        if (this._configManager.getSettingsData().getVideoData().videoWidthInPixels) return this._configManager.getSettingsData().getVideoData().videoWidthValue;
         return 0;
       }
-      /**
-       * Returns current streamer height in pixels.
-       *
-       * @returns Current height in pixels
-       */
       getHeight() {
-        if (this._initialized) return this._stageController.getContainerHeight();else {
-          if (this._configManager.getSettingsData().getVideoData().videoHeightInPixels) return this._configManager.getSettingsData().getVideoData().videoHeightValue;
-        }
+        if (this._initialized) return this._stageController.getContainerHeight();
+        if (this._configManager.getSettingsData().getVideoData().videoHeightInPixels) return this._configManager.getSettingsData().getVideoData().videoHeightValue;
         return 0;
       }
-      /**
-       * Changes the streamer scaling mode. Available modes include fill, letterbox, original, and crop.
-       *
-       * @param newMode - New scaling mode name (fill, letterbox, original, crop)
-       */
       setScalingMode(newMode) {
-        if (this._stageController) {
-          this._stageController.setScalingMode(newMode);
-        } else {
-          this._configManager.getSettingsData().getVideoData().scalingMode = newMode;
-        }
+        if (this._stageController) this._stageController.setScalingMode(newMode);else this._configManager.getSettingsData().getVideoData().scalingMode = newMode;
       }
-      /**
-       * Returns the current streamer scaling mode.
-       *
-       * @returns Current scaling mode
-       */
       getScalingMode() {
-        if (this._stageController) {
-          return this._stageController.getScalingMode();
-        } else {
-          return this._configManager.getSettingsData().getVideoData().scalingMode;
-        }
+        if (this._stageController) return this._stageController.getScalingMode();
+        return this._configManager.getSettingsData().getVideoData().scalingMode;
       }
-      /**
-       * Forces the streamer to recalculate its size based on parent internal dimensions.
-       */
       updateToSize() {
-        if (this._initialized) {
-          this._stageController.handleResize();
-        }
+        if (this._initialized) this._stageController.handleResize();
       }
-      /**
-       * Returns a promise that resolves with a screenshot of the video element as a blob, or null if taking the
-       * screenshot was not possible.
-       *
-       * @returns Promise resolving to a Blob containing the screenshot or null
-       */
       makeScreenshot() {
         let canvas = document.createElement('canvas');
         let context = canvas.getContext('2d');
@@ -7170,64 +6948,24 @@
             let element = this._stageController.getScreenElement().getVideoElement();
             if (context) {
               context.drawImage(element, 0, 0, canvas.width, canvas.height);
-              canvas.toBlob(blob => {
-                resolve(blob);
-              }, 'image/png');
-            } else {
-              resolve(null);
-            }
-          } else {
-            resolve(null);
-          }
+              canvas.toBlob(blob => resolve(blob), 'image/png');
+            } else resolve(null);
+          } else resolve(null);
         });
       }
-      //------------------------------------------------------------------------//
       // GRAPHS
-      //------------------------------------------------------------------------//
-      /**
-       * Creates a FPS performance graph in the specified location (container ID or reference). The graph is a
-       * separate object that must be started using its start() method and stopped using its stop() method. The dimensions
-       * of the graph depend on the dimensions of the specified container.
-       *
-       * @param container - Element ID or reference to HTMLElement
-       * @returns FPS graph instance
-       */
       createFPSGraph(container) {
         return new FPSGraph(this, container);
       }
-      /**
-       * Creates a bitrate performance graph in the specified location (container ID or reference). The graph is a
-       * separate object that must be started using its start() method and stopped using its stop() method. The dimensions
-       * of the graph depend on the dimensions of the specified container.
-       *
-       * @param container - Element ID or reference to HTMLElement
-       * @returns Bitrate graph instance
-       */
       createBitrateGraph(container) {
         return new BitrateGraph(this, container);
       }
-      /**
-       * Creates a microphone graph in the specified location (container ID or reference). The graph is a
-       * separate object that must be started using its start() method and stopped using its stop() method. The dimensions
-       * of the graph depend on the dimensions of the specified container.
-       *
-       * @param container - Element ID or reference to HTMLElement
-       * @returns Bitrate graph instance
-       */
       createMicrophoneGraph(container) {
         return new MicrophoneGraph(this, container);
       }
-      /**
-       * Adds new graph to the internal collection of active graphs.
-       *
-       * @param newGraph - Graph instance to add
-       */
       addGraph(newGraph) {
         if (this._graphs != null) this._graphs.push(newGraph);
       }
-      /**
-       * Stops all active performance graphs.
-       */
       stopAllGraphs() {
         if (this._graphs != null && this._graphs.length > 0) {
           for (let i = 0; i < this._graphs.length; i++) {
@@ -7235,198 +6973,136 @@
           }
         }
       }
-      //------------------------------------------------------------------------//
       // FULLSCREEN
-      //------------------------------------------------------------------------//
-      /**
-       * Enters fullscreen mode for the streamer container.
-       */
       enterFullScreen() {
         if (this._initialized && this._stageController) this._stageController.enterFullScreen();
       }
-      /**
-       * Exits fullscreen mode.
-       */
       exitFullScreen() {
         if (this._initialized && this._stageController) this._stageController.exitFullScreen();
       }
-      /**
-       * Returns true if the streamer is currently in fullscreen mode.
-       *
-       * @returns Boolean indicating fullscreen status
-       */
       isFullScreenMode() {
         if (this._initialized && this._stageController) return this._stageController.isFullScreenMode();
         return false;
       }
-      //------------------------------------------------------------------------//
-      // SIMPLE GETS & SETS
-      //------------------------------------------------------------------------//
-      /**
-       * Returns the current stream key or null if none is set.
-       *
-       * @returns Current stream key or null
-       */
+      // GETTERS
       getStreamKey() {
         var _a, _b, _c;
         return (_c = (_b = (_a = this.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData()) === null || _b === void 0 ? void 0 : _b.streamKey) !== null && _c !== void 0 ? _c : null;
       }
-      /**
-       * Returns the Stats Controller instance which contains statistical data about streaming performance.
-       *
-       * @returns Stats controller instance or null
-       */
       getStatsController() {
         return this._statsController;
       }
-      /**
-       * Returns the unique ID of this streamer instance. Each subsequent instance has a higher number.
-       *
-       * @returns Streamer instance ID
-       */
       getStreamerID() {
         return this._streamerID;
       }
-      /**
-       * Returns the logger instance used by this streamer.
-       *
-       * @returns Logger instance
-       */
       getLogger() {
         return this._logger;
       }
-      /**
-       * Returns the configuration manager for this streamer.
-       *
-       * @returns Config manager instance or null
-       */
       getConfigManager() {
         return this._configManager;
       }
-      /**
-       * Returns the network controller which manages all server communication.
-       *
-       * @returns Network controller instance or null
-       */
       getNetworkController() {
         return this._networkController;
       }
-      /**
-       * Returns the streamer controller which manages media stream operations.
-       *
-       * @returns Streamer controller instance or null
-       */
       getStreamerController() {
         return this._streamerController;
       }
-      /**
-       * Returns the stage controller which manages visual presentation.
-       *
-       * @returns Stage controller instance or null
-       */
       getStageController() {
         return this._stageController;
       }
-      /**
-       * Returns the storage manager which handles persistent data storage.
-       *
-       * @returns Storage manager instance or null
-       */
       getStorageManager() {
         return this._storageManager;
       }
-      /**
-       * Returns the HTML video element used by this streamer instance.
-       *
-       * @returns Video element or null
-       */
       getVideoElement() {
         var _a, _b, _c;
         return (_c = (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getVideoElement()) !== null && _c !== void 0 ? _c : null;
       }
-      /**
-       * Returns true if this streamer instance has already been initialized.
-       *
-       * @returns Boolean indicating initialization status
-       */
       isInitialized() {
         return this._initialized;
       }
-      /**
-       * Returns the version of this streamer instance. The version is returned in the SemVer format (Major.Minor.Patch).
-       *
-       * @returns Streamer version string
-       */
+      isDestroyed() {
+        return this._isDestroyed;
+      }
       getVersion() {
         return this.STREAMER_VERSION;
       }
-      /**
-       * Returns the development branch of this streamer (e.g., main, experimental).
-       *
-       * @returns Branch name string
-       */
       getBranch() {
         return this.STREAMER_BRANCH;
       }
-      //------------------------------------------------------------------------//
-      // EVENT
-      //------------------------------------------------------------------------//
-      /**
-       * Dispatches an event with the specified name and data.
-       *
-       * @param eventName - Name of the event to dispatch
-       * @param event - Object containing event data
-       */
+      // EVENTS
       dispatchEvent(eventName, event) {
         super.dispatchEvent(eventName, event);
       }
-      //------------------------------------------------------------------------//
-      // CLEAN UP
-      //------------------------------------------------------------------------//
-      /**
-       * Starts the streaming process.
-       *
-       * @returns Promise that resolves when streaming has started
-       */
+      // START / STOP
       start() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
           return (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.start();
         });
       }
-      /**
-       * Stops the streaming process.
-       */
       stop() {
         var _a;
-        return (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.stop();
+        (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.stop();
+      }
+      // DEBUG
+      debugMediaState() {
+        var _a;
+        (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.debugMediaState();
       }
-      //------------------------------------------------------------------------//
-      // CLEAN UP
-      //------------------------------------------------------------------------//
       /**
-       * Destroys this instance of StormStreamer, releasing all resources and disconnecting from the server.
-       * After calling this method, the instance should not be used anymore.
+       * Destroys this instance of StormStreamer, releasing all resources.
+       * This method is SYNCHRONOUS - it sets flags immediately to prevent race conditions.
+       * All pending async operations will detect the destroyed state and abort.
        */
       destroy() {
-        var _a, _b, _c, _d;
-        this._logger.warning(this, "Destroying streamer instance, bye, bye!");
-        if (this.DEV_MODE && 'StormStreamerArray' in window) window.StormStreamerArray[this._streamerID] = null;
-        // part1
+        var _a, _b, _c, _d, _e, _f, _g;
+        // Prevent double destroy
+        if (this._isDestroyed) {
+          (_a = this._logger) === null || _a === void 0 ? void 0 : _a.warning(this, "🔴 [DESTROY] Already destroyed, skipping");
+          return;
+        }
+        (_b = this._logger) === null || _b === void 0 ? void 0 : _b.warning(this, "🔴 [DESTROY] Starting streamer instance destruction (sync)...");
+        // CRITICAL: Set flag IMMEDIATELY
+        this._isDestroyed = true;
         this._initialized = false;
         this._isRemoved = true;
-        // part3
-        (_b = (_a = this._networkController) === null || _a === void 0 ? void 0 : _a.getConnection()) === null || _b === void 0 ? void 0 : _b.destroy();
-        (_c = this._streamerController) === null || _c === void 0 ? void 0 : _c.destroy();
-        (_d = this._stageController) === null || _d === void 0 ? void 0 : _d.destroy();
-        // part2
+        // Remove from global array
+        if (this.DEV_MODE && 'StormStreamerArray' in window) {
+          window.StormStreamerArray[this._streamerID] = null;
+        }
+        // Stop all graphs
+        this.stopAllGraphs();
+        this._graphs = [];
+        // Destroy network controller
+        if (this._networkController) {
+          (_c = this._logger) === null || _c === void 0 ? void 0 : _c.info(this, "🔴 [DESTROY] Destroying NetworkController...");
+          try {
+            (_d = this._networkController.getConnection()) === null || _d === void 0 ? void 0 : _d.destroy();
+          } catch (e) {/* ignore */}
+          this._networkController = null;
+        }
+        // Destroy streamer controller (this is also sync now)
+        if (this._streamerController) {
+          (_e = this._logger) === null || _e === void 0 ? void 0 : _e.info(this, "🔴 [DESTROY] Destroying StreamerController...");
+          this._streamerController.destroy();
+          this._streamerController = null;
+        }
+        // Destroy stage controller
+        if (this._stageController) {
+          (_f = this._logger) === null || _f === void 0 ? void 0 : _f.info(this, "🔴 [DESTROY] Destroying StageController...");
+          try {
+            this._stageController.destroy();
+          } catch (e) {/* ignore */}
+          this._stageController = null;
+        }
+        // Clear other references
+        this._storageManager = null;
+        this._statsController = null;
+        // Remove all event listeners
         this.removeAllEventListeners();
+        (_g = this._logger) === null || _g === void 0 ? void 0 : _g.success(this, "🔴 [DESTROY] Streamer instance destroyed successfully (sync)");
       }
     }
-    /**
-     * Next ID for the streamer instance. Each subsequent instance has a higher number.
-     * @private
-     */
     StormStreamer.NEXT_STREAMER_ID = 0;
 
     function create(config) {