fix: compose post-gesture snapshots with android freshness

Author: thymikee

src/daemon/__tests__/interaction-outcome-policy.test.ts

@@ -5,7 +5,7 @@ import {
   buildInteractionSurfaceSignature,
   classifyInteractionSurfaceChange,
   markPendingInteractionOutcome,
-  stripInternalInteractionOutcomeFlags,
+  stripInternalInteractionFlags,
 } from '../interaction-outcome-policy.ts';
 import type { SessionState } from '../types.ts';
 import { IOS_SIMULATOR } from '../../__tests__/test-utils/device-fixtures.ts';
@@ -84,9 +84,9 @@ test('markPendingInteractionOutcome stores retry state only for explicit retry f
   assert.equal(longPressSession.pendingInteractionOutcome, undefined);
 });
 
-test('stripInternalInteractionOutcomeFlags removes internal interaction controls', () => {
+test('stripInternalInteractionFlags removes internal interaction controls', () => {
   assert.deepEqual(
-    stripInternalInteractionOutcomeFlags({
+    stripInternalInteractionFlags({
       platform: 'ios',
       interactionOutcome: { retryOnNoChange: true },
       postGestureStabilization: true,

src/daemon/handlers/__tests__/snapshot-handler.test.ts

@@ -1032,6 +1032,80 @@ test('captureSnapshot retries pending tap outcome before post-gesture stabilizat
   expect(session.postGestureStabilization).toBeUndefined();
 });
 
+test('captureSnapshot composes post-gesture stabilization with Android freshness capture', async () => {
+  const sessionName = 'android-post-gesture-freshness';
+  const session = makeSession(sessionName, androidDevice);
+  const baselineNodes = Array.from({ length: 18 }, (_, index) => ({
+    ref: `e${index + 1}`,
+    index,
+    depth: 0,
+    type: 'android.widget.TextView',
+    label: `Inbox row ${index + 1}`,
+  }));
+  const changedNodes = Array.from({ length: 18 }, (_, index) => ({
+    ref: `e${index + 1}`,
+    index,
+    depth: 0,
+    type: 'android.widget.TextView',
+    label: index === 0 ? 'album-0' : `Album row ${index + 1}`,
+  }));
+  session.snapshot = {
+    nodes: baselineNodes,
+    createdAt: Date.now(),
+    backend: 'android',
+    comparisonSafe: true,
+  };
+  session.androidSnapshotFreshness = {
+    action: 'click',
+    markedAt: Date.now(),
+    baselineCount: baselineNodes.length,
+    baselineSignatures: buildSnapshotSignatures(baselineNodes),
+    routeComparable: true,
+  };
+  session.postGestureStabilization = {
+    action: 'click',
+    markedAt: Date.now(),
+  };
+
+  mockDispatch
+    .mockResolvedValueOnce({
+      nodes: baselineNodes,
+      truncated: false,
+      backend: 'android',
+      analysis: { rawNodeCount: 18, maxDepth: 1 },
+    })
+    .mockResolvedValueOnce({
+      nodes: changedNodes,
+      truncated: false,
+      backend: 'android',
+      analysis: { rawNodeCount: 18, maxDepth: 1 },
+    })
+    .mockResolvedValueOnce({
+      nodes: changedNodes,
+      truncated: false,
+      backend: 'android',
+      analysis: { rawNodeCount: 18, maxDepth: 1 },
+    });
+
+  const result = await captureSnapshot({
+    device: androidDevice,
+    session,
+    flags: { snapshotInteractiveOnly: true },
+    logPath: '/tmp/daemon.log',
+  });
+
+  expect(result.snapshot.nodes).toEqual(
+    expect.arrayContaining([expect.objectContaining({ label: 'album-0' })]),
+  );
+  expect(mockDispatch.mock.calls.map((call) => call[1])).toEqual([
+    'snapshot',
+    'snapshot',
+    'snapshot',
+  ]);
+  expect(session.androidSnapshotFreshness).toBeUndefined();
+  expect(session.postGestureStabilization).toBeUndefined();
+});
+
 test('captureSnapshot composes pending outcome retry with Android freshness capture', async () => {
   const sessionName = 'android-lazy-outcome-freshness';
   const session = makeSession(sessionName, androidDevice);

src/daemon/handlers/find.ts

@@ -16,7 +16,7 @@ import { captureSnapshot } from './snapshot-capture.ts';
 import { setSessionSnapshot } from '../session-snapshot.ts';
 import { errorResponse } from './response.ts';
 import { getActiveAndroidSnapshotFreshness } from '../android-snapshot-freshness.ts';
-import { stripInternalInteractionOutcomeFlags } from '../interaction-outcome-policy.ts';
+import { stripInternalInteractionFlags } from '../interaction-outcome-policy.ts';
 import { dispatchFindReadOnlyViaRuntime } from '../selector-runtime.ts';
 import { PUBLIC_COMMANDS } from '../../command-catalog.ts';
 
@@ -502,7 +502,7 @@ function recordFindAction(ctx: FindContext, match: ResolvedMatch, action: string
 // --- Helpers ---
 
 function publicFindFlags(flags: DaemonRequest['flags']): Record<string, unknown> {
-  return { ...(stripInternalInteractionOutcomeFlags(flags) ?? {}) };
+  return { ...(stripInternalInteractionFlags(flags) ?? {}) };
 }
 
 function buildAmbiguousMatchError(

src/daemon/handlers/interaction-common.ts

@@ -11,7 +11,7 @@ import {
 } from '../android-snapshot-freshness.ts';
 import {
   markPendingInteractionOutcome,
-  stripInternalInteractionOutcomeFlags,
+  stripInternalInteractionFlags,
 } from '../interaction-outcome-policy.ts';
 import { markPostGestureStabilization } from '../post-gesture-stabilization.ts';
 
@@ -99,7 +99,7 @@ export function finalizeTouchInteraction(params: {
     actionFinishedAt,
     androidFreshnessBaseline,
   } = params;
-  const actionFlags = stripInternalInteractionOutcomeFlags(flags);
+  const actionFlags = stripInternalInteractionFlags(flags);
   sessionStore.recordAction(session, {
     command,
     positionals,

src/daemon/handlers/snapshot-capture.ts

@@ -39,7 +39,6 @@ import {
   type InteractionSurfaceChange,
 } from '../interaction-outcome-policy.ts';
 import {
-  capturePostGestureStabilizedSnapshot,
   capturePostGestureStabilizedResult,
 } from '../post-gesture-stabilization.ts';
 import { findNodeByLabel, pruneGroupNodes, resolveRefLabel } from '../snapshot-processing.ts';
@@ -91,12 +90,7 @@ export async function captureSnapshot(params: CaptureSnapshotParams): Promise<{
     (params.device.platform === 'ios' || params.device.platform === 'android') &&
     params.session?.postGestureStabilization
   ) {
-    return {
-      snapshot: await capturePostGestureStabilizedSnapshot({
-        session: params.session,
-        capture: async () => (await captureSnapshotAttempt(params)).snapshot,
-      }),
-    };
+    return await capturePostGestureAwareSnapshot({ ...params, session: params.session });
   }
   const freshness = getActiveAndroidSnapshotFreshness(params.session);
   if (freshness && params.device.platform === 'android') {
@@ -127,7 +121,7 @@ async function captureInteractionOutcomeAwareSnapshot(
   let settled = await waitForDelayedInteractionSurfaceChange(
     params,
     pending,
-    await captureSnapshotAttemptForInteractionOutcome(params),
+    await capturePostActionSnapshotAttempt(params),
   );
   let latest = settled.latest;
   let outcome = await retryPendingInteractionOutcome({
@@ -142,7 +136,7 @@ async function captureInteractionOutcomeAwareSnapshot(
     settled = await waitForDelayedInteractionSurfaceChange(
       params,
       pending,
-      await captureSnapshotAttemptForInteractionOutcome(params),
+      await capturePostActionSnapshotAttempt(params),
     );
     latest = settled.latest;
     outcome = await retryPendingInteractionOutcome({
@@ -157,7 +151,7 @@ async function captureInteractionOutcomeAwareSnapshot(
   latest = await capturePostGestureStabilizedResult({
     session,
     initial: latest,
-    capture: async () => await captureSnapshotAttemptForInteractionOutcome(params),
+    capture: async () => await capturePostActionSnapshotAttempt(params),
     readSnapshot: (attempt) => attempt.snapshot,
   });
   if (outcome.change !== 'ambiguous' && latest.freshness?.staleAfterRetries !== true) {
@@ -195,7 +189,7 @@ async function waitForDelayedInteractionSurfaceChange(
   if (change !== 'unchanged') return { latest, change };
 
   await sleep(INTERACTION_CHANGE_RECHECK_DELAY_MS);
-  latest = await captureSnapshotAttemptForInteractionOutcome(params);
+  latest = await capturePostActionSnapshotAttempt(params);
   change = classifyInteractionSurfaceChange(
     pending.preSignature,
     buildInteractionSurfaceSignature(latest.snapshot.nodes),
@@ -292,7 +286,28 @@ async function captureAndroidFreshnessAwareAttempt(
   };
 }
 
-async function captureSnapshotAttemptForInteractionOutcome(
+async function capturePostGestureAwareSnapshot(
+  params: CaptureSnapshotParams & { session: SessionState },
+): Promise<{
+  snapshot: SnapshotState;
+  analysis?: AndroidSnapshotAnalysis;
+  androidSnapshot?: AndroidSnapshotBackendMetadata;
+  freshness?: AndroidFreshnessCaptureMeta;
+}> {
+  const latest = await capturePostGestureStabilizedResult({
+    session: params.session,
+    capture: async () => await capturePostActionSnapshotAttempt(params),
+    readSnapshot: (attempt) => attempt.snapshot,
+  });
+  return {
+    snapshot: latest.snapshot,
+    analysis: latest.data.analysis,
+    androidSnapshot: latest.data.androidSnapshot,
+    freshness: latest.freshness,
+  };
+}
+
+async function capturePostActionSnapshotAttempt(
   params: CaptureSnapshotParams & { session: SessionState },
 ): Promise<SnapshotAttempt> {
   const freshness = getActiveAndroidSnapshotFreshness(params.session);

src/daemon/interaction-outcome-policy.ts

@@ -37,7 +37,7 @@ export function markPendingInteractionOutcome(params: {
     action: command,
     command: retryCommand,
     positionals,
-    flags: stripInternalInteractionOutcomeFlags(flags),
+    flags: stripInternalInteractionFlags(flags),
     markedAt: Date.now(),
     attemptsRemaining: OUTCOME_RETRY_ATTEMPTS,
     preSignature,
@@ -134,7 +134,7 @@ export function emitInteractionSettleTimeout(params: {
   });
 }
 
-export function stripInternalInteractionOutcomeFlags(
+export function stripInternalInteractionFlags(
   flags: CommandFlags | undefined,
 ): CommandFlags | undefined {
   if (!flags?.interactionOutcome && !flags?.postGestureStabilization) return flags;

src/platforms/ios/runner-client.ts

@@ -3,7 +3,7 @@ import { withRetry } from '../../utils/retry.ts';
 import type { DeviceInfo } from '../../utils/device.ts';
 import { emitDiagnostic } from '../../utils/diagnostics.ts';
 import { getRequestSignal } from '../../daemon/request-cancel.ts';
-import { RUNNER_COMMAND_TIMEOUT_MS, RUNNER_STARTUP_TIMEOUT_MS } from './runner-transport.ts';
+import { RUNNER_COMMAND_TIMEOUT_MS } from './runner-transport.ts';
 import {
   type RunnerSessionOptions,
   type RunnerSession,
@@ -12,6 +12,7 @@ import {
   stopIosRunnerSession,
   validateRunnerDevice,
   executeRunnerCommandWithSession,
+  readRunnerStartupTimeoutMs,
 } from './runner-session.ts';
 import {
   assertRunnerRequestActive,
@@ -250,10 +251,6 @@ async function executeRunnerCommand(
   }
 }
 
-function readRunnerStartupTimeoutMs(session: Pick<RunnerSession, 'startupTimeoutMs'>): number {
-  return session.startupTimeoutMs ?? RUNNER_STARTUP_TIMEOUT_MS;
-}
-
 async function handleRunnerTransportErrorAfterCommandSend(
   device: DeviceInfo,
   session: RunnerSession,

src/platforms/ios/runner-session.ts

@@ -703,7 +703,9 @@ function markRunnerPreflightError(error: unknown, details: Record<string, unknow
   );
 }
 
-function readRunnerStartupTimeoutMs(session: Pick<RunnerSession, 'startupTimeoutMs'>): number {
+export function readRunnerStartupTimeoutMs(
+  session: Pick<RunnerSession, 'startupTimeoutMs'>,
+): number {
   return session.startupTimeoutMs ?? RUNNER_STARTUP_TIMEOUT_MS;
 }