catalyst-core 0.2.0-beta.2 → 0.3.0-beta.1

package/dist/native/bridge/perf/collectors/NetworkTimingCollector.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NetworkTimingCollector = void 0;
+var _constants = require("../core/constants.js");
+/**
+ * NetworkTimingCollector.js
+ *
+ * Adds lightweight Catalyst timeline spans for fetch() and XMLHttpRequest.
+ * Chrome already has detailed network timing; these spans exist to attach
+ * network work to Catalyst interaction sessions via sessionId.
+ */
+
+const FETCH_WRAPPED = "__catalystNetworkTimingFetchWrapped";
+const XHR_WRAPPED = "__catalystNetworkTimingXhrWrapped";
+const XHR_META = "__catalystNetworkTimingMeta";
+const MAX_LABEL_LENGTH = 72;
+class NetworkTimingCollector {
+  constructor(measure) {
+    this._measure = measure;
+    this._getInteraction = null;
+    this._requestSeq = 0;
+  }
+  setInteractionSource(fn) {
+    this._getInteraction = fn;
+  }
+  setWaterfallSource(fn) {
+    this._notifyWaterfall = fn;
+  }
+  init() {
+    if (typeof window === "undefined") return;
+    this._wrapFetch();
+    this._wrapXhr();
+  }
+  _wrapFetch() {
+    const originalFetch = window.fetch;
+    if (typeof originalFetch !== "function" || originalFetch[FETCH_WRAPPED]) return;
+    const collector = this;
+    function catalystFetch(input, init) {
+      const span = collector._start("fetch", init?.method ?? input?.method ?? "GET", init?.url ?? input?.url ?? input);
+      try {
+        return originalFetch.apply(this, arguments).then(response => {
+          collector._finish(span, {
+            status: response?.status ?? null,
+            ok: response?.ok ?? null
+          });
+          return response;
+        }, error => {
+          collector._finish(span, {
+            outcome: "error",
+            ok: false
+          });
+          throw error;
+        });
+      } catch (error) {
+        collector._finish(span, {
+          outcome: "error",
+          ok: false
+        });
+        throw error;
+      }
+    }
+    catalystFetch[FETCH_WRAPPED] = true;
+    window.fetch = catalystFetch;
+  }
+  _wrapXhr() {
+    const proto = window.XMLHttpRequest?.prototype;
+    if (!proto || proto[XHR_WRAPPED]) return;
+    if (typeof proto.open !== "function" || typeof proto.send !== "function") return;
+    const originalOpen = proto.open;
+    const originalSend = proto.send;
+    const collector = this;
+    proto.open = function catalystXhrOpen(method, url) {
+      this[XHR_META] = {
+        method,
+        url
+      };
+      return originalOpen.apply(this, arguments);
+    };
+    proto.send = function catalystXhrSend() {
+      const meta = this[XHR_META] ?? {};
+      const span = collector._start("xhr", meta.method ?? "GET", meta.url ?? "unknown");
+      let emitted = false;
+      const finish = (outcome = "complete") => {
+        if (emitted) return;
+        emitted = true;
+        const status = this.status;
+        collector._finish(span, {
+          status,
+          ok: collector._statusOk(status),
+          outcome
+        });
+      };
+      this.addEventListener?.("loadend", () => finish(), {
+        once: true
+      });
+      try {
+        return originalSend.apply(this, arguments);
+      } catch (error) {
+        finish("error");
+        throw error;
+      }
+    };
+    proto[XHR_WRAPPED] = true;
+  }
+  _start(api, method, rawUrl) {
+    const startTime = performance.now();
+    const normalizedMethod = String(method || "GET").toUpperCase();
+    const url = this._normalizeUrl(rawUrl);
+    const label = this._labelForUrl(url);
+    const requestId = `${api}:${++this._requestSeq}`;
+    const startMark = `${_constants.PREFIX.NETWORK_TIMING}:${requestId}:start`;
+    performance.mark(startMark, {
+      startTime
+    });
+    const interaction = this._getInteraction?.();
+    const interactionId = interaction?.activeInteractionId ?? null;
+    if (interactionId) interaction?.onNetworkCall?.();
+    return {
+      api,
+      method: normalizedMethod,
+      url,
+      label,
+      requestId,
+      startMark,
+      startTime,
+      interactionId
+    };
+  }
+  _finish(span, result = {}) {
+    const endTime = performance.now();
+    const durationMs = Math.round(endTime - span.startTime);
+    const outcome = result.outcome ?? "complete";
+    const ok = result.ok ?? this._statusOk(result.status);
+    const color = outcome !== "complete" || ok === false || durationMs > _constants.THRESHOLD.FETCH_SLOW_MS ? _constants.COLOR.ERROR : _constants.COLOR.SECONDARY;
+    const detail = {
+      api: span.api,
+      method: span.method,
+      url: span.url,
+      status: result.status ?? null,
+      ok,
+      outcome,
+      durationMs,
+      sessionId: span.interactionId,
+      requestId: span.requestId,
+      simulatorValid: true
+    };
+    this._notifyWaterfall?.({
+      ...detail,
+      startTime: span.startTime,
+      endTime
+    });
+    this._measure.emit(`${span.interactionId ? `[${span.interactionId}] ` : ""}Network: ${span.method} ${span.label} - ${durationMs}ms`, span.startMark, endTime, {
+      interactionId: span.interactionId,
+      ...detail,
+      sessionId: undefined
+    }, _constants.TRACK.NETWORK, color);
+  }
+  _normalizeUrl(rawUrl) {
+    const value = rawUrl?.url ?? rawUrl ?? "unknown";
+    try {
+      const parsed = new URL(String(value), window.location?.href);
+      return `${parsed.origin}${parsed.pathname}`;
+    } catch {
+      return String(value).split("?")[0].split("#")[0];
+    }
+  }
+  _labelForUrl(url) {
+    try {
+      const parsed = new URL(url, window.location?.href);
+      const label = parsed.origin === window.location?.origin ? parsed.pathname : `${parsed.host}${parsed.pathname}`;
+      return (label || "/").slice(0, MAX_LABEL_LENGTH);
+    } catch {
+      return String(url || "unknown").slice(0, MAX_LABEL_LENGTH);
+    }
+  }
+  _statusOk(status) {
+    return typeof status === "number" && status >= 200 && status < 400;
+  }
+}
+exports.NetworkTimingCollector = NetworkTimingCollector;

