@stormstreaming/stormstreamer 0.9.3-beta.0 → 1.0.0-rc.1

package/dist/amd/index.js

@@ -1,11 +1,11 @@
  /*
  * StormStreaming JavaScript Streamer
- * Copyright © 2021-2024 Web-Anatomy s.c. All rights reserved.
+ * Copyright © 2021-2025 Web-Anatomy s.c. All rights reserved.
  * contact@stormstreaming.com
  * https://stormstreaming.com
  *
- * Version: 0.9.3-beta.0
- * Version: 3/8/2025, 11:51:36 PM
+ * Version: 1.0.0-rc.1
+ * Version: 11/17/2025, 10:30:25 AM
  *
  * 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,10 +3672,13 @@
         this._lastEventTime = 0;
         this.THROTTLE_INTERVAL = 100; // ms between updates
         this._isMonitoring = false;
+        // POPRAWKA: Dodane pole do przechowywania ID animacji
+        this._animationFrameId = null;
         // Moving average variables for smoothing
         this._instant = 0.0;
         this._slow = 0.0;
         this._main = main;
+        console.log('SoundMeter: Created new instance');
       }
       attach(stream) {
         if (!stream.getAudioTracks().length) {
@@ -3542,9 +3705,17 @@
       }
 
       detach() {
-        var _a, _b;
+        // POPRAWKA: Zabezpieczenie przed wielokrotnym wywołaniem
+        if (!this._audioContext && !this._analyser && !this._microphone) {
+          return; // Już wyczyszczone
+        }
         // Stop monitoring first
         this._isMonitoring = false;
+        // POPRAWKA: Anulowanie requestAnimationFrame
+        if (this._animationFrameId !== null) {
+          cancelAnimationFrame(this._animationFrameId);
+          this._animationFrameId = null;
+        }
         // Disconnect and cleanup nodes in reverse order
         if (this._microphone) {
           try {
@@ -3562,14 +3733,26 @@
           }
           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();
+            // POPRAWKA: Sprawdzenie przed użyciem w Promise
+            if (this._audioContext.state !== 'closed') {
+              // Zapisz referencję przed asynchroniczną operacją
+              const audioContextRef = this._audioContext;
+              // Najpierw ustaw na null, żeby uniknąć podwójnego wywołania
+              this._audioContext = null;
+              // Teraz bezpiecznie zamknij
+              audioContextRef.suspend().then(() => audioContextRef.close()).catch(e => {
+                console.warn('SoundMeter: Error closing audio context:', e);
+              });
+            } 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,7 +3765,11 @@
         this._isMonitoring = true;
         const dataArray = new Float32Array(this._analyser.frequencyBinCount);
         const analyze = () => {
-          if (!this._analyser || !this._isMonitoring) return;
+          // POPRAWKA: Dodatkowe sprawdzenie przed kontynuacją
+          if (!this._analyser || !this._isMonitoring || !this._audioContext) {
+            this._animationFrameId = null;
+            return;
+          }
           const now = Date.now();
           try {
             // Read time-domain data
@@ -3612,13 +3799,21 @@
           } catch (error) {
             console.error('SoundMeter: Error during analysis:', error);
             this._isMonitoring = false;
+            this._animationFrameId = null;
             return;
           }
-          // Schedule next analysis
-          requestAnimationFrame(analyze);
+          // Schedule next analysis only if still monitoring
+          if (this._isMonitoring) {
+            this._animationFrameId = requestAnimationFrame(analyze);
+          }
         };
         // Start analysis loop
-        requestAnimationFrame(analyze);
+        this._animationFrameId = requestAnimationFrame(analyze);
+      }
+      // POPRAWKA: Dodana metoda destroy
+      destroy() {
+        console.log('SoundMeter: Destroying instance');
+        this.detach();
       }
     }
 
@@ -4018,7 +4213,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
@@ -4224,6 +4418,16 @@
         this._currentOrientation = ((_a = window.screen.orientation) === null || _a === void 0 ? void 0 : _a.type) || '';
         this._statusTimer = null;
         this._debug = false;
+        // NOWE POLA DLA ANULOWANIA OPERACJI
+        this._deviceChangeHandler = null;
+        this._orientationChangeHandler = null;
+        this._isDestroying = false;
+        this._cameraAbortController = null;
+        this._microphoneAbortController = null;
+        this._startCameraAbortController = null;
+        this._switchingCamera = false;
+        this._switchingMicrophone = false;
+        this._firstPublish = true;
         /**
          * Handles device state changes and initiates publishing if appropriate
          * @private
@@ -4240,6 +4444,7 @@
          */
         this.handleOrientationChange = () => __awaiter(this, void 0, void 0, function* () {
           var _d, _e;
+          if (this._isDestroying) return;
           // Dajemy chwilę na ustabilizowanie się orientacji
           yield new Promise(resolve => setTimeout(resolve, 500));
           const newOrientation = ((_d = window.screen.orientation) === null || _d === void 0 ? void 0 : _d.type) || '';
@@ -4261,7 +4466,7 @@
             try {
               yield this.startCamera();
               // Jeśli stream był opublikowany, publikujemy ponownie
-              if (streamKey) {
+              if (streamKey && !this._isDestroying) {
                 this.publish(streamKey);
               }
             } catch (error) {
@@ -4270,7 +4475,9 @@
             }
           }
         });
