browser-debugger-cli 0.7.2 → 0.9.0

package/dist/telemetry/a11y.d.ts

@@ -1,9 +1,12 @@
 import type { Protocol } from '../connection/typed-cdp.js';
-import type { A11yNode, A11yTree, A11yQueryPattern, A11yQueryResult } from '../types.js';
+import type { A11yNode, A11yTree, A11yQueryPattern, A11yQueryResult, NodeRef } from '../types.js';
 /**
  * Builds accessibility tree from raw CDP nodes.
  *
  * Pure function that filters out ignored nodes and builds the tree structure.
+ * Children that are ignored are replaced by their own non-ignored children
+ * (as DevTools shows the tree), so every `childIds` entry is in `nodes`, and
+ * nodes are listed depth-first from the root (document order).
  * Separated from collectA11yTree for easier unit testing.
  *
  * @param rawNodes - Raw AXNode array from CDP
@@ -14,7 +17,7 @@ export declare function buildTreeFromRawNodes(rawNodes: Protocol.Accessibility.A
 /**
  * Collects the full accessibility tree from the page via IPC.
  *
- * Uses the worker's persistent CDP connection through callCDP for consistency
+ * Uses the session's persistent CDP connection through callCDP for consistency
  * with other DOM commands and to avoid connection conflicts.
  *
  * @returns Parsed and filtered accessibility tree
@@ -25,6 +28,8 @@ export declare function collectA11yTree(): Promise<A11yTree>;
  * Queries accessibility tree by pattern (role, name, description).
  *
  * Performs case-insensitive matching with AND logic for multiple fields.
+ * An element reported more than once (by the page's tree and its frame's)
+ * is listed once.
  *
  * @param tree - Accessibility tree to search
  * @param pattern - Query pattern with optional role, name, description
@@ -46,36 +51,42 @@ export declare function queryA11yTree(tree: A11yTree, pattern: A11yQueryPattern)
 /**
  * Parses query pattern string into A11yQueryPattern object.
  *
- * Supports format: "role:button name:Submit description:Main"
- * Also accepts = as separator: "role=button name=Submit"
- * Fields are separated by spaces, case-insensitive.
+ * Fields are `key:value` or `key=value`, separated by spaces or commas.
+ * Keys: role, name, description (desc). Case-insensitive. A role ends at the
+ * next `key:`; a name or description runs to the next role/name/description
+ * field with a value, or to the end, so it may contain spaces and colons
+ * (`name=E-mail address:`). Quote a value to end it explicitly.
  *
  * @param patternString - Query pattern string
  * @returns Parsed query pattern
+ * @throws CommandError (81) for unknown keys, also a misspelled one inside a name
  *
  * @example
  * ```typescript
- * parseQueryPattern('role:button name:Submit')
- * // => { role: 'button', name: 'Submit' }
- *
- * parseQueryPattern('role=heading')
- * // => { role: 'heading' }
- *
- * parseQueryPattern('name:Email')
- * // => { name: 'Email' }
+ * parseQueryPattern('role:button name:Submit')     // { role: 'button', name: 'Submit' }
+ * parseQueryPattern('role=link,name=Google Chrome') // { role: 'link', name: 'Google Chrome' }
+ * parseQueryPattern('name:"Sign in" role:button')  // { name: 'Sign in', role: 'button' }
+ * parseQueryPattern('name=E-mail address:')        // { name: 'E-mail address:' }
  * ```
  */
 export declare function parseQueryPattern(patternString: string): A11yQueryPattern;
 /**
- * Resolve accessibility properties for a DOM node by CSS selector or nodeId via IPC.
+ * Resolve accessibility properties for a DOM node via IPC.
  *
- * Uses the worker's persistent CDP connection through callCDP for consistency.
- * Supports direct nodeId lookup (bypassing selector) for index-based access patterns.
+ * Uses the session's persistent CDP connection through callCDP for consistency.
+ * Selectors are resolved by the caller (see `resolveBackendNodeIds`), so they
+ * reach shadow roots and same-origin iframes like every other DOM command.
  *
- * @param selector - CSS selector (ignored if nodeId provided)
- * @param nodeId - Optional nodeId to use directly instead of querying by selector
+ * @param target - Node reference
  * @returns A11y node or null if not found
- * @throws Error if selector is invalid or element not found
  */
