react-render-detective 0.1.0

package/dist/chunk-7FTXUOB6.cjs

@@ -0,0 +1,1030 @@
+'use strict';
+
+// src/core/inspect.ts
+var REACT_ELEMENT = /* @__PURE__ */ Symbol.for("react.element");
+var REACT_TRANSITIONAL_ELEMENT = /* @__PURE__ */ Symbol.for("react.transitional.element");
+function isReactElement(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const t = value.$$typeof;
+  return t === REACT_ELEMENT || t === REACT_TRANSITIONAL_ELEMENT;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  if (isReactElement(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function valueType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (isReactElement(value)) return "element";
+  const t = typeof value;
+  if (t === "object") return "object";
+  if (t === "function") return "function";
+  return t;
+}
+function elementName(value) {
+  const type = value.type;
+  if (typeof type === "string") return type;
+  if (typeof type === "function") return type.displayName ?? type.name ?? "Anonymous";
+  return "Element";
+}
+function inspect(value, limits) {
+  const budget = { nodes: limits.maxSerializedNodes };
+  try {
+    return walk(value, limits, budget, limits.depth, /* @__PURE__ */ new WeakSet());
+  } catch {
+    return { t: "truncated", hint: "inspection failed" };
+  }
+}
+function walk(value, limits, budget, depth, seen) {
+  if (budget.nodes-- <= 0) return { t: "truncated", hint: "size limit" };
+  if (value === void 0) return { t: "undefined" };
+  if (value === null) return { t: "primitive", v: null };
+  const type = typeof value;
+  if (type === "number") return Number.isNaN(value) ? { t: "nan" } : { t: "primitive", v: value };
+  if (type === "boolean") return { t: "primitive", v: value };
+  if (type === "string") {
+    const s = value;
+    return {
+      t: "primitive",
+      v: s.length > limits.maxStringLength ? `${s.slice(0, limits.maxStringLength)}\u2026(+${s.length - limits.maxStringLength})` : s
+    };
+  }
+  if (type === "symbol") return { t: "symbol", v: String(value) };
+  if (type === "bigint") return { t: "bigint", v: `${String(value)}n` };
+  if (type === "function") {
+    const fn = value;
+    return { t: "function", name: fn.displayName ?? fn.name ?? "anonymous" };
+  }
+  const obj = value;
+  if (seen.has(obj)) return { t: "circular" };
+  seen.add(obj);
+  if (isReactElement(obj)) return { t: "element", name: elementName(obj) };
+  if (Array.isArray(obj)) {
+    const length = obj.length;
+    if (depth <= 0) return { t: "array", length };
+    const take2 = Math.min(length, limits.maxArrayLength);
+    const items = [];
+    for (let i = 0; i < take2; i++) items.push(walk(obj[i], limits, budget, depth - 1, seen));
+    return { t: "array", length, items, truncated: take2 < length };
+  }
+  const ctor = objectTag(obj);
+  let keys;
+  try {
+    keys = Object.keys(obj);
+  } catch {
+    return { t: "object", ctor };
+  }
+  if (depth <= 0) {
+    return { t: "object", ctor, keys: keys.slice(0, limits.maxObjectKeys), truncated: keys.length > limits.maxObjectKeys };
+  }
+  const take = Math.min(keys.length, limits.maxObjectKeys);
+  const entries = {};
+  for (let i = 0; i < take; i++) {
+    const k = keys[i];
+    let v;
+    try {
+      v = obj[k];
+    } catch {
+      entries[k] = { t: "truncated", hint: "getter threw" };
+      continue;
+    }
+    entries[k] = walk(v, limits, budget, depth - 1, seen);
+  }
+  return { t: "object", ctor, entries, truncated: take < keys.length };
+}
+function objectTag(obj) {
+  const proto = Object.getPrototypeOf(obj);
+  if (proto === Object.prototype || proto === null) return void 0;
+  const name = proto?.constructor?.name;
+  return typeof name === "string" && name !== "Object" ? name : void 0;
+}
+function formatInspected(node) {
+  if (!node) return "\u2026";
+  switch (node.t) {
+    case "primitive":
+      return typeof node.v === "string" ? JSON.stringify(node.v) : String(node.v);
+    case "undefined":
+      return "undefined";
+    case "nan":
+      return "NaN";
+    case "symbol":
+    case "bigint":
+      return node.v;
+    case "function":
+      return `\u0192 ${node.name}()`;
+    case "element":
+      return `<${node.name} />`;
+    case "circular":
+      return "[Circular]";
+    case "truncated":
+      return `[\u2026 ${node.hint}]`;
+    case "array": {
+      if (!node.items) return `Array(${node.length})`;
+      const body = node.items.map(formatInspected).join(", ");
+      return `[${body}${node.truncated ? ", \u2026" : ""}]`;
+    }
+    case "object": {
+      const prefix = node.ctor ? `${node.ctor} ` : "";
+      if (node.entries) {
+        const body = Object.entries(node.entries).map(([k, v]) => `${k}: ${formatInspected(v)}`).join(", ");
+        return `${prefix}{ ${body}${node.truncated ? ", \u2026" : ""} }`;
+      }
+      if (node.keys) return `${prefix}{ ${node.keys.join(", ")}${node.truncated ? ", \u2026" : ""} }`;
+      return `${prefix}{\u2026}`;
+    }
+  }
+}
+
+// src/core/config.ts
+function detectDev() {
+  try {
+    const env = typeof process !== "undefined" ? process?.env : void 0;
+    if (env && env.NODE_ENV) return env.NODE_ENV !== "production";
+  } catch {
+  }
+  return false;
+}
+var defaultConfig = {
+  enabled: detectDev(),
+  mode: "console",
+  include: [],
+  exclude: [],
+  samplingRate: 1,
+  maxEvents: 1e3,
+  slowRenderThreshold: 16,
+  thresholds: { monitor: 5, slow: 16, verySlow: 50, critical: 100 },
+  inspection: {
+    depth: 1,
+    maxObjectKeys: 20,
+    maxArrayLength: 20,
+    maxStringLength: 120,
+    maxSerializedNodes: 200
+  },
+  compareFunctionSource: false
+};
+function mergeConfig(base, options = {}) {
+  const { thresholds, inspection, ...rest } = options;
+  const next = {
+    ...base,
+    ...rest,
+    thresholds: { ...base.thresholds, ...thresholds },
+    inspection: { ...base.inspection, ...inspection }
+  };
+  next.samplingRate = clamp(next.samplingRate, 0, 1);
+  next.maxEvents = Math.max(1, Math.floor(next.maxEvents));
+  next.inspection.depth = clamp(Math.floor(next.inspection.depth), 0, 6);
+  return next;
+}
+function clamp(n, lo, hi) {
+  if (typeof n !== "number" || Number.isNaN(n)) return lo;
+  return Math.min(hi, Math.max(lo, n));
+}
+function matches(name, patterns) {
+  for (const p of patterns) {
+    if (typeof p === "string" ? p === name : p.test(name)) return true;
+  }
+  return false;
+}
+function shouldInstrument(name, config) {
+  if (matches(name, config.exclude)) return false;
+  if (config.include.length > 0 && !matches(name, config.include)) return false;
+  return true;
+}
+
+// src/core/compare.ts
+var EMPTY = {};
+function diffProps(previous, current, config) {
+  const prev = previous ?? EMPTY;
+  const next = current ?? EMPTY;
+  const changed = [];
+  const unchanged = [];
+  const keys = /* @__PURE__ */ new Set();
+  for (const k in prev) keys.add(k);
+  for (const k in next) keys.add(k);
+  for (const key of keys) {
+    const hadPrev = key in prev;
+    const hasNext = key in next;
+    const a = prev[key];
+    const b = next[key];
+    if (hadPrev && hasNext && Object.is(a, b)) {
+      unchanged.push(key);
+      continue;
+    }
+    if (!hadPrev) {
+      changed.push({ key, kind: "added", valueType: valueType(b), current: snap(b, config) });
+      continue;
+    }
+    if (!hasNext) {
+      changed.push({ key, kind: "removed", valueType: valueType(a), previous: snap(a, config) });
+      continue;
+    }
+    changed.push(describeChange(key, a, b, config));
+  }
+  return { changed, unchanged };
+}
+function describeChange(key, a, b, config) {
+  const type = valueType(b);
+  const base = {
+    key,
+    kind: "value",
+    valueType: type,
+    previous: snap(a, config),
+    current: snap(b, config)
+  };
+  if (typeof a === "function" && typeof b === "function") {
+    base.kind = "reference";
+    if (config.compareFunctionSource) {
+      base.sourceEqual = safeSource(a) === safeSource(b);
+    }
+    return base;
+  }
+  const shallow = shallowEqual(a, b, config);
+  if (shallow === true) {
+    base.kind = "reference";
+    base.shallowEqual = true;
+  } else if (shallow === false) {
+    base.kind = "value";
+    base.shallowEqual = false;
+  }
+  return base;
+}
+function shallowEqual(a, b, config) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const { maxObjectKeys, maxArrayLength } = config.inspection;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b)) return false;
+    if (a.length !== b.length) return false;
+    if (a.length > maxArrayLength) return void 0;
+    for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+    return true;
+  }
+  if (a instanceof Date || b instanceof Date) {
+    return a instanceof Date && b instanceof Date ? a.getTime() === b.getTime() : false;
+  }
+  if (isReactElement(a) && isReactElement(b)) {
+    const ea = a;
+    const eb = b;
+    if (ea.type !== eb.type || ea.key !== eb.key) return false;
+    return shallowEqual(ea.props, eb.props, config);
+  }
+  if (!isPlainObject(a) || !isPlainObject(b)) return void 0;
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  if (ka.length > maxObjectKeys) return void 0;
+  for (const k of ka) {
+    if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
+    if (!Object.is(a[k], b[k])) return false;
+  }
+  return true;
+}
+function snap(value, config) {
+  return inspect(value, config.inspection);
+}
+function safeSource(fn) {
+  try {
+    return Function.prototype.toString.call(fn);
+  } catch {
+    return "";
+  }
+}
+
+// src/core/diagnose.ts
+function severityFor(duration, t) {
+  if (duration >= t.critical) return "critical";
+  if (duration >= t.verySlow) return "very-slow";
+  if (duration >= t.slow) return "slow";
+  if (duration >= t.monitor) return "monitor";
+  return "normal";
+}
+function diagnose(input, thresholds) {
+  const severity = severityFor(input.selfDuration, thresholds);
+  const d = classify(input);
+  d.severity = severity;
+  if (!input.committed) {
+    d.evidence.unshift(
+      "This render attempt was not committed \u2014 React discarded it (concurrent interruption or a development replay). It is excluded from statistics."
+    );
+  } else if (input.attempts > 1) {
+    d.evidence.push(
+      `Render function ran ${input.attempts}\xD7 for one commit \u2014 a development replay (StrictMode double-invoke or a discarded attempt). Not production behaviour.`
+    );
+  }
+  if (severity === "critical" || severity === "very-slow") {
+    d.evidence.push(`Render cost ${fmt(input.selfDuration)} \u2014 above the ${thresholds.verySlow}ms threshold.`);
+  }
+  return d;
+}
+function classify(input) {
+  const { changedProps, contextChanges, parentRendered, parentUnknown, parentName } = input;
+  if (input.phase === "mount") {
+    return make("mount", "high", `${input.componentName} mounted.`, ["First render of this instance."], false);
+  }
+  if (input.trackedState.length > 0) {
+    const names = input.trackedState.map((s) => s.name);
+    const evidence = input.trackedState.map(
+      (s) => `\`${s.name}\`: ${formatInspected(s.previous)} \u2192 ${formatInspected(s.current)}`
+    );
+    if (changedProps.length > 0) {
+      evidence.push(`Props also changed: ${changedProps.map((c) => c.key).join(", ")}.`);
+    }
+    return make(
+      "state",
+      "high",
+      `${input.componentName} rendered because its own state changed: ${names.join(", ")}.`,
+      evidence,
+      false
+    );
+  }
+  if (changedProps.length > 0) {
+    const meaningful = changedProps.filter((c) => c.kind !== "reference");
+    const referenceOnly = changedProps.filter((c) => c.kind === "reference");
+    if (meaningful.length > 0) {
+      const keys2 = meaningful.map((c) => c.key);
+      const evidence2 = [
+        `Props changed with new values: ${keys2.join(", ")}.`,
+        ...meaningful.map(describe)
+      ];
+      if (referenceOnly.length > 0) {
+        evidence2.push(
+          `Also changed by reference only (contents identical): ${referenceOnly.map((c) => c.key).join(", ")}.`
+        );
+      }
+      return make(
+        "props",
+        "high",
+        `${input.componentName} rendered because ${plural(keys2.length, "prop")} changed: ${keys2.join(", ")}.`,
+        evidence2,
+        false,
+        referenceOnly.length > 0 ? stabiliseSuggestion(referenceOnly, parentName) : void 0
+      );
+    }
+    const keys = referenceOnly.map((c) => c.key);
+    const evidence = [
+      `${plural(keys.length, "prop")} changed by reference only: ${keys.join(", ")}.`,
+      ...referenceOnly.map(describe)
+    ];
+    if (parentRendered && parentName) {
+      evidence.push(`${parentName} re-rendered in the same commit and recreated ${keys.length > 1 ? "these values" : `\`${keys[0]}\``}.`);
+    }
+    const confidence = referenceOnly.some((c) => c.shallowEqual === true || c.valueType === "function") ? "medium" : "low";
+    return make(
+      "props",
+      confidence,
+      `${input.componentName} rendered because ${keys.join(", ")} changed by reference \u2014 the contents did not.`,
+      evidence,
+      true,
+      stabiliseSuggestion(referenceOnly, parentName)
+    );
+  }
+  if (input.propsReevaluated === false) {
+    if (contextChanges.length > 0) {
+      const c = contextChanges[0];
+      const detail = c.changedKeys.length > 0 ? ` Changed: ${c.changedKeys.join(", ")}.` : "";
+      return make(
+        "context",
+        "medium",
+        `${input.componentName} rendered after ${c.contextName} updated in the same commit.${detail}`,
+        [
+          "No new props came from above \u2014 the render started at this component.",
+          `Tracked context ${c.contextName} changed in this commit.`,
+          c.referenceOnly ? `${c.contextName}'s value changed by reference only \u2014 its contents are identical.` : `${c.contextName}'s contents changed.`,
+          "React does not expose which contexts a component subscribes to, so this is correlation within one commit, not a recorded subscription."
+        ],
+        c.referenceOnly,
+        c.referenceOnly ? `${c.contextName}'s provider recreates its value every render. Stabilise it with useMemo if consumers are doing real work.` : void 0
+      );
+    }
+    return make(
+      "state-or-external",
+      input.selfRenderProven ? "high" : "medium",
+      `${input.componentName} rendered from inside itself \u2014 local state, a store subscription, or a forced update.`,
+      [
+        "No new props came from above: the wrapper did not re-render.",
+        input.selfRenderProven ? "An instrumented child re-rendered from above in this commit, which proves this component produced it." : "No instrumented descendant rendered in this commit, so an uninstrumented descendant could in principle be the origin instead.",
+        "React does not expose hook state without private internals, so the exact source is not observable. Use useTrackedState to name it."
+      ],
+      false
+    );
+  }
+  if (input.propsReevaluated === true) {
+    const known = parentRendered && parentName;
+    return make(
+      "parent",
+      known && contextChanges.length === 0 ? "high" : "medium",
+      `${input.componentName} rendered because its parent rendered \u2014 its own inputs did not change.`,
+      [
+        known ? `${parentName} re-rendered in this commit.` : "Something above re-rendered this component, but the nearest instrumented ancestor did not \u2014 an uninstrumented component sits in between.",
+        "Every prop is identical by reference.",
+        contextChanges.length === 0 ? "No tracked context changed in this commit." : `A tracked context also changed (${contextChanges.map((c) => c.contextName).join(", ")}) \u2014 but new props arrived from above, so propagation is the direct cause.`
+      ],
+      true,
+      memoSuggestion(input)
+    );
+  }
+  if (parentRendered) {
+    const evidence = [
+      `${parentName ?? "The nearest instrumented ancestor"} re-rendered in this commit.`,
+      "Every prop is identical by reference.",
+      contextChanges.length === 0 ? "No tracked context changed in this commit." : `A tracked context also changed (${contextChanges.map((c) => c.contextName).join(", ")}) \u2014 if this component consumes it, that is an alternative cause.`
+    ];
+    return make(
+      "parent",
+      contextChanges.length === 0 ? "high" : "medium",
+      `${input.componentName} rendered because its parent rendered \u2014 its own inputs did not change.`,
+      evidence,
+      true,
+      memoSuggestion(input)
+    );
+  }
+  if (contextChanges.length > 0) {
+    const c = contextChanges[0];
+    const detail = c.changedKeys.length > 0 ? ` Changed: ${c.changedKeys.join(", ")}.` : "";
+    return make(
+      "context",
+      "medium",
+      `${input.componentName} rendered after ${c.contextName} updated in the same commit.${detail}`,
+      [
+        `Props are identical and the parent did not re-render.`,
+        `Tracked context ${c.contextName} changed in this commit.`,
+        c.referenceOnly ? `${c.contextName}'s value changed by reference only \u2014 its contents are identical.` : `${c.contextName}'s contents changed.`,
+        "React does not expose which contexts a component subscribes to, so this is correlation within one commit, not a recorded subscription."
+      ],
+      c.referenceOnly,
+      c.referenceOnly ? `${c.contextName}'s provider recreates its value every render. Stabilise it with useMemo if consumers are doing real work.` : void 0
+    );
+  }
+  if (parentUnknown) {
+    return make(
+      "unknown",
+      "low",
+      `Cause could not be determined reliably for ${input.componentName}.`,
+      [
+        "Props are identical and no tracked context changed.",
+        "This component has no instrumented ancestor, so a parent-propagated render cannot be ruled out.",
+        "Instrument the parent, or track the context it consumes, to narrow this down."
+      ],
+      false
+    );
+  }
+  return make(
+    "state-or-external",
+    "medium",
+    `${input.componentName} rendered from inside itself \u2014 local state, a store subscription, or a forced update.`,
+    [
+      "Props are identical by reference.",
+      "The nearest instrumented ancestor did not re-render in this commit.",
+      "No tracked context changed in this commit.",
+      "React does not expose hook state without private internals, so the exact source is not observable. Use useTrackedState to name it."
+    ],
+    false
+  );
+}
+function memoSuggestion(input) {
+  const worth = input.selfDuration >= 1 || input.priorAvoidableRenders >= 5;
+  return worth ? `Check whether ${input.componentName} benefits from React.memo(). It has re-rendered with identical props ${input.priorAvoidableRenders + 1}\xD7 at ${fmt(input.selfDuration)} each \u2014 measure before and after.` : `Props are identical, but this render costs ${fmt(input.selfDuration)}. Memoizing is unlikely to pay for itself yet.`;
+}
+function stabiliseSuggestion(changes, parentName) {
+  const fns = changes.filter((c) => c.valueType === "function").map((c) => c.key);
+  const objs = changes.filter((c) => c.valueType === "object" || c.valueType === "array").map((c) => c.key);
+  const where = parentName ? ` in ${parentName}` : "";
+  const parts = [];
+  if (fns.length > 0) parts.push(`${list(fns)} ${plural(fns.length, "is", "are")} recreated on every render${where} \u2014 useCallback, or hoist it, if a memoized child depends on it`);
+  if (objs.length > 0) parts.push(`${list(objs)} ${plural(objs.length, "is", "are")} a new object each render${where} \u2014 useMemo it, or pass the primitive fields you actually use`);
+  if (parts.length === 0) return `Find where ${list(changes.map((c) => c.key))} is created${where} and stabilise it.`;
+  return `${capitalize(parts.join("; "))}.`;
+}
+function describe(c) {
+  switch (c.kind) {
+    case "added":
+      return `\`${c.key}\` was added.`;
+    case "removed":
+      return `\`${c.key}\` was removed.`;
+    case "reference":
+      if (c.valueType === "function") {
+        return c.sourceEqual ? `\`${c.key}\` is a new function with identical source \u2014 an inline closure recreated by the parent.` : `\`${c.key}\` is a new function reference.`;
+      }
+      if (c.shallowEqual === true) return `\`${c.key}\` is a new ${c.valueType} whose shallow contents are identical.`;
+      return `\`${c.key}\` changed reference; contents were too large or too exotic to compare cheaply.`;
+    case "value":
+      return `\`${c.key}\` changed value.`;
+  }
+}
+function make(reason, confidence, summary, evidence, potentiallyAvoidable, suggestion) {
+  return { reason, confidence, summary, evidence, potentiallyAvoidable, suggestion, severity: "normal" };
+}
+var fmt = (ms) => `${ms.toFixed(1)}ms`;
+var list = (xs) => xs.map((x) => `\`${x}\``).join(", ");
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+function plural(n, one, many) {
+  if (one === "is") return n === 1 ? "is" : many;
+  return n === 1 ? `${one}` : `${one}s`;
+}
+
+// src/core/ringBuffer.ts
+var RingBuffer = class {
+  constructor(capacity) {
+    this.head = 0;
+    this.count = 0;
+    this.items = new Array(Math.max(1, capacity));
+  }
+  push(item) {
+    this.items[this.head] = item;
+    this.head = (this.head + 1) % this.items.length;
+    if (this.count < this.items.length) this.count++;
+  }
+  get size() {
+    return this.count;
+  }
+  /** Oldest → newest. */
+  toArray() {
+    const out = [];
+    const len = this.items.length;
+    const start = (this.head - this.count + len) % len;
+    for (let i = 0; i < this.count; i++) {
+      const v = this.items[(start + i) % len];
+      if (v !== void 0) out.push(v);
+    }
+    return out;
+  }
+  clear() {
+    this.items = new Array(this.items.length);
+    this.head = 0;
+    this.count = 0;
+  }
+  resize(capacity) {
+    const existing = this.toArray();
+    this.items = new Array(Math.max(1, capacity));
+    this.head = 0;
+    this.count = 0;
+    const keep = existing.slice(Math.max(0, existing.length - this.items.length));
+    for (const item of keep) this.push(item);
+  }
+};
+
+// src/core/store.ts
+var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+var EMPTY_STATE = [];
+var DURATION_SAMPLE = 200;
+var SWEEP_DELAY_MS = 250;
+var emptyReasons = () => ({
+  mount: 0,
+  props: 0,
+  state: 0,
+  parent: 0,
+  context: 0,
+  "state-or-external": 0,
+  unknown: 0
+});
+var Detective = class {
+  constructor() {
+    this.config = { ...defaultConfig };
+    this.nodes = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.pending = [];
+    this.contextChanges = [];
+    /** Orders renders and context updates so they can be matched without timers. */
+    this.seq = 0;
+    this.flushScheduled = false;
+    this.nextId = 0;
+    /** Nodes created by `useRenderDiagnostics`, where props/state cannot be separated. */
+    this.hookModeNodes = /* @__PURE__ */ new WeakSet();
+    this.initialized = false;
+    this.events = new RingBuffer(this.config.maxEvents);
+  }
+  /** Idempotent: repeated calls reconfigure, they never duplicate anything (§47). */
+  init(options = {}) {
+    this.configure(options);
+    this.initialized = true;
+    return this;
+  }
+  configure(options = {}) {
+    const previousMax = this.config.maxEvents;
+    this.config = mergeConfig(this.config, options);
+    if (this.config.maxEvents !== previousMax) this.events.resize(this.config.maxEvents);
+  }
+  get isInitialized() {
+    return this.initialized;
+  }
+  get enabled() {
+    return this.config.enabled;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  // ---------------------------------------------------------------- registry
+  /**
+   * 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, parent) {
+    if (!shouldInstrument(name, this.config)) return void 0;
+    const sampled = this.config.samplingRate >= 1 || Math.random() < this.config.samplingRate;
+    const node = {
+      id: `rrd_${++this.nextId}`,
+      name,
+      parent,
+      depth: parent ? parent.depth + 1 : 0,
+      sampled,
+      attempts: 0,
+      pendingState: [],
+      seenCommit: false,
+      renderNumber: 0,
+      lastCommitTime: -1,
+      durations: [],
+      stats: {
+        renderCount: 0,
+        mountCount: 0,
+        uncommittedAttempts: 0,
+        devReplays: 0,
+        totalSelfDuration: 0,
+        maxSelfDuration: 0,
+        slowRenders: 0,
+        potentiallyAvoidableRenders: 0,
+        reasons: emptyReasons()
+      }
+    };
+    return node;
+  }
+  attach(node) {
+    this.nodes.set(node.id, node);
+  }
+  detach(node) {
+    node.prevProps = void 0;
+    node.pendingProps = void 0;
+    this.nodes.delete(node.id);
+  }
+  /** Hot path. Must stay allocation-free and O(1). */
+  recordAttempt(node, props) {
+    node.attempts++;
+    node.pendingProps = props;
+  }
+  recordStateChange(node, change) {
+    if (node.pendingState.length < 16) node.pendingState.push(change);
+  }
+  /**
+   * 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, commit) {
+    this.pending.push({
+      ...commit,
+      node,
+      attempts: node.attempts,
+      props: node.pendingProps,
+      state: node.pendingState.length > 0 ? node.pendingState : EMPTY_STATE,
+      seq: ++this.seq
+    });
+    node.seenCommit = true;
+    node.attempts = 0;
+    node.pendingProps = void 0;
+    if (node.pendingState.length > 0) node.pendingState = [];
+    node.lastCommitTime = commit.commitTime;
+    this.scheduleFlush();
+  }
+  recordContextChange(change) {
+    this.contextChanges.push({ change, seq: ++this.seq });
+    this.scheduleFlush();
+  }
+  // ------------------------------------------------------------ deferred work
+  scheduleFlush() {
+    if (this.flushScheduled) return;
+    this.flushScheduled = true;
+    queueMicrotask(() => {
+      this.flushScheduled = false;
+      try {
+        this.flush();
+      } catch {
+      }
+    });
+    this.scheduleSweep();
+  }
+  scheduleSweep() {
+    if (this.sweepHandle !== void 0) return;
+    this.sweepHandle = setTimeout(() => {
+      this.sweepHandle = void 0;
+      try {
+        this.sweep();
+      } catch {
+      }
+    }, SWEEP_DELAY_MS);
+    this.sweepHandle.unref?.();
+  }
+  /** Attempts that never reached a commit were abandoned or replayed. */
+  sweep() {
+    for (const node of this.nodes.values()) {
+      if (node.attempts > 0) {
+        node.stats.uncommittedAttempts += node.attempts;
+        node.attempts = 0;
+      }
+    }
+  }
+  /** Runs after the commit, off the render path. Whole batch is available here. */
+  flush() {
+    if (this.pending.length === 0) {
+      this.contextChanges.length = 0;
+      return;
+    }
+    const batch = this.pending;
+    this.pending = [];
+    const pendingContexts = this.contextChanges;
+    this.contextChanges = [];
+    const hookMode = this.hookModeNodes;
+    let nextReal = -1;
+    for (let i = batch.length - 1; i >= 0; i--) {
+      const rec = batch[i];
+      if (rec.commitTime >= 0) nextReal = rec.commitTime;
+      else if (nextReal >= 0) rec.commitTime = nextReal;
+      else rec.commitTime = now();
+    }
+    const contexts = pendingContexts.map(({ change, seq }) => {
+      if (change.commitTime >= 0) return change;
+      const following = batch.find((r) => r.seq > seq);
+      return { ...change, commitTime: following ? following.commitTime : batch[batch.length - 1]?.commitTime ?? now() };
+    });
+    const commitMembers = /* @__PURE__ */ new Map();
+    const descendantTime = /* @__PURE__ */ new Map();
+    for (const rec of batch) {
+      let set = commitMembers.get(rec.commitTime);
+      if (!set) commitMembers.set(rec.commitTime, set = /* @__PURE__ */ new Set());
+      set.add(rec.node);
+    }
+    for (const rec of batch) {
+      const parent = rec.node.parent;
+      if (!parent) continue;
+      if (!commitMembers.get(rec.commitTime)?.has(parent)) continue;
+      descendantTime.set(parent, (descendantTime.get(parent) ?? 0) + rec.subtreeDuration);
+    }
+    const provenSelfRender = /* @__PURE__ */ new Set();
+    const hasInstrumentedDescendant = /* @__PURE__ */ new Set();
+    for (const rec of batch) {
+      const members = commitMembers.get(rec.commitTime);
+      if (rec.attempts > 0 && rec.node.parent && members?.has(rec.node.parent)) {
+        provenSelfRender.add(rec.node.parent);
+      }
+      for (let a = rec.node.parent; a; a = a.parent) {
+        if (members?.has(a)) hasInstrumentedDescendant.add(a);
+      }
+    }
+    for (const rec of batch) {
+      if (!rec.node.sampled) continue;
+      const counted = rec.attempts > 0 || rec.phase === "mount" || provenSelfRender.has(rec.node) || !hasInstrumentedDescendant.has(rec.node);
+      if (!counted) continue;
+      try {
+        this.emit(
+          this.buildEvent(rec.node, rec, commitMembers, descendantTime, contexts, provenSelfRender, hookMode.has(rec.node))
+        );
+      } catch {
+      }
+    }
+  }
+  buildEvent(node, rec, commitMembers, descendantTime, contexts, provenSelfRender, isHookMode) {
+    const parent = node.parent;
+    const parentRendered = parent ? commitMembers.get(rec.commitTime)?.has(parent) === true : false;
+    const propsReevaluated = isHookMode ? void 0 : rec.attempts > 0;
+    const isMount = rec.phase === "mount";
+    const props = rec.props ?? node.prevProps ?? {};
+    const { changed, unchanged } = isMount || propsReevaluated === false ? { changed: [], unchanged: Object.keys(props) } : diffProps(node.prevProps, props, this.config);
+    node.prevProps = props;
+    const accounted = descendantTime.get(node) ?? 0;
+    const selfDuration = Math.max(0, rec.subtreeDuration - accounted);
+    const relevantContexts = contexts.filter((c) => c.commitTime === rec.commitTime);
+    const trackedState = rec.state;
+    node.renderNumber++;
+    const diagnosis = diagnose(
+      {
+        componentName: node.name,
+        phase: rec.phase,
+        parentName: parent?.name,
+        parentRendered,
+        parentUnknown: !parent,
+        propsReevaluated,
+        selfRenderProven: provenSelfRender.has(node),
+        changedProps: changed,
+        contextChanges: relevantContexts,
+        selfDuration,
+        attempts: rec.attempts,
+        committed: true,
+        trackedState,
+        priorAvoidableRenders: node.stats.potentiallyAvoidableRenders
+      },
+      this.config.thresholds
+    );
+    const componentInfo = {
+      id: node.id,
+      name: node.name,
+      parentId: parent?.id,
+      depth: node.depth
+    };
+    const event = {
+      id: `${node.id}#${node.renderNumber}`,
+      component: componentInfo,
+      timestamp: rec.startTime,
+      renderNumber: node.renderNumber,
+      phase: rec.phase,
+      timings: {
+        subtreeDuration: rec.subtreeDuration,
+        baseDuration: rec.baseDuration,
+        selfDuration,
+        accountedDescendantDuration: accounted,
+        commitTime: rec.commitTime,
+        startTime: rec.startTime
+      },
+      changedProps: changed,
+      unchangedProps: unchanged,
+      parent: parent ? { id: parent.id, name: parent.name, parentId: parent.parent?.id, depth: parent.depth } : void 0,
+      parentRendered,
+      selfOriginated: propsReevaluated === false,
+      contextChanges: relevantContexts,
+      trackedState,
+      committed: true,
+      attempts: Math.max(1, rec.attempts),
+      devReplay: rec.attempts > 1,
+      diagnosis
+    };
+    this.updateStats(node, event);
+    return event;
+  }
+  updateStats(node, event) {
+    const s = node.stats;
+    s.renderCount++;
+    if (event.phase === "mount") s.mountCount++;
+    if (event.devReplay) s.devReplays++;
+    const d = event.timings.selfDuration;
+    s.totalSelfDuration += d;
+    if (d > s.maxSelfDuration) s.maxSelfDuration = d;
+    if (d >= this.config.slowRenderThreshold) s.slowRenders++;
+    if (event.diagnosis.potentiallyAvoidable) s.potentiallyAvoidableRenders++;
+    s.reasons[event.diagnosis.reason]++;
+    node.durations.push(d);
+    if (node.durations.length > DURATION_SAMPLE) node.durations.shift();
+  }
+  emit(event) {
+    this.events.push(event);
+    const { onEvent } = this.config;
+    if (onEvent) {
+      try {
+        onEvent(event);
+      } catch {
+      }
+    }
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  // -------------------------------------------------------------------- query
+  getEvents() {
+    this.flush();
+    return this.events.toArray();
+  }
+  getComponentStats(name) {
+    this.flush();
+    const out = [];
+    for (const node of this.nodes.values()) {
+      if (name && node.name !== name) continue;
+      if (node.stats.renderCount === 0 && node.stats.uncommittedAttempts === 0) continue;
+      out.push(toStats(node));
+    }
+    return out;
+  }
+  getStats() {
+    const all = this.getComponentStats();
+    const byName = /* @__PURE__ */ new Map();
+    for (const s of all) {
+      const existing = byName.get(s.name);
+      byName.set(s.name, existing ? mergeStats(existing, s) : s);
+    }
+    const merged = [...byName.values()];
+    return {
+      components: merged.length,
+      totalRenders: merged.reduce((a, s) => a + s.renderCount, 0),
+      totalRenderTime: merged.reduce((a, s) => a + s.totalSelfDuration, 0),
+      slowRenders: merged.reduce((a, s) => a + s.slowRenders, 0),
+      potentiallyAvoidableRenders: merged.reduce((a, s) => a + s.potentiallyAvoidableRenders, 0),
+      devReplays: merged.reduce((a, s) => a + s.devReplays, 0),
+      slowest: [...merged].sort((a, b) => b.maxSelfDuration - a.maxSelfDuration).slice(0, 10),
+      mostRendered: [...merged].sort((a, b) => b.renderCount - a.renderCount).slice(0, 10),
+      mostExpensive: [...merged].sort((a, b) => b.totalSelfDuration - a.totalSelfDuration).slice(0, 10)
+    };
+  }
+  clear() {
+    this.events.clear();
+    this.pending.length = 0;
+    this.contextChanges.length = 0;
+    for (const node of this.nodes.values()) {
+      node.stats = {
+        renderCount: 0,
+        mountCount: 0,
+        uncommittedAttempts: 0,
+        devReplays: 0,
+        totalSelfDuration: 0,
+        maxSelfDuration: 0,
+        slowRenders: 0,
+        potentiallyAvoidableRenders: 0,
+        reasons: emptyReasons()
+      };
+      node.durations.length = 0;
+      node.renderNumber = 0;
+    }
+  }
+  /** Full teardown — used by tests and by HMR disposal. */
+  reset() {
+    this.clear();
+    this.nodes.clear();
+    this.listeners.clear();
+    if (this.sweepHandle !== void 0) clearTimeout(this.sweepHandle);
+    this.sweepHandle = void 0;
+    this.config = { ...defaultConfig };
+    this.events.resize(this.config.maxEvents);
+    this.initialized = false;
+  }
+};
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p / 100 * sorted.length) - 1));
+  return sorted[idx];
+}
+function toStats(node) {
+  const sorted = [...node.durations].sort((a, b) => a - b);
+  const s = node.stats;
+  return {
+    id: node.id,
+    name: node.name,
+    renderCount: s.renderCount,
+    mountCount: s.mountCount,
+    uncommittedAttempts: s.uncommittedAttempts,
+    devReplays: s.devReplays,
+    totalSelfDuration: s.totalSelfDuration,
+    averageSelfDuration: s.renderCount ? s.totalSelfDuration / s.renderCount : 0,
+    medianSelfDuration: percentile(sorted, 50),
+    p95SelfDuration: percentile(sorted, 95),
+    p99SelfDuration: percentile(sorted, 99),
+    maxSelfDuration: s.maxSelfDuration,
+    slowRenders: s.slowRenders,
+    potentiallyAvoidableRenders: s.potentiallyAvoidableRenders,
+    reasons: { ...s.reasons }
+  };
+}
+function mergeStats(a, b) {
+  const renderCount = a.renderCount + b.renderCount;
+  const total = a.totalSelfDuration + b.totalSelfDuration;
+  const reasons = { ...a.reasons };
+  for (const key of Object.keys(b.reasons)) reasons[key] += b.reasons[key];
+  return {
+    id: a.id,
+    name: a.name,
+    renderCount,
+    mountCount: a.mountCount + b.mountCount,
+    uncommittedAttempts: a.uncommittedAttempts + b.uncommittedAttempts,
+    devReplays: a.devReplays + b.devReplays,
+    totalSelfDuration: total,
+    averageSelfDuration: renderCount ? total / renderCount : 0,
+    medianSelfDuration: Math.max(a.medianSelfDuration, b.medianSelfDuration),
+    p95SelfDuration: Math.max(a.p95SelfDuration, b.p95SelfDuration),
+    p99SelfDuration: Math.max(a.p99SelfDuration, b.p99SelfDuration),
+    maxSelfDuration: Math.max(a.maxSelfDuration, b.maxSelfDuration),
+    slowRenders: a.slowRenders + b.slowRenders,
+    potentiallyAvoidableRenders: a.potentiallyAvoidableRenders + b.potentiallyAvoidableRenders,
+    reasons
+  };
+}
+var KEY = /* @__PURE__ */ Symbol.for("react-render-detective.instance");
+function getDetective() {
+  const g = globalThis;
+  if (!g[KEY]) g[KEY] = new Detective();
+  return g[KEY];
+}
+
+exports.Detective = Detective;
+exports.RingBuffer = RingBuffer;
+exports.defaultConfig = defaultConfig;
+exports.detectDev = detectDev;
+exports.diagnose = diagnose;
+exports.diffProps = diffProps;
+exports.formatInspected = formatInspected;
+exports.getDetective = getDetective;
+exports.inspect = inspect;
+exports.isPlainObject = isPlainObject;
+exports.isReactElement = isReactElement;
+exports.matches = matches;
+exports.mergeConfig = mergeConfig;
+exports.severityFor = severityFor;
+exports.shallowEqual = shallowEqual;
+exports.shouldInstrument = shouldInstrument;
+exports.valueType = valueType;
+//# sourceMappingURL=chunk-7FTXUOB6.cjs.map
+//# sourceMappingURL=chunk-7FTXUOB6.cjs.map