perf: speed up hot iOS taps (#572)

* perf: skip fresh iOS tap preflight

* perf: use app root for iOS coordinate taps

* perf: simplify iOS coordinate tap payloads

* fix: tighten hot iOS tap safety window

* chore: trace skipped iOS tap preflights

Author: thymikee

ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Interaction.swift

@@ -1359,12 +1359,17 @@ extension RunnerTests {
 
 #if !os(tvOS)
   private func interactionCoordinate(app: XCUIApplication, x: Double, y: Double) -> XCUICoordinate {
+#if os(iOS)
+    let origin = app.coordinate(withNormalizedOffset: CGVector(dx: 0, dy: 0))
+    return origin.withOffset(CGVector(dx: x, dy: y))
+#else
     let root = interactionRoot(app: app)
     let origin = root.coordinate(withNormalizedOffset: CGVector(dx: 0, dy: 0))
     let rootFrame = root.frame
     let offsetX = x - Double(rootFrame.origin.x)
     let offsetY = y - Double(rootFrame.origin.y)
     return origin.withOffset(CGVector(dx: offsetX, dy: offsetY))
+#endif
   }
 #endif
 

src/platforms/ios/__tests__/runner-session.test.ts

@@ -161,7 +161,48 @@ test('runner session probes readiness before mutating commands', async () => {
   });
 });
 
