@e2e-dev/mobile 0.12.1-nightly-20261013094930 → 0.12.1

package/dist/.build.json

@@ -1 +1 @@
-{"version":"0.12.1-nightly-20261013094930"}
+{"version":"0.12.1"}

package/dist/engine.js

@@ -29,21 +29,23 @@ export function buildEngine(surface) {
         dispose: (context) => surface.dispose(context),
         observe: (operation, options) => surface.observe(operation, options),
         locate: (expression, operation) => surface.locate(expression, operation),
-        perform: (ref, action, operation) => surface.perform(ref, action, operation),
+        // The harness signal does not abort at an operation's budget, so each
+        // input enforces its own; see InputBudget in support.ts.
+        perform: (ref, action, operation) => surface.perform(ref, action, operation, surface.inputBudget(action.kind, operation.timeoutMs)),
         actions: DEVICE_ACTIONS,
-        performAt: (point, action, operation) => surface.performAt(point, action, operation),
+        performAt: (point, action, operation) => surface.performAt(point, action, operation, surface.inputBudget(action.kind, operation.timeoutMs)),
         pointerActions: DEVICE_POINTER_ACTIONS,
         keyboard: {
-            type: (text, keyboardOptions, operation) => surface.typeText(text, keyboardOptions, operation),
-            press: (key, operation) => surface.pressFocusedKey(key, operation),
-            dismiss: (operation) => surface.dismissKeyboard(operation.signal),
+            type: (text, keyboardOptions, operation) => surface.typeText(text, keyboardOptions, operation, surface.inputBudget('type', operation.timeoutMs)),
+            press: (key, operation) => surface.pressFocusedKey(key, operation, surface.inputBudget('press', operation.timeoutMs)),
+            dismiss: (operation) => surface.dismissKeyboard(operation.signal, surface.inputBudget('keyboard dismiss', operation.timeoutMs)),
         },
         validateApp: (app, info) => validateApp(app, info, surface.options.platform),
         // No `open`: a device app has no URL to open, so the runner serves
         // `app.open()` with `restart`, the fresh launch of the pinned app, which
         // is also the device's "recreate the context".
         session: {
-            back: (operation) => surface.back(operation),
+            back: (operation) => surface.back(operation, surface.inputBudget('back', operation.timeoutMs)),
             restart: (operation) => surface.restart(operation),
             reset: (operation) => surface.reset(operation),
         },

package/dist/errors.d.ts

@@ -14,8 +14,10 @@
  * | anything else, agent-device's own timeouts included         | ENGINE_FAILURE with the text |
  *
  * `OPERATION_TIMEOUT` is never produced here. In the contract it means the
- * harness budget expired, which `raceAbort` already reports, and core
- * replaces its message with a bare `operation timed out`. A timeout
+ * operation budget expired: `InputBudget` (support.ts) reports it for an input
+ * the budget ran out before, and `ACTION_MAY_HAVE_COMMITTED` for one sent that
+ * did not answer in time. Core replaces the timeout's message with a bare
+ * `operation timed out`. A timeout
  * agent-device itself reports (a simulator boot, the runner connecting, an
  * app launch) is a device-side fault whose text is the diagnosis, so it
  * stays `ENGINE_FAILURE` and keeps its message and hint.

package/dist/errors.js

@@ -14,8 +14,10 @@
  * | anything else, agent-device's own timeouts included         | ENGINE_FAILURE with the text |
  *
  * `OPERATION_TIMEOUT` is never produced here. In the contract it means the
- * harness budget expired, which `raceAbort` already reports, and core
- * replaces its message with a bare `operation timed out`. A timeout
+ * operation budget expired: `InputBudget` (support.ts) reports it for an input
+ * the budget ran out before, and `ACTION_MAY_HAVE_COMMITTED` for one sent that
+ * did not answer in time. Core replaces the timeout's message with a bare
+ * `operation timed out`. A timeout
  * agent-device itself reports (a simulator boot, the runner connecting, an
  * app launch) is a device-side fault whose text is the diagnosis, so it
  * stays `ENGINE_FAILURE` and keeps its message and hint.

package/dist/support.d.ts

@@ -12,6 +12,34 @@ export interface Rect {
     readonly height: number;
 }
 export declare function cancelled(text: string): EngineError;
+/**
+ * One input operation's budget (`actionTimeout`, or the call's `timeout`),
+ * which the harness signal does not enforce. Only the device commands that
+ * send input run under it; reads stay unbounded, so a locator poll keeps its
+ * last snapshot and a target settling before a tap is relocated in full.
+ */
+export declare class InputBudget {
+    private readonly label;
+    private readonly track;
+    private readonly endsAt;
+    private sent;
+    /**
+     * `track` keeps the device command itself in flight, past a timeout that
+     * abandons it, until it settles. The callers' own tracking settles with the
+     * race, so this is the registration the next attempt waits on.
+     */
+    constructor(label: string, timeoutMs: number, track: <T>(pending: Promise<T>) => Promise<T>);
+    /**
+     * Sends one input with what is left of the budget. With none left it sends
+     * nothing: `OPERATION_TIMEOUT`, or `ACTION_MAY_HAVE_COMMITTED` once an
+     * earlier input of this operation went out. A gesture that holds (`holdMs`)
+     * at least as long as the budget left could only be cut off mid-gesture, so
+     * it is refused unsent. An input that does not answer in time may have
+     * landed, so it is `ACTION_MAY_HAVE_COMMITTED` and the runner never repeats it.
+     */
+    send<T>(dispatch: () => Promise<T>, holdMs?: number): Promise<T>;
+    private maybeCommitted;
+}
 export declare function invalidState(text: string): EngineError;
 export declare function notActionable(text: string): EngineError;
 export declare function unsupported(text: string): EngineError;

package/dist/support.js

@@ -1,8 +1,60 @@
 /** Shared helpers for the agent-device engine: error constructors, filenames, PNG headers, gestures, the screen location and size. */
-import { EngineError } from 'e2e/engine';
+import { EngineError, withTimeout } from 'e2e/engine';
 export function cancelled(text) {
     return new EngineError('CANCELLED', text, { retryable: false });
 }
+/**
+ * The least time an input gets to answer once sent, however little budget
+ * was left: a tap that lands is then not reported as cut off.
+ */
+const MIN_ANSWER_MS = 250;
+/**
+ * One input operation's budget (`actionTimeout`, or the call's `timeout`),
+ * which the harness signal does not enforce. Only the device commands that
+ * send input run under it; reads stay unbounded, so a locator poll keeps its
+ * last snapshot and a target settling before a tap is relocated in full.
+ */
+export class InputBudget {
+    label;
+    track;
+    endsAt;
+    sent = false;
+    /**
+     * `track` keeps the device command itself in flight, past a timeout that
+     * abandons it, until it settles. The callers' own tracking settles with the
+     * race, so this is the registration the next attempt waits on.
+     */
+    constructor(label, timeoutMs, track) {
+        this.label = label;
+        this.track = track;
+        this.endsAt = Date.now() + timeoutMs;
+    }
+    /**
+     * Sends one input with what is left of the budget. With none left it sends
+     * nothing: `OPERATION_TIMEOUT`, or `ACTION_MAY_HAVE_COMMITTED` once an
+     * earlier input of this operation went out. A gesture that holds (`holdMs`)
+     * at least as long as the budget left could only be cut off mid-gesture, so
+     * it is refused unsent. An input that does not answer in time may have
+     * landed, so it is `ACTION_MAY_HAVE_COMMITTED` and the runner never repeats it.
+     */
+    send(dispatch, holdMs = 0) {
+        const remaining = this.endsAt - Date.now();
+        if (remaining <= 0) {
+            return Promise.reject(this.sent ? this.maybeCommitted() : new EngineError('OPERATION_TIMEOUT', `${this.label} timed out before it was sent`, { retryable: false }));
+        }
+        if (holdMs >= remaining) {
+            return Promise.reject(new EngineError('NOT_ACTIONABLE', `${this.label} holds for ${holdMs} ms, but only ${Math.floor(remaining)} ms of its timeout are left; raise the timeout or shorten the hold`, { retryable: false }));
+        }
+        const pending = this.track(dispatch());
+        this.sent = true;
+        return withTimeout(pending, Math.max(remaining, MIN_ANSWER_MS), () => this.maybeCommitted());
+    }
+    maybeCommitted() {
+        return new EngineError('ACTION_MAY_HAVE_COMMITTED', `${this.label} timed out before the device answered; its input may have been dispatched`, {
+            retryable: false,
+        });
+    }
+}
 export function invalidState(text) {
     return new EngineError('INVALID_STATE', text, { retryable: false });
 }

package/dist/surface.d.ts

@@ -14,6 +14,7 @@
 import { type EngineAttemptContext, type EngineCleanupContext, type EngineInitInfo, type EngineObserveOptions, type EngineSnapshot, type LocatorAction, type LocatorExpression, type NodeRef, type OperationContext, type PointerAction, type VideoSegment, type SemanticNode, type ViewportPoint } from 'e2e/engine';
 import { type AgentDeviceClient, type ClientFactory, type DevicePermission, type LaunchPermissions, type MobileOptions, type PermissionState } from './options.ts';
 import { DevicePool } from './pool.ts';
+import { InputBudget } from './support.ts';
 /** Hinge poses `device.fold` accepts: `closed` lights the outer display, `half-open` and `open` the inner one. */
 export type FoldPose = 'closed' | 'half-open' | 'open';
 /** How `installApp` puts a build on the device. */
@@ -138,6 +139,8 @@ export declare class AgentDeviceSurface {
      * not yet arrived.
      */
     screenCommand<T>(label: string, run: (client: AgentDeviceClient) => Promise<T>, signal: AbortSignal): Promise<T>;
+    /** The budget one input runs under; its device commands stay in flight until they settle. */
+    inputBudget(label: string, timeoutMs: number): InputBudget;
     /** Registers one device command as in flight until it settles. */
     private track;
     /**
@@ -313,7 +316,7 @@ export declare class AgentDeviceSurface {
      * return, since the input lands late in the command's own round trip.
      */
     private markAction;
-    perform(ref: NodeRef, action: LocatorAction, operation: OperationContext): Promise<void>;
+    perform(ref: NodeRef, action: LocatorAction, operation: OperationContext, input: InputBudget): Promise<void>;
     /**
      * Keys on a touch surface, in the contract's key grammar: `Enter` submits
      * through the soft keyboard, `Space` and any single character are typed
@@ -327,7 +330,7 @@ export declare class AgentDeviceSurface {
      * node's bounds are in, with no element resolved behind it. `settle` waits
      * for the UI to go quiet, as the node taps do.
      */
-    performAt(point: ViewportPoint, action: PointerAction, operation: OperationContext): Promise<void>;
+    performAt(point: ViewportPoint, action: PointerAction, operation: OperationContext, input: InputBudget): Promise<void>;
     /**
      * Types into whatever holds focus through the device's text-input path;
      * agent-device's `type` lands on the focused field. `replace` is not a
@@ -336,13 +339,13 @@ export declare class AgentDeviceSurface {
      */
     typeText(text: string, options: {
         readonly replace: boolean;
-    }, operation: OperationContext): Promise<void>;
+    }, operation: OperationContext, input: InputBudget): Promise<void>;
     /**
      * One key to the focused field, with the same reach as a node press: Enter
      * submits through the soft keyboard, Space and single characters are typed.
      * Modifiers and the other named keys have no event bus to land on.
      */
