@itmetsam/samurai-framework 0.10.0 → 0.12.1

package/dist/browser/page-network.js

@@ -0,0 +1,163 @@
+import { DataCollector, ResponseBodyUnavailableError, } from "../network/data-collector.js";
+import { NetworkTracker } from "../network/network-tracker.js";
+import { RequestTimeoutError, ResponseTimeoutError, toPredicate, } from "../network/network-wait.js";
+import { Response } from "../network/response.js";
+import { Router } from "../network/router.js";
+import { isUnsupported, UnsupportedOperationError, } from "../transport/unsupported.js";
+import { Lazy } from "./lazy.js";
+/** Thrown by `PageNetwork.tracker()` when config `network.track` turned tracking off */
+class NetworkTrackingDisabledError extends Error {
+    constructor() {
+        super("network tracking is disabled");
+        this.name = "NetworkTrackingDisabledError";
+    }
+}
+/**
+ * Everything a page does with its network: request tracking and idle waits, response bodies, waiting for a
+ * request or response, the HTTP cache switch and the routes (interception).
+ */
+export class PageNetwork {
+    constructor(connector, contextId, deps) {
+        this.connector = connector;
+        this.contextId = contextId;
+        this.deps = deps;
+        this.lazyTracker = new Lazy();
+        this.lazyCollector = new Lazy();
+        this.lazyRouter = new Lazy();
+        this.responses = new WeakMap();
+        this.openCollector = async () => {
+            const { maxBodySize } = await this.deps.config.network();
+            return DataCollector.start(this.connector, this.contextId, {
+                ...(maxBodySize !== undefined && { maxBodySize }),
+            });
+        };
+    }
+    /** The network tracker, created on first use. Rejects with NetworkTrackingDisabledError when config turned tracking off */
+    tracker() {
+        return this.lazyTracker.get(async () => {
+            const settings = await this.deps.config.network();
+            if (settings.track === false)
+                throw new NetworkTrackingDisabledError();
+            const tracker = await NetworkTracker.start(this.connector, await this.deps.tree.ensure(), this.contextId);
+            const { emitter } = this.deps;
+            tracker.on("request", (request) => emitter.emit("request", request));
+            tracker.on("response", (response) => emitter.emit("response", this.responseFor(response)));
+            tracker.on("requestfailed", (failed) => emitter.emit("requestfailed", failed));
+            if (settings.collectBodies)
+                await this.startBodyCollection();
+            return tracker;
+        }, (err) => err instanceof NetworkTrackingDisabledError);
+    }
+    /** Starts following requests now; does nothing when config `network.track` is false */
+    async startTracking() {
+        try {
+            await this.tracker();
+        }
+        catch (err) {
+            if (!(err instanceof NetworkTrackingDisabledError))
+                throw err;
+        }
+    }
+    /** Waits until no request has been in flight for `idleTime` ms (default config `network.idleTime`, then 500) */
+    async waitForIdle(options = {}) {
+        const tracker = await this.tracker();
+        const idleTime = await this.deps.config.idleTime(options.idleTime);
+        const timeout = await this.deps.config.navigationTimeout(options.timeout);
+        await tracker.waitForIdle({ idleTime, timeout });
+    }
+    /** Starts keeping response bodies, which is what makes `response.body()` possible */
+    async startBodyCollection() {
+        await this.lazyCollector.get(this.openCollector);
+    }
+    /** One Response per network response, whoever asks, so a body is read from the browser once */
+    responseFor(data) {
+        let response = this.responses.get(data);
+        if (!response) {
+            response = new Response(data, (loaded) => this.loadBody(loaded));
+            this.responses.set(data, response);
+        }
+        return response;
+    }
+    async loadBody(response) {
+        if (!this.lazyCollector.started) {
+            throw new ResponseBodyUnavailableError(response.url, "no body collection was running: call page.startBodyCollection() before the request, or listen with page.on('response')");
+        }
+        const collector = await this.lazyCollector.get(this.openCollector);
+        const body = await collector.read(response.id, response.url);
+        void collector.release(response.id);
+        return body;
+    }
+    /** Resolves with the next response whose URL matches (a pattern, see `route`) or that the function accepts */
+    async waitForResponse(match, options = {}) {
+        await Promise.all([this.tracker(), this.startBodyCollection()]);
+        return this.waitForNetworkEvent("response", match, options);
+    }
+    /** Like `waitForResponse`, for requests */
+    async waitForRequest(match, options = {}) {
+        await this.tracker();
+        return this.waitForNetworkEvent("request", match, options);
+    }
+    waitForNetworkEvent(event, match, options) {
+        const matches = toPredicate(match);
+        const Timeout = event === "request" ? RequestTimeoutError : ResponseTimeoutError;
+        return this.deps.waitForEvent(event, matches, options, (timeout) => new Timeout(event === "request" ? "waitForRequest" : "waitForResponse", match, timeout));
+    }
+    /** Turns the browser's HTTP cache off (`true`) or back on for this page: every request then goes to the server */
+    async setCacheDisabled(disabled) {
+        try {
+            await this.connector.send("network.setCacheBehavior", {
+                cacheBehavior: disabled ? "bypass" : "default",
+                contexts: [this.contextId],
+            });
+        }
+        catch (err) {
+            if (isUnsupported(err)) {
+                throw new UnsupportedOperationError("setCacheDisabled(): not supported by the browser");
+            }
+            throw err;
+        }
+    }
+    router() {
+        return this.lazyRouter.get(async () => {
+            const routeTimeout = (await this.deps.config.network()).routeTimeout;
+            return new Router(this.connector, await this.deps.tree.ensure(), this.contextId, { ...(routeTimeout !== undefined && { routeTimeout }) });
+        });
+    }
+    /** Sends requests whose URL matches to `handler` (see `Page.route`) */
+    async route(url, handler) {
+        await (await this.router()).route(url, handler);
+    }
+    /** Removes the routes for `url` (only the one with `handler`, when given) */
+    async unroute(url, handler) {
+        if (!this.lazyRouter.started)
+            return;
+        await (await this.router()).unroute(url, handler);
+    }
+    async unrouteAll() {
+        if (!this.lazyRouter.started)
+            return;
+        await (await this.router()).unrouteAll();
+    }
+    /** Errors thrown by route handlers so far */
+    routeErrors() {
+        return this.lazyRouter.peek()?.errors ?? [];
+    }
+    /** The first half of releasing the network: the tracker goes before the tree it reads */
+    async disposeTracker() {
+        try {
+            await (await this.lazyTracker.take())?.dispose();
+        }
+        catch {
+            // A tracker that never started (or was switched off) has nothing to release
+        }
+    }
+    /** The second half: the router, then the body collector */
+    disposeRest() {
+        const router = this.lazyRouter.take();
+        const collector = this.lazyCollector.take();
+        return [
+            router?.then((resolved) => resolved.dispose()),
+            collector?.then((resolved) => resolved.dispose()),
+        ];
+    }
+}

