@applitools/nlp-web-runner 5.2.2 → 5.4.0

package/dist/_inline/nlp-runner/web/index.d.ts

@@ -1,4 +1,3 @@
-import { AbsolutePosition, Action, AnchorDescriptor, AnchorDescriptor as AnchorDescriptor$1, Any, ChromeElementDescriptor, CloseAction, Condition, ContentType, ControlType, DropPreinstructionsControlFlow, ElementDescriptor, ElementDescriptor as ElementDescriptor$1, ElementScrollDirection, EntriesOperation, Extractor, FileHandle, Generator as Generator$1, IfControlFlow, InitializeScopeControlFlow, Instruction, InterpolatedString, JSExpression, JSExpressionReference, KeysOperation, NumberExpression, OTP, Operand, Operation, Pattern, Primitive, RandomValue, Reference, RelativePosition, SetPreinstructionsControlFlow, SizeOperation, StructuralType, Structure, TryControlFlow, ValuesOperation } from "@applitools/nlp-parser";
 import { Dispatcher, WebSocket } from "undici";
 import { Readable } from "node:stream";
 import { Har } from "chrome-har";
@@ -6,10 +5,537 @@ import { Protocol } from "devtools-protocol";
 type WebDriver = never;
 import { ProtocolMapping } from "devtools-protocol/types/protocol-mapping.js";
 
