j'BUdZddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z m Z mZmZmZmZmZmZddlmZddlmZmZmZmZmZmZmZm Z!m"Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ddl,m-Z-d Z.d Z/d Z0d Z1d Z2dZ3dZ4dZ5dZ6dZ7dZ8dZ9dZ:dZ;e<Z=de>d<e?fdd Z@dd!ZA dd"lBmCZDdZEn#eF$rZGdZDeGZEd#e>d$<YdZG[GndZG[GwwxYwdd%lmHZHd&ZIdd(ZJdd0ZKdd2ZLdd4ZMdd5ZNdd6ZOGd7d8ZPePZQd/e>d9<dd<ZRGd=d>ZSdd@ZTGdAdBZUddFZVddIZW dddJddKddVZXeZYdWe>dX<eZZdYe>dZ<dd\Z[dd^Z\dd`Z]ddbZ^ddeZ_ddgZ`ddiZaddkZbddqZcddsZdddtZeddwZfddyZgdd{Zhdd|Zidd}ddZj dddJdddZkddZlddZmdande>d<daod'e>d<dapd'e>d<daqd'e>d<iZrde>d<dZsdZtddZuddZvddZwddZxdd}ddZye GddZzddZ{ddZ|ddZ}ddZ~ddZddZddZgdZdS)aiWiring that routes pointer movement through the wrapper's own generator. WHY THE MOTION IS GENERATED HERE AND NOT IN THE BROWSER ------------------------------------------------------- Until now every ``mousemove`` was expanded inside the browser, by code that ships with the binary. That has three consequences we want to be rid of: * The trajectory is built from compiled-in constants, so its shape is an invariant across every session of every install. Generated here it derives from the session seed instead, which means two users - and two sessions of the same user - do not move the same way, and a replayed seed replays the cursor exactly like it replays the fingerprint. * The expansion happened *inside* the browser's own mouse-dispatch entry point, which is what breaks hover (see HOVER, below). * Changing anything about it required rebuilding and re-releasing a browser. Nothing is lost by moving it. The in-browser expansion dispatched its waypoints with exactly the same arguments the ordinary ``mouse.move`` path uses - same pressure, same input source, same pointer id, same synthesized flags - so a waypoint driven from here is indistinguishable from one the binary used to generate itself. HOW IT REACHES ``page.click`` WITHOUT A NEW API ----------------------------------------------- This package's promise is that it *is* Playwright: same objects, same methods, no rewrite. A ``page.move_like_a_human()`` helper would break that promise - it only helps code that was written after we shipped it, and every existing script keeps teleporting. So there is no new API. Instead we wrap the *one* internal funnel every pointer action already goes through. In Playwright's Python bindings, ``Page.click``, ``Frame.click`` and ``Locator.click`` all end up in the same coroutine on the implementation object (``Frame._click``); ``hover`` / ``dblclick`` / ``tap`` / ``check`` / ``uncheck`` funnel the same way, and ``Page.set_checked`` funnels into ``check`` / ``uncheck``. Wrapping those six coroutines therefore covers the public surface for the sync API *and* the async API at once, because the sync API is a greenlet driver over the very same implementation objects. User code that already says ``page.click("#buy")`` gets the motion with no edit. ``Mouse.move`` and ``Mouse.wheel`` are wrapped for the same reason. The wrappers are installed on the class, once per process, but they are inert unless the page belongs to a session that asked for them: the lookup is a weak-keyed registry, and a page from a plain ``sync_playwright()`` browser in the same process finds nothing and is delegated to untouched. HOVER ----- The in-browser expansion ran *inside* the mouse-dispatch entry point, i.e. after the automation layer had already installed its hit-target interceptor for this action. The interceptor's job is to confirm that the point being clicked really lands on the element it was told to click. It sees the first event of the action, and the first event of the action was the first waypoint of the curve, which sits far away from the target - usually over ````. The interceptor concludes the element is covered by another element and the action fails. On Windows that is roughly three hover calls in four. Generating here fixes it by construction, not by tuning: the whole approach runs to completion *before* we call the original coroutine, so the interceptor is installed after the cursor has already arrived. The only event it sees is the single, exact move the automation layer makes itself, onto the point it computed. There is no waypoint left inside the checked window for it to mistake for an obstruction. THE THREE LAYERS, AND WHO OWNS WHAT ------------------------------------ ``_motion`` the shape and the pacing of ONE stroke, A to B. ``_behaviour`` what an action is made of and what happens between actions: how many strokes, where they aim inside a control, the overshoot and the correction, the fidget while nothing is happening, the pointer creep during a scroll. Pure: it returns a timeline and never touches a clock. this module everything with a side effect. It decides WHEN the macro layer runs, walks the timeline against a real clock, keeps coordinates inside the viewport (a waypoint outside it is not merely dropped by the browser, it parks the cursor at the origin), and guarantees that none of the above can fail a call that would otherwise have succeeded. ``_motion`` is an optional dependency and its absence is survivable: without it a session hands the job back to the browser's own expansion and says so. ``_behaviour`` is not optional - it decides where an action aims - so it is imported plainly. It is pure stdlib and in this same package, so an install in which it fails to import is an install in which nothing else works either. WHEN THE MACRO LAYER RUNS - AND WHY IT IS NOT A BACKGROUND TASK ---------------------------------------------------------------- The honest way to make a pointer move while the caller's script is doing nothing would be a background task dispatching pointer events on its own. We do not do that, deliberately. The caller's script is single-threaded by assumption; a second writer on the same page would interleave a ``mousemove`` into the middle of somebody's ``click`` - precisely the hit-target failure described under HOVER - and it would keep sending input to a page whose script believes nothing is touching it. A stealth feature that intermittently breaks clicks is not a stealth feature. So every event this module sends is sent from inside a call the user made, and the macro layer is folded into the head of the NEXT action instead: * the wall clock since the last dispatch is real, and it is the input the idle planner wants. We plan the whole of that idle period, then dispatch only the tail of it that fits the movement budget (:func:`_behaviour.tail_within`). What reaches the wire is therefore the last fraction of a second of a fidget that is planned as if it had been running all along; * the approach to a control is planned by :func:`_behaviour.plan_approach`, so an action is one to three submovements with a dwell between them, ending on a point inside the element that is not its centre; * ``mouse.wheel`` becomes a burst of detents with the pointer creeping between them, which is what a hand on a wheel does. The whole of it is bounded by ``humanize=``: one action never spends more than that budget in motion, and the budget is enforced by DROPPING waypoints, never by emitting them faster than a device could report them. ) annotationsN) dataclass)AnyCallableDictIterableListOptionalSequenceTuple)WeakKeyDictionary)DONESLEEPEvPacerPointerPersonaStepclamp_to_viewport fine_timer fit_timelineinitial_pointer landing_pointplan_aimless_move plan_approach plan_idle plan_scrollsteps_from_waypoints tail_within)sub_seedINVPW_CURSOR_ENGINEpythonbinaryoffINVPW_CURSOR_LANDINGg?gy@g@gffffff?)g@g@g@g(@gQ?gp= ף?set_warnedkeystrmessagecategorytypereturnNonec|tvrdSt|tjd|z|ddS)Nzinvisible_playwright: ) stacklevel)r&addwarningswarn)r'r)r*s LC:\Projects\Muse2API\.venv\Lib\site-packages\invisible_playwright/_cursor.py _warn_oncer5sE g~~ KK M*W4h1MMMMMMc8tdS)z;Test hook: forget which warnings have already been emitted.N)r&clearr6r4_reset_warningsr:s MMOOOOOr6)jugglerzOptional[BaseException]_MOTION_IMPORT_ERROR)MIN_EVENT_INTERVAL_MS) CursorMotion MotionProfile new_motionOptional[Callable[..., Any]]ct}|.tD]&}t||d}t|r|cS't%dt tjdtdnd}tdd|zdzdS) zEReturn the callable that builds a per-page stroke generator, or None.Nz (: )z no-motionzFno cursor motion generator found (invisible_core.juggler.CursorMotion)zk; falling back to the browser's own motion for this process. This is a broken install, not a configuration.) _motion_mod_MOTION_FACTORY_NAMESgetattrcallabler<r+__name__r5)modnamefactorydetails r4_motion_factoryrOs C )  Dc4..G     + LT& ' ' 0KK4HKKKK   028 9<( ( 4r6rMCallable[..., Any]seedint max_secondsfloatrc tj|j}n#ttf$ri}YnwxYwd|vr |||S||S)aConstruct a profile, whether or not the generator wants the cap. The cap belongs to the public constructor (``humanize=``), so the wrapper honours it either way: a generator that takes it applies it itself, one that does not gets its schedule fitted here. rSrQrS)inspect signature parameters TypeError ValueError)rMrQrSparamss r4_build_profiler]ss"7++6 z "wDk:::: 74==s 22boolc>tduo tS)z?True when a generator exists AND the bindings could be wrapped.N)rO_ensure_patchedr9r6r4motion_availablera,s   D ( >_->->>r6humanizec,|stStjtpd}|tdfvrtS|tdddfvrtStrtntS)anDecide who generates the motion for a session. ``humanize`` keeps exactly the meaning it has always had on the public constructor: falsy disables humanisation, ``True`` enables it with the default cap, a number enables it with that cap in seconds. This function only decides WHERE the motion comes from, never WHETHER the user asked for it. rEr;nonefalse0) ENGINE_OFFosenvironget ENGINE_ENVstriplower ENGINE_BINARYra ENGINE_PYTHON)rbchoices r4resolve_cursor_enginerq1s jnnZ((.B 5 5 7 7 = = ? ?F -+++ *fgs333-.. A==MAr6c|durtS t|}n#ttf$r tcYSwxYw|dkr|ntS)z1The motion-duration cap implied by ``humanize=``.Tr)_DEFAULT_MAX_SECONDSrTrZr[)rbvalues r4max_seconds_forruFsd4##$h z "$$$####$AII55#77s 88ctjtpddvS)zGWhether an action may be told to click somewhere other than the centre.rE)r#rfreno)rhrirj LANDING_ENVrlrmr9r6r4landing_enabledryQs@ JNN; ' ' -2 4 4 6 6 < < > >G r6cFeZdZdZdZed dZed dZd S) _RealTimerzWall clock and a real sleep.r9r,rTc(tjSN)time perf_counterr9r6r4nowz_RealTimer.nowcs """r6secondsr-c>Ktj|d{VdSr})asynciosleep)rs r4rz_RealTimer.sleepgs.mG$$$$$$$$$$$r6N)r,rT)rrTr,r-)rJ __module__ __qualname____doc__ __slots__ staticmethodrrr9r6r4r{r{^s]&&I###\#%%%\%%%r6r{_TIMER session_seedordinalct|}t|dzdz}||dzdzz dz}|dz }|dkr||dzz dzdz}|dz}|dk||dz z}|dzS) uHDerive a page's motion seed from the session seed. Per PAGE rather than per session so that determinism survives more than one tab: a single shared stream would make every path depend on the order in which tabs happened to move. Same session seed plus same tab ordinal gives the same path, which is what makes a replayed seed replay the cursor. Kept inside int31 for consistency with the rest of the seeding. ⛔ EVERY BIT OF THE ORDINAL COUNTS, not only the low 16. A page the site opened is numbered in a space of its own above bit 62 (`_behaviour. popup_number`), and with the old mask two popups shared a path whenever their numbers agreed on 16 bits. The higher bits are folded in only when there are any, so the pages the script asks for (0, 1, 2 ...) keep the seeds they always had. llyn<ilkJ rl5.ei)rR)rrhhighs r4page_motion_seedrps 'llG \  Z ':5A w:- .*r6ceZdZdZdZd d Zd S) _Sessionz6Everything a session hands to the pages underneath it.rVrQrRrSrTr,r-cVt||_t||_dSr})rRrQrTrS)selfrQrSs r4__init__z_Session.__init__s%II  --r6N)rQrRrSrTr,r-)rJrrrrrr9r6r4rrs3@@'I......r6rpagec6t|jdS)u:The page's number in the session, as the server gave it. ⛔ READ FROM THE PAGE, NEVER COUNTED HERE. The server sends it in the page's initializer (`PageDispatcher.number`: the number the client reserved at the `new_page()` call, or a popup's derived one), and the server draws the page's acts under it. This cursor used to count its own, at each page's FIRST MOVEMENT: a script that created two pages and moved on the second first gave the second page 0 here and 1 there - two counters for one fact, with two different orders ([B237]). pageNumber)rR _initializer)rs r4 page_numberrs t . / //r6cFeZdZdZdZd"d Zd#dZd$dZd%dZd&dZ d'd Z d!S)( _PageCursorzACursor state for one page: where it is, and how it likes to move.) rQrS_profilepersonaxybusyaction last_event_atrQrRrSrTrMrPr,r-ct||_t||_t ||j|j|_t j|j|_d|_ d|_ d|_ d|_ d|_ dS)NFr)rRrQrTrSr]rr from_seedrrrrrr)rrQrSrMs r4rz_PageCursor.__init__swII  --&w 4;KLL %/ :: "&"&  .2r6widthOptional[float]heightTuple[float, float]c R||}}|r|sOtddttdttdfzt\}}t|jdd}t |r{ |||\}}t |t |fS#tttf$r3}tddt|j d |d Yd}~nd}~wwxYwt|j t |t |fS) aWhere the pointer is before this page's first movement. Never the origin, and never a constant: a session whose first movement departs from (0, 0) is announcing that it had no pointer state at all before it started, which no real navigation produces. z no-viewportza page reported no viewport size; the cursor start position falls back to a nominal %dx%d viewport. Coordinates are still seeded, but they are not derived from the real window.r start_pointNzbad-start-pointz-the motion generator's start_point() failed (rCz)); using the behaviour planner's instead.)r5rR_FALLBACK_VIEWPORTrHrrIrTrZr[ArithmeticErrorr+rJrrQ) rrrwrfnpxpyexcs r4rz_PageCursor.start_points[f1 & & I)!,--s3Ea3H/I/IJK   &DAq T]M4 8 8 B<<  AqBRyy%))++z?;   %%Cyy)))3330 ty588U1XX*>???s>,B++C5)C00C5rrc|j|j5t|\}}|||\|_|_t |jt |jfS)zACurrent pointer position, placing it first if it has never moved.)rr _viewportrrT)rrrrs r4herez_PageCursor.heresV 6>TV^T??DAq!--a33NDFDFTV}}eDFmm++r6fxfytxty List[Tuple[float, float, float]]cf|j||||}t||jSr})rpath_normalise_waypointsrS)rrrrrraws r4rz_PageCursor.paths0m  RR00#C)9:::r6boundsCallable[..., List[Any]]cF|j|jj|dddfd}|S)a A ``_behaviour`` renderer backed by the stroke generator. This is what keeps ONE stroke model in the product: the macro planner decides that a movement happens and where it goes, and every stroke it asks for is drawn by ``_motion``. N)rtarget_wstartrendkindr(lead_msrTrrrrr, List[Any]c  t|d|d|d|d|}nM#t$r@t|d|d|d|d}YnwxYw|r'td|Dsfd|D}t ||||S)Nrr)rc3K|]k}t|dr tt|ddpdn6tt |dkrt|dndVldS)dt_msN)hasattrrTrHlentuple).0ps r4 z7_PageCursor.renderer..render..s--$%#*!W"5"5 KuWQ%=%=%DEEE/2588}}q/@/@ad c------r6c g|]o}tt|drt|ddn|dtt|drt|ddn|dfpS)rNrrr)rTrrH)rrnominals r4 z8_PageCursor.renderer..render..s%%%wq#Pgad333AaDQQwq#Pgad333AaDQQ!%%%r6)rrr)listrrZanyr) rrrrrrrrprofiles r4renderz$_PageCursor.renderer..renders# M7<<a%(CFCF19(;;<< M M M7<<a%(CFCFKKLL  M  %3--),----- %%%%%!$%%%($ s?AAB  B )rrrrrr(rrTrrrrr,r)rr sample_ms)rrrrrs @@r4rendererz_PageCursor.renderersT-,(=C/3         4 r6tagr( random.Randomcdtjt|jd||jfzS)zAA per-(page, action, purpose) stream. Reproducible from the seed.z%s:%d)randomRandomrrQr)rrs r4rngz_PageCursor.rngs1} TY3 *< < = =   r6N)rQrRrSrTrMrPr,r-)rrrrr,rrrr,r) rrTrrTrrTrrTr,r)rrr,r)rr(r,r) rJrrrrrrrrrrr9r6r4rrsKK4I 3 3 3 3 !@!@!@!@F,,,,;;;;$$$$L      r6rsteps Iterable[Any] List[_Ev]c2g}d}|D]}|tdt|jz }|jdkr3|t ||j|j|jdkrdndt|ddt|dd|S)zFTurn a ``_behaviour`` Step list (relative delays) into absolute times.rwaitwheelmovedxdy) maxrTdelay_msrappend_EvrrrH)routtss r4 _timeliner sC A FF SeAJ'' ( (( 6V    3q!#qsqv/@/@GGfq$,,gas.C.CEE F F F F Jr6rrc ~g}|D]T}t|dd}|}t|drmt|dd}|t|dz nd}|t|t|jt d|ft |}t|dkra|t|dt|d t dt|d f|t|dt|d d fV|sgStd |Dr d |D}|dd dkr |t|z fd|D}g}d} |D]2\}} } | | dzz } |t| || 3t||}g} d} |D]6}| |j |j|j | z dz f|j } 7| S)aReduce whatever the generator returns to ``(x, y, delay_seconds)``. Three shapes are accepted: a waypoint object carrying ``x`` / ``y`` / ``dt_ms``, an ``(x, y, delay_seconds)`` triple, and a bare ``(x, y)`` pair whose pacing is then spread evenly over the cap. The cap from ``humanize=`` is applied through :func:`_fit_timeline`, so a tighter cap makes the movement shorter AND coarser rather than merely denser. rNrr@@rr/rrrc3*K|]\}}}|dkVdS)rNr9)r_ds r4rz'_normalise_waypoints..Gs, * *1a18 * * * * * *r6c g|] \}}}||df S)rr9)rrrrs r4rz(_normalise_waypoints..Ks$55571a1a,555r6c"g|] \}}}||f Sr9r9)rrrrevens r4rz(_normalise_waypoints..Ns%55571a1a,555r6) rHrrTrrrrrallr _fit_timelinert_ms)rrSpointsrrrdelayseqevsrrrrprevevrs @r4rr-sN02F  @ @ AsD ! ! =WQ__=Aw--E-2->E%LL6))CE MM588U13ZZS%A B B B Ahh s88q== MM5Q==%A--S%A--9P9PQ R R R R MM5Q==%A--> ? ? ? ?   * *6 * * ***665f555 ay|aS[[(5555f555C A!!1a QZ 3q!Q<<    [ ) )C,.C D BD"$46 9:;;;w Jr6Ttimer emit_lastoriginr Sequence[_Ev] emit_moveCallable[[float, float], Any] emit_wheel'Optional[Callable[[float, float], Any]]r r r Optional[Tuple[float, float]]c^K||nt}|sdSt|||}t5 ||\}} |t krn|t kr|| d{V^| jr4|| ||| j | j d{Vn|| j | j d{V|| dddn #1swxYwY|jS)aThe ASYNCHRONOUS driver of :class:`invisible_core.juggler.Pacer`. Returns events sent. The rules it obeys - absolute deadlines from one ``t0``, drop rather than send late while the drop stays within reach, never two events in one instant - are not written here: they are in :mod:`._pacing`, because the server's drag is synchronous and has to obey the same ones. This function supplies a clock, a way of waiting and where the pointer starts from; it makes no decision the pacer has not already made. Nr)r r )rr _fine_timersteprrrris_wheeldroppedrrrremitted delivered) rr rr r r tmpacerwhatargs r4 _dispatchr_s$#B q #6 : : :E $$ $ 26688,,ID#t||u}}hhsmm#######| .%MMOOO j0000000000isu--------- MM"&&(( # # # $ $$$$$$$$$$$$$$$ ?sCDD!$D!z"'WeakKeyDictionary[Any, _Session]' _SESSIONSz%'WeakKeyDictionary[Any, _PageCursor]'_PAGESobjc$t|d|S)z>The implementation object behind a sync/async binding wrapper. _impl_objrH)r s r4_implr$s 3 S ) ))r6ownerctsdStdS t||tt |<n#t $rYdSwxYwdS)aArm the Python cursor engine for a Browser or a BrowserContext. Registering the *owner* (rather than each page) is what lets pages created by any route benefit: ``context.new_page()``, ``browser.new_page()`` - which makes its context inside the driver, out of reach of any wrapper we install on our side - and popups a site opens by itself. A page looks its session up lazily through its own context and browser the first time it moves. FNT)r`rOrrr$rZ)r%rQrSs r4 enable_forr'sq   u u"*4"="= %,, uu 4s%A AAOptional[_Session]ct|}||St|dd}|dSt|}||St|dd}|dSt|S)N_browser_context_browser)rrjrH)rsessioncontextbrowsers r4_session_for_pager/smmD!!Gd.55GtmmG$$Ggz400Gt == ! !!r6Optional[_PageCursor]c t|}||St|}|dSt}|dSt |jt |} t||j|}nA#t$r4}tddt|j d|dYd}~dSd}~wwxYw|t|<|S)Nzprofile-constructionz6the cursor motion generator could not be constructed (rCz]); this session will not humanise its pointer. This is a broken install, not a configuration.) rrjr/rOrrQrrrS Exceptionr5r+rJ)rcursorr,rMrQrs r4_cursor_for_pager4s ZZ  F  %%GtGt GL+d*;*; < > B<)B77B<frame Optional[Any]c$t|ddS)N_pager#)r5s r4_page_of_framer9s 5'4 ( ((r6mousecNt|dd}|t|ddndS)N_channel_objectr#)r:channels r4_page_of_mouser?s1eZ..G070C77It , , ,Mr6'Tuple[Optional[float], Optional[float]]ct|ddpt|dd}t|tr*|d|dfSdS)N_viewport_size viewport_sizerrNN)rH isinstancedictrj)rsizes r4rrs` 4)4 0 0 XGD/SW4X4XD$5xx  $((8"4"444 :r6rct|\}}|r|stSt|dz t|dz fS)z588c> ))r6rrrrrc|r|sdSd|cxkot|kncod|cxkot|kncS)NTr)rT)rrrrs r4_insiderLse At !    eAhh     63!#6#6#6#6eAhh#6#6#6#66r6Tuple[type, ...]cl ddlm}n*#t$r ddlm}n#t$rYYdSwxYwYnwxYw|fS)Nr)Errorr9)&invisible_playwright._pw._impl._errorsrO ImportError)invisible_playwright._pw._impl._api_types)PWErrors r4 _page_errorsrTsKKKKKKK   R R R R R R R   222  S R :$ 00 *0*00cl ddlm}n*#t$r ddlm}n#t$rYYdSwxYwYnwxYw|fS)Nr) TimeoutErrorr9)rPrWrQrR) PWTimeouts r4_timeout_errorsrYsTTTTTTT   [ [ [ [ [ [ [   222  \ [ <rUselector$Tuple[Optional[Any], Optional[dict]]cK ||d{V}n#t$rYdSwxYw|dS |d{V}n#t$rd}YnwxYw|st|d{VdS||fS)aResolve the element and its box, or (None, None). Never raises. Deliberately non-blocking and deliberately forgiving: this is a hint used to aim a mouse path, never a correctness step. It resolves the element if it is already there and gives up otherwise, so it can neither add a wait to a passing call nor invent an exception on a failing one - the original coroutine still does its own waiting and still raises its own errors. NrD)query_selectorrT bounding_box_dispose)r5rZhandleboxs r4 _element_boxrbs++H55555555 >>zz ~z'')))))))) >> vz 3;s 55AA.-A.r`cpK |d{VdS#t$rYdSwxYwr})disposerT)r`s r4r_r_,sY nn >>     s  55positioncpKt||d{V\}}||dSt|d{Vt|trDd|vr@d|vr<|dt |dz|dt |dzfS|d|ddz z|d|ddz zfS)zWhere the action is about to touch, in viewport coordinates. Kept as its own function because it is the whole of what the aiming needs when the caller has specified a position: no landing draw, no hit test. Nrrr@r)rbr_rErFrT)r5rZrer`ras r4 _target_pointrh3s %UH55555555KFC ~t 6  (D!!PcXoo#//3x% ...C5#;O;O0OOO s8c'lS( (#c(S]S5H*H HHr6c K t|jddd||didd{VS#t$rYdSwxYw)usDoes (x, y), in the same main-frame space as the box, land on this element? A bounding box is not the element. An inline link that wraps across two lines, a rotated control, a rounded button: all of them have points inside their box that belong to something else. The centre is checked by the automation layer itself; a point we chose has to be checked by us, or we would be turning working clicks into hit-target failures. ⛔ THE QUESTION GOES TO THE SERVER, WHICH ANSWERS IT FOR THE ACTION TOO (`Actions.hit_target`). It used to be answered here with `document.elementFromPoint`, in the element's own document but at the main frame's coordinates: in a nested frame that asked about another place, and in a shadow root the hit is the host, never the control. Both rejected every off-centre point, so those clicks went to the exact geometric centre, one number for every install. `checkHitTarget` is a method of this package's server, not of Playwright's protocol: the Node driver arm (`INVPW_TRANSPORT=driver`) refuses it, and there the landing falls back to the centre. checkHitTargetNpointrrT) is_internalF)r^r<sendrT)r`rrs r4_hitsroBs(&/.. dWAA.>.>$?/  >>uus5:AA)r r3to_xto_yraw_movec Kt|\}}| jj||}nB#t $r5} t ddt| jd| dg}Yd} ~ nd} ~ wwxYwg} d} t|t|f} |D]j\} }}| |dzz } t| |||\}}t|t|f| krF| t| ||k| tt| | r | djnd||dfd }t| ||djjfd{V||c__|pt _dS)aEmit the intermediate waypoints of one plain stroke. Used by ``mouse.move``, which is the one entry point where the caller named the exact destination and the macro layer has nothing to add. The endpoint is the caller's to emit - a bare ``mouse.move`` has to land on the exact coordinates it was given, unclamped - so this returns after waiting out the last waypoint's deadline without sending it. The return value is kept at 0.0: with absolute scheduling there is no owed pause left to hand back. z path-failedz:the cursor motion generator raised while planning a path (rCzQ); this movement is not humanised. This is a broken install, not a configuration.NrrrrTrr,r-cNK||d{V||c__dSr}rl)rrr3rrs r4emitz_travel..emits=hq!nn&(((r6FrrrTrrTr,r-)rrrrrr2r5r+rJround_clamprrrrrrrr)r3rrprqrrr rr waypointsrrrend_keyrrrcxcyrvs` ` r4_travelr~`s$( T??DAq KK KK&(D$??  M04Cyy/A/A/A333 H    C AT{{E$KK(G"## B UV^B1%%B "IIuRyy !W , ,  3q"b>>""""JJs3q#6#b',,377tDDEEE""""""" CUe"Hfh/ 1 1 11111111tFHfh!OV0022F 3s"A B+B  B)r r  Sequence[Any]budget_sc >Ktt||}|sdSd fd }t|||||jjfd{V|s'|r%|d j|d jc__|pt _dS) zADispatch a planned ``_behaviour`` timeline, inside a time budget.NrrTrr,r-cNK||d{V||c__dSr}rl)rrr3r s r4rz_run_steps..moves=i1oo&(((r6rrtrw)rrrrrrrr) r3rr rrr r rrs ` ` r4 _run_stepsrs  %((( 3 3C """"""" Cz)"Hfh/ 1 1 11111111 22 WYB &(!OV0022Fr6c||nt}|jdS||jz dz}|tkrdSt |jt zdz|dzS)zHow much of the movement budget this action may spend on a fidget. Zero when the previous event was moments ago: two calls back to back are one piece of work, and inserting a fidget between them would be both a lie and a delay. Nrrg?)rrr_IDLE_MIN_GAP_MSminrS_IDLE_BUDGET_FRAC)r3r rgap_mss r4_idle_budget_msrsm#B #sffhh-- 7F    s v!$55> M MMr6rc t||}|dkrgS||nt}t||jp|z dzt }t |}||}|d}| |j j krIt|j |j |||j||} t!| |||St#|j |j ||||j||} t!| |||S)apWhat the hand did while the caller's script was busy elsewhere. We cannot dispatch into the past, so the idle period is planned in full and only its tail is kept - see :func:`_behaviour.tail_within`. The alternative, inventing a short episode from scratch, would have a distribution of its own that no amount of seeding makes match the planner's. rNrzcursor:fidget-gate)noncer)rrrrr_IDLE_MAX_GAP_MSrJrrrr aimless_raterrQrrrr) r3rr budgetrrrrgaters r4 _plan_fidgetrsCVU + +F }} #B "&&((f2>bffhh?6I!##F T]]F ;;t  D ::* + +D {{}}v~222" Kv-(?(?   5&$777  V^T66mFOOF$;$;   E ufdF 3 33r6zOptional[bool] _PATCH_STATE_ORIGINAL_MOUSE_MOVE_ORIGINAL_MOUSE_WHEEL_ORIGINAL_MOUSE_CLICKrF_ORIGINAL_FRAME_ACTIONS)_clickdblclickhovertapcheckuncheck_invpw_cursor_wrappedargskwargsrLindexcT||vr||St||kr||ndSr})r)rrrLrs r4_firstrs3 v~~d|d))e++4;;5r6originalcd fd }t|tdtdd |_j|_|S) Nrrrrr,c Kd} t|||d{V}nO#tj$rt$r3}t ddt |jd|dYd}~nd}~wwxYw|s|g|Ri|d{VS |g|Rii||d{VS#t$r8}t ddt |jdtdYd}~nd}~wwxYw|g|Ri|d{VS) Nzapproach-failedzthe cursor approach raised (rCzH); the action itself is unaffected and ran normally. Please report this.z landing-retryz0an off-centre landing point was not actionable (z6); the action was retried with its own arguments. Set z#=off to disable off-centre landing.) _approachrCancelledErrorr2r5r+rJrYrx)rrr overridesrrs r4wrapperz#_wrap_frame_action..wrappers.2  'dF;;;;;;;;II%        !!99%%%sss,          9!$888888888888 8  !$IIII1HF1Hi1HIIIIIIII I      26c1C1C1C[[[R         Xd4T444V444444444s,A+)A&&A+BC"*.CC"TrJr)rrrrrrr,rsetattr_MARKERrHrJrrrs` r4_wrap_frame_actionrsX555555< GWd###xY??G&GO Nr6cnt|dko"d|vod|vottS)aQIs it safe to add ``position``/``timeout`` to this call's arguments? Only when the caller supplied neither. The bindings pass everything but the selector by keyword, so ``args`` longer than the selector means an unknown caller shape and we keep our hands off rather than risk a "got multiple values for argument" on somebody's click. Also requires that Playwright's TimeoutError be importable, because that is what the retry below catches: without it an off-centre point that turns out not to be actionable would fail a call that would otherwise have worked. rretimeout)rr^rY)rrs r4 _may_overrider)sH D Q $ f $ $ V # $ "" # # r6ralandingDict[str, Any]cX|d|dz |d|dz dtdS)aiThe kwargs that make the action itself land on our point. Without this the approach ends off-centre and the automation layer then moves to the exact geometric centre anyway, so the LAST event of every element-targeted action is ``box.x + width/2, box.y + height/2`` - one exact number, identical in every install, readable from a single event. The bounded ``timeout`` is the price of touching the action's own arguments: if our point is not actionable, the caller's call must still succeed, so the retry has to be reachable before the caller's own deadline rather than after it. rrrrrl)rer)_LANDING_ATTEMPT_TIMEOUT_MS)rars r4_landing_overrider=sBc#h&c#h&  /   r6Optional[Dict[str, Any]]cK|drdSt|}|dSt|}||jrdSt ||dd}t |t sdSt}t|dd}||dSd|_|xj dz c_ t|||||d{V} | d|_dSt|\} } t| j d| j d| | s d|_dSt||| |||d{V| jd|_S#d|_wxYw) zWalk the cursor onto the element this action is about to touch. Returns the kwargs overrides the action should run with, or None. trialNrZrr:TrF)rjr9r4rrrEr(rrHr_choose_landingrrLr _walk_ontooverride) r5rrr rr3rZrr:aimrrs r4rrSszz't % D |t d # #F ~~tdFJ22H h $ $t D D'4 ( (E |u}tFK MMQMM#E68T6JJJJJJJJ ; 1s{1~s{1~q!<<   sD%?????????| e s&D7 :D7 D77 EcJeZdZUdZded<ded<ded<ed d Zd S) _AimaWhere this action is going, and how the caller must be adjusted for it. ``override`` is the kwargs change that tells the action to click the point we walked to rather than the element's centre; None means the action is left exactly as the caller wrote it. zDict[str, float]rarrrrr,cf|jd|jd|jd|jdfS)Nrrrr)ra)rs r4rectz _Aim.rects0 tx}!48H#57 7r6N)r,r)rJrrr__annotations__propertyrr9r6r4rrsaNNN&&&& 777X777r6rOptional[_Aim]c Kt||d{V\}}||dS |d}t|trhd|vrdd|vr`t ||dt |dz|dt |dzfdt |d{VSt|d|d|d|df|dtt}trt||ry|dtkrh|dtkrWt||d |d d{Vr4t ||t||t |d{VSt ||d|dd z z|d|dd z zfdt |d{VS#t |d{VwxYw) aPick the point on the element this action will land on. Split out of ``_approach`` so the element handle's lifetime is one small scope with one ``finally`` in it, rather than a nested try inside a function that also spends a time budget and dispatches events. Nrerrrrzcursor:landing)spreadkeeprrrg)rbrjrErFrrTr_rr_LANDING_SPREAD _LANDING_KEEPryr_LANDING_MIN_BOX_PXror) r5r3rZrrr`rarers r4rrsn%UH55555555KFC ~t::j)) h % % F#//cXooc#hx})=)==!#hx})=)==?@DFF.v) Xs3xWs8} = JJ' ( ("       GdF++ GG 333H !444FGAJ ;;;;;;;;5W&7W&E&EFFvC#c(S\C%77c(S]S%88:;?AAvhvsAKdfd }t|}|j}t|||} | r_tt d| Ddz |t z} t || || | d {Vt|| z d }t|j |j | ||j ||j |j|| } | rt || |||d d {Vd S|j\|_|_d S)z5Spend the time budget getting the pointer to ``aim``.rrTrr,r-c2K||d{VdSr}r9rrr:rs r4rz_walk_onto..raws3d5!Qr6c3$K|] }|jV dSr})rrrs r4rz_walk_onto..s$33q 333333r6r)rr Ng?)rrrF)rr r rw)rJrSrrsumrrrrrQrrrrrrrr) r3rrrr:r rrrfidgetspentrs `` r4rrs       T]]F  F &$ . .F *C33F33333f<..00uEJJJJJJJJJJVe^S))  V^V[[%6%6&mS[v&&   E  )fE#(*** * * * * * * * * * ![&(((r6cd dfd }t|td td d |_j|_|S)NrrrrTrrrRr,c K||dkr t}|t|nd}|S|jsLd|_|xjdz c_ dfd }t |||||d{Vd |_n #d |_wxYwnO#t j$rt$r3}td d t|j d |d Yd}~nd}~wwxYw|||d{VS)NrTrrTrr,r-c2K||d{VdSr}r9)rrrrs r4rz._wrap_mouse_move..wrapper..raw3"*(4R"8"8888888888r6Fz move-failedz*the cursor path raised during mouse.move (rCz5); the move itself is unaffected. Please report this.)r)rrTrrTr,r-) r?r4rrr~rrr2r5r+rJ) rrrrrr3rrrs ` r4rz!_wrap_mouse_move..wrappers =EQJJ %d++373C)$///%fk%"&FKMMQ&MM,9999999&fdAq#>>>>>>>>>&+ e ++++)      !MCyy)))3330 XdAq6666666666s0AB A91B9 BBC)C  CTrJrr}) rrrrTrrTrrRr,rrrs` r4_wrap_mouse_movers]7777777< GWd###xV<.wrappers ))Aq// ! ! ! ! ! ! ! !%        ##99%%%sss,         XdAq33F333333333s"A.)A))A.TrJr) rrrrTrrTrrr,rrrs` r4_wrap_mouse_clickrsX444444  GWd###xX>>G&GO Nr6delta_xdelta_yc |t|t|z}|dkrgSd}tdt|jdzdz }ttdt t ||z |d}|dkrgSt |}t|j|j | |||d|j | |} d | D} t| } | r| d krgSg} d x} }d }| D]}|jd kr| |#|dz }|t!| kr || z ||z }}n|j| z }||z||z}}| |z } ||z }| t%|j|j|jd || | S)aA wheel burst carrying exactly (delta_x, delta_y), with the hand on it. One protocol-level wheel event of 900 px is not a scroll a person performs; a notched wheel produces detents. The number of detents is bounded by the movement budget, and the deltas are rescaled so the burst sums EXACTLY to what the caller asked for - a scroll that lands somewhere else is a broken call, not a subtle one. rIgY@rrgV@r)tickstick_dyrrc2g|]}|jdk |jS)r)rrrs r4rz _scroll_plan..Ls& 7 7 7qQVw%6%6ad%6%6%6r6rrr)rrrrrr)absrrRrSrrxrJrrQrrrrrrrrrrrrr)r3rrrtotalnotch max_ticksrrrsharestotrused_xused_yseenrrrfracs r4 _scroll_planr4s LL3w<< 'E s{{ EAs6-6=>>??I As5//B??@@ A AE qyy T]]F  V^V[[%6%6S v&&   E 8 7E 7 7 7F f++C SAXX CFV D  @ @ 6W   JJqMMM    3v;;  v%w'7BB4#:Dt^Wt^B" "  4!#qz(/B2??? @ @ @ @ Jr6cd fd }t|tdtd d |_j|_|S) NrrdeltaXrTdeltaYr,c  K||}} t}|t|nd}||jsd|_|xjdz c_ t ||t |t |}|rOt t|dd d fd }d fd } t|||| |j d{V d|_dS d|_n #d|_wxYwnO#tj $rt$r3} tddt| jd| dYd} ~ nd} ~ wwxYw ||d{VS)NTrr:rrTrr,r-cBK||d{VdSdSdSr}r9rs r4r z5_wrap_mouse_wheel..wrapper..emit_movewsL#/E4E&*d5!Q&7&7 7 7 7 7 7 7 7 7 7 0/4E4Er6rrc2K||d{VdSr}r9)rrrrs r4rz6_wrap_mouse_wheel..wrapper..emit_wheel{rr6)rFz wheel-failedzthe scroll planner raised (rCz7); the scroll itself is unaffected. Please report this.rw)rrTrrTr,r-)r?r4rrrrTrrHrrSrrr2r5r+rJ)rrrrrrr3planr rrr:rrs` @@r4rz"_wrap_mouse_wheel..wrapperis!6 !$''D/3/?%d+++TF!&+!"  " ('eGnneGnnUUD $3 'gt < <88888889999999)y*282DFFFFFFFFFF#"'FKKK $#(FKK%FK''''%        59#YY5G5G5GN          XdFF333333333s7AC"A3CC" C" CC""D.;)D))D.TrJr)rrrrTrrTr,rrrs` r4_wrap_mouse_wheelrdsY "4"4"4"4"4"4H GWd###xW==G&GO Nr6c ttS ddlm}ddlm}t D]T}t ||d}|t |tdr,|t|<t||t|U|j }t |tds|a t||_ t |dd}|,t |tds|at||_t |dd}|,t |tds|at%||_danB#t($r5}t+d d t-|jd |d daYd}~nd}~wwxYwtS) zIInstall the wrappers once per process. Idempotent, and honest on failure.Nr)Frame)MouseFrrTbindingsz.the Playwright bindings could not be wrapped (rCz), so pointer movement is not humanised in this process. The installed Playwright version is probably outside the supported range.)r%invisible_playwright._pw._impl._framer%invisible_playwright._pw._impl._inputr_FRAME_ACTIONSrHrrrrrrrrrrrrrr2r5r+rJ)rrrLrrclickrrs r4r`r`s ????????????" ? ?DudD11H78We#D#D,4 #D ) E4!3H!=!= > > > >ztWe,, 0#' )$//EJx..  WUGU%C%C $) !,U33ELw--  WUGU%C%C $) !+E22EK  JCyy!!!333 (     sDD,, E+6+E&&E+) rkrnrgrorxr=r'ryrurarrq)r'r(r)r(r*r+r,r-)r,r-)r,rA)rMrPrQrRrSrTr,r)r,r^)rbrr,r()rbrr,rT)rrRrrRr,rR)rrr,rR)rrr,r)rrrSrTr,rr})rr r rrrr rr r^r rr,rR)r rr,r)r%rrQrRrSrTr,r^)rrr,r()rrr,r0)r5rr,r6)r:rr,r6)rrr,r@r) rrTrrTrrrrr,r^)r,rM)r5rrZr(r,r[)r`rr,r-)r5rrZr(rerr,r)r`rrrTrrTr,r^)r3rrrrprTrqrTrrrr rr,rT)r3rrrr rrrrrTr rr r^r,r-)r3rr rr,rT)r3rrrr rr,r) rrrrFrLr(rrRr,r)rrPr,rP)rrrrFr,r^)rarFrrr,r) r5rrrrrFr rr,r) r5rr3rrZr(rrrrFr,r)r3rrrrrrrr:rr rr,r-) r3rrrrrTrrTr,r)r __future__rrrWrhrr~r2 dataclassesrtypingrrrrr r r r weakrefr invisible_core.jugglerrrrrrrrrryrrrrrrrrrrrrinvisible_core.seedmixrrkrornrgrxrsrrrrrrrrr%r&rRuntimeWarningr5r:invisible_corer;rFr<r2 _motion_excr=rGrOr]rarqruryr{rrrrrrrrrrr$r'r/r4r9r?rrJrLrTrYrbr_rhror~rrrrrrrrrrrrrrrrrrrrrrr`__all__r9r6r4rspppb#""""" !!!!!!QQQQQQQQQQQQQQQQQQQQ%%%%%%,+++++#    % % % suu9GNNNNN8 655555   @@@K4??????????@988888H.     ???? BBBB*8888 % % % % % % % %jll6........ 0 0 0 0p p p p p p p p z    ////j;?& ,0&&&&&&Z1B0A0C0C CCCC0A0A0C0CCCCC**** ( " " " " :))))NNNN****77772     I I I IJ??????L;? 33333334 N N N N 4444F $ ####5999996:::::6:::::!#""""L !6666 """"J(.%)000000f 7777777 7$((((V&)&)&)&)R""""JD----`,,,,^''''T   s$B--C2 CC