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

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

@@ -3589,8 +3589,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.2", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
 
-// How often to re-check `window.__stream.state` while a prefetch is connecting.
+// Legacy fallback only: poll interval for head-scripts that predate the
+// `onSettled` hook. The event-driven path (preferred) carries no such latency.
 const ADOPT_POLL_MS = 100;
+// Safety-net re-check for the event path — covers the (unexpected) case where
+// `onSettled` never fires. Coarse on purpose: it's a backstop, not the hot
+// path, so it adds no latency to a healthy adoption.
+const ADOPT_EVENT_SAFETY_MS = 1000;
 /**
  * Adopts a WebRTC connection prefetched by the `stream-prefetch.js` head-script
  * and parked on `window.__stream`, instead of running `connectToSignaling` from
@@ -3609,7 +3614,9 @@ 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 the script settles it, then adopt-if-ready.
+     * - still `connecting` → wait for the script's `onSettled` callback (no
+     *   polling latency) and adopt-if-ready the instant it fires; on older
+     *   scripts without the hook, fall back to a `timer` poll.
      *
      * Deliberately NO time budget: for DIRECT orchestration the prefetch holds
      * the socket open while the orchestrator provisions a machine, which can take
@@ -3639,12 +3646,48 @@ class StreamAdoptionService {
                 return of(this.tryAdopt());
             }
             Logger.info('[Adoption] Prefetch in progress — waiting before connecting');
+            // Preferred path: the script fires `onSettled` the moment it parks
+            // `ready`/`failed`, so we adopt with zero polling lag.
+            if (typeof parked.onSettled === 'function') {
+                return this.awaitSettled$(parked);
+            }
+            // Legacy fallback: older head-script without the hook — poll its state.
             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()));
         });
     }
+    /**
+     * Event-driven wait: resolve the instant the script's `onSettled` callback
+     * fires (ready/failed), then adopt-if-ready. Emits exactly once.
+     *
+     * A coarse {@link ADOPT_EVENT_SAFETY_MS} interval is a backstop only — if
+     * `onSettled` somehow never fires it still settles, without adding latency to
+     * the normal case. 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;
+            const finish = () => {
+                if (done)
+                    return;
+                done = true;
+                subscriber.next(this.tryAdopt());
+                subscriber.complete();
+            };
+            parked.onSettled?.(() => finish());
+            const safety = setInterval(() => {
+                if ((window.__stream?.state ?? 'failed') !== 'connecting')
+                    finish();
+            }, ADOPT_EVENT_SAFETY_MS);
+            return () => {
+                done = true;
+                clearInterval(safety);
+            };
+        });
+    }
     /**
      * @returns `true` if a ready parked stream was adopted (caller must NOT
      *          start a fresh connection), `false` otherwise.
@@ -6122,81 +6165,76 @@ class StreamStatusTelemetryService2 {
     /**
      * 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.
+     * 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 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));
+        // 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,
-            prefetchSavedMs: savedMs,
-            adoptionWaitMs: waitMs,
-            adoptionOverheadMs,
+            // 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),
         };
-        // 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.
+        // positioned at the prefetch start; ship the samples.
         const region = this.readRegionCache();
-        this.emitAdoptedPhase(0, 0, {
+        this.emitAdoptedPhase(0, startMs, 0, adoptionAtMs, {
             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, {
+            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: Math.round(sigRaw),
-        }, [{ id: 'signaling-ws-connected', time: Math.round(wsOpen) }]);
-        // WebRTC negotiation (phaseNo 3).
-        this.emitAdoptedPhase(2, webMs, {
+            prefetchSignalingMs: sigDur,
+        }, [{ id: 'signaling-ws-connected', time: wsOpenMs }]);
+        // WebRTC negotiation (phaseNo 3) — [ws_open → ready].
+        this.emitAdoptedPhase(2, wsOpenMs, webDur, adoptionAtMs, {
             iceCandidateCount: 0,
-            prefetched: true,
-            prefetchWebrtcMs: Math.round(webRaw),
-        }, []);
+            prefetchWebrtcMs: webDur,
+        });
+        // Unreal communication chains from the adoption moment (real wall-clock).
+        s.lastMilestonePerf = now;
     }
-    /** 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) {
+    /**
+     * 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;
@@ -6207,11 +6245,13 @@ class StreamStatusTelemetryService2 {
             id: bucket.id,
             color: bucket.color,
             duration: durationMs,
+            prefetched: true,
+            spanStartMs,
+            adoptionAtMs,
             milestones,
-            params: toPhaseParams(extras),
+            params: toPhaseParams({ ...extras, prefetched: true }),
             overlays: [],
         });
-        s.lastMilestonePerf += durationMs;
     }
     /** Streamer identity params for the adopted signaling phase — mirrors the
      *  `ssinfo-received` closer's shape (client / instanceName / …ssData). */