@3dsource/angular-unreal-module 0.0.146-dev.0 → 0.0.146-dev.10

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

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, DestroyRef, ChangeDetectionStrategy, Component, Injectable, signal, effect, untracked, computed, Pipe, input, ElementRef, viewChild, afterNextRender, HostListener, output, makeEnvironmentProviders, provideEnvironmentInitializer } from '@angular/core';
 import { SourceButtonComponent, SourceLoadingComponent } from '@3dsource/source-ui-native';
-import { Subject, skip, share, merge, map, scan, timestamp, startWith, pairwise, concatMap, of, animationFrameScheduler, interval, Observable, timer, take, defer, switchMap, from, throwError, EMPTY, retry, timeout as timeout$1, repeat, takeUntil as takeUntil$1, fromEvent, tap as tap$1, throttleTime, delay, concat, debounceTime, mergeMap, shareReplay, NEVER, asyncScheduler, filter as filter$1, withLatestFrom as withLatestFrom$1, Subscription, bufferTime, combineLatestWith, distinctUntilChanged as distinctUntilChanged$1 } from 'rxjs';
+import { Subject, skip, share, merge, map, scan, timestamp, startWith, pairwise, concatMap, of, animationFrameScheduler, interval, Observable, timer, take, defer, switchMap, from, throwError, EMPTY, retry, timeout as timeout$1, repeat, BehaviorSubject, takeUntil as takeUntil$1, fromEvent, tap as tap$1, throttleTime, delay, concat, debounceTime, mergeMap, ignoreElements, shareReplay, NEVER, asyncScheduler, filter as filter$1, withLatestFrom as withLatestFrom$1, Subscription, bufferTime, combineLatestWith, distinctUntilChanged as distinctUntilChanged$1 } from 'rxjs';
 import { createAction, props, createReducer, on, createFeature, Store, createSelector, provideState } from '@ngrx/store';
 import { whereNot, Falsy, Logger, calculateMedian, clampf, lerp, getCanvasCached, getSnapshot, fitIntoRectangle, generateUuid, Truthy, tapLog, Semaphore, COLOR_CODES, where, KeyboardNumericCode, InvertedKeyMap, HEXtoRGB, RGBtoHSV, inverseLerp, HSVtoRGB, RGBtoHEX, fpIsASameAsB } from '@3dsource/utils';
 import { filter, map as map$1, distinctUntilChanged, takeWhile, takeUntil, catchError, tap, timeout, finalize, first, switchMap as switchMap$1, withLatestFrom, exhaustMap, debounceTime as debounceTime$1, take as take$1, startWith as startWith$1 } from 'rxjs/operators';