package/dist/native/bridge/perf/collectors/RenderCollector.js

@@ -0,0 +1,284 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RenderCollector = void 0;
+var _constants = require("../core/constants.js");
+/**
+ * RenderCollector.js
+ *
+ * Instruments: bugs #1, #6, #10, #14, #15, #16
+ *   #1  page slowness / cache miss     → LoAF during navigation session = render blocked by loading
+ *   #6  blank screens                  → LoAF blocks first render; LCP may never fire
+ *   #10 footer flash on Drug/OTC       → layout-shift fires just after navigation session closes
+ *   #14 transitions not soft           → layout-shift during nav = skeleton→content swap too abrupt
+ *   #15 quantity selector slow         → LoAF burst in the 2s after interaction (lazy chunk blocks)
+ *   #16 prescription screen touch lag  → same LoAF burst pattern after tap
+ *
+ * Spans emitted:
+ *   catalyst:loaf|<ms>ms           — long animation frame (Track: Render)
+ *                                    detail: blockingDuration, scriptCount, sessionContext
+ *   catalyst:layout-shift|<value>  — unexpected layout shift (Track: Render)
+ *                                    detail: value, sessionContext
+ *   catalyst:fps-drop|<fps>fps-min|<ms>ms — native fps-drop episode (Track: Render)
+ *                                    detail: minFps, avgFps, durationMs, sessionContext
+ *                                    closes on recovery >55fps OR after 10s max
+ *   catalyst:long-task|<ms>ms      — native long task > 16ms (Track: Render)
+ *   catalyst:mem/jvm|<MB>MB     — JVM heap PSS — Kotlin/Java objects (Track: Render, blue)
+ *   catalyst:mem/native|<MB>MB  — native heap PSS — V8 + Blink + JNI, WebView proxy (Track: Render, orange)
+ *   catalyst:mem/total|<MB>MB   — total process PSS — what Android OOM killer sees (Track: Render, purple→red)
+ *
+ * Notifies:
+ *   ScrollCollector.onLoaf()       — so scroll session can increment its loafCount
+ *   HookCollector.onLoaf()         — so hook mount sessions can detect LoAF bursts
+ */
+
+class RenderCollector {
+  constructor(measure, getSessionContext, nativeToWeb) {
+    this._measure = measure;
+    // getSessionContext() returns 'navigation'|'scroll'|'keyboard'|'none'
+    // provided by index.js so RenderCollector doesn't import other collectors
+    this._getSessionContext = getSessionContext;
+    this._nativeToWeb = nativeToWeb ?? (t => t);
+    this._loafListeners = []; // [fn] called on every LoAF
+    this._getInteraction = null; // set by index.js after construction
+  }
+
+  /** Called by index.js to wire up interaction session context. */
+  setInteractionSource(fn) {
+    this._getInteraction = fn;
+  }
+
+  /** Called by index.js to wire up insights notifications. */
+  setInsightsSource(fn) {
+    this._notifyInsights = fn;
+  }
+
+  /** Called by index.js to feed the normalized perf store. */
+  setWaterfallSource(fn) {
+    this._notifyWaterfall = fn;
+  }
+
+  // Allow other collectors to subscribe to LoAF events
+  addLoafListener(fn) {
+    this._loafListeners.push(fn);
+  }
+  init() {
+    this._observeLoAF();
+    this._observeLayoutShift();
+  }
+
+  // ─── Native MetricsMonitor events ────────────────────────────────────────
+
+  onNativeEvent(event) {
+    const t = this._nativeToWeb(event.nativeTime);
+    switch (event.type) {
+      case "fps-drop-episode":
+        {
+          const start = Math.max(0, this._nativeToWeb(event.startNativeTime));
+          const end = Math.max(start, this._nativeToWeb(event.endNativeTime));
+          const markName = `${_constants.PREFIX.FPS_DROP}:${Math.round(start)}`;
+          performance.mark(markName, {
+            startTime: start
+          });
+          const interactionId = this._getInteraction?.()?.interactionIdForRange(start, end) ?? null;
+          if (interactionId) this._getInteraction?.()?.onFpsDrop();
+          this._measure.emit(`${interactionId ? `[${interactionId}] ` : ""}FPS drop: ${event.minFps.toFixed(1)}fps - ${Math.round(event.durationMs)}ms`, markName, end, {
+            interactionId,
+            minFps: event.minFps,
+            avgFps: event.avgFps,
+            durationMs: event.durationMs,
+            sessionContext: this._getSessionContext(),
+            thread: event.thread ?? null,
+            simulatorValid: false
+          }, _constants.TRACK.RENDER, event.minFps < 30 ? "error" : "tertiary");
+          this._notifyWaterfall?.({
+            metric: "fps-drop",
+            startTime: start,
+            endTime: end,
+            durationMs: event.durationMs,
+            minFps: event.minFps,
+            avgFps: event.avgFps,
+            sessionId: interactionId
+          });
+          return {
+            interactionId,
+            startTime: start,
+            endTime: end
+          };
+        }
+      case "long-task":
+        {
+          const markName = `${_constants.PREFIX.LONG_TASK}:${Math.round(t)}`;
+          const interactionId = this._getInteraction?.()?.interactionIdForRange(t, t + event.durationMs) ?? null;
+          performance.mark(markName, {
+            startTime: t
+          });
+          this._measure.emit(`${interactionId ? `[${interactionId}] ` : ""}Long task: ${event.durationMs}ms`, markName, t + event.durationMs, {
+            interactionId,
+            durationMs: event.durationMs,
+            sessionContext: this._getSessionContext(),
+            thread: event.thread ?? null,
+            simulatorValid: true
+          }, _constants.TRACK.RENDER, event.durationMs > 100 ? "error" : "tertiary");
+          this._notifyWaterfall?.({
+            metric: "long-task",
+            startTime: t,
+            endTime: t + event.durationMs,
+            durationMs: event.durationMs,
+            sessionId: interactionId
+          });
+          break;
+        }
+      case "memory-snapshot":
+        {
+          const jvmMark = `catalyst:mem/jvm:${Math.round(t)}`;
+          performance.mark(jvmMark, {
+            startTime: t
+          });
+          this._measure.emit(`JVM memory: ${event.jvmMb.toFixed(1)}MB`, jvmMark, t + 1, {
+            memoryId: `memory-jvm-${Math.round(t)}`,
+            jvmMb: event.jvmMb,
+            peakMb: event.peakMb,
+            thread: event.thread ?? null,
+            simulatorValid: false,
+            ...(event.coldStartMs != null ? {
+              coldStartMs: event.coldStartMs
+            } : {})
+          }, _constants.TRACK.MEMORY, "primary");
+          const webviewMemoryId = `memory-webview-${Math.round(t)}`;
+          const webviewMark = `catalyst:mem/webview:${Math.round(t)}`;
+          performance.mark(webviewMark, {
+            startTime: t
+          });
+          this._measure.emit(`WebView memory: ${event.webviewMb.toFixed(1)}MB`, webviewMark, t + 1, {
+            memoryId: webviewMemoryId,
+            webviewMb: event.webviewMb,
+            otherMb: event.otherMb,
+            peakMb: event.peakMb,
+            thread: event.thread ?? null,
+            simulatorValid: false,
+            ...(event.coldStartMs != null ? {
+              coldStartMs: event.coldStartMs
+            } : {})
+          }, _constants.TRACK.MEMORY, "tertiary-dark");
+          const totalMark = `${_constants.PREFIX.MEMORY_TOTAL}:${Math.round(t)}`;
+          performance.mark(totalMark, {
+            startTime: t
+          });
+          this._measure.emit(`Total memory: ${event.totalMb.toFixed(1)}MB`, totalMark, t + 1, {
+            memoryId: `memory-total-${Math.round(t)}`,
+            totalMb: event.totalMb,
+            jvmMb: event.jvmMb,
+            webviewMb: event.webviewMb,
+            otherMb: event.otherMb,
+            peakMb: event.peakMb,
+            thread: event.thread ?? null,
+            simulatorValid: false,
+            ...(event.coldStartMs != null ? {
+              coldStartMs: event.coldStartMs
+            } : {})
+          }, _constants.TRACK.MEMORY, event.totalMb > 400 ? "error" : "secondary");
+          this._notifyInsights?.({
+            currentMb: event.webviewMb,
+            startTime: t,
+            endTime: t + 1,
+            memoryId: webviewMemoryId
+          });
+          this._notifyWaterfall?.({
+            metric: "memory",
+            startTime: t,
+            endTime: t + 1,
+            durationMs: 1,
+            totalMb: event.totalMb,
+            webviewMb: event.webviewMb
+          });
+          break;
+        }
+    }
+  }
+
+  // ─── Long Animation Frames ────────────────────────────────────────────────
+
+  _observeLoAF() {
+    if (!PerformanceObserver.supportedEntryTypes?.includes("long-animation-frame")) return;
+    const obs = new PerformanceObserver(list => {
+      for (const entry of list.getEntries()) {
+        const start = entry.startTime;
+        const end = start + entry.duration;
+        const context = this._getSessionContext();
+
+        // Register with shared Measure so all collectors get overlap detection
+        this._measure.recordLoaf(start, end);
+
+        // Notify subscribers (ScrollCollector, HookCollector)
+        this._loafListeners.forEach(fn => fn(start, end));
+        const markName = `${_constants.PREFIX.LOAF}:${Math.round(start)}`;
+        performance.mark(markName, {
+          startTime: start
+        });
+        this._measure.emit(`${_constants.PREFIX.LOAF}|${Math.round(entry.duration)}ms`, markName, end, {
+          blockingDuration: entry.blockingDuration,
+          scriptCount: entry.scripts?.length ?? 0,
+          sessionContext: context,
+          simulatorValid: false
+        }, _constants.TRACK.RENDER);
+        this._notifyWaterfall?.({
+          metric: "loaf",
+          startTime: start,
+          endTime: end,
+          durationMs: entry.duration
+        });
+      }
+    });
+    obs.observe({
+      type: "long-animation-frame",
+      buffered: true
+    });
+  }
+
+  // ─── Layout shift ─────────────────────────────────────────────────────────
+
+  _observeLayoutShift() {
+    if (!PerformanceObserver.supportedEntryTypes?.includes("layout-shift")) return;
+    const obs = new PerformanceObserver(list => {
+      for (const entry of list.getEntries()) {
+        if (entry.hadRecentInput) continue; // user-initiated shift, ignore
+
+        const context = this._getSessionContext();
+        const markName = `catalyst:cls:${Math.round(entry.startTime)}`;
+        performance.mark(markName, {
+          startTime: entry.startTime
+        });
+        if (entry.value > 0.1) {
+          this._notifyInsights?.({
+            value: entry.value,
+            sessionContext: context,
+            startTime: entry.startTime,
+            endTime: entry.startTime + 1
+          });
+        }
+        this._measure.emit(`${_constants.PREFIX.LAYOUT_SHIFT}|${entry.value.toFixed(4)}`, markName, entry.startTime + 1,
+        // point-in-time event, minimal duration
+        {
+          value: entry.value,
+          sessionContext: context,
+          simulatorValid: false
+        }, _constants.TRACK.RENDER);
+        this._notifyWaterfall?.({
+          metric: "layout-shift",
+          startTime: entry.startTime,
+          endTime: entry.startTime + 1,
+          durationMs: 1,
+          value: entry.value
+        });
+      }
+    });
+    obs.observe({
+      type: "layout-shift",
+      buffered: true
+    });
+  }
+}
+exports.RenderCollector = RenderCollector;

