react-render-detective 0.5.0 → 0.6.0

package/dist/index.d.ts

@@ -1,96 +1,8 @@
-import { b as RenderEvent, j as Confidence, R as RenderReason, a as DetectiveOptions, D as DetectiveConfig, A as AppStats, d as ComponentStats } from './types-gl13xwmN.js';
-export { i as ComponentInfo, C as ContextChange, f as Diagnosis, I as Inspected, g as InspectionLimits, M as Mode, P as PropChange, k as PropChangeKind, h as PropValueType, c as RenderPhase, l as RenderTimings, e as Thresholds, T as TrackedStateChange } from './types-gl13xwmN.js';
+import { j as Confidence, b as RenderEvent, R as RenderReason, a as DetectiveOptions, D as DetectiveConfig, A as AppStats, d as ComponentStats } from './types-CRET8EhB.js';
+export { i as ComponentInfo, C as ContextChange, f as Diagnosis, I as Inspected, g as InspectionLimits, M as Mode, P as PropChange, k as PropChangeKind, h as PropValueType, c as RenderPhase, l as RenderTimings, S as SelectorChange, e as Thresholds, T as TrackedStateChange } from './types-CRET8EhB.js';
 import { RenderProfile } from './testing.js';
 import { ComponentType, ReactNode, Dispatch, SetStateAction } from 'react';
 
-/**
- * Interaction-scoped attribution.
- *
- * Performance is felt per interaction, not in aggregate — and INP is the metric
- * teams are actually judged on. This joins the two halves: the browser says a
- * keystroke took 240ms, and the render events say which components spent it and
- * why.
- *
- * Uses `PerformanceObserver` with `event` timing, a public browser API. Where it
- * is unsupported (older Safari, jsdom) interaction tracking simply stays empty
- * rather than guessing.
- */
-interface InteractionRecord {
-    id: string;
-    /** `click`, `keydown`, `pointerup`… */
-    type: string;
-    /** Best-effort description of what was interacted with. */
-    target?: string;
-    startTime: number;
-    /** Browser-reported event duration — the number INP is computed from. */
-    durationMs: number;
-    /**
-     * For a manually measured interaction: how long the synchronous action took.
-     * Immune to throttling, unlike the full window, which waits on a frame.
-     */
-    handlerMs?: number;
-    /** Renders committed inside this interaction's window. */
-    renders: RenderEvent[];
-    /** Sum of self durations for those renders. */
-    renderTimeMs: number;
-    /** Render time that no observable input change explains. */
-    avoidableRenderTimeMs: number;
-}
-interface InteractionSummary {
-    interaction: InteractionRecord;
-    /** Components ordered by cost within this interaction. */
-    contributors: Array<{
-        component: string;
-        source?: string;
-        renders: number;
-        totalMs: number;
-        cause: string;
-    }>;
-    headline: string;
-    nextStep: string;
-    confidence: Confidence;
-}
-interface RawEventTiming {
-    name: string;
-    startTime: number;
-    duration: number;
-    target?: string;
-    handlerMs?: number;
-}
-declare class InteractionTracker {
-    private capacity;
-    private records;
-    private observer;
-    private nextId;
-    constructor(capacity?: number);
-    /** Returns false when the browser cannot report event timing. */
-    start(): boolean;
-    stop(): void;
-    /** Is the automatic path available in this browser? */
-    get automatic(): boolean;
-    /**
-     * Time an interaction by hand.
-     *
-     * The automatic path depends on the Event Timing API, which Safari only
-     * gained in 16.4 and which does not fire for synthetic input at all — so
-     * anything driven by a test harness records nothing. This measures a specific
-     * action instead, up to the paint that follows it, and needs no browser
-     * support beyond `performance.now`.
-     */
-    measure<T>(label: string, action: () => T): T;
-    /** Exposed for tests and for `measure`. */
-    record(timing: RawEventTiming): InteractionRecord;
-    clear(): void;
-    /**
-     * Joins render events to interactions by commit time. A render belongs to an
-     * interaction when it committed between the event starting and shortly after
-     * it finished — React commits just after the event handler returns.
-     */
-    attribute(events: RenderEvent[]): InteractionRecord[];
-}
-declare function summarise(record: InteractionRecord): InteractionSummary;
-declare function formatInteraction(summary: InteractionSummary): string;
-
 /**
  * "Where should I spend my next hour?"
  *
@@ -171,6 +83,31 @@ interface RenderDetectiveProps {
  */
 declare function RenderDetective({ name, children }: RenderDetectiveProps): ReactNode;
 
