react-render-detective 0.1.0

package/dist/core.d.ts

@@ -0,0 +1,198 @@
+import { D as DetectiveConfig, T as TrackedStateChange, R as RenderReason, a as DetectiveOptions, b as RenderEvent, c as RenderPhase, C as ContextChange, d as ComponentStats, A as AppStats, P as PropChange, e as Thresholds, f as Diagnosis, I as Inspected, g as InspectionLimits, h as PropValueType } from './types-CY61yfhK.js';
+export { i as ComponentInfo, j as Confidence, M as Mode, k as PropChangeKind, l as RenderTimings } from './types-CY61yfhK.js';
+
+/** What an instrumentation site reports at commit time. */
+interface CommitInput {
+    phase: RenderPhase;
+    subtreeDuration: number;
+    baseDuration: number;
+    startTime: number;
+    /** `-1` when there is no Profiler; the flush pass resolves it. */
+    commitTime: number;
+}
+interface NodeRecord {
+    id: string;
+    name: string;
+    /** Nearest instrumented ancestor, held directly so diagnosis never needs the registry. */
+    parent?: NodeRecord;
+    depth: number;
+    sampled: boolean;
+    /** Retained so the next render can be diffed. One props object per component. */
+    prevProps?: Record<string, unknown>;
+    pendingProps?: Record<string, unknown>;
+    /** Render-function invocations not yet matched to a commit. */
+    attempts: number;
+    /** Named state updates reported by `useTrackedState`, consumed at the next commit. */
+    pendingState: TrackedStateChange[];
+    /** Set as soon as a commit is queued, so mount detection never waits on flush. */
+    seenCommit: boolean;
+    /**
+     * `useId` of the first component to call `useTrackedState` under this node.
+     * Later callers (descendants) cannot claim state attribution from it.
+     */
+    stateOwner?: string;
+    renderNumber: number;
+    lastCommitTime: number;
+    durations: number[];
+    stats: MutableStats;
+}
+interface MutableStats {
+    renderCount: number;
+    mountCount: number;
+    uncommittedAttempts: number;
+    devReplays: number;
+    totalSelfDuration: number;
+    maxSelfDuration: number;
+    slowRenders: number;
+    potentiallyAvoidableRenders: number;
+    reasons: Record<RenderReason, number>;
+}
+declare class Detective {
+    config: DetectiveConfig;
+    private nodes;
+    private events;
+    private listeners;
+    private pending;
+    private contextChanges;
+    /** Orders renders and context updates so they can be matched without timers. */
+    private seq;
+    private flushScheduled;
+    private sweepHandle;
+    private nextId;
+    /** Nodes created by `useRenderDiagnostics`, where props/state cannot be separated. */
+    readonly hookModeNodes: WeakSet<NodeRecord>;
+    private initialized;
+    constructor();
+    /** Idempotent: repeated calls reconfigure, they never duplicate anything (§47). */
+    init(options?: DetectiveOptions): Detective;
+    configure(options?: DetectiveOptions): void;
+    get isInitialized(): boolean;
+    get enabled(): boolean;
+    subscribe(listener: (event: RenderEvent) => void): () => void;
+    /**
+     * Creates a node without publishing it. StrictMode's double mount renders
+     * discards one of the two, and only the surviving fiber's effect attaches —
+     * so discarded nodes are simply garbage collected.
+     */
+    createNode(name: string, parent: NodeRecord | undefined): NodeRecord | undefined;
+    attach(node: NodeRecord): void;
+    detach(node: NodeRecord): void;
+    /** Hot path. Must stay allocation-free and O(1). */
+    recordAttempt(node: NodeRecord, props: Record<string, unknown>): void;
+    recordStateChange(node: NodeRecord, change: TrackedStateChange): void;
+    /**
+     * Hot path. Called from Profiler#onRender; only enqueues.
+     *
+     * `attempts` is the number of times the *wrapper* rendered, i.e. how often
+     * this component's props were re-evaluated from above. Zero means the render
+     * originated at or below this component — the flush pass works out which.
+     */
+    recordCommit(node: NodeRecord, commit: CommitInput): void;
+    recordContextChange(change: ContextChange): void;
+    private scheduleFlush;
+    private scheduleSweep;
+    /** Attempts that never reached a commit were abandoned or replayed. */
+    private sweep;
+    /** Runs after the commit, off the render path. Whole batch is available here. */
+    flush(): void;
+    private buildEvent;
+    private updateStats;
+    private emit;
+    getEvents(): RenderEvent[];
+    getComponentStats(name?: string): ComponentStats[];
+    getStats(): AppStats;
+    clear(): void;
+    /** Full teardown — used by tests and by HMR disposal. */
+    reset(): void;
+}
+
+declare function getDetective(): Detective;
+
+/**
+ * Best-effort dev detection. No bundler-specific globals are referenced in the
+ * core (`import.meta.env` is Vite-only), so this works everywhere and defaults
+ * to **off** when it cannot tell — production safety over convenience (§29).
+ */
+declare function detectDev(): boolean;
+declare const defaultConfig: DetectiveConfig;
+declare function mergeConfig(base: DetectiveConfig, options?: DetectiveOptions): DetectiveConfig;
+declare function matches(name: string, patterns: Array<string | RegExp>): boolean;
+/** Filter policy: exclude wins over include; empty include means "everything". */
+declare function shouldInstrument(name: string, config: DetectiveConfig): boolean;
+
+interface PropsDiff {
+    changed: PropChange[];
+    unchanged: string[];
+}
+/** Result of a bounded contents comparison. `undefined` = could not determine. */
+type ShallowResult = boolean | undefined;
+declare function diffProps(previous: Record<string, unknown> | undefined, current: Record<string, unknown> | undefined, config: DetectiveConfig): PropsDiff;
+/**
+ * Bounded shallow comparison. Returns `undefined` rather than guessing when the
+ * values are too large or of a shape we cannot compare cheaply — the diagnostic
+ * engine treats that as "unknown", never as "equal".
+ */
+declare function shallowEqual(a: unknown, b: unknown, config: DetectiveConfig): ShallowResult;
+
+interface DiagnosisInput {
+    componentName: string;
+    phase: RenderPhase;
+    parentName?: string;
+    /** Nearest instrumented ancestor re-rendered in this same commit. */
+    parentRendered: boolean;
+    /** True when we have no instrumented ancestor, so `parentRendered` is unknown. */
+    parentUnknown: boolean;
+    /**
+     * Did something above re-evaluate this component's props?
+     * `true`  — the wrapper re-rendered, so the render came from above.
+     * `false` — it did not, so the render started here or below.
+     * `undefined` — hook mode, where the two cannot be told apart.
+     */
+    propsReevaluated: boolean | undefined;
+    /** An instrumented child re-rendered from above, proving this component rendered. */
+    selfRenderProven: boolean;
+    changedProps: PropChange[];
+    contextChanges: ContextChange[];
+    /** Named state updates from `useTrackedState`. Empty unless opted in. */
+    trackedState: TrackedStateChange[];
+    selfDuration: number;
+    attempts: number;
+    committed: boolean;
+    /** How many times this component already produced a "no observable change" render. */
+    priorAvoidableRenders: number;
+}
+declare function severityFor(duration: number, t: Thresholds): Diagnosis["severity"];
+/**
+ * Pure. No React, no globals, no I/O — so diagnostic correctness can be tested
+ * directly (§70).
+ */
+declare function diagnose(input: DiagnosisInput, thresholds: Thresholds): Diagnosis;
+
+declare function isReactElement(value: unknown): boolean;
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+declare function valueType(value: unknown): PropValueType;
+/**
+ * Bounded, cycle-safe, non-retaining snapshot.
+ *
+ * Deliberately not `JSON.stringify`: that throws on cycles and BigInt, drops
+ * `undefined`/functions/symbols, and has no size ceiling.
+ */
+declare function inspect(value: unknown, limits: InspectionLimits): Inspected;
+/** Single-line rendering for console output. */
+declare function formatInspected(node: Inspected | undefined): string;
+
+/** Fixed-capacity ring buffer. Bounded memory is a hard requirement (§26). */
+declare class RingBuffer<T> {
+    private items;
+    private head;
+    private count;
+    constructor(capacity: number);
+    push(item: T): void;
+    get size(): number;
+    /** Oldest → newest. */
+    toArray(): T[];
+    clear(): void;
+    resize(capacity: number): void;
+}
+
+export { AppStats, ComponentStats, ContextChange, Detective, DetectiveConfig, DetectiveOptions, Diagnosis, type DiagnosisInput, Inspected, InspectionLimits, PropChange, PropValueType, RenderEvent, RenderPhase, RenderReason, RingBuffer, Thresholds, TrackedStateChange, defaultConfig, detectDev, diagnose, diffProps, formatInspected, getDetective, inspect, isPlainObject, isReactElement, matches, mergeConfig, severityFor, shallowEqual, shouldInstrument, valueType };

