What winwright shipped.
Every entry in docs/CHANGELOG.md, read at 6d1a41c and dated by the commit that wrote it.
- WW551 · e826dc4A case cannot drive the common Open or Save dialog, so choosing a file through it has no case
'choose file' fills the common Open or Save dialog's name box by id and confirms; a read absent proves it closed, and pick sets the type (design recorded in
src/Winwright/Acting/Act.cs). - WW550 · e6c2602A case cannot drop a file from Explorer onto the application, so a drop zone has no case
'drop file' drops a file onto the app by a real drag carrying CF_HDROP; a target that answers no effect is a named hole (design recorded in
src/Winwright/Acting/FileDrop.cs). - WW549 · da0d785A case first in its run cannot type: the window it launched never comes forward before any synthesised input
A launch hands the started process the foreground first, so a case first in its run or soaked alone comes forward (design recorded in
src/Winwright/Windowing/ForegroundLock.cs). - WW548 · 7c853f3A case cannot claim a window covers its monitor, so a full-screen mode that leaves a border or a pixel uncovered passes
A step claims fillsMonitor: its element covers the whole monitor it is on, so a full screen leaving a border fails naming both rectangles and each edge left uncovered in pixels.
- WW545 · d87820dTyping into a terminal substitutes the last character for an earlier one about once a send in fifty, unrepaired
Typing into a terminal repairs the last-character substitution before Enter, proven by quickshell's tab case passing 300 of 300 guest runs on 1.1.2, the repair firing on two.
- WW547 · c40adc6A run's summary says "1 case that ran say what they catch", plural verb and pronoun on a single case
A run's two catches lines agree with one case in every word, saying "1 case that ran says what it catches", and the tests assert the whole singular sentence.
- WW546 · b871ebeA case's type step drops the resend count, so a repaired substitution traces exactly like a clean send
A case's type step that WW249 had to resend stays green and its trace line names how many resends it took, so the fault rate can be read off an adopter's own runs.
- WW544 · 01119e1A case cannot press Alt alone, so a menu bar shown the Windows way by an Alt tap has no case
A press of a modifier alone, such as Alt, is a tap sent down and up with nothing between, so a classic menu bar shown by an Alt tap has a case.
- WW543 · f19b711A staged fixture file keeps its source's modification time, so a rule about how recent a file is fails a day later
A staged copy is written now, or as old as a file's modified age says, so a rule about how recent a file is holds the day after the fixture.
- WW542 · f19b711A step's with cannot name the project's root, so a case types a checkout's path whole and is red on any other desk
A step's with fills {root}, {root/} and {files}, and fixtures fill {root} where {files} was, so a case reaches its checkout on any desk.
- WW540 · f19b711A case cannot add an item to a selection or click with Ctrl or Shift held, so a list choosing several has no case
A click takes holding ctrl or shift, sent in one batch with the click, so a list answering only the gesture adds a row or a range.
- WW541 · af968ffA catches that is the case name with a word added passes WW537 and runs unnamed, so the claim diff reads the name
A run names the cases whose catches begins or ends with their own name, quoting the claim and refusing nothing, so a pasted title past WW537 is seen.
- WW539 · dcd5b7bA case cannot claim an element is drawn inside another, so a control clipped or laid out empty passes every case
A step claims within, its element drawn inside a second locator's and not empty, failing with both rectangles, so a control clipped or laid out empty has a case.
- WW538 · 31abf0fA case cannot click with the middle or right button, so a tab closed by a middle click has no case
A click names its button, middle or right beside the default left, in its step and its rendered name, so a tab closed by a middle click has a case.
- WW537 · f99f58bA case whose catches is only its own name again loads, so the claim diff between runs turns back into a diff of names
A catches that only repeats the case's own name, folded for case, spacing and punctuation, is refused where it is written, so the claim diff stays a diff of claims.
- WW536 · 953220bA fixture cannot open the window a drop lands in, so a drop onto Explorer needs code outside the case
A fixture's opens puts an Explorer folder beside the window under test and closes it with the case, so a drop onto Explorer needs no code outside the case.
- WW535 · 953220bA case cannot read a file on disk, so a drop onto Explorer cannot be checked by the case that made it
A step naming a file takes read and claims sameBytesAs, waited for over the resolve timeout, so a drop onto Explorer is checked byte for byte by the case.
- WW534 · 6d81913Two runners driving one guest VM interleave their windows, and neither says another run holds the desk
A guest run claims the desk through a host mutex a second runner waits on and names, and a foreground lost to a process no case started says so (design recorded in
README.md). - WW533 · 0239471A case renamed and a claim no case makes any more read alike between runs, so a lost claim is one rename among many
A run keeps each case's catches by its name, so a rename that kept its claim holds and a claim no case makes is named lost (design recorded in
src/Winwright/Scenarios/RanBefore.cs). - WW532 · 81f9b84A case that ran last run and not this one goes unnoticed while the total holds, so a swap reads green
With lastRun declared, a run names the cases that appeared and vanished since the last run over its selection (design recorded in
src/Winwright/Scenarios/RanBefore.cs). - WW531 · 58d0fc7A process that outlived its case is named by pid alone, never by the case that launched it
A process that outlived its case, or left early, is named with the case it was launched for and whether that launch was lent, so a survivor in a long run can be traced.
- WW530 · f7631f8A drag can only be released over an element of the window it started in, so a drop onto Explorer has no case
A drag step with "toDesktop": true looks its
toup from the desktop, so a case can drop onto another window, such as an Explorer folder (design recorded inREADME.md). - WW529 · 8dd4025A filled JSON store naming {files} inside a string comes out invalid, because the path's backslashes are not escaped
A filled .json file gets each replacement JSON-escaped, so a store naming {files} parses and keeps the path (design recorded in
src/Winwright/Scenarios/FixtureDeclaration.cs). - WW528 · c06f314A case cannot claim a reading is empty, so a tab with no status or a field left blank has no claim
A case claims a reading is empty with empty: true, which holds only for an element that is there and says nothing (design recorded in
src/Winwright/Scenarios/StepDeclaration.cs). - WW527 · 832ff79A staged file cannot name the server a fixture reaches, so its store carries a second spelling of the address
A staged file with fill: true gets {reach0} and {files} filled as UTF-8, so a store names its server once, in reaches (design recorded in
src/Winwright/Scenarios/StagedFile.cs). - WW525 · 076a8e8Reading value on an element with no Value pattern polls for seconds and fails as nothing answered, never naming picked
A case that stops short collapses what its expand steps left open, so a drop-down from one red case won't hold the next (design recorded in
src/Winwright/Scenarios/CaseRun.cs). - WW526 · 7ae3713The chord, contains and drag suite tests go red when the desk refuses the foreground, instead of excusing it
A suite desk test whose only shortfall is a desk hole is excused, not red; a held guest desk excused 9, a healthy one passed all (design recorded in
tests/Winwright.Tests/BusyDesk.cs). - WW524 · 38b163fA staged file always lands flat under {files}, so a store one folder down cannot be reproduced (WW519)
A files entry may be {from, to} so a store lands one folder down under {files}; escapes and collisions are refused at load (design recorded in
src/Winwright/Scenarios/StagedFile.cs). - WW523 · e709f83A case cannot read an element's item status, so a state an application publishes there cannot be asserted
A locator selects by item status with [status="Connected"], so a case finds the connected tab without its title (design recorded in
src/Winwright/Locating/LocatorStep.cs). - WW522 · 9998060A case cannot say it needs a server the application connects to, so a connected client's window has no case
A fixture names its server in 'reaches'; each launch probes it, offers {reach0} if it answers, else holes every check unlaunched (design recorded in
src/Winwright/Processes/Reaching.cs). - WW521 · e84924bA project declaration names one executable, so a run against a Release build launches the Debug path
A declared path may carry {configuration}, filled by caller, WINWRIGHT_CONFIGURATION or file, refused by name if unfilled (design recorded in
src/Winwright/Projects/ProjectDeclaration.cs). - WW520 · 56743aaA case cannot drag one element onto another, so a strip reordered by dragging has no case
A case drags one element onto another with 'act: drag' and 'to', past the drag threshold, and the fixture's tab strip reorders in the guest (design recorded in
src/Winwright/Acting/Drag.cs). - WW519 · 3742239A staged store never reaches an application reading a Windows known folder, and the launch is green (WW509)
A fixture setting a profile variable says on its line and each case's that an app asking for the folder sees the real one (design recorded in
src/Winwright/Scenarios/FixtureDeclaration.cs). - WW518 · 242fa5ba typing step's line says nothing about the desk, because an act carries one precondition and two were read
Typing composes the pair it reads, so its line names the control that took the focus and how the desk was ours (design recorded in
src/Winwright/Verdicts/Precondition.cs). - WW517 · b3b62eaa foreground check that passed records neither who held the desk nor which finding made it ours
A met foreground names the holder and the finding that made it ours, and a press carries both to its trace line (design recorded in
src/Winwright/Windowing/Foreground.cs). - WW515 · 45b8811staging a launch and building it are two calls whose order nothing enforces
Staging hands back the type a launch is composed from, and a fixture that needs it is refused until something has (design recorded in
src/Winwright/Scenarios/StagedFixture.cs). - WW514 · 03986aea generated sentence may carry an interpolation hole the build cannot resolve, and the page publishes it verbatim
Anything brace-delimited that could be a name is a hole now, and one the build cannot resolve stops it (design recorded in
site/scripts/format.mjs). - WW513 · 0db54f9the application's other launcher sets no working directory, and nothing can assert the one it would set
A read-out starts at the project's root, and a case drives one to read back what it resolved there (design recorded in
src/Winwright/Asserting/DerivedSet.cs). - WW512 · da39bf9the directory a launch starts in is asserted on the ProcessStartInfo and never on a running process
The fixture answers --resolve, so five cases start a process and read back what a relative argument resolved to (design recorded in
tests/Winwright.Tests/LaunchDirectoryTests.cs). - WW511 · ceb9b84three generators read an enum with a matcher that only recognises a valueless member, and the pairing copies it
Four matchers read any member now, and the pairings count what the body separates instead of copying the generator's regex (design recorded in
site/scripts/csharp.mjs). - WW510 · 3c98bd4the version swap is the one behaviour on the site no run exercises, on both halves of it
Both halves run in a case now: the area's over the page the build wrote, the landing page's through a render.
- WW509 · 9cda5b0A fixture cannot put a file where the application looks, so a case needing a known store writes into the user profile
A fixture stages files into a directory of its own, named by '{files}' in a variable or the working directory (design recorded in
src/Winwright/Scenarios/FixtureDeclaration.cs). - WW508 · b7733b2A fixture cannot name a file in the project, because the launched application starts wherever the runner happened to be
A launch starts in the project's root, and a fixture may name a directory of its own against it (design recorded in
src/Winwright/Scenarios/FixtureDeclaration.cs). - WW507 · e2c3106the oldest generator still reads a doc comment its own way, and the shared reader's case excepts it by name
The shared reader carries what a matcher reads off a line, so product.mjs asks for the declared value and a valueless member now stops the build (design recorded in
site/scripts/csharp.mjs). - WW506 · fbb7b45the documentation area still bakes the version, so its package references go stale while the landing page stays current
The area asks nuget.org for the version its references state, through the same picker the landing page uses rather than a copy (design recorded in
site/scripts/nuget-feed.mjs). - WW505 · 29b21c3four published sentences cite a task id, so an adopter reads WW483 and has nothing to open
No published sentence cites a task id any more, refused where the two catalogues are declared and again where the pages read them (design recorded in
tests/Winwright.Tests/DeskFactTests.cs). - WW504 · 861b82ethe six page generators are chained by hand in two package.json scripts, and nothing holds the lists equal
The two chains are held to the generators that write into the area, so one missing from either, or chained nowhere at all, is a red (design recorded in
site/scripts/docs-area.test.mjs). - WW503 · ae44eccthe README's project example omits a key this build reads, and the gate over it checks nine names somebody typed
The README's example is held to every key the build reads rather than to nine typed names, and it gained the one it was missing.
- WW502 · 3f5009bone of the four page generators keeps its own C# reader, and it already disagrees with the shared one
One C# reader for every generator, with the grammar page's payload byte-identical across the move and a case that refuses a second copy (design recorded in
site/scripts/csharp.test.mjs). - WW501 · 2fdcaf2the twelve readings a step may name are published as bare words, so nothing tells 'picked' from 'selected'
Each of the twelve readings carries a sentence in the vocabulary, and the page publishes it beside the word an author chooses (design recorded in
src/Winwright/Scenarios/ReadBack.cs). - WW500 · d44caeethe site bakes the version at build time, so a release leaves the page offering the version before it
The page states what nuget.org says is published and falls back to the generated number, so a release no longer leaves it advertising the version before it.
- WW499 · 5ad1e08the README's table of locator forms is a hand-kept copy of the parser's own, and the two already differ
The README's grammar table is held to the parser both ways now: every form the grammar states is shown, and every form shown parses (design recorded in
tests/Winwright.Tests/Grammar.cs). - WW498 · a5ce6acevery page assumes the vocabulary, so a first-time reader meets case, hole, desk and reading undefined
Six words the area uses more narrowly than a reader already does are defined once, each ending in the page where it does its work (design recorded in
site/scripts/vocabulary.test.mjs). - WW497 · d3520f5the area links README anchors by hand, so a renamed heading breaks them with nothing going red
A README anchor the area links that names no heading is a red, proved by a control that renamed one and turned the gate over (design recorded in
site/scripts/readme-links.test.mjs). - WW496 · c3b37c9the site ships two sitemaps under one base, and the one robots.txt names lists no page of the area
One sitemap lists every page under this base, the area's eleven included, and the second one nothing pointed at is no longer published (design recorded in
site/scripts/docs-sitemap.mjs). - WW495 · 6962bcethe area publishes HTML alone, so an agent renders three pages to learn what the tool is
Every page of the area publishes a Markdown twin beside its HTML, converted from the same render and listed in the site's own llms.txt (design recorded in
site/scripts/docs-twins.mjs). - WW494 · bc25affa first run's refusals are written up by cause, and a stuck reader has only the words on their screen
A stuck reader has a page addressed by the words on their screen: seven refusals, each quoted from where it is said (design recorded in
site/scripts/messages.mjs). - WW493 · 01796dcevery example in the area was written rather than run, so no page shows one real adoption end to end
One adoption is a page end to end now: the build that fails first, the line that repairs it, and a case pressing a button and reading the label back, all captured from real runs.
- WW492 · 25c8263the in-app half is described as a list of types, so nobody can tell what shipping it costs their users
The in-app half is argued as a shipping decision: every surface off until armed, what it buys, and the hole a run without it answers (design recorded in
site/scripts/inapp.mjs). - WW491 · 74bb023what earns a hole rather than a red is spread over the README, so a reader who met a 2 cannot look it up
A reader who met a 2 has one page: all 24 conditions a hole can name, the desk's apart from their own, and the order a run folds by (design recorded in
site/scripts/holes.mjs). - WW490 · 9a0e50ewinwright.json is described by an example, so a reader cannot tell which keys this build accepts
Every key winwright.json reads is a page row saying what it declares, what leaving it out does and what it refuses (design recorded in
src/Winwright/Projects/ProjectDeclaration.cs). - WW489 · a594e3cthe verb catalogue is a README table, so no row can be linked and no verb says what it needs of the desk
All 121 verbs are a page, off the catalogue the suite gates, each saying whether it needs a desk or the in-app half (design recorded in
site/scripts/verbs.mjs). - WW488 · ed9e98dthe case format answers only to an installed plugin, so a reader deciding has no field list to read
Every field of a file, a case, a step and a fixture is a page now, generated from the loader's own schema, with each closed list printed whole (design recorded in
site/scripts/format.mjs). - WW487 · 397811ethe locator grammar lives in a section of a 1,000-line README, so learning it means reading the file
The locator grammar is its own page, read out of the parser on every build, with every form parsed by the suite and every refusal it can answer with (design recorded in
site/scripts/grammar.mjs). - WW486 · db4b578a click on an icon in the overflow is refused as covered by the flyout that holds it
A click on an icon in the overflow lands on it: the flyout's pane that answers at the icon's centre is read as what holds the icon, and never as something over it.
- WW485 · e751bffthe fixture wears the generic executable icon, so every window a run puts up is unmarked on the desk and in captures
The mark is built in at 16, 32, 48 and 256, so every fixture window and its tray entry wear it (design recorded in
src/Winwright.Fixture/Winwright.Fixture.csproj). - WW484 · 348202aclaude-tray's Profile submenu switches were only ever checked in whichever position the guest happened to hold
A fixture puts claude-tray's switches in either position, so both words, both scope sentences, Open Claude Code's two shapes and the pin and its undo are cases.
- WW483 · a94ec23a case cannot click a tray icon, so the window an application opens on a left-click is claimed by nothing
A tray step clicks its icon with
click tray icon, a pointer at the icon's centre that lands on it or is a hole naming the desk, and the next step reads the window it opened. - WW482 · f8a00f6claude-tray's session row announces its disclosure chevron as a font glyph, which a screen reader reads as nothing
claude-tray's session-row chevron announces collapsed or expanded in all five languages, so the migrated readable-row claim passes in the guest instead of reading U+E70D.
- WW481 · f712518claude-tray's self-check is red on three read-out flags that Block J added and its flag catalogue never named
claude-tray's flag catalogue names --observing, --profile-names and --menu-state, so its --selftest is 1061 of 1061 in the guest again and its CI gate is about the application.
- WW480 · 098642fthe preview loop is a 451-line screen copy wired into four documents, and deleting it is not a migration
claude-tray draws its preview windows as cases: it took Winwright.InApp by decision,
preview.cmdreaches one by tag, and the 451-line screen copy is deleted. - WW472 · d81f637the runner says a shell holding the desk clears itself, and carries the tree anyway when it does not
The runner asks the desk for the foreground as a fixture does and refuses before the carry when it is not given; one input event is what was missing (design recorded in
tools/desk-take.ps1). - WW384 · d458b1dthe clearer's acting half is run by nothing but a guest, so a repair that moved no window would read as one that worked
The arm runs against a real window:
run-desk.cmdreads off the desk that it went down and let the foreground go (design recorded intests/Winwright.Tests/DeskProbeTests.cs). - WW158 · 836550bthe display condition counts monitors and measures the virtual screen, which the session that rendered nothing passed
The display condition answered absent on a console session that disconnected itself, where monitor count and virtual screen still said present; reconnected, it answered met.
- WW88 · 6917d3fpportal carries an interaction harness and twenty-seven copies of one runner
pportal's 285-line interaction harness is two cases, proven with a pad plugged in: the capture opens and quotes it, and a desk without one is an absence the run names rather than a red.
- WW86 · 2b452ecclaude-tray still carries a 3,004-line interaction harness, and one of its claims has no case
Check-Interaction.ps1 is deleted and the icon's left-click is its last claim to become a case: 23 cases check 95 claims in 128-159 s, where the script checked 31 in 46 s and crashed.
- WW479 · c1ba0eca state an application appends can be claimed present and never claimed absent, so the mark is one-sided
notEndsWithLabelclaims a reading does not end with a declared string, so an appended state is falsifiable both ways; the empty key reds rather than holding of everything. - WW478 · 09a81actwo of the four sampled modes have no case, and they are the ones a mark drawn for nothing would show up in
The mark is claimed absent on the one entry it would be drawn on, so a mark or a line drawn unconditionally now reds; unset is recorded as not a case rather than missing.
- WW477 · a3f6235a locator substituting a label asks for the whole of it, so nameStarts cannot take the one whose end moves
A nameStarts locator takes the fixed part a trailing placeholder leaves, so a label whose end moves can be addressed;
namestays equality and the brace must be the whole value. - WW476 · 481ff9cthe mark T172 draws when the variable names another profile is asserted by nothing that has ever run
The submenu mark for a variable naming another profile is read by a case, on a sampled environment the fixture declares and the read-out is asked of.
- WW475 · 9a3ad8ba label carrying a placeholder is refused for every claim, including the two that only read the part it does not move
A begins-with or ends-with claim reads the fixed part a placeholder at the far end leaves, and each is refused by the label the other can use.
- WW474 · 7a37e95CI runs the desk half on a runner that promises no desk, so it has been red about nothing since September
CI asks the desk-free half the gate derives, so a red there is about the tree again and the desk half stays where it is proved.
- WW473 · e75f9dba read-out is launched without the fixture's arguments, so it answers about a machine the window is not showing
A read-out carries the argument its fixture's environment reaches the application through, so a window drawn on a sampled machine is asked about that one.
- WW85 · 98c1fcathe environment sweep walks a submenu per sampled mode
A fixture per sampled mode, each walking a submenu of its own; the second's line is addressed by the front WW477 let a locator ask for, and claimed on what the locator did not choose.
- WW83 · b1de20fthe switch case drives the one path that rewrites a real setting
The switch case drives the pick in the adopter against the published engine, and the store bracket around the suite reports the run left the machine as it found it.
- WW471 · 11bc7c5the preamble reads the foreground once, so it reports absent a desk every act in the run then waited for and had
The desk is read again when the run ends, so a window that came forward is told from one the desk never reached, and neither look waits.
- WW470 · 6f8c6dcthe desk precondition is read once, so a window still coming forward is reported as a desk somebody else holds
An act waits for the desk over the resolve budget: a window still arriving is driven, and a desk truly held still holes (design recorded in
src/Winwright/Windowing/Foreground.cs). - WW469 · 0ebd67ea read-out carrying anything but ASCII reaches the expectation as mojibake and reads as missing from the window
Both ends of the read-out's pipe declare UTF-8, so an accented value arrives as what the application printed.
- WW468 · 0ebd67ea set read out of the application is derived in the machine's language and compared against a window in the fixture's
A read-out's arguments take
{language}, so it answers in the language the window under test was launched in. - WW467 · d698580publishing from a tree that declares an unpublished version spends a second number on the same release
An empty input publishes what the tree declares when nuget.org has not got it, so a locally packed version is the one that ships.
- WW466 · 2735decA sweep over a reported set that finds anything missing throws instead of reporting the red
A reported set carries one origin per value, so a sweep that finds something missing names it instead of throwing.
- WW465 · b88c520a screen copy of a window whose pixels are not in the rectangle yet passes every question a capture is asked
A copy is of a rectangle, so the frame is read either side of the take and a window that moved out of it is refused naming both — which is the wallpaper that passed.
- WW464 · 45b8e12the reference tells an author a submenu locator may name any element of the window, which the walk stopped honouring
The reference names the entry whose submenu is wanted and says what a step naming the window expands instead, which is the walk WW83 built and the sentence that argued against it.
- WW463 · 3a6a734nothing says whether the entry a submenu step hands back is the submenu's or the parent it was expanded from
Measured and held by a case: both kinds hand back the entry under the one they expanded, so a step's expectation is compared against the entry it named.
- WW462 · 0063cf5the sweep for verbs that reach the desk walks one file, so a verb reaching it through another is never seen
The sweep crosses files: 24 verbs became 51, each classified, and the excuse a synthesised act is written with is one the rule can see (design recorded in
tests/Winwright.Tests/Checkout.cs). - WW457 · 293e5d1a menu key is refused where the foreground is the shell's flyout or the popup's owner, which is how a tray menu stands
A tray menu takes a key wherever it stands, and the walk reads the entry the menu shows rather than the window that raised it (design recorded in
src/Winwright/Acting/Menu.cs). - WW87 · 218d4c0freewilly carries its own copy of the capture script and a layout probe
The 382-line capture script is gone: its five assertions are readings this engine takes, and the menu it existed for is photographed by a case that waits until the menu is there to photograph.
- WW461 · 7a9a134the tray step shuts the flyout it opened while the menu stands, which dismisses every menu but this fixture's
The flyout close moved to where WW343 put the foreground restore, and the one tray case that drives the scenario runner reads an entry of a menu that shuts itself.
- WW460 · 8ccdafathe diagnosed miss reaches a case in this suite and not a scenario step, which is the door an adopter reads
A scenario step's never-answered detail carries the miss now, and the case asserts on the detail a trace prints rather than on an expectation in hand.
- WW459 · 0ddee3fa miss is diagnosed down the first branch while resolving walks every one, so it can describe the wrong parent
A miss walks the frontier its resolution walks, so the parent it names and the contents it prints are on a route something would have taken.
- WW458 · d26430ba route unambiguous as a whole is refused where one step matches two, and an act throws reading itself back
A route resolves where one step matches two and only one holds the rest, and the tray case drives the locator an adopter writes rather than one written around it.
- WW456 · 60c97e6a tray-menu step that resolves nothing says only that, so three runs have gone on ruling out what the desk held
A miss now says what the thing it stopped under was holding, and the never-answered sentence carries that diagnosis — which is where an adopter reads a red.
- WW455 · 9f8ece5every menu this fixture puts up holds itself open, which no application's does, so no case meets one that shuts
--tray=shutsis the same drop-down with AutoClose left alone, and both readings hold against it in the guest — so a menu's lifetime is not what stops claude-tray either. - WW454 · cc8e1d7the switch case and the store bracket were written against an engine claude-tray could not restore
The switch case, the read-out it picks with and the suite inside the store comparison are in claude-tray at ff727c1, and nine of its ten tests pass in the guest.
- WW453 · 72c4d60no menu this fixture puts up has a submenu, so the verb an adopter's next step calls is driven against nothing
--trayputs up a submenu in both kinds, and driving it foundSubject.Windowasking the root — which answers nothing for a tray, and is the sentence an adopter's third step reports. - WW452 · f07eb25no case reads inside a tray menu another process owns, which is the step claude-tray's own case fails on
Two cases resolve
Menu > MenuItem[name=...]against the desktop into a launched tray's menu, both kinds — so the boundary is not what stops claude-tray one step in. - WW451 · 603e305no case here opens the tray menu of another process, which is an adopter's only shape and the one WW322 was fixed from
--tray is a launched process whose only surface is an icon, and two cases open its menu, both kinds, across the boundary WW322 had to be diagnosed from an adopter's log for want of.
- WW450 · c18ba98a desk that draws no menu shadows turns the shadow-skip case red, and no desk fact the engine declares can excuse it
A desk with drop shadows off is a hole naming the setting, where the case waited ten seconds and went red (design recorded in
src/Winwright/Windowing/DropShadows.cs). - WW449 · 73fa339a minimised dialog whose desk another process took reads as asking, and the case refuses the excuse it has for that
The excuse is decided by whose window the probe read, so a desk another process took is a hole on CI's runner too (design recorded in
tests/Winwright.Tests/DeskProbeTests.cs). - WW448 · f5ce19atwelve cases wait for the fixture's window with the same line, budget and poll, each written out where it is used
The twelve are one call on the deadline this suite declares, so four typed numbers for one wait are gone (design recorded in
tests/Winwright.Tests/Fixture.cs). - WW447 · ec01905seven cases that only reflect sit in a serial class, so a verb added to the engine is red eight minutes into a guest run
The seven carry WW431's mark, so an unclassified verb is named by the gate in seconds instead of by a guest run (design recorded in
tests/Winwright.Tests/NoCooperationTests.cs). - WW446 · 1163523the deadline catalogue counts
Attempt.Until(and notAttempt.UntilTrue(, so 45 of the waits here are in it nowhereBoth spellings are counted, so the catalogue holds 63 waits across 35 files and each one says what makes its look false (design recorded in
tests/Winwright.Tests/Deadlines.cs). - WW445 · c15be9dthe sweep that holds a no-desk mark honest finds cases by
public void, so a marked async case is checked by nothingA marked case is found by its own declaration, whatever shape it has, and a written sample proves the sweep sees both (design recorded in
tests/Winwright.Tests/NoDeskTests.cs). - WW444 · fccb20ca step's rows are held to its own reader by nothing, so a row no property reads is a key that loads and does nothing
Each of a step's rows is paired with what reads it, so a row nothing reads is red rather than published (design recorded in
tests/Winwright.Tests/StepDeclarationTests.cs). - WW443 · 933667aa case that reads a file cannot say it needs no desk while its class builds a tray icon for every case
A case that reads a file and reaches for nothing moves to a class that needs nothing, and a rule holds the door shut (design recorded in
tests/Winwright.Tests/NoDeskTests.cs). - WW442 · 4ba54dcthe tray fixture shuts an overflow it found open, so the case holding it to leaving the overflow as found goes red
The tray fixture shuts only a flyout its own search opened, and a case that leaves one standing before Add reads it still standing after.
- WW441 · 2105b69a host that cannot build refuses the guest run as though the desk-free cases were red
A host that never ran a case says so, prints what dotnet said and goes on to the guest; the dump reader tells the same two endings apart (design recorded in
tools/host-gate.ps1). - WW440 · 08a003fthe suite reads whether a half is armed with its own copy of the walk, and three preconditions now lean on it
The engine publishes the reading, the suite asks it instead of walking again, and a rule keeps it one walk (design recorded in
src/Winwright/Capturing/OwnRender.cs). - WW439 · d612ae1the guest exits 91 and 92 to say which sync failure it hit, and nothing on the host reads either number
The host switches on the code the guest leaves with, declared once and interpolated into the guest's own program (design recorded in
tools/run-tests-vm.ps1). - WW438 · a686d44shipping a task rewrites the roadmap a case reads, so the guest run that proved the work is stale before the commit
The order a ship imposes is written in the catalogue, in both its refusals, and in the skill a finished task loads (design recorded in
tests/Winwright.Tests/Criteria.cs). - WW437 · 96a701cthe catalogue of every way a thread is parked walks src and tests, so a tool that parks one is invisible to it
The sweep walks tools too, and the eight parkings it found are the kinds already written rather than a kind for a tree (design recorded in
tests/Winwright.Tests/Sleeps.cs). - WW436 · 9dcc2e4listing a process's windows calls GetWindowTextW on each, which never returns for a window of this very process
A window of this process gets 500ms to answer for its title; another process's is still read from the cached caption (design recorded in
src/Winwright/Windowing/Win32.cs). - WW435 · ffa4ebda case's and a fixture's fields still reach the loader one hand-written line each, where a step's are read off its rows
A case's and a fixture's fields are read off the schema's rows, and a row nothing hands on is refused at load (design recorded in
src/Winwright/Scenarios/ScenarioFile.cs). - WW434 · 160ae2bthe label family is three properties and two hand-written chains, where the sweep and pointing families are one list
The three ways of claiming a declared string are one list the claim set and refusal walk, each saying what it claims (design recorded in
src/Winwright/Scenarios/StepDeclaration.cs). - WW433 · 8708a93the host gate takes only classes that are sealed, so a quarter of the desk-free suite never runs in the cheap half
The gate takes a class that needs no desk whether or not it is sealed, and its list is held against the suite's own declarations both ways.
- WW432 · 93ae7acthe bound's holder walk runs only where a sync has already put it in the guest, and nothing says so
The holder walk is sent by whoever is about to use it, so a bound fired before any sync asks the guest rather than a file that is not there.
- WW431 · bf76e41the host gate takes whole classes, so a case that reads a file inside a serial class waits for the guest
A case inside a serial class marks itself as needing no desk, the gate answers it, and a mark that lies is red before the guest (design recorded in
tests/Winwright.Tests/NoDesk.cs). - WW430 · 872f7d1the gate answers 738 cases on the host and the guest runs the same 738 again, and nothing may skip them
The runner reports what the desk-free half cost the guest: about a twentieth of the case time, so the skip is not worth its mechanism (design recorded in
tools/run-tests-vm.ps1). - WW429 · 3c1bc65the floor a verdict refuses under is this guest's, measured once, and written into a tool an adopter runs
An attribution clears the floor the run's own control measured, and says whose floor refused it where there is no control (design recorded in
tools/Winwright.Typing/Enough.cs). - WW428 · 1e66679the runner waits for four things and each wait was argued alone, so the numbers agree with nothing
The runner's waits are one list of rows the deadlines are built from, and the header prints them with the total they imply (design recorded in
tools/run-tests-vm.ps1). - WW427 · 20efe5fa case asserting which desk fact a run degraded on is asserting where the intruder landed, which it cannot arrange
Every case that provokes the desk and names a reading says what pins it, read back against the sources both ways (design superseded: the four it names are not the seven there are).
- WW426 · 65f0f8fthe floor a verdict needs is one number for five runners measuring rates that differ by an order
Each arm declares the rate it is about and needs three over it in rounds, so a short run is refused with that arm's own number (design recorded in
tools/Winwright.Typing/Arms.cs). - WW425 · 27d7235damage on a line that also holds a legitimate non-ascii character is invisible, and this repository writes both
The encoding check reads each run of non-ascii characters on its own, so damage beside a correct dash is found (design recorded in
tests/Winwright.Tests/EncodingTests.cs). - WW424 · 0e68e80a hand-written list inside the only case about a set is where that set drifts, and three of them are still here
The fixture's languages are one hand-made list, held both ways against the strings files it ships (design superseded: Provocation.Known and FixtureArms were already counted both ways).
- WW423 · 72ea3fca sample adopter's projects are inside this checkout and every sweep that walks it from the root reads them
Checkout names the adopter's tree, every project sits in a named tree, and no reading of this project's code takes from it (design recorded in
tests/Winwright.Tests/Checkout.cs). - WW422 · cfb0242a ledger row an older build wrote silences the rate on every line, and nothing says a reading has gone
A report whose excused rows include one naming no case says which readings that row took away, and says nothing where every row names one (design recorded in
tools/Winwright.RollCall/Roll.cs). - WW420 · 0f6d371the runner's failure arms are read for their shape and run by nothing, and the door that would drive them exists
runner-arms.ps1 drives the bound, the held tree it leaves and a red run through the guest, and each says what it found (design recorded in
tools/runner-arms.ps1). - WW419 · 4933de9every reading the engine takes about an application is driven with one application up, and a run has several
Two fixtures up at once each report their own surfaces and geometry, and the instance check tells them apart by pid (design recorded in
tests/Winwright.Tests/TwoApplicationsTests.cs). - WW418 · 4fcef94the case proving a wait is skipped asks whether the test host is armed, so another class holding a half decides it
The two in-process cases say out loud that they hold only while nothing else in the test host is armed, and the out-of-process claim is named as the pair's other half.
- WW416 · 35fade2the guest answers the host in markers nothing reads back, so one it writes and no arm switches on is silent
The three words that cross are a catalogue held both ways, cut at the here-strings that tell the writing from the reading (design recorded in
tests/Winwright.Tests/GuestMarkerTests.cs). - WW406 · f949720the test host goes away mid-run and 900-odd cases never run, three times in about fifteen guest runs
A red run says which thread was waiting: both kept dumps name Win32.TextOf under the captures case, waiting in GetWindowTextW (design recorded in
tools/Winwright.Blame/Waiting.cs). - WW391 · a2cc3c3a claim joins the format by being a field and a field still joins in five places, one of them a 29-parameter verb
A field joins the format in a schema row and a property, not five places:
Oftakes what a case wrote, not 29 parameters (design recorded insrc/Winwright/Scenarios/Written.cs). - WW421 · 6d56cefthe guard against double-encoded text names the extensions it reads, and the tools' scripts are not among them
The walk reads every file that is not built output or a binary, so the tools' scripts are in it (design recorded in
tests/Winwright.Tests/EncodingTests.cs). - WW417 · fb7377da rule that only reads sources is met by a seventeen-minute guest run, and the split that would ask it sooner exists
The runner answers the desk-free half on this host first, derived from the serial collection (design recorded in
tools/host-gate.ps1). - WW415 · 44efc47the bound gives up on a run and names nothing that is still running, one command before the sync names it
The bound asks the guest who is still running and names them, off the walk the sync shares (design recorded in
tools/holders.ps1). - WW414 · 5fe977cthe skill may not backtick a control type, so guidance about the tree is written around a rule about the engine
A backticked word the tree's own vocabulary knows is checked against that, so the skill says MenuItem (design recorded in
tests/Winwright.Tests/SkillTests.cs). - WW413 · 95d5536two arms have a control that would refuse a run and neither checks it, so both read a desk with a floor and say nothing
Neither arm attributes below the desk's floor (design superseded: provoke already asks its control, and sweep has none) (design recorded in
tools/Winwright.Typing/Enough.cs). - WW412 · 69a1818a guest that has just been powered on is refused for having no session, which it has a minute later
The session probe waits three minutes for a guest to finish logging in, and says so while it does (design recorded in
tools/run-tests-vm.ps1). - WW411 · bacc8e7the flyout case asserts the overflow is there a line after the verb held it, and the shell sometimes shuts it first
A flyout gone before the provocation is a hole naming the desk, which is what the rest of the case already does (design recorded in
tests/Winwright.Tests/NotificationAreaTests.cs). - WW410 · 60e8e7da runner at one round is asserted to have printed and never to have printed something a reader could act on
No runner concludes below thirty rounds, and the smoke run asserts each of them refuses (design recorded in
tools/Winwright.Typing/Enough.cs). - WW409 · f39efbba flag that draws nothing is skipped by the run that drives every shape, so what those shapes open is asserted nowhere
Each shape that draws nothing names what drives it, read both ways against the fixture's own catalogue (design recorded in
tests/Winwright.Tests/Undrawn.cs). - WW408 · 2491ef0the sweeps over the shipped halves each name their own two assemblies, and nothing says what shipped means
Checkout.Shipped names the libraries once, held against the project files the build reads (design recorded in
tests/Winwright.Tests/Checkout.cs). - WW407 · d1ed823the rate on an excused line fires on no ordinary run, because the clause above it covers every one
A reading silent on both shapes an ordinary run takes is red here (design superseded: the rate does speak on ordinary runs) (design recorded in
tests/Winwright.Tests/RollCallTests.cs). - WW405 · e2a7169the suite drives the engine inside its own process, so anything the engine keys by process is untestable here
The fixture can be an application that never took the half, so two of them are two processes (design recorded in
src/Winwright.Fixture/Flags.cs, tests/Winwright.Tests/FixtureTests.cs). - WW404 · 23210a6a sync refused by something holding the guest tree names the path and never what is holding it
The refusal names the processes holding the tree, and finding none is its own sentence (design recorded in
tools/run-tests-vm.ps1, tests/Winwright.Tests/DeskProbeTests.cs). - WW403 · 64465eba criterion a partial ship raises is labelled by its task and the catalogue groups by block, which nothing says
The field is
Undernow and says a label may be a task's id, with the partial ships kept in a place of their own (design superseded: WW87's criterion was already labelled by its task). - WW402 · c77b0baa render of a surface that is genuinely one colour is refused as a display that was drawing nothing
A rendered surface may be one colour and says so on the pass; a window that rendered flat is refused exactly as it was (design recorded in
src/Winwright/Capturing/CaptureReceipt.cs). - WW401 · 0477360a case that loses the desk mid-act fails in the words of its own subject, so a desk fault reads as five separate defects
A failed reading after a synthesised act looks again, and a window that lost the desk is a hole naming it, not a red (design recorded in
src/Winwright/Scenarios/CaseRun.cs). - WW400 · 73eb9f0three of the probe's six answers are still produced only from typed looks, and two of them can now be arranged
staleandclearare produced from real looks now, so five of the six answers come from a window this suite put up (design recorded intests/Winwright.Tests/DeskProbeTests.cs). - WW399 · f7c3df7a tray locator naming its container works against one kind of tray and not the other, and nothing warns an adopter
The skill says to address a tray menu at its entries and why, and a case holds that sentence to what this suite measured (design recorded in
skills/winwright/SKILL.md). - WW398 · 7d84695a case wanting the tree without the rectangle wrote a second walk of it, beside the one renderer that says it is the one
The shape is a projection over the one renderer now, and the second recursion is gone (design superseded: the two walks had not drifted; both indented alike).
- WW397 · 46bff35the ladder's control has stopped reading zero, so every rung above it is refused and the tool can attribute nothing
The floor is measured and dated: 4 of 3600 over three runs and a cold boot, so a re-run is no remedy and the refusal says so (design recorded in
tools/Winwright.Typing/Transfer.cs). - WW396 · b4733f3a run that powers the guest on never closes its output, so a caller that pipes it waits long past the end
The console is started through a launch that inherits nothing, so a piped run ends when the run does — measured cold (design recorded in
tools/run-tests-vm.ps1). - WW395 · fe679ffthe guarding rung spells the engine's interval itself, so moving the engine's leaves it pricing a placement nobody pays
Two cases read all three spellings out of their files and fail where they disagree, the prose included (design recorded in
tests/Winwright.Tests/TypingIntervalTests.cs). - WW394 · a37cff0a rung added to the ladder's walk prints the rung below it's sentence, because the verdict's switch ends in a default
The walk is derived from the pairs, so a rung joins it by having a sentence and there is no default left to borrow one from (design recorded in
tools/Winwright.Typing/Transfer.cs). - WW393 · e2f662athree tasks held the arms to lists and none of them ran one, so a runner that throws on its first line is green
Every arm and the bare run are driven at one round, so a runner that throws is red on the run that broke it (design recorded in
tests/Winwright.Tests/TypingArmRunTests.cs). - WW392 · 928be4ca pane joins the fixture in five places and the only way to learn which is to add one and read the reds
One case names every place a pane joins and lists all the disagreements at once, including the value flag nothing held (design recorded in
tests/Winwright.Tests/SurfaceCatalogueTests.cs). - WW390 · facc46anothing holds a third bool-and-two-outs verb to the annotation, so the next one costs a task to notice
A sweep over both shipped halves finds every bool-and-out verb by reflection, so the third one is caught the day it compiles (design recorded in
tests/Winwright.Tests/TryVerbTests.cs). - WW389 · fc92feffive readings come off one set of ledgers and each knows when to be quiet only from the ones already written
The five readings are one list now — the window each speaks over and which outranks which — driven by two cases (design recorded in
tools/Winwright.RollCall/Readings.cs). - WW388 · b2cf99fa stale desk is reported and a clearable one is repaired, and nothing says which desks a run tidies before it starts
A stale desk is put away as well as said, and the runner declares which desks it tidies against a case that reads its arms (design recorded in
tools/run-tests-vm.ps1). - WW387 · a8c7b5bnothing can answer for a window that is not hooked, so an absent half is told from a late one by waiting
An armed half puts up a message-only window, so a wait is paid once a window and given back the moment one appears (design recorded in
src/Winwright/Capturing/OwnRender.cs). - WW386 · 7f06d3dthe runner waits on the guest with no bound, so a wedge outside a case is still a run nobody can tell from a slow one
The wait is bounded, says which minute it is on, and ends by reading the desk and the log rather than by being killed (design recorded in
tools/run-tests-vm.ps1). - WW385 · c3bfc13no run ever declares a capture naming a popup, so the branch wiring the step to the ask is asserted by nothing
A declared case captures the popup and the pixel count says which tree crossed; naming one nobody has is a red, not a hole (design recorded in
tests/Winwright.Tests/CaseRunTests.cs). - WW383 · 583c65fno case puts a real window up and reads shell out of the probe, so that arm is only ever produced from typed looks
The shell list takes a parameter now, so a case names its own dialog a shell surface and reads
shellout of a real look (design recorded intests/Winwright.Tests/DeskProbeTests.cs). - WW382 · ab2cf63the two tray menu kinds read as the same tree and nothing claims they must, so a framework changing one is invisible
The entries match and the containers do not: the Win32 kind names its Menu, which is where the difference stops (design recorded in
tests/Winwright.Tests/NotificationAreaTests.cs). - WW381 · 07ffc53the pause sits after the send and WW368 put the provoking call before it, so it guards the half already acquitted
The ladder holds both placements:
guardis the act with the engine's fifty milliseconds above the send, a run from an answer (design recorded intools/Winwright.Typing/Transfer.cs). - WW380 · 444f47fan arm now carries a delegate and nothing checks it is the right one, so sweep could run the delay experiment
The arms are method groups, so the row names its runner and a case reads which one each reaches off the delegate (design recorded in
tools/Winwright.Typing/Arms.cs). - WW379 · 59a8b6bno fixture control settles after the act returns, so every claim about the two instants is asserted through a projection
A box reads back what was written and, a moment later, what the application made of it, so a case drives both instants (design recorded in
src/Winwright.Fixture/SettlesPane.cs). - WW378 · a16835athe absent refusal keeps the last hand-written copy of the claim set, and it is already one claim behind
The absent refusal asks the claim set instead of a chain, so the claim it had never heard of is refused with the right sentence (design recorded in
src/Winwright/Scenarios/StepDeclaration.cs). - WW377 · 8e6cc6fChord.TryParse has the shape WW364 annotated and none of the annotation, so its callers spell the bangs instead
Chord.TryParse says which out is null on which answer, the three bangs are gone, and neither engine caller had to change (design recorded in
src/Winwright/Acting/Chord.cs). - WW376 · fc95f65the rate WW363 added says nothing on the run that first shows a rise, which is the run a reader is holding
The sentence says how many of this run's excuses no ledger has seen, which needs no history and names the rise on the run that has it (design recorded in
tools/Winwright.RollCall/Roll.cs). - WW375 · 5f117a9a minimized window holding a stale foreground refuses every guest run as a question waiting to be answered
A minimised window holding the desk gets its own word and the run goes on, because nobody can read it and nobody can answer it (design recorded in
tools/desk-probe.ps1). - WW374 · 7590578a capture asked for before the application hooked the message is refused as a product built wrong
Both asks wait where the silence is a window whose hook has not run, so a race stops being a sentence about the product (design recorded in
src/Winwright/Capturing/OwnRender.cs). - WW373 · 7a8e6a9a case that deadlocks wedges the run instead of failing, and only a person watching the guest ends it
A single case is bounded at ten minutes against a slowest honest one of 158 seconds, so a deadlock is a red naming it (design recorded in
tests/Winwright.Tests/Winwright.Tests.csproj). - WW372 · 22f9db6no declared step can ask for a popup's picture, and its four refusals would all reach the verdict as holes
A capture names the popup its picture is of, and a name no popup has is a red where an unadopted half stays a hole (design recorded in
src/Winwright/Capturing/OwnRender.cs). - WW371 · 7fcd4e2an asking desk refuses every guest run, and the only remedy is a person at the guest console
A window with a minimise button is put away and only a question still refuses (design superseded: the minimise it called failed had held every time) (design recorded in
tools/desk-clear.ps1). - WW370 · 5b44ee6the loop's one branch that answers nothing is the desktop skip, and no case arranges a desktop-held desk to run it
Get-DeskLooks takes the desktop list, so a case names the class of its own window and runs the skip that makes a quiet desk clear (design recorded in
tools/desk-probe.ps1). - WW369 · 6e3108ba locator naming a control type the tree lacks reads as nothing answered, which is what a vanished menu reads as
Both menu kinds are read as a shape now, so a regression to buttons is a red naming the tree and not a desk sentence (design recorded in
tests/Winwright.Tests/NotificationAreaTests.cs). - WW368 · c7f767fthe provoke arm reads zero for the read the engine now makes and the engine still faults once in twelve hundred
A ladder walks the arm to the act a difference at a rung, reproduces its 1 in 1200, and names the per-round focus (design recorded in
tools/Winwright.Typing/Transfer.cs). - WW367 · 6a0efc7which code an arm runs is still a branch per name in Measured, so an arm reaches the tool in two places again
An arm carries the code it runs, over one context all four fit, so an arm with no branch no longer compiles (design recorded in
tools/Winwright.Typing/Arms.cs). - WW366 · 5605186a step's trace line carries the reading the act took and the verdict beside it used one the expectation polled for
The act's own trace line now carries what the verdict settled on where that differs from what the act read (design recorded in
src/Winwright/Tracing/TraceStep.cs). - WW365 · f4f9ea2Of reads at cognitive complexity 119 because its refusals thread twenty locals, and the step they judge now exists
Nine refusal families ask the step rather than twenty locals, in the order they always ran; Of reads 15 not 119 (design recorded in
src/Winwright/Scenarios/StepDeclaration.cs). - WW364 · c66c16eLocator.TryParse is not null-annotated, so a caller that refused on false still carries a bang to use what it parsed
TryParse now says which out is null on which answer, so the four bangs are gone and reading a refused parse's locator warns (design recorded in
src/Winwright/Locating/Locator.cs). - WW363 · bbf4f8ethe run report says whether an excuse is new and not whether this suite is getting harder to run on a real desk
An excused case now says how often the last 20 ledgers excused it, so a rising set of tray cases stops reading as ordinary (design recorded in
tools/Winwright.RollCall/Readers.cs). - WW362 · 555a380a capture through the attach door depends on a variable nobody set, and the run that could set it does not
A third message asks the application why it drew nothing, so a half told nowhere to write stops reading as no half at all (design recorded in
src/Winwright/Capturing/OwnRender.cs). - WW361 · bbdffe6an application answers renders only for the windows it remembered to name, and a dialog it opens is none of them
Renders.Everywhere hooks every window one UI thread shows, including ones shown later, and says how many it is answering for (design recorded in
src/Winwright.InApp/Renders.cs). - WW360 · 6f3609dwinwright_check says a file loads and the run then refuses it, because the check tool is handed no project
winwright_check takes an optional project, holds the file against it with the run's own walk, and says when it read the file alone (design recorded in
tools/Winwright.Mcp/Served.cs). - WW359 · 409f8f5the render channel WW349 built carries a window's tree and there is no way to ask it for one popup's
A second registered message carries a popup's name, and a name matching two popups is refused rather than photographed (design recorded in
src/Winwright/Capturing/OwnRender.cs). - WW358 · 2692dc4the fixture always has a frame, so no case can make a shell-drawn shadow the largest window a process owns
--shadowed is a frameless process owning only a tray menu and the shell's shadow, so Largest's skip has a case that fails without it (design recorded in
src/Winwright.Fixture/Shadowed.cs). - WW357 · b53d8adthe probe's twelve looks at a live foreground are run by nothing, so a look built wrong classifies perfectly
The polling is a function taking its count and pause, and two cases run it against a desk this suite arranged (design recorded in
tools/desk-probe.ps1). - WW356 · 8a7c4acthe fixture's tray menu is built of buttons, so the locator an adopter writes against a real menu finds nothing here
The entries are menu items now, so a case here names MenuItem as the adopters do and the container still reads unnamed (design recorded in
tests/Winwright.Tests/TrayIconFixture.cs). - WW355 · 1e76b5bevery send waits fifty milliseconds for a provider that only one kind of read wakes, and no cheaper read was tried
The settle asks one pattern of an element already resolved, at 92ms a round against 153; the pause stays, on 1 of 1200 without (design recorded in
src/Winwright/Acting/Keyboard.cs). - WW354 · e961239the typing tool's arms are documented in a .cmd and parsed in a switch, and nothing holds the two lists together
The arms are one list the parse reads and a case holds the .cmd's prose to, and a word naming none is refused with it (design recorded in
tools/Winwright.Typing/Arms.cs). - WW353 · 44cb82aa click sends and reads once, so its answer is whatever was there at that instant and nothing retries it
The click takes the pause WW329 measured rather than a poll, since it has no named thing to poll toward; priced at 50ms a round (design recorded in
src/Winwright/Acting/Pointer.cs). - WW352 · 5aa35b3StepDeclaration.Of takes 28 parameters and its constructor 23, so every new field is threaded through both by hand
A field reaches a step by name now and the constructor is three; Of keeps the signature its format's keys give it (design recorded in
src/Winwright/Scenarios/StepDeclaration.cs). - WW351 · 5e0485cthe claim set is computed from Of's parameters, so a claim is still added there rather than by declaring a field
The set is read off the step's own fields, so a claim is a field and a schema row and no longer a line in Of (design recorded in
src/Winwright/Scenarios/StepDeclaration.cs). - WW350 · d25eae2which of a tray menu's two readings answers is a race, and the suite asserted the one that won a single run
Both readings are taken at the answering look, the menu gets one more poll where only the proxy answered, and Read prefers it (design recorded in
src/Winwright/Acting/NotificationArea.cs). - WW349 · 1fc8b71the engine can now take a screen copy and still cannot take the render it calls the default
The run asks over a window message and the application draws its own tree, so an ordinary window is a picture rather than a hole (design recorded in
src/Winwright/Capturing/OwnRender.cs). - WW348 · 9f99c3aa case that captures with no captures declared is a hole at run time, and the file said so at load
A verb says which declaration it needs, and both of Suite's doors refuse a step the project cannot serve before a window is launched (design recorded in
src/Winwright/Scenarios/ActVerb.cs). - WW347 · 95bc9faa WPF popup is layered for its own drop shadow, so the copy route now refuses the only capture that reaches one
A popup's own tree is photographed by the in-app half, and the layer refusal names that way through (design recorded in
src/Winwright.InApp/Popups.cs). - WW346 · c09ab15the largest window a tray process owns is the shadow behind its menu, so the convenience verb answers the desktop
The shell's shadow behind a menu is named by class and skipped, so Largest answers the window the application drew (design recorded in
src/Winwright/Windowing/TopLevelWindows.cs). - WW345 · fde144bthe probe that refuses a guest run is guest-side PowerShell and nothing runs any of its four answers
the probe is a file with the classification as a function, and every answer is run against looks a case made up rather than read as text.
- WW344 · 0045613putting the desk back answers for the flyout and says nothing about the foreground, the half that gets refused
the reading answers for both halves, and the desktop half is a comparison rather than a return code: who was asked for, and who holds it now.
- WW343 · f0ed89ca case that opens a tray menu leaves the desktop on the shell, because the step cannot give it back
the case gives the desk back where it ends: the menu step hands its reading up, and a restore that did not hold is a hole rather than a silent leak.
- WW342 · da11acathe pause repairs the fault and nothing says whether the read provokes it or the pumping it forces
it is the read and not the pumping: 4800 dispatched messages provoked nothing and the automation read provoked 8 of 400, so the pause pays for the provider.
- WW341 · 1a0f0f0every other synthesised act reads the instant SendInput returns, and only typing was measured
the observable exists and reads nothing: 1800 rounds of click, press and nudge, none late, none lost, which bounds the rate under 1% against typing's 2.58%.
- WW340 · 1f5aeafthe claim set is built inside the refusal and thrown away, so Checkable and the schema keep lists of their own
a claim is a declared thing: the set the refusal builds is kept on the step, Checkable's nineteen ORs read it, and the published format marks which fields are claims.
- WW339 · dc749c3a tray menu's reading is called Highlighted and now often holds the menu's own name instead
The menu standing and the entry highlighted are two fields and exactly one answers, so a trace records the menu as the menu rather than where an entry used to be.
- WW338 · eaeb4cca tray menu is told from the one before it by name, so two unnamed menus read as one menu standing
Every menu standing is read and told apart by its runtime id, and the case that provokes it goes red against the old comparison with the sentence WW322 spent itself on.
- WW336 · ceea9b8no act names a capture, so a migrated capture is C# beside the cases rather than one of them
A case names a capture and what to call it; the project says where pictures go, and the engine performs the copy it has always been able to judge.
- WW335 · 8374983a borderless window sets WS_POPUP, so the route alone would copy an application's own frame
Measured and refuted: a chromeless WPF window reads 0x160F0000 with no WS_POPUP anywhere, and the fixture now draws one so the rule is pinned rather than argued.
- WW334 · ee64e78a layered window's rectangle is a rectangle of the desktop, and nothing refuses a copy of one
A layered window is its own reading and its own refusal, exempt on no route — the shadow behind a menu is a popup exactly as the menu is, and it is the desktop.
- WW333 · 3cc3d29the tray menu case proves the verb against a Win32 popup and never against a WinForms one
The fixture hosts a drop-down as readily as a tracked popup, and the case driving it went red against the old reading and green against the new one, measured in that order.
- WW332 · 3cc3d29the tray menu verb has no case that opens a menu, only one that fails to find an icon
The fixture answers the tray callback with a tracked popup, and the verb opening that one while a drop-down stayed invisible is what told WW322 which half was wrong.
- WW331 · 1d0958ethe desk probe calls a focused taskbar a question waiting to be answered
A shell holding the desk is its own reading and says so instead of refusing, and the classes that name it are asserted apart from the desktop's.
- WW330 · 3a282d9a run whose tray cases fail inside the overflow leaves the chevron focused and the taskbar holding the foreground
The act shuts the flyout it opened and gives the desktop back where nothing opened, and hands a caller that got a menu the same call for after it has read one.
- WW329 · 181c354the engine's own read-back poll is what provokes the substitution it then repairs
The first look waits 50ms: 31 substitutions of 1200 became none, at 7ms a round, and the engine's own path then read 0 of 600 where 15 were due.
- WW328 · d14df58the diagnosis of a locator that matched nothing walks the whole desktop and throws where that walk fails
The door walk catches the COM failure beside the one it already caught, so a locator correctly found to match nothing no longer fails from the code explaining why.
- WW327 · e12f715the instance check's own case asserts about a process it never waited for, and reads nothing on a loaded desk
The three launches go through the wait that was already there, so the case establishes the premise WW180 and WW283 had each tried to read around.
- WW326 · d14df58a case can claim one reading equals an earlier one and never that it holds it inside
contains is the fourth way a step points at an earlier one, and asking PointsAt for it found the sixth call site WW308 said would spell the fold differently.
- WW325 · 52b8ce8no reading answers whether a control will take input, so a case cannot check that a button is greyed
A reading off the property ElementFacts has read since block A, declared always-answering so a step claiming it answers is refused where it is written.
- WW324 · 7f6d3ebthe overflow flyout is read back as absent once in four runs, after the open reported that it held
The same read, one call earlier: the case polls for the flyout it had just been told was usable, so a genuine absence still fails and one unlucky look does not.
- WW323 · 2c90a1fa step naming label and expectReported loads, and the report then prints the key against the other well's value
The eleven lists are one set a step declares itself into, so a pair nobody enumerated is refused by the same rule as every other and the refusal names both fields.
- WW322 · 623a483the tray menu will not open on the guest: the icon is found in the overflow and the application key highlights nothing
The suite puts up the kind of menu that never takes the focus, and the reading asks for a standing menu first — which is what three adopted cases failed on.
- WW318 · c6e2316A case cannot claim that something is not in the tree
absent polls until the locator matches nothing, and refuses to hold where the region the last step looks under is not there to be absent from.
- WW317 · 6c1b66aA command that only a keyboard chord reaches cannot be driven by a case
press takes a chord beside a traversal key, parsed where the case wrote it and sent as one batch, so an application whose commands have no button is reachable.
- WW316 · d591069the recorder that exists to diagnose the fault rewrites a caption holding every character it ever saw
Measured after: 134, 102, 105 and 113ms a round by quarter where it went 4600 to 11325, and the faults stopped climbing with it.
- WW312 · c003822a band of spacings from forty to seventy milliseconds makes the fault five times likelier and nothing says why
2700 rounds over three send shapes and six spacings faulted twice, both at no spacing at all, where 48-64ms alone predicted 35 (design recorded in
tools/Winwright.Typing/Sweep.cs). - WW288 · 7f6d3eba search whose flyout shut mid-look gives up, so the icon case is a hole on the runs the shell decides
Nothing shuts it: three candidates were ruled out and the search now looks again before concluding, which is how the rest of the engine reads.
- WW248 · d9c650aa test class holding an in-process dialog cannot also drive a launched window, and nothing says so
A recurring excuse that has not said it means to be is refused, because intent is not derivable and both rules that tried to derive it marked honest cases.
- WW321 · 759f979a synthesised act whose locator matched nothing throws out of its own trace step, so a red case reports Broken
An act against nothing has no element, so the type says so: the trace line reports the locator that matched nothing and the case fails as itself instead of breaking.
- WW320 · f5129a8routing a capture needs a main window to compare against, so an application showing only a menu cannot be routed
A one-argument overload answers from the window's own class and ownership, so a menu with nothing behind it routes as the screen copy it is.
- WW319 · 5bc395ea hidden element reserves its rectangle, so the layout check reads space nobody can see as drawn on
Whether anybody can see it is decided before what it measures, so a hidden panel no longer fills the covering box nor overlaps the control drawn where it sits.
- WW315 · 72a342bsix of the eleven adopted cases have nothing to check on the guest, which holds no profiles and no transcripts
A bench inside the tree gives the run two profiles and a transcript through the application's own discovery, and the six that had nothing to check now answer.
- WW314 · 0f2246fa guest sitting at its lock screen is found only after the tree is carried, so the refusal costs a full sync
A
cmd /c exiton the desk runs before anything is staged, so a locked guest refuses for one process start where it used to cost the whole carry. - WW313 · 8aa38cccollisions across four runs total 21 where independence predicts 14, and the ledger says they are independent
By quarter the round slows 4600 to 11325ms while failures rise 6, 6, 11, 22 — so the excess is a rate climbing within the run, not a cause shared between arms.
- WW311 · 0f2246fa run that just booted the guest is measured on a desk still putting up its startup notifications
The foreground is polled before the carry and the desk is named — clear, busy, asking or broken — and the last two refuse, naming the window, before the twenty minutes are spent.
- WW310 · 8aa38ccspacing the code units 64ms apart is five to nine times worse than spacing them 32 or 96, three runs over
A band and not a tick: 7.2, 7.6 and 9.6% across 48 to 64ms, back under 2% by 80 — and 130 of 130 failures are the one fault, unchanged at every spacing.
- WW309 · 8aa38ccthe same arm measured three times gave 14, 9 and 2 of 400, so arm-to-arm readings are drawn off a rate that moves
Failures are independent — 0 and 1 collisions against 1.2 expected — so the reading is the discordant rounds, where the split reads 9 against 8 that a total had called worse.
- WW308 · 8aa38ccthe pointer family is three loose strings, and its target-and-mode shape is rebuilt at five call sites
Stored as one target and one mode with the three fields derived from them, so the five rebuilt copies are gone and no key, schema or case file moved — 1819 green.
- WW307 · 8aa38ccthree of the six comparison keys are never read from a JSON document by any test
The three keys are read from a document and checked for value and mode: with two of them swapped in the loader's positional call, 29 tests pass and only this one fails.
- WW306 · 8aa38ccthe typing experiment counts rounds it never typed as substitutions, and they read as a rate
A OneDrive prompt held the guest desk and the run refused at round 1, naming it a lost foreground and exiting 3, where it would have reported 200 substitutions as a rate.
- WW305 · 8aa38ccthe runner waits on vmrun start, which prints nothing and in some states never returns
The start is launched and never waited on, and the poll says its time: a cold guest printed '11s waited; vmrun start has not returned yet' and ran on to 1819 green.
- WW304 · 8aa38ccnothing separates the delay between code units from the work the quiet arm does between them
A delay alone reproduces the quiet arm — 0 in 1100 at 128ms and above, against 2% below it — so time was sufficient and its own price, 128ms a code unit, is what refuses it.
- WW249 · 8aa38ccthe case proving that typing reaches a WPF box fails about one guest run in four
Type repeats the send on WW310's signature and nothing else: 13 of 400 faulted on the guest and all 13 were repaired by one resend, none surviving, each reported rather than swallowed.
- WW82 · 8aa38ccthe menu case reads the notification area and nothing else does
A tray icon is found again by its runtime id, so an application rewriting its own tooltip no longer reads as an icon that vanished: with the match off, one case of 1820 fails, and it is this one.
- WW78 · 8aa38ccthe keyboard case is the only observable of a live input path and it lives in a script
The case is a data file and ran green in the guest — 3 of 3 checks, click to read-back — so the engine is exercised end to end outside the 3004-line script that held it.
- WW303 · f5a173ethe raise refuses the second copy in a file that holds two, so the publish stops before publishing
A file already reading the new version is this having worked, not a disagreement; only a file reading neither refuses, and two cases now cover a raise nothing covered.
- WW302 · 67f3595WW249 gains a red every fourth run and no experiment, so each one observes what nine already did
400 rounds each way, alternated under one desk: 14 substitutions batched against 0 sent one code unit at a time, which is the division ten sightings could not make.
- WW300 · c439dd3which excuses recur across runs is unreadable, so this suite's own structure and a busy desk read alike
The four earlier ledgers are intersected by case: a guest run of 1816 said 8 excused, and none of them is new — one clause, because all eight recurring made a per-line mark useless.
- WW299 · c6599cda run that discovers 600 fewer cases than the last still reads as green
Read off the listing each run keeps and said only where it moved: a guest run printed all 1813 discovered cases ran, where the run before discovered 1812.
- WW298 · bd38a54the excused count is compared with one predecessor, so a second busy-desk run in a row reads as ordinary
Four counts read as a series rather than one difference: a guest run said 8, where the 4 before it excused 8, 8, 8 and 9, so a repeated anomaly cannot become the baseline.
- WW297 · 444840bthe roll call never runs on a failing suite, so the worst runs report no excuses and file no ledger
CallTarget makes the failure a task's, so OnError reaches the roll: a red guest run printed 9 excused against 8 the run before, filed its ledger, and still exited 1.
- WW295 · 009ddc9a locator can be built out of a declared string but never out of a value the application reports
A locator brace spelled
{report:name}is answered by asking the application, once per run, so a case can select the element only the machine's own state can name. - WW294 · 7cba7d8an expectation whose value the application reports can only be a set, and the submenu's marks are single values
claude-tray answers
--menu-stateas one line by the same calls its report makes, so the profile a check mark should be on is a value and no longer a regex over prose. - WW293 · dd67089the runner's adopter parameters cannot be passed through the command its own comment says a person types
The wrapper forwards
%*, so the four flags an adopter needs reach the runner through the command they are told to type rather than around it. - WW292 · 402d771a menu entry decorates the value it is about, so no set claim compares against it and the script counted instead
coversWithinclaims each declared value appears inside a matched name, so an entry that decorates what it is about is compared rather than counted. - WW291 · 5e486d0the one read-out reportedSets was written for is a diagnostic report, and every line of it becomes a member
--profile-namesanswers one label per line by the same discovery route as the report, so a derived set comes from the application and the report is left to its reader. - WW290 · e99a9bea set name declared in both wells resolves to the reported one and the strings key is shadowed in silence
A reported set whose name the strings also declare says which key it shadowed, so the second declaration is stated rather than passed over in silence.
- WW289 · 0ed3175a toast takes the desk and the run excuses 43 checks, reading as green as one that excused 8
Every run now says its count against the run before it; measured, 8 against 8, on a third guest run — the first two proving it reads nothing where nothing was filed.
- WW287 · 886235dthe sentence for an exit code Windows would not name has nothing that provokes it
Removed rather than provoked, on a measurement: the state that makes
ExitCodethrow makesHasExitedthrow one line earlier, so nothing could reach the sentence it bought. - WW286 · 752a3eda lent launch that exited is recorded at the end of the run and read by nothing
The register collects every departure and
EarlyExitsreads them, so a run whose lent launch died says so, counting apart the exit no single case can claim. - WW283 · 114dd3cWW180's count has recurred past its repair, and this time the process is in neither list
A candidate running a different binary is recorded rather than skipped in silence, so
Candidatesaccounts for all three and a red carries the path it claimed to be running. - WW279 · 114dd3ca resident launch that died on startup is reported as an application whose controls are all missing
A launch the register found already gone is recorded as a
Departure, and the case's own line names the exit before the outcome rather than sending a reader to its locators. - WW275 · 95416bacovers is two-way and reads as one-way, so a completeness claim against a shared container cannot be written
The README teaches both directions,
coversAtLeastwrites the completeness-only claim for a container no locator separates, and both clauses agree with their count. - WW269 · d0586eda caption counting down in real time cannot survive an exact comparison across a round trip
sameCountdownAscompares the numbers and ignores the words, allowing the last to have ticked down by one, so a caption that counts is not a red build about a clock. - WW260 · 5792891an expected set is derived from the project's strings and never from what the application reports
A project declares
reportedSetsand a step names one the way it names a strings key, so a count comes from what the application prints rather than from the case. - WW259 · 6e8208d
expandgoes through the pattern, and the submenu the menu case is about only opens to a keyA step names
open submenuand reaches the keyboard walk, handing back the entry the menu landed on soreads: namecompares against the submenu rather than the window. - WW258 · da709c8a case cannot name a tray icon or open its menu, and the engine has done both since block D
A tray step also names
open tray menu, reaching the focus-and-application-key route, and puts the overflow back the way it found it. - WW230 · 9b0cbe7the only place the engine's package exists is a folder inside this repository
Published, and the bootstrap deleted: claude-tray restores 0.1.0-alpha.3 from the feed alone, with no path into this repository, and its eight case-loading tests pass.
- WW223 · aa0e562adding a tray icon and finding it does not hold every time
The occurrence arrived and named itself: the overflow shut mid-search, so it is a hole under the search's own condition and never an icon that was absent.
- WW285 · ddb7289the loading case gives a slow guest six seconds to launch and walk a tree, then blames the fixture
A run that spent the fixture's whole window getting to the reading is a hole naming the clock, gated so arriving in time, or arriving late to something still there, is refused the excuse.
- WW284 · ddb7289two committed source files carry a double-encoded em-dash, one of them in shipped documentation
The six characters are gone, and a case walks every text file refusing any line that was UTF-8, read as Windows-1252 and written back — the note describing them was the last one it found.
- WW282 · d512af4the sequence case reads a skipped state as a broken order and has no guard at all
All three animation cases read their own cadence before they judge, and a state nobody saw is the machine's only where the machine could not have seen it.
- WW281 · f7ec07ca slow-machine excuse is written to the test's own output and counted nowhere
Both gates write to one ledger through one owner, and a column says which kind was not met — so the roll call counts a budget this suite missed as a hole like any other.
- WW280 · 7f30bc0a run too slow to observe the animation says so and goes red about it anyway
A cadence this suite chose, missed because the machine was slow, is a hole naming the reading — gated so a run that kept pace, or got one look, is refused the excuse.
- WW278 · 86b5f1fthe sessions note stays open after the click that should close it, so the case leaves the window changed
The case restores the window by clicking away, which is how the application says the note closes — measured green, so the dot's second click reopens what it dismissed and the clicks were landing.
- WW277 · 656ac25a sweep matches its last step against the whole window, so every step scoping it is decoration
A sweep walks the route its earlier steps name and matches its last step under what it reached, so a scope is a scope and a route that resolves to nothing sweeps nothing.
- WW276 · 656ac25a repeated case makes its claim once per member, so a member with nothing to check holes on every run
A repeated case's per-member claims are gathered into one: red where any member that carried it failed, a hole only where none did, and otherwise a pass saying how many carried it.
- WW274 · 1e5983ca locator step names one control type, so a rule governing a family of controls cannot be swept
A step names several control types with
|between them, matched as one search, so a rule governing a family of controls is one sweep rather than one mostly-empty sweep per type. - WW273 · 2cf5b1ea locator can only name an element by a string typed into the case
A locator carries
{a.key}and the run reads it out of the project's strings in the fixture's language, refusing an undeclared key before the first act — the same hole{}already was. - WW272 · 11e7136a sweep that matched nothing is a red, and a page with no rows is a fact about the application
eachSpokenandownHeadercount a locator matching nothing as a hole naming it, so a page allowed to have no rows degrades rather than reds — unless the locator was built out of a declared string. - WW271 · 07ea156a repack of the same version is invisible to the adopter, and the refusal then blames the case file
pack-local.cmdpacks and evicts together and refuses where the version it read packed no such file, and the bootstrap now names the refusal a stale package produces. - WW270 · 4696966a case can claim a reading is one declared string and never that it is not one
A step names a key in
notLabeland the reading must not be the string it declares, with a reading that answered nothing holding neither claim. - WW268 · 1459720a case can claim a reading came back to an earlier step's and never that it differs from one
A step names an earlier one in
unlikeand claims its reading differs from what that one read, judged and refused whereversameAsis. - WW267 · ec8ab3aa picker is reached by naming a value, and the values are the machine's own data
A step names
pick atwith a position, and the walk reaches whatever sits there — reporting by name what the case could not have written. - WW266 · ec8ab3ano reading answers what a picker has selected, and a ComboBox offers no value to read
A step reads
pickedand gets what a container has chosen, which is also whatanythingnow answers for a picker carrying no value of its own. - WW265 · d129863the picker walk reads the items of a shut picker, and a WPF ComboBox has none until it opens
The walk opens a picker that holds nothing, reads what appeared and puts it back only where it opened it — driven by a WPF picker the fixture had never carried.
- WW264 · b5629fea control wearing its neighbour's label reads as named, and nothing can tell the two apart
A step claims
ownHeader: of the rows its locator matches, no control inside one announces a different row's header, with the headers derived from the page. - WW263 · b442bf1a case has a fixed list of steps, and the panels it must visit are derived from the strings
A case names
forEachand runs its steps once per string the key declares, with the member reaching a locator through{}and an empty derivation refused. - WW262 · 620f07ea case can claim one element is named and a set of strings was read, and nothing about every element
A step claims
eachSpoken: every element its locator matches announces a name, judged by what tells a label from a glyph — and a locator matching nothing fails. - WW261 · 4696966a case expecting a label has to type it, which is the hardcoded set one control down
A step names a key in
labeland the reading is compared against the string it declares, read out of the language the fixture says its window is in. - WW257 · 33c862aa launch that draws no window is refused, and a tray is a process that draws none
A fixture says
residentand the run holds the launch as a process against the desktop, keeping the drew-no-window refusal for every fixture that did not say so. - WW256 · bd684a9a case cannot claim a state was never observed while it waited, only what it read at the end
A step names a key in
neverand claims it was showing at no moment while its locator was waited for, reporting how many times it looked and holing an absence a short walk found. - WW255 · 8cef0dea case cannot claim a reading came back to what an earlier step read, only that it moved
A step names an earlier one in
sameAsand claims its reading is back to what that one read, judged where the case knows all its steps and never against a value the file typed. - WW254 · d7956e2the engine walks a picker and reports the hops, and no case can name that act
A case names
pick, hands it the value inwith, and reads the route and the switch count in the step's own line; one claiming nothing of what it reached is refused. - WW253 · 4a6bd25a case cannot claim a row reads as text rather than as a picture, only that its subtree grew
A step claims
spoken: everything under its locator that announces anything announces a name, and something does — two count-free halves, judged by what the tree drew. - WW251 · 30b0dcfa case cannot claim that an act unfolded a subtree, only that one reading moved
A step may claim the act put something under its locator that was not in the tree before it, compared against the engine's own reading rather than a count the case typed.
- WW240 · 37a2923a project that ships several languages cannot derive a set at all, and the language it runs in is knowable
A fixture says which language its window is in and a set derives from the file for it, so claude-tray declares all five it ships instead of one.
- WW239 · 3d646b9the release workflow keeps its own list of where the version lives, and the list was already wrong once
One line names every copy, and the same flags raise them and read them back — so a copy nobody added is in neither half, and the README joined both.
- WW84 · e71cba0the names case observes what no screenshot can
The walk visits all six panels the strings declare and asserts both branches of the naming rule on each, with every label a key — passing with no hole and no word typed anywhere in the file.
- WW81 · 40c1be4the profiles case is the only thing in that repository that drives the picker
The picker walks by position and back, the report comes back with it, and the not-yet line is never shown on the way — with three claims left open as WW268-WW270.
- WW80 · 6945aafthe sessions case drives the one surface a capture provably cannot finish checking
Two cases: the note's date matched as a pattern and the row's call tree read as a subtree that grew, the popup resolving from the main window's root; the field count is WW253.
- WW252 · d7ac8adthe routine that explains why a locator found nothing throws when the element arrives while it is explaining
A chain that matches by the time the diagnosis walks it is a reading — a wait that was too short — rather than an index one past the end.
- WW250 · d7ac8ada case can say what a reading is and that it says something, and nothing in between
A step may name the shape of a reading it cannot name the value of, and a pattern matching the empty string is refused as
answerswearing a check. - WW247 · 385dd16three cases were moved to an in-process dialog on an inference that turned out to be false
The three false sentences are corrected to what was measured, and each says the dialog's reason is now WW248 rather than a rule about Windows.
- WW246 · b64111dthe window under test reads as nothing against a real window, so no act on it can ever own the foreground
An element with no handle of its own belongs to the window the run attached to, so synthesised input reaches a WPF application at all.
- WW245 · 315bbcethe hole about a refused foreground names who holds it and never what was wanted, so two faults read alike
Every absence about the foreground names both sides, so a hole says what it compared against and not only who answered.
- WW244 · a6b46e9an act that was never sent is invisible in the verdict where its step carries no expectation
An act that was never sent is a hole in the verdict whatever its step claimed, and the case stops there rather than reading a window nothing moved.
- WW243 · b64111dthe keyboard case has never run green: the click it opens with is never sent, and the red names the step after it
The case runs green once WW244 and WW246 land: three checks, nothing excused, against real keys on a real WPF window.
- WW242 · 1242872a language file named by its tag alone is invisible, so a project declares strings nothing ever reads
The tag walk reaches the first part of a file name, so
en.jsonis read;strings.jsonstill answers nothing, because that isCulture's job and never the index's. - WW241 · 1242872a sweep reads once and concludes, so it fails against a window that had not finished drawing
A sweep polls the resolve budget like any read, and one that gave up says so and whether the page was still showing the project's loading text.
- WW238 · d17805ano reading answers a label's words, so a case cannot check what a label says
A label's words are in its name, so
namereads them — refused where the locator matched on the name, because then the reading is fixed before the act runs. - WW237 · ffc833da case cannot say a reading answered at all, only what it answered
A step claims the reading it names says something rather than nothing, so a value the case cannot know is still a claim it can make.
- WW236 · bc6625ca case cannot check a derived set, so the criterion about them cannot be tried
A step covers a key and the set comes out of the project's own strings, so a string added to the file fails the case until the window carries it.
- WW235 · 43f574da timing case fails more often as the suite it runs in grows
The release runs on its own thread instead of the thread pool, and the hold is a checked fraction of the retry budget rather than a multiple of its sleep.
- WW234 · 6f73ff5WW226 drew a ranges pane for a verb four cases already drove
The pane stays for the scenario-level cases it suits, and nudge is proven on a trackbar this thread owns rather than in the process that cannot be driven.
- WW233 · 4d46314the roll says how many checks were excused and never which ones
Each excuse carries the case that made it, read off the stack, so eleven holes became a list somebody could act on rather than a number.
- WW232 · 6f73ff5eleven checks are excused on every green guest run, all for one condition
Every excuse left is one whose subject is the absent foreground: five, all deliberate, down from eleven.
- WW231 · da35247a case that excused itself is reported as a pass and counted as one
The roll says how many checks the desk excused and for which facts, so a green that covers 1,560 of 1,571 says so instead of claiming all of them.
- WW229 · 9c04fb3a case can expect a value and never that one moved
A step claims the reading moved without naming what it moved to, and an act nothing attempted is a hole in the verdict rather than a red.
- WW228 · 2990c7ean app project at the repository root compiles the driving project into itself
The adoption section names the one line an app at a repository root needs, and samples/Adopter carries a driving project underneath it so deleting the line goes red.
- WW227 · 5fbc5bcan adopting project can only run its cases on the desk somebody is using
The runner takes a tree, a name, a command and what to bring back, so an adopting repository runs its cases in the guest instead of on somebody's desk.
- WW226 · eb28cbdthe proving ground draws no range control, so an arrow key has nothing to move
A pane draws three ranges — room either way, already at the maximum, and no room at all — so nudge has a name in the vocabulary and three things driving it.
- WW225 · f05b19da case can name no synthesised input, so migrating one that proves input stops proving it
A case names four synthesised acts and reads what holds the focus, so the keyboard case's three assertions are all writable.
- WW224 · df203a9a block criterion names a surface the plugin never got
The criterion now names the three surfaces the plugin carries and says why there are no slash commands, so it covers nothing nobody intends to build.
- WW222 · 8b2abadnothing in a session runs a case, so the tools stop at would-load
A verb runs the cases a selection asks for and answers the verdict, and a desk that cannot observe answers a hole rather than a red.
- WW221 · 3bb1a26a fresh clone has the plugin's wiring and none of its tools
A launcher looks for the assembly and, finding none, names the missing surface and the build command on stderr instead of failing as a .NET error.
- WW220 · 03e119ba search misses an icon in a flyout that opened and had laid out somebody else's
A search that opened the flyout polls for the name it was given, so a stranger laid out first is no longer answered as this icon being absent from everywhere.
- WW219 · 03e119ba case needing four polls inside eighty milliseconds claims the guest is the application
The claim is made about the readings that happened, so a guest that fitted three polls proves it, and the stronger claim still holds on every run that saw the move.
- WW218 · 8e4240dthe dump the fixture writes reads as empty at five seconds and one millisecond
A whole file is filled beside the name and moved over it, so an existing dump is a finished dump, and a wait that ran out names the file that never arrived.
- WW217 · 03e119bthe tray cases go red about the shell on a guest that placed no icon and shut its own flyout
A desk placing no icon anywhere is a hole naming it, asked by a new reading after the search fails, and the second call of a pair is excused like the first.
- WW216 · 03e119ba project declaring nine attempts breaks every step instead of being refused once
Both ends of the cap Retry publishes are checked where the number is declared, so nine is refused once with the file named instead of thrown once per step.
- WW215 · c527aacan unshared run keeps every window it launched open until the last case ends
A case that owns its process gives it back when it finishes, so the criterion holds during the run and not only at the end of it.
- WW214 · 2743ca9a fixture two files both need is written twice and the second copy drifts
A fixture name resolves across the whole suite, so one launch is declared once, and a name two files declare is refused naming both before any case resolves against either.
- WW213 · 2743ca9a step that only reads has to borrow an act that means nothing
Reading is a verb: a read touches nothing, is never retried, expects something or is refused, and an element nothing drew is a failure naming the locator instead of a throw.
- WW79 · 95618c0the panes case proves a report is readable and needs no second profile
Two cases: the headers cover a derived set and run everywhere, and the body claims three readings behind a precondition this repository measures.
- WW69 · 7c456e0the skill is loaded on every turn against a budget it does not need
It loads on a window rather than every turn and says which loop answers which question, and both its costs are measured apart rather than assumed small.
- WW67 · f197cb4a hand-written harness script is the path of least resistance
A write naming the engine's acting, locating or asserting surface is denied and the refusal names the case file and winwright_check that replace it.
- WW66 · d678d09the schema of a case arrives as flag names typed from memory
The tools carry the loader's own schema as their input schema, so a misspelled key is unsendable and a case is read back before its file exists.
- WW65 · fc6b4cdadopting the tool is a per-machine install somebody has to remember
Two commands wire it and committing .claude/settings.json wires every clone, with the version its manifest carries read against the tree by the gate that compares the packages.
- WW63 · a91a6a4a scenario says what to do and never why it is worth doing
Each case carries the defect it exists to catch and the task it was filed under, and a run counts and names the cases that say nothing rather than leaving that to whoever last looked.
- WW62 · a91a6a4three cases driving the same window each pay their own launch
A shareable fixture two read-only cases want costs one launch where the invocation asks to share, and the first case through owns the window, so one run alone still owns its process.
- WW61 · a91a6a4a case with an absent precondition goes red for a reason about the desk it ran on
A case declares what the machine must have, an absent precondition makes every check in it unchecked and named, and a requirement nothing measured is refused.
- WW60 · a91a6a4a case that needs a fixture reaches for this machine instead
One declaration decides the launch and what the expectations are read from, and an environment reaching the launch nowhere — or twice — is refused before anything starts.
- WW59 · a91a6a4there is no way to run one case, or one file, without running the rest
Run takes a file, a case or a tag, names every case it did not run in the sentence it opens with, and refuses a selector that matches nothing rather than passing over none.
- WW58 · a91a6a4the format is a convention the author is asked to remember
Every field is judged where it is written: a key the format does not have is refused at its own address in the file, before the rest of it is read.
- WW57 · a91a6a4a case is two hundred lines of script that mostly repeats the previous case
A case is a data file — steps, locators, acts and expectations as fields — and CaseRun owns the loop, the waits, the attempts and which acts survive being repeated.
- WW212 · b9cb0b8nothing ties a fixture surface to the flag that justifies it, so one wired in without a flag carries no reason
Every fixture type is now a shape naming the flag whose reason justifies it or the plumbing saying why not, checked both ways — and the check named a shape I had filed under the wrong flag.
- WW211 · be3fa8fa fixture write slower than the budget this suite chose is a red about the fixture
A write that never landed inside the budget is now unchecked and says so, one that landed and read as nothing stays red, and the gate is its own because a slow machine is no desk fact.
- WW210 · a402458nothing checks a pattern act never reaches synthesised input, so a quiet fallback would go green
Filed expecting Act, Pick and Selecting to reach nothing; two of the three do, deliberately — so it is 14 verbs paired with how a caller learns, and Act alone asserted to reach none.
- WW209 · d34f6c3the verb catalogue says every verb the engine offers and reads two of its ten namespaces, with nothing saying why
The catalogue reads any engine file that touches the application, not two namespaces: 18 verbs an adopter can call, never asked what they need, and the README named 22 of 31 families.
- WW208 · b119719the list of desk-dependent calls is typed by hand, and a reading missing from it is a case nothing asks to excuse
The engine's surface is read for verbs that reach the desk and the list must name each: thirteen do, and the reading found a second call missing on the day it was written.
- WW207 · 16ed73bfour sweeps carry their own copy of the member walk and two of them get a tuple-returning member wrong
One walk beside the file walk, with the tuple fix the two older copies lacked — and it turned out all four read a field initialised by a call as a member.
- WW206 · f3c3dcathe sweep rule is checked per file, so a file holding two sweeps passes on the strength of the one that reads code
The unit is the sweep, so a file holding two is two: thirteen are found where eight files were, and the excuse list is empty rather than hand-written.
- WW205 · 585732cthe register stops what it started and cannot say when it is gone, so every caller needing that writes the wait
The register answers a three-state reading of stopped and gone, and the suite's copy of the wait is deleted rather than kept beside it.
- WW204 · e80f6c6a suite fixture threw away a desk reading and the case downstream reported the shell's refusal as the fixture failing
Seven discarded desk readings are paired with what downstream could be wronged by them, swept over every member rather than every case — which is where the one that cost a red lived.
- WW203 · 0cfd886two guest runs timed out six milliseconds past a five-second deadline waiting for the fixture to write its dump
One budget was covering a cold start, a layout and a write while the cold start alone is given twice as long; each caller now waits for the window first, checked.
- WW202 · 4f47c87three source sweeps still match raw text, and one of them is the twin of the catalogue just repaired for it
Four raw sweeps, not three — the fourth was found by the check this built, which is now what makes the fifth red rather than a repeat.
- WW201 · 2d238b0a case starts a process from a file it then deletes, so its own cleanup throws and the run reports a broken harness
Four classes deleted a binary they had started, not one; each now settles through a door, and a source-read check names the fifth rather than waiting for a guest run to.
- WW200 · ca96055the fixture's own refusal is eleven arms and the suite cannot see its types, so nothing pairs any of them
The fixture names its arm at the head of every refusal and prints the ten with its catalogue, so the suite pairs each against a real run rather than a type it cannot load.
- WW199 · 96576f1this block promises a fixture provokes every capture refusal, and four of the six arms are provoked by a case instead
The criterion now says what it keeps — every arm has something — and the gap narrowed first: a cloak shape closed the arm that turned out to be provokable after all.
- WW198 · 24e0c31the sleep catalogue matches one spelling of waiting, and a second is already in the tree that it counts as nothing
Six spellings of parking a thread are read as code rather than prose, which found the spin the catalogue described and never counted, and three files parked on a signal.
- WW197 · 989be48a case that excuses the desk once counts as excused for every assertion in it, including the ones that never were
An excuse now covers the desk fact of the reading it names and nothing else; the finer unit found five cases owing a reason and one owing the repair its own comment predicted.
- WW196 · 9bfd2b7five more refusals carry several arms each and the pairing counts each as one, so most arms are provoked by nobody
Four more refusals declare their arm and all thirty-two are paired one by one, read off the engine both ways; the judgement is recorded as arithmetic a check holds.
- WW195 · 3aa696ethe region is read before a capture and never after, so a window that arrived while it was taken is not seen
The region is read on both sides of the take, and a window that arrived inside it is a sixth refusal arm with its own sentence rather than a capture reported as clear.
- WW194 · b1f3df3a render is refused for a backdrop it cannot transmit, because the refusal keys on reach and not on the route taken
The backdrop refusal keys on the route taken, so an off-screen render is no longer refused for a hazard the compositor never reaches and a forced copy still is.
- WW193 · c1b14b9two source-read catalogues carry the same tree walk and a third is asked for, and the first got its exclusions wrong
One walk, with the trees, the exclusions and the caching: eighteen copies across sixteen files now ask Checkout, and a case reads the sources to prove none is left.
- WW192 · 9488bcba summary counts holes without saying which were the desk's, though the engine now declares which conditions are
Both headlines divide their holes into the desk's, this run's and unclassified, and every line says which it was — read off the engine's own declared conditions.
- WW191 · 5dbac17the third-state rule reaches only a suite reading that answers a verdict, and the defect it was written for did not
Two earlier boundaries read off the assembly: eight readings that swallow and answer a value, and the helper that narrows a three-state one, measured against WW181's kept signature.
- WW190 · 9b2cb2ca case asserting a desk-dependent verdict without excusing the desk is caught by a guest run and by nothing here
Every case asking the shell, the foreground or the focus is read out of the sources and paired with how it excuses the desk; sixteen did not, and a held desk now passes.
- WW189 · 4f8068ca search over a walk that ran out answers not showing, so a page too deep to reach reports as finished
A walk says how much it did not reach and a reading that found nothing in a short one is unchecked, while finding the string stays proof a truncated walk cannot argue with.
- WW188 · d613c1cone refusal type has five arms now and the pairing records one, so an arm added later is provoked by nobody
A refusal says which of its five arms it is, and each arm is paired with the fixture shape or the case that provokes it, checked against the engine both ways.
- WW187 · 18e29d1two capture refusals fire only where the caller remembered to take the reading, and nothing makes anyone take it
A capture taken through the door reads the region, the glass and the colours itself and refuses on any, asking only the questions the route it took can be hurt by.
- WW185 · 0e6ac84a sweep records what each environment concluded and nothing about the machine it ran on, which is what a sweep asks
Each environment carries the reading its own run took, the summary prints one for every machine that had something to explain, and a partial sweep names what it did not read.
- WW184 · 0e2f875eight files carry a sleep and nothing says which are the deadline machinery and which are a wait in disguise
Every file that calls it is paired with why its sleeping is not a scenario waiting, checked against the sources both ways, and the one that is still a wait is counted.
- WW183 · 0fd3a1ba case reds when somebody touches the machine, though the engine already calls that a desk fact and names it
The engine declares which conditions are the desk's and why each is, so the suite reads them instead of keeping a list that had already missed two.
- WW182 · 867c0ada suite reading invents its own shape instead of the engine's three-state Finding, and shipped able to say two things
The tray census answers the engine's Finding, and a suite reading that answers a verdict without one is red here, so the third state is a property of the type.
- WW181 · 50e06dbthe ghost census says none where the flyout would not open, so it reports a clean desk it never looked at
The census answers seen and clean, seen and holding, or not read, so a shell that would not open the flyout is a hole and never a desk this suite calls clean.
- WW180 · ca62adfa case counts two processes it launched a moment earlier and sees one, twice in eight guest runs
A candidate that will not say which binary it runs is still passed over and is now named, so a count of none is never a claim about a process nobody could read.
- WW179 · 00c0d92a desk fact met while building a fixture is thrown, so the case reads as a broken harness rather than a hole
A fixture the desk refused answers the reading an act answers and the case excuses itself, so a held desk produced nine ordinary failures and no broken harness at all.
- WW178 · b907b7athe fixture is claimed to need no account, no network and no second display, and nothing in the suite checks any of it
The fixture's sources are read back for a network, an account, a second display or a well-known folder, and its project for a package, so the criterion is a check.
- WW177 · 5f98d3bthe summary a run exits on never shows what the run read, so the readings and the verdict are two pages that never meet
The summary prints what the run read above the verdict it makes legible, and refuses a reading that opened a store fingerprint and never closed it.
- WW176 · b26f7d732 criteria decide when a block is finished and no case names evidence for any of them, so the reading is a recollection
Every criterion the roadmap declares is paired with the case that shows it, checked both ways, so what nothing shows is a counted bucket and finishing a block is a reading.
- WW175 · 303ffdaa deadline handed a look that never answers null returns on the first look, and nothing says the wait was skipped
Every deadline in both trees is catalogued with what its look answers as nothing, checked against the sources both ways, so a wait that cannot answer it is visible when written.
- WW174 · 8479ffda tray menu that never came up records Failed whether the code or the desk was at fault, and answers no verdict
A tray menu answers a verdict and a step that agree, so a shell hiding the icon or a desk refusing the focus is a hole and only a menu the icon never showed is red.
- WW173 · 87f3681a run that died with the desk owned leaves the notification area unusable, and the next run reds without saying why
Every run reads back what an earlier one left in the notification area and names it, so a shell holding icons from a run that died says so instead of four cases timing out.
- WW172 · 809508ca desk another window owns turns 32 cases red about the application, which is the confusion this tool exists to end
Every desk-dependent case resolves the hole its own act already answered, so a desk another window owns turned 32 reds into 3 instead of into 32 claims about the application.
- WW171 · dd925abthe cycle case declares a 200ms animation this harness cannot read that fast, so a guest run goes red about the desk
Three cases declare one length named for what this desk can read, and the sequence is measured off three looks a state, so a fixture cycling as asked no longer reds about the desk.
- WW170 · bfc45d2the store fingerprint's after half is called only by its own tests, so no run says what it left changed
Preamble.Around closes the fingerprint the same reading opened, so what a run left changed is reported beside the desk and the binary rather than by whoever remembered the second call.
- WW168 · a39933cfinding a tray icon answers null whether the icon is absent or the flyout simply would not open
Looking for a tray icon answers a reading that says whether every place was looked at, so an absent icon fails and a flyout that would not open is a hole about the desk.
- WW167 · b45e383forty reader-facing renderings and nothing pairs them with a case, so two shipped unasserted before anybody noticed
Every rendering the engine answers is paired with the case asserting its text, checked against the assembly both ways, so a new one starts unpaired and the suite says so.
- WW46 · ffc549fa change meant to be invisible has no cheap way to prove it was
Two renders are compared byte for byte with no tolerance chosen, and where they differ the answer says whether the picture changed with them or only the file did.
- WW43 · 2a9a831a page still computing is photographed and announced as a picture of a report
A project declares which keys are its loading strings, the text is resolved out of its own language files, and a key none of them carries refuses instead of matching nothing.
- WW42 · 44371d2a copy of exactly one colour is written and reported as a capture
Distinct colours are counted on any picture including the opaque copy the alpha scan cannot answer for, and a capture of exactly one is refused rather than reported.
- WW41 · 0d46429a window with a system backdrop transmits what is behind it through the glass
The compositor is asked which backdrop a window opted into, and a receipt handed that reading refuses rather than warns, exempting the popups the copy route exists for.
- WW40 · ffeb16fa copy trimmed around an intruder is a picture of something nobody asked for
A receipt handed a reading of what stood over the region refuses rather than accepting a cropped picture, naming the intruder, its process and the pixels it takes.
- WW38 · bb9fcc5sampled points cannot answer whether a region is covered
The z order above the window is enumerated and every frame intersected with the capture rectangle, so the answer is how many pixels are taken and by which named windows.
- WW166 · ca8d031a failed step's diagnosis is built by nobody, so a reader still writes a throwaway script to see what the window had
A red expectation carries the control view it failed to read, because Expect.Of is handed the subject rather than a function and reads the window the instant the deadline ran out.
- WW165 · 6c57cd5opening the notification overflow answers a bare bool, so a run that could not open it says only false
Working the overflow answers a reading with the reason, a hole rather than a red, and a step; and a rule keeps the rest of the block from answering yes or no where a failure has a cause.
- WW164 · a57fe6athe suite waits for the fixture's dumps to exist rather than to be written, so a half-written file reads as an empty one
The wait is on a dump that reads as a tree and a report holding a surface, and a file still being written answers false rather than throwing, so neither is read half-finished.
- WW163 · e45e852nine of sixteen results answer an assertion and no trace step, so a run's record loses the steps behind its verdict
Every result answering a verdict answers the step behind it, paired by reading the assembly, so a tenth added with one half fails rather than quietly narrowing what a trace covers.
- WW162 · 3690a9ethe cycle-length check divides by a sample count, so a slow reader reports 653ms a state against a declared 200
The check reads how often it looked and concludes nothing where that is slower than a state, and it measures between the first change and the last rather than across the whole watch.
- WW161 · bb41708a shape that ends in a refusal exits 3, and nothing a person or a case reads says so
A shape that ends in a refusal says which code it ends with, the codes are listed once where a person driving by hand meets them, and the suite reads the number off the article rather than a copy.
- WW160 · 5e58452twelve refusals claim a case builds what provokes them, and nothing checks that any such case exists
Every refusal no flag reaches names the case that provokes it, and the case is looked up in the suite rather than believed, so one renamed or deleted fails the pairing instead of shrinking it.
- WW159 · 7b31cdethe animation check demands every declared state inside a fixed window, and a loaded machine loses one
The animation is sampled by resolving one id rather than walking the tree, and until it has shown every state it declares, so a red names the states never seen rather than the reader's speed.
- WW157 · b3e4b66a person at the keyboard turns a run red, since nothing tells input this run synthesised from input it did not
Input this run synthesised is stamped where it leaves the process and compared against the machine's last, so a person at the keyboard is named as one rather than as a lost foreground.
- WW156 · 93d8147nothing reads the desk before a run starts, so a machine that cannot observe still produces results
The desk's six conditions join the preamble a runner already asks for, and a desk that cannot observe answers the whole run: measured without a session, exit 2 over one hole and no case result.
- WW155 · 16f05a7the menu reading names whatever holds the desk, so a walk can report an entry from another window
The focus is read against the application under test, so a walk or a traversal ending on another application's window is a hole naming what took the desk rather than a red about this one.
- WW154 · 50a0cb6nothing at the root tells an adopter what this is, what it refuses, or how to take it
A README at the root says what winwright is, what it needs, how an adopter takes it and what each exit code means, and a case holds it to the engine's own codes, verb families and non-goals.
- WW153 · 7572435the agreement report prints the +sha its own sentence drops, in a column too narrow to hold it
The report spells a version the way its own sentence does and names the build separately, in a column as wide as the widest thing in it, so every row lines up whatever a copy declares.
- WW152 · 5f2cfd5nothing reads the survivors a run had to stop, so the summary never names what outlived the scenario
The register answers what it had to stop as a finding for the run's own reading, and a register nobody stopped says the roll was never taken rather than that nothing outlived the run.
- WW151 · 64d4f79nothing a run calls takes the store fingerprint, so leaving the machine as it was is met by whoever remembers
The run's own reading takes the fingerprint and reports what moved as a finding, so a scenario that changed a setting says so and one that declared no store says that instead of nothing.
- WW150 · 15ff81btwo runs on one machine share one results directory, so each roll call reads the other run's files
The listing and the results land in a directory named for the run, so two runs on one machine cannot read each other's files and no second shell can manufacture a phantom shortfall.
- WW149 · 9ed23e4the roll call's own tests print roll call verdicts into the run, so the output carries sentences about nothing
The roll call writes where its caller says, so a run carries one verdict about itself and the cases assert the words a reader gets instead of leaking them above the real one.
- WW148 · ecb11bca destructive list can still be built from bare names by an overload that names no project and refuses nothing
The route that declines the language guard is named for what it gives up rather than spelled as an overload, so nothing reaches it by having strings rather than a project to hand.
- WW147 · 55385f2the one act that retries throws the attempt count away, so a third-attempt success reaches no trace
A restore keeps what its bounded press answered and offers it as a trace step, so a control that only comes round on the third go is a finding in the report rather than a green that hid it.
- WW146 · a470c3dfour refusals need a shape the fixture cannot take, so nothing will notice when they stop working
Three shapes the fixture could not take are flags now, so every refusal the framework names is provoked by driving it or by a case that builds one, and the bucket nothing could reach is empty.
- WW145 · 29e742ca pairing names the flag that reaches a refusal and nothing checks that the flag reaches it
Each of the four pairings naming a flag is a case that launches the fixture with it, drives the thing, and insists on that refusal by type, with a fifth entry failing until one exists.
- WW144 · 4254ccda rendered line hides its locator in the middle of a string, so every reader parses it back out by hand
Inspect.Rendered hands each line its locator step as a field, so both hand-written parsers are gone and the view under a red is the same rendering rather than a second one.
- WW143 · b0104d8the suite spells the engine's own waiting rule by hand eighteen times, and one of them is a bare sleep
Every hand-rolled wait loop is a deadline on a named condition through the engine's own Attempt, with the deadlines in one file; one sleep stays, measured and said.
- WW142 · 15b7d2ethe agreement check carries an exit code for a gate and no gate anywhere runs it
Continuous integration reads the tree's version, the assembly it loaded, both packages it built and the adopter's pinned reference, and exits 1 on any disagreement.
- WW141 · 694044enothing names which verbs need no cooperation, so a verb that starts needing the in-app half goes unnoticed
Every verb is catalogued against what it needs from the application, checked against the engine's surface, and those a bare window suffices for are driven against one.
- WW140 · 006e0abone transient COM error from UI Automation reads as a desk that cannot observe anything at all
An assembly that will not load is answered on the first look and a failed call is looked at again on a deadline, with a reading that needed two saying so.
- WW139 · 6896849a comment key in a strings file joins the derived set, so the expectation demands a window shows the comment
A derivation leaves out the keys that are notes rather than strings, and names how many of each reason it left out in the source sentence every verdict prints.
- WW138 · 2eeb059the roll call runs only when somebody types the script, so a plain dotnet test still prints the old pass
A bare dotnet test takes the roll and refuses in the roll's own words, skipping only where a filter made the run short on purpose.
- WW137 · 72920d0a test recorded as not executed counts as having answered, so the roll call passes a run that skipped them
The roll counts what executed, keeps what was recorded and never ran on its own line, and the exit code asks the roll rather than restating its rule.
- WW136 · b12f703nothing a run calls checks the declared pointer reasons, so a reason that went stale survives every run
The preamble carries findings beside its conditions, so a declared reason the tree disputes is printed where a reader already looks and excuses nothing.
- WW135 · 763952ca subject built from the timeouts alone carries no destructive list, so the guard depends on which constructor was typed
The bare-timeouts constructor is gone and the only one left takes a declaration, so the shape that gives the guard up is named for what it gives up.
- WW134 · af996daa destructive entry declared by name stops being refused once the application shows another language
An entry is declared by an automation id or by a strings key resolved in every language the project ships, and a bare name is refused where more than one is shipped.
- WW133 · a4495f3an input case on a busy desk fails about the code, because a refused foreground is not turned into a hole
Every input result answers with the third verdict, so a desk this run could not have is a hole naming the condition it lacked rather than a red about the application.
- WW132 · 246c67aseventeen refusals are named in the framework and the fixture can provoke six, with nothing saying which
Each refusal is paired with the flag that reaches it or the reason none can, checked against the assemblies and the flags the built fixture prints, with the four unreachable ones counted.
- WW131 · 6ec8dc6a themed control's own chrome is reported as laid out outside the thing containing it
The dump says who put each element there and the reading keeps a framework template's own faults apart, which left the fixture's window one finding about elements it declared instead of five.
- WW130 · 581d87ean element collapsed on purpose is reported as laid out and occupying nothing
The dump carries what the application set and the check leaves an element it is not showing alone, counting it in the sentence — which removed every such fault from the fixture's own window.
- WW129 · bbecdf7a stopped process is waited off the desktop and not out of the machine, so the next class starts on a busy one
The settle waits for the processes to have exited, and the suite went from a dozen unreproducible foreground failures on a busy run to three clean runs in a row.
- WW128 · bc91630the fixture takes the foreground every time it is launched, and the suite launches it constantly
Its windows are shown without activating, taking the full run from twelve foreground failures to one - and the one left over is the same one every time rather than a different set each run.
- WW127 · 79e65d2two checks read the live desktop root and assert about whatever the machine is showing
Both property checks read a control this suite made, and the desktop root keeps one reading that says what the engine does with an element it did not choose rather than what that element is.
- WW126 · 64b0837the suite gets flakier the more times it is run, so state is outliving the process that made it
A run's tray icon carries its own process id so a ghost from a killed run cannot be read as this one's, and windows are waited off the desktop rather than only stopped.
- WW125 · 71a11e3a test class that touches the desktop can be written outside the serial collection and nothing says so
Seven classes that put a window or a process in front of the machine now declare the serial collection, and a check reads the suite's own sources so the eighth cannot be written without one.
- WW124 · 1b4456fan automation id with a space in it renders as a locator step the grammar then refuses
An id is quoted when the grammar would not read the whole of it, a line break in a name is escaped rather than printed, and the property is checked against chrome nobody here wrote.
- WW123 · 18bbd0dnothing refuses a reference between the two halves, and one edit would merge them
The suite reads both project files and both built assemblies and refuses a reference either way, and the same rule is asserted of the fixture and the sample adopter.
- WW122 · 4e6fe98the in-app half is a project reference, so an adopter cannot pin it or take it at all
Both halves declare a package id and pack in continuous integration, a sample adopter compiles against the packed in-app half by one reference, and the agreement check reads the built package.
- WW121 · cf3eb5aa render says nothing about whether this process can see the display it drew on
The in-app half asks for per-monitor awareness at load and every receipt now carries what the process actually sees, so a size drawn in the wrong space says so instead of looking correct.
- WW119 · 109fd6cthe tray fixture returns before the shell has put the icon anywhere a test can find it
The tray fixture blocks until a reading finds the icon rather than until the shell takes the message, on the engine's own deadline, and shuts the flyout it opened to look.
- WW118 · b81155ea derived set can carry a placeholder value that no exact read will ever match
A derived set leaves out the strings carrying a placeholder and names them in the source sentence every verdict prints, and a key where none survives is refused rather than derived empty.
- WW117 · 6351b80a test host that dies mid-run still prints a pass
The run now takes a roll call: what discovery listed against what the results file recorded, counted per method, and a suite short of what it found exits non-zero instead of printing a pass.
- WW116 · 3139a1bnothing declares which entries are destructive, and invoke will press any of them
A project names what ends the run beside its executable, and the door every act passes through refuses those entries until a subject says MeaningIt once, where a reviewer reads it.
- WW115 · 58b7788a pointer act says what it clicks and never why the pattern route was unavailable
A pointer act now states why the pattern route was unavailable, the summary groups the cost by reason and names what a peer would remove, and preflight reads each claim back against the tree.
- WW113 · 0e2777cthe first line inspect prints is a locator step that matches nothing when it is used as one
Inspect marks the root as the root instead of printing it in the copyable shape, so every line still shaped like a locator is one that resolves — under a red too.
- WW112 · fb9e6aenothing makes an act go through the actionability check, so a verb that forgets it still runs
The live element is no longer public: an act reaches one only by being admitted, which resolves, judges the four and refuses first, so no verb can spell the skip.
- WW111 · d845350the suite's own window fixtures take the foreground from whoever is working at the machine
The fixtures that only read are created past every monitor, and the ones that act stay on the desk and say why - a window outside the monitors is one UI Automation calls offscreen.
- WW110 · c6f39f3nothing enumerates what a run measured, so a runner that forgets a precondition stops checking it
One reading takes all six conditions at once and renders the preamble a summary opens with, and a measurement it could not take is recorded as unread rather than left out.
- WW109 · 22abaf3a trace line that does not parse refuses without naming the file or the line it is on
A line that is not a step is refused by file, by line counted the way an editor counts, and by its own text cut to what a terminal shows - and a blank one is still skipped.
- WW108 · 7b5f018the summary names an assertion and the trace numbers a step, and nothing joins the two
One call writes the step and joins it: the result carries the ordinal and the step carries the assertion's name, so neither half can be recorded without the other.
- WW107 · 166ee3ba fixture is only ever driven by the framework that ships with it
Every shape that draws is launched and seen to open a window, the three that show nothing say so in the catalogue, and a person can ask for the window to come forward.
- WW106 · e9c85caa fixture that drifts from the products it stands in for is worse than none
Every shape carries the defect it reproduces and the catalogue prints it, with a check that no reason is a restatement of what the shape does rather than a record of what happened.
- WW105 · 5edeb15the catalogue of what the fixture can do lives only in its own source
The fixture prints its whole catalogue on request, and the list is checked both ways against the flags its own sources read, so neither a dead row nor an unlisted shape can survive.
- WW104 · 96fdab1a surface with no accessibility tree is only found inside an installer
The fixture draws a pane whose every element refuses an automation peer, so a locator resolves against nothing on it while the geometry dump reports all of it.
- WW103 · 606b6a0an intruder covering a rectangle has to be arranged by hand every time
The fixture puts a topmost window on exactly the rectangle a run names in physical pixels, so an intruder in the way and one in the way of nothing are both produced on demand.
- WW102 · 75b4a0ea localized window is needed to develop the label rule and no fixture has one
The fixture ships three language files and labels its window from the one a run asks for, including the key whose value carries a placeholder that an exact read can never match.
- WW101 · 0a1d73fthe surface protocol is implemented in one product and copied into the next
The fixture implements the whole in-app protocol and this suite drives it end to end, so an adopter has something to copy that is known current rather than current when copied.
- WW100 · 510d484the store a run must not touch belongs to whoever is running it
The fixture writes a store from constants and rewrites it to the same number of bytes on request, so the clean run and the caught mutation are both observable and nothing real is touched.
- WW99 · 7a179e2a second instance has to be started by hand to test the refusal that exists for it
The fixture opens a second windowed instance and a resident one showing nothing, so the refusal, the override beside it and the case that must never fire are all driven.
- WW98 · 0e78064a byte-identical render has nothing to be identical to
The fixture draws a surface with no clock, no machine name, no real data and no themed control, and renders it on request - so two renders of it are byte-identical.
- WW97 · 1aeef76an animation with a known length and a known frame count does not exist to capture
The fixture cycles states that announce their own place, so how many there are, what order they arrive in and how long each stands are all read off the window rather than typed.
- WW96 · 15bfb3fa page that is still loading cannot be produced when the check needs one
The fixture stays loading for a duration the run names and shows the note in the content's place, so both the refusal and the page that finishes inside the wait are driven.
- WW95 · bada8d6a borderless window with no main window handle exists in only one real product
The fixture raises a borderless captionless window on request, beside the main one or as the only one a run has, so a process the object reports nothing about is producible on demand.
- WW94 · fcbc904the backdrop refusal has only one arm to be tested against
The fixture opts a window into any of the four backdrops on demand and reads back what the compositor gave it, so a window that never asked is told apart from one that asked for nothing.
- WW93 · 74303aba collapsed pane, a popup and a submenu are three different kinds of absence
One flag puts a collapsed pane, a closed popup and an unopened submenu on one page, so the three absences the tree reports differently can be classified against a window rather than from memory.
- WW92 · a976199a control that announces nothing has to be found inside somebody else's product
One flag puts all five namings on one page - nothing, a glyph, an echoed id, a neighbouring label and a button that keeps its text - so the check has its whole case set on demand.
- WW91 · d0983eba window hosted under two different message pumps is the difference no picture can see
One flag ships the same window under a dispatcher that runs and one that never does, so a window that composes perfectly and answers no message is producible on demand.
- WW90 · 59e088devery refusal the framework makes is asserted only against a defect nobody can reproduce
The fixture takes flags and refuses one it does not know before the presentation stack starts, naming its whole catalogue, so a misspelt shape is a red exit rather than a silent default.
- WW89 · d65a89ethere is no window to develop against that is not somebody's shipping product
A WPF fixture belongs to this repository and the suite launches it, reads its tree and stops it, with nothing on it read off the machine it runs on.
- WW77 · 3a85c3ea surface with no accessibility tree can only be checked by reading its source
The application dumps every laid-out rectangle with its depth in physical pixels and the engine reads it back, so a surface with no accessibility tree is assertable without reading its source.
- WW76 · 948ee77the same single-threaded runner is copied into every test file that touches a control
One bounded runner rethrows what the work threw as itself, and this suite's own eight copies of it were deleted in the same commit, which is the saving stated as a deletion.
- WW75 · 6c3f909a popup closes the moment the window is raised to be photographed
The host walks the logical tree, holds every popup it finds open and puts each one back, so a closed popup is reached at all and no page has to remember the rule for itself.
- WW74 · e4dbd40the app knows what it drew and nothing asks it
The application writes a name and four physical-pixel numbers per surface and the engine reads them back, with a surface nobody reported answering as a named hole rather than a throw.
- WW73 · e1fa7c8a brush shared between capture threads belongs to whichever one reached it first
A brush handed to a capture is frozen as a copy or refused by name, with both threads stated, instead of the drawing raising an error that names neither the brush nor either thread.
- WW72 · 5dee74ca capture is rendered on no background and comes back unreadable
The application's own key is asked first and the observed window colour is the fallback, the classic palette is never consulted, and neither answering is stated rather than turned into white.
- WW71 · 1279159the render verb is written again in every project that wants one
One package renders a tree with no window shown - measure, arrange, update, target, background, encode - with the arrange inside, and a size of nothing refused rather than written as an empty file.
- WW70 · f1eeaaathree copies of the engine can be in play and quietly disagree
The copies in play are read together and answer agreed, behind or unpinnable, exiting non-zero on the two that are not agreement - and one copy nobody can pin makes the whole reading unpinnable.
- WW68 · d92c669a machine that can observe nothing reports a build failure
Six conditions are read before anything launches - session, desktop, display, coordinates, automation, foreground - and a desk lacking one excuses a check as a named hole instead of a red.
- WW64 · 64d4f0aan answer has to be verified by reading the file the command already read
Every answer carries where it came from as fields - file, line, key, element, pattern - so a missing header reads as strings.en.json:6 and the trace keeps it, rather than a reader opening the file.
- WW56 · e33ba21an assertion is trusted without ever being watched fail
A case declares the defects its check must catch and each one is run against it, so a check that stayed green with a declared defect in place is a red rather than a line that passes forever.
- WW55 · 45f0b2ediagnosing a failure costs a throwaway script that dumps the tree
A red carries the control view it had in hand - bounded, saying what it cut, marking the element the check read - so the dump that took a throwaway script arrives with the failure.
- WW51 · 906d6cea page renders correctly above a screenful of blank space and nothing notices
A dump is checked against itself for the four faults and measured for how much of the surface was drawn on, with every expectation derived from the dump rather than typed into a case.
- WW44 · d10c188nothing checks that a capture contains the surface it was taken for
A capture is asserted against the rectangle the application said it drew, telling clipped from elsewhere because they are two repairs, and a surface nobody reported is a hole rather than a red.
- WW35 · 5c4e5afa tree that failed to build writes a file that looks like a successful capture
A picture is scanned for any pixel carrying an alpha of its own, so a blank is a red - and one with no alpha channel to read is unchecked rather than passed, because that scan never ran.
- WW34 · fd073f8a screen copy can photograph anything that happens to be in the rectangle
A capture routes to the off-screen render by default and reaches the screen copy only for a menu, a balloon or an owned popup - or where a caller forced it and said why, which the receipt keeps.
- WW54 · a1f6a7fno reading and a window that was talking are reported with the same sentence
A read that ended with nothing says whether the window was working or blank, how many polls saw it, and what to look at, so only one of the two points at the deadline.
- WW53 · 2580deba run mutates the store of the user who launched it
The store is hashed around the case and every file, directory and variable that moved is named, so a rewrite of the same length and the same date is still caught.
- WW52 · ebf608da control announcing its glyph codepoint satisfies every check for a non-empty name
A name is read for what it is, so a glyph codepoint, an echoed automation id and an unfilled template each fail as themselves and print as escapes rather than as nothing.
- WW50 · d1163a8labels are matched in English against a window rendering another language
A label resolves to the language the window is rendering, a value carrying a placeholder is refused outright, and a language nobody declared strings for is named instead of answered in English.
- WW49 · e1e226ca hardcoded expected set silently stops covering what it was written for
Expected sets come from the project's own strings and never from the tree being asserted, and a key that declares nothing is refused rather than passing against an empty window.
- WW48 · cbf9d57an assertion is a boolean, so a failure says nothing about what was there instead
An expectation reports every reading it saw, the wait and the polls, so a subject that answered the wrong thing throughout is never reported as one that never answered.
- WW47 · f5cbff5a wrong capture is caught only because a person looked at the picture
A capture states the window, the process and the arguments behind it, and refuses outright when the window belongs to another process or nothing is drawing it.
- WW45 · 5006080an animation has no observable, so a transition ships unlooked-at
Frames land in slots computed from the first one and held against a stopwatch, so one slow capture costs its own frame and not the run, and the sequence reports the drift it measured.
- WW39 · fa997c6a window can be visible by its style bits and painted by nothing
Windows the compositor is not drawing are left out of a listing and carry the reason when one is asked for anyway, so a stock desktop stops reporting 12 intruders in 27 windows.
- WW37 · 2d9752fa capture is offset or scaled on any display that is not at one hundred percent
Per-monitor awareness is set when the engine assembly loads, so every rectangle and every synthesised click is in the space the window lives in on a display at any scaling.
- WW36 · 984dafba copy of the window rectangle carries a strip of the desktop down every edge
The extended frame bounds is what a capture copies, and the run prints the four trims, which on an overlapped window are eleven a side and none at the top.
- WW33 · 60b9e02an act leaves the window in a state the next case did not ask for
Surfaces are recorded as a case found them and put back on leaving the scope, only where they moved, and a restore that did not take is reported rather than assumed.
- WW32 · a1bd795a selection that silently does not land leaves the pane it should have built unrealised
A selection is confirmed against the control and a condition the caller names, the pointer is reached for only after that did not pass, and nothing reports a landing it did not confirm.
- WW31 · a458a95the notification-area icon has no clickable point and no reliable right-click
Icons are addressed by rectangle since every taskbar button refuses a clickable point, the overflow is opened through the chevron found by id, and the menu route is focus plus the application key.
- WW30 · c577a64a flaky act is hidden behind a retry that runs until it passes
Attempts are capped, a cap large enough to hide a failure is refused, and the count is stamped onto the trace step so a green that took three goes still says so.
- WW29 · cd5ef64a menu is driven by clicks a shell does not always deliver
A menu is entered with F10, walked with Down and expanded with Right against a polled deadline, nothing resets between attempts, and this surface has no invoke at all.
- WW28 · 4531785a picker walked to a value passes through every value on the way
A pick reports the route it took and every value it stopped on, and the keyboard walk anchors at whichever end is nearer so the count stays as small as the picker allows.
- WW27 · a53b9fckeyboard traversal has no observable at all
A traversal key answers with what holds the focus rather than whether it moved, and a nudge presses away from whichever end the range sits at and says it did.
- WW26 · 558f93btyping is asserted by a screenshot, which cannot see whether a key arrived
Text goes in as real keys and the act waits for the control's own value to say so, refusing a control that reports no value because typing nobody can read back is the screenshot.
- WW25 · 5d19a57a pointer act happens implicitly wherever a pattern was missing
A pointer act is its own declared kind that nothing falls back to, it sends nothing unless the window owns the foreground, and what needs a desktop is summarised from the declaration.
- WW24 · 35a0e5fan act needs the foreground, so a run started from an editor drives somebody else's window
Invoke, toggle, value, range, selection and expand each re-resolve, require actionability, act through the pattern and read back, proven with the foreground held elsewhere.
- WW23 · 8c2b3e5there is no way to ask what patterns an element actually offers
What an element offers is asked for by locator, and every declared act is checked against it before the run, refusing with the element and the pattern both named.
- WW22 · e585c51a resolved element goes stale and the act runs against a handle nobody holds
A subject holds a locator and never an element, resolving again per act, and every pattern is read into plain values so two readings either side of an act can differ.
- WW21 · 20dcd44two elements carrying the same name cannot be told apart by any condition
The grammar takes order=left, right, top or bottom and sorts matches by rectangle, and a step matching several without saying which is refused with what it matched.
- WW20 · 383de26a control missing because its pane is collapsed reads the same as one that is gone
A miss says whether the step matched elsewhere, whether what it stopped under is shut and must be opened, or that nothing in the window is shut and the control is gone.
- WW19 · 194a6fdthe control view only prints when a check has already failed
Inspect walks the control view of a live window and prints one line per element that begins with the locator step addressing it, then its rectangle, state and patterns.
- WW18 · 0f998eean act runs against an element that is present and not yet actionable
Presence, on screen, enabled and the pattern the act needs are judged over one snapshot, and the refusal names which of the four was missing with the remedy that is its own.
- WW17 · 23fc5f2a scenario sleeps because there is no way to wait for a condition
Once looks a single time and sleeps never, Until takes its deadline as a required argument and reports what it spent, and neither is reachable from the other.
- WW16 · 64d3c17an element is addressed by hand-built automation conditions at every call site
One grammar parses id, name, type, class, pattern, index and descendant chaining, round-trips, and refuses a control type or pattern UI Automation itself does not have.
- WW15 · eef92fca launch argument silently does not survive an attach
The language is resolved saved preference first and display language second, reported out loud with where it was read, and one asked for that the app is not in is a hole.
- WW14 · 2123bd3there is no way to drive a process somebody else started
Attach takes a pid or a window, names the binary it reached, and is its own type with no arguments to read, so a check needing one is a hole rather than a comparison.
- WW13 · b450380a synthesized key press goes to whatever owns the foreground, which is usually the editor
The foreground is asked once and answered as a met or absent precondition naming what holds it, and the type carries no wait, poll or retry for anything to route around it.
- WW12 · 3dcdd5aa second window of the app under test can sit on top of the one being driven
Only an instance showing a top-level window stops the run, and the refusal names each one and the override; a resident instance showing nothing is reported and never refused.
- WW11 · 9c17f5da borderless window is invisible to the launcher, because its main window handle stays zero
Top-level windows are enumerated by process id with a size floor, largest first, so an owned borderless popup the main window handle skips is found with its class, title and bounds.
- WW10 · 4166d0fattaching to a running instance checks whatever binary is up, not the one that was named
The running instance is identified by file version and then write time, and a mismatch becomes an absent precondition naming both, with the version difference preferred.
- WW9 · 18c4d93a build that failed leaves the previous exe in place and the run reports on code that is not in the tree
The binary's write time is compared against the newest source outside build output, and older yields an absent precondition carrying both stamps rather than a failure.
- WW8 · b7f4f5da case that returns early leaves its process running and locks the next build
A LaunchedProcess can only be made by the register, so an early return still stops the process, and whatever was alive at the end is named with its pid and whether it stopped.
- WW7 · 40cdbbca step that threw is indistinguishable from one that failed its assertion
A throw is recorded as a HarnessError carrying its step and exception, gives the run a fourth outcome that exits 3 and outranks the other three, and reads as threw in the trace.
- WW6 · f870dd0a summary can say every check passed while one of them never ran
The summary refuses the word while anything is unchecked and names what is on the list, and Coverage.RequireEvery is the gate an adopting project's own green asks first.
- WW5 · 80561c4every path, timeout and language file is typed into the scenario that needs it
A winwright.json found by walking up from the scenario carries the executable, source root, language files and timeouts, resolved against its own directory, and refuses by name what it omits.
- WW4 · c00e284the same unrun assertion is tallied once per environment a sweep walks
A sweep tallies each assertion once by name and keeps every occurrence under it, so one hole met in three environments reads as one hole and still prints three lines, each naming its environment.
- WW3 · 472ce5ba run records what it concluded and not what it observed
Each step is written as one JSONL line the moment it happens, carrying the locator, what it resolved to, the pattern, the read-back, the wait and the polls, flushed so a run that dies keeps it.
- WW2 · d2df0e5nothing separates an assertion that should have run from one this project can never observe
A hole is now constructed from an absent named precondition and from nothing else, and an assertion naming no subject, or a requirement no run measures, is refused when the scenario loads.
- WW1 · 0fbd8f2an assertion that could not be evaluated reports the same green as one that passed
A run reads as one of three outcomes whose enum values are the exit codes themselves - 0, 1, 2 - and the degraded summary names every assertion that never ran.
- WW552A Mica window whose picture is drawn by Direct3D has no capture route at all
A render of a page holding an HwndHost refuses, naming each hosted region and where it sits, instead of writing a picture with a hole.