@itmetsam/samurai-framework 0.9.0 → 0.12.0

package/dist/locator/page-scripts.js

@@ -0,0 +1,54 @@
+/** Page-side source strings and the actionability checks each action waits for */
+/** What `setInputFiles` needs to know about the element before it sends files */
+export const FILE_INPUT_INFO = `(el) => ({
+  tag: el.tagName.toLowerCase(),
+  type: (el.getAttribute("type") || "").toLowerCase(),
+  multiple: Boolean(el.multiple),
+})`;
+export const FILE_INPUT_CHECKS = ["attached", "enabled"];
+export const DROP_CHECKS = ["attached", "visible"];
+/** The sandbox `dropFiles` builds its files in */
+export const DROP_SANDBOX = "samurai-drop";
+const DROP_KEY = `globalThis[Symbol.for("samurai.drop")]`;
+export const DROP_INPUT = `() => {
+  const input = document.createElement("input");
+  input.type = "file";
+  input.multiple = true;
+  ${DROP_KEY} = input;
+  return input;
+}`;
+/** Fires dragenter, dragover and drop at the element's centre with the input's files (retyped where asked) */
+export const DROP_EVENTS = `(el, types) => {
+  const input = ${DROP_KEY};
+  delete ${DROP_KEY};
+  const data = new DataTransfer();
+  Array.from(input.files).forEach((file, i) => {
+    data.items.add(types[i] ? new File([file], file.name, { type: types[i], lastModified: file.lastModified }) : file);
+  });
+  const box = el.getBoundingClientRect();
+  const at = { clientX: box.left + box.width / 2, clientY: box.top + box.height / 2 };
+  for (const type of ["dragenter", "dragover", "drop"]) {
+    el.dispatchEvent(new DragEvent(type, Object.assign({ bubbles: true, cancelable: true, composed: true, dataTransfer: data }, at)));
+  }
+}`;
+export const SCREENSHOT_CHECKS = ["attached", "visible"];
+export const CLICK_CHECKS = [
+    "attached",
+    "visible",
+    "stable",
+    "enabled",
+    "hit target",
+];
+export const FILL_CHECKS = [
+    "attached",
+    "visible",
+    "enabled",
+    "editable",
+    "hit target",
+];
+export const PRESS_CHECKS = [
+    "attached",
+    "visible",
+    "enabled",
+];
+export const ATTACHED_ONLY = ["attached"];

package/dist/locator/page-search.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Page-side pieces the text and label searches share. They are strings, glued into the function declarations
+ * of `TEXT_LOCATE` and `LABEL_LOCATE`, which run in the page with `(starts, value, match, ignoreCase)` in scope.
+ */
+/** `normalise` collapses whitespace and trims (lower-casing with `ignoreCase`); `textMatches` compares a text with `value` by `match` */
+export declare const MATCHING_JS = "\n  const normalise = (text) => {\n    const collapsed = String(text).replace(/\\s+/g, \" \").trim();\n    return ignoreCase ? collapsed.toLowerCase() : collapsed;\n  };\n  const wanted = normalise(value);\n  const textMatches = (text) => {\n    const normal = normalise(text);\n    return match === \"full\" ? normal === wanted : normal.includes(wanted);\n  };";
+/** The nodes to search in: the start nodes, else the whole document */
+export declare const ROOTS_JS = "const roots = starts.length > 0 ? starts : [document];";
+/** A sort callback putting elements in document order */
+export declare const DOCUMENT_ORDER_JS = "(a, b) => (a === b ? 0 : a.compareDocumentPosition(b) & 4 ? -1 : 1)";

package/dist/locator/page-search.js

