@e2e-dev/web 0.15.5-nightly-20261105030216 → 0.15.5

package/README.md

@@ -146,4 +146,4 @@ ones the engine launches. Under pnpm, run the bin by name:
 
 ## Documentation
 
-Full documentation lives at [e2e.tester.army/docs](https://e2e.tester.army/docs).
+Full documentation lives at [e2e.com/docs](https://e2e.com/docs).

package/dist/.build.json

@@ -1 +1 @@
-{"version":"0.15.5-nightly-20261105030216"}
+{"version":"0.15.5"}

package/dist/actions.d.ts

@@ -8,7 +8,7 @@ import type { ConnectionBudget } from './operation-budget.ts';
  * platform's own actionability checks. `lookup` resolves the second ref of a
  * drag; everything else needs only the target.
  */
-export declare function dispatchLocatorAction(target: ActionTarget, action: LocatorAction, operation: ConnectionBudget, lookup: (ref: NodeRef) => ActionTarget): Promise<void>;
+export declare function dispatchLocatorAction(target: ActionTarget, action: LocatorAction, operation: ConnectionBudget, lookup: (ref: NodeRef) => Promise<ActionTarget>): Promise<void>;
 /**
  * Dispatches one pointer action at a viewport point with nothing resolved
  * behind it: no actionability wait, because there is no element to wait on,

package/dist/actions.js

@@ -34,13 +34,15 @@ async function setChecked(target, checked, operation) {
     try {
         if ((await element.isChecked()) === checked)
             return;
-        if (!checked && (await isRadio(element))) {
+        const radio = checked ? undefined : await radioKind(element);
+        if (radio === 'native') {
             throw new EngineError('NOT_ACTIONABLE', 'uncheck cannot clear a radio button; select another radio in its group', {
                 retryable: false,
             });
         }
         await element.click({ timeout: remaining() });
-        const unchanged = (detail = '') => new EngineError('NOT_ACTIONABLE', `${verb} clicked the control but its checked state did not change${detail}`, {
+        const hint = radio === 'aria' ? '; a radio usually clears only when another radio in its group is selected' : '';
+        const unchanged = (detail = '') => new EngineError('NOT_ACTIONABLE', `${verb} clicked the control but its checked state did not change${detail}${hint}`, {
             retryable: false,
         });
         let firstRead = true;
@@ -70,9 +72,17 @@ async function setChecked(target, checked, operation) {
             void element.dispose().catch(() => undefined);
     }
 }
-/** Whether a checkable element is a radio, which a click can select but never clear. */
-function isRadio(element) {
-    return element.evaluate((node) => (node instanceof HTMLInputElement && node.type === 'radio') || node.getAttribute('role') === 'radio');
+/**
+ * Which kind of radio a checkable element is, if any. A native radio can be
+ * selected but never cleared by a click. An ARIA radio is clicked like any
+ * control, as Playwright does: its script decides what a click does.
+ */
+function radioKind(element) {
+    return element.evaluate((node) => {
+        if (node instanceof HTMLInputElement && node.type === 'radio')
+            return 'native';
+        return node.getAttribute('role') === 'radio' ? 'aria' : undefined;
+    });
 }
 /**
  * Attaches files to a file input, or to a control that opens a native file
@@ -190,7 +200,8 @@ export async function dispatchLocatorAction(target, action, operation, lookup) {
             await uploadFiles(target, action.paths, operation);
             return;
         case 'dragTo': {
-            const other = lookup(action.target);
+            const other = await lookup(action.target);
+            operation.signal.throwIfAborted();
             // Playwright's own drag when both sides are locators: it waits for
             // actionability on each and reports better failures than a pointer
             // sequence can. Anything else - an observed reference on either side -

package/dist/browser-connection.d.ts

@@ -1,6 +1,5 @@
 /** Shares one browser process connection across a worker's attempts. */
-import type { Browser } from 'playwright-core';
-import { chromium } from 'playwright-core';
+import type { Browser, BrowserType } from 'playwright-core';
 /** Every browser the engine launches, in the order the CLI lists them. */
 export declare const BROWSER_NAMES: readonly ['chromium', 'firefox', 'webkit'];
 export type BrowserName = (typeof BROWSER_NAMES)[number];
@@ -27,7 +26,7 @@ export declare class BrowserConnection {
     dispose(): Promise<void>;
 }
 /** Maps a browser name to its Playwright BrowserType. */
-export declare function browserType(name: BrowserName): typeof chromium;
+export declare function browserType(name: BrowserName): Promise<BrowserType>;
 /**
  * Attaches to a remote browser over the Chrome DevTools Protocol. CDP attach
  * is chromium-only; a hosted-browser engine (a per-run cloud session) resolves

package/dist/browser-connection.js

@@ -1,6 +1,11 @@
 /** Shares one browser process connection across a worker's attempts. */
-import { chromium, firefox, selectors, webkit } from 'playwright-core';
 import { SELECTOR_ENGINES } from './selector-engines.js';
+/**
+ * Playwright, imported the first time a browser is looked up, launched, or
+ * attached to. A process that only reads the config (`e2e list`, a run whose
+ * browsers come from a provider) never loads it.
+ */
+const loadPlaywright = () => import('playwright-core');
 /** Every browser the engine launches, in the order the CLI lists them. */
 export const BROWSER_NAMES = ['chromium', 'firefox', 'webkit'];
 /** Whether `name` is a browser the engine launches. */
@@ -44,8 +49,12 @@ export class BrowserConnection {
                 return this.acquire(name, headed, timeoutMs, connect);
             this.pending = undefined;
         }
-        await registerSelectorEngines();
-        const launching = connect !== undefined ? connect() : browserType(name).launch({ headless: !headed, timeout: timeoutMs, ...RUNNER_OWNS_SIGNALS });
+        // Set before anything awaits: the first call loads Playwright, and a `dispose`
+        // that arrives meanwhile must close the browser this launch produces, while a
+        // second caller waits for it instead of launching another.
+        const launching = registerSelectorEngines().then(() => connect !== undefined
+            ? connect()
+            : browserType(name).then((type) => type.launch({ headless: !headed, timeout: timeoutMs, ...RUNNER_OWNS_SIGNALS })));
         this.pending = launching;
         try {
             return await launching;
@@ -69,7 +78,8 @@ export class BrowserConnection {
     }
 }
 /** Maps a browser name to its Playwright BrowserType. */
-export function browserType(name) {
+export async function browserType(name) {
+    const { chromium, firefox, webkit } = await loadPlaywright();
     if (name === 'firefox')
         return firefox;
     if (name === 'webkit')
@@ -84,6 +94,7 @@ export function browserType(name) {
  */
 export async function connectCdp(endpoint, timeoutMs) {
     await registerSelectorEngines();
+    const { chromium } = await loadPlaywright();
     return chromium.connectOverCDP(endpoint, { timeout: timeoutMs });
 }
 /** Registration is process-wide and rejected twice; one shared promise serves every connection. */
@@ -97,6 +108,8 @@ function registerSelectorEngines() {
     // Playwright serializes a function argument with `toString()` and invokes it
     // in the page, so each factory is materialized from its source here to keep
     // the in-page code self-contained, the same way the reader is assembled.
-    selectorEngines ??= Promise.all(SELECTOR_ENGINES.map(({ name, source }) => selectors.register(name, new Function(`return ${source};`)()))).then(() => undefined);
+    selectorEngines ??= loadPlaywright()
+        .then(({ selectors }) => Promise.all(SELECTOR_ENGINES.map(({ name, source }) => selectors.register(name, new Function(`return ${source};`)()))))
+        .then(() => undefined);
     return selectorEngines;
 }

package/dist/browser.js

@@ -11,11 +11,11 @@
  * never re-implemented here: `context.app.resolveUrl` is the one place that
  * says which URLs a test may open.
  */
-import { ConfigurationError, Deadline, describePattern, EngineError, matchesText, obj, pollCondition, raceAbort, rejectUnknownOptions, TestError, toTextPattern, urlMatches, validateJsonValue, withTimeout, } from 'e2e/engine';
+import { ConfigurationError, Deadline, describePattern, EngineError, matchesText, obj, pollCondition, raceAbort, stepTimeout, 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, pageFunctionSource } from './evaluation.js';
+import { isTestErrorCode, message as causeMessage, pageScriptFailure, translatePwError } from './support.js';
+import { compileEvaluation, decodeEvaluation, pageFunctionSource } from './evaluation.js';
 import { initScriptLabel, testInitScriptSource } from './init-scripts.js';
 import { MEDIA_KEYS, mediaLabel, mediaProblem } from './media.js';
 import { lowercaseNames } from './protected-app.js';
@@ -62,10 +62,7 @@ function webResponse(response, body) {
  * downloads are canceled and nothing is attached after it.
  */
 async function collectDownloads(surface, context, trigger, count, timeout, api) {
-    if (timeout !== undefined && (!Number.isFinite(timeout) || timeout <= 0)) {
-        throw new TestError('INVALID_ARGUMENT', `${api} timeout must be positive and finite`);
-    }
-    const operation = context.operation(timeout);
+    const operation = context.operation(stepTimeout(timeout, api));
     const waitMs = operation.timeoutMs;
     const deadline = new Deadline(waitMs);
     const scope = new AbortController();
@@ -170,12 +167,12 @@ export function createBrowserFixture(surface, context) {
      * harness gives `app.open` - a document load is not an action and must not
      * be cut at the action timeout.
      */
-    const navigation = (options, run) => {
-        const operation = context.operation(options?.timeout ?? context.timeouts.test);
+    const navigation = (api, options, run) => {
+        const operation = context.operation(stepTimeout(options?.timeout, api) ?? context.timeouts.test);
         return surface.guard(operation, 'navigation', run);
     };
     /** 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 deadlineFor = (timeout, api) => new Deadline(context.operation(stepTimeout(timeout, api) ?? context.timeouts.assertion).timeoutMs);
     /** 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. */
@@ -184,7 +181,7 @@ export function createBrowserFixture(surface, context) {
     const browser = {
         goto(url, options) {
             const resolved = context.app.resolveUrl(url);
-            return navigation(options, (operation) => surface.navigating(async () => {
+            return navigation('browser.goto', options, (operation) => surface.navigating(async () => {
                 const page = await surface.ensurePage();
                 await page.goto(resolved, {
                     waitUntil: options?.waitUntil ?? 'load',
@@ -192,13 +189,13 @@ export function createBrowserFixture(surface, context) {
                 });
             }));
         },
-        reload: (options) => navigation(options, (operation) => surface.navigating(async () => {
+        reload: (options) => navigation('browser.reload', options, (operation) => surface.navigating(async () => {
             await surface.requirePage().reload({ waitUntil: 'load', timeout: operation.timeoutMs });
         })),
-        back: (options) => navigation(options, (operation) => surface.navigating(async () => {
+        back: (options) => navigation('browser.back', options, (operation) => surface.navigating(async () => {
             await surface.requirePage().goBack({ waitUntil: 'load', timeout: operation.timeoutMs });
         })),
-        forward: (options) => navigation(options, (operation) => surface.navigating(async () => {
+        forward: (options) => navigation('browser.forward', options, (operation) => surface.navigating(async () => {
             await surface.requirePage().goForward({ waitUntil: 'load', timeout: operation.timeoutMs });
         })),
         url: () => currentUrl(),
@@ -216,11 +213,19 @@ export function createBrowserFixture(surface, context) {
             const evaluate = compileEvaluation(source, arg !== undefined);
             // JSON safety is checked above; Playwright's recursive argument type cannot expand JsonValue.
             const input = arg;
-            const result = await surface.guard(context.operation(), 'evaluate', () => surface.requirePage().evaluate(evaluate, input));
-            if (!result.ok)
-                throw new TestError('EVALUATE_FAILED', result.message);
-            validateJsonValue(result.value, 'evaluate result');
-            return result.value;
+            // A handle, not a value: the boundary resolves to a string, which Playwright
+            // keeps out of its in-page serializer when it is taken back from a handle.
+            const report = await surface.guard(context.operation(), 'evaluate', async (operation) => {
+                const page = surface.requirePage();
+                try {
+                    const handle = await page.evaluateHandle(evaluate, input);
+                    return await handle.jsonValue();
+                }
+                catch (cause) {
+                    throw (await pageScriptFailure(page, cause, 'evaluate', operation.timeoutMs)) ?? cause;
+                }
+            });
+            return decodeEvaluation(report);
         },
         async addInitScript(script, ...rest) {
             const source = await testInitScriptSource(script, rest.length === 0 ? undefined : { arg: rest[0] }, (file) => surface.projectPath(file));
@@ -234,6 +239,12 @@ export function createBrowserFixture(surface, context) {
             // is latched on the surface and fails the next step with its real cause.
             const handleRoute = async (route) => {
                 let decided = false;
+                const request = route.request();
+                // Noted before the abort, so a navigation it fails reads as aborted by the test.
+                const abort = async () => {
+                    surface.noteRouteAbort(request);
+                    await route.abort();
+                };
                 const decide = (name) => {
                     if (decided) {
                         throw new TestError('ACTION_FAILED', `route handler already decided; ${name} called twice`);
@@ -249,11 +260,10 @@ export function createBrowserFixture(surface, context) {
                         await act();
                     }
                     catch (cause) {
-                        await route.abort().catch(() => undefined);
+                        await abort().catch(() => undefined);
                         throw cause;
                     }
                 };
-                const request = route.request();
                 const postData = request.postData();
                 const publicRoute = {
                     request: {
@@ -306,7 +316,7 @@ export function createBrowserFixture(surface, context) {
                     },
                     abort: async (...args) => {
                         requireNoArguments('route.abort', args);
-                        await decideWith('abort', () => route.abort());
+                        await decideWith('abort', abort);
                     },
                 };
                 try {
@@ -320,7 +330,7 @@ export function createBrowserFixture(surface, context) {
                         ? cause
                         : new TestError('ACTION_FAILED', `route handler failed: ${causeMessage(cause)}`));
                     if (!decided)
-                        await route.abort().catch(() => undefined);
+                        await abort().catch(() => undefined);
                 }
             };
             // Tracked so the attempt end waits for a handler still running and
@@ -344,7 +354,7 @@ export function createBrowserFixture(surface, context) {
         },
         waitForResponse(pattern, options) {
             const wirePattern = toTextPattern(pattern);
-            const operation = context.operation(options?.timeout);
+            const operation = context.operation(stepTimeout(options?.timeout, 'browser.waitForResponse'));
             return surface.guard(operation, 'waitForResponse', async (currentOperation) => {
                 const page = await surface.ensurePage();
                 const response = await page.waitForResponse((candidate) => routePatternMatches(wirePattern, candidate.url()), { timeout: currentOperation.timeoutMs });
@@ -502,7 +512,7 @@ export function createBrowserFixture(surface, context) {
  */
 function createBrowserExpectation(deps, negated = false) {
     const poll = async (api, label, read, timeout) => {
-        const deadline = deps.deadlineFor(timeout);
+        const deadline = deps.deadlineFor(timeout, api);
         // pollCondition calls onTimeout only after a read completed, so a sample is always there.
         let last;
         await pollCondition({

package/dist/element-list.d.ts

@@ -0,0 +1,28 @@
+/** The elements one document's observation walk read, kept behind a single in-page array. */
+import type { ElementHandle, JSHandle } from 'playwright-core';
+/**
+ * One handle to the in-page array the reader filled, and the element handles
+ * made from it on demand.
+ *
+ * An observation can list thousands of nodes and an action touches a few, so a
+ * handle per node would cost a round trip to create and another to release for
+ * every node, every observation. The array keeps each element alive, which is
+ * what a handle did: a ref names the element the walk read, never whatever sits
+ * at that position now. Disposing the list releases the array and every handle
+ * made from it.
+ */
+export declare class ElementList {
+    readonly handle: JSHandle;
+    private readonly resolved;
+    private disposed;
+    constructor(handle: JSHandle);
+    /**
+     * A new handle to one element of the walk. The caller owns it and disposes
+     * it; a missing element, or a document replaced since the walk, is a stale node.
+     */
+    fetch(index: number): Promise<ElementHandle<Element>>;
+    /** The element of one node, made once and kept until the list is disposed. */
+    at(index: number): Promise<ElementHandle<Element>>;
+    /** Releases the array and every element made from it; safe to call again. */
+    dispose(): void;
+}

package/dist/element-list.js

@@ -0,0 +1,73 @@
+/** The elements one document's observation walk read, kept behind a single in-page array. */
+import { EngineError } from 'e2e/engine';
+import { navigationStaleOr } from './support.js';
+/**
+ * One handle to the in-page array the reader filled, and the element handles
+ * made from it on demand.
+ *
+ * An observation can list thousands of nodes and an action touches a few, so a
+ * handle per node would cost a round trip to create and another to release for
+ * every node, every observation. The array keeps each element alive, which is
+ * what a handle did: a ref names the element the walk read, never whatever sits
+ * at that position now. Disposing the list releases the array and every handle
+ * made from it.
+ */
+export class ElementList {
+    handle;
+    resolved = new Map();
+    disposed = false;
+    constructor(handle) {
+        this.handle = handle;
+    }
+    /**
+     * A new handle to one element of the walk. The caller owns it and disposes
+     * it; a missing element, or a document replaced since the walk, is a stale node.
+     */
+    async fetch(index) {
+        const handle = await this.handle
+            .evaluateHandle((elements, at) => elements[at], index)
+            .catch((cause) => {
+            throw navigationStaleOr(cause, 'resolve observed node');
+        });
+        const element = handle.asElement();
+        if (element === null) {
+            void handle.dispose().catch(() => undefined);
+            throw new EngineError('NODE_STALE', `observation node ${String(index)} lost its element`, { retryable: true });
+        }
+        return element;
+    }
+    /** The element of one node, made once and kept until the list is disposed. */
+    at(index) {
+        if (this.disposed)
+            return Promise.reject(staleList());
+        let element = this.resolved.get(index);
+        if (element === undefined) {
+            element = this.fetch(index).then((made) => {
+                if (!this.disposed)
+                    return made;
+                void made.dispose().catch(() => undefined);
+                throw staleList();
+            }, (cause) => {
+                this.resolved.delete(index);
+                throw this.disposed ? staleList() : cause;
+            });
+            this.resolved.set(index, element);
+        }
+        return element;
+    }
+    /** Releases the array and every element made from it; safe to call again. */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const element of this.resolved.values()) {
+            void element.then((made) => made.dispose()).catch(() => undefined);
+        }
+        this.resolved.clear();
+        void this.handle.dispose().catch(() => undefined);
+    }
+}
+/** The observation the list belonged to was replaced or cleared, so its refs no longer bind. */
+function staleList() {
+    return new EngineError('NODE_STALE', 'observation node references were released', { retryable: true });
+}

package/dist/evaluation.d.ts

@@ -1,18 +1,25 @@
-type EvaluationResult = {
-    ok: true;
-    value: unknown;
-} | {
-    ok: false;
-    message: string;
-};
-/** 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 });";
+/** Separates exceptions thrown by trusted page code from failures of the evaluation transport. */
+import type { JsonValue } from 'e2e';
+/** The `__name` helper tsx's `keepNames` output calls, declared beside test code serialized into the page; it takes `defineProperty` before that code runs. */
+export declare const KEEP_NAMES_HELPER = "const __name = ((define) => (target, value) => define(target, 'name', { value, configurable: true }))(({}).constructor.defineProperty);";
 /** 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;
+/**
+ * Builds, in the page, the encoder of an evaluation result into JSON text.
+ * Called before the caller's code runs, it takes the intrinsics it needs from
+ * literals, so code that deletes or replaces `Array`, `Object`, or `JSON`
+ * cannot reach it. Only JSON passes: `null`, booleans, finite numbers,
+ * strings, arrays, and plain objects. Anything else throws `{ invalid }` with
+ * the reason `validateJsonValue` gives. Embedded into the page as source, so
+ * it captures nothing from this module.
+ */
+export declare function pageValueEncoder(): (root: unknown) => string | undefined;
 /**
  * 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.
+ * other value is the result. The boundary resolves to JSON text, a primitive the caller takes
+ * back without Playwright serializing it in the page, so a page that deleted or replaced a
+ * global the serializer needs still returns its result; `decodeEvaluation` reads it.
  *
  * A function serialized with `toString()` carries whatever the loader compiled
  * it to. e2e before 0.17 loaded tests through tsx, whose esbuild `keepNames`
@@ -20,5 +27,6 @@ export declare function pageFunctionSource(fn: (...args: never[]) => unknown): s
  * 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 {};
+export declare function compileEvaluation(source: string, hasArgument: boolean): (arg: unknown) => Promise<string>;
+/** The result of the boundary `compileEvaluation` compiled, from the JSON text it resolved to; throws what the page threw. */
+export declare function decodeEvaluation(text: string): JsonValue | undefined;

package/dist/evaluation.js

@@ -1,8 +1,7 @@
-/** Separates exceptions thrown by trusted page code from failures of the evaluation transport. */
 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 });";
+/** The `__name` helper tsx's `keepNames` output calls, declared beside test code serialized into the page; it takes `defineProperty` before that code runs. */
+export const KEEP_NAMES_HELPER = "const __name = ((define) => (target, value) => define(target, 'name', { value, configurable: true }))(({}).constructor.defineProperty);";
 /** 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();
@@ -34,10 +33,82 @@ export function pageFunctionSource(fn) {
         }
     }
 }
+/**
+ * Builds, in the page, the encoder of an evaluation result into JSON text.
+ * Called before the caller's code runs, it takes the intrinsics it needs from
+ * literals, so code that deletes or replaces `Array`, `Object`, or `JSON`
+ * cannot reach it. Only JSON passes: `null`, booleans, finite numbers,
+ * strings, arrays, and plain objects. Anything else throws `{ invalid }` with
+ * the reason `validateJsonValue` gives. Embedded into the page as source, so
+ * it captures nothing from this module.
+ */
+export function pageValueEncoder() {
+    const { getPrototypeOf, keys } = ({}).constructor;
+    const objectPrototype = getPrototypeOf({});
+    const { isArray } = [].constructor;
+    const charCodeAt = ''.charCodeAt;
+    const hex = '0123456789abcdef';
+    const invalid = (reason) => ({ invalid: reason });
+    const quote = (text) => {
+        let out = '"';
+        for (let i = 0; i < text.length; i++) {
+            const code = charCodeAt.call(text, i);
+            const escape = code === 34 || code === 92 || code < 32 || code === 0x2028 || code === 0x2029 || (code >= 0xd800 && code <= 0xdfff);
+            out += escape ? `\\u${hex[code >> 12]}${hex[(code >> 8) & 15]}${hex[(code >> 4) & 15]}${hex[code & 15]}` : text[i];
+        }
+        return `${out}"`;
+    };
+    const ancestors = [];
+    const encode = (value) => {
+        if (value === null)
+            return 'null';
+        switch (typeof value) {
+            case 'string':
+                return quote(value);
+            case 'boolean':
+                return value ? 'true' : 'false';
+            case 'number':
+                if (value !== value || value === Infinity || value === -Infinity)
+                    throw invalid('contains a non-finite number');
+                return `${value}`;
+            case 'object':
+                break;
+            default:
+                throw invalid(`must be JSON-safe, found ${typeof value}`);
+        }
+        const array = isArray(value);
+        const prototype = getPrototypeOf(value);
+        if (!array && prototype !== objectPrototype && prototype !== null)
+            throw invalid('must be JSON-safe');
+        for (let i = 0; i < ancestors.length; i++) {
+            if (ancestors[i] === value)
+                throw invalid('contains a cycle');
+        }
+        ancestors[ancestors.length] = value;
+        let text = '';
+        if (array) {
+            for (let i = 0; i < value.length; i++)
+                text += `${i === 0 ? '' : ','}${encode(value[i])}`;
+            text = `[${text}]`;
+        }
+        else {
+            const record = value;
+            const names = keys(record);
+            for (let i = 0; i < names.length; i++)
+                text += `${i === 0 ? '' : ','}${quote(names[i])}:${encode(record[names[i]])}`;
+            text = `{${text}}`;
+        }
+        ancestors.length -= 1;
+        return text;
+    };
+    return (root) => (root === undefined ? undefined : encode(root));
+}
 /**
  * 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.
+ * other value is the result. The boundary resolves to JSON text, a primitive the caller takes
+ * back without Playwright serializing it in the page, so a page that deleted or replaced a
+ * global the serializer needs still returns its result; `decodeEvaluation` reads it.
  *
  * A function serialized with `toString()` carries whatever the loader compiled
  * it to. e2e before 0.17 loaded tests through tsx, whose esbuild `keepNames`
@@ -48,23 +119,49 @@ export function pageFunctionSource(fn) {
 export function compileEvaluation(source, hasArgument) {
     try {
         return new Function('arg', `
-      return (async () => {
-        ${KEEP_NAMES_HELPER}
+      ${KEEP_NAMES_HELPER}
+      return (async (encode, run) => {
+        const report = (ok, key, text) => \`{"ok":\${ok}\${text === undefined ? '' : \`,"\${key}":\${text}\`}}\`;
+        let value;
         try {
-          return { ok: true, value: await ((result) => typeof result === 'function' ? result(${hasArgument ? 'arg' : ''}) : result)((${source}\n)) };
+          value = await run();
         } catch (cause) {
           let message;
           try {
-            message = typeof cause?.message === 'string' ? cause.message : String(cause);
+            message = typeof cause?.message === 'string' ? cause.message : \`\${cause}\`;
           } catch {
             message = 'Page evaluation threw an unprintable value';
           }
-          return { ok: false, message };
+          return report(false, 'message', encode(message));
         }
-      })();
+        try {
+          return report(true, 'value', encode(value));
+        } catch (cause) {
+          if (cause !== null && typeof cause === 'object' && typeof cause.invalid === 'string') {
+            return report(false, 'invalid', encode(cause.invalid));
+          }
+          return '{"ok":false,"message":"evaluate result cannot be read"}';
+        }
+      })((${pageValueEncoder.toString()})(), async () => ((result) => typeof result === 'function' ? result(${hasArgument ? 'arg' : ''}) : result)((${source}\n)));
     `);
     }
     catch (cause) {
         throw new TestError('EVALUATE_FAILED', message(cause), { cause });
     }
 }
+/** The result of the boundary `compileEvaluation` compiled, from the JSON text it resolved to; throws what the page threw. */
+export function decodeEvaluation(text) {
+    let report;
+    try {
+        // oxlint-disable-next-line e2e/no-unchecked-json -- the text is what compileEvaluation's own boundary wrote
+        report = JSON.parse(text);
+    }
+    catch (cause) {
+        throw new TestError('EVALUATE_FAILED', 'page evaluation returned an unreadable result', { cause });
+    }
+    if (report.ok)
+        return report.value;
+    if ('invalid' in report)
+        throw new TestError('INVALID_ARGUMENT', `evaluate result ${report.invalid}`);
+    throw new TestError('EVALUATE_FAILED', report.message);
+}

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

@@ -1460,6 +1460,8 @@ export const readSemanticsFunction = (element, options) => {
         // no rect, as Playwright's `boundingBox()` answers null; a box with no
         // size, or one `visibility: hidden` keeps, is still a rect.
         const rect = el.getClientRects().length === 0 ? null : el.getBoundingClientRect();
+        const borderLeft = Number.parseFloat(style?.borderLeftWidth ?? '') || 0;
+        const borderTop = Number.parseFloat(style?.borderTopWidth ?? '') || 0;
         const role = isDocumentRoot ? 'document' : roleOf(el, tag);
         let level = null;
         if (role === 'heading') {
@@ -1494,6 +1496,7 @@ export const readSemanticsFunction = (element, options) => {
             attributes,
             testId: el.getAttribute(options.testIdAttribute),
             rect: rect === null ? null : { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+            origin: rect === null || (borderLeft === 0 && borderTop === 0) ? null : { x: rect.x + borderLeft, y: rect.y + borderTop },
         };
     };
     // The conditional return type resolves per call site; inside the body the

package/dist/install.d.ts

@@ -13,7 +13,7 @@ export declare function runPlaywrightCli(args: readonly string[]): Promise<numbe
  * disk, a `warn` when the first run will download it, or none when `env`
  * points at another browser cache than this process loaded.
  */
-export declare function browserCheck(name: BrowserName, env: NodeJS.ProcessEnv, headed: boolean, isInstalled?: (name: BrowserName) => boolean | undefined): EngineDoctorCheck[];
+export declare function browserCheck(name: BrowserName, env: NodeJS.ProcessEnv, headed: boolean, isInstalled?: (name: BrowserName) => boolean | undefined | Promise<boolean | undefined>): Promise<EngineDoctorCheck[]>;
 /** What an installer receives besides the browser names. */
 export interface InstallContext {
     /** Receives every line the installer prints: the download URL, progress, warnings. */
@@ -36,7 +36,7 @@ export interface EnsureBrowsersOptions {
      * Injected detection for tests; defaults to an executable existence check.
      * Undefined means "cannot tell here": the installer runs and decides.
      */
-    readonly isInstalled?: (name: BrowserName) => boolean | undefined;
+    readonly isInstalled?: (name: BrowserName) => boolean | undefined | Promise<boolean | undefined>;
     /** Injected installer for tests; defaults to spawning the Playwright CLI. */
     readonly install?: (names: readonly BrowserName[], context: InstallContext) => Promise<void>;
     /** Aborts a download in progress; the run's interrupt owns it. */