@3dsource/angular-unreal-module 0.0.122 → 0.0.123

package/fesm2022/3dsource-angular-unreal-module.mjs

@@ -1,12 +1,12 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, ChangeDetectionStrategy, Component, Injectable, DestroyRef, effect, untracked, computed, signal, Pipe, input, ElementRef, viewChild, afterNextRender, HostListener, output, makeEnvironmentProviders, provideEnvironmentInitializer } from '@angular/core';
 import { SourceButtonComponent, SourceLoadingComponent } from '@3dsource/source-ui-native';
-import { merge, map, scan, timestamp, startWith, pairwise, concatMap, of, animationFrameScheduler, interval, Observable, skip, switchMap, concat, delay, debounceTime, timer, take, timeout, mergeMap, EMPTY, Subject, share, takeUntil as takeUntil$1, shareReplay, from, fromEvent, throwError, defer, retry, tap as tap$1, throttleTime, NEVER, asyncScheduler, filter as filter$1, withLatestFrom as withLatestFrom$1, Subscription, bufferTime, combineLatestWith, distinctUntilChanged as distinctUntilChanged$1 } from 'rxjs';
+import { merge, map, scan, timestamp, startWith, pairwise, concatMap, of, animationFrameScheduler, interval, Observable, skip, switchMap, concat, delay, debounceTime, timer, take, timeout, mergeMap, EMPTY, Subject, share, takeUntil as takeUntil$1, shareReplay, from, fromEvent, throwError, defer, retry, repeat, tap as tap$1, throttleTime, NEVER, asyncScheduler, filter as filter$1, withLatestFrom as withLatestFrom$1, Subscription, bufferTime, combineLatestWith, distinctUntilChanged as distinctUntilChanged$1 } from 'rxjs';
 import { createAction, props, createReducer, on, createFeature, createSelector, Store, provideState } from '@ngrx/store';
 import { concatLatestFrom } from '@ngrx/operators';
 import { Actions, createEffect, ofType, provideEffects } from '@ngrx/effects';
 import { whereNot, Logger, calculateMedian, clampf, lerp, getCanvasCached, getSnapshot, fitIntoRectangle, Truthy, tapLog, Falsy, generateUuid, COLOR_CODES, where, KeyboardNumericCode, InvertedKeyMap, Semaphore, HEXtoRGB, RGBtoHSV, inverseLerp, HSVtoRGB, RGBtoHEX, fpIsASameAsB } from '@3dsource/utils';
-import { map as map$1, distinctUntilChanged, takeWhile, filter, tap, takeUntil, catchError, withLatestFrom, exhaustMap, switchMap as switchMap$1, timeout as timeout$1, debounceTime as debounceTime$1, take as take$1, startWith as startWith$1 } from 'rxjs/operators';
+import { map as map$1, distinctUntilChanged, takeWhile, filter, tap, takeUntil, catchError, withLatestFrom, exhaustMap, switchMap as switchMap$1, timeout as timeout$1, finalize, first, debounceTime as debounceTime$1, take as take$1, startWith as startWith$1 } from 'rxjs/operators';
 import { DialogRef, DIALOG_DATA, Dialog } from '@angular/cdk/dialog';
 import { HttpClient } from '@angular/common/http';
 import { ScrollStrategyOptions } from '@angular/cdk/overlay';
@@ -207,8 +207,31 @@ const CONSOLE_COMMAND_DISABLE_MESSAGES = 'DisableAllScreenMessages';
 const CONSOLE_COMMAND_PIXEL_QUALITY = 'PixelStreaming.FreezeFrameQuality 95';
 const FULL_HD_WIDTH = 1920;
 const FULL_HD_HEIGHT = 1080;
-const WS_TIMEOUT = 2000;
+// Bound on a single WS upgrade attempt (`createWebSocket`). On cold
+// connections the TCP+TLS+WS handshake can legitimately take 3-5 s
+// (cold DNS, TLS session miss). 2 s was too aggressive — first
+// attempts kept timing out and the second attempt (with warm caches)
+// would connect in <500 ms. 10 s gives slow networks room without
+// letting a truly hung handshake hold up `connectToCirrus` forever.
+const WS_TIMEOUT = 6000;
 const POLLING_TIME = 4000;
+// Staged retry policy for `SignallingService.connectToSignaling`:
+//   INNER_RETRY_LIMIT = max number of WS+orchestration attempts before
+//     the pipeline gives up on the current region and bubbles the error
+//     to the outer retry. URL rotation (`urlGen`) advances across these.
+//   OUTER_RETRY_DELAY = backoff between region re-picks. Intentionally
+//     longer than POLLING_TIME so region discovery is rare relative to
+//     WS retries.
+const INNER_RETRY_LIMIT = 3;
+const OUTER_RETRY_DELAY = POLLING_TIME * 2;
+// Extra WS-only retries on the SAME wsUrl (cached AwsInstance) BEFORE
+// falling through to a URL-rotating retry that re-polls orchestration.
+// Why: a fresh `default` poll asks orchestrator to RESERVE a new
+// instance — the previous reservation is orphaned (server-side leak).
+// One quick same-wsUrl retry catches transient WS failures (network
+// blip, brief unavailability) without burning a second reservation.
+// Total WS attempts before URL rotation = 1 + WS_RETRY_PER_INSTANCE.
+const WS_RETRY_PER_INSTANCE = 1;
 const WS_OPEN_STATE = 1;
 const DEFAULT_AFK_TIMEOUT_PERIOD = 15;
 const DEFAULT_AFK_TIMEOUT = 600; // 10 minutes
@@ -1276,12 +1299,6 @@ class UnrealEffects {
             onDataChannelClose: this.unrealInitialConfig?.reconnect?.onDataChannelClose ??
                 DEFAULT_RECONNECT_ON_DATACHANNEL_CLOSE,
         };
-        this.destroyConnectionsCleanup$ = createEffect(() => {
-            return this.actions$.pipe(ofType(destroyUnrealScene), tap(() => {
-                this.commandsSender.destroy();
-                this.videoService.setContainer(null);
-            }));
-        }, { dispatch: false });
         this.destroyConnections$ = createEffect(() => {
             return this.actions$.pipe(ofType(destroyUnrealScene), map(() => destroyRemoteConnections({ reason: DisconnectReason.Destroy })));
         });
