@stormstreaming/stormstreamer 1.0.0-rc.0 → 1.0.0

package/dist/amd/index.js

@@ -4,8 +4,8 @@
  * contact@stormstreaming.com
  * https://stormstreaming.com
  *
- * Version: 1.0.0-rc.0
- * Version: 3/28/2025, 9:18:38 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
@@ -2500,6 +2500,9 @@
          * @private
          */
         this._isMutedByBrowser = false;
+        // POPRAWKA: Dodane pola do przechowywania referencji do handlerów
+        this._loadedMetadataHandler = null;
+        this._volumeChangeHandler = null;
         /**
          * Called whenever browser stops playback
          */
@@ -2555,20 +2558,24 @@
          * Fires whenever something changes video object volume
          * @param event
          */
-        // @ts-ignore
-        this._videoElement.onvolumechange = () => {
+        // POPRAWKA: Zapisanie referencji do handlera
+        this._volumeChangeHandler = () => {
           this.dispatchVolumeEvent();
         };
+        // @ts-ignore
+        this._videoElement.onvolumechange = this._volumeChangeHandler;
         this._videoElement.onpause = () => {
           // nothing
         };
-        this._videoElement.addEventListener('loadedmetadata', () => {
+        // POPRAWKA: Zapisanie referencji do handlera
+        this._loadedMetadataHandler = () => {
           this._main.dispatchEvent("metadata", {
             ref: this._main,
             videoWidth: this._videoElement.videoWidth,
             videoHeight: this._videoElement.videoHeight
           });
-        });
+        };
+        this._videoElement.addEventListener('loadedmetadata', this._loadedMetadataHandler);
         /**
          * Updates every second,
          * @param event
@@ -2590,7 +2597,9 @@
         this._videoElement.onended = event => {
           this._logger.info(this, "VideoElement :: onended");
         };
-        this._videoElement.onplay = () => {};
+        this._videoElement.onplay = () => {
+          // nothing
+        };
       }
       /**
        * Sets new volume for playback. It'll also try to store value in a browser memory
@@ -2647,6 +2656,65 @@
       getVideoElement() {
         return this._videoElement;
       }
+      // POPRAWKA: Dodana metoda destroy
+      /**
+       * Destroys the ScreenElement and cleans up all resources
+       */
+      destroy() {
+        this._logger.info(this, "Destroying ScreenElement...");
+        try {
+          // 1. Usuń event listener z głównej klasy
+          this._main.removeEventListener("playbackForceMute", this.onForceMute);
+          // 2. Zatrzymaj wszelkie aktywne strumienie w elemencie video
+          if (this._videoElement.srcObject instanceof MediaStream) {
+            const stream = this._videoElement.srcObject;
+            stream.getTracks().forEach(track => {
+              track.enabled = false;
+              track.stop();
+            });
+          }
+          this._videoElement.pause();
+          this._videoElement.onload = null;
+          this._videoElement.onstalled = null;
+          this._videoElement.onerror = null;
+          this._videoElement.onvolumechange = null;
+          this._videoElement.onpause = null;
+          this._videoElement.ontimeupdate = null;
+          this._videoElement.onended = null;
+          this._videoElement.onplay = null;
+          this._videoElement.onloadstart = null;
+          this._videoElement.onloadeddata = null;
+          this._videoElement.onloadedmetadata = null;
+          this._videoElement.oncanplay = null;
+          this._videoElement.oncanplaythrough = null;
+          this._videoElement.onprogress = null;
+          this._videoElement.onseeking = null;
+          this._videoElement.onseeked = null;
+          this._videoElement.onwaiting = null;
+          this._videoElement.ondurationchange = null;
+          this._videoElement.onratechange = null;
+          this._videoElement.onsuspend = null;
+          this._videoElement.onemptied = null;
+          if (this._loadedMetadataHandler) {
+            this._videoElement.removeEventListener('loadedmetadata', this._loadedMetadataHandler);
+            this._loadedMetadataHandler = null;
+          }
+          this._videoElement.removeAttribute('src');
+          this._videoElement.srcObject = null;
+          try {
+            this._videoElement.load();
+          } catch (e) {
+            // Ignoruj błędy podczas load()
+          }
+          this._videoElement.removeAttribute('playsinline');
+          this._videoElement.removeAttribute('webkit-playsinline');
+          if (this._videoElement.parentNode) this._videoElement.parentNode.removeChild(this._videoElement);
+          this._volumeChangeHandler = null;
+          this._logger.success(this, "ScreenElement successfully destroyed");
+        } catch (error) {
+          this._logger.error(this, "Error during ScreenElement destroy: " + error);
+        }
+      }
     }
 
     /**
@@ -2741,6 +2809,10 @@
          */
         this._parentOriginalOverflow = '';
         this._debug = false;
