How to self-healing tests when half the flake isn't a selector at all.

They assume self-healing means selector heal. Every top SERP result for this query (BrowserStack, Wopee, Healenium, Mabl, TestDino, Ministry of Testing) defines self-healing as 'an AI proposes a new CSS or XPath when the old one breaks'. That's only half the problem. The other half is timing flake: the click landed correctly, but the assertion fired before the React panel finished hydrating, or the streaming AI response was still arriving, or the toast had not animated in. A test that retries the selector against a half-rendered page is still red. Self-healing has to address both axes, and the second one rarely shows up in vendor copy because it doesn't sell licences.

Two distinct kernels run in two distinct phases. Selector kernel: the catch block at assrt-mcp/src/core/agent.ts lines 1012-1019 catches every tool error, calls `await this.browser.snapshot()`, slices the result to 2,000 characters, and inlines that slice into the next tool_result string with the literal instruction 'Please call snapshot and try a different approach.' The model's next turn sees the failure cause and the updated page in the same message. Timing kernel: the wait_for_stable case at lines 956-1009 injects `new MutationObserver(...)` into the live page via `await this.browser.evaluate(...)`, polls `window.__assrt_mutations` every 500ms, declares the page stable after `stable_seconds` of no new mutations (default 2, max 10), hard-caps at `timeout_seconds` (default 30, max 60), and tears down both globals. Together: ~60 lines of MIT Node, one file, no SaaS.

networkIdle resolves on a network condition. It does not resolve on rendering. A SPA that keeps a websocket warm, an analytics beacon firing every 5s, or a long-poll never reach idle, so networkIdle either times out or resolves at the wrong moment. The MutationObserver resolves on a render condition. It counts every childList, subtree, and characterData mutation across `document.body` and waits for `stable_seconds` of zero new mutations. Streaming AI responses, hydration, framer-motion transitions, and React Suspense boundaries all stop mutating the DOM eventually; the network may never. The observer is wired with the exact options at agent.ts:968-970: `{ childList: true, subtree: true, characterData: true }`.

Open `node_modules/@assrt-ai/assrt/dist/core/agent.js` after `npm install @assrt-ai/assrt`, or read the source at `assrt-mcp/src/core/agent.ts` on GitHub. Lines 962-994 are: an evaluate call that installs `window.__assrt_observer = new MutationObserver(...)` listening on `document.body`; a 500ms poll loop that reads `window.__assrt_mutations`, resets `stableSince` whenever the count changes, and breaks when `stableSince` is older than `stable_seconds`; and a second evaluate call that disconnects the observer and deletes both globals. The whole thing is 33 lines of Node. No external service, no AI roundtrip, no stored state on disk after the call returns.

You usually don't have to. The system prompt at agent.ts lines 249-254 tells the agent to call `wait_for_stable` after triggering async actions, so a #Case that reads 'Send the message and verify the AI response contains "hello"' typically results in the agent calling `send → wait_for_stable → snapshot → assert`. If you want to be explicit, write `Wait for the page to stabilise.` as a step in your #Case and the model will dispatch wait_for_stable. If you want to override the defaults, the agent currently picks them from the tool input; the maximums are hard-coded at agent.ts:957-958 and cannot exceed 60s/10s respectively.

Yes. assrt-mcp is MIT-licensed on npm as `@assrt-ai/assrt` and on GitHub under the assrt-ai org. The heal logic lives in one file: `src/core/agent.ts`. The selector-heal catch block is 6 lines (1014-1019). The timing-heal kernel is 33 lines (962-994). The snapshot truncation cap that bounds both is one constant: `SNAPSHOT_MAX_CHARS = 120_000` at `src/core/browser.ts:523`. After install you can `grep -n 'MutationObserver' node_modules/@assrt-ai/assrt/dist/core/agent.js` and read the exact bytes that ship.

Because the heal is implementation, not IP. There is no proprietary algorithm to charge for; the timing kernel is a MutationObserver and a poll loop; the selector kernel is a catch block and a string concat. Vendors charge for the SaaS surface around it: dashboards, audit logs of selector rewrites, role-based access, multi-tenant cloud runners, support contracts. Those are valuable to large enterprises and irrelevant to a developer who wants their CI to stop being red. Assrt ships the heal kernels with a free MCP, runs in your own Chrome, writes results to /tmp on your machine. Cloud sync to app.assrt.ai is opt-in.

Two functions, ~30 lines. First, `installObserver(page)` runs a `page.evaluate` that creates `window.__assrt_observer = new MutationObserver(m => window.__assrt_mutations += m.length)` on `document.body` with `{childList:true, subtree:true, characterData:true}`. Second, `waitForStable(page, {stableMs=2000, timeoutMs=30000})` polls `await page.evaluate('window.__assrt_mutations')` every 500ms, records `stableSince` whenever the count changes, and resolves when `Date.now() - stableSince >= stableMs` or rejects on timeout. Add `await waitForStable(page)` after every async-triggering click in your spec and the timing-flake half of self-healing is solved without any vendor.

A fixed timeout pays the same wait cost on every run regardless of whether the page is fast or slow. The MutationObserver pays only the wait it needs: if the page settles in 600ms, the call returns in 600ms; if it takes 8s, the call returns in 8s; if it never settles, it caps at the timeout. On a 20-step scenario with 6 wait points, fixed timeouts add ~12s; the observer typically adds 3-5s. The bigger payoff is correctness, not speed: a fixed timeout silently swallows late-arriving content that mutates the DOM after the wait elapsed; the observer catches it.

No. The cleanup phase at agent.ts:990-994 disconnects the observer and deletes both `window.__assrt_observer` and `window.__assrt_mutations` globals via a second evaluate call. The whole timing-heal call returns the page to its pre-call state on `window`. Even if a test crashes mid-heal, the observer disconnects automatically when the page navigates or unloads. Net memory cost during the heal: one MutationObserver and one number on `window`. Net cost after: zero.