@buoy-gg/highlight-updates 7.0.38 → 7.0.39

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

@@ -1 +1,76 @@
-"use strict";export function isOnScreenTap(t){return!!t&&t.x>=-.1&&t.x<=1.1&&t.y>=-.1&&t.y<=1.1}export function isRectCenterOnScreen(t,e,a){if(!t||e<=0||a<=0)return!1;const r=t.x+t.width/2,o=t.y+t.height/2,n=.1*e,s=.1*a;return r>=-n&&r<=e+n&&o>=-s&&o<=a+s}export function looseText(t){return String(t??"").toLowerCase().replace(/\s+/g," ").replace(/(\d)[,\u00a0\u202f](?=\d{3}\b)/g,"$1").trim()}export function scoreTapMatch(t,e){if(null!=e.nativeTag&&t.nativeTag===e.nativeTag)return 1e3;const a=String(e.query??e.testID??"").trim().toLowerCase();if(!a)return 0;const r=[t.testID,t.label,t.text,t.name].filter(Boolean).map(t=>t.toLowerCase());let o=0;for(const t of r)t===a?o=Math.max(o,100):t.startsWith(a)?o=Math.max(o,50):t.includes(a)&&(o=Math.max(o,25));const n=looseText(a);if(n)for(const t of r){const e=looseText(t);e===n?o=Math.max(o,90):e.startsWith(n)?o=Math.max(o,45):e.includes(n)&&(o=Math.max(o,22))}return e.testID&&t.testID&&t.testID.toLowerCase()===e.testID.toLowerCase()&&(o=Math.max(o,200)),0===o?0:((t.testID??"").toLowerCase().startsWith("buoy-dial-")&&(o+=40),t.tap&&(isOnScreenTap(t.tap)?o+=20:o-=40),o)}
+"use strict";
+
+/**
+ * Shared tap-target scoring for describe_screen / tap_element.
+ *
+ * Ranking used to be substring-on-testID only, so `tap: "ASSETS"` preferred
+ * `nav-assets-tool-test` (score 25) over a visible dial icon, and off-screen
+ * Expo Router screens (y > 1) stayed in the candidate list.
+ */
+
+/** True when the measured center is inside the window (10% slack for home-indicator / portal hosts). */
+export function isOnScreenTap(tap) {
+  if (!tap) return false;
+  return tap.x >= -0.1 && tap.x <= 1.1 && tap.y >= -0.1 && tap.y <= 1.1;
+}
+
+/**
+ * Point-in-window test in *points* (measureInWindow coords), with slack so
+ * the floating menu and rows clipped at the home indicator still count.
+ * Previous Expo Router screens typically measure at y > 1.2× window height.
+ */
+export function isRectCenterOnScreen(rect, screenW, screenH) {
+  if (!rect || screenW <= 0 || screenH <= 0) return false;
+  const cx = rect.x + rect.width / 2;
+  const cy = rect.y + rect.height / 2;
+  const slackX = screenW * 0.1;
+  const slackY = screenH * 0.1;
+  return cx >= -slackX && cx <= screenW + slackX && cy >= -slackY && cy <= screenH + slackY;
+}
+
+/**
+ * The comparable form of a piece of text.
+ *
+ * "1,450", `1450` and "1,450 Points" are one request as far as a person is
+ * concerned. Measured on a live QA run: waits for BOTH "1,450" and 1450 failed
+ * against a balance that was on screen, because the thousands separator made
+ * every comparison miss. Lowercased, whitespace collapsed, digit-group
+ * separators dropped. A number arrives here as a number often enough that the
+ * coercion is not optional — `.trim()` on one is a crash.
+ */
+export function looseText(value) {
+  return String(value ?? "").toLowerCase().replace(/\s+/g, " ").replace(/(\d)[,\u00a0\u202f](?=\d{3}\b)/g, "$1").trim();
+}
+export function scoreTapMatch(c, params) {
+  if (params.nativeTag != null && c.nativeTag === params.nativeTag) return 1000;
+  const q = String(params.query ?? params.testID ?? "").trim().toLowerCase();
+  if (!q) return 0;
+  const fields = [c.testID, c.label, c.text, c.name].filter(Boolean).map(s => s.toLowerCase());
+  let best = 0;
+  for (const f of fields) {
+    if (f === q) best = Math.max(best, 100);else if (f.startsWith(q)) best = Math.max(best, 50);else if (f.includes(q)) best = Math.max(best, 25);
+  }
+  // Same tiers on the loose form, one notch lower so an exact hit still wins
+  // when both match. Skipped when the loose query is empty, or `includes("")`
+  // would score every candidate on the screen.
+  const looseQuery = looseText(q);
+  if (looseQuery) {
+    for (const f of fields) {
+      const loose = looseText(f);
+      if (loose === looseQuery) best = Math.max(best, 90);else if (loose.startsWith(looseQuery)) best = Math.max(best, 45);else if (loose.includes(looseQuery)) best = Math.max(best, 22);
+    }
+  }
+  if (params.testID && c.testID && c.testID.toLowerCase() === params.testID.toLowerCase()) {
+    best = Math.max(best, 200);
+  }
+  if (best === 0) return 0;
+  const id = (c.testID ?? "").toLowerCase();
+  // Dial icons are the thing agents mean when they tap a tool name. (No
+  // penalties for app testID patterns — this ships in the library, and we
+  // don't know consumer apps' naming conventions.)
+  if (id.startsWith("buoy-dial-")) best += 40;
+  if (c.tap) {
+    if (isOnScreenTap(c.tap)) best += 20;else best -= 40;
+  }
+  return best;
+}

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