-    pressFocusedKey(key: string, operation: OperationContext): Promise<void>;
+    pressFocusedKey(key: string, operation: OperationContext, input: InputBudget): Promise<void>;
     /**
      * Hides the soft keyboard, so a control it covered can be reached.
      * agent-device presses the keyboard's own dismiss key and refuses when the
@@ -351,7 +354,7 @@ export declare class AgentDeviceSurface {
      * makes that guess, the way a user does and Maestro's `hideKeyboard` does,
      * in {@link dismissKeyboardByGesture}.
      */
-    dismissKeyboard(signal: AbortSignal): Promise<void>;
+    dismissKeyboard(signal: AbortSignal, input?: InputBudget): Promise<void>;
     /**
      * A keyboard with no dismiss key goes the way a user sends it away: a short
      * drag at the centre of the screen, which a scroll view turns into a
@@ -378,7 +381,7 @@ export declare class AgentDeviceSurface {
      * press, or the one given when no tip is showing.
      */
     private dismissKeyboardTip;
-    back(operation: OperationContext): Promise<void>;
+    back(operation: OperationContext, input: InputBudget): Promise<void>;
     restart(operation: OperationContext): Promise<void>;
     /** Clears the pinned app's persisted state and relaunches it: the device equivalent of a fresh context. */
     reset(operation: OperationContext): Promise<void>;