-test('runner session probes readiness before mutating commands even when marked ready', async () => {
+test('runner session skips readiness preflight for tap commands after a recent successful response', async () => {
+  const session = makeRunnerSession({ ready: true, lastSuccessfulRunnerResponseAtMs: Date.now() });
+  mockSendRunnerCommandOnce.mockResolvedValueOnce(runnerResponse({ tapped: true }));
+
+  const result = await executeRunnerCommandWithSession(
+    IOS_SIMULATOR,
+    session,
+    { command: 'tap', x: 120, y: 240, appBundleId: 'com.example.demo' },
+    '/tmp/runner.log',
+    30_000,
+  );
+
+  assert.deepEqual(result, { tapped: true });
+  assert.equal(mockWaitForRunner.mock.calls.length, 0);
+  assert.equal(mockSendRunnerCommandOnce.mock.calls.length, 1);
+});
+
+test('runner session skips readiness preflight for tapSeries after a recent successful response', async () => {
+  const session = makeRunnerSession({ ready: true, lastSuccessfulRunnerResponseAtMs: Date.now() });
+  mockSendRunnerCommandOnce.mockResolvedValueOnce(runnerResponse({ tapped: true }));
+
+  const result = await executeRunnerCommandWithSession(
+    IOS_SIMULATOR,
+    session,
+    {
+      command: 'tapSeries',
+      x: 120,
+      y: 240,
+      count: 2,
+      intervalMs: 80,
+      appBundleId: 'com.example.demo',
+    },
+    '/tmp/runner.log',
+    30_000,
+  );
+
+  assert.deepEqual(result, { tapped: true });
+  assert.equal(mockWaitForRunner.mock.calls.length, 0);
+  assert.equal(mockSendRunnerCommandOnce.mock.calls.length, 1);
+});
+
+test('runner session keeps readiness preflight for tap commands when ready but never proven fresh', async () => {
   const session = makeRunnerSession({ ready: true });
   mockWaitForRunner.mockResolvedValueOnce(runnerResponse({ uptimeMs: 42 }));
   mockSendRunnerCommandOnce.mockResolvedValueOnce(runnerResponse({ tapped: true }));
@@ -180,6 +221,47 @@ test('runner session probes readiness before mutating commands even when marked
   assert.equal(mockSendRunnerCommandOnce.mock.calls.length, 1);
 });
 
+test('runner session keeps readiness preflight for tap commands when marked ready but stale', async () => {
+  const session = makeRunnerSession({
+    ready: true,
+    lastSuccessfulRunnerResponseAtMs: Date.now() - 11_000,
+  });
+  mockWaitForRunner.mockResolvedValueOnce(runnerResponse({ uptimeMs: 42 }));
+  mockSendRunnerCommandOnce.mockResolvedValueOnce(runnerResponse({ tapped: true }));
+
+  const result = await executeRunnerCommandWithSession(
+    IOS_SIMULATOR,
+    session,
+    { command: 'tap', x: 120, y: 240, appBundleId: 'com.example.demo' },
+    '/tmp/runner.log',
+    30_000,
+  );
+
+  assert.deepEqual(result, { tapped: true });
+  assert.equal(mockWaitForRunner.mock.calls.length, 1);
+  assert.deepEqual(mockWaitForRunner.mock.calls[0]?.[2], { command: 'uptime' });
+  assert.equal(mockSendRunnerCommandOnce.mock.calls.length, 1);
+});
+
+test('runner session keeps readiness preflight for non-tap mutating commands when marked ready', async () => {
+  const session = makeRunnerSession({ ready: true, lastSuccessfulRunnerResponseAtMs: Date.now() });
+  mockWaitForRunner.mockResolvedValueOnce(runnerResponse({ uptimeMs: 42 }));
+  mockSendRunnerCommandOnce.mockResolvedValueOnce(runnerResponse({ pressed: true }));
+
+  const result = await executeRunnerCommandWithSession(
+    IOS_SIMULATOR,
+    session,
+    { command: 'longPress', x: 120, y: 240, appBundleId: 'com.example.demo' },
+    '/tmp/runner.log',
+    30_000,
+  );
+
+  assert.deepEqual(result, { pressed: true });
+  assert.equal(mockWaitForRunner.mock.calls.length, 1);
+  assert.deepEqual(mockWaitForRunner.mock.calls[0]?.[2], { command: 'uptime' });
+  assert.equal(mockSendRunnerCommandOnce.mock.calls.length, 1);
+});
+
 test('runner session preserves structured runner failures', async () => {
   const session = makeRunnerSession({ ready: true });
   mockWaitForRunner.mockResolvedValueOnce(

src/platforms/ios/runner-session-types.ts

@@ -11,6 +11,7 @@ export type RunnerSession = {
   testPromise: Promise<ExecResult>;
   child: ExecBackgroundResult['child'];
   ready: boolean;
+  lastSuccessfulRunnerResponseAtMs?: number;
   startupTimings?: Record<string, number>;
   startupTimingsReported?: boolean;
   simulatorSetRedirect?: { release: () => Promise<void> };

src/platforms/ios/runner-session.ts

@@ -43,6 +43,9 @@ const runnerSessionLocks = new Map<string, Promise<unknown>>();
 const RUNNER_STOP_WAIT_TIMEOUT_MS = 10_000;
 const RUNNER_INVALIDATE_WAIT_TIMEOUT_MS = 1_000;
 const RUNNER_READY_PREFLIGHT_TIMEOUT_MS = 5_000;
+// Hot tap loops can skip one uptime preflight only while the runner has just responded.
+// Failed mutating taps still invalidate the session instead of being replayed.
+const RUNNER_TAP_PREFLIGHT_SKIP_FRESHNESS_MS = 10_000;
 const RUNNER_SHUTDOWN_TIMEOUT_MS = 15_000;
 
 function withRunnerSessionLock<T>(deviceId: string, task: () => Promise<T>): Promise<T> {
@@ -441,24 +444,40 @@ export async function executeRunnerCommandWithSession(
   }
 
   const deadline = Deadline.fromTimeoutMs(timeoutMs);
-  const readinessTimeoutMs = session.ready
-    ? Math.min(RUNNER_READY_PREFLIGHT_TIMEOUT_MS, deadline.remainingMs())
-    : Math.min(RUNNER_STARTUP_TIMEOUT_MS, deadline.remainingMs());
-  const readinessResponse = await withDiagnosticTimer(
-    'ios_runner_readiness_preflight',
-    async () =>
-      await waitForRunner(
-        device,
-        session.port,
-        { command: 'uptime' },
-        logPath,
-        readinessTimeoutMs,
-        session,
-        signal,
-      ),
-    { command: command.command, sessionReady: session.ready, timeoutMs: readinessTimeoutMs },
-  );
-  await parseRunnerResponse(readinessResponse, session, logPath);
+  const shouldPreflight = shouldPreflightMutatingRunnerCommand(session, command);
+  if (shouldPreflight) {
+    const readinessTimeoutMs = session.ready
+      ? Math.min(RUNNER_READY_PREFLIGHT_TIMEOUT_MS, deadline.remainingMs())
+      : Math.min(RUNNER_STARTUP_TIMEOUT_MS, deadline.remainingMs());
+    const readinessResponse = await withDiagnosticTimer(
+      'ios_runner_readiness_preflight',
+      async () =>
+        await waitForRunner(
+          device,
+          session.port,
+          { command: 'uptime' },
+          logPath,
+          readinessTimeoutMs,
+          session,
+          signal,
+        ),
+      { command: command.command, sessionReady: session.ready, timeoutMs: readinessTimeoutMs },
+    );
+    await parseRunnerResponse(readinessResponse, session, logPath);
+  } else {
+    emitDiagnostic({
+      level: 'debug',
+      phase: 'ios_runner_readiness_preflight_skipped',
+      data: {
+        command: command.command,
+        lastSuccessfulRunnerResponseAgeMs:
+          session.lastSuccessfulRunnerResponseAtMs === undefined
+            ? undefined
+            : Date.now() - session.lastSuccessfulRunnerResponseAtMs,
+        sessionReady: session.ready,
+      },
+    });
+  }
   const remainingMs = deadline.remainingMs();
   if (remainingMs <= 0) {
     throw new AppError('COMMAND_FAILED', 'Runner command deadline exceeded', { timeoutMs });
@@ -508,12 +527,26 @@ export async function parseRunnerResponse(
     });
   }
   session.ready = true;
+  session.lastSuccessfulRunnerResponseAtMs = Date.now();
   if (json.data && typeof json.data === 'object' && !Array.isArray(json.data)) {
     return json.data as Record<string, unknown>;
   }
   return {};
 }
 
+function shouldPreflightMutatingRunnerCommand(
+  session: RunnerSession,
+  command: RunnerCommand,
+): boolean {
+  if (!session.ready) return true;
+  if (command.command !== 'tap' && command.command !== 'tapSeries') return true;
+  const lastSuccessAt = session.lastSuccessfulRunnerResponseAtMs;
+  return (
+    lastSuccessAt === undefined ||
+    Date.now() - lastSuccessAt > RUNNER_TAP_PREFLIGHT_SKIP_FRESHNESS_MS
+  );
+}
+
 async function measureRunnerStartupStep<T>(
   timings: Record<string, number>,
   phase: string,