browser-debugger-cli 0.8.0 → 0.9.0

package/dist/runtime/dom/formSubmitHelpers.js

@@ -3,9 +3,11 @@
  */
 import { CDPTimeoutError } from '../../connection/errors.js';
 import { trackInFlightRequests } from '../../connection/inFlightRequests.js';
-import { submitTimeoutError } from '../../errors/messages.js';
+import { submitNetworkBusyWarning, submitTimeoutError } from '../../errors/messages.js';
+import { ELEMENT_IDENTITY_JS } from './elementInfo.js';
 import { throwIfInvalidSelector } from './formFillHelpers/shared.js';
 import { FIND_ELEMENTS_JS, selectorArgsJS } from './targetNode.js';
+import { summarizePendingRequests } from '../page/loadingState.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
 import { clickElement } from './formFillHelpers/index.js';
 /**
@@ -61,9 +63,10 @@ const PREPARE_SUBMIT_SCRIPT = `
     // Like pressing Enter: the form's default button is the submitter, so its
     // name=value is sent too
     const submitter = submitters.find((f) => !f.matches(':disabled'));
+    const element = (${ELEMENT_IDENTITY_JS})(submitter || el);
     if (submitter) el.requestSubmit(submitter);
     else el.requestSubmit();
-    return { action: 'submitted', clicked: Boolean(submitter) };
+    return { action: 'submitted', clicked: Boolean(submitter), element: element };
   }
   return { action: 'click' };
 })`;
@@ -84,9 +87,14 @@ const FAILURE_SUGGESTIONS = {
 /**
  * Watches navigation and network activity from before a submission is
  * triggered, so fast navigations are not missed.
+ *
+ * A navigation is a new document committed in the main frame
+ * (`Page.frameNavigated`), whatever its URL: a POST that redirects back to
+ * the form's own URL (a login error) navigates too.
  */
 class SubmissionWatcher {
     navigated = false;
+    documentRequest;
     onChange = null;
     requests;
     disposers = [];
@@ -96,27 +104,66 @@ class SubmissionWatcher {
     constructor(cdp) {
         this.requests = trackInFlightRequests(cdp, () => this.onChange?.());
         this.disposers.push(this.requests.dispose);
-        this.disposers.push(cdp.on('Page.frameNavigated', (params) => {
-            if (params.frame.parentId !== undefined)
+        this.disposers.push(cdp.on('Page.frameNavigated', (params, sessionId) => {
+            if (sessionId !== undefined || params.frame.parentId !== undefined)
                 return;
             this.navigated = true;
             this.onChange?.();
+        }), cdp.on('Network.requestWillBeSent', (params, sessionId) => {
+            if (sessionId !== undefined || params.type !== 'Document')
+                return;
+            this.documentRequest ??= {
+                requestId: params.requestId,
+                method: params.request.method,
+                url: params.request.url,
+                startedAt: Date.now(),
+            };
+        }), cdp.on('Network.responseReceived', (params) => {
+            if (params.requestId !== this.documentRequest?.requestId)
+                return;
+            this.documentRequest.status = params.response.status;
+            this.documentRequest.statusText = params.response.statusText;
+        }), cdp.on('Network.loadingFailed', (params) => {
+            if (params.requestId !== this.documentRequest?.requestId)
+                return;
+            this.documentRequest.errorText = params.errorText;
         }));
     }
     /** Whether the main frame navigated since watching began. */
     get navigationOccurred() {
         return this.navigated;
     }
+    /** How far the first page request sent since watching began got, if one was sent */
+    get firstDocumentRequest() {
+        const request = this.documentRequest;
+        if (!request)
+            return undefined;
+        const answered = request.status !== undefined || request.errorText !== undefined;
+        return {
+            method: request.method,
+            url: request.url,
+            ...(!answered && { pendingMs: Date.now() - request.startedAt }),
+            ...(request.status !== undefined && { status: request.status }),
+            ...(request.statusText && { statusText: request.statusText }),
+            ...(request.errorText !== undefined && { errorText: request.errorText }),
+        };
+    }
+    /** Requests still in flight */
+    get pendingRequests() {
+        return this.requests.count;
+    }
     /** Requests started since watching began. */
     get networkRequests() {
         return this.requests.started;
     }
     /**
      * Wait until the network is idle for `waitNetwork` ms and, if requested,
-     * the main frame navigated.
+     * the main frame navigated. When a requested navigation happened but the
+     * network was still busy at the timeout (a slow script or tracker on the
+     * new page), the wait ends without an error: resolves to `'busy'`.
      *
      * @param options - Wait conditions
-     * @returns Resolves when done
+     * @returns `'idle'`, or `'busy'` when only the network wait timed out
      * @throws CDPTimeoutError after `timeout` ms
      */
     wait(options) {
@@ -131,13 +178,16 @@ class SubmissionWatcher {
             };
             const deadline = setTimeout(() => {
                 finish();
-                reject(new CDPTimeoutError('Wait for completion timed out', new Error(`${timeout}ms`)));
+                if (waitNavigation && this.navigated)
+                    resolve('busy');
+                else
+                    reject(new CDPTimeoutError('Wait for completion timed out', new Error(`${timeout}ms`)));
             }, timeout);
             const check = () => {
                 const networkIdle = waitNetwork === 0 || this.requests.count === 0;
                 if (networkIdle && (!waitNavigation || this.navigated)) {
                     finish();
-                    resolve();
+                    resolve('idle');
                 }
             };
             const schedule = () => {
@@ -184,14 +234,16 @@ async function triggerSubmit(cdp, selector, index) {
             clicked: false,
             exitCode: FAILURE_EXIT_CODES[reason],
             suggestion: FAILURE_SUGGESTIONS[reason],
+            ...(reason === 'not-submittable' && { unsuitableElement: true }),
         };
         return { failure };
     }
-    if (prepared.action === 'submitted')
-        return { clicked: prepared.clicked === true };
+    if (prepared.action === 'submitted') {
+        return { clicked: prepared.clicked === true, element: prepared.element };
+    }
     const click = await clickElement(cdp, selector, index !== undefined ? { index } : {});
     if (click.success)
-        return { clicked: true };
+        return { clicked: true, element: click.element };
     const failure = {
         success: false,
         error: click.error ?? 'Click failed',
@@ -202,6 +254,21 @@ async function triggerSubmit(cdp, selector, index) {
     };
     return { failure };
 }
+/**
+ * The requests still running in the session, the longest-running first.
+ *
+ * @param pendingRequests - Source of the session's pending requests
+ * @returns The ones to name and the count, none without a source
+ */
+function pendingSummary(pendingRequests) {
+    if (!pendingRequests)
+        return {};
+    const requests = [...pendingRequests()];
+    return {
+        pending: summarizePendingRequests(requests, Date.now()),
+        pendingCount: requests.length,
+    };
+}
 /**
  * Submit a form and wait for the result.
  *
@@ -218,22 +285,29 @@ export async function submitForm(cdp, selector, options = {}) {
         const triggered = await triggerSubmit(cdp, selector, index);
         if ('failure' in triggered)
             return triggered.failure;
-        if (waitNetwork > 0 || waitNavigation) {
-            await watcher.wait({ waitNavigation, waitNetwork, timeout });
-        }
+        const outcome = waitNetwork > 0 || waitNavigation
+            ? await watcher.wait({ waitNavigation, waitNetwork, timeout })
+            : 'idle';
         return {
             success: true,
             selector,
+            ...(triggered.element !== undefined && { element: triggered.element }),
             clicked: triggered.clicked,
             networkRequests: watcher.networkRequests,
             navigationOccurred: watcher.navigationOccurred,
             waitTimeMs: Date.now() - startTime,
+            ...(outcome === 'busy' && {
+                warning: submitNetworkBusyWarning(timeout, watcher.pendingRequests),
+            }),
         };
     }
     catch (error) {
         if (!(error instanceof CDPTimeoutError))
             throw error;
-        const err = submitTimeoutError(timeout, waitNavigation);
+        const err = submitTimeoutError(timeout, waitNavigation, {
+            document: watcher.firstDocumentRequest,
+            ...pendingSummary(options.pendingRequests),
+        });
         return {
             success: false,
             error: err.message,

package/dist/runtime/dom/frameLayout.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Layout of an element inside a cross-origin iframe that shares the page's
+ * process (an a11y query can return those).
+ *
+ * The element is measured in its own frame, whose scripts cannot see the top
+ * page, so its measurements are relative to the frame's viewport. The
+ * iframe element holding the frame is measured in its own document, and the
+ * element is placed in the top-level viewport through it: mapped by the
+ * frame's position and scale, clipped to the frame's viewport and to what clips the
+ * iframe, and fixed, scrolled or hidden as the iframe is.
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { Protocol } from '../../connection/typed-cdp.js';
+import type { LayoutBox } from '../../ipc/protocol/domTypes.js';
+import { type FrameMapping } from './frameScopedConnection.js';
+import type { RawLayout } from './layout.js';
+/**
+ * Ids of all frames below a frame tree's root.
+ *
+ * @param tree - Frame tree
+ * @returns Frame ids, depth-first
+ */
+export declare function childFrameIds(tree: Protocol.Page.FrameTree | undefined): string[];
+/**
+ * The iframe element whose document holds an element.
+ *
+ * @param cdp - CDP connection
+ * @param objectId - Remote object of the element
+ * @returns Backend node id of the iframe element, undefined when not found
+ */
+export declare function findFrameOwner(cdp: CDPConnection, objectId: string): Promise<number | undefined>;
+/**
+ * Overlap of boxes.
+ *
+ * @param boxes - Boxes (null ones are left out)
+ * @returns Overlap (zero size when they do not overlap)
+ */
+export declare function intersection(...boxes: Array<LayoutBox | null>): LayoutBox;
+/**
+ * Whether a box lies inside another.
+ *
+ * @param inner - Inner box
+ * @param outer - Outer box
+ * @returns True when it does
+ */
+export declare function inside(inner: LayoutBox, outer: LayoutBox): boolean;
+/**
+ * Place an element measured inside a cross-origin frame in the top-level
+ * viewport, through the measurements of the frame's iframe element: mapped by
+ * the frame's position and scale (border, padding, `transform`, `zoom`),
+ * clipped to the frame's viewport and to what clips the iframe.
+ *
+ * @param raw - The element, measured in its frame
+ * @param owner - The iframe element, measured in its document
+ * @param mapping - How the frame's viewport maps into the top-level viewport
+ * @returns The element's layout in the top-level page (unchanged when the
+ *   iframe could not be measured)
+ */
+export declare function placeInOwnerFrame(raw: RawLayout, owner: RawLayout, mapping: FrameMapping): RawLayout;
+//# sourceMappingURL=frameLayout.d.ts.map

package/dist/runtime/dom/frameLayout.js

@@ -0,0 +1,140 @@
+/**
+ * Layout of an element inside a cross-origin iframe that shares the page's
+ * process (an a11y query can return those).
+ *
+ * The element is measured in its own frame, whose scripts cannot see the top
+ * page, so its measurements are relative to the frame's viewport. The
+ * iframe element holding the frame is measured in its own document, and the
+ * element is placed in the top-level viewport through it: mapped by the
+ * frame's position and scale, clipped to the frame's viewport and to what clips the
+ * iframe, and fixed, scrolled or hidden as the iframe is.
+ */
+import { mapBox } from './frameScopedConnection.js';
+import { createLogger } from '../../ui/logging/index.js';
+import { getErrorMessage } from '../../utils/errors.js';
+const log = createLogger('dom');
+/**
+ * Ids of all frames below a frame tree's root.
+ *
+ * @param tree - Frame tree
+ * @returns Frame ids, depth-first
+ */
+export function childFrameIds(tree) {
+    return (tree?.childFrames ?? []).flatMap((child) => [child.frame.id, ...childFrameIds(child)]);
+}
+/**
+ * Backend node id of the document holding an element.
+ *
+ * @param cdp - CDP connection
+ * @param objectId - Remote object of the element
+ * @returns The document's backend node id, if it could be read
+ */
+async function ownerDocumentId(cdp, objectId) {
+    const doc = (await cdp.send('Runtime.callFunctionOn', {
+        objectId,
+        functionDeclaration: 'function () { return this.ownerDocument; }',
+    }));
+    if (!doc.result.objectId)
+        return undefined;
+    const { node } = (await cdp.send('DOM.describeNode', {
+        objectId: doc.result.objectId,
+    }));
+    return node.backendNodeId;
+}
+/**
+ * The iframe element whose document holds an element.
+ *
+ * @param cdp - CDP connection
+ * @param objectId - Remote object of the element
+ * @returns Backend node id of the iframe element, undefined when not found
+ */
+export async function findFrameOwner(cdp, objectId) {
+    try {
+        const documentId = await ownerDocumentId(cdp, objectId);
+        const { frameTree } = (await cdp.send('Page.getFrameTree'));
+        for (const frameId of childFrameIds(frameTree)) {
+            const owner = (await cdp.send('DOM.getFrameOwner', {
+                frameId,
+            }));
+            const { node } = (await cdp.send('DOM.describeNode', {
+                backendNodeId: owner.backendNodeId,
+            }));
+            if (node.contentDocument?.backendNodeId === documentId)
+                return owner.backendNodeId;
+        }
+    }
+    catch (error) {
+        log.debug(`Frame owner not found: ${getErrorMessage(error)}`);
+    }
+    return undefined;
+}
+/**
+ * Overlap of boxes.
+ *
+ * @param boxes - Boxes (null ones are left out)
+ * @returns Overlap (zero size when they do not overlap)
+ */
+export function intersection(...boxes) {
+    const present = boxes.filter((box) => box !== null);
+    const left = Math.max(...present.map((box) => box.x));
+    const top = Math.max(...present.map((box) => box.y));
+    const right = Math.min(...present.map((box) => box.x + box.width));
+    const bottom = Math.min(...present.map((box) => box.y + box.height));
+    return { x: left, y: top, width: Math.max(0, right - left), height: Math.max(0, bottom - top) };
+}
+/**
+ * Whether a box lies inside another.
+ *
+ * @param inner - Inner box
+ * @param outer - Outer box
+ * @returns True when it does
+ */
+export function inside(inner, outer) {
+    return (inner.x >= outer.x &&
+        inner.y >= outer.y &&
+        inner.x + inner.width <= outer.x + outer.width &&
+        inner.y + inner.height <= outer.y + outer.height);
+}
+/**
+ * Place an element measured inside a cross-origin frame in the top-level
+ * viewport, through the measurements of the frame's iframe element: mapped by
+ * the frame's position and scale (border, padding, `transform`, `zoom`),
+ * clipped to the frame's viewport and to what clips the iframe.
+ *
+ * @param raw - The element, measured in its frame
+ * @param owner - The iframe element, measured in its document
+ * @param mapping - How the frame's viewport maps into the top-level viewport
+ * @returns The element's layout in the top-level page (unchanged when the
+ *   iframe could not be measured)
+ */
+export function placeInOwnerFrame(raw, owner, mapping) {
+    const frame = owner.elements[0];
+    if (!raw.page || !owner.page || !frame)
+        return raw;
+    const frameView = mapBox(mapping, { x: 0, y: 0, ...raw.page.viewport });
+    const elements = raw.elements.map((element) => {
+        const inner = element.geometry;
+        const outer = frame.geometry;
+        const rect = mapBox(mapping, inner.rect);
+        const ownClip = inner.clip ? mapBox(mapping, inner.clip) : null;
+        return {
+            ...element,
+            context: [frame.element, element.context].filter(Boolean).join(' > '),
+            geometry: {
+                ...inner,
+                rect,
+                clip: intersection(ownClip, frameView, outer.clip),
+                clipper: inner.clipper ?? (inside(rect, frameView) ? outer.clipper : frame.element),
+                hidden: inner.hidden ?? (outer.hidden ? 'inside a hidden iframe' : null),
+                invisible: inner.invisible ?? outer.invisible,
+                fixed: outer.fixed,
+                sticky: outer.sticky ?? false,
+                pageScroll: outer.pageScroll,
+                scrollLock: outer.scrollLock ?? null,
+                offset: mapping.origin,
+            },
+        };
+    });
+    return { ...raw, page: owner.page, elements, crossOriginFrame: false };
+}
+//# sourceMappingURL=frameLayout.js.map

package/dist/runtime/dom/frameOrigin.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The origin a frame's scripts really run with, for `bdg dom frames`.
+ *
+ * Chrome reports `securityOrigin: "://"` for frames without an origin of
+ * their own (srcdoc, about:blank, data:) and the URL's origin for sandboxed
+ * frames, so neither tells whether the parent can reach the frame's
+ * document. The frame's default execution context knows: it reports the
+ * inherited origin for srcdoc and about:blank, and `"://"` for opaque ones
+ * (data: URLs, sandboxes without `allow-same-origin`). A frame that has no
+ * context yet falls back to the rules below; a frame inside an opaque one
+ * counts as opaque too (sandbox flags are inherited).
+ */
+/** Origin of documents that share no origin with anything */
+export declare const OPAQUE_ORIGIN = "null";
+/** What is known about a frame's origin */
+export interface FrameOriginFacts {
+    /** Frame URL */
+    url: string;
+    /** `Page.Frame.securityOrigin` */
+    securityOrigin: string;
+    /** Origin of the frame's default execution context, when it has one */
+    contextOrigin?: string | undefined;
+    /** Origin of the parent frame (already resolved) */
+    parentOrigin?: string | undefined;
+    /** `sandbox` attribute of the frame's element, when present */
+    sandbox?: string | undefined;
+}
+/**
+ * Whether a `sandbox` attribute makes the frame's origin opaque.
+ *
+ * @param sandbox - Attribute value (undefined when the attribute is missing)
+ * @returns True unless the attribute is missing or allows same-origin
+ */
+export declare function isOpaqueSandbox(sandbox: string | undefined): boolean;
+/**
+ * The origin a frame's scripts run with.
+ *
+ * @param facts - What Chrome reports about the frame
+ * @returns e.g. `https://example.com`, or `"null"` for an opaque origin
+ */
+export declare function effectiveFrameOrigin(facts: FrameOriginFacts): string;
+/**
+ * Whether the top page's scripts cannot reach a frame's document.
+ *
+ * @param origin - The frame's effective origin
+ * @param topOrigin - The page's effective origin
+ * @returns True for a different or opaque origin
+ */
+export declare function isCrossOrigin(origin: string, topOrigin: string): boolean;
+//# sourceMappingURL=frameOrigin.d.ts.map

package/dist/runtime/dom/frameOrigin.js

@@ -0,0 +1,62 @@
+/**
+ * The origin a frame's scripts really run with, for `bdg dom frames`.
+ *
+ * Chrome reports `securityOrigin: "://"` for frames without an origin of
+ * their own (srcdoc, about:blank, data:) and the URL's origin for sandboxed
+ * frames, so neither tells whether the parent can reach the frame's
+ * document. The frame's default execution context knows: it reports the
+ * inherited origin for srcdoc and about:blank, and `"://"` for opaque ones
+ * (data: URLs, sandboxes without `allow-same-origin`). A frame that has no
+ * context yet falls back to the rules below; a frame inside an opaque one
+ * counts as opaque too (sandbox flags are inherited).
+ */
+/** Origin of documents that share no origin with anything */
+export const OPAQUE_ORIGIN = 'null';
+/**
+ * Whether a reported origin names a real (tuple) origin.
+ *
+ * @param origin - Origin as Chrome reports it
+ * @returns False for `"://"`, `"null"` and empty
+ */
+function isTupleOrigin(origin) {
+    return origin !== undefined && origin !== '' && origin !== '://' && origin !== OPAQUE_ORIGIN;
+}
+/**
+ * Whether a `sandbox` attribute makes the frame's origin opaque.
+ *
+ * @param sandbox - Attribute value (undefined when the attribute is missing)
+ * @returns True unless the attribute is missing or allows same-origin
+ */
+export function isOpaqueSandbox(sandbox) {
+    if (sandbox === undefined)
+        return false;
+    return !sandbox.toLowerCase().split(/\s+/).includes('allow-same-origin');
+}
+/**
+ * The origin a frame's scripts run with.
+ *
+ * @param facts - What Chrome reports about the frame
+ * @returns e.g. `https://example.com`, or `"null"` for an opaque origin
+ */
+export function effectiveFrameOrigin(facts) {
+    if (facts.contextOrigin !== undefined) {
+        return isTupleOrigin(facts.contextOrigin) ? facts.contextOrigin : OPAQUE_ORIGIN;
+    }
+    if (isOpaqueSandbox(facts.sandbox) || facts.parentOrigin === OPAQUE_ORIGIN)
+        return OPAQUE_ORIGIN;
+    if (isTupleOrigin(facts.securityOrigin))
+        return facts.securityOrigin;
+    const inherits = facts.url === '' || facts.url.startsWith('about:');
+    return inherits && isTupleOrigin(facts.parentOrigin) ? facts.parentOrigin : OPAQUE_ORIGIN;
+}
+/**
+ * Whether the top page's scripts cannot reach a frame's document.
+ *
+ * @param origin - The frame's effective origin
+ * @param topOrigin - The page's effective origin
+ * @returns True for a different or opaque origin
+ */
+export function isCrossOrigin(origin, topOrigin) {
+    return origin === OPAQUE_ORIGIN || origin !== topOrigin;
+}
+//# sourceMappingURL=frameOrigin.js.map

package/dist/runtime/dom/frameScopedConnection.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Run the interaction scripts inside the frame of a cached element that the
+ * top page cannot reach.
+ *
+ * An element from `bdg dom a11y query` may be in a cross-origin iframe that
+ * shares the page's process (same site, e.g. a consent dialog served from a
+ * subdomain). The top page cannot hold it, so its page scripts run in the
+ * element's own frame instead: every `Runtime.evaluate` becomes a
+ * `Runtime.callFunctionOn` on the element (which runs in the element's
+ * context), and mouse events, whose coordinates the scripts measure in the
+ * frame's viewport, are mapped into the top-level viewport
+ * ({@link FrameMapping}).
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { LayoutBox, LayoutPoint } from '../../ipc/protocol/domTypes.js';
+/**
+ * How a point in a frame's viewport maps into the top-level viewport:
+ * `top = origin + frame * scale` per axis (the scale is not 1 when the
+ * iframe, or an ancestor of it, is scaled with `transform` or `zoom`).
+ */
+export interface FrameMapping {
+    /** Where the frame viewport's (0, 0) lies in the top-level viewport (border and padding included) */
+    origin: LayoutPoint;
+    scaleX: number;
+    scaleY: number;
+}
+/** A box as the frame and as CDP (top-level viewport) see it */
+interface ReferenceBox {
+    /** `getBoundingClientRect()` in the frame */
+    rect: LayoutBox;
+    /** `DOM.getContentQuads` (top-level viewport), each as x1,y1,…,x4,y4 */
+    quads: number[][];
+}
+/**
+ * `Runtime.callFunctionOn` parameters that evaluate an expression in the
+ * context of the element `objectId` refers to.
+ *
+ * @param params - `Runtime.evaluate` parameters
+ * @param objectId - Remote object of the element
+ * @returns Parameters for `Runtime.callFunctionOn`
+ * @throws Error for a parameter `Runtime.callFunctionOn` has no counterpart for
+ *   (e.g. `timeout`), so it is not dropped silently
+ */
+export declare function evaluateOnNodeParams(params: Record<string, unknown>, objectId: string): Record<string, unknown>;
+/**
+ * How the frame maps into the top-level viewport, from one box seen both ways.
+ *
+ * @param box - The reference box in the frame and in the top-level viewport
+ * @returns The mapping
+ * @throws CommandError (83) when the box has no quads or size, or is rotated or skewed
+ */
+export declare function frameMappingFrom(box: ReferenceBox): FrameMapping;
+/**
+ * Map a point of the frame's viewport into the top-level viewport.
+ *
+ * @param mapping - Frame mapping
+ * @param point - Point in the frame's viewport
+ * @returns Point in the top-level viewport
+ */
+export declare function mapPoint(mapping: FrameMapping, point: LayoutPoint): LayoutPoint;
+/**
+ * Map a box of the frame's viewport into the top-level viewport.
+ *
+ * @param mapping - Frame mapping
+ * @param box - Box in the frame's viewport
+ * @returns Box in the top-level viewport
+ */
+export declare function mapBox(mapping: FrameMapping, box: LayoutBox): LayoutBox;
+/**
+ * How the element's frame maps into the top-level viewport.
+ *
+ * @param cdp - CDP connection
+ * @param objectId - Remote object of the element
+ * @returns The mapping
+ * @throws CommandError (83) when the frame cannot be measured or is rotated or skewed
+ */
+export declare function measureFrameMapping(cdp: CDPConnection, objectId: string): Promise<FrameMapping>;
+/**
+ * A view of the session's connection whose page scripts run in the frame of
+ * one element and whose mouse events land on that frame.
+ *
+ * The mapping is measured at the first mouse event (after the scripts scrolled
+ * the element into view) and kept for the rest of the action; a failed
+ * measurement is not kept (the next event measures again) and fails the event.
+ *
+ * @param cdp - Session connection
+ * @param objectId - Remote object of the element
+ * @returns Connection to hand to the interaction functions
+ */
+export declare function frameScopedConnection(cdp: CDPConnection, objectId: string): CDPConnection;
+export {};
+//# sourceMappingURL=frameScopedConnection.d.ts.map