package/dist/surface.js

@@ -25,7 +25,7 @@ import { deviceLabel, pinnedApp } from './bindings.js';
 import { assertAppId } from './links.js';
 import { DevicePool, deviceSelection } from './pool.js';
 import { recordLease, travelledLease } from './provider.js';
-import { invalidState, notActionable, logicalScreenSize, readPngSize, sanitizeFilename, screenLocation, swipeWithin, unsupported, } from './support.js';
+import { invalidState, notActionable, logicalScreenSize, readPngSize, sanitizeFilename, screenLocation, swipeWithin, unsupported, InputBudget, } from './support.js';
 /** Why nothing is pinned with `appPath` alone: the install is the suite's. */
 const UNINSTALLED_BUILD = "the build the target's `app.appPath` names installed first with `device.installApp()`";
 /** Platform element types that are the soft keyboard or one of its keys, as agent-device names them. */
@@ -99,6 +99,10 @@ function depthBelow(entry, ancestor) {
     }
     return hops;
 }
+/** Sends an input under its operation's budget, or directly from a fixture call, which has none. */
+function sendInput(input, dispatch) {
+    return input === undefined ? dispatch() : input.send(dispatch);
+}
 function sleep(ms, signal) {
     return new Promise((resolve) => {
         const timer = setTimeout(done, ms);
@@ -276,6 +280,10 @@ export class AgentDeviceSurface {
         this.markAction(before);
         return result;
     }
+    /** The budget one input runs under; its device commands stay in flight until they settle. */
+    inputBudget(label, timeoutMs) {
+        return new InputBudget(label, timeoutMs, (pending) => this.track(pending));
+    }
     /** Registers one device command as in flight until it settles. */
     track(pending) {
         this.inflight.add(pending);
@@ -853,7 +861,7 @@ export class AgentDeviceSurface {
         this.indexBeforeAction = before;
         this.lastActionAt = Date.now();
     }
-    async perform(ref, action, operation) {
+    async perform(ref, action, operation, input) {
         // A test's step verifies its outcome with `expect`, so it never waits for
         // the screen to settle afterwards; it only lets a control that came with
         // the last action finish arriving. The agent reads the screen right after
@@ -872,7 +880,7 @@ export class AgentDeviceSurface {
             if (action.kind !== 'swipe')
                 throw notActionable(`the screen root takes swipe only, not ${action.kind}; act on a node`);
             const before = this.latestIndex;
-            await this.command('swipe', (client) => client.interactions.scroll({ direction: action.direction, ...settle }), operation.signal);
+            await this.command('swipe', (client) => input.send(() => client.interactions.scroll({ direction: action.direction, ...settle })), operation.signal);
             this.markAction(before);
             return;
         }
@@ -889,26 +897,26 @@ export class AgentDeviceSurface {
             const target = deterministic ? await this.settled(entry, operation) : entry;
             switch (action.kind) {
                 case 'tap':
-                    return client.interactions.press({ ...this.actionTarget(target, true), ...settle });
+                    return input.send(() => client.interactions.press({ ...this.actionTarget(target, true), ...settle }));
                 case 'focus':
                     // A touch surface focuses by tapping, and a tap on anything but an
                     // editable field activates it; focus is offered for fields only.
                     if (target.node.role !== 'textbox') {
                         throw unsupported(`agent-device can only focus editable fields; node ${target.id} is ${target.node.role ?? 'unknown'}`);
                     }
-                    return client.interactions.press({ ...this.actionTarget(target), ...settle });
+                    return input.send(() => client.interactions.press({ ...this.actionTarget(target), ...settle }));
                 case 'doubleTap':
-                    return client.interactions.press({ ...this.actionTarget(target), count: 2, ...settle });
+                    return input.send(() => client.interactions.press({ ...this.actionTarget(target), count: 2, ...settle }));
                 case 'longPress':
-                    return client.interactions.longPress({ ...this.actionTarget(target), ...settle, durationMs: action.durationMs ?? DEFAULT_LONG_PRESS_MS });
+                    return input.send(() => client.interactions.longPress({ ...this.actionTarget(target), ...settle, durationMs: action.durationMs ?? DEFAULT_LONG_PRESS_MS }), action.durationMs ?? DEFAULT_LONG_PRESS_MS);
                 case 'hover':
-                    return client.interactions.hover(this.actionTarget(target));
+                    return input.send(() => client.interactions.hover(this.actionTarget(target)));
                 case 'fill':
                     // oxlint-disable-next-line unicorn/no-array-fill-with-reference-type -- agent-device fill, not Array#fill
-                    return client.interactions.fill({ ...this.actionTarget(target), text: action.value, ...settle });
+                    return input.send(() => client.interactions.fill({ ...this.actionTarget(target), text: action.value, ...settle }));
                 case 'clear':
                     // oxlint-disable-next-line unicorn/no-array-fill-with-reference-type -- agent-device fill, not Array#fill
-                    return client.interactions.fill({ ...this.actionTarget(target), text: '', ...settle });
+                    return input.send(() => client.interactions.fill({ ...this.actionTarget(target), text: '', ...settle }));
                 case 'check':
                 case 'uncheck': {
                     const wanted = action.kind === 'check';
@@ -920,22 +928,22 @@ export class AgentDeviceSurface {
                     }
                     if (checked === wanted)
                         return undefined;
-                    return client.interactions.press({ ...this.actionTarget(target, true), ...settle });
+                    return input.send(() => client.interactions.press({ ...this.actionTarget(target, true), ...settle }));
                 }
                 case 'press':
-                    return this.pressKey(client, target, action.key, settle);
+                    return this.pressKey(client, target, action.key, settle, input);
                 case 'swipe': {
                     const rect = target.node.rect;
                     if (rect === undefined)
                         throw notActionable(`node ${target.id} has no bounds to swipe within`);
-                    return client.interactions.swipe(swipeWithin(rect, action.direction, action.momentum));
+                    return input.send(() => client.interactions.swipe(swipeWithin(rect, action.direction, action.momentum)));
                 }
                 case 'dragTo': {
                     const destination = this.resolveRef(action.target);
-                    return client.interactions.drag({
+                    return input.send(() => client.interactions.drag({
                         source: this.actionTarget(target).ref,
                         destination: this.actionTarget(destination).ref,
-                    });
+                    }));
                 }
                 case 'scrollIntoView':
                 case 'selectOption':
@@ -959,7 +967,7 @@ export class AgentDeviceSurface {
      * modifiers and the other named keys (`Escape`, `Tab`, `Backspace`, the
      * arrows) have nothing to land on and are refused.
      */
-    async pressKey(client, entry, key, settle) {
+    async pressKey(client, entry, key, settle, input) {
         const parsed = parseKey(key);
         if (parsed === undefined) {
             throw unsupported(`"${key}" is not a key: press takes one key in the form [Modifier+]...Key, a named key (${KEY_NAMES.join(', ')}) or one character`);
@@ -968,14 +976,14 @@ export class AgentDeviceSurface {
             throw unsupported(`agent-device cannot hold ${parsed.modifiers.join('+')} on a device surface; press the key alone`);
         }
         if (parsed.key.kind === 'named' && parsed.key.name === 'Enter') {
-            return client.command.keyboard({ action: 'enter' });
+            return input.send(() => client.command.keyboard({ action: 'enter' }));
         }
         if (parsed.key.kind === 'char' || parsed.key.name === 'Space') {
             const text = parsed.key.kind === 'char' ? parsed.key.char : ' ';
             if (entry.node.role === 'textbox' && entry.node.states?.focused !== true) {
-                await client.interactions.press({ ...this.actionTarget(entry), ...settle });
+                await input.send(() => client.interactions.press({ ...this.actionTarget(entry), ...settle }));
             }
-            return client.interactions.type({ text });
+            return input.send(() => client.interactions.type({ text }));
         }
         throw unsupported(`agent-device cannot press ${parsed.key.name} on a device surface; only Enter, Space, and single characters reach the soft keyboard`);
     }
@@ -984,10 +992,11 @@ export class AgentDeviceSurface {
      * node's bounds are in, with no element resolved behind it. `settle` waits
      * for the UI to go quiet, as the node taps do.
      */
-    async performAt(point, action, operation) {
+    async performAt(point, action, operation, input) {
         const settle = operation.origin === 'test' ? {} : this.settleOptions;
         const before = this.latestIndex;
-        await this.command(`${action.kind} at point`, (client) => pointerInteraction(client, point, action, settle), operation.signal);
+        const holdMs = action.kind === 'longPress' ? (action.durationMs ?? DEFAULT_LONG_PRESS_MS) : action.kind === 'swipeTo' ? action.durationMs : undefined;
+        await this.command(`${action.kind} at point`, (client) => input.send(() => pointerInteraction(client, point, action, settle), holdMs), operation.signal);
         this.markAction(before);
     }
     /**
@@ -996,12 +1005,12 @@ export class AgentDeviceSurface {
      * device primitive without a target, so it is refused rather than faked:
      * the model clears a listed field by filling it by id.
      */
-    async typeText(text, options, operation) {
+    async typeText(text, options, operation, input) {
         if (options.replace) {
             throw unsupported('agent-device cannot clear the focused field without a node; type into a listed field by id to replace its value');
         }
         const before = this.latestIndex;
-        await this.command('keyboard.type', (client) => client.interactions.type({ text }), operation.signal);
+        await this.command('keyboard.type', (client) => input.send(() => client.interactions.type({ text })), operation.signal);
         this.markAction(before);
     }
     /**
@@ -1009,7 +1018,7 @@ export class AgentDeviceSurface {
      * submits through the soft keyboard, Space and single characters are typed.
      * Modifiers and the other named keys have no event bus to land on.
      */
-    async pressFocusedKey(key, operation) {
+    async pressFocusedKey(key, operation, input) {
         const parsed = parseKey(key);
         if (parsed === undefined) {
             throw unsupported(`"${key}" is not a key: press takes one key in the form [Modifier+]...Key, a named key (${KEY_NAMES.join(', ')}) or one character`);
@@ -1019,11 +1028,11 @@ export class AgentDeviceSurface {
         }
         const before = this.latestIndex;
         if (parsed.key.kind === 'named' && parsed.key.name === 'Enter') {
-            await this.command('keyboard.press', (client) => client.command.keyboard({ action: 'enter' }), operation.signal);
+            await this.command('keyboard.press', (client) => input.send(() => client.command.keyboard({ action: 'enter' })), operation.signal);
         }
         else if (parsed.key.kind === 'char' || parsed.key.name === 'Space') {
             const text = parsed.key.kind === 'char' ? parsed.key.char : ' ';
-            await this.command('keyboard.press', (client) => client.interactions.type({ text }), operation.signal);
+            await this.command('keyboard.press', (client) => input.send(() => client.interactions.type({ text })), operation.signal);
         }
         else {
             throw unsupported(`agent-device cannot press ${parsed.key.name} on a device surface; only Enter, Space, and single characters reach the soft keyboard`);
@@ -1038,15 +1047,15 @@ export class AgentDeviceSurface {
      * makes that guess, the way a user does and Maestro's `hideKeyboard` does,
      * in {@link dismissKeyboardByGesture}.
      */
-    async dismissKeyboard(signal) {
+    async dismissKeyboard(signal, input) {
         const before = this.latestIndex;
         try {
-            await this.command('keyboard.dismiss', (client) => client.command.keyboard({ action: 'dismiss' }), signal);
+            await this.command('keyboard.dismiss', (client) => sendInput(input, () => client.command.keyboard({ action: 'dismiss' })), signal);
         }
         catch (cause) {
             if (!(cause instanceof EngineError && cause.code === 'UNSUPPORTED_CAPABILITY'))
                 throw cause;
-            await this.dismissKeyboardByGesture(signal);
+            await this.dismissKeyboardByGesture(signal, input);
         }
         this.markAction(before);
     }
@@ -1068,8 +1077,8 @@ export class AgentDeviceSurface {
      * look is the observation's own capture, sparse-tree retries included: a
      * one-node tree has no keys and would pass for a dismissed keyboard.
      */
-    async dismissKeyboardByGesture(signal) {
-        let raw = await this.dismissKeyboardTip(await this.snapshot(signal, false), signal);
+    async dismissKeyboardByGesture(signal, input) {
+        let raw = await this.dismissKeyboardTip(await this.snapshot(signal, false), signal, input);
         if (!keyboardShowing(raw))
             return;
         const projected = projectSnapshot(raw.nodes ?? [], { mintId: () => 'keyboard', viewport: raw.viewport });
@@ -1080,7 +1089,7 @@ export class AgentDeviceSurface {
             { x: centre.x, y: centre.y - viewport.height * KEYBOARD_DRAG_RATIO },
         ];
         for (const to of drags) {
-            await this.command('keyboard.dismiss', (client) => client.interactions.swipe({ from: centre, to }), signal);
+            await this.command('keyboard.dismiss', (client) => sendInput(input, () => client.interactions.swipe({ from: centre, to })), signal);
             raw = await this.snapshot(signal, false);
             if (!keyboardShowing(raw))
                 return;
@@ -1093,7 +1102,7 @@ export class AgentDeviceSurface {
      * Maestro's `hideKeyboard` presses it too. Answers the capture after the
      * press, or the one given when no tip is showing.
      */
-    async dismissKeyboardTip(raw, signal) {
+    async dismissKeyboardTip(raw, signal, input) {
         const nodes = raw.nodes ?? [];
         const tip = nodes.find((node) => (node.label ?? node.value ?? '').startsWith('Speed up your typing'));
         if (tip?.rect === undefined)
@@ -1102,13 +1111,13 @@ export class AgentDeviceSurface {
         const button = nodes.find((node) => node.label === 'Continue' && node.rect !== undefined && node.rect.y > tipTop);
         if (button?.rect === undefined)
             return raw;
-        await this.command('keyboard.dismiss', (client) => client.interactions.press(centreOf(button.rect)), signal);
+        await this.command('keyboard.dismiss', (client) => sendInput(input, () => client.interactions.press(centreOf(button.rect))), signal);
         return await this.snapshot(signal, false);
     }
-    async back(operation) {
+    async back(operation, input) {
         const settle = operation.origin === 'test' ? {} : this.settleOptions;
         const before = this.latestIndex;
-        await this.command('back', (client) => client.command.back({ ...settle }), operation.signal);
+        await this.command('back', (client) => input.send(() => client.command.back({ ...settle })), operation.signal);
         this.markAction(before);
     }
     async restart(operation) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e2e-dev/mobile",
-  "version": "0.12.1-nightly-20261013094930",
+  "version": "0.12.1",
   "description": "Mobile engine (iOS and Android) for e2e agentic end-to-end testing, built on agent-device",
   "keywords": [
     "e2e",
@@ -57,7 +57,7 @@
   },
   "peerDependencies": {
     "ai": "^7.0.0",
-    "e2e": "0.21.0-nightly-20261013094930"
+    "e2e": ">=0.15.0 <1"
   },
   "peerDependenciesMeta": {
     "ai": {
@@ -68,7 +68,7 @@
     "@types/node": "26.6.2",
     "@types/pngjs": "6.0.5",
     "ai": "7.0.107",
-    "e2e": "0.21.0-nightly-20261013094930",
+    "e2e": "0.21.0",
     "typescript": "7.0.2",
     "vitest": "5.0.1"
   },