+        this._animationFrameId = null;
+        this._isDestroying = false;
+        this._fullscreenChangeHandler = null;
+        this._transitionEndHandler = null;
         //------------------------------------------------------------------------//
         // FULLSCREEN
         //------------------------------------------------------------------------//
@@ -2795,11 +2867,15 @@
             if (this._autoResizeEnabled) this.handleResize();
           });
         }
-        document.addEventListener('fullscreenchange', this.onFullScreenChange, false);
-        document.addEventListener('webkitfullscreenchange', this.onFullScreenChange, false);
-        document.addEventListener('mozfullscreenchange', this.onFullScreenChange, false);
-        document.addEventListener('webkitendfullscreen', this.onFullScreenChange, false);
-        this._screenElement.getVideoElement().addEventListener('webkitendfullscreen', this.onFullScreenChange, false);
+        this._fullscreenChangeHandler = this.onFullScreenChange;
+        this._transitionEndHandler = () => {
+          this.handleResize();
+        };
+        document.addEventListener('fullscreenchange', this._fullscreenChangeHandler, false);
+        document.addEventListener('webkitfullscreenchange', this._fullscreenChangeHandler, false);
+        document.addEventListener('mozfullscreenchange', this._fullscreenChangeHandler, false);
+        document.addEventListener('webkitendfullscreen', this._fullscreenChangeHandler, false);
+        this._screenElement.getVideoElement().addEventListener('webkitendfullscreen', this._fullscreenChangeHandler, false);
         this._main.addEventListener("metadata", event => {
           this._videoWidth = event.videoWidth;
           this._videoHeight = event.videoHeight;
@@ -2861,12 +2937,14 @@
         let result = false;
         if (this._parentElement != null && this._videoContainer != null) {
           this._logger.info(this, "Detaching from parent: " + this._videoContainer);
+          // POPRAWKA: Usuń event listener z zapisanym handlerem
+          if (this._transitionEndHandler) {
+            this._parentElement.removeEventListener("transitionend", this._transitionEndHandler);
+          }
           this._parentElement.removeChild(this._videoContainer);
           if (this._resizeObserver) {
             this._resizeObserver.unobserve(this._parentElement);
-            this._resizeObserver.disconnect();
           }
-          if (this._autoResizeEnabled) this._parentElement.removeEventListener("transitionend", this.handleResize);
           this._main.dispatchEvent("containerChange", {
             ref: this._main,
             container: null
@@ -2879,16 +2957,22 @@
         return result;
       }
       handleResize() {
-        if (!this._parentElement || this._isResizing) return;
+        if (!this._parentElement || this._isResizing || this._isDestroying) return;
+        // POPRAWKA: Anulowanie poprzedniego requestAnimationFrame
+        if (this._animationFrameId !== null) {
+          cancelAnimationFrame(this._animationFrameId);
+        }
         this._isResizing = true;
         this._parentOriginalOverflow = this._parentElement.style.overflow;
         this._parentElement.style.overflow = 'hidden';
-        // Używamy requestAnimationFrame aby dać przeglądarce czas na zastosowanie overflow
-        requestAnimationFrame(() => {
-          // Obliczamy nowe wymiary
+        this._animationFrameId = requestAnimationFrame(() => {
+          if (this._isDestroying) return;
           this.calculateNewDimensions();
-          this._parentElement.style.overflow = this._parentOriginalOverflow;
+          if (this._parentElement) {
+            this._parentElement.style.overflow = this._parentOriginalOverflow;
+          }
           this._isResizing = false;
+          this._animationFrameId = null;
           if (this._tempContainerWidth !== this._containerWidth || this._tempContainerHeight !== this._containerHeight) {
             this._main.dispatchEvent("resizeUpdate", {
               ref: this._main,
@@ -3145,7 +3229,83 @@
       // CLEANUP
       //------------------------------------------------------------------------//
       destroy() {
-        this.detachFromParent();
+        var _a;
+        this._logger.info(this, "Starting StageController destroy...");
+        this._isDestroying = true;
+        try {
+          // 1. Anuluj animacje
+          if (this._animationFrameId !== null) {
+            cancelAnimationFrame(this._animationFrameId);
+            this._animationFrameId = null;
+          }
+          // 2. Odłącz od rodzica
+          this.detachFromParent();
+          // 3. Zatrzymaj i rozłącz ResizeObserver
+          if (this._resizeObserver) {
+            this._resizeObserver.disconnect();
+          }
+          // 4. Usuń event listenery fullscreen
+          if (this._fullscreenChangeHandler) {
+            document.removeEventListener('fullscreenchange', this._fullscreenChangeHandler);
+            document.removeEventListener('webkitfullscreenchange', this._fullscreenChangeHandler);
+            document.removeEventListener('mozfullscreenchange', this._fullscreenChangeHandler);
+            document.removeEventListener('webkitendfullscreen', this._fullscreenChangeHandler);
+            if ((_a = this._screenElement) === null || _a === void 0 ? void 0 : _a.getVideoElement()) {
+              this._screenElement.getVideoElement().removeEventListener('webkitendfullscreen', this._fullscreenChangeHandler);
+            }
+            this._fullscreenChangeHandler = null;
+          }
+          // 6. Zniszcz ScreenElement
+          if (this._screenElement) {
+            // Wyczyść video element
+            const videoElement = this._screenElement.getVideoElement();
+            if (videoElement) {
+              // Zatrzymaj wszelkie strumienie
+              if (videoElement.srcObject instanceof MediaStream) {
+                videoElement.srcObject.getTracks().forEach(track => {
+                  track.enabled = false;
+                  track.stop();
+                });
+              }
+              // Wyczyść element
+              videoElement.pause();
+              videoElement.removeAttribute('src');
+              videoElement.srcObject = null;
+              videoElement.load();
+              // Usuń z DOM jeśli jest podłączony
+              if (videoElement.parentNode) {
+                videoElement.parentNode.removeChild(videoElement);
+              }
+            }
+            // Jeśli ScreenElement ma własną metodę destroy, wywołaj ją
+            if (typeof this._screenElement.destroy === 'function') {
+              this._screenElement.destroy();
+            }
+            this._screenElement = null;
+          }
+          // 7. Usuń kontener video z DOM
+          if (this._videoContainer) {
+            if (this._videoContainer.parentNode) {
+              this._videoContainer.parentNode.removeChild(this._videoContainer);
+            }
+            this._videoContainer = null;
+          }
+          // 8. Resetuj zmienne
+          this._containerWidth = 0;
+          this._containerHeight = 0;
+          this._tempContainerWidth = 0;
+          this._tempContainerHeight = 0;
+          this._videoWidth = 0;
+          this._videoHeight = 0;
+          this.isInFullScreenMode = false;
+          this._isResizing = false;
+          this._autoResizeEnabled = false;
+          this._logger.success(this, "StageController successfully destroyed");
+        } catch (error) {
+          this._logger.error(this, "Error during destroy: " + error);
+        } finally {
+          this._isDestroying = false;
+        }
       }
     }
     /**
@@ -3512,9 +3672,12 @@
         this._lastEventTime = 0;
         this.THROTTLE_INTERVAL = 100; // ms between updates
         this._isMonitoring = false;
-        // Moving average variables for smoothing
-        this._instant = 0.0;
-        this._slow = 0.0;
+        this._animationFrameId = null;
+        // 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;
       }
       attach(stream) {
@@ -3530,22 +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() {
-        var _a, _b;
-        // Stop monitoring first
+        if (!this._audioContext && !this._analyser && !this._microphone) {
+          return;
+        }
         this._isMonitoring = false;
-        // Disconnect and cleanup nodes in reverse order
+        if (this._animationFrameId !== null) {
+          cancelAnimationFrame(this._animationFrameId);
+          this._animationFrameId = null;
+        }
         if (this._microphone) {
           try {
             this._microphone.disconnect();
@@ -3562,14 +3727,22 @@
           }
           this._analyser = null;
         }
-        if (((_a = this._audioContext) === null || _a === void 0 ? void 0 : _a.state) !== 'closed') {
+        if (this._audioContext) {
           try {
-            (_b = this._audioContext) === null || _b === void 0 ? void 0 : _b.close();
+            if (this._audioContext.state !== 'closed') {
+              const audioContextRef = this._audioContext;
+              this._audioContext = null;
+              audioContextRef.suspend().then(() => audioContextRef.close()).catch(e => {
+                console.warn('SoundMeter: Error closing audio context:', e);
+              });
+            } else {
+              this._audioContext = null;
+            }
           } catch (e) {
-            console.warn('SoundMeter: Error closing audio context:', e);
+            console.warn('SoundMeter: Error handling audio context:', e);
+            this._audioContext = null;
           }
         }
-        this._audioContext = null;
         this.clear();
       }
       clear() {
@@ -3582,24 +3755,29 @@
         this._isMonitoring = true;
         const dataArray = new Float32Array(this._analyser.frequencyBinCount);
         const analyze = () => {
-          if (!this._analyser || !this._isMonitoring) return;
+          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;
@@ -3612,13 +3790,17 @@
           } catch (error) {
             console.error('SoundMeter: Error during analysis:', error);
             this._isMonitoring = false;
+            this._animationFrameId = null;
             return;
           }
-          // Schedule next analysis
-          requestAnimationFrame(analyze);
+          if (this._isMonitoring) {
+            this._animationFrameId = requestAnimationFrame(analyze);
+          }
         };
-        // Start analysis loop
-        requestAnimationFrame(analyze);
+        this._animationFrameId = requestAnimationFrame(analyze);
+      }
+      destroy() {
+        this.detach();
       }
     }
 
@@ -4018,7 +4200,6 @@
               streamStatusInfo.videoWidth = msgJSON.videoWidth;
               streamStatusInfo.videoHeight = msgJSON.videoHeight;
               streamStatusInfo.currentBitrate = msgJSON.realBitrate;
-              console.log(streamStatusInfo);
               this._main.dispatchEvent("streamStatusUpdate", {
                 ref: this._main,
                 streamStatus: streamStatusInfo
@@ -4137,7 +4318,7 @@
        * @param config
        */
       constructor(main) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         /**
          * Whenever current window is active or not
          * @private
@@ -4151,7 +4332,7 @@
           'iceServers': []
         };
         /**
-         * Whenever microphone is currenly muted
+         * Whenever microphone is currently muted
          * @private
          */
         this._isMicrophoneMuted = false;
@@ -4161,7 +4342,7 @@
          */
         this._pendingMicrophoneState = null;
         /**
-         * Whenever we have cheched for permissions
+         * Whenever we have checked for permissions
          * @private
          */
         this._permissionChecked = false;
@@ -4224,57 +4405,93 @@
         this._currentOrientation = ((_a = window.screen.orientation) === null || _a === void 0 ? void 0 : _a.type) || '';
         this._statusTimer = null;
         this._debug = false;
+        // FIELDS FOR OPERATION CANCELLATION
+        this._deviceChangeHandler = null;
+        this._orientationChangeHandler = null;
+        /**
+         * 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;
-          // 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 (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);
             }
           }
         });
-        this.onServerDisconnect = () => {};
-        /**
-         * Method for handling a situation when a given streamKey is already in use.
-         */
+        this.onServerDisconnect = () => {
+          // Implementation
+        };
         this.onStreamKeyTaken = () => {
+          if (this._isDestroyed) return;
           if (this._restartTimer != null) {
             clearInterval(this._restartTimer);
             this._restartTimerCount = 0;
@@ -4283,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);
@@ -4293,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);
           };
@@ -4335,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);
             }
@@ -4362,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(),
@@ -4396,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();
@@ -4419,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!");
@@ -4442,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
+          });
         });
       }
       /**
@@ -4481,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);
@@ -4499,18 +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();
+            }
           }
         });
       }
@@ -4519,56 +4784,92 @@
        * @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() {
-        navigator.mediaDevices.addEventListener('devicechange', () => __awaiter(this, void 0, void 0, function* () {
+        if (this._isDestroyed) return;
+        this._deviceChangeHandler = () => __awaiter(this, void 0, void 0, function* () {
           var _a;
+          if (this._isDestroyed) return;
+          if (this._publishState === exports.PublishState.PUBLISHED) {
+            this._logger.info(this, "Device change detected, but already publish - no restarting streamer");
+            return;
+          }
           this._logger.info(this, "Device change detected, restarting streamer");
-          // Store current stream key if we're publishing
           const streamKey = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey;
-          const wasPublishing = this._publishState === exports.PublishState.CONNECTED || this._publishState === exports.PublishState.PUBLISHED;
+          const wasPublishing = this._publishState === exports.PublishState.CONNECTED;
           try {
-            // Stop all current operations
             this.stop();
-            // Wait a moment for devices to settle
             yield new Promise(resolve => setTimeout(resolve, 500));
-            // Restart the streamer
+            if (this._isDestroyed) return;
             yield this.start();
-            // If we were publishing before, try to resume
+            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");
-                // Używamy ogólnego eventu zamiast nowego
                 this._main.dispatchEvent("inputDeviceError", {
                   ref: this._main
                 });
@@ -4576,20 +4877,33 @@
             }
             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();
           }
@@ -4599,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];
@@ -4608,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) {
@@ -4618,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) {
@@ -4632,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,
@@ -4655,13 +4987,15 @@
         if (this._cameraList == null || this._microphoneList == null) {
           this.grabDevices();
         }
-        const videoElement = this._main.getStageController().getScreenElement().getVideoElement();
-        videoElement.srcObject = stream;
-        videoElement.autoplay = true;
-        videoElement.playsInline = true;
-        videoElement.disableRemotePlayback = true;
-        videoElement.controls = false;
-        videoElement.muted = true;
+        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;
+          videoElement.playsInline = true;
+          videoElement.disableRemotePlayback = true;
+          videoElement.controls = false;
+          videoElement.muted = true;
+        }
         this.setPublishState(exports.PublishState.INITIALIZED);
       }
       /**
@@ -4669,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;
@@ -4682,35 +5017,36 @@
         }
       }
       /**
-       * 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);
-        if (this._main.getConfigManager().getStreamData().streamKey == streamKey && this._publishState == exports.PublishState.CONNECTED) {
-          this._logger.warning(this, "Already published!");
-          return false;
+        if (this._main.getConfigManager().getStreamData().streamKey != null && !this._firstPublish) {
+          this.unpublish();
         }
-        if (this._main.getConfigManager().getStreamData().streamKey != null) this.unpublish();
         this._main.getConfigManager().getStreamData().streamKey = streamKey;
         if (!this.isStreamReady(true, true)) {
           this._logger.warning(this, "Cannot publish - stream not ready (missing video or audio track)");
           return false;
         }
-        if (this._debug) this._logger.decoratedLog("Publishing: " + streamKey, "dark-red");
-        this._logger.info(this, "Publish: " + streamKey);
         this.closeWebRTCConnection();
         this._main.dispatchEvent("publish", {
           ref: this._main,
           streamKey: streamKey
         });
         this.initializeWebRTC();
+        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;
@@ -4724,40 +5060,48 @@
         this._main.dispatchEvent("unpublish", {
           ref: this._main
         });
-        this.closeStream();
+        this.closeWebRTCConnection();
+        this.setPublishState(exports.PublishState.UNPUBLISHED);
       }
       /**
-       * This method
+       * Stops publishing AND releases camera/microphone
+       */
+      unpublishAndRelease() {
+        this._logger.info(this, "📹 [UNPUBLISH+RELEASE] unpublishAndRelease() - stopping everything");
+        this.unpublish();
+        this.stopCameraStream();
+      }
+      /**
+       * Sets up orientation listener
        * @private
        */
       setupOrientationListener() {
-        // Sprawdzamy czy urządzenie wspiera event orientationchange
+        if (this._isDestroyed) return;
+        this._orientationChangeHandler = this.handleOrientationChange;
         if (window.screen && window.screen.orientation) {
-          window.screen.orientation.addEventListener('change', this.handleOrientationChange);
+          window.screen.orientation.addEventListener('change', this._orientationChangeHandler);
         } else {
-          // Fallback dla starszych urządzeń
-          window.addEventListener('orientationchange', this.handleOrientationChange);
+          window.addEventListener('orientationchange', this._orientationChangeHandler);
         }
       }
       //------------------------------------------------------------------------//
       // 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() {
@@ -4772,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;
         });
@@ -4818,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'];
@@ -4843,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", {
@@ -4857,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) {
@@ -4895,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", {
@@ -4933,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) {
@@ -4946,8 +5284,8 @@
                 }
               }
             }