-        this.onServerDisconnect = () => {};
+        this.onServerDisconnect = () => {
+          // Implementation
+        };
         /**
          * Method for handling a situation when a given streamKey is already in use.
          */
@@ -4463,6 +4670,7 @@
             this.initializeStream();
             this.setupOrientationListener();
             this.setupPermissionListeners();
+            this.setupDeviceChangeListener();
             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();
@@ -4508,6 +4716,7 @@
             // Initialize device lists
             yield this.grabDevices();
           } catch (error) {
+            console.log(error);
             this._logger.error(this, "Error initializing devices: " + JSON.stringify(error));
             yield this.grabDevices();
           }
@@ -4542,6 +4751,46 @@
           };
         });
       }
+      /**
+       * Sets up event listener for device changes and handles them appropriately
+       * @private
+       */
+      setupDeviceChangeListener() {
+        this._deviceChangeHandler = () => __awaiter(this, void 0, void 0, function* () {
+          var _a;
+          if (this._isDestroying) 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");
+          const streamKey = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey;
+          const wasPublishing = this._publishState === exports.PublishState.CONNECTED;
+          try {
+            this.stop();
+            yield new Promise(resolve => setTimeout(resolve, 500));
+            if (!this._isDestroying) {
+              yield this.start();
+              if (wasPublishing && streamKey && !this._isDestroying) {
+                this._logger.info(this, "Resuming publishing after device change");
+                if (this.isStreamReady(true, true)) {
+                  this.publish(streamKey);
+                } else {
+                  this._logger.warning(this, "Cannot resume publishing - stream not ready after device change");
+                  this._main.dispatchEvent("inputDeviceError", {
+                    ref: this._main
+                  });
+                }
+              }
+            }
+            this._logger.success(this, "Successfully handled device change");
+          } catch (error) {
+            this._logger.error(this, "Error handling device change: " + JSON.stringify(error));
+            this.setInputDeviceState(exports.InputDevicesState.INVALID);
+          }
+        });
+        navigator.mediaDevices.addEventListener('devicechange', this._deviceChangeHandler);
+      }
       handlePermissionChange(device, state) {
         return __awaiter(this, void 0, void 0, function* () {
           if (state === 'denied') {
@@ -4617,12 +4866,14 @@
           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;
+        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);
       }
       /**
@@ -4649,25 +4900,24 @@
        * @returns {boolean} - true jeśli udało się rozpocząć publikowanie
        */
       publish(streamKey) {
+        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;
       }
       unpublish() {
@@ -4692,12 +4942,11 @@
        * @private
        */
       setupOrientationListener() {
-        // Sprawdzamy czy urządzenie wspiera event orientationchange
+        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);
         }
       }
       //------------------------------------------------------------------------//
@@ -4916,6 +5165,7 @@
                 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));
             }