@@ -0,0 +1,19 @@
+/**
+ * Page-side pieces the text and label searches share. They are strings, glued into the function declarations
+ * of `TEXT_LOCATE` and `LABEL_LOCATE`, which run in the page with `(starts, value, match, ignoreCase)` in scope.
+ */
+/** `normalise` collapses whitespace and trims (lower-casing with `ignoreCase`); `textMatches` compares a text with `value` by `match` */
+export const MATCHING_JS = `
+  const normalise = (text) => {
+    const collapsed = String(text).replace(/\\s+/g, " ").trim();
+    return ignoreCase ? collapsed.toLowerCase() : collapsed;
+  };
+  const wanted = normalise(value);
+  const textMatches = (text) => {
+    const normal = normalise(text);
+    return match === "full" ? normal === wanted : normal.includes(wanted);
+  };`;
+/** The nodes to search in: the start nodes, else the whole document */
+export const ROOTS_JS = `const roots = starts.length > 0 ? starts : [document];`;
+/** A sort callback putting elements in document order */
+export const DOCUMENT_ORDER_JS = `(a, b) => (a === b ? 0 : a.compareDocumentPosition(b) & 4 ? -1 : 1)`;

package/dist/locator/selector-errors.d.ts

@@ -3,7 +3,3 @@ export declare class InvalidSelectorError extends Error {
     readonly selector: string;
     constructor(selector: string, reason: string);
 }
-/** The browser does not implement this kind of locator */
-export declare class UnsupportedOperationError extends Error {
-    constructor(message: string);
-}

package/dist/locator/selector-errors.js

@@ -6,10 +6,3 @@ export class InvalidSelectorError extends Error {
         this.selector = selector;
     }
 }
-/** The browser does not implement this kind of locator */
-export class UnsupportedOperationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "UnsupportedOperationError";
-    }
-}

package/dist/locator/selector.d.ts

@@ -6,23 +6,17 @@ export type Selector = {
 } | {
     kind: "css";
     value: string;
-} | {
+} | ({
     kind: "text";
-    value: string;
-    match: "full" | "partial";
-    ignoreCase: boolean;
-} | {
+} & TextMatch) | {
     kind: "role";
-    role?: string;
+    role: string;
     name?: string;
 }
 /** Form controls named by a `<label>`, `aria-labelledby` or `aria-label` whose text matches */
