perf: cache safe device hot paths

Author: thymikee

src/core/__tests__/dispatch-resolve.test.ts

@@ -1,15 +1,27 @@
 import { beforeEach, test, vi } from 'vitest';
 import assert from 'node:assert/strict';
 
+const { mockFindBootableIosSimulator, mockListAppleDevices } = vi.hoisted(() => ({
+  mockFindBootableIosSimulator: vi.fn(),
+  mockListAppleDevices: vi.fn(),
+}));
+
 vi.mock('../../platforms/ios/devices.ts', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../../platforms/ios/devices.ts')>();
-  return { ...actual, findBootableIosSimulator: vi.fn() };
+  return {
+    ...actual,
+    findBootableIosSimulator: mockFindBootableIosSimulator,
+    listAppleDevices: mockListAppleDevices,
+  };
 });
 
-import { resolveIosDevice } from '../dispatch-resolve.ts';
+import {
+  resolveIosDevice,
+  resolveTargetDevice,
+  withResolveTargetDeviceCacheScope,
+} from '../dispatch-resolve.ts';
 import type { DeviceInfo } from '../../utils/device.ts';
 import { AppError } from '../../utils/errors.ts';
-import { findBootableIosSimulator } from '../../platforms/ios/devices.ts';
 
 const physical: DeviceInfo = {
   platform: 'ios',
@@ -38,11 +50,10 @@ const bootedSimulator: DeviceInfo = {
   booted: true,
 };
 
-const mockFindBootableIosSimulator = vi.mocked(findBootableIosSimulator);
-
 beforeEach(() => {
   mockFindBootableIosSimulator.mockReset();
   mockFindBootableIosSimulator.mockResolvedValue(null);
+  mockListAppleDevices.mockReset();
 });
 
 // --- Physical device rejected in favour of simulator fallback ---
@@ -112,3 +123,53 @@ test('resolveIosDevice returns simulator directly when present in device list',
   assert.equal(result.kind, 'simulator');
   assert.equal(mockFindBootableIosSimulator.mock.calls.length, 0);
 });
+
+test('resolveTargetDevice reuses request-scoped device resolution cache for identical selectors', async () => {
+  mockListAppleDevices.mockResolvedValue([bootedSimulator]);
+
+  const [first, second] = await withResolveTargetDeviceCacheScope(async () => [
+    await resolveTargetDevice({ platform: 'ios', device: 'iPhone 15' }),
+    await resolveTargetDevice({ platform: 'ios', device: 'iPhone 15' }),
+  ]);
+
+  assert.equal(first.id, 'sim-2');
+  assert.equal(second.id, 'sim-2');
+  assert.equal(mockListAppleDevices.mock.calls.length, 1);
+});
+
+test('resolveTargetDevice request cache key separates device selectors', async () => {
+  mockListAppleDevices.mockResolvedValue([simulator, bootedSimulator]);
+
+  await withResolveTargetDeviceCacheScope(async () => {
+    await resolveTargetDevice({ platform: 'ios', device: 'iPhone 16' });
+    await resolveTargetDevice({ platform: 'ios', device: 'iPhone 15' });
+  });
+
+  assert.equal(mockListAppleDevices.mock.calls.length, 2);
+});
+
+test('resolveTargetDevice does not reuse cache across request scopes', async () => {
+  mockListAppleDevices.mockResolvedValue([bootedSimulator]);
+
+  await withResolveTargetDeviceCacheScope(
+    async () => await resolveTargetDevice({ platform: 'ios', device: 'iPhone 15' }),
+  );
+  await withResolveTargetDeviceCacheScope(
+    async () => await resolveTargetDevice({ platform: 'ios', device: 'iPhone 15' }),
+  );
+
+  assert.equal(mockListAppleDevices.mock.calls.length, 2);
+});
+
+test('resolveTargetDevice reuses cache across nested request scopes', async () => {
+  mockListAppleDevices.mockResolvedValue([bootedSimulator]);
+
+  await withResolveTargetDeviceCacheScope(async () => {
+    await resolveTargetDevice({ platform: 'ios', device: 'iPhone 15' });
+    await withResolveTargetDeviceCacheScope(
+      async () => await resolveTargetDevice({ platform: 'ios', device: 'iPhone 15' }),
+    );
+  });
+
+  assert.equal(mockListAppleDevices.mock.calls.length, 1);
+});