+interface TrackSelectorOptions {
+    /** Readable label — a property path where one could be derived, else the call site. */
+    name?: string;
+    /** `File.tsx:12:3` of the call, supplied by the build plugin. */
+    source?: string;
+}
+/**
+ * Records a store value and returns it untouched.
+ *
+ * Pass-through by construction: the value is returned as given, and nothing
+ * here can change what the component receives.
+ */
+declare function trackSelector<T>(value: T, options?: TrackSelectorOptions): T;
+/**
+ * Wraps a store hook so its results are attributed. Signature-preserving: extra
+ * arguments (react-redux's equality function, for instance) pass straight
+ * through, because changing them would change the app's behaviour.
+ *
+ *   const useSelector = createTrackedSelectorHook(useReduxSelector);
+ *
+ * The build plugin rewrites `useSelector` imports for you; use this directly for
+ * a custom store hook, or where the plugin cannot run.
+ */
+declare function createTrackedSelectorHook<A extends unknown[], R>(hook: (...args: A) => R, options?: TrackSelectorOptions): (...args: A) => R;
+
 /**
  * In-component diagnostics without wrapping.
  *
@@ -231,6 +168,13 @@ interface Explanation {
         share: number;
         valueType: string;
     }>;
+    /** Store selectors that returned a new reference with identical contents. */
+    unstableSelectors: Array<{
+        name: string;
+        source?: string;
+        count: number;
+        share: number;
+    }>;
     averageSelfDuration: number;
     totalSelfDuration: number;
     potentiallyAvoidableRenders: number;
@@ -280,25 +224,6 @@ declare function explain(componentName: string): string | undefined;
 declare function explainStructured(componentName: string): Explanation | undefined;
 /** Snapshot render behaviour for regression testing. See `react-render-detective/testing`. */
 declare function getRenderProfile(scenario: string): RenderProfile;