package/dist/browser/page-settings.d.ts

@@ -0,0 +1,35 @@
+import type { SamuraiTestConfig } from "../types/config.js";
+import type { BiDiCommands } from "../types/bidi.js";
+/** Options that otherwise come from `samurai.config.ts` */
+export type PageSettings = Pick<SamuraiTestConfig, "network" | "navigation" | "use">;
+/** What `navigateTo` and `reload` wait for */
+export type ReadinessState = NonNullable<BiDiCommands["browsingContext.navigate"]["params"]["wait"]>;
+/** The settings a page uses: the ones it was given, else the project's config, else the defaults */
+export declare class PageConfig {
+    private readonly given?;
+    constructor(given?: PageSettings | undefined);
+    network(): Promise<{
+        track?: boolean;
+        idleTime?: number;
+        routeTimeout?: number;
+        collectBodies?: boolean;
+        maxBodySize?: number;
+    }>;
+    navigation(): Promise<{
+        timeout?: number;
+        waitUntil?: "none" | "interactive" | "complete";
+    }>;
+    use(): Promise<{
+        viewport?: {
+            width: number;
+            height: number;
+        } | null;
+        headless?: boolean;
+    }>;
+    /** The time (ms) a navigation or a wait may take: the call's, else config `navigation.timeout`, else 30 s */
+    navigationTimeout(override?: number): Promise<number>;
+    /** What a navigation waits for: the call's, else config `navigation.waitUntil`, else the load event */
+    navigationWait(override?: ReadinessState): Promise<ReadinessState>;
+    /** Time (ms) without requests in flight that counts as idle: the call's, else config `network.idleTime`, else 500 */
+    idleTime(override?: number): Promise<number>;
+}

