@e2e-dev/web 0.12.0 → 0.14.0-nightly-20261008205824

package/dist/browser.js

@@ -12,9 +12,10 @@
  * says which URLs a test may open.
  */
 import { ConfigurationError, Deadline, describePattern, EngineError, matchesText, pollCondition, raceAbort, rejectUnknownOptions, TestError, toTextPattern, urlMatches, validateJsonValue, withTimeout, } from 'e2e/engine';
+import { classifyInputError } from './actions.js';
 import { saveDownloadsTo, saveFromBrowser, saveLocally } from './downloads.js';
 import { isTestErrorCode, message as causeMessage, translatePwError } from './support.js';
-import { compileEvaluation } from './evaluation.js';
+import { compileEvaluation, pageFunctionSource } from './evaluation.js';
 import { initScriptLabel, testInitScriptSource } from './init-scripts.js';
 import { lowercaseNames } from './protected-app.js';
 import { parseContinue, parseFulfill, requireNoArguments } from './route-options.js';
@@ -62,31 +63,33 @@ export function createBrowserFixture(surface, context) {
     };
     /** An assertion-style budget: the given timeout or the assertion timeout, clamped to the test. */
     const deadlineFor = (timeout) => new Deadline(context.operation(timeout ?? context.timeouts.assertion).timeoutMs);
-    const currentUrl = () => surface.guard(context.operation(), 'url', async () => surface.requirePage().url());
-    const currentTitle = () => surface.guard(context.operation(), 'title', () => surface.requirePage().title());
+    /** The page URL, read within the action timeout or, for a matcher poll, within the poll's deadline. */
+    const currentUrl = (deadline) => surface.guard(context.operation(deadline?.remaining()), 'url', async () => surface.requirePage().url());
+    /** The page title, read within the action timeout or, for a matcher poll, within the poll's deadline. */
+    const currentTitle = (deadline) => surface.guard(context.operation(deadline?.remaining()), 'title', () => surface.requirePage().title());
     const expectation = createBrowserExpectation({ currentUrl, currentTitle, baseHref, deadlineFor, context });
     const browser = {
         goto(url, options) {
             const resolved = context.app.resolveUrl(url);
-            return navigation(options, async (operation) => {
+            return navigation(options, (operation) => surface.navigating(async () => {
                 const page = await surface.ensurePage();
                 await page.goto(resolved, {
                     waitUntil: options?.waitUntil ?? 'load',
                     timeout: operation.timeoutMs,
                 });
-            });
+            }));
         },
-        reload: (options) => navigation(options, async (operation) => {
+        reload: (options) => navigation(options, (operation) => surface.navigating(async () => {
             await surface.requirePage().reload({ waitUntil: 'load', timeout: operation.timeoutMs });
-        }),
-        back: (options) => navigation(options, async (operation) => {
+        })),
+        back: (options) => navigation(options, (operation) => surface.navigating(async () => {
             await surface.requirePage().goBack({ waitUntil: 'load', timeout: operation.timeoutMs });
-        }),
-        forward: (options) => navigation(options, async (operation) => {
+        })),
+        forward: (options) => navigation(options, (operation) => surface.navigating(async () => {
             await surface.requirePage().goForward({ waitUntil: 'load', timeout: operation.timeoutMs });
-        }),
-        url: currentUrl,
-        title: currentTitle,
+        })),
+        url: () => currentUrl(),
+        title: () => currentTitle(),
         // The same poll as `expect(browser).toHaveURL`, exposed as a wait.
         waitForURL: (url, options) => {
             rejectUnknownOptions('browser.waitForURL', options, ['timeout']);
@@ -95,7 +98,7 @@ export function createBrowserFixture(surface, context) {
         locator: (selector) => context.locator({ kind: 'selector', selector: requireSelector('browser.locator', selector) }),
         frameLocator: (selector) => frameScreen(context, [requireSelector('browser.frameLocator', selector)]),
         async evaluate(fn, arg) {
-            const source = typeof fn === 'string' ? fn : fn.toString();
+            const source = typeof fn === 'string' ? fn : pageFunctionSource(fn);
             validateJsonValue(arg, 'evaluate argument');
             const evaluate = compileEvaluation(source, arg !== undefined);
             // JSON safety is checked above; Playwright's recursive argument type cannot expand JsonValue.
@@ -329,17 +332,17 @@ export function createBrowserFixture(surface, context) {
                     return new TestError('ACTION_FAILED', `no download started within ${awaiting.waitMs}ms; the trigger resolved after ${awaiting.triggerMs}ms`, { cause });
                 }
                 return translated;
-            });
+            }, 'test-code');
         },
         keyboard: {
-            press: (key) => surface.guard(context.operation(), 'keyboard.press', () => surface.requirePage().keyboard.press(key)),
-            type: (text) => surface.guard(context.operation(), 'keyboard.type', () => surface.requirePage().keyboard.type(text)),
+            press: (key) => surface.guard(context.operation(), 'keyboard.press', () => surface.requirePage().keyboard.press(key), classifyInputError),
+            type: (text) => surface.guard(context.operation(), 'keyboard.type', () => surface.requirePage().keyboard.type(text), classifyInputError),
         },
         mouse: {
-            move: (x, y) => surface.guard(context.operation(), 'mouse.move', () => surface.requirePage().mouse.move(x, y)),
-            wheel: (deltaX, deltaY) => surface.guard(context.operation(), 'mouse.wheel', () => surface.requirePage().mouse.wheel(deltaX, deltaY)),
-            down: () => surface.guard(context.operation(), 'mouse.down', () => surface.requirePage().mouse.down()),
-            up: () => surface.guard(context.operation(), 'mouse.up', () => surface.requirePage().mouse.up()),
+            move: (x, y) => surface.guard(context.operation(), 'mouse.move', () => surface.requirePage().mouse.move(x, y), classifyInputError),
+            wheel: (deltaX, deltaY) => surface.guard(context.operation(), 'mouse.wheel', () => surface.requirePage().mouse.wheel(deltaX, deltaY), classifyInputError),
+            down: () => surface.guard(context.operation(), 'mouse.down', () => surface.requirePage().mouse.down(), classifyInputError),
+            up: () => surface.guard(context.operation(), 'mouse.up', () => surface.requirePage().mouse.up(), classifyInputError),
         },
     };
     const action = { kind: 'resource' };
