jdZddlmZddlZddlmZddlmZddlm Z dd l m Z m Z m Z gd ZGd d eZGd deZGddeZddZGddZdS)ujThe retry loop, and the actions that run inside it. ⛔ THIS IS THE PIECE THAT FAILS SILENTLY, and the reason is the shape of the loop: if a condition is checked ONCE and then acted on, the page can change between the check and the action. It doesn't break: it breaks ONE TIME IN TWENTY, when loading is slower than usual. THE RIGHT SHAPE, and every line of this file exists to keep it: until it expires: RESOLVE THE SELECTOR FROM SCRATCH <- don't reuse the old handle ask whether it is actionable get the point act if something says "it's not there anymore": START OVER ⛔ **The selector is resolved on EVERY turn.** Reusing the previous turn's handle is the mistake that makes the loop pointless: if the DOM has changed, that handle points to a detached node, and the action goes nowhere without saying anything. ⛔ **And a timeout must say WHY.** A bare `TimeoutError` on a retry loop is the least useful thing you can print: the reason for the last turn - "missing visible", "the selector finds nothing", "no quad" - is the only information that tells you what to look at. ) annotationsN)Optional)_pacing)EvaluationError) BUTTON_MASKKeyboard UnknownKeyvisiblestableenabledceZdZdZdS)ElementNotActionablezEThe loop timed out. The message carries the reason for the LAST turn.N__name__ __module__ __qualname____doc__VC:\Projects\Historical\venv\Lib\site-packages\invisible_playwright/_juggler/actions.pyrr*sOOOOrrceZdZdZdS) ActionMisseduThe event went out and landed on something other than the element. ⛔ NOT RETRYABLE, AND THAT IS THE WHOLE DIFFERENCE FROM `WrongHitTarget`. That one is raised BEFORE anything happened, so starting over is free. This one is raised after: a press has been delivered to whatever was under the pointer, and a loop that repeated the action would be pressing twice. It exists because the alternative was silence. Measured 2026-09-19 with a target that moves (`tests/gates/hover_non_mente.py` in the workbench): `hover()` returned normally 2 times out of 8 with the page having seen no event at all, and `click()` 8 times out of 8 - the hit-target check before the press passed, then the element left between `mousedown` and `mouseup`, the two landed on different nodes and no `click` was ever born. Nothing after the commit looked, for a reason that is right (see `_act_on_target`), so the caller was told "done". [B217] Nrrrrrr.srrceZdZdZdS)WrongHitTargetuThe event would have landed on ANOTHER element. RETRYABLE condition. ⛔ It's the window that the rest of the loop doesn't close, and it was MEASURED, not feared. Between the actionability check and the event a couple of commands go by; if the layout moves in that gap - a banner appearing, a font finishing loading, a `setTimeout` shifting the page - the point calculated earlier no longer belongs to the intended element. The case from 2026-08-27: a page that at 1200 ms reveals a block higher up. `dblclick` succeeded, the page saw NO `dblclick` event at all, and on the same page without that timer the same code worked. No error anywhere: the click had landed nineteen pixels higher. NrrrrrrAs    rrreturnlistcg}|D]=}|t|trd|int|>|S)uA string becomes `{"valueOrLabel": ...}`, and that's NOT a detail. ⛔ THE INJECTED SCRIPT'S FILTER STARTS FROM `matches = true` AND NARROWS it down ONLY if the criterion carries one of `valueOrLabel`, `value`, `label` or `index`. A bare string has none of those, so every option matches and **the first one** gets picked. Measured on 2026-08-27 on a `` with `display:none`. Asking that input for a quad answered "it isn't visible" on every turn until the timeout, so an upload to the commonest upload widget there is could not happen through either door, `set_input_files` or a file chooser's `set_files`. Such an action gets the element and no point: no scroll, no hit test, nothing a hidden element cannot satisfy. ⛔ AND IT IS A PROPERTY OF THE ACTION, NOT OF FILE INPUTS: every action whose `states` are empty declared that it needs no visibility, and the quad put the requirement back. `focus`, `blur` and `dispatch_event` on a `display:none` element timed out the same way, 4 s out of 4, where Playwright performs all three; they pass `needs_point=False` too. ⛔ `position` travels HERE and not through each action, because the point is recomputed on every turn of this loop: an offset applied by the caller once would be stale the moment the page moved, which is precisely the case this loop exists to absorb. ⛔ `element_id` IS THE ElementHandle CASE, and it changes exactly two things. The node is not looked up again - a handle names one node, and re-querying the selector would be a different element with the same description, which is not what `handle.click()` means - and the node is NOT disposed at the end, because it belongs to the caller and disposing it would destroy the handle they still hold. Everything else is deliberately shared: states, the point, the scroll, the hit-target check, the retry on detachment. A second loop for handles would be a second definition of "actionable" and a second click path, and two click paths are two fingerprints. Nz#no main frame: the page isn't readyzhaven't tried yetrTrFryzthe selector finds nothingokz missing %smissingza statezFthe element was outside the viewport; scrolled it in and starting overz*the element has no quad (it isn't visible)done notconnectedz&the node detached while I was using itz*the event would have landed elsewhere (%s)z=%r not actionable in %.0fs after %d attempts. Last reason: %s皙?)r8rK RuntimeError ACTION_STATEStime monotonicr9query_selectorelement_statesrLdisposerurRscroll_into_view hit_targetrrr$rsleep)rCr|runrvrZrSrBrwrxryrzr{fdeadlinereasonturnsrToursresult element_okrQverdictes r_retryzActions._retrysP  11 9DEE E"(.f>##g-$B  QJEGDx 1)(GG#h55a&5QQGD &9FF &E &!X44QHHF!::d++*!- 9&*ooa%&H&HG&&00&4W&=&= =#H1t1H$$Q000001111E #s1gu55D1t1H$$Q000011C# B B B"Q//A! J J J(FI) J41t1H$$Q0001t1H$$Q000011~(***!$,guf#EFGGG Jt   EB s]BH?= H?+AH?A H? H?>J!? I> I"J!" I>/I94J!9I>>J!!#Kcb|j|||||S)uDoes a MAIN-FRAME point land on `element`? `"done"`, or what is there. ⛔ ONE QUESTION, ONE ANSWER, THREE ASKERS: the trial, the check before a commit, and the humanised cursor choosing an off-centre landing (`ElementHandle.checkHitTarget`). The cursor used to answer it on its own with `document.elementFromPoint` at main-frame coordinates, which is wrong twice: inside a nested frame the number means another place, and inside a shadow root the hit is the host, never the control. Both made every landing fail its check and fall back to the exact geometric centre - one number for every click. Asking here means the cursor accepts exactly the points the action itself would accept. )r9check_hit_target _hit_point)rCrrTrQs rrzActions.hit_targets,x((GT__Q5N5NOOOrc ||jjkr|S|j|jj}|j|}|d|dz|dz |d|dz|dz fS)uThe caller's point, expressed in `f`'s own coordinate space. ⛔ A POINT IS ALWAYS IN THE MAIN FRAME'S SPACE when it gets here: `Page.getContentQuads` answers there and `dispatchMouseEvent` wants it there. Handing that number to a hit test running INSIDE a nested frame asks the child about a coordinate that means something else, and it answers `` - which is how a covered element used to be reported for something sitting right under the pointer. The shift is the difference between the two content origins, read from the engine rather than recomputed here. rr`rra)r8rKr9content_origin)rCrrQmainheres rrzActions._hit_points ) ) )Lx&&t~'@AAx&&q))a49$tCy0a49$tCy02 2r) mousedownmouseup)rzlandsrtuplec||s,||||}|dkrt||} |s|r}|jd||t ||jd|jd} d| dD} | r/tdd d | Dz| S) u5Approach, check that the point still belongs to the element, and only then do the thing that cannot be taken back. ⛔ `force` SKIPS THE CHECK, AND THAT IS NOT AN EXEMPTION - IT IS WHAT THE OPTION MEANS. "Receives events" is one of the actionability checks `force` is documented to bypass, and an overlay intercepting the pointer is the ordinary reason somebody passes it. Honouring `force` on the state checks alone would leave it half wired, which is the defect this was: an option accepted on every public signature that changed nothing a caller could observe. ⛔ IT USED TO BE AN INTERCEPTOR, and that history is why the shape here matters. An interceptor watched each event WHILE it arrived and BLOCKED the ones whose point had stopped belonging to the element. It needed capture listeners for the duration of every action, and the block itself was a tell: a real `mousedown` that vanishes under `preventDefault` is not something any input stack produces. It was replaced by two pure DOM reads, one before the action and one after, and the one AFTER is what this corrects. ⛔ A CHECK AFTER THE EVENT CANNOT ANSWER THE QUESTION IT IS ASKED, AND IT DROVE A RETRY. Once the event has gone out, these two are the SAME observation: the point stopped belonging to the element BEFORE the event, so the click landed on something else; the point stopped belonging to the element BECAUSE of the event, so the click landed exactly where it was aimed and the control did what it exists to do. The second is not an edge case, it is most controls. Measured on the published 0.22.0, one `browser_click` per call: a button that hides itself on click received THIRTY-NINE clicks and the call then reported failure; a panel toggle was opened and closed by a single call, which reported success; a button that only moves, and one that does nothing, were correct thirty times out of thirty. The discriminant is not movement - it is the target ceasing to be hittable BY ITS OWN EFFECT. A check whose negative result carries no information cannot gate anything, so it is gone rather than narrowed. What it leaves behind is the invariant `_retry` depends on: starting over is sound only while nothing has happened, and every raise here is now before `commit`. ⛔ AND THE READ MOVED AFTER `approach`, WHICH IS WHERE THE RACE IS. It used to run before the pointer moved, so a page that rearranges itself on hover - a menu opening under the cursor is the ordinary case - was judged in the layout that existed before the thing that changed it. What is left is one round trip between this read and the press. Closing that one belongs to the engine, the only place that can verify and dispatch without a gap; it is not closed by reading the DOM again afterwards, which is what this function just stopped doing. Measured by `tests/gates/injected_page_surface.js`: the bundle touches the page's window zero times, in every phase. ⛔ AND WHAT CLOSES THE GAP IS NOT A THIRD READ OF THE GEOMETRY. It is the engine telling us where each event LANDED, recorded at dispatch by a privileged listener the page cannot see (`Page.pointerLanded`). That answer distinguishes what a read after the fact cannot: an event that hit the element and then saw it move away by its own effect landed ON the element, and says so. `lands` names the events the commit emits - the press and the release for a click, the one move for a hover - and every one of them must have landed on the element or inside it, which is also the condition under which the DOM composes a `click`. A miss raises `ActionMissed`, which `_retry` does not catch: something has happened, and the invariant this loop rests on is that it starts over only while nothing has. `force` skips this as it skips the check before: the caller has said the event is to go wherever the pointer is, and an overlay receiving it is then not a miss but the request. [B217] rzPage.pointerLanded)rVrWtypes afterEventIdrXrYc"g|] }|d | S)landedrrels r z*Actions._act_on_target..#s!GGGA1X;GaGGGrlandingsz3the action went out but did not reach the element: z; c3<K|]}|dd|dVdS)typez landed on onNrrs rrgz)Actions._act_on_target..'sI 1 1$%67vYYY$ H 1 1 1 1 1 1r) rrr7rnr_last_event_idr.rjoin) rCrrTrQapproachcommitrzrrranswermisseds r_act_on_targetzActions._act_on_targetsZ   .ooa%88G&  $W--- 2 2 V[[!5-.G+/;;262E"G"G*.r !CCF HG !3GGGF 2"Iii 1 1)/ 1 1 1111222 rr )staterZrSryrcf|p |jj}|tdtj|z}d} |j|||} |dkr"| sdS|j|| d}ns| ro|dkr| S |j|| |r| Sd |z}n&#t$r} t| }Yd} ~ nd} ~ wwxYw|j|| nd }tj|krtd ||||fztj d ) uWaits for a selector to reach a state, and returns its handle. ⛔ THE HANDLE IS NOT DISPOSED HERE, and that is deliberate: the caller is about to use it. `_retry` disposes what it resolves on every turn precisely because it re-resolves, so this cannot go through it - it would hand back an objectId it has just released, and a released handle does not raise, it answers wrong. ⛔ AND `state="attached"` AND `"detached"` ARE NOT ELEMENT STATES. The injected script knows visible / hidden / enabled / disabled / editable / checked; presence in the DOM is answered by the selector resolving at all, so those two are handled here rather than asked of a function that would reject them. Nz$no main frame: the page is not readyz not tried yetTrdetachedzthe element is still attachedattachedzthe element is not %szthe selector matches nothingz.%r did not become %s in %.0fs. Last reason: %sr) r8rKrrrr9rr element_staterr$rr) rCr|rrZrSryframerrrTfailures rwait_for_selectorzActions.wait_for_selector,s"5DN5 =EFF F>##g-  h--eXf-MMG "" 4  0008 8J&&"N*x--eWeDD'&4uz,Actions.hover..run..csrc4dpSN mousemove _mouse_eventrQrCsrrz,Actions.hover..run..dst00eDDMrrz)r)rrrzrrrOrL)rrTrQoptsrCs `rrzActions.hover..run^sZ&&7E%MMMMM488G,,--%'&& &rrZrwrSrBr)rCr|rZrSrBrwrrs` ` rhoverz Actions.hover\s_ & & & & & &t{8SI'j$,xIICGII Irr)rZrSbuttondelay_msclicksrB modifiersrwrintrOptional[float]rrc J  fd} j|| f|||| d S)Nc  fd} || fd|tdS)Nc<S)Nrrrr_click_at_point)rrrrrQrCsractz'Actions.click..run..actqs3$$U6&/88%MMM rc4dS)Nr)rr)rrQrCsrrz,Actions.click..run..s%!2!2;=F"3"H"Hrrzrrrzr) rrTrQrrrrrrrCs ` rrzActions.click..runps          &&7EHHHHHH488G,,-- '// /rrr) rCr|rZrSrrrrBrrwrrs ` ``` ` ` rclickz Actions.clicklsw / / / / / / / / / /&t{8SM'H$,MMGKMM Mr)rZrSrrrBrc .|j|f||d||||d|S)u⛔ These are NOT two `click`s in a row: the second one must carry `clickCount: 2`, and it's that field - not the interval between the two - that gives birth to the `dblclick` event. Two clicks with `clickCount: 1` produce two `click` events and no `dblclick`, which is a silent failure: the action succeeds and the site's handler never fires. ⛔ AND IT FORWARDS `frame_id`, which it used to accept and drop. A double click on an element inside an iframe resolved the selector in the MAIN frame instead, so it either found nothing or found a same-named element in the wrong document. The signature said the argument was honoured; nothing else did.r)rZrrrSrBrr)r) rCr|rZrSrrrBrrs rdblclickzActions.dblclicksDtz(JGF!"X$-JJDHJJ Jrc *|j|df||||d|S)NTr _set_checkedrCr|rZrSrBrwrs rcheckz Actions.checks> t 4OZ*2XOOIMOO Orc *|j|df||||d|S)NFrrrs runcheckzActions.unchecks> t 5O'j*2XOOIMOO Or)rSrBrwwantedc >fd}j||f||||dS)u`check` / `uncheck`. ⛔ It CHECKS FIRST, and rechecks after. Clicking without looking flips a box that was already right - that's the obvious defect - but the second check is the one that matters: a `