@buoy-gg/highlight-updates 7.0.30 → 7.0.32

package/lib/commonjs/highlight-updates/components/HighlightUpdatesModal.js

@@ -557,6 +557,7 @@ function HighlightUpdatesModal({
         style: styles.inlineRoot,
         children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
           style: styles.inlineHeader,
+          ..._sharedUi.windowDragProps,
           children: renderHeaderContent()
         }), body, footerNode]
       })

package/lib/commonjs/highlight-updates/utils/rawEventEmitter.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveRawEventEmitter = resolveRawEventEmitter;
+/**
+ * The one guarded require for React Native's RawEventEmitter.
+ *
+ * `RawEventEmitter` mirrors every event React Native dispatches BEFORE React's
+ * plugins or components see it, which makes it the only way to observe what a
+ * HUMAN is touching without instrumenting the app: Buoy mounts as a sibling of
+ * the app tree, not a parent, so there is no root View to put a capture
+ * responder on.
+ *
+ * Two things this file is careful about, both learned the hard way in
+ * focus-inspector's copy:
+ *
+ * 1. It is a DEEP import that RN's export map warns about and could move in any
+ *    release. The failure has to degrade to "capture unavailable" rather than
+ *    taking the host app's bundle down — and Metro only treats a require as
+ *    optional when it sits LEXICALLY inside a try statement, so wrapping it in
+ *    a helper or an arrow makes Metro hard-fail the bundle instead.
+ * 2. Keeping it in its own module gives the unit suite a seam: Node's `require`
+ *    ignores Vitest's module mocks, so the emitter can only be faked by mocking
+ *    a module reached with a real `import`.
+ */
+
+function resolveRawEventEmitter() {
+  let mod;
+  try {
+    mod = require("react-native/Libraries/Core/RawEventEmitter");
+  } catch (e) {
+    return {
+      emitter: null,
+      reason: e?.message ?? "RawEventEmitter is unavailable"
+    };
+  }
+  const candidate = mod?.default ?? mod;
+  if (typeof candidate?.addListener !== "function") {
+    return {
+      emitter: null,
+      reason: "RawEventEmitter has no addListener"
+    };
+  }
+  return {
+    emitter: candidate,
+    reason: null
+  };
+}

package/lib/commonjs/highlight-updates/utils/screenElements.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.describeScreen = describeScreen;
+exports.resolveTouchTarget = resolveTouchTarget;
 exports.tapElement = tapElement;