@@ -372,15 +375,26 @@ export function createBrowserFixture(surface, context) {
         mouse: { move: action, wheel: action, down: action, up: action },
     });
 }
-/** `expect(browser)` matchers: URL, title, and class polling against the assertion budget. */
+/**
+ * `expect(browser)` matchers: URL, title, and class polling against the
+ * assertion budget. Every read is bounded by the poll's deadline, so a page
+ * that stops answering ends the assertion at its own timeout, and the
+ * failure reports the last read instead of reading a hung page again.
+ */
 function createBrowserExpectation(deps, negated = false) {
-    const poll = async (api, label, condition, observed, timeout) => {
+    const poll = async (api, label, read, timeout) => {
+        const deadline = deps.deadlineFor(timeout);
+        // pollCondition calls onTimeout only after a read completed, so a sample is always there.
+        let last;
         await pollCondition({
-            deadline: deps.deadlineFor(timeout),
+            deadline,
             signal: deps.context.signal,
             negated,
-            evaluate: condition,
-            onTimeout: async () => new TestError('ASSERTION_FAILED', `expect.${negated ? 'not.' : ''}${api} failed\nexpected: ${negated ? 'not ' : ''}${label}\nobserved: ${await observed()}`),
+            evaluate: async () => {
+                last = await read(deadline);
+                return last.matches;
+            },
+            onTimeout: (cause) => new TestError('ASSERTION_FAILED', `expect.${negated ? 'not.' : ''}${api} failed\nexpected: ${negated ? 'not ' : ''}${label}\nobserved: ${last?.observed ?? 'nothing'}`, cause === undefined ? undefined : { cause }),
         });
     };
     const validate = (api, options, keys = ['timeout']) => rejectUnknownOptions(`expect.${negated ? 'not.' : ''}${api}`, options, keys);
@@ -396,41 +410,39 @@ function createBrowserExpectation(deps, negated = false) {
             }
             const label = typeof expected === 'string' ? expected : String(expected);
             const target = deps.baseHref();
-            return poll('toHaveURL', `URL ${label}${ignoreCase === true ? ' (ignoring case)' : ''}`, async () => urlMatches(await deps.currentUrl(), expected, target, ignoreCase), async () => `URL ${await deps.currentUrl()}`, options?.timeout);
+            return poll('toHaveURL', `URL ${label}${ignoreCase === true ? ' (ignoring case)' : ''}`, async (deadline) => {
+                const url = await deps.currentUrl(deadline);
+                return { matches: urlMatches(url, expected, target, ignoreCase), observed: `URL ${url}` };
+            }, options?.timeout);
         },
         toHaveTitle(expected, options) {
             validate('toHaveTitle', options);
             const pattern = toTextPattern(expected, { exact: true });
-            return poll('toHaveTitle', `title ${describePattern(pattern)}`, async () => matchesText(await deps.currentTitle(), pattern), async () => `title ${JSON.stringify(await deps.currentTitle())}`, options?.timeout);
+            return poll('toHaveTitle', `title ${describePattern(pattern)}`, async (deadline) => {
+                const title = await deps.currentTitle(deadline);
+                return { matches: matchesText(title, pattern), observed: `title ${JSON.stringify(title)}` };
+            }, options?.timeout);
         },
         toHaveClass(target, expected, options) {
             validate('toHaveClass', options);
             const pattern = toTextPattern(expected, { exact: true });
-            return poll('toHaveClass', `class ${describePattern(pattern)}`, async () => {
+            return poll('toHaveClass', `class ${describePattern(pattern)}`, async (deadline) => {
+                let value;
                 try {
-                    const value = await target.getAttribute('class');
-                    if (value === null)
-                        return false;
-                    const normalized = value.trim().split(/\s+/).join(' ');
-                    return matchesText(normalized, pattern);
+                    // A locator read takes the action timeout; the poll's deadline is the tighter bound.
+                    value = await withTimeout(target.getAttribute('class'), deadline.remaining(), () => new EngineError('OPERATION_TIMEOUT', 'class read timed out', { retryable: false }));
                 }
                 catch (error) {
                     if (isTestErrorCode(error, 'LOCATOR_NOT_FOUND'))
-                        return undefined;
-                    throw error;
-                }
-            }, async () => {
-                try {
-                    const value = await target.getAttribute('class');
-                    if (value === null)
-                        return 'no class attribute';
-                    return `class ${JSON.stringify(value)}`;
-                }
-                catch (error) {
-                    if (isTestErrorCode(error, 'LOCATOR_NOT_FOUND'))
-                        return 'no node';
+                        return { matches: undefined, observed: 'no node' };
                     throw error;
                 }
+                if (value === null)
+                    return { matches: false, observed: 'no class attribute' };
+                return {
+                    matches: matchesText(value.trim().split(/\s+/).join(' '), pattern),
+                    observed: `class ${JSON.stringify(value)}`,
+                };
             }, options?.timeout);
         },
     };

package/dist/dialogs.js

@@ -45,15 +45,18 @@ export class DialogRouter {
             return;
         }
         let decided = false;
+        let answered = false;
         const publicDialog = {
             message: dialog.message(),
             accept: async (text) => {
                 decided = true;
                 await dialog.accept(text);
+                answered = true;
             },
             dismiss: async () => {
                 decided = true;
                 await dialog.dismiss();
+                answered = true;
             },
         };
         try {
@@ -81,6 +84,8 @@ export class DialogRouter {
                     retryable: false,
                     cause,
                 }));
+            if (!answered)
+                await dialog.dismiss().catch(() => undefined);
         }
     }
 }

