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

package/dist/.build.json

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

package/dist/actions.d.ts

@@ -2,21 +2,28 @@
 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,
  * and the page decides what the gesture lands on, as it does for a person.
  */
-export declare function dispatchPointerAction(page: Page, at: ViewportPoint, action: PointerAction): Promise<void>;
+export declare function dispatchPointerAction(page: Page, at: ViewportPoint, action: PointerAction, signal?: AbortSignal): Promise<void>;
+/** Translates the failure of an input operation with no element behind it: a pointer action at a point, or a keystroke. */
+export declare function classifyInputError(cause: unknown, label: string): Error;
 /**
  * Classifies a failed action onto the error contract (see the table above
  * `POST_DISPATCH_PATTERN` in support.ts): stale, not actionable, possibly
- * committed, or an engine fault.
+ * committed, or an engine fault. A strict mode violation is a located match
+ * that turned ambiguous: stale like a detached one before any input, so the
+ * runner locates again and reports the ambiguity or acts on the one match
+ * left; possibly committed once input went out, as the second side of a drag
+ * resolves after the press.
  */
 export declare function classifyActionError(rawCause: unknown, action: LocatorAction): Error;

package/dist/actions.js

@@ -1,6 +1,6 @@
 /** Locator action dispatch for the Playwright engine. */
-import { EngineError } from 'e2e/engine';
-import { asActionable, isClassified, isNavigationRace, isPwTimeout, message, nearestPixel, performElementSwipe, performPointDrag, performPointerDrag, performViewportSwipe, POST_DISPATCH_PATTERN, } from './support.js';
+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;
 /** The keys a click holds, as Playwright's `modifiers` takes them; the contract spells them the same. */
