rerender-lens 0.3.0 → 0.5.0

package/dist/jest.js

@@ -0,0 +1,1751 @@
+import { existsSync, readFileSync, appendFileSync, mkdirSync, writeFileSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+// src/runner-report.ts
+
+// src/diff.ts
+var REACT_ELEMENT = /* @__PURE__ */ Symbol.for("react.element");
+var REACT_TRANSITIONAL_ELEMENT = /* @__PURE__ */ Symbol.for("react.transitional.element");
+function isReactElement(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const t = v.$$typeof;
+  return t === REACT_ELEMENT || t === REACT_TRANSITIONAL_ELEMENT;
+}
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function remember(seen, a, b) {
+  let set = seen.get(a);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    seen.set(a, set);
+  }
+  if (set.has(b)) return true;
+  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;
+  if (a instanceof Date) return b instanceof Date && a.getTime() === b.getTime();
+  if (a instanceof RegExp) return b instanceof RegExp && a.source === b.source && a.flags === b.flags;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i], seen)) return false;
+    return true;
+  }
+  if (Array.isArray(b)) return false;
+  if (ArrayBuffer.isView(a)) {
+    if (!ArrayBuffer.isView(b) || a.constructor !== b.constructor) return false;
+    const ta = a;
+    const tb = b;
+    if (ta.length !== tb.length) return false;
+    for (let i = 0; i < ta.length; i++) if (ta[i] !== tb[i]) return false;
+    return true;
+  }
+  if (a instanceof Map) {
+    if (!(b instanceof Map) || a.size !== b.size) return false;
+    for (const [k, v] of a) {
+      if (!b.has(k) || !deepEqual(v, b.get(k), seen)) return false;
+    }
+    return true;
+  }
+  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;
+      return false;
+    }
+    return true;
+  }
+  if (isReactElement(a)) {
+    if (!isReactElement(b)) return false;
+    return a.type === b.type && a.key === b.key && deepEqual(a.props, b.props, seen);
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    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], 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";
+  }
+  if (isReactElement(prev) && isReactElement(next)) {
+    return deepEqual(prev, next) ? "element" : "different";
+  }
+  return deepEqual(prev, next) ? "deep-equal" : "different";
+}
+function joinPath(base, key) {
+  if (typeof key === "number") return `${base}[${key}]`;
+  if (base === "") return key;
+  return /^[A-Za-z_$][\w$]*$/.test(key) ? `${base}.${key}` : `${base}[${JSON.stringify(key)}]`;
+}
+function diffRecords(prev, next, basePath = "") {
+  const p = prev ?? {};
+  const n = next ?? {};
+  const changes = [];
+  const keys = /* @__PURE__ */ new Set([...Object.keys(p), ...Object.keys(n)]);
+  for (const key of keys) {
+    const inPrev = Object.prototype.hasOwnProperty.call(p, key);
+    const inNext = Object.prototype.hasOwnProperty.call(n, key);
+    const path = joinPath(basePath, key);
+    if (inPrev && !inNext) {
+      changes.push({ path, kind: "removed", prev: p[key], next: void 0 });
+      continue;
+    }
+    if (!inPrev && inNext) {
+      changes.push({ path, kind: "added", prev: void 0, next: n[key] });
+      continue;
+    }
+    const a = p[key];
+    const b = n[key];
+    if (Object.is(a, b)) continue;
+    const kind = classify(a, b);
+    if (kind === "different") {
+      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 || "(value)";
+  if (Array.isArray(a) && Array.isArray(b)) {
+    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 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 null;
+  }
+  return deepEqual(a, b) ? null : path || "(value)";
+}
+
+// src/report.ts
+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) {
+  const chain = custom ?? [];
+  if (chain.some((n) => /^useSelector$/.test(n)))
+    return "the Redux selector returns a new object on every call: return a stored slice, pass shallowEqual as the equality function, or memoize it with createSelector";
+  if (chain.some((n) => /^useAppSelector$/.test(n)))
+    return "the selector returns a new object on every call: return a stored slice, pass shallowEqual, or memoize it with createSelector";
+  if (chain.some((n) => /^use[A-Z]\w*Store$/.test(n) || n === "useStore" || n === "useBoundStore"))
+    return "the store selector returns a new object on every call: select a primitive, or wrap the selector with useShallow (Zustand) / an equality function";
+  return "getSnapshot returns a new reference with the same contents: cache the snapshot in the store and return the same object while the data is unchanged";
+}
+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)`;
+    case "element":
+      return `memoize the element with useMemo, or pass it as children from a stable parent`;
+    case "deep-equal":
+      return Array.isArray(change.next) ? `memoize the array with useMemo (same items, new reference)` : `memoize the object with useMemo, or hoist it to module scope if it is constant`;
+    default:
+      return "";
+  }
+}
+function describe(change) {
+  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`;
+    case "function":
+      return `prop "${change.path}" is a new function instance on every render`;
+    case "element":
+      return `prop "${change.path}" is a new React element with the same type and props`;
+    case "different":
+      return `prop "${change.path}" changed`;
+    case "added":
+      return `prop "${change.path}" was added`;
+    case "removed":
+      return `prop "${change.path}" was removed`;
+  }
+}
+function buildReport(input) {
+  const stateChanges = input.stateChanges ?? [];
+  const hookChanges = input.hookChanges ?? [];
+  const isStateHook = (h) => h.hook === "useState" || h.hook === "useReducer";
+  const genuineProps = input.propChanges.some(isGenuine);
+  const genuineState = stateChanges.some(isGenuine) || hookChanges.some((h) => isStateHook(h) && isGenuine(h));
+  const genuineHooks = hookChanges.some((h) => !isStateHook(h) && isGenuine(h));
+  const causes = [genuineProps && "props", genuineState && "state", genuineHooks && "hooks"].filter(Boolean);
+  let trigger;
+  if (causes.length === 0) trigger = "parent";
+  else if (causes.length === 1) trigger = causes[0];
+  else trigger = "mixed";
+  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 = [];
+  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}. ${memoFix}.`);
+  } else if (avoidable && input.parent) {
+    reasons.push(`caused by <${input.parent.name}> re-rendering (${describeTrigger(input.parent.trigger)}).`);
+  }
+  for (const c of input.propChanges) {
+    const fix = fixFor(c);
+    reasons.push(fix ? `${describe(c)}: ${fix}.` : `${describe(c)}.`);
+  }
+  const memoized = input.memoized !== false;
+  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 ${input.classComponent ? "extend PureComponent (or implement shouldComponentUpdate)" : "wrap it in React.memo (or extend PureComponent)"}.`
+    );
+  }
+  for (const c of stateChanges) {
+    if (isGenuine(c)) reasons.push(`state "${c.path}" changed.`);
+    else reasons.push(`setState was called with a value deep-equal to the current "${c.path}" (new reference, same contents).`);
+  }
+  for (const c of hookChanges) {
+    if (c.hook === "useContext" && isGenuine(c)) {
+      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.`);
+    else if (c.hook === "useSyncExternalStore") reasons.push(`${hookLabel(c)} returned a new reference that is deep-equal to the previous value: ${storeAdvice(c.custom)}.`);
+    else reasons.push(`${hookLabel(c)} returned a new reference that is deep-equal to the previous value: memoize the context/store value where it is produced.`);
+  }
+  if (input.commitCause === "effect-after-commit") {
+    const who = input.updaters && input.updaters.length ? input.updaters.map((u) => `<${u}>`).join(", ") : "a component that rendered in it";
+    reasons.push(`this commit was scheduled right after commit #${input.afterCommit ?? "?"} by ${who}: an effect there set state (effect \u2192 setState loop). Derive the value during render or compute it before setting state.`);
+  } else if (input.commitCause === "suspense-resolved") {
+    reasons.push("this commit shows content that was suspended (a Suspense boundary resolved).");
+  }
+  const report = {
+    component: input.component,
+    instanceId: input.instanceId ?? 0,
+    commitId: input.commitId ?? 0,
+    renderCount: input.renderCount,
+    trigger,
+    avoidable,
+    memoized,
+    props: { prev: input.prevProps, next: input.nextProps },
+    propChanges: input.propChanges,
+    stateChanges,
+    hookChanges,
+    parent: input.parent ?? null,
+    owner: input.owner ?? null,
+    path: input.path ?? [],
+    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;
+  if (input.source) report.source = input.source;
+  if (input.hookState) report.hookState = input.hookState;
+  if (input.contexts) report.contexts = input.contexts;
+  if (input.state) report.state = input.state;
+  if (input.updaters && input.updaters.length) report.updaters = input.updaters;
+  if (input.commitCause) report.commitCause = input.commitCause;
+  if (input.afterCommit !== void 0) report.afterCommit = input.afterCommit;
+  if (input.key !== void 0) report.key = input.key;
+  return report;
+}
+function describeTrigger(t) {
+  switch (t) {
+    case "props":
+      return "its props changed";
+    case "state":
+      return "its state changed";
+    case "hooks":
+      return "a context or store it reads changed";
+    case "mixed":
+      return "its props and state changed";
+    default:
+      return "its own parent re-rendered";
+  }
+}
+var KIND_LABEL = {
+  "deep-equal": "equal by value",
+  function: "new function",
+  element: "equal element",
+  different: "changed",
+  added: "added",
+  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 parts = [...counts2].map(([kind, n]) => `${n} ${KIND_LABEL[kind] || kind}`);
+  if (parts.length === 0) parts.push("no changes");
+  return parts.join(", ");
+}
+function printReport(report, options) {
+  const c = options.console ?? console;
+  const open = options.collapse === false ? c.group : c.groupCollapsed;
+  const verdict = report.avoidable ? "avoidable re-render" : `re-render (${report.trigger})`;
+  open.call(c, `[rerender-lens] <${report.component}> ${verdict}: ${summarize(report)}`);
+  for (const r of report.reasons) c.log(`- ${r}`);
+  if (report.path.length) c.log(`at ${[...report.path, report.component].join(" > ")}`);
+  for (const ch of [...report.propChanges, ...report.stateChanges, ...report.hookChanges]) {
+    c.log(`${ch.path} (${KIND_LABEL[ch.kind]})`, { prev: ch.prev, next: ch.next });
+  }
+  c.log("props", report.props);
+  if (report.hookState && report.hookState.length) c.log("hooks", Object.fromEntries(report.hookState.map((h) => [h.path, h.value])));
+  if (report.contexts && report.contexts.length) c.log("contexts", Object.fromEntries(report.contexts.map((x) => [x.name, x.value])));
+  if (report.state) c.log("state", report.state);
+  c.groupEnd();
+}
+
+// src/state.ts
+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, truncated: 0 };
+    g[KEY] = s;
+  }
+  return s;
+}
+function warnOnce(key, message) {
+  const s = getState();
+  if (s.warnedOnce.has(key)) return;
+  s.warnedOnce.add(key);
+  (s.options.console ?? console).warn(`[rerender-lens] ${message}`);
+}
+function dispatch(report, override) {
+  const s = getState();
+  const options = s.options;
+  if (!options.silent && (report.avoidable || options.logAll)) {
+    const max = options.maxReportsPerComponent ?? 0;
+    const n = (s.printed.get(report.component) ?? 0) + 1;
+    s.printed.set(report.component, n);
+    if (max <= 0 || n <= max) {
+      printReport(report, options);
+    } else if (n === max + 1) {
+      (options.console ?? console).log(
+        `[rerender-lens] <${report.component}> reached maxReportsPerComponent (${max}); further reports are not printed.`
+      );
+    }
+  }
+  if (options.notifier) {
+    try {
+      options.notifier(report);
+    } catch (err) {
+      warnOnce("notifier", `notifier threw: ${String(err)}`);
+    }
+  }
+}
+
+// src/types.ts
+var MARKER = "rerenderLens";
+
+// 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");
+  }
+  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 disable;
+}
+function disable() {
+  const s = getState();
+  if (!s.enabled) return;
+  s.detach?.();
+  s.detach = null;
+  s.enabled = false;
+}
+
+// src/hookNames.ts
+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) {
+  const names = [];
+  let past = false;
+  for (const line of stack.split("\n")) {
+    const m = /^\s*at\s+(?:async\s+)?([^\s(]+)|^([^@\s]+)@/.exec(line);
+    const name = m ? (m[1] || m[2] || "").replace(/^Object\./, "").replace(/^Proxy\./, "") : "";
+    if (!name) continue;
+    if (!past) {
+      if (name.includes(marker)) past = true;
+      continue;
+    }
+    if (name === componentName || name.endsWith("." + componentName)) break;
+    if (/^use[A-Z0-9_]/.test(name) && !BUILTIN_HOOKS.has(name)) names.push(name);
+    if (names.length > 8) break;
+  }
+  return names;
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function makeDispatcher(fiber, componentName, out, marker) {
+  let node = fiber.memoizedState;
+  let index = 0;
+  const take = (count) => {
+    const first = node;
+    for (let i = 0; i < count && node; i++) node = node.next;
+    index += count;
+    return first;
+  };
+  const record = (primitive, count) => {
+    const stack = new Error().stack || "";
+    const chain = customHooksFromStack(stack, componentName, marker);
+    const start = index;
+    const first = take(count);
+    if (chain.length) for (let i = 0; i < count; i++) out.set(start + i, chain);
+    return first;
+  };
+  const memoized = (n) => n ? n.memoizedState : void 0;
+  const dispatcher = {};
+  const define = (name, impl) => {
+    const fn = { [marker + name]: (...a) => impl(...a) }[marker + name];
+    dispatcher[name] = fn;
+  };
+  define("useState", () => {
+    const n = record("useState", 1);
+    return [memoized(n), noop];
+  });
+  define("useReducer", () => {
+    const n = record("useReducer", 1);
+    return [memoized(n), noop];
+  });
+  define("useRef", (init2) => {
+    const n = record("useRef", 1);
+    return n ? n.memoizedState : { current: init2 };
+  });
+  define("useMemo", (fn) => {
+    const n = record("useMemo", 1);
+    const s = memoized(n);
+    return Array.isArray(s) ? s[0] : typeof fn === "function" ? fn() : void 0;
+  });
+  define("useCallback", (fn) => {
+    const n = record("useCallback", 1);
+    const s = memoized(n);
+    return Array.isArray(s) ? s[0] : fn;
+  });
+  for (const effect of ["useEffect", "useLayoutEffect", "useInsertionEffect", "useImperativeHandle"]) define(effect, () => void record(effect, 1));
+  define("useContext", (ctx) => {
+    record("useContext", 0);
+    const c = ctx;
+    return c ? c._currentValue : void 0;
+  });
+  define("useDebugValue", () => void record("useDebugValue", 0));
+  define("useSyncExternalStore", (_subscribe, getSnapshot) => {
+    const n = record("useSyncExternalStore", 2);
+    return n ? n.memoizedState : typeof getSnapshot === "function" ? getSnapshot() : void 0;
+  });
+  define("useTransition", () => {
+    record("useTransition", 2);
+    return [false, noop];
+  });
+  define("useDeferredValue", (v) => {
+    const n = record("useDeferredValue", 1);
+    return n ? n.memoizedState : v;
+  });
+  define("useId", () => {
+    const n = record("useId", 1);
+    return n ? n.memoizedState : "id";
+  });
+  define("useOptimistic", (v) => {
+    const n = record("useOptimistic", 1);
+    return [n ? n.memoizedState : v, noop];
+  });
+  for (const action of ["useActionState", "useFormState"]) {
+    define(action, (_fn, init2) => {
+      const n = record(action, 3);
+      return [n ? n.memoizedState : init2, noop, false];
+    });
+  }
+  define("useEffectEvent", (fn) => {
+    record("useEffectEvent", 1);
+    return fn;
+  });
+  define("useCacheRefresh", () => {
+    record("useCacheRefresh", 1);
+    return noop;
+  });
+  define("useHostTransitionStatus", () => ({ pending: false, data: null, method: null, action: null }));
+  define("useMemoCache", (size) => new Array(Number(size) || 0).fill(/* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")));
+  define("use", (usable) => {
+    record("use", 0);
+    const u = usable;
+    if (u && typeof u.then === "function") {
+      if (u.status === "fulfilled") return u.value;
+      throw new Error("rerender-lens: cannot replay use() on a pending promise");
+    }
+    return u ? u._currentValue : void 0;
+  });
+  define("readContext", (ctx) => ctx?._currentValue);
+  return { dispatcher, nodesConsumed: () => index };
+}
+function renderFunctionOf(type) {
+  let t = type;
+  while (t && typeof t === "object" && t.type) t = t.type;
+  if (t && typeof t === "object" && typeof t.render === "function") return { fn: t.render, name: t.render.name || t.displayName || "Component" };
+  if (typeof t === "function") return { fn: t, name: t.name || "Component" };
+  return { fn: null, name: "Component" };
+}
+function resolveHookNames(fiber, ref) {
+  const type = fiber.type;
+  if (!type || !ref) return /* @__PURE__ */ new Map();
+  const cached = cache.get(type);
+  if (cached) return cached.byNode;
+  const result = { byNode: /* @__PURE__ */ new Map(), ok: false };
+  cache.set(type, result);
+  const { fn, name } = renderFunctionOf(type);
+  if (!fn) return result.byNode;
+  const useH = "H" in ref;
+  const marker = "__rl_";
+  const previous = useH ? ref.H : ref.current;
+  const { dispatcher, nodesConsumed } = makeDispatcher(fiber, name, result.byNode, marker);
+  const proxy = new Proxy(dispatcher, {
+    get(target, key) {
+      if (key in target) return target[key];
+      return () => void 0;
+    }
+  });
+  let total = 0;
+  for (let n = fiber.memoizedState; n && typeof n === "object" && "next" in n; n = n.next) total++;
+  try {
+    if (useH) ref.H = proxy;
+    else ref.current = proxy;
+    const secondArg = fiber.tag === 11 ? fiber.stateNode?.ref ?? null : void 0;
+    fn(fiber.memoizedProps ?? {}, secondArg);
+    result.ok = nodesConsumed() === total;
+    if (!result.ok) result.byNode.clear();
+  } catch {
+    result.byNode.clear();
+  } finally {
+    if (useH) ref.H = previous;
+    else ref.current = previous;
+  }
+  return result.byNode;
+}
+
+// src/fiber.ts
+var FunctionComponent = 0;
+var ClassComponent = 1;
+var HostRoot = 3;
+var ContextProvider = 10;
+var ForwardRef = 11;
+var SuspenseComponent = 13;
+var MemoComponent = 14;
+var SimpleMemoComponent = 15;
+var PerformedWork = 1;
+var HOOK = "__REACT_DEVTOOLS_GLOBAL_HOOK__";
+var nowMs = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+function ensureDevtoolsHook() {
+  const g = globalThis;
+  let hook = g[HOOK];
+  if (!hook) {
+    let nextId = 0;
+    const renderers = /* @__PURE__ */ new Map();
+    hook = {
+      renderers,
+      supportsFiber: true,
+      inject(renderer) {
+        const id = ++nextId;
+        renderers.set(id, renderer);
+        return id;
+      },
+      onCommitFiberRoot() {
+      },
+      onCommitFiberUnmount() {
+      },
+      onScheduleFiberRoot() {
+      },
+      onPostCommitFiberRoot() {
+      }
+    };
+    g[HOOK] = hook;
+  }
+  return hook;
+}
+var capturedRenderers = /* @__PURE__ */ new Map();
+var dispatcherRefs = /* @__PURE__ */ new Map();
+var INJECT_WRAPPED = /* @__PURE__ */ Symbol.for("rerender-lens.injectWrapped");
+var ATTACHED = /* @__PURE__ */ Symbol.for("rerender-lens.attached");
+function pickRenderer(r) {
+  const info = r ?? {};
+  return { version: info.version, bundleType: info.bundleType, rendererPackageName: info.rendererPackageName };
+}
+function wrapInject(hook) {
+  const h = hook;
+  if (h[INJECT_WRAPPED] || typeof hook.inject !== "function") return;
+  const original = hook.inject;
+  hook.inject = function(renderer) {
+    const id = original.call(this, renderer);
+    const key = typeof id === "number" ? id : capturedRenderers.size + 1;
+    capturedRenderers.set(key, pickRenderer(renderer));
+    const ref = renderer?.currentDispatcherRef;
+    if (ref && typeof ref === "object") dispatcherRefs.set(key, ref);
+    return id;
+  };
+  h[INJECT_WRAPPED] = true;
+}
+function getDispatcherRef() {
+  for (const ref of dispatcherRefs.values()) return ref;
+  const g = globalThis;
+  const hook = g[HOOK];
+  let found = null;
+  if (hook && hook.renderers && typeof hook.renderers.forEach === "function") {
+    hook.renderers.forEach((r) => {
+      const ref = r?.currentDispatcherRef;
+      if (!found && ref && typeof ref === "object") found = ref;
+    });
+  }
+  return found;
+}
+function attach() {
+  const hook = ensureDevtoolsHook();
+  wrapInject(hook);
+  if (hook[ATTACHED]) return () => {
+  };
+  hook[ATTACHED] = true;
+  const previous = hook.onCommitFiberRoot;
+  const patched = function(id, root, priority, didError) {
+    const started = nowMs();
+    try {
+      onCommit(root, priorityLabel(priority));
+    } catch (err) {
+      warnOnce("commit", `failed to inspect a commit: ${String(err)}`);
+    } finally {
+      const spent = nowMs() - started;
+      const s = getState();
+      s.overheadMs += spent;
+      if (spent > s.maxCommitMs) s.maxCommitMs = spent;
+    }
+    if (typeof previous === "function") return previous.call(this, id, root, priority, didError);
+  };
+  hook.onCommitFiberRoot = patched;
+  const previousSchedule = hook.onScheduleFiberRoot;
+  const patchedSchedule = function(id, root, children) {
+    getState().scheduled++;
+    if (typeof previousSchedule === "function") return previousSchedule.call(this, id, root, children);
+  };
+  hook.onScheduleFiberRoot = patchedSchedule;
+  return () => {
+    hook[ATTACHED] = false;
+    if (hook.onCommitFiberRoot === patched) hook.onCommitFiberRoot = previous;
+    if (hook.onScheduleFiberRoot === patchedSchedule) hook.onScheduleFiberRoot = previousSchedule;
+  };
+}
+function priorityLabel(priority) {
+  switch (priority) {
+    case 1:
+      return "immediate";
+    case 2:
+      return "user-blocking";
+    case 3:
+      return "normal";
+    case 4:
+      return "low";
+    case 5:
+      return "idle";
+    default:
+      return void 0;
+  }
+}
+var flagsOf = (f) => f.flags ?? f.effectTag ?? 0;
+var isComponentTag = (tag) => tag === FunctionComponent || tag === ClassComponent || tag === ForwardRef || tag === MemoComponent || tag === SimpleMemoComponent;
+function isMemoizedFiber(fiber) {
+  if (fiber.tag === MemoComponent || fiber.tag === SimpleMemoComponent) return true;
+  if (fiber.tag === ClassComponent) {
+    const inst = fiber.stateNode;
+    return !!(inst && inst.isPureReactComponent);
+  }
+  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;
+  let children = 0;
+  for (let c = fiber.child; c; c = c.sibling) if (typeof c.actualDuration === "number") children += c.actualDuration;
+  return { self: Math.max(0, tree - children), tree };
+}
+function fiberType(fiber) {
+  return fiber.elementType ?? fiber.type;
+}
+function fiberName(fiber) {
+  return getDisplayName(fiberType(fiber));
+}
+function didRender(fiber) {
+  return (flagsOf(fiber) & PerformedWork) !== 0;
+}
+function isHotSwapped(fiber, alt) {
+  return fiber.type !== alt.type;
+}
+var counts = /* @__PURE__ */ new WeakMap();
+var ids = /* @__PURE__ */ new WeakMap();
+var fibersById = /* @__PURE__ */ new Map();
+var hasWeakRef = typeof WeakRef === "function";
+var pruneAt = 5e3;
+function remember2(id, fiber) {
+  if (!hasWeakRef) return;
+  if (fibersById.get(id)?.deref() === fiber) return;
+  fibersById.set(id, new WeakRef(fiber));
+  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) {
+  return ids.get(fiber) ?? (fiber.alternate ? ids.get(fiber.alternate) : void 0);
+}
+function instanceId(fiber) {
+  const existing = instanceIdOf(fiber);
+  if (existing !== void 0) {
+    ids.set(fiber, existing);
+    remember2(existing, fiber);
+    return existing;
+  }
+  const s = getState();
+  const id = s.nextInstanceId++;
+  ids.set(fiber, id);
+  remember2(id, fiber);
+  return id;
+}
+function nearestComponent(fiber) {
+  let f = fiber;
+  while (f && f.tag !== HostRoot) {
+    if (isComponentTag(f.tag)) return f;
+    f = f.return;
+  }
+  return null;
+}
+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", 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]) };
+  }
+  return void 0;
+}
+function sourceOf(fiber) {
+  const src = fiber._debugSource;
+  if (src && typeof src.fileName === "string") {
+    const out = { fileName: src.fileName };
+    if (typeof src.lineNumber === "number") out.lineNumber = src.lineNumber;
+    if (typeof src.columnNumber === "number") out.columnNumber = src.columnNumber;
+    return out;
+  }
+  const st = fiber._debugStack;
+  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;
+  counts.set(fiber, n);
+  return n;
+}
+function componentPath(fiber) {
+  const path = [];
+  let f = fiber.return;
+  while (f && f.tag !== HostRoot) {
+    if (isComponentTag(f.tag)) path.unshift(fiberName(f));
+    f = f.return;
+  }
+  return path;
+}
+function ownerName(fiber) {
+  const owner = fiber._debugOwner;
+  if (!owner) return null;
+  if (owner.type !== void 0) return getDisplayName(owner.type);
+  return typeof owner.name === "string" ? owner.name : null;
+}
+var isStateNode = (n) => !!n.queue && typeof n.queue.lastRenderedReducer === "function";
+var isStoreNode = (n) => !!n.queue && typeof n.queue.getSnapshot === "function";
+function hookLabel2(node) {
+  if (isStoreNode(node)) return "useSyncExternalStore";
+  if (isStateNode(node)) {
+    const r = node.queue.lastRenderedReducer;
+    return r.name === "basicStateReducer" ? "useState" : "useReducer";
+  }
+  return "state";
+}
+var NODELESS_HOOKS = /* @__PURE__ */ new Set(["useContext", "useDebugValue", "use"]);
+function hookLabelsFor(fiber, first) {
+  const types = fiber._debugHookTypes?.filter((t) => !NODELESS_HOOKS.has(t));
+  let nodeCount = 0;
+  for (let n = first; n; n = n.next) nodeCount++;
+  return types && types.length === nodeCount ? types : null;
+}
+var isHookList = (v) => !!v && typeof v === "object" && "next" in v;
+function snapshotHooks(fiber) {
+  const out = [];
+  if (fiber.tag === ClassComponent) return out;
+  const first = fiber.memoizedState;
+  if (!isHookList(first)) return out;
+  const labels = hookLabelsFor(fiber, first);
+  let i = 0;
+  for (let n = first; n; n = n.next, i++) {
+    if (!isStateNode(n) && !isStoreNode(n)) continue;
+    const hook = labels?.[i] ?? hookLabel2(n);
+    out.push({ path: `${hook}#${i}`, hook, index: i, value: n.memoizedState });
+  }
+  return out;
+}
+function snapshotContexts(fiber) {
+  const out = [];
+  for (let d = fiber.dependencies?.firstContext ?? null; d; d = d.next) out.push({ name: d.context.displayName ?? "Context", value: d.memoizedValue });
+  return out;
+}
+function diffHooks(fiber, alt) {
+  const out = [];
+  if (fiber.tag === ClassComponent) return out;
+  let a = alt.memoizedState;
+  let b = fiber.memoizedState;
+  if (!a || !b || typeof b !== "object" || !("next" in b)) return out;
+  const labels = hookLabelsFor(fiber, b);
+  let i = 0;
+  while (a && b) {
+    const deferred = labels?.[i] === "useDeferredValue";
+    if ((deferred || isStateNode(b) || isStoreNode(b)) && !Object.is(a.memoizedState, b.memoizedState)) {
+      const hook = labels?.[i] ?? hookLabel2(b);
+      out.push({
+        path: `${hook}#${i}`,
+        hook,
+        index: i,
+        kind: classify(a.memoizedState, b.memoizedState),
+        prev: a.memoizedState,
+        next: b.memoizedState
+      });
+    }
+    a = a.next;
+    b = b.next;
+    i++;
+  }
+  return out;
+}
+function findProvider(fiber, context) {
+  let f = fiber.return;
+  while (f && f.tag !== HostRoot) {
+    if (f.tag === ContextProvider) {
+      const t = f.type;
+      if (t === context || t && typeof t === "object" && t._context === context) return f;
+    }
+    f = f.return;
+  }
+  return null;
+}
+var isPlainObject2 = (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)) {
+    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";
+      const change = {
+        path: `useContext(${name})`,
+        hook: "useContext",
+        index: i,
+        kind: classify(a.memoizedValue, b.memoizedValue),
+        prev: a.memoizedValue,
+        next: b.memoizedValue
+      };
+      const provider = findProvider(fiber, b.context);
+      if (provider) {
+        const path = componentPath(provider);
+        change.provider = { component: path[path.length - 1] ?? null, path };
+      }
+      if (isPlainObject2(a.memoizedValue) && isPlainObject2(b.memoizedValue)) {
+        const prev = a.memoizedValue;
+        const next = b.memoizedValue;
+        const keys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)]);
+        change.changedKeys = [...keys].filter((k) => !Object.is(prev[k], next[k]));
+        change.totalKeys = keys.size;
+      }
+      out.push(change);
+    }
+    a = a.next;
+    b = b.next;
+    i++;
+  }
+  return out;
+}
+var isGenuine2 = (c) => c.kind === "different" || c.kind === "added" || c.kind === "removed";
+var isRefObject2 = (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 && isRefObject2(pr) && isRefObject2(nr)) {
+    const { ref: _p, ...restPrev } = prev;
+    const { ref: _n, ...restNext } = next;
+    return [{ path: "ref", kind: "deep-equal", prev: pr, next: nr }, ...diffRecords(restPrev, restNext)];
+  }
+  return diffRecords(prev, next);
+}
+function analyze(fiber, alt, trackHooks) {
+  const prevProps = alt.memoizedProps ?? {};
+  const nextProps = fiber.memoizedProps ?? {};
+  const propChanges = diffProps(prevProps, nextProps);
+  let stateChanges = [];
+  let hookChanges = [];
+  if (fiber.tag === ClassComponent) {
+    if (alt.memoizedState !== fiber.memoizedState) {
+      stateChanges = diffRecords(
+        alt.memoizedState ?? {},
+        fiber.memoizedState ?? {}
+      );
+    }
+  } else if (trackHooks) {
+    hookChanges = [...diffHooks(fiber, alt), ...diffContexts(fiber, alt)];
+  }
+  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");
+  const trigger = causes.length === 0 ? "parent" : causes.length === 1 ? causes[0] : "mixed";
+  return { propChanges, stateChanges, hookChanges, trigger };
+}
+function nearestRenderedAncestor(fiber, cache2, trackHooks) {
+  let f = fiber.return;
+  while (f && f.tag !== HostRoot) {
+    if (isComponentTag(f.tag) && f.alternate && didRender(f)) {
+      let info = cache2.get(f);
+      if (info === void 0) {
+        info = { name: fiberName(f), trigger: analyze(f, f.alternate, trackHooks).trigger };
+        cache2.set(f, info);
+      }
+      return info;
+    }
+    f = f.return;
+  }
+  return null;
+}
+function updatersOf(root) {
+  const set = root.memoizedUpdaters;
+  if (!set || typeof set.forEach !== "function") return [];
+  const names = [];
+  set.forEach((f) => {
+    const comp = nearestComponent(f);
+    if (comp) {
+      const name = fiberName(comp);
+      if (!names.includes(name)) names.push(name);
+    }
+  });
+  return names;
+}
+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();
+  if (!s.enabled) return;
+  s.commits++;
+  const o = s.options;
+  const trackHooks = o.trackHooks !== false;
+  const rendered = [];
+  const renderedNames = /* @__PURE__ */ new Set();
+  let hot = false;
+  let resolvedBoundaries = null;
+  const stack = [root.current];
+  while (stack.length) {
+    const fiber = stack.pop();
+    const alt = fiber.alternate;
+    if (alt && isComponentTag(fiber.tag) && didRender(fiber)) {
+      if (isHotSwapped(fiber, alt)) hot = true;
+      renderedNames.add(fiberName(fiber));
+      if (shouldTrack(fiberType(fiber), o)) rendered.push(fiber);
+    }
+    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);
+    }
+  }
+  if (hot && o.ignoreHotReload !== false) return;
+  rendered.reverse();
+  const at = nowMs();
+  const updaters = updatersOf(root);
+  let commitCause;
+  let afterCommit;
+  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 (resolvedBoundaries) commitCause = "suspense-resolved";
+  if (rendered.length === 0) {
+    lastCommit = { id: s.nextCommitId, at, rendered: renderedNames };
+    return;
+  }
+  const commitId = s.nextCommitId++;
+  lastCommit = { id: commitId, at, rendered: renderedNames };
+  const dispatcherRef = o.resolveHookNames ? getDispatcherRef() : null;
+  const parentCache = /* @__PURE__ */ new Map();
+  const endDiffScope = 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;
+        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 = 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)
+      });
+      dispatch(report);
+    }
+  } finally {
+    endDiffScope();
+  }
+}
+
+// src/causes.ts
+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 { roots: [...roots.values()].sort((a, b) => b.count - a.count), rootByReport, avoidable, wasted };
+}
+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 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));
+}
+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 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 ownerName2 = 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: 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 propChanges) {
+    if (!AVOIDABLE_KINDS.has(c.kind)) continue;
+    const owner = ownerName2 || "?";
+    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; 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}>.`,
+        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}>.`,
+        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 {
+      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" || /^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) {
+      out.push({
+        kind: "splitContext",
+        owner: providerOwner || `${ctxName}.Provider`,
+        target: r.component,
+        prop: ctxName,
+        label: `split ${ctxName}${providerOwner ? ` in <${providerOwner}>` : ""}: only ${c.changedKeys.join(", ")} changed`,
+        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_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: `<${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");
+      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).`,
+        snippet: `// ${r.component}
+setState((prev) => (deepEqual(prev, next) ? prev : next));`
+      });
+    }
+  }
+  return out;
+}
+var fixKey = (f) => `${f.kind}|${f.owner}|${f.prop || f.target}`;
+function rankFixes(reports) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const r of reports) {
+    if (!r.avoidable) continue;
+    for (const f of fixesFor(r)) {
+      const key = fixKey(f);
+      let agg = byKey.get(key);
+      if (!agg) {
+        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));
+}
+function formatFixes(reports, limit = 10) {
+  const ranked = rankFixes(reports);
+  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");
+}
+
+// src/sessions.ts
+function summarizeReports(reports, meta = {}) {
+  var _a;
+  const byComponent = {};
+  let avoidable = 0;
+  let wasted = 0;
+  for (const r of reports) {
+    const c = byComponent[_a = r.component] || (byComponent[_a] = { total: 0, avoidable: 0, wasted: 0 });
+    c.total++;
+    if (r.avoidable) {
+      c.avoidable++;
+      avoidable++;
+      if (typeof r.selfDuration === "number") {
+        c.wasted += r.selfDuration;
+        wasted += r.selfDuration;
+      }
+    }
+  }
+  return {
+    id: meta.id ?? `s${Date.now().toString(36)}`,
+    name: meta.name ?? "session",
+    startedAt: meta.startedAt ?? (reports[0]?.time ?? 0),
+    endedAt: meta.endedAt ?? (reports[reports.length - 1]?.time ?? null),
+    total: reports.length,
+    avoidable,
+    wasted,
+    byComponent,
+    fixes: rankFixes(reports).map((f) => ({ key: f.key, label: f.label, count: f.count }))
+  };
+}
+
+// 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;
+}
+function checkBudget(reports, budget) {
+  const b = typeof budget === "number" ? { "*": budget } : budget;
+  const fallback = typeof b["*"] === "number" ? b["*"] : 0;
+  const counts2 = avoidableCounts(reports);
+  const violations = [];
+  const slack = [];
+  const names = /* @__PURE__ */ new Set([...Object.keys(counts2), ...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;
+    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 };
+}
+function assertWithinBudget(reports, budget) {
+  const result = checkBudget(reports, budget);
+  if (result.ok) return result;
+  const lines = result.violations.map((v) => `  <${v.component}>: ${v.avoidable} avoidable re-render${v.avoidable === 1 ? "" : "s"} (budget ${v.allowed})`);
+  throw new Error(`Re-render budget exceeded:
+${lines.join("\n")}
+
+Fixes, most impact first:
+${formatFixes(reports)}`);
+}
+
+// src/notifiers.ts
+function createCollector() {
+  const reports = [];
+  return {
+    reports,
+    get avoidable() {
+      return reports.filter((r) => r.avoidable);
+    },
+    notifier: (r) => {
+      reports.push(r);
+    },
+    clear: () => {
+      reports.length = 0;
+    },
+    assertNoAvoidable() {
+      const bad = reports.filter((r) => r.avoidable);
+      if (bad.length === 0) return;
+      const lines = bad.map((r) => `  <${r.component}> render #${r.renderCount}:
+${r.reasons.map((x) => `    - ${x}`).join("\n")}`);
+      throw new Error(`${bad.length} avoidable re-render${bad.length === 1 ? "" : "s"} detected:
+${lines.join("\n")}
+
+Fixes, most impact first:
+${formatFixes(reports)}`);
+    },
+    fixes: () => rankFixes(reports),
+    summary: (name) => summarizeReports(reports, name ? { name } : {}),
+    assertWithinBudget: (budget) => assertWithinBudget(reports, budget)
+  };
+}
+
+// src/runner-report.ts
+var OUT_ENV = "RERENDER_LENS_OUT";
+function setupRerenderLens(options = {}, hooks = {}) {
+  ensureDevtoolsHook();
+  const { failFast, ...rest } = options;
+  const collector = createCollector();
+  init({ trackAllMemoized: true, silent: true, ...rest, notifier: collector.notifier });
+  const flush = () => {
+    const reports = collector.reports.slice();
+    if (!reports.length) return;
+    const file = process.env[OUT_ENV];
+    if (file) appendFileSync(file, JSON.stringify({ file: hooks.testPath?.() ?? "", reports: reports.map(slim) }) + "\n");
+    collector.clear();
+    if (failFast) {
+      const avoidable = reports.filter((r) => r.avoidable);
+      if (avoidable.length) throw new Error(`rerender-lens: ${avoidable.length} avoidable re-render${avoidable.length === 1 ? "" : "s"} in this file
+${formatFixes(avoidable, 5)}`);
+    }
+  };
+  hooks.afterAll?.(flush);
+  return { collector, flush };
+}
+function slim(r) {
+  const value = (v) => Array.isArray(v) ? [] : typeof v === "function" ? `\u0192 ${v.name || ""}` : v && typeof v === "object" ? {} : v;
+  return {
+    ...r,
+    propChanges: r.propChanges.map((c) => ({ ...c, prev: value(c.prev), next: value(c.next) })),
+    stateChanges: r.stateChanges.map((c) => ({ ...c, prev: value(c.prev), next: value(c.next) })),
+    hookChanges: r.hookChanges.map((c) => ({ ...c, prev: value(c.prev), next: value(c.next) })),
+    props: { prev: {}, next: {} },
+    hookState: void 0,
+    contexts: void 0,
+    state: void 0
+  };
+}
+function createRunFile() {
+  const dir = join(tmpdir(), "rerender-lens");
+  mkdirSync(dir, { recursive: true });
+  const file = join(dir, `run-${process.pid}-${Date.now()}.jsonl`);
+  writeFileSync(file, "");
+  process.env[OUT_ENV] = file;
+  return file;
+}
+function finishRun(file, options = {}) {
+  const reports = readRun(file);
+  const log = options.write ?? ((line) => void process.stdout.write(line + "\n"));
+  const avoidable = reports.filter((r) => r.avoidable).length;
+  let error = null;
+  log("");
+  log(`rerender-lens: ${reports.length} report${reports.length === 1 ? "" : "s"}, ${avoidable} avoidable across the run`);
+  if (avoidable) log(formatFixes(reports, options.limit ?? 10));
+  if (options.exportTo) writeFileSync(options.exportTo, JSON.stringify({ rerenderLens: true, version: 2, exportedAt: (/* @__PURE__ */ new Date()).toISOString(), reports }, null, 2));
+  if (options.budget) {
+    const budget = JSON.parse(readFileSync(options.budget, "utf8"));
+    const result = checkBudget(reports, budget);
+    if (!result.ok) {
+      const lines = result.violations.map((v) => `  budget exceeded: <${v.component}> ${v.avoidable} avoidable (allowed ${v.allowed})`);
+      for (const line of lines) log(line);
+      error = new Error(`rerender-lens: re-render budget exceeded (${options.budget})
+${lines.join("\n")}`);
+    } else log(`  within budget (${options.budget})`);
+  }
+  try {
+    rmSync(file, { force: true });
+  } catch {
+  }
+  if (process.env[OUT_ENV] === file) delete process.env[OUT_ENV];
+  return { reports, error };
+}
+var RunReporterCore = class {
+  constructor(options = {}) {
+    this.done = false;
+    this.options = options;
+    this.file = createRunFile();
+  }
+  /** Publish the path again (the runner may have replaced `process.env` since the constructor ran). */
+  arm() {
+    process.env[OUT_ENV] = this.file;
+  }
+  /** The run's result, or null when the run was already finished (runners fire two "done" events). */
+  finish() {
+    if (this.done) return null;
+    this.done = true;
+    return finishRun(this.file, this.options);
+  }
+};
+function readRun(file) {
+  if (!existsSync(file)) return [];
+  const out = [];
+  for (const line of readFileSync(file, "utf8").split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (Array.isArray(parsed.reports)) out.push(...parsed.reports);
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/jest.ts
+function reporterOptionsOf(a, b) {
+  if (b && typeof b === "object") return b;
+  const first = a;
+  if (first && typeof first === "object" && !("rootDir" in first) && ("budget" in first || "limit" in first || "exportTo" in first || "write" in first)) return first;
+  return {};
+}
+var RerenderLensJestReporter = class {
+  /** Jest: `new Reporter(globalConfig, reporterOptions, reporterContext)`. */
+  constructor(globalConfigOrOptions, options) {
+    this.error = null;
+    this.core = new RunReporterCore(reporterOptionsOf(globalConfigOrOptions, options));
+  }
+  onRunStart() {
+    this.core.arm();
+  }
+  onRunComplete() {
+    const result = this.core.finish();
+    if (result?.error) {
+      this.error = result.error;
+      process.exitCode = 1;
+    }
+  }
+  /** Jest fails the run when a reporter reports an error. */
+  getLastError() {
+    return this.error ?? void 0;
+  }
+};
+
+export { OUT_ENV, checkBudget, RerenderLensJestReporter as default, formatFixes, readRun, setupRerenderLens };
+//# sourceMappingURL=jest.js.map
+//# sourceMappingURL=jest.js.map