@buoy-gg/focus-inspector 7.0.41 → 7.0.42

package/lib/module/detect/detectors.js

@@ -1,359 +1 @@
-"use strict";
-
-/**
- * detectors — pure functions from the recorded stream to the three TV focus bug
- * classes. No timers, no RN, no fiber access, so every rule below is a unit
- * test rather than a device session.
- *
- * The honesty rule that shapes all of this: focus can only be OBSERVED from JS,
- * never computed. There is no "where would RIGHT take me" API on either
- * platform, and a JS re-implementation of Android's FocusFinder geometry would
- * lie in exactly the cases this tool exists for (guides, traps, nextFocus*
- * overrides). So geometry is only ever used to *downgrade* a flag ("that's the
- * screen edge, not a dead end") or to *suspect* one — never to assert what the
- * engine would do.
- */
-
-export const DIRECTIONS = ["up", "down", "left", "right"];
-
-/** Consecutive failed presses in one direction before it counts as a dead end. */
-export const DEAD_END_ATTEMPTS = 3;
-
-/** Presses before "unvisited" is worth reporting at all — below this it's noise. */
-export const COVERAGE_MIN_PROBES = 12;
-function keyOf(tag, direction) {
-  return `${tag}:${direction}`;
-}
-
-/**
- * A direction can legitimately move focus sometimes and not others (a rail
- * scrolls, then hits its end), so a dead end is the *trailing run* of failures,
- * not a lifetime tally. One successful move clears it.
- */
-export function detectDeadEnds(probes, nodes, minAttempts = DEAD_END_ATTEMPTS, since = 0) {
-  const trailing = new Map();
-  for (const probe of probes) {
-    if (!probe.resolved || probe.tag === null) continue;
-    if (probe.at < since) continue;
-    const key = keyOf(probe.tag, probe.direction);
-    if (probe.movedTo === null) trailing.set(key, (trailing.get(key) ?? 0) + 1);else trailing.set(key, 0);
-  }
-  const byTag = new Map();
-  for (const node of nodes) byTag.set(node.nativeTag, node);
-  const flags = [];
-  trailing.forEach((attempts, key) => {
-    if (attempts < minAttempts) return;
-    const [tagPart, directionPart] = key.split(":");
-    const tag = Number(tagPart);
-    const direction = directionPart;
-    flags.push({
-      tag,
-      direction,
-      attempts,
-      atEdge: isAtEdge(byTag.get(tag), direction, nodes)
-    });
-  });
-  return flags.sort((a, b) => b.attempts - a.attempts);
-}
-
-/**
- * "The screen ends here" — the one honest reason a direction can legitimately
- * move nothing.
- *
- * This is NOT the viewport test it started as. Abutting the bottom of the
- * WINDOW says nothing inside a ScrollView: the armed focus trap in the TV
- * example sits flush with the viewport bottom at its scroll position, so a
- * geometric edge test excused a real four-way trap as "expected". What actually
- * matters is whether the inventory knows of a focusable further along in that
- * direction — if it does, focus refusing to move is a dead end no matter where
- * the element is drawn.
- *
- * Geometry still only ever DOWNGRADES a flag here, which is the rule for the
- * whole detector layer: it never claims to know where the engine would go.
- */
-function isAtEdge(node, direction, nodes) {
-  const frame = node?.frame;
-  if (!frame) return false;
-  const centerX = frame.x + frame.width / 2;
-  const centerY = frame.y + frame.height / 2;
-  for (const other of nodes) {
-    if (other.nativeTag === node.nativeTag) continue;
-    // Guides are stops, but an invisible one is never the reason a user thinks
-    // "there is more over there" — judge the edge on real content.
-    if (other.guide) continue;
-    const otherFrame = other.frame;
-    if (!otherFrame) continue;
-    const otherX = otherFrame.x + otherFrame.width / 2;
-    const otherY = otherFrame.y + otherFrame.height / 2;
-    switch (direction) {
-      case "up":
-        if (otherY < frame.y) return false;
-        break;
-      case "down":
-        if (otherY > frame.y + frame.height) return false;
-        break;
-      case "left":
-        if (otherX < frame.x) return false;
-        break;
-      case "right":
-        if (otherX > frame.x + frame.width) return false;
-        break;
-    }
-  }
-  return true;
-}
-function unionBox(frames) {
-  if (frames.length === 0) return null;
-  let left = Infinity;
-  let top = Infinity;
-  let right = -Infinity;
-  let bottom = -Infinity;
-  for (const frame of frames) {
-    left = Math.min(left, frame.x);
-    top = Math.min(top, frame.y);
-    right = Math.max(right, frame.x + frame.width);
-    bottom = Math.max(bottom, frame.y + frame.height);
-  }
-  return {
-    x: left,
-    y: top,
-    width: right - left,
-    height: bottom - top
-  };
-}
-function isBeyond(box, point, direction) {
-  switch (direction) {
-    case "up":
-      return point.y < box.y;
-    case "down":
-      return point.y > box.y + box.height;
-    case "left":
-      return point.x < box.x;
-    case "right":
-      return point.x > box.x + box.width;
-    default:
-      return false;
-  }
-}
-
-/** Blocked in at least this many directions before "trap" is the right word. */
-const TRAP_MIN_BLOCKED = 2;
-
-/**
- * A trap is a REGION focus cannot get OUT of, which is usually not one element
- * and is not "all four directions are dead".
- *
- * Both of the obvious rules were tried against the armed trap in the TV example
- * (a row of three tiles in one `TVFocusGuideView`) and both missed it. Per
- * element: left/right move freely between the tiles, so no single tile
- * dead-ends four ways. All-four-directions on the group: the box is
- * left-aligned with everything else on the screen, so LEFT is a legitimate
- * screen edge and the union never reaches four.
- *
- * What actually defines the bug is escape: for every direction in which
- * something focusable EXISTS outside the container, focus has to have been
- * observed failing to get there. A direction with nothing beyond it is not
- * evidence either way, and a container with nothing outside it at all is the
- * whole screen, not a trap.
- */
-export function detectTraps(deadEnds, nodes) {
-  const byTag = new Map();
-  for (const node of nodes) byTag.set(node.nativeTag, node);
-  const groups = new Map();
-  for (const flag of deadEnds) {
-    const node = byTag.get(flag.tag);
-    const containerTag = node?.guideAncestorTag ?? flag.tag;
-    const group = groups.get(containerTag) ?? {
-      containerTag,
-      tags: new Set(),
-      directions: new Set()
-    };
-    group.tags.add(flag.tag);
-    group.directions.add(flag.direction);
-    groups.set(containerTag, group);
-  }
-  const traps = [];
-  groups.forEach(group => {
-    if (group.directions.size < TRAP_MIN_BLOCKED) return;
-
-    // Everything the container holds, not just the elements we have evidence
-    // about — the box focus is stuck inside is the container's, not the probes'.
-    const members = new Set(group.tags);
-    for (const node of nodes) {
-      if (node.guideAncestorTag === group.containerTag) members.add(node.nativeTag);
-    }
-    members.add(group.containerTag);
-    const container = byTag.get(group.containerTag);
-    const box = container?.guide && container.frame ? container.frame : unionBox(Array.from(members).map(tag => byTag.get(tag)?.frame).filter(frame => !!frame));
-    if (!box) return;
-    let escapable = 0;
-    let reachableOutside = 0;
-    for (const direction of DIRECTIONS) {
-      const hasOutside = nodes.some(node => {
-        if (node.guide || members.has(node.nativeTag) || !node.frame) return false;
-        const center = {
-          x: node.frame.x + node.frame.width / 2,
-          y: node.frame.y + node.frame.height / 2
-        };
-        return isBeyond(box, center, direction);
-      });
-      if (!hasOutside) continue;
-      reachableOutside += 1;
-      if (!group.directions.has(direction)) escapable += 1;
-    }
-    // Nothing outside at all means the container IS the screen.
-    if (reachableOutside === 0 || escapable > 0) return;
-    const guide = container?.guide;
-    const trapped = guide !== undefined && (guide.trap.up || guide.trap.down || guide.trap.left || guide.trap.right);
-    traps.push({
-      tags: Array.from(group.tags).sort((a, b) => a - b),
-      containerTag: group.containerTag,
-      directions: DIRECTIONS.filter(d => group.directions.has(d)),
-      guideTrapTag: trapped ? group.containerTag : undefined
-    });
-  });
-  return traps;
-}
-
-/**
- * Focus that parked somewhere with no visible highlight — the "focus vanished"
- * symptom. Two shapes: it landed on a TVFocusGuideView (a real focus stop the
- * user cannot see), or on a tag the inventory has never heard of (a view
- * outside the walked tree, or one that unmounted since the last scan).
- */
-export function detectInvisibleStops(transitions, nodes, since = 0) {
-  const byTag = new Map();
-  for (const node of nodes) byTag.set(node.nativeTag, node);
-  const flags = new Map();
-  for (const transition of transitions) {
-    const tag = transition.toTag;
-    if (tag === null) continue;
-    // A move made before the current scan cannot be judged against the current
-    // inventory: after any navigation EVERY tag from the old screen looks like
-    // a mystery stop, which buried the real flags under a wall of noise on the
-    // first device run. Focus flags are per-screen, and `since` is that screen.
-    if (transition.at < since) continue;
-    const node = byTag.get(tag);
-    const reason = !node ?
-    // Nothing in the inventory: only meaningful once a scan has run at all,
-    // otherwise every transition would be "invisible".
-    nodes.length > 0 ? "unknown" : null : node.guide ? "guide" : null;
-    if (!reason) continue;
-    const existing = flags.get(tag);
-    if (existing) {
-      existing.count += 1;
-      existing.at = transition.at;
-    } else {
-      flags.set(tag, {
-        tag,
-        reason,
-        at: transition.at,
-        count: 1
-      });
-    }
-  }
-  return Array.from(flags.values()).sort((a, b) => b.at - a.at);
-}
-
-/**
- * `since` is the timestamp of the inventory these flags are judged against —
- * normally the last scan. Everything older belonged to a screen that no longer
- * exists, and judging it here produces confident nonsense.
- */
-export function detectFlags(transitions, probes, nodes, lostCount, since = 0) {
-  const deadEnds = detectDeadEnds(probes, nodes, DEAD_END_ATTEMPTS, since);
-  return {
-    deadEnds,
-    traps: detectTraps(deadEnds, nodes),
-    invisibleStops: detectInvisibleStops(transitions, nodes, since),
-    lostCount
-  };
-}
-
-/**
- * Coverage. Observed absence is EVIDENCE, not proof: focus is nondeterministic
- * enough on tvOS that "never visited" cannot be promoted to "unreachable"
- * without native support that does not exist. So the strong word is reserved
- * for the case where geometry AND the observed graph agree.
- */
-export function computeCoverage(nodes, visited, transitions, probes) {
-  const visitedSet = new Set(visited);
-  // Guides are counted as focusables (they really are stops), but an unvisited
-  // guide is not a bug — it is the normal case for one that only redirects.
-  const reachableCandidates = nodes.filter(node => !node.guide);
-  const unvisited = reachableCandidates.filter(node => !visitedSet.has(node.nativeTag)).map(node => node.nativeTag);
-  const meaningful = probes.length >= COVERAGE_MIN_PROBES;
-  const edgeTargets = new Set();
-  for (const transition of transitions) {
-    if (transition.toTag !== null) edgeTargets.add(transition.toTag);
-  }
-  const byTag = new Map();
-  for (const node of nodes) byTag.set(node.nativeTag, node);
-  const suspectedUnreachable = meaningful ? unvisited.filter(tag => {
-    if (edgeTargets.has(tag)) return false;
-    const node = byTag.get(tag);
-    if (!node?.frame) return false;
-    // A visited neighbour sitting right next to it means the traversal DID
-    // pass by — so focus skipping it is worth suspecting.
-    return reachableCandidates.some(other => other.nativeTag !== tag && visitedSet.has(other.nativeTag) && isAdjacent(node, other));
-  }) : [];
-  return {
-    focusables: reachableCandidates.length,
-    visited: reachableCandidates.filter(node => visitedSet.has(node.nativeTag)).length,
-    unvisited,
-    suspectedUnreachable,
-    meaningful
-  };
-}
-
-/** Normalized-frame gap within which two elements are plausibly D-pad neighbours. */
-const ADJACENCY_GAP = 0.12;
-function isAdjacent(a, b) {
-  const fa = a.frame;
-  const fb = b.frame;
-  if (!fa || !fb) return false;
-  const horizontalOverlap = fa.x < fb.x + fb.width && fb.x < fa.x + fa.width;
-  const verticalOverlap = fa.y < fb.y + fb.height && fb.y < fa.y + fa.height;
-  if (horizontalOverlap) {
-    const gap = Math.max(fa.y - (fb.y + fb.height), fb.y - (fa.y + fa.height));
-    if (gap <= ADJACENCY_GAP) return true;
-  }
-  if (verticalOverlap) {
-    const gap = Math.max(fa.x - (fb.x + fb.width), fb.x - (fa.x + fa.width));
-    if (gap <= ADJACENCY_GAP) return true;
-  }
-  return false;
-}
-
-/**
- * The observed out-edges of one element — what the desktop's D-pad compass
- * renders. A direction with no entry is UNKNOWN (dim), which is a different
- * statement from a dead end (pressed, went nowhere).
- */
-export function observedEdges(tag, transitions, probes = []) {
-  // A press that moved nothing leaves a probe but no transition. Without the
-  // probes, a direction that was pressed three times and went nowhere still
-  // read "unknown" while the dead-end flag below it said the opposite.
-  const seen = [];
-  for (const transition of transitions) {
-    if (transition.fromTag !== tag || transition.direction === null) continue;
-    seen.push({
-      at: transition.at,
-      direction: transition.direction,
-      to: transition.toTag
-    });
-  }
-  for (const probe of probes) {
-    if (probe.tag !== tag || !probe.resolved || probe.movedTo !== null) continue;
-    seen.push({
-      at: probe.at,
-      direction: probe.direction,
-      to: null
-    });
-  }
-  seen.sort((a, b) => a.at - b.at);
-  const edges = {};
-  for (const observation of seen) edges[observation.direction] = observation.to;
-  return edges;
-}
-//# sourceMappingURL=detectors.js.map
+"use strict";export const DIRECTIONS=["up","down","left","right"];export const DEAD_END_ATTEMPTS=3;export const COVERAGE_MIN_PROBES=12;function y(r,i){return`${r}:${i}`}export function detectDeadEnds(r,i,n=DEAD_END_ATTEMPTS,e=0){const s=new Map;for(const a of r){if(!a.resolved||a.tag===null)continue;if(a.at<e)continue;const f=y(a.tag,a.direction);if(a.movedTo===null)s.set(f,(s.get(f)??0)+1);else s.set(f,0)}const t=new Map;for(const a of i)t.set(a.nativeTag,a);const o=[];s.forEach((a,f)=>{if(a<n)return;const[g,h]=f.split(":");const c=Number(g);const d=h;o.push({tag:c,direction:d,attempts:a,atEdge:x(t.get(c),d,i)})});return o.sort((a,f)=>f.attempts-a.attempts)}function x(r,i,n){const e=r?.frame;if(!e)return false;const s=e.x+e.width/2;const t=e.y+e.height/2;for(const o of n){if(o.nativeTag===r.nativeTag)continue;if(o.guide)continue;const a=o.frame;if(!a)continue;const f=a.x+a.width/2;const g=a.y+a.height/2;switch(i){case"up":if(g<e.y)return false;break;case"down":if(g>e.y+e.height)return false;break;case"left":if(f<e.x)return false;break;case"right":if(f>e.x+e.width)return false;break}}return true}function w(r){if(r.length===0)return null;let i=Infinity;let n=Infinity;let e=-Infinity;let s=-Infinity;for(const t of r){i=Math.min(i,t.x);n=Math.min(n,t.y);e=Math.max(e,t.x+t.width);s=Math.max(s,t.y+t.height)}return{x:i,y:n,width:e-i,height:s-n}}function v(r,i,n){switch(n){case"up":return i.y<r.y;case"down":return i.y>r.y+r.height;case"left":return i.x<r.x;case"right":return i.x>r.x+r.width;default:return false}}const b=2;export function detectTraps(r,i){const n=new Map;for(const t of i)n.set(t.nativeTag,t);const e=new Map;for(const t of r){const o=n.get(t.tag);const a=o?.guideAncestorTag??t.tag;const f=e.get(a)??{containerTag:a,tags:new Set,directions:new Set};f.tags.add(t.tag);f.directions.add(t.direction);e.set(a,f)}const s=[];e.forEach(t=>{if(t.directions.size<b)return;const o=new Set(t.tags);for(const u of i){if(u.guideAncestorTag===t.containerTag)o.add(u.nativeTag)}o.add(t.containerTag);const a=n.get(t.containerTag);const f=a?.guide&&a.frame?a.frame:w(Array.from(o).map(u=>n.get(u)?.frame).filter(u=>!!u));if(!f)return;let g=0;let h=0;for(const u of DIRECTIONS){const T=i.some(l=>{if(l.guide||o.has(l.nativeTag)||!l.frame)return false;const m={x:l.frame.x+l.frame.width/2,y:l.frame.y+l.frame.height/2};return v(f,m,u)});if(!T)continue;h+=1;if(!t.directions.has(u))g+=1}if(h===0||g>0)return;const c=a?.guide;const d=c!==void 0&&(c.trap.up||c.trap.down||c.trap.left||c.trap.right);s.push({tags:Array.from(t.tags).sort((u,T)=>u-T),containerTag:t.containerTag,directions:DIRECTIONS.filter(u=>t.directions.has(u)),guideTrapTag:d?t.containerTag:void 0})});return s}export function detectInvisibleStops(r,i,n=0){const e=new Map;for(const t of i)e.set(t.nativeTag,t);const s=new Map;for(const t of r){const o=t.toTag;if(o===null)continue;if(t.at<n)continue;const a=e.get(o);const f=!a?i.length>0?"unknown":null:a.guide?"guide":null;if(!f)continue;const g=s.get(o);if(g){g.count+=1;g.at=t.at}else{s.set(o,{tag:o,reason:f,at:t.at,count:1})}}return Array.from(s.values()).sort((t,o)=>o.at-t.at)}export function detectFlags(r,i,n,e,s=0){const t=detectDeadEnds(i,n,DEAD_END_ATTEMPTS,s);return{deadEnds:t,traps:detectTraps(t,n),invisibleStops:detectInvisibleStops(r,n,s),lostCount:e}}export function computeCoverage(r,i,n,e){const s=new Set(i);const t=r.filter(c=>!c.guide);const o=t.filter(c=>!s.has(c.nativeTag)).map(c=>c.nativeTag);const a=e.length>=COVERAGE_MIN_PROBES;const f=new Set;for(const c of n){if(c.toTag!==null)f.add(c.toTag)}const g=new Map;for(const c of r)g.set(c.nativeTag,c);const h=a?o.filter(c=>{if(f.has(c))return false;const d=g.get(c);if(!d?.frame)return false;return t.some(u=>u.nativeTag!==c&&s.has(u.nativeTag)&&E(d,u))}):[];return{focusables:t.length,visited:t.filter(c=>s.has(c.nativeTag)).length,unvisited:o,suspectedUnreachable:h,meaningful:a}}const p=.12;function E(r,i){const n=r.frame;const e=i.frame;if(!n||!e)return false;const s=n.x<e.x+e.width&&e.x<n.x+n.width;const t=n.y<e.y+e.height&&e.y<n.y+n.height;if(s){const o=Math.max(n.y-(e.y+e.height),e.y-(n.y+n.height));if(o<=p)return true}if(t){const o=Math.max(n.x-(e.x+e.width),e.x-(n.x+n.width));if(o<=p)return true}return false}export function observedEdges(r,i,n=[]){const e=[];for(const t of i){if(t.fromTag!==r||t.direction===null)continue;e.push({at:t.at,direction:t.direction,to:t.toTag})}for(const t of n){if(t.tag!==r||!t.resolved||t.movedTo!==null)continue;e.push({at:t.at,direction:t.direction,to:null})}e.sort((t,o)=>t.at-o.at);const s={};for(const t of e)s[t.direction]=t.to;return s}

