@atlassian/chippy 0.0.0-stage → 0.0.1-beta.2

package/lib/avalanche.js

@@ -0,0 +1,2601 @@
+// src/chippy-bridge/source-map.ts
+var DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var VALUE_OF = new Int8Array(128).fill(-1);
+for (let index = 0; index < DIGITS.length; index += 1) {
+  VALUE_OF[DIGITS.charCodeAt(index)] = index;
+}
+
+// src/chippy-bridge/fiber-source.ts
+var V8_FRAME = /^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/;
+var AT_FRAME = /^\s*(?:(.*?)@)(.+?):(\d+):(\d+)$/;
+var MAX_CALL_SITE_FRAMES = 4;
+var resolvedFiberSources = /* @__PURE__ */ new WeakMap();
+function parseStackFrames(stack) {
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    const line = raw.trimEnd();
+    if (line === "" || line.includes("(eval at ")) continue;
+    const match = V8_FRAME.exec(line) ?? AT_FRAME.exec(line);
+    if (!match) continue;
+    const [, name, url = "", lineDigits = "", columnDigits = ""] = match;
+    if (url === "" || url.startsWith("data:")) continue;
+    const at = Number(lineDigits);
+    const column = Number(columnDigits);
+    if (!Number.isFinite(at) || !Number.isFinite(column) || at < 1) continue;
+    frames.push({
+      url,
+      line: at,
+      column,
+      ...name !== void 0 && name !== "" ? { function: name } : {}
+    });
+  }
+  return frames;
+}
+function isVendorPath(path) {
+  return path.includes("node_modules") || path.includes("/.vite/deps/") || path.includes("/.yarn/");
+}
+function rawLocation(frame) {
+  return { fileName: frame.url, lineNumber: frame.line, columnNumber: frame.column };
+}
+function locationFromOriginal(original) {
+  return { fileName: original.source, lineNumber: original.line, columnNumber: original.column };
+}
+function writerLocationOf(frames, originalFor) {
+  for (const frame of frames) {
+    if (isVendorPath(frame.url)) continue;
+    const original = originalFor(frame);
+    if (original === null) return rawLocation(frame);
+    if (isVendorPath(original.source)) continue;
+    return locationFromOriginal(original);
+  }
+  return null;
+}
+function debugSourceOf(value) {
+  if (!value || typeof value !== "object") return null;
+  const source = value;
+  if (typeof source.fileName !== "string" || typeof source.lineNumber !== "number") return null;
+  return {
+    fileName: source.fileName,
+    lineNumber: source.lineNumber,
+    columnNumber: typeof source.columnNumber === "number" ? source.columnNumber : null
+  };
+}
+function recordedSource(fiber) {
+  const direct = debugSourceOf(fiber._debugSource);
+  if (direct) return direct;
+  const type = fiber.type;
+  return type && (typeof type === "object" || typeof type === "function") ? debugSourceOf(type._debugSource) : null;
+}
+function getFiberStackFrames(fiber) {
+  if (!fiber || !fiber._debugStack || typeof fiber._debugStack !== "object") return [];
+  const stack = fiber._debugStack.stack;
+  if (typeof stack !== "string" || stack === "") return [];
+  const candidates = [];
+  for (const frame of parseStackFrames(stack)) {
+    if (isVendorPath(frame.url)) continue;
+    candidates.push(frame);
+    if (candidates.length >= MAX_CALL_SITE_FRAMES) break;
+  }
+  return candidates;
+}
+function getFiberSourceCandidate(fiber) {
+  if (!fiber) return null;
+  const recorded = recordedSource(fiber);
+  if (recorded) return recorded;
+  return writerLocationOf(getFiberStackFrames(fiber), () => null);
+}
+function getFiberSource(fiber) {
+  if (!fiber) return null;
+  const cached = resolvedFiberSources.get(fiber);
+  if (cached !== void 0) return cached;
+  return getFiberSourceCandidate(fiber);
+}
+
+// src/avalanche/internals.tsx
+var PerformedWork = 1;
+var Placement = 2;
+var Hydrating = 4096;
+var COMPONENT_TAGS = /* @__PURE__ */ new Set([0, 1, 2, 11, 14, 15]);
+var CONTEXT_PROVIDER_TAG = 10;
+var SuspenseTag = 13;
+var ChildDeletion = 16;
+var Update = 4;
+function isComponentFiber(tag) {
+  return COMPONENT_TAGS.has(tag);
+}
+function isContextProviderFiber(tag) {
+  return tag === CONTEXT_PROVIDER_TAG;
+}
+function isSuspenseFiber(tag) {
+  return tag === SuspenseTag;
+}
+function didSuspenseStateChange(fiber) {
+  const currSuspended = fiber.memoizedState !== null;
+  if (!fiber.alternate) {
+    if (currSuspended) {
+      return { entered: true, left: false };
+    }
+    return null;
+  }
+  const prevSuspended = fiber.alternate.memoizedState !== null;
+  if (prevSuspended === currSuspended) return null;
+  return { entered: currSuspended, left: prevSuspended };
+}
+function didContextValueChange(fiber) {
+  if (fiber.tag !== CONTEXT_PROVIDER_TAG || !fiber.alternate) return false;
+  const alternateFiber = fiber.alternate;
+  const currentFiber = fiber;
+  const prevProps = alternateFiber.memoizedProps;
+  const currentProps = currentFiber.memoizedProps;
+  return prevProps && currentProps && !Object.is(prevProps.value, currentProps.value);
+}
+function isReactInternalComponentType(type) {
+  return typeof type === "symbol";
+}
+function getComponentName(fiber) {
+  const type = fiber.type;
+  const elementType = fiber.elementType;
+  const named = type?.displayName || type?.name || elementType?.displayName || elementType?.name;
+  if (named) return named;
+  const source = getFiberSourceCandidate(fiber);
+  return source && `<${source.fileName}:${source.lineNumber}>` || "Anonymous";
+}
+function isStateHook(hook) {
+  const queue = hook.queue;
+  if (!queue) return false;
+  return typeof queue.dispatch === "function" || "value" in queue && "getSnapshot" in queue;
+}
+function isExternalStoreHook(hook) {
+  const queue = hook.queue;
+  return queue && typeof queue.dispatch !== "function" && "value" in queue && "getSnapshot" in queue;
+}
+function detectHookStateChanges(prevHookChain, currentHookChain) {
+  if (prevHookChain === currentHookChain) {
+    return {
+      hasChange: false,
+      actionable: false,
+      changedIndices: [],
+      changedHooks: [],
+      hasExternalStoreChange: false
+    };
+  }
+  let prevHook = prevHookChain;
+  let currentHook = currentHookChain;
+  let memoizedStateIndex = 0;
+  const changedIndices = [];
+  const changedHooks = [];
+  let hasExternalStoreChange = false;
+  while (prevHook && currentHook) {
+    if (isStateHook(currentHook)) {
+      const prevValueRaw = prevHook.memoizedState === void 0 ? prevHook.queue?.lastRenderedState : prevHook.memoizedState;
+      const curValueRaw = currentHook.memoizedState === void 0 ? currentHook.queue?.lastRenderedState : currentHook.memoizedState;
+      if (!Object.is(prevValueRaw, curValueRaw)) {
+        const isExternal = isExternalStoreHook(currentHook);
+        if (isExternal) hasExternalStoreChange = true;
+        changedIndices.push(memoizedStateIndex);
+        changedHooks.push({
+          prevValue: prevValueRaw,
+          currentValue: curValueRaw,
+          ...isExternal && { isExternalStore: true }
+        });
+      }
+    }
+    prevHook = prevHook.next;
+    currentHook = currentHook.next;
+    memoizedStateIndex++;
+  }
+  return {
+    hasChange: changedIndices.length > 0,
+    actionable: changedIndices.length > 0,
+    changedIndices,
+    changedHooks,
+    hasExternalStoreChange
+  };
+}
+function detectHookThrashing(prevHookChain, currentHookChain, mode = "non-primitive", valueProvenance = null) {
+  if (prevHookChain === currentHookChain) {
+    return { effects: [], callbacks: [], memos: [] };
+  }
+  const thrashedEffects = [];
+  const thrashedCallbacks = [];
+  const thrashedMemos = [];
+  let prevHook = prevHookChain;
+  let currentHook = currentHookChain;
+  let hookIndex = 0;
+  while (prevHook && currentHook) {
+    if (!isStateHook(currentHook)) {
+      const prevValue = prevHook.memoizedState;
+      const currentValue = currentHook.memoizedState;
+      let prevDeps = null;
+      let currentDeps = null;
+      let hookType = null;
+      if (prevValue && currentValue && typeof prevValue === "object" && typeof currentValue === "object" && "deps" in prevValue && "deps" in currentValue && "tag" in currentValue) {
+        prevDeps = prevValue.deps;
+        currentDeps = currentValue.deps;
+        hookType = "effect";
+      } else if (Array.isArray(prevValue) && Array.isArray(currentValue) && prevValue.length === 2 && currentValue.length === 2 && Array.isArray(prevValue[1]) && Array.isArray(currentValue[1])) {
+        prevDeps = prevValue[1];
+        currentDeps = currentValue[1];
+        hookType = typeof currentValue[0] === "function" ? "callback" : "memo";
+      }
+      if (hookType && Array.isArray(prevDeps) && Array.isArray(currentDeps)) {
+        const changedDepIndices = [];
+        const changedDepOrigins = [];
+        for (let j = 0; j < currentDeps.length; j++) {
+          if (!Object.is(prevDeps[j], currentDeps[j])) {
+            changedDepIndices.push(j);
+            let origin = null;
+            const dep = currentDeps[j];
+            if (valueProvenance && dep != null && (typeof dep === "object" || typeof dep === "function")) {
+              origin = valueProvenance.get(dep) || null;
+            }
+            changedDepOrigins.push(origin);
+          }
+        }
+        let shouldReport = changedDepIndices.length > 0;
+        if (shouldReport && mode === "non-primitive") {
+          shouldReport = changedDepIndices.some((idx) => {
+            const dep = currentDeps[idx];
+            const t = typeof dep;
+            return !(dep == null || t === "string" || t === "number" || t === "boolean" || t === "symbol" || t === "bigint");
+          });
+        }
+        if (shouldReport) {
+          const thrashInfo = {
+            hookIndex,
+            hookType,
+            deps: currentDeps,
+            changedDepIndices,
+            changedDepOrigins
+          };
+          if (hookType === "effect") {
+            const effectValue = currentValue;
+            thrashInfo.effectTag = effectValue.tag;
+            if (effectValue.create) {
+              thrashInfo.hookBody = effectValue.create;
+            }
+            thrashedEffects.push(thrashInfo);
+          } else if (hookType === "callback") {
+            const callbackFn = currentValue[0];
+            thrashInfo.hookBody = callbackFn;
+            thrashedCallbacks.push(thrashInfo);
+          } else {
+            const memoValue = currentValue[0];
+            thrashInfo.memoValue = memoValue;
+            thrashInfo.hookBody = memoValue;
+            thrashedMemos.push(thrashInfo);
+          }
+        }
+      }
+    }
+    prevHook = prevHook.next;
+    currentHook = currentHook.next;
+    hookIndex++;
+  }
+  return {
+    effects: thrashedEffects,
+    callbacks: thrashedCallbacks,
+    memos: thrashedMemos
+  };
+}
+function didFiberUpdate(fiber) {
+  return (fiber.flags & PerformedWork) !== 0;
+}
+function didFiberSelfUpdate(fiber) {
+  if (!didFiberUpdate(fiber)) return null;
+  const alt = fiber.alternate;
+  if (!alt) return null;
+  const prevState = alt.memoizedState;
+  const currentState = fiber.memoizedState;
+  const result = detectHookStateChanges(prevState, currentState);
+  return result.hasChange ? result : null;
+}
+function isDevelopment() {
+  return true;
+}
+
+// src/avalanche/commit-stats-indices.ts
+var CS_RESTARTS = 2;
+var CS_UNMOUNTED_COMPONENTS = 8;
+var CS_UNMOUNTED_SUBTREES = 9;
+
+// src/avalanche/report-serializer.tsx
+function serializeReport(report) {
+  const sources = report.sources.map((source) => ({
+    sourceId: source.sourceId,
+    depth: source.depth,
+    causedUpdates: source.causedUpdates,
+    collateralUpdates: source.collateralUpdates,
+    maxCollateralUpdates: source.maxCollateralUpdates,
+    maxPenetrationDepth: source.maxPenetrationDepth,
+    ...source.restartWaste !== void 0 && { restartWaste: source.restartWaste },
+    ...source.maxRestartWaste !== void 0 && { maxRestartWaste: source.maxRestartWaste }
+  }));
+  const sourcesByCommit = report.sourcesByCommit ? Object.fromEntries(
+    Object.entries(report.sourcesByCommit).map(([commitId, commitSources]) => [
+      commitId,
+      commitSources.map((src) => ({
+        sourceId: src.sourceId,
+        depth: src.depth,
+        collateral: src.collateral,
+        rank: src.rank,
+        sourceIndex: src.sourceIndex,
+        ...(src.trashers || src.hooks) && { trashers: src.trashers || src.hooks },
+        ...src.isRepeat && { isRepeat: true }
+      }))
+    ])
+  ) : void 0;
+  const suspenseByCommit = {};
+  if (report.suspenseByCommit) {
+    for (const [k, evts] of Object.entries(report.suspenseByCommit)) {
+      suspenseByCommit[Number(k)] = evts.map((e) => ({
+        depth: e.depth,
+        entered: e.entered,
+        left: e.left
+      }));
+    }
+  }
+  return {
+    meta: report.meta,
+    sources,
+    commitStats: report.commitStats,
+    suspenseByCommit,
+    ...sourcesByCommit && { sourcesByCommit },
+    ...report.interactionsByCommit && { interactionsByCommit: report.interactionsByCommit },
+    ...report.renderedByCommit && { renderedByCommit: report.renderedByCommit },
+    ...(report.metricsByCommit || report.atlByCommit) && {
+      metricsByCommit: report.metricsByCommit || report.atlByCommit,
+      atlByCommit: report.metricsByCommit || report.atlByCommit
+    },
+    ...report.timing && { timing: report.timing }
+  };
+}
+
+// src/avalanche/commit-metrics-adapter.ts
+var active = null;
+var REQUIRED_METHODS = ["isAvailable", "snapshot", "measure", "attach", "isAttached", "reattach", "detach"];
+function registerCommitMetricsAdapter(adapter) {
+  if (!adapter || typeof adapter.id !== "string" || !adapter.id) {
+    throw new TypeError("registerCommitMetricsAdapter expects an adapter with a non-empty id");
+  }
+  for (const method of REQUIRED_METHODS) {
+    if (typeof adapter[method] !== "function") {
+      throw new TypeError(`commit metrics adapter ${adapter.id} is missing ${method}()`);
+    }
+  }
+  active = adapter;
+  return () => {
+    if (active === adapter) active = null;
+  };
+}
+function getCommitMetricsAdapter() {
+  return active;
+}
+function adapterIdFromMode(mode) {
+  return typeof mode === "string" && mode.startsWith("adapter:") ? mode.slice("adapter:".length) : null;
+}
+
+// src/avalanche/reporter.tsx
+function isTrueSource(s) {
+  const commits = Object.values(s.updateHistory);
+  if (commits.length === 0) return false;
+  for (let i = 0; i < commits.length; i++) {
+    const entry = commits[i];
+    if (!entry || entry === "repeat") {
+    } else if (typeof entry === "object" && entry !== null) {
+      if (Object.values(entry).some((hook) => hook !== "repeat")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function buildReport(state, thrashMode, topN, sortBy, options = {}, detectorConfig) {
+  const { minCollateral = 1 } = options;
+  const toHumanReadableId = (internalId, type, depth) => {
+    const componentName = getComponentName({ type });
+    const match = internalId.match(/#(\d+)@/);
+    const instanceNum = match ? match[1] : "1";
+    return `${componentName}#${instanceNum}@${depth}`;
+  };
+  const idMapping = /* @__PURE__ */ new Map();
+  const allSources = Array.from(state.sources.entries()).map(([internalId, s]) => {
+    const humanId = toHumanReadableId(internalId, s.type, s.depth);
+    idMapping.set(internalId, humanId);
+    return {
+      sourceId: humanId,
+      ...s,
+      maxPenetrationDepth: Math.max(0, s.maxPenetrationDepth - s.depth),
+      // Convert to relative depth (never negative!)
+      // Initialize restart waste tracking
+      restartWaste: 0,
+      maxRestartWaste: 0,
+      restartWasteByCommit: {}
+    };
+  }).filter(isTrueSource);
+  Object.entries(state.commitStats).forEach(([commitIdStr, stats]) => {
+    const commitId = Number(commitIdStr);
+    const restarts = stats[CS_RESTARTS];
+    if (restarts === 0) return;
+    const sourcesInCommit = allSources.filter(
+      (source) => source.updateHistory[commitId] !== void 0
+    );
+    if (sourcesInCommit.length === 0) {
+      return;
+    }
+    const restartsPerSource = restarts / sourcesInCommit.length;
+    for (const sourceItem of sourcesInCommit) {
+      sourceItem.restartWaste += restartsPerSource;
+      sourceItem.restartWasteByCommit[commitId] = restartsPerSource;
+      if (restartsPerSource > sourceItem.maxRestartWaste) {
+        sourceItem.maxRestartWaste = restartsPerSource;
+      }
+    }
+  });
+  if (thrashMode === "full") {
+    for (const sourceItem of allSources) {
+      const amplifiedByThisSource = [];
+      state.amplifierSources.forEach((amplifierData, amplifierInternalId) => {
+        const amplifierHumanId = idMapping.get(amplifierInternalId) || toHumanReadableId(amplifierInternalId, amplifierData.type, amplifierData.depth);
+        const causedByHumanId = amplifierData.causedBySourceId ? idMapping.get(amplifierData.causedBySourceId) : null;
+        if (causedByHumanId === sourceItem.sourceId || amplifierHumanId === sourceItem.sourceId) {
+          amplifiedByThisSource.push({
+            sourceId: amplifierHumanId,
+            type: amplifierData.type,
+            depth: amplifierData.depth,
+            effectCount: amplifierData.effectCount,
+            callbackCount: amplifierData.callbackCount,
+            memoCount: amplifierData.memoCount,
+            hooksTotal: amplifierData.hooksTotal,
+            commitIds: amplifierData.commitIds,
+            byCommit: amplifierData.byCommit,
+            lastAmplification: amplifierData.lastAmplification
+          });
+        }
+      });
+      if (amplifiedByThisSource.length > 0) {
+        sourceItem.amplified = amplifiedByThisSource;
+      }
+    }
+  }
+  const sources = [...allSources].sort((a, b) => {
+    const aTotalWaste = a.collateralUpdates + (a.restartWaste || 0);
+    const bTotalWaste = b.collateralUpdates + (b.restartWaste || 0);
+    return bTotalWaste - aTotalWaste || b.maxCollateralUpdates - a.maxCollateralUpdates || (b.maxRestartWaste || 0) - (a.maxRestartWaste || 0);
+  }).slice(0, topN);
+  const coverage = state.commits > 0 ? Math.round(state.commitsWithMemoizedUpdaters / state.commits * 100) + "%" : "0%";
+  const timingEntries = Object.values(state.commitTimings);
+  const totalDetectorOverhead = timingEntries.reduce((sum, t) => sum + t.detectorOverhead, 0);
+  const totalTimeSpan = timingEntries.reduce((sum, t) => sum + t.timeSinceLastCommit, 0);
+  const avgDetectorOverhead = timingEntries.length > 0 ? totalDetectorOverhead / timingEntries.length : 0;
+  const avgTimeBetweenCommits = timingEntries.length > 0 ? totalTimeSpan / timingEntries.length : 0;
+  const topNLookup = /* @__PURE__ */ new Map();
+  for (let i = 0; i < sources.length; i++) {
+    topNLookup.set(sources[i].sourceId, { rank: i + 1, index: i });
+  }
+  const sourcesByCommit = {};
+  allSources.forEach((source) => {
+    Object.entries(source.updateHistory).forEach(([commitIdStr, data]) => {
+      const commitId = Number(commitIdStr);
+      if (typeof data === "string" && data !== "repeat") {
+        return;
+      }
+      const collateral = source.collateralByCommit?.[commitId] ?? 0;
+      if (collateral < minCollateral) {
+        return;
+      }
+      if (!sourcesByCommit[commitId]) {
+        sourcesByCommit[commitId] = [];
+      }
+      const isRepeat = data === "repeat";
+      let hookChanges;
+      if (typeof data === "object" && data !== null) {
+        hookChanges = Object.entries(data).map(([index, hookData]) => ({
+          index: Number(index),
+          prevValue: (
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            hookData !== "repeat" ? hookData.prevValue : void 0
+          ),
+          currentValue: hookData !== "repeat" ? (
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            hookData.currentValue
+          ) : void 0
+        }));
+      }
+      const lookup = topNLookup.get(source.sourceId);
+      const rank = lookup?.rank ?? null;
+      const sourceIndex = lookup?.index ?? null;
+      const entry = {
+        sourceId: source.sourceId,
+        type: source.type,
+        depth: source.depth,
+        collateral,
+        rank,
+        sourceIndex
+      };
+      if (hookChanges && hookChanges.length > 0) {
+        entry.hooks = hookChanges;
+      }
+      if (isRepeat) {
+        entry.isRepeat = true;
+      }
+      sourcesByCommit[commitId].push(entry);
+    });
+  });
+  const hasMetricsData = Object.keys(state.metricsByCommit).length > 0;
+  const integrationMode = detectorConfig?.integrationMode ?? "none";
+  const metricsAdapter = adapterIdFromMode(integrationMode);
+  const metricsAvailable = metricsAdapter !== null && hasMetricsData;
+  const meta = {
+    version: 6,
+    // v6: CommitStats[8,9] = unmountedComponents/unmountedSubtrees; suspenseByCommit
+    commits: state.commits,
+    config: {
+      detectionLevel: detectorConfig?.detectionLevel ?? "full",
+      effectThrashMode: detectorConfig?.effectThrashMode ?? "non-primitive",
+      captureFibers: detectorConfig?.captureFibers ?? false,
+      historySize: detectorConfig?.historySize ?? 1
+    },
+    memoizedUpdatersSupport: {
+      available: state.memoizedUpdatersAvailable,
+      commitsWithData: state.commitsWithMemoizedUpdaters,
+      coverage
+    },
+    integrationMode,
+    metricsAdapter,
+    // Per-field availability — fiber-walk fields are always real measurements
+    // because recordTree() runs in every mode. The only adapter-exclusive
+    // datapoint is the render-counter delta (restarts, metricsByCommit).
+    dataAvailability: {
+      collateral: true,
+      sources: true,
+      restarts: metricsAvailable,
+      performedWork: true,
+      effects: true,
+      memos: true,
+      callbacks: true,
+      contextUpdates: true,
+      metricsByCommit: metricsAvailable,
+      atlByCommit: metricsAvailable
+    },
+    timing: {
+      totalDetectorOverhead,
+      avgDetectorOverhead,
+      totalTimeSpan,
+      avgTimeBetweenCommits
+    }
+  };
+  const base = {
+    meta,
+    sources,
+    sourcesByCommit,
+    commitStats: state.commitStats,
+    commitTimings: state.commitTimings,
+    suspenseByCommit: state.suspenseByCommit,
+    unmountsByCommit: state.unmountsByCommit,
+    interactionsByCommit: state.interactionsByCommit,
+    renderedByCommit: state.renderedByCommit,
+    ...hasMetricsData && { metricsByCommit: state.metricsByCommit, atlByCommit: state.metricsByCommit },
+    toSerializable() {
+      return serializeReport(this);
+    }
+  };
+  if (thrashMode === "full") {
+    const getSortValue = (amplifier) => {
+      if (sortBy === "effect") return amplifier.effectCount;
+      if (sortBy === "callback") return amplifier.callbackCount;
+      if (sortBy === "memo") return amplifier.memoCount;
+      if (sortBy === "total") return amplifier.hooksTotal;
+      return amplifier.effectCount;
+    };
+    const getLinkedSortValue = (as) => {
+      if (sortBy === "effect") return as.effectCount;
+      if (sortBy === "callback") return as.callbackCount;
+      if (sortBy === "memo") return as.memoCount;
+      if (sortBy === "total") return as.hooksTotal;
+      return as.effectCount;
+    };
+    const amplifierSources = Array.from(state.amplifierSources.entries()).map(([internalId, lt]) => {
+      const humanId = idMapping.get(internalId) || toHumanReadableId(internalId, lt.type, lt.depth);
+      const sourceData = state.sources.get(internalId);
+      return {
+        sourceId: humanId,
+        type: lt.type,
+        depth: lt.depth,
+        collateralUpdates: sourceData?.collateralUpdates ?? 0,
+        effectCount: lt.effectCount,
+        callbackCount: lt.callbackCount,
+        memoCount: lt.memoCount,
+        hooksTotal: lt.hooksTotal,
+        commitIds: lt.commitIds,
+        byCommit: lt.byCommit,
+        causedBySourceId: lt.causedBySourceId ? idMapping.get(lt.causedBySourceId) || lt.causedBySourceId : null,
+        lastAmplification: lt.lastAmplification
+      };
+    }).sort((a, b) => getLinkedSortValue(b) - getLinkedSortValue(a) || b.hooksTotal - a.hooksTotal).slice(0, topN);
+    return {
+      ...base,
+      amplifiers: Array.from(state.amplifiers.entries()).map(([type, s]) => ({ type, ...s })).sort(
+        (a, b) => getSortValue(b) - getSortValue(a) || b.hooksTotal - a.hooksTotal || b.maxHooksPerCommit - a.maxHooksPerCommit
+      ).slice(0, topN),
+      amplifierSources
+    };
+  }
+  if (thrashMode === "counts" && state.thrashCounts) {
+    meta.amplifiersMetrics = {
+      totalHookThrashes: state.thrashCounts.totalHooks,
+      affectedComponentCount: state.thrashCounts.affectedComponents.size
+    };
+  }
+  return base;
+}
+
+// src/chippy-bridge/react-renderer.ts
+function getReactRenderers(scope = globalThis) {
+  const g = scope;
+  const hook = g.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (!hook || !hook.renderers || typeof hook.renderers.entries !== "function") {
+    return [];
+  }
+  const out = [];
+  for (const [, renderer] of hook.renderers.entries()) {
+    if (renderer) out.push(renderer);
+  }
+  return out;
+}
+function dispatcherSlotOf(injected) {
+  if (!injected || typeof injected !== "object") return null;
+  const owner = injected;
+  if (typeof owner.H !== "undefined") return { owner, key: "H" };
+  if ("current" in owner) return { owner, key: "current" };
+  return null;
+}
+function getDispatcherSlot(scope = globalThis) {
+  for (const renderer of getReactRenderers(scope)) {
+    const slot = dispatcherSlotOf(renderer.currentDispatcherRef);
+    if (slot) return slot;
+  }
+  return null;
+}
+var modernRefs = /* @__PURE__ */ new WeakMap();
+function dispatcherRefOf(slot) {
+  if (slot.key === "current") return slot.owner;
+  let ref = modernRefs.get(slot.owner);
+  if (!ref) {
+    const { owner } = slot;
+    ref = {
+      get current() {
+        return owner.H;
+      },
+      set current(value) {
+        owner.H = value;
+      }
+    };
+    modernRefs.set(owner, ref);
+  }
+  return ref;
+}
+function getDispatcherRef(scope = globalThis) {
+  const slot = getDispatcherSlot(scope);
+  return slot ? dispatcherRefOf(slot) : null;
+}
+
+// src/debug-render/core.ts
+function parseStackFrames2(stack) {
+  return stack.split("\n").slice(1).map((line) => {
+    const m = line.match(/^\s*at\s+([^\s(]+)\s*\(([^)]+)\)/) || line.match(/^\s*at\s+()(.+)$/);
+    if (!m) return null;
+    const name = (m[1] || "").trim();
+    const locRaw = (m[2] || "").trim();
+    const tail = locRaw.match(/:(\d+):(\d+)\)?$/);
+    const loc = tail ? `${tail[1]}:${tail[2]}` : locRaw;
+    return name ? { name, loc } : null;
+  }).filter((f) => !!f);
+}
+var HOOK_METHODS = [
+  "useCallback",
+  "useContext",
+  "useDebugValue",
+  "useDeferredValue",
+  "useEffect",
+  "useImperativeHandle",
+  "useInsertionEffect",
+  "useLayoutEffect",
+  "useMemo",
+  "useReducer",
+  "useRef",
+  "useState",
+  "useSyncExternalStore",
+  "useTransition",
+  "useId",
+  "useCacheRefresh",
+  "useMemoCache"
+];
+var HOOK_PRIMITIVE = {
+  useCallback: "Callback",
+  useContext: "Context",
+  useDebugValue: "DebugValue",
+  useDeferredValue: "DeferredValue",
+  useEffect: "Effect",
+  useImperativeHandle: "ImperativeHandle",
+  useInsertionEffect: "InsertionEffect",
+  useLayoutEffect: "LayoutEffect",
+  useMemo: "Memo",
+  useReducer: "Reducer",
+  useRef: "Ref",
+  useState: "State",
+  useSyncExternalStore: "SyncExternalStore",
+  useTransition: "Transition",
+  useId: "Id",
+  useCacheRefresh: "CacheRefresh",
+  useMemoCache: "MemoCache"
+};
+function isReactInternalFrameName(name) {
+  return name === "atlDispatcherHook" || name === "record" || name.startsWith("Object.") || name === "renderWithHooks" || name === "updateFunctionComponent" || name === "mountIndeterminateComponent" || name === "beginWork" || /^beginWork\$/.test(name) || name === "performUnitOfWork" || name === "workLoopSync" || name === "renderRootSync" || name === "performConcurrentWorkOnRoot" || name === "workLoop" || name === "flushWork";
+}
+function isHookFrameName(name) {
+  return /^use[A-Z0-9_]/.test(name.slice(name.lastIndexOf(".") + 1));
+}
+function deriveComponentName(frames) {
+  for (const { name } of frames) {
+    if (!name) continue;
+    if (isReactInternalFrameName(name)) continue;
+    if (isHookFrameName(name)) continue;
+    return name;
+  }
+  return "Unknown";
+}
+function createDebugRender(options = {}) {
+  const maxEventsPerComponent = options.maxEventsPerComponent ?? 600;
+  const eventsByComponent = /* @__PURE__ */ new Map();
+  const patchedDispatchers = /* @__PURE__ */ new WeakMap();
+  let installed = false;
+  let originalDescriptor = void 0;
+  let dispatcherSlot = null;
+  let lastSeenDispatcher = null;
+  function record(primitive, args) {
+    const stack = new Error().stack || "";
+    const frames = parseStackFrames2(stack);
+    const componentName = deriveComponentName(frames);
+    const event = {
+      primitive,
+      stack,
+      frames,
+      componentName,
+      args
+    };
+    const list = eventsByComponent.get(componentName) || [];
+    list.push(event);
+    if (list.length > maxEventsPerComponent) {
+      list.splice(0, list.length - maxEventsPerComponent);
+    }
+    eventsByComponent.set(componentName, list);
+  }
+  function patchDispatcher(dispatcher) {
+    if (!dispatcher || typeof dispatcher !== "object") return;
+    const obj = dispatcher;
+    if (patchedDispatchers.has(obj)) return;
+    const restoreMap = /* @__PURE__ */ new Map();
+    for (const methodName of HOOK_METHODS) {
+      const original = obj[methodName];
+      if (typeof original !== "function") continue;
+      restoreMap.set(methodName, original);
+      const primitive = HOOK_PRIMITIVE[methodName] || methodName;
+      obj[methodName] = function atlDispatcherHook(...args) {
+        try {
+          record(primitive, args);
+        } catch (_) {
+        }
+        return original.apply(this, args);
+      };
+    }
+    patchedDispatchers.set(obj, restoreMap);
+  }
+  function unpatchDispatcher(dispatcher) {
+    if (!dispatcher || typeof dispatcher !== "object") return;
+    const obj = dispatcher;
+    const restoreMap = patchedDispatchers.get(obj);
+    if (!restoreMap) return;
+    for (const [methodName, fn] of restoreMap.entries()) {
+      obj[methodName] = fn;
+    }
+    patchedDispatchers.delete(obj);
+  }
+  function install() {
+    if (installed) return { ok: true };
+    const slot = getDispatcherSlot();
+    if (!slot) return { ok: false, reason: "ReactCurrentDispatcher not found" };
+    dispatcherSlot = slot;
+    const { owner, key } = slot;
+    patchDispatcher(owner[key]);
+    lastSeenDispatcher = owner[key];
+    originalDescriptor = Object.getOwnPropertyDescriptor(owner, key) || null;
+    let stored = owner[key];
+    try {
+      Object.defineProperty(owner, key, {
+        configurable: true,
+        get() {
+          return stored;
+        },
+        set(next) {
+          stored = next;
+          if (next !== lastSeenDispatcher) {
+            lastSeenDispatcher = next;
+            patchDispatcher(next);
+          }
+        }
+      });
+    } catch (e) {
+      dispatcherSlot = null;
+      return { ok: false, reason: "cannot define property on ReactCurrentDispatcher" };
+    }
+    installed = true;
+    return { ok: true };
+  }
+  function uninstall() {
+    if (!installed) return;
+    if (dispatcherSlot) {
+      const { owner, key } = dispatcherSlot;
+      try {
+        if (originalDescriptor) {
+          Object.defineProperty(owner, key, originalDescriptor);
+        } else {
+          Object.defineProperty(owner, key, {
+            configurable: true,
+            writable: true,
+            enumerable: true,
+            value: lastSeenDispatcher
+          });
+        }
+      } catch (_) {
+      }
+    }
+    unpatchDispatcher(lastSeenDispatcher);
+    installed = false;
+    dispatcherSlot = null;
+    originalDescriptor = void 0;
+    lastSeenDispatcher = null;
+  }
+  function reset() {
+    eventsByComponent.clear();
+  }
+  function rawEvents(componentName) {
+    return (eventsByComponent.get(componentName) || []).slice();
+  }
+  function allComponents() {
+    return Array.from(eventsByComponent.keys());
+  }
+  function status() {
+    const g = globalThis;
+    const hasDevtoolsHook = !!g.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    const rendererCount = getReactRenderers().length;
+    const hasDispatcherRef = !!(dispatcherSlot || getDispatcherSlot());
+    let totalCapturedEvents = 0;
+    for (const list of eventsByComponent.values()) totalCapturedEvents += list.length;
+    let reason;
+    let hint;
+    if (!hasDevtoolsHook) {
+      reason = "no __REACT_DEVTOOLS_GLOBAL_HOOK__ on window";
+      hint = "devtools-hook-shim must run before react-dom evaluates (extension document_start, or Playwright addInitScript)";
+    } else if (rendererCount === 0) {
+      reason = "__REACT_DEVTOOLS_GLOBAL_HOOK__ present but renderers Map is empty";
+      hint = "react-dom evaluated before the hook shim was installed; reload the page after installing the shim, or use addInitScript before navigation";
+    } else if (!hasDispatcherRef) {
+      reason = "renderer registered but no currentDispatcherRef";
+      hint = "unsupported react-dom version, or hook was replaced after registration";
+    } else if (!installed) {
+      reason = "debug-render not installed";
+      hint = "detector did not call debugRender.install() \u2014 check avalanche install() lifecycle";
+    } else if (totalCapturedEvents === 0) {
+      reason = "capture engine installed but no hook events recorded yet";
+      hint = "trigger at least one render of the component you want to inspect after install";
+    }
+    const ok = installed && hasDispatcherRef && totalCapturedEvents > 0;
+    return {
+      ok,
+      installed,
+      hasDevtoolsHook,
+      rendererCount,
+      hasDispatcherRef,
+      totalCapturedComponents: eventsByComponent.size,
+      totalCapturedEvents,
+      reason,
+      hint
+    };
+  }
+  return {
+    install,
+    uninstall,
+    reset,
+    isInstalled: () => installed,
+    dispatcherRef: () => dispatcherSlot ? dispatcherRefOf(dispatcherSlot) : getDispatcherRef(),
+    rawEvents,
+    allComponents,
+    status,
+    recordEventForTest(event) {
+      const list = eventsByComponent.get(event.componentName) || [];
+      list.push(event);
+      eventsByComponent.set(event.componentName, list);
+    }
+  };
+}
+
+// src/avalanche/commit-surface-ownership.ts
+function createCommitSurfaceOwnership() {
+  let adapterObserved = false;
+  let devtoolsCaptures = /* @__PURE__ */ new WeakMap();
+  return {
+    get adapterObserved() {
+      return adapterObserved;
+    },
+    recordDevtools(root, capture) {
+      devtoolsCaptures.set(root, { current: root.current, capture });
+    },
+    observeAdapter(root) {
+      const previous = devtoolsCaptures.get(root);
+      adapterObserved = true;
+      devtoolsCaptures.delete(root);
+      return previous?.current === root.current ? previous.capture : null;
+    },
+    reset() {
+      adapterObserved = false;
+      devtoolsCaptures = /* @__PURE__ */ new WeakMap();
+    }
+  };
+}
+
+// src/layout-lab/fiber-walk.ts
+function getDisplayName(type) {
+  if (!type) return null;
+  if (typeof type === "string") return type;
+  const obj = type;
+  return obj.displayName || obj.name || null;
+}
+function isUserComponent(fiber) {
+  if (!fiber) return false;
+  const name = getDisplayName(fiber.type);
+  if (!name || typeof fiber.type === "string") return false;
+  if (["hookified", "unboundStoryFn", "Anonymous"].includes(name)) return false;
+  return true;
+}
+function getHookSummary(fiber) {
+  const MAX_HOOKS = 500;
+  const seen = /* @__PURE__ */ new Set();
+  let hookNode = fiber?.memoizedState || null;
+  let hookCount = 0;
+  let hookCountTruncated = false;
+  while (hookNode) {
+    if (seen.has(hookNode)) break;
+    if (hookCount >= MAX_HOOKS) {
+      hookCountTruncated = true;
+      break;
+    }
+    seen.add(hookNode);
+    hookCount += 1;
+    hookNode = hookNode.next || null;
+  }
+  return { hookCount, hookCountTruncated, hookCountMax: MAX_HOOKS };
+}
+function getOwnerChain(fiber) {
+  const chain = [];
+  let current = fiber?._debugOwner || null;
+  while (current) {
+    if (isUserComponent(current)) {
+      chain.push({
+        name: getDisplayName(current.type),
+        key: current.key || null,
+        props: current.memoizedProps ? Object.keys(current.memoizedProps) : [],
+        ...getHookSummary(current),
+        source: describeFiberSource(current)
+      });
+    }
+    current = current._debugOwner || null;
+  }
+  return chain;
+}
+function getReturnComponentChain(fiber) {
+  const chain = [];
+  let current = fiber?.return || null;
+  while (current) {
+    if (isUserComponent(current)) {
+      chain.push({
+        name: getDisplayName(current.type),
+        key: current.key || null,
+        props: current.memoizedProps ? Object.keys(current.memoizedProps) : [],
+        ...getHookSummary(current),
+        source: describeFiberSource(current)
+      });
+    }
+    current = current.return || null;
+  }
+  return chain;
+}
+function describeSource(source) {
+  if (!source) return null;
+  return {
+    fileName: source.fileName || null,
+    lineNumber: source.lineNumber || null,
+    columnNumber: source.columnNumber || null
+  };
+}
+function describeFiberSource(fiber) {
+  return describeSource(getFiberSource(fiber));
+}
+function describeFiberTarget(fiber, domNode) {
+  if (!fiber && !domNode) return null;
+  return {
+    domTag: domNode?.tagName?.toLowerCase() || null,
+    domText: domNode?.textContent?.trim().slice(0, 60) || "",
+    fiberType: getDisplayName(fiber?.type) || getDisplayName(fiber?.elementType) || null,
+    source: describeFiberSource(fiber)
+  };
+}
+function describeComponent(fiber) {
+  if (!fiber) return null;
+  return {
+    name: getDisplayName(fiber.type),
+    key: fiber.key || null,
+    props: fiber.memoizedProps || {},
+    ...getHookSummary(fiber),
+    source: describeFiberSource(fiber),
+    stateNode: fiber.stateNode instanceof Element ? fiber.stateNode.tagName.toLowerCase() : null,
+    owners: getOwnerChain(fiber),
+    parents: getReturnComponentChain(fiber)
+  };
+}
+
+// src/avalanche/interaction-capture.ts
+var EXPLICIT_INTERACTION_EVENTS = ["click", "keydown", "keyup", "input", "change", "submit"];
+var NOISY_INTERACTION_EVENTS = ["wheel", "scroll", "pointermove", "mousemove", "touchmove"];
+var ALL_INTERACTION_EVENTS = [
+  ...EXPLICIT_INTERACTION_EVENTS,
+  "pointerdown",
+  "pointerup",
+  "dblclick",
+  "focusin",
+  "focusout",
+  ...NOISY_INTERACTION_EVENTS
+];
+var MAX_INTERACTION_ACTIONS = 200;
+function createInteractionCapture(options = {}) {
+  const {
+    interactionCapture = "explicit",
+    interactionEvents = [],
+    interactionWindowMs = 1e3
+  } = options;
+  const state = {
+    actions: [],
+    byCommit: {}
+  };
+  let nextActionId = 1;
+  let installed = false;
+  function eventNames() {
+    const base = interactionCapture === "off" ? [] : interactionCapture === "explicit" ? EXPLICIT_INTERACTION_EVENTS : interactionCapture === "noisy" ? EXPLICIT_INTERACTION_EVENTS.concat(NOISY_INTERACTION_EVENTS) : ALL_INTERACTION_EVENTS;
+    return Array.from(new Set(base.concat(interactionEvents).map((name) => String(name).trim()).filter(Boolean)));
+  }
+  function findReactFiberKey(node) {
+    return Object.getOwnPropertyNames(node).find((key) => key.startsWith("__reactFiber$")) || null;
+  }
+  function nearestFiberFromNode(node) {
+    let current = node instanceof Element ? node : null;
+    while (current) {
+      const key = findReactFiberKey(current);
+      if (key) return current[key] || null;
+      current = current.parentElement;
+    }
+    return null;
+  }
+  function nearestComponentFiber(node) {
+    let fiber = nearestFiberFromNode(node);
+    while (fiber) {
+      if (isComponentFiber(fiber.tag)) return fiber;
+      fiber = fiber.return || null;
+    }
+    return null;
+  }
+  function nearestTestId(node) {
+    let current = node instanceof Element ? node : null;
+    while (current) {
+      const value = current.getAttribute("data-testid");
+      if (value) return value;
+      current = current.parentElement;
+    }
+    return null;
+  }
+  function describeActionLocation(target) {
+    const domTarget = target instanceof Element ? target : null;
+    const fiber = nearestComponentFiber(target);
+    const describedTarget = describeFiberTarget(fiber, domTarget);
+    const describedComponent = describeComponent(fiber);
+    return {
+      dom: {
+        tag: describedTarget?.domTag || null,
+        text: describedTarget?.domText || "",
+        nearestTestId: nearestTestId(target)
+      },
+      targetFiber: describedComponent ? {
+        name: describedComponent.name,
+        key: describedComponent.key,
+        source: describedComponent.source,
+        ownerStackKind: describedComponent.owners.length > 0 ? "owners" : "parents",
+        ownerStack: describedComponent.owners.length > 0 ? describedComponent.owners : describedComponent.parents
+      } : null
+    };
+  }
+  function capture(event) {
+    const pathTarget = typeof event.composedPath === "function" ? event.composedPath()[0] : null;
+    const target = pathTarget instanceof Element ? pathTarget : event.target;
+    state.actions.push({
+      id: nextActionId++,
+      action: event.type,
+      timestamp: performance.now(),
+      location: describeActionLocation(target)
+    });
+    if (state.actions.length > MAX_INTERACTION_ACTIONS) {
+      state.actions.splice(0, state.actions.length - MAX_INTERACTION_ACTIONS);
+    }
+  }
+  return {
+    state,
+    install() {
+      if (installed) return;
+      const names = eventNames();
+      if (names.length === 0 || typeof document === "undefined") return;
+      for (const name of names) document.addEventListener(name, capture, true);
+      installed = true;
+    },
+    uninstall() {
+      if (!installed || typeof document === "undefined") return;
+      for (const name of eventNames()) document.removeEventListener(name, capture, true);
+      installed = false;
+    },
+    reset() {
+      state.actions.length = 0;
+      for (const key of Object.keys(state.byCommit)) {
+        delete state.byCommit[Number(key)];
+      }
+      nextActionId = 1;
+    },
+    linkRecent(commitId, commitTime) {
+      const windowMs = Math.max(0, Number(interactionWindowMs) || 0);
+      if (windowMs === 0 || state.actions.length === 0) return;
+      const linked = state.actions.filter((action) => action.timestamp <= commitTime && commitTime - action.timestamp <= windowMs).map((action) => ({
+        id: action.id,
+        lastCommitId: Math.max(0, commitId - 1),
+        deltaTime: Math.round((commitTime - action.timestamp) * 100) / 100,
+        action: action.action,
+        location: action.location
+      }));
+      if (linked.length > 0) state.byCommit[commitId] = linked;
+      while (state.actions.length > 0 && commitTime - state.actions[0].timestamp > windowMs) {
+        state.actions.shift();
+      }
+    }
+  };
+}
+
+// src/avalanche/detector.tsx
+function summarizeFiberSource(fiber) {
+  const source = getFiberSourceCandidate(fiber);
+  return source ? { fileName: source.fileName, lineNumber: source.lineNumber } : null;
+}
+function createAvalancheDetector(options = {}) {
+  const {
+    ignore = [],
+    effectThrashMode = "non-primitive",
+    captureFibers = isDevelopment(),
+    detectionMode = isDevelopment() ? "full" : "amplifiers",
+    historySize = isDevelopment() ? 10 : 1
+  } = options;
+  const mode = detectionMode;
+  let metricsAdapter = null;
+  const resolveMetricsAdapter = () => options.metricsAdapter === void 0 ? getCommitMetricsAdapter() : options.metricsAdapter;
+  const ignoreSet = new Set(ignore);
+  let detectionLevel;
+  let thrashMode;
+  if (mode === true) {
+    detectionLevel = "full";
+    thrashMode = "full";
+  } else if (mode === false) {
+    detectionLevel = "stats";
+    thrashMode = false;
+  } else if (mode === "stats") {
+    detectionLevel = "stats";
+    thrashMode = false;
+  } else if (mode === "sources") {
+    detectionLevel = "sources";
+    thrashMode = false;
+  } else if (mode === "amplifiers") {
+    detectionLevel = "amplifiers";
+    thrashMode = "full";
+  } else if (mode === "amplifierMetrics") {
+    detectionLevel = "amplifierMetrics";
+    thrashMode = "counts";
+  } else if (mode === "full") {
+    detectionLevel = "full";
+    thrashMode = "full";
+  }
+  const enableSourceTracking = detectionLevel !== "stats";
+  const enableAmplifiers = thrashMode !== false;
+  const valueProvenance = /* @__PURE__ */ new WeakMap();
+  class StableSourceIdManager {
+    idMap = /* @__PURE__ */ new WeakMap();
+    // WeakMap only accepts objects/functions, not symbols. Store only valid keys.
+    typeToId = /* @__PURE__ */ new WeakMap();
+    instanceCounters = /* @__PURE__ */ new Map();
+    // "typeId@depth" -> instance count
+    nextTypeId = 1;
+    getSourceId(fiber, type, depth) {
+      let sourceId = this.idMap.get(fiber);
+      if (sourceId) return sourceId;
+      if (fiber.alternate) {
+        sourceId = this.idMap.get(fiber.alternate);
+        if (sourceId) {
+          this.idMap.set(fiber, sourceId);
+          return sourceId;
+        }
+      }
+      const canBeWeakMapKey = typeof type === "object" && type !== null || typeof type === "function";
+      const weakKey = canBeWeakMapKey ? type : null;
+      let typeId = weakKey ? this.typeToId.get(weakKey) : void 0;
+      if (typeId === void 0) {
+        typeId = this.nextTypeId++;
+        if (weakKey) {
+          this.typeToId.set(weakKey, typeId);
+        }
+      }
+      const baseKey = `${typeId}@${depth}`;
+      const instanceNum = this.instanceCounters.get(baseKey) || 1;
+      this.instanceCounters.set(baseKey, instanceNum + 1);
+      sourceId = `T${typeId}#${instanceNum}@${depth}`;
+      this.idMap.set(fiber, sourceId);
+      if (fiber.alternate) {
+        this.idMap.set(fiber.alternate, sourceId);
+      }
+      return sourceId;
+    }
+    clear() {
+      this.instanceCounters.clear();
+      this.typeToId = /* @__PURE__ */ new WeakMap();
+      this.nextTypeId = 1;
+    }
+  }
+  const sourceIdManager = new StableSourceIdManager();
+  const debugRender = createDebugRender();
+  const interactionCapture = createInteractionCapture(options);
+  function getComponentDisplayName(type) {
+    if (!type) return "Unknown";
+    return type.displayName || type.name || String(type);
+  }
+  function isDebugInternalFrame(frame, componentName) {
+    const name = frame.name || "";
+    return !!(metricsAdapter ?? resolveMetricsAdapter())?.frameFilters?.includes(name) || name === "record" || name === componentName || name.includes("react-dom") || name.includes("renderWithHooks") || name.includes("mount") || name.includes("update");
+  }
+  function parentFramesForEvent(event, componentName) {
+    return event.frames.filter((frame) => !isDebugInternalFrame(frame, componentName));
+  }
+  function captureMetricsSnapshot() {
+    return metricsAdapter?.snapshot() ?? null;
+  }
+  const lastSeenHookState = /* @__PURE__ */ new WeakMap();
+  function captureHookStateSnapshot(fiber) {
+    const snapshot = [];
+    let hook = fiber.memoizedState;
+    while (hook) {
+      snapshot.push(hook.memoizedState);
+      hook = hook.next;
+    }
+    return snapshot;
+  }
+  function detectChangesFromLastSeen(fiber, currentSnapshot) {
+    const lastSeen = lastSeenHookState.get(fiber) || fiber.alternate && lastSeenHookState.get(fiber.alternate);
+    const changedIndices = [];
+    const changedHooks = [];
+    if (!lastSeen) {
+      return { changedIndices, changedHooks };
+    }
+    const maxLen = Math.max(lastSeen.length, currentSnapshot.length);
+    for (let i = 0; i < maxLen; i++) {
+      const prev = lastSeen[i];
+      const curr = currentSnapshot[i];
+      if (!Object.is(prev, curr)) {
+        changedIndices.push(i);
+        changedHooks.push({ prevValue: prev, currentValue: curr });
+      }
+    }
+    return { changedIndices, changedHooks };
+  }
+  const state = {
+    commits: 0,
+    sources: /* @__PURE__ */ new Map(),
+    amplifiers: /* @__PURE__ */ new Map(),
+    amplifierSources: /* @__PURE__ */ new Map(),
+    thrashCounts: thrashMode === "counts" ? { totalHooks: 0, affectedComponents: /* @__PURE__ */ new Set() } : null,
+    memoizedUpdatersAvailable: false,
+    commitsWithMemoizedUpdaters: 0,
+    // Per-commit stats: [collateral, effects, memos, callbacks]
+    commitStats: {},
+    // Per-commit adapter counter deltas
+    metricsByCommit: {},
+    lastMetricsSnapshot: null,
+    // Per-commit timing data
+    commitTimings: {},
+    lastCommitEndTime: performance.now(),
+    // Per-commit Suspense boundary transitions
+    suspenseByCommit: {},
+    unmountsByCommit: {},
+    interactionActions: interactionCapture.state.actions,
+    interactionsByCommit: interactionCapture.state.byCommit,
+    renderedByCommit: {}
+  };
+  function _pushToHistory(history, item, limit) {
+    history.push(item);
+    if (history.length > limit) {
+      history.splice(0, history.length - limit);
+    }
+  }
+  function trimHistoryToSize(updHistory, limit) {
+    const keys = Object.keys(updHistory).map(Number).sort((a, b) => a - b);
+    const keysToKeep = keys.slice(keys.length - limit);
+    const trimmed = {};
+    keysToKeep.forEach((key) => {
+      trimmed[key] = updHistory[key];
+    });
+    return trimmed;
+  }
+  function findLastConcreteHook(history, hookIndex, beforeCommitId) {
+    const commitIds = Object.keys(history).map(Number).filter((id) => id < beforeCommitId).sort((a, b) => b - a);
+    for (const commitId of commitIds) {
+      const entry = history[commitId];
+      if (entry && entry !== "repeat" && typeof entry !== "string") {
+        const prev = entry[hookIndex];
+        if (prev && prev !== "repeat" && typeof prev === "object") return prev;
+      }
+    }
+    return null;
+  }
+  function summarizePropValue(value) {
+    const isArray = Array.isArray(value);
+    const type = value === null ? "null" : isArray ? "array" : typeof value;
+    const isFunction = typeof value === "function";
+    const isNull = value === null;
+    const isPrimitive = value == null || type === "string" || type === "number" || type === "boolean" || type === "undefined" || type === "symbol" || type === "bigint";
+    const primitiveDisplay = isPrimitive ? String(value) : void 0;
+    const summary = {
+      type,
+      isArray,
+      isFunction,
+      isNull,
+      preview: primitiveDisplay || (isFunction ? "function" : isArray ? `array(${value.length})` : "object")
+    };
+    if (primitiveDisplay !== void 0) {
+      summary.display = primitiveDisplay;
+    }
+    if (typeof value === "string" || isArray) {
+      summary.length = value.length;
+    }
+    if (isArray) {
+      summary.sample = value.slice(0, 3).map((item) => summarizePropValue(item).preview);
+    } else if (value && typeof value === "object") {
+      const keys = Object.keys(value).slice(0, 5);
+      summary.keysTop = keys;
+      summary.length = Object.keys(value).length;
+      if (keys.length > 0) {
+        summary.preview = `object{${keys.join(",")}}`;
+      }
+    } else if (isFunction) {
+      const fn = value;
+      summary.preview = fn.name ? `function ${fn.name}` : "function";
+    }
+    return summary;
+  }
+  function diffProps(prevProps, currentProps) {
+    const changes = [];
+    const prev = prevProps && typeof prevProps === "object" ? prevProps : {};
+    const current = currentProps && typeof currentProps === "object" ? currentProps : {};
+    const keys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(current)]);
+    keys.forEach((name) => {
+      const prevHas = Object.prototype.hasOwnProperty.call(prev, name);
+      const currentHas = Object.prototype.hasOwnProperty.call(current, name);
+      const prevValue = prev[name];
+      const currentValue = current[name];
+      if (!prevHas && currentHas) {
+        changes.push({ name, kind: "added", prev: summarizePropValue(void 0), current: summarizePropValue(currentValue) });
+      } else if (prevHas && !currentHas) {
+        changes.push({ name, kind: "removed", prev: summarizePropValue(prevValue), current: summarizePropValue(void 0) });
+      } else if (Object.is(prevValue, currentValue)) {
+      } else if (prevValue !== null && currentValue !== null && (typeof prevValue === "object" || typeof prevValue === "function" || typeof currentValue === "object" || typeof currentValue === "function")) {
+        changes.push({ name, kind: "ref-changed", prev: summarizePropValue(prevValue), current: summarizePropValue(currentValue) });
+      } else {
+        changes.push({ name, kind: "scalar-changed", prev: summarizePropValue(prevValue), current: summarizePropValue(currentValue) });
+      }
+    });
+    return changes;
+  }
+  function pushUpdateHistory(updHistory, commitId, changedHookIndices, changedHooks) {
+    const entry = {};
+    for (let i = 0; i < changedHookIndices.length; i++) {
+      const hookIndex = changedHookIndices[i];
+      const hook = changedHooks[i];
+      if (hook === "repeat") {
+        entry[hookIndex] = "repeat";
+      } else {
+        const prevConcrete = findLastConcreteHook(updHistory, hookIndex, commitId);
+        entry[hookIndex] = prevConcrete && typeof prevConcrete === "object" && Object.is(hook.prevValue, prevConcrete.prevValue) && Object.is(hook.currentValue, prevConcrete.currentValue) ? "repeat" : hook;
+      }
+    }
+    const newEntry = Object.values(entry).every((v) => v === "repeat") ? "repeat" : entry;
+    return { ...updHistory, [commitId]: newEntry };
+  }
+  function recordTree(rootFiber, memoizedUpdaters = null) {
+    if (memoizedUpdaters && memoizedUpdaters.size > 0) {
+      state.memoizedUpdatersAvailable = true;
+      state.commitsWithMemoizedUpdaters++;
+    }
+    const perCommit = {
+      selfUpdated: /* @__PURE__ */ new Map(),
+      thrashing: /* @__PURE__ */ new Map(),
+      /** Linked thrashing: keyed by sourceId, tracks per-component thrashing with linkage */
+      linkedThrashing: /* @__PURE__ */ new Map(),
+      rendered: [],
+      selfFibers: /* @__PURE__ */ new WeakMap(),
+      sourceFibers: /* @__PURE__ */ new Set(),
+      // Track source fibers to exclude from collateral count
+      blastBySourceId: /* @__PURE__ */ new Map(),
+      depthBySourceId: /* @__PURE__ */ new Map(),
+      // Simple counts for commitStats
+      totalCollateral: 0,
+      committedComponentCount: 0,
+      // Components with PerformedWork that committed
+      effectCount: 0,
+      memoCount: 0,
+      callbackCount: 0,
+      contextUpdates: 0,
+      // Unmount tracking (populated by deletions-array walk in visit())
+      unmountedComponents: 0,
+      unmountedSubtrees: 0,
+      // Bounded identity samples for branch starts (topmost component fibers in
+      // each deleted subtree). Cap to keep payload small.
+      unmountSamples: null,
+      // Suspense boundary transition events collected during this commit's visit pass
+      suspenseEvents: null
+    };
+    function visit(fiber, depth = 0, currentOwnerSourceId = null) {
+      if (!fiber) return;
+      const hasWorkInSubtree = (
+        // eslint-disable-next-line no-bitwise -- React fiber flags are bitmasks, bitwise AND is required
+        (fiber.flags & PerformedWork) !== 0 || // eslint-disable-next-line no-bitwise
+        (fiber.subtreeFlags & PerformedWork) !== 0 || // fiber.flags & ChildDeletion = this fiber has children being deleted this commit
+        // (React sets ChildDeletion on fiber.flags, NOT subtreeFlags, at commit time)
+        // eslint-disable-next-line no-bitwise
+        (fiber.flags & ChildDeletion) !== 0 || // subtreeFlags propagation — some descendant has deletions
+        // eslint-disable-next-line no-bitwise
+        (fiber.subtreeFlags & ChildDeletion) !== 0 || // Suspense transitioning: React sets Update (4) on the Suspense fiber's flags at commit.
+        // eslint-disable-next-line no-bitwise
+        isSuspenseFiber(fiber.tag) && (fiber.flags & Update) !== 0 || // subtreeFlags & Update: a descendant (e.g. Suspense) received an Update this commit.
+        // React propagates subtreeFlags upward — HostRoot and all intermediate host fibers
+        // will have Update bit set if any descendant has it. This ensures we don't skip
+        // the path to a Suspense boundary when no PerformedWork exists higher in the tree.
+        // eslint-disable-next-line no-bitwise
+        (fiber.subtreeFlags & Update) !== 0
+      );
+      if (!hasWorkInSubtree) {
+        if (fiber.sibling) visit(fiber.sibling, depth, currentOwnerSourceId);
+        return;
+      }
+      if (isContextProviderFiber(fiber.tag) && didContextValueChange(fiber)) {
+        perCommit.contextUpdates++;
+      }
+      if ((fiber.flags & ChildDeletion) !== 0 && fiber.deletions && fiber.deletions.length > 0) {
+        for (let di = 0; di < fiber.deletions.length; di++) {
+          let collectDeletions = function(df, parentIsComponent, branchStartDepth, currentBranch) {
+            const dfIsComponent = isComponentFiber(df.tag);
+            let nextBranch = currentBranch;
+            if (dfIsComponent) {
+              perCommit.unmountedComponents++;
+              if (!parentIsComponent) {
+                perCommit.unmountedSubtrees++;
+                if (perCommit.unmountSamples == null) perCommit.unmountSamples = [];
+                if (perCommit.unmountSamples.length < 30) {
+                  const fiberKey = df.key;
+                  const sample = {
+                    name: getComponentName(df),
+                    key: fiberKey == null ? null : String(fiberKey),
+                    depth: branchStartDepth,
+                    count: 1,
+                    source: summarizeFiberSource(df),
+                    host: summarizeHostSubtree(df)
+                  };
+                  perCommit.unmountSamples.push(sample);
+                  nextBranch = { count: 1, sample };
+                } else {
+                  nextBranch = null;
+                }
+              } else if (currentBranch && currentBranch.sample) {
+                currentBranch.sample.count++;
+              }
+              lastSeenHookState.delete(df);
+              if (df.alternate) lastSeenHookState.delete(df.alternate);
+            }
+            if (df.child) collectDeletions(df.child, dfIsComponent, branchStartDepth + 1, nextBranch);
+            if (df.sibling) collectDeletions(df.sibling, parentIsComponent, branchStartDepth, currentBranch);
+          };
+          const deleted = fiber.deletions[di];
+          if (perCommit.unmountSamples == null) perCommit.unmountSamples = [];
+          if (perCommit.unmountSamples.length < 30) {
+            let labelFiber = deleted;
+            if (!isComponentFiber(labelFiber.tag)) {
+              const stack = [labelFiber];
+              labelFiber = null;
+              while (stack.length) {
+                const f = stack.pop();
+                if (isComponentFiber(f.tag)) {
+                  labelFiber = f;
+                  break;
+                }
+                if (f.child) stack.push(f.child);
+                if (f.sibling) stack.push(f.sibling);
+              }
+            }
+            if (labelFiber) {
+              const counts = countUnmountedComponentSubtree(deleted);
+              const fiberKey = labelFiber.key;
+              perCommit.unmountSamples.push({
+                name: getComponentName(labelFiber),
+                key: fiberKey == null ? null : String(fiberKey),
+                depth,
+                count: counts.components,
+                source: summarizeFiberSource(labelFiber),
+                host: summarizeHostSubtree(deleted)
+              });
+            }
+          }
+          collectDeletions(deleted, false, depth, null);
+        }
+      }
+      const isComponent = isComponentFiber(fiber.tag);
+      let ownerSourceId = currentOwnerSourceId;
+      if (isSuspenseFiber(fiber.tag)) {
+        const suspenseChange = didSuspenseStateChange(fiber);
+        if (suspenseChange) {
+          if (!perCommit.suspenseEvents) {
+            perCommit.suspenseEvents = [];
+          }
+          const event = {
+            depth,
+            entered: suspenseChange.entered,
+            left: suspenseChange.left,
+            ...captureFibers && { fiber }
+          };
+          perCommit.suspenseEvents.push(event);
+          if (enableSourceTracking) {
+            const suspenseType = fiber.type;
+            const sourceId = sourceIdManager.getSourceId(fiber, suspenseType, depth);
+            const suspenseHook = {
+              prevValue: suspenseChange.left ? "suspended" : null,
+              currentValue: suspenseChange.entered ? "suspended" : null,
+              info: suspenseChange.entered ? "suspense:entered-fallback" : "suspense:left-fallback"
+            };
+            perCommit.selfUpdated.set(sourceId, {
+              type: suspenseType,
+              depth,
+              count: 1,
+              changedHookIndices: [0],
+              changedHooks: [suspenseHook],
+              fiber: captureFibers ? fiber : void 0,
+              isUpdater: true
+            });
+            ownerSourceId = sourceId;
+          }
+        }
+      }
+      if (isComponent) {
+        const type = fiber.type;
+        if (didFiberUpdate(fiber)) {
+          perCommit.committedComponentCount++;
+        }
+        if (!didFiberUpdate(fiber)) {
+          if (fiber.child) visit(fiber.child, depth + 1, ownerSourceId);
+          if (fiber.sibling) visit(fiber.sibling, depth, currentOwnerSourceId);
+          return;
+        }
+        if (!ignoreSet.has(type) && !isReactInternalComponentType(type)) {
+          const componentSourceId = sourceIdManager.getSourceId(fiber, type, depth);
+          const parentFiber = fiber.return && isComponentFiber(fiber.return.tag) ? fiber.return : null;
+          const parentSourceId = parentFiber ? sourceIdManager.getSourceId(parentFiber, parentFiber.type, depth - 1) : null;
+          const existingRenderEvidenceIndex = perCommit.rendered.findIndex(
+            (entry) => entry.sourceId === componentSourceId
+          );
+          const initialRenderEvidence = {
+            sourceId: componentSourceId,
+            name: getComponentName(fiber),
+            depth,
+            parentSourceId,
+            ownerSourceId,
+            isSelfSource: false,
+            propChanges: fiber.alternate ? diffProps(fiber.alternate.memoizedProps, fiber.memoizedProps) : [],
+            hasPropChanges: false,
+            trasherCounts: { effects: 0, callbacks: 0, memos: 0 }
+          };
+          initialRenderEvidence.hasPropChanges = initialRenderEvidence.propChanges.length > 0;
+          if (existingRenderEvidenceIndex >= 0) {
+            perCommit.rendered[existingRenderEvidenceIndex] = initialRenderEvidence;
+          } else {
+            perCommit.rendered.push(initialRenderEvidence);
+          }
+          if (enableAmplifiers) {
+            let hook = fiber.memoizedState;
+            let hookIndex = 0;
+            while (hook) {
+              const ms = hook.memoizedState;
+              if (Array.isArray(ms) && ms.length === 2 && Array.isArray(ms[1])) {
+                const result = ms[0];
+                if (result != null && (typeof result === "object" || typeof result === "function")) {
+                  valueProvenance.set(result, {
+                    type,
+                    hookIndex,
+                    depth,
+                    hookType: typeof result === "function" ? "useCallback" : "useMemo"
+                  });
+                }
+              }
+              hook = hook.next;
+              hookIndex++;
+            }
+          }
+          let currentHookSnapshot = null;
+          if (enableSourceTracking) {
+            currentHookSnapshot = captureHookStateSnapshot(fiber);
+          }
+          let isRealSource = false;
+          let changedIndices = [];
+          let changedHooks = [];
+          if (enableSourceTracking) {
+            const inMemoizedUpdaters = memoizedUpdaters ? memoizedUpdaters.has(fiber) || fiber.alternate && memoizedUpdaters.has(fiber.alternate) : null;
+            if (memoizedUpdaters) {
+              if (inMemoizedUpdaters) {
+                isRealSource = true;
+                const selfUpdateResult = didFiberSelfUpdate(fiber);
+                if (selfUpdateResult && selfUpdateResult.actionable) {
+                  changedIndices = selfUpdateResult.changedIndices;
+                  changedHooks = selfUpdateResult.changedHooks;
+                }
+              }
+            } else {
+              const changes = detectChangesFromLastSeen(fiber, currentHookSnapshot);
+              if (changes.changedIndices.length > 0) {
+                isRealSource = true;
+                changedIndices = changes.changedIndices;
+                changedHooks = changes.changedHooks;
+              }
+            }
+            lastSeenHookState.set(fiber, currentHookSnapshot);
+            if (fiber.alternate) {
+              lastSeenHookState.set(fiber.alternate, currentHookSnapshot);
+            }
+          }
+          if (isRealSource && changedIndices.length > 0) {
+            const sourceId = componentSourceId;
+            perCommit.sourceFibers.add(fiber);
+            if (fiber.alternate) {
+              perCommit.sourceFibers.add(fiber.alternate);
+            }
+            const existing = perCommit.selfUpdated.get(sourceId);
+            const updateData = {
+              type,
+              depth,
+              count: (existing?.count || 0) + 1,
+              changedHookIndices: changedIndices,
+              changedHooks,
+              fiber: captureFibers ? fiber : void 0,
+              isUpdater: true
+            };
+            perCommit.selfUpdated.set(sourceId, updateData);
+            perCommit.selfFibers.set(fiber, depth);
+            ownerSourceId = sourceId;
+          }
+          const isSourceItself = perCommit.sourceFibers.has(fiber);
+          const isNonPreventable = (fiber.flags & (Placement | Hydrating)) !== 0;
+          if (isComponent && fiber.alternate && didFiberUpdate(fiber) && ownerSourceId && !isSourceItself && !isNonPreventable) {
+            perCommit.blastBySourceId.set(
+              ownerSourceId,
+              (perCommit.blastBySourceId.get(ownerSourceId) || 0) + 1
+            );
+            const currentMax = perCommit.depthBySourceId.get(ownerSourceId) || 0;
+            if (depth > currentMax) {
+              perCommit.depthBySourceId.set(ownerSourceId, depth);
+            }
+            perCommit.totalCollateral++;
+          }
+          const renderedEntry = perCommit.rendered.find((entry) => entry.sourceId === componentSourceId);
+          if (renderedEntry) {
+            renderedEntry.ownerSourceId = ownerSourceId;
+            renderedEntry.isSelfSource = isRealSource && changedIndices.length > 0;
+          }
+          if (enableAmplifiers && didFiberUpdate(fiber) && fiber.alternate) {
+            const thrashResult = detectHookThrashing(
+              fiber.alternate.memoizedState,
+              fiber.memoizedState,
+              effectThrashMode,
+              valueProvenance
+            );
+            const totalThrashing = thrashResult.effects.length + thrashResult.callbacks.length + thrashResult.memos.length;
+            if (totalThrashing > 0) {
+              if (thrashMode === "counts") {
+                if (state.thrashCounts) {
+                  state.thrashCounts.affectedComponents.add(type);
+                  state.thrashCounts.totalHooks += totalThrashing;
+                }
+              } else if (thrashMode === "full") {
+                const allThrashedHooks = [
+                  ...thrashResult.effects,
+                  ...thrashResult.callbacks,
+                  ...thrashResult.memos
+                ];
+                const existing = perCommit.thrashing.get(type);
+                const thrashData = {
+                  instanceCount: (existing?.instanceCount || 0) + 1,
+                  hookCount: (existing?.hookCount || 0) + totalThrashing,
+                  lastAmplification: {
+                    depth,
+                    thrashedHooks: allThrashedHooks,
+                    fiber: captureFibers ? fiber : void 0
+                  }
+                };
+                perCommit.thrashing.set(type, thrashData);
+                const amplifierSourceId = sourceIdManager.getSourceId(fiber, type, depth);
+                const existingLinked = perCommit.linkedThrashing.get(amplifierSourceId);
+                const effects = (existingLinked?.effects || 0) + thrashResult.effects.length;
+                const callbacks = (existingLinked?.callbacks || 0) + thrashResult.callbacks.length;
+                const memos = (existingLinked?.memos || 0) + thrashResult.memos.length;
+                perCommit.linkedThrashing.set(amplifierSourceId, {
+                  type,
+                  depth,
+                  effects,
+                  callbacks,
+                  memos,
+                  // If this fiber is a source, causedBySourceId is null (self-caused)
+                  // If this fiber is collateral, ownerSourceId is who caused it
+                  causedBySourceId: isRealSource ? null : ownerSourceId,
+                  lastAmplification: {
+                    depth,
+                    thrashedHooks: allThrashedHooks,
+                    fiber: captureFibers ? fiber : void 0
+                  }
+                });
+                const renderedEntry2 = perCommit.rendered.find((entry) => entry.sourceId === amplifierSourceId);
+                if (renderedEntry2) {
+                  renderedEntry2.trasherCounts = { effects, callbacks, memos };
+                }
+                perCommit.effectCount += thrashResult.effects.length;
+                perCommit.memoCount += thrashResult.memos.length;
+                perCommit.callbackCount += thrashResult.callbacks.length;
+              }
+            }
+          }
+        }
+      }
+      if (fiber.child) visit(fiber.child, depth + 1, ownerSourceId);
+      if (fiber.sibling) visit(fiber.sibling, depth, currentOwnerSourceId);
+    }
+    visit(rootFiber);
+    state.commits++;
+    for (const [sourceId, data] of perCommit.selfUpdated.entries()) {
+      const { type, depth, count, changedHookIndices, fiber } = data;
+      let s = state.sources.get(sourceId);
+      if (!s) {
+        s = {
+          type,
+          depth,
+          renderCount: 0,
+          causedUpdates: 0,
+          collateralUpdates: 0,
+          maxCollateralUpdates: 0,
+          maxPenetrationDepth: 0,
+          updateHistory: {},
+          collateralByCommit: {},
+          // Per-commit collateral for this source
+          debugHookIndices: changedHookIndices.slice()
+        };
+        state.sources.set(sourceId, s);
+      }
+      s.renderCount++;
+      s.debugHookIndices = changedHookIndices.slice();
+      const historyWithUpdate = pushUpdateHistory(
+        s.updateHistory,
+        state.commits,
+        changedHookIndices,
+        data.changedHooks
+      );
+      s.updateHistory = trimHistoryToSize(historyWithUpdate, historySize);
+      const thisCommitEntry = s.updateHistory[state.commits];
+      const isRepeat = thisCommitEntry === "repeat";
+      if (!isRepeat && data.isUpdater) {
+        s.causedUpdates += count;
+        const blast = perCommit.blastBySourceId.get(sourceId) || 0;
+        s.collateralUpdates += blast;
+        if (blast > s.maxCollateralUpdates) s.maxCollateralUpdates = blast;
+        s.collateralByCommit[state.commits] = blast;
+        const penetrationDepth = perCommit.depthBySourceId.get(sourceId) || 0;
+        if (penetrationDepth > s.maxPenetrationDepth) {
+          s.maxPenetrationDepth = penetrationDepth;
+        }
+      }
+      if (captureFibers && fiber) {
+        s.fiber = fiber;
+      }
+    }
+    if (enableAmplifiers && thrashMode === "full") {
+      for (const [type, data] of perCommit.thrashing.entries()) {
+        let s = state.amplifiers.get(type);
+        if (!s) {
+          s = {
+            renderCount: 0,
+            instancesTotal: 0,
+            maxInstancesPerCommit: 0,
+            hooksTotal: 0,
+            maxHooksPerCommit: 0,
+            effectCount: 0,
+            callbackCount: 0,
+            memoCount: 0,
+            lastAmplification: { depth: 0, thrashedHooks: [] }
+          };
+          state.amplifiers.set(type, s);
+        }
+        s.renderCount++;
+        s.instancesTotal += data.instanceCount;
+        s.hooksTotal += data.hookCount;
+        if (data.instanceCount > s.maxInstancesPerCommit)
+          s.maxInstancesPerCommit = data.instanceCount;
+        if (data.hookCount > s.maxHooksPerCommit) s.maxHooksPerCommit = data.hookCount;
+        data.lastAmplification.thrashedHooks.forEach((hook) => {
+          if (hook.hookType === "effect") s.effectCount++;
+          else if (hook.hookType === "callback") s.callbackCount++;
+          else if (hook.hookType === "memo") s.memoCount++;
+        });
+        s.lastAmplification = data.lastAmplification;
+      }
+      for (const [sourceId, data] of perCommit.linkedThrashing.entries()) {
+        let as = state.amplifierSources.get(sourceId);
+        if (!as) {
+          as = {
+            type: data.type,
+            depth: data.depth,
+            effectCount: 0,
+            callbackCount: 0,
+            memoCount: 0,
+            hooksTotal: 0,
+            commitIds: [],
+            byCommit: {},
+            causedBySourceId: data.causedBySourceId,
+            lastAmplification: { depth: 0, thrashedHooks: [] }
+          };
+          state.amplifierSources.set(sourceId, as);
+        }
+        as.effectCount += data.effects;
+        as.callbackCount += data.callbacks;
+        as.memoCount += data.memos;
+        as.hooksTotal += data.effects + data.callbacks + data.memos;
+        if (!as.commitIds.includes(state.commits)) {
+          as.commitIds.push(state.commits);
+        }
+        as.byCommit[state.commits] = {
+          effects: data.effects,
+          callbacks: data.callbacks,
+          memos: data.memos
+        };
+        if (data.causedBySourceId !== null) {
+          as.causedBySourceId = data.causedBySourceId;
+        }
+        as.lastAmplification = data.lastAmplification;
+      }
+    }
+    if (perCommit.suspenseEvents && perCommit.suspenseEvents.length > 0) {
+      state.suspenseByCommit[state.commits] = perCommit.suspenseEvents;
+    }
+    if (perCommit.rendered.length > 0) {
+      state.renderedByCommit[state.commits] = perCommit.rendered;
+    }
+    state.commitStats[state.commits] = [
+      perCommit.totalCollateral,
+      perCommit.selfUpdated.size,
+      // Number of sources in this commit
+      0,
+      // restarts - will be updated after the adapter's delta calculation
+      perCommit.committedComponentCount,
+      // performedWork - components with PerformedWork flag
+      perCommit.effectCount,
+      perCommit.memoCount,
+      perCommit.callbackCount,
+      perCommit.contextUpdates,
+      perCommit.unmountedComponents,
+      perCommit.unmountedSubtrees
+    ];
+    if (perCommit.unmountSamples && perCommit.unmountSamples.length > 0) {
+      state.unmountsByCommit[state.commits] = perCommit.unmountSamples;
+    }
+    return perCommit.committedComponentCount;
+  }
+  function resetState() {
+    state.commits = 0;
+    state.sources.clear();
+    state.amplifiers.clear();
+    state.amplifierSources.clear();
+    if (state.thrashCounts) {
+      state.thrashCounts.totalHooks = 0;
+      state.thrashCounts.affectedComponents.clear();
+    }
+    state.memoizedUpdatersAvailable = false;
+    state.commitsWithMemoizedUpdaters = 0;
+    for (const key of Object.keys(state.commitStats)) {
+      delete state.commitStats[Number(key)];
+    }
+    for (const key of Object.keys(state.metricsByCommit)) {
+      delete state.metricsByCommit[Number(key)];
+    }
+    for (const key of Object.keys(state.commitTimings)) {
+      delete state.commitTimings[Number(key)];
+    }
+    for (const key of Object.keys(state.suspenseByCommit)) {
+      delete state.suspenseByCommit[Number(key)];
+    }
+    for (const key of Object.keys(state.unmountsByCommit)) {
+      delete state.unmountsByCommit[Number(key)];
+    }
+    for (const key of Object.keys(state.renderedByCommit)) {
+      delete state.renderedByCommit[Number(key)];
+    }
+    interactionCapture.reset();
+    state.lastMetricsSnapshot = captureMetricsSnapshot();
+    state.lastCommitEndTime = performance.now();
+    sourceIdManager.clear();
+  }
+  const commitSurface = createCommitSurfaceOwnership();
+  let devtoolsHookPrev;
+  let devtoolsUnmountPrev;
+  let devtoolsHookCreatedByUs = false;
+  let pendingDevtoolsUnmounts = { components: 0, subtrees: 0 };
+  let pendingDevtoolsUnmountSamples = [];
+  let integrationMode = "none";
+  function countUnmountedComponentSubtree(fiber, parentIsComponent = false) {
+    if (!fiber) return { components: 0, subtrees: 0 };
+    const isComponent = isComponentFiber(fiber.tag);
+    let components = isComponent ? 1 : 0;
+    let subtrees = isComponent && !parentIsComponent ? 1 : 0;
+    if (fiber.child) {
+      const child = countUnmountedComponentSubtree(fiber.child, isComponent);
+      components += child.components;
+      subtrees += child.subtrees;
+    }
+    if (fiber.sibling) {
+      const sibling = countUnmountedComponentSubtree(fiber.sibling, parentIsComponent);
+      components += sibling.components;
+      subtrees += sibling.subtrees;
+    }
+    return { components, subtrees };
+  }
+  function summarizeHostSubtree(fiber) {
+    const tags = /* @__PURE__ */ new Map();
+    const testIds = /* @__PURE__ */ new Map();
+    const roles = /* @__PURE__ */ new Map();
+    const ariaLabels = [];
+    const textHints = [];
+    let elements = 0;
+    let text = 0;
+    const add = (map, key) => {
+      if (typeof key !== "string" || !key) return;
+      map.set(key, (map.get(key) || 0) + 1);
+    };
+    const addHint = (arr, value, max = 6) => {
+      if (typeof value !== "string") return;
+      const trimmed = value.replace(/\s+/g, " ").trim();
+      if (!trimmed || arr.includes(trimmed)) return;
+      arr.push(trimmed.length > 80 ? `${trimmed.slice(0, 77)}\u2026` : trimmed);
+      if (arr.length > max) arr.length = max;
+    };
+    const top = (map) => Array.from(map.entries()).sort((a, b) => b[1] - a[1]).slice(0, 6);
+    const walk = (f) => {
+      if (!f) return;
+      if (f.tag === 5) {
+        elements++;
+        const props = f.memoizedProps || {};
+        add(tags, typeof f.type === "string" ? f.type : "host");
+        add(testIds, props["data-testid"]);
+        add(roles, props.role);
+        addHint(ariaLabels, props["aria-label"]);
+        addHint(ariaLabels, props.title);
+        addHint(textHints, typeof props.children === "string" ? props.children : null);
+      } else if (f.tag === 6) {
+        text++;
+        addHint(textHints, f.memoizedProps);
+      }
+      walk(f.child);
+      walk(f.sibling);
+    };
+    walk(fiber);
+    return { elements, text, tagsTop: top(tags), testIdsTop: top(testIds), rolesTop: top(roles), ariaLabels, textHints };
+  }
+  function recordMetricsEvidence(commitId, committedComponents, before, after) {
+    if (!metricsAdapter) return;
+    const { delta, restarts } = metricsAdapter.measure(before, after, committedComponents, commitId);
+    state.metricsByCommit[commitId] = delta;
+    if (state.commitStats[commitId]) {
+      state.commitStats[commitId][CS_RESTARTS] = restarts;
+    }
+  }
+  function handleCommit(root, metricsDeltaAvailable) {
+    debugRender.install();
+    const commitHookStartTime = performance.now();
+    const timeSinceLastCommit = commitHookStartTime - state.lastCommitEndTime;
+    const metricsBefore = state.lastMetricsSnapshot || captureMetricsSnapshot();
+    const memoizedUpdaters = root.memoizedUpdaters;
+    const committedComponents = recordTree(root.current, memoizedUpdaters || null);
+    const currentStats = state.commitStats[state.commits];
+    if (currentStats && (pendingDevtoolsUnmounts.components > 0 || pendingDevtoolsUnmounts.subtrees > 0)) {
+      const recordTreeSawDeletions = (currentStats[CS_UNMOUNTED_COMPONENTS] || 0) > 0;
+      if (!recordTreeSawDeletions) {
+        currentStats[CS_UNMOUNTED_COMPONENTS] = pendingDevtoolsUnmounts.components;
+        currentStats[CS_UNMOUNTED_SUBTREES] = pendingDevtoolsUnmounts.subtrees;
+      }
+      pendingDevtoolsUnmounts = { components: 0, subtrees: 0 };
+    }
+    if (pendingDevtoolsUnmountSamples.length > 0) {
+      const existing = state.unmountsByCommit[state.commits];
+      if (existing && existing.length > 0) {
+      } else {
+        state.unmountsByCommit[state.commits] = pendingDevtoolsUnmountSamples;
+      }
+      pendingDevtoolsUnmountSamples = [];
+    }
+    const metricsAfter = captureMetricsSnapshot();
+    if (metricsDeltaAvailable && metricsBefore && metricsAfter) {
+      recordMetricsEvidence(state.commits, committedComponents, metricsBefore, metricsAfter);
+    }
+    state.lastMetricsSnapshot = metricsAfter;
+    const commitHookEndTime = performance.now();
+    interactionCapture.linkRecent(state.commits, commitHookEndTime);
+    state.commitTimings[state.commits] = {
+      timeSinceLastCommit,
+      detectorOverhead: commitHookEndTime - commitHookStartTime
+    };
+    state.lastCommitEndTime = commitHookEndTime;
+    return committedComponents;
+  }
+  return {
+    /**
+     * Start profiling React commits.
+     *
+     * Integration model is OBSERVED at runtime, not declared at install time.
+     *
+     *   'devtools'     — DevTools `onCommitFiberRoot` is the canonical entry
+     *                    point. We define the hook if absent, augment (chain)
+     *                    if present. On every commit we capture the fiber tree.
+     *
+     *   'adapter:<id>' — Promoted from 'devtools' the first time the commit
+     *                    metrics adapter's host callback actually fires for a
+     *                    real commit. From then on the adapter is the
+     *                    authoritative processor and the DevTools surface is
+     *                    chained-observer-only. The adapter is preferred when
+     *                    alive because it carries render-counter deltas
+     *                    (restart math, metricsByCommit).
+     *
+     *   'none'         — Only when no DevTools hook surface can be created and
+     *                    no adapter surface is reachable. Practically never
+     *                    hit, since the content-script ships a
+     *                    devtools-hook-shim before react-dom.
+     *
+     * Double-invocation safety:
+     *   Once an adapter callback has fired, DevTools remains chained for
+     *   existing tooling but does not capture commits; the adapter alone calls
+     *   `handleCommit`. Without a live adapter, DevTools is the capture
+     *   surface. This avoids duplicate capture without relying on per-root
+     *   timing heuristics.
+     *
+     * Side effects:
+     *   - Defines `__REACT_DEVTOOLS_GLOBAL_HOOK__` if it does not already exist
+     *     (minimal contract: `onCommitFiberRoot` only). React reads the hook at
+     *     module-eval time; the content-script shim handles ordering.
+     *   - Asks the adapter (when one is registered) to route its host commit
+     *     callback here, *if and when* the host calls it.
+     *
+     * Safe to call multiple times (idempotent: chains skipped when our wrappers
+     * are already in place).
+     */
+    install() {
+      interactionCapture.install();
+      const devtoolsGlobal = globalThis;
+      metricsAdapter = resolveMetricsAdapter();
+      state.lastMetricsSnapshot = captureMetricsSnapshot();
+      let hook = devtoolsGlobal.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (!hook) {
+        hook = {};
+        devtoolsGlobal.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook;
+        devtoolsHookCreatedByUs = true;
+      } else {
+        devtoolsHookCreatedByUs = false;
+      }
+      devtoolsHookPrev = typeof hook.onCommitFiberRoot === "function" ? hook.onCommitFiberRoot : void 0;
+      devtoolsUnmountPrev = typeof hook.onCommitFiberUnmount === "function" ? hook.onCommitFiberUnmount : void 0;
+      const devtoolsHandler = (...args) => {
+        if (devtoolsHookPrev) {
+          try {
+            devtoolsHookPrev(...args);
+          } catch (_) {
+          }
+        }
+        const root = args[1];
+        if (!root) return;
+        if (commitSurface.adapterObserved && metricsAdapter) {
+          if (!metricsAdapter.isAttached()) {
+            metricsAdapter.reattach();
+            const metricsBefore2 = state.lastMetricsSnapshot || captureMetricsSnapshot();
+            const committedComponents2 = handleCommit(
+              root,
+              /* metricsDeltaAvailable */
+              false
+            );
+            commitSurface.recordDevtools(root, { commitId: state.commits, committedComponents: committedComponents2, metricsBefore: metricsBefore2 });
+            return;
+          }
+          return;
+        }
+        const metricsBefore = state.lastMetricsSnapshot || captureMetricsSnapshot();
+        const committedComponents = handleCommit(
+          root,
+          /* metricsDeltaAvailable */
+          false
+        );
+        commitSurface.recordDevtools(root, { commitId: state.commits, committedComponents, metricsBefore });
+      };
+      hook.onCommitFiberRoot = devtoolsHandler;
+      const devtoolsUnmountHandler = (...args) => {
+        if (devtoolsUnmountPrev) {
+          try {
+            devtoolsUnmountPrev(...args);
+          } catch (_) {
+          }
+        }
+        const fiber = args[1];
+        if (!fiber) return;
+        const counts = countUnmountedComponentSubtree(fiber);
+        pendingDevtoolsUnmounts.components += counts.components;
+        pendingDevtoolsUnmounts.subtrees += counts.subtrees;
+        if (counts.components > 0 && pendingDevtoolsUnmountSamples.length < 30) {
+          let labelFiber = fiber;
+          if (!isComponentFiber(labelFiber.tag)) {
+            const stack = [labelFiber];
+            labelFiber = null;
+            while (stack.length) {
+              const f = stack.pop();
+              if (isComponentFiber(f.tag)) {
+                labelFiber = f;
+                break;
+              }
+              if (f.child) stack.push(f.child);
+              if (f.sibling) stack.push(f.sibling);
+            }
+          }
+          if (labelFiber) {
+            const fiberKey = labelFiber.key;
+            pendingDevtoolsUnmountSamples.push({
+              name: getComponentName(labelFiber),
+              key: fiberKey == null ? null : String(fiberKey),
+              depth: null,
+              count: counts.components,
+              source: summarizeFiberSource(labelFiber),
+              host: summarizeHostSubtree(fiber)
+            });
+          }
+        }
+        lastSeenHookState.delete(fiber);
+        if (fiber.alternate) lastSeenHookState.delete(fiber.alternate);
+      };
+      hook.onCommitFiberUnmount = devtoolsUnmountHandler;
+      integrationMode = "devtools";
+      commitSurface.reset();
+      const adapter = metricsAdapter;
+      if (adapter) {
+        const adapterMode = `adapter:${adapter.id}`;
+        adapter.attach((root) => {
+          const previousCapture = commitSurface.observeAdapter(root);
+          if (integrationMode !== adapterMode) {
+            integrationMode = adapterMode;
+          }
+          if (previousCapture) {
+            const metricsAfter = captureMetricsSnapshot();
+            if (previousCapture.metricsBefore && metricsAfter) {
+              recordMetricsEvidence(previousCapture.commitId, previousCapture.committedComponents, previousCapture.metricsBefore, metricsAfter);
+            }
+            state.lastMetricsSnapshot = metricsAfter;
+          } else {
+            handleCommit(
+              root,
+              /* metricsDeltaAvailable */
+              true
+            );
+          }
+        });
+      }
+    },
+    /**
+     * Stop profiling React commits. Does not clear accumulated state.
+     * Call reset() to clear state.
+     *
+     * Restores the DevTools hook to its prior state:
+     *   - hook was created by us → delete the hook entirely
+     *   - hook had a prior onCommitFiberRoot → restore it
+     *   - hook had no handler → delete the property
+     *
+     * Asks the adapter to remove its host callback only if it is still ours
+     * (don't stomp a concurrent installer).
+     */
+    uninstall() {
+      metricsAdapter?.detach();
+      const devtoolsGlobal = globalThis;
+      const hook = devtoolsGlobal.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (hook) {
+        if (devtoolsHookCreatedByUs) {
+          delete devtoolsGlobal.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+        } else {
+          if (devtoolsHookPrev) {
+            hook.onCommitFiberRoot = devtoolsHookPrev;
+          } else {
+            delete hook.onCommitFiberRoot;
+          }
+          if (devtoolsUnmountPrev) {
+            hook.onCommitFiberUnmount = devtoolsUnmountPrev;
+          } else {
+            delete hook.onCommitFiberUnmount;
+          }
+        }
+      }
+      debugRender.uninstall();
+      interactionCapture.uninstall();
+      commitSurface.reset();
+      pendingDevtoolsUnmounts = { components: 0, subtrees: 0 };
+      pendingDevtoolsUnmountSamples = [];
+      devtoolsHookPrev = void 0;
+      devtoolsUnmountPrev = void 0;
+      devtoolsHookCreatedByUs = false;
+      integrationMode = "none";
+    },
+    /**
+     * Clear all accumulated profiling state. Useful for starting fresh measurements.
+     * Does not uninstall the profiler - call uninstall() separately if needed.
+     */
+    reset() {
+      resetState();
+      debugRender.reset();
+    },
+    /**
+     * Generate a report of top update sources and thrashing components.
+     * @param topN - Number of top sources to include (default: 10)
+     * @param sortBy - Sort thrashers by 'effect', 'callback', 'memo', or 'total' (default: 'effect')
+     * @param options - Report filtering options (e.g., minCollateral to hide low-impact sources)
+     * @returns Report containing sources, blast radius, and optional thrashing data
+     */
+    report(topN = 10, sortBy = "effect", reportOptions) {
+      return buildReport(state, thrashMode, topN, sortBy, reportOptions, {
+        effectThrashMode,
+        captureFibers,
+        historySize,
+        detectionLevel,
+        integrationMode
+      });
+    },
+    /**
+     * Raw passive hook events captured for a component (debug surface).
+     */
+    _debugRawHookEvents(componentName) {
+      const components = debugRender.allComponents();
+      const events = componentName === "*" ? [] : debugRender.rawEvents(componentName);
+      return {
+        ok: true,
+        componentName,
+        status: debugRender.status(),
+        components,
+        events
+      };
+    },
+    _debugInjectHookEventsForTest(componentName, events) {
+      if (typeof debugRender.recordEventForTest !== "function") return;
+      for (const event of events) {
+        debugRender.recordEventForTest({ ...event, componentName });
+      }
+    },
+    _debugSetSourceForTest(sourceId, source) {
+      state.sources.set(sourceId, source);
+    },
+    debugHook(sourceId, hookIndex, windowSize = 3) {
+      let source = state.sources.get(sourceId);
+      let resolvedSourceId = sourceId;
+      if (!source) {
+        for (const [internalId, candidate] of state.sources.entries()) {
+          const candidateHumanId = `${getComponentDisplayName(candidate.type)}#${String(internalId).match(/#(\d+)@/)?.[1] || "1"}@${candidate.depth}`;
+          if (candidateHumanId === sourceId) {
+            source = candidate;
+            resolvedSourceId = internalId;
+            break;
+          }
+        }
+      }
+      if (!source) return { ok: false, error: "sourceId not found", sourceId };
+      const componentName = getComponentDisplayName(source.type);
+      let events = debugRender.rawEvents(componentName);
+      let resolvedComponentName = componentName;
+      if (events.length === 0) {
+        const candidates = debugRender.allComponents();
+        const matching = candidates.find((name) => name === componentName || name.includes(componentName) || componentName.includes(name));
+        if (matching) {
+          resolvedComponentName = matching;
+          events = debugRender.rawEvents(matching);
+        }
+      }
+      const sourceHookIndices = Array.isArray(source.debugHookIndices) ? source.debugHookIndices : [];
+      const targetIndex = Math.floor(hookIndex);
+      const eventIndex = sourceHookIndices[targetIndex] ?? targetIndex;
+      const target = events[eventIndex];
+      const radius = Math.max(0, Math.floor(windowSize));
+      if (!target) {
+        return {
+          ok: false,
+          error: "hook event not found",
+          sourceId: resolvedSourceId,
+          requestedSourceId: sourceId,
+          componentName,
+          resolvedComponentName,
+          hookIndex: targetIndex,
+          eventIndex,
+          sourceHookIndices,
+          eventCount: events.length,
+          status: debugRender.status(),
+          caveat: "hook ancestry comes from passive stack capture during real renders; component-name stack parsing can be ambiguous in bundled/minified code"
+        };
+      }
+      const neighborhood = events.map((event, index) => ({ event, index })).filter(({ index }) => Math.abs(index - eventIndex) <= radius).map(({ event, index }) => ({
+        hookIndex: sourceHookIndices.indexOf(index) >= 0 ? sourceHookIndices.indexOf(index) : index,
+        eventIndex: index,
+        primitive: event.primitive,
+        parents: parentFramesForEvent(event, componentName)
+      }));
+      return {
+        ok: true,
+        sourceId: resolvedSourceId,
+        requestedSourceId: sourceId,
+        componentName,
+        resolvedComponentName,
+        hookIndex: targetIndex,
+        eventIndex,
+        sourceHookIndices,
+        primitive: target.primitive,
+        parents: parentFramesForEvent(target, componentName),
+        neighborhood,
+        eventCount: events.length,
+        status: debugRender.status(),
+        caveat: "hook ancestry comes from passive stack capture during real renders; source-local hook indices are mapped onto the captured component event stream"
+      };
+    },
+    /**
+     * Returns which commit-hook integration model is currently observed.
+     *   'devtools'     — DevTools hook is the active processor (no proven adapter callbacks).
+     *   'adapter:<id>' — The adapter's host surface has fired; it owns the math now.
+     *   'none'         — Detector not installed.
+     */
+    getIntegrationMode() {
+      return integrationMode;
+    },
+    /** Id of the commit metrics adapter resolved on install, or null. */
+    getMetricsAdapterId() {
+      return metricsAdapter?.id ?? null;
+    }
+  };
+}
+var DETECTION_LEVEL = {
+  /** Level 1: Only commitStats (performedWork for restarts) - minimal overhead */
+  LEVEL1_STATS: "stats",
+  /** Level 2: Stats + source tracking (which components caused updates) */
+  LEVEL2_SOURCES: "sources",
+  /** Level 3a: Sources + aggregate amplifier counts only (meta.amplifiersMetrics) */
+  LEVEL3_AMPLIFIER_METRICS: "amplifierMetrics",
+  /** Level 3b: Sources + full amplifier arrays (report.amplifiers, report.amplifierSources) */
+  LEVEL3_AMPLIFIERS: "amplifiers"
+};
+
+// src/plugins/atl/metrics-slot.ts
+var DEFAULT_METRICS_SLOT = "__ATL_REACT_METRICS";
+var METRICS_COUNTER_KEYS = [
+  "mountWorkCount",
+  "updateWorkCount",
+  "commitWorkCount",
+  "interruptedWorkCount",
+  "priorityInterruptedWorkCount",
+  "externalStoreRestartCount",
+  "renderRootSyncCount",
+  "renderRootConcurrentCount",
+  "componentWorkCount",
+  "componentMountWorkCount",
+  "componentUpdateWorkCount",
+  "componentRenderWithHooksCount",
+  "finishClassComponentCount",
+  "domWorkCount",
+  "totalTickCount",
+  "totalCommitCount",
+  "contextUpdateCount",
+  "legacyContextUpdateCount"
+];
+var ACCESSOR_KEYS = [...METRICS_COUNTER_KEYS, "totalRestarts", "totalPerformedWork"];
+function createZeroMetrics() {
+  const metrics = {};
+  for (const key of METRICS_COUNTER_KEYS) metrics[key] = 0;
+  metrics.setStateCount = 0;
+  return metrics;
+}
+function isAllZero(value) {
+  if (!value || typeof value !== "object") return true;
+  const record = value;
+  for (const key of ACCESSOR_KEYS) if ((record[key] || 0) !== 0) return false;
+  return true;
+}
+function isSlotHostLocked(target, slotName = DEFAULT_METRICS_SLOT) {
+  const existing = Object.getOwnPropertyDescriptor(target, slotName);
+  return !!existing && (existing.configurable === false || typeof existing.get === "function");
+}
+function protectMetricsSlot(target, metrics, slotName = DEFAULT_METRICS_SLOT) {
+  try {
+    const existing = Object.getOwnPropertyDescriptor(target, slotName);
+    if (existing && existing.configurable === false) return;
+    Object.defineProperty(target, slotName, { configurable: true, enumerable: true, writable: true, value: metrics });
+  } catch {
+    try {
+      target[slotName] = metrics;
+    } catch {
+    }
+  }
+}
+function seedMetricsSlot(target, slotName = DEFAULT_METRICS_SLOT) {
+  const metrics = createZeroMetrics();
+  try {
+    target[slotName] = metrics;
+  } catch {
+  }
+  protectMetricsSlot(target, metrics, slotName);
+  return metrics;
+}
+function installMetricsAccessor(target, slotName = DEFAULT_METRICS_SLOT) {
+  try {
+    const existing = Object.getOwnPropertyDescriptor(target, slotName);
+    if (existing && existing.configurable === false) return false;
+    let live = existing && typeof existing.get === "function" ? target[slotName] : existing?.value;
+    if (!live || typeof live !== "object") {
+      live = { onCommitFiberRoot: null };
+      for (const key of ACCESSOR_KEYS) live[key] = 0;
+    }
+    Object.defineProperty(target, slotName, {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return live;
+      },
+      set(next) {
+        if (next === void 0 || next === null || isAllZero(next)) return;
+        live = next;
+      }
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/plugins/atl/commit-metrics-adapter.ts
+var ATL_DISPATCHER_FRAME = "atlDispatcherHook";
+var num = (snapshot, key) => snapshot[key] ?? 0;
+var diff = (before, after, key) => num(after, key) - num(before, key);
+function calculateATLDelta(before, after) {
+  return {
+    // Basic work counters
+    mountWorkCount: diff(before, after, "mountWorkCount"),
+    updateWorkCount: diff(before, after, "updateWorkCount"),
+    commitWorkCount: diff(before, after, "commitWorkCount"),
+    performedWorkCount: diff(before, after, "totalPerformedWork"),
+    // Interruption/restart counters
+    interruptedWorkCount: diff(before, after, "interruptedWorkCount"),
+    externalStoreRestartCount: diff(before, after, "externalStoreRestartCount"),
+    priorityInterruptedWorkCount: diff(before, after, "priorityInterruptedWorkCount"),
+    renderRootSyncCount: diff(before, after, "renderRootSyncCount"),
+    renderRootConcurrentCount: diff(before, after, "renderRootConcurrentCount"),
+    // Scheduler
+    ticksCount: diff(before, after, "totalTickCount"),
+    // Component work counters
+    componentWorkCount: diff(before, after, "componentWorkCount"),
+    componentMountWorkCount: diff(before, after, "componentMountWorkCount"),
+    componentUpdateWorkCount: diff(before, after, "componentUpdateWorkCount"),
+    componentRenderWithHooksCount: diff(before, after, "componentRenderWithHooksCount"),
+    finishClassComponentCount: diff(before, after, "finishClassComponentCount"),
+    // DOM work
+    domWorkCount: diff(before, after, "domWorkCount"),
+    // Context updates
+    contextUpdateCount: diff(before, after, "contextUpdateCount"),
+    legacyContextUpdateCount: diff(before, after, "legacyContextUpdateCount"),
+    // Hook-metric delta (react-dom patch; optional). Omit when neither snapshot
+    // carries a numeric setStateCount so we never emit a bogus 0 on unpatched hosts.
+    // TODO: Require finite values on both sides or model a counter reset
+    // explicitly. Treating a missing/wiped side as zero can emit a negative delta,
+    // and typeof NaN === 'number' lets a poisoned counter enter the report.
+    ...typeof after.setStateCount === "number" || typeof before.setStateCount === "number" ? { setStateCount: diff(before, after, "setStateCount") } : {}
+  };
+}
+function createATLCommitMetricsAdapter(options = {}) {
+  const slotName = options.slotName ?? DEFAULT_METRICS_SLOT;
+  const target = () => options.target ?? globalThis;
+  const slot = () => {
+    const value = target()[slotName];
+    return value && typeof value === "object" ? value : null;
+  };
+  let ourHandler;
+  return {
+    id: "atl",
+    frameFilters: [ATL_DISPATCHER_FRAME],
+    prePage() {
+      installMetricsAccessor(target(), slotName);
+    },
+    prepare() {
+      try {
+        if (!isSlotHostLocked(target(), slotName)) seedMetricsSlot(target(), slotName);
+      } catch {
+      }
+    },
+    isAvailable: () => !!slot(),
+    snapshot() {
+      const live = slot();
+      return live ? { ...live } : null;
+    },
+    measure(before, after, committedComponents, commitId) {
+      const delta = calculateATLDelta(before, after);
+      delta.performedWorkCount = committedComponents;
+      const rendered = (delta.componentRenderWithHooksCount ?? 0) + (delta.finishClassComponentCount ?? 0);
+      const restarts = Math.max(0, rendered - committedComponents);
+      if (committedComponents > rendered && rendered > 0) {
+        console.warn(
+          `[Avalanche] Commit ${commitId}: committedComponents (${committedComponents}) > atlTotal (${rendered}). This indicates a counting bug. Using 0 restarts.`
+        );
+      }
+      const live = slot();
+      if (live) {
+        live.totalRestarts = (live.totalRestarts ?? 0) + restarts;
+        live.totalPerformedWork = (live.totalPerformedWork ?? 0) + committedComponents;
+      }
+      return { delta, restarts };
+    },
+    attach(onCommit) {
+      const live = slot();
+      if (!live) return false;
+      const handler = (_rendererID, root) => onCommit(root);
+      live.onCommitFiberRoot = handler;
+      ourHandler = handler;
+      return true;
+    },
+    isAttached() {
+      const live = slot();
+      return !!live && !!ourHandler && live.onCommitFiberRoot === ourHandler;
+    },
+    reattach() {
+      const fresh = seedMetricsSlot(target(), slotName);
+      if (ourHandler) fresh.onCommitFiberRoot = ourHandler;
+    },
+    detach() {
+      const live = slot();
+      if (live && ourHandler && live.onCommitFiberRoot === ourHandler) live.onCommitFiberRoot = void 0;
+      ourHandler = void 0;
+    }
+  };
+}
+var atlCommitMetricsAdapter = createATLCommitMetricsAdapter();
+export {
+  DETECTION_LEVEL,
+  atlCommitMetricsAdapter,
+  createATLCommitMetricsAdapter,
+  createAvalancheDetector,
+  registerCommitMetricsAdapter
+};
+//# sourceMappingURL=avalanche.js.map