@e2e-dev/mobile 0.8.0-canary-20260928184528

package/dist/surface.d.ts

@@ -0,0 +1,405 @@
+/**
+ * The agent-device surface: one simulator or emulator session, driven through
+ * agent-device's typed client, exposed to the runner as the contract's
+ * observe/locate/perform members. It owns the id space (one fresh generation
+ * per observation), the attempt state (artifact directory, screenshot
+ * counter), and every translation between the contract's vocabulary and
+ * agent-device's commands. Its device and session come from the target's
+ * `DevicePool`, by worker slot. The runner owns everything else.
+ *
+ * Every observation is reported under one root of a stable id (`ROOT_ID`)
+ * wrapping the device's top-level elements; a `swipe` performed on that root
+ * scrolls the whole screen.
+ */
+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, ClientFactory, DevicePermission, LaunchPermissions, MobileOptions, PermissionState } from './options.ts';
+import { DevicePool } from './pool.ts';
+/** How `installApp` puts a build on the device. */
+export interface InstallAppOptions {
+    /**
+     * Bundle id or package of the build. `reinstall` needs one: agent-device
+     * removes that app before installing. Defaults to the pinned app.
+     */
+    readonly app?: string;
+    /** Remove the installed app first so the build starts with no data. */
+    readonly reinstall?: boolean;
+}
+/** What an install put on the device, as agent-device identified it. */
+export interface InstalledApp {
+    /** The bundle id or package to open the app by. */
+    readonly app: string;
+    readonly bundleId?: string;
+}
+/** How `device.openApp` launches an app. */
+export interface OpenAppOptions {
+    /** Terminate the app first, so it starts fresh; without it a running app is brought forward as it is. */
+    readonly relaunch?: boolean;
+    /**
+     * Arguments this launch hands the app: its process arguments on iOS,
+     * `am start` arguments on Android. Replaces the engine's `launchArguments`
+     * for a relaunch of the pinned app.
+     */
+    readonly launchArguments?: readonly string[];
+    /**
+     * Permissions the app holds before this launch, each granted, denied, or
+     * reset. Replaces the engine's `permissions` for a relaunch of the pinned
+     * app.
+     */
+    readonly permissions?: LaunchPermissions;
+}
+/** What agent-device is told about settling after an action. */
+type SettleOptions = {
+    readonly settle: true;
+    readonly settleQuietMs: number;
+} | Record<never, never>;
+export declare class AgentDeviceSurface {
+    readonly options: MobileOptions;
+    private readonly createClient;
+    private client;
+    private attempt;
+    /** The device this worker drives, the pool's binding for its slot; undefined leaves the choice to agent-device. */
+    private device;
+    private generation;
+    private readonly located;
+    private idCounter;
+    private appIdentity;
+    /**
+     * The app this worker's agent-device session is on, and so the app a
+     * permission command there acts on: what the warm-up in `prepare` opened
+     * under the session this worker resumed, while that session is still open,
+     * then whatever this surface last opened. Undefined while nothing has been opened in the session, and once
+     * `closeApp` ended it.
+     */
+    private sessionApp;
+    /** The app the build `appPath` installed, once `init` has, itself or through a lease. */
+    private installedApp;
+    /** Where relative build paths resolve; the run's project root once init has told us. */
+    private projectRoot;
+    /** The session and device this worker drives, for the error messages whose recovery is per device; set in init. */
+    private where;
+    /**
+     * Commands still running on the device. agent-device takes no abort
+     * signal, so a cancelled or timed-out call is only abandoned by its
+     * caller; it keeps executing. The next attempt waits for these to settle
+     * before it opens anything, so a ghost tap can never land in a retry.
+     */
+    private readonly inflight;
+    /** The target's devices, one per worker slot; `init` takes this worker's from it. */
+    readonly pool: DevicePool;
+    /** The settle wait every action carries: quiet window from the `settle` option, or nothing when it is `false`. */
+    readonly settleOptions: SettleOptions;
+    /** When this surface last acted on the device (an input or an app launch); the screen may be in transition for a while after. */
+    private lastActionAt;
+    /** The screen as last projected before that action, to tell controls that were already there from ones that came with it. */
+    private indexBeforeAction;
+    /** The most recent projection of the screen, from any observe or locate. */
+    private latestIndex;
+    /** Budget a control that came with the last action gets to finish arriving; see DEFAULT_TRANSITION_MS. */
+    private readonly transitionMs;
+    /**
+     * The screen's logical size as last learned from a snapshot with geometry
+     * or from the device itself, so a snapshot without geometry (an empty
+     * screen before any app is open, a sparse tree) still reports the viewport
+     * every observation must carry.
+     */
+    private knownViewport;
+    constructor(options: MobileOptions, createClient: ClientFactory);
+    /** Whether the manifest declares app restart and state clearing. */
+    get managesApp(): boolean;
+    /** The app `app.open()` launches: the `app` option, else the build `appPath` installed. */
+    get pinnedApp(): string | undefined;
+    /** Whether an attempt is running on this surface right now. */
+    get attemptRunning(): boolean;
+    /** The live client; INVALID_STATE before init or after dispose. */
+    requireClient(): AgentDeviceClient;
+    /**
+     * Runs one agent-device command under an operation budget and translates
+     * its failure. Contributed-fixture methods route through here too, so the
+     * device fixture never carries its own error mapping.
+     */
+    command<T>(label: string, run: (client: AgentDeviceClient) => Promise<T>, signal?: AbortSignal): Promise<T>;
+    /**
+     * Runs a fixture command that changes the screen (a back, the home screen,
+     * a dismissed alert or keyboard, a rotation) and records it as an action,
+     * so a control that arrives with the change waits out the transition
+     * budget before a test acts on it, as it does after a tap. Without this a
+     * `device.back()` followed by a tap lands where the returning screen has
+     * not yet arrived.
+     */
+    screenCommand<T>(label: string, run: (client: AgentDeviceClient) => Promise<T>, signal: AbortSignal): Promise<T>;
+    /** Registers one device command as in flight until it settles. */
+    private track;
+    /**
+     * Waits for every abandoned command to settle, within the caller's
+     * budget. A command that never settles fails the attempt launch instead of
+     * racing it: the launch timeout is the honest bound on a stuck device.
+     */
+    private settleInflight;
+    /** The device selection this worker's commands take. */
+    private selection;
+    init(info: EngineInitInfo): Promise<void>;
+    /**
+     * The app the warm-up left the slot's session on, while agent-device still
+     * holds that session. Only the slot's first worker finds it: a worker
+     * retired after a failing test closed it in `dispose`, and a permission
+     * command on a closed session reaches no device. A session not listed, or
+     * a list that fails, leaves the app unknown, and the first permission
+     * change opens it again.
+     */
+    private resumedSessionApp;
+    startAttempt(context: EngineAttemptContext): Promise<void>;
+    endAttempt(context: EngineCleanupContext): Promise<void>;
+    /**
+     * Asks the device to record its screen into the attempt directory. Taps stay
+     * visible in the recording (agent-device's touch indicator), which is the
+     * closest a phone comes to a cursor.
+     */
+    startVideo(operation: OperationContext): Promise<void>;
+    /** Stops the recording and returns its one segment, or none when the device wrote nothing. */
+    stopVideo(operation: OperationContext): Promise<readonly VideoSegment[]>;
+    dispose(context: EngineCleanupContext): Promise<void>;
+    /**
+     * Opens an app in the session, remembering its identity for the path
+     * anchor. A link is refused before the device sees it: agent-device would
+     * open it as a URL, and `openLink` is the path that carries the
+     * navigation rule.
+     */
+    openApp(app: string, options: OpenAppOptions, signal: AbortSignal): Promise<void>;
+    /** One `open` of an app, remembered as the session's app and as the screen's replacement. */
+    private open;
+    /**
+     * Puts an app's permissions in place before it launches. agent-device sets
+     * a permission on the app its session is on, so a session on another app,
+     * or on none yet, is first brought onto this one with a foreground open;
+     * the warm-up in `prepare` did that for the pinned app under the session
+     * this worker resumed, so its first launch needs none. Before the launch,
+     * never after: iOS terminates a running app whose
+     * permission changed, and Android one whose permission was revoked, so a
+     * change after the launch would leave the test on no screen.
+     */
+    private presetPermissions;
+    /**
+     * One permission change for `device.setPermission`: on the app the session
+     * is on, which is what agent-device acts on. With none known here (nothing
+     * opened yet, `closeApp`, a worker resumed on a bare session) the pinned
+     * app is brought to the foreground first. agent-device's own refusal, met
+     * when its session lost the app since (a failed attempt left it on none),
+     * gets the same foreground open and the command once more.
+     */
+    setPermission(permission: DevicePermission, state: PermissionState, signal: AbortSignal): Promise<void>;
+    private permission;
+    /**
+     * Opens a link on the device, into `app` (the pinned app when none is
+     * named). Bound to an app, agent-device hands the link to it and the
+     * session observes that app afterwards: iOS launches the app first for a
+     * web link and then opens the URL, Android starts a VIEW intent on the
+     * package. Without an app the OS routes the link to the scheme's app, a
+     * verified app link owner, or the browser. iOS needs the app: an unbound
+     * `open <url>` there leaves no app session, so the next snapshot would
+     * fail, and agent-device refuses a deep link without one on a physical
+     * device anyway. An unbound open reports the URL as its app name, which is
+     * no identity, and the package that took the link as its bundle id when
+     * the OS told it; the next snapshot names the foreground app either way.
+     */
+    openLink(url: URL, app: string | undefined, signal: AbortSignal): Promise<void>;
+    /**
+     * What a launch leaves behind. The identity is the app agent-device named;
+     * a link the OS routed keeps the last known one until the next snapshot
+     * reports the foreground app.
+     */
+    private launched;
+    /**
+     * Forgets the screen after a launch or a close. There is no screen before
+     * it worth matching against: every control of whatever shows next is
+     * arriving, whatever the previous screen looked like, and none of its
+     * bindings names a node that still exists.
+     */
+    private screenReplaced;
+    /**
+     * Terminates the session's app, then ends the session. agent-device's bare
+     * `close` ends the session and leaves the app running, so the next
+     * `openApp` would resume it mid-flow; a close that names the app
+     * terminates it first. The app is the one the session last observed, else
+     * the pinned one; with neither known there is nothing to terminate and
+     * only the session ends.
+     */
+    closeApp(signal: AbortSignal): Promise<void>;
+    /**
+     * Installs a build on the session's device. `reinstall` removes the app
+     * named by `options.app` (else the pinned app) first, so the build starts
+     * with no data; a plain install replaces the binary and keeps its data.
+     */
+    installApp(appPath: string | undefined, options: InstallAppOptions, signal: AbortSignal): Promise<InstalledApp>;
+    private snapshot;
+    /**
+     * One capture, taken again once when the iOS runner acquired the tree but
+     * failed its own presentation check on it (a viewport it could not read, a
+     * malformed graph). The check is per capture and a capture is a read, so
+     * the retry is safe; a second failure is the runner's and propagates.
+     */
+    private capture;
+    /**
+     * Snapshot for an observation. Without a pinned app, an observation before
+     * anything is open is an empty screen rather than a fault: the model's next
+     * move is the open tool, and failing the step would take that move away.
+     */
+    private snapshotOrEmpty;
+    private project;
+    /**
+     * The viewport of a snapshot: its own geometry, else the last one this
+     * session learned, else the device's logical screen size read off one
+     * screenshot. A device whose size cannot be learned fails the observation:
+     * the harness measures every rect and point against the viewport, so an
+     * invented one would misplace every tap.
+     */
+    private viewportFor;
+    /** The device's logical screen size as its screenshot reports it; undefined when it reports none. */
+    private probeViewport;
+    observe(operation: OperationContext, options?: EngineObserveOptions): Promise<EngineSnapshot>;
+    /** Retains only action bindings for matches, independently of the observation generation. */
+    locate(expression: LocatorExpression, operation: OperationContext): Promise<readonly SemanticNode[]>;
+    private resolveRef;
+    private actionTarget;
+    /**
+     * The node a toggle press must land on. UIKit reports a settings row as a
+     * labelled `Switch` spanning the whole row with the real control as an
+     * unlabelled `Switch` child at its trailing edge; a press at the row's
+     * centre hits the label and changes nothing. The innermost same-role
+     * descendant with a ref is the control; a node without one is its own.
+     */
+    private controlOf;
+    /** Copies the fields actions use and pre-resolves a toggle's inner control. */
+    private bind;
+    /**
+     * The node a binding stands for, in a fresh snapshot: same role, same test
+     * id, same name and text, and of those the one closest to where it was.
+     */
+    private refind;
+    /**
+     * Lets a control that came with the last action finish arriving before a
+     * test acts on it, and answers the binding to act on. A control already
+     * present at the same place in the snapshot the last action was resolved
+     * from is not in transition and is acted on at once; anything else waits
+     * out the remainder of the transition budget since that action and is then
+     * found again in a fresh snapshot. The budget is the only signal that the
+     * transition is over, since the tree cannot tell a sliding control from a
+     * landed one; the fresh snapshot is where the control landed. Android
+     * reports a window's frames while it slides in, so a ref resolved
+     * mid-flight would send the action where the control was: below the
+     * screen, for a modal rising from the bottom.
+     */
+    private settled;
+    /** The same control in a fresh snapshot; the binding as it was when the snapshot no longer lists it. */
+    private relocated;
+    /**
+     * Records an action the device received: the screen as it was projected
+     * before it, and when it returned. The transition budget counts from the
+     * return, since the input lands late in the command's own round trip.
+     */
+    private markAction;
+    perform(ref: NodeRef, action: LocatorAction, operation: OperationContext): 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
+     * into the focused field. agent-device exposes no key event bus, so
+     * modifiers and the other named keys (`Escape`, `Tab`, `Backspace`, the
+     * arrows) have nothing to land on and are refused.
+     */
+    private pressKey;
+    /**
+     * One pointer action at a screen point in logical pixels, the space every
+     * 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>;
+    /**
+     * 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
+     * device primitive without a target, so it is refused rather than faked:
+     * the model clears a listed field by filling it by id.
+     */
+    typeText(text: string, options: {
+        readonly replace: boolean;
+    }, operation: OperationContext): 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>;
+    /**
+     * 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
+     * keyboard has none (an iPhone), because a touch outside the keyboard is a
+     * guess about the screen it never makes on a caller's behalf. The engine
+     * makes that guess, the way a user does and Maestro's `hideKeyboard` does,
+     * in {@link dismissKeyboardByGesture}.
+     */
+    dismissKeyboard(signal: AbortSignal): 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
+     * dismissal, each followed by a fresh look at whether the keyboard is still
+     * there. Horizontal first: on a vertical scroll view it is no scroll, so
+     * React Native's scroll view takes it as the touch outside the keyboard
+     * that dismisses by default, where a vertical drag scrolls the content and
+     * dismisses only under `keyboardDismissMode="on-drag"`. Vertical second,
+     * for the scroll views that dismiss on a drag alone. Maestro's
+     * `hideKeyboard` drags in the other order, and on a React Native screen
+     * that costs a drag plus the settle after it. The simulator's "Speed up
+     * your typing" tip, which sits over a keyboard the first time it appears,
+     * goes through its Continue button first. A drag is a guess about what sits
+     * at the centre, so the sequence stops the moment the keyboard is gone, and
+     * a keyboard that outlives both drags fails naming what does work. Each
+     * 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.
+     */
+    private dismissKeyboardByGesture;
+    /**
+     * The simulator shows a "Speed up your typing" tip over the keyboard the
+     * first time it appears; its Continue button is the only way past it, and
+     * Maestro's `hideKeyboard` presses it too. Answers the capture after the
+     * press, or the one given when no tip is showing.
+     */
+    private dismissKeyboardTip;
+    back(operation: OperationContext): 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>;
+    /**
+     * Resets the simulator's keychain through agent-device. simctl resets the
+     * whole simulator's, not one app's, and only a simulator has one to reset:
+     * Android is refused before any device command.
+     */
+    clearKeychain(signal: AbortSignal): Promise<void>;
+    /**
+     * A redacted screenshot artifact. The device paints secure fields as dots,
+     * but the last typed character shows in clear, so every secure node's
+     * bounds are painted over before the file is kept. A secure node without
+     * bounds cannot be masked, and an image that cannot be redacted is not
+     * written at all.
+     */
+    screenshot(label: string | undefined, operation: OperationContext): Promise<string>;
+    /** Raw device pixels; cleanup follows the capture even when its caller abandons it. */
+    private rawScreenshot;
+    /**
+     * One screenshot into a temp directory that is removed once `read` has
+     * taken what it needs from the response or the file, even when the caller
+     * abandons the capture.
+     */
+    private captureScreenshot;
+    /**
+     * Screenshot with every secure node on the current screen painted over.
+     * Observes first so the regions describe the screen the pixels show;
+     * throws when a secure field cannot be covered, because an image that may
+     * hold a credential must not leave the engine.
+     */
+    private maskedScreenshot;
+    /**
+     * Viewport pixels for an observation. Best-effort: a screenshot that cannot
+     * be produced or redacted costs the observation its image, not the step.
+     */
+    private capturePixels;
+}
+export {};
+//# sourceMappingURL=surface.d.ts.map

package/dist/surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface.d.ts","sourceRoot":"","sources":["../src/surface.ts"],"names":[],"mappings":"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"}