-/**
- * Interactions, slowest first, with the renders that happened inside each.
- *
- * This is the bridge from render causality to what a user actually feels: the
- * browser reports how long the interaction took, and the render events say
- * which components spent that time and why.
- */
-declare function getInteractions(): InteractionRecord[];
-/** Structured analysis of one interaction. Defaults to the slowest recorded. */
-declare function explainInteractionStructured(id?: string): InteractionSummary | undefined;
-declare function explainInteraction(id?: string): string | undefined;
-declare function printInteractions(limit?: number): void;
-/**
- * Time one interaction explicitly, up to the paint that follows it.
- *
- * Needed wherever the automatic path cannot see: Safari before 16.4, and any
- * synthetic input, which never produces Event Timing entries.
- */
-declare function measureInteraction<T>(label: string, action: () => T): T;
 /**
  * Components ranked by estimated recoverable time — the triage view. Render
  * counts answer the wrong question; this answers "what should I fix first?".
@@ -323,13 +248,8 @@ declare const ReactRenderDetective: {
     explainStructured: typeof explainStructured;
     getOpportunities: typeof getOpportunities;
     printOpportunities: typeof printOpportunities;
-    getInteractions: typeof getInteractions;
-    explainInteraction: typeof explainInteraction;
-    explainInteractionStructured: typeof explainInteractionStructured;
-    printInteractions: typeof printInteractions;
-    measureInteraction: typeof measureInteraction;
     getRenderProfile: typeof getRenderProfile;
     printStats: typeof printStats;
 };
 
-export { AppStats, ComponentStats, Confidence, DetectiveConfig, DetectiveOptions, type Explanation, type InteractionRecord, type InteractionSummary, InteractionTracker, type Opportunity, ReactRenderDetective, RenderDetective, type RenderDetectiveProps, RenderEvent, RenderReason, type TrackOptions, clear, configure, explain, explainEvents, explainInteraction, explainInteractionStructured, explainStructured, formatExplanation, formatInteraction, formatOpportunities, getComponentStats, getConfig, getEvents, getInteractions, getOpportunities, getRenderProfile, getStats, init, isEnabled, measureInteraction, printInteractions, printOpportunities, printStats, rankOpportunities, reset, subscribe, summarise as summariseInteraction, useRenderDiagnostics, useTrackedContextValue, useTrackedEffect, useTrackedState, withRenderDetective };
+export { AppStats, ComponentStats, Confidence, DetectiveConfig, DetectiveOptions, type Explanation, type Opportunity, ReactRenderDetective, RenderDetective, type RenderDetectiveProps, RenderEvent, RenderReason, type TrackOptions, type TrackSelectorOptions, clear, configure, createTrackedSelectorHook, explain, explainEvents, explainStructured, formatExplanation, formatOpportunities, getComponentStats, getConfig, getEvents, getOpportunities, getRenderProfile, getStats, init, isEnabled, printOpportunities, printStats, rankOpportunities, reset, subscribe, trackSelector, useRenderDiagnostics, useTrackedContextValue, useTrackedEffect, useTrackedState, withRenderDetective };

package/dist/index.js

@@ -1,9 +1,9 @@
-import { explainEvents, formatExplanation } from './chunk-HOTY7J3X.js';
-export { explainEvents, formatExplanation } from './chunk-HOTY7J3X.js';
-import { getDetective, inspect, shallowEqual, diffProps, formatInspected } from './chunk-DI5STJM4.js';
+import { explainEvents, formatExplanation } from './chunk-D7M4UC3Y.js';
+export { explainEvents, formatExplanation } from './chunk-D7M4UC3Y.js';
 import { profileFromEvents } from './chunk-LILK23YH.js';
+import { getDetective, shallowEqual, inspect, diffProps, formatInspected } from './chunk-3TZNM7JO.js';
 import * as React from 'react';
-import { createContext, useContext, useState, useRef, useEffect, useLayoutEffect, useCallback, Profiler } from 'react';
+import { createContext, useContext, useRef, useState, useEffect, useLayoutEffect, useCallback, Profiler } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
 // src/console/style.ts
@@ -217,6 +217,8 @@ function label(event) {
       return "context update";
     case "state":
       return "state changed";
+    case "store":
+      return "store update";
     case "state-or-external":
       return "state or external store";
     case "unknown":
@@ -224,194 +226,6 @@ function label(event) {
   }
 }
 
-// src/core/interactions.ts
-var COMMIT_SLACK_MS = 100;
-var FALLBACK_CLOSE_MS = 50;
-var InteractionTracker = class {
-  constructor(capacity = 50) {
-    this.capacity = capacity;
-    this.records = [];
-    this.nextId = 0;
-  }
-  /** Returns false when the browser cannot report event timing. */
-  start() {
-    if (this.observer) return true;
-    const PO = globalThis.PerformanceObserver;
-    const supported = PO?.supportedEntryTypes?.includes("event");
-    if (!PO || !supported) return false;
-    try {
-      const observer = new PO((list) => {
-        for (const entry of list.getEntries()) {
-          const timing = entry;
-          this.record({
-            name: timing.name,
-            startTime: timing.startTime,
-            duration: timing.duration,
-            target: describeTarget(timing.target)
-          });
-        }
-      });
-      observer.observe({ type: "event", buffered: true, durationThreshold: 16 });
-      this.observer = observer;
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  stop() {
-    this.observer?.disconnect();
-    this.observer = void 0;
-  }
-  /** Is the automatic path available in this browser? */
-  get automatic() {
-    return this.observer !== void 0;
-  }
-  /**
-   * Time an interaction by hand.
-   *
-   * The automatic path depends on the Event Timing API, which Safari only
-   * gained in 16.4 and which does not fire for synthetic input at all — so
-   * anything driven by a test harness records nothing. This measures a specific
-   * action instead, up to the paint that follows it, and needs no browser
-   * support beyond `performance.now`.
-   */
-  measure(label2, action) {
-    const startTime = now();
-    let handlerMs = 0;
-    let finished = false;
-    const finish = () => {
-      if (finished) return;
-      finished = true;
-      this.record({ name: label2, startTime, duration: now() - startTime, handlerMs });
-    };
-    let result;
-    try {
-      result = action();
-      handlerMs = now() - startTime;
-    } catch (error) {
-      handlerMs = now() - startTime;
-      finish();
-      throw error;
-    }
-    const raf = globalThis.requestAnimationFrame;
-    if (raf) raf(() => raf(finish));
-    setTimeout(finish, FALLBACK_CLOSE_MS);
-    return result;
-  }
-  /** Exposed for tests and for `measure`. */
-  record(timing) {
-    const record = {
-      id: `interaction_${++this.nextId}`,
-      type: timing.name,
-      target: timing.target,
-      startTime: timing.startTime,
-      durationMs: timing.duration,
-      handlerMs: timing.handlerMs,
-      renders: [],
-      renderTimeMs: 0,
-      avoidableRenderTimeMs: 0
-    };
-    this.records.push(record);
-    if (this.records.length > this.capacity) this.records.shift();
-    return record;
-  }
-  clear() {
-    this.records.length = 0;
-  }
-  /**
-   * Joins render events to interactions by commit time. A render belongs to an
-   * interaction when it committed between the event starting and shortly after
-   * it finished — React commits just after the event handler returns.
-   */
-  attribute(events) {
-    for (const record of this.records) {
-      const from = record.startTime;
-      const to = record.startTime + record.durationMs + COMMIT_SLACK_MS;
-      record.renders = events.filter((e) => e.timings.commitTime >= from && e.timings.commitTime <= to);
-      record.renderTimeMs = record.renders.reduce((a, e) => a + e.timings.selfDuration, 0);
-      record.avoidableRenderTimeMs = record.renders.filter((e) => e.diagnosis.potentiallyAvoidable).reduce((a, e) => a + e.timings.selfDuration, 0);
-    }
-    return [...this.records].sort((a, b) => b.durationMs - a.durationMs);
-  }
-};
-function summarise(record) {
-  const byComponent = /* @__PURE__ */ new Map();
-  for (const event of record.renders) {
-    const entry = byComponent.get(event.component.name) ?? {
-      renders: 0,
-      totalMs: 0,
-      source: event.component.source,
-      cause: event.diagnosis.reason
-    };
-    entry.renders++;
-    entry.totalMs += event.timings.selfDuration;
-    byComponent.set(event.component.name, entry);
-  }
-  const contributors = [...byComponent.entries()].map(([component, v]) => ({ component, source: v.source, renders: v.renders, totalMs: v.totalMs, cause: v.cause })).sort((a, b) => b.totalMs - a.totalMs);
-  const top = contributors[0];
-  const accounted = (record.handlerMs ?? record.durationMs) + record.renderTimeMs;
-  const idleWindow = record.handlerMs !== void 0 && record.durationMs > accounted * 3 && record.durationMs - accounted > 100;
-  const effectiveMs = idleWindow ? accounted : record.durationMs;
-  const share = effectiveMs > 0 ? record.renderTimeMs / effectiveMs : 0;
-  let headline;
-  let nextStep;
-  let confidence = "medium";
-  if (idleWindow) {
-    headline = `${record.type}: ${fmt(record.handlerMs ?? 0)} in the handler and ${fmt(record.renderTimeMs)} rendering. The measured window was ${fmt(record.durationMs)}, but most of that was the page waiting for a frame \u2014 ignore it.`;
-    nextStep = record.renderTimeMs > (record.handlerMs ?? 0) ? `Rendering dominates the real work${top ? `; start with ${top.component}` : ""}.` : "The handler itself costs more than rendering. Profile the handler, not React.";
-    return { interaction: record, contributors, headline, nextStep, confidence: "medium" };
-  }
-  if (record.renders.length === 0) {
-    headline = `${record.type} took ${fmt(record.durationMs)}, and no instrumented component rendered inside it.`;
-    nextStep = "The cost is somewhere other than React rendering \u2014 an event handler, a layout, or an uninstrumented component. Instrument more of the tree to narrow it down.";
-    confidence = "low";
-  } else if (share >= 0.4 && record.avoidableRenderTimeMs > 0) {
-    headline = `${record.type} took ${fmt(record.durationMs)}; ${fmt(record.renderTimeMs)} of it was rendering, and ${fmt(record.avoidableRenderTimeMs)} of that had no input change to explain it.`;
-    nextStep = top ? `Start with ${top.component}${top.source ? ` (${top.source})` : ""} \u2014 ${fmt(top.totalMs)} across ${top.renders} render${top.renders === 1 ? "" : "s"}.` : "Look at the top contributor below.";
-    confidence = "high";
-  } else if (share >= 0.4) {
-    headline = `${record.type} took ${fmt(record.durationMs)}; ${fmt(record.renderTimeMs)} of it was rendering, all of it explained by real input changes.`;
-    nextStep = "This is genuine work. Make the renders cheaper rather than fewer \u2014 or do less of it per interaction.";
-    confidence = "high";
-  } else {
-    headline = `${record.type} took ${fmt(record.durationMs)}, but only ${fmt(record.renderTimeMs)} was React rendering.`;
-    nextStep = "Most of the cost is outside rendering \u2014 event handlers, layout or paint. A browser profile will show more than this tool can.";
-    confidence = "medium";
-  }
-  return { interaction: record, contributors, headline, nextStep, confidence };
-}
-function formatInteraction(summary) {
-  const { interaction: i } = summary;
-  const lines = [
-    `${i.type}${i.target ? ` on ${i.target}` : ""}   ${fmt(i.durationMs)}`,
-    "",
-    summary.headline
-  ];
-  if (summary.contributors.length > 0) {
-    lines.push("", "Rendering inside this interaction");
-    for (const c of summary.contributors.slice(0, 8)) {
-      lines.push(
-        `  ${c.component.padEnd(22)} ${String(c.renders).padStart(4)} render(s)  ${fmt(c.totalMs).padStart(8)}  ${c.cause}`
-      );
-    }
-  }
-  lines.push("", `Next step`, `  ${summary.nextStep}`, "", `Confidence: ${summary.confidence}`);
-  return lines.join("\n");
-}
-function describeTarget(target) {
-  if (!target || typeof target !== "object") return void 0;
-  const el = target;
-  if (!el.tagName) return void 0;
-  const tag = el.tagName.toLowerCase();
-  if (el.id) return `${tag}#${el.id}`;
-  const className = typeof el.className === "string" ? el.className.trim().split(/\s+/)[0] : void 0;
-  if (className) return `${tag}.${className}`;
-  const text = el.textContent?.trim().slice(0, 20);
-  return text ? `${tag} "${text}"` : tag;
-}
-var fmt = (ms) => `${ms.toFixed(1)}ms`;
-var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
-
 // src/core/opportunities.ts
 var DEFAULT_MIN_SAVING_MS = 1;
 function rankOpportunities({ events, lifecycles, minSavingMs = DEFAULT_MIN_SAVING_MS }) {
@@ -530,6 +344,38 @@ function RenderDetective({ name, children }) {
   const { node, onRender } = useInstrumentedNode(name, { children });
   return renderInstrumented(node, onRender, children);
 }
+var useOwnerId = typeof React.useId === "function" ? React.useId : () => "";
+function trackSelector(value, options = {}) {
+  const detective = getDetective();
+  const node = useContext(AncestryContext);
+  const ownerId = useOwnerId();
+  const previous = useRef(void 0);
+  if (!detective.enabled) return value;
+  if (node && node.stateOwner === void 0) node.stateOwner = ownerId;
+  const owns = !node || node.stateOwner === ownerId;
+  const prior = previous.current;
+  previous.current = { value };
+  if (!prior || !node || !owns) return value;
+  if (Object.is(prior.value, value)) return value;
+  try {
+    const equal = shallowEqual(prior.value, value, detective.config);
+    detective.recordSelectorChange(node, {
+      name: options.name ?? options.source ?? "selector",
+      source: options.source,
+      referenceOnly: equal === true,
+      previous: inspect(prior.value, detective.config.inspection),
+      current: inspect(value, detective.config.inspection)
+    });
+  } catch {
+  }
+  return value;
+}
+function createTrackedSelectorHook(hook, options = {}) {
+  return function useTrackedSelector(...args) {
+    const value = hook(...args);
+    return trackSelector(value, options);
+  };
+}
 function useRenderDiagnostics(name, props) {
   const detective = getDetective();
   const parent = useContext(AncestryContext);
@@ -564,11 +410,11 @@ function useRenderDiagnostics(name, props) {
   }
   return last.current;
 }
-var useOwnerId = typeof React.useId === "function" ? React.useId : () => "";
+var useOwnerId2 = typeof React.useId === "function" ? React.useId : () => "";
 function useTrackedState(name, initial) {
   const detective = getDetective();
   const node = useContext(AncestryContext);
-  const ownerId = useOwnerId();
+  const ownerId = useOwnerId2();
   const [state, setState] = useState(initial);
   const previous = useRef(state);
   if (node && node.stateOwner === void 0) node.stateOwner = ownerId;
@@ -629,21 +475,12 @@ function isRecord(v) {
 
 // src/index.ts
 var REPORTER = /* @__PURE__ */ Symbol.for("react-render-detective.reporter");
-var INTERACTIONS = /* @__PURE__ */ Symbol.for("react-render-detective.interactions");
-function tracker() {
-  const g = globalThis;
-  if (!g[INTERACTIONS]) g[INTERACTIONS] = new InteractionTracker();
-  return g[INTERACTIONS];
-}
 function init(options = {}) {
   const detective = getDetective();
   detective.init(options);
   const g = globalThis;
   g[REPORTER]?.();
   g[REPORTER] = void 0;
-  if (detective.enabled) {
-    tracker().start();
-  }
   if (detective.enabled && detective.config.mode !== "silent") {
     g[REPORTER] = attachConsoleReporter(detective);
   } else if (!detective.enabled) {
@@ -675,14 +512,11 @@ function subscribe(listener) {
 }
 function clear() {
   getDetective().clear();
-  tracker().clear();
 }
 function reset() {
   const g = globalThis;
   g[REPORTER]?.();
   g[REPORTER] = void 0;
-  g[INTERACTIONS]?.stop();
-  g[INTERACTIONS] = void 0;
   getDetective().reset();
 }
 function explain(componentName2) {
@@ -697,31 +531,6 @@ function getRenderProfile(scenario) {
   for (const stats of getDetective().getComponentStats()) remounts[stats.name] = stats.remountCount;
   return profileFromEvents(scenario, getEvents(), remounts);
 }
-function getInteractions() {
-  return tracker().attribute(getEvents());
-}
-function explainInteractionStructured(id) {
-  const records = getInteractions();
-  const record = id ? records.find((r) => r.id === id) : records[0];
-  return record ? summarise(record) : void 0;
-}
-function explainInteraction(id) {
-  const summary = explainInteractionStructured(id);
-  return summary ? formatInteraction(summary) : void 0;
-}
-function printInteractions(limit = 5) {
-  const records = getInteractions().slice(0, limit);
-  if (records.length === 0) {
-    console.log(
-      tracker().automatic ? "No interactions recorded yet. Event timing is working \u2014 nothing has taken longer than 16ms.\nSynthetic clicks from a test harness never produce these entries; use measureInteraction() there." : "This browser does not report event timing (Safari before 16.4, jsdom).\nUse measureInteraction(label, fn) to time interactions by hand."
-    );
-    return;
-  }
-  console.log(records.map((r) => formatInteraction(summarise(r))).join("\n\n"));
-}
-function measureInteraction(label2, action) {
-  return tracker().measure(label2, action);
-}
 function getOpportunities(limit = 10) {
   const detective = getDetective();
   const lifecycles = /* @__PURE__ */ new Map();
@@ -780,15 +589,10 @@ var ReactRenderDetective = {
   explainStructured,
   getOpportunities,
   printOpportunities,
-  getInteractions,
-  explainInteraction,
-  explainInteractionStructured,
-  printInteractions,
-  measureInteraction,
   getRenderProfile,
   printStats
 };
 
-export { InteractionTracker, ReactRenderDetective, RenderDetective, clear, configure, explain, explainInteraction, explainInteractionStructured, explainStructured, formatInteraction, formatOpportunities, getComponentStats, getConfig, getEvents, getInteractions, getOpportunities, getRenderProfile, getStats, init, isEnabled, measureInteraction, printInteractions, printOpportunities, printStats, rankOpportunities, reset, subscribe, summarise as summariseInteraction, useRenderDiagnostics, useTrackedContextValue, useTrackedEffect, useTrackedState, withRenderDetective };
+export { ReactRenderDetective, RenderDetective, clear, configure, createTrackedSelectorHook, explain, explainStructured, formatOpportunities, getComponentStats, getConfig, getEvents, getOpportunities, getRenderProfile, getStats, init, isEnabled, printOpportunities, printStats, rankOpportunities, reset, subscribe, trackSelector, useRenderDiagnostics, useTrackedContextValue, useTrackedEffect, useTrackedState, withRenderDetective };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map