package/dist/native/bridge/perf/collectors/ScrollCollector.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScrollCollector = void 0;
+var _constants = require("../core/constants.js");
+var _session = require("../core/session.js");
+/**
+ * ScrollCollector.js
+ *
+ * Instruments: bugs #3, #13
+ *   #3  keyboard sticky scroll bug   → scroll fires during keyboard session → sticky recalc → layout thrash
+ *   #13 cart computation jank        → fps-drop-episode during scroll → scroll session marked janky
+ *
+ * Spans emitted:
+ *   catalyst:session/scroll — scroll-start → scroll-end (Track: Input, shared with keyboard)
+ *                             detail: frameDropCount, minFps, janky, scrollDuration
+ *
+ * Native events consumed (via index.js _routeNativeEvent):
+ *   scroll-start  { nativeTime }   — GestureDetector first onScroll() in CustomWebview.kt
+ *   scroll-end    { nativeTime }   — GestureDetector ACTION_UP / ACTION_CANCEL
+ *
+ * fps-drop-episode routed here (Option B) when scroll session is open:
+ *   index.js checks this._scroll._session.isOpen before calling onFpsDrop(event)
+ */
+
+class ScrollCollector {
+  constructor(measure, nativeToWeb) {
+    this._measure = measure;
+    this._nativeToWeb = nativeToWeb;
+    this._session = new _session.Session(_constants.PREFIX.SESSION_SCROLL, measure, _constants.TRACK.INPUT);
+    this._insightsCb = null; // set by index.js via setInsightsSource
+    this._frameDropCount = 0;
+    this._minFps = 60;
+  }
+  init() {
+    // No DOM listener — scroll events come from native GestureDetector
+  }
+  setInsightsSource(cb) {
+    this._insightsCb = cb;
+  }
+  setWaterfallSource(fn) {
+    this._notifyWaterfall = fn;
+  }
+
+  // Called by RenderCollector when a LoAF fires (shared notification, kept for compat)
+  onLoaf() {
+    if (this._session.isOpen) {
+      this._session.increment("loafCount");
+    }
+  }
+
+  // ─── Native event handlers ────────────────────────────────────────────────
+
+  onScrollStart(event) {
+    if (this._session.isOpen) return; // already tracking, ignore duplicate start
+    const webNow = this._nativeToWeb(event.nativeTime);
+    this._frameDropCount = 0;
+    this._minFps = 60;
+    this._session.open({
+      loafCount: 0
+    }, webNow);
+  }
+  onScrollEnd(event) {
+    if (!this._session.isOpen) return;
+    const startTime = this._session.startTime;
+    const webNow = this._nativeToWeb(event.nativeTime);
+    const loafCount = this._session.get("loafCount") ?? 0;
+    const janky = this._frameDropCount > 0 || this._minFps < 55;
+    const durationMs = Math.round(webNow - startTime);
+    this._session.close({
+      loafCount,
+      frameDropCount: this._frameDropCount,
+      minFps: this._minFps,
+      janky,
+      simulatorValid: false
+    }, webNow);
+    if (janky && this._insightsCb) {
+      this._insightsCb({
+        minFps: this._minFps,
+        frameDropCount: this._frameDropCount,
+        startTime,
+        endTime: webNow
+      });
+    }
+    this._notifyWaterfall?.({
+      kind: "scroll",
+      startTime,
+      endTime: webNow,
+      durationMs,
+      loafCount,
+      frameDropCount: this._frameDropCount,
+      minFps: this._minFps,
+      janky
+    });
+    this._frameDropCount = 0;
+    this._minFps = 60;
+  }
+
+  // ─── fps-drop-episode correlation (Option B) ──────────────────────────────
+  // Called from index.js _routeNativeEvent when scroll session is open.
+
+  onFpsDrop(event) {
+    this._frameDropCount++;
+    if (event.minFps != null && event.minFps < this._minFps) {
+      this._minFps = event.minFps;
+    }
+  }
+}
+exports.ScrollCollector = ScrollCollector;

