feat(limrun): long press on iOS direct sessions via HID touch primitives

The Limrun iOS interactor refused longpress as unsupported although the
SDK exposes touchDown, wait, and touchUp for exactly this composition.
Hold one touch as a single performActions batch so the duration runs
on the device, default to the 800 ms the Android and Linux interactors
use, and admit the longPress fact on the iOS leg.

Author: okwasniewski

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+- Added (limrun): `longpress` on Limrun iOS direct sessions. The interactor refused it as
+  unsupported although the SDK exposes the HID primitives; it now holds one touch as a
+  `performActions` batch of `touchDown`, `wait`, `touchUp`, defaulting to the 800 ms the Android
+  and Linux interactors use when no duration is given.
 - Added (ios): `type` and `fill` work in the Apple Pay sheet on iOS Simulator instead of failing
   with `TEXT_INPUT_NOT_FOCUSED`. `com.apple.PassbookUIService` is served in place like the web
   sign-in host (#2438).

packages/provider-limrun/src/interaction-operations.test.ts

@@ -8,6 +8,7 @@ import {
   limrunSettingsOperationFacts,
   limrunAppSwitcherOperationFacts,
   limrunClipboardOperationFacts,
+  limrunInteractionOperationFacts,
   limrunNavigationOperationFacts,
 } from './interaction-operations.ts';
 
@@ -212,3 +213,13 @@ test('binding omits every operation an unavailable fact refused', () => {
   expect(operations.home).toBeUndefined();
   expect(operations.tvRemote).toBeUndefined();
 });
+
+test('long press is admitted on both direct-session legs and closed with a dead session', () => {
+  expect(limrunInteractionOperationFacts(iosDevice).longPressPoint).toEqual({ available: true });
+  expect(limrunInteractionOperationFacts(androidMobileDevice).longPressPoint).toEqual({
+    available: true,
+  });
+  expect(limrunInteractionOperationFacts(iosDevice, liveSessionUnavailable).longPressPoint).toEqual(
+    liveSessionUnavailable,
+  );
+});

packages/provider-limrun/src/interaction-operations.ts

@@ -164,7 +164,7 @@ export function limrunInteractionOperationFacts(
     ...touchRuntimeOperationFacts({
       unsupported: unsupportedTouch,
       tap: cell,
-      longPress: liveSessionUnavailable ?? (isIosFamily(device) ? unsupportedTouch : cell),
+      longPress: cell,
       // A dead session refuses hover for its own reason; the family builder adds the redirection
       // to longpress either way.
       hover: liveSessionUnavailable ?? unsupportedTouch,

packages/provider-limrun/src/ios-interactor-long-press.test.ts

@@ -0,0 +1,50 @@
+import { expect, test, vi } from 'vitest';
+import { createLimrunIosInteractor, type LimrunIosSession } from './ios.ts';
+
+function sessionWithClient() {
+  const client = {
+    tap: vi.fn(async () => {}),
+    performActions: vi.fn(async () => ({ results: [] })),
+  };
+  const session = {
+    platform: 'ios',
+    instanceId: 'limrun-long-press-instance',
+    client,
+  } as unknown as LimrunIosSession;
+  return { interactor: createLimrunIosInteractor(session), client };
+}
+
+test('long press holds one touch on the device for the requested duration', async () => {
+  const { interactor, client } = sessionWithClient();
+
+  await interactor.longPress(120, 340, 1200);
+
+  expect(client.performActions).toHaveBeenCalledTimes(1);
+  expect(client.performActions).toHaveBeenCalledWith([
+    { type: 'touchDown', x: 120, y: 340 },
+    { type: 'wait', durationMs: 1200 },
+    { type: 'touchUp', x: 120, y: 340 },
+  ]);
+  expect(client.tap).not.toHaveBeenCalled();
+});
+
+test('an omitted duration holds for the 800 ms the other interactors default to', async () => {
+  const { interactor, client } = sessionWithClient();
+
+  await interactor.longPress(40, 60);
+
+  expect(client.performActions).toHaveBeenCalledWith([
+    { type: 'touchDown', x: 40, y: 60 },
+    { type: 'wait', durationMs: 800 },
+    { type: 'touchUp', x: 40, y: 60 },
+  ]);
+});
+
+test('a batch the device rejects surfaces as the long press failure', async () => {
+  const { interactor, client } = sessionWithClient();
+  client.performActions.mockRejectedValueOnce(new Error('touchDown: no foreground application'));
+
+  await expect(interactor.longPress(120, 340, 500)).rejects.toThrow(
+    'touchDown: no foreground application',
+  );
+});

packages/provider-limrun/src/ios.ts

@@ -217,8 +217,17 @@ class LimrunIosInteractor implements Interactor {
     await this.tap(x, y);
   }
 
-  async longPress(): Promise<never> {
-    throw unsupported('longpress', 'Limrun iOS direct sessions do not expose long press yet.');
+  /** One held touch as HID primitives; the hold runs on the device, not across the wire. */
+  async longPress(
+    x: number,
+    y: number,
+    durationMs = DEFAULT_LONG_PRESS_DURATION_MS,
+  ): Promise<void> {
+    await this.session.client.performActions([
+      { type: 'touchDown', x, y },
+      { type: 'wait', durationMs },
+      { type: 'touchUp', x, y },
+    ]);
   }
 
   async focus(x: number, y: number): Promise<void> {
@@ -401,6 +410,9 @@ function inferAppNameFromPath(appPath: string): string | undefined {
 
 const IOS_APP_INVENTORY_RETRY_DELAYS_MS = [0, 250] as const;
 
+/** Hold applied when the caller names no duration; matches the Android and Linux interactors. */
+const DEFAULT_LONG_PRESS_DURATION_MS = 800;
+
 function resolveInstalledIosAppId(params: {
   resultBundleId?: string;
   requestedBundleId?: string;