package/dist/browser/page-settings.js

@@ -0,0 +1,51 @@
+import { readConfig } from "../config/config.js";
+import logger from "../logger/index.js";
+/** Time (ms) a navigation or a wait for a load state may take */
+const DEFAULT_NAVIGATION_TIMEOUT = 30000;
+/** Time (ms) without requests in flight that counts as idle */
+const DEFAULT_IDLE_TIME = 500;
+/** A section of the config, or `{}` when it cannot be read (a page can be used without a project) */
+async function readSection(key) {
+    try {
+        return ((await readConfig(key)) ?? {});
+    }
+    catch (err) {
+        logger.debug("Could not read %s config, using defaults", key, { err });
+        return {};
+    }
+}
+/** The settings a page uses: the ones it was given, else the project's config, else the defaults */
+export class PageConfig {
+    constructor(given) {
+        this.given = given;
+    }
+    network() {
+        return this.given?.network
+            ? Promise.resolve(this.given.network)
+            : readSection("network");
+    }
+    navigation() {
+        return this.given?.navigation
+            ? Promise.resolve(this.given.navigation)
+            : readSection("navigation");
+    }
+    use() {
+        return this.given?.use
+            ? Promise.resolve(this.given.use)
+            : readSection("use");
+    }
+    /** The time (ms) a navigation or a wait may take: the call's, else config `navigation.timeout`, else 30 s */
+    async navigationTimeout(override) {
+        return (override ??
+            (await this.navigation()).timeout ??
+            DEFAULT_NAVIGATION_TIMEOUT);
+    }
+    /** What a navigation waits for: the call's, else config `navigation.waitUntil`, else the load event */
+    async navigationWait(override) {
+        return override ?? (await this.navigation()).waitUntil ?? "complete";
+    }
+    /** Time (ms) without requests in flight that counts as idle: the call's, else config `network.idleTime`, else 500 */
+    async idleTime(override) {
+        return override ?? (await this.network()).idleTime ?? DEFAULT_IDLE_TIME;
+    }
+}

package/dist/browser/page-transfers.d.ts

