@3dsource/angular-unreal-module 0.0.163 → 0.0.164

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

@@ -157,7 +157,6 @@ export interface RequestReservation extends InstanceMessageBase {
 }
 */
 const OrchestrationMessageTypes = {
-    ping: 'ping',
     error: 'error',
     offer: 'offer',
     answer: 'answer',
@@ -171,8 +170,6 @@ const OrchestrationMessageTypes = {
     instanceReady: 'instanceReady',
     p2pEstablished: 'p2pEstablished',
     instanceReserved: 'instanceReserved',
-    playerDisconnected: 'playerDisconnected',
-    streamerDisconnected: 'streamerDisconnected',
     interruptClientStream: 'interruptClientStream',
 };
 
@@ -225,6 +222,14 @@ const OUTER_RETRY_DELAY = POLLING_TIME * 2;
 // 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;
+// Bound on `requestCirrusViaSocket`: how long the orchestration control
+// socket may stay silent between `requestStream` and `instanceReady`.
+// The orchestration itself reports an `eta` (default 150 s in
+// `InstanceReservedHandler`) for a cold machine, so `WS_TIMEOUT` (6 s) is
+// far too short here — this is a provisioning wait, not a handshake.
+// On expiry the request fails like any other, so `connectAttempt`'s
+// URL-rotating tier asks a different orchestration URL for a new machine.
+const INSTANCE_READY_TIMEOUT = 180_000;
 const WS_OPEN_STATE = 1;
 const DEFAULT_AFK_TIMEOUT_PERIOD = 15;
 const DEFAULT_AFK_TIMEOUT = 300; // 5 minutes
@@ -479,7 +484,7 @@ const initialState = {
 };
 const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScene, (state, { isVideoPlaying }) => {
     return { ...state, isVideoPlaying };
-}), on(setAwsInstance, (state, { instanceName, wsUrl, pollingUrl, streamRequestId }) => {
+}), on(setAwsInstance, (state, { instanceName, wsUrl, pollingUrl, streamRequestId, kind }) => {
     return {
         ...state,
         awsInstance: {
@@ -488,7 +493,11 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
             wsUrl,
             pollingUrl,
             streamRequestId,
-            progressComplete: 0,
+            kind: kind ?? state.awsInstance.kind,
+            // In the socket flow this action lands only once `instanceReady`
+            // arrived, i.e. the machine IS provisioned — resetting to 0 here would
+            // throw the bar back to the start right at the end of that phase.
+            progressComplete: kind === 'socket' ? 1 : 0,
         },
     };
 }), on(setViewportReady, (state) => {
@@ -594,6 +603,10 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
             instanceName,
             streamRequestId,
             eta,
+            // `instanceReserved` exists only in the socket flow, and it arrives
+            // BEFORE `setAwsInstance` — so this is where the flow becomes known,
+            // early enough for `selectTotalProgress` to use the eta-driven bar.
+            kind: 'socket',
         },
     };
 }), on(setOrchestrationProgress, (state, { progressComplete }) => {
@@ -780,13 +793,16 @@ function InstanceReadyHandler(msg) {
         Logger.warn('instanceReady received without payload — ignoring');
         return;
     }
+    if (!payload.originInstanceUri) {
+        Logger.warn('instanceReady without originInstanceUri — ignoring');
+        return;
+    }
     // Emit for observability (telemetry) and store the stream-machine coords.
     this.store.dispatch(instanceReady(payload));
-    // Open the SECOND socket directly to the stream machine and route the whole
-    // WebRTC signalling through it. The orchestration socket stays open for
-    // control/lifecycle. `streamRequestId` is handed over so the stream machine's
-    // Cirrus reuses the orchestration-issued connection id.
-    this.connectToStreamMachine(payload.originInstanceUri, payload.streamRequestId);
+    // This is the answer `requestCirrusViaSocket` is waiting for: the Cirrus
+    // address (`originInstanceUri`) plus the connection id to hand it. The socket
+    // itself is opened by the shared `connectToCirrus`, not here.
+    this.onInstanceReady$.next(payload);
 }
 
 function InstanceReservedHandler(msg) {
@@ -797,15 +813,6 @@ function InstanceReservedHandler(msg) {
     }));
 }
 
-function PingHandler() {
-    // Reply pong on the active signalling socket (stream socket in the new flow,
-    // relay socket in the old polling flow).
-    this.sendPlayerSignal(JSON.stringify({
-        type: 'pong',
-        source: 'front',
-    }));
-}
-
 function PlayerCountHandler(msg) {
     Logger.log(msg);
 }
@@ -861,9 +868,16 @@ function OnMessageHandler(e) {
     }
 }
 
