@qawolf/api-contracts 0.30.0 → 0.33.0

package/dist/v1/index.d.ts

@@ -3,15 +3,7 @@ export type { AnyPublicApiContract, PublicApiContract, PublicApiContractKind, }
 export { type IdentityResponse, identityResponse } from "./identity/index.js";
 export { type PublicIdSchema, type PublicIdSchemas, defaultIdSchemas, } from "./ids.js";
 export { makeFlowSelectionSchema } from "./run/index.js";
-export { type BrowserAction, browserActionSchema, } from "./runner/browserAction.js";
-export { runEnvironmentSchema } from "./runner/environment.js";
-export { isShippableRunFilePath, runFilePathSchema, runPackageJsonPath, shippableRunFileExtensions, } from "./runner/files.js";
-export { type RunnerNameForPublicApi, makeRunnerSchema, runnerIdSchema, runnerNameSchema, } from "./runner/identity.js";
-export { type InspectOnRunnerRequest, inspectRequestSchema, } from "./runner/inspect.js";
-export { type JournalEntry, type JournalStream, type KnownJournalStream, type ReadJournalRequest, type ReadJournalResponse, journalEntrySchema, journalStreamSchema, knownJournalStreams, maxJournalStreamNameLength, readJournalRequestSchema, readJournalResponseSchema, } from "./runner/journal.js";
-export { type RunFiles, maxRunFilesByteLength, maxRunnerRequestEncodedByteLength, runFilesByteLength, runFilesSchema, } from "./runner/payloadSize.js";
-export { maxActionErrorMessageLength } from "./runner/performAction.js";
-export { type RunSelection, runSelectionSchema, } from "./runner/runSelection.js";
+export * from "./runnerReexports.js";
 import type { AnyPublicApiContract } from "./definition.js";
 import { type PublicIdSchema, type PublicIdSchemasOf } from "./ids.js";
 export type PublicApiInput<Api extends AnyPublicApiContract> = z.input<Api["input"]>;
@@ -66,9 +58,9 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
+                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
-                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -122,9 +114,9 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     name: z.ZodString;
                     runConcurrencyLimit: z.ZodString;
                     status: z.ZodEnum<{
+                        ready: "ready";
                         blocked: "blocked";
                         "needs-investigation": "needs-investigation";
-                        ready: "ready";
                         running: "running";
                     }>;
                     terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -159,9 +151,9 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