@@ -0,0 +1,36 @@
+import type EventEmitter from "node:events";
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+import type { BrowsingContext } from "../types/bidi-modules/browsing-context.js";
+import type { TreeSource } from "./dialog-handling.js";
+import { Download } from "./download.js";
+import { FileChooser } from "./file-chooser.js";
+import type { PageEventName, PageEvents, WaitOptions } from "./page-events.js";
+import type { PageConfig } from "./page-settings.js";
+/** What `PageTransfers` takes from the page around it */
+export interface PageTransfersDeps {
+    config: PageConfig;
+    tree: TreeSource;
+    /** Where `download` and `filechooser` are emitted */
+    emitter: EventEmitter;
+    /** Resolves with the first event of a kind that `matches` accepts (the page's `waitForPageEvent`) */
+    waitForEvent: <E extends PageEventName>(event: E, matches: (item: PageEvents[E][0]) => boolean, options: WaitOptions, onTimeout: (timeout: number) => Error) => Promise<PageEvents[E][0]>;
+}
+/** What goes between a page and the disk: downloads it starts and file pickers it opens */
+export declare class PageTransfers {
+    private connector;
+    private contextId;
+    private deps;
+    private lazyDownloads;
+    private lazyFileChoosers;
+    constructor(connector: BiDiConnector, contextId: BrowsingContext, deps: PageTransfersDeps);
+    /** Starts following downloads; the browser does this when it opens a page, `page.on("download")` and `waitForDownload` when needed */
+    startDownloadTracking(): Promise<void>;
+    /** Starts following file pickers; the browser does this when it opens a page, `page.on("filechooser")` and `waitForFileChooser` when needed */
+    startFileChooserTracking(): Promise<void>;
+    /** Resolves with the next download (that `accepts`, when given) the page starts */
+    waitForDownload(options?: WaitOptions, accepts?: (download: Download) => boolean): Promise<Download>;
+    /** Resolves with the next file picker (that `accepts`, when given) the page opens */
+    waitForFileChooser(options?: WaitOptions, accepts?: (chooser: FileChooser) => boolean): Promise<FileChooser>;
+    /** Releases both trackers */
+    dispose(): (Promise<void> | undefined)[];
+}

package/dist/browser/page-transfers.js

@@ -0,0 +1,50 @@
+import { Download, DownloadTracker } from "./download.js";
+import { FileChooser, FileChooserTracker } from "./file-chooser.js";
+import { Lazy } from "./lazy.js";
+import { DownloadWaitTimeoutError, FileChooserTimeoutError, } from "./page-wait.js";
+/** What goes between a page and the disk: downloads it starts and file pickers it opens */
+export class PageTransfers {
+    constructor(connector, contextId, deps) {
+        this.connector = connector;
+        this.contextId = contextId;
+        this.deps = deps;
+        this.lazyDownloads = new Lazy();
+        this.lazyFileChoosers = new Lazy();
+    }
+    /** Starts following downloads; the browser does this when it opens a page, `page.on("download")` and `waitForDownload` when needed */
+    async startDownloadTracking() {
+        await this.lazyDownloads.get(async () => {
+            const timeout = await this.deps.config.navigationTimeout();
+            const tracker = await DownloadTracker.start(this.connector, await this.deps.tree.ensure(), this.contextId, { timeout });
+            tracker.on("download", (download) => this.deps.emitter.emit("download", download));
+            return tracker;
+        });
+    }
+    /** Starts following file pickers; the browser does this when it opens a page, `page.on("filechooser")` and `waitForFileChooser` when needed */
+    async startFileChooserTracking() {
+        await this.lazyFileChoosers.get(async () => {
+            const tracker = await FileChooserTracker.start(this.connector, await this.deps.tree.ensure(), this.contextId);
+            tracker.on("filechooser", (chooser) => this.deps.emitter.emit("filechooser", chooser));
+            return tracker;
+        });
+    }
+    /** Resolves with the next download (that `accepts`, when given) the page starts */
+    async waitForDownload(options = {}, accepts = () => true) {
+        await this.startDownloadTracking();
+        return this.deps.waitForEvent("download", accepts, options, (timeout) => new DownloadWaitTimeoutError(timeout));
+    }
+    /** Resolves with the next file picker (that `accepts`, when given) the page opens */
+    async waitForFileChooser(options = {}, accepts = () => true) {
+        await this.startFileChooserTracking();
+        return this.deps.waitForEvent("filechooser", accepts, options, (timeout) => new FileChooserTimeoutError(timeout));
+    }
+    /** Releases both trackers */
+    dispose() {
+        const downloads = this.lazyDownloads.take();
+        const fileChoosers = this.lazyFileChoosers.take();
+        return [
+            downloads?.then((resolved) => resolved.dispose()),
+            fileChoosers?.then((resolved) => resolved.dispose()),
+        ];
+    }
+}