- | {
+ | ({
     kind: "label";
-    value: string;
-    match: "full" | "partial";
-    ignoreCase: boolean;
-}
+} & TextMatch)
 /** Elements whose `data-testid` attribute equals `value` */
  | {
     kind: "testid";
@@ -33,6 +27,12 @@ export type Selector = {
     kind: "nth";
     index: number;
 };
+/** What a text or label step looks for */
+interface TextMatch {
+    value: string;
+    match: "full" | "partial";
+    ignoreCase: boolean;
+}
 export interface TextOptions {
     /** @default "full" */
     match?: "full" | "partial";
@@ -41,8 +41,8 @@ export interface TextOptions {
 }
 export declare function xpathSelector(value: string): Selector;
 export declare function cssSelector(value: string): Selector;
-export declare function textSelector(value: string, { match, ignoreCase }?: TextOptions): Selector;
-export declare function labelSelector(value: string, { match, ignoreCase }?: TextOptions): Selector;
+export declare function textSelector(value: string, options?: TextOptions): Selector;
+export declare function labelSelector(value: string, options?: TextOptions): Selector;
 export declare function testIdSelector(value: string): Selector;
 export declare function roleSelector(role: string, { name }?: {
     name?: string;
@@ -58,3 +58,4 @@ export declare function toBiDiLocator(selector: Selector, scoped: boolean): Node
 /** A short name for error messages */
 export declare function describeSelector(selector: Selector, scoped: boolean): string;
 export declare function describeChain(chain: readonly Selector[]): string;
+export {};

package/dist/locator/selector.js

@@ -9,21 +9,14 @@ export function xpathSelector(value) {
 export function cssSelector(value) {
     return { kind: "css", value: nonEmpty(value, "a css selector") };
 }
-export function textSelector(value, { match = "full", ignoreCase = false } = {}) {
-    return {
-        kind: "text",
-        value: nonEmpty(value, "the text"),
-        match,
-        ignoreCase,
-    };
+function textMatch(value, what, { match = "full", ignoreCase = false }) {
+    return { value: nonEmpty(value, what), match, ignoreCase };
 }
-export function labelSelector(value, { match = "full", ignoreCase = false } = {}) {
-    return {
-        kind: "label",
-        value: nonEmpty(value, "the label"),
-        match,
-        ignoreCase,
-    };
+export function textSelector(value, options = {}) {
+    return { kind: "text", ...textMatch(value, "the text", options) };
+}
+export function labelSelector(value, options = {}) {
+    return { kind: "label", ...textMatch(value, "the label", options) };
 }
 export function testIdSelector(value) {
     return { kind: "testid", value: nonEmpty(value, "the test id") };
@@ -65,7 +58,7 @@ export function toBiDiLocator(selector, scoped) {
             return {
                 type: "accessibility",
                 value: {
-                    ...(selector.role !== undefined && { role: selector.role }),
+                    role: selector.role,
                     ...(selector.name !== undefined && { name: selector.name }),
                 },
             };
@@ -74,6 +67,7 @@ export function toBiDiLocator(selector, scoped) {
                 type: "css",
                 value: `[data-testid="${selector.value.replace(/["\\]/g, "\\$&")}"]`,
             };
+        // The locator resolves these two itself, so a chain never hands them to the browser
         case "label":
             throw new Error("label is resolved by the framework, not by the browser");
         case "nth":
@@ -98,7 +92,7 @@ export function describeSelector(selector, scoped) {
         case "testid":
             return `testid=${JSON.stringify(selector.value)}`;
         case "role":
-            return (`role=${selector.role ?? ""}` +
+            return (`role=${selector.role}` +
                 (selector.name === undefined
                     ? ""
                     : `[name=${JSON.stringify(selector.name)}]`));

package/dist/locator/text-locator.d.ts

@@ -10,4 +10,4 @@
  *
  * A string, so the transpiler cannot inject helpers that do not exist in the page.
  */
-export declare const TEXT_LOCATE = "(starts, value, match, ignoreCase) => {\n  const skipped = new Set([\"SCRIPT\", \"STYLE\", \"NOSCRIPT\", \"TEMPLATE\", \"HEAD\", \"TITLE\", \"META\", \"LINK\"]);\n  const normalise = (text) => {\n    const collapsed = String(text).replace(/\\s+/g, \" \").trim();\n    return ignoreCase ? collapsed.toLowerCase() : collapsed;\n  };\n  const wanted = normalise(value);\n  const roots = starts.length > 0 ? starts : [document];\n  const seen = new Set();\n  const matches = [];\n  for (const root of roots) {\n    for (const el of root.querySelectorAll(\"*\")) {\n      if (seen.has(el) || skipped.has(el.tagName.toUpperCase())) continue;\n      seen.add(el);\n      const text = normalise(el.innerText ?? el.textContent ?? \"\");\n      if (match === \"full\" ? text === wanted : text.includes(wanted)) matches.push(el);\n    }\n  }\n  const hasMatchingDescendant = new Set();\n  for (const el of matches) {\n    for (let parent = el.parentElement; parent; parent = parent.parentElement) hasMatchingDescendant.add(parent);\n  }\n  return matches\n    .filter((el) => !hasMatchingDescendant.has(el))\n    .sort((a, b) => (a.compareDocumentPosition(b) & 4 ? -1 : 1));\n}";
+export declare const TEXT_LOCATE = "(starts, value, match, ignoreCase) => {\n  const skipped = new Set([\"SCRIPT\", \"STYLE\", \"NOSCRIPT\", \"TEMPLATE\", \"HEAD\", \"TITLE\", \"META\", \"LINK\"]);\n  \n  const normalise = (text) => {\n    const collapsed = String(text).replace(/\\s+/g, \" \").trim();\n    return ignoreCase ? collapsed.toLowerCase() : collapsed;\n  };\n  const wanted = normalise(value);\n  const textMatches = (text) => {\n    const normal = normalise(text);\n    return match === \"full\" ? normal === wanted : normal.includes(wanted);\n  };\n  const roots = starts.length > 0 ? starts : [document];\n  const seen = new Set();\n  const matches = [];\n  for (const root of roots) {\n    for (const el of root.querySelectorAll(\"*\")) {\n      if (seen.has(el) || skipped.has(el.tagName.toUpperCase())) continue;\n      seen.add(el);\n      if (textMatches(el.innerText ?? el.textContent ?? \"\")) matches.push(el);\n    }\n  }\n  const hasMatchingDescendant = new Set();\n  for (const el of matches) {\n    for (let parent = el.parentElement; parent; parent = parent.parentElement) hasMatchingDescendant.add(parent);\n  }\n  return matches\n    .filter((el) => !hasMatchingDescendant.has(el))\n    .sort((a, b) => (a === b ? 0 : a.compareDocumentPosition(b) & 4 ? -1 : 1));\n}";

package/dist/locator/text-locator.js

@@ -1,3 +1,4 @@
+import { DOCUMENT_ORDER_JS, MATCHING_JS, ROOTS_JS } from "./page-search.js";
 /**
  * Function declaration run in the page as `(starts, value, match, ignoreCase)`; returns the elements
  * whose text matches. Used when the browser does not implement BiDi's `innerText` locator
@@ -12,20 +13,15 @@
  */
 export const TEXT_LOCATE = `(starts, value, match, ignoreCase) => {
   const skipped = new Set(["SCRIPT", "STYLE", "NOSCRIPT", "TEMPLATE", "HEAD", "TITLE", "META", "LINK"]);
-  const normalise = (text) => {
-    const collapsed = String(text).replace(/\\s+/g, " ").trim();
-    return ignoreCase ? collapsed.toLowerCase() : collapsed;
-  };
-  const wanted = normalise(value);
-  const roots = starts.length > 0 ? starts : [document];
+  ${MATCHING_JS}
+  ${ROOTS_JS}
   const seen = new Set();
   const matches = [];
   for (const root of roots) {
     for (const el of root.querySelectorAll("*")) {
       if (seen.has(el) || skipped.has(el.tagName.toUpperCase())) continue;
       seen.add(el);
-      const text = normalise(el.innerText ?? el.textContent ?? "");
-      if (match === "full" ? text === wanted : text.includes(wanted)) matches.push(el);
+      if (textMatches(el.innerText ?? el.textContent ?? "")) matches.push(el);
     }
   }
   const hasMatchingDescendant = new Set();
@@ -34,5 +30,5 @@ export const TEXT_LOCATE = `(starts, value, match, ignoreCase) => {
   }
   return matches
     .filter((el) => !hasMatchingDescendant.has(el))
-    .sort((a, b) => (a.compareDocumentPosition(b) & 4 ? -1 : 1));
+    .sort(${DOCUMENT_ORDER_JS});
 }`;

package/dist/logger/index.d.ts

@@ -1,2 +1,8 @@
+/** One console line: `LEVEL: message`, then the line's own metadata as JSON when it has any */
+export declare function consoleLine(entry: {
+    level: string;
+    message: unknown;
+    meta?: Record<string, unknown> | undefined;
+}): string;
 declare const logger: import("winston").Logger;
 export default logger;

package/dist/logger/index.js

@@ -1,5 +1,13 @@
 import { createLogger, format, transports } from "winston";
 import { maskFormat } from "../config/mask.js";
+/** Metadata every line carries (`defaultMeta`): not worth printing on each console line */
+const DEFAULT_META_KEYS = ["service"];
+/** One console line: `LEVEL: message`, then the line's own metadata as JSON when it has any */
+export function consoleLine(entry) {
+    const own = Object.fromEntries(Object.entries(entry.meta ?? {}).filter(([key]) => !DEFAULT_META_KEYS.includes(key)));
+    const meta = Object.keys(own).length > 0 ? `\n${JSON.stringify(own)}` : "";
+    return `${entry.level.toUpperCase()}: ${String(entry.message)}${meta}`;
+}
 const logger = createLogger({
     level: "debug",
     format: format.combine(format.timestamp({
@@ -7,18 +15,17 @@ const logger = createLogger({
     }), format.errors({ stack: true }), format.splat(), format.metadata({ key: "meta" }), maskFormat(), format.json({ space: 2 })),
     defaultMeta: { service: "samurai-framework" },
     transports: [
-        //
-        // - Write to all logs with level `info` and below to `quick-start-combined.log`.
-        // - Write all logs error (and below) to `quick-start-error.log`.
-        //
+        // The console shows the log; `logs/error.log` keeps errors and `logs/combined.log` everything
         new transports.Console({
             // The `samurai` command quiets this to "warn"; the log files keep everything
             level: process.env.SAMURAI_LOG_LEVEL ?? "debug",
             // stdout stays free for a command's own output (`samurai run --json`)
             stderrLevels: ["error", "warn", "info", "verbose", "debug"],
-            format: format.combine(format.timestamp(), format.errors({ stack: true }), format.printf(({ level, message, meta }) => {
-                return `${level.toUpperCase()}: ${message}${meta ? `\n${JSON.stringify(meta)}` : null}`;
-            })),
+            format: format.combine(format.timestamp(), format.errors({ stack: true }), format.printf(({ level, message, meta }) => consoleLine({
+                level,
+                message,
+                meta: meta,
+            }))),
         }),
         new transports.File({
             filename: `logs/error.log`,

package/dist/network/bidi-wire.d.ts

@@ -0,0 +1,10 @@
+import type { BytesValue, Header, RequestData } from "../types/bidi-modules/network.js";
+import type { NetworkRequest } from "./network-types.js";
+/** Header list to a lower-cased record; repeated names are joined, base64 values decoded */
+export declare function headersFromBidi(headers: Header[]): Record<string, string>;
+/** A record of headers as the list BiDi commands take */
+export declare function headersToBidi(headers: Record<string, string>): Header[];
+/** A body as BiDi takes it: text as is, bytes as base64 */
+export declare function toBytes(data: string | Buffer): BytesValue;
+/** The request a `network.*` event describes */
+export declare function toRequest(data: RequestData, navigation: string | null, isBlocked: boolean, redirectedFrom: NetworkRequest | null): NetworkRequest;

package/dist/network/bidi-wire.js

@@ -0,0 +1,38 @@
+/** Header list to a lower-cased record; repeated names are joined, base64 values decoded */
+export function headersFromBidi(headers) {
+    const result = {};
+    for (const { name, value } of headers) {
+        const text = value.type === "base64"
+            ? Buffer.from(value.value, "base64").toString("utf8")
+            : value.value;
+        const key = name.toLowerCase();
+        result[key] = key in result ? `${result[key]}, ${text}` : text;
+    }
+    return result;
+}
+/** A record of headers as the list BiDi commands take */
+export function headersToBidi(headers) {
+    return Object.entries(headers).map(([name, value]) => ({
+        name,
+        value: { type: "string", value },
+    }));
+}
+/** A body as BiDi takes it: text as is, bytes as base64 */
+export function toBytes(data) {
+    return typeof data === "string"
+        ? { type: "string", value: data }
+        : { type: "base64", value: data.toString("base64") };
+}
+/** The request a `network.*` event describes */
+export function toRequest(data, navigation, isBlocked, redirectedFrom) {
+    return {
+        id: data.request,
+        url: data.url,
+        method: data.method,
+        headers: headersFromBidi(data.headers),
+        resourceType: data.destination || data.initiatorType || "other",
+        navigation,
+        redirectedFrom,
+        isBlocked,
+    };
+}

package/dist/network/intercept.d.ts

@@ -0,0 +1,30 @@
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+import type { BeforeRequestSentParameters } from "../types/bidi-modules/network.js";
+import { type UrlPattern } from "./url-match.js";
+/**
+ * Keeps one browser-side `network.addIntercept` equal to a page's routes: none, one for everything, or one for
+ * the exact URLs the routes name. Changes are queued, so two `sync` calls never overlap. Requests the intercept
+ * holds are handed to `onBlocked`.
+ */
+export declare class Intercept {
+    private connector;
+    private contextId;
+    private onBlocked;
+    private queue;
+    private ids;
+    private currentKey;
+    private currentId;
+    private subscription;
+    constructor(connector: BiDiConnector, contextId: string, onBlocked: (params: BeforeRequestSentParameters) => void);
+    /** Whether one of `intercepts` is ours: a request held by someone else's intercept is not for us */
+    holds(intercepts: readonly string[] | undefined): boolean;
+    /** Makes the browser-side intercept match the routes' patterns, after the changes queued before this one */
+    sync(patterns: readonly UrlPattern[]): Promise<void>;
+    private apply;
+    /** The exact URLs to block, or undefined to block everything and match in the router */
+    private urlPatterns;
+    private addIntercept;
+    private removeIntercept;
+    private listen;
+    private stop;
+}

package/dist/network/intercept.js

@@ -0,0 +1,130 @@
+import { BiDiError } from "../transport/bidi-error.js";
+import { isExactString } from "./url-match.js";
+/** Whether a browser accepts `urlPatterns` in `network.addIntercept`; asked once per connection */
+const patternsUnsupported = new WeakSet();
+/**
+ * Keeps one browser-side `network.addIntercept` equal to a page's routes: none, one for everything, or one for
+ * the exact URLs the routes name. Changes are queued, so two `sync` calls never overlap. Requests the intercept
+ * holds are handed to `onBlocked`.
+ */
+export class Intercept {
+    constructor(connector, contextId, onBlocked) {
+        this.connector = connector;
+        this.contextId = contextId;
+        this.onBlocked = onBlocked;
+        this.queue = Promise.resolve();
+        this.ids = new Set();
+    }
+    /** Whether one of `intercepts` is ours: a request held by someone else's intercept is not for us */
+    holds(intercepts) {
+        return (intercepts ?? []).some((id) => this.ids.has(id));
+    }
+    /** Makes the browser-side intercept match the routes' patterns, after the changes queued before this one */
+    sync(patterns) {
+        const run = this.queue.then(() => this.apply(patterns));
+        this.queue = run.catch(() => undefined);
+        return run;
+    }
+    async apply(routePatterns) {
+        if (routePatterns.length === 0)
+            return this.stop();
+        await this.listen();
+        const patterns = this.urlPatterns(routePatterns);
+        const key = patterns ? JSON.stringify(patterns) : "all";
+        if (key === this.currentKey)
+            return;
+        const id = await this.addIntercept(patterns);
+        const previous = this.currentId;
+        this.currentId = id;
+        this.currentKey =
+            patterns && !patternsUnsupported.has(this.connector) ? key : "all";
+        this.ids.add(id);
+        // The new intercept is in place before the old one goes: nothing slips through in between
+        if (previous !== undefined)
+            await this.removeIntercept(previous);
+    }
+    /** The exact URLs to block, or undefined to block everything and match in the router */
+    urlPatterns(routePatterns) {
+        if (patternsUnsupported.has(this.connector))
+            return undefined;
+        const patterns = [];
+        for (const pattern of routePatterns) {
+            // The browser reads a URL string in normal form; anything else could mean something else to it
+            if (!isExactString(pattern) || !isNormalUrl(pattern))
+                return undefined;
+            if (!patterns.some((existing) => existing.type === "string" && existing.pattern === pattern)) {
+                patterns.push({ type: "string", pattern });
+            }
+        }
+        return patterns;
+    }
+    async addIntercept(patterns) {
+        const params = {
+            phases: ["beforeRequestSent"],
+            contexts: [this.contextId],
+        };
+        try {
+            const { intercept } = await this.connector.send("network.addIntercept", {
+                ...params,
+                ...(patterns && { urlPatterns: patterns }),
+            });
+            return intercept;
+        }
+        catch (err) {
+            if (patterns &&
+                err instanceof BiDiError &&
+                err.code === "invalid argument") {
+                patternsUnsupported.add(this.connector);
+                return this.addIntercept(undefined);
+            }
+            throw err;
+        }
+    }
+    async removeIntercept(id) {
+        try {
+            await this.connector.send("network.removeIntercept", { intercept: id });
+        }
+        catch (err) {
+            if (!(err instanceof BiDiError && err.code === "no such intercept"))
+                throw err;
+        }
+        finally {
+            this.ids.delete(id);
+        }
+    }
+    async listen() {
+        if (this.subscription)
+            return;
+        this.connector.onEvent("network.beforeRequestSent", this.onBlocked);
+        try {
+            this.subscription = await this.connector.subscribe([
+                "network.beforeRequestSent",
+            ]);
+        }
+        catch (err) {
+            this.connector.offEvent("network.beforeRequestSent", this.onBlocked);
+            throw err;
+        }
+    }
+    async stop() {
+        const id = this.currentId;
+        this.currentId = undefined;
+        this.currentKey = undefined;
+        if (id !== undefined)
+            await this.removeIntercept(id);
+        if (this.subscription) {
+            this.connector.offEvent("network.beforeRequestSent", this.onBlocked);
+            const subscription = this.subscription;
+            this.subscription = undefined;
+            await subscription.unsubscribe();
+        }
+    }
+}
+function isNormalUrl(value) {
+    try {
+        return new URL(value).href === value;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/network/network-tracker.d.ts

@@ -1,47 +1,12 @@
 import type { ContextTree } from "../browser/context-tree.js";
 import type { BiDiConnector } from "../transport/bidi-connection.js";
-import type { Header, RequestData } from "../types/bidi-modules/network.js";
-import { WaitTimeoutError } from "../wait/wait-until.js";
-export interface NetworkRequest {
-    /** The browser's id; the same for every hop of a redirect chain */
-    id: string;
-    url: string;
-    method: string;
-    /** Header names lower-cased; repeated headers joined with ", " */
-    headers: Record<string, string>;
-    /** "document", "script", "image", …; falls back to the initiator type, then "other" */
-    resourceType: string;
-    navigation: string | null;
-    /** The request this one is the redirect of, or null */
-    redirectedFrom: NetworkRequest | null;
-    /** True while a network intercept holds it */
-    isBlocked: boolean;
-}
-export interface NetworkResponse {
-    url: string;
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    fromCache: boolean;
-    request: NetworkRequest;
-}
-export type FailedRequest = NetworkRequest & {
-    errorText: string;
-};
-interface EventMap {
-    request: [NetworkRequest];
-    response: [NetworkResponse];
-    requestfailed: [FailedRequest];
-}
-export type NetworkEventName = keyof EventMap;
+import { type EventMap, type NetworkEventName, type NetworkRequest } from "./network-types.js";
+export type { FailedRequest, NetworkEventName, NetworkRequest, NetworkResponse, } from "./network-types.js";
+export { NetworkIdleTimeoutError } from "./network-wait.js";
 export interface TrackerOptions {
     /** Requests it returns true for are neither counted nor emitted. Default: none */
     ignore?: (request: NetworkRequest) => boolean;
 }
-/** waitForIdle ran out of time with requests still in flight; `last` holds (up to five of) their URLs */
-export declare class NetworkIdleTimeoutError extends WaitTimeoutError<string[]> {
-    constructor(timeout: number, inflight: number, urls: string[]);
-}
 /**
  * Follows the network activity of one page (its frames included): which requests are in flight,
  * and `request` / `response` / `requestfailed` events. In-flight is keyed by `request id:redirect count`,
@@ -53,20 +18,22 @@ export declare class NetworkTracker {
     private ignore;
     private connector;
     private events;
-    private active;
-    /** The context each request in flight belongs to, by the same key */
-    private contexts;
-    /** Requests that may still be the source of a redirect, by hop key */
+    private subscription;
+    /**
+     * Every hop that is in flight or may still be the source of a redirect, by hop key. A redirect response ends a
+     * hop's flight (`live` false) but keeps it, for the next hop's `redirectedFrom`.
+     */
     private hops;
+    /** Rejects a pending `waitForIdle`; each wait adds its own */
     private waiters;
     private disposed;
     private constructor();
     static start(connector: BiDiConnector, tree: ContextTree, contextId: string, options?: TrackerOptions): Promise<NetworkTracker>;
-    private subscription;
     /** Requests currently in flight */
     get inflight(): number;
     /** URLs of the requests currently in flight, oldest first */
     get inflightUrls(): string[];
+    private liveHops;
     /** Waits that have not finished yet */
     get waiting(): number;
     on<E extends NetworkEventName>(event: E, listener: (...args: EventMap[E]) => void): void;
@@ -95,7 +62,3 @@ export declare class NetworkTracker {
     /** A listener that throws must not stop the tracker or the other listeners */
     private emit;
 }
-export declare function toRequest(data: RequestData, navigation: string | null, isBlocked: boolean, redirectedFrom: NetworkRequest | null): NetworkRequest;
-/** Header list to a lower-cased record; repeated names are joined, base64 values decoded */
-export declare function toHeaders(headers: Header[]): Record<string, string>;
-export {};