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

package/dist/.build.json

@@ -1 +1 @@
-{"version":"0.13.0"}
+{"version":"0.14.0-nightly-20261008205824"}

package/dist/actions.d.ts

@@ -2,12 +2,13 @@
 import type { Page } from 'playwright-core';
 import { type LocatorAction, type NodeRef, type PointerAction, type ViewportPoint } from 'e2e/engine';
 import { type ActionTarget } from './support.ts';
+import type { ConnectionBudget } from './operation-budget.ts';
 /**
  * Dispatches one deterministic locator action onto a Playwright target with the
  * 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, timeout: number, lookup: (ref: NodeRef) => ActionTarget): Promise<void>;
+export declare function dispatchLocatorAction(target: ActionTarget, action: LocatorAction, operation: ConnectionBudget, lookup: (ref: NodeRef) => 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

@@ -1,5 +1,5 @@
 /** Locator action dispatch for the Playwright engine. */
-import { EngineError } from 'e2e/engine';
+import { Deadline, EngineError, pollCondition } from 'e2e/engine';
 import { asActionable, isClassified, isNavigationRace, isPwTimeout, message, nearestPixel, performElementSwipe, performPointDrag, performPointerDrag, performViewportSwipe, POST_DISPATCH_PATTERN, translatePwError, } from './support.js';
 /** How long a long press holds the button when the action names no duration. */
 const DEFAULT_LONG_PRESS_MS = 500;