package/dist/browser/page.d.ts

@@ -1,92 +1,48 @@
-import Locator, { type TextOptions } from "../locator/locator.js";
-import type { NetworkRequest, FailedRequest } from "../network/network-tracker.js";
-import { Recorder, type RecorderOptions } from "../recorder/recorder.js";
+import Locator from "../locator/locator.js";
+import type { TextOptions } from "../locator/selector.js";
+import type { NetworkRequest } from "../network/network-tracker.js";
+import type { Recorder, RecorderOptions } from "../recorder/recorder.js";
 import { ContextTree } from "./context-tree.js";
-import { Dialog } from "./dialog.js";
 import type { BrowserContext } from "./browser-context.js";
 import { type PdfOptions } from "./pdf.js";
 import { type EmulationOptions } from "./emulation.js";
-import { Download } from "./download.js";
-import { FileChooser } from "./file-chooser.js";
+import type { Download } from "./download.js";
+import type { FileChooser } from "./file-chooser.js";
 import { type ScreenshotOptions } from "./screenshot.js";
 import { Evidence } from "./evidence.js";
-import { type ConsoleMessage, type LogRecord, type PageError } from "./page-logs.js";
-import { type RouteHandler } from "../network/router.js";
+import { type LogRecord, type PageError } from "./page-logs.js";
+import type { RouteHandler } from "../network/router.js";
 import { Response } from "../network/response.js";
-import { type NetworkMatch } from "../network/network-wait.js";
+import type { NetworkMatch } from "../network/network-wait.js";
 import type { UrlPattern } from "../network/url-match.js";
+import type { LoadState, NavigateOptions, NavigationResult } from "./page-navigation.js";
+import { type PageEventName, type PageEvents, type WaitableEventName, type WaitForEventOptions, type WaitOptions } from "./page-events.js";
+export type { PageEventName, WaitableEventName, WaitForEventOptions, WaitOptions, };
+import { type PageSettings, type ReadinessState } from "./page-settings.js";
+export type { PageSettings, ReadinessState };
+import { type Viewport } from "./viewport.js";
 import { type PreloadHandle } from "../script/preload.js";
 import type { BiDiConnector } from "../transport/bidi-connection.js";
-import type { BiDiCommands } from "../types/bidi.js";
-import type { SamuraiTestConfig } from "../types/config.js";
 import type { BrowsingContext } from "../types/bidi-modules/browsing-context.js";
