@e2e-dev/web 0.12.0 → 0.13.0

package/dist/.build.json

@@ -1 +1 @@
-{"version":"0.12.0"}
+{"version":"0.13.0"}

package/dist/actions.d.ts

@@ -13,10 +13,16 @@ export declare function dispatchLocatorAction(target: ActionTarget, action: Loca
  * 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 { 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. */
@@ -151,7 +151,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 +171,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 +184,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 +235,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/attempt-session.d.ts

@@ -1,6 +1,7 @@
 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';
@@ -57,8 +58,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. */

package/dist/attempt-session.js

@@ -3,7 +3,7 @@ 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';
@@ -83,8 +83,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,23 +92,26 @@ 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) {

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>;

package/dist/browser.js

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

package/dist/evaluation.d.ts

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

package/dist/evaluation.js

@@ -5,11 +5,14 @@ import { message } from './support.js';
 export const KEEP_NAMES_HELPER = "const __name = (target, value) => Object.defineProperty(target, 'name', { value, configurable: true });";
 /**
  * Compiles the page-side error boundary without evaluating the caller's source in this process.
+ * The source is one expression: a function it evaluates to is called with the argument, any
+ * other value is the result.
  *
  * A function serialized with `toString()` carries whatever the loader compiled
- * it to. tsx runs esbuild with `keepNames`, which wraps every nested named
- * binding in a module-scoped `__name(target, name)` helper; the page has no
- * such helper, so the same one is declared next to the inlined source.
+ * it to. e2e before 0.17 loaded tests through tsx, whose esbuild `keepNames`
+ * wraps every nested named binding in a module-scoped `__name(target, name)`
+ * helper; the page has no such helper, so the same one is declared next to
+ * the inlined source for as long as this engine supports those runners.
  */
 export function compileEvaluation(source, hasArgument) {
     try {
@@ -17,7 +20,7 @@ export function compileEvaluation(source, hasArgument) {
       return (async () => {
         ${KEEP_NAMES_HELPER}
         try {
-          return { ok: true, value: await (${source}\n)(${hasArgument ? 'arg' : ''}) };
+          return { ok: true, value: await ((result) => typeof result === 'function' ? result(${hasArgument ? 'arg' : ''}) : result)((${source}\n)) };
         } catch (cause) {
           let message;
           try {

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

@@ -219,7 +219,21 @@ export const readSemanticsFunction = (element, options) => {
             }
             case 'th': {
                 const scope = (el.getAttribute('scope') ?? '').toLowerCase();
-                return scope === 'row' || scope === 'rowgroup' ? 'rowheader' : 'columnheader';
+                if (scope === 'row' || scope === 'rowgroup')
+                    return 'rowheader';
+                if (scope === 'col' || scope === 'colgroup')
+                    return 'columnheader';
+                const previous = el.previousElementSibling;
+                const next = el.nextElementSibling;
+                if (previous === null && next === null) {
+                    const row = el.parentElement;
+                    const table = row?.tagName.toLowerCase() === 'tr' ? row.closest('table') : null;
+                    return table !== null && table.rows.length <= 1 ? null : 'columnheader';
+                }
+                if (previous?.tagName.toLowerCase() === 'th' && next?.tagName.toLowerCase() === 'th')
+                    return 'columnheader';
+                const hasDataNeighbor = [previous, next].some((cell) => cell?.tagName.toLowerCase() === 'td' && ((cell.textContent ?? '').trim() !== '' || cell.children.length > 0));
+                return hasDataNeighbor ? 'rowheader' : 'columnheader';
             }
             case 'dialog':
                 return 'dialog';

package/dist/install.d.ts

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

package/dist/install.js

@@ -1,29 +1,45 @@
 /** First-run browser provisioning for the Playwright engine. */
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import os from 'node:os';
 import path from 'node:path';
 import { EngineError, InfrastructureError } from 'e2e/engine';
 import { browserType } from './browser-connection.js';
+/** Whether `chromium_headless_shell-<revision>` under `browsersPath` finished installing and holds its executable. */
+function headlessShellInstalled(browsersPath, revision) {
+    const shellRoot = path.join(browsersPath, `chromium_headless_shell-${revision}`);
+    if (!existsSync(path.join(shellRoot, 'INSTALLATION_COMPLETE')))
+        return false;
+    const executable = process.platform === 'win32' ? 'chrome-headless-shell.exe' : 'chrome-headless-shell';
+    return readdirSync(shellRoot, { withFileTypes: true }).some((entry) => entry.isDirectory() && existsSync(path.join(shellRoot, entry.name, executable)));
+}
 /**
- * Whether the browser's executable exists on disk, or undefined when this
- * process cannot tell. Playwright resolves its browser cache from
- * `PLAYWRIGHT_BROWSERS_PATH` at module load, so the in-process check is only
- * authoritative when the run's environment agrees with this process's. A run
- * pointed at another cache is left to the CLI, which resolves against the
- * environment it is spawned with and is a no-op when nothing is missing.
+ * Whether the build the run launches (headless shell for headless chromium, else the full build)
+ * is on disk, or undefined when `env` points at another cache than this process loaded.
  */
-function isBrowserInstalled(name, env) {
+function isBrowserInstalled(name, env, headed) {
     if (env['PLAYWRIGHT_BROWSERS_PATH'] !== process.env['PLAYWRIGHT_BROWSERS_PATH'])
         return undefined;
     try {
-        return existsSync(browserType(name).executablePath());
+        const executable = browserType(name).executablePath();
+        if (headed || name !== 'chromium')
+            return existsSync(executable);
+        return headlessShellAt(executable);
     }
     catch {
         return false;
     }
 }
+/** Whether the shell beside `executable`'s full build is installed. */
+function headlessShellAt(executable) {
+    const marker = `${path.sep}chromium-`;
+    const at = executable.lastIndexOf(marker);
+    if (at === -1)
+        return false;
+    const revision = executable.slice(at + marker.length).split(path.sep)[0] ?? '';
+    return revision !== '' && headlessShellInstalled(executable.slice(0, at), revision);
+}
 /** The `node` arguments that run the pinned `playwright-core` CLI with `args`. */
 function playwrightCliArgs(args) {
     const require = createRequire(import.meta.url);
@@ -37,7 +53,10 @@ function playwrightCliArgs(args) {
  */
 export function runPlaywrightCli(args) {
     return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, playwrightCliArgs(args), { stdio: 'inherit' });
+        const child = spawn(process.execPath, playwrightCliArgs(args), {
+            stdio: 'inherit',
+            env: installEnvironment(),
+        });
         const forward = (signal) => child.kill(signal);
         process.on('SIGINT', forward);
         process.on('SIGTERM', forward);
@@ -55,6 +74,16 @@ export function runPlaywrightCli(args) {
         });
     });
 }
+/** The `playwright install` arguments for `names`: `--only-shell` on a headless chromium run. */
+export function installArgs(names, headed) {
+    if (headed || !names.includes('chromium'))
+        return [...names];
+    return ['--only-shell', ...names];
+}
+/** `env` with `PLAYWRIGHT_SKIP_BROWSER_GC=1` unless already set, so an install keeps other tools' browsers. */
+function installEnvironment(env = process.env) {
+    return { ...env, PLAYWRIGHT_SKIP_BROWSER_GC: env['PLAYWRIGHT_SKIP_BROWSER_GC'] ?? '1' };
+}
 /**
  * Ensures the given Playwright browsers are installed, downloading any
  * missing ones via `playwright-core install`. Called from the engine's `prepare`,
@@ -65,7 +94,8 @@ export function runPlaywrightCli(args) {
  */
 export async function ensureBrowsersInstalled(names, options = {}) {
     const env = options.env ?? process.env;
-    const isInstalled = options.isInstalled ?? ((name) => isBrowserInstalled(name, env));
+    const headed = options.headed ?? false;
+    const isInstalled = options.isInstalled ?? ((name) => isBrowserInstalled(name, env, headed));
     const verdicts = new Map([...new Set(names)].map((name) => [name, isInstalled(name)]));
     const missing = [...verdicts.keys()].filter((name) => verdicts.get(name) !== true);
     if (missing.length === 0)
@@ -78,7 +108,7 @@ export async function ensureBrowsersInstalled(names, options = {}) {
     if (knownMissing)
         log(`Downloading missing Playwright browsers (first run): ${missing.join(', ')}...`);
     const install = options.install ?? runPlaywrightInstall;
-    await install(missing, { log, signal: options.signal, env });
+    await install(missing, { log, signal: options.signal, env: installEnvironment(env), headed });
     if (knownMissing)
         log('Browser download complete.');
 }
@@ -109,13 +139,13 @@ function forwardLines(stream, log) {
     stream.on('end', () => flush(pending));
 }
 /** Spawns `node <playwright-core>/cli.js install <names>`, narrating its output through `log`. */
-function runPlaywrightInstall(names, { log, signal, env }) {
+function runPlaywrightInstall(names, { log, signal, env, headed }) {
     return new Promise((resolve, reject) => {
         if (signal?.aborted === true) {
             reject(new EngineError('CANCELLED', 'browser install cancelled', { retryable: false }));
             return;
         }
-        const child = spawn(process.execPath, playwrightCliArgs(['install', ...names]), {
+        const child = spawn(process.execPath, playwrightCliArgs(['install', ...installArgs(names, headed)]), {
             stdio: ['ignore', 'pipe', 'pipe'],
             env,
         });

package/dist/operation-budget.d.ts

@@ -6,5 +6,19 @@ export interface ConnectionBudget {
 }
 /** Preserves the reason for an engine-owned deadline without relabeling caller cancellation. */
 export declare function connectionAbort(signal: AbortSignal, label: string): EngineError;
+/**
+ * Whether the operation's deadline may end it. `test-code` is for an
+ * operation that runs the test's own code (a download trigger): that code
+ * keeps its own steps and their budgets, so the operation is not cut under
+ * it, and only cancellation ends the wait.
+ */
+export type OperationBound = 'deadline' | 'test-code';
+/**
+ * Bounds one operation by its budget: a call still pending at the deadline
+ * is abandoned as `OPERATION_TIMEOUT` instead of holding the test until its
+ * own timeout. `remaining` hands `work` the time left before Playwright's
+ * own timeout, the one to pass Playwright.
+ */
+export declare function withOperationDeadline<T>(budget: ConnectionBudget, label: string, work: (remaining: () => ConnectionBudget) => Promise<T>, bound?: OperationBound): Promise<T>;
 /** Bounds the entire transition, aborts abandoned work, and never grants a fresh dispatch budget. */
 export declare function withConnectionBudget<T>(budget: ConnectionBudget, label: string, work: (remaining: () => ConnectionBudget) => Promise<T>): Promise<T>;

package/dist/operation-budget.js

@@ -6,6 +6,37 @@ export function connectionAbort(signal, label) {
         ? signal.reason
         : new EngineError('CANCELLED', `${label} cancelled`, { retryable: false });
 }
+/**
+ * How much sooner than an operation's deadline Playwright's own timeout
+ * fires: its error names what blocked an action, or that the input was
+ * already dispatched, and this lead lets that answer arrive before the
+ * deadline does. The deadline is for the calls Playwright never answers: an
+ * evaluate, which takes no timeout, and every call while a trace snapshots a
+ * page whose renderer is stuck in a script. A budget shorter than twice the
+ * lead splits in half.
+ */
+const PLAYWRIGHT_TIMEOUT_LEAD_MS = 250;
+/**
+ * Bounds one operation by its budget: a call still pending at the deadline
+ * is abandoned as `OPERATION_TIMEOUT` instead of holding the test until its
+ * own timeout. `remaining` hands `work` the time left before Playwright's
+ * own timeout, the one to pass Playwright.
+ */
+export function withOperationDeadline(budget, label, work, bound = 'deadline') {
+    if (bound === 'test-code') {
+        const endsAt = Date.now() + budget.timeoutMs;
+        return raceAbort(() => work(() => {
+            if (budget.signal.aborted)
+                throw connectionAbort(budget.signal, label);
+            return { signal: budget.signal, timeoutMs: Math.max(1, endsAt - Date.now()) };
+        }), budget.signal, label);
+    }
+    return withConnectionBudget(budget, label, (remaining) => work(() => {
+        const current = remaining();
+        const lead = Math.min(PLAYWRIGHT_TIMEOUT_LEAD_MS, current.timeoutMs / 2);
+        return { signal: current.signal, timeoutMs: Math.ceil(current.timeoutMs - lead) };
+    }));
+}
 /** Bounds the entire transition, aborts abandoned work, and never grants a fresh dispatch budget. */
 export async function withConnectionBudget(budget, label, work) {
     const controller = new AbortController();

package/dist/support.d.ts

@@ -102,19 +102,23 @@ export declare function isTestErrorCode(cause: unknown, code: string): cause is
  * | `TimeoutError` on a read, navigation, or artifact call          | OPERATION_TIMEOUT         |
  * | `TimeoutError` on an action, log ends before the input dispatch | NOT_ACTIONABLE            |
  * | `TimeoutError` on an action, log shows the dispatch started     | ACTION_MAY_HAVE_COMMITTED |
+ * | operation deadline cut off an action, pointer, or keyboard call | ACTION_MAY_HAVE_COMMITTED |
  * | element detached / not attached / no element / resolved hidden  | NODE_STALE (retryable)    |
  * | execution context destroyed / frame detached by a navigation    | NODE_STALE (retryable)    |
+ * | strict mode violation, log ends before the input dispatch       | NODE_STALE (retryable)    |
+ * | strict mode violation, log shows the dispatch started           | ACTION_MAY_HAVE_COMMITTED |
  * | not an input / not editable / not checkable                     | NOT_ACTIONABLE            |
- * | strict mode violation, anything else                            | ENGINE_FAILURE           |
+ * | anything else                                                   | ENGINE_FAILURE            |
  *
  * The action split is read from the call log Playwright appends to a timeout
- * message: `performing <x> action`, `<x> action done`, and `waiting for
- * scheduled navigations to finish` are only logged once the input is being (or
- * has been) dispatched, so a timeout whose log reaches them is uncertain and
- * the harness must not blindly repeat it. Every earlier line (`waiting for
- * element to be visible, enabled and stable`, `scrolling into view if
- * needed`, `retrying <x> action`) precedes dispatch and is a plain
- * actionability miss.
+ * or strict mode message: `performing <x> action`, `<x> action done`, and
+ * `waiting for scheduled navigations to finish` are only logged once the input
+ * is being (or has been) dispatched, so a failure whose log reaches them is
+ * uncertain and the harness must not blindly repeat it. Every earlier line
+ * (`waiting for element to be visible, enabled and stable`, `scrolling into
+ * view if needed`, `retrying <x> action`) precedes dispatch and is a plain
+ * actionability miss. Only whole `- ` log lines count, so a locator or element
+ * text quoting those words never does.
  */
 export declare const POST_DISPATCH_PATTERN: RegExp;
 /** Translates an unexpected Playwright error at the contract boundary. */
@@ -142,7 +146,7 @@ export declare function performViewportSwipe(page: Page, direction: ScrollDirect
  * CSS pixel instead.
  */
 export declare function nearestPixel(point: ViewportPoint): ViewportPoint;
-/** A pointer drag from one viewport point to another, on whole pixels, with an intermediate move so drag handlers see motion. */
-export declare function performPointDrag(mouse: Mouse, start: ViewportPoint, end: ViewportPoint): Promise<void>;
+/** A pointer drag from one viewport point to another, on whole pixels, with an intermediate move so drag handlers see motion; paced over `durationMs` when given. */
+export declare function performPointDrag(mouse: Mouse, start: ViewportPoint, end: ViewportPoint, durationMs?: number, signal?: AbortSignal): Promise<void>;
 export declare function performElementSwipe(target: ActionTarget, direction: ScrollDirection, momentum: Momentum, timeout: number): Promise<void>;
 export {};

package/dist/support.js

@@ -1,4 +1,5 @@
 /** Shared error translation, filename, and swipe helpers for the Playwright engine. */
+import { setTimeout } from 'node:timers/promises';
 import { EngineError, withinCleanupBudget } from 'e2e/engine';
 import { ConfigurationError, InfrastructureError, TestError } from 'e2e/engine';
 export const DEFAULT_VIEWPORT = { width: 1280, height: 720 };
@@ -193,11 +194,12 @@ export class ErrorLatch {
     }
 }
 /**
- * The runner error classes as their `name` reads. A project loads this engine
- * from its config file in one module realm (tsx) while the runner's core runs
- * in another, so a runner error reaching the engine is often a `TestError`
- * from a copy of `e2e` this module never imported: `instanceof` says no while
- * `name` and `code` still tell the truth.
+ * The runner error classes as their `name` reads. A project can load this
+ * engine against a copy of `e2e` other than the one the runner's core runs
+ * from (and e2e before 0.17 always loaded config in a module realm of its
+ * own), so a runner error reaching the engine can be a `TestError` this
+ * module never imported: `instanceof` says no while `name` and `code` still
+ * tell the truth.
  */
 const CLASSIFIED_NAMES = new Set([
     'EngineError',
@@ -236,21 +238,25 @@ export function isTestErrorCode(cause, code) {
  * | `TimeoutError` on a read, navigation, or artifact call          | OPERATION_TIMEOUT         |
  * | `TimeoutError` on an action, log ends before the input dispatch | NOT_ACTIONABLE            |
  * | `TimeoutError` on an action, log shows the dispatch started     | ACTION_MAY_HAVE_COMMITTED |
+ * | operation deadline cut off an action, pointer, or keyboard call | ACTION_MAY_HAVE_COMMITTED |
  * | element detached / not attached / no element / resolved hidden  | NODE_STALE (retryable)    |
  * | execution context destroyed / frame detached by a navigation    | NODE_STALE (retryable)    |
+ * | strict mode violation, log ends before the input dispatch       | NODE_STALE (retryable)    |
+ * | strict mode violation, log shows the dispatch started           | ACTION_MAY_HAVE_COMMITTED |
  * | not an input / not editable / not checkable                     | NOT_ACTIONABLE            |
- * | strict mode violation, anything else                            | ENGINE_FAILURE           |
+ * | anything else                                                   | ENGINE_FAILURE            |
  *
  * The action split is read from the call log Playwright appends to a timeout
- * message: `performing <x> action`, `<x> action done`, and `waiting for
- * scheduled navigations to finish` are only logged once the input is being (or
- * has been) dispatched, so a timeout whose log reaches them is uncertain and
- * the harness must not blindly repeat it. Every earlier line (`waiting for
- * element to be visible, enabled and stable`, `scrolling into view if
- * needed`, `retrying <x> action`) precedes dispatch and is a plain
- * actionability miss.
+ * or strict mode message: `performing <x> action`, `<x> action done`, and
+ * `waiting for scheduled navigations to finish` are only logged once the input
+ * is being (or has been) dispatched, so a failure whose log reaches them is
+ * uncertain and the harness must not blindly repeat it. Every earlier line
+ * (`waiting for element to be visible, enabled and stable`, `scrolling into
+ * view if needed`, `retrying <x> action`) precedes dispatch and is a plain
+ * actionability miss. Only whole `- ` log lines count, so a locator or element
+ * text quoting those words never does.
  */
-export const POST_DISPATCH_PATTERN = /performing \w+ action|\w+ action done|waiting for scheduled navigations to finish/i;
+export const POST_DISPATCH_PATTERN = /^\s*- (performing \w+ action|[\w ]+ action done|waiting for scheduled navigations to finish)\s*$/im;
 /** Translates an unexpected Playwright error at the contract boundary. */
 export function translatePwError(cause, operation) {
     if (isClassified(cause))
@@ -321,16 +327,31 @@ export async function performViewportSwipe(page, direction, momentum) {
 export function nearestPixel(point) {
     return { x: Math.round(point.x), y: Math.round(point.y) };
 }
-/** A pointer drag from one viewport point to another, on whole pixels, with an intermediate move so drag handlers see motion. */
-export async function performPointDrag(mouse, start, end) {
+/** A pointer drag from one viewport point to another, on whole pixels, with an intermediate move so drag handlers see motion; paced over `durationMs` when given. */
+export async function performPointDrag(mouse, start, end, durationMs, signal) {
     const from = nearestPixel(start);
     const to = nearestPixel(end);
     const middle = nearestPixel({ x: (from.x + to.x) / 2, y: (from.y + to.y) / 2 });
     await mouse.move(from.x, from.y);
     await mouse.down();
-    await mouse.move(middle.x, middle.y);
-    await mouse.move(to.x, to.y);
-    await mouse.up();
+    try {
+        if (durationMs !== undefined) {
+            const steps = Math.max(2, Math.round(durationMs / 16));
+            const startedAt = performance.now();
+            for (let step = 1; step <= steps; step += 1) {
+                const due = startedAt + (durationMs * step) / steps;
+                await setTimeout(Math.max(0, due - performance.now()), undefined, { signal });
+                await mouse.move(from.x + ((to.x - from.x) * step) / steps, from.y + ((to.y - from.y) * step) / steps);
+            }
+        }
+        else {
+            await mouse.move(middle.x, middle.y);
+            await mouse.move(to.x, to.y);
+        }
+    }
+    finally {
+        await mouse.up();
+    }
 }
 export async function performElementSwipe(target, direction, momentum, timeout) {
     // Hover first: it auto-waits for visibility on both target kinds, so the

package/dist/surface.d.ts

@@ -11,6 +11,7 @@ import { type EngineAttemptContext, type EngineCleanupContext, type EngineInitIn
 import { type BrowserName } from './browser-connection.ts';
 import { type BrowserProvider, type LeaseDownloads } from './provider.ts';
 import { DialogRouter } from './dialogs.ts';
+import { type OperationBound } from './operation-budget.ts';
 import { type WebInitScript } from './init-scripts.ts';
 import { ErrorLatch } from './support.ts';
 type RoutePredicate = (url: URL) => boolean;
@@ -297,11 +298,13 @@ export declare class PlaywrightSurface {
      * The single entry of every operation: rethrows an error latched on an
      * unawaited path, refuses a cancelled operation, races `fn` against the
      * operation signal so an abort mid-call surfaces as `CANCELLED` instead of
-     * waiting out Playwright, and translates raw errors at the contract
+     * waiting out Playwright, bounds it by the operation's budget so a call a
+     * hung page never answers is `OPERATION_TIMEOUT`, and translates raw errors at the contract
      * boundary. `translate` overrides the default translation for operations
-     * with a documented retryable failure mode.
+     * with a documented retryable failure mode; `bound` is `test-code` for an
+     * operation that runs the test's own code, which the deadline never cuts.
      */
-    guard<T>(operation: OperationContext, label: string, fn: (operation: OperationContext) => Promise<T>, translate?: (cause: unknown, label: string) => Error): Promise<T>;
+    guard<T>(operation: OperationContext, label: string, fn: (operation: OperationContext) => Promise<T>, translate?: (cause: unknown, label: string) => Error, bound?: OperationBound): Promise<T>;
     /** Opens one URL the harness resolved; the attempt's page is created on first use. */
     open(url: string, operation: OperationContext): Promise<void>;
     back(operation: OperationContext): Promise<void>;

package/dist/surface.js

@@ -10,7 +10,7 @@ import { mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { EngineError, raceAbort, TestError, withinCleanupBudget, } from 'e2e/engine';
 import { matchesText } from 'e2e/engine';
-import { classifyActionError, dispatchLocatorAction, dispatchPointerAction } from './actions.js';
+import { classifyActionError, classifyInputError, dispatchLocatorAction, dispatchPointerAction } from './actions.js';
 import { BrowserConnection, connectCdp } from './browser-connection.js';
 import { AttemptSession } from './attempt-session.js';
 import { LeasedBrowsers } from './provider.js';
@@ -20,7 +20,7 @@ import { applyPostSteps, frameSelectors, projectExpression } from './locators.js
 import { ROOT_NODE_ID, toSemanticNode } from './observation.js';
 import { captureObservation } from './observation-capture.js';
 import { maskOptions, secureFieldMasks } from './observe.js';
-import { connectionAbort } from './operation-budget.js';
+import { connectionAbort, withOperationDeadline } from './operation-budget.js';
 import { CLOSED_SHADOW_ROOTS_INIT_SCRIPT } from './closed-shadow.js';
 import { ConfiguredInitScripts } from './init-scripts.js';
 import { SECURE_FIELD_SELECTOR } from './read-node.js';
@@ -109,7 +109,7 @@ export class PlaywrightSurface {
             return this.leases.prepare(info);
         if (this.connect !== undefined)
             return;
-        await ensureBrowsersInstalled([this.browserName], { env: info.env, signal: info.signal, log: info.log });
+        await ensureBrowsersInstalled([this.browserName], { env: info.env, signal: info.signal, log: info.log, headed: info.headed });
     }
     /** Releases the browsers `prepare` leased; a local launch or a `connect` has nothing to release. */
     async finish(info) {
@@ -395,16 +395,18 @@ export class PlaywrightSurface {
      * The single entry of every operation: rethrows an error latched on an
      * unawaited path, refuses a cancelled operation, races `fn` against the
      * operation signal so an abort mid-call surfaces as `CANCELLED` instead of
-     * waiting out Playwright, and translates raw errors at the contract
+     * waiting out Playwright, bounds it by the operation's budget so a call a
+     * hung page never answers is `OPERATION_TIMEOUT`, and translates raw errors at the contract
      * boundary. `translate` overrides the default translation for operations
-     * with a documented retryable failure mode.
+     * with a documented retryable failure mode; `bound` is `test-code` for an
+     * operation that runs the test's own code, which the deadline never cuts.
      */
-    async guard(operation, label, fn, translate = translatePwError) {
+    async guard(operation, label, fn, translate = translatePwError, bound = 'deadline') {
         this.latch.throwPending();
         try {
             return this.session === undefined
-                ? await raceAbort(() => fn(operation), operation.signal, label)
-                : await this.session.run(operation, label, fn);
+                ? await withOperationDeadline(operation, label, (remaining) => fn({ ...operation, ...remaining() }), bound)
+                : await this.session.run(operation, label, fn, bound);
         }
         catch (cause) {
             throw translate(cause, label);
@@ -519,7 +521,7 @@ export class PlaywrightSurface {
             return matches.map(({ raw, index }) => {
                 const pinned = handles?.[index];
                 // A single match keeps the strict locator, so a ref that turns
-                // ambiguous between locate and perform fails loud instead of acting
+                // ambiguous between locate and perform is stale instead of acting
                 // on whichever element is first.
                 const locator = reads.length === 1 ? projected.locator : projected.locator.nth(index);
                 const id = refs.storeLocated(pinned === undefined ? { kind: 'locator', locator } : { kind: 'element', element: pinned });
@@ -545,10 +547,10 @@ export class PlaywrightSurface {
     }
     /** One pointer action at a viewport point in CSS pixels, with nothing resolved behind it; see `dispatchPointerAction`. */
     performAt(point, action, operation) {
-        return this.guard(operation, `${action.kind} at point`, () => {
+        return this.guard(operation, `${action.kind} at point`, (currentOperation) => {
             this.requireSession().requireObservation();
-            return dispatchPointerAction(this.requirePage(), point, action);
-        });
+            return dispatchPointerAction(this.requirePage(), point, action, currentOperation.signal);
+        }, classifyInputError);
     }
     /**
      * Types into whatever holds focus. Keystrokes into a document body are
@@ -578,14 +580,14 @@ export class PlaywrightSurface {
                 checkpoint();
             }
             await page.keyboard.type(text);
-        });
+        }, classifyInputError);
     }
     /** Sends one key to whatever holds focus, in the contract's key grammar Playwright shares. */
     pressKey(key, operation) {
         return this.guard(operation, 'keyboard.press', () => {
             this.requireSession().requireObservation();
             return this.requirePage().keyboard.press(key);
-        });
+        }, classifyInputError);
     }
     /**
      * Refuses focused typing when nothing that takes keystrokes has focus, in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e2e-dev/web",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Web engine for e2e agentic end-to-end testing, built on Playwright",
   "keywords": [
     "e2e",
@@ -50,18 +50,18 @@
     "playwright-core": "1.63.0"
   },
   "peerDependencies": {
-    "e2e": ">=0.15.0 <1"
+    "e2e": ">=0.18.0 <1"
   },
   "devDependencies": {
     "@types/node": "26.6.2",
-    "e2e": "0.17.0",
+    "e2e": "0.18.0",
     "@types/pngjs": "6.0.5",
     "pngjs": "7.0.0",
     "typescript": "7.0.2",
     "vitest": "5.0.1"
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": "^22.22.3 || >=24.8.0"
   },
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc --project tsconfig.build.json && node ../../scripts/stamp-dist.ts",