react-perf-recorder 0.1.0

package/dist/engine.iife.js

@@ -0,0 +1,3661 @@
+"use strict";
+(() => {
+  // src/shared/url.ts
+  var JWT = /^eyJ[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}$/;
+  var OPAQUE = /^[A-Za-z0-9_-]{60,}$/;
+  var SECRET_NAME = /^(token|access[-_]?token|id[-_]?token|refresh[-_]?token|jwt|auth|authorization|key|api[-_]?key|secret|password|pwd|sig|signature|session|sid)$/i;
+  var MASK = "***";
+  var ABSOLUTE = /^[a-z][a-z0-9+.-]*:/i;
+  var maskValue = (value) => JWT.test(value) || OPAQUE.test(value) ? MASK : value;
+  var maskQuery = (search) => {
+    const params = new URLSearchParams(search);
+    let touched = false;
+    for (const [name, value] of [...params]) {
+      const masked = SECRET_NAME.test(name) ? MASK : maskValue(value);
+      if (masked === value) continue;
+      params.set(name, masked);
+      touched = true;
+    }
+    return touched ? params.toString() : search.replace(/^\?/, "");
+  };
+  var maskHash = (hash) => {
+    const body = hash.replace(/^#/, "");
+    if (!body) return "";
+    return body.includes("=") ? maskQuery(body) : body.split("/").map(maskValue).join("/");
+  };
+  function safeUrl(raw) {
+    if (!raw) return raw;
+    const relative = /^[/?#]/.test(raw);
+    if (!relative && !ABSOLUTE.test(raw)) return maskLoose(raw);
+    try {
+      const url = new URL(raw, relative ? "http://localhost" : void 0);
+      const path = url.pathname.split("/").map(maskValue).join("/");
+      const query = maskQuery(url.search);
+      const hash = maskHash(url.hash);
+      const tail = `${path}${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`;
+      return relative ? tail : `${url.protocol}//${url.host}${tail}`;
+    } catch {
+      return maskLoose(raw);
+    }
+  }
+  var maskLoose = (raw) => raw.replace(/eyJ[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}/g, MASK).replace(new RegExp(`(${SECRET_NAME.source.slice(1, -1)})=[^&\\s]+`, "gi"), `$1=${MASK}`);
+
+  // src/core/stack.ts
+  var V8_FRAME = /^\s*at (?:(?:async )?(.+?) \()?(.+?):(\d+):(\d+)\)?\s*$/;
+  var GECKO_FRAME = /^\s*(.*?)@(.+?):(\d+):(\d+)\s*$/;
+  var servedPath = (url) => url.replace(/^[a-z]+:\/\/[^/]+/, "").split(/[?#]/)[0].replace(/^\//, "");
+  function parseStack(stack) {
+    const frames = [];
+    for (const line of stack.split("\n")) {
+      const m = V8_FRAME.exec(line) ?? GECKO_FRAME.exec(line);
+      if (!m) continue;
+      frames.push({ fn: (m[1] ?? "").replace(/^Object\./, "").replace(/ \[as .+\]$/, ""), url: m[2], line: Number(m[3]), column: Number(m[4]) });
+    }
+    return frames;
+  }
+  var OWN = (() => {
+    const url = (parseStack(new Error().stack ?? "")[0]?.url ?? "").split(/[?#]/)[0];
+    const at = Math.max(url.lastIndexOf("/dist/"), url.lastIndexOf("/src/"));
+    return at >= 0 ? [`${url.slice(0, at)}/dist/`, `${url.slice(0, at)}/src/`] : [];
+  })();
+  var packageOf = (path) => {
+    const parts = path.split("/").filter(Boolean);
+    return parts[0]?.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? "";
+  };
+  function libraryOf(url) {
+    const path = url.split(/[?#]/)[0];
+    if (OWN.some((prefix) => path.startsWith(prefix))) return "react-perf-recorder";
+    const deps = /\/deps\/([^/]+)\.js$/.exec(path);
+    if (deps && (url.includes("?v=") || path.includes("/.vite"))) return deps[1].startsWith("chunk-") ? "" : packageOf(deps[1].replace(/_/g, "/"));
+    const at = path.lastIndexOf("/node_modules/");
+    if (at >= 0) return packageOf(path.slice(at + "/node_modules/".length));
+    return null;
+  }
+
+  // src/core/react-compat.ts
+  var BOTTOM_FRAME = /react_stack_bottom_frame/;
+  var ownerStackSites = /* @__PURE__ */ new WeakMap();
+  var sawSite = false;
+  var sawFiberWithoutSite = false;
+  function siteOf(f) {
+    const legacy = f._debugSource;
+    if (legacy?.fileName) {
+      sawSite = true;
+      return { url: legacy.fileName, line: legacy.lineNumber, column: legacy.columnNumber ?? 0, exact: true };
+    }
+    const stack = f._debugStack;
+    if (stack instanceof Error) {
+      const site = ownerStackSite(stack);
+      if (site) sawSite = true;
+      else sawFiberWithoutSite = true;
+      return site;
+    }
+    sawFiberWithoutSite = true;
+    return null;
+  }
+  function ownerStackSite(error) {
+    const known2 = ownerStackSites.get(error);
+    if (known2 !== void 0) return known2;
+    const holder = Error;
+    const previous = holder.prepareStackTrace;
+    let text = "";
+    try {
+      holder.prepareStackTrace = void 0;
+      text = error.stack ?? "";
+    } catch {
+      text = "";
+    } finally {
+      holder.prepareStackTrace = previous;
+    }
+    const frames = parseStack(text);
+    const frame = frames[1];
+    const site = frame && !BOTTOM_FRAME.test(frame.fn) ? { url: frame.url, line: frame.line, column: frame.column, exact: false } : null;
+    ownerStackSites.set(error, site);
+    return site;
+  }
+  function sourcesUnavailable() {
+    return sawFiberWithoutSite && !sawSite;
+  }
+  var ContextProviderTag = 10;
+  var ContextConsumerTag = 9;
+  var isProviderTag = (tag) => tag === ContextProviderTag;
+  var isConsumerTag = (tag) => tag === ContextConsumerTag;
+  function contextOf(f) {
+    const type = f.type;
+    return type?._context ?? type ?? null;
+  }
+  var HOOKS_WITHOUT_CELLS = /* @__PURE__ */ new Set(["useContext", "useDebugValue", "use", "useMemoCache", "useHostTransitionStatus", "useFormStatus"]);
+  var HOOK_CELLS = {
+    useSyncExternalStore: 2,
+    useTransition: 2,
+    useActionState: 3,
+    useFormState: 3
+  };
+  var hookCells = (type) => HOOKS_WITHOUT_CELLS.has(type) ? 0 : HOOK_CELLS[type] ?? 1;
+  var LANES_18 = [
+    [1, "Sync"],
+    [2, "InputContinuousHydration"],
+    [4, "InputContinuous"],
+    [8, "DefaultHydration"],
+    [16, "Default"],
+    [32, "TransitionHydration"],
+    [4194240, "Transition"],
+    [31 << 22, "Retry"],
+    [1 << 27, "SelectiveHydration"],
+    [1 << 28, "IdleHydration"],
+    [1 << 29, "Idle"],
+    [1 << 30, "Offscreen"]
+  ];
+  var LANES_19 = [
+    [1, "SyncHydration"],
+    [2, "Sync"],
+    [4, "InputContinuousHydration"],
+    [8, "InputContinuous"],
+    [16, "DefaultHydration"],
+    [32, "Default"],
+    [64, "TransitionHydration"],
+    [261888, "Transition"],
+    [3932160, "TransitionDeferred"],
+    [62914560, "Retry"],
+    [1 << 26, "SelectiveHydration"],
+    [1 << 27, "IdleHydration"],
+    [1 << 28, "Idle"],
+    [1 << 29, "Offscreen"],
+    [1 << 30, "Deferred"]
+  ];
+  function laneLabel(lanes) {
+    if (!lanes) return void 0;
+    const lowest = lanes & -lanes;
+    for (const [mask, label] of majorVersion() >= 19 ? LANES_19 : LANES_18) if (lowest & mask) return label;
+    return `lane:${lowest}`;
+  }
+  var captured = /* @__PURE__ */ new Set();
+  function captureRenderers() {
+    const target2 = globalThis;
+    let hook = target2.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (!hook) {
+      const renderers = /* @__PURE__ */ new Map();
+      const noop = () => {
+      };
+      hook = {
+        renderers,
+        supportsFiber: true,
+        isDisabled: false,
+        inject(renderer2) {
+          const id = renderers.size + 1;
+          renderers.set(id, renderer2);
+          return id;
+        },
+        onCommitFiberRoot: noop,
+        onCommitFiberUnmount: noop,
+        onPostCommitFiberRoot: noop,
+        onScheduleFiberRoot: noop,
+        checkDCE: noop,
+        on: noop,
+        off: noop,
+        emit: noop,
+        sub: () => noop
+      };
+      target2.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook;
+    }
+    for (const renderer2 of hook.renderers?.values() ?? []) captured.add(renderer2);
+    const original = hook.inject;
+    if (typeof original === "function" && !original.rprCaptured) {
+      const inject = function(renderer2) {
+        captured.add(renderer2);
+        return original.call(this, renderer2);
+      };
+      inject.rprCaptured = true;
+      hook.inject = inject;
+    }
+  }
+  function knownRenderers() {
+    const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    return [...captured, ...hook?.renderers?.values() ?? []];
+  }
+  function reactVersion() {
+    return knownRenderers().find((r) => r.version)?.version ?? null;
+  }
+  function renderer() {
+    return knownRenderers().find((r) => r.currentDispatcherRef) ?? null;
+  }
+  function majorVersion() {
+    return Number.parseInt(reactVersion() ?? "", 10) || 0;
+  }
+
+  // src/core/commit-hook.ts
+  var RecorderError = class extends Error {
+    constructor(code, message, owner) {
+      super(message);
+      this.code = code;
+      this.owner = owner;
+      this.name = "RecorderError";
+    }
+  };
+  function hookOwner(root) {
+    const setter = Object.getOwnPropertyDescriptor(root, "current")?.set;
+    if (!setter) return null;
+    return setter.owner ?? "unknown script";
+  }
+  function hookCommits(roots, owner, onCommit, onUpdate) {
+    for (const root of roots) {
+      const busy = hookOwner(root);
+      if (busy) throw new RecorderError("BUSY", `root.current is already hooked by ${busy}: wait for it to finish or call its stop()`, busy);
+    }
+    const errors = [];
+    const overhead = { commitMs: 0, maxCommitMs: 0 };
+    const restores = roots.map((root) => {
+      let current = root.current;
+      let lanes = 0;
+      let passthrough = false;
+      const set = (fiber) => {
+        current = fiber;
+        const taken = lanes;
+        lanes = 0;
+        if (passthrough) return;
+        const started = performance.now();
+        try {
+          onCommit({ root, fiber, lanes: taken });
+        } catch (error) {
+          if (errors.length < 3) errors.push(String(error?.stack || error).slice(0, 300));
+        }
+        const ms = performance.now() - started;
+        overhead.commitMs += ms;
+        overhead.maxCommitMs = Math.max(overhead.maxCommitMs, ms);
+      };
+      set.owner = `react-perf-recorder:${owner}`;
+      Object.defineProperty(root, "current", { configurable: true, enumerable: true, get: () => current, set });
+      const pendingDescriptor = Object.getOwnPropertyDescriptor(root, "pendingLanes");
+      let pendingLanes = root.pendingLanes ?? 0;
+      const hasPending = pendingDescriptor && "value" in pendingDescriptor && pendingDescriptor.configurable;
+      if (hasPending) {
+        Object.defineProperty(root, "pendingLanes", {
+          configurable: true,
+          enumerable: true,
+          get: () => pendingLanes,
+          set: (value) => {
+            const added = value & ~pendingLanes;
+            lanes |= pendingLanes & ~value;
+            pendingLanes = value;
+            if (!added || passthrough || !onUpdate) return;
+            try {
+              onUpdate();
+            } catch (error) {
+              if (errors.length < 3) errors.push(String(error?.stack || error).slice(0, 300));
+            }
+          }
+        });
+      }
+      return () => {
+        if (Object.getOwnPropertyDescriptor(root, "current")?.set === set) {
+          Object.defineProperty(root, "current", { configurable: true, enumerable: true, writable: true, value: current });
+        } else {
+          passthrough = true;
+        }
+        if (hasPending) Object.defineProperty(root, "pendingLanes", { configurable: true, enumerable: true, writable: true, value: pendingLanes });
+      };
+    });
+    let active = true;
+    return {
+      overhead,
+      stop() {
+        if (active) restores.forEach((restore) => restore());
+        active = false;
+        return errors;
+      }
+    };
+  }
+
+  // src/core/sites.ts
+  var positionKey = (p) => `${p.url}:${p.line}:${p.column}`;
+  var known = /* @__PURE__ */ new Map();
+  var asked = /* @__PURE__ */ new Set();
+  var queue = /* @__PURE__ */ new Map();
+  var listeners = /* @__PURE__ */ new Set();
+  var mapper = null;
+  var inFlight = null;
+  var scheduled = null;
+  function mappedSite(position) {
+    const key = positionKey(position);
+    const site = known.get(key);
+    if (site) return site;
+    if (site === "" || !mapper) return void 0;
+    if (!asked.has(key)) {
+      asked.add(key);
+      queue.set(key, position);
+      schedule();
+    }
+    return void 0;
+  }
+  function schedule() {
+    if (scheduled || inFlight) return;
+    scheduled = setTimeout(() => {
+      scheduled = null;
+      void flush();
+    }, 0);
+  }
+  function flush() {
+    if (!mapper || !queue.size) return Promise.resolve();
+    const positions = [...queue.values()];
+    queue.clear();
+    const request = mapper(positions).then((sites) => {
+      for (const [key, site] of Object.entries(sites)) known.set(key, site);
+      for (const position of positions) if (!known.has(positionKey(position))) known.set(positionKey(position), "");
+      if (Object.keys(sites).length) for (const listener of listeners) listener();
+    }).catch(() => {
+      for (const position of positions) asked.delete(positionKey(position));
+    }).finally(() => {
+      inFlight = null;
+      if (queue.size) schedule();
+    });
+    inFlight = request;
+    return request;
+  }
+
+  // src/core/fiber.ts
+  var Tag = {
+    FunctionComponent: 0,
+    ClassComponent: 1,
+    IndeterminateComponent: 2,
+    HostRoot: 3,
+    HostPortal: 4,
+    HostComponent: 5,
+    HostText: 6,
+    ForwardRef: 11,
+    MemoComponent: 14,
+    SimpleMemoComponent: 15,
+    HostHoistable: 26,
+    HostSingleton: 27
+  };
+  var ProfileMode = 2;
+  var isHost = (f) => f.tag === Tag.HostComponent || f.tag === Tag.HostHoistable || f.tag === Tag.HostSingleton;
+  var isComposite = (f) => typeof f.type === "function" || Boolean(f.type?.render || f.type?.type);
+  var mountedInPlace = (f) => f.alternate === null && isComposite(f) && f.return !== null && f.return.alternate !== null && f.return.tag !== Tag.HostRoot;
+  var hasHooks = (f) => f.tag === Tag.FunctionComponent || f.tag === Tag.ForwardRef || f.tag === Tag.SimpleMemoComponent || f.tag === Tag.IndeterminateComponent;
+  var hasProfileTimings = (f) => (f.mode & ProfileMode) !== 0 && typeof f.actualDuration === "number";
+  function nameOf(f) {
+    if (isProviderTag(f.tag)) return `Provider(${contextOf(f)?.displayName || "context"})`;
+    if (isConsumerTag(f.tag)) return `Consumer(${contextOf(f)?.displayName || "context"})`;
+    const t = f.type;
+    if (t == null || typeof t === "string") return null;
+    if (typeof t === "function") return t.displayName || f.elementType?.displayName || t.name || "Anonymous";
+    if (typeof t === "object") {
+      if (t.displayName) return t.displayName;
+      if (t.render) return t.render.displayName || t.render.name || "ForwardRef";
+      if (t.type) return t.type.displayName || t.type.name || "Memo";
+    }
+    return null;
+  }
+  var isProvider = (name) => name.startsWith("Provider(");
+  function wrapsProvider(f) {
+    const child = currentOf(f).child;
+    return Boolean(child && !child.sibling && isProvider(nameOf(child) ?? ""));
+  }
+  var libraryByType = /* @__PURE__ */ new WeakMap();
+  function isLibraryFiber(f) {
+    const type = typeof f.type === "function" || f.type && typeof f.type === "object" ? f.type : null;
+    const known2 = type ? libraryByType.get(type) : void 0;
+    if (known2 !== void 0) return known2;
+    const library = definedInPackage(f);
+    if (type) libraryByType.set(type, library);
+    return library;
+  }
+  function definedInPackage(f) {
+    const site = siteOf(f.child ?? f);
+    return !site || libraryOf(site.url) !== null;
+  }
+  function sourceOf(f, root = "") {
+    const site = siteOf(f);
+    if (!site) return "";
+    const file = relativeFile(site.url, root);
+    if (site.exact) return `${file}:${site.line}`;
+    return mappedSite(site) || file;
+  }
+  function generatedSourceOf(f) {
+    const site = siteOf(f);
+    return site && !site.exact ? { url: site.url, line: site.line, column: site.column } : void 0;
+  }
+  function siteKeyOf(f, root = "") {
+    const site = siteOf(f);
+    return site ? `${relativeFile(site.url, root)}:${site.line}:${site.column}` : "";
+  }
+  function relativeFile(fileName, root = "") {
+    const file = fileName.replace(/^[a-z]+:\/\/[^/]+/, "").replace(/[?#].*$/, "");
+    if (root && file.startsWith(root)) return file.slice(root.length).replace(/^\/+/, "");
+    const i = file.lastIndexOf("/src/");
+    return i >= 0 ? file.slice(i + 1) : file.replace(/^\/+/, "").split("/").slice(-3).join("/");
+  }
+  var fiberKey = null;
+  function fiberFromNode(node) {
+    for (let el = node; el; el = el.parentNode) {
+      if (!fiberKey) fiberKey = Object.keys(el).find((k) => k.startsWith("__reactFiber$")) ?? null;
+      const fiber = fiberKey ? el[fiberKey] : void 0;
+      if (fiber) return fiber;
+    }
+    return null;
+  }
+  function eachFiber(visit) {
+    for (const root of findRoots()) {
+      const stack = [root.current];
+      while (stack.length) {
+        const f = stack.pop();
+        if (visit(f) === false) return;
+        if (f.sibling) stack.push(f.sibling);
+        if (f.child) stack.push(f.child);
+      }
+    }
+  }
+  function hostRootOf(f) {
+    let node = f;
+    while (node?.return) node = node.return;
+    return node?.tag === Tag.HostRoot ? node.stateNode : null;
+  }
+  var created = /* @__PURE__ */ new Set();
+  function findRoots(doc = document) {
+    const roots = /* @__PURE__ */ new Set();
+    for (const ref of created) {
+      const root = ref.deref();
+      if (!root) created.delete(ref);
+      else if (root.containerInfo?.isConnected && root.current) roots.add(root);
+    }
+    const candidates = [doc.getElementById("root"), ...Array.from(doc.body?.children ?? [])];
+    for (const el of Array.from(doc.body?.children ?? [])) candidates.push(...Array.from(el.children));
+    for (const el of candidates) {
+      if (!el) continue;
+      const key = Object.keys(el).find((k) => k.startsWith("__reactContainer$"));
+      const container = key ? el[key] : void 0;
+      if (container?.stateNode) roots.add(container.stateNode);
+    }
+    return [...roots];
+  }
+  function nearestHosts(f, limit = 500) {
+    const out = [];
+    const stack = f.child ? [f.child] : [];
+    if (isHost(f)) return [f.stateNode];
+    while (stack.length && out.length < limit) {
+      const node = stack.pop();
+      if (node.sibling) stack.push(node.sibling);
+      if (isHost(node)) {
+        out.push(node.stateNode);
+      } else if (node.tag === Tag.HostText) {
+        const parent = node.stateNode.parentElement;
+        if (parent && !out.includes(parent)) out.push(parent);
+      } else if (node.child) {
+        stack.push(node.child);
+      }
+    }
+    return out;
+  }
+  function compositeChain(f) {
+    const chain = [];
+    for (let node = f; node; node = node.return) if (isComposite(node)) chain.push(node);
+    return chain.reverse();
+  }
+  function currentOf(f) {
+    let top = f;
+    while (top.return) top = top.return;
+    if (top.tag !== Tag.HostRoot || top.stateNode?.current === top) return f;
+    return f.alternate ?? f;
+  }
+  function compositeChildren(f, skip, limit = 100) {
+    const out = [];
+    const stack = [];
+    const first = currentOf(f).child;
+    if (first) stack.push(first);
+    while (stack.length && out.length < limit) {
+      const node = stack.pop();
+      if (node.sibling) stack.push(node.sibling);
+      if (isComposite(node) && !skip(node)) out.push(node);
+      else if (node.child) stack.push(node.child);
+    }
+    return out;
+  }
+
+  // src/core/dom.ts
+  var touchedHas = (touched, f) => touched.has(f) || f.alternate !== null && touched.has(f.alternate);
+  var DomWatcher = class {
+    constructor() {
+      this.counts = { text: 0, attr: 0, child: 0 };
+      this.observer = null;
+      this.scopeHosts = null;
+    }
+    setScopeHosts(hosts) {
+      this.scopeHosts = hosts;
+    }
+    start(target2 = document.body) {
+      this.observer = new MutationObserver((records) => this.consume(records, null));
+      this.observer.observe(target2, {
+        subtree: true,
+        characterData: true,
+        characterDataOldValue: true,
+        attributes: true,
+        attributeOldValue: true,
+        childList: true
+      });
+    }
+    takeForCommit() {
+      const touched = /* @__PURE__ */ new Set();
+      if (this.observer) this.consume(this.observer.takeRecords(), touched);
+      return touched;
+    }
+    stop() {
+      if (this.observer) this.consume(this.observer.takeRecords(), null);
+      this.observer?.disconnect();
+      this.observer = null;
+    }
+    inScope(node) {
+      const hosts = this.scopeHosts;
+      if (!hosts) return true;
+      for (const host of hosts) if (host.contains(node)) return true;
+      return false;
+    }
+    valueNow(m) {
+      if (m.type !== "attributes") return m.target.data ?? null;
+      const element = m.target;
+      return m.attributeName && typeof element.getAttribute === "function" ? element.getAttribute(m.attributeName) : null;
+    }
+    recordKey(m) {
+      return m.type === "attributes" ? `a:${m.attributeName}` : "t";
+    }
+    /**
+     * Compares the oldest overwritten value with the current one: React 19 blanks a form field's `name` and writes
+     * it straight back on every render, two writes that change nothing.
+     */
+    changedSomething(m, before) {
+      if (m.type === "childList") return true;
+      const oldest = before.get(m.target)?.get(this.recordKey(m));
+      return (oldest === void 0 ? m.oldValue : oldest) !== this.valueNow(m);
+    }
+    /** One half of each fiber pair is enough, as readers check both; host fibers are skipped, nobody asks about them. */
+    mark(node, touched) {
+      for (let f = fiberFromNode(node); f; f = f.return) {
+        if (isHost(f) || f.tag === Tag.HostText) continue;
+        if (touchedHas(touched, f)) return;
+        touched.add(f);
+      }
+    }
+    consume(records, touched) {
+      const before = /* @__PURE__ */ new Map();
+      for (const m of records) {
+        if (m.type === "childList") continue;
+        let perNode = before.get(m.target);
+        if (!perNode) before.set(m.target, perNode = /* @__PURE__ */ new Map());
+        const key = this.recordKey(m);
+        if (!perNode.has(key)) perNode.set(key, m.oldValue);
+      }
+      for (const m of records) {
+        if (!this.changedSomething(m, before)) continue;
+        if (touched) {
+          this.mark(m.target, touched);
+          if (m.type === "childList") {
+            m.addedNodes.forEach((node) => this.mark(node, touched));
+            if (m.removedNodes.length) {
+              const sibling = m.previousSibling ?? m.nextSibling;
+              if (sibling) this.mark(sibling, touched);
+            }
+          }
+        }
+        if (!this.inScope(m.target)) continue;
+        if (m.type === "characterData") this.counts.text++;
+        else if (m.type === "attributes") this.counts.attr++;
+        else this.counts.child++;
+      }
+    }
+  };
+
+  // src/core/scope.ts
+  function scopeFromFiber(target2, projectRoot = "") {
+    const chain = [];
+    for (let node = target2; node; node = node.return) chain.push(node);
+    chain.reverse();
+    return { kind: "scope", chain, name: nameOf(target2) ?? String(target2.type ?? "root"), source: sourceOf(target2, projectRoot) };
+  }
+  var sameKind = (a, b) => a.key === b.key && a.index === b.index && (a.elementType === b.elementType || (nameOf(a) ?? a.type) === (nameOf(b) ?? b.type));
+  var ScopeTracker = class {
+    constructor(handle) {
+      this.state = "attached";
+      this.remounts = 0;
+      this.lostAtMs = [];
+      this.anchors = handle.chain.slice();
+      this.name = handle.name;
+      this.source = handle.source;
+    }
+    get target() {
+      return this.anchors[this.anchors.length - 1];
+    }
+    /** Names of the composite ancestors above the scope, nearest last. */
+    ancestorNames() {
+      return this.anchors.slice(0, -1).map((f) => nameOf(f)).filter((n) => Boolean(n));
+    }
+    /** Walks the chain in a committed tree; `visit` snapshots each chain fiber and reports whether it rendered. */
+    resolve(committedRoot, visit, atMs) {
+      const first = this.anchors[0];
+      if (committedRoot !== first && committedRoot.alternate !== first) return { status: "untouched" };
+      const fibers = [];
+      const rendered = [];
+      let structural = false;
+      let node = committedRoot;
+      for (let i = 0; i < this.anchors.length; i++) {
+        if (i > 0) {
+          const parent = fibers[i - 1];
+          if (!structural && this.state === "attached" && parent.alternate && parent.child === parent.alternate.child) return { status: "untouched" };
+          const anchor = this.anchors[i];
+          let found = null;
+          if (!structural) {
+            for (let c = parent.child; c && !found; c = c.sibling) if (c === anchor || c.alternate === anchor) found = c;
+          }
+          if (!found) {
+            for (let c = parent.child; c && !found; c = c.sibling) if (sameKind(c, anchor)) found = c;
+            if (found) structural = true;
+          }
+          if (!found) return this.markLost(atMs);
+          node = found;
+        }
+        fibers.push(node);
+        rendered.push(visit(node).rendered);
+      }
+      this.anchors = fibers;
+      const remounted = structural || this.state === "lost";
+      if (remounted) this.remounts++;
+      this.state = "attached";
+      return { status: "found", fibers, rendered, remounted };
+    }
+    markLost(atMs) {
+      if (this.state === "attached") this.lostAtMs.push(Math.round(atMs));
+      this.state = "lost";
+      return { status: "lost" };
+    }
+  };
+
+  // src/core/live-highlight.ts
+  var PERFORMED_WORK = 1;
+  var ranNow = (f) => f.alternate !== null && isComposite(f) && (f.flags & PERFORMED_WORK) !== 0;
+  var LiveHighlight = class {
+    constructor(sink2, scope) {
+      this.sink = sink2;
+      this.hook = null;
+      this.dom = new DomWatcher();
+      this.scope = scope ? new ScopeTracker(scope) : null;
+    }
+    /** False when there is no React root or another script holds its commit hook. */
+    start() {
+      const roots = this.scope ? [hostRootOf(this.scope.target)].filter((r) => Boolean(r)) : findRoots();
+      if (!roots.length || roots.some((root) => hookOwner(root))) return false;
+      this.dom.start();
+      this.hook = hookCommits(roots, "live-highlight", (info) => this.onCommit(info));
+      return true;
+    }
+    stop() {
+      this.hook?.stop();
+      this.hook = null;
+      this.dom.stop();
+    }
+    onCommit({ fiber }) {
+      const touched = this.dom.takeForCommit();
+      let start = fiber;
+      if (this.scope) {
+        const res = this.scope.resolve(fiber, (f) => ({ rendered: ranNow(f) }), 0);
+        if (res.status !== "found") return;
+        start = res.fibers[res.fibers.length - 1];
+      }
+      const pairs = [];
+      const withoutDom = /* @__PURE__ */ new Set();
+      const mounted = /* @__PURE__ */ new Set();
+      const stack = [[start, null]];
+      while (stack.length) {
+        const [f, pending] = stack.pop();
+        let next = pending;
+        if (ranNow(f) && (!pending || pending[2] && !isLibraryFiber(f))) {
+          next = [nameOf(f) ?? "Anonymous", f, isLibraryFiber(f)];
+          if (!touchedHas(touched, f)) withoutDom.add(f);
+        } else if (!pending && mountedInPlace(f)) {
+          next = [nameOf(f) ?? "Anonymous", f, isLibraryFiber(f)];
+          mounted.add(f);
+        }
+        if (next && !next[2] && (isHost(f) || f.tag === Tag.HostText)) {
+          const el = isHost(f) ? f.stateNode : f.stateNode.parentElement;
+          if (el) pairs.push([el, next[0], next[1]]);
+          next = null;
+        }
+        if (f !== start && f.sibling) stack.push([f.sibling, pending]);
+        if (f.child && !(f.alternate && f.child === f.alternate.child)) stack.push([f.child, next]);
+      }
+      if (pairs.length) this.sink.flash(pairs, withoutDom, mounted);
+    }
+  };
+
+  // src/shared/same-content.ts
+  var REACT_ELEMENT = /* @__PURE__ */ Symbol.for("react.element");
+  var REACT_TRANSITIONAL_ELEMENT = /* @__PURE__ */ Symbol.for("react.transitional.element");
+  var ELEMENT_SKIP = /* @__PURE__ */ new Set(["_owner", "_store", "_self", "_source", "_debugInfo", "_debugStack", "_debugTask"]);
+  var isElement = (value) => {
+    const tag = value.$$typeof;
+    return tag === REACT_ELEMENT || tag === REACT_TRANSITIONAL_ELEMENT;
+  };
+  function sameContent(a, b, budget = 5e4) {
+    const stack = [[a, b]];
+    const seen = /* @__PURE__ */ new WeakMap();
+    let nodes = 0;
+    while (stack.length) {
+      const [x, y] = stack.pop();
+      if (Object.is(x, y)) continue;
+      if (++nodes > budget) return "unknown";
+      if (typeof x !== typeof y) return false;
+      if (typeof x === "function") continue;
+      if (typeof x !== "object" || x === null || y === null) return false;
+      const ox = x;
+      const oy = y;
+      if (seen.get(ox) === oy) continue;
+      seen.set(ox, oy);
+      if (Object.getPrototypeOf(ox) !== Object.getPrototypeOf(oy)) return false;
+      if (typeof Node !== "undefined" && ox instanceof Node) return false;
+      if (Array.isArray(ox)) {
+        const ay = oy;
+        if (ox.length !== ay.length) return false;
+        for (let i = 0; i < ox.length; i++) stack.push([ox[i], ay[i]]);
+      } else if (ox instanceof Date) {
+        if (ox.getTime() !== oy.getTime()) return false;
+      } else if (ox instanceof Map) {
+        const my = oy;
+        if (ox.size !== my.size) return false;
+        for (const [k, v] of ox) {
+          if (!my.has(k)) return false;
+          stack.push([v, my.get(k)]);
+        }
+      } else if (ox instanceof Set) {
+        const sy = oy;
+        if (ox.size !== sy.size) return false;
+        for (const v of ox) if (!sy.has(v)) return false;
+      } else if (ArrayBuffer.isView(ox)) {
+        const bx = new Uint8Array(ox.buffer, ox.byteOffset, ox.byteLength);
+        const view = oy;
+        const by = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+        if (bx.length !== by.length) return false;
+        for (let i = 0; i < bx.length; i++) if (bx[i] !== by[i]) return false;
+      } else {
+        const element = isElement(ox);
+        const keys = Object.keys(ox).filter((k) => !element || !ELEMENT_SKIP.has(k));
+        const keysY = Object.keys(oy).filter((k) => !element || !ELEMENT_SKIP.has(k));
+        if (keys.length !== keysY.length) return false;
+        for (const k of keys) {
+          if (!Object.prototype.hasOwnProperty.call(oy, k)) return false;
+          stack.push([ox[k], oy[k]]);
+        }
+      }
+    }
+    return true;
+  }
+
+  // src/shared/stats.ts
+  var topEntries = (map, n) => [...map].sort((a, b) => b[1] - a[1]).slice(0, n);
+  function medianGap(times) {
+    if (times.length < 2) return null;
+    const gaps = times.slice(1).map((t, i) => t - times[i]).sort((a, b) => a - b);
+    return gaps[Math.floor(gaps.length / 2)];
+  }
+
+  // src/shared/schema.ts
+  var RECORDING_SCHEMA = "react-perf-recorder/recording";
+  var GLOBAL_KEY = "__REACT_PERF_RECORDER__";
+  var CLIENT_HEADER = "x-react-perf-recorder";
+
+  // src/shared/segments.ts
+  var AMBIENT_POINTER = /^(pointer|mouse)(move|over|out|enter|leave)$/;
+  var eventName = (type) => type && AMBIENT_POINTER.test(type) ? "pointer" : type;
+  var USER_EVENTS = /* @__PURE__ */ new Set([
+    "click",
+    "input",
+    "change",
+    "keydown",
+    "keyup",
+    "keypress",
+    "pointerdown",
+    "pointerup",
+    "mousedown",
+    "mouseup",
+    "touchstart",
+    "touchend",
+    "submit",
+    "focusin",
+    "focusout",
+    "focus",
+    "blur",
+    "wheel",
+    "scroll",
+    "popstate"
+  ]);
+  var LATENCY_TYPES = {
+    click: ["pointerdown", "pointerup", "click", "mousedown", "mouseup"],
+    typing: ["keydown", "keypress", "keyup", "beforeinput", "input"],
+    change: ["pointerdown", "pointerup", "click", "change", "input"],
+    key: ["keydown", "keyup", "keypress"],
+    submit: ["keydown", "keyup", "click", "pointerup", "submit"]
+  };
+  function buildSegments(actions, commits, latency = [], frames = [], quietMs = 1e3) {
+    const sorted = actions.slice().sort((a, b) => a.atMs - b.atMs);
+    const byTime = commits.slice().sort((a, b) => a.t - b.t);
+    const segments = [];
+    let c = 0;
+    for (let i = 0; i < sorted.length; i++) {
+      const action = sorted[i];
+      const nextStart = sorted[i + 1]?.atMs ?? Infinity;
+      while (c < byTime.length && byTime[c].t < action.atMs) c++;
+      const segment = {
+        action: action.id,
+        atMs: action.atMs,
+        durationMs: 0,
+        commits: 0,
+        renders: 0,
+        reaction: { commits: 0, renders: 0 },
+        background: { commits: 0, renders: 0 },
+        topRoots: [],
+        commitIds: [],
+        longFrames: 0,
+        maxFrameMs: 0
+      };
+      const roots = /* @__PURE__ */ new Map();
+      let last = action.endMs;
+      let maxReaction = 0;
+      for (let j = c; j < byTime.length; j++) {
+        const commit = byTime[j];
+        if (commit.t >= nextStart || commit.t - last > quietMs) break;
+        last = Math.max(last, commit.t);
+        segment.commits++;
+        segment.renders += commit.n;
+        segment.commitIds.push(commit.i);
+        const bucket = commit.event && USER_EVENTS.has(commit.event) ? segment.reaction : segment.background;
+        bucket.commits++;
+        bucket.renders += commit.n;
+        if (bucket === segment.reaction) maxReaction = Math.max(maxReaction, commit.n);
+        for (const [root, cascade] of commit.roots ?? []) roots.set(root, (roots.get(root) ?? 0) + cascade);
+      }
+      const end = Math.min(nextStart, Math.max(last, action.endMs));
+      segment.durationMs = Math.max(0, Math.round(end - action.atMs));
+      segment.topRoots = [...roots].sort((a, b) => b[1] - a[1]).slice(0, 5);
+      if (action.kind === "typing" && action.chars) {
+        segment.perChar = {
+          commits: +(segment.reaction.commits / action.chars).toFixed(2),
+          renders: Math.round(segment.reaction.renders / action.chars),
+          maxRenders: maxReaction
+        };
+      }
+      const types = LATENCY_TYPES[action.kind];
+      if (types) {
+        const matched = latency.filter(
+          (e) => types.includes(e.type) && e.atMs >= action.atMs - 50 && e.atMs <= Math.max(action.endMs, action.atMs) + 50
+        );
+        if (matched.length) segment.latency = matched.reduce((worst, e) => e.duration > worst.duration ? e : worst);
+      }
+      for (const frame of frames) {
+        if (frame.atMs + frame.duration < action.atMs || frame.atMs > end) continue;
+        segment.longFrames++;
+        segment.maxFrameMs = Math.max(segment.maxFrameMs, frame.duration);
+      }
+      segments.push(segment);
+    }
+    return segments;
+  }
+
+  // src/core/actions.ts
+  var KEYS = /* @__PURE__ */ new Set(["Enter", "Escape", "Tab", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "PageUp", "PageDown", "Home", "End"]);
+  var SECRET_AUTOCOMPLETE = /(password|one-time-code|cc-number|cc-csc|cc-exp)/;
+  var TEXT_INPUT = /^(text|search|email|tel|url|number|password|)$/;
+  var TYPING_GAP_MS = 1500;
+  var SCROLL_GAP_MS = 300;
+  var INTERACTIVE = 'button, a, [role="button"], [role="tab"], [role="menuitem"], [role="option"], [role="checkbox"], [role="switch"], label, input, select, textarea, summary, [data-testid]';
+  function shortText(el, max) {
+    if (el === document.body || el === document.documentElement) return "";
+    const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+    let text = "";
+    for (let node = walker.nextNode(); node && text.length < max * 2; node = walker.nextNode()) text += ` ${node.nodeValue ?? ""}`;
+    return text.replace(/\s+/g, " ").trim().slice(0, max);
+  }
+  function isSecretField(el, secretSelector) {
+    if (secretSelector && el.matches(secretSelector)) return true;
+    if (el instanceof HTMLInputElement && el.type === "password") return true;
+    return SECRET_AUTOCOMPLETE.test(el.getAttribute("autocomplete") ?? "");
+  }
+  var isTextField = (el) => el instanceof HTMLTextAreaElement || el instanceof HTMLInputElement && TEXT_INPUT.test(el.type);
+  var ActionTracker = class {
+    constructor(options, now, emit) {
+      this.options = options;
+      this.now = now;
+      this.emit = emit;
+      this.actions = [];
+      this.nextId = 1;
+      this.typing = null;
+      this.scrolling = /* @__PURE__ */ new Map();
+      this.listeners = [];
+    }
+    start() {
+      const on = (type, handler) => {
+        const listener = (event) => {
+          if (this.isOwn(event)) return;
+          try {
+            handler(event);
+          } catch {
+          }
+        };
+        window.addEventListener(type, listener, { capture: true, passive: true });
+        this.listeners.push([type, listener]);
+      };
+      on("input", (e) => this.onInput(e));
+      on("change", (e) => this.onChange(e));
+      on("click", (e) => this.onClick(e));
+      on("keydown", (e) => this.onKey(e));
+      on("submit", (e) => this.push("submit", e.target));
+      on("scroll", (e) => this.onScroll(e));
+    }
+    /** Called by the navigation tracker: back and forward are user actions, push and replace are consequences. */
+    navigation(url) {
+      this.flushTyping();
+      this.record({ id: this.nextId++, kind: "navigation", atMs: Math.round(this.now()), endMs: Math.round(this.now()), url });
+    }
+    stop() {
+      for (const [type, listener] of this.listeners) window.removeEventListener(type, listener, { capture: true });
+      this.listeners = [];
+      this.flushTyping();
+      for (const [target2, pending] of this.scrolling) {
+        clearTimeout(pending.timer);
+        this.scrolling.delete(target2);
+        this.record(pending.action);
+      }
+    }
+    describe(el, event) {
+      const target2 = { tag: el.tagName.toLowerCase() };
+      const testId = el.closest("[data-testid]");
+      if (testId && (testId === el || testId.contains(el))) target2.testId = testId.getAttribute("data-testid") ?? void 0;
+      const name = el.getAttribute("name");
+      if (name) target2.name = name;
+      const label = el.getAttribute("aria-label") ?? el.getAttribute("placeholder") ?? void 0;
+      if (label) target2.label = label.slice(0, 60);
+      const role = el.getAttribute("role");
+      if (role) target2.role = role;
+      if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement)) {
+        const text = shortText(el, 40);
+        if (text) target2.text = text;
+      }
+      const id = el.getAttribute("id");
+      if (id) target2.id = id;
+      const href = el.getAttribute("href");
+      if (href) target2.href = href.slice(0, 200);
+      if (el.hasAttribute("disabled")) target2.disabled = true;
+      if (el instanceof HTMLInputElement && (el.type === "checkbox" || el.type === "radio")) target2.checked = el.checked;
+      const selector = this.selectorOf(el);
+      if (selector) {
+        target2.selector = selector;
+        const like = document.querySelectorAll(selector);
+        if (like.length > 1) target2.nth = [...like].indexOf(el);
+      }
+      const box = el.getBoundingClientRect();
+      if (box.width || box.height) {
+        target2.box = { x: Math.round(box.x), y: Math.round(box.y), w: Math.round(box.width), h: Math.round(box.height) };
+      }
+      const pointer = event;
+      if (pointer && typeof pointer.clientX === "number" && (pointer.clientX || pointer.clientY)) {
+        target2.point = { x: Math.round(pointer.clientX), y: Math.round(pointer.clientY) };
+      }
+      const owner = this.ownerOf(el);
+      if (owner) {
+        target2.component = nameOf(owner) ?? void 0;
+        const source = sourceOf(owner, this.options.projectRoot);
+        if (source) target2.source = source;
+        const generated = generatedSourceOf(owner);
+        if (generated) target2.generatedSource = generated;
+        const path = this.pathOf(owner);
+        if (path.length) target2.path = path;
+      }
+      const inScope = this.options.inScope(el);
+      if (inScope !== void 0) target2.inScope = inScope;
+      return target2;
+    }
+    /** `[data-testid="send"]`, `#amount`, `button[name="save"]`: enough to find the element again. */
+    selectorOf(el) {
+      const tag = el.tagName.toLowerCase();
+      const testId = el.getAttribute("data-testid");
+      if (testId) return `[data-testid="${CSS.escape(testId)}"]`;
+      const id = el.getAttribute("id");
+      if (id) return `#${CSS.escape(id)}`;
+      const own2 = ["name", "role", "aria-label", "type", "href"].map((attr) => [attr, el.getAttribute(attr)]).find(([, value]) => value);
+      const self = own2 ? `${tag}[${own2[0]}="${CSS.escape(own2[1])}"]` : tag;
+      const anchor = el.parentElement?.closest("[data-testid]");
+      const inside = anchor?.getAttribute("data-testid");
+      return inside ? `[data-testid="${CSS.escape(inside)}"] ${self}` : self;
+    }
+    /** The component that rendered the element: the first with a name of its own, wrappers and providers skipped. */
+    ownerOf(el) {
+      for (let f = fiberFromNode(el); f; f = f.return) {
+        const name = nameOf(f);
+        if (name && !isProvider(name) && !this.options.wrapperPattern.test(name)) return f;
+      }
+      return null;
+    }
+    /** The app's components above the one that rendered the element, nearest last: `Layout › Chat › MessageRow`. */
+    pathOf(owner) {
+      const path = [];
+      for (let f = owner.return; f && path.length < 4; f = f.return) {
+        const name = nameOf(f);
+        if (!name || isProvider(name) || this.options.wrapperPattern.test(name) || isLibraryFiber(f) || wrapsProvider(f)) continue;
+        path.push(name);
+      }
+      return path.reverse();
+    }
+    isOwn(event) {
+      const host = this.options.ownHost;
+      return Boolean(host && event.composedPath().includes(host));
+    }
+    record(action) {
+      if (this.actions.length >= 5e3) return;
+      this.actions.push(action);
+      this.emit(action);
+    }
+    push(kind, el, extra = {}, event) {
+      if (!el) return;
+      this.flushTyping();
+      const at = Math.round(this.now());
+      this.record({ id: this.nextId++, kind, atMs: at, endMs: at, target: this.describe(el, event), ...extra });
+    }
+    valueFields(el) {
+      if (isSecretField(el, this.options.secretSelector)) return { secret: true };
+      const value = el.value ?? "";
+      return { length: value.length, ...this.options.values ? { value: value.slice(0, 200) } : {} };
+    }
+    onInput(event) {
+      const el = event.target;
+      if (!(el instanceof Element) || !(isTextField(el) || el.isContentEditable)) return;
+      const now = Math.round(this.now());
+      if (this.typing && this.typing.el === el && now - this.typing.action.endMs < TYPING_GAP_MS) {
+        const action = this.typing.action;
+        action.chars = (action.chars ?? 0) + 1;
+        action.endMs = now;
+        Object.assign(action, this.valueFields(el));
+        return;
+      }
+      this.flushTyping();
+      this.typing = {
+        el,
+        action: { id: this.nextId++, kind: "typing", atMs: now, endMs: now, target: this.describe(el), chars: 1, ...this.valueFields(el) }
+      };
+    }
+    onChange(event) {
+      const el = event.target;
+      if (!(el instanceof Element) || isTextField(el)) return;
+      const extra = isSecretField(el, this.options.secretSelector) ? { secret: true } : this.options.values ? {
+        value: el instanceof HTMLInputElement && /checkbox|radio/.test(el.type) ? String(el.checked) : String(el.value ?? "").slice(0, 200)
+      } : {};
+      this.push("change", el, extra);
+    }
+    onClick(event) {
+      const el = event.target instanceof Element ? event.target : null;
+      this.push("click", el?.closest(INTERACTIVE) ?? el, {}, event);
+    }
+    onKey(event) {
+      if (!KEYS.has(event.key) || event.repeat) return;
+      const el = event.target instanceof Element ? event.target : document.activeElement;
+      this.push("key", el ?? document.body, { key: event.key });
+    }
+    onScroll(event) {
+      const target2 = event.target;
+      const el = target2 === document ? document.scrollingElement : target2;
+      if (!(el instanceof Element)) return;
+      const top = Math.round(el.scrollTop);
+      const now = Math.round(this.now());
+      const pending = this.scrolling.get(target2);
+      if (pending) {
+        clearTimeout(pending.timer);
+        const scroll = pending.action.scroll;
+        scroll.pixels += Math.abs(top - scroll.to);
+        scroll.to = top;
+        pending.action.endMs = now;
+      }
+      const entry = pending ?? {
+        action: {
+          id: this.nextId++,
+          kind: "scroll",
+          atMs: now,
+          endMs: now,
+          target: this.describe(el),
+          scroll: { from: top, to: top, pixels: 0 }
+        },
+        timer: 0
+      };
+      entry.timer = setTimeout(() => {
+        this.scrolling.delete(target2);
+        this.record(entry.action);
+      }, SCROLL_GAP_MS);
+      this.scrolling.set(target2, entry);
+    }
+    flushTyping() {
+      if (!this.typing) return;
+      this.record(this.typing.action);
+      this.typing = null;
+    }
+  };
+
+  // src/core/reasons.ts
+  var MAX_PROPS = 10;
+  var same = (a, b) => sameContent(a, b, 2e4) === true;
+  var sameCheap = (a, b) => sameContent(a, b, 2e3) === true;
+  function snapshotOf(f) {
+    return { props: f.memoizedProps, state: f.memoizedState, ctx: f.dependencies?.firstContext ?? null };
+  }
+  function didRender(prev, f) {
+    return Boolean(prev) && (prev.props !== f.memoizedProps || prev.state !== f.memoizedState || prev.ctx !== (f.dependencies?.firstContext ?? null));
+  }
+  function propsReason(before, after) {
+    const a = before || {};
+    const b = after || {};
+    const changed = [];
+    const sameShape = [];
+    for (const key of /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])) {
+      if (key === "children" && a[key] === b[key]) continue;
+      if (a[key] === b[key]) continue;
+      (key in a && key in b && same(a[key], b[key]) ? sameShape : changed).push(key);
+    }
+    return {
+      kind: "props",
+      ...changed.length ? { changed: changed.slice(0, MAX_PROPS) } : {},
+      ...sameShape.length ? { sameRef: sameShape.slice(0, MAX_PROPS) } : {}
+    };
+  }
+  function reasonsOf(prev, f, describe) {
+    if (prev.props !== f.memoizedProps) return [propsReason(prev.props, f.memoizedProps)];
+    const out = [];
+    if (hasHooks(f)) {
+      let a = prev.state;
+      let b = f.memoizedState;
+      let before = null;
+      for (let i = 0; a && b && i < 1e3; i++) {
+        if (b.queue && a.memoizedState !== b.memoizedState) {
+          const mark = same(a.memoizedState, b.memoizedState) ? { sameContent: true } : null;
+          if (b.queue.getSnapshot) {
+            const deps = Array.isArray(before?.memoizedState) ? before.memoizedState[1] : null;
+            const selector = Array.isArray(deps) && typeof deps[2] === "function" ? describe.selector(deps[2]) : "";
+            const store = Array.isArray(deps) && typeof deps[0] === "function" ? describe.store(deps[0]) : null;
+            out.push({ kind: "store", hook: i, ...store ? { store } : {}, ...selector ? { selector } : {}, ...mark });
+          } else if (b.queue.lastRenderedReducer) {
+            out.push({ kind: "state", hook: i, ...mark });
+          }
+        }
+        before = b;
+        a = a.next;
+        b = b.next;
+      }
+    } else if (f.tag === Tag.ClassComponent && prev.state !== f.memoizedState) {
+      out.push({ kind: "state", ...same(prev.state, f.memoizedState) ? { sameContent: true } : {} });
+    }
+    const current = f.dependencies?.firstContext ?? null;
+    if (current && prev.ctx !== current) {
+      const old = /* @__PURE__ */ new Map();
+      for (let d = prev.ctx; d; d = d.next) old.set(d.context, d.memoizedValue);
+      for (let d = current; d; d = d.next) {
+        if (!old.has(d.context) || old.get(d.context) === d.memoizedValue) continue;
+        out.push({
+          kind: "context",
+          context: d.context.displayName || "(unnamed)",
+          contextObject: d.context,
+          ...same(old.get(d.context), d.memoizedValue) ? { sameContent: true } : {}
+        });
+      }
+    }
+    if (!out.length && hasHooks(f) && prev.state !== f.memoizedState) return [{ kind: "bailout" }];
+    return out.length ? out : [{ kind: "unknown" }];
+  }
+  function parentReason(prev, f, describe) {
+    if (prev.props === f.memoizedProps) return reasonsOf(prev, f, describe);
+    const a = prev.props || {};
+    const b = f.memoizedProps || {};
+    const changed = [];
+    const sameShape = [];
+    let children = false;
+    const compare = (key) => {
+      if (a[key] === b[key]) return;
+      if (key === "children") children = true;
+      else (key in a && key in b && sameCheap(a[key], b[key]) ? sameShape : changed).push(key);
+    };
+    for (const key in a) compare(key);
+    for (const key in b) if (!(key in a)) compare(key);
+    if (!changed.length && !sameShape.length) return [{ kind: "parent", ...children ? { children: true } : { equal: true } }];
+    return [
+      {
+        kind: "parent",
+        ...changed.length ? { changed: changed.slice(0, MAX_PROPS) } : {},
+        ...sameShape.length ? { sameRef: sameShape.slice(0, MAX_PROPS) } : {},
+        ...children ? { children: true } : {}
+      }
+    ];
+  }
+  function hookTypeAt(f, index) {
+    const types = f._debugHookTypes;
+    if (!types) return void 0;
+    let cell = 0;
+    for (const type of types) {
+      const cells = hookCells(type);
+      if (!cells) continue;
+      if (index < cell + cells) return type;
+      cell += cells;
+    }
+    return void 0;
+  }
+  var GENERIC_NAMES = /* @__PURE__ */ new Set(["", "anonymous", "selector", "select", "fn", "memoized", "memoizedFn"]);
+  function fallbackSelectorLabel(fn) {
+    const name = fn.name.replace(/^bound /, "");
+    if (!GENERIC_NAMES.has(name)) return name;
+    return String(fn).replace(/\s+/g, " ").slice(0, 100);
+  }
+
+  // src/core/memo-hits.ts
+  var HOOK_TAGS = /* @__PURE__ */ new Set([Tag.FunctionComponent, Tag.ForwardRef, Tag.SimpleMemoComponent]);
+  var MAX_LISTED = 30;
+  var MAX_INSPECTED = 15;
+  var cellsByType = /* @__PURE__ */ new WeakMap();
+  function memoCells(f) {
+    const type = f.type;
+    if (!type || typeof type !== "function" && typeof type !== "object") return null;
+    const known2 = cellsByType.get(type);
+    if (known2 !== void 0) return known2;
+    const types = f._debugHookTypes;
+    if (!types) return null;
+    const cells = [];
+    let cell = 0;
+    for (const t of types) {
+      const n = hookCells(t);
+      if (!n) continue;
+      if (t === "useMemo" || t === "useCallback") cells.push([cell, t]);
+      cell += n;
+    }
+    const result = cells.length ? cells : null;
+    cellsByType.set(type, result);
+    return result;
+  }
+  var MemoHits = class {
+    constructor(sourceOf2) {
+      this.sourceOf = sourceOf2;
+      this.components = /* @__PURE__ */ new Map();
+    }
+    track(name, f, previousHooks) {
+      if (!HOOK_TAGS.has(f.tag)) return;
+      const cells = memoCells(f);
+      if (!cells) return;
+      let entry = this.components.get(name);
+      if (!entry) this.components.set(name, entry = { source: this.sourceOf(f), hooks: /* @__PURE__ */ new Map(), latest: null });
+      let before = previousHooks;
+      let after = f.memoizedState;
+      let at = 0;
+      let missed = false;
+      for (const [cell, kind] of cells) {
+        for (; at < cell && before && after; at++) {
+          before = before.next;
+          after = after.next;
+        }
+        if (!before || !after) break;
+        const old = before.memoizedState;
+        const now = after.memoizedState;
+        if (!Array.isArray(old) || !Array.isArray(now)) continue;
+        let hook = entry.hooks.get(cell);
+        if (!hook) entry.hooks.set(cell, hook = { kind, renders: 0, recomputed: 0, noDeps: false, deps: /* @__PURE__ */ new Map() });
+        hook.renders++;
+        if (old === now) continue;
+        hook.recomputed++;
+        missed = true;
+        const oldDeps = old[1];
+        const newDeps = now[1];
+        if (!oldDeps || !newDeps) {
+          hook.noDeps = true;
+          continue;
+        }
+        for (let i = 0; i < Math.max(oldDeps.length, newDeps.length); i++) {
+          if (Object.is(oldDeps[i], newDeps[i])) continue;
+          let dep = hook.deps.get(i);
+          if (!dep) hook.deps.set(i, dep = { changed: 0, sameContent: 0 });
+          dep.changed++;
+          if (sameCheap(oldDeps[i], newDeps[i])) dep.sameContent++;
+        }
+      }
+      if (missed) entry.latest = new WeakRef(f);
+    }
+    /** The hooks that recomputed on half their renders or more, worst first; the worst are named by `inspect`. */
+    result(inspect) {
+      const listed = [];
+      for (const [component, entry] of this.components) {
+        for (const [hook, agg] of entry.hooks) {
+          if (agg.renders < 2 || agg.recomputed * 2 < agg.renders) continue;
+          listed.push({
+            component,
+            ...entry.source ? { source: entry.source } : {},
+            hook,
+            kind: agg.kind,
+            renders: agg.renders,
+            recomputed: agg.recomputed,
+            ...agg.noDeps ? { noDeps: true } : {},
+            deps: [...agg.deps].map(([index, d]) => ({ index, ...d })).sort((a, b) => b.changed - a.changed),
+            fiber: entry.latest?.deref()
+          });
+        }
+      }
+      listed.sort((a, b) => b.recomputed - a.recomputed || b.renders - a.renders);
+      const top = listed.slice(0, MAX_LISTED);
+      const named = /* @__PURE__ */ new Map();
+      for (const stat of top) {
+        const fiber = stat.fiber;
+        delete stat.fiber;
+        if (!fiber) continue;
+        if (!named.has(fiber) && named.size < MAX_INSPECTED) named.set(fiber, inspect(fiber));
+        const info = named.get(fiber)?.get(stat.hook);
+        if (info) stat.info = info;
+      }
+      return top;
+    }
+  };
+
+  // src/core/env/frames.ts
+  var supported = (type) => typeof PerformanceObserver !== "undefined" && (PerformanceObserver.supportedEntryTypes ?? []).includes(type);
+  var shortSource = (url, root) => {
+    if (!url) return "";
+    const path = url.replace(/^https?:\/\/[^/]+/, "").replace(/[?#].*$/, "");
+    if (root && path.startsWith(root)) return path.slice(root.length).replace(/^\/+/, "");
+    return path.replace(/^\/@fs\//, "/").replace(/^\//, "");
+  };
+  var FrameWatcher = class {
+    constructor(options) {
+      this.options = options;
+      this.longTasks = { count: 0, maxMs: 0, totalMs: 0 };
+      this.loaf = [];
+      this.latency = [];
+      /** Index in `latency` of the worst entry of each interaction, so the same interaction is kept once. */
+      this.worstByInteraction = /* @__PURE__ */ new Map();
+      this.observers = [];
+    }
+    start() {
+      const { t0 } = this.options;
+      const at = (time) => Math.round(time - t0);
+      if (supported("longtask")) {
+        this.observe("longtask", (entry) => {
+          if (entry.startTime < t0) return;
+          this.longTasks.count++;
+          this.longTasks.totalMs += Math.round(entry.duration);
+          this.longTasks.maxMs = Math.max(this.longTasks.maxMs, Math.round(entry.duration));
+        });
+      }
+      if (supported("long-animation-frame")) {
+        this.observe("long-animation-frame", (raw) => {
+          const entry = raw;
+          if (entry.startTime < t0 || this.loaf.length >= 500) return;
+          const scripts = (entry.scripts ?? []).slice().sort((a, b) => b.duration - a.duration).slice(0, 5).map((s) => {
+            const source = shortSource(s.sourceURL, this.options.projectRoot);
+            return {
+              invoker: String(s.invoker ?? s.sourceFunctionName ?? "").slice(0, 120),
+              source: s.sourceCharPosition != null && s.sourceCharPosition >= 0 ? `${source}@${s.sourceCharPosition}` : source,
+              duration: Math.round(s.duration),
+              layout: Math.round(s.forcedStyleAndLayoutDuration ?? 0),
+              .../react-perf-recorder/.test(s.sourceURL ?? "") ? { own: true } : {}
+            };
+          });
+          const frame = {
+            atMs: at(entry.startTime),
+            duration: Math.round(entry.duration),
+            blocking: Math.round(entry.blockingDuration ?? 0),
+            commits: this.options.countCommits(at(entry.startTime), at(entry.startTime + entry.duration)),
+            scripts
+          };
+          this.loaf.push(frame);
+          this.options.onFrame(frame);
+        });
+      }
+      if (supported("event")) {
+        this.observe(
+          "event",
+          (raw) => {
+            const entry = raw;
+            if (!entry.interactionId || entry.startTime < t0 || this.latency.length >= 2e3) return;
+            const latency = {
+              atMs: at(entry.startTime),
+              type: entry.name,
+              duration: Math.round(entry.duration),
+              inputDelay: Math.round(entry.processingStart - entry.startTime),
+              processing: Math.round(entry.processingEnd - entry.processingStart),
+              presentation: Math.max(0, Math.round(entry.startTime + entry.duration - entry.processingEnd)),
+              interactionId: entry.interactionId
+            };
+            const seen = this.worstByInteraction.get(latency.interactionId);
+            if (seen !== void 0 && this.latency[seen].duration >= latency.duration) return;
+            if (seen !== void 0) this.latency[seen] = latency;
+            else {
+              this.worstByInteraction.set(latency.interactionId, this.latency.length);
+              this.latency.push(latency);
+            }
+            this.options.onLatency(latency);
+          },
+          { durationThreshold: 16 }
+        );
+      }
+    }
+    stop() {
+      for (const [observer, onEntry] of this.observers) {
+        observer.takeRecords?.().forEach(onEntry);
+        observer.disconnect();
+      }
+      this.observers = [];
+    }
+    observe(type, onEntry, extra = {}) {
+      try {
+        const observer = new PerformanceObserver((list) => list.getEntries().forEach(onEntry));
+        observer.observe({ type, buffered: false, ...extra });
+        this.observers.push([observer, onEntry]);
+      } catch {
+      }
+    }
+  };
+
+  // src/core/env/navigations.ts
+  function trackHistory(now, onNavigation) {
+    const original = { pushState: history.pushState, replaceState: history.replaceState };
+    const wrapped = {};
+    const here = () => safeUrl(location.pathname + location.search);
+    for (const method of ["pushState", "replaceState"]) {
+      const fn = function(...args) {
+        const before = here();
+        const result = original[method].apply(this, args);
+        const url = here();
+        onNavigation({
+          type: method === "pushState" ? "push" : "replace",
+          atMs: Math.round(now()),
+          url,
+          ...url === before ? { sameUrl: true } : {}
+        });
+        return result;
+      };
+      wrapped[method] = fn;
+      history[method] = fn;
+    }
+    const onPop = () => onNavigation({ type: "pop", atMs: Math.round(now()), url: here() });
+    window.addEventListener("popstate", onPop);
+    return () => {
+      for (const method of ["pushState", "replaceState"]) if (history[method] === wrapped[method]) history[method] = original[method];
+      window.removeEventListener("popstate", onPop);
+    };
+  }
+
+  // src/shared/summary.ts
+  var perSec = (n, ms) => ms > 0 ? +(n * 1e3 / ms).toFixed(2) : 0;
+  function hookChain(hook, mode = "full") {
+    if (!hook) return "";
+    const steps = hook.path ?? [];
+    const at = hook.library && hook.libraryAt !== void 0 && hook.libraryAt < steps.length ? hook.libraryAt : -1;
+    if (!steps.length) return hook.type ?? "";
+    if (at < 0) return steps.join(" \u203A ");
+    if (mode === "short") return [...steps.slice(0, at), `${hook.library}.${steps[at]}`].join(" \u203A ");
+    return [...steps.slice(0, at), `[${hook.library}] ${steps[at]}`, ...steps.slice(at + 1)].join(" \u203A ");
+  }
+  function hookText(hook, mode = "full") {
+    if (!hook) return "";
+    const site = hook.site ? ` @ ${hook.site}${hook.code ? ` ${hook.code}` : ""}` : "";
+    return `${hookChain(hook, mode)}${site}`;
+  }
+  var contextKey = (name) => `ctx:${name}`;
+  function hookOf(root, reason) {
+    if (!reason) return void 0;
+    if (reason.kind === "context") return reason.context ? root.hooks?.[contextKey(reason.context)] : void 0;
+    return reason.hook !== void 0 ? root.hooks?.[reason.hook] : void 0;
+  }
+  var names = (list, max = 5) => (list ?? []).slice(0, max).join(", ");
+  function reasonText(reason) {
+    const mark = reason.sameContent ? " SAME-CONTENT" : "";
+    const props = [names(reason.changed), reason.sameRef?.length ? `same: ${names(reason.sameRef)}` : ""].filter(Boolean).join(" | ");
+    switch (reason.kind) {
+      case "state":
+        return reason.hook === void 0 ? `class state${mark}` : `state #${reason.hook}${mark}`;
+      case "store":
+        return `external store #${reason.hook}${mark}${reason.store ? ` [${reason.store}]` : ""}${reason.selector ? ` ${reason.selector}` : ""}`;
+      case "context":
+        return `context ${reason.context || "(unnamed)"}${mark}`;
+      case "props":
+        return `props: ${props || "(new object)"}`;
+      case "parent":
+        if (reason.equal) return "parent: props equal";
+        if (!props) return "parent: children";
+        return `parent: props ${props}${reason.children ? " +children" : ""}`;
+      case "bailout":
+        return "bailout: state set to the same value";
+      default:
+        return "unknown";
+    }
+  }
+  var textOf = (reason) => reason.text ?? reasonText(reason);
+  var reasonsById = (reasons = []) => new Map(reasons.map((r) => [r.i, r]));
+  function reasonLine(root, reason, n, mode = "full") {
+    if (!reason) return `${n}\xD7 unknown`;
+    const hook = hookText(hookOf(root, reason), mode);
+    return `${n}\xD7 ${textOf(reason)}${hook ? ` \xB7 ${hook}` : ""}`;
+  }
+  function rootLine(root, durationMs, reasons, mode = "full") {
+    return {
+      root: root.name,
+      source: root.source,
+      path: root.path,
+      hits: root.hits,
+      hitsPerSec: perSec(root.hits, durationMs),
+      instances: root.instances,
+      perHit: root.perHit,
+      noDomChange: root.noDomChange,
+      ...root.mounts ? { mounts: root.mounts } : {},
+      ...root.renderMs ? { renderMsPerHit: +(root.renderMs / Math.max(1, root.hits)).toFixed(2) } : {},
+      reasons: root.reasons.slice(0, 3).map(([id, n]) => reasonLine(root, reasons.get(id), n, mode)),
+      causes: root.causes.slice(0, 3).map(([k, n]) => `${n}\xD7 ${k}`),
+      ...root.lanes.length ? { lanes: root.lanes.map(([l, n]) => `${l}:${n}`).join(" ") } : {}
+    };
+  }
+  function memoWhy(m) {
+    if (m.noDeps) return "no dependency array: it runs on every render";
+    const dep = m.deps[0];
+    if (!dep) return "its dependencies changed";
+    const name = m.info?.deps?.[dep.index];
+    const which = name ? `\`${name}\`` : `dependency ${dep.index + 1}`;
+    return dep.sameContent === dep.changed ? `${which} is a new object with the same content every time` : dep.sameContent ? `${which} changed ${dep.changed}\xD7, ${dep.sameContent} of them to the same content` : `${which} changed ${dep.changed}\xD7`;
+  }
+  function memoLine(m) {
+    const site = m.info?.site ? ` \xB7 ${m.info.site}${m.info.code ? ` ${m.info.code}` : ""}` : m.source ? ` \xB7 ${m.source}` : "";
+    return `${m.component} \xB7 ${m.kind} #${m.hook} \xB7 recomputed ${m.recomputed} of ${m.renders} renders \u2014 ${memoWhy(m)}${site}`;
+  }
+  function actionText(action) {
+    const t = action.target;
+    const field = t ? t.testId ?? t.name ?? t.label ?? t.text ?? t.tag : "";
+    const where = t?.component ? ` in ${t.component}` : "";
+    switch (action.kind) {
+      case "typing":
+        return `typing ${action.chars ?? 0} chars into \xAB${field}\xBB${where}${action.secret ? " (secret)" : action.value !== void 0 ? ` = ${JSON.stringify(action.value)}` : ""}`;
+      case "key":
+        return `${action.key} on \xAB${field}\xBB${where}`;
+      case "scroll":
+        return `scroll \xAB${field}\xBB ${action.scroll?.pixels ?? 0}px`;
+      case "navigation":
+        return `back/forward to ${action.url}`;
+      default:
+        return `${action.kind} \xAB${field}\xBB${where}${action.value !== void 0 ? ` = ${JSON.stringify(action.value)}` : ""}`;
+    }
+  }
+  function summarize(rec, top = 5, hooks = "full") {
+    const ms = rec.durationMs;
+    const reasons = reasonsById(rec.reasons);
+    const allRoots = [...rec.roots, ...rec.outsideRoots];
+    const actionsById = new Map(rec.actions.map((a) => [a.id, a]));
+    const actions = rec.segments.slice().sort((a, b) => b.renders - a.renders).slice(0, 10).sort((a, b) => a.atMs - b.atMs).map((s) => {
+      const action = actionsById.get(s.action);
+      const root = s.topRoots[0] ? allRoots[s.topRoots[0][0]] : void 0;
+      return {
+        id: s.action,
+        what: action ? actionText(action) : `action ${s.action}`,
+        atSec: +(s.atMs / 1e3).toFixed(1),
+        commits: s.commits,
+        renders: s.renders,
+        reaction: s.reaction.renders,
+        ...s.perChar ? { perChar: `${s.perChar.renders} renders, ${s.perChar.commits} commits per char (max ${s.perChar.maxRenders})` } : {},
+        ...s.latency ? { latencyMs: s.latency.duration } : {},
+        ...s.longFrames ? { longFrames: s.longFrames } : {},
+        ...root ? {
+          topRoot: `${root.name} \xD7${s.topRoots[0][1]} \u2014 ${root.reasons[0] ? reasonLine(root, reasons.get(root.reasons[0][0]), root.reasons[0][1], hooks) : ""}`
+        } : {}
+      };
+    });
+    const texts2 = rec.totals.domTextChanges;
+    return {
+      ...rec.id ? { id: rec.id } : {},
+      ...rec.status ? { status: rec.status } : {},
+      ...rec.partial ? { partial: true } : {},
+      createdAt: rec.createdAt,
+      ...rec.label ? { label: rec.label } : {},
+      source: rec.tool.source,
+      url: rec.page.url,
+      viewport: rec.page.viewport,
+      durationSec: +(ms / 1e3).toFixed(1),
+      scope: rec.scope ? { name: rec.scope.name, source: rec.scope.source, state: rec.scope.state, remounts: rec.scope.remounts } : null,
+      totals: {
+        commits: rec.totals.commits,
+        commitsPerSec: perSec(rec.totals.commits, ms),
+        commitsInScope: rec.totals.commitsInScope,
+        renders: rec.totals.renders,
+        rendersPerScopeCommit: rec.totals.rendersPerScopeCommit,
+        rendersFromOutside: rec.totals.rendersFromOutside,
+        rendersWithoutDom: rec.totals.rendersWithoutDom,
+        domTextChanges: texts2,
+        rendersPerTextChange: texts2 ? +(rec.totals.renders / texts2).toFixed(1) : null
+      },
+      topRoots: rec.roots.slice(0, top).map((r) => rootLine(r, ms, reasons, hooks)),
+      outsideRoots: rec.outsideRoots.slice(0, 3).map((r) => rootLine(r, ms, reasons, hooks)),
+      topCauses: rec.causes.slice(0, 5).map((c) => ({
+        key: c.key,
+        events: c.events,
+        commits: c.commits,
+        ...c.keys ? {
+          keys: Object.entries(c.keys).sort((a, b) => b[1].changed + b[1].sameContent - (a[1].changed + a[1].sameContent)).slice(0, 6).map(([k, v]) => `${k}${v.sameContent ? ` (same content ${v.sameContent}/${v.changed + v.sameContent + v.unknown})` : ""}`).join(", ")
+        } : {}
+      })),
+      actions,
+      plugins: Object.fromEntries(
+        Object.entries(rec.plugins).filter(([, section]) => section.active ?? Boolean(section.highlights?.length)).map(([name, section]) => [name, { version: section.version, highlights: section.highlights.slice(0, 3) }])
+      ),
+      frames: {
+        longTasks: rec.frames.longTasks.count,
+        maxLongTaskMs: rec.frames.longTasks.maxMs,
+        longFrames: rec.frames.loaf.length,
+        worstFrameMs: rec.frames.loaf.reduce((m, f) => Math.max(m, f.duration), 0)
+      },
+      overhead: rec.overhead,
+      ...rec.memos?.length ? { memos: rec.memos.slice(0, 5).map(memoLine) } : {},
+      warnings: [...rec.warnings, ...rec.errors.map((e) => `error: ${e}`)].slice(0, 10)
+    };
+  }
+
+  // src/core/hook-names.ts
+  var RENDER_MARK = "__rprInspectRender";
+  var DISPATCHER_MARK = "__rpr_";
+  var MEMO_CACHE_SENTINEL = /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel");
+  var NOT_PENDING = Object.freeze({ pending: false, data: null, method: null, action: null });
+  function inspectHooks(fiber) {
+    const render = renderFunctionOf(fiber);
+    const ref = renderer()?.currentDispatcherRef;
+    if (!render || !ref) return null;
+    const log = [];
+    let hook = fiber.memoizedState;
+    let index = 0;
+    const next = () => {
+      const current = hook;
+      if (hook) hook = hook.next;
+      index++;
+      return current;
+    };
+    const logged = (primitive, first, context) => log.push({ primitive, index: first, context, stack: new Error().stack ?? "" });
+    const stateHook = (primitive, count = 1) => {
+      const first = index;
+      const current = next();
+      for (let i = 1; i < count; i++) next();
+      logged(primitive, first);
+      return current;
+    };
+    const noop = () => {
+    };
+    const readContext = (context) => context._currentValue;
+    const dispatcher = {
+      readContext,
+      useContext: function __rpr_useContext(context) {
+        logged("Context", null, context);
+        return readContext(context);
+      },
+      useState: function __rpr_useState() {
+        const h = stateHook("State");
+        return [h?.memoizedState, noop];
+      },
+      useReducer: function __rpr_useReducer() {
+        const h = stateHook("Reducer");
+        return [h?.memoizedState, noop];
+      },
+      // A copy: a component that writes its ref in render would otherwise leave this run's noop setters in the real one.
+      useRef: function __rpr_useRef() {
+        const real = stateHook("Ref")?.memoizedState;
+        return { current: real?.current };
+      },
+      useEffect: function __rpr_useEffect() {
+        stateHook("Effect");
+      },
+      useLayoutEffect: function __rpr_useLayoutEffect() {
+        stateHook("LayoutEffect");
+      },
+      useInsertionEffect: function __rpr_useInsertionEffect() {
+        stateHook("InsertionEffect");
+      },
+      useImperativeHandle: function __rpr_useImperativeHandle() {
+        stateHook("ImperativeHandle");
+      },
+      useCallback: function __rpr_useCallback(callback) {
+        const h = stateHook("Callback");
+        return Array.isArray(h?.memoizedState) ? h.memoizedState[0] : callback;
+      },
+      useMemo: function __rpr_useMemo(create) {
+        const h = stateHook("Memo");
+        return Array.isArray(h?.memoizedState) ? h.memoizedState[0] : create();
+      },
+      useDebugValue: function __rpr_useDebugValue() {
+      },
+      useDeferredValue: function __rpr_useDeferredValue(value) {
+        const h = stateHook("DeferredValue");
+        return h ? h.memoizedState : value;
+      },
+      // React keeps an isPending state hook and the start function hook.
+      useTransition: function __rpr_useTransition() {
+        const h = stateHook("Transition", 2);
+        return [Boolean(h?.memoizedState), noop];
+      },
+      // The store hook plus the effect that subscribes to it.
+      useSyncExternalStore: function __rpr_useSyncExternalStore(_subscribe, getSnapshot) {
+        const h = stateHook("SyncExternalStore", 2);
+        return h ? h.memoizedState : getSnapshot();
+      },
+      useId: function __rpr_useId() {
+        return stateHook("Id")?.memoizedState ?? "";
+      },
+      useMutableSource: function __rpr_useMutableSource() {
+        stateHook("MutableSource");
+      },
+      useCacheRefresh: function __rpr_useCacheRefresh() {
+        stateHook("CacheRefresh");
+        return noop;
+      },
+      // ---- React 19 ------------------------------------------------------------------------------------------------
+      // Without these the stand-in throws at the first one and the component's hooks are named only up to it.
+      /** A context is read like `useContext`; a promise gives up its value only if it already has one. */
+      use: function __rpr_use(usable) {
+        if (usable && typeof usable === "object") {
+          if ("_currentValue" in usable) {
+            const context = usable;
+            logged("Context", null, context);
+            return readContext(context);
+          }
+          const thenable = usable;
+          if (typeof thenable.then === "function") {
+            if (thenable.status === "fulfilled") return thenable.value;
+            if (thenable.status === "rejected") throw thenable.reason;
+            throw new Error("use() is still pending");
+          }
+        }
+        return void 0;
+      },
+      // The state, the pending flag and the action queue.
+      useActionState: function __rpr_useActionState(_action, initialState) {
+        const h = stateHook("ActionState", 3);
+        return [h ? h.memoizedState : initialState, noop, false];
+      },
+      useFormState: function __rpr_useFormState(_action, initialState) {
+        const h = stateHook("FormState", 3);
+        return [h ? h.memoizedState : initialState, noop, false];
+      },
+      useOptimistic: function __rpr_useOptimistic(passthrough) {
+        const h = stateHook("Optimistic");
+        return [h ? h.memoizedState : passthrough, noop];
+      },
+      useEffectEvent: function __rpr_useEffectEvent(callback) {
+        stateHook("EffectEvent");
+        return typeof callback === "function" ? callback : noop;
+      },
+      // The compiler's cache lives on the fiber's update queue, not in the hook list, so it takes no cell; the
+      // sentinel makes the compiled body recompute rather than read.
+      useMemoCache: function __rpr_useMemoCache(size) {
+        return new Array(typeof size === "number" ? size : 0).fill(MEMO_CACHE_SENTINEL);
+      },
+      // What `useFormStatus` reads; outside a form action there is nothing pending.
+      useHostTransitionStatus: function __rpr_useHostTransitionStatus() {
+        return NOT_PENDING;
+      }
+    };
+    const restoreContexts = setupContexts(fiber);
+    const errorCtor = Error;
+    const stackLimit = errorCtor.stackTraceLimit;
+    errorCtor.stackTraceLimit = 100;
+    const useH = ref.H !== void 0 || !("current" in ref);
+    const previous = useH ? ref.H : ref.current;
+    if (useH) ref.H = dispatcher;
+    else ref.current = dispatcher;
+    const props = fiber.memoizedProps;
+    const second = fiber.tag === Tag.ForwardRef ? fiber.ref ?? null : void 0;
+    const marker = {
+      [RENDER_MARK]() {
+        render(props, second);
+      }
+    };
+    try {
+      marker[RENDER_MARK]();
+    } catch {
+    } finally {
+      if (useH) ref.H = previous;
+      else ref.current = previous;
+      restoreContexts();
+      errorCtor.stackTraceLimit = stackLimit;
+    }
+    return buildInfo(fiber, log);
+  }
+  function renderFunctionOf(fiber) {
+    if (fiber.tag === Tag.ForwardRef) return typeof fiber.type?.render === "function" ? fiber.type.render : null;
+    if (fiber.tag === Tag.FunctionComponent || fiber.tag === Tag.SimpleMemoComponent || fiber.tag === Tag.IndeterminateComponent) {
+      return typeof fiber.type === "function" && !fiber.type.prototype?.isReactComponent ? fiber.type : null;
+    }
+    return null;
+  }
+  function setupContexts(fiber) {
+    const saved = /* @__PURE__ */ new Map();
+    for (let node = fiber.return; node; node = node.return) {
+      if (node.tag !== 10) continue;
+      const context = node.type?._context ?? node.type;
+      if (context && !saved.has(context)) {
+        saved.set(context, context._currentValue);
+        context._currentValue = node.memoizedProps?.value;
+      }
+    }
+    return () => saved.forEach((value, context) => context._currentValue = value);
+  }
+  var reactExport = (primitive) => `use${primitive}`;
+  function buildInfo(fiber, log) {
+    const hooks = /* @__PURE__ */ new Map();
+    const contexts = /* @__PURE__ */ new Map();
+    for (const entry of log) {
+      if (entry.index === null && !entry.context) continue;
+      const frames = parseStack(entry.stack);
+      const renderAt = frames.findIndex((f) => f.fn.includes(RENDER_MARK));
+      const dispatcherAt = frames.findIndex((f) => f.fn.includes(DISPATCHER_MARK));
+      if (renderAt < 1 || dispatcherAt < 0 || dispatcherAt >= renderAt) continue;
+      let start = dispatcherAt + 1;
+      if (start < renderAt && frames[start].fn.split(".").pop() === reactExport(entry.primitive)) start++;
+      const component = renderAt - 1;
+      const steps = frames.slice(start, component).map((f) => ({ name: f.fn.split(".").pop() || "", library: libraryOf(f.url) })).filter((step) => step.name && step.library !== "react-perf-recorder").reverse();
+      const site = frames[component];
+      const at = steps.findIndex((step) => step.library !== null);
+      const library = at >= 0 ? steps.slice(at).find((step) => step.library)?.library || "deps" : void 0;
+      const info = {
+        ...entry.index !== null ? { type: hookTypeAt(fiber, entry.index) } : {},
+        path: [...steps.map((step) => step.name), entry.primitive],
+        ...library ? { library, libraryAt: at } : {},
+        ...site ? { generated: { url: site.url, line: site.line, column: site.column } } : {}
+      };
+      if (entry.index !== null) hooks.set(entry.index, info);
+      else if (entry.context && !contexts.has(entry.context)) contexts.set(entry.context, info);
+    }
+    return { hooks, contexts };
+  }
+
+  // src/core/env/origin.ts
+  var EFFECT_FRAMES = /flushPassiveEffects|flushPendingEffects|commitPassiveMount|commitHookEffectList/;
+  var REACT_FRAMES = /^(react-dom|react|scheduler)$/;
+  function captureStack() {
+    const holder = Error;
+    const limit = holder.stackTraceLimit;
+    holder.stackTraceLimit = 40;
+    try {
+      return new Error().stack ?? "";
+    } finally {
+      holder.stackTraceLimit = limit;
+    }
+  }
+  function updateOrigin() {
+    const frames = parseStack(captureStack()).slice(1);
+    const own2 = frames.filter((f) => libraryOf(f.url) !== "react-perf-recorder");
+    if (!own2.length) return null;
+    const inEffect = own2.some((f) => EFFECT_FRAMES.test(f.fn));
+    const kind = inEffect ? "effect" : "update";
+    const react = own2[0].url;
+    const app = own2.find((f) => f.url !== react && libraryOf(f.url) === null);
+    if (app) {
+      const name2 = app.fn.split(".").pop()?.replace(/^bound /, "") ?? "";
+      const file = servedPath(app.url);
+      return { text: `${kind}${name2 ? ` ${name2}` : ""} @ ${file}`, kind };
+    }
+    const outside = own2.find((f) => {
+      const library2 = libraryOf(f.url);
+      return f.url !== react && library2 !== null && !REACT_FRAMES.test(library2);
+    });
+    if (!outside) return null;
+    const library = libraryOf(outside.url) || "package";
+    const name = outside.fn.split(".").pop()?.replace(/^bound /, "") ?? "";
+    return { text: `${kind}${name ? ` ${name}` : ""} (${library})`, kind };
+  }
+
+  // src/core/env/timers.ts
+  var sink = null;
+  var running = null;
+  var installed = false;
+  var texts = /* @__PURE__ */ new WeakMap();
+  var own = /* @__PURE__ */ new WeakMap();
+  var order = 0;
+  var nextOrder = () => ++order;
+  function setTimerSink(next) {
+    sink = next;
+  }
+  function runningTimer() {
+    return running ? timerText(running) : null;
+  }
+  function runningTimerLibrary() {
+    return running ? libraryOfCaller(running) : null;
+  }
+  var callers = /* @__PURE__ */ new WeakMap();
+  function libraryOfCaller(t) {
+    let library = callers.get(t.origin);
+    if (library === void 0) {
+      const caller = parseStack(t.origin.stack ?? "").slice(1).find((f) => libraryOf(f.url) !== "react-perf-recorder");
+      callers.set(t.origin, library = caller ? libraryOf(caller.url) : null);
+    }
+    return library;
+  }
+  function timerText(t) {
+    let text = texts.get(t.origin);
+    if (text) return text;
+    const frames = parseStack(t.origin.stack ?? "").slice(1).filter((f) => libraryOf(f.url) !== "react-perf-recorder");
+    const app = frames.find((f) => libraryOf(f.url) === null);
+    const name = (app?.fn.split(".").pop() || t.fn.name || "").replace(/^bound /, "");
+    if (app) {
+      const file = servedPath(app.url);
+      text = `timer ${t.kind}${name ? ` ${name}` : ""} @ ${file}`;
+    } else {
+      const library = frames.map((f) => libraryOf(f.url)).find(Boolean);
+      text = `timer ${t.kind}${library ? ` (${library})` : ""}`;
+    }
+    texts.set(t.origin, text);
+    return text;
+  }
+  function scheduledByRecorder(stack) {
+    const caller = parseStack(stack)[1];
+    return caller !== void 0 && libraryOf(caller.url) === "react-perf-recorder";
+  }
+  function ours(t) {
+    let result = own.get(t.origin);
+    if (result === void 0) own.set(t.origin, result = scheduledByRecorder(t.origin.stack ?? ""));
+    return result;
+  }
+  function wrap(kind) {
+    const target2 = window;
+    const original = target2[kind];
+    if (typeof original !== "function") return;
+    const wrapped = function(callback, ...rest) {
+      if (typeof callback !== "function") return original.call(window, callback, ...rest);
+      const scheduled2 = { kind, fn: callback, origin: new Error() };
+      return original.call(
+        window,
+        function(...args) {
+          const s = sink;
+          if (!s) return callback.apply(this, args);
+          const outer = running;
+          const startedAt = nextOrder();
+          running = scheduled2;
+          try {
+            return callback.apply(this, args);
+          } finally {
+            running = outer;
+            s.after(
+              () => timerText(scheduled2),
+              () => ours(scheduled2),
+              () => libraryOfCaller(scheduled2),
+              startedAt
+            );
+          }
+        },
+        ...rest
+      );
+    };
+    Object.defineProperty(wrapped, "name", { value: kind });
+    target2[kind] = wrapped;
+  }
+  function installTimers() {
+    if (installed || typeof window === "undefined") return;
+    installed = true;
+    wrap("setTimeout");
+    wrap("setInterval");
+    wrap("requestAnimationFrame");
+  }
+
+  // src/core/recorder.ts
+  var PATH_DEPTH = 4;
+  function pathText(ref, base) {
+    const names2 = [];
+    for (let r = ref; r && names2.length < PATH_DEPTH; r = r.up) names2.push(r.name);
+    for (let i = 0; i < base.length && names2.length < PATH_DEPTH; i++) names2.push(base[i]);
+    return names2.join(" < ");
+  }
+  var MAX_TIMES = 2e3;
+  var SAMPLED_PARENTS = 50;
+  var MAX_UPDATE_NOTES = 10;
+  var MAX_CAUSE_KEYS = 300;
+  var MAX_CHAIN_NODES = 5e4;
+  var CHAINS_PER_COMPONENT = 3;
+  var MAX_CHAIN_LINKS = 20;
+  var WAYS_PER_COMMIT = 30;
+  var MAX_SEGMENT_COMMITS = 2e4;
+  var currentEventType = () => {
+    const event = globalThis.event;
+    return event && typeof event.type === "string" ? event.type : void 0;
+  };
+  var messageSource = () => {
+    const event = globalThis.event;
+    const target2 = event?.type === "message" ? event.target : null;
+    if (!target2 || target2 === globalThis || typeof MessagePort !== "undefined" && target2 instanceof MessagePort) return void 0;
+    return target2.constructor?.name || void 0;
+  };
+  var shallowEqual = (x, y) => {
+    const a = x;
+    const b = y;
+    if (a === b) return true;
+    if (!a || !b) return false;
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((key) => Object.is(a[key], b[key]));
+  };
+  var medianGapMs = (times) => {
+    const gap = medianGap(times);
+    return gap === null ? null : Math.round(gap);
+  };
+  var Recorder = class {
+    constructor(deps, options) {
+      this.deps = deps;
+      this.options = options;
+      this.t0 = performance.now();
+      this.startedAt = /* @__PURE__ */ new Date();
+      this.records = /* @__PURE__ */ new WeakMap();
+      this.rootsByKey = /* @__PURE__ */ new Map();
+      this.rootList = [];
+      this.reasonIds = /* @__PURE__ */ new Map();
+      this.reasonIdsByFields = /* @__PURE__ */ new Map();
+      this.memoHits = new MemoHits((f) => sourceOf(f, this.config.projectRoot));
+      this.reasonList = [];
+      this.components = /* @__PURE__ */ new Map();
+      this.watch = /* @__PURE__ */ new Map();
+      this.zoneNodes = /* @__PURE__ */ new Map();
+      this.zones = /* @__PURE__ */ new Map();
+      this.causeStats = /* @__PURE__ */ new Map();
+      this.commitList = [];
+      this.segmentCommits = [];
+      this.commitTimes = [];
+      this.bigCommits = [];
+      this.navigations = [];
+      this.hmr = [];
+      this.errors = [];
+      this.warnings = [];
+      this.dom = new DomWatcher();
+      /** Whether childLanes can be trusted to point at fresh updates; React 19 answers no and the walk widens. */
+      this.narrowUpdateWalk = true;
+      this.hook = null;
+      this.stopHistory = null;
+      this.roots = [];
+      this.conditions = {};
+      this.truncated = false;
+      /** Commits so far, kept or not: the list stops at the timeline limit, the ids do not. */
+      this.commitSeq = 0;
+      this.stopped = false;
+      this.overlayMs = 0;
+      this.highlighted = false;
+      /** Fibers a cause already names since the last commit. */
+      this.claimed = /* @__PURE__ */ new WeakSet();
+      /** Where updates of this commit window came from, used only for the components no other event explains. */
+      this.origins = [];
+      this.frameCount = 0;
+      this.counting = false;
+      this.totals = {
+        commits: 0,
+        commitsInScope: 0,
+        renders: 0,
+        mounts: 0,
+        rendersFromOutside: 0,
+        rendersWithoutDom: 0,
+        causesDropped: 0,
+        lanes: {}
+      };
+      /**
+       * Left out of a path: an unnamed wrapper, a provider-only component, a package's own. Cached by type, as the
+       * answer is the same for every instance.
+       */
+      this.structuralByType = /* @__PURE__ */ new WeakMap();
+      this.chainNodes = [];
+      /** Interned links: parent id → name → reason id → node id. */
+      this.chainIndex = /* @__PURE__ */ new Map();
+      /** A root's links are told apart by the root itself: two roots of one name start two chains. */
+      this.rootChains = /* @__PURE__ */ new Map();
+      this.config = deps.config;
+      this.wrapperRe = new RegExp(this.config.wrapperPattern || "^$");
+      this.prune = options.prune !== false;
+      this.scope = options.scope ? new ScopeTracker(options.scope) : null;
+      for (const name of options.watch ?? []) this.watch.set(name, { mounted: 0, renders: 0, byRoot: /* @__PURE__ */ new Map() });
+      this.frames = new FrameWatcher({
+        t0: this.t0,
+        projectRoot: this.config.projectRoot,
+        countCommits: (from, to) => this.countCommits(from, to),
+        onFrame: (frame) => this.emit({ k: "frame", frame }),
+        onLatency: (entry) => this.emit({ k: "latency", entry })
+      });
+      this.actions = options.actions === false ? null : new ActionTracker(
+        {
+          values: this.config.actions.values,
+          secretSelector: this.config.actions.secretSelector,
+          wrapperPattern: this.wrapperRe,
+          projectRoot: this.config.projectRoot,
+          ownHost: deps.ownHost,
+          inScope: (el) => this.scope ? this.scopeHosts().some((h) => h.contains(el)) : void 0
+        },
+        () => this.now(),
+        (action) => this.emit({ k: "action", action })
+      );
+    }
+    structural(name, f) {
+      const type = f.type;
+      const keyed = type !== null && (typeof type === "object" || typeof type === "function");
+      const known2 = keyed ? this.structuralByType.get(type) : void 0;
+      if (known2 !== void 0) return known2;
+      const result = this.wrapperRe.test(name) || isProvider(name) || wrapsProvider(f) || isLibraryFiber(f);
+      if (keyed) this.structuralByType.set(type, result);
+      return result;
+    }
+    now() {
+      return performance.now() - this.t0;
+    }
+    get startConditions() {
+      return this.conditions;
+    }
+    get scopeInfo() {
+      return this.scope ? { name: this.scope.name, source: this.scope.source } : null;
+    }
+    start() {
+      this.roots = this.scope ? [hostRootOf(this.scope.target)].filter((r) => Boolean(r)) : findRoots();
+      if (!this.roots.length) throw new RecorderError("NO_ROOT", "React 18 dev root not found on the page");
+      for (const root of this.roots) {
+        const owner = hookOwner(root);
+        if (owner) throw new RecorderError("BUSY", `root.current is already hooked by ${owner}: wait for it to finish or call its stop()`, owner);
+      }
+      this.resolveZones();
+      for (const root of this.roots) this.seed(root.current);
+      this.conditions = this.readConditions();
+      this.deps.plugins.start(this.pluginSession(), this.t0);
+      if (this.scope) this.dom.setScopeHosts(this.scopeHosts());
+      this.dom.start();
+      this.hook = hookCommits(
+        this.roots,
+        this.options.source ?? "panel",
+        (info) => this.onCommit(info),
+        () => this.noteUpdate()
+      );
+      this.deps.plugins.targets = () => this.freshUpdates();
+      setTimerSink({
+        after: (text, ours2, library, startedAt) => {
+          const plugins = this.deps.plugins;
+          if (!this.freshUpdates(false).size) return;
+          if (ours2()) return;
+          if (plugins.hasWaiting && plugins.deliver(library(), () => this.freshUpdates(), startedAt)) return;
+          plugins.emit("core", { type: text() }, this.freshUpdates());
+        }
+      });
+      this.frames.start();
+      if (this.options.frames) {
+        this.counting = true;
+        const tick = () => {
+          if (!this.counting) return;
+          this.frameCount++;
+          requestAnimationFrame(tick);
+        };
+        requestAnimationFrame(tick);
+      }
+      this.actions?.start();
+      this.stopHistory = trackHistory(
+        () => this.now(),
+        (nav) => {
+          if (this.navigations.length < 500) this.navigations.push(nav);
+          this.emit({ k: "nav", nav });
+          this.deps.plugins.emit("core", { type: `navigation ${nav.type}` });
+          if (nav.type === "pop") this.actions?.navigation(nav.url);
+        }
+      );
+    }
+    noteHmr(type, paths) {
+      const entry = { atMs: Math.round(this.now()), type, paths: paths.slice(0, 10) };
+      this.hmr.push(entry);
+      this.emit({ k: "hmr", ...entry });
+      if (!this.warnings.some((w) => w.startsWith("HMR")))
+        this.warnings.push("HMR update during the recording: commits around it include react-refresh work");
+    }
+    /** What the panel shows while the recording runs: counters and the roots leading so far, with their reason. */
+    live() {
+      const elapsedMs = Math.round(this.now());
+      return {
+        commits: this.totals.commits,
+        commitsInScope: this.totals.commitsInScope,
+        renders: this.totals.renders,
+        rendersPerSec: elapsedMs > 200 ? Math.round(this.totals.renders * 1e3 / elapsedMs) : 0,
+        elapsedMs,
+        scopeState: this.scope?.state ?? null,
+        topRoots: [...this.rootList].sort((a, b) => b.cascade - a.cascade).slice(0, 3).map((agg) => ({
+          name: agg.name,
+          hits: agg.hits,
+          perHit: agg.hits ? Math.round(agg.cascade / agg.hits) : 0,
+          ...(() => {
+            const info = this.reasonList[topEntries(agg.reasons, 1)[0]?.[0] ?? -1];
+            return info ? { reason: textOf(info), info } : { reason: "" };
+          })()
+        }))
+      };
+    }
+    stop() {
+      if (this.stopped) throw new RecorderError("NOT_RECORDING", "recording already stopped");
+      this.stopped = true;
+      setTimerSink(null);
+      this.deps.plugins.targets = null;
+      const hookErrors = this.hook?.stop() ?? [];
+      this.errors.push(...hookErrors);
+      this.dom.stop();
+      this.frames.stop();
+      this.counting = false;
+      this.actions?.stop();
+      this.stopHistory?.();
+      const sections = this.deps.plugins.stop(this.pluginSession());
+      this.warnings.push(...this.deps.plugins.warnings.splice(0));
+      const conditionsAfter = this.readConditions();
+      this.overlayMs += this.deps.highlight?.takeCostMs?.() ?? 0;
+      const durationMs = Math.round(this.now());
+      this.emit({ k: "end", atMs: durationMs });
+      return this.build(durationMs, sections, conditionsAfter);
+    }
+    // ---- commits -------------------------------------------------------------------------------------------------
+    onCommit({ fiber, lanes }) {
+      const started = performance.now();
+      const t = Math.round(started - this.t0);
+      this.totals.commits++;
+      if (this.commitTimes.length < MAX_SEGMENT_COMMITS) this.commitTimes.push(t);
+      const lane = laneLabel(lanes);
+      const event = currentEventType();
+      const source = event === "message" ? messageSource() : void 0;
+      this.claimed = /* @__PURE__ */ new WeakSet();
+      const origins = this.origins;
+      this.origins = [];
+      const timer = runningTimer();
+      if (timer && !(this.deps.plugins.hasWaiting && this.deps.plugins.deliver(runningTimerLibrary(), () => null)))
+        this.deps.plugins.emit("core", { type: timer });
+      const causes = this.deps.plugins.drain();
+      this.deps.plugins.commit(this.pluginSession());
+      const c = {
+        t,
+        renders: 0,
+        renderMs: 0,
+        noDom: 0,
+        cascade: /* @__PURE__ */ new Map(),
+        sampledParents: this.options.sampleReasons ? /* @__PURE__ */ new Map() : null,
+        reasons: /* @__PURE__ */ new Map(),
+        outside: null,
+        pairs: [],
+        withoutDom: /* @__PURE__ */ new Set(),
+        mounted: /* @__PURE__ */ new Set(),
+        ways: this.options.sampleReasons ? null : /* @__PURE__ */ new Map(),
+        touched: this.dom.takeForCommit()
+      };
+      if (this.scope) {
+        const prevs = [];
+        const resolution = this.scope.resolve(fiber, (f) => this.visitChain(f, prevs), t);
+        if (resolution.status === "found") this.scanScope(resolution, prevs, c);
+        else if (resolution.status === "lost" && this.scope.lostAtMs.at(-1) === t) this.emit({ k: "scope", atMs: t, state: "lost" });
+      } else {
+        this.scan(fiber, false, "", null, c, false);
+      }
+      this.finishCommit(c, causes, lane, event, source, origins);
+    }
+    visitChain(f, prevs) {
+      const prev = this.prevOf(f);
+      prevs.push(prev);
+      const rendered = didRender(prev, f);
+      this.remember(f);
+      return { rendered };
+    }
+    scanScope(res, prevs, c) {
+      const { fibers, rendered } = res;
+      const n = fibers.length;
+      const target2 = fibers[n - 1];
+      if (res.remounted) {
+        this.emit({ k: "scope", atMs: c.t, state: "remounted" });
+        this.dom.setScopeHosts(this.scopeHosts());
+      }
+      const parentRendered = n >= 2 ? rendered[n - 2] : false;
+      let rootKey = null;
+      if (rendered[n - 1] && parentRendered) {
+        let top = n - 2;
+        while (top > 0 && rendered[top - 1]) top--;
+        let j = top;
+        while (j < n - 1 && !nameOf(fibers[j])) j++;
+        if (j < n - 1 && prevs[j]) {
+          const { agg } = this.hitRoot(fibers[j], nameOf(fibers[j]), this.chainPath(fibers, j), prevs[j], c, true);
+          c.outside = agg;
+          rootKey = agg.key;
+        }
+      }
+      const prevTarget = prevs[n - 1];
+      if (prevTarget) {
+        this.records.set(target2, prevTarget);
+        if (target2.alternate) this.records.set(target2.alternate, prevTarget);
+      }
+      this.scan(target2, parentRendered, this.chainPath(fibers, n - 1), rootKey, c, true);
+      if (c.renders) this.dom.setScopeHosts(nearestHosts(target2));
+    }
+    chainPath(fibers, upTo) {
+      const names2 = [];
+      for (let i = upTo - 1; i >= 0 && names2.length < 4; i--) {
+        const name = nameOf(fibers[i]);
+        if (name && !this.structural(name, fibers[i])) names2.push(name);
+      }
+      return names2.join(" < ");
+    }
+    scan(start, parentRendered, path, rootKey, c, isolate) {
+      const highlight = Boolean(this.deps.highlight) && this.deps.highlight.enabled !== false && this.options.highlight !== false;
+      if (highlight) this.highlighted = true;
+      const base = path ? path.split(" < ") : [];
+      const stack = [[start, parentRendered, null, rootKey, null, null, -1]];
+      while (stack.length) {
+        const [f, parentDid, currentPath, currentKey, pending, zoneTag, currentChain] = stack.pop();
+        let chain = currentChain;
+        const prev = this.prevOf(f);
+        const rendered = didRender(prev, f);
+        const name = nameOf(f);
+        let key = currentKey;
+        let nextPending = pending;
+        const zone = isHost(f) && this.zoneNodes.size ? this.zoneNodes.get(f.stateNode) ?? zoneTag : zoneTag;
+        if (name && !prev && isComposite(f)) {
+          if (highlight && !nextPending && mountedInPlace(f)) {
+            nextPending = [name, f, isLibraryFiber(f)];
+            c.mounted.add(f);
+          }
+          this.totals.mounts++;
+          this.componentOf(name, f).mounts++;
+          const agg = currentKey ? this.rootsByKey.get(currentKey) : void 0;
+          if (agg) agg.mounts++;
+        }
+        if (name && rendered) {
+          c.renders++;
+          this.totals.renders++;
+          this.memoHits.track(name, f, prev.state);
+          const wasted = !touchedHas(c.touched, f);
+          const comp = this.componentOf(name, f);
+          comp.renders++;
+          if (wasted) {
+            comp.withoutDom++;
+            c.noDom++;
+            this.totals.rendersWithoutDom++;
+            c.withoutDom.add(f);
+          }
+          let reasons = null;
+          const ownWork = parentDid && isComposite(f) && prev !== void 0 && (prev.props === f.memoizedProps || (f.tag === Tag.MemoComponent || f.tag === Tag.SimpleMemoComponent) && shallowEqual(prev.props, f.memoizedProps));
+          let rootAgg = null;
+          if (!parentDid || ownWork) {
+            const hit = this.hitRoot(f, name, pathText(currentPath, base), prev, c, false);
+            key = hit.agg.key;
+            reasons = hit.reasons;
+            rootAgg = hit.agg;
+          } else if (isComposite(f) && !isProvider(name)) {
+            comp.byParent++;
+            const sampled = c.sampledParents?.get(comp) ?? 0;
+            if (sampled < SAMPLED_PARENTS) {
+              c.sampledParents?.set(comp, sampled + 1);
+              reasons = parentReason(prev, f, this.deps.plugins);
+            } else comp.sampled = true;
+          }
+          let firstId = -1;
+          for (const reason of reasons ?? []) {
+            const id = this.reasonId(reason);
+            if (firstId < 0) firstId = id;
+            comp.reasons.set(id, (comp.reasons.get(id) ?? 0) + 1);
+          }
+          if (rootAgg) {
+            chain = this.options.sampleReasons ? -1 : this.chainLink(-1, name, firstId, rootAgg);
+            if (chain >= 0) c.ways?.set(chain, (c.ways.get(chain) ?? 0) + 1);
+          } else if (chain >= 0 && isComposite(f) && !isProvider(name) && !comp.library && !comp.wrapper) {
+            chain = this.chainLink(chain, name, firstId);
+            comp.chains.set(chain, (comp.chains.get(chain) ?? 0) + 1);
+            c.ways?.set(chain, (c.ways.get(chain) ?? 0) + 1);
+          }
+          const agg = key ? this.rootsByKey.get(key) : void 0;
+          if (agg) {
+            agg.cascade++;
+            c.cascade.set(agg, (c.cascade.get(agg) ?? 0) + 1);
+            if (agg.outside) this.totals.rendersFromOutside++;
+          }
+          const w = this.watch.get(name);
+          if (w) {
+            w.renders++;
+            w.byRoot.set(agg ?? null, (w.byRoot.get(agg ?? null) ?? 0) + 1);
+          }
+          if (zone) {
+            const z = this.zones.get(zone);
+            if (z) z.renders++;
+          }
+          if (highlight && isComposite(f) && (!nextPending || nextPending[2] && !isLibraryFiber(f))) nextPending = [name, f, isLibraryFiber(f)];
+        }
+        if (nextPending && !nextPending[2] && (isHost(f) || f.tag === Tag.HostText)) {
+          const el = isHost(f) ? f.stateNode : f.stateNode.parentElement;
+          if (el) c.pairs.push([el, nextPending[0], nextPending[1]]);
+          nextPending = null;
+        }
+        if (rendered || !prev) this.remember(f);
+        if (!(isolate && f === start) && f.sibling) stack.push([f.sibling, parentDid, currentPath, currentKey, pending, zoneTag, currentChain]);
+        const untouched = this.prune && f.alternate !== null && f.child === f.alternate.child;
+        if (f.child && !untouched) {
+          const childPath = name && !this.structural(name, f) ? { name, up: currentPath } : currentPath;
+          stack.push([f.child, rendered, childPath, rendered ? key : currentKey, nextPending, zone, rendered ? chain : -1]);
+        }
+      }
+    }
+    chainLink(up, name, reason, root) {
+      let byReason;
+      if (root) {
+        byReason = this.rootChains.get(root);
+        if (!byReason) this.rootChains.set(root, byReason = /* @__PURE__ */ new Map());
+      } else {
+        let byName = this.chainIndex.get(up);
+        if (!byName) this.chainIndex.set(up, byName = /* @__PURE__ */ new Map());
+        byReason = byName.get(name);
+        if (!byReason) byName.set(name, byReason = /* @__PURE__ */ new Map());
+      }
+      const known2 = byReason.get(reason);
+      if (known2 !== void 0) return known2;
+      if (this.chainNodes.length >= MAX_CHAIN_NODES) return -1;
+      const id = this.chainNodes.length;
+      this.chainNodes.push({ up, name, reason, ...root ? { root } : {} });
+      byReason.set(reason, id);
+      return id;
+    }
+    /** The links of a chain from its root down; one past 20 keeps its root, the two below it and the last sixteen. */
+    chainLinks(id, rootIndex) {
+      const links = [];
+      for (let at = id; at >= 0; at = this.chainNodes[at].up) {
+        const node = this.chainNodes[at];
+        const root = node.root ? rootIndex(node.root) : void 0;
+        links.push({ name: node.name, ...node.reason >= 0 ? { reason: node.reason } : {}, ...root !== void 0 ? { root } : {} });
+      }
+      links.reverse();
+      return links.length > MAX_CHAIN_LINKS ? [...links.slice(0, 3), { name: "\u2026", skipped: links.length - (MAX_CHAIN_LINKS - 1) }, ...links.slice(-(MAX_CHAIN_LINKS - 4))] : links;
+    }
+    /** A commit's busiest links and every link above them, so the tree they make has no holes. */
+    commitWays(ways) {
+      const kept = new Map(topEntries(ways, WAYS_PER_COMMIT));
+      for (const id of [...kept.keys()])
+        for (let up = this.chainNodes[id].up; up >= 0 && !kept.has(up); up = this.chainNodes[up].up) kept.set(up, ways.get(up) ?? 0);
+      return [...kept];
+    }
+    /** The links the commits point at, numbered afresh from 0, and each commit's links in those numbers. */
+    exportNodes(rootIndex) {
+      const used = /* @__PURE__ */ new Set();
+      for (const commit of this.commitList) for (const [id] of commit.ways ?? []) used.add(id);
+      const ids = [...used].sort((a, b) => a - b);
+      const renumber = new Map(ids.map((id, i) => [id, i]));
+      const nodes = ids.map((id) => {
+        const node = this.chainNodes[id];
+        const root = node.root ? rootIndex(node.root) : void 0;
+        return {
+          up: node.up >= 0 ? renumber.get(node.up) ?? -1 : -1,
+          name: node.name,
+          ...node.reason >= 0 ? { reason: node.reason } : {},
+          ...root !== void 0 ? { root } : {}
+        };
+      });
+      return { nodes, renumber };
+    }
+    componentOf(name, f) {
+      let comp = this.components.get(name);
+      if (!comp) {
+        comp = {
+          renders: 0,
+          mounts: 0,
+          library: isLibraryFiber(f),
+          wrapper: this.wrapperRe.test(name) || isProvider(name) || wrapsProvider(f),
+          withoutDom: 0,
+          byParent: 0,
+          memo: f.tag === Tag.MemoComponent || f.tag === Tag.SimpleMemoComponent,
+          reasons: /* @__PURE__ */ new Map(),
+          chains: /* @__PURE__ */ new Map()
+        };
+        this.components.set(name, comp);
+      }
+      return comp;
+    }
+    hitRoot(f, name, path, prev, c, outside) {
+      const source = sourceOf(f, this.config.projectRoot);
+      const generated = generatedSourceOf(f);
+      const key = `${outside ? "outside|" : ""}${name}|${siteKeyOf(f, this.config.projectRoot) || source}|${path}`;
+      let agg = this.rootsByKey.get(key);
+      if (!agg) {
+        agg = {
+          index: this.rootList.length,
+          key,
+          name,
+          source,
+          generated,
+          path,
+          outside,
+          hits: 0,
+          instances: 0,
+          inCommit: 0,
+          lastCommit: -1,
+          cascade: 0,
+          times: [],
+          reasons: /* @__PURE__ */ new Map(),
+          causes: /* @__PURE__ */ new Map(),
+          lanes: /* @__PURE__ */ new Map(),
+          noDomChange: 0,
+          renderMs: 0,
+          mounts: 0,
+          library: isLibraryFiber(f),
+          hookIdx: /* @__PURE__ */ new Set(),
+          contexts: /* @__PURE__ */ new Map(),
+          latest: null
+        };
+        this.rootsByKey.set(key, agg);
+        this.rootList.push(agg);
+        this.emit({
+          k: "root",
+          i: agg.index,
+          key,
+          name,
+          source,
+          path,
+          ...generated ? { generatedSource: generated } : {},
+          ...outside ? { outside: true } : {}
+        });
+      }
+      if (agg.lastCommit !== this.totals.commits) {
+        agg.lastCommit = this.totals.commits;
+        agg.hits++;
+        agg.inCommit = 0;
+        if (agg.times.length < MAX_TIMES) agg.times.push(c.t);
+        agg.latest = new WeakRef(f);
+      }
+      agg.inCommit++;
+      agg.instances = Math.max(agg.instances, agg.inCommit);
+      const ids = c.reasons.get(agg) ?? /* @__PURE__ */ new Set();
+      const reasons = reasonsOf(prev, f, this.deps.plugins);
+      for (const reason of reasons) {
+        const id = this.reasonId(reason);
+        agg.reasons.set(id, (agg.reasons.get(id) ?? 0) + 1);
+        if (reason.hook !== void 0) agg.hookIdx.add(reason.hook);
+        if (reason.contextObject && reason.context) agg.contexts.set(contextKey(reason.context), reason.contextObject);
+        ids.add(id);
+      }
+      c.reasons.set(agg, ids);
+      if (!outside && !touchedHas(c.touched, f)) agg.noDomChange++;
+      if (hasProfileTimings(f)) {
+        agg.renderMs += f.actualDuration;
+        c.renderMs += f.actualDuration;
+      }
+      if (!outside) c.cascade.set(agg, c.cascade.get(agg) ?? 0);
+      return { agg, reasons };
+    }
+    finishCommit(c, causes, lane, event, source, origins) {
+      if (lane) this.totals.lanes[lane] = (this.totals.lanes[lane] ?? 0) + 1;
+      if (!c.renders) {
+        this.totals.causesDropped += causes.length;
+        return;
+      }
+      this.totals.commitsInScope++;
+      const keys = /* @__PURE__ */ new Set();
+      const targets = /* @__PURE__ */ new Map();
+      const someoneAimed = causes.some((cause) => cause.fibers?.size);
+      for (const cause of causes) {
+        if (someoneAimed && cause.aimed && !cause.fibers) {
+          this.totals.causesDropped++;
+          continue;
+        }
+        const key = this.attachCause(cause);
+        keys.add(key);
+        if (cause.fibers?.size) targets.set(key, /* @__PURE__ */ new Set([...targets.get(key) ?? [], ...cause.fibers]));
+      }
+      if (event && USER_EVENTS.has(event)) keys.add(this.attachCause({ plugin: "core", type: `input ${eventName(event)}`, atMs: c.t }));
+      else if (source) keys.add(this.attachCause({ plugin: "core", type: `message ${source}`, atMs: c.t }));
+      const claimedByEvents = new Set([...targets.values()].flatMap((set) => [...set]));
+      for (const origin of origins) {
+        if (origin.kind === "update" && origin.event && origin.event === event) continue;
+        if ([...origin.fibers].some((f) => claimedByEvents.has(f))) continue;
+        const key = this.attachCause({ plugin: "core", type: origin.text, atMs: c.t });
+        keys.add(key);
+        targets.set(key, /* @__PURE__ */ new Set([...targets.get(key) ?? [], ...origin.fibers]));
+      }
+      if (!keys.size) keys.add(this.attachCause({ plugin: "core", type: "none", atMs: c.t }));
+      for (const key of keys) this.causeStats.get(key).commits++;
+      const involved = /* @__PURE__ */ new Set([...c.cascade.keys(), ...c.outside ? [c.outside] : []]);
+      const fiberOf = (agg) => agg.latest?.deref();
+      const hits = (key, agg) => {
+        const set = targets.get(key);
+        if (!set) return true;
+        const f = fiberOf(agg);
+        return f !== void 0 && set.has(f) || ![...involved].some((other) => set.has(fiberOf(other)));
+      };
+      for (const agg of involved) {
+        const own2 = [...keys].filter((key) => hits(key, agg));
+        for (const key of own2.length ? own2 : keys) agg.causes.set(key, (agg.causes.get(key) ?? 0) + 1);
+        if (lane && agg.lastCommit === this.totals.commits) agg.lanes.set(lane, (agg.lanes.get(lane) ?? 0) + 1);
+      }
+      const ranked = [...c.cascade].sort((a, b) => b[1] - a[1]);
+      const roots = ranked.slice(0, 5).map(([agg, n]) => [agg.index, n]);
+      const previous = this.commitList[this.commitList.length - 1];
+      const record = {
+        i: this.commitSeq++,
+        atMs: c.t,
+        ...previous ? { sinceMs: +(c.t - previous.atMs).toFixed(1) } : {},
+        renders: c.renders,
+        ...c.renderMs ? { ms: +c.renderMs.toFixed(2) } : {},
+        ...lane ? { lane } : {},
+        ...event ? { event } : {},
+        ...keys.size ? { causeIds: [...keys].map((key) => this.causeStats.get(key).i) } : {},
+        ...ranked.length ? { roots: ranked.slice(0, 10).map(([agg, hits2]) => ({ i: agg.index, hits: hits2, reasonIds: [...c.reasons.get(agg) ?? []] })) } : {},
+        ...c.outside ? { outside: c.outside.index } : {},
+        ...c.noDom ? { noDom: c.noDom } : {},
+        ...c.ways?.size ? { ways: this.commitWays(c.ways) } : {}
+      };
+      const limit = this.options.timeline ?? this.config.timelineLimit;
+      if (this.commitList.length < limit) this.commitList.push(record);
+      else this.truncated = true;
+      if (c.renders >= (this.options.bigCommit ?? this.config.bigCommit)) this.bigCommits.push(record.i);
+      if (this.segmentCommits.length < MAX_SEGMENT_COMMITS) this.segmentCommits.push({ i: record.i, t: c.t, n: c.renders, event, roots });
+      this.emit({
+        k: "commit",
+        t: c.t,
+        n: c.renders,
+        ...record.ms ? { ms: record.ms } : {},
+        ...lane ? { lane } : {},
+        ...event ? { event } : {},
+        roots: ranked.map(([agg, n]) => [agg.index, n, [...c.reasons.get(agg) ?? []]]),
+        causes: [...keys],
+        ...c.outside ? { outside: c.outside.index } : {},
+        ...c.noDom ? { noDom: c.noDom } : {}
+      });
+      if (c.pairs.length && this.deps.highlight) {
+        const started = performance.now();
+        this.deps.highlight.flash(c.pairs, c.withoutDom, c.mounted);
+        this.overlayMs += performance.now() - started;
+      }
+    }
+    attachCause(cause) {
+      let key = `${cause.plugin}:${cause.type}`;
+      if (!this.causeStats.has(key) && this.causeStats.size >= MAX_CAUSE_KEYS) key = `${cause.plugin}:other`;
+      let stat = this.causeStats.get(key);
+      if (!stat) {
+        stat = { i: this.causeStats.size, key, plugin: cause.plugin, type: key.slice(cause.plugin.length + 1), events: 0, commits: 0 };
+        this.causeStats.set(key, stat);
+      }
+      stat.events++;
+      if (cause.changes?.length) {
+        stat.keys ??= {};
+        for (const change of cause.changes.slice(0, 40)) {
+          const k = stat.keys[change.key] ??= { changed: 0, sameContent: 0, unknown: 0 };
+          const same2 = sameContent(change.prev, change.next, 2e4);
+          if (same2 === true) k.sameContent++;
+          else if (same2 === "unknown") k.unknown++;
+          else k.changed++;
+        }
+      }
+      return key;
+    }
+    /**
+     * An update was just scheduled and nothing else explains it: no user event, no timer callback, no store or query
+     * event yet. The stack still holds the code that asked for it, so the cause names that code.
+     */
+    noteUpdate() {
+      if (this.origins.length >= MAX_UPDATE_NOTES || runningTimer()) return;
+      const fibers = this.freshUpdates(false);
+      if (!fibers.size) return;
+      const origin = updateOrigin();
+      if (origin) this.origins.push({ ...origin, fibers, event: currentEventType() });
+    }
+    /**
+     * Unclaimed fibers updated since the last commit. React 19 sets childLanes only at render, so once a narrow walk
+     * misses what a wide one finds, the walk stays wide.
+     */
+    freshUpdates(claim = true) {
+      const lanes = this.roots.reduce((all, root) => all | (root.pendingLanes ?? 0), 0);
+      if (!lanes) return /* @__PURE__ */ new Set();
+      if (!this.narrowUpdateWalk) return this.scanUpdates(lanes, false, claim);
+      const narrow = this.scanUpdates(lanes, true, claim);
+      if (narrow.size) return narrow;
+      const wide = this.scanUpdates(lanes, false, claim);
+      if (wide.size) this.narrowUpdateWalk = false;
+      return wide;
+    }
+    scanUpdates(lanes, narrow, claim) {
+      const out = /* @__PURE__ */ new Set();
+      const stack = this.roots.map((root) => root.current);
+      const limit = narrow ? 2e3 : 2e4;
+      for (let visits = 0; stack.length && visits < limit; visits++) {
+        const f = stack.pop();
+        if ((f.lanes ?? 0) & lanes && !this.claimed.has(f)) {
+          out.add(f);
+          if (f.alternate) out.add(f.alternate);
+          if (claim) {
+            this.claimed.add(f);
+            if (f.alternate) this.claimed.add(f.alternate);
+          }
+        }
+        for (let child = f.child; child; child = child.sibling)
+          if (!narrow || ((child.lanes ?? 0) | (child.childLanes ?? 0)) & lanes) stack.push(child);
+      }
+      return out;
+    }
+    // ---- snapshots and helpers ------------------------------------------------------------------------------------
+    prevOf(f) {
+      return this.records.get(f) ?? (f.alternate ? this.records.get(f.alternate) : void 0);
+    }
+    remember(f) {
+      const snapshot = snapshotOf(f);
+      this.records.set(f, snapshot);
+      if (f.alternate) this.records.set(f.alternate, snapshot);
+    }
+    seed(start) {
+      const stack = [[start, null]];
+      while (stack.length) {
+        const [f, zoneTag] = stack.pop();
+        this.remember(f);
+        const name = nameOf(f);
+        const w = name ? this.watch.get(name) : void 0;
+        if (w) w.mounted++;
+        const zone = isHost(f) && this.zoneNodes.size ? this.zoneNodes.get(f.stateNode) ?? zoneTag : zoneTag;
+        if (zone && name) this.zones.get(zone).mounted++;
+        if (f.sibling) stack.push([f.sibling, zoneTag]);
+        if (f.child) stack.push([f.child, zone]);
+      }
+    }
+    pluginSession() {
+      return { scope: this.scopeInfo, findFibers: (pred, limit) => this.findFibers(pred, limit) };
+    }
+    findFibers(pred, limit = Infinity) {
+      const out = [];
+      for (const root of this.roots.length ? this.roots : findRoots()) {
+        const stack = [root.current];
+        while (stack.length && out.length < limit) {
+          const f = stack.pop();
+          try {
+            if (pred(f)) out.push(f);
+          } catch {
+          }
+          if (f.sibling) stack.push(f.sibling);
+          if (f.child) stack.push(f.child);
+        }
+      }
+      return out;
+    }
+    resolveZones() {
+      for (const [name, spec] of Object.entries(this.options.zones ?? {})) {
+        const { selector, viaAriaControls } = typeof spec === "string" ? { selector: spec, viaAriaControls: false } : spec;
+        let el = document.querySelector(selector);
+        if (el && viaAriaControls) {
+          const id = el.getAttribute("aria-controls");
+          el = id ? document.getElementById(id) : null;
+        }
+        this.zones.set(name, { renders: 0, mounted: 0, found: Boolean(el) });
+        if (el) this.zoneNodes.set(el, name);
+      }
+    }
+    scopeHosts() {
+      return this.scope ? nearestHosts(this.scope.target) : [];
+    }
+    countCommits(from, to) {
+      let n = 0;
+      for (const t of this.commitTimes) if (t >= from && t <= to) n++;
+      return n;
+    }
+    /** One entry per distinct reason; everything else — roots, components, commits — points at it by id. */
+    reasonId(reason) {
+      const fieldKey = reason.kind === "parent" ? `parent|${reason.changed?.join(",") ?? ""}|${reason.sameRef?.join(",") ?? ""}|${reason.children ? 1 : 0}${reason.equal ? 1 : 0}` : JSON.stringify({ ...reason, contextObject: void 0 });
+      const known2 = this.reasonIdsByFields.get(fieldKey);
+      if (known2 !== void 0) return known2;
+      const { contextObject: _context, ...fields } = reason;
+      const text = reasonText(fields);
+      let id = this.reasonIds.get(text);
+      if (id === void 0) {
+        id = this.reasonIds.size;
+        this.reasonIds.set(text, id);
+        const info = { i: id, ...fields };
+        this.reasonList.push(info);
+        this.emit({ k: "reason", info });
+      }
+      this.reasonIdsByFields.set(fieldKey, id);
+      return id;
+    }
+    emit(event) {
+      if (this.stopped && event.k !== "end") return;
+      try {
+        this.deps.onEvent(event);
+      } catch {
+      }
+    }
+    readConditions() {
+      return {
+        viewport: `${innerWidth}\xD7${innerHeight}`,
+        url: safeUrl(location.pathname + location.search),
+        dpr: devicePixelRatio,
+        ...this.deps.plugins.conditions()
+      };
+    }
+    // ---- result ----------------------------------------------------------------------------------------------------
+    hookInfo(agg) {
+      if (!agg.hookIdx.size && !agg.contexts.size) return void 0;
+      const fiber = agg.latest?.deref();
+      if (!fiber) return void 0;
+      const out = {};
+      let names2 = null;
+      if (this.options.hookNames !== false && isMounted(fiber)) {
+        try {
+          names2 = inspectHooks(fiber);
+        } catch (error) {
+          this.warnings.push(`hook names for ${agg.name}: ${String(error?.message ?? error).slice(0, 120)}`);
+        }
+      }
+      for (const index of agg.hookIdx) out[index] = names2?.hooks.get(index) ?? { type: hookTypeAt(fiber, index) };
+      for (const [key, context] of agg.contexts) {
+        const info = names2?.contexts.get(context);
+        if (info) out[key] = info;
+      }
+      return out;
+    }
+    rootStat(agg, withHooks) {
+      return {
+        key: agg.key,
+        name: agg.name,
+        source: agg.source,
+        ...agg.generated ? { generatedSource: agg.generated } : {},
+        path: agg.path,
+        hits: agg.hits,
+        instances: agg.instances,
+        cascade: agg.cascade,
+        perHit: agg.hits ? Math.round(agg.cascade / agg.hits) : 0,
+        medianGapMs: medianGapMs(agg.times),
+        firstAtMs: agg.times[0] ?? 0,
+        lastAtMs: agg.times.at(-1) ?? 0,
+        reasons: topEntries(agg.reasons, 8),
+        causes: topEntries(agg.causes, 8),
+        lanes: topEntries(agg.lanes, 5),
+        noDomChange: agg.noDomChange,
+        ...agg.renderMs ? { renderMs: +agg.renderMs.toFixed(1) } : {},
+        ...agg.mounts ? { mounts: agg.mounts } : {},
+        ...agg.library ? { library: true } : {},
+        ...withHooks ? { hooks: this.hookInfo(agg) } : {},
+        ...agg.outside ? { scopeRenders: agg.cascade } : {}
+      };
+    }
+    build(durationMs, sections, conditionsAfter) {
+      const inside = this.rootList.filter((r) => !r.outside).sort((a, b) => b.cascade - a.cascade);
+      const outside = this.rootList.filter((r) => r.outside).sort((a, b) => b.cascade - a.cascade);
+      const hooksFor = /* @__PURE__ */ new Set([...inside.slice(0, 30), ...outside.slice(0, 10)]);
+      const statsByIndex = /* @__PURE__ */ new Map();
+      for (const agg of this.rootList) statsByIndex.set(agg.index, this.rootStat(agg, hooksFor.has(agg)));
+      const remap = /* @__PURE__ */ new Map();
+      const orderedInside = inside.map((agg) => agg.index);
+      const allOrdered = [...orderedInside, ...outside.map((agg) => agg.index)];
+      allOrdered.forEach((index, i) => remap.set(index, i));
+      const mapRoots = (pairs) => pairs?.map(([index, n]) => [remap.get(index), n]);
+      const rootsOrdered = allOrdered.map((index) => statsByIndex.get(index));
+      const ways = this.exportNodes((agg) => remap.get(agg.index));
+      const changed = Object.fromEntries(
+        Object.keys({ ...this.conditions, ...conditionsAfter }).filter((key) => this.conditions[key] !== conditionsAfter[key]).map((key) => [key, [this.conditions[key] ?? null, conditionsAfter[key] ?? null]])
+      );
+      const actions = this.actions?.actions ?? [];
+      const segments = buildSegments(
+        actions,
+        this.segmentCommits.map((c) => ({ ...c, roots: mapRoots(c.roots) })),
+        this.frames.latency,
+        this.frames.loaf
+      );
+      const actionOfCommit = /* @__PURE__ */ new Map();
+      for (const segment of segments) for (const i of segment.commitIds ?? []) actionOfCommit.set(i, segment.action);
+      const commitsOfAction = new Map(segments.map((s) => [s.action, s.commitIds ?? []]));
+      const kept = (i) => i < this.commitList.length;
+      for (const action of actions) {
+        const ids = commitsOfAction.get(action.id)?.filter(kept);
+        if (ids?.length) action.commitIds = ids;
+      }
+      const memos = this.memoHits.result((fiber) => {
+        if (this.options.hookNames === false || !isMounted(fiber)) return null;
+        try {
+          return inspectHooks(fiber)?.hooks ?? null;
+        } catch {
+          return null;
+        }
+      });
+      const commits = this.totals.commits;
+      const commitsInScope = this.totals.commitsInScope;
+      return {
+        schema: RECORDING_SCHEMA,
+        version: 2,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...this.options.label ? { label: this.options.label } : {},
+        tool: { version: this.config.version, source: this.options.source ?? "panel", plugins: this.deps.plugins.info() },
+        page: {
+          url: safeUrl(location.href),
+          title: document.title,
+          viewport: `${innerWidth}\xD7${innerHeight}`,
+          dpr: devicePixelRatio,
+          userAgent: navigator.userAgent
+        },
+        react: { version: reactVersion(), roots: this.roots.length, profileTimings: this.rootList.some((r) => r.renderMs > 0) },
+        ...this.options.meta ? { meta: this.options.meta } : {},
+        options: optionsJson(this.options),
+        startedAt: this.startedAt.toISOString(),
+        durationMs,
+        scope: this.scope ? {
+          name: this.scope.name,
+          // Asked again rather than kept from when the area was picked: by now the dev server may have mapped it.
+          source: sourceOf(this.scope.target, this.config.projectRoot) || this.scope.source,
+          path: this.scope.ancestorNames().slice(-6),
+          state: this.scope.state,
+          remounts: this.scope.remounts,
+          lostAtMs: this.scope.lostAtMs
+        } : null,
+        totals: {
+          commits,
+          commitsInScope,
+          renders: this.totals.renders,
+          mounts: this.totals.mounts,
+          rendersPerCommit: commits ? +(this.totals.renders / commits).toFixed(1) : 0,
+          rendersPerScopeCommit: commitsInScope ? +(this.totals.renders / commitsInScope).toFixed(1) : 0,
+          rendersFromOutside: this.totals.rendersFromOutside,
+          rendersWithoutDom: this.totals.rendersWithoutDom,
+          domTextChanges: this.dom.counts.text,
+          causesDropped: this.totals.causesDropped,
+          lanes: this.totals.lanes
+        },
+        roots: rootsOrdered.slice(0, orderedInside.length),
+        outsideRoots: rootsOrdered.slice(orderedInside.length),
+        // The app's own components first: a UI kit fills the top with its wrappers and internals otherwise.
+        components: [...this.components].sort(
+          (a, b) => Number(a[1].library || a[1].wrapper) - Number(b[1].library || b[1].wrapper) || b[1].renders + b[1].mounts - (a[1].renders + a[1].mounts)
+        ).slice(0, 150).map(([name, s]) => ({
+          name,
+          renders: s.renders,
+          ...s.mounts ? { mounts: s.mounts } : {},
+          ...s.library ? { library: true } : {},
+          ...s.wrapper ? { wrapper: true } : {},
+          withoutDom: s.withoutDom,
+          byParent: s.byParent,
+          ...s.memo ? { memo: true } : {},
+          reasons: topEntries(s.reasons, 4),
+          ...s.chains.size ? {
+            chains: topEntries(s.chains, CHAINS_PER_COMPONENT).map(([id, n]) => ({
+              n,
+              links: this.chainLinks(id, (agg) => remap.get(agg.index))
+            }))
+          } : {},
+          ...s.sampled ? { sampled: true } : {}
+        })),
+        ...this.watch.size ? {
+          watch: Object.fromEntries(
+            [...this.watch].map(([name, w]) => [
+              name,
+              {
+                mounted: w.mounted,
+                renders: w.renders,
+                byRoot: [...w.byRoot].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([agg, n]) => [agg ? remap.get(agg.index) : null, n])
+              }
+            ])
+          )
+        } : {},
+        ...this.zones.size ? { zones: Object.fromEntries(this.zones) } : {},
+        causes: [...this.causeStats.values()].sort((a, b) => b.commits - a.commits),
+        actions,
+        segments: segments.map(({ commitIds: _ids, ...rest }) => rest),
+        ...memos.length ? { memos } : {},
+        latency: this.frames.latency,
+        reasons: this.reasonList,
+        ...ways.nodes.length ? { chainNodes: ways.nodes } : {},
+        commits: {
+          list: this.commitList.map((commit) => ({
+            ...commit,
+            ...commit.ways ? { ways: commit.ways.map(([id, n]) => [ways.renumber.get(id), n]) } : {},
+            ...commit.roots ? { roots: commit.roots.map((r) => ({ ...r, i: remap.get(r.i) })) } : {},
+            ...commit.outside !== void 0 ? { outside: remap.get(commit.outside) } : {},
+            ...actionOfCommit.get(commit.i) !== void 0 ? { actionId: actionOfCommit.get(commit.i) } : {}
+          })),
+          truncated: this.truncated
+        },
+        bigCommits: this.bigCommits.filter((i) => i < this.commitList.length),
+        frames: {
+          longTasks: this.frames.longTasks,
+          loaf: this.frames.loaf,
+          ...this.options.frames && durationMs ? { fps: +(this.frameCount * 1e3 / durationMs).toFixed(1) } : {}
+        },
+        dom: { ...this.dom.counts },
+        navigations: this.navigations,
+        hmr: this.hmr,
+        conditions: this.conditions,
+        ...Object.keys(changed).length ? { conditionsChanged: changed } : {},
+        plugins: sections,
+        overhead: {
+          commitMs: +(this.hook?.overhead.commitMs ?? 0).toFixed(1),
+          maxCommitMs: +(this.hook?.overhead.maxCommitMs ?? 0).toFixed(1),
+          overlayMs: +this.overlayMs.toFixed(1),
+          highlight: this.highlighted
+        },
+        warnings: [
+          ...this.warnings,
+          ...[...this.components.values()].some((comp) => comp.sampled) ? [
+            `reasons of renders caused by a parent were worked out for ${SAMPLED_PARENTS} instances of a component a commit: their counts are a sample`
+          ] : [],
+          ...sourcesUnavailable() ? [
+            `React ${reactVersion() ?? "19.0"} tells nothing about where a component comes from: no files, and the app's own components cannot be told from a package's. React 19.1 or newer brings both back.`
+          ] : [],
+          ...this.highlighted ? ["highlight was on: drawing the outlines costs main-thread time, so timings and long frames read high"] : []
+        ],
+        errors: this.errors
+      };
+    }
+  };
+  function isMounted(fiber) {
+    const root = hostRootOf(fiber);
+    if (!root) return false;
+    let top = fiber;
+    while (top?.return) top = top.return;
+    return top === root.current || top === root.current.alternate;
+  }
+  function optionsJson(options) {
+    const out = {};
+    for (const [key, value] of Object.entries(options)) {
+      if (key === "scope" || key === "meta" || value === void 0) continue;
+      out[key] = value;
+    }
+    return out;
+  }
+
+  // src/core/transport.ts
+  var FLUSH_MS = 2e3;
+  var HEARTBEAT_MS = 1e4;
+  var BATCH = 200;
+  var PENDING_KEY = "react-perf-recorder:session";
+  var SessionWriter = class {
+    constructor(endpoint, meta) {
+      this.endpoint = endpoint;
+      this.id = null;
+      this.failed = null;
+      this.token = null;
+      this.queue = [];
+      this.timer = null;
+      this.heartbeat = null;
+      this.sending = Promise.resolve();
+      this.opening = this.open(meta);
+    }
+    push(event) {
+      if (this.failed) return;
+      this.queue.push(event);
+      if (this.queue.length >= BATCH) void this.flush();
+      else if (!this.timer) this.timer = setTimeout(() => void this.flush(), FLUSH_MS);
+    }
+    flush() {
+      if (this.timer) clearTimeout(this.timer);
+      this.timer = null;
+      this.sending = this.sending.then(async () => {
+        await this.opening;
+        if (!this.id || this.failed || !this.queue.length) return;
+        const events = this.queue.splice(0);
+        await this.post(`sessions/${this.id}/events`, { events }).catch((error) => {
+          this.failed = `events not saved: ${String(error?.message ?? error)}`;
+        });
+      });
+      return this.sending;
+    }
+    /** Page is going away: send what is left without waiting; the server marks the session interrupted. */
+    beacon(atMs) {
+      if (!this.id || !this.token || this.failed) return;
+      const events = [...this.queue.splice(0), { k: "end", atMs }];
+      const url = `${this.endpoint}/sessions/${this.id}/events?token=${encodeURIComponent(this.token)}&end=1`;
+      try {
+        navigator.sendBeacon?.(url, new Blob([JSON.stringify({ events })], { type: "text/plain" }));
+      } catch {
+      }
+      this.clearPending();
+    }
+    async finish(recording) {
+      await this.flush();
+      this.stopHeartbeat();
+      this.clearPending();
+      if (!this.id || this.failed) return null;
+      try {
+        const saved = await this.post(`sessions/${this.id}/finish`, { recording });
+        return saved;
+      } catch (error) {
+        this.failed = `recording not saved: ${String(error?.message ?? error)}`;
+        return null;
+      }
+    }
+    static takeInterrupted() {
+      try {
+        const raw = sessionStorage.getItem(PENDING_KEY);
+        if (!raw) return null;
+        sessionStorage.removeItem(PENDING_KEY);
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    }
+    async open(meta) {
+      try {
+        const { id, token } = await this.post("sessions", meta);
+        this.id = id;
+        this.token = token;
+        try {
+          sessionStorage.setItem(PENDING_KEY, JSON.stringify({ id }));
+        } catch {
+        }
+        this.heartbeat = setInterval(() => void this.post(`sessions/${this.id}/events`, { events: [] }).catch(() => {
+        }), HEARTBEAT_MS);
+      } catch (error) {
+        this.failed = `dev server unavailable: ${String(error?.message ?? error)}`;
+      }
+    }
+    stopHeartbeat() {
+      if (this.heartbeat) clearInterval(this.heartbeat);
+      this.heartbeat = null;
+    }
+    clearPending() {
+      try {
+        sessionStorage.removeItem(PENDING_KEY);
+      } catch {
+      }
+    }
+    async post(path, body) {
+      const response = await fetch(`${this.endpoint}/${path}`, {
+        method: "POST",
+        headers: { "content-type": "application/json", [CLIENT_HEADER]: "1" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) throw new Error(`${response.status} ${await response.text().catch(() => "")}`.trim());
+      return response.json();
+    }
+  };
+
+  // src/core/engine.ts
+  function applySites(recording, sites) {
+    for (const action of recording.actions ?? []) {
+      const own2 = action.target?.generatedSource;
+      if (!own2) continue;
+      const mapped = sites[`${own2.url}:${own2.line}:${own2.column}`];
+      if (mapped) action.target.source = mapped.site;
+      delete action.target.generatedSource;
+    }
+    for (const root of [...recording.roots, ...recording.outsideRoots]) {
+      const own2 = root.generatedSource;
+      if (own2) {
+        const ownMapped = sites[`${own2.url}:${own2.line}:${own2.column}`];
+        if (ownMapped) root.source = ownMapped.site;
+        delete root.generatedSource;
+      }
+      for (const hook of Object.values(root.hooks ?? {})) {
+        const g = hook.generated;
+        if (!g) continue;
+        const mapped = sites[`${g.url}:${g.line}:${g.column}`];
+        if (mapped) {
+          hook.site = mapped.site;
+          if (mapped.code) hook.code = mapped.code;
+        }
+        delete hook.generated;
+      }
+    }
+    for (const memo of recording.memos ?? []) {
+      const g = memo.info?.generated;
+      if (!g) continue;
+      const mapped = sites[`${g.url}:${g.line}:${g.column}`];
+      if (mapped) {
+        memo.info.site = mapped.site;
+        if (mapped.code) memo.info.code = mapped.code;
+        if (mapped.deps) memo.info.deps = mapped.deps;
+      }
+      delete memo.info.generated;
+    }
+  }
+  var Engine = class {
+    constructor(config, plugins, highlight = null, ownHost = null) {
+      this.config = config;
+      this.plugins = plugins;
+      this.highlight = highlight;
+      this.ownHost = ownHost;
+      this.last = null;
+      this.recorder = null;
+      /** The area the running recording was started with, as it was found: a load recording finds it before the panel does. */
+      this.recordingScope = null;
+      this.writer = null;
+      this.timer = null;
+      /** `saved`: a recording that stopped on its own at the length limit, once it is saved — no one else asked for it. */
+      this.listeners = /* @__PURE__ */ new Set();
+      /** The stop the length limit made, for whoever was waiting to stop it themselves. */
+      this.autoStop = null;
+      this.idle = null;
+      this.idleHighlight = null;
+      this.idleRetry = null;
+      this.wrapperRe = new RegExp(config.wrapperPattern || "^$");
+    }
+    /** The panel and its highlight canvas: events inside the panel are not user actions. */
+    attachUi(highlight, ownHost) {
+      this.highlight = highlight;
+      this.ownHost = ownHost;
+    }
+    get version() {
+      return this.config.version;
+    }
+    get recording() {
+      return Boolean(this.recorder);
+    }
+    get scopeOfRecording() {
+      return this.recordingScope;
+    }
+    onChange(listener) {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    }
+    status() {
+      const roots = findRoots();
+      const busy = roots.map((root) => hookOwner(root)).find(Boolean) ?? null;
+      return {
+        version: this.version,
+        recording: this.recording,
+        busyOwner: this.recording ? null : busy,
+        react: { found: roots.length > 0, version: reactVersion(), roots: roots.length },
+        scope: this.recorder?.scopeInfo ?? null,
+        sessionId: this.writer?.id ?? null,
+        plugins: this.plugins.info()
+      };
+    }
+    /**
+     * Outlines renders in the area while nothing is recorded. A recording takes the commit hook over and, with
+     * `highlight` on, keeps drawing; this resumes after it stops.
+     */
+    highlightWhenIdle(on, scope = null) {
+      this.idle = on ? { scope } : null;
+      this.syncIdleHighlight();
+    }
+    get idleHighlighting() {
+      return Boolean(this.idleHighlight);
+    }
+    syncIdleHighlight() {
+      this.idleHighlight?.stop();
+      this.idleHighlight = null;
+      if (this.idleRetry) clearTimeout(this.idleRetry);
+      this.idleRetry = null;
+      if (!this.idle || this.recorder || !this.highlight) return;
+      try {
+        const live = new LiveHighlight(this.highlight, this.resolveScope(this.idle.scope));
+        if (live.start()) this.idleHighlight = live;
+      } catch {
+      }
+      if (!this.idleHighlight) this.idleRetry = setTimeout(() => this.syncIdleHighlight(), 1e3);
+    }
+    start(options = {}) {
+      if (this.recorder) throw new RecorderError("ALREADY", "a recording is already running");
+      const scope = this.resolveScope(options.scope ?? null);
+      this.idleHighlight?.stop();
+      this.idleHighlight = null;
+      const writerRef = { current: null };
+      const recorder = new Recorder(
+        {
+          config: this.config,
+          plugins: this.plugins,
+          ownHost: this.ownHost,
+          highlight: options.highlight === false ? null : this.highlight,
+          onEvent: (event) => writerRef.current?.push(event)
+        },
+        { ...options, scope }
+      );
+      try {
+        recorder.start();
+      } catch (error) {
+        this.syncIdleHighlight();
+        throw error;
+      }
+      this.recorder = recorder;
+      this.recordingScope = scope;
+      if (this.config.endpoint && options.save !== false) {
+        writerRef.current = this.writer = new SessionWriter(this.config.endpoint, {
+          source: options.source ?? "api",
+          label: options.label,
+          page: {
+            url: safeUrl(location.href),
+            title: document.title,
+            viewport: `${innerWidth}\xD7${innerHeight}`,
+            dpr: devicePixelRatio,
+            userAgent: navigator.userAgent
+          },
+          scope: recorder.scopeInfo,
+          conditions: recorder.startConditions,
+          plugins: this.plugins.info()
+        });
+      }
+      this.autoStop = null;
+      this.timer = setTimeout(() => {
+        const stop = this.autoStop = this.stop();
+        stop.then((saved) => this.listeners.forEach((l) => l("saved", saved))).catch(() => {
+        });
+      }, this.config.maxDurationMs);
+      this.listeners.forEach((l) => l("started"));
+      return { scope: recorder.scopeInfo };
+    }
+    /** Stops, builds the recording and, with a dev server, saves it; resolves with the id of the saved session. */
+    async stop() {
+      const recorder = this.recorder;
+      if (!recorder) throw new RecorderError("NOT_RECORDING", "no recording is running");
+      if (this.timer) clearTimeout(this.timer);
+      this.recorder = null;
+      this.recordingScope = null;
+      const writer = this.writer;
+      this.writer = null;
+      let recording;
+      try {
+        recording = recorder.stop();
+      } finally {
+        this.syncIdleHighlight();
+        this.listeners.forEach((l) => l("stopped"));
+      }
+      if (writer) {
+        const saved = await writer.finish(recording);
+        if (saved) {
+          Object.assign(recording, { id: saved.id, dir: saved.dir });
+          applySites(recording, saved.sites ?? {});
+        } else recording.saveError = writer.failed ?? "not saved";
+      }
+      this.last = recording;
+      return recording;
+    }
+    async record(durationMs, options = {}) {
+      this.start(options);
+      await new Promise((resolve) => setTimeout(resolve, durationMs));
+      if (!this.recorder && this.autoStop) return this.autoStop;
+      return this.stop();
+    }
+    live() {
+      return this.recorder?.live() ?? null;
+    }
+    noteHmr(type, paths) {
+      this.recorder?.noteHmr(type, paths);
+    }
+    /** The page unloads mid-recording: flush what is left; the server marks the session interrupted. */
+    interrupt() {
+      if (!this.recorder) return;
+      this.writer?.beacon(Math.round(this.recorder.now()));
+    }
+    /**
+     * The app's own components on the page right now, by name. A script that was told to record inside one and did
+     * not find it can say what there is instead of failing into nothing.
+     */
+    componentNames(limit = 60) {
+      const names2 = /* @__PURE__ */ new Set();
+      eachFiber((f) => {
+        const name = nameOf(f);
+        if (name && !isLibraryFiber(f)) names2.add(name);
+        return names2.size < limit;
+      });
+      return [...names2];
+    }
+    /**
+     * Every instance of a component on the page now, found by its name and file. A line that moved since the
+     * recording (the code was edited) still finds it by the file; failing that, by the name alone.
+     */
+    findComponents(name, source, limit = 50) {
+      const named = [];
+      eachFiber((f) => {
+        const inner = f.return !== null && isComposite(f.return) && nameOf(f.return) === name;
+        if (nameOf(f) === name && isComposite(f) && !inner) named.push(f);
+        return named.length < limit * 4;
+      });
+      if (!source) return named.slice(0, limit);
+      const file = source.replace(/:\d+(:\d+)?$/, "");
+      const same2 = named.filter((f) => sourceOf(f, this.config.projectRoot) === source);
+      const sameFile = named.filter((f) => sourceOf(f, this.config.projectRoot).replace(/:\d+(:\d+)?$/, "") === file);
+      return (same2.length ? same2 : sameFile.length ? sameFile : named).slice(0, limit);
+    }
+    /**
+     * The topmost of the app's own components, as the tree shows them with these filters: where a tree of the whole
+     * app opens when no area has been picked yet.
+     */
+    topComponent(shown) {
+      for (const root of findRoots()) {
+        const [top] = compositeChildren(root.current, (f) => this.hidden(this.ownerOf(f), shown), 1);
+        if (top) return top;
+      }
+      return null;
+    }
+    /** Composite ancestors of an element, nearest first. */
+    owners(el) {
+      const host = fiberFromNode(el);
+      return host ? this.ownersOfFiber(host) : [];
+    }
+    /** The fiber itself when it is a component, then its composite ancestors, nearest first. */
+    ownersOfFiber(fiber) {
+      return compositeChain(currentOf(fiber)).reverse().map((f) => this.ownerOf(f));
+    }
+    ownerOf(fiber) {
+      const name = nameOf(fiber) ?? "Anonymous";
+      return {
+        name,
+        source: sourceOf(fiber, this.config.projectRoot),
+        wrapper: this.wrapperRe.test(name),
+        provider: isProvider(name) || wrapsProvider(fiber),
+        library: isLibraryFiber(fiber),
+        fiber
+      };
+    }
+    /** Nearest components below one; what is hidden is walked through, not stopped at. */
+    childOwners(fiber, shown) {
+      return compositeChildren(fiber, (f) => this.hidden(this.ownerOf(f), shown)).map((f) => this.ownerOf(f));
+    }
+    /** A component the tree leaves out: the checkboxes decide, and an unnamed wrapper follows the library one. */
+    hidden(owner, shown) {
+      return !shown.library && (owner.library || owner.wrapper) || !shown.providers && owner.provider;
+    }
+    scopeFromFiber(fiber) {
+      return scopeFromFiber(fiber, this.config.projectRoot);
+    }
+    scopeFromElement(el, level = 0) {
+      const owners = this.owners(el).filter((o) => !o.wrapper && !o.library && !o.provider);
+      const owner = owners[Math.min(level, owners.length - 1)];
+      if (!owner) throw new RecorderError("SCOPE_NOT_FOUND", "no React component owns this element");
+      return this.scopeFromFiber(owner.fiber);
+    }
+    /** Finds the component again after a reload by its composite path, e.g. ['OrdersPanel', 'PositionTable']. */
+    scopeFromNames(names2) {
+      const target2 = names2.at(-1);
+      let found = null;
+      eachFiber((f) => {
+        if (!target2 || nameOf(f) !== target2) return;
+        const chain = compositeChain(f).map((x) => nameOf(x)).filter((n) => Boolean(n));
+        let i = names2.length - 1;
+        for (let j = chain.length - 1; j >= 0 && i >= 0; j--) if (chain[j] === names2[i]) i--;
+        if (i < 0) found = f;
+        return i >= 0;
+      });
+      if (found) return this.scopeFromFiber(found);
+      throw new RecorderError("SCOPE_NOT_FOUND", `component ${names2.join(" > ")} is not mounted`);
+    }
+    resolveScope(spec) {
+      if (!spec) return null;
+      if ("kind" in spec) return spec;
+      if ("names" in spec) return this.scopeFromNames(spec.names);
+      const el = document.querySelector(spec.selector);
+      if (!el) throw new RecorderError("SCOPE_NOT_FOUND", `no element matches ${spec.selector}`);
+      if (spec.component) {
+        const owner = this.owners(el).find((o) => o.name === spec.component);
+        if (!owner) throw new RecorderError("SCOPE_NOT_FOUND", `${spec.component} does not own ${spec.selector}`);
+        return this.scopeFromFiber(owner.fiber);
+      }
+      return this.scopeFromElement(el, spec.level ?? 0);
+    }
+  };
+
+  // src/core/plugins.ts
+  var WAIT_MS = 1e3;
+  var MAX_BUFFER = 5e3;
+  var PluginHost = class {
+    constructor(entries) {
+      this.loaded = [];
+      this.recording = false;
+      /** Set by the recorder: components that got updates since the last commit, to aim a cause at their roots. */
+      this.targets = null;
+      this.buffer = [];
+      /** `waitForTimer` events, until a timer of their plugin's packages runs. */
+      this.waiting = [];
+      this.owners = /* @__PURE__ */ new Map();
+      /** Plugins whose events a timer of theirs has delivered in this recording. */
+      this.delivering = /* @__PURE__ */ new Set();
+      this.t0 = 0;
+      this.warnings = [];
+      for (const [factoryOrPlugin, options] of entries) {
+        try {
+          const plugin = typeof factoryOrPlugin === "function" ? factoryOrPlugin(options) : factoryOrPlugin;
+          if (!plugin?.name) throw new Error("plugin without a name");
+          this.loaded.push({ plugin });
+          for (const name of plugin.packages ?? []) this.owners.set(name, plugin.name);
+        } catch (error) {
+          this.loaded.push({ plugin: { name: `plugin#${this.loaded.length}` }, error: String(error?.message ?? error) });
+        }
+      }
+    }
+    setupAll() {
+      for (const entry of this.loaded) {
+        if (entry.error || !entry.plugin.setup) continue;
+        this.guard(entry, () => entry.plugin.setup(this.context(entry.plugin.name)));
+      }
+    }
+    info() {
+      return this.loaded.map(({ plugin, error }) => ({ name: plugin.name, sectionVersion: plugin.sectionVersion ?? 1, ...error ? { error } : {} }));
+    }
+    context(name) {
+      const host = this;
+      return {
+        get recording() {
+          return host.recording;
+        },
+        emitCause: (event) => host.emit(name, event),
+        now: () => host.now(),
+        warn: (message) => host.warnings.push(`${name}: ${message}`)
+      };
+    }
+    /** Aimed only when the caller says it can be: an event that runs before React cannot say whom it woke. */
+    emit(plugin, event, fibers) {
+      if (!this.recording || this.buffer.length >= MAX_BUFFER) return null;
+      if (event.waitForTimer && this.waiting.length < MAX_BUFFER) {
+        const same2 = event.merge ? this.waiting.find((w) => w.plugin === plugin && w.merge === event.merge) : void 0;
+        if (same2) {
+          same2.type = event.type;
+          return same2;
+        }
+        const cause2 = {
+          plugin,
+          type: event.type,
+          atMs: Math.round(this.now()),
+          changes: event.changes,
+          data: event.data,
+          merge: event.merge,
+          order: nextOrder(),
+          emittedMs: performance.now()
+        };
+        this.waiting.push(cause2);
+        return cause2;
+      }
+      const aimed = fibers ?? (event.aim ? this.targets?.() : void 0);
+      const cause = {
+        plugin,
+        type: event.type,
+        atMs: Math.round(this.now()),
+        changes: event.changes,
+        data: event.data,
+        ...aimed ? { aimed: true } : {},
+        fibers: aimed?.size ? aimed : void 0
+      };
+      this.buffer.push(cause);
+      return cause;
+    }
+    get hasWaiting() {
+      return this.waiting.length > 0;
+    }
+    /**
+     * A timer of `library` updated components: the events its plugin had waiting since before it started go to them,
+     * or to the commit as it is when `fibers` is null (the commit ran inside the timer). Returns whether it was a
+     * plugin's delivery, which then needs no cause of its own. A timer that updated no one is not called: a library
+     * runs other timers too (garbage collection, the next poll), and one of those must not take the events.
+     */
+    deliver(library, fibers, startedAt = Infinity) {
+      const plugin = library ? this.owners.get(library) : void 0;
+      if (!plugin) return false;
+      const mine = this.waiting.filter((w) => w.plugin === plugin && w.order < startedAt);
+      if (!mine.length) return false;
+      this.waiting = this.waiting.filter((w) => !mine.includes(w));
+      this.delivering.add(plugin);
+      const aimed = fibers();
+      for (const { merge, order: order2, emittedMs, ...cause } of mine) this.buffer.push(aimed ? { ...cause, aimed: true, fibers: aimed } : cause);
+      return true;
+    }
+    drain() {
+      if (this.waiting.length && performance.now() - this.waiting[0].emittedMs > WAIT_MS) {
+        const cutoff = performance.now() - WAIT_MS;
+        for (const { merge, order: order2, emittedMs, ...cause } of this.waiting.filter((w) => w.emittedMs <= cutoff))
+          if (!this.delivering.has(cause.plugin)) this.buffer.push(cause);
+        this.waiting = this.waiting.filter((w) => w.emittedMs > cutoff);
+      }
+      if (!this.buffer.length) return this.buffer;
+      const out = this.buffer;
+      this.buffer = [];
+      return out;
+    }
+    now() {
+      return performance.now() - this.t0;
+    }
+    selector(fn, depth = 0) {
+      if (depth > 3) return fallbackSelectorLabel(fn);
+      return this.describe(fn, "selector", depth) ?? fallbackSelectorLabel(fn);
+    }
+    store(getSnapshot) {
+      return this.describe(getSnapshot, "store", 0);
+    }
+    describe(fn, kind, depth) {
+      for (const entry of this.loaded) {
+        if (entry.error || !entry.plugin.describe) continue;
+        try {
+          const label = entry.plugin.describe(fn, kind, (inner) => this.selector(inner, depth + 1));
+          if (label != null) return label;
+        } catch {
+        }
+      }
+      return null;
+    }
+    start(session, t0) {
+      this.t0 = t0;
+      this.buffer = [];
+      this.waiting = [];
+      this.delivering.clear();
+      this.recording = true;
+      for (const entry of this.loaded) {
+        if (entry.error || !entry.plugin.start) continue;
+        this.guard(entry, () => entry.plugin.start({ ...this.context(entry.plugin.name), ...session }));
+      }
+    }
+    commit(session) {
+      for (const entry of this.loaded) {
+        if (entry.error || !entry.plugin.commit) continue;
+        this.guard(entry, () => entry.plugin.commit({ ...this.context(entry.plugin.name), ...session }));
+      }
+    }
+    stop(session) {
+      this.recording = false;
+      this.buffer = [];
+      this.waiting = [];
+      const sections = {};
+      for (const entry of this.loaded) {
+        if (entry.error || !entry.plugin.stop) continue;
+        this.guard(entry, () => {
+          const section = entry.plugin.stop({ ...this.context(entry.plugin.name), ...session });
+          if (section) sections[entry.plugin.name] = section;
+        });
+      }
+      return sections;
+    }
+    conditions() {
+      const out = {};
+      for (const entry of this.loaded) {
+        if (entry.error || !entry.plugin.conditions) continue;
+        this.guard(entry, () => Object.assign(out, entry.plugin.conditions()));
+      }
+      return out;
+    }
+    guard(entry, fn) {
+      try {
+        fn();
+      } catch (error) {
+        this.warnings.push(`${entry.plugin.name}: ${String(error?.message ?? error).slice(0, 200)}`);
+      }
+    }
+  };
+
+  // src/iife/engine.ts
+  var target = window;
+  if (!target[GLOBAL_KEY]) {
+    const engine = new Engine(
+      {
+        version: true ? "0.1.0" : "dev",
+        projectRoot: "",
+        wrapperPattern: "^(Anonymous|ForwardRef|Memo)$",
+        actions: { values: false, secretSelector: "" },
+        maxDurationMs: 6e5,
+        bigCommit: 150,
+        timelineLimit: 5e3,
+        endpoint: null
+      },
+      new PluginHost([])
+    );
+    captureRenderers();
+    installTimers();
+    target[GLOBAL_KEY] = { version: engine.version, engine, panel: null, format: { summarize, reasonLine, hookText, actionText } };
+  }
+})();