package/dist/engine.js

@@ -104,8 +104,6 @@ export function web(options = {}) {
         },
         artifacts: {
             screenshot: (label, operation) => surface.screenshot(label, operation),
-            startTrace: (operation) => surface.startTrace(operation),
-            stopTrace: (operation) => surface.stopTrace(operation),
             startVideo: (operation) => surface.startVideo(operation),
             stopVideo: (operation) => surface.stopVideo(operation),
         },

package/dist/evaluation.d.ts

@@ -7,13 +7,18 @@ type EvaluationResult = {
 };
 /** The `__name` helper tsx's `keepNames` output calls, declared beside test code serialized into the page. */
 export declare const KEEP_NAMES_HELPER = "const __name = (target, value) => Object.defineProperty(target, 'name', { value, configurable: true });";
+/** A function expression for page code, including ordinary and async method shorthand. Never runs it here. */
+export declare function pageFunctionSource(fn: (...args: never[]) => unknown): string;
 /**
  * Compiles the page-side error boundary without evaluating the caller's source in this process.
+ * The source is one expression: a function it evaluates to is called with the argument, any
+ * other value is the result.
  *
  * A function serialized with `toString()` carries whatever the loader compiled
- * it to. tsx runs esbuild with `keepNames`, which wraps every nested named
- * binding in a module-scoped `__name(target, name)` helper; the page has no
- * such helper, so the same one is declared next to the inlined source.
+ * it to. e2e before 0.17 loaded tests through tsx, whose esbuild `keepNames`
+ * wraps every nested named binding in a module-scoped `__name(target, name)`
+ * helper; the page has no such helper, so the same one is declared next to
+ * the inlined source for as long as this engine supports those runners.
  */
 export declare function compileEvaluation(source: string, hasArgument: boolean): (arg: unknown) => Promise<EvaluationResult>;
 export {};

