browser-debugger-cli 0.9.0 → 0.10.0

package/dist/runtime/dom/actionEffects.d.ts

@@ -1,15 +1,16 @@
 /**
  * What a DOM action changed on the page: whether it navigated (to a new
- * document or within the same one), which messages appeared, and whether it
- * had no visible effect at all. Costs one page script sent before the action
- * (not waited for: CDP runs it before the action's own scripts) and one read
+ * document or within the same one), which messages and elements appeared,
+ * whether it had no visible effect at all, and whether the page was still
+ * working on the result. Costs one page script sent before the action (not
+ * waited for: CDP runs it before the action's own scripts) and one read
  * after it, plus a second look 300 ms later when nothing seemed to happen.
- * Worst case, when the page does not answer (a navigation is pending), the
- * snapshot is given up after {@link START_TIMEOUT_MS} and each read after
- * {@link READ_TIMEOUT_MS}.
+ * Worst case, when the page does not answer (a navigation is pending, or a
+ * long script runs), the snapshot is given up after {@link START_TIMEOUT_MS}
+ * and each read after {@link READ_TIMEOUT_MS}.
  */
 import type { CDPConnection } from '../../connection/cdp.js';
-import type { ActionEffects, NewMessage, PageNavigation } from '../../ipc/protocol/domTypes.js';
+import type { ActionEffects, NewMessage, PageNavigation, PendingChanges, ShownElement, TriggeredRequest } from '../../ipc/protocol/domTypes.js';
 import { type NavigationEvents } from './pageActivity.js';
 /** A message element as a page snapshot lists it */
 export interface SeenMessage {
@@ -19,6 +20,13 @@ export interface SeenMessage {
     element: string;
 }
 export type { NavigationEvents };
+/** Signs that the page was still working at a read (same document only) */
+export interface SettleSignals {
+    /** How long ago each recent burst of structural DOM changes was (ms, newest last) */
+    burstAges: number[];
+    /** A loading indicator shown since the action began, described */
+    loading: string | null;
+}
 /** The page after the action */
 export interface ReadSnapshot {
     href: string;
@@ -29,6 +37,25 @@ export interface ReadSnapshot {
     /** Why "no effect" can't be claimed even without changes */
     uncertain?: string;
     messages: SeenMessage[];
+    /** Whether the page was still working (same document only) */
+    settle?: SettleSignals;
+    /** Elements the action showed (when asked for) */
+    shown?: ShownElement[];
+}
+/** What collecting saw of the page's work, for {@link pendingChanges} */
+export interface PageWork {
+    /** Signals of the last read, when there was one in the same document */
+    settle?: SettleSignals;
+    /** The DOM kept changing in bursts over a second look ({@link domLooksBusy}) */
+    domChanging: boolean;
+    /** A read got no answer within its time (a long script) */
+    unresponsive: boolean;
+    /** A main-frame load was still pending */
+    navigating: boolean;
+}
+/** Effects, plus the page's work for deciding whether it had settled */
+export interface CollectedEffects extends ActionEffects {
+    work?: PageWork;
 }
 /** What the action did besides changing the page, for the "no effect" decision */
 export interface OtherActivity {
@@ -55,6 +82,50 @@ export interface OtherActivity {
  * @returns New messages
  */
 export declare function newMessages(before: SeenMessage[], after: SeenMessage[], newDocument: boolean): NewMessage[];
+/**
+ * Elements to report as shown: those whose text is not already reported as
+ * a new message, at most {@link MAX_SHOWN_ELEMENTS}, texts cut to
+ * {@link MAX_MESSAGE_LENGTH} characters.
+ *
+ * @param shown - Elements the page found shown by the action
+ * @param messages - New messages being reported
+ * @returns Elements to report
+ */
+export declare function shownElements(shown: ShownElement[], messages: NewMessage[]): ShownElement[];
+/**
+ * Whether a read's DOM looks busy, worth a second look: at least
+ * {@link BUSY_BURSTS} bursts of structural changes within
+ * {@link BUSY_WINDOW_MS}, the last within {@link BUSY_RECENT_MS}. Text-only
+ * changes (clocks) and style changes (animations) are not bursts.
+ *
+ * @param settle - Signals of the read
+ * @returns True when the DOM may still be changing
+ */
+export declare function domLooksBusy(settle: SettleSignals | undefined): boolean;
+/**
+ * Whether the DOM kept changing during the second look: at least
+ * {@link BUSY_BURSTS} new bursts within the time since the first read (a
+ * render that ends in two commits, or a poller updating once a second, does
+ * not count).
+ *
+ * @param settle - Signals of the second read
+ * @param sinceMs - Time since the first read
+ * @returns True when the DOM is still changing
+ */
+export declare function domKeptChanging(settle: SettleSignals | undefined, sinceMs: number): boolean;
+/**
+ * What the page was still working on when the action returned, or undefined
+ * when it looked settled: content requests (documents, fetch/XHR, scripts)
+ * still pending, a new document still loading, a loading indicator that
+ * appeared, a DOM still changing ({@link domKeptChanging}), or a page that
+ * did not answer (a long script). A result a timer renders later, with no
+ * DOM change before it, is not seen.
+ *
+ * @param work - What collecting saw
+ * @param requests - Requests the action triggered (with pending ones)
+ * @returns Pending work, or undefined
+ */
+export declare function pendingChanges(work: PageWork, requests?: TriggeredRequest[]): PendingChanges | undefined;
 /**
  * How the page's location changed: a new document committed in the main
  * frame (also when it has the URL it had, as after a form POST that
@@ -72,8 +143,8 @@ export declare function pageNavigation(startHref: string | undefined, read: Read
 /**
  * Whether an action had no visible effect: the page was read before and
  * after in the same document, it counted no DOM change, nothing made the
- * check uncertain, and no navigation, message, request, dialog or new window
- * happened.
+ * check uncertain, and no navigation, message, shown element, request,
+ * dialog or new window happened.
  *
  * @param read - Page read after the action
  * @param effects - Navigation and messages found
@@ -81,16 +152,24 @@ export declare function pageNavigation(startHref: string | undefined, read: Read
  * @returns True to report `effect: "none"`
  */
 export declare function hadNoEffect(read: ReadSnapshot | undefined, effects: ActionEffects, activity: OtherActivity): boolean;
+/** What collecting looks at besides navigation and messages */
+export interface CollectOptions {
+    /** Dialogs the action opened */
+    dialogs: number;
+    /** Decide "no effect" (with a second look when nothing seemed to happen) */
+    detectNoEffect: boolean;
+    /** List the elements the action showed */
+    reportShown?: boolean;
+    /** Take a second look when the DOM looks busy, to tell whether it is still changing */
+    detectUnsettled?: boolean;
+}
 /** Collects what changed, once the action and its wait are done */
 export interface ActionEffectsWatch {
     /**
-     * @param options - Dialogs the action opened, and whether to decide "no effect"
-     * @returns What changed
+     * @param options - Dialogs, and what to decide and list
+     * @returns What changed, and the page's work at the end
      */
-    collect(options: {
-        dialogs: number;
-        detectNoEffect: boolean;
-    }): Promise<ActionEffects>;
+    collect(options: CollectOptions): Promise<CollectedEffects>;
     /** Stop listening and stop the page's watch (always call) */
     dispose(): void;
 }

package/dist/runtime/dom/actionEffects.js

@@ -1,12 +1,13 @@
 /**
  * What a DOM action changed on the page: whether it navigated (to a new
- * document or within the same one), which messages appeared, and whether it
- * had no visible effect at all. Costs one page script sent before the action
- * (not waited for: CDP runs it before the action's own scripts) and one read
+ * document or within the same one), which messages and elements appeared,
+ * whether it had no visible effect at all, and whether the page was still
+ * working on the result. Costs one page script sent before the action (not
+ * waited for: CDP runs it before the action's own scripts) and one read
  * after it, plus a second look 300 ms later when nothing seemed to happen.
- * Worst case, when the page does not answer (a navigation is pending), the
- * snapshot is given up after {@link START_TIMEOUT_MS} and each read after
- * {@link READ_TIMEOUT_MS}.
+ * Worst case, when the page does not answer (a navigation is pending, or a
+ * long script runs), the snapshot is given up after {@link START_TIMEOUT_MS}
+ * and each read after {@link READ_TIMEOUT_MS}.
  */
 import { EFFECTS_READ_SCRIPT, EFFECTS_START_SCRIPT, EFFECTS_STOP_SCRIPT, } from './actionEffectsScripts.js';
 import { listenForActivity, } from './pageActivity.js';
@@ -16,6 +17,19 @@ import { getErrorMessage } from '../../utils/errors.js';
 const log = createLogger('dom');
 /** Messages reported per action */
 const MAX_NEW_MESSAGES = 3;
+/** Shown elements reported per action */
+const MAX_SHOWN_ELEMENTS = 3;
+/**
+ * Bursts of DOM changes that make the DOM look busy: at least this many
+ * within {@link BUSY_WINDOW_MS}, the last within {@link BUSY_RECENT_MS}
+ */
+const BUSY_BURSTS = 2;
+const BUSY_WINDOW_MS = 500;
+const BUSY_RECENT_MS = 150;
+/** Second look at a DOM that looked busy; it is still changing with {@link BUSY_BURSTS} new bursts by then (ms) */
+const STILL_CHANGING_RECHECK_MS = 250;
+/** Resource types of pending requests that mean more content is coming */
+const CONTENT_REQUEST_TYPES = new Set(['Document', 'XHR', 'Fetch', 'Script']);
 /** Longest message text reported */
 const MAX_MESSAGE_LENGTH = 120;
 /** How long collecting waits for the snapshot taken before the action */
@@ -90,6 +104,76 @@ function cutText(text) {
         return text;
     return `${characters.slice(0, MAX_MESSAGE_LENGTH - 1).join('')}…`;
 }
+/**
+ * Elements to report as shown: those whose text is not already reported as
+ * a new message, at most {@link MAX_SHOWN_ELEMENTS}, texts cut to
+ * {@link MAX_MESSAGE_LENGTH} characters.
+ *
+ * @param shown - Elements the page found shown by the action
+ * @param messages - New messages being reported
+ * @returns Elements to report
+ */
+export function shownElements(shown, messages) {
+    const reported = new Set(messages.map((message) => message.text));
+    return shown
+        .filter((element) => !reported.has(cutText(element.text)))
+        .slice(0, MAX_SHOWN_ELEMENTS)
+        .map((element) => ({ ...element, text: cutText(element.text) }));
+}
+/**
+ * Whether a read's DOM looks busy, worth a second look: at least
+ * {@link BUSY_BURSTS} bursts of structural changes within
+ * {@link BUSY_WINDOW_MS}, the last within {@link BUSY_RECENT_MS}. Text-only
+ * changes (clocks) and style changes (animations) are not bursts.
+ *
+ * @param settle - Signals of the read
+ * @returns True when the DOM may still be changing
+ */
+export function domLooksBusy(settle) {
+    if (!settle)
+        return false;
+    const recent = settle.burstAges.filter((age) => age <= BUSY_WINDOW_MS);
+    return recent.length >= BUSY_BURSTS && Math.min(...recent) <= BUSY_RECENT_MS;
+}
+/**
+ * Whether the DOM kept changing during the second look: at least
+ * {@link BUSY_BURSTS} new bursts within the time since the first read (a
+ * render that ends in two commits, or a poller updating once a second, does
+ * not count).
+ *
+ * @param settle - Signals of the second read
+ * @param sinceMs - Time since the first read
+ * @returns True when the DOM is still changing
+ */
+export function domKeptChanging(settle, sinceMs) {
+    if (!settle)
+        return false;
+    return settle.burstAges.filter((age) => age < sinceMs).length >= BUSY_BURSTS;
+}
+/**
+ * What the page was still working on when the action returned, or undefined
+ * when it looked settled: content requests (documents, fetch/XHR, scripts)
+ * still pending, a new document still loading, a loading indicator that
+ * appeared, a DOM still changing ({@link domKeptChanging}), or a page that
+ * did not answer (a long script). A result a timer renders later, with no
+ * DOM change before it, is not seen.
+ *
+ * @param work - What collecting saw
+ * @param requests - Requests the action triggered (with pending ones)
+ * @returns Pending work, or undefined
+ */
+export function pendingChanges(work, requests = []) {
+    const settle = work.settle;
+    const pendingRequests = requests.filter((request) => request.pending && CONTENT_REQUEST_TYPES.has(request.resourceType ?? '')).length;
+    const pending = {
+        ...(pendingRequests > 0 && { requests: pendingRequests }),
+        ...(work.navigating && { navigation: true }),
+        ...(settle?.loading && { loading: settle.loading }),
+        ...(work.domChanging && { domChanging: true }),
+        ...(work.unresponsive && { busy: true }),
+    };
+    return Object.keys(pending).length > 0 ? pending : undefined;
+}
 /**
  * How the page's location changed: a new document committed in the main
  * frame (also when it has the URL it had, as after a form POST that
@@ -122,8 +206,8 @@ export function pageNavigation(startHref, read, events) {
 /**
  * Whether an action had no visible effect: the page was read before and
  * after in the same document, it counted no DOM change, nothing made the
- * check uncertain, and no navigation, message, request, dialog or new window
- * happened.
+ * check uncertain, and no navigation, message, shown element, request,
+ * dialog or new window happened.
  *
  * @param read - Page read after the action
  * @param effects - Navigation and messages found
@@ -137,6 +221,7 @@ export function hadNoEffect(read, effects, activity) {
         read.uncertain === undefined &&
         effects.navigation === undefined &&
         (effects.messages ?? []).length === 0 &&
+        (effects.shown ?? []).length === 0 &&
         activity.requests === 0 &&
         activity.dialogs === 0 &&
         !activity.opened);
@@ -155,6 +240,7 @@ export function watchActionEffects(cdp) {
         listener: listenForActivity(cdp),
         start: evaluate(cdp, EFFECTS_START_SCRIPT),
         stopConfirmed: false,
+        unresponsive: false,
     };
     return {
         collect: (options) => collectEffects(watch, options),
@@ -163,28 +249,82 @@ export function watchActionEffects(cdp) {
 }
 /**
  * What changed: the navigation (from CDP events even without a snapshot),
- * new messages and, when asked, "no effect" after a second look.
+ * new messages, shown elements when asked, "no effect" after a second look
+ * when asked, and the page's work at the end.
  *
  * @param watch - The action's watch
- * @param options - Dialogs the action opened, and whether to decide "no effect"
+ * @param options - Dialogs, and what to decide and list
  * @returns What changed
  */
 async function collectEffects(watch, options) {
-    const start = await raceTimeout(watch.start, START_TIMEOUT_MS);
-    if (!start)
-        return effectsOf(undefined, undefined, watch.listener.events);
-    let snapshot = await readPage(watch, false);
+    const start = await awaitStart(watch);
+    if (!start) {
+        return { ...effectsOf(undefined, undefined, watch.listener.events), work: pageWork(watch) };
+    }
+    const reportShown = options.reportShown === true;
+    let snapshot = await readPage(watch, { stop: false, reportShown });
     let effects = effectsOf(start, snapshot, watch.listener.events);
     const quiet = () => hadNoEffect(snapshot, effects, { ...watch.listener.activity(), dialogs: options.dialogs });
-    if (!options.detectNoEffect || !quiet())
-        return effects;
-    await delay(NO_EFFECT_RECHECK_MS);
-    snapshot = await readPage(watch, true);
-    effects = effectsOf(start, snapshot, watch.listener.events);
-    return quiet() ? { ...effects, effect: 'none' } : effects;
+    if (options.detectNoEffect && quiet()) {
+        await delay(NO_EFFECT_RECHECK_MS);
+        snapshot = await readPage(watch, { stop: true, reportShown });
+        effects = effectsOf(start, snapshot, watch.listener.events);
+        if (quiet())
+            effects = { ...effects, effect: 'none' };
+    }
+    const domChanging = options.detectUnsettled === true && (await stillChanging(watch, snapshot));
+    return { ...effects, work: pageWork(watch, snapshot, domChanging) };
+}
+/**
+ * The snapshot taken before the action, waiting at most
+ * {@link START_TIMEOUT_MS}; a snapshot still unanswered then (and no
+ * navigation pending) marks the page unresponsive.
+ *
+ * @param watch - The action's watch
+ * @returns The snapshot, or undefined
+ */
+async function awaitStart(watch) {
+    const started = await raceTimeout(watch.start.then((value) => ({ value })), START_TIMEOUT_MS);
+    if (!started)
+        watch.unresponsive = !watch.listener.navigationPending();
+    return started?.value;
+}
+/**
+ * Whether the DOM is still changing: when the last read looked busy
+ * ({@link domLooksBusy}), a second read {@link STILL_CHANGING_RECHECK_MS}
+ * later must see it keep changing ({@link domKeptChanging}).
+ *
+ * @param watch - The action's watch
+ * @param snapshot - Last read, if any
+ * @returns True when the DOM kept changing
+ */
+async function stillChanging(watch, snapshot) {
+    if (!domLooksBusy(snapshot?.settle))
+        return false;
+    const firstRead = Date.now();
+    await delay(STILL_CHANGING_RECHECK_MS);
+    const recheck = await readPage(watch, { stop: false, reportShown: false });
+    return domKeptChanging(recheck?.settle, Date.now() - firstRead);
+}
+/**
+ * The page's work as the last read and the CDP events saw it.
+ *
+ * @param watch - The action's watch
+ * @param snapshot - Last read, if any
+ * @param domChanging - Whether the DOM kept changing over a second look
+ * @returns Page work
+ */
+function pageWork(watch, snapshot, domChanging = false) {
+    return {
+        ...(snapshot?.settle && { settle: snapshot.settle }),
+        domChanging,
+        unresponsive: watch.unresponsive,
+        navigating: watch.listener.navigationPending(),
+    };
 }
 /**
- * Navigation and new messages from the snapshots and CDP events.
+ * Navigation, new messages and shown elements from the snapshots and CDP
+ * events.
  *
  * @param start - Snapshot before the action, if taken
  * @param snapshot - Read after the action, if taken
@@ -194,26 +334,32 @@ async function collectEffects(watch, options) {
 function effectsOf(start, snapshot, events) {
     const navigation = pageNavigation(start?.href, snapshot, events);
     const messages = start && snapshot ? newMessages(start.messages, snapshot.messages, snapshot.fresh) : [];
+    const shown = shownElements(snapshot?.shown ?? [], messages);
     return {
         ...(navigation && { navigation }),
         ...(messages.length > 0 && { messages }),
+        ...(shown.length > 0 && { shown }),
     };
 }
 /**
  * Read the page after the action, unless a main-frame load is pending (the
  * read would wait for the new page). A stopping read that answered stops the
- * page's watch, so disposing need not.
+ * page's watch, so disposing need not. A read that got no answer in time
+ * marks the page unresponsive.
  *
  * @param watch - The action's watch
- * @param stop - Also stop the page's watch
+ * @param options - Also stop the page's watch; list shown elements
  * @returns The read, or undefined
  */
-async function readPage(watch, stop) {
+async function readPage(watch, options) {
     if (watch.listener.navigationPending())
         return undefined;
-    const expression = `(${EFFECTS_READ_SCRIPT})(${stop})`;
-    const snapshot = await raceTimeout(evaluate(watch.cdp, expression), READ_TIMEOUT_MS);
-    if (stop && snapshot)
+    const expression = `(${EFFECTS_READ_SCRIPT})(${options.stop}, ${options.reportShown})`;
+    const answer = await raceTimeout(evaluate(watch.cdp, expression).then((value) => ({ value })), READ_TIMEOUT_MS);
+    if (!answer)
+        watch.unresponsive = !watch.listener.navigationPending();
+    const snapshot = answer?.value;
+    if (options.stop && snapshot)
         watch.stopConfirmed = true;
     return snapshot;
 }

package/dist/runtime/dom/actionEffectsScripts.d.ts

@@ -1,7 +1,8 @@
 /**
  * Page scripts behind the "what changed" part of DOM action results: one
  * snapshot before the action ({@link EFFECTS_START_SCRIPT}) and one read after
- * it ({@link EFFECTS_READ_SCRIPT}).
+ * it ({@link EFFECTS_READ_SCRIPT}), plus the snapshot a hover takes of what
+ * is hidden around its target ({@link REVEAL_SNAPSHOT_JS}).
  */
 /**
  * Page-side test whether an element is part of a message's chrome rather
@@ -10,12 +11,43 @@
  * not `closeable`, `enclosed` or `disclosure`).
  */
 export declare const MESSAGE_CHROME_JS = "(node) => {\n  const closer = /(^|[-_\\s])(close|dismiss)($|[-_\\s])/i;\n  return node.getAttribute('aria-hidden') === 'true' ||\n    /^(button|script|style|template)$/.test(node.localName) ||\n    node.getAttribute('role') === 'button' ||\n    closer.test(node.getAttribute('class') || '') ||\n    closer.test(node.getAttribute('aria-label') || '');\n}";
+/**
+ * Page-side snapshot a hover takes right before the mouse moves (called by
+ * the click script with the hovered element): the elements around it (its
+ * parent and everything in it) and the tooltips, menus, listboxes, dialogs
+ * and popovers anywhere on the page that are hidden, at most
+ * {@link MAX_REVEAL_CANDIDATES} looked at within {@link REVEAL_BUDGET_MS}.
+ * They are kept by identity in the action's watch, so its read can tell
+ * which of them the hover revealed, also through CSS `:hover` rules that
+ * change no DOM, and elements moving in the page can't pass for revealed
+ * ones. Does nothing without a running watch (another frame).
+ */
+export declare const REVEAL_SNAPSHOT_JS: string;
+/**
+ * Page-side list of the elements an action showed: elements added during
+ * the watch inside the target's container ({@link NEAR_SCOPE_JS}) or, anywhere,
+ * popups and messages (tooltip, menu, listbox, dialog, alert and status
+ * roles, `aria-live`, message-like classes), plus, after a hover, the
+ * elements hidden before it that are shown now ({@link REVEAL_SNAPSHOT_JS}).
+ * Background widgets elsewhere on the page do not count. Only shown ones
+ * with visible text count, the outermost of nested ones, and not those
+ * whose text a removed element had (a re-render). At most
+ * {@link MAX_SHOWN}, within {@link SHOWN_BUDGET_MS}.
+ */
+export declare const SHOWN_ELEMENTS_JS: string;
 /**
  * Page-side test whether a mutation is only focus/hover churn: a class
  * change on an element the action's events hit (`targets`) that only adds
  * or removes classes containing "focus" or "hover".
  */
 export declare const CHURN_ONLY_JS = "(record, targets) => {\n  if (record.type !== 'attributes' || record.attributeName !== 'class' || !targets.has(record.target)) return false;\n  const tokens = (text) => new Set((text || '').split(/\\s+/).filter(Boolean));\n  const before = tokens(record.oldValue);\n  const after = tokens(record.target.getAttribute('class'));\n  const changed = [...before].filter((c) => !after.has(c)).concat([...after].filter((c) => !before.has(c)));\n  return changed.every((c) => /focus|hover/i.test(c));\n}";
+/**
+ * Page-side test whether a mutation changes the page's structure or state
+ * rather than only animating it: elements added or removed, or an attribute
+ * other than `style` changed. Text-only changes (clocks, counters) and style
+ * changes (script-driven animations) do not count.
+ */
+export declare const STRUCTURAL_CHANGE_JS = "(record) => {\n  if (record.type === 'attributes') return record.attributeName !== 'style';\n  if (record.type !== 'childList') return false;\n  const element = (node) => node.nodeType === 1;\n  return Array.from(record.addedNodes).some(element) || Array.from(record.removedNodes).some(element);\n}";
 /**
  * Page-side reason why "no effect" can't be claimed even without DOM
  * changes, or undefined: `clipboard` (a copy or cut happened), `no-event`
@@ -29,22 +61,28 @@ export declare const CHURN_ONLY_JS = "(record, targets) => {\n  if (record.type
 export declare const UNCERTAIN_JS = "(state, active) => {\n  if (state.copied) return 'clipboard';\n  if (state.targets.size === 0) return 'no-event';\n  const controls = /^(input|select|textarea|option|label|canvas|video|audio|iframe|embed|object)$/;\n  for (const node of state.path) {\n    if (controls.test(node.localName) || node.isContentEditable) return 'control';\n    if (node.hasAttribute('popovertarget') || node.hasAttribute('commandfor')) return 'control';\n    if (node.localName === 'a' && node.hasAttribute('href')) {\n      if (node.hasAttribute('download') || (node.target && node.target !== '_self')) return 'new-window';\n      if (!/^https?:$/.test(node.protocol)) return 'external-link';\n    }\n  }\n  for (const node of state.targets) if (node.localName.includes('-') && !node.shadowRoot) return 'closed-shadow';\n  const plain = (node) => /^(body|button|summary)$/.test(node.localName) ||\n    (node.localName === 'a' && node.hasAttribute('href')) ||\n    (node.localName === 'input' && /^(button|submit|reset)$/i.test(node.type || ''));\n  if (active && active !== state.focus && !plain(active)) return 'focus';\n  return undefined;\n}";
 /**
  * Snapshot before an action, left in `window.__bdgEffects`: the messages
- * shown, and a MutationObserver (on the document, its open shadow roots and
- * any shadow root attached while watching, which also counts as a change)
- * counting changes other than {@link CHURN_ONLY_JS}. Capture listeners
- * record which elements the action's events reached, copy/cut events, and
- * the scroll position at the first press (a click scrolls its target into
- * view first). The watch stops itself after {@link MAX_WATCH_MS}, so a
- * snapshot that ran late (after a navigation, with nobody reading it)
- * leaves nothing behind. Evaluates to the URL and the messages.
+ * and loading indicators shown, and a MutationObserver (on the document,
+ * its open shadow roots and any shadow root attached while watching, which
+ * also counts as a change) counting changes other than
+ * {@link CHURN_ONLY_JS}, keeping the elements added and removed and the
+ * times of {@link STRUCTURAL_CHANGE_JS} bursts. Capture listeners record
+ * which elements the action's events reached, the first key press's target,
+ * copy/cut events and the scroll position at the first press (a click
+ * scrolls its target into view first). The watch stops itself after
+ * {@link MAX_WATCH_MS}, so a snapshot that ran late (after a navigation,
+ * with nobody reading it) leaves nothing behind. Evaluates to the URL and
+ * the messages.
  */
 export declare const EFFECTS_START_SCRIPT: string;
 /**
- * Read after an action (call with `true` to also stop watching): the URL,
- * the messages shown and, when the snapshot is still there (same document),
- * the number of changes counted (plus one when the page scrolled after the
- * press) and why "no effect" could not be claimed ({@link UNCERTAIN_JS}).
- * `fresh` means a new document (everything shown is new).
+ * Read after an action, called with `(stop, shown)`: `stop` also stops
+ * watching, `shown` lists the elements the action showed
+ * ({@link SHOWN_ELEMENTS_JS}). Returns the URL, the messages shown and,
+ * when the snapshot is still there (same document), the number of changes
+ * counted (plus one when the page scrolled after the press), why "no
+ * effect" could not be claimed ({@link UNCERTAIN_JS}) and whether the page
+ * is still working ({@link SETTLE_JS}). `fresh` means a new document
+ * (everything shown is new).
  */
 export declare const EFFECTS_READ_SCRIPT: string;
 /** Stops the watch {@link EFFECTS_START_SCRIPT} left (when no read stopped it) */