package/lib/module/index.js

@@ -1,36 +1 @@
-"use strict";
-
-/**
- * @buoy-gg/focus-inspector
- *
- * TV focus debugging for React Native TV apps, from Buoy Desktop: what holds
- * D-pad focus right now, every focus transition with the direction that caused
- * it, the inventory of focusable elements, and automatic flags for the three
- * big TV focus bug classes — focus gets STUCK (dead end / trap), focus
- * DISAPPEARS (parks on an invisible stop or leaves the RN tree), and an element
- * is never REACHED.
- *
- * This package renders NOTHING on the device, and that is a hard constraint
- * rather than a preference: on Android TV any focusable view in an overlay
- * becomes a D-pad stop in the host app's focus order, so an on-device panel
- * would change the navigation it is measuring. See the README.
- *
- * It also ships no native code — the focus stream comes from a JS-only global
- * observer (`RawEventEmitter`'s `topFocus`/`topBlur`), which is why Buoy stays
- * podspec-free.
- */
-
-// =============================================================================
-// EXTERNAL SYNC (device → desktop dashboard)
-// =============================================================================
-export { focusInspectorSyncAdapter } from "./sync/focusInspectorSyncAdapter";
-// =============================================================================
-// STORE (the recorded stream + its types)
-// =============================================================================
-export { clearHistory, getState, recordBlur, recordFocus, recordKey, resetStore, setTracking, subscribe } from "./store/focusStore";
-// =============================================================================
-// SCAN + DETECT (exported so the desktop panel shares one set of types)
-// =============================================================================
-export { scanFocusables } from "./scan/focusableScanner";
-export { computeCoverage, detectDeadEnds, detectFlags, detectInvisibleStops, detectTraps, observedEdges } from "./detect/detectors";
-//# sourceMappingURL=index.js.map
+"use strict";export{focusInspectorSyncAdapter}from"./sync/focusInspectorSyncAdapter";export{clearHistory,getState,recordBlur,recordFocus,recordKey,resetStore,setTracking,subscribe}from"./store/focusStore";export{scanFocusables}from"./scan/focusableScanner";export{computeCoverage,detectDeadEnds,detectFlags,detectInvisibleStops,detectTraps,observedEdges}from"./detect/detectors";

