browser-debugger-cli 0.7.2 → 0.9.0

package/dist/runtime/dom/actionEffects.js

@@ -0,0 +1,256 @@
+/**
+ * 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
+ * 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}.
+ */
+import { EFFECTS_READ_SCRIPT, EFFECTS_START_SCRIPT, EFFECTS_STOP_SCRIPT, } from './actionEffectsScripts.js';
+import { listenForActivity, } from './pageActivity.js';
+import { createLogger } from '../../ui/logging/index.js';
+import { delay, raceTimeout } from '../../utils/async.js';
+import { getErrorMessage } from '../../utils/errors.js';
+const log = createLogger('dom');
+/** Messages reported per action */
+const MAX_NEW_MESSAGES = 3;
+/** Longest message text reported */
+const MAX_MESSAGE_LENGTH = 120;
+/** How long collecting waits for the snapshot taken before the action */
+const START_TIMEOUT_MS = 200;
+/** How long a read after the action may take before its part is skipped */
+const READ_TIMEOUT_MS = 250;
+/** Second look before claiming "no effect" (late timers, animations) */
+const NO_EFFECT_RECHECK_MS = 300;
+/**
+ * Texts that tick on their own (clocks, counters, countdowns, percentages):
+ * digits with separators and at most a time unit, e.g. `12:04:33`, `57%`,
+ * `3 s`. Their changes are not reported as new messages.
+ */
+const TICKING_TEXT = /^[\d\s:.,/%+\-–—()]*\d[\d\s:.,/%+\-–—()]*(ms|s|sec|secs|min|mins|h|am|pm)?$/i;
+/**
+ * Messages that are new after the action: all of them after a new document
+ * loaded; otherwise those whose text is shown more often than before (a
+ * re-rendered message with the same text is not new) and those whose
+ * element changed its text. Texts that tick on their own
+ * ({@link TICKING_TEXT}: clocks, counters) are left out; other elements
+ * that change on their own (a rotating banner) are not recognised. Each text
+ * is reported once, at most {@link MAX_NEW_MESSAGES}, cut to
+ * {@link MAX_MESSAGE_LENGTH} characters.
+ *
+ * @param before - Messages before the action
+ * @param after - Messages after the action
+ * @param newDocument - Whether a new document loaded
+ * @returns New messages
+ */
+export function newMessages(before, after, newDocument) {
+    const countTexts = (messages) => {
+        const counts = new Map();
+        messages.forEach(({ text }) => counts.set(text, (counts.get(text) ?? 0) + 1));
+        return counts;
+    };
+    const beforeCounts = countTexts(before);
+    const afterCounts = countTexts(after);
+    const textBefore = new Map(before.map((message) => [message.id, message.text]));
+    const isNew = (message) => {
+        if (newDocument)
+            return true;
+        const previous = textBefore.get(message.id);
+        if (previous === message.text)
+            return false;
+        if (previous !== undefined)
+            return true;
+        return (afterCounts.get(message.text) ?? 0) > (beforeCounts.get(message.text) ?? 0);
+    };
+    const reported = new Set();
+    const result = [];
+    for (const message of after) {
+        if (result.length >= MAX_NEW_MESSAGES)
+            break;
+        if (reported.has(message.text) || TICKING_TEXT.test(message.text))
+            continue;
+        if (!isNew(message))
+            continue;
+        reported.add(message.text);
+        result.push({ text: cutText(message.text), element: message.element });
+    }
+    return result;
+}
+/**
+ * Cut a text to {@link MAX_MESSAGE_LENGTH} characters, marking the cut.
+ *
+ * @param text - Text
+ * @returns Text of at most that length
+ */
+function cutText(text) {
+    const characters = Array.from(text);
+    if (characters.length <= MAX_MESSAGE_LENGTH)
+        return text;
+    return `${characters.slice(0, MAX_MESSAGE_LENGTH - 1).join('')}…`;
+}
+/**
+ * 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
+ * redirects back), or a same-document URL change (history API, hash).
+ *
+ * Without the URL before the action, a same-document change is reported
+ * only when Chrome announced one.
+ *
+ * @param startHref - URL before the action (undefined when not read)
+ * @param read - Page read after the action (undefined when not read)
+ * @param events - Main-frame navigation events
+ * @returns Navigation, or undefined when the location did not change
+ */
+export function pageNavigation(startHref, read, events) {
+    if (events.document) {
+        const status = events.statusByLoader.get(events.document.loaderId);
+        return {
+            url: read?.href ?? events.document.url,
+            sameDocument: false,
+            ...(status !== undefined && { status }),
+        };
+    }
+    const url = read?.href ?? events.withinDocumentUrl;
+    if (url === undefined || url === startHref)
+        return undefined;
+    if (startHref === undefined && events.withinDocumentUrl === undefined)
+        return undefined;
+    return { url, sameDocument: true };
+}
+/**
+ * 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.
+ *
+ * @param read - Page read after the action
+ * @param effects - Navigation and messages found
+ * @param activity - Requests, dialogs and windows during the action
+ * @returns True to report `effect: "none"`
+ */
+export function hadNoEffect(read, effects, activity) {
+    return (read !== undefined &&
+        !read.fresh &&
+        read.changes === 0 &&
+        read.uncertain === undefined &&
+        effects.navigation === undefined &&
+        (effects.messages ?? []).length === 0 &&
+        activity.requests === 0 &&
+        activity.dialogs === 0 &&
+        !activity.opened);
+}
+/**
+ * Start watching an action's effects: listen for main-frame navigations,
+ * document statuses, requests and new windows, and send the page snapshot
+ * without waiting for it.
+ *
+ * @param cdp - CDP connection
+ * @returns Watch to collect from after the action
+ */
+export function watchActionEffects(cdp) {
+    const watch = {
+        cdp,
+        listener: listenForActivity(cdp),
+        start: evaluate(cdp, EFFECTS_START_SCRIPT),
+        stopConfirmed: false,
+    };
+    return {
+        collect: (options) => collectEffects(watch, options),
+        dispose: () => disposeWatch(watch),
+    };
+}
+/**
+ * What changed: the navigation (from CDP events even without a snapshot),
+ * new messages and, when asked, "no effect" after a second look.
+ *
+ * @param watch - The action's watch
+ * @param options - Dialogs the action opened, and whether to decide "no effect"
+ * @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);
+    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;
+}
+/**
+ * Navigation and new messages from the snapshots and CDP events.
+ *
+ * @param start - Snapshot before the action, if taken
+ * @param snapshot - Read after the action, if taken
+ * @param events - Main-frame navigation events
+ * @returns Effects, without empty parts
+ */
+function effectsOf(start, snapshot, events) {
+    const navigation = pageNavigation(start?.href, snapshot, events);
+    const messages = start && snapshot ? newMessages(start.messages, snapshot.messages, snapshot.fresh) : [];
+    return {
+        ...(navigation && { navigation }),
+        ...(messages.length > 0 && { messages }),
+    };
+}
+/**
+ * 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.
+ *
+ * @param watch - The action's watch
+ * @param stop - Also stop the page's watch
+ * @returns The read, or undefined
+ */
+async function readPage(watch, stop) {
+    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)
+        watch.stopConfirmed = true;
+    return snapshot;
+}
+/**
+ * Stop listening, and stop the page's watch unless a read did. The stop is
+ * sent even when the snapshot never answered: CDP runs it after the
+ * snapshot, wherever that ran (the page also stops watching on its own
+ * after 30 s).
+ *
+ * @param watch - The action's watch
+ */
+function disposeWatch(watch) {
+    watch.listener.dispose();
+    if (watch.stopConfirmed)
+        return;
+    void watch.cdp
+        .send('Runtime.evaluate', { expression: EFFECTS_STOP_SCRIPT })
+        .catch((error) => log.debug(`Effects watch not stopped: ${getErrorMessage(error)}`));
+}
+/**
+ * Evaluate a page script for its value (undefined on an exception or a
+ * failed call).
+ *
+ * @param cdp - CDP connection
+ * @param expression - Script
+ * @returns Its value, or undefined
+ */
+async function evaluate(cdp, expression) {
+    try {
+        const reply = (await cdp.send('Runtime.evaluate', { expression, returnByValue: true }));
+        if (!reply.exceptionDetails)
+            return reply.result?.value;
+        log.debug(`Effects script failed: ${reply.exceptionDetails.text}`);
+    }
+    catch (error) {
+        log.debug(`Effects script not run: ${getErrorMessage(error)}`);
+    }
+    return undefined;
+}
+//# sourceMappingURL=actionEffects.js.map

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