+            if (this._isDestroyed) return;
             try {
-              // Aktualizacja wybranych urządzeń
               if (deviceAccess.camera.allowed) {
                 this._selectedCamera = this.pickCamera();
               }
@@ -4955,153 +5293,217 @@
                 this._selectedMicrophone = this.pickMicrophone();
               }
             } 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();
+            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 by ID
+       */
+      selectCamera(cameraID) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+          if (this._isDestroyed) return;
+          if (this._cameraAbortController) {
+            this._cameraAbortController.abort();
+          }
+          this._cameraAbortController = new AbortController();
+          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);
+            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;
+            for (let i = 0; i < this._cameraList.getSize(); i++) {
+              if (this._cameraList.get(i).id == cameraID) {
+                this._selectedCamera = this._cameraList.get(i);
+                this._selectedCamera.isSelected = true;
+                (_b = this._main.getStorageManager()) === null || _b === void 0 ? void 0 : _b.saveField("cameraID", this._selectedCamera.id);
+                found = true;
+                break;
+              }
+            }
             this._main.dispatchEvent("deviceListUpdate", {
               ref: this._main,
               cameraList: this._cameraList.getArray(),
               microphoneList: this._microphoneList.getArray()
             });
-            this._main.dispatchEvent("inputDeviceError", {
-              ref: this._main
-            });
+            if (signal.aborted || this._isDestroyed) return;
+            this.stopCameraStream();
+            if (this._selectedCamera != null) {
+              this._constraints.video.deviceId = this._selectedCamera.id;
+              if (signal.aborted || this._isDestroyed) return;
+              yield new Promise((resolve, reject) => {
+                const timeout = setTimeout(resolve, 500);
+                signal.addEventListener('abort', () => {
+                  clearTimeout(timeout);
+                  reject(new Error('Aborted'));
+                });
+              });
+              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 && !this._isDestroyed) {
+                this.publish(streamKey);
+              }
+            } else {
+              this.setInputDeviceState(exports.InputDevicesState.INVALID);
+            }
+          } catch (error) {
+            if (error.message !== 'Aborted' && !this._isDestroyed) {
+              this._logger.error(this, '📹 [ERROR] selectCamera() - Error switching camera: ' + error);
+              this.setInputDeviceState(exports.InputDevicesState.INVALID);
+            }
+          } finally {
+            this._switchingCamera = false;
+            if (((_c = this._cameraAbortController) === null || _c === void 0 ? void 0 : _c.signal) === signal) {
+              this._cameraAbortController = null;
+            }
           }
         });
       }
       /**
-       * Selects camera based on camera device ID;
-       * @param cameraID
+       * Selects microphone by ID
        */