@@ -4942,94 +5192,145 @@
         });
       }
       /**
-       * Selects camera based on camera device ID;
+       * Selects camera based on camera device ID with abort support
        * @param cameraID
        */
       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;
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+          // Anuluj poprzednie przełączanie kamery
+          if (this._cameraAbortController) {
+            this._cameraAbortController.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._cameraAbortController = new AbortController();
+          const signal = this._cameraAbortController.signal;
+          try {
+            this._switchingCamera = true;
+            for (let i = 0; i < this._cameraList.getSize(); i++) {
+              this._cameraList.get(i).isSelected = false;
             }
-          });
-        } else {
-          this.setInputDeviceState(exports.InputDevicesState.INVALID);
-        }
+            this._selectedCamera = null;
+            this.setInputDeviceState(exports.InputDevicesState.UPDATING);
+            this.setCameraState(exports.DeviceState.NOT_INITIALIZED);
+            // Zapamiętaj aktualny stream key i stan publikacji
+            const streamKey = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey;
+            const wasPublished = this._publishState === exports.PublishState.CONNECTED;
+            let found = false;
+            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()
+            });
+            if (signal.aborted) return;
+            this.stopCameraStream();
+            if (this._selectedCamera != null) {
+              // Update constraints with new device
+              this._constraints.video.deviceId = this._selectedCamera.id;
+              // Sprawdź czy nie anulowano
+              if (signal.aborted) return;
+              // Poczekaj z możliwością anulowania
+              yield new Promise((resolve, reject) => {
+                const timeout = setTimeout(resolve, 500);
+                signal.addEventListener('abort', () => {
+                  clearTimeout(timeout);
+                  reject(new Error('Aborted'));
+                });
+              });
+              if (signal.aborted) return;
+              // Restart camera stream
+              yield this.startCamera();
+              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.publish(streamKey);
+              }
+            } else {
+              this.setInputDeviceState(exports.InputDevicesState.INVALID);
+            }
+          } catch (error) {
+            if (error.message !== 'Aborted') {
+              this._logger.error(this, '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;
+            }
+          }
+        });
       }
       /**
-       * Method tries to select (change) microphone based on its system ID
+       * Method tries to select (change) microphone based on its system ID with abort support
        * @param micID
        */
       selectMicrophone(micID) {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-          for (let i = 0; i < this._microphoneList.getSize(); i++) {
-            this._microphoneList.get(i).isSelected = false;
+          // Anuluj poprzednie przełączanie mikrofonu
+          if (this._microphoneAbortController) {
+            this._microphoneAbortController.abort();
           }
-          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._microphoneAbortController = new AbortController();
+          const signal = this._microphoneAbortController.signal;
+          try {
+            this._switchingMicrophone = true;
+            for (let i = 0; i < this._microphoneList.getSize(); i++) {
+              this._microphoneList.get(i).isSelected = false;
             }
-          }
-          // 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._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;
+              }
+            }
+            // Zawsze wysyłamy aktualizację list urządzeń
+            this._main.dispatchEvent("deviceListUpdate", {
+              ref: this._main,
+              cameraList: this._cameraList.getArray(),
+              microphoneList: this._microphoneList.getArray()
             });
-            this._stream = null;
-          }
-          try {
+            if (signal.aborted) return;
+            // 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._stream = null;
+            }
+            if (signal.aborted) return;
+            // Poczekaj z możliwością anulowania
+            yield new Promise((resolve, reject) => {
+              const timeout = setTimeout(resolve, 500);
+              signal.addEventListener('abort', () => {
+                clearTimeout(timeout);
+                reject(new Error('Aborted'));
+              });
+            });
+            if (signal.aborted) return;
             // Rozpocznij wszystko od nowa
             yield this.startCamera();
             this.setMicrophoneState(exports.DeviceState.ENABLED);
@@ -5039,25 +5340,38 @@
               this.setInputDeviceState(exports.InputDevicesState.INVALID);
             }
             // Jeśli stream był opublikowany, publikujemy ponownie
-            if (wasPublished && streamKey) {
+            if (wasPublished && streamKey && !signal.aborted) {
               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') {
+              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.
-       *
+       * This method tries to start a camera with abort support
        * @private
        */
       startCamera() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+          // Anuluj poprzednie uruchamianie kamery
+          if (this._startCameraAbortController) {
+            this._startCameraAbortController.abort();
+          }
+          this._startCameraAbortController = new AbortController();
+          const signal = this._startCameraAbortController.signal;
           if (this._stream) {
             this._stream.getTracks().forEach(track => {
               track.stop();
@@ -5077,11 +5391,18 @@
                 }
               } : false
             };
+            if (signal.aborted) return;
             try {
               const stream = yield navigator.mediaDevices.getUserMedia(constraints);
+              if (signal.aborted) {
+                // Jeśli anulowano, zatrzymaj nowo utworzony strumień
+                stream.getTracks().forEach(track => track.stop());
+                return;
+              }
               this._stream = stream;
               this.onCameraStreamSuccess(this._stream);
             } catch (error) {
+              if (signal.aborted) return;
               if (constraints.video) {
                 this.onUserMediaError({
                   name: error.name || 'Error',
@@ -5101,6 +5422,10 @@
           } catch (error) {
             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;
+            }
           }
         });
       }
@@ -5132,7 +5457,6 @@
       }
       /**
        * This method selects a camera based on previous uses or saved IDs
-       *
        * @private
        */
       pickCamera() {
@@ -5202,7 +5526,6 @@
       }
       /**
        * This method selects a microphone based on previous uses or saved IDs
-       *
        * @private
        */
       pickMicrophone() {
@@ -5303,7 +5626,6 @@
       }
       /**
        * Applies the microphone state to the actual stream tracks
-       *
        * @param enabled true to enable tracks, false to disable
        * @private
        */