@@ -0,0 +1,52 @@
+/**
+ * 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}).
+ */
+/**
+ * Page-side test whether an element is part of a message's chrome rather
+ * than its text: aria-hidden parts, buttons, and elements whose class or
+ * aria-label names a close/dismiss control (`close`, `btn-close`, `close_x`;
+ * 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 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 reason why "no effect" can't be claimed even without DOM
+ * changes, or undefined: `clipboard` (a copy or cut happened), `no-event`
+ * (no event reached the page), `control` (form controls, labels, media,
+ * frames, popover/command buttons: their effect needs no DOM change),
+ * `new-window` (download or `target` links), `external-link` (mailto:, tel:,
+ * javascript: and other non-http links), `closed-shadow` (a custom element
+ * whose inside is not observed) or `focus` (focus moved to an element that
+ * may reveal content with CSS).
+ */
+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.
+ */
+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).
+ */
+export declare const EFFECTS_READ_SCRIPT: string;
+/** Stops the watch {@link EFFECTS_START_SCRIPT} left (when no read stopped it) */
+export declare const EFFECTS_STOP_SCRIPT = "if (window.__bdgEffects) { window.__bdgEffects.stop(); delete window.__bdgEffects; }";
+//# sourceMappingURL=actionEffectsScripts.d.ts.map