-      selectCamera(cameraID) {
-        var _a, _b;
-        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;
-        for (let i = 0; i < this._cameraList.getSize(); i++) {
-          if (this._cameraList.get(i).id == cameraID) {
-            this._selectedCamera = this._cameraList.get(i);
-            this._selectedCamera.isSelected = true;
-            (_b = this._main.getStorageManager()) === null || _b === void 0 ? void 0 : _b.saveField("cameraID", this._selectedCamera.id);
-            break;
+      selectMicrophone(micID) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+          if (this._isDestroyed) return;
+          if (this._microphoneAbortController) {
+            this._microphoneAbortController.abort();
           }
-        }
-        this._main.dispatchEvent("deviceListUpdate", {
-          ref: this._main,
-          cameraList: this._cameraList.getArray(),
-          microphoneList: this._microphoneList.getArray()
-        });
-        this.stopCameraStream();
-        if (this._selectedCamera != null) {
-          // Update constraints with new device
-          this._constraints.video.deviceId = this._selectedCamera.id;
-          // Restart camera stream
-          this.startCamera().then(() => {
-            // Jeśli stream był opublikowany, publikujemy ponownie
-            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) {
-              this.publish(streamKey);
+          this._microphoneAbortController = new AbortController();
+          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;
             }
-          });
-        } else {
-          this.setInputDeviceState(exports.InputDevicesState.INVALID);
-        }
-      }
-      /**
-       * Method tries to select (change) microphone based on its system ID
-       * @param micID
-       */
-      selectMicrophone(micID) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-          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);
-              this._selectedMicrophone.isSelected = true;
-              (_b = this._main.getStorageManager()) === null || _b === void 0 ? void 0 : _b.saveField("microphoneID", this._selectedMicrophone.id);
-              break;
+            this._selectedMicrophone = null;
+            this.setInputDeviceState(exports.InputDevicesState.UPDATING);
+            this.setMicrophoneState(exports.DeviceState.NOT_INITIALIZED);
+            const streamKey = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey;
+            const wasPublished = this._publishState === exports.PublishState.CONNECTED;
+            for (let i = 0; i < this._microphoneList.getSize(); i++) {
+              if (this._microphoneList.get(i).id == micID) {
+                this._selectedMicrophone = this._microphoneList.get(i);
+                this._selectedMicrophone.isSelected = true;
+                (_b = this._main.getStorageManager()) === null || _b === void 0 ? void 0 : _b.saveField("microphoneID", this._selectedMicrophone.id);
+                break;
+              }
             }