@@ -1678,9 +1695,9 @@ class AFKService extends SubService {
     resetAfkWarningTimer() {
         if (this.active) {
             this.clearTimers();
-            this.warnTimer = setTimeout(() => {
-                this.showAfkOverlay();
-            }, (this.warnTimeout() || DEFAULT_AFK_TIMEOUT) * 1000);
+            // `selectWarnTimeout` already falls back to DEFAULT_AFK_TIMEOUT when
+            // config is missing, so warnTimeout() always returns a positive number.
+            this.warnTimer = setTimeout(() => this.showAfkOverlay(), this.warnTimeout() * 1000);
         }
     }
     /**
@@ -1700,7 +1717,8 @@ class AFKService extends SubService {
     }
     reset() {
         this.hideOverlay();
-        clearInterval(this.countdownTimer);
+        // startAfkWarningTimer → resetAfkWarningTimer → clearTimers() already
+        // clears the countdown interval, no separate clearInterval needed.
         this.startAfkWarningTimer();
     }
     showAfkOverlay() {
@@ -1903,7 +1921,7 @@ const BITRATE_MONITOR = new DataFlowMonitor(FilterModel.yellowFlag, FilterModel.
 
 class VideoService extends SubService {
     constructor() {
-        super(...arguments);
+        super();
         this.isVideoPlaying = this.store.selectSignal(unrealFeature.selectIsVideoPlaying);
         this.video = null;
         this.audio = null;
@@ -1922,6 +1940,11 @@ class VideoService extends SubService {
             ? // IMPORTANT! DO NOT CHANGE THOSE NUMBERS, LBM Stats are based on those values
                 interval(250).pipe(map(() => track.pcClient), switchMap$1((pcClient) => from(this.getStats(pcClient))), filter(Truthy))
             : of(null)), filter(Truthy), share());
+        this.destroyAbort = new AbortController();
+        this.destroyRef.onDestroy(() => {
+            this.destroyAbort.abort();
+            this.destroy();
+        });
     }
     setContainer(container = null) {
         this.container = container;
@@ -1933,7 +1956,9 @@ class VideoService extends SubService {
         this.VideoEncoderQP = Number(new TextDecoder('utf-16').decode(data));
     }
     create() {
-        this.disconnect$.pipe(take(1)).subscribe(() => this.destroy());
+        this.disconnect$
+            .pipe(take(1), takeUntil$1(this.destroy$))
+            .subscribe(() => this.destroy());
         this.destroy();
         this.createWebRtcVideo();
         this.createWebRtcAudio();
@@ -2006,8 +2031,13 @@ class VideoService extends SubService {
             window.addEventListener('pointerdown', resume, {
                 once: true,
                 capture: true,
+                signal: this.destroyAbort.signal,
+            });
+            window.addEventListener('keydown', resume, {
+                once: true,
+                capture: true,
+                signal: this.destroyAbort.signal,
             });
-            window.addEventListener('keydown', resume, { once: true, capture: true });
         }
     }
     async getStats(pcClient) {
@@ -2173,7 +2203,7 @@ class VideoService extends SubService {
             .pipe(takeUntil$1(merge(this.disconnect$, this.destroy$)))
             .subscribe(() => this.changeStatusMainVideoOnScene(true));
         fromEvent(this.video, 'loadedmetadata')
-            .pipe(take(1), filter((data) => this.video === data.target), tapLog('VideoService loadedmetadata:'), filter(() => !!this.video))
+            .pipe(take(1), filter((data) => this.video === data.target), tapLog('VideoService loadedmetadata:'), filter(() => !!this.video), takeUntil$1(this.destroy$))
             .subscribe(() => this.store.dispatch(videoStreamInitialized()));
     }
     createWebRtcAudio() {
@@ -2189,18 +2219,16 @@ class VideoService extends SubService {
             error: () => ({}),
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: VideoService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: VideoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: VideoService }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: VideoService, decorators: [{
             type: Injectable
-        }] });
+        }], ctorParameters: () => [] });
 
-class CommandTelemetryService {
+class CommandTelemetryService extends SubService {
     constructor() {
-        this.actions$ = inject(Actions);
-        this.destroyRef = inject(DestroyRef);
-        this.destroy$ = new Subject();
+        super();
         this.appId = 'metabox-telemetry';
         this.commandsSent = {};
         this.exileTimeout = 60000;
@@ -2208,13 +2236,7 @@ class CommandTelemetryService {
         this.commandSequenceNumber = 0;
         this.payloads = [];
         this.httpClient = inject(HttpClient);
-        this.unrealConfig = inject(UNREAL_CONFIG, {
-            optional: true,
-        });
-        this.destroyRef.onDestroy(() => {
-            this.destroy$.next();
-            this.destroy$.complete();
-        });
+        this.unrealConfig = inject(UNREAL_CONFIG, { optional: true });
         this.init();
     }
     init() {
@@ -2648,12 +2670,11 @@ class SignallingService extends SubService {
         this.onConfig$ = new Subject();
         this.onWebRtcIce$ = new Subject();
         this.onWebRtcAnswer$ = new Subject();
-        // Fan-in produced by abortEstablishingConnection$ in unreal.effects.ts
-        // whenever cirrus drops, dropConnection fires, or the scene is destroyed.
-        this.abort$ = this.actions$.pipe(ofType(abortEstablishingConnection), tap(() => this.close({
-            code: 1000,
-            reason: DisconnectReason.AbortEstablishingConnection,
-        })));
+        // Pure signal — no side-effects. The `close()` is wired ONCE in init()
+        // below so a single abort event triggers exactly one close, regardless
+        // of how many pipelines have `takeUntil(this.abort$)` attached.
+        this.abort$ = this.actions$.pipe(ofType(abortEstablishingConnection));
+        this.ws = null;
         this.wsMsgHandlers = {};
         this.init();
     }
@@ -2662,9 +2683,24 @@ class SignallingService extends SubService {
             return;
         }
         this.setHandlersFromStream();
-        const stop$ = merge(this.abort$, this.destroy$);
+        // Single owner of the "close on abort" side-effect. Previously this
+        // lived as a `tap` inside `abort$` itself, which made every
+        // `takeUntil(this.abort$)` subscriber fire its own close().
+        this.abort$.pipe(takeUntil(this.destroy$)).subscribe(() => {
+            this.close({
+                code: 1000,
+                reason: DisconnectReason.AbortEstablishingConnection,
+            });
+        });
+        // `dataChannelReady` is a per-session event. Bind ONLY to destroy$, not
+        // to abort$ — `abort$` fires on every destroyUnrealScene (route swap),
+        // and `init()` runs once in the constructor. If these subs were torn
+        // down by abort$, a second in-injector session (e.g. navigating between
+        // two routes that both host <app-unreal-scene>) would never send
+        // `p2pEstablished` / `streamPreparedForUserInteraction`. `send()` is
+        // already a no-op on a closed WS, so there's no risk of stray messages.
         this.actions$
-            .pipe(ofType(dataChannelReady), takeUntil(stop$))
+            .pipe(ofType(dataChannelReady), takeUntil(this.destroy$))
             .subscribe(() => {
             this.send({
                 type: 'p2pEstablished',
@@ -2675,7 +2711,7 @@ class SignallingService extends SubService {
         this.actions$
             .pipe(ofType(dataChannelReady), switchMap(() => this.store
             .select(unrealFeature.selectViewportReady)
-            .pipe(filter(Truthy), take(1))), takeUntil(stop$))
+            .pipe(filter(Truthy), take(1))), takeUntil(this.destroy$))
             .subscribe(() => {
             this.send({
                 type: 'streamPreparedForUserInteraction',
@@ -2692,36 +2728,93 @@ class SignallingService extends SubService {
             return EMPTY;
         }
         Logger.log('CONNECT TO SIGNALLING');
+        // Side-effects that belong to one logical `connectToSignaling`
+        // invocation (NOT one retry attempt). Wrapping them in a `defer`
+        // makes them fire on subscribe (lazy), but only ONCE — the retry
+        // below sits INSIDE this defer's projection so re-subscribing the
+        // inner pipeline does not re-trigger these.
         return defer(() => {
-            // Preparation for WebSocket Orchestration. Inside defer so these
-            // side effects only fire once the caller actually subscribes.
             this.correlationId = generateUuid();
             this.commandTelemetryService.reset();
             this.startEstablishingConnection();
-            return this.getRegion().pipe(tap((region) => this.region.set(region ?? '')), map$1((region) => this.adaptUrlsToRegion(urlList, region)), switchMap((urls) => this.getAwsInstance(urls).pipe(take(1))), tap((awsInstance) => this.store.dispatch(setAwsInstance(awsInstance))), switchMap(({ wsUrl }) => this.connectToCirrus(wsUrl ?? '').pipe(filter(Truthy), take(1))), takeUntil(this.abort$));
-        }).pipe(
-        // Retry the whole attempt on error, advancing to the next URL each time.
-        // Note: this currently re-runs `getRegion()` on every retry — see
-        // `SIGNALLING.md` for the leak description and proposed fix. The
-        // dispatch below is observability-only so the viewer can show the
-        // retry storm in the Anomalies table without the fix being applied.
+            // Staged retry:
+            //   * `getRegion()` is pulled in front of the retry — region
+            //     discovery happens once per outer cycle.
+            //   * `connectAttempt(urls)` owns inner retry + URL rotation +
+            //     WS connect. WS/orch failures stay inside it (capped at
+            //     `INNER_RETRY_LIMIT`).
+            //   * If the inner retry exhausts, the error propagates to the
+            //     OUTER retry below which re-runs `getRegion()` (rare, real
+            //     "region down" case). Outer delay > inner so escalation is
+            //     bounded.
+            const connectCycle$ = this.getRegion().pipe(tap((region) => this.region.set(region ?? '')), map$1((region) => this.adaptUrlsToRegion(urlList, region)), switchMap((urls) => this.connectAttempt(urls)), takeUntil(this.abort$));
+            return connectCycle$.pipe(retry({
+                delay: (err, attempt) => {
+                    this.store.dispatch(signalingRetryAttempted({
+                        attempt,
+                        reason: err?.message ?? 'unknown',
+                        kind: 'region-cycle',
+                    }));
+                    Logger.info(`Outer retry (region re-pick) in ${OUTER_RETRY_DELAY}ms. Attempt# ${attempt}.`, err?.message);
+                    return timer(OUTER_RETRY_DELAY);
+                },
+            }));
+        }).pipe(takeUntil(this.abort$));
+    }
+    /**
+     * One inner cycle: rotate `urlGen` over the pool, resolve via
+     * {@link getAwsInstance}, open WS via {@link connectToCirrus},
+     * retry up to {@link INNER_RETRY_LIMIT} on any hard failure. The
+     * urlGen lives in this closure so retries advance through the
+     * pool. Exhaustion bubbles to {@link connectToSignaling}'s outer
+     * retry which re-pings the region.
+     */
+    connectAttempt(urls) {
+        const urlGen = getActiveUrl(urls);
+        return defer(() => this.getAwsInstance(`${urlGen.next().value}`)).pipe(tap((awsInstance) => this.store.dispatch(setAwsInstance(awsInstance))), switchMap(({ wsUrl }) => 
+        // ── WS-only retry tier ─────────────────────────────────────────────
+        // Tries the SAME `wsUrl` up to `WS_RETRY_PER_INSTANCE` extra times
+        // before letting the error bubble up to the outer (URL-rotating)
+        // retry. This is important because the outer retry calls
+        // `getAwsInstance(url)` again, which polls orchestration again,
+        // which causes orchestrator to RESERVE A NEW instance — the
+        // previous reservation is orphaned (server-side leak).
+        //
+        // The same-wsUrl retry catches transient WS failures (network
+        // blip, brief region unavailability, slow cold handshake) without
+        // burning a second reservation. If WS still fails after these
+        // extra attempts, the instance is genuinely unusable and we
+        // accept the cost of rotating.
+        this.connectToCirrus(wsUrl ?? '').pipe(filter(Truthy), take(1), retry({
+            count: WS_RETRY_PER_INSTANCE,
+            delay: (err, attempt) => {
+                this.store.dispatch(signalingRetryAttempted({
+                    attempt,
+                    reason: err?.message ?? 'unknown',
+                    kind: 'ws-retry',
+                }));
+                this.showStatusMessage(UnrealStatusMessage.CONNECTING_TO_SESSION);
+                Logger.info(`WS-only retry on SAME url in ${POLLING_TIME}ms. Attempt# ${attempt}.`, err?.message);
+                return timer(POLLING_TIME);
+            },
+        }))), 
+        // ── URL-rotating retry tier ─────────────────────────────────────────
+        // Triggers only when the WS-only retries above are exhausted. Each
+        // attempt advances `urlGen` → new `getAwsInstance(url)` → new
+        // orchestration poll → new AwsInstance reservation.
         retry({
+            count: INNER_RETRY_LIMIT,
             delay: (err, attempt) => {
                 this.store.dispatch(signalingRetryAttempted({
                     attempt,
                     reason: err?.message ?? 'unknown',
                     kind: 'connect',
                 }));
-                Logger.info(`Retrying Signalling Connection in ${POLLING_TIME}ms. Attempt# ${attempt}.`, err?.message);
+                this.showStatusMessage(UnrealStatusMessage.CONNECTING_TO_SESSION);
+                Logger.info(`Inner retry (WS+orch) in ${POLLING_TIME}ms. Attempt# ${attempt}.`, err?.message);
                 return timer(POLLING_TIME);
             },
-            // count: 10, // Optional: cap the number of attempts.
-        }), 
-        // abort$ sits OUTSIDE retry, so it kills the entire retry loop,
-        // not just the current attempt. Each inner createWebSocket also
-        // receives abort$ independently, so mid-connection attempts are
-        // canceled too.
-        takeUntil(this.abort$));
+        }));
     }
     startEstablishingConnection() {
         this.showStatusMessage(UnrealStatusMessage.STARTING_YOUR_SESSION);
@@ -2736,174 +2829,114 @@ class SignallingService extends SubService {
         });
     }
     /**
-     * Resolves an active AWS *signaling* instance and returns a WebSocket endpoint.
-     *
-     * The observable produced by this method is **cold** and executes inside a `defer`,
-     * so each subscription (including those triggered by `retry`) pulls the **next**
-     * URL candidate from a generator created by `getActiveUrl(urlsPool)`.
-     *
-     * ### Execution flow
-     *
-     * 1. **Telemetry** — Starts a `getSignaling` span for end-to-end timing.
-     * 2. **Candidate URL selection** — A stateful generator (`urlGen`) is created
-     *    from `urlsPool`. Each resubscription (e.g., via `retry`) advances to the next URL.
-     * 3. **Short-circuit for WS URLs** — If the picked candidate already matches
-     *    `ws://` or `wss://`, emit `{ wsUrl, pollingUrl: null, instanceName: null }`
-     *    immediately and complete (no HTTP request).
-     * 4. **Await client/view identifiers** — `this.store.select(selectClientAndViewIds)`
-     *    is tapped for logging (missing IDs) and then filtered to require both `clientId`
-     *    and `viewId` to be truthy.
-     * 5. **Single in-flight HTTP orchestration call** — Uses `exhaustMap` to issue
-     *    `GET {signalingUrl}{clientId}/{viewId}`. New `{clientId, viewId}` emissions
-     *    while the request is in flight are **ignored** until completion, preventing overlap.
-     * 6. **Per-attempt timeout** — `timeout(WS_TIMEOUT)` caps how long we wait for a response.
-     *    On timeout, the attempt errors and the outer `retry` schedules the next URL.
-     * 7. **Response validation and progress reporting** — A `filter`:
-     *    - Calls `TelemetryStop('getSignaling', { ...data, multi: true })` on receipt.
-     *    - If `data.signallingServer === ''` or `data.error`:
-     *      shows a status message, optionally dispatches `setStatusPercentSignallingServer`
-     *      with `data.info.percent`, and **throws** to fail the attempt (triggers `retry`).
-     * 8. **Mapping to `AwsInstance`** — Converts the validated orchestration payload into:
-     *    - `wsUrl`: via `httpUrlToWs(\`\${location.protocol}//\${data.signallingServer}\`)`
-     *    - `pollingUrl`: the base `signalingUrl` that succeeded
-     *    - `instanceName`: the (validated) `data.signallingServer`
-     * 9. **Retry policy** — On *any* upstream error (timeout, HTTP error, invalid payload),
-     *    `retry({ delay })`:
-     *    - Shows a “connecting” status,
-     *    - Logs the attempt number,
-     *    - Waits `WS_TIMEOUT` ms (via `timer`) and **resubscribes**, advancing `urlGen`.
-     *
-     * ### Concurrency semantics
-     *
-     * - `exhaustMap` guarantees a **single** HTTP request per attempt; later
-     *   `{clientId, viewId}` emissions are ignored until the current request completes.
-     *
-     * ### Telemetry semantics
-     *
-     * - `trackStartCommand('EXT-getSignaling')` begins before work.
-     * - `trackStopCommand('getSignaling', {...})` runs on receipt of an orchestration response.
-     *   If an attempt fails (e.g., timeout), stopping the span is the responsibility of
-     *   your telemetry layer or a `finalize` elsewhere if desired.
-     *
-     * ### Error & retry semantics
-     *
-     * - Missing/never-emitted IDs → timeout → retry with next URL.
-     * - HTTP/network error → retry with next URL.
-     * - Invalid orchestration payload (`error` set or empty `signallingServer`) → throw in
-     *   validation filter → retry with next URL.
-     * - Short-circuit WS path **does not** retry (emits once, completes).
-     *
-     * @param urlsPool - Ordered list of base URLs to probe. Retries advance through this list
-     * until a working signaling server is found. A candidate may also be a direct `ws://`/`wss://`
-     * URL to short-circuit HTTP orchestration.
-     *
-     * @returns Observable that emits exactly one {@link AwsInstance} on success and then completes.
-     * On failure, the stream errors; the built-in `retry` operator re-subscribes after `WS_TIMEOUT`
-     * and advances to the next URL candidate.
-     *
-     * @throws Emits an error within the observable chain (not a thrown synchronous exception) when:
-     * - The HTTP request fails or times out.
-     * - The orchestration response indicates an error or an empty `signallingServer`.
-     * - Any other operator in the chain surfaces an error.
-     *
-     * @remarks
-     * - The URL generator (`urlGen`) is created **outside** `defer`, so resubscriptions
-     *   advance the pool. Creating it inside `defer` would restart from the first URL each retry.
-     * - `location.protocol` is used to derive `ws` vs. `wss`. If this may run in non-browser
-     *   contexts (e.g., SSR), guard or abstract this logic.
-     * - Consider capping retries with `count` in `retry({ count, delay })` when appropriate.
-     *
-     * @example
-     * ```ts
-     * getAwsInstance(['https://signaling.example.com/', 'wss://direct.example.com'])
-     *   .subscribe({
-     *     next: ({ wsUrl }) => connect(wsUrl),
-     *     error: (e) => console.error('Unable to establish signaling:', e),
-     *   });
-     * ```
-     *
-     * @see httpUrlToWs
-     * @see selectClientAndViewIds
-     * @see setStatusPercentSignallingServer
+     * Resolve one URL to an `AwsInstance`. Dispatches to
+     * {@link directWsInstance} for `ws://` / `wss://` URLs, otherwise
+     * to {@link pollOrchestration}.
      */