package/lib/module/observe/focusEventObserver.js

@@ -1,99 +1 @@
-"use strict";
-
-/**
- * focusEventObserver — the global, zero-instrumentation focus source.
- *
- * `react-native/Libraries/Core/RawEventEmitter` mirrors every Fabric-dispatched
- * event BEFORE React's plugins or components see it, and on both tvOS and
- * Android TV every focus change arrives there as `topFocus` / `topBlur` with
- * the focused view's native tag. Its own source comment blesses exactly this
- * use ("app-specific perf monitoring … and maybe debugging").
- *
- * Why not the obvious alternatives:
- * - `onFocus`/`onBlur` props would require instrumenting the app's components,
- *   and would MISS the interesting cases: focus really does park on views with
- *   no handler (a TVFocusGuideView with `destinations` is an invisible focus
- *   stop). A per-component observer reports "focus is nowhere" for the exact
- *   bug this tool exists to catch.
- * - `TVEventHandler`'s `focus`/`blur` HWEvents are deprecated and 0.85 deleted
- *   the Fabric calls that emitted them (fork issue #1037). They still fire on
- *   the 0.83 line, so they're folded in as optional enrichment below — never
- *   required, or the tool would work on one app and not the other.
- * - There is no root-level capture View to wrap the app in: Buoy mounts as a
- *   SIBLING of the app tree, not a parent.
- *
- * The deep import is guarded. If it ever moves, the snapshot degrades to
- * `observer: "unavailable"` and the panel says so, rather than the tool taking
- * the app's bundle down.
- */
-
-import { recordBlur, recordFocus } from "../store/focusStore";
-import { resolveRawEventEmitter } from "./rawEventEmitter";
-let emitter = null;
-let emitterResolved = false;
-let subscriptions = [];
-let status = "idle";
-let unavailableReason = null;
-function getEmitter() {
-  if (emitterResolved) return emitter;
-  emitterResolved = true;
-  const resolution = resolveRawEventEmitter();
-  emitter = resolution.emitter;
-  unavailableReason = resolution.reason;
-  return emitter;
-}
-
-/**
- * Pull the native tag out of a raw event. Fabric puts it on `nativeEvent.target`
- * on both platforms (probe-verified); `nativeEvent.tag` is the older shape and
- * costs nothing to accept.
- */
-function tagOf(event) {
-  const native = event?.nativeEvent;
-  if (!native) return null;
-  const target = native.target ?? native.tag;
-  return typeof target === "number" && Number.isFinite(target) ? target : null;
-}
-export function attachFocusObserver() {
-  if (subscriptions.length > 0) return;
-  const raw = getEmitter();
-  if (!raw) {
-    status = "unavailable";
-    return;
-  }
-  try {
-    // Two named listeners rather than the `*` wildcard channel: the wildcard
-    // exists, but its payload contract was never runtime-verified, and named
-    // channels sidestep the question entirely.
-    subscriptions = [raw.addListener("topFocus", event => {
-      const tag = tagOf(event);
-      if (tag !== null) recordFocus(tag);
-    }), raw.addListener("topBlur", event => {
-      const tag = tagOf(event);
-      if (tag !== null) recordBlur(tag);
-    })];
-    status = "listening";
-  } catch (e) {
-    subscriptions = [];
-    status = "unavailable";
-    unavailableReason = e?.message ?? "addListener failed";
-  }
-}
-export function detachFocusObserver() {
-  subscriptions.forEach(subscription => {
-    try {
-      subscription.remove();
-    } catch {
-      /* a listener that's already gone is fine */
-    }
-  });
-  subscriptions = [];
-  if (status === "listening") status = "idle";
-}
-export function getFocusObserverStatus() {
-  return {
-    status,
-    reason: status === "unavailable" ? unavailableReason : null
-  };
-}
-//# sourceMappingURL=focusEventObserver.js.map
+"use strict";import{recordBlur as s,recordFocus as c}from"../store/focusStore";import{resolveRawEventEmitter as f}from"./rawEventEmitter";let a=null;let o=false;let i=[];let n="idle";let l=null;function v(){if(o)return a;o=true;const t=f();a=t.emitter;l=t.reason;return a}function u(t){const e=t?.nativeEvent;if(!e)return null;const r=e.target??e.tag;return typeof r==="number"&&Number.isFinite(r)?r:null}export function attachFocusObserver(){if(i.length>0)return;const t=v();if(!t){n="unavailable";return}try{i=[t.addListener("topFocus",e=>{const r=u(e);if(r!==null)c(r)}),t.addListener("topBlur",e=>{const r=u(e);if(r!==null)s(r)})];n="listening"}catch(e){i=[];n="unavailable";l=e?.message??"addListener failed"}}export function detachFocusObserver(){i.forEach(t=>{try{t.remove()}catch{}});i=[];if(n==="listening")n="idle"}export function getFocusObserverStatus(){return{status:n,reason:n==="unavailable"?l:null}}

