browser-debugger-cli 0.8.0 → 0.10.0

package/dist/runtime/dom/wait.js

@@ -0,0 +1,199 @@
+/**
+ * `bdg dom wait`: wait in the page until elements appear, become visible,
+ * contain a text or are gone, and/or the page has loaded.
+ *
+ * The page watches itself (a MutationObserver plus a short poll for style
+ * and frame changes the observer cannot see) and answers as soon as what it
+ * shows changes; the condition is decided here ({@link isWaitConditionMet}).
+ * Each page call lasts at most {@link WAIT_SLICE_MS}, so a navigation during
+ * the wait (the page's context is destroyed) only costs a retry on the new
+ * document. `--gone` is confirmed by a second snapshot of the same settled
+ * document, so the empty document right after a navigation does not count.
+ */
+import { CommandError } from '../../errors/index.js';
+import { invalidSelectorError, waitTimeoutError } from '../../errors/messages.js';
+import { isContextLostError } from './evalHelpers.js';
+import { DEEP_QUERY_JS, FILTER_MATCHING_JS, selectorArgsJS } from './targetNode.js';
+import { isWaitConditionMet, needsGoneConfirmation, normalizeWaitText, } from './waitCondition.js';
+import { createLogger } from '../../ui/logging/index.js';
+import { delay, raceTimeout } from '../../utils/async.js';
+import { getErrorMessage } from '../../utils/errors.js';
+import { EXIT_CODES } from '../../utils/exitCodes.js';
+import { filterDefined } from '../../utils/objects.js';
+import { parseSelectorFilters } from '../../utils/selectorFilters.js';
+const log = createLogger('dom');
+/** Longest a single page call waits for a change */
+const WAIT_SLICE_MS = 2000;
+/** Pause before asking a page that could not answer (navigating) again */
+const RETRY_DELAY_MS = 100;
+/** Pause before the snapshot that confirms elements are gone */
+const GONE_CONFIRM_DELAY_MS = 50;
+/**
+ * Page-side: report what the page shows (matches, text matches, visible
+ * ones, readyState) as soon as it differs from `previous` (at once when
+ * `previous` is null), or after `sliceMs` without a change.
+ */
+const WAIT_SNAPSHOT_JS = `async function (selector, parts, text, previous, sliceMs) {
+  const { passesAll } = (${FILTER_MATCHING_JS})([]);
+  const textFilter = text === null ? [] : [{ kind: 'has-text', text: text }];
+  const visibleFilter = [{ kind: 'visible' }];
+  const snapshot = () => {
+    const matches = selector === null ? [] : (${DEEP_QUERY_JS})(selector, parts);
+    const withText = matches.filter((el) => passesAll(el, textFilter));
+    return {
+      count: matches.length,
+      textCount: withText.length,
+      visibleCount: withText.filter((el) => passesAll(el, visibleFilter)).length,
+      readyState: document.readyState,
+      documentId: performance.timeOrigin
+    };
+  };
+  const changed = (s) => previous === null || s.count !== previous.count ||
+    s.textCount !== previous.textCount || s.visibleCount !== previous.visibleCount ||
+    s.readyState !== previous.readyState || s.documentId !== previous.documentId;
+  let current = snapshot();
+  if (changed(current)) return current;
+  return await new Promise((resolve) => {
+    let scheduled = null;
+    const observer = new MutationObserver(() => { if (scheduled === null) scheduled = setTimeout(check, 16); });
+    const poll = setInterval(check, 100);
+    const slice = setTimeout(finish, sliceMs);
+    function check() {
+      scheduled = null;
+      current = snapshot();
+      if (changed(current)) finish();
+    }
+    function finish() {
+      observer.disconnect();
+      clearInterval(poll);
+      clearTimeout(slice);
+      clearTimeout(scheduled);
+      document.removeEventListener('readystatechange', check);
+      resolve(current);
+    }
+    observer.observe(document, { childList: true, subtree: true, attributes: true, characterData: true });
+    document.addEventListener('readystatechange', check);
+  });
+}`;
+/**
+ * Wait until the page meets the condition.
+ *
+ * @param cdp - CDP connection
+ * @param params - Condition and timeout
+ * @returns What the page showed when it was met, and how long it took
+ * @throws CommandError (81) for an invalid selector, (102) when the timeout passed;
+ *   CDP errors other than a lost page context (a closed connection) as they are
+ */
+export async function waitForCondition(cdp, params) {
+    const condition = waitConditionOf(params);
+    const started = Date.now();
+    const deadline = started + params.timeout;
+    let last;
+    let confirming = false;
+    while (Date.now() < deadline) {
+        const snapshot = await nextSnapshot(cdp, condition, confirming ? null : (last ?? null), deadline);
+        if (!snapshot) {
+            confirming = false;
+            await delay(RETRY_DELAY_MS);
+            continue;
+        }
+        if (isWaitConditionMet(snapshot, condition, last)) {
+            return {
+                ...condition,
+                elapsedMs: Date.now() - started,
+                ...snapshotData(snapshot, condition),
+            };
+        }
+        last = snapshot;
+        confirming = needsGoneConfirmation(snapshot, condition);
+        if (confirming)
+            await delay(GONE_CONFIRM_DELAY_MS);
+    }
+    const err = waitTimeoutError(condition, last, params.timeout);
+    throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.CDP_TIMEOUT);
+}
+/**
+ * The condition of a request (options that are off left out).
+ *
+ * @param params - Request
+ * @returns Condition
+ */
+function waitConditionOf(params) {
+    return {
+        ...filterDefined({ selector: params.selector, text: params.text }),
+        ...(params.gone && { gone: true }),
+        ...(params.visible && { visible: true }),
+        ...(params.load && { load: true }),
+    };
+}
+/**
+ * The snapshot as reported: `textCount` only when a text was given.
+ *
+ * @param snapshot - What the page showed
+ * @param condition - What was waited for
+ * @returns Snapshot fields of the result
+ */
+function snapshotData(snapshot, condition) {
+    return {
+        count: snapshot.count,
+        ...(condition.text !== undefined && { textCount: snapshot.textCount }),
+        visibleCount: snapshot.visibleCount,
+        readyState: snapshot.readyState,
+    };
+}
+/**
+ * Ask the page for its next snapshot.
+ *
+ * @param cdp - CDP connection
+ * @param condition - What is waited for
+ * @param previous - Last snapshot (null for the first call)
+ * @param deadline - When the wait ends (epoch ms)
+ * @returns The snapshot, or undefined when the page could not answer (its context was lost
+ *   to a navigation, or the time ran out)
+ * @throws CommandError (81) for an invalid selector; other CDP errors (a closed connection) as they are
+ */
+async function nextSnapshot(cdp, condition, previous, deadline) {
+    const remaining = deadline - Date.now();
+    const selectorArgs = condition.selector === undefined ? 'null, null' : selectorArgsJS(condition.selector);
+    const text = condition.text === undefined ? null : normalizeWaitText(condition.text);
+    const args = `${selectorArgs}, ${JSON.stringify(text)}, ${JSON.stringify(previous)}, ${Math.min(remaining, WAIT_SLICE_MS)}`;
+    const evaluated = cdp.send('Runtime.evaluate', {
+        expression: `(${WAIT_SNAPSHOT_JS})(${args})`,
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    evaluated.catch(() => undefined);
+    const response = await raceTimeout(evaluated, remaining).catch((error) => {
+        if (!isContextLostError(error))
+            throw error;
+        log.debug(`dom wait: page context lost (${getErrorMessage(error)}), retrying`);
+        return undefined;
+    });
+    if (!response)
+        return undefined;
+    if (response.exceptionDetails)
+        return pageException(response.exceptionDetails, condition);
+    return response.result.value;
+}
+/**
+ * Handle an exception of the page script: an invalid selector is the
+ * user's; anything else (a document being replaced) is retried.
+ *
+ * @param details - Exception details
+ * @param condition - What is waited for
+ * @returns undefined (retry)
+ * @throws CommandError (81) for an invalid selector
+ */
+function pageException(details, condition) {
+    const description = details.exception?.description ?? details.text;
+    if (condition.selector !== undefined && description.startsWith('SyntaxError')) {
+        const detail = parseSelectorFilters(condition.selector)
+            ? undefined
+            : description.split('\n')[0];
+        const err = invalidSelectorError(condition.selector, detail);
+        throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    log.debug(`dom wait: page script failed (${description.split('\n')[0]}), retrying`);
+    return undefined;
+}
+//# sourceMappingURL=wait.js.map

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

@@ -0,0 +1,71 @@
+/**
+ * What `bdg dom wait` waits for, and whether what the page shows meets it.
+ *
+ * The page reports a {@link WaitSnapshot} whenever it changes; the condition
+ * is decided here, in one place.
+ */
+/** What to wait for */
+export interface WaitCondition {
+    /** Selector (filters like :has-text and :visible allowed); absent when only waiting for the load */
+    selector?: string;
+    /** Text one of the matches must contain (case-insensitive, whitespace collapsed) */
+    text?: string;
+    /** Wait for the (visible, with `visible`) matches to be gone */
+    gone?: boolean;
+    /** Only count visible matches */
+    visible?: boolean;
+    /** Also wait for `document.readyState` to be `complete` */
+    load?: boolean;
+}
+/** What the page shows at one moment */
+export interface WaitSnapshot {
+    /** Elements matching the selector */
+    count: number;
+    /** Of those, the ones containing the text (all of them without a text) */
+    textCount: number;
+    /** Of the text matches, the visible ones */
+    visibleCount: number;
+    /** `document.readyState` */
+    readyState: string;
+    /** The document's identity (`performance.timeOrigin`): a new document after a navigation has another */
+    documentId: number;
+}
+/**
+ * The text as the page compares it: whitespace collapsed, lower case (like `:has-text`).
+ *
+ * @param text - Text as given
+ * @returns Normalized text
+ */
+export declare function normalizeWaitText(text: string): string;
+/**
+ * The matches the condition counts: visible ones with `visible`, else those
+ * containing the text (all matches without a text).
+ *
+ * @param snapshot - What the page shows
+ * @param condition - What is waited for
+ * @returns Number of counted matches
+ */
+export declare function countedMatches(snapshot: WaitSnapshot, condition: WaitCondition): number;
+/**
+ * Whether the page shows what is waited for.
+ *
+ * Elements are gone only when two consecutive snapshots of the same
+ * document, neither of it still `loading`, show none: right after a
+ * navigation commits, the new document is empty for a moment.
+ *
+ * @param snapshot - What the page shows
+ * @param condition - What is waited for
+ * @param previous - The snapshot before it, if any
+ * @returns True when the elements are there (or gone with `gone`) and, with `load`, the page loaded
+ */
+export declare function isWaitConditionMet(snapshot: WaitSnapshot, condition: WaitCondition, previous?: WaitSnapshot): boolean;
+/**
+ * Whether a `--gone` wait should confirm this snapshot with another one: it
+ * shows no (counted) matches in a document past `loading`.
+ *
+ * @param snapshot - What the page shows
+ * @param condition - What is waited for
+ * @returns True when one more snapshot of the same document may meet the condition
+ */
+export declare function needsGoneConfirmation(snapshot: WaitSnapshot, condition: WaitCondition): boolean;
+//# sourceMappingURL=waitCondition.d.ts.map

package/dist/runtime/dom/waitCondition.js

@@ -0,0 +1,75 @@
+/**
+ * What `bdg dom wait` waits for, and whether what the page shows meets it.
+ *
+ * The page reports a {@link WaitSnapshot} whenever it changes; the condition
+ * is decided here, in one place.
+ */
+/**
+ * The text as the page compares it: whitespace collapsed, lower case (like `:has-text`).
+ *
+ * @param text - Text as given
+ * @returns Normalized text
+ */
+export function normalizeWaitText(text) {
+    return text.replace(/\s+/g, ' ').trim().toLowerCase();
+}
+/**
+ * The matches the condition counts: visible ones with `visible`, else those
+ * containing the text (all matches without a text).
+ *
+ * @param snapshot - What the page shows
+ * @param condition - What is waited for
+ * @returns Number of counted matches
+ */
+export function countedMatches(snapshot, condition) {
+    return condition.visible ? snapshot.visibleCount : snapshot.textCount;
+}
+/**
+ * Whether the page shows what is waited for.
+ *
+ * Elements are gone only when two consecutive snapshots of the same
+ * document, neither of it still `loading`, show none: right after a
+ * navigation commits, the new document is empty for a moment.
+ *
+ * @param snapshot - What the page shows
+ * @param condition - What is waited for
+ * @param previous - The snapshot before it, if any
+ * @returns True when the elements are there (or gone with `gone`) and, with `load`, the page loaded
+ */
+export function isWaitConditionMet(snapshot, condition, previous) {
+    if (condition.load && snapshot.readyState !== 'complete')
+        return false;
+    if (condition.selector === undefined)
+        return true;
+    if (!condition.gone)
+        return countedMatches(snapshot, condition) > 0;
+    if (previous?.documentId !== snapshot.documentId)
+        return false;
+    return showsNoneSettled(previous, condition) && showsNoneSettled(snapshot, condition);
+}
+/**
+ * Whether a `--gone` wait should confirm this snapshot with another one: it
+ * shows no (counted) matches in a document past `loading`.
+ *
+ * @param snapshot - What the page shows
+ * @param condition - What is waited for
+ * @returns True when one more snapshot of the same document may meet the condition
+ */
+export function needsGoneConfirmation(snapshot, condition) {
+    if (!condition.gone || condition.selector === undefined)
+        return false;
+    if (condition.load && snapshot.readyState !== 'complete')
+        return false;
+    return showsNoneSettled(snapshot, condition);
+}
+/**
+ * No counted matches, in a document that is no longer `loading`.
+ *
+ * @param snapshot - What the page shows
+ * @param condition - What is waited for
+ * @returns True when nothing counted matches in a settled document
+ */
+function showsNoneSettled(snapshot, condition) {
+    return snapshot.readyState !== 'loading' && countedMatches(snapshot, condition) === 0;
+}
+//# sourceMappingURL=waitCondition.js.map

package/dist/runtime/page/emulation.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Page emulation a session was started with: the viewport size
+ * (`--viewport`) and `prefers-color-scheme` (`--color-scheme`).
+ *
+ * The overrides belong to the session's CDP connection: they last across
+ * navigations and reloads, and Chrome drops them when the session ends, so
+ * an attached Chrome (`--chrome-ws-url`) gets its own settings back.
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { ColorScheme, ViewportSize } from '../../types.js';
+/**
+ * `Emulation.setDeviceMetricsOverride` parameters for a session viewport: a
+ * desktop viewport of that size at the display's own pixel ratio.
+ *
+ * @param viewport - Viewport size in CSS px
+ * @param deviceScaleFactor - Pixel ratio (0 keeps the display's)
+ * @returns CDP parameters
+ */
+export declare function viewportOverride(viewport: ViewportSize, deviceScaleFactor?: number): {
+    width: number;
+    height: number;
+    deviceScaleFactor: number;
+    mobile: false;
+};
+/**
+ * Apply the session's emulation to its page.
+ *
+ * @param cdp - Session connection
+ * @param emulation - Viewport and color scheme, when given at start
+ */
+export declare function applySessionEmulation(cdp: CDPConnection, emulation: {
+    viewport?: ViewportSize;
+    colorScheme?: ColorScheme;
+}): Promise<void>;
+/** Page emulation of a session: what `--viewport` and `--color-scheme` set */
+export interface SessionEmulation {
+    viewport?: ViewportSize;
+    colorScheme?: ColorScheme;
+}
+/**
+ * Change the page emulation mid-session (`bdg page emulate`): set the
+ * viewport or the color scheme, or clear both (back to the browser window
+ * and the system setting).
+ *
+ * @param cdp - Session connection
+ * @param current - Emulation now in effect
+ * @param change - What to set, or `reset`
+ * @param record - Called after each change Chrome accepted (so a later
+ *   failure leaves the recorded emulation true)
+ * @returns Emulation in effect afterwards
+ */
+export declare function emulatePage(cdp: CDPConnection, current: SessionEmulation, change: SessionEmulation & {
+    reset?: boolean;
+}, record: (emulation: SessionEmulation) => void): Promise<SessionEmulation>;
+/** What the page currently renders with, for `bdg status` */
+export interface PageAppearance {
+    /** Layout viewport without scrollbars (as `dom layout` reports it) */
+    viewport?: ViewportSize;
+    /** `prefers-color-scheme` the page sees */
+    colorScheme?: ColorScheme;
+}
+/**
+ * The viewport and color scheme the page renders with. A busy page (or one
+ * still navigating) does not answer within {@link APPEARANCE_TIMEOUT_MS}; then
+ * nothing is reported rather than holding up `bdg status`.
+ *
+ * @param cdp - Session connection
+ * @returns Viewport and color scheme, or nothing
+ */
+export declare function pageAppearance(cdp: CDPConnection): Promise<PageAppearance>;
+//# sourceMappingURL=emulation.d.ts.map

package/dist/runtime/page/emulation.js

@@ -0,0 +1,117 @@
+/**
+ * Page emulation a session was started with: the viewport size
+ * (`--viewport`) and `prefers-color-scheme` (`--color-scheme`).
+ *
+ * The overrides belong to the session's CDP connection: they last across
+ * navigations and reloads, and Chrome drops them when the session ends, so
+ * an attached Chrome (`--chrome-ws-url`) gets its own settings back.
+ */
+import { VIEWPORT_SIZE_JS } from '../dom/elementGeometry.js';
+import { createLogger } from '../../ui/logging/index.js';
+import { getErrorMessage } from '../../utils/errors.js';
+const log = createLogger('session');
+/**
+ * `Emulation.setDeviceMetricsOverride` parameters for a session viewport: a
+ * desktop viewport of that size at the display's own pixel ratio.
+ *
+ * @param viewport - Viewport size in CSS px
+ * @param deviceScaleFactor - Pixel ratio (0 keeps the display's)
+ * @returns CDP parameters
+ */
+export function viewportOverride(viewport, deviceScaleFactor = 0) {
+    return { width: viewport.width, height: viewport.height, deviceScaleFactor, mobile: false };
+}
+/**
+ * Apply the session's emulation to its page.
+ *
+ * @param cdp - Session connection
+ * @param emulation - Viewport and color scheme, when given at start
+ */
+export async function applySessionEmulation(cdp, emulation) {
+    if (emulation.viewport) {
+        await cdp.send('Emulation.setDeviceMetricsOverride', viewportOverride(emulation.viewport));
+    }
+    if (emulation.colorScheme) {
+        await cdp.send('Emulation.setEmulatedMedia', {
+            features: [{ name: 'prefers-color-scheme', value: emulation.colorScheme }],
+        });
+    }
+}
+/**
+ * Change the page emulation mid-session (`bdg page emulate`): set the
+ * viewport or the color scheme, or clear both (back to the browser window
+ * and the system setting).
+ *
+ * @param cdp - Session connection
+ * @param current - Emulation now in effect
+ * @param change - What to set, or `reset`
+ * @param record - Called after each change Chrome accepted (so a later
+ *   failure leaves the recorded emulation true)
+ * @returns Emulation in effect afterwards
+ */
+export async function emulatePage(cdp, current, change, record) {
+    let state = current;
+    const step = async (send, next) => {
+        await send();
+        state = next;
+        record(state);
+    };
+    const { viewport: _viewport, colorScheme, ...rest } = state;
+    if (change.reset || change.viewport) {
+        await step(() => change.viewport
+            ? cdp.send('Emulation.setDeviceMetricsOverride', viewportOverride(change.viewport))
+            : cdp.send('Emulation.clearDeviceMetricsOverride', {}), {
+            ...rest,
+            ...(colorScheme && { colorScheme }),
+            ...(change.viewport && { viewport: change.viewport }),
+        });
+    }
+    if (change.reset || change.colorScheme) {
+        const { colorScheme: _scheme, ...withoutScheme } = state;
+        await step(() => cdp.send('Emulation.setEmulatedMedia', {
+            features: [{ name: 'prefers-color-scheme', value: change.colorScheme ?? '' }],
+        }), { ...withoutScheme, ...(change.colorScheme && { colorScheme: change.colorScheme }) });
+    }
+    return state;
+}
+/** How long `bdg status` waits for the page to report its appearance */
+const APPEARANCE_TIMEOUT_MS = 1000;
+/**
+ * The viewport and color scheme the page renders with. A busy page (or one
+ * still navigating) does not answer within {@link APPEARANCE_TIMEOUT_MS}; then
+ * nothing is reported rather than holding up `bdg status`.
+ *
+ * @param cdp - Session connection
+ * @returns Viewport and color scheme, or nothing
+ */
+export async function pageAppearance(cdp) {
+    const expression = `(() => {
+    const size = (${VIEWPORT_SIZE_JS})(window);
+    return { width: Math.round(size.width), height: Math.round(size.height), dark: matchMedia('(prefers-color-scheme: dark)').matches };
+  })()`;
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), APPEARANCE_TIMEOUT_MS);
+    });
+    try {
+        const response = (await Promise.race([
+            cdp.send('Runtime.evaluate', { expression, returnByValue: true }),
+            timeout,
+        ]));
+        const value = response?.result?.value;
+        if (!value)
+            return {};
+        return {
+            viewport: { width: value.width, height: value.height },
+            colorScheme: value.dark ? 'dark' : 'light',
+        };
+    }
+    catch (error) {
+        log.debug(`Could not read the page's viewport and color scheme: ${getErrorMessage(error)}`);
+        return {};
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=emulation.js.map

package/dist/runtime/page/loadingState.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Whether the page finished loading, and what it is still waiting for.
+ *
+ * Start and `bdg page` wait a limited time for the page; a document still
+ * `loading` after that (a script whose server never answers) makes every
+ * later command misleading, so they report it with the requests still
+ * running.
+ */
+import type { PendingRequestInfo, PageLoadingState } from '../../ipc/protocol/commands.js';
+import type { PendingRequest } from '../../telemetry/network.js';
+import type { CDPSender } from '../../telemetry/objectExpander.js';
+/**
+ * The requests to name: load-blocking ones (scripts, styles, images, frames)
+ * first, the longest-running first within each group.
+ *
+ * @param pending - Requests still running
+ * @param now - Current time (ms)
+ * @returns Up to {@link MAX_NAMED_PENDING_REQUESTS} requests
+ */
+export declare function summarizePendingRequests(pending: Iterable<PendingRequest>, now: number): PendingRequestInfo[];
+/**
+ * The page's `document.readyState`.
+ *
+ * @param cdp - CDP connection
+ * @returns The state, or undefined when the page did not answer in time
+ */
+export declare function readDocumentReadyState(cdp: CDPSender): Promise<string | undefined>;
+/**
+ * What the page is still loading, if it has not finished.
+ *
+ * @param cdp - CDP connection
+ * @param pending - Requests still running (from the session's network telemetry)
+ * @returns The loading state, or undefined when the document is complete or did not answer
+ */
+export declare function readPageLoadingState(cdp: CDPSender, pending: Iterable<PendingRequest>): Promise<PageLoadingState | undefined>;
+//# sourceMappingURL=loadingState.d.ts.map

package/dist/runtime/page/loadingState.js

@@ -0,0 +1,86 @@
+/**
+ * Whether the page finished loading, and what it is still waiting for.
+ *
+ * Start and `bdg page` wait a limited time for the page; a document still
+ * `loading` after that (a script whose server never answers) makes every
+ * later command misleading, so they report it with the requests still
+ * running.
+ */
+import { createLogger } from '../../ui/logging/index.js';
+import { raceTimeout } from '../../utils/async.js';
+import { getErrorMessage } from '../../utils/errors.js';
+const log = createLogger('readiness');
+/** Pending requests named in the report */
+const MAX_NAMED_PENDING_REQUESTS = 3;
+/** How long the page gets to report its readyState (a busy page is not waited on) */
+const READY_STATE_TIMEOUT_MS = 1000;
+/** Request types that never hold up the load event, listed after the ones that do */
+const NON_BLOCKING_TYPES = new Set([
+    'XHR',
+    'Fetch',
+    'EventSource',
+    'Ping',
+    'Preflight',
+    'Prefetch',
+]);
+/**
+ * The requests to name: load-blocking ones (scripts, styles, images, frames)
+ * first, the longest-running first within each group.
+ *
+ * @param pending - Requests still running
+ * @param now - Current time (ms)
+ * @returns Up to {@link MAX_NAMED_PENDING_REQUESTS} requests
+ */
+export function summarizePendingRequests(pending, now) {
+    const rank = (entry) => NON_BLOCKING_TYPES.has(entry.request.resourceType ?? '') ? 1 : 0;
+    return [...pending]
+        .sort((a, b) => rank(a) - rank(b) || a.request.timestamp - b.request.timestamp)
+        .slice(0, MAX_NAMED_PENDING_REQUESTS)
+        .map(({ request }) => ({
+        method: request.method,
+        url: request.url,
+        ...(request.resourceType && { resourceType: request.resourceType }),
+        pendingMs: Math.max(0, now - request.timestamp),
+    }));
+}
+/**
+ * The page's `document.readyState`.
+ *
+ * @param cdp - CDP connection
+ * @returns The state, or undefined when the page did not answer in time
+ */
+export async function readDocumentReadyState(cdp) {
+    try {
+        const evaluated = cdp.send('Runtime.evaluate', {
+            expression: 'document.readyState',
+            returnByValue: true,
+        });
+        evaluated.catch(() => undefined);
+        const response = await raceTimeout(evaluated, READY_STATE_TIMEOUT_MS);
+        const value = response?.result?.value;
+        return typeof value === 'string' ? value : undefined;
+    }
+    catch (error) {
+        log.debug(`Could not read document.readyState: ${getErrorMessage(error)}`);
+        return undefined;
+    }
+}
+/**
+ * What the page is still loading, if it has not finished.
+ *
+ * @param cdp - CDP connection
+ * @param pending - Requests still running (from the session's network telemetry)
+ * @returns The loading state, or undefined when the document is complete or did not answer
+ */
+export async function readPageLoadingState(cdp, pending) {
+    const readyState = await readDocumentReadyState(cdp);
+    if (readyState === undefined || readyState === 'complete')
+        return undefined;
+    const requests = [...pending];
+    return {
+        readyState,
+        pending: summarizePendingRequests(requests, Date.now()),
+        pendingCount: requests.length,
+    };
+}
+//# sourceMappingURL=loadingState.js.map