@itmetsam/samurai-framework 0.8.0 → 0.10.0

package/dist/cli/console-reporter.js

@@ -2,16 +2,19 @@ const seconds = (ms) => `${(ms / 1000).toFixed(1)}s`;
 /** Prints a run for a person: one line per test as it ends, then every failure in full and a count */
 export class ConsoleReporter {
     constructor({ write, color }) {
+        /** Whether the run has more than one browser: only then is each test labelled with its browser */
+        this.labelled = false;
         this.write = write;
         this.paint = (code, text) => color ? `\u001b[${code}m${text}\u001b[0m` : text;
     }
     handle(event) {
         switch (event.type) {
             case "run-start":
-                this.write(`Running ${event.total} ${event.total === 1 ? "test" : "tests"} against ${event.environment}\n`);
+                this.labelled = event.browsers.length > 1;
+                this.write(`Running ${event.total} ${event.total === 1 ? "test" : "tests"} against ${event.environment}${this.labelled ? ` in ${event.browsers.join(", ")}` : ""}\n`);
                 return;
             case "test-end":
-                this.write(`  ${this.line(event.name, event.result)}\n`);
+                this.write(`  ${this.line(event.name, event.result, event.browser)}\n`);
                 return;
             case "run-end":
                 this.summary(event.summary);
@@ -20,13 +23,17 @@ export class ConsoleReporter {
                 return;
         }
     }
-    line(name, result) {
+    /** ` [chrome]` in a run with more than one browser, else nothing */
+    tag(browser) {
+        return this.labelled ? ` ${this.paint(90, `[${browser}]`)}` : "";
+    }
+    line(name, result, browser) {
         const took = "duration" in result
             ? ` ${this.paint(90, `(${seconds(result.duration)})`)}`
             : "";
         return result.status === "success"
-            ? `${this.paint(32, "✔")} ${name}${took}`
-            : `${this.paint(31, "✖")} ${name}${took}`;
+            ? `${this.paint(32, "✔")} ${name}${this.tag(browser)}${took}`
+            : `${this.paint(31, "✖")} ${name}${this.tag(browser)}${took}`;
     }
     summary(summary) {
         const failed = summary.tests.filter((test) => test.status !== "success");
@@ -34,7 +41,7 @@ export class ConsoleReporter {
             if (!("name" in test))
                 continue;
             const message = "message" in test ? test.message : "did not finish";
-            this.write(`\n${this.paint(31, `${test.name}`)}\n`);
+            this.write(`\n${this.paint(31, `${test.name}`)}${"browser" in test ? this.tag(test.browser) : ""}\n`);
             this.write(`${message
                 .split("\n")
                 .map((line) => `    ${line}`)

package/dist/cli/init.js

@@ -23,7 +23,7 @@ export function scaffold(name) {
 
 export default defineConfig({
   srcDir: "./tests",
-  browser: "firefox",
+  browsers: ["firefox"],
   timeout: 30000,
   environments: {
     local: { baseURL: "http://localhost:3000" },

package/dist/cli/main.d.ts

@@ -1,4 +1,4 @@
-export declare const USAGE = "samurai: browser tests over WebDriver BiDi\n\nUsage:\n  samurai run [options]       Run the tests (the default command)\n  samurai list [options]      List the tests without running them\n  samurai record <spec>       Open a browser and record what you do into a spec file\n  samurai init [folder]       Scaffold a project: config, an example test, .env.example\n  samurai flow <command>      List, check and run the flows in ./flows (see below)\n  samurai browsers [command]  List, install and remove the browsers SAMURAI launches\n\nOptions for run and list:\n  --env <name>                Environment to run against (or SAMURAI_ENV)\n  --file <spec>               Only this spec file; repeatable\n  --grep <text>               Only tests whose full name contains the text\n  --group <name>              Only the tests of this group of the config's groups\n  --json                      Machine-readable output: JSON lines for run, one array for list\n\nOptions for run:\n  --timeout <ms>              Time one test may take\n  --expect-timeout <ms>       Time actions and assertions retry\n  --headless, --no-headless   Run the browser without a window, or with one.\n                              Default: the config's use.headless, else headless when CI is set\n  --port <n>                  Browser debugging port (default 9223)\n\nOptions for record (also --env, --port, --json, --headless, --no-headless):\n  --new <title>               Add a test with this title (creates the spec file if needed)\n  --test <name|index>         Record into this test; not needed when the file has one\n  --at <n>                    Insert from step n (default: after the last step)\n  --url <url>                 Page to start on (default: the environment's baseURL)\n  Stop with Ctrl+C or by closing the browser window.\n\n  -h, --help                  Show this help\n  -v, --version               Show the version\n\nExit code: 0 when every test passed, 1 when a test failed, 2 for a usage or configuration error.\n\nsamurai flow:\n  list                        The flows in ./flows\n  check [<flow>...]           Check flows without running them\n  run <flow>... | --all       Run flows; each writes result/flows/<id>.json\n  Options for run: --env, --headless, --timeout, --expect-timeout, --port, --json, --allow-unsupported\n  Run `samurai flow` alone for the details.\n\nsamurai browsers:\n  list                        The pinned browsers and every build in the cache (the default)\n  install [firefox|chrome|all]\n                              Download the pinned builds (default: all)\n  uninstall <name> [--build <id>] | --unused\n\nRun it in the project folder, the one holding samurai.config.ts.\n";
+export declare const USAGE = "samurai: browser tests over WebDriver BiDi\n\nUsage:\n  samurai run [options]       Run the tests (the default command)\n  samurai list [options]      List the tests without running them\n  samurai record <spec>       Open a browser and record what you do into a spec file\n  samurai init [folder]       Scaffold a project: config, an example test, .env.example\n  samurai flow <command>      List, check and run the flows in ./flows (see below)\n  samurai browsers [command]  List, install and remove the browsers SAMURAI launches\n\nOptions for run and list:\n  --env <name>                Environment to run against (or SAMURAI_ENV)\n  --file <spec>               Only this spec file; repeatable\n  --grep <text>               Only tests whose full name contains the text\n  --group <name>              Only the tests of this group of the config's groups\n  --browser <name>            Run in this browser (firefox or chrome) instead of the config's\n                              browsers; repeat it for more than one\n  --json                      Machine-readable output: JSON lines for run, one array for list\n\nOptions for run:\n  --timeout <ms>              Time one test may take\n  --expect-timeout <ms>       Time actions and assertions retry\n  --headless, --no-headless   Run the browser without a window, or with one.\n                              Default: the config's use.headless, else headless when CI is set\n  --port <n>                  Browser debugging port (default 9223)\n\nOptions for record (also --env, --port, --json, --headless, --no-headless):\n  --browser <name>            Record in this browser (default: the first of the config's browsers)\n  --new <title>               Add a test with this title (creates the spec file if needed)\n  --test <name|index>         Record into this test; not needed when the file has one\n  --at <n>                    Insert from step n (default: after the last step)\n  --url <url>                 Page to start on (default: the environment's baseURL)\n  Stop with Ctrl+C or by closing the browser window.\n\n  -h, --help                  Show this help\n  -v, --version               Show the version\n\nExit code: 0 when every test passed, 1 when a test failed, 2 for a usage or configuration error.\n\nsamurai flow:\n  list                        The flows in ./flows\n  check [<flow>...]           Check flows without running them\n  run <flow>... | --all       Run flows; each writes result/flows/<id>.json\n  Options for run: --env, --headless, --timeout, --expect-timeout, --port, --json, --allow-unsupported\n  Run `samurai flow` alone for the details.\n\nsamurai browsers:\n  list                        The pinned browsers and every build in the cache (the default)\n  install [firefox|chrome|all]\n                              Download the pinned builds (default: all)\n  uninstall <name> [--build <id>] | --unused\n\nRun it in the project folder, the one holding samurai.config.ts.\n";
 export interface Io {
     out: (text: string) => void;
     err: (text: string) => void;

package/dist/cli/main.js

@@ -22,6 +22,8 @@ Options for run and list:
   --file <spec>               Only this spec file; repeatable
   --grep <text>               Only tests whose full name contains the text
   --group <name>              Only the tests of this group of the config's groups
+  --browser <name>            Run in this browser (firefox or chrome) instead of the config's
+                              browsers; repeat it for more than one
   --json                      Machine-readable output: JSON lines for run, one array for list
 
 Options for run:
@@ -32,6 +34,7 @@ Options for run:
   --port <n>                  Browser debugging port (default 9223)
 
 Options for record (also --env, --port, --json, --headless, --no-headless):
+  --browser <name>            Record in this browser (default: the first of the config's browsers)
   --new <title>               Add a test with this title (creates the spec file if needed)
   --test <name|index>         Record into this test; not needed when the file has one
   --at <n>                    Insert from step n (default: after the last step)
@@ -99,6 +102,8 @@ export async function main(argv, io) {
             if (at !== undefined && (!Number.isInteger(at) || at < 0))
                 throw new Error(`--at must be a step number, got "${values.at}"`);
             const flags = parseRunnerFlags(rest);
+            if (flags.browsers && flags.browsers.length > 1)
+                throw new Error("--browser: a recording uses one browser");
             const test = values.test === undefined
                 ? undefined
                 : /^\d+$/.test(values.test)
@@ -116,6 +121,7 @@ export async function main(argv, io) {
                 ...(values.url !== undefined && { url: values.url }),
                 ...(flags.headless !== undefined && { headless: flags.headless }),
                 ...(flags.port !== undefined && { port: flags.port }),
+                ...(flags.browsers && { browser: flags.browsers[0] }),
                 ...(io.signal && { signal: io.signal }),
                 onStarted: () => {
                     if (!values.json)
@@ -178,6 +184,7 @@ export async function main(argv, io) {
             ...(flags.grep !== undefined && { grep: flags.grep }),
             ...(flags.group !== undefined && { group: flags.group }),
             ...(flags.files && { files: flags.files }),
+            ...(flags.browsers && { browsers: flags.browsers }),
         };
         if (command === "list") {
             const tests = await listTests(options);

package/dist/config/config.js

@@ -1,6 +1,7 @@
 import path from "path";
 import logger from "../logger/index.js";
 import { pathToFileURL } from "url";
+import { validateBrowserConfig } from "../runner/browsers.js";
 let activeProject;
 /** Makes `project` the one config, secrets, reports and downloads are resolved for; `undefined` ends it */
 export function setActiveProject(project) {
@@ -22,14 +23,17 @@ export function browsersDir() {
 }
 /** The whole `samurai.config.ts` of the project (the working directory unless a project is active) */
 export async function loadConfig() {
-    if (activeProject?.config)
+    if (activeProject?.config) {
+        validateBrowserConfig(activeProject.config);
         return activeProject.config;
+    }
     const configUrl = path.join(projectDir(), "samurai.config.ts");
     logger.debug("Reading config from: %s", configUrl);
     const config = (await import(pathToFileURL(configUrl).href));
     if (!config.default) {
         throw new Error("samurai.config.ts does not export defineConfig as default!");
     }
+    validateBrowserConfig(config.default);
     return config.default;
 }
 /** A project's config without keeping the project active (`withProject` is one at a time): the given one, else its samurai.config.ts */

package/dist/flows/run/handlers/support.d.ts

@@ -1,5 +1,6 @@
 import { type AnyNodeDefinition, type ExpressionContext, type FlowFile, type FlowNodeModel } from "../../core/index.js";
 import type { RunEvent } from "../../../runner/reporter.js";
+import type { SupportedBrowser } from "../../../types/browser.js";
 import type { NodeResult, NodeTest } from "../events.js";
 /** What a handler can use of the run */
 export interface HandlerRun {
@@ -10,8 +11,10 @@ export interface HandlerRun {
     };
     context: ExpressionContext;
     nodeTests: Record<string, NodeTest[]>;
+    /** The browsers of the nodes that have their own (a Group node's group); the others use the project's */
+    nodeBrowsers?: Record<string, SupportedBrowser[]>;
     signal: AbortSignal;
-    runTests: (tests: NodeTest[], onEvent: (e: RunEvent) => void) => Promise<"passed" | "failed" | "cancelled">;
+    runTests: (tests: NodeTest[], onEvent: (e: RunEvent) => void, browsers?: SupportedBrowser[]) => Promise<"passed" | "failed" | "cancelled">;
     sleep: (ms: number, signal: AbortSignal) => Promise<void>;
     onTestEvent: (nodeId: string, e: RunEvent) => void;
     /** Definitions of kinds core doesn't have (steps), for expression scopes */

package/dist/flows/run/handlers/support.js

@@ -7,7 +7,7 @@ export const fail = (e) => ({
 export async function runNodeTests(node, run, list) {
     let result;
     try {
-        result = await run.runTests(list, (e) => run.onTestEvent(node.id, e));
+        result = await run.runTests(list, (e) => run.onTestEvent(node.id, e), run.nodeBrowsers?.[node.id]);
     }
     catch (e) {
         return fail(e);

package/dist/flows/run/project.js

@@ -109,6 +109,7 @@ export async function runFlowInProject(options) {
     // Phase 3: walk it
     const byId = new Map(tests.map((t) => [t.id, t]));
     const nodeTests = {};
+    const nodeBrowsers = {};
     for (const node of flow.nodes) {
         const ids = node.kind === "test"
             ? [node.ref?.testId ?? ""]
@@ -117,6 +118,11 @@ export async function runFlowInProject(options) {
                 : undefined;
         if (!ids)
             continue;
+        if (node.kind === "group") {
+            const browsers = groups.find((g) => g.name === node.ref?.group)?.browsers;
+            if (browsers)
+                nodeBrowsers[node.id] = browsers;
+        }
         nodeTests[node.id] = ids.flatMap((id) => {
             const t = byId.get(id);
             return t ? [{ file: t.file, name: t.name }] : [];
@@ -126,6 +132,7 @@ export async function runFlowInProject(options) {
     return runFlow({
         flow,
         nodeTests,
+        nodeBrowsers,
         environment,
         ...(options.signal && { signal: options.signal }),
         ...(options.onEvent && { onEvent: options.onEvent }),
@@ -133,7 +140,7 @@ export async function runFlowInProject(options) {
         unsupported,
         handlers: { ...HANDLERS, ...steps.handlers },
         nodes: steps.nodes,
-        runTests: async ({ tests, onEvent, signal }) => {
+        runTests: async ({ tests, onEvent, signal, browsers }) => {
             const summary = await run({
                 projectDir,
                 config,
@@ -148,6 +155,7 @@ export async function runFlowInProject(options) {
                     expectTimeout: options.expectTimeout,
                 }),
                 ...(options.port !== undefined && { port: options.port }),
+                ...(browsers && { browsers }),
                 files: [...new Set(tests.map((t) => t.file))],
                 testNames: tests.map((t) => t.name),
                 reportPath: false,

package/dist/flows/run/run.d.ts

@@ -2,10 +2,13 @@ import { type AnyNodeDefinition, type FlowFile } from "../core/index.js";
 import type { RunEvent } from "../../runner/reporter.js";
 import type { FlowEvent, FlowSummary, NodeTest } from "./events.js";
 import { type Handler } from "./handlers/index.js";
+import type { SupportedBrowser } from "../../types/browser.js";
 export interface RunFlowOptions {
     flow: FlowFile;
     /** The tests of each Test and Group node, by node id */
     nodeTests: Record<string, NodeTest[]>;
+    /** The browsers a Group node runs in (its group's); a node not listed uses the project's */
+    nodeBrowsers?: Record<string, SupportedBrowser[]>;
     environment: {
         name: string;
         variables: Record<string, string | number | boolean>;
@@ -20,6 +23,8 @@ export interface RunFlowOptions {
         tests: NodeTest[];
         onEvent: (e: RunEvent) => void;
         signal: AbortSignal;
+        /** Set for a node that runs in browsers of its own */
+        browsers?: SupportedBrowser[];
     }) => Promise<"passed" | "failed" | "cancelled">;
     sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
     /**

package/dist/flows/run/run.js

@@ -65,9 +65,15 @@ export async function runFlow(options) {
         environment: options.environment,
         context,
         nodeTests: options.nodeTests,
+        ...(options.nodeBrowsers && { nodeBrowsers: options.nodeBrowsers }),
         signal,
         sleep: options.sleep ?? defaultSleep,
-        runTests: (tests, onTestEvent) => options.runTests({ tests, onEvent: onTestEvent, signal }),
+        runTests: (tests, onTestEvent, browsers) => options.runTests({
+            tests,
+            onEvent: onTestEvent,
+            signal,
+            ...(browsers && { browsers }),
+        }),
         onTestEvent: (nodeId, event) => onEvent({ type: "test", nodeId, event }),
         nodes,
         log: (nodeId, level, text) => logger[level](`[${nodeId}] ${text}`),

package/dist/locator/locator.js

@@ -88,6 +88,16 @@ const NAMED_KEYS = {
 };
 /** Unicode code point WebDriver uses for the Backspace key */
 const BACKSPACE = "";
+/**
+ * Chrome answers a command sent while the page swaps documents with an unknown error that says the context
+ * is gone for the moment; the same call a moment later works.
+ */
+const DOCUMENT_SWAP = /Cannot find context with specified id|execution contexts? (was |were )?(cleared|destroyed)/i;
+function isDocumentSwap(err) {
+    return (err instanceof BiDiError &&
+        err.code === "unknown error" &&
+        DOCUMENT_SWAP.test(err.message));
+}
 export default class Locator {
     /**
      * `selector` is an xpath, or a chain of selector steps that each search inside the previous step's matches.
@@ -216,7 +226,15 @@ export default class Locator {
                 nodes = picked ? [picked] : [];
             }
             else {
-                nodes = await this.locateStep(selector, index > 0, nodes, index === this.chain.length - 1 ? max : undefined);
+                try {
+                    nodes = await this.locateStep(selector, index > 0, nodes, index === this.chain.length - 1 ? max : undefined);
+                }
+                catch (err) {
+                    // The page is swapping documents: nothing matches right now, and the waits that poll try again
+                    if (isDocumentSwap(err))
+                        return [];
+                    throw err;
+                }
             }
             if (nodes.length === 0)
                 return [];
@@ -335,7 +353,8 @@ export default class Locator {
         }
         catch (err) {
             // The document changed between the search and the probe
-            if (err instanceof BiDiError && err.code === "no such node")
+            if ((err instanceof BiDiError && err.code === "no such node") ||
+                isDocumentSwap(err))
                 return DETACHED_STATE;
             throw err;
         }

package/dist/network/data-collector.d.ts

@@ -12,6 +12,7 @@ export declare class ResponseBodyUnavailableError extends Error {
 export declare class DataCollector {
     private connector;
     private id;
+    private maxBodySize;
     private disposed;
     private constructor();
     static start(connector: BiDiConnector, contextId: string, options?: {

package/dist/network/data-collector.js

@@ -1,6 +1,12 @@
 import { BiDiError } from "../transport/bidi-error.js";
 /** How large a response body may be to be kept: 10 MiB */
 const DEFAULT_MAX_BODY_SIZE = 10 * 1024 * 1024;
+/**
+ * Chrome counts the headers of a response in the size it compares with the collector's limit (a 14-byte body
+ * arrives as about 200 bytes), Firefox counts the body. Chrome's limit is raised by this much and the body is
+ * measured after it is read.
+ */
+const CHROME_HEADER_ALLOWANCE = 64 * 1024;
 /** The body of a response cannot be read */
 export class ResponseBodyUnavailableError extends Error {
     constructor(url, reason) {
@@ -15,18 +21,22 @@ export class ResponseBodyUnavailableError extends Error {
  * started. This registers one for a page and reads bodies through it.
  */
 export class DataCollector {
-    constructor(connector, id) {
+    constructor(connector, id, maxBodySize) {
         this.connector = connector;
         this.id = id;
+        this.maxBodySize = maxBodySize;
         this.disposed = false;
     }
     static async start(connector, contextId, options = {}) {
+        const maxBodySize = options.maxBodySize ?? DEFAULT_MAX_BODY_SIZE;
         const { collector } = await connector.send("network.addDataCollector", {
             dataTypes: ["response"],
-            maxEncodedDataSize: options.maxBodySize ?? DEFAULT_MAX_BODY_SIZE,
+            maxEncodedDataSize: connector.browserName === "chrome"
+                ? maxBodySize + CHROME_HEADER_ALLOWANCE
+                : maxBodySize,
             contexts: [contextId],
         });
-        return new DataCollector(connector, collector);
+        return new DataCollector(connector, collector, maxBodySize);
     }
     /** The body of the response to request `requestId`; `url` only names it in errors */
     async read(requestId, url) {
@@ -36,7 +46,13 @@ export class DataCollector {
                 request: requestId,
                 collector: this.id,
             });
-            return bytes.type === "base64" ? Buffer.from(bytes.value, "base64") : Buffer.from(bytes.value, "utf8");
+            const body = bytes.type === "base64"
+                ? Buffer.from(bytes.value, "base64")
+                : Buffer.from(bytes.value, "utf8");
+            if (body.length > this.maxBodySize) {
+                throw new ResponseBodyUnavailableError(url, `the response is larger than maxBodySize (${this.maxBodySize} bytes)`);
+            }
+            return body;
         }
         catch (err) {
             if (err instanceof BiDiError && err.code === "no such network data") {
@@ -67,7 +83,9 @@ export class DataCollector {
             return;
         this.disposed = true;
         try {
-            await this.connector.send("network.removeDataCollector", { collector: this.id });
+            await this.connector.send("network.removeDataCollector", {
+                collector: this.id,
+            });
         }
         catch (err) {
             if (!(err instanceof BiDiError && err.code === "no such network collector"))

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

@@ -54,6 +54,8 @@ export declare class NetworkTracker {
     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 hops;
     private waiters;
@@ -73,7 +75,7 @@ export declare class NetworkTracker {
      * Resolves once no request has been in flight for `idleTime` ms. A quiet page resolves after `idleTime`.
      * Rejects with NetworkIdleTimeoutError after `timeout` ms, or with "page closed" when disposed.
      */
-    waitForIdle({ idleTime, timeout }: {
+    waitForIdle({ idleTime, timeout, }: {
         idleTime: number;
         timeout: number;
     }): Promise<void>;
@@ -85,6 +87,11 @@ export declare class NetworkTracker {
     private onBeforeRequestSent;
     private onResponseCompleted;
     private onFetchError;
+    /**
+     * A document replaced another: the requests of the old one that are still in flight are over. Firefox reports each
+     * as failed (NS_BINDING_ABORTED); Chrome says nothing, which would keep the page "busy" for good.
+     */
+    private onNavigationCommitted;
     /** A listener that throws must not stop the tracker or the other listeners */
     private emit;
 }

package/dist/network/network-tracker.js

@@ -1,6 +1,8 @@
 import EventEmitter from "node:events";
 import logger from "../logger/index.js";
 import { WaitTimeoutError } from "../wait/wait-until.js";
+/** The error text of a request that the page left before it finished, when the browser says none */
+const ABORTED_BY_NAVIGATION = "aborted by navigation";
 /** How many URLs a timeout message names */
 const URLS_IN_MESSAGE = 5;
 /** waitForIdle ran out of time with requests still in flight; `last` holds (up to five of) their URLs */
@@ -24,6 +26,8 @@ export class NetworkTracker {
         this.connector = connector;
         this.events = new EventEmitter();
         this.active = new Map();
+        /** The context each request in flight belongs to, by the same key */
+        this.contexts = new Map();
         /** Requests that may still be the source of a redirect, by hop key */
         this.hops = new Map();
         this.waiters = new Set();
@@ -41,6 +45,8 @@ export class NetworkTracker {
                 return;
             this.hops.set(key, request);
             this.active.set(key, request.url);
+            if (params.context)
+                this.contexts.set(key, params.context);
             this.emit("request", request);
             this.events.emit("change");
         };
@@ -51,6 +57,7 @@ export class NetworkTracker {
             const request = this.hops.get(key);
             if (!this.active.delete(key) || !request)
                 return;
+            this.contexts.delete(key);
             const { response } = params;
             // A redirect response keeps its request around: the next hop links back to it
             if (response.status < 300 || response.status >= 400)
@@ -72,10 +79,34 @@ export class NetworkTracker {
             const request = this.hops.get(key);
             if (!this.active.delete(key) || !request)
                 return;
+            this.contexts.delete(key);
             this.hops.delete(key);
             this.emit("requestfailed", Object.assign(request, { errorText: params.errorText }));
             this.events.emit("change");
         };
+        /**
+         * A document replaced another: the requests of the old one that are still in flight are over. Firefox reports each
+         * as failed (NS_BINDING_ABORTED); Chrome says nothing, which would keep the page "busy" for good.
+         */
+        this.onNavigationCommitted = (params) => {
+            if (!this.owns(params.context))
+                return;
+            let changed = false;
+            for (const [key, requestContext] of [...this.contexts]) {
+                const request = this.hops.get(key);
+                if (!request || request.navigation === params.navigation)
+                    continue;
+                if (!this.tree.isWithin(requestContext, params.context))
+                    continue;
+                this.contexts.delete(key);
+                this.active.delete(key);
+                this.hops.delete(key);
+                this.emit("requestfailed", Object.assign(request, { errorText: ABORTED_BY_NAVIGATION }));
+                changed = true;
+            }
+            if (changed)
+                this.events.emit("change");
+        };
     }
     static async start(connector, tree, contextId, options = {}) {
         const tracker = new NetworkTracker(tree, contextId, options.ignore ?? (() => false), connector);
@@ -83,11 +114,13 @@ export class NetworkTracker {
         connector.onEvent("network.beforeRequestSent", tracker.onBeforeRequestSent);
         connector.onEvent("network.responseCompleted", tracker.onResponseCompleted);
         connector.onEvent("network.fetchError", tracker.onFetchError);
+        connector.onEvent("browsingContext.navigationCommitted", tracker.onNavigationCommitted);
         try {
             tracker.subscription = await connector.subscribe([
                 "network.beforeRequestSent",
                 "network.responseCompleted",
                 "network.fetchError",
+                "browsingContext.navigationCommitted",
             ]);
         }
         catch (err) {
@@ -118,10 +151,12 @@ export class NetworkTracker {
      * Resolves once no request has been in flight for `idleTime` ms. A quiet page resolves after `idleTime`.
      * Rejects with NetworkIdleTimeoutError after `timeout` ms, or with "page closed" when disposed.
      */
-    waitForIdle({ idleTime, timeout }) {
+    waitForIdle({ idleTime, timeout, }) {
         return new Promise((resolve, reject) => {
             let idleTimer;
-            const waiter = { reject: (reason) => finish(() => reject(reason)) };
+            const waiter = {
+                reject: (reason) => finish(() => reject(reason)),
+            };
             const finish = (settle) => {
                 clearTimeout(idleTimer);
                 clearTimeout(deadline);
@@ -147,6 +182,7 @@ export class NetworkTracker {
         this.disposed = true;
         this.removeListeners();
         this.active.clear();
+        this.contexts.clear();
         this.hops.clear();
         [...this.waiters].forEach((waiter) => waiter.reject(new Error("page closed")));
         await this.subscription?.unsubscribe();
@@ -155,6 +191,7 @@ export class NetworkTracker {
         this.connector.offEvent("network.beforeRequestSent", this.onBeforeRequestSent);
         this.connector.offEvent("network.responseCompleted", this.onResponseCompleted);
         this.connector.offEvent("network.fetchError", this.onFetchError);
+        this.connector.offEvent("browsingContext.navigationCommitted", this.onNavigationCommitted);
     }
     owns(context) {
         return context !== null && this.tree.isWithin(context, this.contextId);
@@ -190,7 +227,9 @@ export function toRequest(data, navigation, isBlocked, redirectedFrom) {
 export function toHeaders(headers) {
     const result = {};
     for (const { name, value } of headers) {
-        const text = value.type === "base64" ? Buffer.from(value.value, "base64").toString("utf8") : value.value;
+        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;
     }

package/dist/network/router.d.ts

@@ -35,6 +35,11 @@ interface RouteDeps {
     next: () => Promise<void>;
     /** Called once the route is answered, whichever way */
     settled: (route: Route) => void;
+    /**
+     * Whether a replaced body needs a `content-length` of its own. Firefox keeps the old one and cuts the new body
+     * off; Chrome sets the right one itself and hangs the request when it is given one.
+     */
+    sendsContentLength: boolean;
 }
 /**
  * A request the browser holds until it is answered. Answer it exactly once with `fulfill`, `continue`,