-          }
-          // Zawsze wysyłamy aktualizację list urządzeń
-          this._main.dispatchEvent("deviceListUpdate", {
-            ref: this._main,
-            cameraList: this._cameraList.getArray(),
-            microphoneList: this._microphoneList.getArray()
-          });
-          // Odłącz SoundMeter przed zmianą strumienia
-          this._soundMeter.detach();
-          // Zamknij istniejące połączenie WebRTC
-          this.closeWebRTCConnection();
-          // Zatrzymaj obecny strumień
-          if (this._stream) {
-            this._stream.getTracks().forEach(track => {
-              track.stop();
+            this._main.dispatchEvent("deviceListUpdate", {
+              ref: this._main,
+              cameraList: this._cameraList.getArray(),
+              microphoneList: this._microphoneList.getArray()
             });
-            this._stream = null;
-          }
-          try {
-            // Rozpocznij wszystko od nowa
+            if (signal.aborted || this._isDestroyed) return;
+            this._soundMeter.detach();
+            this.closeWebRTCConnection();
+            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 || this._isDestroyed) return;
+            yield new Promise((resolve, reject) => {
+              const timeout = setTimeout(resolve, 500);
+              signal.addEventListener('abort', () => {
+                clearTimeout(timeout);
+                reject(new Error('Aborted'));
+              });
+            });
+            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) {
+            if (wasPublished && streamKey && !signal.aborted && !this._isDestroyed) {
               this.publish(streamKey);
             }
           } catch (error) {
-            console.error("Error changing microphone:", error);
-            this._main.dispatchEvent("inputDeviceError", {
-              ref: this._main
-            });
-            this.setInputDeviceState(exports.InputDevicesState.INVALID);
+            if (error.message !== 'Aborted' && !this._isDestroyed) {
+              console.error("Error changing microphone:", error);
+              this._main.dispatchEvent("inputDeviceError", {
+                ref: this._main
+              });
+              this.setInputDeviceState(exports.InputDevicesState.INVALID);
+            }
+          } finally {
+            this._switchingMicrophone = false;
+            if (((_c = this._microphoneAbortController) === null || _c === void 0 ? void 0 : _c.signal) === signal) {
+              this._microphoneAbortController = null;
+            }
           }
         });
       }
       /**
-       * This method tries to start a camera.
-       *
+       * Starts camera with abort support
        * @private
        */
       startCamera() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+          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 = {
@@ -5116,11 +5518,24 @@
                 }
               } : false
             };