-/** Options that otherwise come from `samurai.config.ts` */
-export type PageSettings = Pick<SamuraiTestConfig, "network" | "navigation" | "use">;
-export type ReadinessState = NonNullable<BiDiCommands["browsingContext.navigate"]["params"]["wait"]>;
-export type LoadState = "load" | "domcontentloaded" | "networkidle";
-export interface NavigateOptions {
-    /** When navigateTo resolves. @default config `navigation.waitUntil`, then "complete" */
-    wait?: ReadinessState;
-    /** Time (ms) the navigation may take. @default config `navigation.timeout`, then 30000 */
-    timeout?: number;
-    /** Scheme added to a URL without one. @default "https" */
-    protocol?: "http" | "https";
-}
-interface NetworkEvents {
-    request: [NetworkRequest];
-    response: [Response];
-    requestfailed: [FailedRequest];
-}
-/** Everything `page.on` can listen for */
-interface PageEvents extends NetworkEvents {
-    download: [Download];
-    filechooser: [FileChooser];
-    dialog: [Dialog];
-    console: [ConsoleMessage];
-    pageerror: [PageError];
-}
-export type PageEventName = keyof PageEvents;
-/** Events `page.waitForEvent` can wait for */
-export type WaitableEventName = "download" | "filechooser" | "request" | "response";
-export interface WaitForEventOptions<T> {
-    /** Only an event this accepts counts */
-    predicate?: (item: T) => boolean;
-    /** Time (ms) to wait. @default config `navigation.timeout`, then 30000 */
-    timeout?: number;
-    /** Runs once the wait is set up; what it causes cannot be missed */
-    trigger?: () => Promise<unknown>;
-}
+export type { LoadState, NavigateOptions, NavigationResult };
 export default class Page {
     private biDiConnector;
     private id;
-    private contextTree;
+    private lazyTree;
     private helperRealm;
     private initScripts;
-    private settings;
-    private networkTracker;
+    private pageConfig;
     private pageEvents;
-    /** The navigation started by the last navigateTo; failures of it fail a wait */
-    private lastNavigation;
-    /** Base for relative page.goto URLs; falls back to the active run's baseURL */
-    private baseURL;
-    /** How far navigations that did not wait for the load got, by navigation id (the latest few) */
-    private navigationProgress;
-    private documentEvents;
-    private dialogHandling;
-    private pageLogs;
-    private loadedLogs;
+    private documents;
+    private nav;
+    private net;
+    private dialogs;
+    private lazyLogs;
     private errorsAllowed;
     private isClosed;
     private browserContext;
-    private downloadTracker;
-    private fileChooserTracker;
-    private collectorPromise;
-    private responses;
-    private routerPromise;
-    private loadedRouter;
-    /** The context tree once loaded, for handlers that cannot wait for it */
-    private loadedTree;
-    private openDialogs;
+    private transfers;
+    private evidence;
     /** `settings` override what `samurai.config.ts` says; without them the config is read when needed */
     constructor(biDiConnector: BiDiConnector, contextId: string, settings?: PageSettings);
     /** The BiDi browsing context id of this page's top-level context */
@@ -95,6 +51,7 @@ export default class Page {
     tree(): Promise<ContextTree>;
     /** Locates an element on the page and returns an interactable object */
     locator(xpath: string): Locator;
+    private locate;
     /** Locates elements with a CSS selector */
     getByCss(css: string): Locator;
     /** Locates elements by their text: an exact match unless `match: "partial"` */
@@ -133,10 +90,7 @@ export default class Page {
      *  await page.goto("/products");
      *  await page.goto("https://example.com", { wait: "interactive" });
      */
-    goto(url: string, options?: NavigateOptions): Promise<{
-        navigation: string | null;
-        url: string;
-    }>;
+    goto(url: string, options?: NavigateOptions): Promise<NavigationResult>;
     /**
      * Navigates to `url` and resolves when the page reached `wait` (default "complete", the load event).
      * A URL without a scheme gets `https://`. Throws NavigationError when the navigation fails or takes too long.
@@ -145,15 +99,7 @@ export default class Page {
      *  await page.navigateTo("example.com");
      *  await page.navigateTo("localhost:3000", { wait: "interactive", protocol: "http" });
      */
-    navigateTo(url: string, options?: NavigateOptions | ReadinessState, protocol?: "http" | "https"): Promise<{
-        navigation: string | null;
-        url: string;
-    }>;
-    /**
-     * Runs a navigation command and settles what waiting for it means: failures become NavigationErrors, and a
-     * navigation that did not wait for the load is watched so `waitForLoadState` can tell it from the old page.
-     */
-    private navigation;
+    navigateTo(url: string, options?: NavigateOptions | ReadinessState, protocol?: "http" | "https"): Promise<NavigationResult>;
     /**
      * Reloads the page and resolves when it reached `wait` (default like `navigateTo`). Firefox does not support
      * `ignoreCache`; asking for it throws UnsupportedOperationError.
@@ -162,26 +108,11 @@ export default class Page {
         wait?: ReadinessState;
         timeout?: number;
         ignoreCache?: boolean;
-    }): Promise<{
-        navigation: string | null;
-        url: string;
-    }>;
+    }): Promise<NavigationResult>;
     /** Goes back one entry in the history. False when there is none to go back to */
     goBack(): Promise<boolean>;
     /** Goes forward one entry in the history. False when there is none */
     goForward(): Promise<boolean>;
-    private traverse;
-    /**
-     * Whether going back would only reach the blank page a tab starts with. Firefox does not keep that page in the
-     * history, Chrome does; the Navigation API (Chrome only) lets Chrome say the same as Firefox.
-     */
-    private atFirstEntry;
-    /**
-     * Starts listening for the end of a history traversal (the new entry committed, or the history or fragment changed
-     * within the document). `done` resolves at the first such event, or after a second without one (a page restored from
-     * the back-forward cache may say nothing); it never rejects.
-     */
-    private watchHistoryTraversal;
     /** The URL of the page now */
     url(): Promise<string>;
     /** The title of the document now */
@@ -191,27 +122,20 @@ export default class Page {
      * @example
      *  await page.setViewport({ width: 390, height: 844, devicePixelRatio: 3 });
      */
-    setViewport(viewport: {
-        width: number;
-        height: number;
-        devicePixelRatio?: number;
-    } | null): Promise<void>;
-    /**
-     * Runs `change`, then waits until the page has stopped resizing. Chrome answers a viewport reset before the window
-     * has its own size back, so a read right after it can still show the old size. The wait ends 50 ms after the last
-     * `resize` event, and after 300 ms when the size does not change at all (no event comes). Never fails: a page that
-     * cannot be watched is simply not waited for.
-     */
-    private untilResized;
+    setViewport(viewport: Viewport | null): Promise<void>;
     /** Gives the page the size from config `use.viewport` (1280x720 by default); the browser does this when it opens a page */
     applyDefaultViewport(): Promise<void>;
+    /**
+     * What the browser sets up on every page it opens: the default size, then everything that has to be listening
+     * before the page does anything (requests, dialogs, logs, downloads, file pickers). Safe to call again.
+     */
+    startTracking(): Promise<void>;
     /**
      * Takes a screenshot and returns the image (also written to `options.path`).
      * @example
      *  await page.screenshot({ path: "out/home.png", fullPage: true });
      */
     screenshot(options?: ScreenshotOptions): Promise<Buffer>;
-    private evidence;
     /** @internal The runner gives each test its own evidence folder */
     setEvidence(evidence: Evidence | undefined): void;
     /** Waits `ms` milliseconds. Prefer waiting for something (an assertion, `waitForNetworkIdle`) when you can */
@@ -259,20 +183,6 @@ export default class Page {
     waitForLoadState(state?: LoadState, options?: {
         timeout?: number;
     }): Promise<void>;
-    private progressOf;
-    private onDocumentEvent;
-    private onDomContentLoaded;
-    private onLoad;
-    /** Starts recording which navigations reached DOMContentLoaded and load; kept until dispose */
-    private watchDocumentEvents;
-    private canBeAborted;
-    /** Subscribes to what a wait listens for; a browser that lacks the navigationAborted event (Firefox) is asked only once */
-    private subscribeToDocumentEvents;
-    private waitForDocumentState;
-    private networkSettings;
-    private navigationSettings;
-    /** The network tracker, created on first use. Rejects with NetworkTrackingDisabledError when config turned tracking off */
-    private network;
     /**
      * Starts following this page's requests now. Tracking only sees requests made after it started, so the
      * browser calls this when it opens a page; without it, tracking starts on first use. Does nothing when
@@ -310,10 +220,7 @@ export default class Page {
      *  const download = await page.waitForDownload({ trigger: () => link.click() });
      *  const file = await download.path();
      */
-    waitForDownload(options?: {
-        timeout?: number;
-        trigger?: () => Promise<unknown>;
-    }): Promise<Download>;
+    waitForDownload(options?: WaitOptions): Promise<Download>;
     /**
      * Resolves with the next file picker the page opens (a click on an `<input type=file>` or its label). Nothing shows
      * on screen: answer it with `chooser.setFiles(...)`.
@@ -321,10 +228,7 @@ export default class Page {
      *  const chooser = await page.waitForFileChooser({ trigger: () => page.locator("label[@for='avatar']").click() });
      *  await chooser.setFiles("./fixtures/avatar.png");
      */
-    waitForFileChooser(options?: {
-        timeout?: number;
-        trigger?: () => Promise<unknown>;
-    }): Promise<FileChooser>;
+    waitForFileChooser(options?: WaitOptions): Promise<FileChooser>;
     /**
      * Playwright-style wait for one page event: `download`, `filechooser`, `request` or `response`. Same as the named
      * `waitFor…` method, with an optional predicate (a function, or `predicate` in the options). Call it before the event
@@ -340,9 +244,6 @@ export default class Page {
      * `network.collectBodies` calls it when the browser opens the page.
      */
     startBodyCollection(): Promise<void>;
-    /** One Response per network response, whoever asks, so a body is read from the browser once */
-    private responseFor;
-    private loadBody;
     /**
      * Resolves with the next response of this page whose URL matches (a pattern, see `route`) or that the function
      * accepts. Call it before the request is made, or pass `trigger`, which runs once the wait is set up.
@@ -350,16 +251,9 @@ export default class Page {
      *  const response = await page.waitForResponse("**\/api/users", { trigger: () => button.click() });
      *  const users = await response.json();
      */
-    waitForResponse(match: NetworkMatch<Response>, options?: {
-        timeout?: number;
-        trigger?: () => Promise<unknown>;
-    }): Promise<Response>;
+    waitForResponse(match: NetworkMatch<Response>, options?: WaitOptions): Promise<Response>;
     /** Like `waitForResponse`, for requests */
-    waitForRequest(match: NetworkMatch<NetworkRequest>, options?: {
-        timeout?: number;
-        trigger?: () => Promise<unknown>;
-    }): Promise<NetworkRequest>;
-    private waitForNetworkEvent;
+    waitForRequest(match: NetworkMatch<NetworkRequest>, options?: WaitOptions): Promise<NetworkRequest>;
     /**
      * Resolves with the first `event` `matches` accepts. Listens before `trigger` runs, so what the trigger causes cannot
      * be missed; a trigger that throws rejects the wait with its error. `onTimeout` builds the error for a wait that ran out.
@@ -367,7 +261,6 @@ export default class Page {
     private waitForPageEvent;
     /** Turns the browser's HTTP cache off (`true`) or back on for this page: every request then goes to the server */
     setCacheDisabled(disabled: boolean): Promise<void>;
-    private router;
     /**
      * Sends requests whose URL matches to `handler`, which must answer with `route.fulfill()`, `route.continue()`,
      * `route.abort()` or `route.fallback()` (await the answer: a handler that returns first lets the request continue).
@@ -402,12 +295,4 @@ export default class Page {
     get pageErrorsAllowed(): boolean;
     /** Starts watching for dialogs; the browser does this when it opens a page, `page.on("dialog")` when needed */
     startDialogHandling(): Promise<void>;
-    private ownsContext;
-    private onPromptOpened;
-    private onPromptClosed;
-    /** Lets the listeners answer; a dialog still open afterwards gets the default answer, so nothing hangs */
-    private dispatchDialog;
-    /** Captures an image of the given navigable, and returns it as a Base64-encoded string */
-    captureScreenshot(clip?: BiDiCommands["browsingContext.captureScreenshot"]["params"]["clip"], format?: BiDiCommands["browsingContext.captureScreenshot"]["params"]["format"], origin?: BiDiCommands["browsingContext.captureScreenshot"]["params"]["origin"]): Promise<void>;
 }
-export {};