+                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
-                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -236,9 +228,9 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
+                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
-                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -851,6 +843,210 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 failureReason: z.ZodEnum<{
                     "runner-unreachable": "runner-unreachable";
                     "nothing-to-inspect": "nothing-to-inspect";
+                    "runner-is-not-a-browser": "runner-is-not-a-browser";
+                }>;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>], "outcome">;
+        };
+        inspectMobile: {
+            readonly description: "Inspect one thing on a mobile interactive runner: the Appium session's status, the WebView contexts available, the current context's page source, or the elements at a point or carrying some text. Mobile only — a browser runner answers `runner-is-not-mobile`; call `runner.inspect` for a browser's equivalent surface instead. `what: \"session\"` always answers with the session's own status rather than `screen-needs-a-run`, since that is the question it exists to answer; the other three request kinds need a live session first and answer the same `screen-needs-a-run` or `screen-not-ready` outcomes `runner.performAction` and `runner.takeScreenshot` use, instead of reading anything when there is none. `screen-needs-a-run` means no Appium session has started on this runner yet — call `runner.runFlow` with a flow that opens one, then inspect again. `screen-not-ready` means the runner's Appium session exists but did not answer this instant, or more than one is somehow live — retry once; if it persists, relaunch the runner. `runner-is-not-mobile` means there is nothing here to inspect, and retrying will never help — launch a `node20WithAndroid` or `node20WithIos` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                request: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    what: z.ZodLiteral<"session">;
+                }, z.core.$strip>, z.ZodObject<{
+                    what: z.ZodLiteral<"contexts">;
+                }, z.core.$strip>, z.ZodObject<{
+                    context: z.ZodOptional<z.ZodString>;
+                    what: z.ZodLiteral<"page">;
+                }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    by: z.ZodLiteral<"point">;
+                    context: z.ZodOptional<z.ZodString>;
+                    what: z.ZodLiteral<"elements">;
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                }, z.core.$strip>, z.ZodObject<{
+                    by: z.ZodLiteral<"text">;
+                    context: z.ZodOptional<z.ZodString>;
+                    partial: z.ZodOptional<z.ZodBoolean>;
+                    text: z.ZodString;
+                    what: z.ZodLiteral<"elements">;
+                }, z.core.$strip>], "by">], "what">;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "runner.inspectMobile";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+                outcome: z.ZodLiteral<"success">;
+                session: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    deviceName: z.ZodOptional<z.ZodString>;
+                    platformName: z.ZodString;
+                    sessionId: z.ZodString;
+                    type: z.ZodLiteral<"ready">;
+                }, z.core.$strip>, z.ZodObject<{
+                    error: z.ZodString;
+                    type: z.ZodLiteral<"unreachable">;
+                }, z.core.$strip>, z.ZodObject<{
+                    sessionCount: z.ZodNumber;
+                    type: z.ZodLiteral<"ambiguous">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"no-session">;
+                }, z.core.$strip>], "type">;
+                what: z.ZodLiteral<"session">;
+            }, z.core.$strip>, z.ZodObject<{
+                contexts: z.ZodArray<z.ZodString>;
+                current: z.ZodString;
+                outcome: z.ZodLiteral<"success">;
+                what: z.ZodLiteral<"contexts">;
+            }, z.core.$strip>, z.ZodObject<{
+                context: z.ZodString;
+                orientation: z.ZodEnum<{
+                    PORTRAIT: "PORTRAIT";
+                    LANDSCAPE: "LANDSCAPE";
+                }>;
+                outcome: z.ZodLiteral<"success">;
+                pageSource: z.ZodType<{
+                    selectors: {
+                        strategy: {
+                            name: "xpath";
+                            type: "unique" | "full-path" | "sibling-of" | "parent-of";
+                        } | {
+                            name: "ios-predicate";
+                        } | {
+                            hostSelector: string;
+                            innerSelector: string;
+                            name: "shadow";
+                        };
+                        value: string;
+                    }[];
+                    tag: string;
+                    attributes?: {
+                        bounds?: {
+                            bottom: number;
+                            left: number;
+                            right: number;
+                            top: number;
+                        } | undefined;
+                        rest?: Record<string, string> | undefined;
+                    } | undefined;
+                } & {
+                    children?: (({
+                        selectors: {
+                            strategy: {
+                                name: "xpath";
+                                type: "unique" | "full-path" | "sibling-of" | "parent-of";
+                            } | {
+                                name: "ios-predicate";
+                            } | {
+                                hostSelector: string;
+                                innerSelector: string;
+                                name: "shadow";
+                            };
+                            value: string;
+                        }[];
+                        tag: string;
+                        attributes?: {
+                            bounds?: {
+                                bottom: number;
+                                left: number;
+                                right: number;
+                                top: number;
+                            } | undefined;
+                            rest?: Record<string, string> | undefined;
+                        } | undefined;
+                    } & /*elided*/ any) | string)[];
+                }, unknown, z.core.$ZodTypeInternals<{
+                    selectors: {
+                        strategy: {
+                            name: "xpath";
+                            type: "unique" | "full-path" | "sibling-of" | "parent-of";
+                        } | {
+                            name: "ios-predicate";
+                        } | {
+                            hostSelector: string;
+                            innerSelector: string;
+                            name: "shadow";
+                        };
+                        value: string;
+                    }[];
+                    tag: string;
+                    attributes?: {
+                        bounds?: {
+                            bottom: number;
+                            left: number;
+                            right: number;
+                            top: number;
+                        } | undefined;
+                        rest?: Record<string, string> | undefined;
+                    } | undefined;
+                } & {
+                    children?: (({
+                        selectors: {
+                            strategy: {
+                                name: "xpath";
+                                type: "unique" | "full-path" | "sibling-of" | "parent-of";
+                            } | {
+                                name: "ios-predicate";
+                            } | {
+                                hostSelector: string;
+                                innerSelector: string;
+                                name: "shadow";
+                            };
+                            value: string;
+                        }[];
+                        tag: string;
+                        attributes?: {
+                            bounds?: {
+                                bottom: number;
+                                left: number;
+                                right: number;
+                                top: number;
+                            } | undefined;
+                            rest?: Record<string, string> | undefined;
+                        } | undefined;
+                    } & /*elided*/ any) | string)[];
+                }, unknown>>;
+                what: z.ZodLiteral<"page">;
+            }, z.core.$strip>, z.ZodObject<{
+                matches: z.ZodArray<z.ZodObject<{
+                    attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+                    bounds: z.ZodOptional<z.ZodObject<{
+                        bottom: z.ZodNumber;
+                        left: z.ZodNumber;
+                        right: z.ZodNumber;
+                        top: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    center: z.ZodOptional<z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    selectors: z.ZodArray<z.ZodObject<{
+                        strategy: z.ZodUnion<readonly [z.ZodObject<{
+                            name: z.ZodLiteral<"xpath">;
+                            type: z.ZodEnum<{
+                                unique: "unique";
+                                "full-path": "full-path";
+                                "sibling-of": "sibling-of";
+                                "parent-of": "parent-of";
+                            }>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            name: z.ZodLiteral<"ios-predicate">;
+                        }, z.core.$strip>, z.ZodObject<{
+                            hostSelector: z.ZodString;
+                            innerSelector: z.ZodString;
+                            name: z.ZodLiteral<"shadow">;
+                        }, z.core.$strip>]>;
+                        value: z.ZodString;
+                    }, z.core.$strip>>;
+                    tag: z.ZodString;
+                }, z.core.$strip>>;
+                outcome: z.ZodLiteral<"success">;
+                what: z.ZodLiteral<"elements">;
+            }, z.core.$strip>], "what">, z.ZodObject<{
+                failureReason: z.ZodEnum<{
+                    "runner-unreachable": "runner-unreachable";
+                    "runner-is-not-mobile": "runner-is-not-mobile";
+                    "screen-needs-a-run": "screen-needs-a-run";
+                    "screen-not-ready": "screen-not-ready";
                 }>;
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "outcome">;
@@ -882,7 +1078,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>;
         };
         performAction: {
-            readonly description: "Perform one raw browser action on an interactive runner: click, double_click, move, drag, scroll, keypress, type, or navigate. Coordinates are whole pixels on the runner's virtual desktop, in the same space as `runner.takeScreenshot`. One action per request, and the runner serves one at a time. The action shapes follow the computer-use vocabulary, minus `screenshot` (use `runner.takeScreenshot`) and `wait` (delay on the caller's side). A success means the action took effect. `action-failed`, with a reason, if it reached the runner and did not take effect. On a runner image with a browser, the first action on a runner that has never run anything starts its browser and waits for it, so it can take up to a minute to answer — no `runner.runFlow` is needed before acting; if the browser is still starting when the wait runs out, the answer is `screen-not-ready` and retrying converges. `screen-needs-a-run` if the browser could not be started that way — usually a runner whose runs all finished without starting its desktop; call `runner.runFlow` with a flow that opens a browser. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. A `navigate` does not go through the screen, so a screen that is not ready does not stop it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may have stopped answering mid-action. This does not mean the action was not performed — take a screenshot before repeating it.";
+            readonly description: "Perform one raw browser action on an interactive runner: click, double_click, move, drag, scroll, keypress, type, or navigate. Coordinates are whole pixels on the runner's virtual desktop, in the same space as `runner.takeScreenshot`. One action per request, and the runner serves one at a time. The action shapes follow the computer-use vocabulary, minus `screenshot` (use `runner.takeScreenshot`) and `wait` (delay on the caller's side). A success means the action took effect. `action-failed`, with a reason, if it reached the runner and did not take effect. On a runner image with a browser, the first action on a runner that has never run anything starts its browser and waits for it, so it can take up to a minute to answer — no `runner.runFlow` is needed before acting; if the browser is still starting when the wait runs out, the answer is `screen-not-ready` and retrying converges. On a mobile runner, the same `screen-needs-a-run` and `screen-not-ready` outcomes mean no Appium session has started yet, or it did not answer this instant; `runner.runFlow` is what starts one, same as a browser. `screen-needs-a-run` if the browser could not be started that way — usually a runner whose runs all finished without starting its desktop; call `runner.runFlow` with a flow that opens a browser. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. A `navigate` does not go through the screen, so a screen that is not ready does not stop it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `action-not-supported-on-mobile` if the runner is a mobile device and this action has no touchscreen equivalent: `double_click`, `scroll`, `move`, `keypress` and `navigate`, and a `click` whose `button` is not `left`, are all pointer-device concepts a touchscreen has nothing to offer for. `click` taps, `drag` swipes between its path's first and last point, and `type` types into whatever the last tap focused. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may have stopped answering mid-action. This does not mean the action was not performed — take a screenshot before repeating it.";
             readonly input: z.ZodObject<{
                 action: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     button: z.ZodLiteral<"left" | "right" | "wheel" | "back" | "forward">;
@@ -932,9 +1128,10 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>, z.ZodObject<{
                 failureReason: z.ZodEnum<{
                     "runner-unreachable": "runner-unreachable";
-                    "runner-has-no-screen": "runner-has-no-screen";
                     "screen-needs-a-run": "screen-needs-a-run";
                     "screen-not-ready": "screen-not-ready";
+                    "runner-has-no-screen": "runner-has-no-screen";
+                    "action-not-supported-on-mobile": "action-not-supported-on-mobile";
                 }>;
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "failureReason">], "outcome">;
@@ -955,7 +1152,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     payload: z.ZodUnknown;
                     recordedAt: z.ZodISODateTime;
                     sequence: z.ZodNumber;
-                }, z.core.$strip>, z.ZodTransform<import("./runner/journal.js").JournalEntry<unknown>, {
+                }, z.core.$strip>, z.ZodTransform<import("./runnerReexports.js").JournalEntry<unknown>, {
                     payload: unknown;
                     recordedAt: string;
                     sequence: number;
@@ -1033,7 +1230,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>], "outcome">;
         };
         takeScreenshot: {
-            readonly description: "Take one screenshot of an interactive runner's screen. The image is the runner's whole virtual desktop, browser window and all. `screen-needs-a-run` if the runner's virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` with a flow that opens a browser, then ask for the screen again. On a runner image with a browser that has never run anything, any `runner.performAction` also starts the browser itself. Evaluating a snippet does not start the desktop. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
+            readonly description: "Take one screenshot of an interactive runner's screen. On a runner with a browser the image is the whole virtual desktop, browser window and all. On a mobile runner it is the device's own screen, re-encoded to JPEG on the pod so this contract reads one image format regardless of runner family. `screen-needs-a-run` if the runner's virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` with a flow that opens a browser, then ask for the screen again. On a runner image with a browser that has never run anything, any `runner.performAction` also starts the browser itself. Evaluating a snippet does not start the desktop. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
             }, z.core.$strip>;
