fix(selectors): keep the wrapper-collapse fallback to non-actionable wrappers

Review follow-up on #2482. The unverified-hittability collapse accepted any
ancestry chain whose rects agreed within a point, so a cell and the button
inside it (both actionable, no hittability evidence) collapsed to the
descendant: a silent wrong-control press where the previous rules refused as
ambiguous. The fallback now requires every candidate above the control to be a
non-actionable wrapper, and a negative regression covers the semantic-ancestor
case next to the captured Other/Button success case.

Gate: pnpm check:affected --run - 304 files / 2011 tests, all runnable checks passed.

Author: prateekranka

packages/selectors/src/interaction-targeting-wrapper-chain.test.ts

@@ -68,6 +68,36 @@ test('refuses a chain whose rects differ beyond sub-pixel slack', () => {
   );
 });
 
+test('refuses a chain of two real controls that share one rect', () => {
+  // A cell and the button inside it share an identifier and their rects agree
+  // within slack. Both are actionable, so collapsing to the descendant would
+  // silently press the wrong control; the ambiguity refusal must survive.
+  const snapshot = makeSnapshotState([
+    {
+      index: 0,
+      depth: 1,
+      type: 'XCUIElementTypeCell',
+      identifier: 'row_action',
+      rect: { x: 20, y: 63, width: 36, height: 36 },
+    },
+    {
+      index: 1,
+      depth: 2,
+      parentIndex: 0,
+      type: 'XCUIElementTypeButton',
+      identifier: 'row_action',
+      rect: { x: 20.5, y: 63, width: 35, height: 36 },
+    },
+  ]);
+
+  assert.equal(
+    resolveUnverifiedWrapperControl(
+      snapshot.nodes.filter((node) => node.identifier === 'row_action'),
+    ),
+    null,
+  );
+});
+
 test('refuses a chain whose deepest candidate is not a semantic touch target', () => {
   const snapshot = makeSnapshotState([
     {

packages/selectors/src/interaction-targeting-wrapper-chain.ts

@@ -7,15 +7,19 @@ import { isSemanticTouchTarget } from './touch-semantics.ts';
 const WRAPPER_RECT_SLACK = 1;
 
 /**
- * The deepest semantic touch target of a single ancestry chain whose candidates
- * all lack hittability evidence, or null when the chain does not denote one
+ * The control of a single ancestry chain that is one actionable control wrapped
+ * by non-actionable wrappers, or null when the chain does not denote one
  * control.
  *
  * Regular iOS snapshots omit unverified hittability, and
  * `findPreferredActionableDescendant` requires verified hittability, so a
  * SwiftUI wrapper can never relate to its own control through the resolution
  * ladder: press and wait then see two actionable elements for one toolbar
- * button. Candidates carrying any hittability fact keep the existing rules.
+ * button. The collapse stays narrow on purpose: every candidate above the
+ * control must be a non-actionable wrapper, so a chain of two real controls (a
+ * cell and the button inside it) keeps the existing ambiguity refusal instead of
+ * silently pressing the descendant. Candidates carrying any hittability fact
+ * also keep the existing rules.
  */
 export function resolveUnverifiedWrapperControl(
   candidates: readonly SnapshotNode[],
@@ -26,6 +30,10 @@ export function resolveUnverifiedWrapperControl(
     (candidate.depth ?? 0) > (deepest.depth ?? 0) ? candidate : deepest,
   );
   if (!isSemanticTouchTarget(control)) return null;
+  const wrapsOnlyNonActionable = candidates.every(
+    (candidate) => candidate === control || !isSemanticTouchTarget(candidate),
+  );
+  if (!wrapsOnlyNonActionable) return null;
   const controlRect = normalizeRect(control.rect);
   if (!controlRect) return null;
   return candidates.every((candidate) =>