package/lib/module/observe/keyEventObserver.js

@@ -1,86 +1 @@
-"use strict";
-
-/**
- * keyEventObserver — the direction half of the stream.
- *
- * D-pad HWEvents carry NO tag on either platform (an Android payload is exactly
- * `{"eventKeyAction":1,"eventType":"right"}`), and focus events carry no
- * direction. So key events tell you *which way the user pushed* and focus
- * events tell you *where focus went*; the store joins them on time.
- *
- * `TVEventHandler.addListener` (not the `useTVEventHandler` hook) because sync
- * adapters are not React components — nothing here mounts.
- *
- * On the 0.83 fork line iOS Fabric ALSO still emits tagged `focus`/`blur`
- * HWEvents here. Those are folded into the same store as enrichment so the
- * older line gets a focus source even if the RawEventEmitter path ever fails —
- * never depended on, because 0.85 deleted them.
- */
-
-import * as ReactNative from "react-native";
-import { recordBlur, recordFocus, recordKey } from "../store/focusStore";
-/**
- * `TVEventHandler` only exists on the react-native-tvos fork. A namespace read
- * (rather than a named import) keeps this module importable on stock RN.
- */
-const RN = ReactNative;
-export const isTV = RN.Platform?.isTV === true;
-export const platformOS = RN.Platform?.OS ?? "unknown";
-
-/**
- * Long-press variants move focus the same way a tap does, so they map to the
- * same direction. Everything else (select, menu, playPause, pans, swipes) never
- * moves focus and is dropped rather than logged as a probe that can't resolve.
- */
-const DIRECTION_BY_EVENT_TYPE = {
-  up: "up",
-  down: "down",
-  left: "left",
-  right: "right",
-  longUp: "up",
-  longDown: "down",
-  longLeft: "left",
-  longRight: "right"
-};
-let subscription = null;
-function handleEvent(raw) {
-  const event = raw;
-  const eventType = event?.eventType;
-  if (typeof eventType !== "string") return;
-
-  /**
-   * Dedupe by ignoring key DOWN, never key UP. tvOS emits keyAction 1 (up)
-   * ONLY for button presses — filtering to "down" would swallow every tvOS
-   * event — while Android's key-down dispatch sits behind a feature flag that
-   * is off by default. One press must open exactly one probe.
-   */
-  if (event?.eventKeyAction === 0) return;
-
-  // 0.83-line iOS bonus: tagged focus/blur HWEvents. Guarded on the tag being
-  // present so 0.85's tag-less variants (if any ever return) can't record a
-  // transition to nowhere.
-  if (eventType === "focus" || eventType === "blur") {
-    if (typeof event?.tag !== "number") return;
-    if (eventType === "focus") recordFocus(event.tag);else recordBlur(event.tag);
-    return;
-  }
-  const direction = DIRECTION_BY_EVENT_TYPE[eventType];
-  if (direction) recordKey(direction);
-}
-export function attachKeyObserver() {
-  if (subscription || !isTV || !RN.TVEventHandler) return;
-  subscription = RN.TVEventHandler.addListener(handleEvent);
-}
-export function detachKeyObserver() {
-  if (!subscription) return;
-  try {
-    subscription.remove();
-  } catch {
-    /* already gone */
-  }
-  subscription = null;
-}
-export function isKeyObserverListening() {
-  return subscription !== null;
-}
-//# sourceMappingURL=keyEventObserver.js.map
+"use strict";import*as u from"react-native";import{recordBlur as c,recordFocus as f,recordKey as s}from"../store/focusStore";const r=u;export const isTV=r.Platform?.isTV===true;export const platformOS=r.Platform?.OS??"unknown";const l={up:"up",down:"down",left:"left",right:"right",longUp:"up",longDown:"down",longLeft:"left",longRight:"right"};let t=null;function a(i){const e=i;const n=e?.eventType;if(typeof n!=="string")return;if(e?.eventKeyAction===0)return;if(n==="focus"||n==="blur"){if(typeof e?.tag!=="number")return;if(n==="focus")f(e.tag);else c(e.tag);return}const o=l[n];if(o)s(o)}export function attachKeyObserver(){if(t||!isTV||!r.TVEventHandler)return;t=r.TVEventHandler.addListener(a)}export function detachKeyObserver(){if(!t)return;try{t.remove()}catch{}t=null}export function isKeyObserverListening(){return t!==null}