@@ -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 }) => {
@@ -643,10 +648,12 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
     return { ...state, analyticsEvent: event };
 }), on(setCirrusConnected, (state) => {
     return { ...state, cirrusConnected: true };
-}), on(streamAdopted, (state, { machineId }) => {
+}), on(streamAdopted, (state, { machineId, ssData }) => {
     return {
         ...state,
         cirrusConnected: true,
+        adopted: true,
+        ssData: ssData ?? state.ssData,
         awsInstance: {
             ...state.awsInstance,
             wsUrl: machineId,
@@ -676,6 +683,7 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
     return {
         ...state,
         cirrusConnected: false,
+        adopted: false,
         dataChannelConnected: false,
         viewportReady: false,
         isVideoPlaying: false,
@@ -1314,13 +1322,18 @@ const selectTotalProgress = createSelector(unrealFeature.selectStatusPercentSign
     const SIGNALLING_MAX = SIGNALLING_PERCENT_VALUE / 100;
     const ORCHESTRATION_WS_PATTERN = /^wss:\/\/orchestration-websocket/i;
     const isNewOrchestration = ORCHESTRATION_WS_PATTERN.test(awsInstance?.wsUrl ?? '');
-    // Orchestration progress is 0–1 from the backend; map to 0–1 directly.
-    // Once the data channel is connected, signaling is fully complete (1.0).
-    const signalingProgress = isNewOrchestration
-        ? dataChannelConnected
-            ? 1
-            : (awsInstance?.progressComplete ?? 0)
-        : (statusPercentSignallingServer ?? 0) / 100;
+    // 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.
+    // Otherwise: new orchestration reports 0–1 progress; legacy uses the
+    // polling percent.
+    const signalingProgress = dataChannelConnected
+        ? 1
+        : isNewOrchestration
+            ? (awsInstance?.progressComplete ?? 0)
+            : (statusPercentSignallingServer ?? 0) / 100;
     // +1% bump once WS URL is known (visual step for WS handshake)
     const splitPoint = awsInstance?.wsUrl
         ? SIGNALLING_MAX + 0.01
@@ -1664,6 +1677,10 @@ class RegionsPingService {
      * entry is well-formed and still within {@link REGION_PING_CACHE_TTL_MS}.
      * All access is guarded — `localStorage` can throw (private mode, disabled
      * storage) or be absent (non-browser).
+     *
+     * Public so adopted connections (which skip `getFastest`) can replay the
+     * region-resolving telemetry phase from the same cached winner — see
+     * `UnrealEffects.regionTelemetryOnAdopt$`.
      */
     readCachedWinner() {
         try {
@@ -2573,7 +2590,13 @@ class VideoService extends SubService {
         this.audio = null;
         this.container = null;
         this.latencyTestTimings = new LatencyTimings();
-        this.videoTrack$ = new Subject();
+        // BehaviorSubject (not Subject) so a late subscriber to `videoStats$` still
+        // gets the current track. Adoption (`WebRtcPlayerService.adopt`) calls
+        // `attachVideoStream` synchronously/early — before the resize and app-init
+        // (`initAppByDataChannelReady$`) subscribers attach — and a plain Subject
+        // would drop that emission, so the stats interval (and `setViewportReady`,
+        // gated on `framesPerSecond`) would never start.
+        this.videoTrack$ = new BehaviorSubject(null);
         this.VideoEncoderQP = 0;
         this.aggregatedStats = {};
         this.kalmanFilter1D = new KalmanFilter1D(FilterModel.initialBitrateEstimate, FilterModel.initialErrorCovariance, FilterModel.processNoise, FilterModel.measurementNoise);
@@ -3579,6 +3602,70 @@ class StreamAdoptionService {
         this.signalling = inject(SignallingService);
         this.webRtc = inject(WebRtcPlayerService);
     }
+    /**
+     * Decide adoption, WAITING for an in-flight prefetch instead of racing it.
+     *
+     * - nothing parked → emit `false` at once (caller connects normally).
+     * - already settled (`ready`/`failed`/`adopted`) → adopt-if-ready at once.
+     * - still `connecting` → wait for the script's `onSettled` callback and
+     *   adopt-if-ready the instant it fires (event-driven, zero polling latency).
+     *
+     * Deliberately NO time budget: for DIRECT orchestration the prefetch holds
+     * the socket open while the orchestrator provisions a machine, which can take
+     * minutes (150–200s+). A fixed deadline would make Angular give up and open a
+     * second connection mid-provisioning — exactly the race/orphan this avoids.
+     * The wait is bounded by liveness instead: the script flips the parked state
+     * to `failed` on a dead socket (`ws.onclose`/`onerror`), and the caller wraps
+     * 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$() {
+        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 this.awaitSettled$(parked);
+        });
+    }
+    /**
+     * Event-driven wait: the script fires `onSettled` the instant it parks
+     * `ready`/`failed`, so we adopt with zero polling lag. Emits exactly once.
+     *
+     * No timer/budget by design: an indefinitely `connecting` stream is valid
+     * (DIRECT orchestration holds the socket open for minutes while it
+     * provisions), and every terminal state — including a dead socket — flips to
+     * `ready`/`failed` and fires the hook. Teardown (route change → unsubscribe)
+     * sets `done`, so a late callback after cancel can't trigger a stray adoption.
+     */
+    awaitSettled$(parked) {
+        return new Observable((subscriber) => {
+            let done = false;
+            parked.onSettled(() => {
+                if (done)
+                    return;
+                done = true;
+                subscriber.next(this.tryAdopt());
+                subscriber.complete();
+            });
+            return () => {
+                done = true;
+            };
+        });
+    }
     /**
      * @returns `true` if a ready parked stream was adopted (caller must NOT
      *          start a fresh connection), `false` otherwise.
@@ -3598,14 +3685,19 @@ 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) and record the adopted machine. NOTE: clientId/viewId are
-        // left untouched — the host app (metabox) already set them authoritatively
-        // from its own data before `initSignalling`; the script's ids are only used
-        // internally to establish the prefetched connection.
-        this.store.dispatch(streamAdopted({ machineId: parked.machineId ?? null }));
+        // connection), record the adopted machine, and hydrate the streamer info
+        // (`ssData`) the prefetch captured from the `ssInfo` message. NOTE:
+        // clientId/viewId are left untouched — the host app (metabox) already set
+        // them authoritatively from its own data before `initSignalling`; the
+        // script's ids are only used internally to establish the connection.
+        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).
         this.signalling.adoptSocket(parked.ws, parked.ids.correlationId);
@@ -4148,12 +4240,19 @@ class UnrealEffects {
             }), map(([, matchMakerUrls]) => [...matchMakerUrls].filter(Truthy)), filter((urls) => urls.length > 0), 
             // Ensure a single in-flight request per attempt.
             exhaustMap((urls) => 
-            // Adopt a prefetched `window.__stream` if one is ready; otherwise
-            // fall back to opening a fresh signalling connection.
-            this.streamAdoptionService.tryAdopt()
-                ? EMPTY
-                : this.signallingService.connectToSignaling(urls)));
-        }, { dispatch: false });
+            // If a prefetched `window.__stream` is ready — or still connecting —
+            // adopt it (waiting for it to finish) instead of racing a second
+            // connection; otherwise fall back to a fresh signalling connection.
+            // `takeUntil(abort)` cancels the wait on teardown / route change so a
+            // fast switch can't leave overlapping connections.
+            this.streamAdoptionService.awaitAndAdopt$().pipe(switchMap((adopted) => adopted ? EMPTY : this.signallingService.connectToSignaling(urls)), takeUntil(this.actions$.pipe(ofType(abortEstablishingConnection))), 
+            // The adopt/connect stream is side-effect-only (its values aren't
+            // actions) — swallow them, and emit `setEstablishingConnection`
+            // first so the reconnect/resume popup stays hidden during the
+            // (possibly deferred) prefetch-adoption wait. Adoption otherwise
+            // defers `connectToSignaling`, which is what normally sets this.
+            ignoreElements(), startWith(setEstablishingConnection({ value: true })))));
+        });
     }
     canPeerReconnect() {
         return RECONNECT_CONFIG.enabled && this.signallingService.isConnected();
@@ -5455,6 +5554,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';
@@ -5485,6 +5597,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.
@@ -5562,7 +5685,10 @@ class StreamStatusTelemetryService2 {
                     // 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.
+                    // `toPhaseParams` only accepts primitives. Adopted connections never
+                    // run `getRegion`, but `UnrealEffects.regionTelemetryOnAdopt$` replays
+                    // the region waterfall (start → end → resolved) from the cached winner,
+                    // so this phase still appears with its ping samples.
                     {
                         id: 'region-resolved',
                         event: this.actions$.pipe(ofType(regionResolved), take(1), map(({ region, pingsMs }) => ({
@@ -5874,6 +6000,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;
                     }
@@ -5884,6 +6017,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,
@@ -6001,6 +6140,127 @@ 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 the phases are positioned at their real (anchor-relative) spans — shifted
+     * LEFT to overlap the HTML-loading / route-idle rows — rather than sequentially
+     * after them. That's the whole point of the prefetch: the handshake already
+     * happened while the page was loading. Each phase ships:
+     *  - `duration` — the real sub-step time the prefetch spent.
+     *  - `spanStartMs` — anchor-relative start, so the viewer left-shifts the bar.
+     *  - `adoptionAtMs` — where Angular took over (the next phase, Unreal
+     *    communication, resumes here on the sequential timeline).
+     *  - savings params: `prefetchConnectMs` (full handshake), `prefetchSavedMs`
+     *    (done before Angular was ready), `adoptionWaitMs` (real connect→adopted
+     *    wait), `adoptionOverheadMs` (prefetch-ready → adopted gap).
+     */
+    emitAdoptedConnection(timings) {
+        const s = this.session;
+        if (!s)
+            return;
+        const t = timings ?? {};
+        const now = performance.now();
+        // Everything in anchor-relative ms — the same scale the viewer renders on
+        // (and the prefetch marks share the page `performance` clock).
+        const toMs = (perf) => Math.round(perf - s.anchorPerf);
+        const startMs = toMs(t['prefetch_start'] ?? s.startedAtPerf);
+        const wsOpenMs = Math.max(startMs, toMs(t['ws_open'] ?? t['prefetch_start'] ?? s.startedAtPerf));
+        const readyMs = Math.max(wsOpenMs, toMs(t['ready'] ?? t['dc_open'] ?? t['ws_open'] ?? s.startedAtPerf));
+        const adoptionAtMs = toMs(now);
+        const sessionStartMs = toMs(s.startedAtPerf);
+        const sigDur = wsOpenMs - startMs;
+        const webDur = readyMs - wsOpenMs;
+        const connectMs = readyMs - startMs;
+        // Savings, anchored at the moment Angular reached the connect call.
+        const savings = {
+            prefetched: true,
+            prefetchConnectMs: connectMs,
+            // How much of the handshake finished before Angular was ready (the win).
+            prefetchSavedMs: Math.max(0, Math.min(connectMs, sessionStartMs - startMs)),
+            // The real wait Angular experienced (connect call → adopted).
+            adoptionWaitMs: Math.max(0, adoptionAtMs - sessionStartMs),
+            // Gap between the prefetch being ready and Angular adopting it.
+            adoptionOverheadMs: Math.max(0, adoptionAtMs - readyMs),
+        };
+        // Region (phaseNo 1) — served from the ping cache during prefetch (~0),
+        // positioned at the prefetch start; ship the samples.
+        const region = this.readRegionCache();
+        this.emitAdoptedPhase(0, startMs, 0, adoptionAtMs, {
+            region: region?.region_code ?? '',
+            pingsMs: region?.result.length ? `${region.result.join(', ')} ms` : null,
+        });
+        // Signaling (phaseNo 2) — [prefetch_start → ws_open]; streamer identity +
+        // savings; ws-connected marker sits at the phase's own end.
+        this.emitAdoptedPhase(1, startMs, sigDur, adoptionAtMs, {
+            ...this.adoptedSignalingParams(),
+            ...savings,
+            prefetchSignalingMs: sigDur,
+        }, [{ id: 'signaling-ws-connected', time: wsOpenMs }]);
+        // WebRTC negotiation (phaseNo 3) — [ws_open → ready].
+        this.emitAdoptedPhase(2, wsOpenMs, webDur, adoptionAtMs, {
+            iceCandidateCount: 0,
+            prefetchWebrtcMs: webDur,
+        });
+        // Unreal communication chains from the adoption moment (real wall-clock).
+        s.lastMilestonePerf = now;
+    }
+    /**
+     * Emit one adopted phase positioned at its real `spanStartMs` (left-shifted
+     * to overlap page load) with its real prefetch `duration`. `prefetched`,
+     * `spanStartMs` and `adoptionAtMs` ride as top-level wire fields the viewer
+     * uses to lay the bar out; the rest become display params.
+     */
+    emitAdoptedPhase(bucketIdx, spanStartMs, durationMs, adoptionAtMs, 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,
+            prefetched: true,
+            spanStartMs,
+            adoptionAtMs,
+            milestones,
+            params: toPhaseParams({ ...extras, prefetched: true }),
+            overlays: [],
+        });
+    }
+    /** 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;