fix: improve maestro text tap targets

Author: thymikee

src/compat/maestro/__tests__/runtime-geometry.test.ts

@@ -0,0 +1,40 @@
+import { expect, test } from 'vitest';
+import { pointForMaestroTapOnTarget } from '../runtime-geometry.ts';
+
+test('pointForMaestroTapOnTarget biases broad iOS scroll-area text matches toward the visible label', () => {
+  const point = pointForMaestroTapOnTarget(
+    {
+      node: {
+        index: 5,
+        ref: 'e5',
+        type: 'scroll-area',
+        label: 'Chat',
+        rect: { x: 0, y: 117, width: 402, height: 48 },
+      },
+      rect: { x: 0, y: 117, width: 402, height: 48 },
+      frame: { referenceWidth: 402, referenceHeight: 874 },
+    },
+    true,
+  );
+
+  expect(point).toEqual({ x: 84, y: 141 });
+});
+
+test('pointForMaestroTapOnTarget biases broad iOS other text matches at tab bar height', () => {
+  const point = pointForMaestroTapOnTarget(
+    {
+      node: {
+        index: 5,
+        ref: 'e5',
+        type: 'Other',
+        label: 'Chat',
+        rect: { x: 0, y: 117, width: 402, height: 48 },
+      },
+      rect: { x: 0, y: 117, width: 402, height: 48 },
+      frame: { referenceWidth: 402, referenceHeight: 874 },
+    },
+    true,
+  );
+
+  expect(point).toEqual({ x: 84, y: 141 });
+});

src/compat/maestro/__tests__/runtime-interactions.test.ts

@@ -0,0 +1,103 @@
+import { expect, test } from 'vitest';
+import type { DaemonRequest, DaemonResponse } from '../../../daemon/types.ts';
+import type { ReplayVarScope } from '../../../replay/vars.ts';
+import type { SnapshotState } from '../../../utils/snapshot.ts';
+import { invokeMaestroTapOn } from '../runtime-interactions.ts';
+import { rememberMaestroSnapshot } from '../runtime-support.ts';
+
+test('invokeMaestroTapOn resolves mutating taps from a fresh snapshot instead of stale assertion cache', async () => {
+  const scope: ReplayVarScope = { values: {} };
+  const selector =
+    'label="Article by Gandalf" || text="Article by Gandalf" || id="Article by Gandalf"';
+  rememberMaestroSnapshot(scope, staleLaunchSnapshot(), selector);
+
+  const clicks: string[][] = [];
+  const response = await invokeMaestroTapOn({
+    baseReq: {
+      token: 'test',
+      session: 'nav',
+      flags: { platform: 'ios' },
+    },
+    positionals: [selector],
+    scope,
+    invoke: async (req: DaemonRequest): Promise<DaemonResponse> => {
+      if (req.command === 'snapshot') return { ok: true, data: currentBreadcrumbSnapshot() };
+      if (req.command === 'click') {
+        clicks.push(req.positionals ?? []);
+        return { ok: true, data: {} };
+      }
+      return { ok: false, error: { code: 'UNEXPECTED_COMMAND', message: req.command } };
+    },
+  });
+
+  expect(response.ok).toBe(true);
+  expect(clicks).toEqual([['86', '89']]);
+});
+
+function staleLaunchSnapshot(): SnapshotState {
+  return {
+    createdAt: Date.now(),
+    nodes: [
+      appNode(),
+      windowNode(),
+      {
+        index: 2,
+        ref: 'e3',
+        type: 'Other',
+        label: 'Article by Gandalf',
+        depth: 2,
+        rect: { x: 0, y: 0, width: 402, height: 48 },
+      },
+    ],
+  };
+}
+
+function currentBreadcrumbSnapshot(): SnapshotState {
+  return {
+    createdAt: Date.now(),
+    nodes: [
+      appNode(),
+      windowNode(),
+      {
+        index: 2,
+        ref: 'e3',
+        type: 'ScrollView',
+        label: 'Article by Gandalf',
+        depth: 4,
+        parentIndex: 1,
+        rect: { x: 0, y: 58.33333333333333, width: 402, height: 58.33333333333333 },
+      },
+      {
+        index: 3,
+        ref: 'e4',
+        type: 'Cell',
+        label: 'Article by Gandalf',
+        depth: 5,
+        parentIndex: 2,
+        rect: { x: 8, y: 65.33333587646484, width: 155, height: 48 },
+      },
+    ],
+  };
+}
+
+function appNode(): SnapshotState['nodes'][number] {
+  return {
+    index: 0,
+    ref: 'e1',
+    type: 'Application',
+    label: 'React Navigation Example',
+    depth: 0,
+    rect: { x: 0, y: 0, width: 402, height: 874 },
+  };
+}
+
+function windowNode(): SnapshotState['nodes'][number] {
+  return {
+    index: 1,
+    ref: 'e2',
+    type: 'Window',
+    depth: 1,
+    parentIndex: 0,
+    rect: { x: 0, y: 0, width: 402, height: 874 },
+  };
+}