+/**
+ * Open handler of the CIRRUS socket only (`addWsHandlers`), so
+ * `setCirrusConnected` now means what it says. It used to also send
+ * `requestStream` here, which made the flag fire on the orchestration control
+ * socket — a whole provisioning wait (`eta`, ~150 s) before any Cirrus existed.
+ * `requestStream` belongs to the control socket and is sent by
+ * `requestCirrusViaSocket`.
+ */
 function OnOpenHandler() {
     this.store.dispatch(setCirrusConnected());
-    this.sendRequestStream();
 }
 
 /**
@@ -1183,7 +1197,9 @@ const selectSignalingParameters = createSelector(unrealFeature.selectSsData, unr
         info.push(`Unreal App Version: ${data.streamerVersion}`);
         info.push(`APP: ${data.streamPath}${data.streamApp}`);
     }
-    info.push(`Polling: ${instance.pollingUrl}`);
+    // The endpoint that handed us the Cirrus address: an HTTP polling URL in one
+    // flow, a `wss://` orchestration URL in the other.
+    info.push(`Orchestration: ${instance.pollingUrl}`);
     info.push(`WS: ${instance.wsUrl}`);
     return info.join('<br>');
 });
@@ -1203,13 +1219,15 @@ const selectIsLoaderScreenVisible = createSelector(selectIsFullyConnected, (full
  */
 const selectTotalProgress = createSelector(unrealFeature.selectStatusPercentSignallingServer, selectCommandProgress, unrealFeature.selectAwsInstance, unrealFeature.selectDataChannelConnected, (statusPercentSignallingServer, commandProgress, awsInstance, dataChannelConnected) => {
     const SIGNALLING_MAX = SIGNALLING_PERCENT_VALUE / 100;
-    const ORCHESTRATION_WS_PATTERN = /^wss:\/\/orchestration-websocket/i;
-    const isNewOrchestration = ORCHESTRATION_WS_PATTERN.test(awsInstance?.wsUrl ?? '');
+    // Stated by the service (`AwsInstance.kind`), not sniffed from the hostname.
+    // In the socket flow it is set by `instanceReserved` — i.e. before
+    // `setAwsInstance` — so the eta-driven bar is picked up from the start of
+    // the provisioning wait.
+    const isNewOrchestration = awsInstance?.kind === 'socket';
     // Once the data channel is connected, signaling is fully complete (1.0) —
     // regardless of orchestration type. This is what makes an ADOPTED stream
-    // (whose wsUrl is the machine host, not the orchestration-websocket URL,
-    // and which never set `statusPercentSignallingServer`) correctly show the
-    // whole first phase done instead of stalling near the command-only value.
+    // (which never set `statusPercentSignallingServer`) correctly show the whole
+    // first phase done instead of stalling near the command-only value.
     // Otherwise: new orchestration reports 0–1 progress; legacy uses the
     // polling percent.
     const signalingProgress = dataChannelConnected
@@ -1832,10 +1850,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.0", ngImpor
         }], ctorParameters: () => [] });
 
 function StreamerListHandler(msg) {
-    // `subscribe` is player signalling — reply on the active signalling socket
-    // (stream socket in the new flow, relay socket in the old polling flow),
-    // matching the socket the `streamerList` arrived on.
-    this.sendPlayerSignal(JSON.stringify({
+    // `subscribe` is player signalling → the Cirrus socket.
+    this.send(JSON.stringify({
         type: 'subscribe',
         streamerId: msg.ids[0],
     }));
@@ -2042,19 +2058,6 @@ function createWebSocket(wsUrl, timeoutMs = WS_TIMEOUT) {
     }));
 }
 
-function PlayerDisconnectHandler() {
-    this.store.dispatch(disconnectStream({
-        reason: DisconnectReason.OrchestrationPlayerDisconnected,
-        message: 'Orchestration: PlayerDisconnectHandler',
-    }));
-}
-function StreamerDisconnectHandler() {
-    this.store.dispatch(disconnectStream({
-        reason: DisconnectReason.OrchestrationStreamerDisconnected,
-        message: 'Orchestration: StreamerDisconnectHandler',
-    }));
-}
-
 // Structured constants holding code + description
 const ORCHESTRATION_ERROR_CODES = {
     NO_AVAILABLE_INSTANCES: {
@@ -2079,6 +2082,16 @@ function OrchestrationErrorHandler(msg) {
     if (RETRY_CODES.has(msg.payload.code)) {
         const errorInfo = Object.values(ORCHESTRATION_ERROR_CODES).find(({ code }) => code === msg.payload.code);
         this.store.dispatch(setOrchestrationMessage({ message: errorInfo?.description }));
+        // Same telemetry channel as the WS/URL/region retry tiers — this branch used
+        // to resend silently, so `kind: 'orchestration'` was declared but never seen.
+        // No count cap here on purpose: the wait is bounded by
+        // `INSTANCE_READY_TIMEOUT` in `requestCirrusViaSocket`, and on expiry the
+        // URL-rotating tier takes over.
+        this.store.dispatch(signalingRetryAttempted({
+            attempt: ++this.orchestrationRetryCount,
+            reason: errorInfo?.description ?? `code ${msg.payload.code}`,
+            kind: 'orchestration',
+        }));
         this.orchestrationRetrySub?.unsubscribe();
         this.orchestrationRetrySub = timer(POLLING_TIME)
             .pipe(takeUntil(this.destroy$))
@@ -2102,21 +2115,27 @@ class SignallingService extends SubService {
         this.onConfig$ = new Subject();
         this.onWebRtcIce$ = new Subject();
         this.onWebRtcAnswer$ = new Subject();
+        // Fed by `InstanceReadyHandler`. `requestCirrusViaSocket` awaits it the same
+        // way `requestCirrusViaPolling` awaits a ready polling response — it is the
+        // socket flow's "here is your Cirrus URL" answer.
+        this.onInstanceReady$ = new Subject();
         // 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));
+        // The CIRRUS signalling socket — the only socket that speaks WebRTC
+        // (config/offer/answer/iceCandidate/ping). Same field in all three flows:
+        // the polled `signallingServer`, the stream machine (`originInstanceUri`), or
+        // a direct dev URL.
         this.ws = null;
-        // Second socket, opened directly to the stream machine (originInstanceUri
-        // from `instanceReady`). Carries the whole WebRTC signalling
-        // (config/offer/answer/iceCandidate/ping); `this.ws` stays for control.
-        this.streamWs = null;
-        // True once the stream-machine socket is established. After this the
-        // orchestration server intentionally closes the browser's orchestration
-        // socket (instance is "occupied") — that close must NOT be treated as a drop.
-        this.streamMachineConnected = false;
-        // Bounded retry counter for the stream-machine connection (new-flow only).
-        this.streamMachineRetryCount = 0;
+        // The orchestration CONTROL socket (socket flow only). Opened by
+        // `requestCirrusViaSocket` to ask for a machine and closed the moment
+        // `instanceReady` arrives — per the backend contract nothing uses it after the
+        // handover, so it is never left open with dangling handlers.
+        this.controlWs = null;
+        // `requestStream` resends driven by `OrchestrationErrorHandler` within one
+        // `requestCirrusViaSocket` wait. Reported as `kind: 'orchestration'` retries.
+        this.orchestrationRetryCount = 0;
         this.wsMsgHandlers = {};
         this.init();
     }
@@ -2124,7 +2143,7 @@ class SignallingService extends SubService {
         if (this.unrealConfig?.playwright) {
             return;
         }
-        this.setHandlersFromStream();
+        this.setMessageHandlers();
         // 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().
@@ -2139,13 +2158,12 @@ class SignallingService extends SubService {
         // 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`. `sendPlayerSignal()` is already a no-op on a closed WS,
+        // `p2pEstablished`. `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(() => {
-            // Player signalling → active signalling socket (stream/relay).
-            this.sendPlayerSignal({
+            this.send({
                 type: 'p2pEstablished',
                 source: 'front',
                 sessionId: generateUuid(),
@@ -2196,7 +2214,7 @@ class SignallingService extends SubService {
     }
     /**
      * One inner cycle: rotate `urlGen` over the pool, resolve via
-     * {@link getAwsInstance}, open WS via {@link connectToCirrus},
+     * {@link requestCirrus}, 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
@@ -2204,12 +2222,20 @@ class SignallingService extends SubService {
      */
     connectAttempt(urls) {
         const urlGen = getActiveUrl(urls);
-        return defer(() => this.getAwsInstance(`${urlGen.next().value}`)).pipe(tap((awsInstance) => this.store.dispatch(setAwsInstance(awsInstance))), switchMap(({ wsUrl, streamRequestId }) => 
+        return defer(() => {
+            // One control socket per ATTEMPT, whatever transport this attempt picks —
+            // a rotation from a `wss://` orchestration URL to an `http://` one would
+            // otherwise leave the previous control socket behind. Deliberately NOT
+            // inside the WS-only tier below: that tier reuses the same resolved
+            // machine, so its control socket must survive.
+            this.teardownControlWs();
+            return this.requestCirrus(`${urlGen.next().value}`);
+        }).pipe(tap((awsInstance) => this.store.dispatch(setAwsInstance(awsInstance))), switchMap(({ wsUrl, streamRequestId }) => 
         // ── 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,
+        // `requestCirrus(url)` again, which asks orchestration again,
         // which causes orchestrator to RESERVE A NEW instance — the
         // previous reservation is orphaned (server-side leak).
         //
@@ -2218,13 +2244,10 @@ class SignallingService extends SubService {
         // burning a second reservation. If WS still fails after these
         // extra attempts, the instance is genuinely unusable and we
         // accept the cost of rotating.
-        // POLLING flow only: the polled `signallingServer` IS Cirrus (single
-        // socket), so the orchestration-issued connection id rides on this
-        // upgrade URL. In the new WS flow this socket is orchestration-only
-        // control and `streamRequestId` is still unknown here (it arrives later
-        // in `instanceReserved`/`instanceReady`) → no-op, URL unchanged; the id
-        // is attached to the machine address instead, see
-        // `connectToStreamMachine`.
+        // `wsUrl` is always a CIRRUS address here, whichever request method
+        // produced it, so the orchestration-issued connection id always rides
+        // on this upgrade URL and Cirrus adopts it instead of generating its
+        // own. Absent id (older backend, direct dev URL) → URL unchanged.
         this.connectToCirrus(withStreamRequestId(wsUrl ?? '', streamRequestId)).pipe(filter(Truthy), take(1), retry({
             count: WS_RETRY_PER_INSTANCE,
             delay: (err, attempt) => {
@@ -2278,22 +2301,52 @@ class SignallingService extends SubService {
         });
     }
     /**
-     * Resolve one URL to an `AwsInstance`. Dispatches to
-     * {@link directWsInstance} for `ws://` / `wss://` URLs, otherwise
-     * to {@link pollOrchestration}.
+     * Ask the orchestration for a Cirrus to connect to. All three
+     * implementations answer the same question — "which Cirrus, and with which
+     * `streamRequestId`?" — and emit ONE `AwsInstance` whose `wsUrl` is a Cirrus
+     * address. What differs is only how the answer is obtained and therefore how
+     * it can fail:
+     *
+     * | Method                     | Transport            | Fails on                       |
+     * | -------------------------- | -------------------- | ------------------------------ |
+     * | {@link requestCirrusViaPolling} | HTTP poll loop  | HTTP 4xx (dead URL)            |
+     * | {@link requestCirrusViaSocket}  | control WS      | socket drop / no `instanceReady` in {@link INSTANCE_READY_TIMEOUT} |
+     * | {@link requestCirrusDirect}     | none (dev)      | never — nothing is requested   |
+     *
+     * Whatever they return goes through the SAME downstream in
+     * {@link connectAttempt}: `setAwsInstance` → `connectToCirrus` → the WS-only
+     * and URL-rotating retry tiers. A failure inside any of them is just an
+     * error on this observable, so those tiers handle it uniformly.
      */
-    getAwsInstance(url) {
-        return url.match(/^ws(s?):\/\//i)
-            ? this.directWsInstance(url)
-            : this.pollOrchestration(url);
+    requestCirrus(url) {
+        if (!url.match(/^ws(s?):\/\//i)) {
+            return this.requestCirrusViaPolling(url);
+        }
+        // A `ws://` URL is the orchestration control endpoint when the app supplied
+        // a stream-request context (the same precondition `sendRequestStream` needs);
+        // without it there is nothing to negotiate and the URL is Cirrus itself.
+        return this.hasOrchestrationContext()
+            ? this.requestCirrusViaSocket(url)
+            : this.requestCirrusDirect(url);
+    }
+    /** True when `requestStream` can be composed → new orchestration. */
+    hasOrchestrationContext() {
+        return !!this.streamRequestContext() && !!this.environmentId();
+    }
+    /**
+     * Wait until `clientId` and `viewId` are known — every request method needs
+     * them before it may talk to the backend.
+     */
+    waitForClientAndViewIds() {
+        return this.store.select(selectClientAndViewIds).pipe(filter(({ clientId, viewId }) => !!clientId && !!viewId), take(1));
     }
     /**
-     * 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.
+     * Direct `ws://` / `wss://` short-circuit — no orchestration at all, the URL
+     * already points at Cirrus. Dev/playwright convenience, hence no
+     * `kind`: nothing was requested.
      */
-    directWsInstance(url) {
-        return this.store.select(selectClientAndViewIds).pipe(filter(({ clientId, viewId }) => !!clientId && !!viewId), take(1), map$1(() => ({
+    requestCirrusDirect(url) {
+        return this.waitForClientAndViewIds().pipe(map$1(() => ({
             wsUrl: url,
             pollingUrl: null,
             instanceName: 'Direct Connection',
@@ -2306,7 +2359,7 @@ class SignallingService extends SubService {
      * last response captured in the closure). Maps the final ready
      * response to an `AwsInstance`.
      */
-    pollOrchestration(url) {
+    requestCirrusViaPolling(url) {
         return defer(() => {
             let lastResp;
             this.store.dispatch(pollingStarted());
@@ -2324,12 +2377,84 @@ class SignallingService extends SubService {
                 // The orchestration issues the connection id here; it is handed to
                 // Cirrus on the WS upgrade URL (see `connectAttempt`).
                 streamRequestId: data.streamRequestId,
+                kind: 'polling',
             })), finalize(() => {
                 this.commandTelemetryService.trackStopCommand('EXT-getSignaling', true, { ...(lastResp ?? {}), multi: true });
                 this.store.dispatch(pollingEnded());
             }));
         });
     }
+    /**
+     * WS-orchestration path — the socket-transport twin of
+     * {@link requestCirrusViaPolling}. Opens the control socket, sends
+     * `requestStream` and waits for `instanceReady`, whose `originInstanceUri`
+     * IS the Cirrus address.
+     *
+     * Failure modes are handled here so they surface as a plain error and reach
+     * `connectAttempt`'s retry tiers (previously this branch lived outside them
+     * and a dead control socket silently hung the session):
+     *  - control socket closes/errors before `instanceReady` → error
+     *  - no `instanceReady` within {@link INSTANCE_READY_TIMEOUT} → error
+     *
+     * The control socket lives exactly as long as this wait — see
+     * {@link awaitInstanceReady}.
+     */
+    requestCirrusViaSocket(url) {
+        return defer(() => {
+            let resolved;
+            this.orchestrationRetryCount = 0;
+            this.commandTelemetryService.trackStartCommand('EXT-getSignaling');
+            return this.waitForClientAndViewIds().pipe(switchMap(() => createWebSocket(url)), switchMap((control) => this.awaitInstanceReady(control, url)), tap((instance) => {
+                resolved = instance;
+            }), finalize(() => this.commandTelemetryService.trackStopCommand('EXT-getSignaling', true, { ...(resolved ?? {}), multi: true })));
+        });
+    }
+    /**
+     * Send `requestStream` on the freshly opened control socket and resolve with
+     * the machine coordinates from `instanceReady`.
+     *
+     * The socket lives exactly as long as this wait: its close/error are HARD
+     * failures of the request, and on resolution it is closed with every handler
+     * detached (the backend does not use it after the handover). So the control
+     * socket has no post-handover state at all — nothing that could report a stale
+     * "disconnect" against a live stream.
+     */
+    awaitInstanceReady(control, orchestrationUrl) {
+        return new Observable((observer) => {
+            control.onmessage = OnMessageHandler.bind(this);
+            control.onclose = (e) => observer.error(new Error(`Orchestration socket closed before instanceReady (code ${e.code})`));
+            control.onerror = () => observer.error(new Error('Orchestration socket error before instanceReady'));
+            this.controlWs = control;
+            Logger.log('ORCHESTRATION CONTROL WS OPEN');
+            this.sendRequestStream();
+            const sub = this.onInstanceReady$.pipe(take(1)).subscribe((payload) => {
+                // The control socket has done its only job. Per the backend contract it
+                // is not used after the handover, so it is closed here — with all its
+                // handlers detached by `teardownSocket`, which also means the close
+                // itself cannot come back as an error above.
+                this.teardownControlWs();
+                observer.next({
+                    wsUrl: payload.originInstanceUri,
+                    // The endpoint that answered — the orchestration URL here, the HTTP
+                    // polling URL in the other flow. Shown as `Orchestration:` in the overlay.
+                    pollingUrl: orchestrationUrl,
+                    instanceName: payload.originInstanceId,
+                    streamRequestId: payload.streamRequestId,
+                    kind: 'socket',
+                });
+                observer.complete();
+            });
+            // Errored, timed out or aborted before `instanceReady` — same teardown,
+            // the socket must not be left behind either way.
+            return () => {
+                sub.unsubscribe();
+                this.teardownControlWs();
+            };
+        }).pipe(timeout$1({
+            first: INSTANCE_READY_TIMEOUT,
+            with: () => throwError(() => new Error(`No instanceReady within ${INSTANCE_READY_TIMEOUT}ms — requesting another machine`)),
+        }), takeUntil(this.abort$));
+    }
     /**
      * Poll the SAME `url` until ready, or until HTTP 4xx says the URL
      * is dead.
@@ -2386,37 +2511,31 @@ class SignallingService extends SubService {
         // 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 });
+            // Only the Cirrus socket — the control socket belongs to
+            // `requestCirrusViaSocket`, which already opened it to GET this `wsUrl`.
+            this.closeCirrus({
+                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);
         }));
     }
+    /**
+     * Handlers for the CIRRUS socket — the only long-lived socket. Its close/error
+     * are real stream events (`setCirrusDisconnected` / `dropConnection`), unlike
+     * the control socket's, which never outlives {@link awaitInstanceReady}.
+     */
     addWsHandlers(ws) {
         ws.onmessage = OnMessageHandler.bind(this);
-        // Orchestration socket close/error is benign ONCE the stream machine is
-        // connected (orchestration closes it after marking the instance occupied).
-        ws.onclose = (e) => this.onOrchestrationClose(e);
-        ws.onerror = (e) => this.onOrchestrationError(e);
+        ws.onclose = OnCloseHandler.bind(this);
+        ws.onerror = OnErrorHandler.bind(this);
         this.ws = ws;
         Logger.log('WS HANDLERS ADDED');
         OnOpenHandler.call(this);
     }
-    onOrchestrationClose(e) {
-        if (this.streamMachineConnected) {
-            Logger.log(`Orchestration socket closed after occupancy (benign): ${e.code}`);
-            return;
-        }
-        OnCloseHandler.call(this, e);
-    }
-    onOrchestrationError(e) {
-        if (this.streamMachineConnected) {
-            Logger.log('Orchestration socket error after occupancy (benign)');
-            return;
-        }
-        OnErrorHandler.call(this, e);
-    }
     /**
      * Adopt a live signalling socket opened by the `stream-prefetch.js`
      * head-script. The socket is already OPEN and `requestStream` was already
@@ -2433,104 +2552,32 @@ class SignallingService extends SubService {
         this.ws = ws;
         Logger.log('WS ADOPTED (handshake already done, requestStream already sent)');
     }
-    /**
-     * Open the SECOND socket, directly to the stream machine's Cirrus
-     * (`originInstanceUri` from `instanceReady`). The whole WebRTC signalling
-     * (config/offer/answer/iceCandidate/ping) flows over this socket; the
-     * orchestration socket (`this.ws`) stays open for control/lifecycle.
-     *
-     * "Just connect" — nothing is sent on open (the machine is already reserved
-     * for this session): Cirrus pushes `config` and Unreal sends the `offer`.
-     *
-     * The orchestration-issued `streamRequestId` (from the same `instanceReady`
-     * payload) rides on this upgrade URL: in the new flow THIS is the Cirrus
-     * socket, so it is the one that must carry the id (the first socket is
-     * orchestration-only control and needs nothing). Without it the stream
-     * machine's Cirrus falls back to its own `guid()` and the session can no
-     * longer be correlated. Absent id → URL unchanged.
-     */
-    connectToStreamMachine(originInstanceUri, streamRequestId) {
-        if (!originInstanceUri) {
-            Logger.warn('instanceReady without originInstanceUri — stream socket not opened');
-            return;
-        }
-        // Guard: a stream socket is already live. A duplicate / re-sent
-        // `instanceReady` must NOT tear down the active stream.
-        if (this.streamMachineConnected) {
-            Logger.warn('Stream machine already connected — ignoring duplicate instanceReady');
-            return;
-        }
-        // Drop any prior (half-open) stream socket AND cancel any in-flight connect
-        // before a fresh attempt — e.g. a retry that resolved to a different machine
-        // or two instanceReady messages before the first connect resolves.
-        this.teardownStreamWs();
-        this.streamWsSub = createWebSocket(withStreamRequestId(originInstanceUri, streamRequestId))
-            .pipe(takeUntil(this.abort$), takeUntil(this.destroy$), take(1))
-            .subscribe({
-            next: (ws) => {
-                this.streamMachineRetryCount = 0;
-                this.addStreamWsHandlers(ws);
-            },
-            error: (err) => {
-                Logger.error('Stream-machine WS failed to connect', err?.message);
-                this.retryStreamMachine();
-            },
-        });
-    }
-    /**
-     * The stream-machine (Cirrus) connection failed. Re-request a machine over
-     * the still-open orchestration socket: orchestration issues a new
-     * streamRequestId and a fresh `instanceReady(originInstanceUri)`, which calls
-     * {@link connectToStreamMachine} again on a different machine. Bounded by
-     * {@link INNER_RETRY_LIMIT}; on exhaustion the stream is dropped.
-     */
-    retryStreamMachine() {
-        if (this.streamMachineRetryCount >= INNER_RETRY_LIMIT) {
-            Logger.error('Stream-machine connection exhausted retries — dropping');
-            this.store.dispatch(disconnectStream({
-                reason: DisconnectReason.ReconnectFailed,
-                message: 'Could not connect to the stream machine',
-            }));
-            return;
-        }
-        this.streamMachineRetryCount++;
-        this.orchestrationRetrySub?.unsubscribe();
-        this.orchestrationRetrySub = timer(POLLING_TIME)
-            .pipe(takeUntil(this.abort$))
-            .subscribe(() => this.sendRequestStream());
-    }
-    addStreamWsHandlers(ws) {
-        ws.onmessage = OnMessageHandler.bind(this);
-        ws.onclose = OnCloseHandler.bind(this);
-        ws.onerror = OnErrorHandler.bind(this);
-        this.streamWs = ws;
-        this.streamMachineConnected = true;
-        Logger.log('STREAM-MACHINE WS CONNECTED');
-    }
-    teardownStreamWs() {
-        this.streamWsSub?.unsubscribe();
-        this.teardownSocket(this.streamWs, 1000, DisconnectReason.NewConnectionAttempt);
-        this.streamWs = null;
-        this.streamMachineConnected = false;
-    }
     showStatusMessage(statusMessage) {
         this.store.dispatch(setStatusMessage({ statusMessage }));
     }
     /**
-     * Close the connection with the signaling server
-     * @param data
+     * Close everything: the Cirrus socket AND the orchestration control socket.
+     * Used on abort/teardown. A new connection attempt inside a live cycle uses
+     * {@link closeCirrus} instead, so it does not kill the control socket that
+     * produced the address it is about to connect to.
      */
     close(data) {
         const { code, reason } = data;
-        this.onWebRtcAnswer$.next(null);
         this.orchestrationRetrySub?.unsubscribe();
-        this.streamWsSub?.unsubscribe();
+        this.closeCirrus(data);
+        this.teardownControlWs(code, reason);
+    }
+    /** Close only the Cirrus signalling socket. */
+    closeCirrus(data) {
+        const { code, reason } = data;
+        this.onWebRtcAnswer$.next(null);
         this.teardownSocket(this.ws, code, reason);
         this.ws = null;
-        this.teardownSocket(this.streamWs, code, reason);
-        this.streamWs = null;
-        this.streamMachineConnected = false;
-        this.streamMachineRetryCount = 0;
+    }
+    teardownControlWs(code = 1000, reason = DisconnectReason.NewConnectionAttempt) {
+        this.teardownSocket(this.controlWs, code, reason);
+        this.controlWs = null;
+        this.orchestrationRetryCount = 0;
     }
     teardownSocket(ws, code, reason) {
         if (!ws) {
@@ -2547,17 +2594,16 @@ class SignallingService extends SubService {
             ws.close(code, reason);
         }
     }
+    /**
+     * Player signalling (offer/answer/iceCandidate/pong/p2pEstablished/subscribe)
+     * — always the Cirrus socket, in every flow.
+     */
     send(data) {
         this.sendTo(this.ws, data);
     }
-    /**
-     * Send player signalling (offer/answer/iceCandidate/pong/p2pEstablished/
-     * subscribe) over the ACTIVE signalling socket: the stream-machine socket in
-     * the new flow (once connected), or the orchestration/relay socket in the old
-     * polling flow (where there is no separate stream socket).
-     */
-    sendPlayerSignal(data) {
-        this.sendTo(this.streamMachineConnected ? this.streamWs : this.ws, data);
+    /** Orchestration control messages (`requestStream`) — the control socket. */
+    sendToOrchestration(data) {
+        this.sendTo(this.controlWs, data);
     }
     sendTo(ws, data) {
         let dataString = data;
@@ -2587,21 +2633,45 @@ class SignallingService extends SubService {
             Logger.colored(...COLOR_CODES.FROM_CIRRUS_ERROR, `Invalid CIRRUS message type: ${msg.type}`);
         }
     }
-    setHandlersFromStream() {
-        this.wsMsgHandlers.ping = PingHandler.bind(this);
+    /**
+     * One handler map shared by both sockets — `handleMessage` dispatches purely by
+     * message type. Which socket a type can arrive on is fixed, so registration is
+     * split by origin: {@link setOrchestrationHandlers} (control socket) and
+     * {@link setStreamHandlers} (Cirrus).
+     *
+     * Keepalive is deliberately absent: both servers ping at the WS **protocol**
+     * level (`ws.ping()`), which the browser answers on its own — the page never
+     * sees a ping and must never reply with an application-level `pong`. An
+     * unregistered type is dropped silently by `handleMessage`, so a `ping` from a
+     * not-yet-updated backend is simply ignored.
+     */
+    setMessageHandlers() {
+        this.setOrchestrationHandlers();
+        this.setStreamHandlers();
+    }
+    /**
+     * Messages from the ORCHESTRATION control socket. Only reachable during the
+     * provisioning wait — `requestCirrusViaSocket` closes that socket the moment
+     * `instanceReady` lands.
+     */
+    setOrchestrationHandlers() {
+        // `instanceReserved` (eta/progress) and `instanceReady` (the Cirrus address)
+        // ARE the request/response pair of `requestCirrusViaSocket`.
+        this.wsMsgHandlers.instanceReserved = InstanceReservedHandler.bind(this);
+        this.wsMsgHandlers.instanceReady = InstanceReadyHandler.bind(this);
+        // Orchestration-side refusals (4001 no instances / 4002 limit reached) →
+        // resend `requestStream`, bounded by `INSTANCE_READY_TIMEOUT`.
         this.wsMsgHandlers.error = OrchestrationErrorHandler.bind(this);
+    }
+    /** Messages from the CIRRUS socket — the actual stream signalling. */
+    setStreamHandlers() {
         this.wsMsgHandlers.config = ConfigHandler.bind(this);
+        this.wsMsgHandlers.offer = OfferHandler.bind(this);
         this.wsMsgHandlers.answer = AnswerHandler.bind(this);
+        this.wsMsgHandlers.iceCandidate = IceCandidateHandler.bind(this);
         this.wsMsgHandlers.ssInfo = SSInfoHandler.bind(this);
         this.wsMsgHandlers.playerCount = PlayerCountHandler.bind(this);
         this.wsMsgHandlers.streamerList = StreamerListHandler.bind(this);
-        this.wsMsgHandlers.iceCandidate = IceCandidateHandler.bind(this);
-        this.wsMsgHandlers.instanceReady = InstanceReadyHandler.bind(this);
-        this.wsMsgHandlers.instanceReserved = InstanceReservedHandler.bind(this);
-        this.wsMsgHandlers.playerDisconnected = PlayerDisconnectHandler.bind(this);
-        this.wsMsgHandlers.streamerDisconnected =
-            StreamerDisconnectHandler.bind(this);
-        this.wsMsgHandlers.offer = OfferHandler.bind(this);
     }
     sendRequestStream() {
         const context = this.streamRequestContext();
@@ -2609,7 +2679,7 @@ class SignallingService extends SubService {
         if (!context || !environmentId) {
             return;
         }
-        this.send({
+        this.sendToOrchestration({
             type: OrchestrationMessageTypes.requestStream,
             correlationId: this.correlationId,
             payload: {
@@ -2620,18 +2690,12 @@ class SignallingService extends SubService {
         });
     }
     /**
-     * Check if the ACTIVE player-signalling socket is open and ready. Mirrors
-     * {@link sendPlayerSignal}'s socket choice so peer-reconnect gating is correct
-     * in both flows:
-     *  - NEW flow (`streamMachineConnected`): the stream-machine socket
-     *    (`streamWs`). The orchestration socket (`this.ws`) is intentionally
-     *    closed after occupancy, so checking it would wrongly report "not
-     *    connected" and block reconnect.
-     *  - OLD polling flow: the single relay socket (`this.ws`) — unchanged.
+     * Is the player-signalling socket open? Always the Cirrus socket — the
+     * control socket's state is irrelevant to the stream (orchestration closes it
+     * once the instance is occupied), so it must not be part of this gate.
      */
     isConnected() {
-        const activeWs = this.streamMachineConnected ? this.streamWs : this.ws;
-        return !!(activeWs && activeWs.readyState === WS_OPEN_STATE);
+        return !!(this.ws && this.ws.readyState === WS_OPEN_STATE);
     }
     getRegion() {
         Logger.log('Start Getting Region');
@@ -3550,7 +3614,7 @@ class WebRtcPlayerService extends SubService {
         });
         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(merge(this.disconnect$, this.destroy$)))
-            .subscribe((candidate) => this.signallingSrv.sendPlayerSignal({
+            .subscribe((candidate) => this.signallingSrv.send({
             type: 'iceCandidate',
             candidate,
         }));
@@ -3700,7 +3764,7 @@ class WebRtcPlayerService extends SubService {
             const offer = await pcClient.createOffer();
             offer.sdp = this.mungeSDP(offer.sdp ?? '');
             await pcClient.setLocalDescription(offer);
-            this.signallingSrv.sendPlayerSignal(offer);
+            this.signallingSrv.send(offer);
         }
         catch {
             Logger.error("Couldn't create offer");
@@ -3715,7 +3779,7 @@ class WebRtcPlayerService extends SubService {
             const answer = await pcClient.createAnswer();
             answer.sdp = this.mungeSDP(answer.sdp ?? '');
             await pcClient.setLocalDescription(answer);
-            this.signallingSrv.sendPlayerSignal(answer);
+            this.signallingSrv.send(answer);
             // Observability signal for the signaling waterfall — the handshake
             // went "answer sent" between `offer received` and `datachannel_ready`.
             this.store.dispatch(answerSent());
@@ -4169,7 +4233,15 @@ class UnrealEffects {
                             userAgent: navigator.userAgent,
                             error,
                         };
-                        return this.http.post(awsInstance.pollingUrl || '', body).pipe(catchError((postError) => {
+                        // Only the polling flow has an HTTP endpoint to report to;
+                        // `pollingUrl` is a `wss://` orchestration address otherwise.
+                        const reportUrl = awsInstance.pollingUrl?.startsWith('http')
+                            ? awsInstance.pollingUrl
+                            : null;
+                        const report$ = reportUrl
+                            ? this.http.post(reportUrl, body)
+                            : of(null);
+                        return report$.pipe(catchError((postError) => {
                             Logger.error('Error sending timeout info:', postError);
                             return of(null);
                         }), 
@@ -8100,5 +8172,5 @@ function provideUnrealModule() {
  * Generated bundle index. Do not edit.
  */
 
-export { AFKService, AUTO_HIGH_RESOLUTION_IDLE_MS, AfkTimeoutModalComponent, AggregatorService, AnalyticsService, AnswerHandler, CommandTelemetryService, ConfigHandler, ConsoleExtensionsService, ControlScheme, DATA_CHANNEL_CONNECTION_TIMEOUT, DEBOUNCE_TO_MANY_RESIZE_CALLS, DEFAULT_AFK_TIMEOUT, DEFAULT_AFK_TIMEOUT_PERIOD, DESTROY_DISCONNECT_REASONS, DevModeService, DisconnectReason, FULL_HD_HEIGHT, FULL_HD_WIDTH, FileHandlerService, FileReceiverService, FpsMonitorService, FreezeFrameComponent, FreezeFrameService, INNER_RETRY_LIMIT, IceCandidateHandler, ImageLoadingSrcComponent, InputOptions, InputService, InstanceReadyHandler, InstanceReservedHandler, IntroSrcComponent, LatencyTimings, LoadingProgressService, MINIMAL_FPS, MIN_CONTAINER_SIZE, MessageType, MouseButton, MouseButtonsMask, OUTER_RETRY_DELAY, OnCloseHandler, OnErrorHandler, OnMessageHandler, OnOpenHandler, OrchestrationMessageTypes, POLLING_TIME, PingHandler, PlayerCountHandler, RECONNECT_CONFIG, REGION_PING_ACCURATE_SAMPLES, REGION_PING_BACKGROUND_REFRESH_DELAY_MS, REGION_PING_CACHE_KEY, REGION_PING_CACHE_TTL_MS, REGION_PING_WARMUP_DEADLINE_MS, RegionsPingService, SAME_SIZE_THRESHOLD, SCREEN_LOCKER_CONTAINER_ID, SIGNALLING_PERCENT_VALUE, SSInfoHandler, STREAMING_AUDIO_ID, STREAMING_VIDEO_ID, SafePipe, SignallingService, SpecialKeyCodes, StatGraphComponent, StreamAdoptionService, 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, provideUnrealState, 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, streamAdopted, trackMixpanelEvent, trackTelemetryData, uint8ToBase64, unrealCommandCallback, unrealFeature, unrealReducer, updateCirrusInfo, videoAdaptedToContainer, videoStreamInitialized };
+export { AFKService, AUTO_HIGH_RESOLUTION_IDLE_MS, AfkTimeoutModalComponent, AggregatorService, AnalyticsService, AnswerHandler, CommandTelemetryService, ConfigHandler, ConsoleExtensionsService, ControlScheme, DATA_CHANNEL_CONNECTION_TIMEOUT, DEBOUNCE_TO_MANY_RESIZE_CALLS, DEFAULT_AFK_TIMEOUT, DEFAULT_AFK_TIMEOUT_PERIOD, DESTROY_DISCONNECT_REASONS, DevModeService, DisconnectReason, FULL_HD_HEIGHT, FULL_HD_WIDTH, FileHandlerService, FileReceiverService, FpsMonitorService, FreezeFrameComponent, FreezeFrameService, INNER_RETRY_LIMIT, INSTANCE_READY_TIMEOUT, IceCandidateHandler, ImageLoadingSrcComponent, InputOptions, InputService, InstanceReadyHandler, InstanceReservedHandler, IntroSrcComponent, LatencyTimings, LoadingProgressService, MINIMAL_FPS, MIN_CONTAINER_SIZE, MessageType, MouseButton, MouseButtonsMask, OUTER_RETRY_DELAY, OnCloseHandler, OnErrorHandler, OnMessageHandler, OnOpenHandler, OrchestrationMessageTypes, POLLING_TIME, PlayerCountHandler, RECONNECT_CONFIG, REGION_PING_ACCURATE_SAMPLES, REGION_PING_BACKGROUND_REFRESH_DELAY_MS, REGION_PING_CACHE_KEY, REGION_PING_CACHE_TTL_MS, REGION_PING_WARMUP_DEADLINE_MS, RegionsPingService, SAME_SIZE_THRESHOLD, SCREEN_LOCKER_CONTAINER_ID, SIGNALLING_PERCENT_VALUE, SSInfoHandler, STREAMING_AUDIO_ID, STREAMING_VIDEO_ID, SafePipe, SignallingService, SpecialKeyCodes, StatGraphComponent, StreamAdoptionService, 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, provideUnrealState, 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, streamAdopted, trackMixpanelEvent, trackTelemetryData, uint8ToBase64, unrealCommandCallback, unrealFeature, unrealReducer, updateCirrusInfo, videoAdaptedToContainer, videoStreamInitialized };
 //# sourceMappingURL=3dsource-angular-unreal-module.mjs.map