@@ -1045,9 +1242,9 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             }, z.core.$strip>, z.ZodObject<{
                 failureReason: z.ZodEnum<{
                     "runner-unreachable": "runner-unreachable";
-                    "runner-has-no-screen": "runner-has-no-screen";
                     "screen-needs-a-run": "screen-needs-a-run";
                     "screen-not-ready": "screen-not-ready";
+                    "runner-has-no-screen": "runner-has-no-screen";
                 }>;
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "outcome">;
@@ -1147,9 +1344,9 @@ export declare const publicContractsV1: {
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
+                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
-                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -1203,9 +1400,9 @@ export declare const publicContractsV1: {
                     name: z.ZodString;
                     runConcurrencyLimit: z.ZodString;
                     status: z.ZodEnum<{
+                        ready: "ready";
                         blocked: "blocked";
                         "needs-investigation": "needs-investigation";
-                        ready: "ready";
                         running: "running";
                     }>;
                     terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -1240,9 +1437,9 @@ export declare const publicContractsV1: {
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
+                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
-                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -1317,9 +1514,9 @@ export declare const publicContractsV1: {
                 name: z.ZodString;
                 runConcurrencyLimit: z.ZodString;
                 status: z.ZodEnum<{
+                    ready: "ready";
                     blocked: "blocked";
                     "needs-investigation": "needs-investigation";
-                    ready: "ready";
                     running: "running";
                 }>;
                 terminatedAt: z.ZodOptional<z.ZodISODateTime>;
@@ -1932,6 +2129,210 @@ export declare const publicContractsV1: {
                 failureReason: z.ZodEnum<{
                     "runner-unreachable": "runner-unreachable";
                     "nothing-to-inspect": "nothing-to-inspect";
+                    "runner-is-not-a-browser": "runner-is-not-a-browser";
+                }>;
+                outcome: z.ZodLiteral<"failure">;
+            }, z.core.$strip>], "outcome">;
+        };
+        inspectMobile: {
+            readonly description: "Inspect one thing on a mobile interactive runner: the Appium session's status, the WebView contexts available, the current context's page source, or the elements at a point or carrying some text. Mobile only — a browser runner answers `runner-is-not-mobile`; call `runner.inspect` for a browser's equivalent surface instead. `what: \"session\"` always answers with the session's own status rather than `screen-needs-a-run`, since that is the question it exists to answer; the other three request kinds need a live session first and answer the same `screen-needs-a-run` or `screen-not-ready` outcomes `runner.performAction` and `runner.takeScreenshot` use, instead of reading anything when there is none. `screen-needs-a-run` means no Appium session has started on this runner yet — call `runner.runFlow` with a flow that opens one, then inspect again. `screen-not-ready` means the runner's Appium session exists but did not answer this instant, or more than one is somehow live — retry once; if it persists, relaunch the runner. `runner-is-not-mobile` means there is nothing here to inspect, and retrying will never help — launch a `node20WithAndroid` or `node20WithIos` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                request: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    what: z.ZodLiteral<"session">;
+                }, z.core.$strip>, z.ZodObject<{
+                    what: z.ZodLiteral<"contexts">;
+                }, z.core.$strip>, z.ZodObject<{
+                    context: z.ZodOptional<z.ZodString>;
+                    what: z.ZodLiteral<"page">;
+                }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    by: z.ZodLiteral<"point">;
+                    context: z.ZodOptional<z.ZodString>;
+                    what: z.ZodLiteral<"elements">;
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                }, z.core.$strip>, z.ZodObject<{
+                    by: z.ZodLiteral<"text">;
+                    context: z.ZodOptional<z.ZodString>;
+                    partial: z.ZodOptional<z.ZodBoolean>;
+                    text: z.ZodString;
+                    what: z.ZodLiteral<"elements">;
+                }, z.core.$strip>], "by">], "what">;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "runner.inspectMobile";
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+                outcome: z.ZodLiteral<"success">;
+                session: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    deviceName: z.ZodOptional<z.ZodString>;
+                    platformName: z.ZodString;
+                    sessionId: z.ZodString;
+                    type: z.ZodLiteral<"ready">;
+                }, z.core.$strip>, z.ZodObject<{
+                    error: z.ZodString;
+                    type: z.ZodLiteral<"unreachable">;
+                }, z.core.$strip>, z.ZodObject<{
+                    sessionCount: z.ZodNumber;
+                    type: z.ZodLiteral<"ambiguous">;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"no-session">;
+                }, z.core.$strip>], "type">;
+                what: z.ZodLiteral<"session">;
+            }, z.core.$strip>, z.ZodObject<{
+                contexts: z.ZodArray<z.ZodString>;
+                current: z.ZodString;
+                outcome: z.ZodLiteral<"success">;
+                what: z.ZodLiteral<"contexts">;
+            }, z.core.$strip>, z.ZodObject<{
+                context: z.ZodString;
+                orientation: z.ZodEnum<{
+                    PORTRAIT: "PORTRAIT";
+                    LANDSCAPE: "LANDSCAPE";
+                }>;
+                outcome: z.ZodLiteral<"success">;
+                pageSource: z.ZodType<{
+                    selectors: {
+                        strategy: {
+                            name: "xpath";
+                            type: "unique" | "full-path" | "sibling-of" | "parent-of";
+                        } | {
+                            name: "ios-predicate";
+                        } | {
+                            hostSelector: string;
+                            innerSelector: string;
+                            name: "shadow";
+                        };
+                        value: string;
+                    }[];
+                    tag: string;
+                    attributes?: {
+                        bounds?: {
+                            bottom: number;
+                            left: number;
+                            right: number;
+                            top: number;
+                        } | undefined;
+                        rest?: Record<string, string> | undefined;
+                    } | undefined;
+                } & {
+                    children?: (({
+                        selectors: {
+                            strategy: {
+                                name: "xpath";
+                                type: "unique" | "full-path" | "sibling-of" | "parent-of";
+                            } | {
+                                name: "ios-predicate";
+                            } | {
+                                hostSelector: string;
+                                innerSelector: string;
+                                name: "shadow";
+                            };
+                            value: string;
+                        }[];
+                        tag: string;
+                        attributes?: {
+                            bounds?: {
+                                bottom: number;
+                                left: number;
+                                right: number;
+                                top: number;
+                            } | undefined;
+                            rest?: Record<string, string> | undefined;
+                        } | undefined;
+                    } & /*elided*/ any) | string)[];
+                }, unknown, z.core.$ZodTypeInternals<{
+                    selectors: {
+                        strategy: {
+                            name: "xpath";
+                            type: "unique" | "full-path" | "sibling-of" | "parent-of";
+                        } | {
+                            name: "ios-predicate";
+                        } | {
+                            hostSelector: string;
+                            innerSelector: string;
+                            name: "shadow";
+                        };
+                        value: string;
+                    }[];
+                    tag: string;
+                    attributes?: {
+                        bounds?: {
+                            bottom: number;
+                            left: number;
+                            right: number;
+                            top: number;
+                        } | undefined;
+                        rest?: Record<string, string> | undefined;
+                    } | undefined;
+                } & {
+                    children?: (({
+                        selectors: {
+                            strategy: {
+                                name: "xpath";
+                                type: "unique" | "full-path" | "sibling-of" | "parent-of";
+                            } | {
+                                name: "ios-predicate";
+                            } | {
+                                hostSelector: string;
+                                innerSelector: string;
+                                name: "shadow";
+                            };
+                            value: string;
+                        }[];
+                        tag: string;
+                        attributes?: {
+                            bounds?: {
+                                bottom: number;
+                                left: number;
+                                right: number;
+                                top: number;
+                            } | undefined;
+                            rest?: Record<string, string> | undefined;
+                        } | undefined;
+                    } & /*elided*/ any) | string)[];
+                }, unknown>>;
+                what: z.ZodLiteral<"page">;
+            }, z.core.$strip>, z.ZodObject<{
+                matches: z.ZodArray<z.ZodObject<{
+                    attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+                    bounds: z.ZodOptional<z.ZodObject<{
+                        bottom: z.ZodNumber;
+                        left: z.ZodNumber;
+                        right: z.ZodNumber;
+                        top: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    center: z.ZodOptional<z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    selectors: z.ZodArray<z.ZodObject<{
+                        strategy: z.ZodUnion<readonly [z.ZodObject<{
+                            name: z.ZodLiteral<"xpath">;
+                            type: z.ZodEnum<{
+                                unique: "unique";
+                                "full-path": "full-path";
+                                "sibling-of": "sibling-of";
+                                "parent-of": "parent-of";
+                            }>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            name: z.ZodLiteral<"ios-predicate">;
+                        }, z.core.$strip>, z.ZodObject<{
+                            hostSelector: z.ZodString;
+                            innerSelector: z.ZodString;
+                            name: z.ZodLiteral<"shadow">;
+                        }, z.core.$strip>]>;
+                        value: z.ZodString;
+                    }, z.core.$strip>>;
+                    tag: z.ZodString;
+                }, z.core.$strip>>;
+                outcome: z.ZodLiteral<"success">;
+                what: z.ZodLiteral<"elements">;
+            }, z.core.$strip>], "what">, z.ZodObject<{
+                failureReason: z.ZodEnum<{
+                    "runner-unreachable": "runner-unreachable";
+                    "runner-is-not-mobile": "runner-is-not-mobile";
+                    "screen-needs-a-run": "screen-needs-a-run";
+                    "screen-not-ready": "screen-not-ready";
                 }>;
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "outcome">;
@@ -1963,7 +2364,7 @@ export declare const publicContractsV1: {
             }, z.core.$strip>;
         };
         performAction: {
-            readonly description: "Perform one raw browser action on an interactive runner: click, double_click, move, drag, scroll, keypress, type, or navigate. Coordinates are whole pixels on the runner's virtual desktop, in the same space as `runner.takeScreenshot`. One action per request, and the runner serves one at a time. The action shapes follow the computer-use vocabulary, minus `screenshot` (use `runner.takeScreenshot`) and `wait` (delay on the caller's side). A success means the action took effect. `action-failed`, with a reason, if it reached the runner and did not take effect. On a runner image with a browser, the first action on a runner that has never run anything starts its browser and waits for it, so it can take up to a minute to answer — no `runner.runFlow` is needed before acting; if the browser is still starting when the wait runs out, the answer is `screen-not-ready` and retrying converges. `screen-needs-a-run` if the browser could not be started that way — usually a runner whose runs all finished without starting its desktop; call `runner.runFlow` with a flow that opens a browser. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. A `navigate` does not go through the screen, so a screen that is not ready does not stop it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may have stopped answering mid-action. This does not mean the action was not performed — take a screenshot before repeating it.";
+            readonly description: "Perform one raw browser action on an interactive runner: click, double_click, move, drag, scroll, keypress, type, or navigate. Coordinates are whole pixels on the runner's virtual desktop, in the same space as `runner.takeScreenshot`. One action per request, and the runner serves one at a time. The action shapes follow the computer-use vocabulary, minus `screenshot` (use `runner.takeScreenshot`) and `wait` (delay on the caller's side). A success means the action took effect. `action-failed`, with a reason, if it reached the runner and did not take effect. On a runner image with a browser, the first action on a runner that has never run anything starts its browser and waits for it, so it can take up to a minute to answer — no `runner.runFlow` is needed before acting; if the browser is still starting when the wait runs out, the answer is `screen-not-ready` and retrying converges. On a mobile runner, the same `screen-needs-a-run` and `screen-not-ready` outcomes mean no Appium session has started yet, or it did not answer this instant; `runner.runFlow` is what starts one, same as a browser. `screen-needs-a-run` if the browser could not be started that way — usually a runner whose runs all finished without starting its desktop; call `runner.runFlow` with a flow that opens a browser. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. A `navigate` does not go through the screen, so a screen that is not ready does not stop it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `action-not-supported-on-mobile` if the runner is a mobile device and this action has no touchscreen equivalent: `double_click`, `scroll`, `move`, `keypress` and `navigate`, and a `click` whose `button` is not `left`, are all pointer-device concepts a touchscreen has nothing to offer for. `click` taps, `drag` swipes between its path's first and last point, and `type` types into whatever the last tap focused. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may have stopped answering mid-action. This does not mean the action was not performed — take a screenshot before repeating it.";
             readonly input: z.ZodObject<{
                 action: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     button: z.ZodLiteral<"left" | "right" | "wheel" | "back" | "forward">;
@@ -2013,9 +2414,10 @@ export declare const publicContractsV1: {
             }, z.core.$strip>, z.ZodObject<{
                 failureReason: z.ZodEnum<{
                     "runner-unreachable": "runner-unreachable";
-                    "runner-has-no-screen": "runner-has-no-screen";
                     "screen-needs-a-run": "screen-needs-a-run";
                     "screen-not-ready": "screen-not-ready";
+                    "runner-has-no-screen": "runner-has-no-screen";
+                    "action-not-supported-on-mobile": "action-not-supported-on-mobile";
                 }>;
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "failureReason">], "outcome">;
@@ -2036,7 +2438,7 @@ export declare const publicContractsV1: {
                     payload: z.ZodUnknown;
                     recordedAt: z.ZodISODateTime;
                     sequence: z.ZodNumber;
-                }, z.core.$strip>, z.ZodTransform<import("./runner/journal.js").JournalEntry<unknown>, {
+                }, z.core.$strip>, z.ZodTransform<import("./runnerReexports.js").JournalEntry<unknown>, {
                     payload: unknown;
                     recordedAt: string;
                     sequence: number;
@@ -2114,7 +2516,7 @@ export declare const publicContractsV1: {
             }, z.core.$strip>], "outcome">;
         };
         takeScreenshot: {
-            readonly description: "Take one screenshot of an interactive runner's screen. The image is the runner's whole virtual desktop, browser window and all. `screen-needs-a-run` if the runner's virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` with a flow that opens a browser, then ask for the screen again. On a runner image with a browser that has never run anything, any `runner.performAction` also starts the browser itself. Evaluating a snippet does not start the desktop. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
+            readonly description: "Take one screenshot of an interactive runner's screen. On a runner with a browser the image is the whole virtual desktop, browser window and all. On a mobile runner it is the device's own screen, re-encoded to JPEG on the pod so this contract reads one image format regardless of runner family. `screen-needs-a-run` if the runner's virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` with a flow that opens a browser, then ask for the screen again. On a runner image with a browser that has never run anything, any `runner.performAction` also starts the browser itself. Evaluating a snippet does not start the desktop. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
             }, z.core.$strip>;
@@ -2126,9 +2528,9 @@ export declare const publicContractsV1: {
             }, z.core.$strip>, z.ZodObject<{
                 failureReason: z.ZodEnum<{
                     "runner-unreachable": "runner-unreachable";
-                    "runner-has-no-screen": "runner-has-no-screen";
                     "screen-needs-a-run": "screen-needs-a-run";
                     "screen-not-ready": "screen-not-ready";
+                    "runner-has-no-screen": "runner-has-no-screen";
                 }>;
                 outcome: z.ZodLiteral<"failure">;
             }, z.core.$strip>], "outcome">;