@applitools/nlp-web-runner 5.3.0 → 5.4.1-dev.df8483935

package/dist/_inline/_chunks/rolldown-runtime-D7D4PA-g.js

@@ -1 +1 @@
-var T=l;(function(B,E){var C=l,Y=B();while(!![]){try{var x=-parseInt(C(0x183))/0x1+parseInt(C(0x182))/0x2*(parseInt(C(0x17c))/0x3)+-parseInt(C(0x17f))/0x4*(-parseInt(C(0x17b))/0x5)+parseInt(C(0x17a))/0x6+-parseInt(C(0x17e))/0x7*(parseInt(C(0x17d))/0x8)+parseInt(C(0x185))/0x9*(-parseInt(C(0x179))/0xa)+parseInt(C(0x184))/0xb*(-parseInt(C(0x180))/0xc);if(x===E)break;else Y['push'](Y['shift']());}catch(J){Y['push'](Y['shift']());}}}(D,0x48619));function D(){var f=['mtG1mtmZmeDWwNbcyG','nw1QsKHTtG','ndm4s2rWwvD6','mtqXndq4AvLXEgPT','n1jvte9rtW','mtmXmti0ohf0qLzVCG','mZi0vuDsv1fN','zgvMAw5LuhjVCgvYDhK','mZG2oezvu2TAsG','mtuZotu2AxLjENHh','mtaYodGZrgDqtfDJ','ntu4zwvlsujx','Dg9tDhjPBMDuywC','mZe5ntbvqxLpwhG'];D=function(){return f;};return D();}var __defProp=Object[T(0x181)],__exportAll=(B,E)=>{var V=T;let Y={};for(var x in B)__defProp(Y,x,{'get':B[x],'enumerable':!![]});if(!E)__defProp(Y,Symbol[V(0x178)],{'value':'Module'});return Y;};function l(B,E){B=B-0x178;var Y=D();var x=Y[B];if(l['FKetDi']===undefined){var J=function(f){var j='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var m='',z='';for(var H=0x0,A,y,w=0x0;y=f['charAt'](w++);~y&&(A=H%0x4?A*0x40+y:y,H++%0x4)?m+=String['fromCharCode'](0xff&A>>(-0x2*H&0x6)):0x0){y=j['indexOf'](y);}for(var t=0x0,N=m['length'];t<N;t++){z+='%'+('00'+m['charCodeAt'](t)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(z);};l['ekiccp']=J,l['ZAmgBV']={},l['FKetDi']=!![];}var C=Y[0x0],T=B+C,V=l['ZAmgBV'][T];return!V?(x=l['ekiccp'](x),l['ZAmgBV'][T]=x):x=V,x;}export{__exportAll as t};
+function J(G,F){G=G-0x13f;var R=i();var l=R[G];if(J['eCUCuW']===undefined){var d=function(s){var E='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var x='',H='';for(var T=0x0,c,z,y=0x0;z=s['charAt'](y++);~z&&(c=T%0x4?c*0x40+z:z,T++%0x4)?x+=String['fromCharCode'](0xff&c>>(-0x2*T&0x6)):0x0){z=E['indexOf'](z);}for(var O=0x0,P=x['length'];O<P;O++){H+='%'+('00'+x['charCodeAt'](O)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(H);};J['vIMQhY']=d,J['UDeAWb']={},J['eCUCuW']=!![];}var u=R[0x0],A=G+u,K=J['UDeAWb'][A];return!K?(l=J['vIMQhY'](l),J['UDeAWb'][A]=l):l=K,l;}function i(){var s=['otuYmJK2vfPcyNDt','mZaWnJGWmwXOvKLszW','mteYDvDiD3by','mZu1otbXCNHUC1C','mti1nhHlBhHUCa','tw9KDwXL','mtaZngrYvuLUvW','mtyXmZvxDej0sxO','zgvMAw5LuhjVCgvYDhK','mu5wrvHzEa','nte4nxfczefSwG','mZaZmtm4Bvfnq210','oti0odC0twrLyuz4'];i=function(){return s;};return i();}var A=J;(function(G,F){var u=J,R=G();while(!![]){try{var l=parseInt(u(0x13f))/0x1*(parseInt(u(0x142))/0x2)+-parseInt(u(0x141))/0x3+parseInt(u(0x143))/0x4+parseInt(u(0x140))/0x5*(parseInt(u(0x147))/0x6)+-parseInt(u(0x14a))/0x7*(-parseInt(u(0x145))/0x8)+parseInt(u(0x144))/0x9+parseInt(u(0x146))/0xa*(-parseInt(u(0x149))/0xb);if(l===F)break;else R['push'](R['shift']());}catch(d){R['push'](R['shift']());}}}(i,0xcf08b));var __defProp=Object[A(0x14b)],__exportAll=(G,F)=>{var K=A;let R={};for(var l in G)__defProp(R,l,{'get':G[l],'enumerable':!![]});if(!F)__defProp(R,Symbol['toStringTag'],{'value':K(0x148)});return R;};export{__exportAll as t};

package/dist/_inline/_externals/nlp-runner.externals.json

@@ -1,5 +1,4 @@
 {
-  "@applitools/nlp-parser": "workspace:^",
   "culori": "^4.0.2",
   "undici": "^7.25.0",
   "chrome-har": "^1.3.1",

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,6 +5,537 @@ import { Protocol } from "devtools-protocol";
 type WebDriver = never;
 import { ProtocolMapping } from "devtools-protocol/types/protocol-mapping.js";
 
+//#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 Program$1 = Instruction[];
+type SealedProgram = {
+  __seal?: never;
+};
+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 {
@@ -7873,7 +8403,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;
@@ -7885,7 +8415,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;
@@ -8245,7 +8775,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 = {
@@ -8288,8 +8818,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?: {
@@ -8650,7 +9180,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> = {
@@ -9477,8 +10007,22 @@ declare class Runner<TAutomator extends Automator> extends EventTargetNode<Runne
   }>);
   get status(): ProgressStatus;
   constructor(options: RunnerOptions<TAutomator>);
-  run(input: string | Instruction[], options?: RunOptions): Promise<RunResult>;
+  run(input: string | Program$1 | SealedProgram, 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>;