src/core/dispatch-resolve.ts

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { AppError } from '../utils/errors.ts';
 import {
   normalizePlatformSelector,
@@ -28,6 +29,8 @@ type ResolveDeviceFlags = Pick<
   | 'androidDeviceAllowlist'
 >;
 
+const resolveTargetDeviceCacheScope = new AsyncLocalStorage<Map<string, DeviceInfo>>();
+
 type AppleDeviceSelector = {
   platform?: Exclude<PlatformSelector, 'android'>;
   target?: DeviceTarget;
@@ -98,6 +101,14 @@ export async function resolveTargetDevice(flags: ResolveDeviceFlags): Promise<De
     target: flags.target,
   });
   const androidSerialAllowlist = resolveAndroidSerialAllowlist(flags.androidDeviceAllowlist);
+  const cacheKey = buildResolveTargetDeviceCacheKey({
+    flags,
+    normalizedPlatform,
+    iosSimulatorSetPath,
+    androidSerialAllowlist,
+  });
+  const cached = readResolveTargetDeviceCache(cacheKey);
+  if (cached) return cached;
   return await withDiagnosticTimer(
     'resolve_target_device',
     async () => {
@@ -117,20 +128,23 @@ export async function resolveTargetDevice(flags: ResolveDeviceFlags): Promise<De
 
       if (selector.platform === 'linux') {
         const devices = await listLinuxDevices();
-        return await resolveDevice(devices, selector);
+        return cacheResolvedTargetDevice(cacheKey, await resolveDevice(devices, selector));
       }
 
       if (selector.platform === 'android') {
         await ensureAdb();
         const devices = await listAndroidDevices({ serialAllowlist: androidSerialAllowlist });
-        return await resolveDevice(devices, selector);
+        return cacheResolvedTargetDevice(cacheKey, await resolveDevice(devices, selector));
       }
 
       if (selector.platform) {
         const devices = await listAppleDevices({ simulatorSetPath: iosSimulatorSetPath });
-        return await resolveAppleDevice(devices, selector as AppleDeviceSelector, {
-          simulatorSetPath: iosSimulatorSetPath,
-        });
+        return cacheResolvedTargetDevice(
+          cacheKey,
+          await resolveAppleDevice(devices, selector as AppleDeviceSelector, {
+            simulatorSetPath: iosSimulatorSetPath,
+          }),
+        );
       }
 
       const devices: DeviceInfo[] = [];
@@ -145,11 +159,51 @@ export async function resolveTargetDevice(flags: ResolveDeviceFlags): Promise<De
       try {
         devices.push(...(await listLinuxDevices()));
       } catch {}
-      return await resolveDevice(devices, selector, { simulatorSetPath: iosSimulatorSetPath });
+      return cacheResolvedTargetDevice(
+        cacheKey,
+        await resolveDevice(devices, selector, { simulatorSetPath: iosSimulatorSetPath }),
+      );
     },
     {
       platform: normalizedPlatform,
       target: flags.target,
     },
   );
 }
+
+export async function withResolveTargetDeviceCacheScope<T>(task: () => Promise<T>): Promise<T> {
+  if (resolveTargetDeviceCacheScope.getStore()) return await task();
+  return await resolveTargetDeviceCacheScope.run(new Map(), task);
+}
+
+function readResolveTargetDeviceCache(cacheKey: string): DeviceInfo | undefined {
+  const cache = resolveTargetDeviceCacheScope.getStore();
+  const cached = cache?.get(cacheKey);
+  if (!cached) return undefined;
+  return { ...cached };
+}
+
+function cacheResolvedTargetDevice(cacheKey: string, device: DeviceInfo): DeviceInfo {
+  resolveTargetDeviceCacheScope.getStore()?.set(cacheKey, { ...device });
+  return device;
+}
+
+function buildResolveTargetDeviceCacheKey(params: {
+  flags: ResolveDeviceFlags;
+  normalizedPlatform?: PlatformSelector;
+  iosSimulatorSetPath?: string;
+  androidSerialAllowlist?: ReadonlySet<string>;
+}): string {
+  const { flags, normalizedPlatform, iosSimulatorSetPath, androidSerialAllowlist } = params;
+  return JSON.stringify({
+    platform: normalizedPlatform,
+    target: flags.target,
+    device: flags.device,
+    udid: flags.udid,
+    serial: flags.serial,
+    iosSimulatorSetPath,
+    androidSerialAllowlist: androidSerialAllowlist
+      ? Array.from(androidSerialAllowlist).sort()
+      : undefined,
+  });
+}

src/core/dispatch.ts

@@ -39,7 +39,7 @@ import {
 import { readNotificationPayload } from './dispatch-payload.ts';
 import { parseDeviceRotation } from './device-rotation.ts';
 
-export { resolveTargetDevice } from './dispatch-resolve.ts';
+export { resolveTargetDevice, withResolveTargetDeviceCacheScope } from './dispatch-resolve.ts';
 export { shouldUseIosTapSeries, shouldUseIosDragSeries };
 
 export type BatchStep = {