rerender-lens 0.3.0 → 0.5.0

package/dist/rerender-lens.iife.js

@@ -1,10 +1,39 @@
-var RerenderLens = (function (exports) {
-  'use strict';
+/* rerender-lens 0.5.0 — rerender-lens.core.js: types, version, diff, report, state, overlay. Built by scripts/build-vendor.mjs; do not edit. */
+(() => {
+  var __defProp = Object.defineProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
 
   // src/types.ts
+  var types_exports = {};
+  __export(types_exports, {
+    MARKER: () => MARKER
+  });
   var MARKER = "rerenderLens";
 
+  // src/version.ts
+  var version_exports = {};
+  __export(version_exports, {
+    VERSION: () => VERSION
+  });
+  var VERSION = true ? "0.5.0" : "dev";
+
   // src/diff.ts
+  var diff_exports = {};
+  __export(diff_exports, {
+    AVOIDABLE_KINDS: () => AVOIDABLE_KINDS,
+    DEFAULT_DIFF_BUDGET: () => DEFAULT_DIFF_BUDGET,
+    beginDiffScope: () => beginDiffScope,
+    classify: () => classify,
+    deepEqual: () => deepEqual,
+    diffBudgetExhausted: () => diffBudgetExhausted,
+    diffLeaves: () => diffLeaves,
+    diffRecords: () => diffRecords,
+    firstDifferentPath: () => firstDifferentPath,
+    isReactElement: () => isReactElement
+  });
   var REACT_ELEMENT = /* @__PURE__ */ Symbol.for("react.element");
   var REACT_TRANSITIONAL_ELEMENT = /* @__PURE__ */ Symbol.for("react.transitional.element");
   function isReactElement(v) {
@@ -27,10 +56,49 @@ var RerenderLens = (function (exports) {
     set.add(b);
     return false;
   }
+  var scope = null;
+  var DEFAULT_DIFF_BUDGET = 5e4;
+  function beginDiffScope(budget = 2e5) {
+    const previous = scope;
+    scope = { cache: /* @__PURE__ */ new WeakMap(), remaining: budget, exhausted: false };
+    return () => {
+      scope = previous;
+    };
+  }
+  function diffBudgetExhausted() {
+    return scope?.exhausted === true;
+  }
   function deepEqual(a, b, seen = /* @__PURE__ */ new Map()) {
     if (Object.is(a, b)) return true;
     if (typeof a !== typeof b) return false;
     if (typeof a !== "object" || a === null || b === null) return false;
+    if (!scope) {
+      const end = beginDiffScope(DEFAULT_DIFF_BUDGET);
+      try {
+        return deepEqual(a, b, seen);
+      } finally {
+        end();
+      }
+    }
+    const sc = scope;
+    const objA = a;
+    const objB = b;
+    const hit = sc.cache.get(objA)?.get(objB);
+    if (hit !== void 0) return hit;
+    if (--sc.remaining < 0) {
+      sc.exhausted = true;
+      return false;
+    }
+    const result = deepEqualObjects(objA, objB, seen);
+    let m = sc.cache.get(objA);
+    if (!m) {
+      m = /* @__PURE__ */ new WeakMap();
+      sc.cache.set(objA, m);
+    }
+    m.set(objB, result);
+    return result;
+  }
+  function deepEqualObjects(a, b, seen) {
     const objA = a;
     const objB = b;
     if (remember(seen, objA, objB)) return true;
@@ -59,6 +127,10 @@ var RerenderLens = (function (exports) {
     }
     if (a instanceof Set) {
       if (!(b instanceof Set) || a.size !== b.size) return false;
+      if (a.size > 50) {
+        for (const v of a) if (!b.has(v)) return false;
+        return true;
+      }
       outer: for (const v of a) {
         if (b.has(v)) continue;
         for (const w of b) if (deepEqual(v, w, seen)) continue outer;
@@ -74,14 +146,16 @@ var RerenderLens = (function (exports) {
       const ka = Object.keys(a);
       const kb = Object.keys(b);
       if (ka.length !== kb.length) return false;
+      const rb = b;
       for (const k of ka) {
         if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
-        if (!deepEqual(a[k], b[k], seen)) return false;
+        if (!deepEqual(a[k], rb[k], seen)) return false;
       }
       return true;
     }
     return false;
   }
+  var AVOIDABLE_KINDS = /* @__PURE__ */ new Set(["deep-equal", "function", "element"]);
   function classify(prev, next) {
     if (typeof prev === "function" && typeof next === "function") {
       return prev.name === next.name && prev.toString() === next.toString() ? "function" : "different";
@@ -118,33 +192,60 @@ var RerenderLens = (function (exports) {
       if (Object.is(a, b)) continue;
       const kind = classify(a, b);
       if (kind === "different") {
-        changes.push({ path: firstDifferentPath(a, b, path), kind, prev: a, next: b });
+        changes.push({ path: diffBudgetExhausted() ? path : firstDifferentPath(a, b, path) ?? path, kind, prev: a, next: b });
       } else {
         changes.push({ path, kind, prev: a, next: b });
       }
     }
     return changes;
   }
-  function firstDifferentPath(a, b, path, depth = 0) {
-    if (depth > 8) return path;
+  function firstDifferentPath(a, b, path = "", depth = 0) {
+    if (depth > 8) return path || "(value)";
     if (Array.isArray(a) && Array.isArray(b)) {
-      if (a.length !== b.length) return `${path}.length`;
+      if (a.length !== b.length) return path ? `${path}.length` : "length";
       for (let i = 0; i < a.length; i++) {
         if (!deepEqual(a[i], b[i])) return firstDifferentPath(a[i], b[i], joinPath(path, i), depth + 1);
       }
-      return path;
+      return null;
     }
     if (isPlainObject(a) && isPlainObject(b)) {
       const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
       for (const k of keys) {
         if (!deepEqual(a[k], b[k])) return firstDifferentPath(a[k], b[k], joinPath(path, k), depth + 1);
       }
-      return path;
+      return null;
     }
-    return path;
+    return deepEqual(a, b) ? null : path || "(value)";
+  }
+  function diffLeaves(a, b, limit = 20, path = "", out = []) {
+    if (out.length >= limit || Object.is(a, b)) return out;
+    if (Array.isArray(a) && Array.isArray(b)) {
+      const n = Math.max(a.length, b.length);
+      for (let i = 0; i < n && out.length < limit; i++) diffLeaves(a[i], b[i], limit, joinPath(path, i), out);
+      return out;
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+      for (const k of /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])) {
+        if (out.length >= limit) break;
+        diffLeaves(a[k], b[k], limit, joinPath(path, k), out);
+      }
+      return out;
+    }
+    if (!deepEqual(a, b)) out.push({ path: path || "(value)", prev: a, next: b });
+    return out;
   }
 
   // src/report.ts
+  var report_exports = {};
+  __export(report_exports, {
+    KIND_LABEL: () => KIND_LABEL,
+    buildReport: () => buildReport,
+    fixFor: () => fixFor,
+    hookLabel: () => hookLabel,
+    printReport: () => printReport,
+    storeAdvice: () => storeAdvice,
+    summarize: () => summarize
+  });
   var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
   var hookLabel = (c) => c.custom && c.custom.length ? `${c.custom.join(" \u203A ")} \u203A ${c.hook}#${c.index}` : `${c.hook} #${c.index}`;
   function storeAdvice(custom) {
@@ -159,10 +260,12 @@ var RerenderLens = (function (exports) {
   }
   var isGenuine = (c) => c.kind === "different" || c.kind === "added" || c.kind === "removed";
   var isChildren = (change) => change.path === "children";
+  var isRefObject = (change) => change.path === "ref" && change.kind === "deep-equal";
   function fixFor(change) {
     if (isChildren(change) && (change.kind === "element" || change.kind === "deep-equal")) {
       return `lift the children out of the parent's render: memoize them with useMemo, hoist static elements to module scope, or render them from a component that does not re-render`;
     }
+    if (isRefObject(change)) return `create the ref once with useRef (or createRef outside the render) and pass the same object every time`;
     switch (change.kind) {
       case "function":
         return `wrap it in useCallback (or hoist it out of the parent's render)`;
@@ -178,6 +281,7 @@ var RerenderLens = (function (exports) {
     if (isChildren(change) && (change.kind === "element" || change.kind === "deep-equal")) {
       return `children are new React elements with the same types and props on every render of the parent`;
     }
+    if (isRefObject(change)) return `prop "ref" is a new ref object on every render (React re-attaches it each time)`;
     switch (change.kind) {
       case "deep-equal":
         return `prop "${change.path}" is a new reference but deep-equal to the previous value`;
@@ -205,11 +309,21 @@ var RerenderLens = (function (exports) {
     if (causes.length === 0) trigger = "parent";
     else if (causes.length === 1) trigger = causes[0];
     else trigger = "mixed";
-    const avoidable = trigger === "parent";
+    const nothingChanged = input.propChanges.length === 0 && stateChanges.length === 0 && hookChanges.length === 0;
+    const cacheHit = input.compiled === true && trigger === "parent" && input.propChanges.length === 0;
+    const revealed = input.revealed === true && trigger === "parent";
+    const avoidable = trigger === "parent" && !cacheHit && !revealed;
     const reasons = [];
-    if (avoidable && input.propChanges.length === 0 && stateChanges.length === 0 && hookChanges.length === 0) {
+    const memoFix = input.classComponent ? `Make "${input.component}" extend PureComponent (or implement shouldComponentUpdate)` : `Wrap "${input.component}" in React.memo (or extend PureComponent)`;
+    if (cacheHit) {
+      reasons.push(`compiled by React Compiler: its output is memoized and the inputs did not change, so this render is cheap; nothing to fix.`);
+    } else if (revealed) {
+      reasons.push(
+        `re-rendered because the Suspense boundary above it switched from its fallback to content: React re-renders the content it kept hidden while the fallback was shown. A one-off; nothing to fix.`
+      );
+    } else if (avoidable && nothingChanged) {
       const who = input.parent ? `<${input.parent.name}> re-rendered (${describeTrigger(input.parent.trigger)})` : "its parent re-rendered";
-      reasons.push(`re-rendered with identical props because ${who}. Wrap "${input.component}" in React.memo (or extend PureComponent).`);
+      reasons.push(`re-rendered with identical props because ${who}. ${memoFix}.`);
     } else if (avoidable && input.parent) {
       reasons.push(`caused by <${input.parent.name}> re-rendering (${describeTrigger(input.parent.trigger)}).`);
     }
@@ -218,9 +332,9 @@ var RerenderLens = (function (exports) {
       reasons.push(fix ? `${describe(c)}: ${fix}.` : `${describe(c)}.`);
     }
     const memoized = input.memoized !== false;
-    if (avoidable && !memoized && input.propChanges.length > 0) {
+    if (avoidable && !memoized && !input.compiled && input.propChanges.length > 0) {
       reasons.push(
-        `"${input.component}" is not memoized, so fixing the props alone will not stop this re-render: also wrap it in React.memo (or extend PureComponent).`
+        `"${input.component}" is not memoized, so fixing the props alone will not stop this re-render: also ${input.classComponent ? "extend PureComponent (or implement shouldComponentUpdate)" : "wrap it in React.memo (or extend PureComponent)"}.`
       );
     }
     for (const c of stateChanges) {
@@ -232,6 +346,8 @@ var RerenderLens = (function (exports) {
         const where = c.provider && c.provider.component ? ` (provided by <${c.provider.component}>)` : "";
         const keys = c.changedKeys && typeof c.totalKeys === "number" && c.changedKeys.length > 0 && c.changedKeys.length < c.totalKeys ? `: only ${c.changedKeys.map((k) => `"${k}"`).join(", ")} of ${c.totalKeys} keys changed, yet every consumer re-renders. Split the context or memoize the slices consumers read` : "";
         reasons.push(`${c.path} changed${where}${keys}.`);
+      } else if (c.hook === "useDeferredValue" && isGenuine(c)) {
+        reasons.push(`${hookLabel(c)} caught up with its latest value: this is the deferred second render React schedules after the urgent one; nothing to fix.`);
       } else if (isGenuine(c)) reasons.push(`${hookLabel(c)} changed.`);
       else if (isStateHook(c))
         reasons.push(`${hookLabel(c)} was set to a value deep-equal to the current one (new reference, same contents): reuse the existing object or bail out before calling the setter.`);
@@ -262,6 +378,7 @@ var RerenderLens = (function (exports) {
       reasons,
       time: now()
     };
+    if (input.compiled) report.compiled = true;
     if (input.selfDuration !== void 0) report.selfDuration = input.selfDuration;
     if (input.treeDuration !== void 0) report.treeDuration = input.treeDuration;
     if (input.commitPriority) report.commitPriority = input.commitPriority;
@@ -298,13 +415,13 @@ var RerenderLens = (function (exports) {
     removed: "removed"
   };
   function summarize(report) {
-    const counts2 = /* @__PURE__ */ new Map();
-    for (const c of [...report.propChanges, ...report.stateChanges, ...report.hookChanges]) {
-      counts2.set(c.kind, (counts2.get(c.kind) ?? 0) + 1);
+    const counts = /* @__PURE__ */ new Map();
+    for (const c of [...report.propChanges || [], ...report.stateChanges || [], ...report.hookChanges || []]) {
+      counts.set(c.kind, (counts.get(c.kind) ?? 0) + 1);
     }
-    const parts = [...counts2].map(([kind, n]) => `${n} ${KIND_LABEL[kind]}`);
-    if (parts.length === 0) parts.push("no changes");
-    return parts.join(", ");
+    const parts2 = [...counts].map(([kind, n]) => `${n} ${KIND_LABEL[kind] || kind}`);
+    if (parts2.length === 0) parts2.push("no changes");
+    return parts2.join(", ");
   }
   function printReport(report, options) {
     const c = options.console ?? console;
@@ -324,12 +441,18 @@ var RerenderLens = (function (exports) {
   }
 
   // src/state.ts
+  var state_exports = {};
+  __export(state_exports, {
+    dispatch: () => dispatch,
+    getState: () => getState,
+    warnOnce: () => warnOnce
+  });
   var KEY = /* @__PURE__ */ Symbol.for("rerender-lens.state");
   function getState() {
     const g = globalThis;
     let s = g[KEY];
     if (!s) {
-      s = { options: {}, enabled: false, printed: /* @__PURE__ */ new Map(), detach: null, nextInstanceId: 1, nextCommitId: 1, warnedOnce: /* @__PURE__ */ new Set(), scheduled: 0, commits: 0, overheadMs: 0, maxCommitMs: 0 };
+      s = { options: {}, enabled: false, printed: /* @__PURE__ */ new Map(), detach: null, nextInstanceId: 1, nextCommitId: 1, warnedOnce: /* @__PURE__ */ new Set(), scheduled: 0, commits: 0, overheadMs: 0, maxCommitMs: 0, truncated: 0 };
       g[KEY] = s;
     }
     return s;
@@ -342,7 +465,7 @@ var RerenderLens = (function (exports) {
   }
   function dispatch(report, override) {
     const s = getState();
-    const options = s.options;
+    const options = override ? { ...s.options, ...override } : s.options;
     if (!options.silent && (report.avoidable || options.logAll)) {
       const max = options.maxReportsPerComponent ?? 0;
       const n = (s.printed.get(report.component) ?? 0) + 1;
@@ -359,12 +482,348 @@ var RerenderLens = (function (exports) {
       try {
         options.notifier(report);
       } catch (err) {
-        (options.console ?? console).warn("[rerender-lens] notifier threw", err);
+        warnOnce("notifier", `notifier threw: ${String(err)}`);
       }
     }
   }
 
+  // src/overlay.ts
+  var overlay_exports = {};
+  __export(overlay_exports, {
+    clearHighlight: () => clearHighlight,
+    destroyOverlay: () => destroyOverlay,
+    flash: () => flash,
+    highlight: () => highlight
+  });
+  var ROOT_ID = "rerender-lens-overlay";
+  var layer = null;
+  function ensureLayer() {
+    if (typeof document === "undefined" || !document.body) return null;
+    if (layer && layer.root.isConnected) return layer;
+    let root = document.getElementById(ROOT_ID);
+    if (!root) {
+      root = document.createElement("div");
+      root.id = ROOT_ID;
+      root.setAttribute("aria-hidden", "true");
+      Object.assign(root.style, {
+        position: "fixed",
+        inset: "0",
+        pointerEvents: "none",
+        zIndex: "2147483647",
+        overflow: "visible"
+      });
+      document.body.appendChild(root);
+    }
+    layer = { root, sticky: [] };
+    return layer;
+  }
+  function box(rect, color, fill, label) {
+    const b = document.createElement("div");
+    Object.assign(b.style, {
+      position: "absolute",
+      left: `${rect.left}px`,
+      top: `${rect.top}px`,
+      width: `${Math.max(rect.width, 2)}px`,
+      height: `${Math.max(rect.height, 2)}px`,
+      boxSizing: "border-box",
+      border: `2px solid ${color}`,
+      background: fill,
+      borderRadius: "2px"
+    });
+    if (label) {
+      const tag = document.createElement("span");
+      tag.textContent = label;
+      Object.assign(tag.style, {
+        position: "absolute",
+        left: "-2px",
+        top: rect.top > 20 ? "-20px" : "100%",
+        font: "11px/16px system-ui, sans-serif",
+        color: "#fff",
+        background: color,
+        padding: "1px 5px",
+        borderRadius: "2px",
+        whiteSpace: "nowrap"
+      });
+      b.appendChild(tag);
+    }
+    return b;
+  }
+  function highlight(target) {
+    const l = ensureLayer();
+    if (!l) return;
+    for (const s of l.sticky) s.remove();
+    l.sticky = [];
+    if (!target) return;
+    const frag = document.createDocumentFragment();
+    for (const rect of measure(target.nodes)) {
+      const b = box(rect, "#1a73e8", "rgba(26, 115, 232, 0.12)", target.label);
+      frag.appendChild(b);
+      l.sticky.push(b);
+    }
+    l.root.appendChild(frag);
+  }
+  var MAX_BOXES = 100;
+  function measure(nodes) {
+    const rects = [];
+    for (const node of nodes) {
+      if (rects.length >= MAX_BOXES) break;
+      const rect = node.getBoundingClientRect();
+      if (rect.width === 0 && rect.height === 0) continue;
+      rects.push(rect);
+    }
+    return rects;
+  }
+  function clearHighlight() {
+    highlight(null);
+  }
+  function flash(target, duration = 500) {
+    const l = ensureLayer();
+    if (!l) return;
+    const frag = document.createDocumentFragment();
+    const boxes = [];
+    for (const rect of measure(target.nodes)) {
+      const b = box(rect, "#d93025", "rgba(217, 48, 37, 0.15)");
+      b.style.transition = `opacity ${duration}ms ease-out`;
+      frag.appendChild(b);
+      boxes.push(b);
+    }
+    if (!boxes.length) return;
+    l.root.appendChild(frag);
+    requestAnimationFrame(() => {
+      for (const b of boxes) b.style.opacity = "0";
+    });
+    setTimeout(() => {
+      for (const b of boxes) b.remove();
+    }, duration + 50);
+  }
+  function destroyOverlay() {
+    if (layer) layer.root.remove();
+    layer = null;
+  }
+
+  // vendor-rerender-lens.core.js
+  var parts = globalThis.__RERENDER_LENS_PARTS__ = globalThis.__RERENDER_LENS_PARTS__ || {};
+  parts["types"] = types_exports;
+  parts["version"] = version_exports;
+  parts["diff"] = diff_exports;
+  parts["report"] = report_exports;
+  parts["state"] = state_exports;
+  parts["overlay"] = overlay_exports;
+})();
+
+;
+/* rerender-lens 0.5.0 — rerender-lens.engine.js: fiber, tracker, hookNames. Built by scripts/build-vendor.mjs; do not edit. */
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // rerender-lens-part:diff
+  var require_diff = __commonJS({
+    "rerender-lens-part:diff"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["diff"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["diff"];
+    }
+  });
+
+  // rerender-lens-part:report
+  var require_report = __commonJS({
+    "rerender-lens-part:report"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["report"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["report"];
+    }
+  });
+
+  // rerender-lens-part:state
+  var require_state = __commonJS({
+    "rerender-lens-part:state"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["state"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["state"];
+    }
+  });
+
+  // rerender-lens-part:types
+  var require_types = __commonJS({
+    "rerender-lens-part:types"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["types"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["types"];
+    }
+  });
+
+  // src/fiber.ts
+  var fiber_exports = {};
+  __export(fiber_exports, {
+    COMMIT_TIME_BUDGET_MS: () => COMMIT_TIME_BUDGET_MS,
+    MAX_REPORTS_PER_COMMIT: () => MAX_REPORTS_PER_COMMIT,
+    attach: () => attach,
+    durationsOf: () => durationsOf,
+    ensureDevtoolsHook: () => ensureDevtoolsHook,
+    fiberById: () => fiberById,
+    fiberForNode: () => fiberForNode,
+    fiberName: () => fiberName,
+    fiberType: () => fiberType,
+    findProvider: () => findProvider,
+    getDispatcherRef: () => getDispatcherRef,
+    getRenderers: () => getRenderers,
+    hostNodesOf: () => hostNodesOf,
+    instanceIdOf: () => instanceIdOf,
+    isCompiledFiber: () => isCompiledFiber,
+    isMemoizedFiber: () => isMemoizedFiber,
+    isProductionReact: () => isProductionReact,
+    nearestComponent: () => nearestComponent,
+    onCommit: () => onCommit,
+    parseStackLocation: () => parseStackLocation,
+    priorityLabel: () => priorityLabel,
+    snapshotContexts: () => snapshotContexts,
+    snapshotHooks: () => snapshotHooks,
+    sourceOf: () => sourceOf
+  });
+  var import_diff = __toESM(require_diff(), 1);
+  var import_report = __toESM(require_report(), 1);
+  var import_state2 = __toESM(require_state(), 1);
+
+  // src/tracker.ts
+  var tracker_exports = {};
+  __export(tracker_exports, {
+    configure: () => configure,
+    disable: () => disable,
+    getDisplayName: () => getDisplayName,
+    init: () => init,
+    isEnabled: () => isEnabled,
+    shouldTrack: () => shouldTrack,
+    track: () => track
+  });
+  var import_types = __toESM(require_types(), 1);
+  var import_state = __toESM(require_state(), 1);
+  var MEMO = /* @__PURE__ */ Symbol.for("react.memo");
+  var FORWARD_REF = /* @__PURE__ */ Symbol.for("react.forward_ref");
+  var isMemo = (t) => typeof t === "object" && t !== null && t.$$typeof === MEMO;
+  var isForwardRef = (t) => typeof t === "object" && t !== null && t.$$typeof === FORWARD_REF;
+  var isClass = (t) => typeof t === "function" && !!t.prototype?.isReactComponent;
+  var isPureClass = (t) => isClass(t) && !!t.prototype.isPureReactComponent;
+  var isComponentLike = (t) => typeof t === "function" || isMemo(t) || isForwardRef(t);
+  function getDisplayName(type) {
+    if (typeof type === "string") return type;
+    if (isMemo(type)) return type.displayName ?? getDisplayName(type.type);
+    if (isForwardRef(type)) return type.displayName ?? getDisplayName(type.render);
+    if (typeof type === "function") {
+      const t = type;
+      return t.displayName ?? (t.name || "Anonymous");
+    }
+    return "Anonymous";
+  }
+  function hasMarker(type) {
+    if (type === null || typeof type !== "function" && typeof type !== "object") return false;
+    if (type[import_types.MARKER] === true) return true;
+    if (isMemo(type)) return hasMarker(type.type);
+    if (isForwardRef(type)) return hasMarker(type.render);
+    return false;
+  }
+  function matches(m, name) {
+    if (typeof m === "string") return m === name;
+    if (m instanceof RegExp) return m.test(name);
+    return m(name);
+  }
+  function shouldTrack(type, o) {
+    if (!isComponentLike(type)) return false;
+    const name = getDisplayName(type);
+    if (o.exclude?.some((m) => matches(m, name))) return false;
+    if (hasMarker(type)) return true;
+    if (o.include?.some((m) => matches(m, name))) return true;
+    if (o.trackAllComponents) return true;
+    if (o.trackAllMemoized) return isMemo(type) || isPureClass(type);
+    return false;
+  }
+  function init(options = {}) {
+    const s = (0, import_state.getState)();
+    s.options = { ...options };
+    s.printed.clear();
+    if (!s.enabled) {
+      s.detach = attach();
+      s.enabled = true;
+    }
+    return disable;
+  }
+  function configure(options) {
+    const s = (0, import_state.getState)();
+    s.options = { ...s.options, ...options };
+  }
+  function disable() {
+    const s = (0, import_state.getState)();
+    if (!s.enabled) return;
+    s.detach?.();
+    s.detach = null;
+    s.enabled = false;
+  }
+  function isEnabled() {
+    return (0, import_state.getState)().enabled;
+  }
+  function track(component, name) {
+    const t = component;
+    t[import_types.MARKER] = true;
+    if (name) t.displayName = name;
+    return component;
+  }
+
   // src/hookNames.ts
+  var hookNames_exports = {};
+  __export(hookNames_exports, {
+    HOOK_NODE_COUNT: () => NODE_COUNT,
+    clearHookNameCache: () => clearHookNameCache,
+    customHooksFromStack: () => customHooksFromStack,
+    resolveHookNames: () => resolveHookNames
+  });
+  var NODE_COUNT = {
+    useState: 1,
+    useReducer: 1,
+    useRef: 1,
+    useMemo: 1,
+    useCallback: 1,
+    useEffect: 1,
+    useLayoutEffect: 1,
+    useInsertionEffect: 1,
+    useImperativeHandle: 1,
+    useSyncExternalStore: 2,
+    useTransition: 2,
+    useDeferredValue: 1,
+    useId: 1,
+    useOptimistic: 1,
+    useActionState: 3,
+    useFormState: 3,
+    useEffectEvent: 1,
+    useCacheRefresh: 1
+  };
+  var BUILTIN_HOOKS = /* @__PURE__ */ new Set([...Object.keys(NODE_COUNT), "useContext", "useDebugValue", "use"]);
   var noop = () => {
   };
   function customHooksFromStack(stack, componentName, marker) {
@@ -379,7 +838,7 @@ var RerenderLens = (function (exports) {
         continue;
       }
       if (name === componentName || name.endsWith("." + componentName)) break;
-      if (/^use[A-Z0-9_]/.test(name)) names.push(name);
+      if (/^use[A-Z0-9_]/.test(name) && !BUILTIN_HOOKS.has(name)) names.push(name);
       if (names.length > 8) break;
     }
     return names;
@@ -528,6 +987,8 @@ var RerenderLens = (function (exports) {
     }
     return result.byNode;
   }
+  function clearHookNameCache() {
+  }
 
   // src/fiber.ts
   var FunctionComponent = 0;
@@ -616,10 +1077,10 @@ var RerenderLens = (function (exports) {
       try {
         onCommit(root, priorityLabel(priority));
       } catch (err) {
-        warnOnce("commit", `failed to inspect a commit: ${String(err)}`);
+        (0, import_state2.warnOnce)("commit", `failed to inspect a commit: ${String(err)}`);
       } finally {
         const spent = nowMs() - started;
-        const s = getState();
+        const s = (0, import_state2.getState)();
         s.overheadMs += spent;
         if (spent > s.maxCommitMs) s.maxCommitMs = spent;
       }
@@ -628,7 +1089,7 @@ var RerenderLens = (function (exports) {
     hook.onCommitFiberRoot = patched;
     const previousSchedule = hook.onScheduleFiberRoot;
     const patchedSchedule = function(id, root, children) {
-      getState().scheduled++;
+      (0, import_state2.getState)().scheduled++;
       if (typeof previousSchedule === "function") return previousSchedule.call(this, id, root, children);
     };
     hook.onScheduleFiberRoot = patchedSchedule;
@@ -679,6 +1140,11 @@ var RerenderLens = (function (exports) {
     }
     return false;
   }
+  function isCompiledFiber(fiber) {
+    if (fiber.tag === ClassComponent) return false;
+    const cache2 = fiber.updateQueue?.memoCache;
+    return !!cache2 && Array.isArray(cache2.data);
+  }
   function durationsOf(fiber) {
     if (typeof fiber.actualDuration !== "number") return null;
     const tree = fiber.actualDuration;
@@ -702,11 +1168,14 @@ var RerenderLens = (function (exports) {
   var ids = /* @__PURE__ */ new WeakMap();
   var fibersById = /* @__PURE__ */ new Map();
   var hasWeakRef = typeof WeakRef === "function";
-  function remember2(id, fiber) {
+  var pruneAt = 5e3;
+  function remember(id, fiber) {
     if (!hasWeakRef) return;
+    if (fibersById.get(id)?.deref() === fiber) return;
     fibersById.set(id, new WeakRef(fiber));
-    if (fibersById.size > 5e3) {
+    if (fibersById.size > pruneAt) {
       for (const [k, ref] of fibersById) if (!ref.deref()) fibersById.delete(k);
+      pruneAt = Math.max(5e3, fibersById.size * 2);
     }
   }
   function instanceIdOf(fiber) {
@@ -723,13 +1192,13 @@ var RerenderLens = (function (exports) {
     const existing = instanceIdOf(fiber);
     if (existing !== void 0) {
       ids.set(fiber, existing);
-      remember2(existing, fiber);
+      remember(existing, fiber);
       return existing;
     }
-    const s = getState();
+    const s = (0, import_state2.getState)();
     const id = s.nextInstanceId++;
     ids.set(fiber, id);
-    remember2(id, fiber);
+    remember(id, fiber);
     return id;
   }
   function hostNodesOf(fiber, limit = 50) {
@@ -761,7 +1230,7 @@ var RerenderLens = (function (exports) {
   }
   var INTERNAL_FRAME = /react-dom|react_jsx|jsx-(dev-)?runtime|\/react\/|node_modules\/react|react-stack-bottom-frame|react_stack_bottom_frame|scheduler/;
   function parseStackLocation(stack) {
-    for (const line of stack.split("\n")) {
+    for (const line of stack.split("\n", 24)) {
       const m = /(?:at\s+(?:.*?\s+)?\(?|@)?((?:https?|file|webpack|vite|blob):[^\s()]+?):(\d+):(\d+)\)?\s*$/.exec(line.trim());
       if (!m || !m[1] || INTERNAL_FRAME.test(m[1])) continue;
       return { fileName: m[1], lineNumber: Number(m[2]), columnNumber: Number(m[3]) };
@@ -777,9 +1246,16 @@ var RerenderLens = (function (exports) {
       return out;
     }
     const st = fiber._debugStack;
-    const text = typeof st === "string" ? st : st && typeof st.stack === "string" ? st.stack : null;
-    return text ? parseStackLocation(text) : void 0;
+    if (st && typeof st === "object") {
+      if (sourceCache.has(st)) return sourceCache.get(st);
+      const text = typeof st.stack === "string" ? st.stack : null;
+      const out = text ? parseStackLocation(text) : void 0;
+      sourceCache.set(st, out);
+      return out;
+    }
+    return typeof st === "string" ? parseStackLocation(st) : void 0;
   }
+  var sourceCache = /* @__PURE__ */ new WeakMap();
   function bumpCount(fiber) {
     const prev = counts.get(fiber) ?? (fiber.alternate ? counts.get(fiber.alternate) : void 0) ?? 0;
     const n = prev + 1;
@@ -803,7 +1279,7 @@ var RerenderLens = (function (exports) {
   }
   var isStateNode = (n) => !!n.queue && typeof n.queue.lastRenderedReducer === "function";
   var isStoreNode = (n) => !!n.queue && typeof n.queue.getSnapshot === "function";
-  function hookLabel2(node) {
+  function hookLabel(node) {
     if (isStoreNode(node)) return "useSyncExternalStore";
     if (isStateNode(node)) {
       const r = node.queue.lastRenderedReducer;
@@ -828,7 +1304,7 @@ var RerenderLens = (function (exports) {
     let i = 0;
     for (let n = first; n; n = n.next, i++) {
       if (!isStateNode(n) && !isStoreNode(n)) continue;
-      const hook = labels?.[i] ?? hookLabel2(n);
+      const hook = labels?.[i] ?? hookLabel(n);
       out.push({ path: `${hook}#${i}`, hook, index: i, value: n.memoizedState });
     }
     return out;
@@ -847,13 +1323,14 @@ var RerenderLens = (function (exports) {
     const labels = hookLabelsFor(fiber, b);
     let i = 0;
     while (a && b) {
-      if ((isStateNode(b) || isStoreNode(b)) && !Object.is(a.memoizedState, b.memoizedState)) {
-        const hook = labels?.[i] ?? hookLabel2(b);
+      const deferred = labels?.[i] === "useDeferredValue";
+      if ((deferred || isStateNode(b) || isStoreNode(b)) && !Object.is(a.memoizedState, b.memoizedState)) {
+        const hook = labels?.[i] ?? hookLabel(b);
         out.push({
           path: `${hook}#${i}`,
           hook,
           index: i,
-          kind: classify(a.memoizedState, b.memoizedState),
+          kind: (0, import_diff.classify)(a.memoizedState, b.memoizedState),
           prev: a.memoizedState,
           next: b.memoizedState
         });
@@ -875,12 +1352,16 @@ var RerenderLens = (function (exports) {
     }
     return null;
   }
-  var isPlainObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
+  var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
   function diffContexts(fiber, alt) {
     const out = [];
     let a = alt.dependencies?.firstContext ?? null;
     let b = fiber.dependencies?.firstContext ?? null;
     let i = 0;
+    if (b && !("memoizedValue" in b)) {
+      (0, import_state2.warnOnce)("contextValues", "this React does not record context values on the fiber (React < 18): context changes are reported as plain parent re-renders.");
+      return out;
+    }
     while (a && b) {
       if (a.context === b.context && !Object.is(a.memoizedValue, b.memoizedValue)) {
         const name = b.context.displayName ?? "Context";
@@ -888,7 +1369,7 @@ var RerenderLens = (function (exports) {
           path: `useContext(${name})`,
           hook: "useContext",
           index: i,
-          kind: classify(a.memoizedValue, b.memoizedValue),
+          kind: (0, import_diff.classify)(a.memoizedValue, b.memoizedValue),
           prev: a.memoizedValue,
           next: b.memoizedValue
         };
@@ -897,7 +1378,7 @@ var RerenderLens = (function (exports) {
           const path = componentPath(provider);
           change.provider = { component: path[path.length - 1] ?? null, path };
         }
-        if (isPlainObject2(a.memoizedValue) && isPlainObject2(b.memoizedValue)) {
+        if (isPlainObject(a.memoizedValue) && isPlainObject(b.memoizedValue)) {
           const prev = a.memoizedValue;
           const next = b.memoizedValue;
           const keys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)]);
@@ -912,16 +1393,34 @@ var RerenderLens = (function (exports) {
     }
     return out;
   }
-  var isGenuine2 = (c) => c.kind === "different" || c.kind === "added" || c.kind === "removed";
+  var isGenuine = (c) => c.kind === "different" || c.kind === "added" || c.kind === "removed";
+  var isRefObject = (v) => {
+    if (typeof v !== "object" || v === null) return false;
+    const keys = Object.keys(v);
+    return keys.length === 1 && keys[0] === "current";
+  };
+  function diffProps(prev, next) {
+    if (prev === next) return [];
+    const pr = prev.ref;
+    const nr = next.ref;
+    if (pr !== nr && isRefObject(pr) && isRefObject(nr)) {
+      const { ref: _p, ...restPrev } = prev;
+      const { ref: _n, ...restNext } = next;
+      void _p;
+      void _n;
+      return [{ path: "ref", kind: "deep-equal", prev: pr, next: nr }, ...(0, import_diff.diffRecords)(restPrev, restNext)];
+    }
+    return (0, import_diff.diffRecords)(prev, next);
+  }
   function analyze(fiber, alt, trackHooks) {
     const prevProps = alt.memoizedProps ?? {};
     const nextProps = fiber.memoizedProps ?? {};
-    const propChanges = prevProps === nextProps ? [] : diffRecords(prevProps, nextProps);
+    const propChanges = diffProps(prevProps, nextProps);
     let stateChanges = [];
     let hookChanges = [];
     if (fiber.tag === ClassComponent) {
       if (alt.memoizedState !== fiber.memoizedState) {
-        stateChanges = diffRecords(
+        stateChanges = (0, import_diff.diffRecords)(
           alt.memoizedState ?? {},
           fiber.memoizedState ?? {}
         );
@@ -929,11 +1428,11 @@ var RerenderLens = (function (exports) {
     } else if (trackHooks) {
       hookChanges = [...diffHooks(fiber, alt), ...diffContexts(fiber, alt)];
     }
-    const isStateHook = (h) => h.hook !== "useContext" && h.hook !== "useSyncExternalStore";
+    const isStateHook = (h) => h.hook !== "useContext" && h.hook !== "useSyncExternalStore" && h.hook !== "useDeferredValue";
     const causes = [];
-    if (propChanges.some(isGenuine2)) causes.push("props");
-    if (stateChanges.some(isGenuine2) || hookChanges.some((h) => isStateHook(h) && isGenuine2(h))) causes.push("state");
-    if (hookChanges.some((h) => !isStateHook(h) && isGenuine2(h))) causes.push("hooks");
+    if (propChanges.some(isGenuine)) causes.push("props");
+    if (stateChanges.some(isGenuine) || hookChanges.some((h) => isStateHook(h) && isGenuine(h))) causes.push("state");
+    if (hookChanges.some((h) => !isStateHook(h) && isGenuine(h))) causes.push("hooks");
     const trigger = causes.length === 0 ? "parent" : causes.length === 1 ? causes[0] : "mixed";
     return { propChanges, stateChanges, hookChanges, trigger };
   }
@@ -967,8 +1466,28 @@ var RerenderLens = (function (exports) {
   }
   var lastCommit = null;
   var EFFECT_LOOP_WINDOW_MS = 50;
+  var MAX_REPORTS_PER_COMMIT = 200;
+  var COMMIT_TIME_BUDGET_MS = 25;
+  function isDeferredCatchUp(fiber) {
+    const types = fiber._debugHookTypes;
+    if (!types || !types.includes("useDeferredValue") || !fiber.alternate) return false;
+    const first = fiber.memoizedState;
+    if (!isHookList(first)) return false;
+    const labels = hookLabelsFor(fiber, first);
+    if (!labels) return false;
+    let a = fiber.alternate.memoizedState;
+    let b = first;
+    for (let i = 0; a && b; a = a.next, b = b.next, i++) {
+      if (labels[i] === "useDeferredValue" && !Object.is(a.memoizedState, b.memoizedState)) return true;
+    }
+    return false;
+  }
+  function isUnder(fiber, boundaries) {
+    for (let f = fiber.return; f && f.tag !== HostRoot; f = f.return) if (f.tag === SuspenseComponent && boundaries.includes(f)) return true;
+    return false;
+  }
   function onCommit(root, commitPriority) {
-    const s = getState();
+    const s = (0, import_state2.getState)();
     if (!s.enabled) return;
     s.commits++;
     const o = s.options;
@@ -976,7 +1495,7 @@ var RerenderLens = (function (exports) {
     const rendered = [];
     const renderedNames = /* @__PURE__ */ new Set();
     let hot = false;
-    let suspenseResolved = false;
+    let resolvedBoundaries = null;
     const stack = [root.current];
     while (stack.length) {
       const fiber = stack.pop();
@@ -986,7 +1505,7 @@ var RerenderLens = (function (exports) {
         renderedNames.add(fiberName(fiber));
         if (shouldTrack(fiberType(fiber), o)) rendered.push(fiber);
       }
-      if (fiber.tag === SuspenseComponent && alt && alt.memoizedState !== null && fiber.memoizedState === null) suspenseResolved = true;
+      if (fiber.tag === SuspenseComponent && alt && alt.memoizedState !== null && fiber.memoizedState === null) (resolvedBoundaries ?? (resolvedBoundaries = [])).push(fiber);
       if (!alt || fiber.child !== alt.child) {
         for (let c = fiber.child; c; c = c.sibling) stack.push(c);
       }
@@ -997,10 +1516,11 @@ var RerenderLens = (function (exports) {
     const updaters = updatersOf(root);
     let commitCause;
     let afterCommit;
-    if (lastCommit && at - lastCommit.at < EFFECT_LOOP_WINDOW_MS && updaters.some((u) => lastCommit.rendered.has(u))) {
+    const inputDriven = commitPriority === "immediate" || commitPriority === "user-blocking";
+    if (!inputDriven && lastCommit && at - lastCommit.at < EFFECT_LOOP_WINDOW_MS && updaters.some((u) => lastCommit.rendered.has(u)) && !rendered.some(isDeferredCatchUp)) {
       commitCause = "effect-after-commit";
       afterCommit = lastCommit.id;
-    } else if (suspenseResolved) commitCause = "suspense-resolved";
+    } else if (resolvedBoundaries) commitCause = "suspense-resolved";
     if (rendered.length === 0) {
       lastCommit = { id: s.nextCommitId, at, rendered: renderedNames };
       return;
@@ -1009,153 +1529,414 @@ var RerenderLens = (function (exports) {
     lastCommit = { id: commitId, at, rendered: renderedNames };
     const dispatcherRef = o.resolveHookNames ? getDispatcherRef() : null;
     const parentCache = /* @__PURE__ */ new Map();
-    for (const fiber of rendered) {
-      const alt = fiber.alternate;
-      const a = analyze(fiber, alt, trackHooks);
-      const durations = durationsOf(fiber);
-      let hookState = o.includeState !== false && trackHooks ? snapshotHooks(fiber) : void 0;
-      if (dispatcherRef && fiber.tag !== ClassComponent && (a.hookChanges.length || hookState && hookState.length)) {
-        const names = resolveHookNames(fiber, dispatcherRef);
-        if (names.size) {
-          for (const c of a.hookChanges) if (c.hook !== "useContext" && names.has(c.index)) c.custom = names.get(c.index);
-          if (hookState) hookState = hookState.map((h) => names.has(h.index) ? { ...h, custom: names.get(h.index) } : h);
+    const endDiffScope = (0, import_diff.beginDiffScope)();
+    const deadline = at + COMMIT_TIME_BUDGET_MS;
+    try {
+      for (let i = 0; i < rendered.length; i++) {
+        if (i >= MAX_REPORTS_PER_COMMIT || (i & 15) === 15 && nowMs() > deadline) {
+          s.truncated += rendered.length - i;
+          (0, import_state2.warnOnce)("truncated", `a commit rendered ${rendered.length} tracked components; only ${i} were reported (see info().truncated). Narrow \`include\` or turn off includeState.`);
+          break;
+        }
+        const fiber = rendered[i];
+        const alt = fiber.alternate;
+        const a = analyze(fiber, alt, trackHooks);
+        const durations = durationsOf(fiber);
+        let hookState = o.includeState !== false && trackHooks ? snapshotHooks(fiber) : void 0;
+        if (dispatcherRef && fiber.tag !== ClassComponent && (a.hookChanges.length || hookState && hookState.length)) {
+          const names = resolveHookNames(fiber, dispatcherRef);
+          if (names.size) {
+            for (const c of a.hookChanges) if (c.hook !== "useContext" && names.has(c.index)) c.custom = names.get(c.index);
+            if (hookState) hookState = hookState.map((h) => names.has(h.index) ? { ...h, custom: names.get(h.index) } : h);
+          }
         }
+        const report = (0, import_report.buildReport)({
+          component: fiberName(fiber),
+          instanceId: instanceId(fiber),
+          renderCount: bumpCount(fiber),
+          prevProps: alt.memoizedProps ?? {},
+          nextProps: fiber.memoizedProps ?? {},
+          propChanges: a.propChanges,
+          stateChanges: a.stateChanges,
+          hookChanges: a.hookChanges,
+          ...o.includeState !== false ? {
+            hookState,
+            contexts: trackHooks ? snapshotContexts(fiber) : void 0,
+            state: fiber.tag === ClassComponent && fiber.memoizedState && typeof fiber.memoizedState === "object" ? fiber.memoizedState : void 0
+          } : {},
+          updaters,
+          commitCause,
+          afterCommit,
+          key: fiber.key === null || fiber.key === void 0 ? null : String(fiber.key),
+          parent: a.trigger === "parent" ? nearestRenderedAncestor(fiber, parentCache, trackHooks) : null,
+          owner: ownerName(fiber),
+          path: componentPath(fiber),
+          memoized: isMemoizedFiber(fiber),
+          compiled: isCompiledFiber(fiber),
+          classComponent: fiber.tag === ClassComponent,
+          revealed: resolvedBoundaries !== null && a.trigger === "parent" && isUnder(fiber, resolvedBoundaries),
+          selfDuration: durations ? durations.self : void 0,
+          treeDuration: durations ? durations.tree : void 0,
+          commitId,
+          commitPriority,
+          source: sourceOf(fiber)
+        });
+        (0, import_state2.dispatch)(report);
       }
-      const report = buildReport({
-        component: fiberName(fiber),
-        instanceId: instanceId(fiber),
-        renderCount: bumpCount(fiber),
-        prevProps: alt.memoizedProps ?? {},
-        nextProps: fiber.memoizedProps ?? {},
-        propChanges: a.propChanges,
-        stateChanges: a.stateChanges,
-        hookChanges: a.hookChanges,
-        ...o.includeState !== false ? {
-          hookState,
-          contexts: trackHooks ? snapshotContexts(fiber) : void 0,
-          state: fiber.tag === ClassComponent && fiber.memoizedState && typeof fiber.memoizedState === "object" ? fiber.memoizedState : void 0
-        } : {},
-        updaters,
-        commitCause,
-        afterCommit,
-        key: fiber.key === null || fiber.key === void 0 ? null : String(fiber.key),
-        parent: a.trigger === "parent" ? nearestRenderedAncestor(fiber, parentCache, trackHooks) : null,
-        owner: ownerName(fiber),
-        path: componentPath(fiber),
-        memoized: isMemoizedFiber(fiber),
-        selfDuration: durations ? durations.self : void 0,
-        treeDuration: durations ? durations.tree : void 0,
-        commitId,
-        commitPriority,
-        source: sourceOf(fiber)
-      });
-      dispatch(report);
+    } finally {
+      endDiffScope();
     }
   }
 
-  // src/tracker.ts
-  var MEMO = /* @__PURE__ */ Symbol.for("react.memo");
-  var FORWARD_REF = /* @__PURE__ */ Symbol.for("react.forward_ref");
-  var isMemo = (t) => typeof t === "object" && t !== null && t.$$typeof === MEMO;
-  var isForwardRef = (t) => typeof t === "object" && t !== null && t.$$typeof === FORWARD_REF;
-  var isClass = (t) => typeof t === "function" && !!t.prototype?.isReactComponent;
-  var isPureClass = (t) => isClass(t) && !!t.prototype.isPureReactComponent;
-  var isComponentLike = (t) => typeof t === "function" || isMemo(t) || isForwardRef(t);
-  function getDisplayName(type) {
-    if (typeof type === "string") return type;
-    if (isMemo(type)) return type.displayName ?? getDisplayName(type.type);
-    if (isForwardRef(type)) return type.displayName ?? getDisplayName(type.render);
-    if (typeof type === "function") {
-      const t = type;
-      return t.displayName ?? (t.name || "Anonymous");
+  // vendor-rerender-lens.engine.js
+  var parts = globalThis.__RERENDER_LENS_PARTS__ = globalThis.__RERENDER_LENS_PARTS__ || {};
+  parts["fiber"] = fiber_exports;
+  parts["tracker"] = tracker_exports;
+  parts["hookNames"] = hookNames_exports;
+})();
+
+;
+/* rerender-lens 0.5.0 — rerender-lens.js: devtools bridge + notifiers (window.RerenderLens). Built by scripts/build-vendor.mjs; do not edit. */
+"use strict";
+var RerenderLens = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
     }
-    return "Anonymous";
-  }
-  function hasMarker(type) {
-    if (type === null || typeof type !== "function" && typeof type !== "object") return false;
-    if (type[MARKER] === true) return true;
-    if (isMemo(type)) return hasMarker(type.type);
-    if (isForwardRef(type)) return hasMarker(type.render);
-    return false;
-  }
-  function matches(m, name) {
-    if (typeof m === "string") return m === name;
-    if (m instanceof RegExp) return m.test(name);
-    return m(name);
-  }
-  function shouldTrack(type, o) {
-    if (!isComponentLike(type)) return false;
-    const name = getDisplayName(type);
-    if (o.exclude?.some((m) => matches(m, name))) return false;
-    if (hasMarker(type)) return true;
-    if (o.include?.some((m) => matches(m, name))) return true;
-    if (o.trackAllComponents) return true;
-    if (o.trackAllMemoized) return isMemo(type) || isPureClass(type);
-    return false;
-  }
-  function init(options = {}) {
-    const s = getState();
-    s.options = { ...options };
-    s.printed.clear();
-    if (!s.enabled) {
-      s.detach = attach();
-      s.enabled = true;
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // rerender-lens-part:types
+  var require_types = __commonJS({
+    "rerender-lens-part:types"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["types"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["types"];
+    }
+  });
+
+  // rerender-lens-part:tracker
+  var require_tracker = __commonJS({
+    "rerender-lens-part:tracker"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["tracker"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["tracker"];
+    }
+  });
+
+  // rerender-lens-part:fiber
+  var require_fiber = __commonJS({
+    "rerender-lens-part:fiber"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["fiber"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["fiber"];
+    }
+  });
+
+  // rerender-lens-part:diff
+  var require_diff = __commonJS({
+    "rerender-lens-part:diff"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["diff"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["diff"];
+    }
+  });
+
+  // rerender-lens-part:report
+  var require_report = __commonJS({
+    "rerender-lens-part:report"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["report"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["report"];
+    }
+  });
+
+  // rerender-lens-part:state
+  var require_state = __commonJS({
+    "rerender-lens-part:state"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["state"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["state"];
+    }
+  });
+
+  // rerender-lens-part:overlay
+  var require_overlay = __commonJS({
+    "rerender-lens-part:overlay"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["overlay"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["overlay"];
+    }
+  });
+
+  // rerender-lens-part:version
+  var require_version = __commonJS({
+    "rerender-lens-part:version"(exports, module) {
+      var p = globalThis.__RERENDER_LENS_PARTS__;
+      if (!p || !p["version"]) throw new Error("rerender-lens: load vendor/rerender-lens.core.js and vendor/rerender-lens.engine.js before vendor/rerender-lens.js");
+      module.exports = p["version"];
+    }
+  });
+
+  // src/inject.ts
+  var inject_exports = {};
+  __export(inject_exports, {
+    DEVTOOLS_MARKER: () => DEVTOOLS_MARKER,
+    MARKER: () => import_types.MARKER,
+    PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+    VERSION: () => import_version2.VERSION,
+    buildReport: () => import_report.buildReport,
+    classify: () => import_diff4.classify,
+    combineNotifiers: () => combineNotifiers,
+    configure: () => import_tracker2.configure,
+    createCollector: () => createCollector,
+    createDevtoolsNotifier: () => createDevtoolsNotifier,
+    deepEqual: () => import_diff4.deepEqual,
+    diffRecords: () => import_diff4.diffRecords,
+    disable: () => import_tracker2.disable,
+    ensureDevtoolsHook: () => import_fiber2.ensureDevtoolsHook,
+    getDisplayName: () => import_tracker2.getDisplayName,
+    getRenderers: () => import_fiber2.getRenderers,
+    init: () => import_tracker2.init,
+    isEnabled: () => import_tracker2.isEnabled,
+    isProductionReact: () => import_fiber2.isProductionReact,
+    printReport: () => import_report.printReport,
+    serialize: () => serialize,
+    shouldTrack: () => import_tracker2.shouldTrack,
+    summarize: () => import_report.summarize,
+    track: () => import_tracker2.track
+  });
+  var import_types = __toESM(require_types(), 1);
+  var import_tracker2 = __toESM(require_tracker(), 1);
+  var import_fiber2 = __toESM(require_fiber(), 1);
+  var import_diff4 = __toESM(require_diff(), 1);
+  var import_report = __toESM(require_report(), 1);
+
+  // src/fixes.ts
+  var import_diff2 = __toESM(require_diff(), 1);
+
+  // src/causes.ts
+  var import_diff = __toESM(require_diff(), 1);
+  var isAncestorReport = (anc, r) => anc.path.length < r.path.length && r.path[anc.path.length] === anc.component && anc.path.every((p, i) => r.path[i] === p);
+  var bump = (m, key, n = 1) => void m.set(key, (m.get(key) || 0) + n);
+  function indexByComponent(reports) {
+    const index = /* @__PURE__ */ new Map();
+    for (const r of reports) {
+      const list = index.get(r.component);
+      if (list) list.push(r);
+      else index.set(r.component, [r]);
+    }
+    return index;
+  }
+  function rootCauseOf(r, commitReports, index = indexByComponent(commitReports)) {
+    let cur = r;
+    const seen = /* @__PURE__ */ new Set([r]);
+    while (cur.trigger === "parent" && cur.parent) {
+      const parent = cur.parent;
+      const candidates = index.get(parent.name);
+      const p = candidates && candidates.find((x) => isAncestorReport(x, cur));
+      if (!p || seen.has(p)) return { name: parent.name, trigger: parent.trigger, report: null };
+      seen.add(p);
+      cur = p;
+    }
+    return cur === r ? null : { name: cur.component, trigger: cur.trigger, report: cur };
+  }
+  function rootCausesOf(reports) {
+    const roots = /* @__PURE__ */ new Map();
+    const rootByReport = /* @__PURE__ */ new Map();
+    const index = indexByComponent(reports);
+    let avoidable = 0;
+    let wasted = 0;
+    for (const r of reports) {
+      if (!r.avoidable) continue;
+      avoidable++;
+      if (typeof r.selfDuration === "number") wasted += r.selfDuration;
+      const root = rootCauseOf(r, reports, index);
+      const name = root ? root.name : r.parent && r.parent.name || "(unknown)";
+      const trigger = root ? root.trigger : r.parent && r.parent.trigger || "parent";
+      rootByReport.set(r, name);
+      let agg = roots.get(name);
+      if (!agg) {
+        agg = { name, trigger, count: 0, components: /* @__PURE__ */ new Map() };
+        roots.set(name, agg);
+      }
+      agg.count++;
+      bump(agg.components, r.component);
     }
-    return disable;
-  }
-  function configure(options) {
-    const s = getState();
-    s.options = { ...s.options, ...options };
+    return { roots: [...roots.values()].sort((a, b) => b.count - a.count), rootByReport, avoidable, wasted };
   }
-  function disable() {
-    const s = getState();
-    if (!s.enabled) return;
-    s.detach?.();
-    s.detach = null;
-    s.enabled = false;
+  function groupByCommit(reports) {
+    const out = /* @__PURE__ */ new Map();
+    for (const r of reports) {
+      if (typeof r.commitId !== "number" || r.commitId <= 0) continue;
+      const list = out.get(r.commitId);
+      if (list) list.push(r);
+      else out.set(r.commitId, [r]);
+    }
+    return out;
   }
-  function isEnabled() {
-    return getState().enabled;
+  function rankRootCauses(reports) {
+    const byName = /* @__PURE__ */ new Map();
+    for (const commit of groupByCommit(reports).values()) {
+      for (const root of rootCausesOf(commit).roots) {
+        let agg = byName.get(root.name);
+        if (!agg) {
+          agg = { name: root.name, trigger: root.trigger, commits: 0, count: 0, components: /* @__PURE__ */ new Map() };
+          byName.set(root.name, agg);
+        }
+        agg.commits++;
+        agg.count += root.count;
+        for (const [c, n] of root.components) bump(agg.components, c, n);
+      }
+    }
+    return [...byName.values()].sort((a, b) => b.count - a.count || b.commits - a.commits || a.name.localeCompare(b.name));
   }
-  function track(component, name) {
-    const t = component;
-    t[MARKER] = true;
-    if (name) t.displayName = name;
-    return component;
+  var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+  function formatRootCauses(reports, limit = 5) {
+    const ranked = rankRootCauses(reports);
+    const lines = ranked.slice(0, limit).map((root, i) => `${String(i + 1).padStart(2)}. <${root.name}> (${root.trigger}) started ${plural(root.commits, "commit")}, ${plural(root.count, "avoidable re-render")}  (${[...root.components].map(([c, n]) => `<${c}>${n > 1 ? " x" + n : ""}`).join(", ")})`);
+    if (ranked.length > limit) lines.push(`    \u2026 ${ranked.length - limit} more`);
+    return lines.join("\n");
   }
 
   // src/fixes.ts
-  var AVOIDABLE = /* @__PURE__ */ new Set(["deep-equal", "function", "element"]);
+  var MAX_FIX_REPORTS = 50;
   var rootOf = (path) => path.split(/[.[]/)[0] || path;
+  var identifier = (name) => /^[A-Za-z_$][\w$]*$/.test(name) ? name : "value";
+  function shortValue(v, max = 60) {
+    let s;
+    try {
+      s = JSON.stringify(v);
+    } catch {
+      s = String(v);
+    }
+    if (s === void 0) s = String(v);
+    return s.length > max ? s.slice(0, max - 3) + "..." : s;
+  }
   function fixesFor(r) {
     const out = [];
-    const owner = r.owner || r.parent && r.parent.name || "?";
-    const changes = [...r.propChanges, ...r.stateChanges, ...r.hookChanges];
+    const ownerName = r.owner || r.parent && r.parent.name || null;
+    const propChanges = r.propChanges || [];
+    const changes = [...propChanges, ...r.stateChanges || [], ...r.hookChanges || []];
     if (r.avoidable && (changes.length === 0 || r.memoized === false)) {
+      const identical = changes.length === 0;
       out.push({
         kind: "memo",
         owner: r.component,
         target: r.component,
         prop: null,
         label: `Wrap <${r.component}> in React.memo`,
-        detail: changes.length === 0 ? `<${r.component}> re-rendered with identical props because <${r.parent && r.parent.name || "its parent"}> re-rendered.` : `<${r.component}> is not memoized: fixing its props alone will not stop the re-render.`
+        detail: identical ? `<${r.component}> re-rendered with identical props because <${r.parent && r.parent.name || "its parent"}> re-rendered.` : `<${r.component}> is not memoized: fixing its props alone will not stop the re-render.`,
+        snippet: `// ${r.component}
+import { memo } from 'react';
+
+export const ${r.component} = memo(function ${r.component}(props) {
+  // ...
+});
+// class components: extend PureComponent instead`
       });
     }
-    for (const c of r.propChanges) {
-      if (!AVOIDABLE.has(c.kind)) continue;
+    for (const c of propChanges) {
+      if (!import_diff2.AVOIDABLE_KINDS.has(c.kind)) continue;
+      const owner = ownerName || "?";
       const root = rootOf(c.path);
+      const id = identifier(root);
       if (root === "children" && (c.kind === "element" || c.kind === "deep-equal")) {
-        out.push({ kind: "children", owner, target: r.component, prop: "children", label: `memoize children of <${r.component}> in <${owner}>`, detail: `<${owner}> re-creates the children of <${r.component}> on every render.` });
+        out.push({
+          kind: "children",
+          owner,
+          target: r.component,
+          prop: "children",
+          label: `memoize children of <${r.component}> in <${owner}>`,
+          detail: `<${owner}> re-creates the children of <${r.component}> on every render; they have the same types and props each time.`,
+          snippet: `// ${owner}
+import { useMemo } from 'react';
+
+const children = useMemo(() => (
+  <>{/* the same elements */}</>
+), [/* deps */]);
+
+<${r.component}>{children}</${r.component}>
+
+// static children: hoist them to module scope
+const STATIC = <em>hi</em>;`
+        });
       } else if (c.kind === "function") {
-        out.push({ kind: "useCallback", owner, target: r.component, prop: root, label: `useCallback(${root}) in <${owner}>`, detail: `prop "${c.path}" of <${r.component}> is a new function on every render of <${owner}>.` });
+        out.push({
+          kind: "useCallback",
+          owner,
+          target: r.component,
+          prop: root,
+          label: `useCallback(${root}) in <${owner}>`,
+          detail: `prop "${c.path}" of <${r.component}> is a new function on every render of <${owner}>.`,
+          snippet: `// ${owner}
+import { useCallback } from 'react';
+
+const ${id} = useCallback((/* args */) => {
+  // ...
+}, [/* deps */]);
+
+<${r.component} ${root}={${id}} />`
+        });
       } else if (c.kind === "element") {
-        out.push({ kind: "useMemoElement", owner, target: r.component, prop: root, label: `memoize element prop ${root} in <${owner}>`, detail: `prop "${c.path}" of <${r.component}> is a new element with the same type and props on every render of <${owner}>.` });
+        out.push({
+          kind: "useMemoElement",
+          owner,
+          target: r.component,
+          prop: root,
+          label: `memoize element prop ${root} in <${owner}>`,
+          detail: `prop "${c.path}" of <${r.component}> is a new element with the same type and props on every render of <${owner}>.`,
+          snippet: `// ${owner}
+import { useMemo } from 'react';
+
+const ${id} = useMemo(() => ${shortValue(c.next, 40)}, [/* deps */]);
+// or pass it as children from a component that does not re-render`
+        });
       } else {
-        out.push({ kind: "useMemo", owner, target: r.component, prop: root, label: `useMemo(${root}) in <${owner}>`, detail: `prop "${c.path}" of <${r.component}> is a new ${Array.isArray(c.next) ? "array" : "object"} with the same contents on every render of <${owner}>.` });
+        const isArray = Array.isArray(c.next);
+        out.push({
+          kind: "useMemo",
+          owner,
+          target: r.component,
+          prop: root,
+          label: `useMemo(${root}) in <${owner}>`,
+          detail: `prop "${c.path}" of <${r.component}> is a new ${isArray ? "array" : "object"} with the same contents on every render of <${owner}>.`,
+          snippet: `// ${owner}
+import { useMemo } from 'react';
+
+const ${id} = useMemo(() => (${shortValue(c.next, 80)}), [/* deps */]);
+
+// or, when it never changes, hoist it to module scope:
+const ${id.toUpperCase()} = ${shortValue(c.next, 80)};`
+        });
       }
     }
-    for (const c of [...r.stateChanges, ...r.hookChanges]) {
-      const isContext = c.hook === "useContext";
+    for (const c of [...r.stateChanges || [], ...r.hookChanges || []]) {
+      const isContext = c.hook === "useContext" || /^useContext/.test(c.path);
       const ctxName = isContext ? (/useContext\((.*)\)/.exec(c.path) || [])[1] || "Context" : "";
       const providerOwner = isContext && c.provider && c.provider.component ? c.provider.component : null;
       if (isContext && c.kind === "different" && c.changedKeys && typeof c.totalKeys === "number" && c.changedKeys.length > 0 && c.changedKeys.length < c.totalKeys) {
@@ -1165,20 +1946,63 @@ var RerenderLens = (function (exports) {
           target: r.component,
           prop: ctxName,
           label: `split ${ctxName}${providerOwner ? ` in <${providerOwner}>` : ""}: only ${c.changedKeys.join(", ")} changed`,
-          detail: `${c.changedKeys.length} of ${c.totalKeys} keys changed in ${ctxName}, yet every consumer re-rendered.`
+          detail: `${c.changedKeys.map((k) => `"${k}"`).join(", ")} of ${c.totalKeys} keys changed in ${ctxName}, yet every consumer (like <${r.component}>) re-rendered. Consumers that read the other keys re-render for nothing.`,
+          snippet: `// ${providerOwner || "Provider"}
+// one context per independently-changing slice
+const ${identifier(ctxName)}Static = createContext(...);
+const ${identifier(ctxName)}${c.changedKeys.map((k) => k[0].toUpperCase() + k.slice(1)).join("")} = createContext(...);
+
+// or keep one context and let consumers select a slice:
+const ${c.changedKeys[0]} = useContextSelector(${ctxName}, (v) => v.${c.changedKeys[0]});`
         });
         continue;
       }
-      if (!AVOIDABLE.has(c.kind)) continue;
+      if (!import_diff2.AVOIDABLE_KINDS.has(c.kind)) continue;
       if (isContext) {
-        out.push({ kind: "contextValue", owner: providerOwner || `${ctxName}.Provider`, target: r.component, prop: ctxName, label: `memoize the ${ctxName} provider value${providerOwner ? ` in <${providerOwner}>` : ""}`, detail: `${ctxName} produced a new value that is deep-equal to the previous one.` });
+        out.push({
+          kind: "contextValue",
+          owner: providerOwner || `${ctxName}.Provider`,
+          target: r.component,
+          prop: ctxName,
+          label: `memoize the ${ctxName} provider value${providerOwner ? ` in <${providerOwner}>` : ""}`,
+          detail: `<${r.component}> re-rendered because ${ctxName} produced a new value that is deep-equal to the previous one${providerOwner ? ` (Provider rendered by <${providerOwner}>)` : ""}.`,
+          snippet: `// ${providerOwner || `where <${ctxName}.Provider> is rendered`}
+const value = useMemo(() => ({ /* ... */ }), [/* deps */]);
+<${ctxName}.Provider value={value}>`
+        });
       } else if (c.hook === "useSyncExternalStore") {
         const chain = c.custom || [];
         const redux = chain.some((n) => /^use(App)?Selector$/.test(n));
         const zustand = !redux && chain.some((n) => /^use[A-Z]\w*Store$/.test(n) || n === "useStore" || n === "useBoundStore");
-        out.push({ kind: "storeSnapshot", owner: r.component, target: r.component, prop: c.path, label: redux ? `memoize the selector in <${r.component}>` : zustand ? `useShallow in <${r.component}>` : `stable getSnapshot in <${r.component}>`, detail: storeAdvice(c.custom) });
+        const via = chain.length ? ` via ${chain.join(" \u203A ")}` : "";
+        out.push({
+          kind: "storeSnapshot",
+          owner: r.component,
+          target: r.component,
+          prop: c.path,
+          label: redux ? `memoize the selector in <${r.component}>` : zustand ? `useShallow in <${r.component}>` : `stable getSnapshot in <${r.component}>`,
+          detail: redux ? `the selector${via} returns a new object on every call, so the component re-renders on every store change.` : zustand ? `the store selector${via} returns a new object on every call, so the component re-renders on every store change.` : `${c.path}${via} returned a new reference with the same contents; getSnapshot must return a cached value.`,
+          snippet: redux ? `// ${r.component}
+import { shallowEqual } from 'react-redux';
+const slice = useSelector(selectSlice, shallowEqual);
+// or memoize: const selectSlice = createSelector([selectA, selectB], (a, b) => ({ a, b }));` : zustand ? `// ${r.component}
+import { useShallow } from 'zustand/react/shallow';
+const { a, b } = useStore(useShallow((s) => ({ a: s.a, b: s.b })));
+// or select a primitive: const a = useStore((s) => s.a);` : `// ${r.component}
+// getSnapshot must return the same reference while the data is unchanged
+const snapshot = useSyncExternalStore(subscribe, store.getSnapshot /* cached */);`
+        });
       } else {
-        out.push({ kind: "bailout", owner: r.component, target: r.component, prop: c.path, label: `bail out before setting ${c.path} in <${r.component}>`, detail: `${c.path} was set to a value deep-equal to the current one (new reference).` });
+        out.push({
+          kind: "bailout",
+          owner: r.component,
+          target: r.component,
+          prop: c.path,
+          label: `bail out before setting ${c.path} in <${r.component}>`,
+          detail: `${c.path} was set to a value deep-equal to the current one (new reference).`,
+          snippet: `// ${r.component}
+setState((prev) => (deepEqual(prev, next) ? prev : next));`
+        });
       }
     }
     return out;
@@ -1192,11 +2016,12 @@ var RerenderLens = (function (exports) {
         const key = fixKey(f);
         let agg = byKey.get(key);
         if (!agg) {
-          agg = { ...f, key, count: 0, components: {} };
+          agg = { ...f, key, count: 0, components: {}, reports: [] };
           byKey.set(key, agg);
         }
         agg.count++;
         agg.components[r.component] = (agg.components[r.component] || 0) + 1;
+        if (agg.reports.length < MAX_FIX_REPORTS) agg.reports.push(r);
       }
     }
     return [...byKey.values()].sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
@@ -1206,6 +2031,8 @@ var RerenderLens = (function (exports) {
     if (!ranked.length) return "No avoidable re-renders.";
     const lines = ranked.slice(0, limit).map((f, i) => `${String(i + 1).padStart(2)}. ${f.label}  (removes ${f.count}: ${Object.entries(f.components).map(([c, n]) => `<${c}>${n > 1 ? " x" + n : ""}`).join(", ")})`);
     if (ranked.length > limit) lines.push(`    \u2026 ${ranked.length - limit} more`);
+    const roots = formatRootCauses(reports, 5);
+    if (roots) lines.push("", "Root causes:", roots);
     return lines.join("\n");
   }
 
@@ -1242,25 +2069,25 @@ var RerenderLens = (function (exports) {
 
   // src/budget.ts
   function avoidableCounts(reports) {
-    const counts2 = {};
-    for (const r of reports) if (r.avoidable) counts2[r.component] = (counts2[r.component] || 0) + 1;
-    return counts2;
+    const counts = {};
+    for (const r of reports) if (r.avoidable) counts[r.component] = (counts[r.component] || 0) + 1;
+    return counts;
   }
   function checkBudget(reports, budget) {
     const b = typeof budget === "number" ? { "*": budget } : budget;
     const fallback = typeof b["*"] === "number" ? b["*"] : 0;
-    const counts2 = avoidableCounts(reports);
+    const counts = avoidableCounts(reports);
     const violations = [];
     const slack = [];
-    const names = /* @__PURE__ */ new Set([...Object.keys(counts2), ...Object.keys(b).filter((k) => k !== "*")]);
+    const names = /* @__PURE__ */ new Set([...Object.keys(counts), ...Object.keys(b).filter((k) => k !== "*")]);
     for (const component of names) {
       const allowed = typeof b[component] === "number" ? b[component] : fallback;
-      const avoidable = counts2[component] || 0;
+      const avoidable = counts[component] || 0;
       if (avoidable > allowed) violations.push({ component, avoidable, allowed });
       else if (avoidable < allowed) slack.push({ component, avoidable, allowed });
     }
     violations.sort((x, y) => y.avoidable - y.allowed - (x.avoidable - x.allowed));
-    return { ok: violations.length === 0, violations, slack, counts: counts2 };
+    return { ok: violations.length === 0, violations, slack, counts };
   }
   function assertWithinBudget(reports, budget) {
     const result = checkBudget(reports, budget);
@@ -1310,101 +2137,19 @@ ${formatFixes(reports)}`);
     };
   }
 
-  // src/overlay.ts
-  var ROOT_ID = "rerender-lens-overlay";
-  var layer = null;
-  function ensureLayer() {
-    if (typeof document === "undefined" || !document.body) return null;
-    if (layer && layer.root.isConnected) return layer;
-    let root = document.getElementById(ROOT_ID);
-    if (!root) {
-      root = document.createElement("div");
-      root.id = ROOT_ID;
-      root.setAttribute("aria-hidden", "true");
-      Object.assign(root.style, {
-        position: "fixed",
-        inset: "0",
-        pointerEvents: "none",
-        zIndex: "2147483647",
-        overflow: "visible"
-      });
-      document.body.appendChild(root);
-    }
-    layer = { root, sticky: [] };
-    return layer;
-  }
-  function box(rect, color, fill, label) {
-    const b = document.createElement("div");
-    Object.assign(b.style, {
-      position: "absolute",
-      left: `${rect.left}px`,
-      top: `${rect.top}px`,
-      width: `${Math.max(rect.width, 2)}px`,
-      height: `${Math.max(rect.height, 2)}px`,
-      boxSizing: "border-box",
-      border: `2px solid ${color}`,
-      background: fill,
-      borderRadius: "2px"
-    });
-    if (label) {
-      const tag = document.createElement("span");
-      tag.textContent = label;
-      Object.assign(tag.style, {
-        position: "absolute",
-        left: "-2px",
-        top: rect.top > 20 ? "-20px" : "100%",
-        font: "11px/16px system-ui, sans-serif",
-        color: "#fff",
-        background: color,
-        padding: "1px 5px",
-        borderRadius: "2px",
-        whiteSpace: "nowrap"
-      });
-      b.appendChild(tag);
-    }
-    return b;
-  }
-  function highlight(target) {
-    const l = ensureLayer();
-    if (!l) return;
-    for (const s of l.sticky) s.remove();
-    l.sticky = [];
-    if (!target) return;
-    for (const node of target.nodes) {
-      const rect = node.getBoundingClientRect();
-      if (rect.width === 0 && rect.height === 0) continue;
-      const b = box(rect, "#1a73e8", "rgba(26, 115, 232, 0.12)", target.label);
-      l.root.appendChild(b);
-      l.sticky.push(b);
-    }
-  }
-  function clearHighlight() {
-    highlight(null);
-  }
-  function flash(target, duration = 500) {
-    const l = ensureLayer();
-    if (!l) return;
-    for (const node of target.nodes) {
-      const rect = node.getBoundingClientRect();
-      if (rect.width === 0 && rect.height === 0) continue;
-      const b = box(rect, "#d93025", "rgba(217, 48, 37, 0.15)");
-      b.style.transition = `opacity ${duration}ms ease-out`;
-      l.root.appendChild(b);
-      requestAnimationFrame(() => {
-        b.style.opacity = "0";
-      });
-      setTimeout(() => b.remove(), duration + 50);
-    }
-  }
-
-  // src/version.ts
-  var VERSION = "0.3.0" ;
-
   // src/devtools.ts
+  var import_diff3 = __toESM(require_diff(), 1);
+  var import_tracker = __toESM(require_tracker(), 1);
+  var import_state = __toESM(require_state(), 1);
+  var import_fiber = __toESM(require_fiber(), 1);
+  var import_overlay = __toESM(require_overlay(), 1);
+  var import_version = __toESM(require_version(), 1);
   var DEVTOOLS_MARKER = "__rerenderLens";
   var PROTOCOL_VERSION = 2;
   var DEFAULT_CHANNEL = "rerender-lens";
-  function serialize(value, maxDepth = 6, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+  var SERIALIZE_MAX_ENTRIES = 100;
+  var SERIALIZE_MAX_NODES = 2e4;
+  function serialize(value, maxDepth = 4, seen = /* @__PURE__ */ new WeakSet(), depth = 0, budget = { nodes: SERIALIZE_MAX_NODES }) {
     if (value === null || value === void 0) return value;
     const t = typeof value;
     if (t === "string" || t === "boolean") return value;
@@ -1415,24 +2160,56 @@ ${formatFixes(reports)}`);
     const obj = value;
     if (seen.has(obj)) return "[Circular]";
     if (depth >= maxDepth) return "[\u2026]";
+    if (--budget.nodes < 0) return "[\u2026]";
+    const next = (v) => serialize(v, maxDepth, seen, depth + 1, budget);
     seen.add(obj);
     try {
-      if (isReactElement(obj)) {
-        const out2 = { $type: "element", name: getDisplayName(obj.type) };
+      if ((0, import_diff3.isReactElement)(obj)) {
+        const out2 = { $type: "element", name: (0, import_tracker.getDisplayName)(obj.type) };
         if (obj.key !== null && obj.key !== void 0) out2.key = String(obj.key);
-        out2.props = serialize(obj.props, maxDepth, seen, depth + 1);
+        out2.props = next(obj.props);
         return out2;
       }
       if (obj instanceof Date) return { $type: "Date", value: obj.toISOString() };
       if (obj instanceof RegExp) return { $type: "RegExp", value: String(obj) };
+      if (ArrayBuffer.isView(obj) || obj instanceof ArrayBuffer) {
+        const bin = obj;
+        return { $type: bin.constructor?.name || "ArrayBuffer", length: typeof bin.length === "number" ? bin.length : bin.byteLength };
+      }
+      if (obj instanceof Promise) return "[Promise]";
+      if (typeof Node !== "undefined" && obj instanceof Node) return typeof Element !== "undefined" && obj instanceof Element ? `<${obj.tagName.toLowerCase()}>` : `[${obj.nodeName}]`;
+      if (obj === globalThis) return "[Window]";
       if (obj instanceof Map) {
-        return { $type: "Map", entries: [...obj].map(([k, v]) => [serialize(k, maxDepth, seen, depth + 1), serialize(v, maxDepth, seen, depth + 1)]) };
+        const entries = [];
+        for (const [k, v] of obj) {
+          if (entries.length >= SERIALIZE_MAX_ENTRIES) {
+            entries.push(["\u2026", `+${obj.size - SERIALIZE_MAX_ENTRIES} more`]);
+            break;
+          }
+          entries.push([next(k), next(v)]);
+        }
+        return { $type: "Map", entries };
+      }
+      if (obj instanceof Set) {
+        const values = [];
+        for (const v of obj) {
+          if (values.length >= SERIALIZE_MAX_ENTRIES) {
+            values.push(`\u2026+${obj.size - SERIALIZE_MAX_ENTRIES} more`);
+            break;
+          }
+          values.push(next(v));
+        }
+        return { $type: "Set", values };
+      }
+      if (Array.isArray(obj)) {
+        const out2 = obj.slice(0, SERIALIZE_MAX_ENTRIES).map(next);
+        if (obj.length > SERIALIZE_MAX_ENTRIES) out2.push(`\u2026+${obj.length - SERIALIZE_MAX_ENTRIES} more`);
+        return out2;
       }
-      if (obj instanceof Set) return { $type: "Set", values: [...obj].map((v) => serialize(v, maxDepth, seen, depth + 1)) };
-      if (Array.isArray(obj)) return obj.map((v) => serialize(v, maxDepth, seen, depth + 1));
-      if (typeof Element !== "undefined" && obj instanceof Element) return `<${obj.tagName.toLowerCase()}>`;
       const out = {};
-      for (const k of Object.keys(obj)) out[k] = serialize(obj[k], maxDepth, seen, depth + 1);
+      const keys = Object.keys(obj);
+      for (const k of keys.slice(0, SERIALIZE_MAX_ENTRIES)) out[k] = next(obj[k]);
+      if (keys.length > SERIALIZE_MAX_ENTRIES) out["\u2026"] = `+${keys.length - SERIALIZE_MAX_ENTRIES} more`;
       const proto = Object.getPrototypeOf(obj);
       if (proto && proto !== Object.prototype && proto.constructor?.name) out.$type = proto.constructor.name;
       return out;
@@ -1472,33 +2249,42 @@ ${formatFixes(reports)}`);
   }
   function createDevtoolsNotifier(options = {}) {
     const bufferSize = options.bufferSize ?? 300;
-    const maxDepth = options.maxDepth ?? 6;
+    const maxDepth = options.maxDepth ?? 4;
     const target = options.target ?? (typeof window !== "undefined" ? window : void 0);
     const buffer = [];
     let seq = 0;
     let flashOn = options.flashAvoidable ?? false;
+    let live = !target || typeof target.addEventListener !== "function";
+    if (!live) {
+      target.addEventListener("message", (event) => {
+        const data = event.data;
+        if ((event.source === target || !event.source) && data && data.__rerenderLensReady === true) live = true;
+      });
+    }
     const post = (type, payload) => {
-      if (!target) return;
+      if (!target || type === "report" && !live) return;
       const msg = { [DEVTOOLS_MARKER]: true, version: PROTOCOL_VERSION, type, payload };
       target.postMessage(msg, "*");
     };
     const source = options.source ?? "page";
     const info = () => ({
       count: buffer.length,
-      library: VERSION,
+      library: import_version.VERSION,
       protocol: PROTOCOL_VERSION,
-      react: getRenderers(),
-      production: isProductionReact(),
-      enabled: isEnabled(),
-      options: serializeOptions(getState().options),
+      react: (0, import_fiber.getRenderers)(),
+      production: (0, import_fiber.isProductionReact)(),
+      enabled: (0, import_tracker.isEnabled)(),
+      options: serializeOptions((0, import_state.getState)().options),
       source,
       injected: typeof window !== "undefined" && typeof window.__RERENDER_LENS_INJECTED__ === "string",
-      scheduled: getState().scheduled,
-      commits: getState().commits,
-      overhead: { totalMs: getState().overheadMs, maxCommitMs: getState().maxCommitMs }
+      scheduled: (0, import_state.getState)().scheduled,
+      commits: (0, import_state.getState)().commits,
+      overhead: { totalMs: (0, import_state.getState)().overheadMs, maxCommitMs: (0, import_state.getState)().maxCommitMs },
+      truncated: (0, import_state.getState)().truncated
     });
     const bridge = {
       replay: () => {
+        live = true;
         post("hello", info());
         for (const e of buffer) post("report", e.payload);
       },
@@ -1510,7 +2296,7 @@ ${formatFixes(reports)}`);
         return buffer.length;
       },
       version: PROTOCOL_VERSION,
-      library: VERSION,
+      library: import_version.VERSION,
       info,
       pull: (since = 0) => {
         const first = buffer[0];
@@ -1519,41 +2305,41 @@ ${formatFixes(reports)}`);
         return { seq, reports, dropped };
       },
       configure: (next) => {
-        configure(deserializeOptions(next ?? {}));
-        return serializeOptions(getState().options);
+        (0, import_tracker.configure)(deserializeOptions(next ?? {}));
+        return serializeOptions((0, import_state.getState)().options);
       },
-      getOptions: () => serializeOptions(getState().options),
+      getOptions: () => serializeOptions((0, import_state.getState)().options),
       highlight: (id) => {
         if (id === null || id === void 0) {
-          clearHighlight();
+          (0, import_overlay.clearHighlight)();
           return true;
         }
-        const fiber = fiberById(id);
+        const fiber = (0, import_fiber.fiberById)(id);
         if (!fiber) {
-          clearHighlight();
+          (0, import_overlay.clearHighlight)();
           return false;
         }
-        const nodes = hostNodesOf(fiber);
-        highlight({ nodes, label: fiberName(fiber) });
+        const nodes = (0, import_fiber.hostNodesOf)(fiber);
+        (0, import_overlay.highlight)({ nodes, label: (0, import_fiber.fiberName)(fiber) });
         return nodes.length > 0;
       },
       flashAvoidable: (on) => {
         flashOn = !!on;
       },
       inspect: (node) => {
-        const comp = nearestComponent(fiberForNode(node));
+        const comp = (0, import_fiber.nearestComponent)((0, import_fiber.fiberForNode)(node));
         if (!comp) return null;
-        const id = instanceIdOf(comp) ?? null;
+        const id = (0, import_fiber.instanceIdOf)(comp) ?? null;
         const path = [];
         let f = comp.return;
         while (f) {
-          if (f.tag === 0 || f.tag === 1 || f.tag === 11 || f.tag === 14 || f.tag === 15) path.unshift(fiberName(f));
+          if (f.tag === 0 || f.tag === 1 || f.tag === 11 || f.tag === 14 || f.tag === 15) path.unshift((0, import_fiber.fiberName)(f));
           f = f.return;
         }
         return {
-          component: fiberName(comp),
+          component: (0, import_fiber.fiberName)(comp),
           instanceId: id,
-          tracked: shouldTrack(fiberType(comp), getState().options),
+          tracked: (0, import_tracker.shouldTrack)((0, import_fiber.fiberType)(comp), (0, import_state.getState)().options),
           path,
           reports: id === null ? [] : buffer.filter((e) => e.instanceId === id).slice(-20).map((e) => e.payload)
         };
@@ -1681,37 +2467,14 @@ ${formatFixes(reports)}`);
       if (buffer.length > bufferSize) buffer.splice(0, buffer.length - bufferSize);
       postAll("report", payload);
       if (flashOn && report.avoidable && report.instanceId) {
-        const fiber = fiberById(report.instanceId);
-        if (fiber) flash({ nodes: hostNodesOf(fiber), label: report.component });
+        const fiber = (0, import_fiber.fiberById)(report.instanceId);
+        if (fiber) (0, import_overlay.flash)({ nodes: (0, import_fiber.hostNodesOf)(fiber), label: report.component });
       }
     };
   }
 
-  exports.DEVTOOLS_MARKER = DEVTOOLS_MARKER;
-  exports.MARKER = MARKER;
-  exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
-  exports.VERSION = VERSION;
-  exports.buildReport = buildReport;
-  exports.classify = classify;
-  exports.combineNotifiers = combineNotifiers;
-  exports.configure = configure;
-  exports.createCollector = createCollector;
-  exports.createDevtoolsNotifier = createDevtoolsNotifier;
-  exports.deepEqual = deepEqual;
-  exports.diffRecords = diffRecords;
-  exports.disable = disable;
-  exports.ensureDevtoolsHook = ensureDevtoolsHook;
-  exports.getDisplayName = getDisplayName;
-  exports.getRenderers = getRenderers;
-  exports.init = init;
-  exports.isEnabled = isEnabled;
-  exports.isProductionReact = isProductionReact;
-  exports.printReport = printReport;
-  exports.serialize = serialize;
-  exports.shouldTrack = shouldTrack;
-  exports.summarize = summarize;
-  exports.track = track;
-
-  return exports;
-
-})({});
+  // src/inject.ts
+  var import_version2 = __toESM(require_version(), 1);
+  return __toCommonJS(inject_exports);
+})();
+globalThis.RerenderLens = RerenderLens;