browser-debugger-cli 0.8.0 → 0.10.0

package/dist/runtime/dom/formFillHelpers/scroll.js

@@ -3,6 +3,9 @@
  * page boundaries.
  */
 import { CommandError } from '../../../errors/index.js';
+import { scrollNoEffectWarning } from '../../../errors/messages.js';
+import { SCROLL_RANGE_JS, VIEWPORT_SIZE_JS, } from '../elementGeometry.js';
+import { ELEMENT_IDENTITY_JS } from '../elementInfo.js';
 import { throwIfInvalidSelector, withMultipleMatchesWarning, } from './shared.js';
 import { FIND_ELEMENTS_JS, selectorArgsJS } from '../targetNode.js';
 import { EXIT_CODES } from '../../../utils/exitCodes.js';
@@ -29,26 +32,20 @@ const SCROLL_TO_ELEMENT_SCRIPT = `
 
   el.scrollIntoView({ behavior: 'instant', block: 'center' });
 
-  const rect = el.getBoundingClientRect();
-  const scrollX = window.scrollX + rect.left + rect.width / 2 - window.innerWidth / 2;
-  const scrollY = window.scrollY + rect.top + rect.height / 2 - window.innerHeight / 2;
-
   return {
     success: true,
     scrollType: 'element',
     selector: selector,
+    element: (${ELEMENT_IDENTITY_JS})(el),
     matchCount: allMatches.length,
     scrolledTo: {
       x: Math.round(window.scrollX),
       y: Math.round(window.scrollY)
     },
-    viewportSize: {
-      width: window.innerWidth,
-      height: window.innerHeight
-    },
+    viewportSize: (${VIEWPORT_SIZE_JS})(window),
     pageSize: {
-      width: document.documentElement.scrollWidth,
-      height: document.documentElement.scrollHeight
+      width: (document.scrollingElement || document.documentElement).scrollWidth,
+      height: (document.scrollingElement || document.documentElement).scrollHeight
     }
   };
 })`;
@@ -56,6 +53,7 @@ const SCROLL_BY_SCRIPT = `
 (function(options) {
   const beforeX = window.scrollX;
   const beforeY = window.scrollY;
+  const range = (${SCROLL_RANGE_JS})(window);
 
   if (options.top) {
     window.scrollTo({ top: 0, behavior: 'instant' });
@@ -81,16 +79,60 @@ const SCROLL_BY_SCRIPT = `
     scrollType: options.top || options.bottom ? 'position' : 'offset',
     scrolledTo: { x: Math.round(afterX), y: Math.round(afterY) },
     scrolledBy: { x: Math.round(afterX - beforeX), y: Math.round(afterY - beforeY) },
