@3dsource/angular-unreal-module 0.0.110 → 0.0.112

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

@@ -1,10 +1,10 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, ChangeDetectionStrategy, Component, Injectable, DestroyRef, effect, untracked, signal, Pipe, input, ElementRef, viewChild, afterNextRender, HostListener, computed, output, makeEnvironmentProviders, provideEnvironmentInitializer } from '@angular/core';
 import { SourceButtonComponent, SourceLoadingComponent } from '@3dsource/source-ui-native';
-import { merge, map, scan, concatMap, of, animationFrameScheduler, interval, Observable, debounceTime, switchMap, take, fromEvent, EMPTY, timer, timeout, mergeMap, Subject, skip, share, from, throwError, defer, retry, tap as tap$1, startWith, takeUntil as takeUntil$1, auditTime, filter as filter$1, throttleTime, BehaviorSubject, combineLatestWith, distinctUntilChanged as distinctUntilChanged$1, concat } from 'rxjs';
+import { merge, map, scan, concatMap, of, animationFrameScheduler, interval, Observable, debounceTime, switchMap, take, fromEvent, EMPTY, timer, timeout, mergeMap, Subject, skip, share, from, throwError, defer, retry, tap as tap$1, startWith, takeUntil as takeUntil$1, throttleTime, asyncScheduler, filter as filter$1, withLatestFrom as withLatestFrom$1, pairwise, Subscription, bufferTime, BehaviorSubject, combineLatestWith, distinctUntilChanged as distinctUntilChanged$1, concat } from 'rxjs';
 import { createAction, props, createReducer, on, createFeature, createSelector, Store, provideState } from '@ngrx/store';
 import { Actions, createEffect, ofType, provideEffects } from '@ngrx/effects';
-import { map as map$1, distinctUntilChanged, takeWhile, filter, tap, withLatestFrom, exhaustMap, catchError, takeUntil, switchMap as switchMap$1, timeout as timeout$1, debounceTime as debounceTime$1, delay, skip as skip$1 } from 'rxjs/operators';
+import { map as map$1, distinctUntilChanged, takeWhile, filter, tap, withLatestFrom, exhaustMap, catchError, takeUntil, switchMap as switchMap$1, timeout as timeout$1, debounceTime as debounceTime$1, take as take$1, startWith as startWith$1, delay, skip as skip$1 } from 'rxjs/operators';
 import { Logger, calculateMedian, clampf, lerp, getCanvasCached, getSnapshot, fitIntoRectangle, whereNot, Truthy, Falsy, tapLog, generateUuid, COLOR_CODES, where, KeyboardNumericCode, InvertedKeyMap, Semaphore, HEXtoRGB, RGBtoHSV, inverseLerp, HSVtoRGB, RGBtoHEX, fpIsASameAsB } from '@3dsource/utils';
 import { concatLatestFrom } from '@ngrx/operators';
 import { DialogRef, DIALOG_DATA, Dialog } from '@angular/cdk/dialog';
