runline 0.22.0 → 0.24.0

package/dist/plugins/steel/src/page/vendor/aria-snapshot/ariaSnapshot.js

@@ -0,0 +1,411 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Trimmed from playwright packages/injected/src/ariaSnapshot.ts - see README.md.
+// Dropped: the assertion template matchers (matchesExpectAriaTemplate and friends).
+import * as aria from './ariaTypes.js';
+import { escapeRegExp, longestCommonSubstring, normalizeWhiteSpace, truncateDataUrl } from './stringUtils.js';
+import { yamlEscapeKeyIfNeeded, yamlEscapeValueIfNeeded } from './yaml.js';
+import { distillAriaSnapshot } from './ariaSnapshotDistiller.js';
+import { computeBox, getElementComputedStyle, isElementVisible } from './domUtils.js';
+import * as roleUtils from './roleUtils.js';
+export const SENSITIVE_VALUE_MARKER = '[REDACTED]';
+let lastRef = 0;
+function toInternalOptions(options) {
+    const renderBoxes = options.boxes;
+    if (options.mode === 'ai') {
+        // For AI consumption.
+        return {
+            visibility: 'ariaOrVisible',
+            refs: 'interactable',
+            refPrefix: options.refPrefix,
+            includeGenericRole: true,
+            renderActive: !options.doNotRenderActive,
+            renderCursorPointer: true,
+            renderBoxes,
+        };
+    }
+    if (options.mode === 'autoexpect') {
+        // To auto-generate assertions on visible elements.
+        return { visibility: 'ariaAndVisible', refs: 'none', renderBoxes };
+    }
+    if (options.mode === 'codegen') {
+        // To generate aria assertion with regex heurisitcs.
+        return { visibility: 'aria', refs: 'none', renderStringsAsRegex: true, renderBoxes };
+    }
+    // To match aria snapshot.
+    return { visibility: 'aria', refs: 'none', renderBoxes };
+}
+export function generateAriaTree(rootElement, publicOptions) {
+    const options = toInternalOptions(publicOptions);
+    const visited = new Set();
+    // For each node, the elements that contributed to its accessible name.
+    const nameSourceElements = new Map();
+    const snapshot = {
+        root: { role: 'fragment', name: '', children: [], props: {}, box: computeBox(rootElement), receivesPointerEvents: true },
+        info: new Map(),
+        refs: new Map(),
+        iframeRefs: [],
+    };
+    setAriaNodeElement(snapshot.root, rootElement);
+    const visit = (ariaNode, node, parentElementVisible) => {
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        if (node.nodeType === Node.TEXT_NODE && node.nodeValue) {
+            if (!parentElementVisible)
+                return;
+            const text = node.nodeValue;
+            // <textarea>AAA</textarea> should not report AAA as a child of the textarea.
+            if (ariaNode.role !== 'textbox' && text)
+                ariaNode.children.push(node.nodeValue || '');
+            return;
+        }
+        if (node.nodeType !== Node.ELEMENT_NODE)
+            return;
+        const element = node;
+        const isElementVisibleForAria = !roleUtils.isElementHiddenForAria(element);
+        let visible = isElementVisibleForAria;
+        if (options.visibility === 'ariaOrVisible')
+            visible = isElementVisibleForAria || isElementVisible(element);
+        if (options.visibility === 'ariaAndVisible')
+            visible = isElementVisibleForAria && isElementVisible(element);
+        // Optimization: if we only consider aria visibility, we can skip child elements because
+        // they will not be visible for aria as well.
+        if (options.visibility === 'aria' && !visible)
+            return;
+        const ariaChildren = [];
+        if (element.hasAttribute('aria-owns')) {
+            const ids = element.getAttribute('aria-owns').split(/\s+/);
+            for (const id of ids) {
+                const ownedElement = rootElement.ownerDocument.getElementById(id);
+                if (ownedElement)
+                    ariaChildren.push(ownedElement);
+            }
+        }
+        const childAriaNode = visible ? toAriaNode(element, options, nameSourceElements) : null;
+        let elementInfo;
+        if (childAriaNode) {
+            if (childAriaNode.ref) {
+                elementInfo = { element, nameFromContentRefs: [] };
+                snapshot.info.set(childAriaNode.ref, elementInfo);
+                snapshot.refs.set(element, childAriaNode.ref);
+                if (childAriaNode.role === 'iframe')
+                    snapshot.iframeRefs.push(childAriaNode.ref);
+            }
+            ariaNode.children.push(childAriaNode);
+        }
+        processElement(childAriaNode || ariaNode, element, ariaChildren, visible);
+        // Now that the subtree is processed, every descendant that contributed to this node's
+        // accessible name has its ref assigned, so we can resolve those refs as the name's origins.
+        if (elementInfo) {
+            for (const contributor of nameSourceElements.get(childAriaNode) || []) {
+                const ref = snapshot.refs.get(contributor);
+                if (ref && ref !== childAriaNode.ref)
+                    elementInfo.nameFromContentRefs.push(ref);
+            }
+        }
+    };
+    function processElement(ariaNode, element, ariaChildren, parentElementVisible) {
+        // Surround every element with spaces for the sake of concatenated text nodes.
+        const display = getElementComputedStyle(element)?.display || 'inline';
+        const treatAsBlock = (display !== 'inline' || element.nodeName === 'BR') ? ' ' : '';
+        if (treatAsBlock)
+            ariaNode.children.push(treatAsBlock);
+        ariaNode.children.push(roleUtils.getCSSContent(element, '::before') || '');
+        const assignedNodes = element.nodeName === 'SLOT' ? element.assignedNodes() : [];
+        if (assignedNodes.length) {
+            for (const child of assignedNodes)
+                visit(ariaNode, child, parentElementVisible);
+        }
+        else {
+            for (let child = element.firstChild; child; child = child.nextSibling) {
+                if (!child.assignedSlot)
+                    visit(ariaNode, child, parentElementVisible);
+            }
+            if (element.shadowRoot) {
+                for (let child = element.shadowRoot.firstChild; child; child = child.nextSibling)
+                    visit(ariaNode, child, parentElementVisible);
+            }
+        }
+        for (const child of ariaChildren)
+            visit(ariaNode, child, parentElementVisible);
+        ariaNode.children.push(roleUtils.getCSSContent(element, '::after') || '');
+        if (treatAsBlock)
+            ariaNode.children.push(treatAsBlock);
+        if (ariaNode.children.length === 1 && ariaNode.name === ariaNode.children[0])
+            ariaNode.children = [];
+        if (ariaNode.role === 'link' && element.hasAttribute('href')) {
+            const href = element.getAttribute('href');
+            ariaNode.props['url'] = truncateDataUrl(href);
+        }
+        if (ariaNode.role === 'textbox' && element.hasAttribute('placeholder') && element.getAttribute('placeholder') !== ariaNode.name) {
+            const placeholder = element.getAttribute('placeholder');
+            ariaNode.props['placeholder'] = placeholder;
+        }
+    }
+    roleUtils.beginAriaCaches();
+    try {
+        visit(snapshot.root, rootElement, true);
+    }
+    finally {
+        roleUtils.endAriaCaches();
+    }
+    distillAriaSnapshot(snapshot, publicOptions);
+    return snapshot;
+}
+function computeAriaRef(ariaNode, options) {
+    if (options.refs === 'none')
+        return;
+    if (options.refs === 'interactable' && (!ariaNode.box.visible || !ariaNode.receivesPointerEvents))
+        return;
+    const element = ariaNodeElement(ariaNode);
+    let ariaRef = element._ariaRef;
+    if (!ariaRef || ariaRef.role !== ariaNode.role || ariaRef.name !== ariaNode.name) {
+        ariaRef = { role: ariaNode.role, name: ariaNode.name, ref: (options.refPrefix ?? '') + 'e' + (++lastRef) };
+        element._ariaRef = ariaRef;
+    }
+    ariaNode.ref = ariaRef.ref;
+}
+function toAriaNode(element, options, nameSourceElements) {
+    const active = element.ownerDocument.activeElement === element && element.ownerDocument.hasFocus();
+    if (element.nodeName === 'IFRAME') {
+        const ariaNode = {
+            role: 'iframe',
+            name: '',
+            children: [],
+            props: {},
+            box: computeBox(element),
+            receivesPointerEvents: true,
+            active
+        };
+        setAriaNodeElement(ariaNode, element);
+        computeAriaRef(ariaNode, options);
+        return ariaNode;
+    }
+    const defaultRole = options.includeGenericRole ? 'generic' : null;
+    const role = roleUtils.getAriaRole(element) ?? defaultRole;
+    if (!role || role === 'presentation' || role === 'none')
+        return null;
+    const name = roleUtils.getElementAccessibleName(element, false);
+    const receivesPointerEvents = roleUtils.receivesPointerEvents(element);
+    const box = computeBox(element);
+    if (role === 'generic' && box.inline && element.childNodes.length === 1 && element.childNodes[0].nodeType === Node.TEXT_NODE)
+        return null;
+    const result = {
+        role,
+        name: normalizeWhiteSpace(name.text),
+        children: [],
+        props: {},
+        box,
+        receivesPointerEvents,
+        active
+    };
+    setAriaNodeElement(result, element);
+    nameSourceElements.set(result, name.elements);
+    computeAriaRef(result, options);
+    if (roleUtils.kAriaCheckedRoles.includes(role))
+        result.checked = roleUtils.getAriaChecked(element);
+    if (roleUtils.kAriaDisabledRoles.includes(role))
+        result.disabled = roleUtils.getAriaDisabled(element);
+    if (roleUtils.kAriaExpandedRoles.includes(role))
+        result.expanded = roleUtils.getAriaExpanded(element);
+    if (roleUtils.kAriaInvalidRoles.includes(role)) {
+        const invalid = roleUtils.getAriaInvalid(element);
+        result.invalid = invalid === 'false' ? false : invalid === 'true' ? true : invalid;
+    }
+    if (roleUtils.kAriaLevelRoles.includes(role))
+        result.level = roleUtils.getAriaLevel(element);
+    if (roleUtils.kAriaPressedRoles.includes(role))
+        result.pressed = roleUtils.getAriaPressed(element);
+    if (roleUtils.kAriaSelectedRoles.includes(role))
+        result.selected = roleUtils.getAriaSelected(element);
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+        if (element.type !== 'checkbox' && element.type !== 'radio' && element.type !== 'file')
+            result.children = [element instanceof HTMLInputElement && element.type === 'password' ? SENSITIVE_VALUE_MARKER : element.value];
+    }
+    return result;
+}
+function indent(depth) {
+    return '  '.repeat(depth);
+}
+export function renderAriaTree(ariaSnapshot, publicOptions) {
+    const options = toInternalOptions(publicOptions);
+    const lines = [];
+    const iframeDepths = {};
+    const includeText = options.renderStringsAsRegex ? textContributesInfo : () => true;
+    const renderString = options.renderStringsAsRegex ? convertToBestGuessRegex : (str) => str;
+    // Do not render the root fragment, just its children.
+    const nodesToRender = ariaSnapshot.root.role === 'fragment' ? ariaSnapshot.root.children : [ariaSnapshot.root];
+    const visitText = (text, depth) => {
+        if (publicOptions.depth && depth > publicOptions.depth)
+            return;
+        const escaped = yamlEscapeValueIfNeeded(renderString(text));
+        if (escaped)
+            lines.push(indent(depth) + '- text: ' + escaped);
+    };
+    const createKey = (ariaNode, renderCursorPointer) => {
+        let key = ariaNode.role;
+        // Yaml has a limit of 1024 characters per key, and we leave some space for role and attributes.
+        if (ariaNode.name && ariaNode.name.length <= 900) {
+            const name = renderString(ariaNode.name);
+            if (name) {
+                const stringifiedName = name.startsWith('/') && name.endsWith('/') ? name : JSON.stringify(name);
+                key += ' ' + stringifiedName;
+            }
+        }
+        if (ariaNode.checked === 'mixed')
+            key += ` [checked=mixed]`;
+        if (ariaNode.checked === true)
+            key += ` [checked]`;
+        if (ariaNode.disabled)
+            key += ` [disabled]`;
+        if (ariaNode.expanded)
+            key += ` [expanded]`;
+        if (ariaNode.active && options.renderActive)
+            key += ` [active]`;
+        if (ariaNode.invalid === 'grammar' || ariaNode.invalid === 'spelling')
+            key += ` [invalid=${ariaNode.invalid}]`;
+        if (ariaNode.invalid === true)
+            key += ` [invalid]`;
+        if (ariaNode.level)
+            key += ` [level=${ariaNode.level}]`;
+        if (ariaNode.pressed === 'mixed')
+            key += ` [pressed=mixed]`;
+        if (ariaNode.pressed === true)
+            key += ` [pressed]`;
+        if (ariaNode.selected === true)
+            key += ` [selected]`;
+        if (ariaNode.ref) {
+            key += ` [ref=${ariaNode.ref}]`;
+            if (renderCursorPointer && aria.hasPointerCursor(ariaNode))
+                key += ' [cursor=pointer]';
+        }
+        if (options.renderBoxes) {
+            const element = ariaNodeElement(ariaNode);
+            if (element) {
+                const r = element.getBoundingClientRect();
+                key += ` [box=${Math.round(r.x)},${Math.round(r.y)},${Math.round(r.width)},${Math.round(r.height)}]`;
+            }
+        }
+        return key;
+    };
+    const getSingleTextChild = (ariaNode) => {
+        return ariaNode.children.length === 1 && typeof ariaNode.children[0] === 'string' && !Object.keys(ariaNode.props).length ? ariaNode.children[0] : undefined;
+    };
+    const visit = (ariaNode, depth, renderCursorPointer) => {
+        if (publicOptions.depth && depth > publicOptions.depth)
+            return;
+        if (ariaNode.role === 'iframe' && ariaNode.ref)
+            iframeDepths[ariaNode.ref] = depth;
+        const escapedKey = indent(depth) + '- ' + yamlEscapeKeyIfNeeded(createKey(ariaNode, renderCursorPointer));
+        const singleTextChild = getSingleTextChild(ariaNode);
+        const isAtDepthLimit = !!publicOptions.depth && depth === publicOptions.depth;
+        const hasNoChildren = !singleTextChild && (!ariaNode.children.length || isAtDepthLimit);
+        if (hasNoChildren && !Object.keys(ariaNode.props).length) {
+            // Leaf node without children.
+            lines.push(escapedKey);
+        }
+        else if (singleTextChild !== undefined) {
+            // Leaf node with just some text inside.
+            const shouldInclude = includeText(ariaNode, singleTextChild);
+            if (shouldInclude)
+                lines.push(escapedKey + ': ' + yamlEscapeValueIfNeeded(renderString(singleTextChild)));
+            else
+                lines.push(escapedKey);
+        }
+        else {
+            // Node with (optional) props and some children.
+            lines.push(escapedKey + ':');
+            for (const [name, value] of Object.entries(ariaNode.props))
+                lines.push(indent(depth + 1) + '- /' + name + ': ' + yamlEscapeValueIfNeeded(value));
+            const inCursorPointer = !!ariaNode.ref && renderCursorPointer && aria.hasPointerCursor(ariaNode);
+            for (const child of ariaNode.children) {
+                if (typeof child === 'string')
+                    visitText(includeText(ariaNode, child) ? child : '', depth + 1);
+                else
+                    visit(child, depth + 1, renderCursorPointer && !inCursorPointer);
+            }
+        }
+    };
+    for (const nodeToRender of nodesToRender) {
+        if (typeof nodeToRender === 'string')
+            visitText(nodeToRender, 0);
+        else
+            visit(nodeToRender, 0, !!options.renderCursorPointer);
+    }
+    return { text: lines.join('\n'), iframeDepths };
+}
+function convertToBestGuessRegex(text) {
+    const dynamicContent = [
+        // 550e8400-e29b-41d4-a716-446655440000
+        { regex: /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/, replacement: '[0-9a-fA-F-]+' },
+        // 2mb
+        { regex: /\b[\d,.]+[bkmBKM]+\b/, replacement: '[\\d,.]+[bkmBKM]+' },
+        // 2ms, 20s
+        { regex: /\b\d+[hmsp]+\b/, replacement: '\\d+[hmsp]+' },
+        { regex: /\b[\d,.]+[hmsp]+\b/, replacement: '[\\d,.]+[hmsp]+' },
+        // Do not replace single digits with regex by default.
+        // 2+ digits: [Issue 22, 22.3, 2.33, 2,333]
+        { regex: /\b\d+,\d+\b/, replacement: '\\d+,\\d+' },
+        { regex: /\b\d+\.\d{2,}\b/, replacement: '\\d+\\.\\d+' },
+        { regex: /\b\d{2,}\.\d+\b/, replacement: '\\d+\\.\\d+' },
+        { regex: /\b\d{2,}\b/, replacement: '\\d+' },
+    ];
+    let pattern = '';
+    let lastIndex = 0;
+    const combinedRegex = new RegExp(dynamicContent.map(r => '(' + r.regex.source + ')').join('|'), 'g');
+    text.replace(combinedRegex, (match, ...args) => {
+        const offset = args[args.length - 2];
+        const groups = args.slice(0, -2);
+        pattern += escapeRegExp(text.slice(lastIndex, offset));
+        for (let i = 0; i < groups.length; i++) {
+            if (groups[i]) {
+                const { replacement } = dynamicContent[i];
+                pattern += replacement;
+                break;
+            }
+        }
+        lastIndex = offset + match.length;
+        return match;
+    });
+    if (!pattern)
+        return text;
+    pattern += escapeRegExp(text.slice(lastIndex));
+    return String(new RegExp(pattern));
+}
+function textContributesInfo(node, text) {
+    if (!text.length)
+        return false;
+    if (!node.name)
+        return true;
+    // Figure out if text adds any value. "longestCommonSubstring" is expensive, so limit strings length.
+    const substr = (text.length <= 200 && node.name.length <= 200) ? longestCommonSubstring(text, node.name) : '';
+    let filtered = text;
+    while (substr && filtered.includes(substr))
+        filtered = filtered.replace(substr, '');
+    return filtered.trim().length / text.length > 0.1;
+}
+const elementSymbol = Symbol('element');
+function ariaNodeElement(ariaNode) {
+    return ariaNode[elementSymbol];
+}
+function setAriaNodeElement(ariaNode, element) {
+    ariaNode[elementSymbol] = element;
+}
+export function findNewElement(from, to) {
+    const node = aria.findNewNode(from, to);
+    return node ? ariaNodeElement(node) : undefined;
+}

