perf(ios): skip backend re-read in get text for non-editable elements

readTextForNode dispatched a coordinate 'read' to the iOS XCUITest runner for
every get text, where readTextAt() enumerates the full element tree
(allElementsBoundByIndex) — ~20x slower than the snapshot already captured to
resolve the node. That re-read only recovers fuller text for editable/expandable
inputs (textField/searchField/textView/…); for all other element types the
freshly-captured snapshot node text is authoritative.

Return the snapshot node text directly for non-editable nodes with non-empty
readable text, skipping the round-trip. Measured on iPhone 17 sim: get text on a
labeled control drops from ~25s to ~0.3s steady-state. Editable inputs keep the
backend re-read (live value can exceed the snapshot).

Author: thymikee

src/daemon/handlers/__tests__/interaction-read.test.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { SnapshotNode } from '../../../utils/snapshot.ts';
+
+vi.mock('../../../core/dispatch.ts', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../../core/dispatch.ts')>();
+  return {
+    ...actual,
+    dispatchCommand: vi.fn(async () => ({ text: 'backend-text' })),
+  };
+});
+
+import { dispatchCommand } from '../../../core/dispatch.ts';
+import { readTextForNode } from '../interaction-read.ts';
+
+const mockDispatch = vi.mocked(dispatchCommand);
+
+function node(overrides: Partial<SnapshotNode>): SnapshotNode {
+  return {
+    ref: 'e1',
+    index: 0,
+    rect: { x: 0, y: 0, width: 100, height: 40 },
+    ...overrides,
+  } as SnapshotNode;
+}
+
+const baseParams = {
+  device: { platform: 'ios' } as never,
+  flags: undefined,
+  contextFromFlags: () => ({}) as never,
+};
+
+describe('readTextForNode', () => {
+  beforeEach(() => mockDispatch.mockClear());
+
+  it('returns snapshot text without a backend read for non-editable nodes', async () => {
+    const text = await readTextForNode({ ...baseParams, node: node({ type: 'button', label: 'General' }) });
+    expect(text).toBe('General');
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  it('still re-reads via the backend for editable text inputs (live value may exceed snapshot)', async () => {
+    const text = await readTextForNode({ ...baseParams, node: node({ type: 'textfield', value: 'snap' }) });
+    expect(mockDispatch).toHaveBeenCalledOnce();
+    expect(text).toBe('backend-text');
+  });
+
+  it('re-reads when the snapshot node has no readable text', async () => {
+    await readTextForNode({ ...baseParams, node: node({ type: 'other' }) });
+    expect(mockDispatch).toHaveBeenCalledOnce();
+  });
+
+  it('returns snapshot text without a backend read when the node has no resolvable center', async () => {
+    const text = await readTextForNode({ ...baseParams, node: node({ type: 'button', label: 'General', rect: undefined }) });
+    expect(text).toBe('General');
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+});

src/daemon/handlers/interaction-read.ts

@@ -3,6 +3,7 @@ import { emitDiagnostic } from '../../utils/diagnostics.ts';
 import { extractNodeReadText } from '../snapshot-processing.ts';
 import type { SessionState } from '../types.ts';
 import type { SnapshotNode } from '../../utils/snapshot.ts';
+import { prefersValueForReadableText } from '../../utils/text-surface.ts';
 import type { ContextFromFlags } from './interaction-common.ts';
 import { resolveRectCenter } from './interaction-targeting.ts';
 
@@ -22,6 +23,16 @@ export async function readTextForNode(params: {
     return fallbackText;
   }
 
+  // The backend `read` re-resolves the element at a point, which on iOS XCUITest enumerates
+  // the full element tree (allElementsBoundByIndex) and is ~20x slower than the snapshot we
+  // already captured to resolve this node. That re-read only recovers fuller text for
+  // editable/expandable inputs (textField/searchField/textView/…), where the live value can
+  // exceed the snapshot. For every other element type the snapshot node text is authoritative,
+  // so return it directly and skip the expensive round-trip.
+  if (fallbackText && !prefersValueForReadableText(node.type ?? '')) {
+    return fallbackText;
+  }
+
   try {
     const rawData = await dispatchCommand(
       device,

src/utils/text-surface.ts

@@ -85,7 +85,12 @@ export function normalizeType(type: string): string {
   return normalized;
 }
 
-function prefersValueForReadableText(type: string): boolean {
+/**
+ * Editable / expandable text-bearing element types whose live on-screen value can exceed
+ * the captured snapshot text. For these the readable text prefers `value`, and a backend
+ * (e.g. iOS XCUITest) re-read at the element can recover fuller text than the snapshot node.
+ */
+export function prefersValueForReadableText(type: string): boolean {
   const normalized = normalizeType(type);
   return (
     normalized.includes('textfield') ||