execbro 2.3.0 → 2.6.0

package/build/core/screenState.js

@@ -2,9 +2,6 @@ import { executeInApp, delay } from "./jsExecute.js";
 import { iconSemanticHint } from "./iconSemantics.js";
 import { VISIBILITY_HELPERS_JS, detectNativeSheet, NATIVE_SHEET_MARKER_RE_SRC } from "./injected/visibility.js";
 import { RN_PRIMITIVES_SRC, GENERIC_COMPONENT_SRC } from "./injectedFilters.js";
-// ============================================================================
-// Pure helpers (exported for unit tests)
-// ============================================================================
 export function markPressablesCoveredByOverlay(pressables, overlayBounds) {
     for (const p of pressables) {
         const b = p.bounds;
@@ -17,18 +14,7 @@ export function markPressablesCoveredByOverlay(pressables, overlayBounds) {
     }
     return pressables;
 }
-/** A count badge such as "1" or "99+" — the only "label" an icon button like a cart carries. */
 const COUNT_BADGE_LABEL = /^\d{1,3}\+?$/;
-/**
- * Replace component-name fallback labels with semantic icon labels when the
- * pressable's icon child name carries recognizable semantics:
- *   { label: "[FloatingHeader]", icon: "SvgChevronBackward" }
- *     → label "[SvgChevronBackward — possibly back button]"
- * An icon button whose only text is a count badge (cart with "1") keeps that
- * count as nearby context while the label is upgraded to the icon's meaning:
- *   { label: "1", icon: "SvgCartNew" } → label "[SvgCartNew — possibly cart button]", nearbyText "1"
- * Labels from text/a11y are never touched (icon is null for those).
- */
 export function applyIconHintToLabel(p) {
     if (!p.icon)
         return p;
@@ -45,20 +31,17 @@ export function applyIconHintToLabel(p) {
     return p;
 }
 const identityCoords = (item) => ({ center: item.center, frame: item.bounds });
-/** Stand-in when no keyboard state was read: nothing is blocked. */
 const NO_KEYBOARD = { visible: false, height: null, screenY: null, width: null };
 const TEXT_DISPLAY_MAX = 80;
 const IMAGE_SRC_DISPLAY_MAX = 60;
 function truncate(s, max) {
     return s.length > max ? s.slice(0, max) + "…" : s;
 }
-/** One merged-list line for a static text node — coordinates match pressable lines. */
 export function formatTextEntry(t, convert = identityCoords, opts = {}) {
     const { center, frame } = convert(t);
     const body = opts.fullText ? t.text : truncate(t.text, TEXT_DISPLAY_MAX);
     return `  (${center.x}, ${center.y}) 📝 "${body}" frame:(${frame.x},${frame.y} ${frame.width}x${frame.height})`;
 }
-/** One merged-list line for an image node — coordinates match pressable lines. */
 export function formatImageEntry(img, convert = identityCoords) {
     const { center, frame } = convert(img);
     const src = img.src ? ` src="${truncate(img.src, IMAGE_SRC_DISPLAY_MAX)}"` : "";
@@ -67,44 +50,17 @@ export function formatImageEntry(img, convert = identityCoords) {
 }
 const TEXT_CAP = 60;
 const IMAGE_CAP = 40;
-/**
- * Render a ScreenState as the orientation summary used by get_screen_state and the
- * screenshot tools. By default it merges pressables, static text (📝), and images
- * (🖼) into one spatially-ordered list per reachability group — enough to read and
- * navigate the screen without a screenshot:
- *   📍 Detail  [Detail]
- *   🎯 Pressables:
- *     (210, 175) 🖼 Image 420x350 src="…"
- *     (146, 394) 📝 "Valya product" frame:(20,382 251x24)
- *     (210, 838) <Button /> "In cart" frame:(20,810 380x56)
- * pressablesOnly restores the lean pressable-only snapshot; fullText disables the
- * 80-char text truncation.
- */
-/**
- * One line describing the keyboard, or "" when it is down and known to be.
- *
- * The point is layout validation: a raised keyboard shrinks the usable area,
- * and that is exactly when bottom-anchored UI misbehaves. Reporting the height
- * and the remaining content area makes that inspectable without a screenshot.
- */
-export function formatKeyboardLine(k) {
+export function formatKeyboardLine(k, pixelScale = 1) {
     if (k.error)
         return `⌨️ Keyboard: unknown (${k.error})`;
     if (!k.visible || k.height == null || k.screenY == null)
         return "";
-    // Android reports fractional dp (288.3809509277344); whole points are what
-    // a reader can act on, and the sub-pixel tail only obscures the number.
-    const r = (n) => Math.round(n);
+    const s = pixelScale > 0 ? pixelScale : 1;
+    const r = (n) => Math.round(n * s);
+    const unit = s === 1 ? "pt" : "px";
     const width = k.width != null ? `${r(k.width)}x` : "";
-    return `⌨️ Keyboard: visible, ${r(k.height)}pt — content area above it ${width}${r(k.screenY)}pt`;
+    return `⌨️ Keyboard: visible, ${r(k.height)}${unit} — content area above it ${width}${r(k.screenY)}${unit}`;
 }
-/**
- * Splits elements the keyboard covers from those still reachable.
- *
- * Mirrors the existing overlay handling rather than inventing a second notion
- * of "blocked": an element under the keyboard cannot be tapped, for the same
- * reason and with the same consequence as one under a sheet.
- */
 export function partitionByKeyboard(items, k) {
     if (!k.visible || k.screenY == null)
         return { reachable: items, blocked: [] };
@@ -115,18 +71,11 @@ export function partitionByKeyboard(items, k) {
     }
     return { reachable, blocked };
 }
-/**
- * Renders an input's state so the value is unmistakably the value and the
- * placeholder is unmistakably a placeholder. Returns "" for non-inputs.
- */
 export function formatInputState(p) {
     if (!p.isInput)
         return "";
     if (p.inputValue)
         return ` [input] value:${JSON.stringify(p.inputValue)}`;
-    // inputValue/inputPlaceholder are absent on entries captured before this
-    // field existed (or by other producers); fall back to the bare marker
-    // rather than asserting the field is empty.
     if (p.inputValue === undefined && p.inputPlaceholder === undefined)
         return " [input]";
     return p.inputPlaceholder
@@ -146,7 +95,7 @@ export function formatScreenStateSummary(ss, convert = identityCoords, opts = {}
         lines.push("📍 Currently focused screen: unknown (no React Navigation / Expo Router detected)");
     }
     if (opts.keyboard) {
-        const kbLine = formatKeyboardLine(opts.keyboard);
+        const kbLine = formatKeyboardLine(opts.keyboard, opts.pixelScale);
         if (kbLine)
             lines.push(kbLine);
     }
@@ -161,17 +110,12 @@ export function formatScreenStateSummary(ss, convert = identityCoords, opts = {}
     }
     const formatPressable = (p) => {
         const { center, frame } = convert(p);
-        // 🔘 marks tap targets in the enriched view (where 📝 text / 🖼 images also
-        // appear); omitted under pressablesOnly to keep the lean legacy lines.
         const marker = opts.pressablesOnly ? "" : " 🔘";
         return `  (${center.x}, ${center.y})${marker}${p.component ? ` <${p.component} />` : ""} ${p.label ? `"${p.label}"` : "(unlabeled)"}` +
             `${p.nearbyText ? ` near "${p.nearbyText}"` : ""}${p.onPressHint ? ` ${p.onPressHint}` : ""}` +
             `${p.testID ? ` testID="${p.testID}"` : ""}${formatInputState(p)}` +
             ` frame:(${frame.x},${frame.y} ${frame.width}x${frame.height})`;
     };
-    // Merge pressables + (unless pressablesOnly) texts + images for one reachability
-    // group, sorted spatially (top→bottom, then left→right). A text duplicating a
-    // pressable's nearbyText is dropped; texts/images cap with an explicit marker.
     const renderGroup = (pressables, texts, images) => {
         const out = [];
         const nearby = new Set(pressables.map((p) => (p.nearbyText || "").trim()).filter(Boolean));
@@ -195,9 +139,6 @@ export function formatScreenStateSummary(ss, convert = identityCoords, opts = {}
         }
         return out;
     };
-    // A native sheet has no entry in ss.overlays (it's not in the fiber-measured tree), but
-    // it flags the underlying pressables blockedByOverlay — so take the split reachable/blocked
-    // path even when overlays is empty, so those flags surface in the summary.
     if (ss.overlays.length > 0 || ss.nativeOverlay) {
         for (const overlay of ss.overlays) {
             lines.push(`\n🔲 ${overlay.type}${overlay.title ? ` — "${overlay.title}"` : ""}:`);
@@ -227,8 +168,6 @@ export function formatScreenStateSummary(ss, convert = identityCoords, opts = {}
         }
     }
     else {
-        // A raised keyboard blocks taps exactly as an overlay does, so it gets
-        // the same treatment rather than a second notion of "blocked".
         const kb = opts.keyboard;
         const splitP = partitionByKeyboard(ss.pressables, kb ?? NO_KEYBOARD);
         const splitT = partitionByKeyboard(ss.texts, kb ?? NO_KEYBOARD);
@@ -246,14 +185,6 @@ export function formatScreenStateSummary(ss, convert = identityCoords, opts = {}
     }
     return lines.join("\n");
 }
-/**
- * Turn raw onPress handler info ({ n: fn.name, s: source head }) into a
- * displayable hint, or null when nothing meaningful survives:
- * - real names ("handleSubmit", "bound goBack") → "handleSubmit()" / "goBack()"
- * - generic/minified names ("onPress", "anonymous", "t12") are rejected
- * - anonymous with retained source → "{() => setAccepted(prev => !prev)…}"
- * - Hermes bytecode bundles (source = "[bytecode]", stripped in-app) → null
- */
 const GENERIC_HANDLER_NAMES = new Set(["", "anonymous", "onpress", "onclick", "handler", "callback", "fn", "press", "value"]);
 function meaningfulHandlerName(n) {
     let name = (n || "").trim();
@@ -262,7 +193,7 @@ function meaningfulHandlerName(n) {
     if (!name || GENERIC_HANDLER_NAMES.has(name.toLowerCase()))
         return null;
     if (/^[a-zA-Z_$]\d{1,4}$/.test(name) || name.length === 1)
-        return null; // minified (t12, e)
+        return null;
     return name;
 }
 export function describePressHandler(raw) {
@@ -277,17 +208,6 @@ export function describePressHandler(raw) {
         return `{${src.length > 70 ? src.slice(0, 70) + "…" : src}}`;
     return null;
 }
-/**
- * Fallback handler context from the custom component's on* props, for when the
- * direct onPress is anonymous (Hermes discards source even in dev bundles, and
- * names like navigation.goBack are lost to computed assignment):
- * - only trust the prop whose value IS the touchable's onPress (pass-through);
- *   a non-matched candidate is an unverifiable guess that mislabels every button
- *   in a multi-button container (FloatingHeader exposes only onBack, but its menu
- *   and cart buttons run internal handlers) — so it yields null
- * - named fn → "onBack=goBack()"; nameless → "onPress→onBack" (the prop name
- *   alone is greppable context); a bare nameless "onPress" prop adds nothing → null
- */
 export function describePropHandlers(raw) {
     if (!Array.isArray(raw) || raw.length === 0)
         return null;
@@ -318,9 +238,6 @@ export function parseScreenStateResponse(raw) {
         notes: r.notes ?? [],
     };
 }
-// ============================================================================
-// Main function (dispatch phase — Task 3; resolve phase added in Task 4)
-// ============================================================================
 export async function getScreenState(options = {}) {
     const { device } = options;
     const dispatchExpression = `
@@ -618,6 +535,83 @@ export async function getScreenState(options = {}) {
         return 'Unknown';
     }
 
+    // style can be an object, a nested array, or null. Only the flattened result can be
+    // asked about position/backgroundColor, and the previous heuristic read the raw prop —
+    // so any component passing style={[base, override]} was silently skipped.
+    function flattenStyle(s) {
+        if (!s) return null;
+        if (Array.isArray(s)) {
+            var out = null;
+            for (var fi = 0; fi < s.length; fi++) {
+                var f = flattenStyle(s[fi]);
+                if (!f) continue;
+                if (!out) out = {};
+                for (var k in f) out[k] = f[k];
+            }
+            return out;
+        }
+        return typeof s === 'object' ? s : null;
+    }
+
+    // "Opaque enough to hide what is behind it." Colours reach the fiber either as CSS
+    // strings or, on Fabric, as processed ARGB integers; both carry the alpha that decides
+    // whether this is a cover or just a tint. A translucent scrim is deliberately NOT a
+    // cover — the screen shows through it and its elements stay readable.
+    function isOpaqueBackground(st) {
+        if (st.opacity != null && st.opacity < 0.95) return false;
+        var bg = st.backgroundColor;
+        if (bg == null) return false;
+        if (typeof bg === 'number') return ((bg >>> 24) & 255) >= 242;
+        if (typeof bg !== 'string') return false;
+        var v = bg.replace(/\\s/g, '').toLowerCase();
+        if (v === 'transparent') return false;
+        var m = v.match(/^rgba\\(([^)]*)\\)$/);
+        if (m) {
+            var parts = m[1].split(',');
+            if (parts.length === 4 && parseFloat(parts[3]) < 0.95) return false;
+        }
+        if (v.charAt(0) === '#' && (v.length === 9 || v.length === 5)) {
+            var hex = v.length === 9 ? v.slice(7, 9) : (v.charAt(4) + v.charAt(4));
+            var alpha = parseInt(hex, 16);
+            if (!isNaN(alpha) && alpha < 242) return false;
+        }
+        return true;
+    }
+
+    // The opaque surface is usually NOT on the positioned node. The common shape is a
+    // transparent absolutely-positioned wrapper whose child paints the panel — a bottom
+    // sheet is typically an absolute View wrapping an inner (often animated) View that
+    // carries the opaque backgroundColor. Inspecting only the wrapper's own style (the
+    // first version of this rule) therefore recognises almost no real sheet.
+    function hasOpaqueSurface(fiber, ownStyle) {
+        // A wrapper that is itself faded out is not covering anything, whatever its
+        // children declare.
+        if (ownStyle && ownStyle.opacity != null && ownStyle.opacity < 0.95) return false;
+        if (ownStyle && isOpaqueBackground(ownStyle)) return true;
+        var found = false;
+        (function scan(n, d) {
+            if (!n || d > 4 || found) return;
+            if (typeof n.type === 'string') {
+                var st = flattenStyle(n.memoizedProps && n.memoizedProps.style);
+                if (st && isOpaqueBackground(st)) { found = true; return; }
+            }
+            scan(n.child, d + 1);
+            if (!found) scan(n.sibling, d);
+        })(fiber.child, 0);
+        return found;
+    }
+
+    function hasPressableDescendant(f) {
+        var found = false;
+        (function scan(n, d) {
+            if (!n || d > 12 || found) return;
+            if (n.memoizedProps && typeof n.memoizedProps.onPress === 'function') { found = true; return; }
+            scan(n.child, d + 1);
+            if (!found) scan(n.sibling, d);
+        })(f.child, 0);
+        return found;
+    }
+
     // Walk to find viewport dimensions (reused for heuristic overlay detection)
     var viewportW = 9999, viewportH = 9999;
     var rootHostFiber = findFirstHost(roots[0].current, 0);
@@ -660,35 +654,35 @@ export async function getScreenState(options = {}) {
             }
         }
 
-        // Heuristic: absolute-positioned node with high zIndex covering > 40% screen
-        // Only fires if it has at least one pressable child
-        if (typeof fiber.type === 'string') {
-            var style = props.style;
-            if (style && typeof style === 'object' && !Array.isArray(style)) {
-                if ((style.zIndex > 999 || style.position === 'absolute') &&
-                    typeof style.width === 'number' && typeof style.height === 'number') {
-                    if (viewportW < 9999) {
-                        var area = style.width * style.height;
-                        var vArea = viewportW * viewportH;
-                        if (area > vArea * 0.4) {
-                            // Check if it has a pressable child
-                            var hasPressable = false;
-                            (function checkPress(f, d) {
-                                if (!f || d > 10 || hasPressable) return;
-                                if (f.memoizedProps && typeof f.memoizedProps.onPress === 'function') { hasPressable = true; return; }
-                                checkPress(f.child, d + 1);
-                                if (!hasPressable) checkPress(f.sibling, d);
-                            })(fiber.child, 0);
-                            if (hasPressable) {
-                                var hosts2 = [];
-                                findHostsInSubtree(fiber, 0, hosts2, 64);
-                                if (hosts2.length > 0) {
-                                    overlayFiberMeta.push({ type: 'Unknown', fiber: fiber, hostFibers: hosts2 });
-                                }
-                                return;
-                            }
-                        }
-                    }
+        // Geometric occluder: an opaque, absolutely-positioned host view holding at least
+        // one pressable. This is the branch that catches a sheet mounted as an ordinary
+        // view rather than as a Modal, a BottomSheet or a native presentation — a
+        // third-party in-app devtool panel, a hand-rolled dialog — which none of the
+        // name/prop classifiers above can recognise. Without it every element underneath
+        // such a sheet is reported as reachable and taps on them silently hit the sheet.
+        //
+        // Two deliberate changes from the rule this replaces:
+        //   - the size test moves to the resolve pass, which works on MEASURED frames.
+        //     Requiring literal numeric style.width/height here missed every sheet sized
+        //     by flex, percentages or an animated value, which is nearly all of them.
+        //   - opacity is required. A translucent scrim leaves the screen visible and its
+        //     elements legitimately reachable, so it must not count as a cover.
+        // react-native-screens wraps every route in an absolutely-positioned, opaque
+        // container full of pressables — structurally identical to a sheet and, measured,
+        // 78% of the viewport. It is a route container, never an overlay: a screen
+        // presented ON TOP of another is caught by the stackPresentation branch above,
+        // which runs first. Excluding the family here is what keeps the whole visible
+        // screen from being filed under an overlay group.
+        var NAV_CONTAINER_HOST = /^RNS/;
+        if (typeof fiber.type === 'string' && !NAV_CONTAINER_HOST.test(fiber.type)) {
+            var style = flattenStyle(props.style);
+            if (style && (style.zIndex > 999 || style.position === 'absolute') &&
+                hasOpaqueSurface(fiber, style) && hasPressableDescendant(fiber)) {
+                var hosts2 = [];
+                findHostsInSubtree(fiber, 0, hosts2, 64);
+                if (hosts2.length > 0) {
+                    overlayFiberMeta.push({ type: 'Unknown', fiber: fiber, hostFibers: hosts2, geometric: true });
+                    return;
                 }
             }
         }
@@ -708,6 +702,8 @@ export async function getScreenState(options = {}) {
 
     var hostFibers = [];
     var fiberMeta = [];
+    // overlayFiberMeta index -> fiberMeta index at which that overlay's subtree was entered.
+    var overlayEnterIdx = [];
     // A count badge ("1", "99+") is the only text on icon buttons like a cart — treat it
     // as no-own-label so the icon child still surfaces (the count is kept as nearby text).
     var COUNT_BADGE = /^\\d{1,3}\\+?$/;
@@ -886,7 +882,17 @@ export async function getScreenState(options = {}) {
         // geometric containment wrongly swallows the underlying screen's pressables.
         if (ovIdx == null) {
             for (var ofi = 0; ofi < overlayFiberMeta.length; ofi++) {
-                if (overlayFiberMeta[ofi].fiber === fiber) { ovIdx = ofi; break; }
+                if (overlayFiberMeta[ofi].fiber === fiber) {
+                    ovIdx = ofi;
+                    // Paint position of the overlay, expressed on the same counter as the
+                    // pressables. This walk is DFS pre-order over siblings in order, which
+                    // is RN's paint order, so "collected earlier" == "painted underneath".
+                    // Anything collected AFTER the overlay is drawn on top of it and must
+                    // not be reported as blocked by it — a LogBox banner over a sheet, a
+                    // toast over a dialog.
+                    if (overlayEnterIdx[ofi] == null) overlayEnterIdx[ofi] = fiberMeta.length;
+                    break;
+                }
             }
         }
 
@@ -1155,7 +1161,7 @@ export async function getScreenState(options = {}) {
 
     // Store overlay host fibers separately
     var overlayHostFibers = [];
-    var overlayMetaList = overlayFiberMeta.map(function(om) {
+    var overlayMetaList = overlayFiberMeta.map(function(om, omIdx) {
         var startIdx = overlayHostFibers.length;
         for (var hi = 0; hi < om.hostFibers.length; hi++) {
             overlayHostFibers.push(om.hostFibers[hi]);
@@ -1166,7 +1172,11 @@ export async function getScreenState(options = {}) {
             title: (title && title.length > 2) ? title.slice(0, 60) : null,
             hostStart: startIdx,
             hostEnd: overlayHostFibers.length,
-            fullCover: !!om.fullCover
+            fullCover: !!om.fullCover,
+            geometric: !!om.geometric,
+            // null means "never entered during the pressable walk" — treat as painted last
+            // (Infinity) so a subtree with no pressables of its own cannot block anything.
+            enterIdx: overlayEnterIdx[omIdx] == null ? -1 : overlayEnterIdx[omIdx]
         };
     });
 
@@ -1240,7 +1250,7 @@ export async function getScreenState(options = {}) {
         if (dp.error)
             return { success: false, error: dp.error };
     }
-    catch { /* ignore */ }
+    catch { }
     await delay(300);
     const resolveExpression = `
 (function() {
@@ -1311,6 +1321,26 @@ export async function getScreenState(options = {}) {
             if (mm.y + mm.height > cMaxY) cMaxY = mm.y + mm.height;
         }
         if (!bValid) continue;
+        // Size gate for geometric candidates, applied here because this is the first
+        // point where a measured frame exists.
+        //
+        // The upper bound is the important half. A candidate covering essentially the
+        // whole viewport is far more likely to be a screen container (react-native-screens
+        // wraps routes in absoluteFill views, which are opaque and full of pressables)
+        // than a sheet, and promoting one to "overlay" would file the entire visible
+        // screen under an overlay group. Genuine full-screen covers arrive as Modal or as
+        // a covering stackPresentation and are classified above, before this branch runs.
+        if (om.geometric) {
+            var gArea = (bMaxX - bMinX) * (bMaxY - bMinY);
+            if (!(vArea > 0) || gArea < vArea * 0.15 || gArea > vArea * 0.92) continue;
+            // A closed drawer is an opaque, absolutely-positioned, pressable-filled panel
+            // that happens to be parked off-screen (measured at x = -width). It covers
+            // nothing until it slides in, so candidacy has to be judged on the visible
+            // intersection rather than the panel's own size.
+            var visW = Math.min(bMaxX, viewportW) - Math.max(bMinX, 0);
+            var visH = Math.min(bMaxY, viewportH) - Math.max(bMinY, 0);
+            if (visW <= 0 || visH <= 0 || (visW * visH) < gArea * 0.6) continue;
+        }
         // Native covering modals occlude the whole screen — expand their block region to
         // the full viewport so elements that extend past the modal's measured content
         // frame (e.g. the bottom tab bar) are still flagged as blocked, not reachable.
@@ -1323,7 +1353,14 @@ export async function getScreenState(options = {}) {
         var contentBounds = cValid
             ? { x: Math.round(cMinX), y: Math.round(cMinY), width: Math.round(cMaxX - cMinX), height: Math.round(cMaxY - cMinY) }
             : blockBounds;
-        overlays.push({ origIdx: oi, type: om.type, title: om.title, blockBounds: blockBounds, contentBounds: contentBounds, hasContent: cValid, pressables: [] });
+        // Geometric overlays never adopt by geometry. A classified overlay may portal its
+        // content elsewhere in the tree, so containment is a needed fallback for it; a
+        // geometric candidate is a plain in-tree view whose content is exactly its fiber
+        // descendants. Letting it claim everything inside its rect would file the bottom
+        // tab bar as part of the sheet drawn over it, when the truth is the opposite —
+        // the tab bar is behind it and blocked.
+        var geometric = !!om.geometric;
+        overlays.push({ origIdx: oi, type: om.type, title: om.title, blockBounds: blockBounds, contentBounds: contentBounds, hasContent: cValid && !geometric, geometric: geometric, enterIdx: om.enterIdx, pressables: [] });
     }
 
     // Build pressable list
@@ -1335,6 +1372,9 @@ export async function getScreenState(options = {}) {
         if (m.x + m.width < 0 || m.y + m.height < 0) continue;
         if (m.x > viewportW || m.y > viewportH) continue;
         allPressables.push({
+            // Position in the DFS collection order == paint order. Kept so occlusion can
+            // ask "was this drawn before the overlay?" rather than only "is it inside it?".
+            paintIdx: i,
             label: meta[i].label,
             component: meta[i].component || null,
             center: { x: Math.round(m.x + m.width / 2), y: Math.round(m.y + m.height / 2) },
@@ -1402,6 +1442,37 @@ export async function getScreenState(options = {}) {
             b.x + b.width <= ob.x + ob.width &&
             b.y + b.height <= ob.y + ob.height;
     }
+
+    // A geometric candidate has to earn its place: it must either own pressable content or
+    // actually cover something. The name-based classifiers describe a real widget whether
+    // or not it currently holds a button, but "opaque absolute view" is a guess, and a
+    // guess that occludes nothing buys no information — it only adds an empty overlay
+    // group to the output and invites the reader to treat a plain view as a sheet.
+    // True when this overlay is painted over that pressable: the pressable is inside its
+    // rect, is not part of its own subtree, and was collected before it.
+    function occludes(o, p) {
+        return p.overlayIdx !== o.origIdx &&
+            o.enterIdx >= 0 && p.paintIdx < o.enterIdx &&
+            inside(p.bounds, o.blockBounds);
+    }
+
+    var keptOverlays = [];
+    for (var fo = 0; fo < overlays.length; fo++) {
+        var cand = overlays[fo];
+        if (!cand.geometric) { keptOverlays.push(cand); continue; }
+        // A geometric candidate must actually cover something that is not its own content.
+        // Owning pressables is NOT enough: react-native-screens wraps every route in an
+        // absolutely-positioned container that paints an opaque background and is full of
+        // pressables, and promoting one to "overlay" files the whole visible screen under
+        // an overlay group and empties the reachable list. Occluding a foreign element is
+        // what distinguishes a sheet from a screen container.
+        var earns = false;
+        for (var cp = 0; cp < allPressables.length && !earns; cp++) {
+            if (occludes(cand, allPressables[cp])) earns = true;
+        }
+        if (earns) keptOverlays.push(cand);
+    }
+    overlays = keptOverlays;
     for (var pi = 0; pi < allPressables.length; pi++) {
         var p = allPressables[pi];
         var assignedToOverlay = false;
@@ -1417,7 +1488,14 @@ export async function getScreenState(options = {}) {
             // Covered pressables stay in the list but are flagged — agents see what's
             // behind the sheet while knowing taps won't reach it until it closes.
             for (var ov2 = 0; ov2 < overlays.length; ov2++) {
-                if (inside(p.bounds, overlays[ov2].blockBounds)) { p.blockedByOverlay = true; break; }
+                // Geometric overlays respect paint order, so a banner drawn on top of a
+                // sheet is not reported as hidden by it. The name-classified overlays keep
+                // the original containment-only rule: a Modal or a native sheet occludes
+                // what is behind it regardless of where its subtree sits in the walk.
+                var blocks = overlays[ov2].geometric
+                    ? occludes(overlays[ov2], p)
+                    : inside(p.bounds, overlays[ov2].blockBounds);
+                if (blocks) { p.blockedByOverlay = true; break; }
             }
             rootPressables.push(p);
         }
@@ -1425,6 +1503,7 @@ export async function getScreenState(options = {}) {
     for (var si = 0; si < allPressables.length; si++) {
         delete allPressables[si].overlayIdx;
         delete allPressables[si].hasOwnLabel;
+        delete allPressables[si].paintIdx;
     }
 
     // Build typed text/image lists (pair each measurement with its meta by index,
@@ -1505,7 +1584,6 @@ export async function getScreenState(options = {}) {
     }
     if (!screenState)
         return { success: false, error: "Empty screen state response" };
-    // Deduplicate pressables by center coordinates (PDV + onPress fallback can both fire)
     const dedupPressables = (list) => {
         const seen = new Set();
         return list.filter((p) => {
@@ -1520,8 +1598,6 @@ export async function getScreenState(options = {}) {
     for (const overlay of screenState.overlays) {
         overlay.pressables = dedupPressables(overlay.pressables);
     }
-    // Dedup texts/images: a single visual element often maps to nested host nodes
-    // (Image > ExpoImage) or repeated text spans that all measure to the same box.
     const dedupBy = (list, keyExtra) => {
         const seen = new Set();
         return list.filter((item) => {
@@ -1533,16 +1609,6 @@ export async function getScreenState(options = {}) {
         });
     };
     screenState.texts = dedupBy(screenState.texts, (t) => t.text);
-    // Images need geometry-only dedup, not center+src.
-    //
-    // RN's <Image> and the <ExpoImage> it renders both match IMG_NAME and climb to the
-    // same measurable host, but their sources stringify differently — "asset#77" for the
-    // required asset, the resolved "http://127.0.0.1:8083/assets/…?unstable_path=…" URL
-    // for the inner one. Keying on src therefore treated one picture as two, and every
-    // local asset on screen was listed twice at identical coordinates.
-    //
-    // Keep the more informative source: "asset#N" is an opaque registry index, while the
-    // resolved URL carries the actual filename.
     const OPAQUE_ASSET_REF = /^asset#\d+$/;
     const dedupImages = (list) => {
         const byBox = new Map();
@@ -1566,7 +1632,6 @@ export async function getScreenState(options = {}) {
         if (overlay.images)
             overlay.images = dedupImages(overlay.images);
     }
-    // Semantic icon hints + onPress handler hints
     const decorate = (p) => {
         applyIconHintToLabel(p);
         const direct = describePressHandler(p.handler);
@@ -1580,7 +1645,6 @@ export async function getScreenState(options = {}) {
     for (const overlay of screenState.overlays) {
         overlay.pressables.forEach(decorate);
     }
-    // Apply TS-side overlay marking as a safety pass
     for (const overlay of screenState.overlays) {
         if (overlay.pressables.length === 0)
             continue;
@@ -1591,9 +1655,6 @@ export async function getScreenState(options = {}) {
         const overlayBounds = { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
         markPressablesCoveredByOverlay(screenState.pressables, overlayBounds);
     }
-    // Native-presented sheet detection: when an open native sheet covers the screen, its
-    // (and the underlying screen's) coordinates are unreliable — flag it and mark the
-    // underlying pressables blocked so agents fall back to screenshot/OCR.
     try {
         const parsedRaw = JSON.parse(resolveResult.result || "{}");
         const markers = Array.isArray(parsedRaw.nativeMarkers) ? parsedRaw.nativeMarkers : [];
@@ -1604,13 +1665,11 @@ export async function getScreenState(options = {}) {
                 `unreliable. Use ios_screenshot / ocr_screenshot to read and tap it.`;
             screenState.nativeOverlay = { kind: sheet.kind, component: sheet.component, note };
             screenState.notes = [...(screenState.notes ?? []), note];
-            // The native sheet dims/blocks the underlying screen — flag root pressables.
             for (const p of screenState.pressables)
                 p.blockedByOverlay = true;
         }
     }
     catch {
-        /* detection is best-effort; never fail the call over it */
     }
     const json = JSON.stringify(screenState, null, 2);
     return { success: true, result: json, screenState };