package/dist/plugins/steel/src/page/vendor/aria-snapshot/ariaSnapshotDistiller.js

@@ -0,0 +1,207 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { normalizeWhiteSpace } from './stringUtils.js';
+export function distillAriaSnapshot(snapshot, options) {
+    runPlugins(snapshot, options.mode === 'ai' ? aiPlugins : normalizePlugins, options);
+}
+function runPlugins(snapshot, plugins, options) {
+    const ctx = { snapshot, depth: -1, maxDepth: options.depth, ancestors: [], pendingContentRefs: new Set() };
+    const traverse = (node, depth) => {
+        const children = [];
+        const visitChild = (child) => {
+            if (typeof child === 'string') {
+                children.push(child);
+                return;
+            }
+            ctx.depth = depth + 1;
+            for (const plugin of plugins) {
+                const result = plugin.enter?.(child, ctx);
+                if (result === 'remove')
+                    return;
+                if (result === 'unwrap') {
+                    child.children.forEach(visitChild);
+                    return;
+                }
+            }
+            traverse(child, depth + 1);
+            ctx.depth = depth + 1;
+            for (const plugin of plugins) {
+                const result = plugin.exit?.(child, ctx);
+                if (result === 'remove')
+                    return;
+                if (result === 'unwrap') {
+                    children.push(...child.children);
+                    return;
+                }
+            }
+            children.push(child);
+        };
+        ctx.ancestors.push(node);
+        node.children.forEach(visitChild);
+        ctx.ancestors.pop();
+        node.children = children;
+    };
+    // Hooks run on the root as well, but the root cannot be removed or unwrapped.
+    for (const plugin of plugins)
+        plugin.enter?.(snapshot.root, ctx);
+    traverse(snapshot.root, -1);
+    ctx.depth = -1;
+    for (const plugin of plugins)
+        plugin.exit?.(snapshot.root, ctx);
+}
+// A generic node whose only content is text - it carries no structure of its own.
+function isLeafGeneric(node) {
+    return node.role === 'generic' && node.children.every(child => typeof child === 'string');
+}
+// The tree builder emits raw text tokens - text nodes, CSS content, block spacing markers - as
+// string children. Coalesce the adjacent ones, normalize whitespace and drop the empties, then
+// drop a lone text child that merely repeats the node's accessible name. Runs on `exit`, so the
+// merge sees the children in their final shape.
+const mergeStringChildren = {
+    name: 'mergeStringChildren',
+    exit(node) {
+        const children = [];
+        const buffer = [];
+        const flush = () => {
+            if (!buffer.length)
+                return;
+            const text = normalizeWhiteSpace(buffer.join(''));
+            if (text)
+                children.push(text);
+            buffer.length = 0;
+        };
+        for (const child of node.children) {
+            if (typeof child === 'string') {
+                buffer.push(child);
+            }
+            else {
+                flush();
+                children.push(child);
+            }
+        }
+        flush();
+        node.children = children;
+        if (node.children.length === 1 && node.children[0] === node.name)
+            node.children = [];
+    },
+};
+// Only unwrap a generic that encloses at most one element, logical grouping still makes sense,
+// even if it is not ref-able. The decision is made on `exit` - whether the node encloses a single
+// ref-bearing child is only known after its own descendants were unwrapped - so nested wrappers
+// collapse bottom-up.
+const unwrapSingleChildGenerics = {
+    name: 'unwrapSingleChildGenerics',
+    exit(node) {
+        if (node.role === 'generic' && !node.name && node.children.length <= 1 && node.children.every(child => typeof child !== 'string' && !!child.ref))
+            return 'unwrap';
+    },
+};
+// A decorative image - role `img` with no accessible name and no content - carries no
+// information. The decision is made on `exit` - whether the node has content is only known after
+// `mergeStringChildren` dropped the empty text tokens.
+const removeNamelessImages = {
+    name: 'removeNamelessImages',
+    exit(node) {
+        if (node.role === 'img' && !node.name && !node.children.length)
+            return 'remove';
+    },
+};
+// The node's accessible name is derived from content; when every node that contributed to it is
+// represented in the output anyway, the name would just repeat that content and is dropped.
+// Single-pass bookkeeping over the shared `pendingContentRefs` set: entering a node clears its
+// own ref - it is now represented - except for leaf generics, which only exist to supply text
+// and are dropped by `removeNameRepeatingChild` once a kept name shows it. On exit, either every
+// contributor was cleared and the name goes, or the kept name now represents its contributors,
+// so they are cleared for the benefit of the ancestors. A node removed on enter never clears its
+// ref, and an unwrapped one does - matching what remains in the tree.
+const removeRedundantNames = {
+    name: 'removeRedundantNames',
+    enter(node, ctx) {
+        if (!node.ref)
+            return;
+        for (const ref of ctx.snapshot.info.get(node.ref)?.nameFromContentRefs || [])
+            ctx.pendingContentRefs.add(ref);
+        const beyondDepth = !!ctx.maxDepth && ctx.depth > ctx.maxDepth;
+        if (!beyondDepth && !isLeafGeneric(node))
+            ctx.pendingContentRefs.delete(node.ref);
+    },
+    exit(node, ctx) {
+        if (!node.ref)
+            return;
+        const nameFromContentRefs = ctx.snapshot.info.get(node.ref)?.nameFromContentRefs;
+        if (!nameFromContentRefs?.length)
+            return;
+        if (nameFromContentRefs.every(ref => !ctx.pendingContentRefs.has(ref))) {
+            node.name = '';
+        }
+        else {
+            for (const ref of nameFromContentRefs)
+                ctx.pendingContentRefs.delete(ref);
+        }
+    },
+};
+// A generic whose whole content is a piece of text - a single text child, or just an accessible
+// name - that repeats the parent's accessible name adds no information, so it removes itself.
+// `inlineTextIntoGeneric` runs first, bubbling text up through nameless wrappers, so by the time
+// a wrapper exits its text faces the real parent - no need to look further up the ancestor chain.
+// Whenever the node is the source of that name, `removeRedundantNames` keeps the name - the node
+// is a leaf generic - so the text is never lost.
+const removeNameRepeatingChild = {
+    name: 'removeNameRepeatingChild',
+    exit(node, ctx) {
+        const parent = ctx.ancestors[ctx.ancestors.length - 1];
+        if (!parent?.name || node.role !== 'generic' || node.active || Object.keys(node.props).length)
+            return;
+        const singleTextChild = node.children.length === 1 && typeof node.children[0] === 'string' ? node.children[0] : undefined;
+        const text = node.name ? (node.children.length ? undefined : node.name) : singleTextChild;
+        if (text && text === parent.name)
+            return 'remove';
+    },
+};
+// A generic whose only child is a nameless leaf generic inlines that child's text:
+// `generic: - generic: "text"` becomes `generic: "text"`. Runs post-order, so chains collapse
+// bottom-up, and after the other plugins already removed or unwrapped the children.
+const inlineTextIntoGeneric = {
+    name: 'inlineTextIntoGeneric',
+    exit(node) {
+        if (node.role !== 'generic' || Object.keys(node.props).length || node.children.length !== 1)
+            return;
+        const child = node.children[0];
+        if (typeof child === 'string')
+            return;
+        if (child.role !== 'generic' || child.name || child.active || Object.keys(child.props).length)
+            return;
+        if (child.children.length === 1 && typeof child.children[0] === 'string')
+            node.children = [child.children[0]];
+    },
+};
+// Structural normalization applies to all modes - it defines the canonical tree shape.
+const normalizePlugins = [
+    mergeStringChildren,
+    unwrapSingleChildGenerics,
+];
+// The ai preset compresses the snapshot on top of normalization. It runs as one traversal:
+// `removeRedundantNames` bookkeeping must observe every node the tree retains, including the
+// wrappers that `unwrapSingleChildGenerics` is about to unwrap. On exit, text is first inlined
+// into the node, so that `removeNameRepeatingChild` faces the real parent when it compares.
+const aiPlugins = [
+    mergeStringChildren,
+    removeNamelessImages,
+    removeRedundantNames,
+    inlineTextIntoGeneric,
+    removeNameRepeatingChild,
+    unwrapSingleChildGenerics,
+];