package/lib/module/observe/keyEventObserver.web.js

@@ -1,30 +1 @@
-"use strict";
-
-import { recordKey } from '../store/focusStore';
-export const isTV = false;
-export const platformOS = 'web';
-let listening = false;
-const directions = {
-  ArrowUp: 'up',
-  ArrowDown: 'down',
-  ArrowLeft: 'left',
-  ArrowRight: 'right'
-};
-function key(event) {
-  const direction = directions[event.key];
-  if (direction) recordKey(direction);
-}
-export function attachKeyObserver() {
-  if (listening || typeof document === 'undefined') return;
-  listening = true;
-  document.addEventListener('keydown', key, true);
-}
-export function detachKeyObserver() {
-  if (!listening) return;
-  listening = false;
-  document.removeEventListener('keydown', key, true);
-}
-export function isKeyObserverListening() {
-  return listening;
-}
-//# sourceMappingURL=keyEventObserver.web.js.map
+"use strict";import{recordKey as o}from"../store/focusStore";export const isTV=false;export const platformOS="web";let e=false;const i={ArrowUp:"up",ArrowDown:"down",ArrowLeft:"left",ArrowRight:"right"};function r(n){const t=i[n.key];if(t)o(t)}export function attachKeyObserver(){if(e||typeof document==="undefined")return;e=true;document.addEventListener("keydown",r,true)}export function detachKeyObserver(){if(!e)return;e=false;document.removeEventListener("keydown",r,true)}export function isKeyObserverListening(){return e}