-//#region dist/_inline/_chunks/node-CXUBkeAF.d.ts
+//#region ../parser/dist/types.d.ts
+type SetPreinstructionsControlFlow = {
+  type: 'set preinstructions';
+  instructions: Instruction[];
+};
+type DropPreinstructionsControlFlow = {
+  type: 'drop preinstructions';
+};
+type TryControlFlow = {
+  type: 'try';
+  instructions: Instruction[];
+};
+type InitializeScopeControlFlow = {
+  type: 'initialize scope';
+  name: string;
+  parameters?: {
+    name: string;
+    value: AnyExpression;
+    secret: boolean;
+  }[];
+  options?: {
+    navigation?: 'all';
+    assertions?: 'visual' | 'nonvisual' | 'all';
+  };
+};
+type IfControlFlow = {
+  type: 'if';
+  condition: Condition;
+  then?: Instruction[];
+  otherwise?: Instruction[];
+};
+type ControlFlow = SetPreinstructionsControlFlow | DropPreinstructionsControlFlow | TryControlFlow | InitializeScopeControlFlow | IfControlFlow;
+type EmptyAction = {
+  type: 'empty';
+};
+type CommentAction = {
+  type: 'comment';
+  text: string;
+};
+type SetVariableAction = {
+  type: 'set variable';
+  destruction?: boolean;
+  names: {
+    name: string;
+    secret?: boolean;
+  }[];
+  data: {
+    value: AnyExpression | Extractor<ElementDescriptor, any> | Generator$1;
+    secret?: boolean;
+  };
+  scope?: 'public' | 'internal';
+};
+type SetValueAction = {
+  type: 'set value';
+  value: StringExpression | NumberExpression | Generator$1 | FileHandle;
+  element: ElementDescriptor;
+};
+type FetchAction = {
+  type: 'fetch';
+  url: StringExpression;
+  method?: 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head' | 'trace' | 'options' | 'connect';
+  auth?: {
+    type: 'basic';
+    username: StringExpression;
+    password: StringExpression;
+  };
+  headers?: {
+    name: StringExpression;
+    value: StringExpression;
+    secret: boolean;
+  }[];
+  cookies?: {
+    name: StringExpression;
+    value: StringExpression;
+    secret: boolean;
+  }[];
+  body?: {
+    type?: 'json' | 'xml' | 'base64';
+    data: AnyExpression;
+  };
+  statuses?: number[] | '*';
+};
+type AssertAction = {
+  type: 'assert';
+  condition: Condition;
+  timeout?: NumberExpression;
+};
+type EvaluateAction = {
+  type: 'evaluate';
+  js: JSExpression;
+};
+type FocusAction = {
+  type: 'focus';
+  element: ElementDescriptor;
+};
+type CheckAction = {
+  type: 'check';
+  value: boolean;
+  element: ElementDescriptor;
+};
+type ClearAction = {
+  type: 'clear';
+  element?: ElementDescriptor;
+};
+type EraseAction = {
+  type: 'erase';
+  size: NumberExpression;
+  element?: ElementDescriptor;
+};
+type TypeAction = {
+  type: 'type';
+  value: AnyExpression | Extractor<ElementDescriptor, any> | Generator$1;
+  secret?: boolean;
+  element?: ElementDescriptor | ChromeElementDescriptor;
+};
+type SearchAction = {
+  type: 'search';
+  value: StringExpression;
+  element?: ElementDescriptor;
+};
+type HitKeyAction = {
+  type: 'hit key';
+  keys: Key[];
+  times?: NumberExpression;
+};
+type ClickElementAction = {
+  type: 'click';
+  keys?: Key[];
+  element: ElementDescriptor;
+  button?: 'left' | 'right';
+  times?: number;
+};
+type ClickChromeElementAction = {
+  type: 'click';
+  element: ChromeElementDescriptor;
+};
+type HoverAction = {
+  type: 'hover';
+  element: ElementDescriptor;
+};
+type ScrollByDistanceAction = {
+  type: 'scroll';
+  distance?: NumberExpression;
+  direction?: Direction;
+  times?: NumberExpression;
+};
+type ScrollByFractionAction = {
+  type: 'scroll';
+  fraction: NumberExpression;
+  element?: ElementDescriptor | ViewportDescriptor;
+  direction?: Direction;
+  times?: NumberExpression;
+};
+type ScrollToPositionAction = {
+  type: 'scroll';
+  position: AbsolutePosition;
+  element?: ElementDescriptor | ViewportDescriptor;
+  times?: NumberExpression;
+};
+type ScrollToElementAction = {
+  type: 'scroll';
+  element: ElementDescriptor;
+};
+type ScrollTheElementAction = {
+  type: 'scroll';
+  element: ElementDescriptor;
+  direction?: Direction;
+  distance: NumberExpression;
+  times?: NumberExpression;
+};
+type AlertAction = {
+  type: 'alert';
+  value: boolean;
+  condition?: ElementCondition;
+};
+type NavigatePdfAction = {
+  type: 'navigate pdf';
+  page: NumberExpression;
+};
+type NavigateToUrlAction = {
+  type: 'navigate';
+  url: StringExpression;
+  relative?: boolean;
+  statuses?: number[] | '*';
+};
+type NavigateThroughHistoryAction = {
+  type: 'navigate';
+  direction: HistoryDirection;
+  times?: NumberExpression;
+};
+type GoAction = {
+  type: 'go';
+  target: StringExpression;
+};
+type RefreshAction = {
+  type: 'refresh';
+  value?: 'hard' | 'soft';
+};
+type CreateTargetAction = {
+  type: 'create target';
+  url?: StringExpression;
+};
+type CloseTargetAction = {
+  type: 'close target';
+};
+type CloseAction = {
+  type: 'close';
+  element: ElementDescriptor;
+};
+type SwitchTargetByIndexAction = {
+  type: 'switch target';
+  index: NumberExpression;
+};
+type SwitchTargetByTitleAction = {
+  type: 'switch target';
+  title: StringExpression;
+};
+type SwitchTargetByPositionAction = {
+  type: 'switch target';
+  position: SequentialRelativePosition;
+};
+type WaitAction = {
+  type: 'wait';
+  timeout?: NumberExpression;
+  condition?: Condition;
+};
+type FindAction = {
+  type: 'find';
+  element: ElementDescriptor;
+};
+type VisualCheckAction = {
+  type: 'visual check';
+};
+type IntentAction = {
+  type: 'intent';
+  description: string;
+};
+type Action<TType extends string> = Extract<EmptyAction | CommentAction | SetVariableAction | SetValueAction | FetchAction | AssertAction | EvaluateAction | FocusAction | CheckAction | ClearAction | EraseAction | TypeAction | HitKeyAction | SearchAction | ClickElementAction | ClickChromeElementAction | HoverAction | ScrollByDistanceAction | ScrollByFractionAction | ScrollToPositionAction | ScrollToElementAction | ScrollTheElementAction | AlertAction | NavigateToUrlAction | NavigateThroughHistoryAction | NavigatePdfAction | RefreshAction | CreateTargetAction | CloseTargetAction | CloseAction | SwitchTargetByIndexAction | SwitchTargetByTitleAction | SwitchTargetByPositionAction | WaitAction | GoAction | FindAction | VisualCheckAction | IntentAction, {
+  type: TType;
+}>;
+type Instruction = Action<any> | ControlFlow;
+type Primitive<TPrimitiveName extends string> = TPrimitiveName extends 'null' ? null : TPrimitiveName extends 'boolean' ? boolean : TPrimitiveName extends 'number' ? number : TPrimitiveName extends 'string' ? string : TPrimitiveName extends 'any' ? Any : unknown;
+type PrimitiveName<TPrimitive = Any> = TPrimitive extends null ? 'null' : TPrimitive extends boolean ? 'boolean' : TPrimitive extends number ? 'number' : TPrimitive extends string ? 'string' : TPrimitive extends Any ? 'any' : never;
+type Reference<TType> = {
+  isRef: true;
+  name: string;
+  modifiers?: ({
+    get: number | StringExpression;
+  } | {
+    match: Pattern;
+  })[];
+  type?: PrimitiveName<TType>;
+  scope?: 'public' | 'internal';
+};
+type JSExpressionReference<TType> = {
+  isJSExpressionRef: true;
+  expression: JSExpression;
+  type?: PrimitiveName<TType>;
+};
+type InterpolatedString = {
+  isInterpolatedString: true;
+  chunks: (string | Reference<string> | JSExpressionReference<string>)[];
+};
+type JSExpression = {
+  isJSExpression: true;
+  chunks: (string | Reference<Any>)[];
+};
+type Structure = ArrayStructure | RecordStructure;
+type ArrayStructure = {
+  isStructure: true;
+  type: 'array';
+  items: AnyExpression[];
+};
+type RecordStructure = {
+  isStructure: true;
+  type: 'record';
+  items: {
+    key: StringExpression;
+    value: AnyExpression;
+  }[];
+};
+type Pattern = {
+  isPattern: true;
+  flags?: string;
+} & ({
+  pattern: string;
+} | {
+  name: PatternName;
+});
+type PatternName = 'number' | 'price' | 'percentage' | 'date' | 'time' | 'code';
+type Extractor<TValue, TType extends Primitive<any>> = {
+  isExtractor: true;
+  value: TValue;
+  type: PrimitiveName<TType> | 'color' | 'background-color' | 'foreground-color';
+};
+type OTP = {
+  isOTP: true;
+  user: StringExpression;
+};
+type RandomValue<TType extends Primitive<any> = any> = {
+  isRandomValue: true;
+  description?: StringExpression;
+  type?: PrimitiveName<TType>;
+  properties?: string[];
+};
+type Generator$1 = OTP | RandomValue;
+type FileHandle = {
+  isFileHandle: true;
+  filename: StringExpression;
+};
+type NumberExpression = number | NumberOperation | Reference<number> | JSExpressionReference<number>;
+type StringExpression = string | InterpolatedString | Reference<string> | JSExpressionReference<string>;
+type Any = null | boolean | number | string | {
+  [key: string]: Any;
+} | Any[];
+type AnyExpression = null | boolean | number | NumberOperation | string | InterpolatedString | Structure | Reference<Any> | JSExpressionReference<Any>;
+type Condition = {
+  isCondition: true;
+  operation: ConditionOperation;
+};
+type Operation = ConditionOperation | ExpressionOperation;
+type ExpressionOperation = SizeOperation | KeysOperation | ValuesOperation | EntriesOperation | NumberOperation;
+type NumberOperation = AddOperation | SubOperation | MulOperation | DivOperation;
+type ConditionOperation = ParensOperation | IgnoreCaseOperation | MatchCaseOperation | NotOperation | OrOperation | AndOperation | ComparisonOperation | ValidateOperation | MatchOperation | IncludesOnlyOperation | IncludesOperation | StartsWithOperation | EndsWithOperation | VisibleOperation | ClickableOperation | EnabledOperation | HoveredOperation | CheckedOperation | PopulatedOperation;
+type Operand = {
+  isOperand: true;
+  value: AnyExpression | ElementDescriptor | Extractor<ElementDescriptor, any> | DialogDescriptor | ExpressionOperation;
+};
+type ParensOperation = {
+  operator: 'parens';
+  operands: [ConditionOperation];
+};
+type NotOperation = {
+  operator: 'not';
+  operands: [ConditionOperation];
+};
+type IgnoreCaseOperation = {
+  operator: 'ignore case';
+  operands: [ConditionOperation];
+};
+type MatchCaseOperation = {
+  operator: 'match case';
+  operands: [ConditionOperation];
+};
+type SizeOperation = {
+  operator: 'size';
+  operands: [Operand];
+};
+type KeysOperation = {
+  operator: 'keys';
+  operands: [Operand];
+};
+type ValuesOperation = {
+  operator: 'values';
+  operands: [Operand];
+};
+type EntriesOperation = {
+  operator: 'entries';
+  operands: [Operand];
+};
+type AddOperation = {
+  operator: 'add';
+  operands: [Operand, Operand];
+};
+type SubOperation = {
+  operator: 'sub';
+  operands: [Operand, Operand];
+};
+type MulOperation = {
+  operator: 'mul';
+  operands: [Operand, Operand];
+};
+type DivOperation = {
+  operator: 'div';
+  operands: [Operand, Operand];
+};
+type OrOperation = {
+  operator: 'or';
+  operands: [ConditionOperation, ConditionOperation];
+};
+type AndOperation = {
+  operator: 'and';
+  operands: [ConditionOperation, ConditionOperation];
+};
+type ComparisonOperation = EqOperation | LtOperation | GtOperation | LteOperation | GteOperation;
+type EqOperation = {
+  operator: 'eq';
+  operands: [Operand, Operand];
+};
+type LtOperation = {
+  operator: 'lt';
+  operands: [Operand, Operand];
+};
+type GtOperation = {
+  operator: 'gt';
+  operands: [Operand, Operand];
+};
+type LteOperation = {
+  operator: 'lte';
+  operands: [Operand, Operand];
+};
+type GteOperation = {
+  operator: 'gte';
+  operands: [Operand, Operand];
+};
+type ValidateOperation = {
+  operator: 'validate';
+  operands: [Operand, `${'lower' | 'upper' | 'pascal' | 'camel' | 'snake' | 'kebab'}case` | 'capitalized' | 'numeric' | 'alphanumeric'];
+};
+type MatchOperation = {
+  operator: 'match';
+  operands: [Operand, Pattern];
+};
+type IncludesOnlyOperation = {
+  operator: 'includes only';
+  operands: [Operand, Operand, ...Operand[]];
+};
+type IncludesOperation = {
+  operator: 'includes';
+  operands: [Operand, Operand];
+};
+type StartsWithOperation = {
+  operator: 'starts with';
+  operands: [Operand, Operand];
+};
+type EndsWithOperation = {
+  operator: 'ends with';
+  operands: [Operand, Operand];
+};
+type VisibleOperation = {
+  operator: 'visible';
+  operands: [Operand];
+};
+type ClickableOperation = {
+  operator: 'clickable';
+  operands: [Operand];
+};
+type EnabledOperation = {
+  operator: 'enabled';
+  operands: [Operand];
+};
+type HoveredOperation = {
+  operator: 'hovered';
+  operands: [Operand];
+};
+type CheckedOperation = {
+  operator: 'checked';
+  operands: [Operand, boolean];
+};
+type PopulatedOperation = {
+  operator: 'populated';
+  operands: [Operand];
+};
+type ElementScrollDirection = 'horizontal' | 'vertical' | 'both';
+type ElementDescriptor = {
+  nth?: NumberExpression;
+  type?: ElementType | ElementType[];
+  title?: StringExpression | Pattern;
+  orderDirection?: 'forward' | 'backward';
+  state?: {
+    focused?: boolean;
+    active?: boolean;
+  };
+  color?: StringExpression;
+  superlative?: Superlative;
+  selector?: Selector$1;
+  hints?: {
+    type?: ElementType | ElementType[];
+    scrollable?: ElementScrollDirection;
+    role?: 'close' | 'submit' | 'cancel';
+  };
+  avoid?: ElementDescriptorAvoid | ElementDescriptorAvoid[];
+  anchor?: AnchorDescriptor | AnchorDescriptor[];
+  secret?: boolean;
+  fallback?: ElementDescriptor;
+  vocabulary?: Record<string, string>[];
+};
+type ElementDescriptorAvoid = {
+  type?: ElementType | ElementType[];
+  ancestor?: {
+    type?: ElementType | ElementType[];
+    minScore?: number;
+  };
+};
+type Selector$1 = {
+  type: 'css' | 'xpath';
+  selector: StringExpression;
+};
+type AnchorDescriptor<TElement = ElementDescriptor> = RelativeAnchorDescriptor<TElement> | AbsoluteAnchorDescriptor<TElement>;
+type RelativeAnchorDescriptor<TElement = ElementDescriptor> = {
+  position: RelativePosition | RelativePosition[];
+  element: TElement;
+};
+type AbsoluteAnchorDescriptor<TElement = ElementDescriptor> = {
+  position: AbsolutePosition | AbsolutePosition[];
+  element?: TElement | ViewportDescriptor;
+};
+type DialogDescriptor = {
+  isDialogDescriptor: true;
+};
+type ChromeElementDescriptor = {
+  isChromeElementDescriptor: true;
+  title: 'refresh' | 'back' | 'forward' | 'url';
+};
+type ViewportDescriptor = {
+  isViewportDescriptor: true;
+};
+type CharacterKey = 'Backquote' | 'Digit1' | 'Digit2' | 'Digit3' | 'Digit4' | 'Digit5' | 'Digit6' | 'Digit7' | 'Digit8' | 'Digit9' | 'Digit0' | 'Minus' | 'Equal' | 'Backslash' | 'KeyQ' | 'KeyW' | 'KeyE' | 'KeyR' | 'KeyT' | 'KeyY' | 'KeyU' | 'KeyI' | 'KeyO' | 'KeyP' | 'BracketLeft' | 'BracketRight' | 'KeyA' | 'KeyS' | 'KeyD' | 'KeyF' | 'KeyG' | 'KeyH' | 'KeyJ' | 'KeyK' | 'KeyL' | 'Semicolon' | 'Quote' | 'KeyZ' | 'KeyX' | 'KeyC' | 'KeyV' | 'KeyB' | 'KeyN' | 'KeyM' | 'Comma' | 'Period' | 'Slash';
+type ArrowKey = 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight';
+type ControlKey = 'Escape' | 'F1' | 'F2' | 'F3' | 'F4' | 'F5' | 'F6' | 'F7' | 'F8' | 'F9' | 'F10' | 'F11' | 'F12' | 'Backspace' | 'Tab' | 'CapsLock' | 'Enter' | 'ShiftLeft' | 'ShiftRight' | 'ControlLeft' | 'MetaLeft' | 'AltLeft' | 'Space' | 'AltRight' | 'AltGraph' | 'MetaRight' | 'ControlRight' | 'Delete' | 'Home' | 'End' | 'PageUp' | 'PageDown' | 'Insert';
+type Key = ControlKey | ArrowKey | CharacterKey;
+type ElementCondition = {
+  type: ConditionType;
+  element?: ElementDescriptor;
+};
+type ConditionType = 'exists' | 'not-exists' | 'visible' | 'not-visible' | 'clickable';
+type ElementType = StructuralType | ControlType | ContentType;
+type StructuralType = 'app' | 'host' | 'ad' | 'header' | 'footer' | 'sidebar' | 'popup' | 'tooltip' | 'modal' | 'scrollable' | 'form' | 'fieldset' | 'menu' | 'menuitem' | 'hamburger' | 'list' | 'listitem' | 'heading' | 'table' | 'table-cell' | 'table-head-cell' | 'table-row' | 'table-dom-row' | 'table-leaf-row' | 'table-head-row' | 'table-column' | 'table-leaf-column' | 'table-stub-column' | 'card' | 'pdfpage';
+type ControlType = 'checkboxgroup' | 'checkbox' | 'radiogroup' | 'radio' | 'textbox' | 'combobox' | 'listbox' | 'option' | 'datepicker' | 'timepicker' | 'datetimepicker' | 'colorpicker' | 'filepicker' | 'slider' | 'inputbox' | 'selectbox' | 'valuebox' | 'button' | 'color';
+type ContentType = 'text' | 'link' | 'label' | 'logo' | 'image' | 'icon' | 'video' | 'paragraph';
+type HistoryDirection = 'back' | 'forward';
+type SequentialRelativePosition = 'next' | 'previous';
+type Direction = 'up' | 'down' | 'left' | 'right';
+type Superlative = 'smallest' | 'largest' | 'widest' | 'narrowest' | 'tallest' | 'shortest' | 'leftmost' | 'rightmost' | 'topmost' | 'bottommost';
+type AbsolutePosition = 'inside' | 'center' | 'top' | 'bottom' | 'left' | 'right' | 'topleft' | 'topright' | 'bottomleft' | 'bottomright';
+type RelativePosition = 'near' | 'above' | 'below' | 'leftof' | 'rightof' | 'aboveleftof' | 'aboverightof' | 'belowleftof' | 'belowrightof';
+//#endregion
+//#region dist/_inline/_chunks/node-Cd1bkA9w.d.ts
 //#region src/automator.d.ts
 interface Automator {
-  readonly type: 'web' | 'ios';
+  readonly type: 'web' | 'mobile';
   readonly blocked: boolean;
   captureScreenshot(): Promise<string>;
   stabilize(stage: 'basic' | 'strict' | 'paranoid', options?: {
@@ -240,7 +766,7 @@ declare class Rectangle {
 //#region src/patterns.d.ts
 type Match = (text: string) => string | null;
 //#endregion
-//#region dist/_inline/_chunks/script-ClTb75Ul.d.ts
+//#region dist/_inline/_chunks/script-6O13rCLT.d.ts
 //#region src/port.d.ts
 interface PortMessageEvent<TName extends string = string, TPayload = unknown> extends Event {
   readonly name: TName;
@@ -1131,7 +1657,7 @@ declare class Target extends EventTargetNode<TargetEventMap> {
   }: TargetOptions);
   frames(): Generator<Frame, void, unknown>;
   targets(): Generator<Target, void, unknown>;
-  wait(event: 'stable' | 'initialized' | 'windowResolved' | 'navigated' | 'pendingRequests' | 'dialogOpened', {
+  wait(event: 'stable' | 'attached' | 'initialized' | 'windowResolved' | 'navigated' | 'pendingRequests' | 'dialogOpened', {
     signal
   }?: {
     signal?: AbortSignal;
@@ -7702,7 +8228,8 @@ interface AXOption {
 }
 interface AXState {
   disabled?: boolean;
-  active?: boolean;
+  /** Not a hit target (e.g. `pointer-events: none` on web, `isUserInteractionEnabled == false` on iOS). Absent means interactable. */
+  inert?: boolean;
   focused?: boolean;
   checked?: boolean;
 }
@@ -7872,7 +8399,7 @@ interface IAXTreeView<TNode = unknown> extends Iterable<IAXNodeView<TNode>> {
 }
 //#endregion
 //#region src/columbus/types.d.ts
-type ResolvedElementDescriptor = Omit<ElementDescriptor$1, 'title' | 'nth' | 'selector' | 'anchor' | 'color'> & {
+type ResolvedElementDescriptor = Omit<ElementDescriptor, 'title' | 'nth' | 'selector' | 'anchor' | 'color'> & {
   nth?: number;
   title?: string | Pattern;
   color?: string;
@@ -7884,7 +8411,7 @@ type ResolvedElementDescriptor = Omit<ElementDescriptor$1, 'title' | 'nth' | 'se
   fallback?: ResolvedElementDescriptor;
   node?: IAXNodeView;
 };
-type ResolvedAnchor = AnchorDescriptor$1<ResolvedElementDescriptor>;
+type ResolvedAnchor = AnchorDescriptor<ResolvedElementDescriptor>;
 type DescriptorStrategy = 'require' | 'allow' | 'avoid';
 interface ElementDescriptorQuery<TNode extends string[] | IAXNodeView<any>> {
   node: TNode;
@@ -8227,7 +8754,7 @@ type DeviceOptions = {
   connection: Connection$2;
 };
 declare class Device implements Automator {
-  readonly type = "ios";
+  readonly type = "mobile";
   readonly connection: Connection$2;
   readonly blocked = false;
   constructor({
@@ -8244,7 +8771,7 @@ declare class Device implements Automator {
 //#region src/utils/values-stack.d.ts
 type ElementDescriptorItem = {
   type: 'descriptor';
-  entity: ElementDescriptor$1;
+  entity: ElementDescriptor;
   value: ResolvedElementDescriptor;
 };
 type NodeItem = {
@@ -8287,8 +8814,8 @@ type Item<TType extends string> = Extract<ElementDescriptorItem | NodeItem | Ref
 type Entity = Item<any>['entity'];
 declare class ValuesStack {
   #private;
-  descriptor(entity: ElementDescriptor$1): (value: ResolvedElementDescriptor) => ResolvedElementDescriptor;
-  descriptor(entity: ElementDescriptor$1, value: ResolvedElementDescriptor): ResolvedElementDescriptor;
+  descriptor(entity: ElementDescriptor): (value: ResolvedElementDescriptor) => ResolvedElementDescriptor;
+  descriptor(entity: ElementDescriptor, value: ResolvedElementDescriptor): ResolvedElementDescriptor;
   node(entity: ResolvedElementDescriptor): (value: IAXNodeView<Node>) => IAXNodeView<Node>;
   node(entity: ResolvedElementDescriptor, value: IAXNodeView<Node>): IAXNodeView<Node>;
   reference(entity: Reference<Any>): (value: Any, meta?: {
@@ -8649,7 +9176,7 @@ declare const ErrorCode: {
 type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
 //#endregion
 //#region src/utils/evaluate-expression.d.ts
-type EvaluatedExpression<TValue> = TValue extends Extractor<ElementDescriptor$1, infer TResult extends Any> ? TResult : TValue extends NumberExpression ? number : TValue extends SizeOperation ? number : TValue extends KeysOperation ? string[] : TValue extends ValuesOperation | EntriesOperation ? Any[] : TValue extends Condition ? boolean : TValue extends OTP ? string : TValue extends RandomValue<string> ? string | string[] : TValue extends RandomValue<number> ? number : TValue extends Reference<infer TType extends Any> ? TType : TValue extends JSExpressionReference<infer TType extends Any> ? TType : TValue extends InterpolatedString ? string : TValue extends JSExpression ? string : TValue extends Structure ? Record<string, any> | any[] : TValue extends FileHandle ? string : TValue extends Pattern ? RegExp | Match : TValue extends ChromeElementDescriptor ? ChromeElementDescriptor : TValue extends ElementDescriptor$1 ? ResolvedElementDescriptor : TValue;
+type EvaluatedExpression<TValue> = TValue extends Extractor<ElementDescriptor, infer TResult extends Any> ? TResult : TValue extends NumberExpression ? number : TValue extends SizeOperation ? number : TValue extends KeysOperation ? string[] : TValue extends ValuesOperation | EntriesOperation ? Any[] : TValue extends Condition ? boolean : TValue extends OTP ? string : TValue extends RandomValue<string> ? string | string[] : TValue extends RandomValue<number> ? number : TValue extends Reference<infer TType extends Any> ? TType : TValue extends JSExpressionReference<infer TType extends Any> ? TType : TValue extends InterpolatedString ? string : TValue extends JSExpression ? string : TValue extends Structure ? Record<string, any> | any[] : TValue extends FileHandle ? string : TValue extends Pattern ? RegExp | Match : TValue extends ChromeElementDescriptor ? ChromeElementDescriptor : TValue extends ElementDescriptor ? ResolvedElementDescriptor : TValue;
 //#endregion
 //#region src/handler.d.ts
 type HandlerOptions<TAutomator extends Automator, TInstruction extends Instruction> = {
@@ -8749,7 +9276,7 @@ declare abstract class Handler$1<TAutomator extends Automator, TInstruction exte
   evaluate<TValue>(value: TValue): Promise<EvaluatedExpression<TValue>>;
   element(descriptor: ResolvedElementDescriptor): Promise<{
     web: IAXNodeView<WebNode> | null;
-    ios: IAXNodeView<IOSNode> | null;
+    mobile: IAXNodeView<IOSNode> | null;
   }[TAutomator["type"]]>;
   capture(): Promise<Capture | undefined>;
   before(): Promise<void>;
@@ -9316,44 +9843,7 @@ declare const handlers: {
     try: typeof TryHandler;
     if: typeof IfHandler;
   };
-  ios: {
-    check: typeof CheckHandler;
-    click: typeof ClickHandler;
-    find: typeof FindHandler;
-    focus: typeof FocusHandler;
-    scroll: typeof ScrollHandler;
-    type: typeof TypeHandler;
-    assert: typeof AssertHandler;
-    wait: typeof WaitHandler;
-    empty: typeof EmptyHandler;
-    comment: typeof EmptyHandler;
-    fetch: typeof FetchHandler;
-    'set variable': typeof SetVariableHandler;
-    'visual check': typeof VisualCheckHandler;
-    intent: typeof IntentHandler;
-    'set preinstructions': typeof DefinePreinstructionsHandler;
-    'drop preinstructions': typeof DefinePreinstructionsHandler;
-    'initialize scope': typeof InitializeScopeHandler;
-    try: typeof TryHandler;
-    if: typeof IfHandler;
-    "set value": never;
-    evaluate: never;
-    clear: never;
-    erase: never;
-    "hit key": never;
-    search: never;
-    hover: never;
-    alert: never;
-    navigate: never;
-    "navigate pdf": never;
-    refresh: never;
-    "create target": never;
-    "close target": never;
-    close: never;
-    "switch target": never;
-    go: never;
-  };
-  android: {
+  mobile: {
     check: typeof CheckHandler;
     click: typeof ClickHandler;
     find: typeof FindHandler;
@@ -9515,6 +10005,20 @@ declare class Runner<TAutomator extends Automator> extends EventTargetNode<Runne
   constructor(options: RunnerOptions<TAutomator>);
   run(input: string | Instruction[], options?: RunOptions): Promise<RunResult>;
   handle<TInstruction extends Instruction>(instruction: TInstruction, options?: RunOptions): Promise<HandlerResult<TAutomator, TInstruction>>;
+  /**
+   * Locates an element on the page and returns its node, or `null` when nothing matches.
+   *
+   * Accepts either a natural-language element descriptor string (e.g. `"the red submit button below the form"`)
+   * or a structured {@link ElementDescriptor} object. Unlike {@link run}/{@link handle}, this is a pure query:
+   * it stabilizes the page, resolves the descriptor, and runs Columbus element finding, but does not run
+   * preinstructions, capture screenshots, or update the active element.
+   *
+   * Web-oriented: the returned node is a `WebNode`, consistent with `RunnerContext.activeElement`.
+   */
+  find(descriptor: string | ElementDescriptor, options?: {
+    timeout?: number;
+    signal?: AbortSignal;
+  }): Promise<WebNode | null>;
   setScope(...names: string[]): Promise<void>;
   resetScope(): Promise<void>;
   dispose(): Promise<void>;
@@ -9576,7 +10080,7 @@ type SubinstructionExecutionStartedDetails = {
   };
 };
 type StepMetrics = {
-  platform?: 'web' | 'ios';
+  platform?: 'web' | 'mobile';
   stabilizeMs?: number;
   handleMs?: number;
   findStrategy?: 'columbus' | 'selector';
@@ -9664,7 +10168,7 @@ type FindNodeOptions = {
 };
 type FindNodeResult<TAutomator extends Automator> = {
   web: IAXNodeView<WebNode> | null;
-  ios: IAXNodeView<IOSNode$1> | null;
+  mobile: IAXNodeView<IOSNode$1> | null;
 }[TAutomator['type']];
 declare class AXOps<TAutomator extends Automator = Automator> {
   #private;