@3dsource/angular-unreal-module 0.0.123-dev.0 → 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, share as share$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
@@ -1672,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);
         }
     }
     /**
@@ -1694,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() {
@@ -2202,11 +2226,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImpo
             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;
@@ -2214,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() {
@@ -2654,32 +2670,35 @@ 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.
-        // `share()` deduplicates the tap side effect across all takeUntil(abort$)
-        // subscribers — close() runs once per action, not once per subscriber.
-        this.abort$ = this.actions$.pipe(ofType(abortEstablishingConnection), tap(() => this.close({
-            code: 1000,
-            reason: DisconnectReason.AbortEstablishingConnection,
-        })), share$1());
+        // 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();
-        this.destroyRef.onDestroy(() => this.close({
-            code: 1000,
-            reason: DisconnectReason.AbortEstablishingConnection,
-        }));
     }
     init() {
         if (this.unrealConfig?.playwright) {
             return;
         }
         this.setHandlersFromStream();
-        // Subscriptions persist across sessions (use destroy$ only, not abort$).
-        // dataChannelReady is a per-session event; abort$ fires on every
-        // destroyUnrealScene, so binding to it kills the subs after the first
-        // session within a persistent injector. send() is already a no-op when
-        // the WS is closed, so there's no risk of leaking messages during teardown.
+        // 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(this.destroy$))
             .subscribe(() => {
@@ -2709,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(merge(this.abort$, this.destroy$)));
-        }).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. destroy$ is the defense-in-depth
-        // signal for injector teardown — if the abort action chain doesn't
-        // run for any reason, destroy$ still stops the loop.
-        takeUntil(merge(this.abort$, this.destroy$)));
+        }));
     }
     startEstablishingConnection() {
         this.showStatusMessage(UnrealStatusMessage.STARTING_YOUR_SESSION);
@@ -2753,177 +2829,117 @@ 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(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`.
      */
-    getAwsInstance(urlsPool) {
-        this.commandTelemetryService.trackStartCommand('EXT-getSignaling');
-        // Stateful iterator over candidate URLs; retries advance this sequence.
-        const urlGen = getActiveUrl(urlsPool);
+    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(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);
-        }), takeUntil(merge(this.abort$, this.destroy$)));
+        }));
     }
     addWsHandlers(ws) {
         ws.onmessage = OnMessageHandler.bind(this);
@@ -2942,9 +2958,6 @@ class SignallingService extends SubService {
      */
     close(data) {
         const { code, reason } = data;
-        // Signal "no answer in flight anymore" to any subscriber that observes
-        // raw emissions (today's subscribers filter Truthy, but the Subject's
-        // `| null` type is the contract — keep it honored).
         this.onWebRtcAnswer$.next(null);
         this.orchestrationRetrySub?.unsubscribe();
         if (this.ws) {
@@ -4046,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()));
@@ -4670,20 +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 on injector destruction. Cascades through every in-flight
-        // fetch so background pings stop the moment the service dies.
-        this.destroyAbort = new AbortController();
+        // 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.destroyAbort.abort());
+        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
@@ -4700,31 +4707,34 @@ 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) {
-        // Two-tier cancellation:
-        //   - destroyAbort: service teardown (injector destroy)
-        //   - winnerAbort: first successful region resolves Promise.any
-        // Both aborts cascade into every in-flight fetch so losing pings stop
-        // immediately instead of running their full ping_count × timeout budget.
-        const winnerAbort = new AbortController();
-        const stopSignal = AbortSignal.any([
-            winnerAbort.signal,
-            this.destroyAbort.signal,
-        ]);
         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 {
-                if (stopSignal.aborted) {
-                    throw new Error('aborted');
-                }
-                const result = await this.checkLatency(url, timeout ?? defaultTimeout, stopSignal);
-                if (result.length < 2) {
+                const result = await this.checkLatency(url, timeout ?? defaultTimeout, winnerController.signal);
+                if (result.length < 2)
                     throw new Error('insufficient pings');
-                }
                 return { region_code, result };
             }
             finally {
@@ -4732,18 +4742,31 @@ class RegionsPingService {
             }
         });
         try {
-            const winner = await Promise.any(tasks);
-            winnerAbort.abort();
-            return winner;
+            return await Promise.any(tasks);
         }
         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, externalSignal) {
+    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
@@ -4757,7 +4780,7 @@ class RegionsPingService {
                         Expires: '0',
                     },
                     credentials: 'omit',
-                }, timeout, externalSignal);
+                }, timeout, abortSignal);
             }
             catch {
                 // intentional: finally pushes the elapsed time as the latency sample
@@ -4769,20 +4792,31 @@ class RegionsPingService {
         }
         return pingResults;
     }
-    async fetchWithTimeout(url, options = {}, timeout, externalSignal) {
+    async fetchWithTimeout(url, options = {}, timeout, abortSignal) {
         const controller = new AbortController();
-        options.signal = externalSignal
-            ? AbortSignal.any([controller.signal, externalSignal])
-            : controller.signal;
+        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 }); }
@@ -7085,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