@react-perfscope/core 0.1.0

package/dist/index.js

@@ -0,0 +1,990 @@
+// src/recorder.ts
+var BUFFER_CAP = 1e4;
+function createRecorder() {
+  let recording = false;
+  let startedAt = 0;
+  let buffer = [];
+  const subscribers = /* @__PURE__ */ new Set();
+  const collectors = [];
+  function notify(signal) {
+    for (const cb of subscribers) {
+      try {
+        cb(signal);
+      } catch (err) {
+        console.warn("[react-perfscope] subscriber threw:", err);
+      }
+    }
+  }
+  function push(signal) {
+    if (!recording) return;
+    buffer.push(signal);
+    if (buffer.length > BUFFER_CAP) {
+      buffer.splice(0, buffer.length - BUFFER_CAP);
+    }
+    notify(signal);
+  }
+  const recorder = {
+    start() {
+      if (recording) return;
+      recording = true;
+      startedAt = performance.now();
+      buffer = [];
+      for (const c of collectors) {
+        try {
+          c.activate(push);
+        } catch (err) {
+          console.warn(`[react-perfscope] collector ${c.kind} failed to activate:`, err);
+        }
+      }
+    },
+    stop() {
+      if (!recording) {
+        return { signals: [], startedAt: 0, duration: 0 };
+      }
+      for (const c of collectors) {
+        try {
+          c.deactivate();
+        } catch (err) {
+          console.warn(`[react-perfscope] collector ${c.kind} failed to deactivate:`, err);
+        }
+      }
+      const duration = performance.now() - startedAt;
+      const result = {
+        signals: buffer.slice(),
+        startedAt,
+        duration
+      };
+      recording = false;
+      buffer = [];
+      return result;
+    },
+    isRecording() {
+      return recording;
+    },
+    onSignal(cb) {
+      subscribers.add(cb);
+      return () => subscribers.delete(cb);
+    },
+    use(collector) {
+      collectors.push(collector);
+    },
+    __push: push
+  };
+  return recorder;
+}
+
+// src/sourcemap.ts
+import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
+var CHROME_FRAME = /^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/;
+var FIREFOX_FRAME = /^(.*?)@(.+?):(\d+):(\d+)$/;
+async function resolveFrame(frame, fetchMap) {
+  try {
+    const map = await fetchMap(frame.file);
+    if (!map) return frame;
+    const tracer = new TraceMap(map);
+    const pos = originalPositionFor(tracer, { line: frame.line, column: frame.col });
+    if (pos.source == null || pos.line == null || pos.column == null) {
+      return frame;
+    }
+    const resolved = {
+      file: pos.source,
+      line: pos.line,
+      col: pos.column
+    };
+    if (pos.name) resolved.fnName = pos.name;
+    else if (frame.fnName) resolved.fnName = frame.fnName;
+    return resolved;
+  } catch (err) {
+    console.warn("[react-perfscope] resolveFrame failed:", err);
+    return frame;
+  }
+}
+function attachLazyStack(target, raw, skipTopFrames = 0) {
+  let cached = null;
+  Object.defineProperty(target, "stack", {
+    enumerable: true,
+    configurable: true,
+    get() {
+      if (cached === null) {
+        const all = parseStack(raw);
+        cached = skipTopFrames > 0 ? all.slice(skipTopFrames) : all;
+      }
+      return cached;
+    }
+  });
+}
+function createSourceMapResolver(opts = {}) {
+  const f = opts.fetch ?? (typeof fetch !== "undefined" ? fetch.bind(globalThis) : null);
+  const cache = /* @__PURE__ */ new Map();
+  function fetchMapFor(sourceUrl) {
+    if (!f) return Promise.resolve(null);
+    const existing = cache.get(sourceUrl);
+    if (existing) return existing;
+    const promise = (async () => {
+      try {
+        const res = await f(sourceUrl);
+        if (!res || !res.ok) return null;
+        const text = await res.text();
+        const m = text.match(/\/\/[#@]\s*sourceMappingURL=(.+?)\s*$/m);
+        if (!m) return null;
+        const ref = m[1].trim();
+        if (ref.startsWith("data:")) {
+          const commaIdx = ref.indexOf(",");
+          if (commaIdx === -1) return null;
+          const header = ref.slice(0, commaIdx);
+          const payload = ref.slice(commaIdx + 1);
+          const decoded = header.includes("base64") ? typeof atob === "function" ? atob(payload) : globalThis.Buffer.from(payload, "base64").toString("utf8") : decodeURIComponent(payload);
+          return JSON.parse(decoded);
+        }
+        const mapUrl = new URL(ref, sourceUrl).href;
+        const mapRes = await f(mapUrl);
+        if (!mapRes || !mapRes.ok) return null;
+        return await mapRes.json();
+      } catch {
+        return null;
+      }
+    })();
+    cache.set(sourceUrl, promise);
+    return promise;
+  }
+  return {
+    async resolve(frame) {
+      try {
+        return await resolveFrame(frame, fetchMapFor);
+      } catch {
+        return frame;
+      }
+    }
+  };
+}
+function parseStack(raw) {
+  if (!raw) return [];
+  const frames = [];
+  for (const line of raw.split("\n")) {
+    const chromeMatch = line.match(CHROME_FRAME);
+    if (chromeMatch) {
+      const [, fnName, file, lineStr, colStr] = chromeMatch;
+      const frame = {
+        file: file ?? "",
+        line: Number(lineStr),
+        col: Number(colStr)
+      };
+      if (fnName) frame.fnName = fnName;
+      frames.push(frame);
+      continue;
+    }
+    const firefoxMatch = line.match(FIREFOX_FRAME);
+    if (firefoxMatch) {
+      const [, fnName, file, lineStr, colStr] = firefoxMatch;
+      const frame = {
+        file: file ?? "",
+        line: Number(lineStr),
+        col: Number(colStr)
+      };
+      if (fnName) frame.fnName = fnName;
+      frames.push(frame);
+    }
+  }
+  return frames;
+}
+
+// src/collectors/long-tasks.ts
+var LOAF = "long-animation-frame";
+var LEGACY = "longtask";
+function supportsLoAF() {
+  const PO = globalThis.PerformanceObserver;
+  const types = PO?.supportedEntryTypes;
+  return Array.isArray(types) && types.includes(LOAF);
+}
+function mapScripts(scripts) {
+  return scripts.map((s) => ({
+    invokerType: s.invokerType ?? "unknown",
+    invoker: s.invoker ?? "",
+    sourceURL: s.sourceURL ?? "",
+    sourceFunctionName: s.sourceFunctionName ?? "",
+    charPosition: typeof s.sourceCharPosition === "number" ? s.sourceCharPosition : -1,
+    duration: typeof s.duration === "number" ? s.duration : 0
+  }));
+}
+function createLongTasksCollector() {
+  let observer = null;
+  let active = false;
+  return {
+    kind: "long-task",
+    activate(emit) {
+      if (typeof PerformanceObserver === "undefined") {
+        console.warn("[react-perfscope] PerformanceObserver not supported; long-tasks disabled");
+        return;
+      }
+      active = true;
+      const useLoAF = supportsLoAF();
+      try {
+        observer = new PerformanceObserver((list) => {
+          if (!active) return;
+          for (const entry of list.getEntries()) {
+            if (useLoAF) {
+              const loaf = entry;
+              const scripts = Array.isArray(loaf.scripts) ? mapScripts(loaf.scripts) : [];
+              emit({
+                kind: "long-task",
+                at: entry.startTime,
+                duration: entry.duration,
+                stack: [],
+                scripts,
+                ...typeof loaf.blockingDuration === "number" ? { blockingDuration: loaf.blockingDuration } : {}
+              });
+            } else {
+              emit({
+                kind: "long-task",
+                at: entry.startTime,
+                duration: entry.duration,
+                stack: []
+              });
+            }
+          }
+        });
+        observer.observe({ type: useLoAF ? LOAF : LEGACY, buffered: false });
+      } catch (err) {
+        console.warn("[react-perfscope] long-tasks collector failed to start:", err);
+        observer = null;
+        active = false;
+      }
+    },
+    deactivate() {
+      active = false;
+      if (observer) {
+        try {
+          observer.disconnect();
+        } catch {
+        }
+        observer = null;
+      }
+    }
+  };
+}
+
+// src/collectors/forced-reflow.ts
+var LAYOUT_GETTERS = [
+  "offsetWidth",
+  "offsetHeight",
+  "offsetLeft",
+  "offsetTop",
+  "clientWidth",
+  "clientHeight",
+  "scrollWidth",
+  "scrollHeight"
+];
+var LAYOUT_METHODS = ["getBoundingClientRect", "getClientRects"];
+function createForcedReflowCollector() {
+  let active = false;
+  let emit = () => {
+  };
+  const saved = [];
+  let mutationObserver = null;
+  function consumePendingMutations() {
+    if (!mutationObserver) {
+      return true;
+    }
+    return mutationObserver.takeRecords().length > 0;
+  }
+  function patchGetter(proto, key) {
+    if (typeof proto !== "object" || proto === null) return;
+    const desc = Object.getOwnPropertyDescriptor(proto, key);
+    if (!desc || !desc.get) return;
+    saved.push({ proto, key, descriptor: desc });
+    const originalGet = desc.get;
+    Object.defineProperty(proto, key, {
+      configurable: true,
+      get() {
+        if (active) {
+          if (!consumePendingMutations()) {
+            return originalGet.call(this);
+          }
+          const at = performance.now();
+          const rawStack = new Error().stack;
+          const value = originalGet.call(this);
+          const duration = performance.now() - at;
+          const signal = { kind: "forced-reflow", at, duration };
+          attachLazyStack(signal, rawStack, 1);
+          emit(signal);
+          return value;
+        }
+        return originalGet.call(this);
+      },
+      set: desc.set
+    });
+  }
+  function patchMethod(proto, key) {
+    if (typeof proto !== "object" || proto === null) return;
+    const desc = Object.getOwnPropertyDescriptor(proto, key);
+    if (!desc || typeof desc.value !== "function") return;
+    saved.push({ proto, key, descriptor: desc });
+    const original = desc.value;
+    Object.defineProperty(proto, key, {
+      configurable: true,
+      writable: true,
+      value: function patchedLayoutMethod(...args) {
+        if (active) {
+          if (!consumePendingMutations()) {
+            return original.apply(this, args);
+          }
+          const at = performance.now();
+          const rawStack = new Error().stack;
+          const value = original.apply(this, args);
+          const duration = performance.now() - at;
+          const signal = { kind: "forced-reflow", at, duration };
+          attachLazyStack(signal, rawStack, 1);
+          emit(signal);
+          return value;
+        }
+        return original.apply(this, args);
+      }
+    });
+  }
+  return {
+    kind: "forced-reflow",
+    activate(emitFn) {
+      if (active) return;
+      emit = emitFn;
+      active = true;
+      if (typeof MutationObserver !== "undefined" && typeof document !== "undefined") {
+        try {
+          mutationObserver = new MutationObserver(() => {
+          });
+          mutationObserver.observe(document, {
+            attributes: true,
+            childList: true,
+            subtree: true,
+            characterData: true
+          });
+        } catch (err) {
+          console.warn("[react-perfscope] forced-reflow MutationObserver failed:", err);
+          mutationObserver = null;
+        }
+      }
+      if (typeof HTMLElement !== "undefined") {
+        for (const key of LAYOUT_GETTERS) {
+          patchGetter(HTMLElement.prototype, key);
+        }
+      }
+      if (typeof Element !== "undefined") {
+        for (const key of LAYOUT_METHODS) {
+          patchMethod(Element.prototype, key);
+        }
+      }
+    },
+    deactivate() {
+      if (!active) return;
+      active = false;
+      if (mutationObserver) {
+        try {
+          mutationObserver.disconnect();
+        } catch {
+        }
+        mutationObserver = null;
+      }
+      for (const { proto, key, descriptor } of saved) {
+        Object.defineProperty(proto, key, descriptor);
+      }
+      saved.length = 0;
+    }
+  };
+}
+
+// src/collectors/layout-shift.ts
+var PERFSCOPE_HOST_ATTR = "data-perfscope-host";
+function rectsOverlap(a, b, tolerance = 0) {
+  return !(a.x + a.width < b.x - tolerance || b.x + b.width < a.x - tolerance || a.y + a.height < b.y - tolerance || b.y + b.height < a.y - tolerance);
+}
+function collectPerfscopeRects() {
+  const hosts = Array.from(document.querySelectorAll(`[${PERFSCOPE_HOST_ATTR}]`));
+  const rects = [];
+  for (const h of hosts) {
+    const sr = h.shadowRoot;
+    if (sr) {
+      for (const child of Array.from(sr.children)) {
+        const r = child.getBoundingClientRect();
+        if (r.width > 0 && r.height > 0) rects.push(r);
+      }
+    } else {
+      const r = h.getBoundingClientRect();
+      if (r.width > 0 && r.height > 0) rects.push(r);
+    }
+  }
+  return rects;
+}
+function entryIsOnlyFromPerfscope(sources) {
+  if (sources.length === 0) return false;
+  if (typeof document === "undefined") return false;
+  const hostRects = collectPerfscopeRects();
+  if (hostRects.length === 0) return false;
+  for (const src of sources) {
+    let matched = false;
+    const node = src.node;
+    if (node) {
+      if (typeof node.closest === "function") {
+        if (node.closest(`[${PERFSCOPE_HOST_ATTR}]`)) matched = true;
+      } else {
+        let parent = node.parentElement;
+        while (parent) {
+          if (parent.hasAttribute(PERFSCOPE_HOST_ATTR)) {
+            matched = true;
+            break;
+          }
+          parent = parent.parentElement;
+        }
+      }
+    }
+    if (!matched) {
+      for (const hostRect of hostRects) {
+        if (rectsOverlap(src.currentRect, hostRect, 24)) {
+          matched = true;
+          break;
+        }
+      }
+    }
+    if (!matched) return false;
+  }
+  return true;
+}
+function createLayoutShiftCollector() {
+  let observer = null;
+  let active = false;
+  return {
+    kind: "layout-shift",
+    activate(emit) {
+      if (typeof PerformanceObserver === "undefined") {
+        console.warn("[react-perfscope] PerformanceObserver not supported; layout-shift disabled");
+        return;
+      }
+      active = true;
+      try {
+        observer = new PerformanceObserver((list) => {
+          if (!active) return;
+          for (const raw of list.getEntries()) {
+            const entry = raw;
+            const sources = entry.sources ?? [];
+            if (entryIsOnlyFromPerfscope(sources)) continue;
+            const sx = typeof window !== "undefined" && window.scrollX || 0;
+            const sy = typeof window !== "undefined" && window.scrollY || 0;
+            const toDocRect = (r) => new DOMRect(r.x + sx, r.y + sy, r.width, r.height);
+            const rects = sources.map((s) => toDocRect(s.currentRect));
+            const prevRects = sources.map((s) => {
+              const pr = s.previousRect;
+              if (!pr) return null;
+              if (pr.width === 0 && pr.height === 0) return null;
+              return toDocRect(pr);
+            });
+            emit({
+              kind: "layout-shift",
+              at: entry.startTime,
+              value: entry.value,
+              sources: rects,
+              previousSources: prevRects
+            });
+          }
+        });
+        observer.observe({ type: "layout-shift", buffered: false });
+      } catch (err) {
+        console.warn("[react-perfscope] layout-shift collector failed to start:", err);
+        observer = null;
+        active = false;
+      }
+    },
+    deactivate() {
+      active = false;
+      if (observer) {
+        try {
+          observer.disconnect();
+        } catch {
+        }
+        observer = null;
+      }
+    }
+  };
+}
+
+// src/collectors/network.ts
+function createNetworkCollector() {
+  let observer = null;
+  let active = false;
+  return {
+    kind: "network",
+    activate(emit) {
+      if (typeof PerformanceObserver === "undefined") {
+        console.warn("[react-perfscope] PerformanceObserver not supported; network disabled");
+        return;
+      }
+      active = true;
+      try {
+        observer = new PerformanceObserver((list) => {
+          if (!active) return;
+          for (const raw of list.getEntries()) {
+            const entry = raw;
+            emit({
+              kind: "network",
+              url: entry.name,
+              startedAt: entry.startTime,
+              duration: entry.duration,
+              size: entry.transferSize ?? 0,
+              blocking: entry.renderBlockingStatus === "blocking"
+            });
+          }
+        });
+        observer.observe({ type: "resource", buffered: false });
+      } catch (err) {
+        console.warn("[react-perfscope] network collector failed to start:", err);
+        observer = null;
+        active = false;
+      }
+    },
+    deactivate() {
+      active = false;
+      if (observer) {
+        try {
+          observer.disconnect();
+        } catch {
+        }
+        observer = null;
+      }
+    }
+  };
+}
+
+// src/collectors/web-vitals.ts
+import { onLCP, onINP, onCLS, onFCP, onTTFB } from "web-vitals";
+function createWebVitalsCollector() {
+  let active = false;
+  let subscribed = false;
+  let emit = () => {
+  };
+  function makeHandler(name) {
+    return (metric) => {
+      if (!active) return;
+      emit({ kind: "web-vital", name, value: metric.value });
+    };
+  }
+  return {
+    kind: "web-vital",
+    activate(emitFn) {
+      emit = emitFn;
+      active = true;
+      if (subscribed) return;
+      try {
+        onLCP(makeHandler("LCP"));
+        onINP(makeHandler("INP"));
+        onCLS(makeHandler("CLS"));
+        onFCP(makeHandler("FCP"));
+        onTTFB(makeHandler("TTFB"));
+        subscribed = true;
+      } catch (err) {
+        console.warn("[react-perfscope] web-vitals collector failed to subscribe:", err);
+        active = false;
+      }
+    },
+    deactivate() {
+      active = false;
+    }
+  };
+}
+
+// src/collectors/heap.ts
+var SAMPLE_INTERVAL_MS = 250;
+var MAX_SAMPLES = 2e4;
+var MIN_SAMPLES = 4;
+var FLOOR_SEGMENTS = 8;
+var MB = 1024 * 1024;
+var GROWING_SLOPE = 1 * MB;
+var LEAK_SLOPE = 5 * MB;
+var MIN_NET_GROWTH = 2 * MB;
+function readMemory() {
+  const perf = globalThis.performance;
+  const mem = perf?.memory;
+  if (!mem || typeof mem.usedJSHeapSize !== "number") return null;
+  return mem;
+}
+function slope(points) {
+  const n = points.length;
+  if (n < 2) return 0;
+  let sx = 0;
+  let sy = 0;
+  let sxy = 0;
+  let sxx = 0;
+  for (const { x, y } of points) {
+    sx += x;
+    sy += y;
+    sxy += x * y;
+    sxx += x * x;
+  }
+  const denom = n * sxx - sx * sx;
+  if (denom === 0) return 0;
+  return (n * sxy - sx * sy) / denom;
+}
+function analyzeHeapTrend(samples) {
+  if (samples.length < MIN_SAMPLES) return null;
+  const t0 = samples[0].at;
+  const segSize = Math.max(1, Math.ceil(samples.length / FLOOR_SEGMENTS));
+  const floorPoints = [];
+  for (let i = 0; i < samples.length; i += segSize) {
+    const seg = samples.slice(i, i + segSize);
+    let min = Infinity;
+    for (const s of seg) min = Math.min(min, s.used);
+    const mid = seg[Math.floor(seg.length / 2)];
+    floorPoints.push({ x: (mid.at - t0) / 6e4, y: min });
+  }
+  const slopeBytesPerMin = slope(floorPoints);
+  const spanMin = (samples[samples.length - 1].at - t0) / 6e4;
+  const projectedGrowth = slopeBytesPerMin * spanMin;
+  const recent = floorPoints.slice(Math.floor(floorPoints.length / 2));
+  const recentSlope = recent.length >= 2 ? slope(recent) : slopeBytesPerMin;
+  let classification = "stable";
+  const sustained = projectedGrowth >= MIN_NET_GROWTH && recentSlope >= GROWING_SLOPE;
+  if (sustained) {
+    classification = slopeBytesPerMin >= LEAK_SLOPE && recentSlope >= LEAK_SLOPE ? "leak-suspected" : "growing";
+  }
+  return { classification, slopeBytesPerMin };
+}
+function createHeapCollector() {
+  let samples = [];
+  let timer = null;
+  function sample() {
+    const mem = readMemory();
+    if (!mem) return;
+    samples.push({ at: performance.now(), used: mem.usedJSHeapSize, total: mem.totalJSHeapSize });
+    if (samples.length > MAX_SAMPLES) samples.splice(0, samples.length - MAX_SAMPLES);
+  }
+  return {
+    kind: "heap",
+    activate() {
+      samples = [];
+      if (!readMemory()) return;
+      sample();
+      timer = setInterval(sample, SAMPLE_INTERVAL_MS);
+    },
+    deactivate() {
+      if (timer == null) return;
+      clearInterval(timer);
+      timer = null;
+      sample();
+    },
+    finalize(result) {
+      if (samples.length === 0) return result;
+      return { ...result, heapSamples: samples.slice() };
+    }
+  };
+}
+
+// src/collectors/interaction.ts
+var DURATION_THRESHOLD = 40;
+function selectorFor(target) {
+  const el = target;
+  if (!el || typeof el.tagName !== "string") return void 0;
+  let s = el.tagName.toLowerCase();
+  if (el.id) s += `#${el.id}`;
+  else if (typeof el.className === "string" && el.className.trim()) {
+    s += `.${el.className.trim().split(/\s+/)[0]}`;
+  }
+  return s;
+}
+function supportsEventTiming() {
+  const PO = globalThis.PerformanceObserver;
+  const types = PO?.supportedEntryTypes;
+  return !types || types.includes("event");
+}
+function createInteractionCollector() {
+  let active = false;
+  let observer = null;
+  let entries = [];
+  return {
+    kind: "interaction",
+    activate() {
+      if (typeof PerformanceObserver === "undefined" || !supportsEventTiming()) return;
+      active = true;
+      entries = [];
+      try {
+        observer = new PerformanceObserver((list) => {
+          if (!active) return;
+          for (const e of list.getEntries()) entries.push(e);
+        });
+        observer.observe({ type: "event", buffered: false, durationThreshold: DURATION_THRESHOLD });
+        try {
+          observer.observe({ type: "first-input", buffered: false });
+        } catch {
+        }
+      } catch (err) {
+        console.warn("[react-perfscope] interaction collector failed to start:", err);
+        observer = null;
+        active = false;
+      }
+    },
+    deactivate() {
+      active = false;
+      if (observer) {
+        try {
+          observer.disconnect();
+        } catch {
+        }
+        observer = null;
+      }
+    },
+    finalize(result) {
+      const byId = /* @__PURE__ */ new Map();
+      for (const e of entries) {
+        const id = e.interactionId;
+        if (!id) continue;
+        const group = byId.get(id);
+        if (group) group.push(e);
+        else byId.set(id, [e]);
+      }
+      const interactions = [];
+      for (const group of byId.values()) {
+        let duration = 0;
+        let startTime = Infinity;
+        let processingStart = Infinity;
+        let processingEnd = -Infinity;
+        let defining = group[0];
+        let maxProcessing = -Infinity;
+        for (const e of group) {
+          if (e.duration > duration) duration = e.duration;
+          if (e.startTime < startTime) startTime = e.startTime;
+          if (e.processingStart < processingStart) processingStart = e.processingStart;
+          if (e.processingEnd > processingEnd) processingEnd = e.processingEnd;
+          const proc = e.processingEnd - e.processingStart;
+          if (proc > maxProcessing) {
+            maxProcessing = proc;
+            defining = e;
+          }
+        }
+        if (duration < DURATION_THRESHOLD) continue;
+        const inputDelay = Math.max(0, processingStart - startTime);
+        const processing = Math.max(0, processingEnd - processingStart);
+        const presentation = Math.max(0, startTime + duration - processingEnd);
+        interactions.push({
+          kind: "interaction",
+          at: startTime,
+          eventType: defining.name,
+          ...selectorFor(defining.target) ? { target: selectorFor(defining.target) } : {},
+          duration,
+          inputDelay,
+          processing,
+          presentation
+        });
+      }
+      if (interactions.length === 0) return result;
+      interactions.sort((a, b) => a.at - b.at);
+      return { ...result, signals: [...result.signals, ...interactions] };
+    }
+  };
+}
+
+// src/collectors/frames.ts
+var FRAME_BUDGET = 1e3 / 60;
+var BUCKET_MS = 500;
+var MIN_BUCKET_SPAN = 100;
+var MIN_FRAMES = 8;
+var MAX_FRAMES = 2e4;
+function analyzeFrames(frames) {
+  if (frames.length < MIN_FRAMES) return null;
+  let longestFrameMs = 0;
+  let droppedFrames = 0;
+  for (let i = 1; i < frames.length; i++) {
+    const gap = frames[i] - frames[i - 1];
+    if (gap > longestFrameMs) longestFrameMs = gap;
+    const dropped = Math.round(gap / FRAME_BUDGET) - 1;
+    if (dropped > 0) droppedFrames += dropped;
+  }
+  const t0 = frames[0];
+  const end = frames[frames.length - 1];
+  const series = [];
+  let minFps = Infinity;
+  let idx = 0;
+  for (let bStart = t0; bStart < end; bStart += BUCKET_MS) {
+    const bEnd = Math.min(bStart + BUCKET_MS, end);
+    const span = bEnd - bStart;
+    let count = 0;
+    while (idx < frames.length && frames[idx] < bEnd) {
+      count++;
+      idx++;
+    }
+    if (span < MIN_BUCKET_SPAN) break;
+    const fps = count / (span / 1e3);
+    series.push({ at: bStart + span / 2, fps });
+    if (fps < minFps) minFps = fps;
+  }
+  if (series.length === 0) return null;
+  return { series, minFps, longestFrameMs, droppedFrames };
+}
+function createFrameCollector() {
+  let active = false;
+  let rafId = null;
+  let frames = [];
+  function loop(t) {
+    if (!active) return;
+    frames.push(t);
+    if (frames.length > MAX_FRAMES) frames.splice(0, frames.length - MAX_FRAMES);
+    rafId = requestAnimationFrame(loop);
+  }
+  return {
+    kind: "frame",
+    activate() {
+      if (typeof requestAnimationFrame === "undefined") return;
+      active = true;
+      frames = [];
+      rafId = requestAnimationFrame(loop);
+    },
+    deactivate() {
+      active = false;
+      if (rafId != null && typeof cancelAnimationFrame !== "undefined") {
+        try {
+          cancelAnimationFrame(rafId);
+        } catch {
+        }
+      }
+      rafId = null;
+    },
+    finalize(result) {
+      if (frames.length < MIN_FRAMES) return result;
+      return { ...result, frames: frames.slice() };
+    }
+  };
+}
+
+// src/collectors/self-profiling.ts
+var SAMPLE_INTERVAL_MS2 = 10;
+var MAX_BUFFER_SIZE = 1e5;
+var MAX_FRAMES_PER_TASK = 5;
+function isUserResource(url) {
+  if (!url) return false;
+  if (url.includes("/node_modules/")) return false;
+  try {
+    const path = new URL(url).pathname;
+    if (path.startsWith("/@")) return false;
+  } catch {
+    if (url.startsWith("/@")) return false;
+  }
+  return true;
+}
+function frameToStackFrame(trace, frame) {
+  const file = frame.resourceId != null ? trace.resources[frame.resourceId] ?? "" : "";
+  const sf = {
+    file,
+    line: frame.line ?? 0,
+    col: frame.column ?? 0
+  };
+  if (frame.name) sf.fnName = frame.name;
+  return sf;
+}
+function leafUserFrame(trace, stackId) {
+  let id = stackId;
+  let guard = 0;
+  while (id != null && guard++ < 1e3) {
+    const stack = trace.stacks[id];
+    if (!stack) break;
+    const frame = trace.frames[stack.frameId];
+    if (frame && isUserResource(trace.resources[frame.resourceId ?? -1])) {
+      return frame;
+    }
+    id = stack.parentId;
+  }
+  return null;
+}
+function attributeWindow(trace, start, end) {
+  let total = 0;
+  const counts = /* @__PURE__ */ new Map();
+  for (const sample of trace.samples) {
+    if (sample.timestamp < start || sample.timestamp > end) continue;
+    total++;
+    const frame = leafUserFrame(trace, sample.stackId);
+    if (!frame) continue;
+    const sf = frameToStackFrame(trace, frame);
+    const key = `${sf.file}:${sf.line}:${sf.col}:${sf.fnName ?? ""}`;
+    const entry = counts.get(key);
+    if (entry) entry.count++;
+    else counts.set(key, { frame: sf, count: 1 });
+  }
+  if (total === 0) return [];
+  return [...counts.values()].sort((a, b) => b.count - a.count).slice(0, MAX_FRAMES_PER_TASK).map(({ frame, count }) => ({ frame, selfRatio: count / total, sampleCount: count }));
+}
+function attributeLongTaskSignals(trace, signals) {
+  return signals.map((signal) => {
+    if (signal.kind !== "long-task") return signal;
+    const attribution = attributeWindow(trace, signal.at, signal.at + signal.duration);
+    if (attribution.length === 0) return signal;
+    return { ...signal, attribution };
+  });
+}
+function attributeInteractionSignals(trace, signals) {
+  return signals.map((signal) => {
+    if (signal.kind !== "interaction") return signal;
+    const start = signal.at + signal.inputDelay;
+    const attribution = attributeWindow(trace, start, start + signal.processing);
+    if (attribution.length === 0) return signal;
+    return { ...signal, attribution };
+  });
+}
+function createSelfProfilingCollector() {
+  let profiler = null;
+  let tracePromise = null;
+  return {
+    kind: "long-task",
+    activate() {
+      tracePromise = null;
+      const Ctor = globalThis.Profiler;
+      if (typeof Ctor !== "function") return;
+      try {
+        profiler = new Ctor({ sampleInterval: SAMPLE_INTERVAL_MS2, maxBufferSize: MAX_BUFFER_SIZE });
+      } catch (err) {
+        console.warn(
+          "[react-perfscope] self-profiling unavailable (needs Document-Policy: js-profiling header); long tasks keep LoAF-only attribution:",
+          err
+        );
+        profiler = null;
+      }
+    },
+    deactivate() {
+      if (!profiler) return;
+      try {
+        tracePromise = profiler.stop();
+      } catch (err) {
+        console.warn("[react-perfscope] self-profiling stop failed:", err);
+        tracePromise = null;
+      }
+      profiler = null;
+    },
+    async finalize(result) {
+      if (!tracePromise) return result;
+      try {
+        const trace = await tracePromise;
+        const signals = attributeInteractionSignals(trace, attributeLongTaskSignals(trace, result.signals));
+        return { ...result, signals };
+      } catch (err) {
+        console.warn("[react-perfscope] self-profiling finalize failed:", err);
+        return result;
+      } finally {
+        tracePromise = null;
+      }
+    }
+  };
+}
+export {
+  analyzeFrames,
+  analyzeHeapTrend,
+  attachLazyStack,
+  attributeLongTaskSignals,
+  attributeWindow,
+  createForcedReflowCollector,
+  createFrameCollector,
+  createHeapCollector,
+  createInteractionCollector,
+  createLayoutShiftCollector,
+  createLongTasksCollector,
+  createNetworkCollector,
+  createRecorder,
+  createSelfProfilingCollector,
+  createSourceMapResolver,
+  createWebVitalsCollector,
+  isUserResource,
+  parseStack,
+  resolveFrame
+};
+//# sourceMappingURL=index.js.map