package/dist/core.js

@@ -0,0 +1,3 @@
+export { Detective, RingBuffer, defaultConfig, detectDev, diagnose, diffProps, formatInspected, getDetective, inspect, isPlainObject, isReactElement, matches, mergeConfig, severityFor, shallowEqual, shouldInstrument, valueType } from './chunk-GRPJ4JAB.js';
+//# sourceMappingURL=core.js.map
+//# sourceMappingURL=core.js.map

package/dist/core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"core.js"}

package/dist/index.cjs

@@ -0,0 +1,417 @@
+'use strict';
+
+var chunkOCW2Q3UW_cjs = require('./chunk-OCW2Q3UW.cjs');
+var chunk7FTXUOB6_cjs = require('./chunk-7FTXUOB6.cjs');
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+// src/console/reporter.ts
+var ICON = {
+  normal: "\xB7",
+  monitor: "\u2022",
+  slow: "\u25B2",
+  "very-slow": "\u25B2\u25B2",
+  critical: "\u25A0"
+};
+function attachConsoleReporter(detective) {
+  return detective.subscribe((event) => {
+    const mode = detective.config.mode;
+    if (mode === "silent") return;
+    try {
+      if (mode === "verbose") printVerbose(event);
+      else printConcise(event, detective.config.slowRenderThreshold);
+    } catch {
+    }
+  });
+}
+function printConcise(event, slowThreshold) {
+  const { diagnosis, timings, component } = event;
+  const changed = event.changedProps.map((c) => c.key).join(", ");
+  const parts = [
+    `[RRD] ${component.name} #${event.renderNumber}`,
+    `Reason: ${label(event)}`,
+    changed ? `Changed: ${changed}` : void 0,
+    timings.subtreeDuration > 0 ? `Duration: ${timings.selfDuration.toFixed(1)}ms` : void 0
+  ].filter(Boolean);
+  const line = `${ICON[diagnosis.severity] ?? "\xB7"} ${parts.join("  ")}`;
+  const slow = timings.selfDuration >= slowThreshold;
+  if (slow) console.warn(line);
+  else console.log(line);
+}
+function printVerbose(event) {
+  const { diagnosis, timings } = event;
+  const header = `[RRD] ${event.component.name} #${event.renderNumber} \u2014 ${diagnosis.summary}`;
+  const group = diagnosis.severity === "normal" ? console.groupCollapsed : console.group;
+  group.call(console, header);
+  try {
+    console.log(`Cause:       ${label(event)} (confidence: ${diagnosis.confidence})`);
+    if (event.parent) {
+      console.log(`Parent:      ${event.parent.name}${event.parentRendered ? " (re-rendered in this commit)" : " (did not re-render)"}`);
+    }
+    console.log(
+      `Cost:        self ${timings.selfDuration.toFixed(1)}ms \xB7 subtree ${timings.subtreeDuration.toFixed(1)}ms` + (timings.accountedDescendantDuration > 0 ? ` (${timings.accountedDescendantDuration.toFixed(1)}ms in instrumented children)` : "")
+    );
+    if (event.changedProps.length > 0) {
+      console.groupCollapsed(`Props changed (${event.changedProps.length})`);
+      for (const c of event.changedProps) console.log(propLine(c));
+      console.groupEnd();
+    }
+    if (event.unchangedProps.length > 0) {
+      console.log(`Props same:  ${event.unchangedProps.join(", ")}`);
+    }
+    if (event.trackedState.length > 0) {
+      console.log(
+        `State:       ${event.trackedState.map((s) => `${s.name}: ${chunk7FTXUOB6_cjs.formatInspected(s.previous)} \u2192 ${chunk7FTXUOB6_cjs.formatInspected(s.current)}`).join(", ")}`
+      );
+    }
+    if (event.contextChanges.length > 0) {
+      console.log(`Context:     ${event.contextChanges.map((c) => c.contextName).join(", ")} changed in this commit`);
+    }
+    console.groupCollapsed("Evidence");
+    for (const line of diagnosis.evidence) console.log(`\u2022 ${line}`);
+    console.groupEnd();
+    if (diagnosis.suggestion) console.log(`Next step:   ${diagnosis.suggestion}`);
+    if (diagnosis.potentiallyAvoidable) console.log("Flag:        potentially avoidable render");
+  } finally {
+    console.groupEnd();
+  }
+}
+function propLine(c) {
+  const head = `${c.key} (${c.valueType}) \u2014 ${describeKind(c)}`;
+  if (c.kind === "added") return `${head}: ${chunk7FTXUOB6_cjs.formatInspected(c.current)}`;
+  if (c.kind === "removed") return `${head}: was ${chunk7FTXUOB6_cjs.formatInspected(c.previous)}`;
+  return `${head}
+    previous: ${chunk7FTXUOB6_cjs.formatInspected(c.previous)}
+    current:  ${chunk7FTXUOB6_cjs.formatInspected(c.current)}`;
+}
+function describeKind(c) {
+  switch (c.kind) {
+    case "added":
+      return "added";
+    case "removed":
+      return "removed";
+    case "value":
+      return "value changed";
+    case "reference":
+      if (c.valueType === "function") return c.sourceEqual ? "new function, identical source" : "new function reference";
+      return c.shallowEqual === true ? "reference changed, contents identical" : "reference changed";
+  }
+}
+function label(event) {
+  switch (event.diagnosis.reason) {
+    case "mount":
+      return "mount";
+    case "props":
+      return event.changedProps.every((c) => c.kind === "reference") ? "prop changed (reference only)" : "prop changed";
+    case "parent":
+      return "parent rendered";
+    case "context":
+      return "context update";
+    case "state":
+      return "state changed";
+    case "state-or-external":
+      return "state or external store";
+    case "unknown":
+      return "undetermined";
+  }
+}
+var AncestryContext = React.createContext(void 0);
+AncestryContext.displayName = "RenderDetectiveAncestry";
+function useInstrumentedNode(name, props) {
+  const detective = chunk7FTXUOB6_cjs.getDetective();
+  const parent = React.useContext(AncestryContext);
+  const [node] = React.useState(
+    () => detective.enabled ? detective.createNode(name, parent) : void 0
+  );
+  React.useLayoutEffect(() => {
+    if (!node) return;
+    detective.attach(node);
+    return () => detective.detach(node);
+  }, [detective, node]);
+  if (node) {
+    try {
+      detective.recordAttempt(node, props);
+    } catch {
+    }
+  }
+  const onRender = React.useCallback(
+    (_id, phase, actualDuration, baseDuration, startTime, commitTime) => {
+      if (!node) return;
+      try {
+        detective.recordCommit(node, {
+          phase,
+          subtreeDuration: actualDuration,
+          baseDuration,
+          startTime,
+          commitTime
+        });
+      } catch {
+      }
+    },
+    [detective, node]
+  );
+  return { node, onRender };
+}
+function renderInstrumented(node, onRender, children) {
+  if (!node) return children;
+  return /* @__PURE__ */ jsxRuntime.jsx(React.Profiler, { id: node.id, onRender, children: /* @__PURE__ */ jsxRuntime.jsx(AncestryContext.Provider, { value: node, children }) });
+}
+function componentName(component, fallback = "Anonymous") {
+  const c = component;
+  if (!c) return fallback;
+  if (typeof c.displayName === "string" && c.displayName) return c.displayName;
+  if (typeof c.name === "string" && c.name) return c.name;
+  if (c.type) return componentName(c.type, fallback);
+  return fallback;
+}
+function withRenderDetective(Component, options = {}) {
+  const name = options.name ?? componentName(Component);
+  function RenderDetected(props) {
+    const { node, onRender } = useInstrumentedNode(name, props);
+    return renderInstrumented(node, onRender, /* @__PURE__ */ jsxRuntime.jsx(Component, { ...props }));
+  }
+  RenderDetected.displayName = `RenderDetective(${name})`;
+  return RenderDetected;
+}
+
+// src/react/RenderDetective.tsx
+function RenderDetective({ name, children }) {
+  const { node, onRender } = useInstrumentedNode(name, { children });
+  return renderInstrumented(node, onRender, children);
+}
+function useRenderDiagnostics(name, props) {
+  const detective = chunk7FTXUOB6_cjs.getDetective();
+  const parent = React.useContext(AncestryContext);
+  const [node] = React.useState(() => {
+    if (!detective.enabled) return void 0;
+    const created = detective.createNode(name, parent);
+    if (created) detective.hookModeNodes.add(created);
+    return created;
+  });
+  const last = React.useRef(void 0);
+  React.useEffect(() => {
+    if (!node) return;
+    detective.attach(node);
+    const unsubscribe = detective.subscribe((event) => {
+      if (event.component.id === node.id) last.current = event;
+    });
+    return () => {
+      unsubscribe();
+      detective.detach(node);
+    };
+  }, [detective, node]);
+  if (node) {
+    const isMount = !node.seenCommit;
+    detective.recordAttempt(node, props ?? {});
+    detective.recordCommit(node, {
+      phase: isMount ? "mount" : "update",
+      subtreeDuration: 0,
+      baseDuration: 0,
+      startTime: 0,
+      commitTime: -1
+    });
+  }
+  return last.current;
+}
+var useOwnerId = typeof React__namespace.useId === "function" ? React__namespace.useId : () => "";
+function useTrackedState(name, initial) {
+  const detective = chunk7FTXUOB6_cjs.getDetective();
+  const node = React.useContext(AncestryContext);
+  const ownerId = useOwnerId();
+  const [state, setState] = React.useState(initial);
+  const previous = React.useRef(state);
+  if (node && node.stateOwner === void 0) node.stateOwner = ownerId;
+  const owns = !node || node.stateOwner === ownerId;
+  if (node && owns && !Object.is(previous.current, state)) {
+    detective.recordStateChange(node, {
+      name,
+      previous: chunk7FTXUOB6_cjs.inspect(previous.current, detective.config.inspection),
+      current: chunk7FTXUOB6_cjs.inspect(state, detective.config.inspection)
+    });
+    previous.current = state;
+  } else if (!owns) {
+    previous.current = state;
+  }
+  return [state, setState];
+}
+function useTrackedEffect(name, effect, deps) {
+  const detective = chunk7FTXUOB6_cjs.getDetective();
+  const previous = React.useRef(void 0);
+  const changed = React.useRef([]);
+  if (detective.enabled) {
+    const prev = previous.current;
+    changed.current = prev ? deps.map((d, i) => Object.is(d, prev[i]) ? -1 : i).filter((i) => i >= 0) : [];
+    previous.current = deps;
+  }
+  React.useEffect(() => {
+    if (detective.enabled && detective.config.mode !== "silent" && changed.current.length > 0) {
+      console.debug(`[RRD] effect ${name} ran \u2014 deps changed at index ${changed.current.join(", ")}`);
+    }
+    return effect();
+  }, deps);
+}
+function useTrackedContextValue(contextName, value) {
+  const detective = chunk7FTXUOB6_cjs.getDetective();
+  const previous = React.useRef(void 0);
+  const first = React.useRef(true);
+  if (detective.enabled) {
+    if (first.current) {
+      first.current = false;
+    } else if (!Object.is(previous.current, value)) {
+      const prev = previous.current;
+      const equal = chunk7FTXUOB6_cjs.shallowEqual(prev, value, detective.config);
+      const changedKeys = isRecord(prev) && isRecord(value) ? chunk7FTXUOB6_cjs.diffProps(prev, value, detective.config).changed.map((c) => c.key) : [];
+      detective.recordContextChange({
+        contextName,
+        changedKeys,
+        referenceOnly: equal === true,
+        commitTime: -1
+      });
+    }
+    previous.current = value;
+  }
+  return value;
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// src/index.ts
+var REPORTER = /* @__PURE__ */ Symbol.for("react-render-detective.reporter");
+function init(options = {}) {
+  const detective = chunk7FTXUOB6_cjs.getDetective();
+  detective.init(options);
+  const g = globalThis;
+  g[REPORTER]?.();
+  g[REPORTER] = void 0;
+  if (detective.enabled && detective.config.mode !== "silent") {
+    g[REPORTER] = attachConsoleReporter(detective);
+  }
+}
+function configure(options) {
+  chunk7FTXUOB6_cjs.getDetective().configure(options);
+}
+function getConfig() {
+  return chunk7FTXUOB6_cjs.getDetective().config;
+}
+function isEnabled() {
+  return chunk7FTXUOB6_cjs.getDetective().enabled;
+}
+function getEvents() {
+  return chunk7FTXUOB6_cjs.getDetective().getEvents();
+}
+function getStats() {
+  return chunk7FTXUOB6_cjs.getDetective().getStats();
+}
+function getComponentStats(name) {
+  return chunk7FTXUOB6_cjs.getDetective().getComponentStats(name);
+}
+function subscribe(listener) {
+  return chunk7FTXUOB6_cjs.getDetective().subscribe(listener);
+}
+function clear() {
+  chunk7FTXUOB6_cjs.getDetective().clear();
+}
+function reset() {
+  const g = globalThis;
+  g[REPORTER]?.();
+  g[REPORTER] = void 0;
+  chunk7FTXUOB6_cjs.getDetective().reset();
+}
+function explain(componentName2) {
+  const explanation = chunkOCW2Q3UW_cjs.explainEvents(componentName2, getEvents());
+  return explanation ? chunkOCW2Q3UW_cjs.formatExplanation(explanation) : void 0;
+}
+function explainStructured(componentName2) {
+  return chunkOCW2Q3UW_cjs.explainEvents(componentName2, getEvents());
+}
+function printStats() {
+  const s = getStats();
+  const lines = [
+    "React Render Detective",
+    "",
+    `Components               ${s.components}`,
+    `Total renders            ${s.totalRenders}`,
+    `Total render time        ${s.totalRenderTime.toFixed(1)}ms`,
+    `Slow renders             ${s.slowRenders}`,
+    `Potentially avoidable    ${s.potentiallyAvoidableRenders}`
+  ];
+  if (s.devReplays > 0) {
+    lines.push(`Development replays      ${s.devReplays} (StrictMode / discarded \u2014 not counted above)`);
+  }
+  if (s.mostExpensive.length > 0) {
+    lines.push("", "Top by cumulative render time");
+    for (const [i, c] of s.mostExpensive.slice(0, 5).entries()) {
+      lines.push(
+        `${String(i + 1).padStart(2)}. ${c.name.padEnd(22)} ${String(c.renderCount).padStart(6)} renders  ${c.totalSelfDuration.toFixed(1).padStart(8)}ms  (avg ${c.averageSelfDuration.toFixed(1)}ms, p95 ${c.p95SelfDuration.toFixed(1)}ms)`
+      );
+    }
+  }
+  console.log(lines.join("\n"));
+}
+var ReactRenderDetective = {
+  init,
+  configure,
+  getConfig,
+  isEnabled,
+  getEvents,
+  getStats,
+  getComponentStats,
+  subscribe,
+  clear,
+  reset,
+  explain,
+  explainStructured,
+  printStats
+};
+
+Object.defineProperty(exports, "explainEvents", {
+  enumerable: true,
+  get: function () { return chunkOCW2Q3UW_cjs.explainEvents; }
+});
+Object.defineProperty(exports, "formatExplanation", {
+  enumerable: true,
+  get: function () { return chunkOCW2Q3UW_cjs.formatExplanation; }
+});
+exports.ReactRenderDetective = ReactRenderDetective;
+exports.RenderDetective = RenderDetective;
+exports.clear = clear;
+exports.configure = configure;
+exports.explain = explain;
+exports.explainStructured = explainStructured;
+exports.getComponentStats = getComponentStats;
+exports.getConfig = getConfig;
+exports.getEvents = getEvents;
+exports.getStats = getStats;
+exports.init = init;
+exports.isEnabled = isEnabled;
+exports.printStats = printStats;
+exports.reset = reset;
+exports.subscribe = subscribe;
+exports.useRenderDiagnostics = useRenderDiagnostics;
+exports.useTrackedContextValue = useTrackedContextValue;
+exports.useTrackedEffect = useTrackedEffect;
+exports.useTrackedState = useTrackedState;
+exports.withRenderDetective = withRenderDetective;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map