@3dsource/angular-unreal-module 0.0.146-dev.5 → 0.0.146-dev.7

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

@@ -444,6 +444,7 @@ const initialState = {
     isAfkTimerVisible: false,
     afkCountdown: 0,
     cirrusConnected: false,
+    adopted: false,
     establishingConnection: false,
     isReconnecting: false,
     viewportReady: false,
@@ -580,7 +581,11 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
         },
     };
 }), on(initSignalling, (state) => {
-    return { ...state, disconnectReason: DisconnectReason.None };
+    return {
+        ...state,
+        adopted: false,
+        disconnectReason: DisconnectReason.None,
+    };
 }), on(reconnectPeerSuccess, (state) => {
     return { ...state, isReconnecting: false };
 }), on(setSignalingName, (state, { instanceName }) => {
@@ -647,6 +652,7 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
     return {
         ...state,
         cirrusConnected: true,
+        adopted: true,
         ssData: ssData ?? state.ssData,
         awsInstance: {
             ...state.awsInstance,
@@ -677,6 +683,7 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
     return {
         ...state,
         cirrusConnected: false,
+        adopted: false,
         dataChannelConnected: false,
         viewportReady: false,
         isVideoPlaying: false,
@@ -3613,20 +3620,30 @@ class StreamAdoptionService {
      * this in `takeUntil(abortEstablishingConnection)`, so a route change / teardown
      * cancels it. Emits exactly once. Cancelling runs no adoption — which is what
      * stops a fast route-switch from starting overlapping connections.
+     *
+     * Wrapped in `defer` so the `tryAdopt()` side effect (which dispatches
+     * `streamAdopted`) runs at SUBSCRIPTION time, not when the observable is
+     * built. The effect prepends `startWith(setEstablishingConnection(true))`,
+     * which starts the telemetry session and subscribes its phase catalog; that
+     * must happen BEFORE `streamAdopted` → `regionTelemetryOnAdopt$` replays
+     * `regionResolved`, or the region phase fires into a session that doesn't
+     * exist yet and is lost. `defer` guarantees that ordering.
      */
     awaitAndAdopt$() {
-        const parked = window.__stream;
-        if (!parked) {
-            return of(false);
-        }
-        if (parked.state !== 'connecting') {
-            return of(this.tryAdopt());
-        }
-        Logger.info('[Adoption] Prefetch in progress — waiting before connecting');
-        return timer(0, ADOPT_POLL_MS).pipe(map$1(() => window.__stream?.state ?? 'failed'), 
-        // Keep polling while still connecting; the `true` (inclusive) emits the
-        // settling value (`ready`/`failed`) that ends the wait.
-        takeWhile((state) => state === 'connecting', true), last(), map$1(() => this.tryAdopt()));
+        return defer(() => {
+            const parked = window.__stream;
+            if (!parked) {
+                return of(false);
+            }
+            if (parked.state !== 'connecting') {
+                return of(this.tryAdopt());
+            }
+            Logger.info('[Adoption] Prefetch in progress — waiting before connecting');
+            return timer(0, ADOPT_POLL_MS).pipe(map$1(() => window.__stream?.state ?? 'failed'), 
+            // Keep polling while still connecting; the `true` (inclusive) emits the
+            // settling value (`ready`/`failed`) that ends the wait.
+            takeWhile((state) => state === 'connecting', true), last(), map$1(() => this.tryAdopt()));
+        });
     }
     /**
      * @returns `true` if a ready parked stream was adopted (caller must NOT
@@ -3647,7 +3664,7 @@ class StreamAdoptionService {
             return false;
         }
         Logger.info('[Adoption] Adopting prefetched stream', parked.timings);
-        // Stop the script's watchdog and mark the handoff complete.
+        // Clear the script's timers and mark the handoff complete.
         parked.adopt();
         // Flag cirrus connected (so a later `initSignalling` won't open a 2nd
         // connection), record the adopted machine, and hydrate the streamer info
@@ -3658,6 +3675,7 @@ class StreamAdoptionService {
         this.store.dispatch(streamAdopted({
             machineId: parked.machineId ?? null,
             ssData: parked.ssData ?? null,
+            timings: parked.timings ?? null,
         }));
         // Hand the live socket over without re-sending `requestStream`, reusing the
         // script's correlationId (the one `requestStream` was already sent with).
@@ -4214,24 +4232,6 @@ class UnrealEffects {
             // defers `connectToSignaling`, which is what normally sets this.
             ignoreElements(), startWith(setEstablishingConnection({ value: true })))));
         });
-        // Adoption skips `connectToSignaling → getRegion`, so the region-resolving
-        // telemetry phase never fires. Replay the region waterfall (start → end →
-        // resolved) from the cached winner the prefetch reused — a near-zero-length
-        // phase that still carries the ping samples. No live ping sweep; if there is
-        // no cache the resolved event just carries empty values.
-        this.regionTelemetryOnAdopt$ = createEffect(() => {
-            return this.actions$.pipe(ofType(streamAdopted), mergeMap(() => {
-                const cached = this.regionsPingService.readCachedWinner();
-                return [
-                    regionPingFetchStart(),
-                    regionPingFetchEnd(),
-                    regionResolved({
-                        region: cached?.region_code ?? '',
-                        pingsMs: cached?.result ?? [],
-                    }),
-                ];
-            }));
-        });
     }
     canPeerReconnect() {
         return RECONNECT_CONFIG.enabled && this.signallingService.isConnected();
@@ -5533,6 +5533,19 @@ 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;
+/**
+ * Catalog phase ids the prefetch establishes invisibly. For an adopted
+ * connection their live closers are suppressed and the phases are emitted by
+ * {@link StreamStatusTelemetryService2.emitAdoptedConnection} instead, timed
+ * from the prefetch's own marks and anchored at the moment Angular reached the
+ * connect call (session start) — so the waterfall shows the time the prefetch
+ * actually SAVED, not the prefetch's page-load-parallel raw timeline.
+ */
+const PREFETCHED_PHASE_IDS = new Set([
+    'region-resolving',
+    'signaling-connection',
+    'webrtc-negotiation',
+]);
 // 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 = 'source3d.streamTelemetry.userId';
@@ -5563,6 +5576,17 @@ class StreamStatusTelemetryService2 {
         this.disconnectReason$ = this.store.selectSignal(unrealFeature.selectDisconnectReason);
         this.errorMessage$ = this.store.selectSignal(unrealFeature.selectErrorMessage);
         this.viewPortReady$ = this.store.selectSignal(unrealFeature.selectViewportReady);
+        /**
+         * Synchronous adoption flag. The `streamAdopted` reducer sets it BEFORE any
+         * action subscriber runs, so the connection-phase closers (which fire inside
+         * the same dispatch, e.g. `ssinfo-received` off the `ssData` state change)
+         * can read it and defer to the prefetch-timed attribution emitted by
+         * {@link emitAdoptedConnection} instead of recording the live wall-clock.
+         */
+        this.adopted$ = this.store.selectSignal(unrealFeature.selectAdopted);
+        /** Streamer identity for the adopted signaling phase params. */
+        this.ssData$ = this.store.selectSignal(unrealFeature.selectSsData);
+        this.awsInstance$ = this.store.selectSignal(unrealFeature.selectAwsInstance);
         this.session = null;
         /**
          * Whether a session has already started during the current page lifetime.
@@ -5955,6 +5979,13 @@ class StreamStatusTelemetryService2 {
                     if (!this.session)
                         return;
                     if (isCloser) {
+                        // Adopted connections receive the region / signaling / webrtc
+                        // phases from `emitAdoptedConnection` (timed from the prefetch's
+                        // own marks). Skip the live closer for those, so the whole
+                        // pre-adoption wait isn't dumped onto whichever connection closer
+                        // happens to fire first at the adoption instant.
+                        if (this.adopted$() && PREFETCHED_PHASE_IDS.has(bucket.id))
+                            return;
                         this.emitPhaseEnded(bucket, bucketIdx, value);
                         return;
                     }
@@ -5965,6 +5996,12 @@ class StreamStatusTelemetryService2 {
                 }));
             });
         });
+        // Adopted connection: emit the region / signaling / webrtc phases timed
+        // from the prefetch marks, anchored at session start (see method doc). The
+        // live closers for these phases are suppressed (PREFETCHED_PHASE_IDS).
+        sub.add(this.actions$
+            .pipe(ofType(streamAdopted))
+            .subscribe(({ timings }) => this.emitAdoptedConnection(timings)));
         const bootstrapInfo = this.collectBootstrapInfo();
         this.emitLifecycle('stream.session_started', {
             sessionId: id,
@@ -6082,6 +6119,130 @@ class StreamStatusTelemetryService2 {
             overlays,
         });
     }
+    /**
+     * Emit the region / signaling / webrtc phases for an ADOPTED connection.
+     *
+     * The prefetch script established the connection in parallel with page load,
+     * so its raw timeline (prefetch_start … ready) mostly predates this session —
+     * showing it verbatim would look identical to a non-prefetched connect. What
+     * matters is measured from the moment Angular reached the connect call
+     * (session start, == `lastMilestonePerf` here): the REAL wait until adoption,
+     * and how much the prefetch SAVED by finishing the handshake during page load.
+     *
+     * So the three phases fill exactly the `[session start → adopted]` window
+     * (split across signaling / webrtc by the prefetch's own sub-step ratio; the
+     * region was served from cache → ~0), and the savings figures ride in params:
+     *  - `prefetchConnectMs` — full handshake the prefetch measured (the cost a
+     *    cold, non-prefetched connect would pay here).
+     *  - `prefetchSavedMs` — how much of it completed before Angular was ready.
+     *  - `adoptionWaitMs` — the actual wait Angular experienced (= window).
+     *  - `adoptionOverheadMs` — gap between prefetch-ready and adoption.
+     */
+    emitAdoptedConnection(timings) {
+        const s = this.session;
+        if (!s)
+            return;
+        const t = timings ?? {};
+        const start = t['prefetch_start'] ?? s.startedAtPerf;
+        const wsOpen = t['ws_open'] ?? start;
+        const ready = t['ready'] ?? t['dc_open'] ?? wsOpen;
+        // Real prefetch sub-durations — how the handshake actually broke down.
+        const sigRaw = Math.max(0, wsOpen - start);
+        const webRaw = Math.max(0, ready - wsOpen);
+        const connectMs = Math.round(sigRaw + webRaw);
+        // `lastMilestonePerf` is still pinned at session start (the connection
+        // closers are suppressed for adopted sessions), so this is the genuine
+        // connect → adopted wait the user lived through.
+        const now = performance.now();
+        const waitMs = Math.max(0, Math.round(now - s.lastMilestonePerf));
+        // What running the handshake during page load bought us: the part already
+        // done by the time Angular reached the connect call.
+        const savedMs = Math.max(0, Math.min(connectMs, Math.round(s.startedAtPerf - start)));
+        const adoptionOverheadMs = Math.max(0, Math.round(now - ready));
+        const savings = {
+            prefetched: true,
+            prefetchConnectMs: connectMs,
+            prefetchSavedMs: savedMs,
+            adoptionWaitMs: waitMs,
+            adoptionOverheadMs,
+        };
+        // Split the real wait across signaling / webrtc by the prefetch's own
+        // signaling:webrtc proportion.
+        const denom = sigRaw + webRaw;
+        const sigMs = denom > 0 ? Math.round((waitMs * sigRaw) / denom) : 0;
+        const webMs = Math.max(0, waitMs - sigMs);
+        // Region (phaseNo 1) — served from the ping cache during prefetch (~0),
+        // but ship the samples so the phase still carries its data.
+        const region = this.readRegionCache();
+        this.emitAdoptedPhase(0, 0, {
+            region: region?.region_code ?? '',
+            pingsMs: region?.result.length
+                ? `${region.result.join(', ')} ms`
+                : null,
+            prefetched: true,
+        }, []);
+        // Signaling (phaseNo 2) — carries the streamer identity + savings summary.
+        this.emitAdoptedPhase(1, sigMs, {
+            ...this.adoptedSignalingParams(),
+            ...savings,
+            prefetchSignalingMs: Math.round(sigRaw),
+        }, [{ id: 'signaling-ws-connected', time: Math.round(wsOpen) }]);
+        // WebRTC negotiation (phaseNo 3).
+        this.emitAdoptedPhase(2, webMs, {
+            iceCandidateCount: 0,
+            prefetched: true,
+            prefetchWebrtcMs: Math.round(webRaw),
+        }, []);
+    }
+    /** Emit one adopted phase with an explicit (prefetch-derived) duration and
+     *  advance `lastMilestonePerf` synthetically so the next phase chains right. */
+    emitAdoptedPhase(bucketIdx, durationMs, extras, milestones) {
+        const s = this.session;
+        if (!s)
+            return;
+        const bucket = this.phaseCatalog[bucketIdx];
+        this.track('stream.phase_ended', {
+            sessionId: s.id,
+            phaseNo: bucketIdx + 1,
+            id: bucket.id,
+            color: bucket.color,
+            duration: durationMs,
+            milestones,
+            params: toPhaseParams(extras),
+            overlays: [],
+        });
+        s.lastMilestonePerf += durationMs;
+    }
+    /** Streamer identity params for the adopted signaling phase — mirrors the
+     *  `ssinfo-received` closer's shape (client / instanceName / …ssData). */
+    adoptedSignalingParams() {
+        const aws = this.awsInstance$();
+        const ssData = this.ssData$();
+        return {
+            client: aws?.wsUrl ?? null,
+            instanceName: aws?.instanceName ?? null,
+            ...(ssData ?? {}),
+        };
+    }
+    /** Read the region-ping cache the prefetch reused (localStorage), so the
+     *  adopted region phase can still report the winning region + samples. */
+    readRegionCache() {
+        try {
+            const raw = localStorage.getItem(REGION_PING_CACHE_KEY);
+            if (!raw)
+                return null;
+            const parsed = JSON.parse(raw);
+            return {
+                region_code: typeof parsed.region_code === 'string' ? parsed.region_code : '',
+                result: Array.isArray(parsed.result)
+                    ? parsed.result.filter((n) => typeof n === 'number')
+                    : [],
+            };
+        }
+        catch {
+            return null;
+        }
+    }
     handleWindow(samples) {
         if (!this.session)
             return;