@@ -5322,7 +5644,6 @@
       }
       /**
        * 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
@@ -5343,6 +5664,47 @@
           this._peerConnection = null;
         }
       }
+      // Asynchroniczna wersja do użycia w destroy
+      closeWebRTCConnectionAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+          if (this._peerConnection) {
+            try {
+              // Usuń event handlery
+              this._peerConnection.onicecandidate = null;
+              this._peerConnection.onconnectionstatechange = null;
+              this._peerConnection.onnegotiationneeded = null;
+              this._peerConnection.oniceconnectionstatechange = null;
+              this._peerConnection.onicegatheringstatechange = null;
+              this._peerConnection.onsignalingstatechange = null;
+              this._peerConnection.ontrack = null;
+              // Zatrzymaj wszystkie transceivery
+              const transceivers = this._peerConnection.getTransceivers();
+              for (const transceiver of transceivers) {
+                if (transceiver.stop) {
+                  transceiver.stop();
+                }
+              }
+              // Usuń wszystkie tracks
+              const senders = this._peerConnection.getSenders();
+              for (const sender of senders) {
+                if (sender.track) {
+                  sender.track.enabled = false;
+                  sender.track.stop();
+                }
+                this._peerConnection.removeTrack(sender);
+              }
+              // Zamknij połączenie
+              this._peerConnection.close();
+              // Poczekaj na zamknięcie
+              yield new Promise(resolve => setTimeout(resolve, 100));
+            } catch (e) {
+              this._logger.error(this, 'Error closing peer connection: ' + e);
+            } finally {
+              this._peerConnection = null;
+            }
+          }
+        });
+      }
       onDescriptionError(error) {
         this._logger.info(this, "WebRTCStreamer :: onDescriptionError: " + JSON.stringify(error));
       }
@@ -5455,110 +5817,101 @@
         }
       }
       /**
-       * Method stops streaming for all streams
+       * Ulepszona metoda czyszczenia strumienia
+       * @private
+       */
+      cleanupMediaStream(stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+          if (!stream) return;
+          const tracks = stream.getTracks();
+          for (const track of tracks) {
+            try {
+              // Usuń wszystkie event listenery
+              track.onended = null;
+              track.onmute = null;
+              track.onunmute = null;
+              // Wyłącz track
+              track.enabled = false;
+              // Zatrzymaj track
+              track.stop();
+              this._logger.info(this, `Track ${track.kind} stopped. ReadyState: ${track.readyState}`);
+            } catch (e) {
+              this._logger.error(this, `Error stopping track: ${e}`);
+            }
+          }
+          // Poczekaj na cleanup
+          yield new Promise(resolve => setTimeout(resolve, 50));
+        });
+      }
+      /**
+       * Method stops streaming for all streams with proper cleanup
        * @private
        */
       forceStopAllStreams() {
         var _a, _b;
-        // 1. First, detach the sound meter
-        if (this._soundMeter) {
-          this._soundMeter.detach();
-        }
-        // 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');
-          }
-        }
-        // 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}`);
-                }
-              });
+        return __awaiter(this, void 0, void 0, function* () {
+          this._logger.info(this, "Force stopping all streams...");
+          // 1. Odłączenie i zniszczenie SoundMeter
+          if (this._soundMeter) {
+            try {
+              this._soundMeter.destroy();
+            } catch (e) {
+              this._logger.error(this, 'Error destroying SoundMeter: ' + e);
             }
-            videoElement.srcObject = null;
-            videoElement.removeAttribute('src');
-            videoElement.load();
           }
-        } catch (e) {
-          this._logger.error(this, 'Error cleaning video element');
-        }
-        // 4. Handle RTCPeerConnection last, with proper state checking
-        if (this._peerConnection) {
+          // 2. Zatrzymanie głównego strumienia
+          if (this._stream) {
+            yield this.cleanupMediaStream(this._stream);
+            this._stream = null;
+          }
+          // 3. Czyszczenie elementu video
           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}`);
-                }
-              });
+            const videoElement = (_b = (_a = this._main.getStageController()) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getVideoElement();
+            if (videoElement) {
+              // Zatrzymaj strumień w elemencie video
+              if (videoElement.srcObject instanceof MediaStream) {
+                yield this.cleanupMediaStream(videoElement.srcObject);
+              }
+              // Wyczyść element video
+              videoElement.pause();
+              videoElement.removeAttribute('src');
+              videoElement.srcObject = null;
+              videoElement.load();
+              // Usuń event listenery
+              videoElement.onloadedmetadata = null;
+              videoElement.onloadeddata = null;
+              videoElement.oncanplay = null;
+              videoElement.onerror = null;
             }
-            // Now close the peer connection
-            this._peerConnection.close();
-            this._peerConnection = null;
           } catch (e) {
-            this._logger.error(this, 'Error closing peer connection');
+            this._logger.error(this, 'Error cleaning video element: ' + e);
           }
-        }
-        // 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
-        }
+          // 4. Zamknięcie WebRTC
+          yield this.closeWebRTCConnectionAsync();
+          // 5. Resetuj zmienne
+          this._selectedCamera = null;
+          this._selectedMicrophone = null;
+          this._pendingMicrophoneState = null;
+          this._logger.info(this, "Force stop all streams completed");
+        });
       }
       /**
        * Stops all streaming operations and cleans up resources
        */
       stop() {
+        // Anuluj wszystkie aktywne operacje
+        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 status connection and clear timer
         if (this._statusConnection) {
           this._statusConnection.destroy();
@@ -5617,60 +5970,96 @@
         });
       }
       /**
-       * Method used for destroying everything (one-time use)
+       * Method used for destroying everything (one-time use) with proper cleanup
        */
       destroy() {
-        // Stop any ongoing timers and intervals first
-        if (this._statusTimer != null) {
-          clearInterval(this._statusTimer);
-          this._statusTimer = null;
-        }
-        if (this._restartTimer != null) {
-          clearInterval(this._restartTimer);
-          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 other event listeners
-        try {
-          this._main.removeEventListener("serverConnect", this.onServerConnect);
-          this._main.removeEventListener("serverDisconnect", this.onServerDisconnect);
-          this._main.removeEventListener("streamKeyInUse", this.onStreamKeyTaken);
-          this._main.removeEventListener("statusServerConnect", this.onStatusServerConnect);
-          this._main.removeEventListener("statusServerDisconnect", this.onStatusServerDisconnect);
-          this._main.removeEventListener("streamStatusUpdate", this.onStreamStatsUpdate);
-          this._main.removeEventListener("deviceStateChange", this.onDeviceStateChange);
-          document.removeEventListener("visibilitychange", this.visibilityChange);
-          window.removeEventListener("blur", this.onWindowBlur);
-          window.removeEventListener("focus", this.onWindowFocus);
-        } catch (e) {
-          this._logger.error(this, 'Error removing event listeners');
-        }
-        // Make sure we destroy the 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");
+        return __awaiter(this, void 0, void 0, function* () {
+          this._logger.info(this, "Starting StreamerController destroy...");
+          this._isDestroying = true;
+          try {
+            // 1. Anuluj wszystkie aktywne operacje
+            if (this._cameraAbortController) {
+              this._cameraAbortController.abort();
+              this._cameraAbortController = null;
+            }
+            if (this._microphoneAbortController) {
+              this._microphoneAbortController.abort();
+              this._microphoneAbortController = null;
+            }
+            if (this._startCameraAbortController) {
+              this._startCameraAbortController.abort();
+              this._startCameraAbortController = null;
+            }
+            // 2. Zatrzymaj timery
+            if (this._statusTimer != null) {
+              clearInterval(this._statusTimer);
+              this._statusTimer = null;
+            }
+            if (this._restartTimer != null) {
+              clearInterval(this._restartTimer);
+              this._restartTimer = null;
+            }
+            clearTimeout(this._publishTimer);
+            // 3. Usuń event listenery urządzeń
+            if (this._deviceChangeHandler) {
+              navigator.mediaDevices.removeEventListener('devicechange', this._deviceChangeHandler);
+              this._deviceChangeHandler = null;
+            }
+            // 4. Usuń event listenery orientacji
+            if (this._orientationChangeHandler) {
+              if (window.screen && window.screen.orientation) {
+                window.screen.orientation.removeEventListener('change', this._orientationChangeHandler);
+              } else {
+                window.removeEventListener('orientationchange', this._orientationChangeHandler);
+              }
+              this._orientationChangeHandler = null;
+            }
+            // 5. Usuń pozostałe event listenery
+            try {
+              this._main.removeEventListener("serverConnect", this.onServerConnect);
+              this._main.removeEventListener("serverDisconnect", this.onServerDisconnect);
+              this._main.removeEventListener("streamKeyInUse", this.onStreamKeyTaken);
+              this._main.removeEventListener("statusServerConnect", this.onStatusServerConnect);
+              this._main.removeEventListener("statusServerDisconnect", this.onStatusServerDisconnect);
+              this._main.removeEventListener("streamStatusUpdate", this.onStreamStatsUpdate);
+              this._main.removeEventListener("deviceStateChange", this.onDeviceStateChange);
+              document.removeEventListener("visibilitychange", this.visibilityChange);
+              window.removeEventListener("blur", this.onWindowBlur);
+              window.removeEventListener("focus", this.onWindowFocus);
+            } catch (e) {
+              this._logger.error(this, 'Error removing event listeners: ' + e);
+            }
+            // 6. Zniszcz status connection
+            if (this._statusConnection) {
+              this._statusConnection.destroy();
+              this._statusConnection = null;
+            }
+            // 7. Zatrzymaj wszystkie strumienie
+            yield this.forceStopAllStreams();
+            // 8. Resetuj stany
+            this._permissionChecked = false;
+            this._isWindowActive = false;
+            this._isMicrophoneMuted = false;
+            this._publishState = exports.PublishState.NOT_INITIALIZED;
+            this._inputDeviceState = exports.InputDevicesState.NOT_INITIALIZED;
+            this._cameraState = exports.DeviceState.NOT_INITIALIZED;
+            this._microphoneState = exports.DeviceState.NOT_INITIALIZED;
+            this._switchingCamera = false;
+            this._switchingMicrophone = false;
+            // 9. Wyczyść listy urządzeń
+            if (this._cameraList) {
+              this._cameraList = new InputDeviceList();
+            }
+            if (this._microphoneList) {
+              this._microphoneList = new InputDeviceList();
+            }
+            this._logger.success(this, "StreamerController successfully destroyed");
+          } catch (error) {
+            this._logger.error(this, "Error during destroy: " + error);
+          } finally {
+            this._isDestroying = false;
+          }
+        });
       }
     }
 
@@ -6255,7 +6644,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;
@@ -6303,12 +6691,12 @@
          * Version of this streamer in SemVer format (Major.Minor.Patch).
          * @private
          */
-        this.STREAMER_VERSION = "0.9.3-beta.0";
+        this.STREAMER_VERSION = "1.0.0-rc.1";
         /**
          * Compile date for this streamer
          * @private
          */
-        this.COMPILE_DATE = "3/8/2025, 11:51:35 PM";
+        this.COMPILE_DATE = "11/17/2025, 10:30:23 AM";
         /**
          * Defines from which branch this streamer comes from e.g. "Main", "Experimental"
          * @private
@@ -6370,6 +6758,7 @@
         if (this._configManager == null) {
           this._configManager = new ConfigManager(copiedStreamConfig);
           this._logger = new Logger(this._configManager.getSettingsData().getDebugData(), this);
+          this._logger.info(this, "Storm Streamer :: Storm Streaming Suite");
           this._logger.info(this, "StreamerID: " + this._streamerID);
           this._logger.info(this, "Version: " + this.STREAMER_VERSION + " | Compile Date: " + this.COMPILE_DATE + " | Branch: " + this.STREAMER_BRANCH);
           this._logger.info(this, "UserCapabilities :: Browser: " + UserCapabilities.getBrowserName() + " " + UserCapabilities.getBrowserVersion());
@@ -6573,6 +6962,7 @@
        */
       unpublish() {
         var _a;
+        console.log("kutas 1");
         (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.unpublish();
       }
       /**