-    getAwsInstance(urlsPool) {
-        this.commandTelemetryService.trackStartCommand('EXT-getSignaling');
-        // Stateful iterator over candidate URLs; retries advance this sequence.
-        const urlGen = getActiveUrl(urlsPool);
+    getAwsInstance(url) {
+        return url.match(/^ws(s?):\/\//i)
+            ? this.directWsInstance(url)
+            : this.pollOrchestration(url);
+    }
+    /**
+     * Direct `ws://` / `wss://` short-circuit — no HTTP orchestration.
+     * Waits for `clientId` and `viewId` to be truthy in the store, then
+     * emits a `Direct Connection` `AwsInstance` and completes.
+     */
+    directWsInstance(url) {
+        return this.store.select(selectClientAndViewIds).pipe(filter(({ clientId, viewId }) => !!clientId && !!viewId), take(1), map$1(() => ({
+            wsUrl: url,
+            pollingUrl: null,
+            instanceName: 'Direct Connection',
+        })));
+    }
+    /**
+     * HTTP-orchestration path. Brackets {@link pollLoop} with the
+     * `pollingStarted`/`pollingEnded` actions and the `EXT-getSignaling`
+     * telemetry span (start in `defer`, stop in `finalize` with the
+     * last response captured in the closure). Maps the final ready
+     * response to an `AwsInstance`.
+     */
+    pollOrchestration(url) {
         return defer(() => {
-            const signalingUrl = `${urlGen.next().value}`;
-            // Short-circuit if the candidate is already a WS endpoint.
-            if (signalingUrl.match(/^ws(s?):\/\//i)) {
-                return this.store.select(selectClientAndViewIds).pipe(filter(({ clientId, viewId }) => !!clientId && !!viewId), map$1(() => {
-                    return {
-                        wsUrl: signalingUrl,
-                        pollingUrl: null,
-                        instanceName: 'Direct Connection',
-                    };
-                }));
-            }
-            // Old (HTTP-polling) orchestration flow — mark the round trip so
-            // the signaling-phase timeline can show it as a distinct segment.
+            let lastResp;
             this.store.dispatch(pollingStarted());
-            return this.store.select(selectClientAndViewIds).pipe(
-            // Log missing IDs without altering the stream.
-            tap(({ clientId, viewId }) => {
+            this.commandTelemetryService.trackStartCommand('EXT-getSignaling');
+            return this.store.select(selectClientAndViewIds).pipe(tap(({ clientId, viewId }) => {
                 if (!clientId || !viewId) {
                     Logger.error('Client ID or View ID is not set');
                 }
-            }), 
-            // Only proceed when both identifiers are available.
-            filter(({ clientId, viewId }) => !!clientId && !!viewId), 
-            // Take first value
-            take(1), 
-            // Ensure a single in-flight HTTP request per attempt.
-            exhaustMap(({ clientId, viewId }) => this.httpClient.get(`${signalingUrl}${clientId}/${viewId}`)), 
-            // Bound the time spent waiting for the orchestration response.
-            timeout(POLLING_TIME), 
-            // Validate response; report progress; fail fast on invalid payloads.
-            filter((data) => {
-                this.commandTelemetryService.trackStopCommand('EXT-getSignaling', true, { ...data, multi: true });
-                if (data.signallingServer === '' || data.error) {
-                    this.showStatusMessage(data?.mm_message || 'Server not found');
-                    if (data?.info) {
-                        this.store.dispatch(setStatusPercentSignallingServer({
-                            percent: data.info.percent,
-                        }));
-                    }
-                    // Throwing here fails the attempt and activates the retry strategy.
-                    throw new Error(`Orchestration message => ${data?.mm_message || 'Polling retry'}`);
-                }
-                return true;
-            }), 
-            // Map a valid orchestration payload into the final AwsInstance.
-            map$1((data) => {
+            }), filter(({ clientId, viewId }) => !!clientId && !!viewId), take(1), switchMap(({ clientId, viewId }) => this.pollLoop(`${url}${clientId}/${viewId}`).pipe(tap((data) => {
+                lastResp = data;
+            }))), map$1((data) => ({
+                wsUrl: httpUrlToWs(`${location.protocol}//${data.signallingServer}`),
+                pollingUrl: url,
+                instanceName: data.signallingServer ?? '',
+            })), finalize(() => {
+                this.commandTelemetryService.trackStopCommand('EXT-getSignaling', true, { ...(lastResp ?? {}), multi: true });
                 this.store.dispatch(pollingEnded());
-                const wsUrl = httpUrlToWs(`${location.protocol}//${data.signallingServer}`);
-                return {
-                    wsUrl,
-                    pollingUrl: signalingUrl,
-                    instanceName: data.signallingServer ?? '',
-                };
             }));
-        }).pipe(
-        // Retry the whole attempt on error, advancing to the next URL each time.
-        retry({
-            delay: (err, attempt) => {
-                this.store.dispatch(signalingRetryAttempted({
-                    attempt,
-                    reason: err?.message ?? 'unknown',
-                    kind: 'orchestration',
+        });
+    }
+    /**
+     * Poll the SAME `url` until ready, or until HTTP 4xx says the URL
+     * is dead.
+     *
+     * | Response                                 | Class      | Action                       |
+     * | ---------------------------------------- | ---------- | ---------------------------- |
+     * | 200 `{ signallingServer: 'cirrus', ... }`| ✅ Ready   | `first()` emits, loop ends   |
+     * | 200 empty `signallingServer` (any error/info/mm_message) | ⏳ Progress | Dispatch status+percent, re-poll same URL |
+     * | HTTP 4xx (except 429)                    | ❌ Hard    | Re-throw → caller rotates URL |
+     * | HTTP 5xx / 429 / timeout / network       | ⚠️ Soft    | `EMPTY` → `repeat` same URL  |
+     *
+     * `data.error` is NOT treated as fatal — the backend reuses it for
+     * progress strings like `"Ready in ~2m 23s"`. The only fatal exits
+     * are HTTP 4xx and `abort$` upstream.
+     */
+    pollLoop(url) {
+        return defer(() => this.httpClient.get(url)).pipe(timeout(POLLING_TIME), catchError((err) => {
+            // HTTP 4xx (except 429) = the URL itself is dead → rotate.
+            const status = err?.status;
+            if (typeof status === 'number' &&
+                status >= 400 &&
+                status < 500 &&
+                status !== 429) {
+                Logger.warn(`Polling HARD error on ${url} (HTTP ${status}); rotating URL`);
+                return throwError(() => err);
+            }
+            // Everything else = soft → re-poll same URL.
+            Logger.warn(`Polling soft error on ${url} (${err?.message ?? err}); re-polling same URL`);
+            return EMPTY;
+        }), tap((data) => {
+            // Ready response is handled by `first()` below — nothing to
+            // dispatch here. Empty `signallingServer` = progress.
+            if (data.signallingServer)
+                return;
+            this.showStatusMessage(data?.mm_message || 'Server not found');
+            if (data?.info) {
+                this.store.dispatch(setStatusPercentSignallingServer({
+                    percent: data.info.percent,
                 }));
-                this.showStatusMessage(UnrealStatusMessage.CONNECTING_TO_SESSION);
-                Logger.log(`Retrying with new URL in ${POLLING_TIME}ms. Attempt# ${attempt}`, err?.message);
-                return timer(POLLING_TIME);
-            },
-            // count: 10, // Optional: cap the number of attempts.
-        }));
+            }
+        }), 
+        // Re-subscribe (= poll again) after each completed response OR
+        // after `catchError` swallowed a transient failure.
+        repeat({ delay: () => timer(POLLING_TIME) }), 
+        // Stop the poll loop as soon as we get a ready response.
+        first((data) => !!data.signallingServer));
     }
     connectToCirrus(wsUrl) {
-        this.close({ code: 1000, reason: DisconnectReason.NewConnectionAttempt });
-        return createWebSocket(wsUrl).pipe(takeUntil(this.abort$), tapLog('WS CREATED'), tap((ws) => {
+        // Wrapped in `defer` so each subscription (including ws-retry
+        // re-subscriptions from `connectAttempt`) starts a FRESH WS attempt:
+        // the previous socket is closed and a new one is created. Without
+        // this, the WS-only retry would just re-subscribe the SAME WS
+        // observable, which in production-defer'd `createWebSocket` would
+        // still create a new socket, but in tests would re-emit the same
+        // (already-errored) mock observable.
+        return defer(() => {
+            this.close({ code: 1000, reason: DisconnectReason.NewConnectionAttempt });
+            return createWebSocket(wsUrl);
+        }).pipe(takeUntil(this.abort$), tapLog('WS CREATED'), tap((ws) => {
             this.commandTelemetryService.trackStartCommand('EXT-iceCandidate');
             this.addWsHandlers(ws);
         }));
@@ -3004,7 +3037,7 @@ class SignallingService extends SubService {
      * Check if the WebSocket connection is open and ready.
      */
     isConnected() {
-        return this.ws && this.ws.readyState === WS_OPEN_STATE;
+        return !!(this.ws && this.ws.readyState === WS_OPEN_STATE);
     }
     getRegion() {
         Logger.log('Start Getting Region');
@@ -3042,6 +3075,7 @@ class WebRtcPlayerService extends SubService {
         this.actions$
             .pipe(ofType(dropPC), takeUntil(this.destroy$))
             .subscribe(() => this.pcClient?.close());
+        this.destroyRef.onDestroy(() => this.closePC());
     }
     init() {
         this.signallingSrv.onConfig$
@@ -3176,7 +3210,7 @@ class WebRtcPlayerService extends SubService {
         this.commandTelemetryService.trackStartCommand('EXT-Browser ICE connection');
         this.commandTelemetryService.trackStartCommand('EXT-Signaling state change');
         this.handlePeerConnectionEvents(this.pcClient);
-        this.disconnect$.pipe(take(1)).subscribe(() => {
+        this.disconnect$.pipe(take(1), takeUntil(this.destroy$)).subscribe(() => {
             this.closePC();
         });
     }
@@ -3383,39 +3417,39 @@ class WebRtcPlayerService extends SubService {
     }
     handlePeerConnectionEvents(pcClient) {
         fromEvent(pcClient, 'signalingstatechange')
-            .pipe(map$1(() => this.pcClient?.signalingState), takeUntil(this.disconnect$))
+            .pipe(map$1(() => this.pcClient?.signalingState), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((state) => {
             Logger.info('[Signaling state change] |', state, '|');
             this.commandTelemetryService.trackStopCommand('EXT-Signaling state change', true, { state, multi: true });
         });
         fromEvent(pcClient, 'iceconnectionstatechange')
-            .pipe(map$1(() => this.pcClient?.iceConnectionState), takeUntil(this.disconnect$))
+            .pipe(map$1(() => this.pcClient?.iceConnectionState), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((state) => {
             Logger.info('[Browser ICE connection] |', state, '|');
             this.commandTelemetryService.trackStopCommand('EXT-Browser ICE connection', true, { state, multi: true });
         });
         fromEvent(pcClient, 'icegatheringstatechange')
-            .pipe(map$1(() => this.pcClient?.iceGatheringState), takeUntil(this.disconnect$))
+            .pipe(map$1(() => this.pcClient?.iceGatheringState), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((state) => {
             Logger.info('[Browser ICE gathering] |', state, '|');
             this.commandTelemetryService.trackStopCommand('EXT-Browser ICE gathering', true, { state, multi: true });
         });
         fromEvent(pcClient, 'connectionstatechange')
-            .pipe(map$1(() => this.pcClient?.connectionState), takeUntil(this.disconnect$))
+            .pipe(map$1(() => this.pcClient?.connectionState), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((state) => {
             Logger.info('[RTCPeerConnection state] |', state, '|');
         });
         fromEvent(pcClient, 'icecandidate')
-            .pipe(map$1((e) => e.candidate), filter(Truthy), tap$1((candidate) => Logger.info('[Browser ICE candidate]', '| Type=', candidate.type, '| Protocol=', candidate.protocol, '| Address=', candidate.address, '| Port=', candidate.port, '|')), takeUntil(this.disconnect$))
+            .pipe(map$1((e) => e.candidate), filter(Truthy), tap$1((candidate) => Logger.info('[Browser ICE candidate]', '| Type=', candidate.type, '| Protocol=', candidate.protocol, '| Address=', candidate.address, '| Port=', candidate.port, '|')), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((candidate) => this.signallingSrv.send({ type: 'iceCandidate', candidate }));
         // When the server creates the DataChannel (server-offer flow),
         // we receive it here via the 'datachannel' event
         fromEvent(pcClient, 'datachannel')
-            .pipe(tap$1((e) => Logger.info(`[DATACHANNEL] Received remote DC: label="${e.channel.label}" id=${e.channel.id} protocol="${e.channel.protocol}" ordered=${e.channel.ordered}`)), map$1((e) => e.channel), takeUntil(this.disconnect$))
+            .pipe(tap$1((e) => Logger.info(`[DATACHANNEL] Received remote DC: label="${e.channel.label}" id=${e.channel.id} protocol="${e.channel.protocol}" ordered=${e.channel.ordered}`)), map$1((e) => e.channel), takeUntil(merge(this.disconnect$, this.destroy$)))
             .subscribe((datachannel) => {
             this.dcClient = this.setupDataChannelCallbacks(datachannel);
         });
-        const onTrack$ = fromEvent(pcClient, 'track').pipe(takeUntil(this.disconnect$), filter((e) => !!e.track), tap$1((e) => Logger.info('Got track - ' +
+        const onTrack$ = fromEvent(pcClient, 'track').pipe(takeUntil(merge(this.disconnect$, this.destroy$)), filter((e) => !!e.track), tap$1((e) => Logger.info('Got track - ' +
             e.track.kind +
             ' id=' +
             e.track.id +
@@ -3496,7 +3530,7 @@ class WebRtcPlayerService extends SubService {
             fromEvent(datachannel, 'close')
                 .pipe(
             // Only dispatch disconnect if not already reconnecting to avoid infinite loops
-            filter(() => !this.isReconnecting()), take(1))
+            filter(() => !this.isReconnecting()), take(1), takeUntil(this.destroy$))
                 .subscribe((e) => {
                 Logger.warn(`[DATACHANNEL] Data channel disconnected: ${datachannel.label}(${datachannel.id})`, e);
                 this.store.dispatch(disconnectStream({
@@ -3505,7 +3539,7 @@ class WebRtcPlayerService extends SubService {
                 }));
             });
             fromEvent(datachannel, 'error')
-                .pipe(takeUntil(this.disconnect$))
+                .pipe(takeUntil(merge(this.disconnect$, this.destroy$)))
                 .subscribe((e) => {
                 const message = `[DATACHANNEL] Data channel "${datachannel.label}" error. id:${datachannel.id}`;
                 Logger.error(message, e);
@@ -3513,7 +3547,7 @@ class WebRtcPlayerService extends SubService {
             fromEvent(datachannel, 'open')
                 .pipe(tap$1(() => {
                 Logger.info(`[DATACHANNEL] Data channel "${datachannel.label}" connected. id:${datachannel.id}`);
-            }), takeUntil(this.disconnect$))
+            }), takeUntil(merge(this.disconnect$, this.destroy$)))
                 .subscribe(() => {
                 this.commandTelemetryService.trackStopCommand('EXT-DataChannel Connection');
                 this.onDataChannelConnected();
@@ -3526,7 +3560,7 @@ class WebRtcPlayerService extends SubService {
                 `[DATACHANNEL] Message received on "${datachannel.label}" id=${datachannel.id}, byteCode=${view[0]}, size=${view.byteLength}`,
               );
             }),*/
-            map$1((e) => e.data), takeUntil(this.disconnect$))
+            map$1((e) => e.data), takeUntil(merge(this.disconnect$, this.destroy$)))
                 .subscribe((data) => this.onDataChannelMessage$.next(data));
             return datachannel;
         }
@@ -4025,25 +4059,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImpo
                 }]
         }] });
 
-class UnrealCommunicatorService {
+class UnrealCommunicatorService extends SubService {
     constructor() {
-        this.store = inject(Store);
-        this.actions$ = inject(Actions);
+        super();
         this.commandTelemetryService = inject(CommandTelemetryService);
         this.webRtcPlayerService = inject(WebRtcPlayerService);
         this.unrealConfig = inject(UNREAL_CONFIG, { optional: true });
-        this.destroyRef = inject(DestroyRef);
-        this.destroy$ = new Subject();
         this.cirrusConnected = this.store.selectSignal(unrealFeature.selectCirrusConnected);
         this.afkIgnoredCommands = new Set(['executeConsoleCommand']);
         this.skipAfkReset = false;
         // Throttle: input events fire 60-200x/sec, but AFK timeouts are measured in
         // seconds. Leading-edge throttle dispatches once, then suppresses for 1s.
         this.resetAfk$ = new Subject();
-        this.destroyRef.onDestroy(() => {
-            this.destroy$.next();
-            this.destroy$.complete();
-        });
         this.resetAfk$
             .pipe(throttleTime(1000), takeUntil$1(this.destroy$))
             .subscribe(() => this.store.dispatch(resetAfk()));
@@ -4065,12 +4092,6 @@ class UnrealCommunicatorService {
             this.requestQualityControl();
         });
     }
-    destroy() {
-        this.destroy$.next();
-        // Recreate the Subject so it remains usable for the next session.
-        // A completed Subject silently ignores all future next/complete calls.
-        this.destroy$ = new Subject();
-    }
     sendCommandToUnreal(data) {
         if (this.isPlaywrightMode()) {
             return;
@@ -4655,15 +4676,21 @@ class RegionsPingService {
     constructor() {
         this.httpClient = inject(HttpClient);
         this.store = inject(Store);
-        this.unrealInitialConfig = inject(UNREAL_CONFIG, { optional: true });
+        this.unrealConfig = inject(UNREAL_CONFIG, { optional: true });
+        this.destroyRef = inject(DestroyRef);
+        // Aborted when the injector is destroyed. Forwarded into every
+        // `startPinging` call's winnerController so in-flight fetches cancel
+        // immediately on route exit instead of running to natural completion.
+        this.destroyController = new AbortController();
         this.config = {
             ping_count: 2,
             ping_timeout: 2000,
             max_parallel_requests: 10,
             bust_cache: true,
         };
+        this.destroyRef.onDestroy(() => this.destroyController.abort());
     }
-    getFastest(regionListUrl = this.unrealInitialConfig?.regionsPingUrl || '') {
+    getFastest(regionListUrl = this.unrealConfig?.regionsPingUrl || '') {
         // Self-announce every lifecycle waypoint of the region-discovery
         // flow (start / providers-fetched / resolved). The final
         // `regionResolved` forwards the winner's full ping-sample array
@@ -4680,15 +4707,32 @@ class RegionsPingService {
         const defaultTimeout = providers.timeout ?? this.config.ping_timeout;
         return from(this.startPinging(providers.regions, defaultTimeout));
     }
-    getProviders(regionListUrl = this.unrealInitialConfig?.regionsPingUrl || '') {
+    getProviders(regionListUrl = this.unrealConfig?.regionsPingUrl || '') {
         return this.httpClient.get(regionListUrl);
     }
     async startPinging(endpoints, defaultTimeout) {
         const semaphore = new Semaphore(this.config.max_parallel_requests);
+        // Shared "stop" signal. Aborted when EITHER:
+        //   - one region finishes successfully (winner found → cancel losers); OR
+        //   - the service's injector is destroyed (route exit → cancel everything).
+        // Without this, losing regions keep pinging to their own `ping_timeout`,
+        // generating up to `(endpoints.length - 1) × ping_count` wasted requests
+        // every time `getFastest` runs, and in-flight fetches outlive the route.
+        const winnerController = new AbortController();
+        const destroySignal = this.destroyController.signal;
+        let onDestroyAbort;
+        if (destroySignal.aborted) {
+            // Service already destroyed — bail every task synchronously.
+            winnerController.abort(destroySignal.reason);
+        }
+        else {
+            onDestroyAbort = () => winnerController.abort(destroySignal.reason);
+            destroySignal.addEventListener('abort', onDestroyAbort, { once: true });
+        }
         const tasks = endpoints.map(async ({ region_code, url, timeout }) => {
             await semaphore.acquire();
             try {
-                const result = await this.checkLatency(url, timeout ?? defaultTimeout);
+                const result = await this.checkLatency(url, timeout ?? defaultTimeout, winnerController.signal);
                 if (result.length < 2)
                     throw new Error('insufficient pings');
                 return { region_code, result };
@@ -4703,11 +4747,26 @@ class RegionsPingService {
         catch {
             return null;
         }
+        finally {
+            // Cancel losing in-flight pings. Safe to call on success (we already
+            // captured the winner) AND on all-failed (no-op, all tasks settled).
+            winnerController.abort();
+            // Detach the destroy listener so it doesn't linger on the long-lived
+            // destroyController.signal across multiple `getFastest` invocations.
+            if (onDestroyAbort) {
+                destroySignal.removeEventListener('abort', onDestroyAbort);
+            }
+        }
     }
-    async checkLatency(endpoint, timeout) {
+    async checkLatency(endpoint, timeout, abortSignal) {
         const pingResults = [];
         const sep = endpoint.includes('?') ? '&' : '?';
         for (let i = 0; i < this.config.ping_count; i++) {
+            // Bail out as soon as another region's task has won — no point
+            // burning further `ping_timeout` budget here.
+            if (abortSignal?.aborted) {
+                break;
+            }
             const startTime = performance.now();
             try {
                 await this.fetchWithTimeout(this.config.bust_cache
@@ -4721,7 +4780,7 @@ class RegionsPingService {
                         Expires: '0',
                     },
                     credentials: 'omit',
-                }, timeout);
+                }, timeout, abortSignal);
             }
             catch {
                 // intentional: finally pushes the elapsed time as the latency sample
@@ -4733,18 +4792,31 @@ class RegionsPingService {
         }
         return pingResults;
     }
-    async fetchWithTimeout(url, options = {}, timeout) {
+    async fetchWithTimeout(url, options = {}, timeout, abortSignal) {
         const controller = new AbortController();
         options.signal = controller.signal;
+        // Forward an external abort into our local controller so a winner-found signal cancels the in-flight `fetch` immediately. If the
+        // external signal is already aborted, abort synchronously before
+        // even starting the fetch.
+        let onExternalAbort;
+        if (abortSignal) {
+            if (abortSignal.aborted) {
+                controller.abort(abortSignal.reason);
+            }
+            else {
+                onExternalAbort = () => controller.abort(abortSignal.reason);
+                abortSignal.addEventListener('abort', onExternalAbort, { once: true });
+            }
+        }
         const timeoutId = setTimeout(() => controller.abort(new DOMException('Request timed out', 'TimeoutError')), timeout);
         try {
-            const response = await fetch(url, options);
-            clearTimeout(timeoutId);
-            return response;
+            return await fetch(url, options);
         }
-        catch (error) {
+        finally {
             clearTimeout(timeoutId);
-            throw error;
+            if (abortSignal && onExternalAbort) {
+                abortSignal.removeEventListener('abort', onExternalAbort);
+            }
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: RegionsPingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -4752,7 +4824,7 @@ class RegionsPingService {
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: RegionsPingService, decorators: [{
             type: Injectable
-        }] });
+        }], ctorParameters: () => [] });
 
 class StreamStatusTelemetryService extends SubService {
     constructor() {
@@ -5711,7 +5783,7 @@ class AnalyticsService extends SubService {
         });
     }
     monitorMouse() {
-        const stop$ = this.#stopMouse$.asObservable();
+        const stop$ = merge(this.#stopMouse$, this.destroy$);
         const element = document.getElementById('streamingVideo');
         if (!element) {
             return;
@@ -7047,5 +7119,5 @@ function provideUnrealModule() {
  * Generated bundle index. Do not edit.
  */
 
-export { AFKService, AfkTimeoutModalComponent, AggregatorService, AnalyticsService, AnswerHandler, CONSOLE_COMMAND_DISABLE_MESSAGES, CONSOLE_COMMAND_ENABLE_MESSAGES, CONSOLE_COMMAND_PIXEL_QUALITY, CommandTelemetryService, ConfigHandler, ConsoleExtensionsService, ControlScheme, DATA_CHANNEL_CONNECTION_TIMEOUT, DEBOUNCE_TO_MANY_RESIZE_CALLS, DEFAULT_AFK_TIMEOUT, DEFAULT_AFK_TIMEOUT_PERIOD, DEFAULT_RECONNECT_DELAY_MS, DEFAULT_RECONNECT_ENABLED, DEFAULT_RECONNECT_MAX_ATTEMPTS, DEFAULT_RECONNECT_ON_DATACHANNEL_CLOSE, DEFAULT_RECONNECT_ON_ICE_FAILURE, DESTROY_DISCONNECT_REASONS, DataFlowMonitor, DevModeService, DisconnectReason, FULL_HD_HEIGHT, FULL_HD_WIDTH, FileHandlerService, FileReceiverService, FilterSettingsComponent, FpsMonitorService, FreezeFrameComponent, FreezeFrameService, IceCandidateHandler, ImageLoadingSrcComponent, InputOptions, InputService, InstanceReadyHandler, InstanceReservedHandler, IntroSrcComponent, KalmanFilter1D, LatencyTimings, LoadingProgressService, LowBandwidthDetectorComponent, LowBandwidthModalComponent, MINIMAL_FPS, MIN_CONTAINER_SIZE, MessageType, MouseButton, MouseButtonsMask, OnCloseHandler, OnErrorHandler, OnMessageHandler, OnOpenHandler, OrchestrationMessageTypes, POLLING_TIME, PingHandler, PlayerCountHandler, RegionsPingService, SAME_SIZE_THRESHOLD, SCREEN_LOCKER_CONTAINER_ID, SIGNALLING_PERCENT_VALUE, SSInfoHandler, STREAMING_AUDIO_ID, STREAMING_VIDEO_ID, SafePipe, SignallingService, SpecialKeyCodes, StatGraphComponent, StreamStatusTelemetryService, StreamStatusTelemetryService2, SubService, ToClientMessage, UNREAL_CONFIG, UnrealCallbackService, UnrealCommunicatorService, UnrealEffects, UnrealSceneComponent, UnrealStatusMessage, VideoService, VideoStatsComponent, WSCloseCode_CIRRUS_ABNORMAL_CLOSURE, WSCloseCode_CIRRUS_MAX_PLAYERS_ERROR, WSCloseCode_CIRRUS_PLAYER_DISCONNECTED, WSCloseCode_CIRRUS_STREAMER_KIKED_PLAYER, WSCloseCode_FORCE_CIRRUS_CLOSE, WSCloseCode_NORMAL_AFK_TIMEOUT, WSCloseCode_NORMAL_CLOSURE, WSCloseCode_NORMAL_MANUAL_DISCONNECT, WSCloseCode_UNKNOWN, WSCloseCodes, WS_OPEN_STATE, WS_TIMEOUT, WebRtcPlayerService, WebrtcErrorModalComponent, abortEstablishingConnection, answerSent, changeStatusMainVideoOnScene, changeStreamResolutionAction, commandCompleted, commandStarted, dataChannelConnected, dataChannelReady, decodeData, destroyRemoteConnections, destroyUnrealScene, disconnectStream, dispatchResize, dropConnection, dropDC, dropPC, floatToPercents, floatToSmoothPercents, forceResizeViewport, fromResizeObserver, getActiveUrl, getImageFromVideoStream, getResizeStudioValues, getResizeValuesUniversal, getRtcErrorMessage, iceConnectionFailed, initSignalling, instanceReady, keepMaxUntilReset, makeEven, pollingEnded, pollingStarted, provideUnrealModule, qpToQuality, reconnectPeer, reconnectPeerFailed, reconnectPeerSuccess, regionPingFetchEnd, regionPingFetchStart, regionResolved, resetAfk, resetConfig, resetDataChannelForReconnect, resetIntroSrc, resetUserInactivityTimeout, resetWarnTimeout, saveAnalyticsEvent, selectCirrusConnectionId, selectClientAndViewIds, selectCommandProgress, selectFreezeFrameCombinedDataUrl, selectFreezeFrameDataUrl, selectFreezeFrameDataUrlFromVideo, selectFreezeFrameProgressMessageFromVideo, selectIsAutostart, selectIsExistMatchUrls, selectIsFreezeFrameLoading, selectIsFullyConnected, selectIsLoaderScreenVisible, selectIsVideoPlayingAndDataChannelConnected, selectShowLoader, selectShowReconnectPopup, selectSignalingParameters, selectStreamConfig, selectTotalProgress, selectUserInactivityDetected, selectWarnTimeout, setAfkTimerCountdown, setAfkTimerHide, setAfkTimerVisible, setAwsInstance, setCirrusConnected, setCirrusDisconnected, setConfig, setEstablishingConnection, setFreezeFrame, setFreezeFrameFromVideo, setIntroImageSrc, setIntroVideoSrc, setLoadingImageSrc, setLoopBackCommandIsCompleted, setMaxFps, setOrchestrationContext, setOrchestrationMessage, setOrchestrationParameters, setOrchestrationProgress, setSignalingName, setStatusMessage, setStatusPercentSignallingServer, setStreamClientCompanyId, setStreamViewId, setUnrealPlaywrightConfig, setUserInactivityTimeout, setViewportNotReady, setViewportReady, showLoadingProgress, showResumeStreamPopup, showUnrealErrorMessage, showUserInactivityTimeoutPopup, signalingRetryAttempted, smoothTransition, startStream, trackMixpanelEvent, trackTelemetryData, unrealCommandCallback, unrealFeature, unrealReducer, updateCirrusInfo, videoAdaptedToContainer, videoStreamInitialized };
+export { AFKService, AfkTimeoutModalComponent, AggregatorService, AnalyticsService, AnswerHandler, CONSOLE_COMMAND_DISABLE_MESSAGES, CONSOLE_COMMAND_ENABLE_MESSAGES, CONSOLE_COMMAND_PIXEL_QUALITY, CommandTelemetryService, ConfigHandler, ConsoleExtensionsService, ControlScheme, DATA_CHANNEL_CONNECTION_TIMEOUT, DEBOUNCE_TO_MANY_RESIZE_CALLS, DEFAULT_AFK_TIMEOUT, DEFAULT_AFK_TIMEOUT_PERIOD, DEFAULT_RECONNECT_DELAY_MS, DEFAULT_RECONNECT_ENABLED, DEFAULT_RECONNECT_MAX_ATTEMPTS, DEFAULT_RECONNECT_ON_DATACHANNEL_CLOSE, DEFAULT_RECONNECT_ON_ICE_FAILURE, DESTROY_DISCONNECT_REASONS, DataFlowMonitor, DevModeService, DisconnectReason, FULL_HD_HEIGHT, FULL_HD_WIDTH, FileHandlerService, FileReceiverService, FilterSettingsComponent, FpsMonitorService, FreezeFrameComponent, FreezeFrameService, INNER_RETRY_LIMIT, IceCandidateHandler, ImageLoadingSrcComponent, InputOptions, InputService, InstanceReadyHandler, InstanceReservedHandler, IntroSrcComponent, KalmanFilter1D, LatencyTimings, LoadingProgressService, LowBandwidthDetectorComponent, LowBandwidthModalComponent, MINIMAL_FPS, MIN_CONTAINER_SIZE, MessageType, MouseButton, MouseButtonsMask, OUTER_RETRY_DELAY, OnCloseHandler, OnErrorHandler, OnMessageHandler, OnOpenHandler, OrchestrationMessageTypes, POLLING_TIME, PingHandler, PlayerCountHandler, RegionsPingService, SAME_SIZE_THRESHOLD, SCREEN_LOCKER_CONTAINER_ID, SIGNALLING_PERCENT_VALUE, SSInfoHandler, STREAMING_AUDIO_ID, STREAMING_VIDEO_ID, SafePipe, SignallingService, SpecialKeyCodes, StatGraphComponent, StreamStatusTelemetryService, StreamStatusTelemetryService2, SubService, ToClientMessage, UNREAL_CONFIG, UnrealCallbackService, UnrealCommunicatorService, UnrealEffects, UnrealSceneComponent, UnrealStatusMessage, VideoService, VideoStatsComponent, WSCloseCode_CIRRUS_ABNORMAL_CLOSURE, WSCloseCode_CIRRUS_MAX_PLAYERS_ERROR, WSCloseCode_CIRRUS_PLAYER_DISCONNECTED, WSCloseCode_CIRRUS_STREAMER_KIKED_PLAYER, WSCloseCode_FORCE_CIRRUS_CLOSE, WSCloseCode_NORMAL_AFK_TIMEOUT, WSCloseCode_NORMAL_CLOSURE, WSCloseCode_NORMAL_MANUAL_DISCONNECT, WSCloseCode_UNKNOWN, WSCloseCodes, WS_OPEN_STATE, WS_RETRY_PER_INSTANCE, WS_TIMEOUT, WebRtcPlayerService, WebrtcErrorModalComponent, abortEstablishingConnection, answerSent, changeStatusMainVideoOnScene, changeStreamResolutionAction, commandCompleted, commandStarted, dataChannelConnected, dataChannelReady, decodeData, destroyRemoteConnections, destroyUnrealScene, disconnectStream, dispatchResize, dropConnection, dropDC, dropPC, floatToPercents, floatToSmoothPercents, forceResizeViewport, fromResizeObserver, getActiveUrl, getImageFromVideoStream, getResizeStudioValues, getResizeValuesUniversal, getRtcErrorMessage, iceConnectionFailed, initSignalling, instanceReady, keepMaxUntilReset, makeEven, pollingEnded, pollingStarted, provideUnrealModule, qpToQuality, reconnectPeer, reconnectPeerFailed, reconnectPeerSuccess, regionPingFetchEnd, regionPingFetchStart, regionResolved, resetAfk, resetConfig, resetDataChannelForReconnect, resetIntroSrc, resetUserInactivityTimeout, resetWarnTimeout, saveAnalyticsEvent, selectCirrusConnectionId, selectClientAndViewIds, selectCommandProgress, selectFreezeFrameCombinedDataUrl, selectFreezeFrameDataUrl, selectFreezeFrameDataUrlFromVideo, selectFreezeFrameProgressMessageFromVideo, selectIsAutostart, selectIsExistMatchUrls, selectIsFreezeFrameLoading, selectIsFullyConnected, selectIsLoaderScreenVisible, selectIsVideoPlayingAndDataChannelConnected, selectShowLoader, selectShowReconnectPopup, selectSignalingParameters, selectStreamConfig, selectTotalProgress, selectUserInactivityDetected, selectWarnTimeout, setAfkTimerCountdown, setAfkTimerHide, setAfkTimerVisible, setAwsInstance, setCirrusConnected, setCirrusDisconnected, setConfig, setEstablishingConnection, setFreezeFrame, setFreezeFrameFromVideo, setIntroImageSrc, setIntroVideoSrc, setLoadingImageSrc, setLoopBackCommandIsCompleted, setMaxFps, setOrchestrationContext, setOrchestrationMessage, setOrchestrationParameters, setOrchestrationProgress, setSignalingName, setStatusMessage, setStatusPercentSignallingServer, setStreamClientCompanyId, setStreamViewId, setUnrealPlaywrightConfig, setUserInactivityTimeout, setViewportNotReady, setViewportReady, showLoadingProgress, showResumeStreamPopup, showUnrealErrorMessage, showUserInactivityTimeoutPopup, signalingRetryAttempted, smoothTransition, startStream, trackMixpanelEvent, trackTelemetryData, unrealCommandCallback, unrealFeature, unrealReducer, updateCirrusInfo, videoAdaptedToContainer, videoStreamInitialized };
 //# sourceMappingURL=3dsource-angular-unreal-module.mjs.map