package/dist/evaluation.js

@@ -3,13 +3,47 @@ import { TestError } from 'e2e/engine';
 import { message } from './support.js';
 /** The `__name` helper tsx's `keepNames` output calls, declared beside test code serialized into the page. */
 export const KEEP_NAMES_HELPER = "const __name = (target, value) => Object.defineProperty(target, 'name', { value, configurable: true });";
+/** A function expression for page code, including ordinary and async method shorthand. Never runs it here. */
+export function pageFunctionSource(fn) {
+    const source = fn.toString().trim();
+    const parse = (text) => new Function(`return (${text}\n);`);
+    try {
+        parse(source);
+        return source;
+    }
+    catch {
+        // Method toString() omits the function keyword; an arrow or function expression already parsed above.
+        const ordinary = `function ${source}`;
+        let expression;
+        try {
+            parse(ordinary);
+            expression = ordinary;
+        }
+        catch (cause) {
+            if (!/^async\b/.test(source)) {
+                throw new TestError('EVALUATE_FAILED', 'page function cannot be serialized', { cause });
+            }
+            expression = `async function ${source.slice('async'.length)}`;
+        }
+        try {
+            parse(expression);
+            return expression;
+        }
+        catch (cause) {
+            throw new TestError('EVALUATE_FAILED', 'page function cannot be serialized', { cause });
+        }
+    }
+}
 /**
  * Compiles the page-side error boundary without evaluating the caller's source in this process.
+ * The source is one expression: a function it evaluates to is called with the argument, any
+ * other value is the result.
  *
  * A function serialized with `toString()` carries whatever the loader compiled
- * it to. tsx runs esbuild with `keepNames`, which wraps every nested named
- * binding in a module-scoped `__name(target, name)` helper; the page has no
- * such helper, so the same one is declared next to the inlined source.
+ * it to. e2e before 0.17 loaded tests through tsx, whose esbuild `keepNames`
+ * wraps every nested named binding in a module-scoped `__name(target, name)`
+ * helper; the page has no such helper, so the same one is declared next to
+ * the inlined source for as long as this engine supports those runners.
  */
 export function compileEvaluation(source, hasArgument) {
     try {
@@ -17,7 +51,7 @@ export function compileEvaluation(source, hasArgument) {
       return (async () => {
         ${KEEP_NAMES_HELPER}
         try {
-          return { ok: true, value: await (${source}\n)(${hasArgument ? 'arg' : ''}) };
+          return { ok: true, value: await ((result) => typeof result === 'function' ? result(${hasArgument ? 'arg' : ''}) : result)((${source}\n)) };
         } catch (cause) {
           let message;
           try {

package/dist/in-page/read-semantics.js

@@ -54,11 +54,11 @@ export const readSemanticsFunction = (element, options) => {
     const PLACEHOLDER_NAMED_INPUT_TYPES = ['text', 'password', 'number', 'search', 'tel', 'email', 'url'];
     /**
      * How the active mode projects one node, expressed as data so `describe`
-     * stays branch-free. Tree mode is the model-bound projection: bounded text,
-     * a bounded attribute projection, hrefs reduced to origin+path, the root
-     * document named by its title, and no value on a checkbox or radio, whose
-     * value attribute is an app token its checked state already says more
-     * than. Node mode is the full locator-read surface.
+     * stays branch-free. Tree mode is the model-bound projection: bounded line
+     * text (`lineTextOf`), a bounded attribute projection, hrefs reduced to
+     * origin+path, the root document named by its title, and no value on a
+     * checkbox or radio, whose value attribute is an app token its checked
+     * state already says more than. Node mode is the full locator-read surface.
      */
     const projection = options.mode.kind === 'tree'
         ? {
@@ -66,7 +66,7 @@ export const readSemanticsFunction = (element, options) => {
             textLimit: options.mode.textLimit,
             nameLimit: options.mode.nameLimit,
             redactHref: true,
-            directTextOnly: true,
+            lineText: true,
             documentRoot: true,
             checkableValue: false,
         }
@@ -75,7 +75,7 @@ export const readSemanticsFunction = (element, options) => {
             textLimit: null,
             nameLimit: null,
             redactHref: false,
-            directTextOnly: false,
+            lineText: false,
             documentRoot: false,
             checkableValue: true,
         };
@@ -111,7 +111,15 @@ export const readSemanticsFunction = (element, options) => {
      * HTML-AAM scopes it to sectioning content and to the ARIA roles that stand
      * for it, so a `<div role="article">` scopes it like an `<article>`.
      */
-    const isPageLevel = (el) => el.closest(SECTIONING_SCOPE) === null;
+    const isPageLevel = (el) => {
+        for (let candidate = el; candidate !== null;) {
+            if (candidate.closest(SECTIONING_SCOPE) !== null)
+                return false;
+            const root = candidate.getRootNode();
+            candidate = root instanceof ShadowRoot ? root.host : null;
+        }
+        return true;
+    };
     /**
      * The root of a contenteditable region: editable itself, under a parent that
      * is not. A rich-text editor (ProseMirror, TipTap, Lexical, Slate) renders
@@ -219,7 +227,21 @@ export const readSemanticsFunction = (element, options) => {
             }
             case 'th': {
                 const scope = (el.getAttribute('scope') ?? '').toLowerCase();
-                return scope === 'row' || scope === 'rowgroup' ? 'rowheader' : 'columnheader';
+                if (scope === 'row' || scope === 'rowgroup')
+                    return 'rowheader';
+                if (scope === 'col' || scope === 'colgroup')
+                    return 'columnheader';
+                const previous = el.previousElementSibling;
+                const next = el.nextElementSibling;
+                if (previous === null && next === null) {
+                    const row = el.parentElement;
+                    const table = row?.tagName.toLowerCase() === 'tr' ? row.closest('table') : null;
+                    return table !== null && table.rows.length <= 1 ? null : 'columnheader';
+                }
+                if (previous?.tagName.toLowerCase() === 'th' && next?.tagName.toLowerCase() === 'th')
+                    return 'columnheader';
+                const hasDataNeighbor = [previous, next].some((cell) => cell?.tagName.toLowerCase() === 'td' && ((cell.textContent ?? '').trim() !== '' || cell.children.length > 0));
+                return hasDataNeighbor ? 'rowheader' : 'columnheader';
             }
             case 'dialog':
                 return 'dialog';
@@ -354,7 +376,7 @@ export const readSemanticsFunction = (element, options) => {
     /** An element's `::after` contribution, once per read. */
     const afterContentOf = memoized((el) => generatedContentOf(el, '::after'));
     /** True for a subtree the name computation drops: aria-hidden, or hidden by style as innerText leaves it out. */
-    const isNameHidden = (el, style) => el.getAttribute('aria-hidden') === 'true' ||
+    const isNameHidden = (el, style) => (el.getAttribute('aria-hidden') ?? '').toLowerCase() === 'true' ||
         (style !== undefined && (style.display === 'none' || style.visibility === 'hidden'));
     /** `alt` of an element HTML-AAM names by it: an `<img>` or an `<input type="image">`. */
     const altOf = (el) => {
@@ -385,7 +407,7 @@ export const readSemanticsFunction = (element, options) => {
      * under an `aria-hidden` ancestor, which excludes it from the tree as
      * surely as its own attribute would.
      */
-    const isReferenceHidden = (el) => isHidden(el) || el.closest('[aria-hidden="true"]') !== null;
+    const isReferenceHidden = (el) => isHidden(el) || el.closest('[aria-hidden="true" i]') !== null;
     /**
      * The element an id names for `el`, looked up in `el`'s own tree: an IDREF
      * resolves in the tree scope it is written in, so a shadow tree's ids are
@@ -668,6 +690,121 @@ export const readSemanticsFunction = (element, options) => {
         }
         return out.replace(/\s+/g, ' ').trim();
     });
+    /**
+     * Elements whose content is not text in a line: a form control's options
+     * or value, a picture, a frame, a drawn surface. Like a line break, each
+     * separates the words around it.
+     */
+    const LINE_BREAKING_TAGS = [...SKIP_TAGS, ...OPAQUE_TAGS, 'iframe', 'img', 'input', 'select', 'textarea', 'br'];
+    /**
+     * True when an element's text flows in its parent's line: a visible
+     * inline-level box (`inline`, `inline-block`, `ruby`), or `display:
+     * contents`, whose children lay out as the parent's own. Visible as the
+     * walk reads it (`isHidden`): a box with no size shows no words. A slot
+     * has no box and shows the nodes assigned to it, so only its visibility
+     * counts: a hidden one hides the text they inherit it with, and a child
+     * that shows itself again is listed on its own.
+     */
+    const flowsInLine = memoized((el) => {
+        if (LINE_BREAKING_TAGS.indexOf(el.tagName.toLowerCase()) !== -1 || isEditingHost(el))
+            return false;
+        const style = styleOf(el);
+        if (style === undefined || hidesSubtree(el, style))
+            return false;
+        if (el instanceof HTMLSlotElement ? style.visibility !== 'visible' : isHidden(el, style))
+            return false;
+        return isInlineLevel(style);
+    });
+    /** True for a box laid out in its parent's line, or for `display: contents`, which lays out none of its own. */
+    const isInlineLevel = (style) => style.display.startsWith('inline') || style.display.startsWith('ruby') || style.display === 'contents';
+    /**
+     * The nodes an element renders in its place, as the walk reaches them: a
+     * shadow host's shadow tree (a closed one through the record), a slot's
+     * assigned nodes or else its fallback content, any other element's children.
+     */
+    const renderedChildrenOf = (el) => {
+        const shadow = shadowRootOf(el);
+        if (shadow !== null)
+            return Array.from(shadow.childNodes);
+        if (el instanceof HTMLSlotElement) {
+            const assigned = el.assignedNodes();
+            if (assigned.length > 0)
+                return assigned;
+        }
+        return Array.from(el.childNodes);
+    };
+    /**
+     * An element's rendered text with each inline descendant's text in place.
+     * Anything else in the line reads as a space, except a hidden inline
+     * element (a `<wbr>`, a zero-size span), which shows nothing.
+     */
+    const lineRunOf = (el) => {
+        let out = '';
+        for (const child of renderedChildrenOf(el)) {
+            if (child.nodeType === 3)
+                out += child.nodeValue ?? '';
+            if (child.nodeType !== 1)
+                continue;
+            const inner = child;
+            if (flowsInLine(inner)) {
+                out += lineRunOf(inner);
+                continue;
+            }
+            const style = styleOf(inner);
+            if (style === undefined || hidesSubtree(inner, style))
+                continue;
+            const breaking = LINE_BREAKING_TAGS.indexOf(inner.tagName.toLowerCase()) !== -1;
+            if (breaking || !isInlineLevel(style) || !isHidden(inner, style))
+                out += ' ';
+        }
+        return out;
+    };
+    /**
+     * The text an element owns, read as a person reads its line: its own text
+     * with every inline descendant's text in place, so `<p>Read our <a>privacy
+     * policy</a> for details.</p>` reads as the whole sentence while the link
+     * stays a node of its own. Block-level descendants are nodes of their own
+     * and only separate words. An element with no text of its own owns none: a
+     * wrapper of elements leaves them to say what they say (`ownsLine`).
+     */
+    const lineTextOf = memoized((el) => ownsLine(el) ? lineRunOf(el).replace(/\s+/g, ' ').trim() : '');
+    /**
+     * True when an element reads its own line: it has text of its own, or it
+     * offers an action inside an ancestor's line, where its words are what a
+     * person aims at.
+     */
+    const ownsLine = (el) => directTextOf(el) !== '' || (offersAction(el) && isReadInLine(el));
+    /**
+     * True when an element with no role still says it can be acted on: it is
+     * focusable through `tabindex`, it has a click handler set as an attribute
+     * or a property (`onclick`), or it is an `<a>` with no `href`, which an app
+     * wires up by script. Such an element stays listed inside a line, so it
+     * keeps an id to act on. A handler added with `addEventListener` leaves
+     * nothing the page can read.
+     */
+    const offersAction = memoized((el) => {
+        const tabindex = el.getAttribute('tabindex');
+        if (tabindex !== null && /^\s*[-+]?\d/.test(tabindex))
+            return true;
+        if (el.tagName.toLowerCase() === 'a' || el.hasAttribute('onclick'))
+            return true;
+        return el instanceof HTMLElement && el.onclick !== null;
+    });
+    /**
+     * True when an element's text is already read in an ancestor's line
+     * (`lineTextOf`), so the element has nothing to add on text alone. A line
+     * longer than the projection's text bound is cut, so its inline
+     * descendants stay listed and nothing past the cut is lost.
+     */
+    const isReadInLine = memoized((el) => {
+        const parent = el.assignedSlot ?? parentOrHostOf(el);
+        if (parent === null || !flowsInLine(el))
+            return false;
+        if (!ownsLine(parent))
+            return isReadInLine(parent);
+        const fits = projection.textLimit === null || lineTextOf(parent).length <= projection.textLimit;
+        return fits && !isHidden(parent);
+    });
     const accessibleName = memoized((el) => {
         // accname reads a labelledby reference (2B) before the element's own aria-label (2C).
         const referenced = referencedNamesOf(el, nameWalk([], true));
@@ -891,7 +1028,7 @@ export const readSemanticsFunction = (element, options) => {
      * edges. The walk goes on through both and only the element itself stays
      * unlisted.
      */
-    const hidesSubtree = (el, style) => el.getAttribute('aria-hidden') === 'true' ||
+    const hidesSubtree = (el, style) => (el.getAttribute('aria-hidden') ?? '').toLowerCase() === 'true' ||
         isInert(el, style) ||
         style === undefined ||
         style.display === 'none' ||
@@ -1180,7 +1317,7 @@ export const readSemanticsFunction = (element, options) => {
         if (selectedState === null) {
             const ariaSelected = el.getAttribute('aria-selected');
             if (ariaSelected !== null)
-                selectedState = ariaSelected === 'true';
+                selectedState = ariaSelected.toLowerCase() === 'true';
         }
         const disabled = isDisabled(el);
         const ariaExpanded = el.getAttribute('aria-expanded');
@@ -1224,8 +1361,8 @@ export const readSemanticsFunction = (element, options) => {
         let text;
         if (secure)
             text = '';
-        else if (projection.directTextOnly)
-            text = directTextOf(el);
+        else if (projection.lineText)
+            text = lineTextOf(el);
         else
             text = textOf(el);
         if (projection.textLimit !== null)
@@ -1320,7 +1457,9 @@ export const readSemanticsFunction = (element, options) => {
             return true;
         if (accessibleName(el) !== null)
             return true;
-        return directTextOf(el) !== '';
+        if (offersAction(el) && isReadInLine(el))
+            return lineTextOf(el) !== '';
+        return directTextOf(el) !== '' && !isReadInLine(el);
     };
     const walk = (el, parent) => {
         if (truncated)

package/dist/init-scripts.js

@@ -7,7 +7,7 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { ConfigurationError, TestError, validateJsonValue } from 'e2e/engine';
-import { KEEP_NAMES_HELPER } from './evaluation.js';
+import { KEEP_NAMES_HELPER, pageFunctionSource } from './evaluation.js';
 import { message } from './support.js';
 /** Refuses, at config load, a `web({ initScripts })` value that is not a list of scripts. */
 export function validateInitScripts(scripts) {
@@ -93,7 +93,7 @@ async function initScriptSource(script, arg, resolvePath) {
     if (typeof script === 'string')
         return script;
     if (typeof script === 'function') {
-        return `(() => {\n${KEEP_NAMES_HELPER}\n(${script.toString()}\n)(${arg === undefined ? '' : `JSON.parse(${JSON.stringify(JSON.stringify(arg))})`});\n})();`;
+        return `(() => {\n${KEEP_NAMES_HELPER}\n(${pageFunctionSource(script)}\n)(${arg === undefined ? '' : `JSON.parse(${JSON.stringify(JSON.stringify(arg))})`});\n})();`;
     }
     const file = resolvePath(script.path);
     try {

package/dist/install.d.ts

@@ -15,6 +15,8 @@ export interface InstallContext {
     readonly signal?: AbortSignal | undefined;
     /** Environment the installer runs with: the run's, so it fills the cache the workers will launch from. */
     readonly env: NodeJS.ProcessEnv;
+    /** Whether the run launches a window, which decides the chromium build it needs. */
+    readonly headed: boolean;
 }
 export interface EnsureBrowsersOptions {
     /**
@@ -34,7 +36,11 @@ export interface EnsureBrowsersOptions {
     readonly signal?: AbortSignal;
     /** The run's environment; defaults to this process's. */
     readonly env?: NodeJS.ProcessEnv;
+    /** Whether the run launches a window, which decides the chromium build it needs. Defaults to false. */
+    readonly headed?: boolean;
 }
+/** The `playwright install` arguments for `names`: `--only-shell` on a headless chromium run. */
+export declare function installArgs(names: readonly BrowserName[], headed: boolean): string[];
 /**
  * Ensures the given Playwright browsers are installed, downloading any
  * missing ones via `playwright-core install`. Called from the engine's `prepare`,