package/dist/runtime/dom/actionEffectsScripts.js

@@ -0,0 +1,234 @@
+/**
+ * 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}).
+ */
+import { ELEMENT_DESCRIPTION_JS } from './elementInfo.js';
+/** Class or id words that mark an element as a message (flash, toast, field error) */
+const MESSAGE_WORDS = [
+    'flash',
+    'alert',
+    'error',
+    'toast',
+    'notice',
+    'message',
+    'invalid',
+    'feedback',
+];
+/** Elements that show messages by role, plus a cheap prefilter for the class and id words */
+const MESSAGE_CANDIDATES = [
+    '[role="alert"]',
+    '[role="status"]',
+    '[aria-live]',
+    'output',
+    ...MESSAGE_WORDS.flatMap((word) => [`[class*="${word}" i]`, `[id*="${word}" i]`]),
+].join(', ');
+/** Messages kept per snapshot (after filtering) */
+const MAX_MESSAGES = 50;
+/** Time a message snapshot may spend before it stops looking (ms) */
+const MESSAGES_BUDGET_MS = 5;
+/** Longer texts are containers (a page, a form), not messages */
+const MAX_MESSAGE_TEXT = 300;
+/** How long a page keeps watching when no read or stop arrives (ms) */
+const MAX_WATCH_MS = 30000;
+/**
+ * Page-side test whether an element is part of a message's chrome rather
+ * than its text: aria-hidden parts, buttons, and elements whose class or
+ * aria-label names a close/dismiss control (`close`, `btn-close`, `close_x`;
+ * not `closeable`, `enclosed` or `disclosure`).
+ */
+export const MESSAGE_CHROME_JS = `(node) => {
+  const closer = /(^|[-_\\s])(close|dismiss)($|[-_\\s])/i;
+  return node.getAttribute('aria-hidden') === 'true' ||
+    /^(button|script|style|template)$/.test(node.localName) ||
+    node.getAttribute('role') === 'button' ||
+    closer.test(node.getAttribute('class') || '') ||
+    closer.test(node.getAttribute('aria-label') || '');
+}`;
+/**
+ * Page-side list of the messages a page shows: visible elements with an
+ * alert/status role, `aria-live`, `<output>`, or a class or id word from
+ * {@link MESSAGE_WORDS} (timers, marquees and progress bars left out), with
+ * their text (parts matching {@link MESSAGE_CHROME_JS}, such as the "×"
+ * close link, left out). Elements are filtered first, then the first
+ * {@link MAX_MESSAGES} kept, and the whole pass stops after
+ * {@link MESSAGES_BUDGET_MS}. Only the innermost of nested messages is kept,
+ * described by tag, id and classes (or its role when it has neither,
+ * `h3[role="alert"]`). Each element gets a number from `ids` that stays the
+ * same within the document, so a later snapshot can tell a new element from
+ * one that was there.
+ */
+const MESSAGES_JS = `(ids) => {
+  const deadline = performance.now() + ${MESSAGES_BUDGET_MS};
+  const description = ${ELEMENT_DESCRIPTION_JS};
+  const chrome = ${MESSAGE_CHROME_JS};
+  const describe = (el) => {
+    const text = description(el);
+    const role = el.getAttribute('role');
+    return text === el.localName && role ? text + '[role="' + role + '"]' : text;
+  };
+  const word = /\\b(${MESSAGE_WORDS.join('|')})\\b/i;
+  const named = (el) => !/^(timer|marquee|progressbar)$/.test(el.getAttribute('role') || '') &&
+    (el.matches('[role="alert"], [role="status"], [aria-live]:not([aria-live="off"]), output') ||
+      word.test(el.getAttribute('class') || '') || word.test(el.id || ''));
+  const shown = (el) => !el.closest('[aria-hidden="true"]') && el.getClientRects().length > 0 &&
+    (!el.checkVisibility || el.checkVisibility({ visibilityProperty: true, opacityProperty: true }));
+  const inChrome = (node, el) => {
+    for (let n = node; n && n !== el; n = n.parentElement) if (chrome(n)) return true;
+    return false;
+  };
+  const textOf = (el) => {
+    let text = '';
+    const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+    while (text.length <= ${MAX_MESSAGE_TEXT} && walker.nextNode()) {
+      const parent = walker.currentNode.parentElement;
+      if (!parent || inChrome(parent, el)) continue;
+      if (parent.checkVisibility && !parent.checkVisibility({ visibilityProperty: true, opacityProperty: true })) continue;
+      text += ' ' + walker.currentNode.data;
+    }
+    return text.replace(/\\s+/g, ' ').trim();
+  };
+  const found = [];
+  for (const el of document.querySelectorAll(${JSON.stringify(MESSAGE_CANDIDATES)})) {
+    if (found.length >= ${MAX_MESSAGES} || performance.now() > deadline) break;
+    if (!named(el) || !shown(el)) continue;
+    const text = textOf(el);
+    if (text !== '' && text.length <= ${MAX_MESSAGE_TEXT}) found.push({ el: el, text: text });
+  }
+  return found
+    .filter((m) => !found.some((other) => other !== m && m.el.contains(other.el)))
+    .map((m) => {
+      let id = ids.map.get(m.el);
+      if (id === undefined) {
+        id = ids.next++;
+        ids.map.set(m.el, id);
+      }
+      return { id: id, text: m.text, element: describe(m.el) };
+    });
+}`;
+/**
+ * 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 const CHURN_ONLY_JS = `(record, targets) => {
+  if (record.type !== 'attributes' || record.attributeName !== 'class' || !targets.has(record.target)) return false;
+  const tokens = (text) => new Set((text || '').split(/\\s+/).filter(Boolean));
+  const before = tokens(record.oldValue);
+  const after = tokens(record.target.getAttribute('class'));
+  const changed = [...before].filter((c) => !after.has(c)).concat([...after].filter((c) => !before.has(c)));
+  return changed.every((c) => /focus|hover/i.test(c));
+}`;
+/**
+ * Page-side reason why "no effect" can't be claimed even without DOM
+ * changes, or undefined: `clipboard` (a copy or cut happened), `no-event`
+ * (no event reached the page), `control` (form controls, labels, media,
+ * frames, popover/command buttons: their effect needs no DOM change),
+ * `new-window` (download or `target` links), `external-link` (mailto:, tel:,
+ * javascript: and other non-http links), `closed-shadow` (a custom element
+ * whose inside is not observed) or `focus` (focus moved to an element that
+ * may reveal content with CSS).
+ */
+export const UNCERTAIN_JS = `(state, active) => {
+  if (state.copied) return 'clipboard';
+  if (state.targets.size === 0) return 'no-event';
+  const controls = /^(input|select|textarea|option|label|canvas|video|audio|iframe|embed|object)$/;
+  for (const node of state.path) {
+    if (controls.test(node.localName) || node.isContentEditable) return 'control';
+    if (node.hasAttribute('popovertarget') || node.hasAttribute('commandfor')) return 'control';
+    if (node.localName === 'a' && node.hasAttribute('href')) {
+      if (node.hasAttribute('download') || (node.target && node.target !== '_self')) return 'new-window';
+      if (!/^https?:$/.test(node.protocol)) return 'external-link';
+    }
+  }
+  for (const node of state.targets) if (node.localName.includes('-') && !node.shadowRoot) return 'closed-shadow';
+  const plain = (node) => /^(body|button|summary)$/.test(node.localName) ||
+    (node.localName === 'a' && node.hasAttribute('href')) ||
+    (node.localName === 'input' && /^(button|submit|reset)$/i.test(node.type || ''));
+  if (active && active !== state.focus && !plain(active)) return 'focus';
+  return undefined;
+}`;
+/**
+ * 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.
+ */
+export const EFFECTS_START_SCRIPT = `(() => {
+  if (window.__bdgEffects) window.__bdgEffects.stop();
+  const churnOnly = ${CHURN_ONLY_JS};
+  const ids = { map: new WeakMap(), next: 1 };
+  const state = { ids: ids, changes: 0, targets: new Set(), path: new Set(), focus: document.activeElement, pressScroll: null, copied: false, stopped: false };
+  const count = (records) => {
+    for (const record of records) if (!churnOnly(record, state.targets)) state.changes++;
+  };
+  const observer = new MutationObserver(count);
+  const options = { subtree: true, childList: true, characterData: true, attributes: true, attributeOldValue: true };
+  const observe = (root) => {
+    observer.observe(root, options);
+    for (const el of root.querySelectorAll('*')) if (el.shadowRoot) observe(el.shadowRoot);
+  };
+  observe(document);
+  const attachShadow = Element.prototype.attachShadow;
+  const watchedAttach = function (init) {
+    const root = attachShadow.call(this, init);
+    state.changes++;
+    observer.observe(root, options);
+    return root;
+  };
+  Element.prototype.attachShadow = watchedAttach;
+  const types = ['pointerdown', 'mousedown', 'click', 'keydown', 'focusin', 'submit', 'mouseover', 'input', 'change', 'copy', 'cut'];
+  const pressTypes = ['pointerdown', 'mousedown', 'click', 'keydown', 'submit'];
+  const record = (event) => {
+    if (event.type === 'copy' || event.type === 'cut') state.copied = true;
+    const path = event.composedPath().filter((node) => node.nodeType === 1);
+    if (path[0]) state.targets.add(path[0]);
+    path.forEach((node) => state.path.add(node));
+    if (!state.pressScroll && pressTypes.includes(event.type)) state.pressScroll = [scrollX, scrollY];
+  };
+  types.forEach((type) => window.addEventListener(type, record, true));
+  state.flush = () => count(observer.takeRecords());
+  state.stop = () => {
+    if (state.stopped) return;
+    state.stopped = true;
+    clearTimeout(expiry);
+    observer.disconnect();
+    if (Element.prototype.attachShadow === watchedAttach) Element.prototype.attachShadow = attachShadow;
+    types.forEach((type) => window.removeEventListener(type, record, true));
+  };
+  const expiry = setTimeout(state.stop, ${MAX_WATCH_MS});
+  window.__bdgEffects = state;
+  return { href: location.href, messages: (${MESSAGES_JS})(ids) };
+})()`;
+/**
+ * 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).
+ */
+export const EFFECTS_READ_SCRIPT = `((stop) => {
+  const state = window.__bdgEffects;
+  if (!state) return { href: location.href, fresh: true, messages: (${MESSAGES_JS})({ map: new WeakMap(), next: 1 }) };
+  if (!state.stopped) state.flush();
+  if (stop) {
+    state.stop();
+    delete window.__bdgEffects;
+  }
+  const scrolled = state.pressScroll !== null && (state.pressScroll[0] !== scrollX || state.pressScroll[1] !== scrollY);
+  return {
+    href: location.href,
+    fresh: false,
+    changes: state.changes + (scrolled ? 1 : 0),
+    uncertain: (${UNCERTAIN_JS})(state, document.activeElement),
+    messages: (${MESSAGES_JS})(state.ids)
+  };
+})`;
+/** Stops the watch {@link EFFECTS_START_SCRIPT} left (when no read stopped it) */
+export const EFFECTS_STOP_SCRIPT = 'if (window.__bdgEffects) { window.__bdgEffects.stop(); delete window.__bdgEffects; }';
+//# sourceMappingURL=actionEffectsScripts.js.map