-    viewportSize: {
-      width: window.innerWidth,
-      height: window.innerHeight
-    },
+    viewportSize: (${VIEWPORT_SIZE_JS})(window),
     pageSize: {
-      width: document.documentElement.scrollWidth,
-      height: document.documentElement.scrollHeight
-    }
+      width: (document.scrollingElement || document.documentElement).scrollWidth,
+      height: (document.scrollingElement || document.documentElement).scrollHeight
+    },
+    rangeBefore: range,
+    readyState: document.readyState
   };
 })`;
+/**
+ * The direction a page scroll asked for (the options allow one per axis;
+ * only one axis is checked, vertical first).
+ *
+ * @param options - Scroll options
+ * @returns Direction, or undefined when no distance was asked for
+ */
+function requestedDirection(options) {
+    if (options.bottom || (options.down ?? 0) > 0)
+        return 'down';
+    if (options.top || (options.up ?? 0) > 0)
+        return 'up';
+    if ((options.right ?? 0) > 0)
+        return 'right';
+    if ((options.left ?? 0) > 0)
+        return 'left';
+    return undefined;
+}
+/**
+ * Warn when a page scroll moved nothing: the document does not scroll in
+ * that direction, the page was already at its edge, or scrolling is locked;
+ * while the page is still loading, also that it may grow.
+ *
+ * @param result - Page script result
+ * @param options - Scroll options
+ * @returns The scroll result, with `warning` when nothing scrolled
+ */
+function withNoEffectWarning(result, options) {
+    const { rangeBefore, readyState, ...scroll } = result;
+    const direction = requestedDirection(options);
+    const moved = scroll.scrolledBy && (scroll.scrolledBy.x !== 0 || scroll.scrolledBy.y !== 0);
+    if (!direction || moved || !scroll.viewportSize)
+        return scroll;
+    const vertical = direction === 'up' || direction === 'down';
+    const scrollable = vertical
+        ? rangeBefore.up + rangeBefore.down > 0
+        : rangeBefore.left + rangeBefore.right > 0;
+    const warning = scrollNoEffectWarning({
+        direction,
+        reason: !scrollable ? 'too-small' : rangeBefore[direction] <= 0 ? 'at-edge' : 'locked',
+        viewport: vertical ? scroll.viewportSize.height : scroll.viewportSize.width,
+        readyState,
+    });
+    return { ...scroll, warning };
+}
 function isScrollResult(value) {
     if (typeof value !== 'object' || value === null)
         return false;
@@ -164,7 +206,7 @@ export async function scrollPage(cdp, selector, options = {}) {
             };
         }
         if (cdpResponse.result?.value && isScrollResult(cdpResponse.result.value)) {
-            return cdpResponse.result.value;
+            return withNoEffectWarning(cdpResponse.result.value, options);
         }
         return {
             success: false,

package/dist/runtime/dom/formFillHelpers/shared.d.ts

@@ -3,6 +3,7 @@
  * and JS string escaping.
  */
 import type { Protocol } from '../../../connection/typed-cdp.js';
+import type { FillResult } from '../../../ipc/protocol/domTypes.js';
 /**
  * Escape a CSS selector for embedding in a single-quoted JS string.
  */
@@ -20,6 +21,14 @@ export declare function withMultipleMatchesWarning<T extends {
     matchCount?: number | undefined;
     warning?: string | undefined;
 }>(result: T, index: number | undefined, action: string): T;
+/**
+ * Put a warning first when the filled field's value is not the one given
+ * (see `valueMismatch`). Keeps an existing warning after it.
+ *
+ * @param result - Fill result
+ * @returns The result, with the warning when the value differs
+ */
+export declare function withValueMismatchWarning(result: FillResult): FillResult;
 /**
  * Escape a value for embedding in a single-quoted JS string.
  */
@@ -30,6 +39,14 @@ export declare function escapeValueForJS(value: string): string;
  * query-then-act pattern.
  */
 export declare function formatScriptExecutionError(exceptionDetails: Protocol.Runtime.ExceptionDetails, selector: string, operationType?: 'fill' | 'click', expression?: string): string;
+/**
+ * What a page script threw, in one line (`TypeError: Cannot read …` rather
+ * than CDP's bare "Uncaught").
+ *
+ * @param details - Exception details from Runtime.evaluate
+ * @returns First line of the exception's description
+ */
+export declare function exceptionSummary(details: Protocol.Runtime.ExceptionDetails): string;
 /**
  * Throw a user error when a page script failed because the CSS selector is
  * invalid (the browser's `querySelectorAll` rejected it), instead of reporting

package/dist/runtime/dom/formFillHelpers/shared.js

@@ -4,7 +4,7 @@
  */
 import { CommandError } from '../../../errors/index.js';
 import { invalidSelectorError } from '../../../errors/messages.js';
-import { multipleMatchesWarning } from '../../../ui/messages/commands.js';
+import { multipleMatchesWarning, valueMismatchWarning } from '../../../ui/messages/commands.js';
 import { EXIT_CODES } from '../../../utils/exitCodes.js';
 import { detectSelectorQuoteDamage } from '../../../utils/shellDetection.js';
 /**
@@ -29,6 +29,19 @@ export function withMultipleMatchesWarning(result, index, action) {
     const warning = multipleMatchesWarning(count, action);
     return { ...result, warning: result.warning ? `${result.warning}; ${warning}` : warning };
 }
+/**
+ * Put a warning first when the filled field's value is not the one given
+ * (see `valueMismatch`). Keeps an existing warning after it.
+ *
+ * @param result - Fill result
+ * @returns The result, with the warning when the value differs
+ */
+export function withValueMismatchWarning(result) {
+    if (!result.valueMismatch)
+        return result;
+    const warning = valueMismatchWarning(result.valueMismatch);
+    return { ...result, warning: result.warning ? `${warning}; ${result.warning}` : warning };
+}
 /**
  * Escape a value for embedding in a single-quoted JS string.
  */
@@ -81,6 +94,17 @@ export function formatScriptExecutionError(exceptionDetails, selector, operation
     lines.push(`  ${troubleshootingSteps.join('\n  ')}`);
     return lines.join('\n');
 }
+/**
+ * What a page script threw, in one line (`TypeError: Cannot read …` rather
+ * than CDP's bare "Uncaught").
+ *
+ * @param details - Exception details from Runtime.evaluate
+ * @returns First line of the exception's description
+ */
+export function exceptionSummary(details) {
+    const description = details.exception?.description ?? details.text;
+    return description.split('\n')[0] ?? description;
+}
 /**
  * Throw a user error when a page script failed because the CSS selector is
  * invalid (the browser's `querySelectorAll` rejected it), instead of reporting

package/dist/runtime/dom/formFillHelpers/stability.d.ts

@@ -1,14 +1,28 @@
 /**
  * Post-action network-stability wait.
  *
- * Lightweight check used after fill/click/pressKey/scroll: subscribes to
- * CDP network events, waits until no request has been pending for
- * ACTION_NETWORK_IDLE_MS, times out at ACTION_STABILITY_TIMEOUT_MS.
+ * Used around fill/click/hover/pressKey/scroll: tracks in-flight requests
+ * from before the action runs (so a request its handler sends synchronously
+ * is seen), then waits until no request has been pending for
+ * ACTION_NETWORK_IDLE_MS, giving up after ACTION_STABILITY_TIMEOUT_MS.
  */
 import type { CDPConnection } from '../../../connection/cdp.js';
 /**
- * Wait for the network to settle after an action. Returns when idle for
- * the threshold or after the timeout.
+ * Run an action and, when it succeeds, wait for the network to settle.
+ *
+ * Requests are tracked from before the action, so one an event handler
+ * starts while the action runs (`onclick = () => fetch(...)`) is waited for.
+ * `Network.enable` is sent without waiting for it: the session's network
+ * collector has already enabled the domain, and Chrome holds the call until
+ * a pending navigation commits, which would otherwise block for as long as
+ * the new page's server takes to answer.
+ *
+ * @param cdp - CDP connection
+ * @param action - Action to run (its result's `success` decides whether to wait)
+ * @param wait - Wait for the network after the action (false for `--no-wait`)
+ * @returns The action's result, once the network is idle or the wait timed out
  */
-export declare function waitForActionStability(cdp: CDPConnection): Promise<void>;
+export declare function withActionStability<T extends {
+    success: boolean;
+}>(cdp: CDPConnection, action: () => Promise<T>, wait?: boolean): Promise<T>;
 //# sourceMappingURL=stability.d.ts.map

package/dist/runtime/dom/formFillHelpers/stability.js

@@ -1,40 +1,71 @@
 /**
  * Post-action network-stability wait.
  *
- * Lightweight check used after fill/click/pressKey/scroll: subscribes to
- * CDP network events, waits until no request has been pending for
- * ACTION_NETWORK_IDLE_MS, times out at ACTION_STABILITY_TIMEOUT_MS.
+ * Used around fill/click/hover/pressKey/scroll: tracks in-flight requests
+ * from before the action runs (so a request its handler sends synchronously
+ * is seen), then waits until no request has been pending for
+ * ACTION_NETWORK_IDLE_MS, giving up after ACTION_STABILITY_TIMEOUT_MS.
  */
 import { trackInFlightRequests } from '../../../connection/inFlightRequests.js';
 import { createLogger } from '../../../ui/logging/index.js';
 import { delay } from '../../../utils/async.js';
+import { getErrorMessage } from '../../../utils/errors.js';
 const log = createLogger('dom');
 const ACTION_NETWORK_IDLE_MS = 150;
 const ACTION_STABILITY_TIMEOUT_MS = 2000;
 const STABILITY_CHECK_INTERVAL_MS = 50;
 /**
- * Wait for the network to settle after an action. Returns when idle for
- * the threshold or after the timeout.
+ * Run an action and, when it succeeds, wait for the network to settle.
+ *
+ * Requests are tracked from before the action, so one an event handler
+ * starts while the action runs (`onclick = () => fetch(...)`) is waited for.
+ * `Network.enable` is sent without waiting for it: the session's network
+ * collector has already enabled the domain, and Chrome holds the call until
+ * a pending navigation commits, which would otherwise block for as long as
+ * the new page's server takes to answer.
+ *
+ * @param cdp - CDP connection
+ * @param action - Action to run (its result's `success` decides whether to wait)
+ * @param wait - Wait for the network after the action (false for `--no-wait`)
+ * @returns The action's result, once the network is idle or the wait timed out
  */
-export async function waitForActionStability(cdp) {
-    const deadline = Date.now() + ACTION_STABILITY_TIMEOUT_MS;
-    await cdp.send('Network.enable');
+export async function withActionStability(cdp, action, wait = true) {
+    if (!wait)
+        return action();
+    void cdp
+        .send('Network.enable')
+        .catch((error) => log.debug(`Network.enable failed: ${getErrorMessage(error)}`));
     const requests = trackInFlightRequests(cdp);
     try {
-        while (Date.now() < deadline) {
-            if (requests.count === 0) {
-                const idleTime = Date.now() - requests.lastActivity;
-                if (idleTime >= ACTION_NETWORK_IDLE_MS) {
-                    log.debug(`Network stable after ${idleTime}ms idle`);
-                    return;
-                }
-            }
-            await delay(STABILITY_CHECK_INTERVAL_MS);
-        }
-        log.debug('Stability timeout reached, proceeding');
+        const result = await action();
+        if (result.success)
+            await waitForNetworkIdle(requests);
+        return result;
     }
     finally {
         requests.dispose();
     }
 }
+/**
+ * Wait until no request has been in flight for ACTION_NETWORK_IDLE_MS since
+ * the wait began (a request the action started counts until it ends), or
+ * until ACTION_STABILITY_TIMEOUT_MS passed.
+ *
+ * @param requests - Tracker started before the action
+ */
+async function waitForNetworkIdle(requests) {
+    const waitStart = Date.now();
+    const deadline = waitStart + ACTION_STABILITY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (requests.count === 0) {
+            const idleTime = Date.now() - Math.max(requests.lastActivity, waitStart);
+            if (idleTime >= ACTION_NETWORK_IDLE_MS) {
+                log.debug(`Network stable after ${idleTime}ms idle`);
+                return;
+            }
+        }
+        await delay(STABILITY_CHECK_INTERVAL_MS);
+    }
+    log.debug(`Stability timeout reached with ${requests.count} request(s) in flight, proceeding`);
+}
 //# sourceMappingURL=stability.js.map

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

@@ -3,6 +3,7 @@
  */
 import type { CDPConnection } from '../../connection/cdp.js';
 import type { SubmitResult } from '../../ipc/protocol/domTypes.js';
+import type { PendingRequest } from '../../telemetry/network.js';
 /**
  * Options for submitting a form.
  */
@@ -15,6 +16,8 @@ export interface SubmitOptions {
     waitNetwork?: number;
     /** Maximum time to wait in milliseconds (default: 10000) */
     timeout?: number;
+    /** Requests still running in the session (named when the wait times out) */
+    pendingRequests?: () => Iterable<PendingRequest>;
 }
 export type { SubmitResult } from '../../ipc/protocol/domTypes.js';
 /**

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