+            if (signal.aborted || this._isDestroyed) return;
+            this._logger.info(this, `📹 [ACQUIRE] startCamera() - requesting getUserMedia`);
             try {
               const stream = yield navigator.mediaDevices.getUserMedia(constraints);
+              // 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 || this._isDestroyed) return;
+              this._logger.error(this, `📹 [ERROR] startCamera() - getUserMedia failed: ${error.name}: ${error.message}`);
               if (constraints.video) {
                 this.onUserMediaError({
                   name: error.name || 'Error',
@@ -5138,8 +5553,13 @@
             }
             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 {
+            if (((_a = this._startCameraAbortController) === null || _a === void 0 ? void 0 : _a.signal) === signal) {
+              this._startCameraAbortController = null;
+            }
           }
         });
       }
@@ -5147,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);
@@ -5163,33 +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;
@@ -5206,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,
@@ -5232,20 +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;
         }
@@ -5272,7 +5682,6 @@
                 this._logger.info(this, "Canceling Publish!");
                 this._main.getConfigManager().getStreamData().streamKey = null;
               }
-              return null;
             }
           }
           if (!this._selectedMicrophone) {
@@ -5301,75 +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';
@@ -5378,7 +5755,15 @@
       }
       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;
         }
       }
@@ -5393,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) {
@@ -5413,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();
@@ -5425,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,
@@ -5439,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,
@@ -5452,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,
@@ -5475,130 +5862,82 @@
         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}`);
         }
       }
-      /**
-       * Method stops streaming for all streams
-       * @private
-       */
-      forceStopAllStreams() {
-        var _a, _b;
-        // 1. First, detach the sound meter
-        if (this._soundMeter) {
-          this._soundMeter.detach();
+      stop() {
+        this._logger.info(this, "📹 [STOP] stop() - stopping all operations");
+        if (this._cameraAbortController) {
+          this._cameraAbortController.abort();
+          this._cameraAbortController = null;
         }
-        // 2. Stop the main stream if it exists
-        if (this._stream) {
-          try {
-            const tracks = this._stream.getTracks();
-            this._logger.info(this, `Stopping ${tracks.length} tracks from main stream`);
-            tracks.forEach(track => {
-              try {
-                track.enabled = false;
-                track.stop();
-                this._logger.info(this, `Stopped ${track.kind} track: ${track.id}`);
-              } catch (e) {
-                this._logger.error(this, `Error stopping ${track.kind} track: ${e}`);
-              }
-            });
-            this._stream = null;
-          } catch (e) {
-            this._logger.error(this, 'Error stopping main stream');
-          }
+        if (this._microphoneAbortController) {
+          this._microphoneAbortController.abort();
+          this._microphoneAbortController = null;
         }
-        // 3. Clean up video element
-        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 && videoElement.srcObject instanceof MediaStream) {
-            const videoTracks = videoElement.srcObject.getTracks();
-            if (videoTracks.length > 0) {
-              this._logger.info(this, `Stopping ${videoTracks.length} tracks from video element`);
-              videoTracks.forEach(track => {
-                try {
-                  track.enabled = false;
-                  track.stop();
-                } catch (e) {
-                  this._logger.error(this, `Error stopping video element track: ${e}`);
-                }
-              });
-            }
-            videoElement.srcObject = null;
-            videoElement.removeAttribute('src');
-            videoElement.load();
-          }
-        } catch (e) {
-          this._logger.error(this, 'Error cleaning video element');
+        if (this._startCameraAbortController) {
+          this._startCameraAbortController.abort();
+          this._startCameraAbortController = null;
         }
-        // 4. Handle RTCPeerConnection last, with proper state checking
-        if (this._peerConnection) {
-          try {
-            // Only try to remove tracks if the connection isn't already closed
-            if (this._peerConnection.signalingState !== 'closed') {
-              const senders = this._peerConnection.getSenders();
-              this._logger.info(this, `Cleaning up ${senders.length} senders from peer connection`);
-              senders.forEach(sender => {
-                try {
-                  if (sender.track) {
-                    sender.track.enabled = false;
-                    sender.track.stop();
-                    // Only try to remove the track if connection is still open
-                    if (this._peerConnection && this._peerConnection.signalingState !== 'closed') {
-                      this._peerConnection.removeTrack(sender);
-                    }
-                  }
-                } catch (e) {
-                  this._logger.error(this, `Error stopping sender track: ${e}`);
-                }
-              });
-            }
-            // Now close the peer connection
-            this._peerConnection.close();
-            this._peerConnection = null;
-          } catch (e) {
-            this._logger.error(this, 'Error closing peer connection');
-          }
-        }
-        // 5. Ensure we properly null out our device references
-        this._selectedCamera = null;
-        this._selectedMicrophone = null;
-        // 6. Make a final check for any active tracks at the global level
-        try {
-          const allTracks = [];
-          // Try to find any tracks that might still be active by querying devices
-          navigator.mediaDevices.getUserMedia({
-            audio: false,
-            video: false
-          }).then(() => {
-            // This is just to trigger a device check
-            this._logger.info(this, "Performed final device check");
-          }).catch(() => {
-            // Ignore errors from this check
-          });
-        } catch (e) {
-          // Ignore errors from final check
-        }
-      }
-      /**
-       * Stops all streaming operations and cleans up resources
-       */
-      stop() {
-        // Stop status connection and clear timer
         if (this._statusConnection) {
           this._statusConnection.destroy();
           this._statusConnection = null;
@@ -5608,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;
@@ -5625,41 +5960,62 @@
         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)
+       * SYNCHRONOUS destroy - sets flag immediately, cleanup happens in background
+       * This ensures that even if called without await, all async operations will abort
        */
       destroy() {
-        // Stop any ongoing timers and intervals first
+        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;
@@ -5669,13 +6025,23 @@
           this._restartTimer = null;
         }
         clearTimeout(this._publishTimer);
-        // Remove orientation change listeners
-        if (window.screen && window.screen.orientation) {
-          window.screen.orientation.removeEventListener('change', this.handleOrientationChange);
-        } else {
-          window.removeEventListener('orientationchange', this.handleOrientationChange);
+        // 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 other event listeners
+        // Remove event listeners
         try {
           this._main.removeEventListener("serverConnect", this.onServerConnect);
           this._main.removeEventListener("serverDisconnect", this.onServerDisconnect);
@@ -5688,28 +6054,46 @@
           window.removeEventListener("blur", this.onWindowBlur);
           window.removeEventListener("focus", this.onWindowFocus);
         } catch (e) {
-          this._logger.error(this, 'Error removing event listeners');
+          // Ignore errors
         }
-        // Make sure we destroy the status connection
+        // Destroy status connection
         if (this._statusConnection) {
           this._statusConnection.destroy();
           this._statusConnection = null;
         }
-        // Stop all media streams and clean up the WebRTC connection
-        this.forceStopAllStreams();
-        // Reset all state variables
-        this._pendingMicrophoneState = null;
-        this._cameraList = new InputDeviceList();
-        this._microphoneList = new InputDeviceList();
-        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;
-        // Log completion
-        this._logger.success(this, "StreamerController successfully destroyed and all resources released");
+        // 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());
+            }
+            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)");
       }
     }
 
@@ -6294,7 +6678,6 @@
         this.onStreamStatsUpdate = event => {
           var _a;
           (_a = this._graph) === null || _a === void 0 ? void 0 : _a.addEntry(event.high * 500);
-          console.log(event.high * 200);
         };
         this._main = main;
         this._object = container;
@@ -6322,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.0";
-        /**
-         * Compile date for this streamer
-         * @private
-         */
-        this.COMPILE_DATE = "3/28/2025, 9:18:36 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 = [];
         }
@@ -6377,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;
@@ -6395,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);
@@ -6429,289 +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;
         (_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);
@@ -6722,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);
@@ -6736,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);
@@ -6750,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');
@@ -6820,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++) {
@@ -6885,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) {