package/dist/plugins/steel/src/page/vendor/aria-snapshot/ariaTypes.js

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export function hasPointerCursor(ariaNode) {
+    return ariaNode.box.cursor === 'pointer';
+}
+export function findNewNode(from, to) {
+    function fillMap(root, map, position) {
+        let size = 1;
+        let childPosition = position + size;
+        for (const child of root.children || []) {
+            if (typeof child === 'string') {
+                size++;
+                childPosition++;
+            }
+            else {
+                size += fillMap(child, map, childPosition);
+                childPosition += size;
+            }
+        }
+        if (!['none', 'presentation', 'fragment', 'iframe', 'generic'].includes(root.role) && root.name) {
+            let byRole = map.get(root.role);
+            if (!byRole) {
+                byRole = new Map();
+                map.set(root.role, byRole);
+            }
+            const existing = byRole.get(root.name);
+            // This heuristic prioritizes elements at the top of the page, even if somewhat smaller.
+            const sizeAndPosition = size * 100 - position;
+            if (!existing || existing.sizeAndPosition < sizeAndPosition)
+                byRole.set(root.name, { node: root, sizeAndPosition });
+        }
+        return size;
+    }
+    const fromMap = new Map();
+    if (from)
+        fillMap(from, fromMap, 0);
+    const toMap = new Map();
+    fillMap(to, toMap, 0);
+    const result = [];
+    for (const [role, byRole] of toMap) {
+        for (const [name, byName] of byRole) {
+            const inFrom = fromMap.get(role)?.get(name);
+            if (!inFrom)
+                result.push(byName);
+        }
+    }
+    result.sort((a, b) => b.sizeAndPosition - a.sizeAndPosition);
+    return result[0]?.node;
+}