@3dsource/angular-unreal-module 0.0.146-dev.4 → 0.0.146-dev.6

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

@@ -1670,6 +1670,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 {
@@ -3598,26 +3602,41 @@ class StreamAdoptionService {
      *
      * - nothing parked → emit `false` at once (caller connects normally).
      * - already settled (`ready`/`failed`/`adopted`) → adopt-if-ready at once.
-     * - still `connecting` → poll until it settles, then adopt-if-ready. Bounded
-     *   by `timeoutMs` so a stuck prefetch can't block the fallback forever.
+     * - still `connecting` → poll until the script settles it, then adopt-if-ready.
+     *
+     * 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.
      *
-     * Emits exactly once. Cancel by unsubscribing (the effect does this on
-     * teardown via `takeUntil`) — no adoption runs after cancellation, 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$(timeoutMs) {
-        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 AND within budget; the `true`
-        // (inclusive) emits the settling value (or the last one at the deadline).
-        takeWhile((state, i) => state === 'connecting' && i * ADOPT_POLL_MS < timeoutMs, true), last(), map$1(() => this.tryAdopt()));
+    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 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
@@ -3638,7 +3657,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
@@ -4197,9 +4216,7 @@ class UnrealEffects {
             // 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$(this.dataChannelConnectionTimeout)
-                .pipe(switchMap((adopted) => adopted ? EMPTY : this.signallingService.connectToSignaling(urls)), takeUntil(this.actions$.pipe(ofType(abortEstablishingConnection))), 
+            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
@@ -4207,6 +4224,24 @@ 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();
@@ -5615,17 +5650,13 @@ 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.
-                    //
-                    // Adopted connections skip `connectToSignaling` → `getRegion`, so
-                    // `regionResolved` never fires. We synthesise it from `streamAdopted`
-                    // using the cached ping result the prefetch reused, so the region
-                    // phase still appears (with its ping samples). Because this fires at
-                    // adoption time it also re-anchors `lastMilestonePerf`, which keeps the
-                    // following signaling / webrtc phases at ~0 for adopted sessions.
+                    // `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: merge(this.actions$.pipe(ofType(regionResolved)), this.actions$.pipe(ofType(streamAdopted), map(() => this.cachedRegionResult()))).pipe(take(1), map(({ region, pingsMs }) => ({
+                        event: this.actions$.pipe(ofType(regionResolved), take(1), map(({ region, pingsMs }) => ({
                             region,
                             pingsMs: pingsMs.length ? `${pingsMs.join(', ')} ms` : null,
                         }))),
@@ -5786,29 +5817,6 @@ class StreamStatusTelemetryService2 {
             return v4();
         }
     }
-    /**
-     * Region winner + ping samples cached in `localStorage` by
-     * `region-ping-prefetch.js` / `RegionsPingService` (`REGION_PING_CACHE_KEY`).
-     * Used to fill the region phase for ADOPTED connections, which never run
-     * `getRegion()` and so never dispatch `regionResolved`. Empty when there is
-     * no usable cache.
-     */
-    cachedRegionResult() {
-        try {
-            const raw = localStorage.getItem(REGION_PING_CACHE_KEY);
-            const parsed = raw ? JSON.parse(raw) : null;
-            if (parsed && typeof parsed.region_code === 'string') {
-                return {
-                    region: parsed.region_code,
-                    pingsMs: Array.isArray(parsed.result) ? parsed.result : [],
-                };
-            }
-        }
-        catch {
-            /* ignore — best-effort */
-        }
-        return { region: '', pingsMs: [] };
-    }
     init() {
         // Start a new session when a real connection attempt BEGINS, not on
         // every `initSignalling` dispatch. `initSignalling` is fired multiple