src/compat/maestro/runtime-geometry.ts

@@ -1,4 +1,5 @@
 import type { Rect, SnapshotNode } from '../../utils/snapshot.ts';
+import { normalizeType } from '../../utils/snapshot-processing.ts';
 import type { MaestroSnapshotTarget } from './runtime-targets.ts';
 
 const MAESTRO_GEOMETRY_POLICY = {
@@ -10,7 +11,7 @@ const MAESTRO_GEOMETRY_POLICY = {
   },
   largeTextContainerBias: {
     minWidth: 120,
-    minHeight: 70,
+    minHeight: 40,
     width: 168,
     height: 48,
   },
@@ -108,14 +109,13 @@ function shouldBiasMaestroVisibleTextTap(
   rect: Rect,
 ): boolean {
   if (!isVisibleTextSelector) return false;
-  if (
-    rect.height < MAESTRO_GEOMETRY_POLICY.largeTextContainerBias.minHeight ||
-    rect.width < MAESTRO_GEOMETRY_POLICY.largeTextContainerBias.minWidth
-  ) {
+  if (rect.width < MAESTRO_GEOMETRY_POLICY.largeTextContainerBias.minWidth) {
     return false;
   }
-  const type = node.type?.toLowerCase();
-  return type === 'cell' || type === 'other' || type === 'scrollview';
+  const type = normalizeType(node.type ?? '');
+  const scrollableTextContainer = type === 'scrollview' || type === 'scroll-area';
+  if (rect.height < MAESTRO_GEOMETRY_POLICY.largeTextContainerBias.minHeight) return false;
+  return type === 'cell' || type === 'other' || scrollableTextContainer;
 }
 
 function interiorCoordinate(origin: number, size: number): number {

src/compat/maestro/runtime-interactions.ts

@@ -5,7 +5,6 @@ import { sleep } from '../../utils/timeouts.ts';
 import { pointForMaestroTapOnTarget, swipeCoordinatesFromTarget } from './runtime-geometry.ts';
 import {
   captureMaestroRawSnapshot,
-  consumeMaestroSnapshot,
   errorResponse,
   readCachedMaestroReferenceFrame,
   readSnapshotState,
@@ -471,14 +470,6 @@ async function resolveMaestroSnapshotTarget(
   commandLabel: string,
   resolutionOptions: { promoteTapTarget: boolean },
 ): Promise<{ ok: true; target: MaestroSnapshotTarget } | { ok: false; response: DaemonResponse }> {
-  const cachedTarget = resolveCachedMaestroSnapshotTarget(
-    params,
-    selector,
-    options,
-    resolutionOptions,
-  );
-  if (cachedTarget.ok) return cachedTarget;
-
   const snapshotResponse = await captureMaestroRawSnapshot(params);
   if (!snapshotResponse.ok) return { ok: false, response: snapshotResponse };
 
@@ -543,37 +534,6 @@ async function resolveMaestroSnapshotTarget(
   };
 }
 
-function resolveCachedMaestroSnapshotTarget(
-  params: {
-    baseReq: ReplayBaseRequest;
-    scope?: ReplayVarScope;
-  },
-  selector: string,
-  options: MaestroTapOnOptions,
-  resolutionOptions: { promoteTapTarget: boolean },
-): { ok: true; target: MaestroSnapshotTarget } | { ok: false } {
-  const cached = consumeMaestroSnapshot(params.scope, selector);
-  if (!cached) return { ok: false };
-  const resolution = resolveMaestroNodeFromSnapshot(
-    cached.snapshot,
-    selector,
-    options,
-    readMaestroSelectorPlatform(params.baseReq.flags),
-    cached.frame,
-    resolutionOptions,
-  );
-  return resolution.ok
-    ? {
-        ok: true,
-        target: {
-          node: resolution.node,
-          rect: resolution.rect,
-          frame: cached.frame,
-        },
-      }
-    : { ok: false };
-}
-
 function readMaestroTapOnOptions(
   rawOptions: string | undefined,
 ): { ok: true; value: MaestroTapOnOptions | null } | { ok: false; response: DaemonResponse } {