package/dist/native/bridge/perf/collectors/ThreadCollector.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ThreadCollector = void 0;
+var _constants = require("../core/constants.js");
+/**
+ * ThreadCollector.js
+ *
+ * Instruments: thread visibility gap during cache serving.
+ *
+ * Problem: when shouldInterceptRequest serves from cache it calls
+ * disableHardwareAcceleration() / enableHardwareAcceleration() on the WebView.
+ * This creates a software-render window that is invisible in the Render track
+ * because it happens on a bg thread and neither the thread name nor the
+ * hw-accel state appears in any existing span.
+ *
+ * Native events received (via index.js router):
+ *   hw-accel-change  { state: 'off'|'on', trigger: 'cache-serve'|'cleanup',
+ *                      thread, nativeTime }
+ *
+ * Spans emitted (on Render track):
+ *   catalyst:hw-accel/off  — software-render window open (error = bad, overlaps frames)
+ *   catalyst:hw-accel/on   — hardware acceleration restored (primary)
+ *
+ * Overlap detection:
+ *   If a LoAF overlaps a software-render window → notifyInsights so
+ *   InsightsCollector can fire an 'hw-accel-during-frame' critical insight.
+ */
+
+class ThreadCollector {
+  constructor(measure, nativeToWeb) {
+    this._measure = measure;
+    this._nativeToWeb = nativeToWeb;
+
+    // Track open software-render windows: { startMark, startTime, thread }
+    this._openWindow = null;
+    this._notifyInsights = null;
+  }
+
+  /** Called by index.js to wire up insights notifications. */
+  setInsightsSource(fn) {
+    this._notifyInsights = fn;
+  }
+  init() {
+    // No web-side observers — all events come from native via onNativeEvent()
+  }
+  onNativeEvent(event) {
+    if (event.type !== "hw-accel-change") return;
+    const {
+      state,
+      trigger,
+      thread,
+      nativeTime
+    } = event;
+    const webTime = nativeTime != null ? this._nativeToWeb(nativeTime) : performance.now();
+    if (state === "off") {
+      // Software-render window opens — record start, wait for 'on' to close span
+      const markName = `${_constants.PREFIX.HW_ACCEL}/off:start:${Math.round(webTime)}`;
+      performance.mark(markName, {
+        startTime: webTime
+      });
+      this._openWindow = {
+        startMark: markName,
+        startTime: webTime,
+        thread: thread ?? null,
+        trigger: trigger ?? null
+      };
+    } else if (state === "on") {
+      const endTime = webTime;
+      if (this._openWindow) {
+        const {
+          startMark,
+          startTime,
+          thread: offThread,
+          trigger: offTrigger
+        } = this._openWindow;
+        this._openWindow = null;
+        const loafOverlap = this._measure.overlapsLoaf(startTime, endTime);
+        this._measure.emit(`${_constants.PREFIX.HW_ACCEL}/sw-render-window|${offTrigger ?? "unknown"}`, startMark, endTime, {
+          trigger: offTrigger ?? null,
+          thread: offThread ?? null,
+          loafOverlap,
+          simulatorValid: false
+        }, _constants.TRACK.RENDER, loafOverlap ? _constants.COLOR.ERROR : _constants.COLOR.SECONDARY_DARK);
+        if (loafOverlap) {
+          this._notifyInsights?.({
+            durationMs: endTime - startTime,
+            thread: offThread,
+            trigger: offTrigger,
+            startTime,
+            endTime
+          });
+        }
+      }
+
+      // Emit a point-in-time marker for hw-accel restored
+      const onMark = `${_constants.PREFIX.HW_ACCEL}/on:${Math.round(endTime)}`;
+      performance.mark(onMark, {
+        startTime: endTime
+      });
+      this._measure.emit(`${_constants.PREFIX.HW_ACCEL}/restored`, onMark, endTime + 1, {
+        trigger: trigger ?? null,
+        thread: thread ?? null,
+        simulatorValid: false
+      }, _constants.TRACK.RENDER, _constants.COLOR.SECONDARY);
+    }
+  }
+}
+exports.ThreadCollector = ThreadCollector;