@@ -12,6 +12,7 @@ import { HttpClient } from '@angular/common/http';
 import { ScrollStrategyOptions } from '@angular/cdk/overlay';
 import { MetaBoxCommand, EPayloadVersion } from '@3dsource/types-unreal';
 import { toSignal, takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
+import { v4 } from 'uuid';
 import { DomSanitizer } from '@angular/platform-browser';
 import { NgOptimizedImage, AsyncPipe, JsonPipe } from '@angular/common';
 import * as i1 from '@angular/forms';
@@ -150,6 +151,7 @@ const commandCompleted = createAction(scoped$1 `command completed`, props());
 
 const scoped = (templateString) => `[UNREAL] ${templateString[0]}`;
 const trackMixpanelEvent = createAction(scoped `track mixpanel event`, props());
+const trackTelemetryData = createAction(scoped `track telemetry data`, props());
 const changeLowBandwidth = createAction(scoped `change low bandwidth`, props());
 const setMaxFps = createAction(scoped `change fps`, props());
 const destroyRemoteConnections = createAction(scoped `destroyRemoteConnections`, props());
@@ -184,6 +186,47 @@ const changeStreamResolutionAction = createAction(scoped `change stream resoluti
 const changeStreamResolutionSuccessAction = createAction(scoped `change stream resolution success action`, props());
 const setSignalingName = createAction(scoped `set aws instanceName`, props());
 const setOrchestrationParameters = createAction(scoped `set orchestration parameters`, props());
+/**
+ * Dispatched when the orchestration server signals that the reserved
+ * instance is ready to serve the stream (`instanceReady` WS message).
+ * Emitted for observability only — no reducer state change.
+ */
+const instanceReady = createAction(scoped `instance ready`);
+/**
+ * Dispatched when `RegionsPingService.getFastest()` begins — right
+ * before the region-list HTTP request goes out. Bookends the entire
+ * region-discovery flow together with {@link regionResolved}.
+ * Observability-only — no state change.
+ */
+const regionPingFetchStart = createAction(scoped `region ping fetch start`);
+/**
+ * Dispatched once `RegionsPingService.getProviders()` returns the region
+ * list — i.e. the fetch step is done and the actual per-region ping
+ * sweep is about to start. Splits the region-discovery waterfall into
+ * two legs: config fetch vs ping sweep. Observability-only.
+ */
+const regionPingFetchEnd = createAction(scoped `region ping fetch end`);
+/**
+ * Dispatched once the closest region has been resolved by the
+ * regions-ping service. Carries every sampled ping RTT to the winning
+ * region (one entry per probe — `checkLatency` issues `ping_count`
+ * sequential pings per region) so consumers can inspect variance /
+ * jitter, not just the mean. Observability-only — no state change.
+ */
+const regionResolved = createAction(scoped `region resolved`, props());
+/**
+ * Dispatched around the HTTP polling roundtrip inside `getAwsInstance`
+ * (old orchestration flow). Only fires when polling is actually used
+ * (i.e. signaling URL is not a direct `ws://` / `wss://` endpoint).
+ * Observability-only — no state change.
+ */
+const pollingStarted = createAction(scoped `polling started`);
+const pollingEnded = createAction(scoped `polling ended`);
+/**
+ * Dispatched when the client has just sent an SDP answer back to Cirrus
+ * after receiving the server-initiated offer. Observability-only.
+ */
+const answerSent = createAction(scoped `answer sent`);
 const setOrchestrationMessage = createAction(scoped `set orchestration message`, props());
 const setOrchestrationProgress = createAction(scoped `set orchestration progress`, props());
 const setOrchestrationContext = createAction(scoped `set orchestration params`, props());
@@ -508,7 +551,6 @@ const unrealReducer = createReducer(initialState$1, on(changeLowBandwidth, (stat
 }), on(setUnrealPlaywrightConfig, (state) => {
     return {
         ...state,
-        isFirstSuccessLoad: true,
         cirrusConnected: true,
         viewportReady: true,
         dataChannelConnected: true,
@@ -541,7 +583,9 @@ function IceCandidateHandler(msg) {
 }
 
 function InstanceReadyHandler() {
-    //Do nothing here
+    // No state change — emit the action purely so services that want to
+    // observe orchestration progress (e.g. telemetry) have a hook.
+    this.store.dispatch(instanceReady());
 }
 
 function InstanceReservedHandler(msg) {
@@ -1169,6 +1213,7 @@ const selectTotalProgress = createSelector(unrealFeature.selectStatusPercentSign
 });
 const selectClientAndViewIds = createSelector(unrealFeature.selectStreamClientCompanyId, unrealFeature.selectStreamViewId, (clientId, viewId) => ({ clientId, viewId }));
 const selectIsLoaderScreenVisible = createSelector(unrealFeature.selectViewportReady, unrealFeature.selectDataChannelConnected, unrealFeature.selectCirrusConnected, (viewReady, cirrusConnected, dataChannelConnected) => !viewReady || !cirrusConnected || !dataChannelConnected);
+const selectCirrusConnectionId = createSelector(unrealFeature.selectSsData, (data) => data?.connectionId);
 
 class UnrealErrorModalComponent {
     constructor() {
@@ -2580,7 +2625,9 @@ class SignallingService extends SubService {
         this.correlationId = generateUuid();
         this.commandTelemetryService.reset();
         this.startEstablishingConnection();
-        return defer(() => this.getRegion().pipe(tap((region) => this.region.set(region ?? '')), map$1((region) => this.adaptUrlsToRegion(urlList, region)), switchMap((urls) => this.getAwsInstance(urls).pipe(take(1))), tap((awsInstance) => this.store.dispatch(setAwsInstance(awsInstance))), switchMap(({ wsUrl }) => this.connectToCirrus(wsUrl ?? '').pipe(filter(Truthy), take(1))), takeUntil(this.abort$))).pipe(
+        return defer(() => {
+            return this.getRegion().pipe(tap((region) => this.region.set(region ?? '')), map$1((region) => this.adaptUrlsToRegion(urlList, region)), switchMap((urls) => this.getAwsInstance(urls).pipe(take(1))), tap((awsInstance) => this.store.dispatch(setAwsInstance(awsInstance))), switchMap(({ wsUrl }) => this.connectToCirrus(wsUrl ?? '').pipe(filter(Truthy), take(1))), takeUntil(this.abort$));
+        }).pipe(
         // Retry the whole attempt on error, advancing to the next URL each time.
         retry({
             delay: (err, attempt) => {
@@ -2714,6 +2761,9 @@ class SignallingService extends SubService {
                     };
                 }));
             }
+            // Old (HTTP-polling) orchestration flow — mark the roundtrip so
+            // the signaling-phase timeline can show it as a distinct segment.
+            this.store.dispatch(pollingStarted());
             return this.store.select(selectClientAndViewIds).pipe(
             // Log missing IDs without altering the stream.
             tap(({ clientId, viewId }) => {
@@ -2746,6 +2796,7 @@ class SignallingService extends SubService {
             }), 
             // Map a valid orchestration payload into the final AwsInstance.
             map$1((data) => {
+                this.store.dispatch(pollingEnded());
                 const wsUrl = httpUrlToWs(`${location.protocol}//${data.signallingServer}`);
                 return {
                     wsUrl,
@@ -3413,6 +3464,9 @@ class WebRtcPlayerService extends SubService {
             answer.sdp = this.mungeSDP(answer.sdp ?? '');
             await pcClient.setLocalDescription(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());
         }
         catch (e) {
             Logger.error("Couldn't create answer", e);
@@ -4485,6 +4539,7 @@ class InputService extends SubService {
 class RegionsPingService {
     constructor() {
         this.httpClient = inject(HttpClient);
+        this.store = inject(Store);
         this.unrealInitialConfig = inject(UNREAL_CONFIG, { optional: true });
         this.config = {
             ping_count: 2,
@@ -4494,7 +4549,15 @@ class RegionsPingService {
         };
     }
     getFastest(regionListUrl = this.unrealInitialConfig?.regionsPingUrl || '') {
-        return this.getProviders(regionListUrl).pipe(switchMap((providers) => this.getPingResult(providers)), catchError(() => of(null)), tapLog('PingResult'), map$1((data) => data?.region_code));
+        // 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
+        // straight from `PingResult.result` — no aggregation.
+        this.store.dispatch(regionPingFetchStart());
+        return this.getProviders(regionListUrl).pipe(tap(() => this.store.dispatch(regionPingFetchEnd())), switchMap((providers) => this.getPingResult(providers)), catchError(() => of(null)), tapLog('PingResult'), tap((data) => this.store.dispatch(regionResolved({
+            region: data?.region_code ?? '',
+            pingsMs: data?.result ?? [],
+        }))), map$1((data) => data?.region_code));
     }
     getPingResult(providers) {
         const regions = providers.regions;
@@ -4583,11 +4646,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.10", ngImpo
         }] });
 
 class StreamStatusTelemetryService {
-    #store;
-    #videoService;
     constructor() {
-        this.#store = inject(Store);
-        this.#videoService = inject(VideoService);
+        this.store = inject(Store);
+        this.actions$ = inject(Actions);
+        this.videoService = inject(VideoService);
         this.unrealConfig = inject(UNREAL_CONFIG, { optional: true });
         this.init();
     }
@@ -4595,13 +4657,47 @@ class StreamStatusTelemetryService {
         if (this.unrealConfig?.playwright) {
             return;
         }
-        this.#videoService.videoStats$
-            .pipe(withLatestFrom(this.#store.select(unrealFeature.selectAwsInstance), this.#store.select(unrealFeature.selectLowBandwidth), this.#store.select(unrealFeature.selectLowBandwidthStats), this.#store.select(unrealFeature.selectCirrusConnected)), auditTime(5000), filter(([, , , , cirrusConnected]) => cirrusConnected), map$1(([data, signalingServer, isLowBandwidth, lbmStats]) => this.mapEventData(data, signalingServer, isLowBandwidth, lbmStats)))
+        // Start a telemetry session on every `initSignalling` dispatch.
+        // switchMap cancels the previous session's inner pipeline on re-init.
+        // throttleTime leading+trailing emits the first event immediately and
+        // at most one event every 5s afterward.
+        this.actions$
+            .pipe(ofType(initSignalling), switchMap$1(() => {
+            // Captured once per session — marks the UTC moment signaling started.
+            const startedAt = Date.now();
+            const startTimeUtc = new Date(startedAt).toISOString();
+            const signalingReadyTime$ = this.readyTimeSince(this.store.select(unrealFeature.selectCirrusConnected), startedAt);
+            const viewPortReadyTime$ = this.readyTimeSince(this.store.select(unrealFeature.selectViewportReady), startedAt);
+            return this.videoService.videoStats$.pipe(throttleTime(5000, asyncScheduler, {
+                leading: true,
+                trailing: true,
+            }), withLatestFrom(this.store.select(unrealFeature.selectAwsInstance), this.store.select(unrealFeature.selectLowBandwidth), this.store.select(unrealFeature.selectLowBandwidthStats), signalingReadyTime$, viewPortReadyTime$), map$1(([data, signalingServer, isLowBandwidth, lbmStats, signalingReadyTime, viewPortReadyTime,]) => this.mapEventData({
+                data,
+                signalingServer,
+                isLowBandwidth,
+                lbmStats,
+                startTimeUtc,
+                signalingReadyTime,
+                viewPortReadyTime,
+            })));
+        }))
             .subscribe((data) => this.trackEventToMixPanel(data));
     }
-    mapEventData(data, signalingServer, isLowBandwidth, lbmStats) {
+    /**
+     * Emits `undefined` until `readyState$` first emits a truthy value,
+     * then emits the ms elapsed since `startedAt` and completes.
+     * Used with `withLatestFrom` so events carry a stable duration for the whole session.
+     */
+    readyTimeSince(readyState$, startedAt) {
+        return readyState$.pipe(filter(Boolean), take$1(1), map$1(() => Date.now() - startedAt), startWith$1(undefined));
+    }
+    mapEventData(params) {
+        const { data, signalingServer, isLowBandwidth, lbmStats, startTimeUtc, signalingReadyTime, viewPortReadyTime, } = params;
         const { bitrate, VideoEncoderQP, framesPerSecond, frameWidth, frameHeight, jitter, packetsLost, currentRoundTripTime, runTime, } = data.aggregatedStats;
         return {
+            startTimeUtc,
+            signalingReadyTime,
+            viewPortReadyTime,
             runTime,
             frameWidth,
             frameHeight,
@@ -4619,7 +4715,7 @@ class StreamStatusTelemetryService {
         };
     }
     trackEventToMixPanel(data) {
-        this.#store.dispatch(trackMixpanelEvent({ event: 'streamStatus', data }));
+        this.store.dispatch(trackMixpanelEvent({ event: 'streamStatus', data }));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.10", ngImport: i0, type: StreamStatusTelemetryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.10", ngImport: i0, type: StreamStatusTelemetryService }); }
@@ -4628,6 +4724,707 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.10", ngImpo
             type: Injectable
         }], ctorParameters: () => [] });
 
+const QP_RED_THRESHOLD = 35;
+const FPS_LOW_RATIO = 0.7; // p50 fps below 70% of target
+const UNLIMITED_REFERENCE_FPS = 60;
+const SAMPLE_WINDOW_MS = 5000;
+// Persistent per-browser identifier — survives page reloads. Used to group
+// multiple sessions of the same anonymous user for funnel / retention analysis.
+const USER_ID_STORAGE_KEY = 'sourceui.streamTelemetry.userId';
+class StreamStatusTelemetryService2 {
+    constructor() {
+        this.store = inject(Store);
+        this.actions$ = inject(Actions);
+        this.videoService = inject(VideoService);
+        this.signallingService = inject(SignallingService);
+        this.unrealConfig = inject(UNREAL_CONFIG, { optional: true });
+        /**
+         * Per-browser anonymous user id. Read from `localStorage` on first access;
+         * if missing, a new UUID is generated and persisted. Included as
+         * `data.userId` on every emitted event — the server uses it to bucket
+         * per-session files under `data/<userId>/<sessionId>.jsonl`.
+         */
+        this.userId = this.getOrCreateUserId();
+        this.session = null;
+        /**
+         * Whether a session has already started during the current page lifetime.
+         * Used to distinguish a fresh page load (bootstrap measurement is
+         * meaningful) from a Resume/restart (the document is already loaded,
+         * so "bootstrap" is a no-op). Only the first session gets the bootstrap
+         * phase anchored at navigation start (perf.now() === 0).
+         */
+        this.hasStartedBefore = false;
+        /**
+         * Rolling snapshot of the currently selected WebRTC ICE candidate pair
+         * (local/remote type + url). Scanned over `videoStats$` so the stream
+         * *keeps* the first non-null pair even if later stats emit null — WebRTC
+         * doesn't un-select a pair mid-session, but the source is nullable. The
+         * `startWith(null)` seed makes `withLatestFrom` on this stream safe even
+         * before the first video stat arrives (common at data-channel-open).
+         */
+        this.selectedPair$ = this.videoService.videoStats$.pipe(map((s) => s.aggregatedStats.selectedPair ?? null), scan((acc, curr) => curr ?? acc, null), startWith(null));
+        /**
+         * Correlation-matched Observable: emits once when the first `loopBack`
+         * command's corresponding `command completed` action fires. Built from
+         * the two related actions — the command-started captures the correlation
+         * id, the command-completed with that id emits.
+         */
+        this.loopbackReceived$ = this.actions$.pipe(ofType(commandStarted), filter$1(({ command }) => command === 'loopBack'), take(1), switchMap(({ id }) => this.actions$.pipe(ofType(commandCompleted), filter$1((b) => b.id === id), take(1))));
+        // Overlay-referenced milestones — hoisted as fields so both
+        // `milestones: [...]` and `overlays: [...]` share the same object
+        // identity (the in-session Map keys milestones by that identity).
+        this.pollingStartedEntry = {
+            label: 'Polling started (HTTP orchestration)',
+            event: this.actions$.pipe(ofType(pollingStarted)),
+        };
+        this.awsInstanceResolvedEntry = {
+            label: 'Instance WS URL resolved',
+            event: this.actions$.pipe(ofType(setAwsInstance)),
+        };
+        this.loopbackReceivedEntry = {
+            label: 'LoopBack received',
+            event: this.loopbackReceived$,
+        };
+        this.signalingServerConnectedEntry = {
+            label: 'Websocket connected',
+            event: this.store
+                .select(unrealFeature.selectCirrusConnected)
+                .pipe(filter$1(Boolean), take(1)),
+        };
+        this.configReceivedEntry = {
+            label: 'Config received',
+            event: this.signallingService.onConfig$.pipe(filter$1(Boolean), take(1)),
+        };
+        /**
+         * Unified phase catalog — the single source of truth for everything
+         * this service tracks after `session_started`. Each entry is a phase;
+         * its `milestones` array is ordered chronologically and the *last*
+         * entry is the phase closer. When that closer's observable fires, the
+         * service emits one generic `stream.phase_ended` wire event with every
+         * display field the viewer needs.
+         *
+         * `phaseNo` is the array index; `startPhase` chains from the previous
+         * phase's `endPhase` — neither needs to be specified here.
+         */
+        this.phaseCatalog = [
+            {
+                label: 'Region resolving',
+                color: '#61afef',
+                milestones: [
+                    {
+                        label: 'Region ping fetch start',
+                        event: this.actions$.pipe(ofType(regionPingFetchStart)),
+                    },
+                    {
+                        label: 'Region ping fetch end',
+                        event: this.actions$.pipe(ofType(regionPingFetchEnd)),
+                    },
+                    // CLOSER — the `regionResolved` action carries the raw ping
+                    // samples (one per probe) from `RegionsPingService`; the
+                    // catalog flattens them to a comma-separated string since
+                    // `toPhaseParams` only accepts primitives.
+                    {
+                        label: 'Region resolved',
+                        event: this.actions$.pipe(ofType(regionResolved), take(1), map(({ region, pingsMs }) => ({
+                            region,
+                            pingsMs: pingsMs.length ? `${pingsMs.join(', ')} ms` : null,
+                        }))),
+                    },
+                ],
+            },
+            {
+                label: 'Signaling connection',
+                color: '#c678dd',
+                overlays: [
+                    {
+                        from: this.pollingStartedEntry,
+                        to: this.awsInstanceResolvedEntry,
+                        title: 'Polling → instance resolved (HTTP polling + AWS instance handle)',
+                    },
+                    {
+                        from: this.signalingServerConnectedEntry,
+                        to: this.configReceivedEntry,
+                        title: 'Signaling handshake (WS open → Cirrus config received)',
+                    },
+                ],
+                milestones: [
+                    this.pollingStartedEntry,
+                    {
+                        label: 'Polling ended (HTTP orchestration)',
+                        event: this.actions$.pipe(ofType(pollingEnded)),
+                    },
+                    this.awsInstanceResolvedEntry,
+                    this.signalingServerConnectedEntry,
+                    {
+                        label: 'Instance reserved (WS orchestration)',
+                        event: this.actions$.pipe(ofType(setOrchestrationParameters)),
+                    },
+                    {
+                        label: 'Instance ready (WS orchestration)',
+                        event: this.actions$.pipe(ofType(instanceReady)),
+                    },
+                    this.configReceivedEntry,
+                    {
+                        label: 'SSInfo received',
+                        event: this.store.select(unrealFeature.selectSsData).pipe(filter$1(Boolean), take(1), withLatestFrom$1(this.store.select(unrealFeature.selectAwsInstance)), map(([ssData, aws]) => ({
+                            client: aws.wsUrl,
+                            instanceName: aws.instanceName,
+                            ...ssData,
+                        }))),
+                    },
+                ],
+            },
+            {
+                label: 'WebRTC negotiation',
+                color: '#e5c07b',
+                milestones: [
+                    {
+                        label: 'Offer received',
+                        event: this.signallingService.onOffer$.pipe(filter$1(Boolean)),
+                    },
+                    {
+                        label: 'Answer sent (server-offer flow)',
+                        event: this.actions$.pipe(ofType(answerSent)),
+                    },
+                    {
+                        label: 'Answer received (client-offer flow)',
+                        event: this.signallingService.onWebRtcAnswer$.pipe(filter$1(Boolean)),
+                    },
+                    {
+                        label: 'First ICE candidate from server',
+                        event: this.signallingService.onWebRtcIce$.pipe(filter$1(Boolean)),
+                    },
+                    {
+                        label: 'Last ICE candidate from server',
+                        event: this.signallingService.onWebRtcIce$.pipe(filter$1(Boolean)),
+                        mode: 'last',
+                    },
+                    // CLOSER — snaps negotiation diagnostics and the Cirrus
+                    // streamer identity (`ssData`, reliably populated by DC-open
+                    // time) into phase-3 params:
+                    //  - `iceCandidateCount` (total ICE candidates from server — too
+                    //    few hints at a restrictive network)
+                    //  - `handshakeFlow` (server-offer vs client-offer; we only use
+                    //    server-offer today, but the detector stays in place)
+                    //  - `instanceType` / `branchInfo` / version / path / app /
+                    //    `connectionId` (streamer identity, from `ssInfo` message)
+                    {
+                        label: 'Data channel connected',
+                        event: this.store
+                            .select(unrealFeature.selectDataChannelConnected)
+                            .pipe(filter$1(Boolean), take(1), map(() => ({
+                            iceCandidateCount: this.session?.iceCandidateCount ?? 0,
+                            handshakeFlow: this.session?.handshakeFlow ?? null,
+                        }))),
+                    },
+                ],
+            },
+            {
+                label: 'Unreal communication',
+                color: '#98c379',
+                overlays: [
+                    {
+                        from: this.loopbackReceivedEntry,
+                        title: 'Stabilization (warm up)',
+                    },
+                ],
+                milestones: [
+                    {
+                        label: 'First command started',
+                        event: this.actions$.pipe(ofType(commandStarted)),
+                    },
+                    {
+                        label: 'LoopBack sent',
+                        event: this.actions$.pipe(ofType(commandStarted), filter$1(({ command }) => command === 'loopBack')),
+                    },
+                    this.loopbackReceivedEntry,
+                    // CLOSER — flattens the selected ICE candidate pair into two
+                    // string params (local / remote), and snapshots the running
+                    // command counter so phase 5 shows how many commands the client
+                    // fired at Unreal before the viewport was ready.
+                    {
+                        label: 'Viewport ready',
+                        event: this.store.select(unrealFeature.selectViewportReady).pipe(filter$1(Boolean), take(1), withLatestFrom$1(this.selectedPair$), map(([, selectedPair]) => ({
+                            localCandidate: fmtCandidate(selectedPair?.local),
+                            remoteCandidate: fmtCandidate(selectedPair?.remote),
+                            commandCount: this.session?.commandCount ?? 0,
+                        }))),
+                    },
+                ],
+            },
+        ];
+        if (this.unrealConfig?.playwright)
+            return;
+        if (!this.unrealConfig?.streamTelemetryV2)
+            return;
+        this.init();
+    }
+    getOrCreateUserId() {
+        try {
+            const existing = localStorage.getItem(USER_ID_STORAGE_KEY);
+            if (existing && existing.length > 0)
+                return existing;
+            const fresh = v4();
+            localStorage.setItem(USER_ID_STORAGE_KEY, fresh);
+            return fresh;
+        }
+        catch {
+            // localStorage disabled (private-mode restrictions, quota, etc.)
+            // Fall back to a per-tab ephemeral id so telemetry keeps working.
+            return v4();
+        }
+    }
+    init() {
+        // Start a new session on every initSignalling dispatch.
+        this.actions$
+            .pipe(ofType(initSignalling))
+            .subscribe(() => this.startSession());
+        // End the current session when Cirrus drops (true → false transition).
+        this.store
+            .select(unrealFeature.selectCirrusConnected)
+            .pipe(pairwise(), filter$1(([prev, curr]) => prev && !curr))
+            .subscribe(() => this.endSession('disconnected'));
+        // Close the session when the tab is hidden / being evicted from bfcache.
+        // `pagehide` fires in more cases than `beforeunload` (covers iOS Safari, bfcache).
+        fromEvent(window, 'pagehide').subscribe(() => this.endSession('pagehide'));
+    }
+    startSession() {
+        // If a previous session is still active, close it first.
+        this.endSession('restart');
+        const id = v4();
+        const startedAt = Date.now();
+        const startedAtPerf = performance.now();
+        const sub = new Subscription();
+        // Anchor selection:
+        //  - First session on this page → anchor at navigation start (0).
+        //    `performance.now()` is already "ms since navigation start", so
+        //    `session_started.duration` becomes the full page-load + idle-time
+        //    leading up to the first stream start (i.e. the real bootstrap).
+        //  - Resume/restart sessions → anchor at the session's own start.
+        //    The document is already loaded — a "bootstrap" phase would either
+        //    balloon (to include all prior idle time) or be misleading, so we
+        //    suppress it by making the anchor == session_started.
+        const isFirstSession = !this.hasStartedBefore;
+        this.hasStartedBefore = true;
+        const anchorPerf = isFirstSession ? 0 : startedAtPerf;
+        const times = new Map();
+        this.session = {
+            id,
+            startedAt,
+            startedAtPerf,
+            anchorPerf,
+            // Initial milestone anchor = anchorPerf. For the first session this is
+            // navigation start (0), so `session_started.duration` becomes the full
+            // page-load elapsed. For Resume sessions anchor == startedAtPerf, so
+            // `session_started.duration` is 0 (no bootstrap phase).
+            lastMilestonePerf: anchorPerf,
+            seq: 0,
+            sub,
+            qpBad: false,
+            fpsLow: false,
+            maxFpsTarget: UNLIMITED_REFERENCE_FPS,
+            iceCandidateCount: 0,
+            handshakeFlow: null,
+            commandCount: 0,
+            times,
+        };
+        // Side-channel counters for WebRTC negotiation diagnostics — shown
+        // as phase-3 params on the `datachannel_connected` closer. Kept
+        // imperative (session-scoped) so no RxJS hot-stream plumbing is
+        // needed to survive the subscribe-on-close timing.
+        sub.add(this.signallingService.onWebRtcIce$
+            .pipe(filter$1(Boolean))
+            .subscribe(() => {
+            if (this.session)
+                this.session.iceCandidateCount++;
+        }));
+        sub.add(this.actions$.pipe(ofType(answerSent), take(1)).subscribe(() => {
+            if (this.session)
+                this.session.handshakeFlow = 'server-offer';
+        }));
+        sub.add(this.signallingService.onWebRtcAnswer$
+            .pipe(filter$1(Boolean), take(1))
+            .subscribe(() => {
+            if (this.session)
+                this.session.handshakeFlow = 'client-offer';
+        }));
+        // Unreal-command counter — increments on every `commandStarted`
+        // action. Snapshotted into the `viewport_ready` closer payload as
+        // phase-5's `commandCount`.
+        sub.add(this.actions$.pipe(ofType(commandStarted)).subscribe(() => {
+            if (this.session)
+                this.session.commandCount++;
+        }));
+        // Unified catalog loop — one subscription per entry. Non-closers
+        // record their emission time into the session map. The *last* entry
+        // of each phase is the closer: its emission fires a single generic
+        // `stream.phase_ended` event carrying every display field the viewer
+        // needs. The viewer never inspects milestone names or phase kinds;
+        // adding a new phase to `phaseCatalog` is enough — zero viewer work.
+        this.phaseCatalog.forEach((bucket, bucketIdx) => {
+            bucket.milestones.forEach((entry, idx) => {
+                const isCloser = idx === bucket.milestones.length - 1;
+                sub.add(entry.event.subscribe((value) => {
+                    if (!this.session)
+                        return;
+                    if (isCloser) {
+                        this.emitPhaseEnded(bucket, bucketIdx, value);
+                        return;
+                    }
+                    const time = Math.round(performance.now() - this.session.anchorPerf);
+                    if (entry.mode !== 'last' && this.session.times.has(entry))
+                        return;
+                    this.session.times.set(entry, time);
+                }));
+            });
+        });
+        const bootstrapInfo = this.collectBootstrapInfo();
+        this.emitLifecycle('stream.session_started', {
+            sessionId: id,
+            startTimeUtc: new Date(startedAt).toISOString(),
+            pixelRatio: window.devicePixelRatio,
+            // Browser viewport size at session start (`window.innerWidth` /
+            // `innerHeight`). Named `browserInnerSize` to distinguish from
+            // the physical screen — what gates the rendered video resolution
+            // is the container we started from, not the device hardware.
+            browserInnerSize: {
+                width: window.innerWidth,
+                height: window.innerHeight,
+            },
+            userAgent: navigator.userAgent,
+            sampleWindowMs: SAMPLE_WINDOW_MS,
+            // Full page URL — `location.href` is the only reliable way to get this.
+            // The server-observed `Referer` header is truncated to origin for
+            // cross-origin requests by default Referrer-Policy.
+            pageUrl: window.location.href,
+            // Navigation / page-load context for the "app bootstrap → session_started"
+            // waterfall phase. Only useful for the first session (`bootstrap` phase
+            // is suppressed on Resume), but `bootstrapInfo` describes the document,
+            // not the session — harmless and cheap to send either way.
+            ...(bootstrapInfo && { bootstrapInfo }),
+        }, 
+        // Pin the milestone to the captured `performance.now()` so `duration`
+        // equals "ms since navigation start" precisely (for first sessions),
+        // rather than being inflated by any synchronous setup done in between.
+        startedAtPerf);
+        // Track current maxFps target to evaluate FPS-ratio anomalies.
+        sub.add(this.actions$
+            .pipe(ofType(setMaxFps))
+            .subscribe(({ maxFps }) => this.updateMaxFpsTarget(maxFps)));
+        // Periodic aggregated sample — every 5s window.
+        sub.add(this.videoService.videoStats$
+            .pipe(bufferTime(SAMPLE_WINDOW_MS), filter$1((samples) => samples.length > 0))
+            .subscribe((samples) => this.handleWindow(samples)));
+    }
+    endSession(reason) {
+        if (!this.session)
+            return;
+        const { id, sub } = this.session;
+        this.emitLifecycle('stream.session_ended', {
+            sessionId: id,
+            reason,
+            timestamp: new Date().toISOString(),
+        });
+        sub.unsubscribe();
+        this.session = null;
+    }
+    /**
+     * Emit a lifecycle event with a `duration` field — ms between the
+     * previous lifecycle event and now (phase-local, NOT anchor-relative).
+     * For `session_started` this equals the full page-load elapsed on the
+     * first session, or 0 on Resume. Advances `lastMilestonePerf` so the
+     * next event's duration is correctly rooted.
+     */
+    emitLifecycle(event, extra, atPerf) {
+        if (!this.session)
+            return;
+        // `atPerf` lets callers pin the milestone to a specific `performance.now()`
+        // value — useful for `session_started` where the wall-clock and perf-clock
+        // anchors were already captured at the top of `startSession()`.
+        const now = atPerf ?? performance.now();
+        const duration = Math.round(now - this.session.lastMilestonePerf);
+        this.track(event, { duration, ...extra });
+        this.session.lastMilestonePerf = now;
+    }
+    /**
+     * Emit the unified `stream.phase_ended` wire event for a closer. Packs
+     * every display field the viewer consumes — phaseNo (derived from the
+     * catalog index), label, color, milestones, params, overlays. Boundary
+     * labels aren't on the wire — the viewer derives them from neighbour
+     * phases' `label` fields.
+     */
+    emitPhaseEnded(bucket, bucketIdx, extrasValue) {
+        if (!this.session)
+            return;
+        const now = performance.now();
+        const phaseStartMs = Math.round(this.session.lastMilestonePerf - this.session.anchorPerf);
+        const phaseEndMs = Math.round(now - this.session.anchorPerf);
+        const milestones = this.milestonesOfBucket(bucket);
+        const params = toPhaseParams(extrasValue);
+        const overlays = resolveOverlays(bucket.overlays, this.session.times, phaseStartMs, phaseEndMs);
+        this.emitLifecycle('stream.phase_ended', {
+            sessionId: this.session.id,
+            phaseNo: bucketIdx + 1,
+            label: bucket.label,
+            color: bucket.color,
+            milestones,
+            params,
+            overlays,
+        });
+    }
+    handleWindow(samples) {
+        if (!this.session)
+            return;
+        const s = this.session;
+        const bitrate = this.aggregate(samples.map((x) => x.aggregatedStats.bitrate ?? 0));
+        const fps = this.aggregate(samples.map((x) => x.aggregatedStats.framesPerSecond ?? 0));
+        const qp = this.aggregate(samples.map((x) => x.aggregatedStats.VideoEncoderQP ?? 0));
+        const jitter = this.aggregate(samples.map((x) => x.aggregatedStats.jitter ?? 0));
+        const rtt = this.aggregate(samples.map((x) => x.aggregatedStats.currentRoundTripTime ?? 0));
+        const latest = samples[samples.length - 1]?.aggregatedStats;
+        // Periodic sample event.
+        this.track('stream.sample', {
+            sessionId: s.id,
+            seq: s.seq++,
+            timestamp: new Date().toISOString(),
+            sampleCount: samples.length,
+            // Tab visibility state at emission time. Chrome does NOT throttle timers
+            // for WebRTC-active tabs, so the handler runs on time even when hidden —
+            // the point-in-time read is reliable in this specific context.
+            visibilityState: document.visibilityState,
+            bitrate,
+            fps,
+            qp,
+            jitter,
+            rtt,
+            packetsLost: latest?.packetsLost,
+            viewPort: {
+                width: latest?.frameWidth,
+                height: latest?.frameHeight,
+            },
+        });
+        this.evaluateAnomalies(fps, qp);
+    }
+    evaluateAnomalies(fps, qp) {
+        if (!this.session)
+            return;
+        const s = this.session;
+        // Quality (QP red) entry/exit.
+        const qpBadNow = qp.p50 > QP_RED_THRESHOLD;
+        if (qpBadNow !== s.qpBad) {
+            s.qpBad = qpBadNow;
+            this.track(qpBadNow ? 'stream.quality_degraded' : 'stream.quality_recovered', {
+                sessionId: s.id,
+                seq: s.seq,
+                timestamp: new Date().toISOString(),
+                qpP50: qp.p50,
+                qpP95: qp.p95,
+            });
+        }
+        // FPS low vs current target.
+        const ref = s.maxFpsTarget > 0 ? s.maxFpsTarget : UNLIMITED_REFERENCE_FPS;
+        const fpsLowNow = fps.p50 < ref * FPS_LOW_RATIO;
+        if (fpsLowNow && !s.fpsLow) {
+            this.track('stream.fps_low', {
+                sessionId: s.id,
+                seq: s.seq,
+                timestamp: new Date().toISOString(),
+                target: s.maxFpsTarget,
+                referenceTarget: ref,
+                fpsP50: fps.p50,
+                fpsP95: fps.p95,
+            });
+        }
+        s.fpsLow = fpsLowNow;
+    }
+    updateMaxFpsTarget(maxFps) {
+        if (this.session)
+            this.session.maxFpsTarget = maxFps;
+    }
+    /**
+     * Snapshot every milestone recorded in this session that belongs to
+     * {@link phase}. Used to attach a phase's milestone array to the
+     * lifecycle event that closes that phase.
+     */
+    /**
+     * Collect wire-shape milestones that fired within a bucket. Walks the
+     * catalog's own milestone list (minus the closer) and pulls each
+     * entry's time from the in-session map via object identity.
+     */
+    milestonesOfBucket(bucket) {
+        if (!this.session)
+            return [];
+        const out = [];
+        const closerIdx = bucket.milestones.length - 1;
+        for (let i = 0; i < closerIdx; i++) {
+            const entry = bucket.milestones[i];
+            const time = this.session.times.get(entry);
+            if (time !== undefined)
+                out.push({ label: entry.label, time });
+        }
+        return out;
+    }
+    /**
+     * Capture browser navigation timings — useful to explain the
+     * "application bootstrap → session_started" waterfall phase.
+     * Values are ms from navigation start; null if the entry is unavailable
+     * (old browsers, cross-origin iframes with limited perf access, etc.).
+     */
+    collectBootstrapInfo() {
+        try {
+            const nav = performance.getEntriesByType('navigation')[0];
+            if (!nav)
+                return null;
+            return {
+                type: nav.type, // 'navigate' | 'reload' | 'back_forward' | 'prerender'
+                protocol: nav.nextHopProtocol || null, // 'h2' / 'h3' / 'http/1.1'
+                firstByteMs: Math.round(nav.responseStart),
+                domInteractiveMs: Math.round(nav.domInteractive),
+                domContentLoadedMs: Math.round(nav.domContentLoadedEventEnd),
+                loadEventMs: Math.round(nav.loadEventEnd),
+                // Navigation-only size — the HTML document itself. Usually small;
+                // the interesting number is `resources.transferSize` below.
+                navigationTransferSize: nav.transferSize || null,
+                navigationEncodedBodySize: nav.encodedBodySize || null,
+                navigationDecodedBodySize: nav.decodedBodySize || null,
+                resources: this.collectResourceTotals(),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Aggregate all resources the browser has loaded so far
+     * (`performance.getEntriesByType('resource')`), grouped by `initiatorType`.
+     * Gives a real "bytes downloaded before session start" figure — unlike the
+     * navigation entry which only covers the HTML document.
+     *
+     * `transferSize === 0 && decodedBodySize > 0` means the resource came from
+     * the HTTP cache — counted separately so cached hits don't inflate
+     * the "bytes on the wire" metric.
+     */
+    collectResourceTotals() {
+        try {
+            const list = performance.getEntriesByType('resource');
+            if (!list.length)
+                return null;
+            const empty = () => ({
+                count: 0,
+                cachedCount: 0,
+                transferSize: 0,
+                encodedBodySize: 0,
+                decodedBodySize: 0,
+            });
+            const totals = empty();
+            const byType = {};
+            for (const r of list) {
+                const type = r.initiatorType || 'other';
+                const b = (byType[type] ||= empty());
+                const fromCache = r.transferSize === 0 && r.decodedBodySize > 0;
+                const t = r.transferSize || 0;
+                const enc = r.encodedBodySize || 0;
+                const dec = r.decodedBodySize || 0;
+                b.count++;
+                if (fromCache)
+                    b.cachedCount++;
+                b.transferSize += t;
+                b.encodedBodySize += enc;
+                b.decodedBodySize += dec;
+                totals.count++;
+                if (fromCache)
+                    totals.cachedCount++;
+                totals.transferSize += t;
+                totals.encodedBodySize += enc;
+                totals.decodedBodySize += dec;
+            }
+            return { ...totals, byType };
+        }
+        catch {
+            return null;
+        }
+    }
+    aggregate(values) {
+        if (values.length === 0)
+            return { p50: 0, p95: 0, min: 0, max: 0 };
+        const sorted = [...values].sort((a, b) => a - b);
+        // Nearest-rank method: p-th percentile ≡ sorted[ceil(p/100 * n) - 1].
+        // Using `floor` would make p95 collapse to `max` for n=20
+        // (floor(0.95*20) = 19 = max index), hiding the max line behind p95
+        // in charts. `ceil - 1` keeps them distinct: p95 = sorted[18], max = sorted[19].
+        const pick = (p) => {
+            const idx = Math.ceil((p / 100) * sorted.length) - 1;
+            return sorted[Math.max(0, Math.min(sorted.length - 1, idx))];
+        };
+        return {
+            p50: pick(50),
+            p95: pick(95),
+            min: sorted[0],
+            max: sorted[sorted.length - 1],
+        };
+    }
+    track(event, data) {
+        // `userId` is attached to every event so the server can bucket files
+        // under `data/<userId>/<sessionId>.jsonl` without maintaining a
+        // session→user index.
+        this.store.dispatch(trackTelemetryData({
+            event,
+            data: { userId: this.userId, ...data },
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.10", ngImport: i0, type: StreamStatusTelemetryService2, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.10", ngImport: i0, type: StreamStatusTelemetryService2 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.10", ngImport: i0, type: StreamStatusTelemetryService2, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+// ──────────────────────────────────────────────────────────────────
+// Module-scope helpers — keep the class body focused on RxJS wiring.
+// ──────────────────────────────────────────────────────────────────
+/** Compact one side of an ICE candidate pair to `"type (url)"` or just
+ *  `type` (host candidates have no URL). */
+function fmtCandidate(c) {
+    if (!c)
+        return null;
+    return c.url ? `${c.type} (${c.url})` : c.type;
+}
+/**
+ * Flatten the closer's emitted extras object into display key/value
+ * pairs. Null/undefined/empty are dropped; objects and arrays are
+ * skipped — they should be pre-formatted by the closer's `map(...)`.
+ */
+function toPhaseParams(value) {
+    if (!value || typeof value !== 'object')
+        return [];
+    const out = [];
+    for (const [key, v] of Object.entries(value)) {
+        if (v === null || v === undefined || v === '')
+            continue;
+        if (typeof v === 'object')
+            continue;
+        out.push({ key, value: String(v) });
+    }
+    return out;
+}
+/**
+ * Resolve declarative overlay recipes to absolute ms spans. Endpoints
+ * fall back to the phase's own start/end when unspecified; recipes
+ * whose referenced entry never fired are quietly skipped.
+ */
+function resolveOverlays(recipes, times, phaseStartMs, phaseEndMs) {
+    if (!recipes?.length)
+        return [];
+    const out = [];
+    for (const r of recipes) {
+        const fromMs = r.from ? (times.get(r.from) ?? null) : phaseStartMs;
+        const toMs = r.to ? (times.get(r.to) ?? null) : phaseEndMs;
+        if (fromMs === null || toMs === null || toMs <= fromMs)
+            continue;
+        out.push({ fromMs, toMs, title: r.title });
+    }
+    return out;
+}
+
 const ReceivedMimeTypes = {
     ApplicationJson: 'application/json',
 };
@@ -6089,12 +6886,14 @@ function provideUnrealModule() {
         AFKService,
         SignallingService,
         StreamStatusTelemetryService,
+        StreamStatusTelemetryService2,
         FpsMonitorService,
         WebRtcPlayerService,
         provideEnvironmentInitializer(() => {
             inject(AggregatorService);
             inject(InputService);
             inject(StreamStatusTelemetryService);
+            inject(StreamStatusTelemetryService2);
             inject(ConsoleExtensionsService);
             inject(AFKService);
             inject(FreezeFrameService);
@@ -6108,5 +6907,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, CommandsEffects, 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, DataFlowMonitor, DevModeService, DisconnectReason, FULL_HD_HEIGHT, FULL_HD_WIDTH, FileHandlerService, FileReceiverService, FilterSettingsComponent, FpsMonitorService, FreezeFrameComponent, FreezeFrameService, IceCandidateHandler, ImageLoadingSrcComponent, InputOptions, InputService, InstanceReadyHandler, InstanceReservedHandler, IntroSrcComponent, KalmanFilter1D, LatencyTimings, LowBandwidthDetectorComponent, LowBandwidthModalComponent, MINIMAL_FPS, 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_VIDEO_ID, SafePipe, SignallingService, SpecialKeyCodes, StatGraphComponent, StreamStatusTelemetryService, 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, changeLowBandwidth, changeStatusMainVideoOnScene, changeStreamResolutionAction, changeStreamResolutionSuccessAction, commandCompleted, commandStarted, commandsFeature, commandsReducer, dataChannelConnected, dataChannelReady, decodeData, destroyRemoteConnections, destroyUnrealScene, disconnectStream, dispatchResize, dropConnection, dropDC, dropPC, floatToSmoothPercents, forceResizeViewport, fromResizeObserver, getActiveUrl, getImageFromVideoStream, getResizeStudioValues, getResizeStudioValuesOld, getResizeValuesUniversal, getResizeValuesUniversalOld, getRtcErrorMessage, iceConnectionFailed, initSignalling, keepMaxUntilReset, makeEven, provideUnrealModule, qpToQuality, reconnectPeer, reconnectPeerFailed, reconnectPeerSuccess, resetAfk, resetConfig, resetDataChannelForReconnect, resetIntroSrc, resetWarnTimeout, saveAnalyticsEvent, selectClientAndViewIds, selectCommandProgress, selectCommandsInProgress, selectFreezeFrameCombinedDataUrl, selectFreezeFrameDataUrl, selectFreezeFrameDataUrlFromVideo, selectFreezeFrameProgressMessageFromVideo, selectIsAutostart, selectIsExistMatchUrls, selectIsFreezeFrameLoading, selectIsLoaderScreenVisible, selectIsVideoPlayingAndDataChannelConnected, selectShowLoader, selectShowReconnectPopup, selectSignalingParameters, selectStreamConfig, selectTotalProgress, selectWarnTimeout, setAfkTimerCountdown, setAfkTimerHide, setAfkTimerVisible, setAwsInstance, setCirrusConnected, setCirrusDisconnected, setConfig, setDataChannelConnected, setEstablishingConnection, setFreezeFrame, setFreezeFrameFromVideo, setIntroImageSrc, setIntroVideoSrc, setKalmanSettings, setLoadingImageSrc, setLoopBackCommandIsCompleted, setMaxFps, setOrchestrationContext, setOrchestrationMessage, setOrchestrationParameters, setOrchestrationProgress, setSignalingName, setStatusMessage, setStatusPercentSignallingServer, setStreamClientCompanyId, setStreamViewId, setUnrealPlaywrightConfig, setViewportNotReady, setViewportReady, showUnrealErrorMessage, smoothTransition, startStream, trackMixpanelEvent, 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, CommandsEffects, 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, DataFlowMonitor, DevModeService, DisconnectReason, FULL_HD_HEIGHT, FULL_HD_WIDTH, FileHandlerService, FileReceiverService, FilterSettingsComponent, FpsMonitorService, FreezeFrameComponent, FreezeFrameService, IceCandidateHandler, ImageLoadingSrcComponent, InputOptions, InputService, InstanceReadyHandler, InstanceReservedHandler, IntroSrcComponent, KalmanFilter1D, LatencyTimings, LowBandwidthDetectorComponent, LowBandwidthModalComponent, MINIMAL_FPS, 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_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, changeLowBandwidth, changeStatusMainVideoOnScene, changeStreamResolutionAction, changeStreamResolutionSuccessAction, commandCompleted, commandStarted, commandsFeature, commandsReducer, dataChannelConnected, dataChannelReady, decodeData, destroyRemoteConnections, destroyUnrealScene, disconnectStream, dispatchResize, dropConnection, dropDC, dropPC, floatToSmoothPercents, forceResizeViewport, fromResizeObserver, getActiveUrl, getImageFromVideoStream, getResizeStudioValues, getResizeStudioValuesOld, getResizeValuesUniversal, getResizeValuesUniversalOld, getRtcErrorMessage, iceConnectionFailed, initSignalling, instanceReady, keepMaxUntilReset, makeEven, pollingEnded, pollingStarted, provideUnrealModule, qpToQuality, reconnectPeer, reconnectPeerFailed, reconnectPeerSuccess, regionPingFetchEnd, regionPingFetchStart, regionResolved, resetAfk, resetConfig, resetDataChannelForReconnect, resetIntroSrc, resetWarnTimeout, saveAnalyticsEvent, selectCirrusConnectionId, selectClientAndViewIds, selectCommandProgress, selectCommandsInProgress, selectFreezeFrameCombinedDataUrl, selectFreezeFrameDataUrl, selectFreezeFrameDataUrlFromVideo, selectFreezeFrameProgressMessageFromVideo, selectIsAutostart, selectIsExistMatchUrls, selectIsFreezeFrameLoading, selectIsLoaderScreenVisible, selectIsVideoPlayingAndDataChannelConnected, selectShowLoader, selectShowReconnectPopup, selectSignalingParameters, selectStreamConfig, selectTotalProgress, selectWarnTimeout, setAfkTimerCountdown, setAfkTimerHide, setAfkTimerVisible, setAwsInstance, setCirrusConnected, setCirrusDisconnected, setConfig, setDataChannelConnected, setEstablishingConnection, setFreezeFrame, setFreezeFrameFromVideo, setIntroImageSrc, setIntroVideoSrc, setKalmanSettings, setLoadingImageSrc, setLoopBackCommandIsCompleted, setMaxFps, setOrchestrationContext, setOrchestrationMessage, setOrchestrationParameters, setOrchestrationProgress, setSignalingName, setStatusMessage, setStatusPercentSignallingServer, setStreamClientCompanyId, setStreamViewId, setUnrealPlaywrightConfig, setViewportNotReady, setViewportReady, showUnrealErrorMessage, smoothTransition, startStream, trackMixpanelEvent, trackTelemetryData, unrealCommandCallback, unrealFeature, unrealReducer, updateCirrusInfo, videoAdaptedToContainer, videoStreamInitialized };
 //# sourceMappingURL=3dsource-angular-unreal-module.mjs.map