@@ -11,19 +11,25 @@ function heldKeys(action) {
 const DETACHED_PATTERN = /element (is |was )?(detached|not attached)/i;
 /**
  * Sets a checkbox, switch, or radio to `checked` with one click, as
- * Playwright's `check` does, apart from the read after the click: a control
- * that is gone by then (an app that swaps a picked radio for its selected
- * view, or navigates on change) took the click, so the action is done, where
- * Playwright reports it detached as if the click never happened. Whatever
- * took its place is not read: the next observation or assertion shows it,
- * as it does after a tap. The reads and the click share one element, so the state before and after the click
- * is one control's.
+ * Playwright's `check` does, apart from the reads after the click. Playwright
+ * reads the state once; here it is polled until the operation's deadline, so
+ * a control that commits its new state after an await or a timer passes, and
+ * one that never changes fails at the deadline. A control that is gone by
+ * the first read (an app that swaps a picked radio for its selected view, or
+ * navigates on change) took the click, so the action is done, where
+ * Playwright reports it detached as if the click never happened. One that
+ * goes later, still in its old state, may have been replaced for any reason,
+ * so it fails rather than passing on a click the app rejected. Whatever took
+ * its place is not read: the next observation or assertion shows it, as it
+ * does after a tap.
+ * The reads and the click share one element, so the state before and after
+ * the click is one control's.
  */
-async function setChecked(target, checked, timeout) {
-    const deadline = Date.now() + timeout;
+async function setChecked(target, checked, operation) {
+    const deadline = new Deadline(operation.timeoutMs);
     // Playwright reads a timeout of 0 as no timeout at all.
-    const remaining = () => Math.max(1, deadline - Date.now());
-    const element = target.kind === 'element' ? target.element : await target.locator.elementHandle({ timeout });
+    const remaining = () => Math.max(1, deadline.remaining());
+    const element = target.kind === 'element' ? target.element : await target.locator.elementHandle({ timeout: operation.timeoutMs });
     const verb = checked ? 'check' : 'uncheck';
     try {
         if ((await element.isChecked()) === checked)
@@ -34,20 +40,30 @@ async function setChecked(target, checked, timeout) {
             });
         }
         await element.click({ timeout: remaining() });
-        let after;
-        try {
-            after = await element.isChecked();
-        }
-        catch (cause) {
-            if (DETACHED_PATTERN.test(message(cause)) || isNavigationRace(cause))
-                return;
-            throw cause;
-        }
-        if (after !== checked) {
-            throw new EngineError('NOT_ACTIONABLE', `${verb} clicked the control but its checked state did not change`, {
-                retryable: false,
-            });
-        }
+        const unchanged = (detail = '') => new EngineError('NOT_ACTIONABLE', `${verb} clicked the control but its checked state did not change${detail}`, {
+            retryable: false,
+        });
+        let firstRead = true;
+        await pollCondition({
+            deadline,
+            signal: operation.signal,
+            negated: false,
+            evaluate: async () => {
+                const first = firstRead;
+                firstRead = false;
+                try {
+                    return (await element.isChecked()) === checked;
+                }
+                catch (cause) {
+                    if (!DETACHED_PATTERN.test(message(cause)) && !isNavigationRace(cause))
+                        throw cause;
+                    if (first)
+                        return true;
+                    throw unchanged(' before the control was replaced');
+                }
+            },
+            onTimeout: () => unchanged(),
+        });
     }
     finally {
         if (target.kind === 'locator')
@@ -63,7 +79,8 @@ function isRadio(element) {
  * platform's own actionability checks. `lookup` resolves the second ref of a
  * drag; everything else needs only the target.
  */
-export async function dispatchLocatorAction(target, action, timeout, lookup) {
+export async function dispatchLocatorAction(target, action, operation, lookup) {
+    const timeout = operation.timeoutMs;
     const locator = asActionable(target);
     switch (action.kind) {
         case 'tap':
@@ -91,7 +108,7 @@ export async function dispatchLocatorAction(target, action, timeout, lookup) {
             return;
         case 'check':
         case 'uncheck':
-            await setChecked(target, action.kind === 'check', timeout);
+            await setChecked(target, action.kind === 'check', operation);
             return;
         case 'focus':
             // ElementHandle.focus takes no timeout: the element is already resolved.

package/dist/app-log.d.ts

@@ -0,0 +1,20 @@
+/**
+ * What the page did on its own during an attempt: for the harness's app log,
+ * console output, exceptions nothing caught, requests that failed, and
+ * responses with an error status; apart from it, where the page went (a
+ * navigation, a new tab, a frame loading). These are the first things to
+ * read when a step fails because the app broke rather than the test.
+ */
+import type { BrowserContext, Page } from 'playwright-core';
+import type { AppLogEntry } from 'e2e/engine';
+/** Where the app log tells where the page went, and what it asks the engine to tell its navigations from the app's. */
+export interface NavigationLog {
+    /** Takes one line saying where the page went. */
+    readonly navigated: (line: string) => void;
+    /** Whether a navigation of the test's page to `url` is one the engine started, which its step already tells. */
+    readonly ownNavigation: (url: string) => boolean;
+    /** The page the test drives; every other page is a tab the app opened. */
+    readonly testPage: () => Page | undefined;
+}
+/** Reports the context's console output, uncaught exceptions, failed requests, and navigations to `log`, from now on. */
+export declare function installAppLog(context: BrowserContext, log: (entry: AppLogEntry) => void, navigation: NavigationLog): void;

package/dist/app-log.js

@@ -0,0 +1,127 @@
+/**
+ * What the page did on its own during an attempt: for the harness's app log,
+ * console output, exceptions nothing caught, requests that failed, and
+ * responses with an error status; apart from it, where the page went (a
+ * navigation, a new tab, a frame loading). These are the first things to
+ * read when a step fails because the app broke rather than the test.
+ */
+/** Console message types worth a line; `debug` and the rest are the app talking to itself. */
+const CONSOLE_LEVELS = {
+    error: 'error',
+    assert: 'error',
+    warning: 'warning',
+    log: 'info',
+    info: 'info',
+};
+/** Documents that are no place the app went: a fresh tab, an inline frame. */
+const NO_PLACE = new Set(['about:blank', 'about:srcdoc']);
+/** Chrome's console echo of a failed load, which the network lines already tell. */
+const LOAD_ECHO = 'Failed to load resource:';
+/**
+ * Whether a failed request is one the browser cancelled because the page
+ * moved on, not the app failing: Chromium's and Firefox's abort codes, and
+ * WebKit's text, read the way Playwright reads each browser's cancellation.
+ */
+function isCancelled(errorText) {
+    return errorText === 'net::ERR_ABORTED' || errorText === 'NS_BINDING_ABORTED' || errorText.includes('cancelled');
+}
+/** Reports the context's console output, uncaught exceptions, failed requests, and navigations to `log`, from now on. */
+export function installAppLog(context, log, navigation) {
+    const report = (entry) => {
+        try {
+            log(entry);
+        }
+        catch {
+            // The harness's sink never fails a page event.
+        }
+    };
+    const went = (line) => {
+        try {
+            navigation.navigated(line);
+        }
+        catch {
+            // The harness's sink never fails a page event.
+        }
+    };
+    context.on('console', (message) => {
+        const level = CONSOLE_LEVELS[message.type()];
+        if (level !== undefined && !message.text().startsWith(LOAD_ECHO))
+            report({ source: 'console', level, text: consoleText(message) });
+    });
+    context.on('weberror', (webError) => {
+        const error = webError.error();
+        const top = error.stack?.split('\n').find((line) => line.trim().startsWith('at '))?.trim();
+        report({ source: 'error', level: 'error', text: `${error.name}: ${error.message}${top === undefined ? '' : ` ${top}`}` });
+    });
+    context.on('requestfailed', (request) => {
+        const failure = request.failure()?.errorText ?? 'failed';
+        if (isCancelled(failure))
+            return;
+        report({ source: 'network', level: 'error', text: `${requestLine(request)} ${failure}` });
+    });
+    context.on('response', (response) => {
+        const status = response.status();
+        if (status < 400 || isMissingFavicon(response))
+            return;
+        report({ source: 'network', level: status >= 500 ? 'error' : 'warning', text: responseLine(response) });
+    });
+    const watch = (page) => {
+        // A tab's first document is told by its opening.
+        let opened = false;
+        page.on('framenavigated', (frame) => {
+            const tab = page !== navigation.testPage();
+            if (tab && frame === page.mainFrame() && !opened && !NO_PLACE.has(frame.url())) {
+                opened = true;
+                return;
+            }
+            const line = navigationLine(page, frame, tab, navigation);
+            if (line !== undefined)
+                went(line);
+        });
+        // A tab the app opened (`window.open`, a `target="_blank"` link); the test stays on its own page.
+        page.on('popup', (tab) => {
+            const at = NO_PLACE.has(tab.url()) ? '' : ` at ${tab.url()}`;
+            went(`the app opened a new tab${at}; the test stays on its page`);
+        });
+    };
+    for (const page of context.pages())
+        watch(page);
+    context.on('page', watch);
+}
+/**
+ * `navigated to /checkout`, `the new tab navigated to /help`, `frame "pay"
+ * loaded /embed`: one navigation as a line, or undefined for one not worth
+ * telling.
+ */
+function navigationLine(page, frame, tab, navigation) {
+    const url = frame.url();
+    if (NO_PLACE.has(url) || url.startsWith('data:'))
+        return undefined;
+    if (frame === page.mainFrame()) {
+        if (tab)
+            return `the new tab navigated to ${url}`;
+        if (navigation.ownNavigation(url))
+            return undefined;
+        return `navigated to ${url}`;
+    }
+    const name = frame.name();
+    return `frame${name === '' ? '' : ` "${name}"`} loaded ${url}`;
+}
+/** `message (at /app.js:12)`: the text, and where it was logged from when the browser says. */
+function consoleText(message) {
+    const { url, lineNumber } = message.location();
+    return url === '' ? message.text() : `${message.text()} (at ${url}:${lineNumber + 1})`;
+}
+/** A browser's own request for a site icon the app never served: noise on every page of most apps. */
+function isMissingFavicon(response) {
+    return response.status() === 404 && new URL(response.url()).pathname === '/favicon.ico';
+}
+/** `GET https://app.test/api/todos`: the request line a network entry starts with. */
+function requestLine(request) {
+    return `${request.method()} ${request.url()}`;
+}
+/** `GET https://app.test/api/todos 500 Internal Server Error`: the request line and the status it got. */
+function responseLine(response) {
+    const text = response.statusText();
+    return `${requestLine(response.request())} ${response.status()}${text === '' ? '' : ` ${text}`}`;
+}

package/dist/attempt-session.d.ts

@@ -1,3 +1,4 @@
+/** Owns one attempt's live binding, recovery, references, and recordings. */
 import type { Browser, BrowserContext, BrowserContextOptions, Page } from 'playwright-core';
 import { type EngineCleanupContext, type OperationContext, type VideoSegment, type ViewportSize } from 'e2e/engine';
 import { type CdpEndpointResolver, type SessionBinding } from './cdp-recovery.ts';
@@ -39,9 +40,6 @@ export declare class AttemptSession {
     private observed;
     /** Until the attempt's first page opens: a persistent browser's own first tab can serve as that page. */
     private firstPage;
-    private tracing;
-    private traceSegments;
-    private traceParts;
     private requestedViewport;
     constructor(options: SessionOptions);
     /** Captures an immutable connection generation for publication after asynchronous reads. */
@@ -86,24 +84,11 @@ export declare class AttemptSession {
     close(budget: EngineCleanupContext): Promise<void>;
     /** Ordinary contexts are engine-owned; persistent browser processes belong to the host. */
     private release;
-    /** Allocates trace paths inside this attempt's immutable artifact directory. */
-    private tracePath;
-    /** Saves a replaced context's trace when it can still flush it. */
-    private closeTraceSegment;
-    /** Begins tracing the currently committed context. */
-    startTrace(): Promise<void>;
-    /** Returns finalized segments, including any retained before context replacement failed. */
-    private stopTrace;
     /**
      * Starts video once the page is open, so a provider's recording of the
-     * browser starts on the attempt's own tab. A screencast is shared with the
-     * trace, which sizes it for itself, so a trace already running (a host
-     * that starts the video mid-attempt) is split around a screencast's start:
-     * its segment so far is saved, and it resumes on the video's screencast.
+     * browser starts on the attempt's own tab.
      */
     startVideo(signal: AbortSignal): Promise<void>;
-    /** Collects finalized trace segments even when connection replacement failed. */
-    collectTrace(operation: OperationContext): Promise<string | readonly string[]>;
     /** Collects this attempt's video independently of a failed connection. */
     collectVideo(operation: OperationContext): Promise<readonly VideoSegment[]>;
     /** Terminal artifact collection needs its own budget, but no successful UI dispatch. */

package/dist/attempt-session.js

@@ -1,6 +1,3 @@
-/** Owns one attempt's live binding, recovery, references, and recordings. */
-import { mkdirSync } from 'node:fs';
-import path from 'node:path';
 import { EngineError, raceAbort, withinCleanupBudget } from 'e2e/engine';
 import { attachPersistent, recoveryFailed, targetIdentity } from './cdp-recovery.js';
 import { connectionAbort, withConnectionBudget, withOperationDeadline } from './operation-budget.js';
@@ -8,7 +5,6 @@ import { RefRegistry } from './refs.js';
 import { ProviderVideo } from './provider-video.js';
 import { invalidState, translatePwError } from './support.js';
 import { VideoRecorder } from './video.js';
-const TRACE_OPTIONS = { screenshots: true, snapshots: true };
 export class AttemptSession {
     options;
     refs = new RefRegistry();
@@ -19,9 +15,6 @@ export class AttemptSession {
     observed = true;
     /** Until the attempt's first page opens: a persistent browser's own first tab can serve as that page. */
     firstPage = true;
-    tracing = false;
-    traceSegments = 0;
-    traceParts = [];
     requestedViewport;
     constructor(options) {
         this.options = options;
@@ -118,9 +111,6 @@ export class AttemptSession {
         if (budget.signal.aborted)
             throw connectionAbort(budget.signal, 'connection');
         this.invalidate();
-        const resumeTrace = recover && this.tracing;
-        if (recover)
-            this.tracing = false;
         const running = Promise.resolve().then(async () => {
             if (budget.signal.aborted)
                 throw connectionAbort(budget.signal, 'connection');
@@ -137,13 +127,10 @@ export class AttemptSession {
                         await candidate.page.setViewportSize(size);
                     await this.video.pageOpened(candidate.page);
                 }
-                if (resumeTrace)
-                    await candidate.context.tracing.start(TRACE_OPTIONS);
                 if (budget.signal.aborted)
                     throw connectionAbort(budget.signal, 'connection');
                 if (this.state !== pending)
                     throw connectionAbort(this.lifetime.signal, 'connection');
-                this.tracing = resumeTrace;
                 this.state = { kind: 'ready', binding: candidate };
             }
             catch (cause) {
@@ -227,19 +214,15 @@ export class AttemptSession {
         this.invalidate();
         const token = this.token();
         await this.video.pageClosing();
-        const resume = this.video.isArmed ? await this.closeTraceSegment(binding.context) : false;
         for (const page of binding.context.pages())
             await page.close();
         this.check(token);
         this.state = { kind: 'ready', binding: { ...binding, page: null } };
         await this.ensurePage();
-        if (resume)
-            await this.startTrace();
     }
     /** Replaces an ordinary context; persistent recovery never advertises this capability. */
     async replace(storageState, operation) {
         const previous = this.current();
-        const resume = await this.closeTraceSegment(previous.context);
         await this.video.pageClosing();
         await this.transition(previous, operation, async () => {
             await previous.context.close();
@@ -248,8 +231,6 @@ export class AttemptSession {
         });
         if (this.video.isArmed)
             await this.ensurePage();
-        if (resume)
-            await this.startTrace();
     }
     /** Ends this attempt immediately; late work can only access this retired owner. */
     async close(budget) {
@@ -263,74 +244,18 @@ export class AttemptSession {
         if (binding === undefined)
             return;
         await withinCleanupBudget(this.video.abandon(budget.signal), budget);
-        if (this.tracing)
-            await withinCleanupBudget(binding.context.tracing.stop(), budget);
         await withinCleanupBudget(this.release(binding), budget);
     }
     /** Ordinary contexts are engine-owned; persistent browser processes belong to the host. */
     release(binding) {
         return this.options.persistent === undefined ? binding.context.close() : binding.browser.close();
     }
-    /** Allocates trace paths inside this attempt's immutable artifact directory. */
-    tracePath(name) {
-        const relative = path.posix.join('trace', `${name}.zip`);
-        const absolute = path.join(this.options.artifactsDir, relative);
-        mkdirSync(path.dirname(absolute), { recursive: true });
-        return { relative, absolute };
-    }
-    /** Saves a replaced context's trace when it can still flush it. */
-    async closeTraceSegment(context) {
-        if (!this.tracing)
-            return false;
-        this.tracing = false;
-        this.traceSegments += 1;
-        const { relative, absolute } = this.tracePath(`trace-part${this.traceSegments}`);
-        try {
-            await context.tracing.stop({ path: absolute });
-            this.traceParts.push(relative);
-        }
-        catch { /* A disconnected context may have lost its final trace segment. */ }
-        return true;
-    }
-    /** Begins tracing the currently committed context. */
-    async startTrace() {
-        const token = this.token();
-        await this.current().context.tracing.start(TRACE_OPTIONS);
-        this.check(token);
-        this.tracing = true;
-    }
-    /** Returns finalized segments, including any retained before context replacement failed. */
-    async stopTrace() {
-        const parts = this.traceParts;
-        this.traceParts = [];
-        if (parts.length > 0 && !this.tracing)
-            return parts;
-        const { relative, absolute } = this.tracePath('trace');
-        await this.current().context.tracing.stop({ path: absolute });
-        this.tracing = false;
-        return parts.length === 0 ? relative : [...parts, relative];
-    }
     /**
      * Starts video once the page is open, so a provider's recording of the
-     * browser starts on the attempt's own tab. A screencast is shared with the
-     * trace, which sizes it for itself, so a trace already running (a host
-     * that starts the video mid-attempt) is split around a screencast's start:
-     * its segment so far is saved, and it resumes on the video's screencast.
+     * browser starts on the attempt's own tab.
      */
     async startVideo(signal) {
-        const page = await this.ensurePage();
-        const resume = this.video.startsScreencast ? await this.closeTraceSegment(this.current().context) : false;
-        try {
-            await this.video.arm(page, signal);
-        }
-        finally {
-            if (resume)
-                await this.startTrace();
-        }
-    }
-    /** Collects finalized trace segments even when connection replacement failed. */
-    collectTrace(operation) {
-        return this.finalize(operation, 'trace', () => this.stopTrace());
+        await this.video.arm(await this.ensurePage(), signal);
     }
     /** Collects this attempt's video independently of a failed connection. */
     collectVideo(operation) {

package/dist/browser.js

@@ -15,7 +15,7 @@ import { ConfigurationError, Deadline, describePattern, EngineError, matchesText
 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';
@@ -71,23 +71,23 @@ export function createBrowserFixture(surface, 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(),
         // The same poll as `expect(browser).toHaveURL`, exposed as a wait.
@@ -98,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.

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,6 +7,8 @@ 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

package/dist/evaluation.js

@@ -3,6 +3,37 @@ 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