@buoy-gg/highlight-updates 7.0.38 → 7.0.39

package/lib/module/highlight-updates/utils/CommitProfiler.js

@@ -1 +1,442 @@
-"use strict";import{isDevToolsComponentName,isRenderLoopUnsafeName}from"./devtoolsComponentNames";import{ownStateChanged}from"./ownStateChanged";const FunctionComponent=0,ClassComponent=1,ForwardRef=11,MemoComponent=14,SimpleMemoComponent=15,PerformedWork=1,MAX_FIBERS_PER_COMMIT=1e4,MAX_TRACKED_NAMES=300,TOP_COMPONENTS_CAP=20;let hookInstalled=!1,active=!1,sawDurations=!1,captureDetail=!1,totalCommits=0,totalRenders=0,totalRenderMs=0,totalCauses={},buckets=new Map;function getHook(){return"undefined"==typeof global?null:global.__REACT_DEVTOOLS_GLOBAL_HOOK__??null}function getFlags(e){const t=e.flags??e.effectTag;return"number"==typeof t?t:0}function isCompositeTag(e){return 0===e||1===e||11===e||14===e||15===e}function getComponentName(e){const t=e.type;try{switch(e.tag){case 0:case 1:return t?.displayName||t?.name||"Anonymous";case 11:return t?.displayName||t?.render?.displayName||t?.render?.name||"ForwardRef";case 14:case 15:{const n=t?.type??e.elementType?.type;return t?.displayName||n?.displayName||n?.name||"Memo"}default:return"Anonymous"}}catch{return"Anonymous"}}function computeSelfMs(e){const t=e.actualDuration;if("number"!=typeof t)return null;let n=t;for(let t=e.child;null!=t;t=t.sibling)"number"==typeof t.actualDuration&&(n-=t.actualDuration);return n>0?n:0}const FRAMEWORK_WRAPPER_NAMES=new Set(["View","Text","Image","ImageBackground","ScrollView","FlatList","SectionList","SafeAreaView","KeyboardAvoidingView","StatusBar","ActivityIndicator","RefreshControl","Modal","Switch","Pressable","PlatformPressable","TouchableOpacity","TouchableHighlight","TouchableWithoutFeedback","TouchableNativeFeedback","PressabilityDebugView","AnimatedComponent","Wrapper"]),FRAMEWORK_WRAPPER_PREFIXES=["Animated(","Pressability","Virtualized","CellRenderer"];function isFrameworkWrapperName(e){if(FRAMEWORK_WRAPPER_NAMES.has(e))return!0;for(let t=0;t<FRAMEWORK_WRAPPER_PREFIXES.length;t++)if(e.startsWith(FRAMEWORK_WRAPPER_PREFIXES[t]))return!0;return!1}const MAX_PROPS_COMPARED=40,MAX_CHANGED_KEYS=5;function isEquivalentValue(e,t){if(Object.is(e,t))return!0;const n=typeof e;if(n!==typeof t)return!1;if("function"===n)return!0;if(null===e||null===t||"object"!==n)return!1;const r=Array.isArray(e);if(r!==Array.isArray(t))return!1;if(r){if(e.length!==t.length)return!1;for(let n=0;n<e.length;n++)if(!Object.is(e[n],t[n]))return!1;return!0}const o=Object.keys(e),a=Object.keys(t);if(o.length!==a.length)return!1;for(let n=0;n<o.length;n++){const r=o[n];if(!Object.prototype.hasOwnProperty.call(t,r))return!1;if(!Object.is(e[r],t[r]))return!1}return!0}function detectCause(e,t){const n=e.alternate;if(!n)return{cause:"mount"};const r=e.memoizedProps,o=n.memoizedProps;if(r!==o&&r&&o){let e,n=!1,a=!1;const s=Object.keys(r),i=s.length<40?s.length:40;for(let l=0;l<i;l++){const i=s[l],u=o[i],c=r[i];if(!Object.is(u,c)&&(n=!0,t&&(e||(e=[]),e.length<5&&e.push(i)),!isEquivalentValue(u,c)&&(a=!0,!t)))break}if(a||Object.keys(o).length===s.length||(n=!0,a=!0),n)return{cause:a?"props":"propsUnstable",changedKeys:e}}return ownStateChanged(n,e)?{cause:"hooks"}:{cause:"parent"}}function nearestRenderedAncestorName(e){for(let t=e.return;null!=t;t=t.return){if(!isCompositeTag(t.tag))continue;if(!(1&getFlags(t)))continue;const e=getComponentName(t);if(!isFrameworkWrapperName(e))return e}}function recordRender(e,t){const n=getComponentName(e),r=computeSelfMs(e);null!==r&&(sawDurations=!0);const o=r??0;totalRenders+=1,totalRenderMs+=o;const{cause:a,changedKeys:s}=detectCause(e,captureDetail);if(totalCauses[a]=(totalCauses[a]??0)+1,isFrameworkWrapperName(n))return;let i=buckets.get(n);if(!i){if(buckets.size>=300)return;i={renders:0,totalSelfMs:0,maxSelfMs:0,causes:{}},buckets.set(n,i)}if(i.renders+=1,i.totalSelfMs+=o,o>i.maxSelfMs&&(i.maxSelfMs=o),i.causes[a]=(i.causes[a]??0)+1,captureDetail){if(s){i.changedProps||(i.changedProps=new Set);for(let e=0;e<s.length&&!(i.changedProps.size>=5);e++)i.changedProps.add(s[e])}t&&!i.parentName&&(i.parentName=t)}}function handleCommit(e){const t=e?.current;if(!t)return;const n=totalRenders;let r=0,o=t;for(;null!=o&&(r+=1,!(r>1e4));){let e=!1;if(isCompositeTag(o.tag)){const t=getComponentName(o);isRenderLoopUnsafeName(t)?e=!0:isDevToolsComponentName(t)||1&getFlags(o)&&recordRender(o,captureDetail?nearestRenderedAncestorName(o):void 0)}if(!e){const e=o.subtreeFlags;if(("number"!=typeof e||1&e||1&getFlags(o))&&null!=o.child){o=o.child;continue}}for(;null!=o;){if(o===t)return finalizeCommit(n);if(null!=o.sibling){o=o.sibling;break}o=o.return}}finalizeCommit(n)}function finalizeCommit(e){totalRenders>e&&(totalCommits+=1)}function ensureHookInstalled(){if(hookInstalled)return!0;const e=getHook();if(!e)return!1;const t=e.onCommitFiberRoot;return e.onCommitFiberRoot=function(n,r,...o){if(active)try{handleCommit(r)}catch{}return"function"==typeof t?t.call(e,n,r,...o):void 0},hookInstalled=!0,!0}function isSupported(){if("undefined"!=typeof __DEV__&&!__DEV__)return!1;const e=getHook();return Boolean(e&&e.renderers&&e.renderers.size>0)}function isCapturing(){return active}function startCapture(e){ensureHookInstalled()&&(buckets=new Map,sawDurations=!1,captureDetail=!0===e?.detail,totalCommits=0,totalRenders=0,totalRenderMs=0,totalCauses={},active=!0)}function stopCapture(){if(!active&&0===totalRenders&&0===buckets.size)return null;active=!1;const e=Array.from(buckets.entries()).sort((e,t)=>{const n=t[1].totalSelfMs-e[1].totalSelfMs;return 0!==n?n:t[1].renders-e[1].renders}).slice(0,20).map(([e,t])=>({name:e,renders:t.renders,totalMs:round2(t.totalSelfMs),maxMs:round2(t.maxSelfMs),avgMs:t.renders>0?round2(t.totalSelfMs/t.renders):0,causes:t.causes,...t.changedProps&&t.changedProps.size>0?{changedProps:Array.from(t.changedProps)}:null,...t.parentName?{parentName:t.parentName}:null})),t={totalCommits:totalCommits,totalRenders:totalRenders,capturedDurations:sawDurations,totalRenderMs:round2(totalRenderMs),wastedRenders:(totalCauses.parent??0)+(totalCauses.propsUnstable??0),causes:totalCauses,topComponents:e};return buckets=new Map,totalCommits=0,totalRenders=0,totalRenderMs=0,totalCauses={},t}function round2(e){return Math.round(100*e)/100}export const CommitProfiler={isSupported:isSupported,isCapturing:isCapturing,startCapture:startCapture,stopCapture:stopCapture};
+"use strict";
+
+/**
+ * CommitProfiler — per-component render counts + durations across a capture
+ * window, React-DevTools-profiler style, without React DevTools attached.
+ *
+ * Wraps `__REACT_DEVTOOLS_GLOBAL_HOOK__.onCommitFiberRoot` (the callback React
+ * invokes after every commit) and, while a capture is active, walks the
+ * committed fiber tree collecting composite fibers that performed work this
+ * commit. Self duration follows React's convention: `actualDuration` minus the
+ * sum of direct children's `actualDuration` (profiling timers are enabled in
+ * dev builds, where Buoy runs).
+ *
+ * This is intentionally separate from the traceUpdates flow the highlight
+ * overlay uses — traceUpdates emits host views with no timing data.
+ *
+ * Consumed by perf-monitor benchmarks via the shared-ui render-capture
+ * registry (see the registration in this package's index.tsx).
+ */
+
+import { isDevToolsComponentName, isRenderLoopUnsafeName } from "./devtoolsComponentNames";
+// One implementation, shared with the overlay's RenderCauseDetector — the two
+// classifiers are separate on purpose, but this question is not. See the file
+// for why the obvious identity check is wrong.
+import { ownStateChanged } from "./ownStateChanged";
+
+// React work tags for components that render user code.
+const FunctionComponent = 0;
+const ClassComponent = 1;
+const ForwardRef = 11;
+const MemoComponent = 14;
+const SimpleMemoComponent = 15;
+
+// React fiber flag: this fiber rendered (performed work) in the last commit.
+// Stable value 0b1 across React 16-19 (effectTag pre-18, flags after).
+const PerformedWork = 0b1;
+
+/** Overhead guardrail: stop walking a commit past this many visited fibers. */
+const MAX_FIBERS_PER_COMMIT = 10_000;
+
+/** Bound on distinct component names tracked; overflow still counts in totals. */
+const MAX_TRACKED_NAMES = 300;
+
+/** Components returned in the summary. */
+const TOP_COMPONENTS_CAP = 20;
+let hookInstalled = false;
+let active = false;
+let sawDurations = false;
+let captureDetail = false;
+let totalCommits = 0;
+let totalRenders = 0;
+let totalRenderMs = 0;
+let totalCauses = {};
+let buckets = new Map();
+function getHook() {
+  if (typeof global === "undefined") return null;
+  return global.__REACT_DEVTOOLS_GLOBAL_HOOK__ ?? null;
+}
+function getFlags(fiber) {
+  const f = fiber.flags ?? fiber.effectTag;
+  return typeof f === "number" ? f : 0;
+}
+function isCompositeTag(tag) {
+  return tag === FunctionComponent || tag === ClassComponent || tag === ForwardRef || tag === MemoComponent || tag === SimpleMemoComponent;
+}
+
+/** Resolve a composite fiber's display name (DevTools conventions). */
+function getComponentName(fiber) {
+  const type = fiber.type;
+  try {
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ClassComponent:
+        return type?.displayName || type?.name || "Anonymous";
+      case ForwardRef:
+        return type?.displayName || type?.render?.displayName || type?.render?.name || "ForwardRef";
+      case MemoComponent:
+      case SimpleMemoComponent:
+        {
+          const inner = type?.type ?? fiber.elementType?.type;
+          return type?.displayName || inner?.displayName || inner?.name || "Memo";
+        }
+      default:
+        return "Anonymous";
+    }
+  } catch {
+    return "Anonymous";
+  }
+}
+
+/**
+ * Self duration = own actualDuration minus direct children's. React's
+ * bubbleProperties adds every direct child's actualDuration into the parent,
+ * so subtracting them all back out is symmetric and exact.
+ */
+function computeSelfMs(fiber) {
+  const actual = fiber.actualDuration;
+  if (typeof actual !== "number") return null;
+  let self = actual;
+  for (let child = fiber.child; child != null; child = child.sibling) {
+    if (typeof child.actualDuration === "number") self -= child.actualDuration;
+  }
+  return self > 0 ? self : 0;
+}
+
+// React Native framework wrapper components. Their renders are real work
+// but the actionable signal lives on the OWNING component (a Touchable
+// re-rendering is already visible as its parent re-rendering), so they're
+// folded into the capture totals and kept OUT of the per-component list.
+// This is a report-level filter only — unlike isDevToolsComponentName it
+// must NOT prune subtrees (their children are user components).
+const FRAMEWORK_WRAPPER_NAMES = new Set(["View", "Text", "Image", "ImageBackground", "ScrollView", "FlatList", "SectionList", "SafeAreaView", "KeyboardAvoidingView", "StatusBar", "ActivityIndicator", "RefreshControl", "Modal", "Switch", "Pressable", "PlatformPressable", "TouchableOpacity", "TouchableHighlight", "TouchableWithoutFeedback", "TouchableNativeFeedback", "PressabilityDebugView", "AnimatedComponent", "Wrapper"]);
+const FRAMEWORK_WRAPPER_PREFIXES = ["Animated(",
+// Animated(View), Animated(Text), Animated(FlatList), …
+"Pressability", "Virtualized",
+// VirtualizedList + its context providers
+"CellRenderer"];
+function isFrameworkWrapperName(name) {
+  if (FRAMEWORK_WRAPPER_NAMES.has(name)) return true;
+  for (let i = 0; i < FRAMEWORK_WRAPPER_PREFIXES.length; i++) {
+    if (name.startsWith(FRAMEWORK_WRAPPER_PREFIXES[i])) return true;
+  }
+  return false;
+}
+
+/** Bound on prop keys compared per render, so a fat props object can't stall a commit. */
+const MAX_PROPS_COMPARED = 40;
+/** Bound on distinct changed-prop key names remembered per component (detail tier). */
+const MAX_CHANGED_KEYS = 5;
+
+/**
+ * Are two values for the same prop key equivalent despite differing identity?
+ *
+ * Functions always count as equivalent: a fresh arrow per render is THE
+ * unstable-prop bug, and there's no way to compare behaviour anyway. Plain
+ * objects and arrays compare one level deep, which catches `style={{...}}`
+ * and `data={[...]}`. Anything else falls through to a real value change.
+ */
+function isEquivalentValue(a, b) {
+  if (Object.is(a, b)) return true;
+  const ta = typeof a;
+  if (ta !== typeof b) return false;
+  if (ta === "function") return true;
+  if (a === null || b === null || ta !== "object") return false;
+  const aIsArray = Array.isArray(a);
+  if (aIsArray !== Array.isArray(b)) return false;
+  if (aIsArray) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+    return true;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (let i = 0; i < keysA.length; i++) {
+    const k = keysA[i];
+    if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
+    if (!Object.is(a[k], b[k])) return false;
+  }
+  return true;
+}
+/**
+ * Why did this fiber render?
+ *
+ * Simpler than the overlay's RenderCauseDetector, and deliberately so: that
+ * one carries WeakMap fallbacks and fiber-swap detection because traceUpdates
+ * hands it fibers at an ambiguous moment. Here we're inside onCommitFiberRoot
+ * walking the committed tree, so `fiber` is current and `fiber.alternate` is
+ * previous by definition. Porting the swap logic would be cargo-cult.
+ */
+function detectCause(fiber, wantKeys) {
+  const prev = fiber.alternate;
+  if (!prev) return {
+    cause: "mount"
+  };
+  const nextProps = fiber.memoizedProps;
+  const prevProps = prev.memoizedProps;
+  if (nextProps !== prevProps && nextProps && prevProps) {
+    let sawChange = false;
+    let sawValueChange = false;
+    let changedKeys;
+    const keys = Object.keys(nextProps);
+    const limit = keys.length < MAX_PROPS_COMPARED ? keys.length : MAX_PROPS_COMPARED;
+    for (let i = 0; i < limit; i++) {
+      const k = keys[i];
+      const a = prevProps[k];
+      const b = nextProps[k];
+      if (Object.is(a, b)) continue;
+      sawChange = true;
+      if (wantKeys) {
+        if (!changedKeys) changedKeys = [];
+        if (changedKeys.length < MAX_CHANGED_KEYS) changedKeys.push(k);
+      }
+      if (!isEquivalentValue(a, b)) {
+        sawValueChange = true;
+        if (!wantKeys) break; // cause is settled; only keys need the full pass
+      }
+    }
+    // A removed key counts as a real change; cheap to detect via key count.
+    if (!sawValueChange && Object.keys(prevProps).length !== keys.length) {
+      sawChange = true;
+      sawValueChange = true;
+    }
+    if (sawChange) {
+      return {
+        cause: sawValueChange ? "props" : "propsUnstable",
+        changedKeys
+      };
+    }
+  }
+
+  // No prop change of substance. Own state/hooks next.
+  if (ownStateChanged(prev, fiber)) return {
+    cause: "hooks"
+  };
+  return {
+    cause: "parent"
+  };
+}
+
+/**
+ * Nearest ancestor that ALSO rendered this commit and is worth naming — i.e.
+ * skipping framework wrappers, which are never where a fix goes. Answers "who
+ * dragged this along", which is the actionable half of a cascade.
+ */
+function nearestRenderedAncestorName(fiber) {
+  for (let p = fiber.return; p != null; p = p.return) {
+    if (!isCompositeTag(p.tag)) continue;
+    if ((getFlags(p) & PerformedWork) === 0) continue;
+    const name = getComponentName(p);
+    if (isFrameworkWrapperName(name)) continue;
+    return name;
+  }
+  return undefined;
+}
+function recordRender(fiber, parentName) {
+  const name = getComponentName(fiber);
+  const selfMs = computeSelfMs(fiber);
+  if (selfMs !== null) sawDurations = true;
+  const ms = selfMs ?? 0;
+  totalRenders += 1;
+  totalRenderMs += ms;
+  const {
+    cause,
+    changedKeys
+  } = detectCause(fiber, captureDetail);
+  totalCauses[cause] = (totalCauses[cause] ?? 0) + 1;
+
+  // Framework wrappers count toward totals but never surface as a row.
+  if (isFrameworkWrapperName(name)) return;
+  let bucket = buckets.get(name);
+  if (!bucket) {
+    // Bounded map: overflow renders still count toward the totals above.
+    if (buckets.size >= MAX_TRACKED_NAMES) return;
+    bucket = {
+      renders: 0,
+      totalSelfMs: 0,
+      maxSelfMs: 0,
+      causes: {}
+    };
+    buckets.set(name, bucket);
+  }
+  bucket.renders += 1;
+  bucket.totalSelfMs += ms;
+  if (ms > bucket.maxSelfMs) bucket.maxSelfMs = ms;
+  bucket.causes[cause] = (bucket.causes[cause] ?? 0) + 1;
+  if (captureDetail) {
+    if (changedKeys) {
+      if (!bucket.changedProps) bucket.changedProps = new Set();
+      for (let i = 0; i < changedKeys.length; i++) {
+        if (bucket.changedProps.size >= MAX_CHANGED_KEYS) break;
+        bucket.changedProps.add(changedKeys[i]);
+      }
+    }
+    // First parent wins — a component rendered under several parents is rare,
+    // and the first is the one that showed up in the heaviest commit.
+    if (parentName && !bucket.parentName) bucket.parentName = parentName;
+  }
+}
+
+/**
+ * Iterative walk (child → sibling → return) of the committed tree. Never
+ * throws upward — a broken walk must not break React's commit.
+ */
+function handleCommit(root) {
+  const start = root?.current;
+  if (!start) return;
+  const rendersBefore = totalRenders;
+  let visited = 0;
+  let fiber = start;
+  while (fiber != null) {
+    visited += 1;
+    if (visited > MAX_FIBERS_PER_COMMIT) break;
+    let skipSubtree = false;
+    const composite = isCompositeTag(fiber.tag);
+    if (composite) {
+      const compositeName = getComponentName(fiber);
+      // Only Buoy's render-tracking UI gets its SUBTREE pruned — walking it
+      // feeds its own renders back in and loops. Everything else that's merely
+      // devtools noise is skipped as a NODE and we keep descending: app
+      // components live underneath Buoy chrome, and pruning a subtree on a name
+      // match is what made a stray "Virtualized" prefix hide every FlatList in
+      // every app.
+      if (isRenderLoopUnsafeName(compositeName)) {
+        skipSubtree = true;
+      } else if (isDevToolsComponentName(compositeName)) {
+        // skip this node, keep walking its children
+      } else if ((getFlags(fiber) & PerformedWork) !== 0) {
+        // PerformedWork is the only trustworthy "rendered this commit"
+        // signal — actualDuration is stale on bailed-out fibers.
+        recordRender(fiber, captureDetail ? nearestRenderedAncestorName(fiber) : undefined);
+      }
+    }
+    if (!skipSubtree) {
+      // Prune subtrees with no work. subtreeFlags only exists on React 18+;
+      // when absent, always descend.
+      const subtreeFlags = fiber.subtreeFlags;
+      const noSubtreeWork = typeof subtreeFlags === "number" && (subtreeFlags & PerformedWork) === 0 && (getFlags(fiber) & PerformedWork) === 0;
+      if (!noSubtreeWork && fiber.child != null) {
+        fiber = fiber.child;
+        continue;
+      }
+    }
+
+    // No descend: advance to sibling, climbing up as needed.
+    while (fiber != null) {
+      if (fiber === start) return finalizeCommit(rendersBefore);
+      if (fiber.sibling != null) {
+        fiber = fiber.sibling;
+        break;
+      }
+      fiber = fiber.return;
+    }
+  }
+  finalizeCommit(rendersBefore);
+}
+function finalizeCommit(rendersBefore) {
+  if (totalRenders > rendersBefore) totalCommits += 1;
+}
+
+/**
+ * Install the onCommitFiberRoot wrapper once and never restore it — the
+ * `active` flag gates all work, and never restoring avoids clobber races if
+ * something else (e.g. React DevTools attaching mid-session) wraps the hook
+ * after us. The wrapper dies with the JS realm on reload.
+ */
+function ensureHookInstalled() {
+  if (hookInstalled) return true;
+  const hook = getHook();
+  if (!hook) return false;
+  const original = hook.onCommitFiberRoot;
+  hook.onCommitFiberRoot = function (rendererID, root, ...rest) {
+    if (active) {
+      try {
+        handleCommit(root);
+      } catch {
+        // Capture must never break React's commit path.
+      }
+    }
+    return typeof original === "function" ? original.call(hook, rendererID, root, ...rest) : undefined;
+  };
+  hookInstalled = true;
+  return true;
+}
+function isSupported() {
+  if (typeof __DEV__ !== "undefined" && !__DEV__) return false;
+  const hook = getHook();
+  return Boolean(hook && hook.renderers && hook.renderers.size > 0);
+}
+function isCapturing() {
+  return active;
+}
+
+/**
+ * Begin a capture window, discarding any previous unclaimed data.
+ *
+ * `detail` turns on the allocating tier — changed prop key names and parent
+ * component names. Causes themselves are always classified: it costs a shallow
+ * prop compare, against a `computeSelfMs` that already walks every direct
+ * child on every render, and the wasted-render total is the number most worth
+ * seeing without having to know to ask for it.
+ */
+function startCapture(opts) {
+  if (!ensureHookInstalled()) return;
+  buckets = new Map();
+  sawDurations = false;
+  captureDetail = opts?.detail === true;
+  totalCommits = 0;
+  totalRenders = 0;
+  totalRenderMs = 0;
+  totalCauses = {};
+  active = true;
+}
+
+/** End the window and return the aggregate (null if never started). */
+function stopCapture() {
+  if (!active && totalRenders === 0 && buckets.size === 0) return null;
+  active = false;
+  const topComponents = Array.from(buckets.entries()).sort((a, b) => {
+    const byMs = b[1].totalSelfMs - a[1].totalSelfMs;
+    return byMs !== 0 ? byMs : b[1].renders - a[1].renders;
+  }).slice(0, TOP_COMPONENTS_CAP).map(([name, b]) => ({
+    name,
+    renders: b.renders,
+    totalMs: round2(b.totalSelfMs),
+    maxMs: round2(b.maxSelfMs),
+    avgMs: b.renders > 0 ? round2(b.totalSelfMs / b.renders) : 0,
+    causes: b.causes,
+    ...(b.changedProps && b.changedProps.size > 0 ? {
+      changedProps: Array.from(b.changedProps)
+    } : null),
+    ...(b.parentName ? {
+      parentName: b.parentName
+    } : null)
+  }));
+  const summary = {
+    totalCommits,
+    totalRenders,
+    capturedDurations: sawDurations,
+    totalRenderMs: round2(totalRenderMs),
+    // Parent cascades and identity-only prop churn are both removable without
+    // changing behaviour — together they're the recoverable share.
+    wastedRenders: (totalCauses.parent ?? 0) + (totalCauses.propsUnstable ?? 0),
+    causes: totalCauses,
+    topComponents
+  };
+  buckets = new Map();
+  totalCommits = 0;
+  totalRenders = 0;
+  totalRenderMs = 0;
+  totalCauses = {};
+  return summary;
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+export const CommitProfiler = {
+  isSupported,
+  isCapturing,
+  startCapture,
+  stopCapture
+};