+exports.waitFor = waitFor;
 var _reactNative = require("react-native");
 var _tapMatch = require("./tapMatch");
 /**
@@ -773,4 +775,272 @@ async function tapElement(params) {
       }
     };
   }
+}
+
+// --- waitFor --------------------------------------------------------------
+
+const WAIT_DEFAULT_MS = 5_000;
+const WAIT_MAX_MS = 30_000;
+const WAIT_MIN_POLL_MS = 50;
+const WAIT_DEFAULT_POLL_MS = 150;
+
+/**
+ * Block until an element appears (or disappears), then report how long it took.
+ *
+ * WHY THIS EXISTS. `navigate` returns the moment the route is pushed, not when
+ * the new screen has data on it, so "go to /shop then tap Fire Grill" reliably
+ * tapped a loading skeleton. A remote driver solves that with a wait step
+ * (MCP's `run_flow` has `waitFor`/`waitMs`); anything driving the tools from
+ * INSIDE the app had nothing, and its only option was to re-run
+ * `describeScreen` in a loop — which for an agent means burning turns against a
+ * step budget, and for a Scenario means a fixed sleep that is either flaky or
+ * slow.
+ *
+ * MATCHING IS `tapElement`'S, EXACTLY. Same `scoreTapMatch`, same fields, so
+ * "wait for X" and "tap X" can never disagree about what X is. A wait that
+ * resolves on an element the tap then cannot find is worse than no wait.
+ *
+ * PRESENCE MEANS ON SCREEN. An identity scan alone would resolve against a
+ * previous Expo Router screen still mounted behind the current one — the exact
+ * false positive `describeScreen` drops by rect. So a candidate that matches by
+ * name is measured before it counts, and only the matches are measured: the
+ * per-poll cost stays one fiber walk plus a handful of `measureInWindow`
+ * calls, not a full `describeScreen`.
+ *
+ * The poll floor is deliberate. This runs on the JS thread the app is drawing
+ * on, and a caller asking for `pollMs: 0` would starve the very render it is
+ * waiting for.
+ */
+async function waitFor(params) {
+  const hasTarget = params.nativeTag != null || !!params.testID?.trim() || !!params.query?.trim();
+  if (!hasTarget) {
+    return {
+      ok: false,
+      waitedMs: 0,
+      polls: 0,
+      reason: "Nothing to wait for — pass nativeTag, testID or query."
+    };
+  }
+  const timeoutMs = Math.min(Math.max(params.timeoutMs ?? WAIT_DEFAULT_MS, 0), WAIT_MAX_MS);
+  const pollMs = Math.max(params.pollMs ?? WAIT_DEFAULT_POLL_MS, WAIT_MIN_POLL_MS);
+  const wantGone = params.gone === true;
+  const started = Date.now();
+  let polls = 0;
+  for (;;) {
+    polls += 1;
+    const hit = await findOnScreen(params);
+    if (wantGone ? !hit : !!hit) {
+      return {
+        ok: true,
+        waitedMs: Date.now() - started,
+        polls,
+        matched: hit ?? undefined
+      };
+    }
+    if (Date.now() - started >= timeoutMs) {
+      return {
+        ok: false,
+        waitedMs: Date.now() - started,
+        polls,
+        reason: wantGone ? `Still on screen after ${timeoutMs}ms.` : `Not on screen after ${timeoutMs}ms. Call describeScreen to see what is.`,
+        matched: hit ?? undefined
+      };
+    }
+    await new Promise(resolve => setTimeout(resolve, pollMs));
+  }
+}
+
+/** One scan: rank by identity, then confirm the best match is really visible. */
+async function findOnScreen(params) {
+  const ranked = collectCandidates().map(c => ({
+    c,
+    score: matchScore(c, params)
+  })).filter(r => r.score > 0).sort((a, b) => b.score - a.score)
+  // Only the plausible few get measured; a broad query can match dozens.
+  .slice(0, 8);
+  if (ranked.length === 0) return null;
+  await measureCandidates(ranked.map(r => r.c));
+  const win = _reactNative.Dimensions.get("window");
+  const screenW = Math.round(win.width) || 1;
+  const screenH = Math.round(win.height) || 1;
+  for (const {
+    c
+  } of ranked) {
+    if (!(0, _tapMatch.isRectCenterOnScreen)(c.rect, screenW, screenH)) continue;
+    return {
+      nativeTag: c.nativeTag,
+      name: c.name,
+      testID: c.testID,
+      label: c.label,
+      text: c.text,
+      interactive: !!(c.press || c.valueControl || c.textControl)
+    };
+  }
+  return null;
+}
+
+// --- resolveTouchTarget ---------------------------------------------------
+
+/**
+ * What a recorded touch landed on, in the vocabulary `tapElement` searches by.
+ *
+ * Deliberately the SAME fields `describeScreen` emits: a macro recorded from a
+ * human's finger has to replay through `tapElement`, and the only way to
+ * guarantee that is for the recorder to name the element exactly the way the
+ * matcher will look for it. Anything richer here is a selector that records
+ * fine and then can't be found again.
+ */
+
+/**
+ * Resolve the native tag from a raw touch event to the element a HUMAN would
+ * say they tapped.
+ *
+ * Synchronous on purpose. The tag arrives on `topTouchStart`, and by the time
+ * an async resolve came back the press handler may already have navigated —
+ * leaving the recorder to name the element on the screen it moved TO. Everything
+ * here is a fiber walk (no measure), which is what makes that affordable.
+ *
+ * Returns null when the tag belongs to nothing interesting (the background, a
+ * scroll surface): the recorder treats that as "not a step", which is exactly
+ * right — a tap on empty space is not something to replay.
+ */
+/**
+ * Is this fiber inside Buoy's own overlay?
+ *
+ * `FloatingDevTools` marks its single root View with `__buoyDevToolsRoot`, and
+ * everything the tool draws — the bubble, the dial, every modal, every tool
+ * overlay — is under it. Walking the whole chain (rather than a fixed depth) is
+ * the point: a control deep inside a tool's modal is still the tool.
+ */
+function isBuoyChrome(fiber) {
+  let cur = fiber;
+  let depth = 0;
+  while (cur && depth < 400) {
+    if (getProps(cur)?.__buoyDevToolsRoot) return true;
+    cur = cur.return;
+    depth++;
+  }
+  return false;
+}
+
+/**
+ * Climb from the node that was touched to the element that OWNS the press.
+ *
+ * A finger lands on the deepest host view, which for a button is the `<Text>`
+ * inside it. That Text is a legitimate candidate — `findPressHandler` walks up
+ * and finds the button's `onPress`, so it looks drivable — but it carries the
+ * TEXT's identity: no testID, and "visible text" that is whatever string
+ * happens to be in that node.
+ *
+ * Left alone, every recorded step is named after a fragment of copy and
+ * replayed by fuzzy-matching that fragment. In the Poké Mart flow, all six
+ * steps came back as `Text` with no testID at all, so "tap the Charizard row"
+ * was recorded as "The signature. Flame-broiled, wings on, worth the wait." —
+ * the brittlest possible selector, chosen when `shop-item-charizard` was one
+ * fiber up.
+ *
+ * So we walk to the fiber that DECLARES `onPress` and take the candidate there.
+ * Stopping at the declaring fiber matters: keep climbing and a row inside a
+ * pressable list resolves to the list.
+ */
+function preferHandlerOwner(match, byFiber) {
+  // Already the owner (or a Switch/TextInput, whose handler is its own).
+  const own = getProps(match.fiber);
+  if (typeof own?.onPress === "function" || typeof own?.onValueChange === "function" || typeof own?.onChangeText === "function") {
+    return match;
+  }
+
+  // 1. Find the fiber that actually declares the handler.
+  let declaring = null;
+  let cur = match.fiber?.return;
+  let depth = 0;
+  while (cur && depth < 25) {
+    if (typeof getProps(cur)?.onPress === "function") {
+      declaring = cur;
+      break;
+    }
+    cur = cur.return;
+    depth++;
+  }
+  if (!declaring) return match;
+
+  // 2. Take the candidate AT that fiber, or the first one above it.
+  //
+  //    Stopping exactly at the declaring fiber isn't enough: a `<Pressable>`
+  //    declares onPress but is de-duped into the component that renders it
+  //    (`PrimaryButton`), and de-duping keeps the OUTERMOST fiber of everything
+  //    sharing a host instance — which is where the testID ends up. Climbing a
+  //    few levels past the handler is what turns "Text: Add to bag" into
+  //    "PrimaryButton [testID=shop-add-to-bag]". The bound keeps a row inside a
+  //    pressable list from resolving to the list.
+  let probe = declaring;
+  for (let i = 0; i < 6 && probe; i++) {
+    const candidate = byFiber.get(probe);
+    if (candidate) return candidate;
+    probe = probe.return;
+  }
+  return match;
+}
+function resolveTouchTarget(nativeTag) {
+  const candidates = collectCandidates();
+  if (candidates.length === 0) return null;
+  const byFiber = new Map();
+  for (const c of candidates) byFiber.set(c.fiber, c);
+
+  // Fast path: the touched host IS a candidate's host.
+  const direct = candidates.find(c => c.nativeTag === nativeTag);
+
+  // Otherwise find the touched fiber and walk up to the nearest candidate. The
+  // touch lands on the deepest host view (the <Text> inside the button), so the
+  // interesting element is almost always an ancestor.
+  let touched = null;
+  if (!direct) {
+    for (const root of getAllFiberRoots()) {
+      traverseFiberTree(root.current, fiber => {
+        if (touched) return;
+        if (fiber.stateNode && getNativeTag(fiber.stateNode) === nativeTag) {
+          touched = fiber;
+        }
+      });
+      if (touched) break;
+    }
+  }
+  let match = direct ?? null;
+  if (!match && touched) {
+    let cur = touched;
+    let depth = 0;
+    // Prefer an ancestor that is actually drivable; fall back to the nearest
+    // named one so an unlabeled tap still records something a human can read.
+    let named = null;
+    while (cur && depth < 25) {
+      const c = byFiber.get(cur);
+      if (c) {
+        if (c.press || c.valueControl || c.textControl) {
+          match = c;
+          break;
+        }
+        if (!named) named = c;
+      }
+      cur = cur.return;
+      depth++;
+    }
+    if (!match) match = named;
+  }
+  if (!match) return null;
+  match = preferHandlerOwner(match, byFiber);
+  if (!match.press && !match.valueControl && !match.textControl) return null;
+  // Buoy's own chrome is not part of the app under test. Without this, the tap
+  // that stops a recording is recorded as its final step.
+  if (isBuoyChrome(match.fiber)) return null;
+  const control = match.valueControl ? match.valueControl.kind : match.textControl ? "text" : "press";
+  return {
+    nativeTag: match.nativeTag,
+    name: match.name,
+    role: match.role,
+    testID: match.testID,
+    label: match.label,
+    text: match.text,
+    control,
+    value: match.valueControl ? match.valueControl.current : match.textControl ? match.textControl.current : undefined
+  };
 }

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

