@3dsource/angular-unreal-module 0.0.137 → 0.0.139

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

@@ -5107,6 +5107,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.16", ngImpo
             type: Injectable
         }], ctorParameters: () => [] });
 
+/** Trim a resource URL to its path: drop origin and query string so the
+ *  emitted name is short, stable, and not a PII-bearing query. */
+function shortResourceName(url) {
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return (url || '').split('?')[0];
+    }
+}
 const QP_RED_THRESHOLD = 35;
 const FPS_LOW_RATIO = 0.7; // p50 fps below 70% of target
 const UNLIMITED_REFERENCE_FPS = 60;
@@ -5384,9 +5394,19 @@ class StreamStatusTelemetryService2 {
         }
     }
     init() {
-        // Start a new session on every initSignalling dispatch.
+        // Start a new session when a real connection attempt BEGINS, not on
+        // every `initSignalling` dispatch. `initSignalling` is fired multiple
+        // times per page load (the unreal-scene effect, `startStream`, the
+        // reconnect effect), but the connection layer collapses them into one
+        // attempt via `connectToSignaling$` (`exhaustMap` + `!cirrusConnected`
+        // filter). `setEstablishingConnection(true)` is dispatched exactly
+        // once per real attempt from `SignallingService.startEstablishingConnection()`,
+        // downstream of that guard — so binding here yields one session per
+        // attempt instead of a burst of `restart` churn sessions. Genuine
+        // reconnects (e.g. DataChannelTimeout) re-enter the same path and
+        // correctly end the prior session as `restart` + start a new one.
         this.actions$
-            .pipe(ofType(initSignalling), takeUntil$1(this.destroy$))
+            .pipe(ofType(setEstablishingConnection), filter$1(({ value }) => value === true), takeUntil$1(this.destroy$))
             .subscribe(() => this.startSession());
         // Action-stream end triggers (NOT a state-observable subscription).
         //
@@ -5787,6 +5807,9 @@ class StreamStatusTelemetryService2 {
                 // attributes them to `HTML loading` and `Route idle` respectively.
                 resources: split.resources,
                 lazyResources: split.lazyResources,
+                // Top-8 slowest individual resources (path + duration), so the viewer
+                // can name the offending file / GraphQL endpoint.
+                slowestResources: split.slowestResources,
             };
         }
         catch {
@@ -5815,19 +5838,22 @@ class StreamStatusTelemetryService2 {
         try {
             const list = performance.getEntriesByType('resource');
             if (!list.length)
-                return { resources: null, lazyResources: null };
+                return { resources: null, lazyResources: null, slowestResources: [] };
             const empty = () => ({
                 count: 0,
                 cachedCount: 0,
                 transferSize: 0,
                 encodedBodySize: 0,
                 decodedBodySize: 0,
+                durationMs: 0,
+                maxDurationMs: 0,
             });
             const splitEnabled = loadEventEnd > 0;
             const pageLoadTotals = empty();
             const pageLoadByType = {};
             const lazyTotals = empty();
             const lazyByType = {};
+            const slow = []; // every timed resource; trimmed to top-N
             for (const r of list) {
                 const type = r.initiatorType || 'other';
                 const isLazy = splitEnabled && r.startTime > loadEventEnd;
@@ -5838,28 +5864,50 @@ class StreamStatusTelemetryService2 {
                 const t = r.transferSize || 0;
                 const enc = r.encodedBodySize || 0;
                 const dec = r.decodedBodySize || 0;
+                const dur = r.duration || 0; // responseEnd − startTime (ms)
                 b.count++;
                 if (fromCache)
                     b.cachedCount++;
                 b.transferSize += t;
                 b.encodedBodySize += enc;
                 b.decodedBodySize += dec;
+                b.durationMs += dur;
+                if (dur > b.maxDurationMs)
+                    b.maxDurationMs = dur;
                 totals.count++;
                 if (fromCache)
                     totals.cachedCount++;
                 totals.transferSize += t;
                 totals.encodedBodySize += enc;
                 totals.decodedBodySize += dec;
+                totals.durationMs += dur;
+                if (dur > totals.maxDurationMs)
+                    totals.maxDurationMs = dur;
+                if (dur > 0) {
+                    slow.push({
+                        name: shortResourceName(r.name),
+                        type,
+                        durationMs: Math.round(dur),
+                        transferKb: Math.round((t / 1024) * 10) / 10,
+                        lazy: isLazy,
+                    });
+                }
             }
+            slow.sort((a, b) => b.durationMs - a.durationMs);
             return {
                 resources: pageLoadTotals.count > 0
                     ? { ...pageLoadTotals, byType: pageLoadByType }
                     : null,
                 lazyResources: lazyTotals.count > 0 ? { ...lazyTotals, byType: lazyByType } : null,
+                // Top-8 slowest individual resources (path only, query stripped) so
+                // the viewer can name the offending file / endpoint. GraphQL appears
+                // here as its endpoint path (one entry per call) — Resource Timing
+                // can't expose the operation name (it's in the POST body).
+                slowestResources: slow.slice(0, 8),
             };
         }
         catch {
-            return { resources: null, lazyResources: null };
+            return { resources: null, lazyResources: null, slowestResources: [] };
         }
     }
     aggregate(values) {