agent-device 0.21.12 → 0.21.14

package/dist/src/limrun.d.ts

@@ -1,7 +1,6 @@
-import { S as DeviceTarget, b as DeviceInfo, f as LeaseBackend, w as PlatformSelector, x as DeviceKind } from "./sdk-contracts.js";
-import { t as AppsFilter } from "./app-inventory.js";
-import { d as Interactor, f as RunnerContext } from "./sdk-selectors.js";
-import { n as CloudArtifactProvider } from "./cloud-artifacts.js";
+import { D as Point, E as IosTargetActivation, F as SnapshotProvenance, M as SnapshotKeyboardBandFact, O as RawSnapshotNode, P as SnapshotOptions$1, S as DeviceTarget, b as DeviceInfo, f as LeaseBackend, k as Rect, w as PlatformSelector, x as DeviceKind } from "./sdk-contracts.js";
+import { s as AppsFilter, t as GesturePlan } from "./gesture-plan-types.js";
+import { T as BackendSnapshotResult, d as ReadSettingResult, f as ReadableSetting, g as CloudArtifactProvider, i as DeviceRotation, k as SessionSurface, n as ScrollExecutionOptions, p as SettingOptions, r as TvRemoteButton, v as BackMode, y as ScrollDirection } from "./scroll-command.js";
 import { d as AndroidAdbProvider, n as AndroidKeyboardState, s as AndroidInputOwner, t as AndroidKeyboardDismissResult } from "./device-input-state.js";
 //#region packages/contracts/src/device-inventory.d.ts
 type DeviceInventoryRequest = {
@@ -64,6 +63,438 @@ type ProviderAppCatalogQuery = Readonly<{
 }>;
 type ProviderAppCatalogHandler = (query: ProviderAppCatalogQuery, signal?: AbortSignal) => Promise<readonly string[]>;
 //#endregion
+//#region packages/contracts/src/ios-system-surface.d.ts
+/**
+ * iOS out-of-process system surfaces that agent-device observes and drives IN PLACE, never by
+ * activation: launching or activating the host cancels what it presents (issue #2438), so the
+ * runner addresses the host process while it is foreground and the `open` path refuses it. The set
+ * is deliberately closed and tiny; add a host only with live evidence that it presents out of
+ * process and dies on activation. Rationale per host lives in the canonical fixture
+ * `contracts/fixtures/ios-system-surface-hosts.json` (see also docs/adr/0004); this module and the
+ * Swift `SystemSurfaceHostRegistry` both mirror it, each guarded by a parity test.
+ */
+/** Why a system surface is served in place; carried at snapshot-response level as provenance. */
+type IosSystemSurfaceKind = 'web-auth' | 'payment';
+/**
+ * Whole-snapshot provenance: the capture describes a system surface presented over the session app,
+ * not the app itself. Carried at response level (it applies to the entire snapshot) and folded into
+ * iOS snapshot lineage so `--verify`/`--settle` never compare an app baseline against a sheet
+ * capture. Mirrors the Android system-chrome/system-surface provenance model.
+ */
+type IosSystemSurfaceProvenance = Readonly<{
+  bundleId: string;
+  kind: IosSystemSurfaceKind;
+}>;
+//#endregion
+//#region packages/contracts/src/runner-lease-context.d.ts
+type RunnerLogicalLeaseContext = {
+  leaseId?: string;
+  clientId?: string;
+  tenantId?: string;
+  runId?: string;
+  leaseProvider?: string;
+  deviceKey?: string;
+};
+//#endregion
+//#region packages/contracts/src/ios-snapshot.d.ts
+type IosSnapshotProducer = 'apple-runner' | 'simulator-ax-bridge' | 'appium-source' | 'limrun-ios-tree';
+type IosAcquisitionProducer = Exclude<IosSnapshotProducer, 'apple-runner'>;
+type IosAcquisitionIntent = 'full' | 'surface-observation';
+type IosSnapshotProjection = 'regular' | 'raw';
+type IosSnapshotGeneration = string;
+type IosSnapshotLineage = Readonly<{
+  targetId?: string;
+  generation?: IosSnapshotGeneration;
+}>;
+type IosSnapshotPresentationKey = Readonly<{
+  projection: IosSnapshotProjection;
+  interactiveOnly: boolean;
+  depth: number | null;
+  scope: string | null;
+  customActions: boolean;
+}>;
+type CaptureHint = Readonly<{
+  projection: IosSnapshotProjection;
+  rawTraversalDepth: number | null;
+  regularPresentedDepth: number | null;
+  interactiveOnly: boolean;
+  customActions: boolean;
+  acquisitionIntent: IosAcquisitionIntent;
+}>;
+type IosSnapshotFact = 'acquisition-depth' | 'scope' | 'interactive-query' | 'viewport' | 'hittability' | 'generation' | 'truncation';
+type IosViewportEvidence = Readonly<{
+  kind: 'reported';
+  rect: Rect;
+}> | Readonly<{
+  kind: 'derived';
+  rect: Rect;
+}> | Readonly<{
+  kind: 'missing';
+  reason: 'not-provided' | 'not-supported' | 'invalid';
+}>;
+type IosProviderPrunedField = 'nodes' | 'depth' | 'scope' | 'interactive-only';
+type IosAcquisitionResidue = Readonly<{
+  kind: 'provider-pruned';
+  fields: readonly IosProviderPrunedField[];
+}> | Readonly<{
+  kind: 'missing-viewport';
+  reason: 'not-provided' | 'not-supported' | 'invalid';
+}> | Readonly<{
+  kind: 'truncated';
+}> | Readonly<{
+  kind: 'stale-generation';
+  expected?: IosSnapshotGeneration;
+  observed?: IosSnapshotGeneration;
+}> | Readonly<{
+  kind: 'unknown-generation';
+  captureId: string;
+}> | Readonly<{
+  kind: 'unavailable-fact';
+  fact: IosSnapshotFact;
+}> | Readonly<{
+  kind: 'fallback-source';
+  producer: IosSnapshotProducer;
+}>;
+type IosSnapshotAcquisitionForIntent<Intent extends IosAcquisitionIntent> = Readonly<{
+  producer: IosAcquisitionProducer;
+  intent: Intent;
+  hint: CaptureHint & Readonly<{
+    acquisitionIntent: Intent;
+  }>;
+  nodes: readonly RawSnapshotNode[];
+  truncated?: boolean;
+  viewport: IosViewportEvidence;
+  lineage: IosSnapshotLineage;
+  residue: readonly IosAcquisitionResidue[];
+}>;
+type IosSnapshotAcquisition = IosSnapshotAcquisitionForIntent<'full'> | IosSnapshotAcquisitionForIntent<'surface-observation'>;
+type IosSnapshotAcquisitionFacts = Omit<IosSnapshotAcquisition, 'hint'>;
+type IosSnapshotComparisonIdentity = Readonly<{
+  producer: IosSnapshotProducer;
+  intent: IosAcquisitionIntent;
+  lineage: IosSnapshotLineage;
+  presentationKey: IosSnapshotPresentationKey;
+  residue: readonly IosAcquisitionResidue[];
+}>;
+//#endregion
+//#region packages/contracts/src/interactor-types.d.ts
+type RunnerContext = {
+  requestId?: string;
+  signal?: AbortSignal;
+  appBundleId?: string;
+  verbose?: boolean;
+  logPath?: string;
+  traceLogPath?: string;
+  iosXctestrunFile?: string;
+  iosXctestDerivedDataPath?: string;
+  iosXctestEnvDir?: string;
+  runnerLeaseContext?: RunnerLogicalLeaseContext;
+};
+type ScreenshotOptions = {
+  appBundleId?: string;
+  pixelDensity?: number;
+  fullscreen?: boolean;
+  normalizeStatusBar?: boolean;
+  stabilize?: boolean;
+  surface?: SessionSurface;
+  skipIosSimulatorBootCheck?: boolean;
+  captureBackend?: 'runner';
+};
+type ElementSelectorKey = 'id' | 'label' | 'text' | 'value';
+type ElementSelectorTapOptions = {
+  key: ElementSelectorKey;
+  value: string;
+  allowNonHittableCoordinateFallback?: boolean;
+  expectedPoint?: Point;
+};
+type PressPointOptions = Readonly<{
+  button: 'primary' | 'secondary' | 'middle';
+  count: number;
+  intervalMs: number;
+  holdMs: number;
+  jitterPx: number;
+  doubleTap: boolean;
+  surface?: SessionSurface;
+}>;
+/**
+ * The channel the XCTest runner actually entered text through — the Swift
+ * `TextEntryResult.textEntryRoute` (RunnerTests+TextTyping.swift,
+ * RunnerTests+SynthesizedTextEntry.swift). Closed set, because the runner is
+ * its only producer and the boundary that narrows it
+ * (readTypeTextBackendResult, packages/platform-apple/src/interactions.ts) drops a
+ * route it cannot name — so a Swift-side addition would silently vanish. The
+ * route-parity test in packages/platform-apple/src/core/__tests__/interactions.test.ts
+ * reads the Swift sources and fails instead.
+ */
+declare const TEXT_ENTRY_ROUTES: readonly ['xctest-element', 'synthesized-first-responder', 'synthesized-first-responder-replacement', 'xctest-application-fallback'];
+type TextEntryRoute = (typeof TEXT_ENTRY_ROUTES)[number];
+/**
+ * What `Interactor.type` reports back about the entry it performed. Only the
+ * Apple runner populates it; every other platform types blind and returns void.
+ */
+type TypeTextBackendResult = {
+  textEntryRoute?: TextEntryRoute;
+};
+type SnapshotOptions = SnapshotOptions$1 & {
+  appBundleId?: string;
+  signal?: AbortSignal;
+  includeRects?: boolean;
+  includeHiddenContentHints?: boolean;
+  surface?: SessionSurface;
+  /** Internal capture purpose; action outcomes always require the full tree. */
+  acquisitionIntent?: 'full' | 'surface-observation';
+};
+/**
+ * Android's live IME status read. Optional on {@link Interactor}: parity with the retired leaf,
+ * which refused `status`/`get` on every other family (no other platform's runner exposes one).
+ * A single-member discriminated union rather than a bare object so the daemon can derive its wire
+ * `platform` label from `kind` the same way it does for dismiss and enter — an owner can only ever
+ * produce its own result shape.
+ */
+type KeyboardStatusResult = Readonly<{
+  kind: 'ime-probe';
+  visible: boolean;
+  inputType?: string;
+  type?: string;
+  inputMethodPackage?: string;
+  focusedPackage?: string;
+  focusedResourceId?: string;
+  inputOwner?: string;
+}>;
+/**
+ * Owner-shaped dismiss evidence, discriminated by which owner produced it: Android's IME probe
+ * fields, or iOS's `mechanism` disclosure (#1598), or HarmonyOS's bare acknowledgment (its HDC
+ * key press reports nothing beyond success). The daemon derives the wire `platform` label from
+ * `kind` rather than re-deriving it from the device, so an owner can only ever produce its own
+ * result shape — an android-probe result under an `ios` label is unrepresentable.
+ */
+type KeyboardDismissResult = Readonly<{
+  kind: 'ime-probe';
+  attempts?: number;
+  wasVisible?: boolean;
+  dismissed?: boolean;
+  visible?: boolean;
+  inputType?: string;
+  type?: string;
+  inputMethodPackage?: string;
+  focusedPackage?: string;
+  focusedResourceId?: string;
+  inputOwner?: string;
+}> | Readonly<{
+  kind: 'mechanism';
+  wasVisible?: boolean;
+  dismissed?: boolean;
+  visible?: boolean;
+  mechanism?: string;
+}> | Readonly<{
+  kind: 'acknowledged';
+}>;
+/**
+ * Only the Apple runner echoes visibility around the return-key press; Android and HarmonyOS
+ * acknowledge with no fields beyond success. Kind is owner-specific, not just content-shaped —
+ * Android's and HarmonyOS's acknowledgments are structurally identical, so only the discriminant
+ * itself tells the daemon which owner actually pressed enter.
+ */
+type KeyboardEnterResult = Readonly<{
+  kind: 'visibility-echo';
+  visible?: boolean;
+  wasVisible?: boolean;
+}> | Readonly<{
+  kind: 'android-acknowledged';
+}> | Readonly<{
+  kind: 'harmonyos-acknowledged';
+}>;
+/**
+ * Every acquisition carries its provenance pair atomically: the channel alone cannot say who
+ * acquired the tree or which guarantees it carries, and `SnapshotProvenance`
+ * (`@agent-device/kernel/snapshot`) makes a cross-channel `backend`/`producer` combination
+ * fail to compile.
+ */
+type SnapshotResult = Omit<BackendSnapshotResult, 'backend' | 'nodes'> & {
+  nodes?: RawSnapshotNode[];
+  comparisonIdentity?: IosSnapshotComparisonIdentity;
+  /**
+   * Set when the capture describes an in-place iOS system surface (a web sign-in sheet) presented
+   * over the session app rather than the app itself (#2438).
+   */
+  systemSurface?: IosSystemSurfaceProvenance;
+  /**
+   * The keyboard band the producer measured while capturing, when it can measure one (#2660). A
+   * producer that publishes nothing measured nothing, so the tap-path guard keeps deriving the band
+   * from `nodes`; see {@link SnapshotKeyboardBandFact}.
+   */
+  keyboard?: SnapshotKeyboardBandFact;
+  /**
+   * Set when this capture's own command had to bring the session app back to the foreground, i.e.
+   * something else held it and an earlier observation described that instead (#2682).
+   */
+  targetActivation?: IosTargetActivation;
+} & SnapshotProvenance;
+type SnapshotRuntimeAcquiredResult = Readonly<{
+  stage: 'acquired';
+  acquisition: IosSnapshotAcquisitionFacts & Readonly<{
+    producer: IosAcquisitionProducer;
+  }>;
+}>;
+type SnapshotRuntimeResult = SnapshotResult | SnapshotRuntimeAcquiredResult;
+type Interactor = {
+  open(app: string, options?: {
+    activity?: string;
+    appBundleId?: string;
+    launchConsole?: string;
+    launchArgs?: string[];
+    terminateRunningApp?: boolean;
+    url?: string;
+  }): Promise<void>;
+  openDevice(): Promise<void>;
+  close(app: string): Promise<void>;
+  tap(x: number, y: number): Promise<Record<string, unknown> | void>;
+  /** Complete point-press semantics for owners with fused series, alternate buttons, or surfaces. */
+  pressPoint?(point: Point, options: PressPointOptions): Promise<Record<string, unknown> | void>;
+  /** Alternate mouse buttons for owners that otherwise use the shared point-press series. */
+  alternateClick?(point: Point, button: 'secondary' | 'middle'): Promise<Record<string, unknown> | void>;
+  /** Owner-native ref routes; currently the managed web runtime is their only local owner. */
+  tapRef?(ref: string): Promise<Record<string, unknown> | void>;
+  tapElementSelector?(selector: ElementSelectorTapOptions): Promise<Record<string, unknown> | void>;
+  /**
+   * Fused double-click for owners that have one. The shared `--count` series cannot stand in for it —
+   * it spaces and jitters independent presses rather than firing one pair the target reads as a
+   * double — so an owner with no such mechanic leaves this undefined and `press --double` reports the
+   * gap instead of resolving a denial.
+   */
+  doubleTap?(x: number, y: number): Promise<Record<string, unknown> | void>;
+  longPress(x: number, y: number, durationMs?: number): Promise<Record<string, unknown> | void>;
+  /**
+   * Move the pointer to a point without pressing. Only pointer-driven
+   * platforms (web today) implement it; touch platforms have no hover state
+   * and leave it undefined, which the `hover` command reports as unsupported.
+   */
+  hover?(x: number, y: number): Promise<Record<string, unknown> | void>;
+  hoverRef?(ref: string): Promise<Record<string, unknown> | void>;
+  focus(x: number, y: number): Promise<Record<string, unknown> | void>;
+  type(text: string, delayMs?: number): Promise<TypeTextBackendResult | void>;
+  /**
+   * Replace the target's text with `text`. The empty string is the clear request (#2063), not a
+   * no-op: an implementation must empty the field or fail — never report success over an
+   * untouched value. A backend with no clear mechanism refuses the empty text up front (see the
+   * webdriver interactor).
+   */
+  fill(x: number, y: number, text: string, delayMs?: number, options?: {
+    allowNonHittableCoordinateFallback?: boolean;
+  }): Promise<Record<string, unknown> | void>;
+  fillRef?(ref: string, text: string, delayMs?: number): Promise<Record<string, unknown> | void>;
+  scroll(direction: ScrollDirection, options?: ScrollExecutionOptions): Promise<Record<string, unknown> | void>;
+  screenshot(outPath: string, options?: ScreenshotOptions): Promise<void>;
+  setViewport?(width: number, height: number): Promise<Record<string, unknown> | void>;
+  snapshot(options?: SnapshotOptions): Promise<SnapshotRuntimeResult>;
+  /**
+   * Native reading of the live text at a point, when the backend has one. Answers the text the
+   * owner can see right now, which can exceed what an already-captured node carries (an editable
+   * field whose value is longer than its label). Optional: a backend without it leaves the
+   * captured tree as the complete answer.
+   */
+  readTextAtPoint?(point: Point, options?: {
+    appBundleId?: string;
+    surface?: SessionSurface;
+    signal?: AbortSignal;
+  }): Promise<string | undefined>;
+  /**
+   * Native text-presence reading, when the backend has one that does not require a tree capture.
+   * A `true` answer is authoritative; anything else means "not proven here" and the caller
+   * consults the canonical tree (see `FindTextResult`).
+   */
+  findText?(text: string, options?: {
+    appBundleId?: string;
+    signal?: AbortSignal;
+  }): Promise<{
+    found: boolean;
+  }>;
+  gestureViewport?(): Promise<Rect>;
+  back(mode?: BackMode): Promise<void>;
+  /**
+   * Optional (parity with `actionButton`): opens the springboard, a control not every owner
+   * carries. An owner without it leaves it undefined; its fact refuses the press before binding,
+   * and the system-button binder fails closed rather than resolving an absent member as a
+   * successful no-op.
+   */
+  home?(): Promise<void>;
+  setOrientation(orientation: DeviceRotation): Promise<{
+    orientation?: DeviceRotation;
+  } | void>;
+  performGesture?(plan: GesturePlan): Promise<Record<string, unknown> | void>;
+  /**
+   * Optional (parity with `home`): opens the recents surface, a control not every owner carries.
+   * An owner without it leaves it undefined; its fact refuses the press before binding, and the
+   * system-button binder fails closed rather than resolving an absent member as a successful
+   * no-op.
+   */
+  appSwitcher?(): Promise<void>;
+  /**
+   * Optional (parity with `home`): presses one TV remote key, a control only TV-capable owners
+   * carry. An owner without it leaves it undefined; its fact refuses the press before binding,
+   * and the TV remote binder fails closed rather than resolving an absent member as a silent
+   * no-op.
+   */
+  tvRemote?(button: TvRemoteButton, durationMs?: number): Promise<void>;
+  /**
+   * Optional (parity with `keyboardDismiss`): presses the iPhone/iPad Action Button, hardware only
+   * the Apple owner carries. An owner without the button leaves it undefined; its fact refuses the
+   * press before binding, and the system-button binder fails closed rather than resolving an
+   * absent member as a successful no-op.
+   */
+  actionButton?(): Promise<void>;
+  /** Optional: only Android implements a live status read (see {@link KeyboardStatusResult}). */
+  keyboardStatus?(): Promise<KeyboardStatusResult>;
+  /** Optional: platforms with no keyboard-dismiss concept leave it undefined. */
+  keyboardDismiss?(): Promise<KeyboardDismissResult>;
+  /** Optional: platforms with no keyboard-return concept leave it undefined. */
+  keyboardEnter?(): Promise<KeyboardEnterResult>;
+  /**
+   * Optional (parity with `readSetting`): the owner's pasteboard read. An owner with no clipboard
+   * surface leaves both halves undefined; its fact refuses the half before binding, and the
+   * clipboard binder fails closed rather than resolving an absent member as an empty answer.
+   */
+  readClipboard?(): Promise<string>;
+  /**
+   * Optional (parity with `readClipboard`): the owner's pasteboard write, with the same
+   * fact-then-guard contract as the read.
+   */
+  writeClipboard?(text: string): Promise<void>;
+  setSetting(setting: string, state: string, appId?: string, options?: SettingOptions): Promise<Record<string, unknown> | void>;
+  /**
+   * Optional: reads back the value a device holds for one readable setting. The name is narrowed to
+   * `READABLE_SETTINGS`, which is not every setting the write switch serves, and an owner's dispatch
+   * is exhaustive over it — a setting joins the list only with an owner that answers it. An owner with
+   * no read path leaves the member undefined; its fact refuses the read before binding, so an absent
+   * method can never resolve into an empty answer.
+   */
+  readSetting?(setting: ReadableSetting): Promise<ReadSettingResult>;
+  /**
+   * The four alert legs. Each owner runs its own observation and, where it needs one, its own
+   * poll: an alert is a transient device surface, and how long to look for it — and how to press
+   * its buttons — is family mechanics, not something a caller can supply. `timeoutMs` is the
+   * whole window the caller allows; the owner spends it however its backend requires.
+   *
+   * Optional: an owner with no alert surface leaves all four undefined. Its facts refuse every leg
+   * before binding, so the absent members are never resolved, and a fact that admitted a leg the
+   * interactor cannot serve fails closed instead of answering empty.
+   */
+  readAlert?(options?: AlertInteractorOptions): Promise<Record<string, unknown>>;
+  awaitAlert?(options?: AlertInteractorOptions): Promise<Record<string, unknown>>;
+  acceptAlert?(options?: AlertInteractorOptions): Promise<Record<string, unknown>>;
+  dismissAlert?(options?: AlertInteractorOptions): Promise<Record<string, unknown>>;
+};
+/**
+ * The session-derived target one alert leg acts on. `appBundleId` is separate from the runner
+ * context's because the macOS helper reads a frontmost-app surface with no bundle at all, and
+ * the two must not collapse into one field that means both.
+ */
+type AlertInteractorOptions = {
+  timeoutMs?: number;
+  appBundleId?: string;
+  surface?: SessionSurface;
+};
+//#endregion
 //#region packages/contracts/src/provider-device-runtime.d.ts
 type ProviderDeviceInstallResult = {
   bundleId?: string;

package/dist/src/linux.js

@@ -1 +1 @@
-import{D as e}from"./sdk-contracts.js";import{c as t}from"./diagnostics.js";import"./diagnostics2.js";import{a as n}from"./gesture-plan.js";import{S as r,_ as i,a,b as o,d as s,f as c,h as l,i as u,l as d,m as f,n as p,o as m,p as h,r as g,s as _,t as v,u as y,v as b,x}from"./src5.js";function S(){throw new e(`UNSUPPORTED_OPERATION`,`alert not supported on Linux`)}function C(){return{open:e=>s(e),openDevice:()=>Promise.resolve(),close:e=>g(e),tap:(e,t)=>c(e,t),alternateClick:async(e,t)=>t===`secondary`?await l(e.x,e.y):await y(e.x,e.y),doubleTap:(e,t)=>u(e,t),longPress:(e,t,n)=>d(e,t,n),focus:(e,t)=>m(e,t),type:(e,t)=>x(e,t),fill:(e,t,n,r)=>a(e,t,n,r),scroll:(e,t)=>b(e,t),performGesture:async t=>{if(t.topology===`two`)throw new e(`UNSUPPORTED_OPERATION`,`Multi-touch gestures are not supported on Linux`);let{start:r,end:i}=n(t);await o(r.x,r.y,i.x,i.y,t.durationMs)},screenshot:(e,t)=>i(e,t),readTextAtPoint:async(e,t)=>await f(e.x,e.y,t?.surface),snapshot:async e=>await t(`snapshot_capture`,async()=>await p(e,e?.signal),{backend:`linux-atspi`}),back:()=>v(),home:()=>_(),setOrientation:()=>{throw new e(`UNSUPPORTED_OPERATION`,`orientation not supported on Linux`)},appSwitcher:()=>{throw new e(`UNSUPPORTED_OPERATION`,`appSwitcher not yet supported on Linux`)},tvRemote:()=>{throw new e(`UNSUPPORTED_OPERATION`,`tv-remote not supported on Linux`)},readClipboard:()=>h(),writeClipboard:e=>r(e),setSetting:()=>{throw new e(`UNSUPPORTED_OPERATION`,`setSetting not supported on Linux`)},readAlert:S,awaitAlert:S,acceptAlert:S,dismissAlert:S}}export{C as createLinuxInteractor};
+import{O as e}from"./sdk-contracts.js";import{c as t}from"./diagnostics.js";import"./diagnostics2.js";import{a as n}from"./gesture-plan.js";import{S as r,_ as i,a,b as o,d as s,f as c,h as l,i as u,l as d,m as f,n as p,o as m,p as h,r as g,s as _,t as v,u as y,v as b,x}from"./src5.js";function S(){return{open:e=>s(e),openDevice:()=>Promise.resolve(),close:e=>g(e),tap:(e,t)=>c(e,t),alternateClick:async(e,t)=>t===`secondary`?await l(e.x,e.y):await y(e.x,e.y),doubleTap:(e,t)=>u(e,t),longPress:(e,t,n)=>d(e,t,n),focus:(e,t)=>m(e,t),type:(e,t)=>x(e,t),fill:(e,t,n,r)=>a(e,t,n,r),scroll:(e,t)=>b(e,t),performGesture:async t=>{if(t.topology===`two`)throw new e(`UNSUPPORTED_OPERATION`,`Multi-touch gestures are not supported on Linux`);let{start:r,end:i}=n(t);await o(r.x,r.y,i.x,i.y,t.durationMs)},screenshot:(e,t)=>i(e,t),readTextAtPoint:async(e,t)=>await f(e.x,e.y,t?.surface),snapshot:async e=>await t(`snapshot_capture`,async()=>await p(e,e?.signal),{backend:`linux-atspi`}),back:()=>v(),home:()=>_(),setOrientation:()=>{throw new e(`UNSUPPORTED_OPERATION`,`orientation not supported on Linux`)},appSwitcher:()=>{throw new e(`UNSUPPORTED_OPERATION`,`appSwitcher not yet supported on Linux`)},tvRemote:()=>{throw new e(`UNSUPPORTED_OPERATION`,`tv-remote not supported on Linux`)},readClipboard:()=>h(),writeClipboard:e=>r(e),setSetting:()=>{throw new e(`UNSUPPORTED_OPERATION`,`setSetting not supported on Linux`)}}}export{S as createLinuxInteractor};

package/dist/src/local-interactor-operation-set.js

@@ -1 +1 @@
-import{tn as e}from"./sdk-batch.js";import{C as t,O as n,P as r,T as i,U as a,j as o}from"./alert-runtime.js";import{t as s}from"./touch-runtime.js";import{t as c}from"./interactor-operation-catalog.js";function l(l){let{facts:u,pause:d}=l,f={device:l.device,signal:l.signal,resolveInteractor:l.resolveInteractor};return{...u.captureScreenshot.available?a(f):{},...u.focusPoint.available?r(f):{},...o({...f,facts:u}),...u.scrollDirection.available?n(f):{},...u.typeText.available?i(f):{},...u.readTextAtPoint.available?t(f):{},...e(u.tapPoint,()=>s({...f,facts:u,pause:d})),...c({...f,facts:u})}}export{l as t};
+import{tn as e}from"./sdk-batch.js";import{E as t,K as n,L as r,O as i,P as a,j as o}from"./alert-runtime.js";import{t as s}from"./touch-runtime.js";import{t as c}from"./interactor-operation-catalog.js";function l(l){let{facts:u,pause:d}=l,f={device:l.device,signal:l.signal,resolveInteractor:l.resolveInteractor};return{...u.captureScreenshot.available?n(f):{},...u.focusPoint.available?r(f):{},...a({...f,facts:u}),...u.scrollDirection.available?o(f):{},...u.typeText.available?i(f):{},...u.readTextAtPoint.available?t(f):{},...e(u.tapPoint,()=>s({...f,facts:u,pause:d})),...c({...f,facts:u})}}export{l as t};

package/dist/src/location-coordinates.js

@@ -1 +1 @@
-import{D as e}from"./sdk-contracts.js";const t=[`grant`,`deny`,`reset`],n=[`full`,`limited`],r=[`all`,`camera`,`microphone`,`photos`,`contacts`,`contacts-limited`,`notifications`,`calendar`,`location`,`location-always`,`media-library`,`motion`,`reminders`,`siri`],i=[`accessibility`,`screen-recording`,`input-monitoring`],a=[`extra-small`,`small`,`medium`,`large`,`extra-large`,`extra-extra-large`,`extra-extra-extra-large`,`accessibility-medium`,`accessibility-large`,`accessibility-extra-large`,`accessibility-extra-extra-large`,`accessibility-extra-extra-extra-large`];function o(e,t){return Object.freeze({setting:`text-size`,category:e,platformValue:t})}function s(e){return`Text size is ${e.category}`}function c(e,t,n){return e===`clear-app-state`?`Cleared user data for ${n}`:e===`text-size`?`Text size set to ${t}`:`Updated setting: ${e}`}const l=`<wifi|airplane|location> <on|off>`,u=`location set <lat> <lon>`,d=`animations <on|off>`,f=`appearance <light|dark|toggle>`,p=`faceid <match|nonmatch|enroll|unenroll>`,m=`touchid <match|nonmatch|enroll|unenroll>`,h=`fingerprint <match|nonmatch>`,g=`clear-app-state [app-id]`,_=`reset-keychain clear`,v=`text-size [${a.join(`|`)}]`,y=`permission <${t.join(`|`)}> <${r.join(`|`)}> [${n.join(`|`)}]`,b=`permission <grant|reset> <${i.join(`|`)}>`,x=`macOS supports only settings ${f} and settings ${b}. wifi|airplane|location|animations|text-size remain unsupported on macOS.`,S=[`settings ${l}`,`settings ${u}`,`settings ${d}`,`settings ${f}`,`settings ${v}`,`settings ${p}`,`settings ${m}`,`settings ${h}`,`settings ${g}`,`settings ${_}`,`settings ${y}`,`settings ${b}`].join(` | `),C=`settings requires ${l}, ${u}, ${d}, ${f}, ${v}, ${p}, ${m}, ${h}, ${g}, ${_}, ${y}, or ${b}`;function w(e){let t=e.trim().toLowerCase();return t===`appearance`||t===`permission`}function T(e){return`Unsupported macOS setting: ${e}. ${x}`}function E(t){let n=O(t);if(n!==void 0)return n;throw new e(`INVALID_ARGS`,D(t))}function D(e){return`Invalid text size: ${e??``}. Use ${a.join(`|`)}.`}function O(e){return A(a,e)}const k=Object.freeze({message:`Reading or setting a text size is supported on iOS and iPadOS simulators.`,hint:"Run `xcrun simctl ui <device> content_size` on a booted iPhone or iPad simulator.",reason:`setting-unsupported-on-leaf`});function A(e,t){let n=t?.trim().toLowerCase();return n===void 0?void 0:e.find(e=>e===n)}function j(n){let r=A(t,n);if(r!==void 0)return r;throw new e(`INVALID_ARGS`,`Invalid permission action: ${n}. Use ${t.join(`|`)}.`)}function M(t){let n=A(r,t);if(n!==void 0)return n;throw new e(`INVALID_ARGS`,`permission setting requires a target: ${r.join(`|`)}`)}function N(t,n){if(t===void 0||t.trim()===``)throw new e(`INVALID_ARGS`,`settings location set requires ${n}`);return F(Number(t),n)}function P(e){return{latitude:F(e?.latitude,`latitude`),longitude:F(e?.longitude,`longitude`)}}function F(t,n){let r=n===`latitude`?-90:-180,i=n===`latitude`?90:180;if(typeof t!=`number`||!Number.isFinite(t)||t<r||t>i)throw new e(`INVALID_ARGS`,`${n} must be a number from ${r} to ${i}`);return t}export{j as _,r as a,O as b,C as c,a as d,s as f,w as g,D as h,i,b as l,T as m,P as n,t as o,c as p,k as r,n as s,N as t,S as u,M as v,o as x,E as y};
+import{O as e}from"./sdk-contracts.js";const t=[`grant`,`deny`,`reset`],n=[`full`,`limited`],r=[`all`,`camera`,`microphone`,`photos`,`contacts`,`contacts-limited`,`notifications`,`calendar`,`location`,`location-always`,`media-library`,`motion`,`reminders`,`siri`],i=[`accessibility`,`screen-recording`,`input-monitoring`],a=[`extra-small`,`small`,`medium`,`large`,`extra-large`,`extra-extra-large`,`extra-extra-extra-large`,`accessibility-medium`,`accessibility-large`,`accessibility-extra-large`,`accessibility-extra-extra-large`,`accessibility-extra-extra-extra-large`];function o(e,t){return Object.freeze({setting:`text-size`,category:e,platformValue:t})}function s(e){return`Text size is ${e.category}`}function c(e,t,n){return e===`clear-app-state`?`Cleared user data for ${n}`:e===`text-size`?`Text size set to ${t}`:`Updated setting: ${e}`}const l=`<wifi|airplane|location> <on|off>`,u=`location set <lat> <lon>`,d=`animations <on|off>`,f=`appearance <light|dark|toggle>`,p=`faceid <match|nonmatch|enroll|unenroll>`,m=`touchid <match|nonmatch|enroll|unenroll>`,h=`fingerprint <match|nonmatch>`,g=`clear-app-state [app-id]`,_=`reset-keychain clear`,v=`text-size [${a.join(`|`)}]`,y=`permission <${t.join(`|`)}> <${r.join(`|`)}> [${n.join(`|`)}]`,b=`permission <grant|reset> <${i.join(`|`)}>`,x=`macOS supports only settings ${f} and settings ${b}. wifi|airplane|location|animations|text-size remain unsupported on macOS.`,S=[`settings ${l}`,`settings ${u}`,`settings ${d}`,`settings ${f}`,`settings ${v}`,`settings ${p}`,`settings ${m}`,`settings ${h}`,`settings ${g}`,`settings ${_}`,`settings ${y}`,`settings ${b}`].join(` | `),C=`settings requires ${l}, ${u}, ${d}, ${f}, ${v}, ${p}, ${m}, ${h}, ${g}, ${_}, ${y}, or ${b}`;function w(e){let t=e.trim().toLowerCase();return t===`appearance`||t===`permission`}function T(e){return`Unsupported macOS setting: ${e}. ${x}`}function E(t){let n=O(t);if(n!==void 0)return n;throw new e(`INVALID_ARGS`,D(t))}function D(e){return`Invalid text size: ${e??``}. Use ${a.join(`|`)}.`}function O(e){return A(a,e)}const k=Object.freeze({message:`Reading or setting a text size is supported on iOS and iPadOS simulators.`,hint:"Run `xcrun simctl ui <device> content_size` on a booted iPhone or iPad simulator.",reason:`setting-unsupported-on-leaf`});function A(e,t){let n=t?.trim().toLowerCase();return n===void 0?void 0:e.find(e=>e===n)}function j(n){let r=A(t,n);if(r!==void 0)return r;throw new e(`INVALID_ARGS`,`Invalid permission action: ${n}. Use ${t.join(`|`)}.`)}function M(t){let n=A(r,t);if(n!==void 0)return n;throw new e(`INVALID_ARGS`,`permission setting requires a target: ${r.join(`|`)}`)}function N(t,n){if(t===void 0||t.trim()===``)throw new e(`INVALID_ARGS`,`settings location set requires ${n}`);return F(Number(t),n)}function P(e){return{latitude:F(e?.latitude,`latitude`),longitude:F(e?.longitude,`longitude`)}}function F(t,n){let r=n===`latitude`?-90:-180,i=n===`latitude`?90:180;if(typeof t!=`number`||!Number.isFinite(t)||t<r||t>i)throw new e(`INVALID_ARGS`,`${n} must be a number from ${r} to ${i}`);return t}export{j as _,r as a,O as b,C as c,a as d,s as f,w as g,D as h,i,b as l,T as m,P as n,t as o,c as p,k as r,n as s,N as t,S as u,M as v,o as x,E as y};

package/dist/src/managed-device-scope.js

@@ -1 +1 @@
-import{D as e}from"./sdk-contracts.js";import{E as t,k as n}from"./sdk-device.js";import{t as r}from"./scoped-provider.js";const i=r(void 0);function a(){return i.resolve()}async function o(e,t){return await i.run(e,t)}function s(r,i){if(!n(t(r.device),t(i))||r.device.simulatorSetPath!==i.simulatorSetPath)throw new e(`COMMAND_FAILED`,`Managed automation cannot select another device.`,{reason:`managed-device-transport-mismatch`})}function c(){let e=a();if(e)return async t=>{s(e,t)}}async function l(e){let t=c();return t?(await t(e),!0):!1}export{o as a,c as i,a as n,l as r,s as t};
+import{O as e}from"./sdk-contracts.js";import{A as t,D as n}from"./sdk-device.js";import{t as r}from"./scoped-provider.js";const i=r(void 0);function a(){return i.resolve()}async function o(e,t){return await i.run(e,t)}function s(r,i){if(!t(n(r.device),n(i))||r.device.simulatorSetPath!==i.simulatorSetPath)throw new e(`COMMAND_FAILED`,`Managed automation cannot select another device.`,{reason:`managed-device-transport-mismatch`})}function c(){let e=a();if(e)return async t=>{s(e,t)}}async function l(e){let t=c();return t?(await t(e),!0):!1}export{o as a,c as i,a as n,l as r,s as t};