@@ -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.
@@ -151,7 +168,7 @@ export async function dispatchLocatorAction(target, action, timeout, lookup) {
  * behind it: no actionability wait, because there is no element to wait on,
  * and the page decides what the gesture lands on, as it does for a person.
  */
-export async function dispatchPointerAction(page, at, action) {
+export async function dispatchPointerAction(page, at, action, signal) {
     const { mouse } = page;
     const point = nearestPixel(at);
     switch (action.kind) {
@@ -171,9 +188,11 @@ export async function dispatchPointerAction(page, at, action) {
             await mouse.move(point.x, point.y);
             return;
         case 'dragTo':
+            await performPointDrag(mouse, point, action.target, undefined, signal);
+            return;
         case 'swipeTo':
             // A swipe along a path is a pointer drag on a document platform.
-            await performPointDrag(mouse, point, action.target);
+            await performPointDrag(mouse, point, action.target, action.durationMs, signal);
             return;
         case 'swipe':
             // The pointer moves to the point first so the scrollable under it receives the wheel.
@@ -182,6 +201,23 @@ export async function dispatchPointerAction(page, at, action) {
             return;
     }
 }
+/**
+ * An input operation the operation deadline cut off: Playwright never
+ * answered, so whether the input reached the page is unknown, and it must not
+ * be repeated blindly.
+ */
+function inputCutOff(cause, label) {
+    if (!(cause instanceof EngineError) || cause.code !== 'OPERATION_TIMEOUT')
+        return undefined;
+    return new EngineError('ACTION_MAY_HAVE_COMMITTED', `${label} timed out before the page answered; its input may have been dispatched`, {
+        retryable: false,
+        cause,
+    });
+}
+/** Translates the failure of an input operation with no element behind it: a pointer action at a point, or a keystroke. */
+export function classifyInputError(cause, label) {
+    return inputCutOff(cause, label) ?? translatePwError(cause, label);
+}
 /**
  * Whether a failure of this action may carry the value it was given. A
  * sensitive fill's plaintext must never leave the engine: its message is
@@ -216,15 +252,25 @@ function actionabilitySummary(text) {
 /**
  * Classifies a failed action onto the error contract (see the table above
  * `POST_DISPATCH_PATTERN` in support.ts): stale, not actionable, possibly
- * committed, or an engine fault.
+ * committed, or an engine fault. A strict mode violation is a located match
+ * that turned ambiguous: stale like a detached one before any input, so the
+ * runner locates again and reports the ambiguity or acts on the one match
+ * left; possibly committed once input went out, as the second side of a drag
+ * resolves after the press.
  */
 export function classifyActionError(rawCause, action) {
+    const cut = inputCutOff(rawCause, action.kind);
+    if (cut !== undefined)
+        return cut;
     if (isClassified(rawCause))
         return rawCause;
     const text = redactSensitive(message(rawCause), action);
     const cause = isSensitive(action) ? undefined : rawCause;
     if (/strict mode violation/i.test(text)) {
-        return new EngineError('ENGINE_FAILURE', text, { retryable: false, cause });
+        if (POST_DISPATCH_PATTERN.test(text)) {
+            return new EngineError('ACTION_MAY_HAVE_COMMITTED', `${action.kind} matched more than one element after its input was dispatched: ${text}`, { retryable: false, cause });
+        }
+        return new EngineError('NODE_STALE', text, { retryable: true, cause });
     }
     if (DETACHED_PATTERN.test(text)) {
         return new EngineError('NODE_STALE', text, { retryable: true, cause });

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,6 +1,8 @@
+/** 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';
+import { type OperationBound } from './operation-budget.ts';
 import { RefRegistry } from './refs.ts';
 import type { LeaseRecording } from './provider.ts';
 import type { WebScreencastOptions } from './surface.ts';
@@ -38,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. */
@@ -57,8 +56,8 @@ export declare class AttemptSession {
     private invalidate;
     /** Opens a context for this attempt, publishing only after its handlers are installed. */
     start(signal: AbortSignal): Promise<void>;
-    /** Shares one reconnect, then dispatches once with the time that remains. */
-    run<T>(operation: OperationContext, label: string, work: (operation: OperationContext) => Promise<T>): Promise<T>;
+    /** Shares one reconnect, then dispatches once with the time that remains, bounded by the operation's budget unless it runs test code. */
+    run<T>(operation: OperationContext, label: string, work: (operation: OperationContext) => Promise<T>, bound?: OperationBound): Promise<T>;
     /** Owns a candidate through configuration and recording setup, then publishes it once. */
     private transition;
     /** Creates the attempt's active page and records its exact target before exposing it. */
@@ -85,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,14 +1,10 @@
-/** 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 } from './operation-budget.js';
+import { connectionAbort, withConnectionBudget, withOperationDeadline } from './operation-budget.js';
 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;
@@ -83,8 +76,8 @@ export class AttemptSession {
             return binding;
         }));
     }
-    /** Shares one reconnect, then dispatches once with the time that remains. */
-    async run(operation, label, work) {
+    /** Shares one reconnect, then dispatches once with the time that remains, bounded by the operation's budget unless it runs test code. */
+    async run(operation, label, work, bound = 'deadline') {
         const signal = AbortSignal.any([operation.signal, this.lifetime.signal]);
         if (signal.aborted)
             throw connectionAbort(signal, label);
@@ -92,32 +85,32 @@ export class AttemptSession {
             throw this.state.error;
         const persistent = this.options.persistent;
         const reconnect = (this.state.kind === 'pending' || (this.state.kind === 'ready' && !this.state.binding.browser.isConnected()));
-        if (persistent === undefined || !reconnect)
-            return raceAbort(() => work({ ...operation, signal }), signal, label);
-        return withConnectionBudget({ ...operation, signal }, label, async (remaining) => {
-            if (this.state.kind === 'pending') {
-                await raceAbort(this.state.work, remaining().signal, 'CDP recovery');
-            }
-            else {
+        const endsAt = Date.now() + operation.timeoutMs;
+        // Recovery is the engine's own work, so the deadline bounds it whatever the operation runs.
+        if (persistent !== undefined && reconnect) {
+            await withConnectionBudget({ signal, timeoutMs: operation.timeoutMs }, label, async (remaining) => {
+                if (this.state.kind === 'pending') {
+                    await raceAbort(this.state.work, remaining().signal, 'CDP recovery');
+                    return;
+                }
                 const previous = this.current();
                 this.observed = false;
                 await this.transition(previous, remaining(), async () => {
                     await this.video.pageClosing();
                     return attachPersistent(persistent.reconnect, remaining(), previous.identity);
                 }, true);
-            }
-            const current = remaining();
-            return raceAbort(() => work({ ...operation, ...current }), current.signal, label);
-        });
+            });
+        }
+        const left = endsAt - Date.now();
+        if (left <= 0)
+            throw new EngineError('OPERATION_TIMEOUT', `${label} timed out`, { retryable: false });
+        return withOperationDeadline({ signal, timeoutMs: left }, label, (remaining) => work({ ...operation, ...remaining() }), bound);
     }
     /** Owns a candidate through configuration and recording setup, then publishes it once. */
     async transition(previous, budget, open, recover = false) {
         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');
@@ -134,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) {
@@ -224,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();
@@ -245,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) {
@@ -260,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.d.ts

@@ -169,7 +169,7 @@ export interface Browser extends Expectable<BrowserExpectation> {
     locator(selector: string): Locator;
     /** Creates a screen query scope inside one iframe. */
     frameLocator(selector: string): FrameScreen;
-    /** Evaluates trusted test code in the page. */
+    /** Evaluates trusted test code in the page: a function, or a string expression whose value is returned, called first if it is a function. */
     evaluate<T extends JsonValue>(fn: string | (() => T | Promise<T>)): Promise<T>;
     /** Evaluates trusted test code with one required JSON-safe argument. */
     evaluate<T extends JsonValue, Arg extends JsonValue>(fn: string | ((arg: Arg) => T | Promise<T>), arg: Arg): Promise<T>;