@e2e-dev/web 0.15.1 → 0.15.2

package/dist/.build.json

@@ -1 +1 @@
-{"version":"0.15.1"}
+{"version":"0.15.2"}

package/dist/browser.js

@@ -237,6 +237,7 @@ export function createBrowserFixture(surface, context) {
                     url: response.url(),
                     status: response.status(),
                     headers: response.headers(),
+                    // oxlint-disable-next-line e2e/no-unchecked-json -- public API: the caller names T, unknown by default
                     json: async () => JSON.parse(await text()),
                     text,
                 };

package/dist/engine.js

@@ -36,8 +36,8 @@ export function web(options = {}) {
     if (provider !== undefined && options.connect !== undefined) {
         throw new ConfigurationError('INVALID_CONFIG', `web({ browser, connect }) names two browser sources; browser provider "${provider.name}" leases its own browsers, so remove connect`);
     }
-    if (isRecord(options.connect))
-        rejectUnknownKeys('web({ connect })', options.connect, ['cdpEndpoint', 'reconnectEndpoint']);
+    if (options.connect !== undefined)
+        validateConnect(options.connect);
     if (options.connect !== undefined && typeof options.browser === 'string' && options.browser !== 'chromium') {
         throw new ConfigurationError('INVALID_CONFIG', `web({ connect }) requires the chromium browser; CDP attach is chromium-only, got "${options.browser}"`);
     }
@@ -59,9 +59,6 @@ export function web(options = {}) {
     if (options.screencast !== undefined)
         validateScreencast(options.screencast);
     const reconnecting = options.connect?.reconnectEndpoint !== undefined;
-    if (reconnecting && typeof options.connect?.reconnectEndpoint !== 'function') {
-        throw new ConfigurationError('INVALID_CONFIG', 'connect.reconnectEndpoint must be a function');
-    }
     // A per-attempt lease rides the same persistent context as `reconnectEndpoint`, with the same limits.
     const recoverable = reconnecting || provider?.scope === 'attempt';
     const mode = provider === undefined ? 'connect.reconnectEndpoint' : `browser provider "${provider.name}" with scope "attempt"`;
@@ -155,6 +152,38 @@ function persistentContextLimit(what, mode, leased) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+/** Names a value's kind for a config error without echoing it: a CDP URL can carry a session token. */
+function kindOf(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'an array';
+    const type = typeof value;
+    return type === 'object' ? 'an object' : `a ${type}`;
+}
+/**
+ * `cdpEndpoint` is the one resolver every connect mode needs: the shared
+ * browser's source at init, and the fresh browser each persistent attempt
+ * provisions. Without it the attach would call an undefined resolver, so a
+ * config missing it fails here, at load, instead of at worker init or on
+ * every attempt with `ENGINE_FAILURE: ... resolve is not a function`.
+ */
+function validateConnect(connect) {
+    if (!isRecord(connect)) {
+        throw new ConfigurationError('INVALID_CONFIG', `web({ connect }) must be a plain object: { cdpEndpoint, reconnectEndpoint? }, got ${kindOf(connect)}`);
+    }
+    rejectUnknownKeys('web({ connect })', connect, ['cdpEndpoint', 'reconnectEndpoint']);
+    const { cdpEndpoint, reconnectEndpoint } = connect;
+    if (cdpEndpoint === undefined) {
+        throw new ConfigurationError('INVALID_CONFIG', `web({ connect }) requires cdpEndpoint, the resolver that provisions the browser: (signal) => url${reconnectEndpoint === undefined ? '' : '; reconnectEndpoint only reconnects to the browser cdpEndpoint provisioned'}`);
+    }
+    if (typeof cdpEndpoint !== 'function') {
+        throw new ConfigurationError('INVALID_CONFIG', `web({ connect: { cdpEndpoint } }) must be a resolver function (signal) => url, got ${kindOf(cdpEndpoint)}`);
+    }
+    if (reconnectEndpoint !== undefined && typeof reconnectEndpoint !== 'function') {
+        throw new ConfigurationError('INVALID_CONFIG', `web({ connect: { reconnectEndpoint } }) must be a resolver function (signal) => url, got ${kindOf(reconnectEndpoint)}`);
+    }
+}
 /**
  * Refuses a header the browser could not send, at config load rather than at
  * the first request: a name outside the token grammar, a value carrying a

package/dist/observation.js

@@ -83,6 +83,7 @@ async function captureInto(deps, scope, stage, host, framePath, budget, signal)
         return data;
     }));
     const decoded = typeof metadata === 'string'
+        // oxlint-disable-next-line e2e/no-unchecked-json -- page-reported metadata, as unchecked as the structured branch; only the ids and nodes alignment below is checked
         ? JSON.parse(metadata)
         : metadata;
     const { nodes, ids, truncated: walkTruncated } = decoded;

package/dist/support.js

@@ -316,7 +316,7 @@ export async function performViewportSwipe(page, direction, momentum) {
     const viewport = await currentViewport(page);
     const distance = swipeDistance(direction === 'up' || direction === 'down' ? viewport.height : viewport.width, momentum);
     const [deltaX, deltaY] = wheelDelta(direction, distance);
-    return page.mouse.wheel(deltaX, deltaY);
+    await wheelRendered(page, deltaX, deltaY);
 }
 /**
  * The browser truncates a fractional pointer coordinate, so a point composed
@@ -354,10 +354,16 @@ export async function performPointDrag(mouse, start, end, durationMs, signal) {
     }
 }
 export async function performElementSwipe(target, direction, momentum, timeout) {
-    // Hover first: it auto-waits for visibility on both target kinds, so the
-    // immediate box read below observes a settled element.
-    await asActionable(target).hover({ timeout });
-    const box = await targetBoundingBox(target, timeout);
+    // A node the pointer already hovers takes the wheel where it is; one hit at
+    // its centre takes it there, at the box that hit test read; otherwise hover
+    // waits for it to be actionable, scrolls it into view, and reports whatever
+    // intercepts the pointer.
+    const aimed = await (target.kind === 'locator'
+        ? target.locator.evaluate(wheelAim, undefined, { timeout })
+        : target.element.evaluate(wheelAim));
+    if (aimed.aim === 'blocked')
+        await asActionable(target).hover({ timeout });
+    const box = aimed.aim === 'blocked' ? await targetBoundingBox(target, timeout) : aimed.box;
     if (box === null) {
         throw new EngineError('NOT_ACTIONABLE', 'element has no visible bounding box', {
             retryable: false,
@@ -366,7 +372,41 @@ export async function performElementSwipe(target, direction, momentum, timeout)
     const distance = swipeDistance(direction === 'up' || direction === 'down' ? box.height : box.width, momentum);
     const [deltaX, deltaY] = wheelDelta(direction, distance);
     const page = await targetPage(target);
+    if (aimed.aim === 'centre')
+        await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+    await wheelRendered(page, deltaX, deltaY);
+}
+/**
+ * Wheels the page and resolves once a frame rendered the scroll it caused.
+ * The scroll lands on the compositor and reaches script on the next frame, so
+ * a read right after a bare `mouse.wheel` can see the document it left. A
+ * hidden document renders no frames, so it resolves at once.
+ */
+async function wheelRendered(page, deltaX, deltaY) {
     await page.mouse.wheel(deltaX, deltaY);
+    await page.evaluate(nextRenderedFrame);
+}
+/** Page-side: resolves after the next rendered frame, or at once in a hidden document. */
+function nextRenderedFrame() {
+    if (document.visibilityState === 'hidden')
+        return Promise.resolve();
+    return new Promise((resolve) => requestAnimationFrame(() => window.setTimeout(resolve, 0)));
+}
+/**
+ * Page-side: where a wheel reaches `element` in a top-level document, whose
+ * box is the page's: at the pointer when it already hovers the element, at
+ * its centre when the hit target there is the element or inside it, or
+ * `blocked` when neither holds.
+ */
+function wheelAim(element) {
+    if (window !== window.top || element.getClientRects().length === 0)
+        return { aim: 'blocked' };
+    const rect = element.getBoundingClientRect();
+    const box = { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+    if (element.matches(':hover'))
+        return { aim: 'pointer', box };
+    const hit = document.elementFromPoint(rect.x + rect.width / 2, rect.y + rect.height / 2);
+    return hit !== null && element.contains(hit) ? { aim: 'centre', box } : { aim: 'blocked' };
 }
 function swipeDistance(extent, momentum) {
     const ratio = momentum === 'fast' ? 1.5 : momentum === 'slow' ? 0.75 : 0.5;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e2e-dev/web",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "description": "Web engine for e2e agentic end-to-end testing, built on Playwright",
   "keywords": [
     "e2e",
@@ -54,7 +54,7 @@
   },
   "devDependencies": {
     "@types/node": "26.6.2",
-    "e2e": "0.21.1",
+    "e2e": "0.21.2",
     "@types/pngjs": "6.0.5",
     "pngjs": "7.0.0",
     "typescript": "7.0.2",