@@ -0,0 +1,277 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearTouchCapture = clearTouchCapture;
+exports.getTouchCaptureStatus = getTouchCaptureStatus;
+exports.readTouchCapture = readTouchCapture;
+exports.startTouchCapture = startTouchCapture;
+exports.stopTouchCapture = stopTouchCapture;
+var _screenElements = require("./screenElements");
+var _rawEventEmitter = require("./rawEventEmitter");
+/**
+ * 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.
+ */
+
+/** 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 = (0, _rawEventEmitter.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 = (0, _screenElements.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 = (0, _screenElements.resolveTouchTarget)(tag);
+  } catch {
+    /* see onTouchStart */
+  }
+  if (!target) return;
+  push({
+    t: Date.now(),
+    kind,
+    target,
+    value
+  });
+}
+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();
+}
+function stopTouchCapture() {
+  subscriptions.forEach(s => {
+    try {
+      s.remove();
+    } catch {
+      /* already gone is fine */
+    }
+  });
+  subscriptions = [];
+  pending = null;
+  if (status === "capturing") status = "idle";
+}
+function clearTouchCapture() {
+  records = [];
+  seq = 0;
+}
+function getTouchCaptureStatus() {
+  return {
+    status,
+    reason: status === "unavailable" ? unavailableReason : null
+  };
+}
+
+/** Everything recorded after `sinceSeq`, plus where the caller now is. */
+function readTouchCapture(sinceSeq = 0) {
+  return {
+    ...getTouchCaptureStatus(),
+    records: records.filter(r => r.seq > sinceSeq),
+    seq
+  };
+}

