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

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

@@ -6122,81 +6122,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 +6202,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). */