-export declare function resolveA11yNode(selector: string, nodeId?: number): Promise<A11yNode | null>;
+export declare function resolveA11yNode(target: NodeRef): Promise<A11yNode | null>;
+/**
+ * Why an element has no node in the accessibility tree (e.g. it is not
+ * rendered, aria-hidden, or a decorative image with `alt=""`).
+ *
+ * @param target - Node reference
+ * @returns Chrome's reasons in plain words (empty if unknown)
+ */
+export declare function a11yIgnoredReasons(target: NodeRef): Promise<string[]>;
 //# sourceMappingURL=a11y.d.ts.map

package/dist/telemetry/a11y.js

@@ -1,8 +1,16 @@
+import { CommandError } from '../errors/index.js';
+import { unknownQueryFieldError } from '../errors/messages.js';
 import { callCDP } from '../ipc/client.js';
+import { childFrameIds } from '../runtime/dom/frameLayout.js';
+import { EXIT_CODES } from '../utils/exitCodes.js';
+import { levenshteinDistance } from '../utils/levenshtein.js';
 /**
  * Builds accessibility tree from raw CDP nodes.
  *
  * Pure function that filters out ignored nodes and builds the tree structure.
+ * Children that are ignored are replaced by their own non-ignored children
+ * (as DevTools shows the tree), so every `childIds` entry is in `nodes`, and
+ * nodes are listed depth-first from the root (document order).
  * Separated from collectA11yTree for easier unit testing.
  *
  * @param rawNodes - Raw AXNode array from CDP
@@ -10,29 +18,55 @@ import { callCDP } from '../ipc/client.js';
  * @throws Error if no root node found
  */
 export function buildTreeFromRawNodes(rawNodes) {
+    const rawById = new Map(rawNodes.map((rawNode) => [rawNode.nodeId, rawNode]));
+    const rootRaw = rawNodes.find((rawNode) => !rawNode.ignored);
+    if (!rootRaw) {
+        throw new CommandError('No root node found in accessibility tree', { suggestion: 'The page may not be fully loaded. Wait and retry.' }, EXIT_CODES.SOFTWARE_ERROR);
+    }
     const nodes = new Map();
-    let root = null;
-    for (const rawNode of rawNodes) {
-        if (rawNode.ignored) {
-            continue;
-        }
+    const visit = (rawNode) => {
+        if (nodes.has(rawNode.nodeId))
+            return;
         const node = parseA11yNode(rawNode);
+        const childIds = visibleChildIds(rawNode, rawById);
+        if (childIds.length > 0)
+            node.childIds = childIds;
+        else
+            delete node.childIds;
         nodes.set(node.nodeId, node);
-        root ??= node;
-    }
-    if (!root) {
-        throw new Error('No root node found in accessibility tree');
-    }
-    return {
-        root,
-        nodes,
-        count: nodes.size,
+        for (const childId of childIds) {
+            const child = rawById.get(childId);
+            if (child)
+                visit(child);
+        }
     };
+    visit(rootRaw);
+    rawNodes.filter((rawNode) => !rawNode.ignored).forEach(visit);
+    const root = nodes.get(rootRaw.nodeId);
+    return { root, nodes, count: nodes.size };
+}
+/**
+ * Ids of a node's children as shown: ignored children are replaced by their
+ * own non-ignored descendants; ids missing from the tree are dropped.
+ *
+ * @param rawNode - Node whose children to list
+ * @param rawById - All raw nodes by id
+ * @param seen - Ids already listed (guards against cycles)
+ * @returns Child ids, all of non-ignored nodes in the tree
+ */
+function visibleChildIds(rawNode, rawById, seen = new Set()) {
+    return (rawNode.childIds ?? []).flatMap((childId) => {
+        const child = rawById.get(childId);
+        if (!child || seen.has(childId))
+            return [];
+        seen.add(childId);
+        return child.ignored ? visibleChildIds(child, rawById, seen) : [childId];
+    });
 }
 /**
  * Collects the full accessibility tree from the page via IPC.
  *
- * Uses the worker's persistent CDP connection through callCDP for consistency
+ * Uses the session's persistent CDP connection through callCDP for consistency
  * with other DOM commands and to avoid connection conflicts.
  *
  * @returns Parsed and filtered accessibility tree
@@ -44,14 +78,77 @@ export async function collectA11yTree() {
         const response = await callCDP('Accessibility.getFullAXTree', {});
         const result = response.data?.result;
         if (!result?.nodes) {
-            throw new Error('Failed to get accessibility tree');
+            throw new CommandError('Failed to get accessibility tree', { suggestion: 'CDP returned no nodes. The page may not be fully loaded.' }, EXIT_CODES.SOFTWARE_ERROR);
         }
-        return buildTreeFromRawNodes(result.nodes);
+        return buildTreeFromRawNodes([...result.nodes, ...(await collectFrameNodes(result.nodes))]);
     }
     finally {
         await callCDP('Accessibility.disable', {});
     }
 }
+/**
+ * Accessibility nodes of the page's iframes, attached under their `Iframe`
+ * node (the page's own tree stops there). Frames in another process
+ * (cross-origin) cannot be read this way and are skipped. Node ids are
+ * prefixed per frame, as each frame numbers its nodes on its own.
+ *
+ * @param pageNodes - The page's nodes (their iframe nodes get the frame root as
+ *   child; nested frames attach to their parent frame's nodes)
+ * @returns Nodes of all readable frames
+ */
+async function collectFrameNodes(pageNodes) {
+    const tree = (await callCDP('Page.getFrameTree', {})).data?.result;
+    const known = [...pageNodes];
+    const collected = [];
+    for (const [index, frameId] of childFrameIds(tree?.frameTree).entries()) {
+        const nodes = await frameNodes(frameId, `f${index}:`, known);
+        known.push(...nodes);
+        collected.push(...nodes);
+    }
+    return collected;
+}
+/**
+ * One frame's nodes, with ids prefixed, its root attached to the node of its
+ * `<iframe>` element.
+ *
+ * @param frameId - Frame id
+ * @param prefix - Prefix for the frame's node ids
+ * @param ownerNodes - Nodes that may contain the frame's `<iframe>` node
+ * @returns The frame's nodes, or none when it cannot be read
+ */
+async function frameNodes(frameId, prefix, ownerNodes) {
+    const response = await callCDP('Accessibility.getFullAXTree', { frameId });
+    const nodes = response.data?.result
+        ?.nodes;
+    const owner = (await callCDP('DOM.getFrameOwner', { frameId })).data?.result;
+    if (!nodes?.length || !owner)
+        return [];
+    const prefixed = nodes.map((node) => ({
+        ...node,
+        nodeId: prefix + node.nodeId,
+        ...(node.parentId && { parentId: prefix + node.parentId }),
+        ...(node.childIds && { childIds: node.childIds.map((id) => prefix + id) }),
+    }));
+    const root = prefixed.find((node) => !node.parentId);
+    const iframeNode = ownerNodes.find((node) => node.backendDOMNodeId === owner.backendNodeId);
+    if (root && iframeNode)
+        iframeNode.childIds = [...(iframeNode.childIds ?? []), root.nodeId];
+    return prefixed;
+}
+/**
+ * Chrome reports some states (`checked`, `pressed`) as the strings "true" and
+ * "false" (they may also be "mixed"); make those booleans like the others.
+ *
+ * @param value - Property value
+ * @returns The value, with "true"/"false" as booleans
+ */
+function booleanIfFlag(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return value;
+}
 /**
  * Parses raw CDP AXNode into simplified A11yNode format.
  *
@@ -91,7 +188,7 @@ function parseA11yNode(rawNode) {
                 node.required = prop.value.value === true;
             }
             else {
-                props[prop.name] = prop.value.value;
+                props[prop.name] = booleanIfFlag(prop.value.value);
             }
         }
         if (Object.keys(props).length > 0) {
@@ -120,10 +217,18 @@ function extractRole(rawNode) {
     }
     return 'unknown';
 }
+/**
+ * Roles of text nodes: they repeat the name of the element they are in (a
+ * name search found every button three times) and are not elements that
+ * commands can act on. Left out unless the query asks for the role.
+ */
+const TEXT_ROLES = new Set(['statictext', 'inlinetextbox']);
 /**
  * Queries accessibility tree by pattern (role, name, description).
  *
  * Performs case-insensitive matching with AND logic for multiple fields.
+ * An element reported more than once (by the page's tree and its frame's)
+ * is listed once.
  *
  * @param tree - Accessibility tree to search
  * @param pattern - Query pattern with optional role, name, description
@@ -143,10 +248,19 @@ function extractRole(rawNode) {
  */
 export function queryA11yTree(tree, pattern) {
     const matches = [];
+    const seenElements = new Set();
+    const wantsText = pattern.role !== undefined && TEXT_ROLES.has(pattern.role.toLowerCase());
     for (const node of tree.nodes.values()) {
-        if (matchesPattern(node, pattern)) {
-            matches.push(node);
+        if (!wantsText && TEXT_ROLES.has(node.role.toLowerCase()))
+            continue;
+        if (!matchesPattern(node, pattern))
+            continue;
+        if (node.backendDOMNodeId !== undefined) {
+            if (seenElements.has(node.backendDOMNodeId))
+                continue;
+            seenElements.add(node.backendDOMNodeId);
         }
+        matches.push(node);
     }
     return {
         nodes: matches,
@@ -154,128 +268,175 @@ export function queryA11yTree(tree, pattern) {
         pattern,
     };
 }
+/**
+ * Match a value against a query term.
+ *
+ * Without `*` the term matches as a case-insensitive substring (or exactly,
+ * for `exact`); `*` matches any run of characters.
+ *
+ * @param value - Node value (role, name, description)
+ * @param term - Query term
+ * @param exact - Whole-value match instead of substring
+ * @returns True on match
+ */
+function matchesTerm(value, term, exact = false) {
+    if (value === undefined)
+        return false;
+    if (!term.includes('*')) {
+        const [v, t] = [value.toLowerCase(), term.toLowerCase()];
+        return exact ? v === t : v.includes(t);
+    }
+    const source = term
+        .split('*')
+        .map((part) => part.replace(/[.+?^${}()|[\]\\]/g, '\\$&'))
+        .join('[\\s\\S]*');
+    return new RegExp(exact ? `^${source}$` : source, 'i').test(value);
+}
 /**
  * Checks if a node matches the query pattern.
  *
- * All specified fields must match (AND logic).
- * String matching is case-insensitive.
+ * All specified fields must match (AND logic), case-insensitively: role
+ * exactly, name and description as substrings; `*` is a wildcard.
  *
  * @param node - A11y node to test
  * @param pattern - Query pattern
  * @returns True if node matches all pattern criteria
  */
 function matchesPattern(node, pattern) {
-    if (pattern.role) {
-        if (node.role.toLowerCase() !== pattern.role.toLowerCase()) {
-            return false;
-        }
-    }
-    if (pattern.name) {
-        if (!node.name) {
-            return false;
-        }
-        if (!node.name.toLowerCase().includes(pattern.name.toLowerCase())) {
-            return false;
-        }
-    }
-    if (pattern.description) {
-        if (!node.description) {
-            return false;
-        }
-        if (!node.description.toLowerCase().includes(pattern.description.toLowerCase())) {
-            return false;
-        }
-    }
+    if (pattern.role && !matchesTerm(node.role, pattern.role, true))
+        return false;
+    if (pattern.name && !matchesTerm(node.name, pattern.name))
+        return false;
+    if (pattern.description && !matchesTerm(node.description, pattern.description))
+        return false;
     return true;
 }
+/** Query fields and their aliases. */
+const QUERY_FIELDS = {
+    role: 'role',
+    name: 'name',
+    description: 'description',
+    desc: 'description',
+};
+/** The next `key:`/`key=` anywhere (fields may follow other text). */
+const QUERY_KEY = /([a-z]+)\s*[:=]/i;
+/** A quoted value (it may contain anything but its own quote). */
+const QUOTED_QUERY_VALUE = /^\s*("[^"]*"|'[^']*')/;
+/** Where a role value ends: at the next `key:` after a space or comma. */
+const NEXT_QUERY_FIELD = /[\s,]+[a-z]+\s*[:=]/i;
+/**
+ * Where a name or description ends: only at a known field that has a value,
+ * so names keep their spaces and colons (`name=E-mail address:`).
+ */
+const NEXT_KNOWN_QUERY_FIELD = /[\s,]+(?:role|name|description|desc)\s*[:=](?=\s*[^\s,])/i;
+/**
+ * Read one field value.
+ *
+ * @param text - Text after `key:`
+ * @param field - Field the value is for
+ * @returns The value, where it ends in `text`, and whether it was quoted
+ */
+function readQueryValue(text, field) {
+    const quoted = QUOTED_QUERY_VALUE.exec(text);
+    if (quoted?.[1])
+        return { value: quoted[1].slice(1, -1), end: quoted[0].length, quoted: true };
+    const next = (field === 'role' ? NEXT_QUERY_FIELD : NEXT_KNOWN_QUERY_FIELD).exec(text);
+    const end = next ? next.index : text.length;
+    const value = text
+        .slice(0, end)
+        .trim()
+        .replace(/,+$/, '')
+        .replace(/^(["'])(.*)\1$/s, '$2');
+    return { value, end, quoted: false };
+}
 /**
  * Parses query pattern string into A11yQueryPattern object.
  *
- * Supports format: "role:button name:Submit description:Main"
- * Also accepts = as separator: "role=button name=Submit"
- * Fields are separated by spaces, case-insensitive.
+ * Fields are `key:value` or `key=value`, separated by spaces or commas.
+ * Keys: role, name, description (desc). Case-insensitive. A role ends at the
+ * next `key:`; a name or description runs to the next role/name/description
+ * field with a value, or to the end, so it may contain spaces and colons
+ * (`name=E-mail address:`). Quote a value to end it explicitly.
  *
  * @param patternString - Query pattern string
  * @returns Parsed query pattern
+ * @throws CommandError (81) for unknown keys, also a misspelled one inside a name
  *
  * @example
  * ```typescript
- * parseQueryPattern('role:button name:Submit')
- * // => { role: 'button', name: 'Submit' }
- *
- * parseQueryPattern('role=heading')
- * // => { role: 'heading' }
- *
- * parseQueryPattern('name:Email')
- * // => { name: 'Email' }
+ * parseQueryPattern('role:button name:Submit')     // { role: 'button', name: 'Submit' }
+ * parseQueryPattern('role=link,name=Google Chrome') // { role: 'link', name: 'Google Chrome' }
+ * parseQueryPattern('name:"Sign in" role:button')  // { name: 'Sign in', role: 'button' }
+ * parseQueryPattern('name=E-mail address:')        // { name: 'E-mail address:' }
  * ```
  */
 export function parseQueryPattern(patternString) {
     const pattern = {};
-    const parts = patternString.trim().split(/\s+/);
-    for (const part of parts) {
-        const separatorMatch = part.match(/[:=]/);
-        if (!separatorMatch) {
-            continue;
-        }
-        const separator = separatorMatch[0];
-        const [key, ...valueParts] = part.split(separator);
-        const value = valueParts.join(separator);
-        if (!value) {
-            continue;
-        }
-        if (!key) {
-            continue;
-        }
-        const normalizedKey = key.toLowerCase();
-        if (normalizedKey === 'role') {
-            pattern.role = value;
-        }
-        else if (normalizedKey === 'name') {
-            pattern.name = value;
-        }
-        else if (normalizedKey === 'description' || normalizedKey === 'desc') {
-            pattern.description = value;
-        }
+    let rest = patternString;
+    for (let key = QUERY_KEY.exec(rest); key; key = QUERY_KEY.exec(rest)) {
+        const rawKey = key[1] ?? '';
+        const field = QUERY_FIELDS[rawKey.toLowerCase()];
+        if (!field)
+            throwUnknownField(rawKey);
+        const valueText = rest.slice(key.index + key[0].length);
+        const { value, end, quoted } = readQueryValue(valueText, field);
+        if (!quoted && field !== 'role')
+            checkMisspelledField(value, field);
+        if (value)
+            pattern[field] = value;
+        rest = valueText.slice(end);
     }
     return pattern;
 }
 /**
- * Resolve accessibility properties for a DOM node by CSS selector or nodeId via IPC.
+ * Throw the exit-81 error for an unknown query field.
+ *
+ * @param field - The unrecognized key
+ * @param similar - A known field it looks like a typo of
+ * @param value - The name or description that absorbed it
+ * @throws CommandError (81)
+ */
+function throwUnknownField(field, similar, value) {
+    const err = unknownQueryFieldError(field, similar, value);
+    throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
+}
+/** A `word:`/`word=` inside a name or description. */
+const ABSORBED_KEY = /[\s,]([a-z]+)\s*[:=]/gi;
+/**
+ * Reject a name or description that swallowed a misspelled field
+ * (`name:Save rol:button`): a `word:` within edit distance 1 of role, name or
+ * desc (2 of description). Wider distances would catch common label words
+ * (`Date:`, `Note:`, `Code:`).
+ *
+ * @param value - Unquoted name or description
+ * @param field - Field it is the value of
+ * @throws CommandError (81) with a "did you mean" suggestion
+ */
+function checkMisspelledField(value, field) {
+    for (const [, word = ''] of value.matchAll(ABSORBED_KEY)) {
+        const lower = word.toLowerCase();
+        if (QUERY_FIELDS[lower])
+            continue;
+        const similar = Object.keys(QUERY_FIELDS).find((name) => levenshteinDistance(lower, name) <= (name.length > 4 ? 2 : 1));
+        if (similar)
+            throwUnknownField(word, similar, `${field}=${value}`);
+    }
+}
+/**
+ * Resolve accessibility properties for a DOM node via IPC.
  *
- * Uses the worker's persistent CDP connection through callCDP for consistency.
- * Supports direct nodeId lookup (bypassing selector) for index-based access patterns.
+ * Uses the session's persistent CDP connection through callCDP for consistency.
+ * Selectors are resolved by the caller (see `resolveBackendNodeIds`), so they
+ * reach shadow roots and same-origin iframes like every other DOM command.
  *
- * @param selector - CSS selector (ignored if nodeId provided)
- * @param nodeId - Optional nodeId to use directly instead of querying by selector
+ * @param target - Node reference
  * @returns A11y node or null if not found
- * @throws Error if selector is invalid or element not found
  */
-export async function resolveA11yNode(selector, nodeId) {
+export async function resolveA11yNode(target) {
     await callCDP('Accessibility.enable', {});
     try {
-        let targetNodeId;
-        if (nodeId !== undefined) {
-            targetNodeId = nodeId;
-        }
-        else {
-            const docResponse = await callCDP('DOM.getDocument', {});
-            const doc = docResponse.data?.result;
-            if (!doc?.root?.nodeId) {
-                throw new Error('Failed to get document root');
-            }
-            const nodeResponse = await callCDP('DOM.querySelector', {
-                nodeId: doc.root.nodeId,
-                selector,
-            });
-            const nodeResult = nodeResponse.data?.result;
-            if (!nodeResult?.nodeId) {
-                return null;
-            }
-            targetNodeId = nodeResult.nodeId;
-        }
         const a11yResponse = await callCDP('Accessibility.getPartialAXTree', {
-            nodeId: targetNodeId,
+            ...target,
             fetchRelatives: false,
         });
         const a11yResult = a11yResponse.data?.result;
@@ -292,4 +453,40 @@ export async function resolveA11yNode(selector, nodeId) {
         await callCDP('Accessibility.disable', {});
     }
 }
+/**
+ * Why an element has no node in the accessibility tree (e.g. it is not
+ * rendered, aria-hidden, or a decorative image with `alt=""`).
+ *
+ * @param target - Node reference
+ * @returns Chrome's reasons in plain words (empty if unknown)
+ */
+export async function a11yIgnoredReasons(target) {
+    await callCDP('Accessibility.enable', {});
+    try {
+        const response = await callCDP('Accessibility.getPartialAXTree', {
+            ...target,
+            fetchRelatives: false,
+        });
+        const nodes = response.data?.result?.nodes;
+        return (nodes?.[0]?.ignoredReasons ?? []).map((reason) => IGNORED_REASONS[reason.name] ?? reason.name);
+    }
+    finally {
+        await callCDP('Accessibility.disable', {});
+    }
+}
+/** Chrome's ignored reasons in plain words */
+const IGNORED_REASONS = {
+    notRendered: 'not rendered (display: none or hidden)',
+    notVisible: 'not visible',
+    ariaHiddenElement: 'aria-hidden="true"',
+    ariaHiddenSubtree: 'inside an aria-hidden element',
+    presentationalRole: 'presentational (e.g. an image with alt="")',
+    emptyAlt: 'an image with alt=""',
+    inertElement: 'inert',
+    inertSubtree: 'inside an inert element',
+    activeModalDialog: 'outside the open modal dialog',
+    probablyPresentational: 'probably decorative',
+    uninteresting: 'has no role or name',
+    labelFor: 'a label (its text names another element)',
+};
 //# sourceMappingURL=a11y.js.map

package/dist/telemetry/attachedTargets.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Attach to the page's child targets: out-of-process (cross-origin) iframes
+ * and workers.
+ *
+ * Their console, log and network events do not reach the page's own session.
+ * With flattened auto-attach, each child gets a session on the same
+ * connection; its events arrive with that session id, and commands are sent
+ * to it by id. Children start paused, so every collector can enable its
+ * domains before the child loads anything; they are resumed afterwards.
+ */
+import type { CDPConnection } from '../connection/cdp.js';
+import type { CleanupFunction } from '../types.js';
+/** Enables what a collector needs on a child session (e.g. `Runtime.enable`) */
+type ChildSetup = (sessionId: string) => Promise<void>;
+/**
+ * Attach to child targets of the page and run `setup` on each one's session
+ * before it starts. Children that are already attached (e.g. when another
+ * collector registered first) get the setup right away.
+ *
+ * @param cdp - CDP connection to the page
+ * @param setup - Enables domains on a child session (e.g. `Runtime.enable`)
+ * @returns Cleanup function that stops running `setup` for new targets
+ */
+export declare function attachChildTargets(cdp: CDPConnection, setup: ChildSetup): Promise<CleanupFunction>;
+/**
+ * Session of an attached child target (e.g. an out-of-process iframe) on the
+ * connection. Its commands are answered even while the target's scripts keep
+ * it busy, unlike those of a session attached afterwards.
+ *
+ * @param cdp - CDP connection to the page
+ * @param targetId - Target id (an iframe target's id is its frame id)
+ * @returns The session, undefined when the target is not attached
+ */
+export declare function attachedSessionOf(cdp: CDPConnection, targetId: string): string | undefined;
+export {};
+//# sourceMappingURL=attachedTargets.d.ts.map