package/lib/commonjs/sync/highlightUpdatesSyncAdapter.js

@@ -7,6 +7,7 @@ exports.highlightUpdatesSyncAdapter = void 0;
 var _HighlightUpdatesController = _interopRequireDefault(require("../highlight-updates/utils/HighlightUpdatesController"));
 var _RenderTracker = require("../highlight-updates/utils/RenderTracker");
 var _screenElements = require("../highlight-updates/utils/screenElements");
+var _touchCapture = require("../highlight-updates/utils/touchCapture");
 var _CommitProfiler = require("../highlight-updates/utils/CommitProfiler");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ensureInitialized() {
@@ -208,6 +209,27 @@ const highlightUpdatesSyncAdapter = exports.highlightUpdatesSyncAdapter = {
     // Tap an element purely in JS: resolve it (by nativeTag / testID / query),
     // find the nearest onPress up its fiber chain, and invoke it with a
     // synthetic press event. Powers the MCP `tap_element` action.
-    tapElement: params => (0, _screenElements.tapElement)(params ?? {})
+    tapElement: params => (0, _screenElements.tapElement)(params ?? {}),
+    // Block until an element is on screen (or gone), so a driver can act on a
+    // screen that has finished loading instead of the skeleton that was there
+    // when `navigate` returned. Same matcher `tapElement` ranks by.
+    waitFor: params => (0, _screenElements.waitFor)(params ?? {}),
+    // ── Touch capture: the recording half of tapElement ──────────────────
+    // Observe what a HUMAN taps, named in the same vocabulary tapElement
+    // searches by, so the Scenarios recorder can turn a real session into a
+    // replayable macro. Lives here because this tool already owns the fiber
+    // walk both halves need.
+    startTouchCapture: () => (0, _touchCapture.startTouchCapture)(),
+    stopTouchCapture: () => {
+      (0, _touchCapture.stopTouchCapture)();
+      return (0, _touchCapture.getTouchCaptureStatus)();
+    },
+    clearTouchCapture: () => {
+      (0, _touchCapture.clearTouchCapture)();
+      return {
+        ok: true
+      };
+    },
+    readTouchCapture: params => (0, _touchCapture.readTouchCapture)(params?.sinceSeq ?? 0)
   }
 };

package/lib/module/highlight-updates/components/HighlightUpdatesModal.js

@@ -17,7 +17,7 @@
 
 import React, { useState, useEffect, useRef, useCallback } from "react";
 import { View, Text, StyleSheet } from "react-native";
-import { Power, JsModal, devToolsStorageKeys, persistentStorage, night, TickProvider } from "@buoy-gg/shared-ui";
+import { Power, JsModal, devToolsStorageKeys, persistentStorage, night, TickProvider, windowDragProps } from "@buoy-gg/shared-ui";
 import { useIsPro } from "@buoy-gg/license";
 import HighlightUpdatesController from "../utils/HighlightUpdatesController";
 import { RenderTracker } from "../utils/RenderTracker";
@@ -550,6 +550,7 @@ export function HighlightUpdatesModal({
         style: styles.inlineRoot,
         children: [/*#__PURE__*/_jsx(View, {
           style: styles.inlineHeader,
+          ...windowDragProps,
           children: renderHeaderContent()
         }), body, footerNode]
       })