package/lib/module/observe/rawEventEmitter.js

@@ -1,40 +1 @@
-"use strict";
-
-/**
- * The one guarded require for React Native's RawEventEmitter, kept in its own
- * module for two reasons.
- *
- * 1. `react-native/Libraries/Core/RawEventEmitter` is a DEEP import. It warns
- *    under 0.85's export map and could move in any release, so the failure has
- *    to degrade to "observer unavailable" in the snapshot rather than taking
- *    the host app's bundle down. Metro only treats a require as optional when
- *    it sits LEXICALLY inside a try statement — wrapping it in a helper or an
- *    arrow makes Metro hard-fail the bundle instead.
- * 2. It gives the unit suite a seam. Node's `require` resolves through the
- *    filesystem and ignores Vitest's module mocks, so the emitter can only be
- *    faked by mocking a module that is reached with a real `import`.
- */
-
-export 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
-  };
-}
-//# sourceMappingURL=rawEventEmitter.js.map
+"use strict";export function resolveRawEventEmitter(){let e;try{e=require("react-native/Libraries/Core/RawEventEmitter")}catch(r){return{emitter:null,reason:r?.message??"RawEventEmitter is unavailable"}}const t=e?.default??e;if(typeof t?.addListener!=="function"){return{emitter:null,reason:"RawEventEmitter has no addListener"}}return{emitter:t,reason:null}}

package/lib/module/observe/rawEventEmitter.web.js

@@ -1,4 +1 @@
-"use strict";
-
-export { resolveDOMEventEmitter as resolveRawEventEmitter } from '@buoy-gg/shared-ui/utils';
-//# sourceMappingURL=rawEventEmitter.web.js.map
+"use strict";export{resolveDOMEventEmitter as resolveRawEventEmitter}from"@buoy-gg/shared-ui/utils";