@@ -1 +1,60 @@
-"use strict";export function identifierSlug(e){return String(e).toLowerCase().replace(/[^a-z0-9]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}export function renderRowTestID(e){return`buoy-highlight-row-${identifierSlug(e)}`}export function detectedItemTestID(e,t){return`buoy-highlight-detected-${identifierSlug(e)}-${identifierSlug(t)}`}export function patternChipTestID(e,t,i){return`buoy-highlight-${e}-chip-${identifierSlug(t)}-${identifierSlug(i)}`}export function settingTestID(e){return`buoy-highlight-setting-${e}`}
+"use strict";
+
+/**
+ * Stable e2e handles for the Render Highlighter (highlight-updates).
+ *
+ * This tool's list is the hardest thing in Buoy to address, because the thing
+ * it lists is a NATIVE VIEW and the only key it has for one is the fiber's
+ * `nativeTag` — a per-session counter that changes on every launch, on every
+ * remount, and (on a dynamic screen) between two runs of the same test. A
+ * handle built from it would name a different component every time.
+ *
+ * So rows are addressed by their IDENTIFIER, in exactly the priority the list
+ * item itself uses to label them: testID → nativeID → component name →
+ * accessibility label → nativeTag. That is the same string the developer sees
+ * on the row, it is stable as long as the component is, and it is what a test
+ * can name up front. `nativeTag` remains the last resort for an anonymous host
+ * view, which no test should be naming anyway.
+ *
+ * Slug rules are mirrored in `example-dev-build/utils/renderBench.js` so the
+ * fixture and the tool agree about what a row is called; the suite's
+ * `fixture.js` spot-checks that they still do.
+ */
+
+/** Any identifier string → a testID-safe slug. */
+export function identifierSlug(value) {
+  return String(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
+
+/**
+ * `buoy-highlight-row-<slug>` for one row of the render list.
+ *
+ * Sub-handles hang off it: `-name`, `-count`, `-type`, `-cause`, `-identifier`,
+ * `-time`. The count is the tool's whole claim, so it gets its own handle
+ * rather than living inside the row's merged label.
+ */
+export function renderRowTestID(identifier) {
+  return `buoy-highlight-row-${identifierSlug(identifier)}`;
+}
+
+/**
+ * `buoy-highlight-detected-<type>-<slug>` for one chip in DETECTED ITEMS.
+ *
+ * The type is in the handle because the same string legitimately appears under
+ * two categories — a component called `Pressable` and a viewType called
+ * `Pressable` are different filters with the same name, and a suite that added
+ * the wrong one would still see "a pattern was added".
+ */
+export function detectedItemTestID(type, value) {
+  return `buoy-highlight-detected-${identifierSlug(type)}-${identifierSlug(value)}`;
+}
+
+/** `buoy-highlight-<mode>-chip-<type>-<slug>` for an active filter pattern. */
+export function patternChipTestID(mode, type, value) {
+  return `buoy-highlight-${mode}-chip-${identifierSlug(type)}-${identifierSlug(value)}`;
+}
+
+/** `buoy-highlight-setting-<key>` for a settings row's control. */
+export function settingTestID(key) {
+  return `buoy-highlight-setting-${key}`;
+}

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

@@ -1 +1,270 @@
-"use strict";import{resolveTouchTarget}from"./screenElements";import{resolveRawEventEmitter}from"./rawEventEmitter";const TAP_SLOP_PT=14,LONG_PRESS_MS=550,MAX_TAP_MS=4e3,TEXT_COALESCE_MS=8e3,MAX_RECORDS=600;let emitter=null,emitterResolved=!1,unavailableReason=null,subscriptions=[],status="idle",records=[],seq=0,pending=null;function getEmitter(){if(emitterResolved)return emitter;emitterResolved=!0;const t=resolveRawEventEmitter();return emitter=t.emitter,unavailableReason=t.reason,emitter}function num(t){return"number"==typeof t&&Number.isFinite(t)?t:null}function tagOf(t){const e=t?.nativeEvent;return e?num(e.target)??num(e.tag):null}function pointOf(t){const e=t?.nativeEvent;if(!e)return null;const n={x:num(e.pageX),y:num(e.pageY)};if(null!==n.x&&null!==n.y)return{x:n.x,y:n.y};for(const t of["changedTouches","touches"]){const n=e[t];if(Array.isArray(n)&&n.length){const t=n[0],e=num(t?.pageX),r=num(t?.pageY);if(null!==e&&null!==r)return{x:e,y:r}}}return null}function push(t){records.push({...t,seq:++seq}),records.length>600&&(records=records.slice(-600))}function onTouchStart(t){const e=tagOf(t);if(null===e)return;const n=pointOf(t);let r=null;try{r=resolveTouchTarget(e)}catch{}pending={tag:e,x:n?.x??0,y:n?.y??0,t:Date.now(),drift:0,target:r}}function onTouchMove(t){if(!pending)return;const e=pointOf(t);if(!e)return;const n=e.x-pending.x,r=e.y-pending.y;pending.drift=Math.max(pending.drift,Math.sqrt(n*n+r*r))}function onTouchEnd(t){const e=pending;if(pending=null,!e||!e.target)return;const n=pointOf(t);if(n){const t=n.x-e.x,r=n.y-e.y;e.drift=Math.max(e.drift,Math.sqrt(t*t+r*r))}if(e.drift>14)return;const r=Date.now()-e.t;r>4e3||"text"!==e.target.control&&"toggle"!==e.target.control&&"slider"!==e.target.control&&push({t:Date.now(),kind:r>=550?"longPress":"press",target:e.target})}function onTouchCancel(){pending=null}function onChange(t){const e=tagOf(t);if(null===e)return;const n=t.nativeEvent;let r,o;if("string"==typeof n.text)r="text",o=n.text;else if("boolean"==typeof n.value)r="toggle",o=n.value;else{if("number"!=typeof n.value)return;r="slider",o=n.value}const u=records[records.length-1];if(u&&u.kind===r&&u.target.nativeTag===e&&Date.now()-u.t<8e3)return u.value=o,void(u.t=Date.now());let a=null;try{a=resolveTouchTarget(e)}catch{}a&&push({t:Date.now(),kind:r,target:a,value:o})}export function startTouchCapture(){if("capturing"===status)return getTouchCaptureStatus();const t=getEmitter();if(!t)return status="unavailable",getTouchCaptureStatus();try{subscriptions=[t.addListener("topTouchStart",onTouchStart),t.addListener("topTouchMove",onTouchMove),t.addListener("topTouchEnd",onTouchEnd),t.addListener("topTouchCancel",onTouchCancel),t.addListener("topChange",onChange),t.addListener("topValueChange",onChange),t.addListener("topSlidingComplete",onChange)],pending=null,status="capturing"}catch(t){subscriptions=[],status="unavailable",unavailableReason=t?.message??"addListener failed"}return getTouchCaptureStatus()}export function stopTouchCapture(){subscriptions.forEach(t=>{try{t.remove()}catch{}}),subscriptions=[],pending=null,"capturing"===status&&(status="idle")}export function clearTouchCapture(){records=[],seq=0}export function getTouchCaptureStatus(){return{status:status,reason:"unavailable"===status?unavailableReason:null}}export function readTouchCapture(t=0){return{...getTouchCaptureStatus(),records:records.filter(e=>e.seq>t),seq:seq}}
+"use strict";
+
+/**
+ * touchCapture — what a HUMAN is doing to the app, as replayable intents.
+ *
+ * This is the recording half of the pair whose playback half is `tapElement`:
+ * it watches real finger input and names each interaction in exactly the
+ * vocabulary `tapElement` searches by, so a recorded macro can be replayed
+ * without a second guess about what "that button" meant.
+ *
+ * Why RawEventEmitter and not the obvious alternatives:
+ * - A capture-phase responder on a root View would be the textbook answer, but
+ *   Buoy mounts as a SIBLING of the app tree, not a parent. There is no root to
+ *   wrap without changing every host app's integration.
+ * - Patching `Pressability`, or rewriting `onPress` props on the fly, breaks the
+ *   moment a component re-renders (props are rebuilt every render) and misses
+ *   everything driven by react-native-gesture-handler anyway.
+ * - RawEventEmitter mirrors every dispatched event before React's plugins see
+ *   it, needs zero app instrumentation, and is already proven in-tree by
+ *   focus-inspector's TV focus observer.
+ *
+ * Three rules the recorder above depends on:
+ *
+ *   THE TARGET IS RESOLVED AT touchStart, NOT touchEnd. A press handler can
+ *   navigate synchronously, so resolving after the fact names an element on the
+ *   screen the app moved TO. We resolve while the finger is still down and emit
+ *   when it lifts.
+ *
+ *   A DRAG IS NOT A TAP. Scrolling a list produces the same touchStart the
+ *   button above it does. Movement past a threshold, or an explicit
+ *   touchCancel when a ScrollView steals the responder, drops the record —
+ *   otherwise every recording is half scroll noise.
+ *
+ *   KEYSTROKES ARE NOT INTENTS. Typing "SAVE10" fires six change events; a
+ *   macro step wants the finished string. Consecutive edits to the same input
+ *   collapse into the latest value as they arrive.
+ */
+
+import { resolveTouchTarget } from "./screenElements";
+import { resolveRawEventEmitter } from "./rawEventEmitter";
+
+/** Points of finger travel past which the gesture stops being a tap. */
+const TAP_SLOP_PT = 14;
+/** Hold time at or past which a tap is recorded as a long-press. */
+const LONG_PRESS_MS = 550;
+/** A tap that outlasts this was a gesture we don't model — drop it. */
+const MAX_TAP_MS = 4_000;
+/** Consecutive edits to the same input within this window are one intent. */
+const TEXT_COALESCE_MS = 8_000;
+/** Ring buffer size. A recording longer than this is not a macro anyway. */
+const MAX_RECORDS = 600;
+let emitter = null;
+let emitterResolved = false;
+let unavailableReason = null;
+let subscriptions = [];
+let status = "idle";
+let records = [];
+let seq = 0;
+let pending = null;
+function getEmitter() {
+  if (emitterResolved) return emitter;
+  emitterResolved = true;
+  const resolution = resolveRawEventEmitter();
+  emitter = resolution.emitter;
+  unavailableReason = resolution.reason;
+  return emitter;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+
+/** Fabric puts the touched view on `target`; `tag` is the older shape. */
+function tagOf(event) {
+  const native = event?.nativeEvent;
+  if (!native) return null;
+  return num(native.target) ?? num(native.tag);
+}
+
+/**
+ * Touch coordinates. A touch event carries them at the top level on the
+ * synthesized event and inside `touches`/`changedTouches` on the raw one, and
+ * which of those is populated differs by platform and architecture — so read
+ * whichever answers rather than betting on one.
+ */
+function pointOf(event) {
+  const native = event?.nativeEvent;
+  if (!native) return null;
+  const direct = {
+    x: num(native.pageX),
+    y: num(native.pageY)
+  };
+  if (direct.x !== null && direct.y !== null) return {
+    x: direct.x,
+    y: direct.y
+  };
+  for (const key of ["changedTouches", "touches"]) {
+    const list = native[key];
+    if (Array.isArray(list) && list.length) {
+      const first = list[0];
+      const x = num(first?.pageX);
+      const y = num(first?.pageY);
+      if (x !== null && y !== null) return {
+        x,
+        y
+      };
+    }
+  }
+  return null;
+}
+function push(record) {
+  records.push({
+    ...record,
+    seq: ++seq
+  });
+  if (records.length > MAX_RECORDS) records = records.slice(-MAX_RECORDS);
+}
+function onTouchStart(event) {
+  const tag = tagOf(event);
+  if (tag === null) return;
+  const point = pointOf(event);
+  let target = null;
+  try {
+    target = resolveTouchTarget(tag);
+  } catch {
+    // A fiber walk that throws must never break the app's touch handling.
+  }
+  pending = {
+    tag,
+    x: point?.x ?? 0,
+    y: point?.y ?? 0,
+    t: Date.now(),
+    drift: 0,
+    target
+  };
+}
+function onTouchMove(event) {
+  if (!pending) return;
+  const point = pointOf(event);
+  if (!point) return;
+  const dx = point.x - pending.x;
+  const dy = point.y - pending.y;
+  pending.drift = Math.max(pending.drift, Math.sqrt(dx * dx + dy * dy));
+}
+function onTouchEnd(event) {
+  const p = pending;
+  pending = null;
+  if (!p || !p.target) return;
+  const point = pointOf(event);
+  if (point) {
+    const dx = point.x - p.x;
+    const dy = point.y - p.y;
+    p.drift = Math.max(p.drift, Math.sqrt(dx * dx + dy * dy));
+  }
+  if (p.drift > TAP_SLOP_PT) return; // a drag, a scroll, a swipe — not a step
+
+  const held = Date.now() - p.t;
+  if (held > MAX_TAP_MS) return;
+
+  // A text input's tap is just "focus this field"; the intent is the text it
+  // ends up with, which arrives separately as a change event. Recording the
+  // focus tap too would put a step in every macro that does nothing on replay.
+  if (p.target.control === "text") return;
+  // Same for a toggle/slider: the tap and the value change are one intent, and
+  // the change event is the half that carries what it became.
+  if (p.target.control === "toggle" || p.target.control === "slider") return;
+  push({
+    t: Date.now(),
+    kind: held >= LONG_PRESS_MS ? "longPress" : "press",
+    target: p.target
+  });
+}
+function onTouchCancel() {
+  // A ScrollView (or any ancestor) taking the responder terminates the touch.
+  pending = null;
+}
+
+/**
+ * `topChange` is the shared channel for "this control's value became X" —
+ * TextInput sends `text`, Switch sends `value`. Sliders arrive on their own
+ * channel. All three are the same idea: a control the user set.
+ */
+function onChange(event) {
+  const tag = tagOf(event);
+  if (tag === null) return;
+  const native = event.nativeEvent;
+  let kind;
+  let value;
+  if (typeof native.text === "string") {
+    kind = "text";
+    value = native.text;
+  } else if (typeof native.value === "boolean") {
+    kind = "toggle";
+    value = native.value;
+  } else if (typeof native.value === "number") {
+    kind = "slider";
+    value = native.value;
+  } else {
+    return;
+  }
+  const last = records[records.length - 1];
+  if (last && last.kind === kind && last.target.nativeTag === tag && Date.now() - last.t < TEXT_COALESCE_MS) {
+    // Same control, still typing/dragging: this IS the previous intent, further
+    // along. Replace rather than append, or "SAVE10" becomes six macro steps.
+    last.value = value;
+    last.t = Date.now();
+    return;
+  }
+  let target = null;
+  try {
+    target = resolveTouchTarget(tag);
+  } catch {
+    /* see onTouchStart */
+  }
+  if (!target) return;
+  push({
+    t: Date.now(),
+    kind,
+    target,
+    value
+  });
+}
+export function startTouchCapture() {
+  if (status === "capturing") return getTouchCaptureStatus();
+  const raw = getEmitter();
+  if (!raw) {
+    status = "unavailable";
+    return getTouchCaptureStatus();
+  }
+  try {
+    subscriptions = [raw.addListener("topTouchStart", onTouchStart), raw.addListener("topTouchMove", onTouchMove), raw.addListener("topTouchEnd", onTouchEnd), raw.addListener("topTouchCancel", onTouchCancel), raw.addListener("topChange", onChange), raw.addListener("topValueChange", onChange), raw.addListener("topSlidingComplete", onChange)];
+    pending = null;
+    status = "capturing";
+  } catch (e) {
+    subscriptions = [];
+    status = "unavailable";
+    unavailableReason = e?.message ?? "addListener failed";
+  }
+  return getTouchCaptureStatus();
+}
+export function stopTouchCapture() {
+  subscriptions.forEach(s => {
+    try {
+      s.remove();
+    } catch {
+      /* already gone is fine */
+    }
+  });
+  subscriptions = [];
+  pending = null;
+  if (status === "capturing") status = "idle";
+}
+export function clearTouchCapture() {
+  records = [];
+  seq = 0;
+}
+export function getTouchCaptureStatus() {
+  return {
+    status,
+    reason: status === "unavailable" ? unavailableReason : null
+  };
+}
+
+/** Everything recorded after `sinceSeq`, plus where the caller now is. */
+export function readTouchCapture(sinceSeq = 0) {
+  return {
+    ...getTouchCaptureStatus(),
+    records: records.filter(r => r.seq > sinceSeq),
+    seq
+  };
+}

package/lib/module/index.js

@@ -1 +1,130 @@
-"use strict";export{highlightUpdatesPreset,createHighlightUpdatesTool,highlightUpdatesModalPreset,createHighlightUpdatesModalTool}from"./preset";export{default as HighlightUpdatesController}from"./highlight-updates/utils/HighlightUpdatesController";export{highlightUpdatesSyncAdapter}from"./sync/highlightUpdatesSyncAdapter";export{HighlightUpdatesOverlay}from"./highlight-updates/HighlightUpdatesOverlay";export{installProfilerInterceptor,uninstallProfilerInterceptor,setComparisonCallback,isInterceptorInstalled,enableProfilerLogging,disableProfilerLogging,isLoggingEnabled}from"./highlight-updates/utils/ProfilerInterceptor";export{CommitProfiler}from"./highlight-updates/utils/CommitProfiler";export{setCaptureBuoyToolRenders,isCapturingBuoyToolRenders}from"./highlight-updates/utils/devtoolsComponentNames";import{setRenderCaptureProvider}from"@buoy-gg/shared-ui";import{CommitProfiler as _commitProfilerForRegistry}from"./highlight-updates/utils/CommitProfiler";import _controllerForRegistry from"./highlight-updates/utils/HighlightUpdatesController";try{setRenderCaptureProvider({isSupported:_commitProfilerForRegistry.isSupported,start:_commitProfilerForRegistry.startCapture,stop:_commitProfilerForRegistry.stopCapture,startLiveHighlights:()=>{try{const e=_controllerForRegistry.isEnabled(),t=_controllerForRegistry.getHighlightsSuppressed();return _controllerForRegistry.enable(),()=>{try{e?t&&_controllerForRegistry.setHighlightsSuppressed(!0):_controllerForRegistry.disable()}catch{}}}catch{return null}}})}catch{}export{RenderTracker}from"./highlight-updates/utils/RenderTracker";export const onRenderEvent=e=>{const{RenderTracker:t}=require("./highlight-updates/utils/RenderTracker");return t.onRenderEvent(e)};export{detectRenderCause,clearRenderCauseState,removeRenderCauseState,getRenderCauseStats,safeCloneForHistory,capturePropsSnapshot,captureStateSnapshot}from"./highlight-updates/utils/RenderCauseDetector";export{PerformanceLogger}from"./highlight-updates/utils/PerformanceLogger";export{VIEW_TYPE_MAP,getComponentDisplayName,getNativeViewType,isKnownViewType,getAllNativeViewTypes,getAllComponentNames}from"./highlight-updates/utils/ViewTypeMapper";export{HighlightUpdatesModal,HighlightToolView}from"./highlight-updates/components/HighlightUpdatesModal";export{RenderListItem}from"./highlight-updates/components/RenderListItem";export{RenderDetailView}from"./highlight-updates/components/RenderDetailView";export{HighlightFilterView}from"./highlight-updates/components/HighlightFilterView";export{RenderCauseBadge,TwoLevelCauseBadge,CAUSE_CONFIG,COMPONENT_CAUSE_CONFIG}from"./highlight-updates/components/RenderCauseBadge";export{RenderHistoryViewer,RenderHistoryFooter}from"./highlight-updates/components/RenderHistoryViewer";export{generateRendersJson}from"./highlight-updates/utils/renderExportFormatter";export{identifierSlug,renderRowTestID,detectedItemTestID,patternChipTestID,settingTestID}from"./highlight-updates/utils/testIDs";
+"use strict";
+
+/**
+ * @buoy-gg/highlight-updates
+ *
+ * Standalone implementation of React DevTools' "Highlight updates when components
+ * render" feature. Works without requiring DevTools to be connected.
+ *
+ * @example
+ * ```tsx
+ * // Toggle-only preset - tap to enable/disable highlights
+ * import { highlightUpdatesPreset } from '@buoy-gg/highlight-updates';
+ *
+ * <FloatingDevTools apps={[highlightUpdatesPreset]} />
+ *
+ * // Modal preset - full interface with filters and render list
+ * import { highlightUpdatesModalPreset } from '@buoy-gg/highlight-updates';
+ *
+ * <FloatingDevTools apps={[highlightUpdatesModalPreset]} />
+ *
+ * // Or use the standalone controller programmatically
+ * import { HighlightUpdatesController } from '@buoy-gg/highlight-updates';
+ *
+ * HighlightUpdatesController.toggle();
+ * HighlightUpdatesController.enable();
+ * HighlightUpdatesController.disable();
+ * ```
+ */
+
+// Preset exports for FloatingDevTools integration
+export { highlightUpdatesPreset, createHighlightUpdatesTool, highlightUpdatesModalPreset, createHighlightUpdatesModalTool } from "./preset";
+
+// Controller export for standalone usage
+export { default as HighlightUpdatesController } from "./highlight-updates/utils/HighlightUpdatesController";
+
+// External sync (adapter for @buoy-gg/external-sync's useExternalSync)
+export { highlightUpdatesSyncAdapter } from "./sync/highlightUpdatesSyncAdapter";
+
+// Overlay component - auto-rendered by FloatingDevTools, but exported for manual usage
+export { HighlightUpdatesOverlay } from "./highlight-updates/HighlightUpdatesOverlay";
+
+// Profiler interceptor for debugging - captures what DevTools detects
+export { installProfilerInterceptor, uninstallProfilerInterceptor, setComparisonCallback, isInterceptorInstalled, enableProfilerLogging, disableProfilerLogging, isLoggingEnabled } from "./highlight-updates/utils/ProfilerInterceptor";
+
+// CommitProfiler — per-component render counts/durations over a capture window
+export { CommitProfiler } from "./highlight-updates/utils/CommitProfiler";
+
+// Bench "profile our own tools" mode: lets a dedicated benchmark screen
+// include Buoy's tool UI in render capture (normally pruned wholesale).
+// Highlight/events + perf-monitor components stay excluded regardless.
+export { setCaptureBuoyToolRenders, isCapturingBuoyToolRenders } from "./highlight-updates/utils/devtoolsComponentNames";
+
+// Register the render-capture provider so perf-monitor benchmarks can capture
+// renders without depending on this package. Runs at module scope: whenever
+// this package is installed, FloatingDevTools require()s it (including on the
+// fresh realm after a reload-between-cases batch step), and Metro evaluates
+// module side effects regardless of the package.json "sideEffects" hint.
+import { setRenderCaptureProvider } from "@buoy-gg/shared-ui";
+import { CommitProfiler as _commitProfilerForRegistry } from "./highlight-updates/utils/CommitProfiler";
+import _controllerForRegistry from "./highlight-updates/utils/HighlightUpdatesController";
+try {
+  setRenderCaptureProvider({
+    isSupported: _commitProfilerForRegistry.isSupported,
+    start: _commitProfilerForRegistry.startCapture,
+    stop: _commitProfilerForRegistry.stopCapture,
+    // Real-time bounding boxes (the Render Highlighter visual) for the span
+    // of a recording. Saves the user's prior overlay state and hands back a
+    // restore fn: previously ON stays ON, silent tracking (events tool) gets
+    // re-suppressed, otherwise fully disabled again.
+    startLiveHighlights: () => {
+      try {
+        const wasEnabled = _controllerForRegistry.isEnabled();
+        const wasSuppressed = _controllerForRegistry.getHighlightsSuppressed();
+        _controllerForRegistry.enable(); // idempotent; clears suppression
+        return () => {
+          try {
+            if (!wasEnabled) {
+              _controllerForRegistry.disable(); // respects background tracking
+            } else if (wasSuppressed) {
+              _controllerForRegistry.setHighlightsSuppressed(true);
+            }
+          } catch {
+            // restoring the overlay must never throw into the recorder
+          }
+        };
+      } catch {
+        return null;
+      }
+    }
+  });
+} catch {
+  // shared-ui too old to have the registry — capture is simply unavailable.
+}
+
+// RenderTracker singleton for tracking render history
+export { RenderTracker } from "./highlight-updates/utils/RenderTracker";
+// Convenience export for unified events integration
+export const onRenderEvent = callback => {
+  const {
+    RenderTracker
+  } = require("./highlight-updates/utils/RenderTracker");
+  return RenderTracker.onRenderEvent(callback);
+};
+
+// RenderCauseDetector for detecting why components rendered
+export { detectRenderCause, clearRenderCauseState, removeRenderCauseState, getRenderCauseStats,
+// Snapshot capture for render history
+safeCloneForHistory, capturePropsSnapshot, captureStateSnapshot } from "./highlight-updates/utils/RenderCauseDetector";
+
+// PerformanceLogger for performance measurement and debugging
+export { PerformanceLogger } from "./highlight-updates/utils/PerformanceLogger";
+// ViewTypeMapper for translating native view names to component names
+export { VIEW_TYPE_MAP, getComponentDisplayName, getNativeViewType, isKnownViewType, getAllNativeViewTypes, getAllComponentNames } from "./highlight-updates/utils/ViewTypeMapper";
+
+// Modal components for custom integrations
+// `HighlightToolView` is the same tool rendered inline (header bar + body +
+// footer) instead of inside a JsModal — for hosts that show tools in a panel.
+export { HighlightUpdatesModal, HighlightToolView } from "./highlight-updates/components/HighlightUpdatesModal";
+export { RenderListItem } from "./highlight-updates/components/RenderListItem";
+export { RenderDetailView } from "./highlight-updates/components/RenderDetailView";
+export { HighlightFilterView } from "./highlight-updates/components/HighlightFilterView";
+export { RenderCauseBadge, TwoLevelCauseBadge, CAUSE_CONFIG, COMPONENT_CAUSE_CONFIG } from "./highlight-updates/components/RenderCauseBadge";
+export { RenderHistoryViewer, RenderHistoryFooter } from "./highlight-updates/components/RenderHistoryViewer";
+
+// Simple JSON export for renders
+export { generateRendersJson } from "./highlight-updates/utils/renderExportFormatter";
+
+// e2e handle builders — exported so the example app's fixture can derive the
+// same row handles the tool renders instead of hardcoding a second copy.
+export { identifierSlug, renderRowTestID, detectedItemTestID, patternChipTestID, settingTestID } from "./highlight-updates/utils/testIDs";