browser-debugger-cli 0.12.0 → 0.14.0

package/dist/connection/chromeIdentity.d.ts

@@ -49,12 +49,18 @@ export declare function waitForDevToolsEndpoint(logs: StartupLogs, isRunning: ()
  * Check that the Chrome answering on 127.0.0.1:<port> is the one just
  * launched, so bdg never drives another session's browser.
  *
+ * A Chrome that announced 127.0.0.1:<port> but does not answer yet (a slow
+ * start, its `/json/version` request timing out) is asked again until the
+ * deadline; only an answer from something else is a port conflict. A Chrome
+ * that fell back to [::1] is asked once: 127.0.0.1 is held by something else.
+ *
  * @param options - Chrome's log positions from before the launch, requested
  *   port (free on 127.0.0.1 and ::1 right before the launch), Chrome's PID and
- *   longest wait for its announcement
+ *   longest wait for its announcement and its answer
  * @throws ChromeLaunchError: CHROME_DIED_AFTER_LAUNCH if Chrome exits first;
  *   PORT_IN_USE if another browser or process answers on the port;
- *   CHROME_LAUNCH_FAILED if Chrome announced nothing and nothing answers
+ *   CHROME_LAUNCH_FAILED if Chrome announced nothing and nothing answers, or
+ *   announced the port but did not answer on it in time
  */
 export declare function verifyLaunchedChrome(options: {
     logs: StartupLogs;

package/dist/connection/chromeIdentity.js

@@ -18,8 +18,9 @@
  * before the launch, and a second listener is how a conflict shows.
  */
 import { createLogger } from '../ui/logging/index.js';
+import { chromeNotAnsweringReason, portTakenByReason } from '../ui/messages/chrome.js';
 import { delay } from '../utils/async.js';
-import { fetchBrowserWsUrl } from '../utils/http.js';
+import { CDP_HTTP_TIMEOUT_MS, fetchBrowserWsUrl, probeDevToolsEndpoint, } from '../utils/http.js';
 import { isProcessAlive } from '../utils/process.js';
 import { ChromeLaunchError } from './errors.js';
 import { acceptsConnections } from './portReservation.js';
@@ -29,6 +30,8 @@ const LISTENING_PATTERN = /^DevTools listening on (ws:\/\/\S+)/;
 /** How long to wait for Chrome to announce its endpoint after the port answered */
 const ENDPOINT_WAIT_MS = 10000;
 const ENDPOINT_POLL_MS = 50;
+/** Shortest wait for one answer, also when the deadline has passed */
+const MIN_ANSWER_WAIT_MS = 1000;
 const log = createLogger('chrome');
 /**
  * Find the endpoint Chrome announced in its output (the last announcement).
@@ -75,32 +78,75 @@ export async function waitForDevToolsEndpoint(logs, isRunning, timeoutMs = ENDPO
  * Check that the Chrome answering on 127.0.0.1:<port> is the one just
  * launched, so bdg never drives another session's browser.
  *
+ * A Chrome that announced 127.0.0.1:<port> but does not answer yet (a slow
+ * start, its `/json/version` request timing out) is asked again until the
+ * deadline; only an answer from something else is a port conflict. A Chrome
+ * that fell back to [::1] is asked once: 127.0.0.1 is held by something else.
+ *
  * @param options - Chrome's log positions from before the launch, requested
  *   port (free on 127.0.0.1 and ::1 right before the launch), Chrome's PID and
- *   longest wait for its announcement
+ *   longest wait for its announcement and its answer
  * @throws ChromeLaunchError: CHROME_DIED_AFTER_LAUNCH if Chrome exits first;
  *   PORT_IN_USE if another browser or process answers on the port;
- *   CHROME_LAUNCH_FAILED if Chrome announced nothing and nothing answers
+ *   CHROME_LAUNCH_FAILED if Chrome announced nothing and nothing answers, or
+ *   announced the port but did not answer on it in time
  */
 export async function verifyLaunchedChrome(options) {
-    const { logs, port, pid, timeoutMs } = options;
+    const { logs, port, pid, timeoutMs = ENDPOINT_WAIT_MS } = options;
+    const started = Date.now();
     const isRunning = () => isProcessAlive(pid);
     const endpoint = await waitForDevToolsEndpoint(logs, isRunning, timeoutMs);
-    if (!endpoint && !isRunning()) {
-        throw new ChromeLaunchError(`Chrome died immediately after launch (PID: ${pid})`, {
-            issue: { code: 'CHROME_DIED_AFTER_LAUNCH', context: { port, pid } },
-        });
-    }
+    if (!endpoint && !isRunning())
+        throw diedError(port, pid);
     if (!endpoint)
         return acceptUnannouncedChrome(logs, port);
     if (endpoint.port !== port) {
         throw portTakenError(port, `Chrome listens on port ${endpoint.port} instead`);
     }
-    const answering = await fetchBrowserWsUrl(port, log);
-    if (!answering || new URL(answering).pathname !== endpoint.browserPath) {
-        throw portTakenError(port, `another process answers on 127.0.0.1 (Chrome listens on ${endpoint.host})`);
+    const onLoopback = endpoint.host === '127.0.0.1';
+    const deadline = onLoopback ? started + timeoutMs : Date.now();
+    const answer = await waitForAnswer(port, deadline, isRunning);
+    if (answer.kind === 'devtools' && new URL(answer.wsUrl).pathname === endpoint.browserPath) {
+        log.debug(`Chrome on port ${port} is the launched one (${endpoint.browserPath})`);
+        return;
+    }
+    if (answer.kind === 'unreachable' && !isRunning())
+        throw diedError(port, pid);
+    if (answer.kind === 'unreachable' && onLoopback) {
+        throw slowStartError(port, Date.now() - started);
+    }
+    throw portTakenError(port, portTakenByReason(answerSource(answer), endpoint.host));
+}
+/**
+ * Ask 127.0.0.1:<port> for its DevTools version until something answers,
+ * Chrome exits or the deadline passes (at least once). Each request waits at
+ * most until the deadline (but at least MIN_ANSWER_WAIT_MS).
+ *
+ * @param port - Requested port
+ * @param deadline - Time (ms since epoch) to stop asking
+ * @param isRunning - Whether Chrome is still running
+ * @returns The first answer, or the last `unreachable` result
+ */
+async function waitForAnswer(port, deadline, isRunning) {
+    for (;;) {
+        const remaining = Math.max(deadline - Date.now(), MIN_ANSWER_WAIT_MS);
+        const timeoutMs = Math.min(CDP_HTTP_TIMEOUT_MS, remaining);
+        const answer = await probeDevToolsEndpoint(port, undefined, { timeoutMs });
+        if (answer.kind !== 'unreachable' || !isRunning() || Date.now() >= deadline)
+            return answer;
+        await delay(ENDPOINT_POLL_MS);
     }
-    log.debug(`Chrome on port ${port} is the launched one (${endpoint.browserPath})`);
+}
+/**
+ * What answered on 127.0.0.1:<port> instead of the launched Chrome.
+ *
+ * @param answer - The answer
+ * @returns A browser, another process, or nothing
+ */
+function answerSource(answer) {
+    if (answer.kind === 'devtools')
+        return 'browser';
+    return answer.kind === 'not-devtools' ? 'process' : 'nothing';
 }
 /**
  * Accept a Chrome that did not announce its endpoint, if a browser answers on
@@ -128,6 +174,32 @@ async function acceptUnannouncedChrome(logs, port) {
     }
     log.info(`Warning: ${missing}; using the browser on 127.0.0.1:${port}, which was free before the launch`);
 }
+/**
+ * The error for a Chrome that exited during the launch checks.
+ *
+ * @param port - Requested port
+ * @param pid - Chrome's PID
+ * @returns Launch error with the CHROME_DIED_AFTER_LAUNCH issue
+ */
+function diedError(port, pid) {
+    return new ChromeLaunchError(`Chrome died immediately after launch (PID: ${pid})`, {
+        issue: { code: 'CHROME_DIED_AFTER_LAUNCH', context: { port, pid } },
+    });
+}
+/**
+ * The error for a Chrome that announced the port but did not answer on it in
+ * time.
+ *
+ * @param port - Requested port
+ * @param waitedMs - How long bdg waited
+ * @returns Launch error with the CHROME_LAUNCH_FAILED issue
+ */
+function slowStartError(port, waitedMs) {
+    const reason = chromeNotAnsweringReason(port, waitedMs);
+    return new ChromeLaunchError(reason, {
+        issue: { code: 'CHROME_LAUNCH_FAILED', context: { port, reason } },
+    });
+}
 /**
  * The error for a port another process answers on.
  *

package/dist/connection/launcher.js

@@ -3,6 +3,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as chromeLauncher from 'chrome-launcher';
 import { BDG_CHROME_PREFS, DEFAULT_CDP_PORT, CHROME_PROFILE_DIR, DEFAULT_CHROME_LOG_LEVEL, DEFAULT_CHROME_HANDLE_SIGINT, } from '../constants.js';
+import { makeDirectory } from '../utils/directories.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { filterDefined } from '../utils/objects.js';
 import { isProcessAlive } from '../utils/process.js';
@@ -62,7 +63,7 @@ export async function launchChrome(options = {}) {
     const userDataDir = options.userDataDir ?? getPersistentUserDataDir(options.baseDir ?? options.sessionDir);
     if (!fs.existsSync(userDataDir)) {
         try {
-            fs.mkdirSync(userDataDir, { recursive: true });
+            makeDirectory(userDataDir);
         }
         catch (error) {
             throw new ChromeLaunchError(`Failed to create user data directory`, {
@@ -160,7 +161,7 @@ function getPersistentUserDataDir(baseDir) {
     const userDataDir = path.join(dir, CHROME_PROFILE_DIR);
     if (!fs.existsSync(userDataDir)) {
         try {
-            fs.mkdirSync(userDataDir, { recursive: true });
+            makeDirectory(userDataDir);
         }
         catch (error) {
             throw new ChromeLaunchError(`Failed to create user data directory`, {

package/dist/constants.d.ts

@@ -58,7 +58,8 @@ export declare const DOCKER_CHROME_FLAGS: string[];
  */
 export declare const BDG_CHROME_PREFS: Record<string, unknown>;
 /**
- * Maximum network requests to collect before dropping new requests
+ * Finished network requests kept: past this the oldest are dropped, so the
+ * newest are kept (requests in flight are never dropped)
  * Prevents memory issues in long-running sessions with high network activity
  */
 export declare const MAX_NETWORK_REQUESTS = 10000;
@@ -88,6 +89,24 @@ export declare const OBJECT_EXPANSION_FAILURE_THRESHOLD = 5;
  * Can be overridden with --max-body-size flag
  */
 export declare const MAX_RESPONSE_SIZE: number;
+/**
+ * Total size of the response bodies a session keeps (100MB)
+ * Past this the oldest bodies are replaced by a placeholder; their requests stay
+ */
+export declare const MAX_TOTAL_BODY_BYTES: number;
+/**
+ * Characters of one value `dom get --raw` and `dom eval` print (human output,
+ * and eval string results and outer HTML in JSON)
+ */
+export declare const MAX_VALUE_LENGTH = 20000;
+/**
+ * Characters of a console message text in human output (`console`, `peek`)
+ */
+export declare const MAX_CONSOLE_TEXT_LENGTH = 200;
+/**
+ * Characters of a console message text in JSON output (`console`, `peek`)
+ */
+export declare const MAX_CONSOLE_JSON_TEXT_LENGTH = 10000;
 /**
  * Total Chrome network buffer size (50MB)
  * Limits total memory used by Chrome for preserving network payloads
@@ -103,6 +122,15 @@ export declare const CHROME_NETWORK_BUFFER_PER_RESOURCE: number;
  * Limits size of POST body data included in requestWillBeSent notification
  */
 export declare const CHROME_POST_DATA_LIMIT: number;
+/** Matches `dom query` and `dom a11y query` list with `--json` and no `--limit` */
+export declare const QUERY_JSON_LIST_LIMIT = 100;
+/** Matches `dom layout` measures per command (the rest are counted as omitted) */
+export declare const LAYOUT_ELEMENT_LIMIT = 100;
+/**
+ * Requests listed in an action's result (a click that loads a page triggers
+ * its whole load); notable ones are kept before assets
+ */
+export declare const MAX_TRIGGERED_REQUESTS = 50;
 /**
  * Default page readiness timeout (2 seconds)
  * Maximum time to wait for page to be ready before proceeding

package/dist/constants.js

@@ -87,7 +87,8 @@ export const BDG_CHROME_PREFS = {
 // DATA COLLECTION LIMITS
 // ============================================================================
 /**
- * Maximum network requests to collect before dropping new requests
+ * Finished network requests kept: past this the oldest are dropped, so the
+ * newest are kept (requests in flight are never dropped)
  * Prevents memory issues in long-running sessions with high network activity
  */
 export const MAX_NETWORK_REQUESTS = 10000;
@@ -120,6 +121,27 @@ export const OBJECT_EXPANSION_FAILURE_THRESHOLD = 5;
  * Can be overridden with --max-body-size flag
  */
 export const MAX_RESPONSE_SIZE = 5 * 1024 * 1024; // 5MB
+/**
+ * Total size of the response bodies a session keeps (100MB)
+ * Past this the oldest bodies are replaced by a placeholder; their requests stay
+ */
+export const MAX_TOTAL_BODY_BYTES = 100 * 1024 * 1024;
+// ============================================================================
+// OUTPUT VALUE LIMITS (lifted by --full)
+// ============================================================================
+/**
+ * Characters of one value `dom get --raw` and `dom eval` print (human output,
+ * and eval string results and outer HTML in JSON)
+ */
+export const MAX_VALUE_LENGTH = 20_000;
+/**
+ * Characters of a console message text in human output (`console`, `peek`)
+ */
+export const MAX_CONSOLE_TEXT_LENGTH = 200;
+/**
+ * Characters of a console message text in JSON output (`console`, `peek`)
+ */
+export const MAX_CONSOLE_JSON_TEXT_LENGTH = 10_000;
 // ============================================================================
 // CHROME CDP BUFFER LIMITS
 // ============================================================================
@@ -139,6 +161,18 @@ export const CHROME_NETWORK_BUFFER_PER_RESOURCE = 10 * 1024 * 1024; // 10MB
  */
 export const CHROME_POST_DATA_LIMIT = 1 * 1024 * 1024; // 1MB
 // ============================================================================
+// JSON LIST LIMITS
+// ============================================================================
+/** Matches `dom query` and `dom a11y query` list with `--json` and no `--limit` */
+export const QUERY_JSON_LIST_LIMIT = 100;
+/** Matches `dom layout` measures per command (the rest are counted as omitted) */
+export const LAYOUT_ELEMENT_LIMIT = 100;
+/**
+ * Requests listed in an action's result (a click that loads a page triggers
+ * its whole load); notable ones are kept before assets
+ */
+export const MAX_TRIGGERED_REQUESTS = 50;
+// ============================================================================
 // TIMEOUTS & INTERVALS
 // ============================================================================
 /**

package/dist/daemon/SessionController.js

@@ -241,8 +241,15 @@ export class SessionController {
                         duration: data.duration,
                         target: data.target,
                         data: { network: data.network, console: data.console },
-                        totals: { network: data.totalNetwork, console: data.totalConsole },
+                        totals: {
+                            network: data.totalNetwork,
+                            console: data.totalConsole,
+                            ...(data.droppedConsole && { consoleDropped: data.droppedConsole }),
+                            ...(data.droppedNetwork && { networkDropped: data.droppedNetwork }),
+                            ...(data.evictedNetworkBodies && { networkBodiesEvicted: data.evictedNetworkBodies }),
+                        },
                         currentNavigationId: data.currentNavigationId,
+                        ...(data.pageCrashedAt !== undefined && { pageCrashedAt: data.pageCrashedAt }),
                         partial: true,
                     },
                 },

package/dist/daemon/launcher.d.ts

@@ -24,8 +24,9 @@ export declare function launchDaemon(): Promise<SpawnedDaemon | undefined>;
  * Check that the session directory can hold the daemon's files before
  * spawning it (otherwise the daemon dies and only its log says why).
  *
- * @throws SessionDirError (103) for a file, (81) for a too-long path like a
- *   named session's, (82) when not writable
+ * @throws SessionDirError (103) for a file or a path that cannot hold a
+ *   directory (a pseudo-filesystem like `/proc`), (81) for a too-long path
+ *   like a named session's, (82) when not writable
  */
 export declare function assertUsableSessionDir(): void;
 //# sourceMappingURL=launcher.d.ts.map

package/dist/daemon/launcher.js

@@ -11,13 +11,16 @@ import fs from 'fs';
 import { join } from 'path';
 import { DaemonStartupError, SessionDirError } from './errors.js';
 import { sessionDirIsFileError, sessionDirNotWritableError, socketPathTooLongError, } from '../errors/messages.js';
-import { isDaemonAlive } from '../session/daemonSocket.js';
+import { killSessionChromes, readLiveDaemonPid } from '../session/cleanup/staleSession.js';
+import { isDaemonAlive, isDaemonSocketGone } from '../session/daemonSocket.js';
 import { MAX_DAEMON_SOCKET_PATH_BYTES, ensureSessionDir, getSessionDir, getSessionFilePath, } from '../session/paths.js';
 import { createLogger } from '../ui/logging/index.js';
 import { delay } from '../utils/async.js';
+import { directoryProblem } from '../utils/directories.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { EXIT_CODES } from '../utils/exitCodes.js';
 import { DAEMON_SCRIPT_PATH } from '../utils/packageRoot.js';
+import { isProcessAlive } from '../utils/process.js';
 const log = createLogger('launcher');
 const DAEMON_READY_TIMEOUT_MS = 5000;
 const DAEMON_READY_POLL_MS = 20;
@@ -37,6 +40,7 @@ export async function launchDaemon() {
         throw new DaemonStartupError(`Daemon script not found at ${DAEMON_SCRIPT_PATH}. Did you run 'npm run build'?`, 'DAEMON_SCRIPT_NOT_FOUND');
     }
     assertUsableSessionDir();
+    await stopUnreachableDaemon();
     const logPath = join(getSessionDir(), 'daemon.log');
     rotateLog(logPath);
     const logFd = fs.openSync(logPath, 'a');
@@ -54,12 +58,48 @@ export async function launchDaemon() {
     await waitForDaemonReady(() => exited);
     return { pid: daemon.pid, hasExited: () => exited };
 }
+/** How long a daemon that lost its socket gets to end its session before it is killed */
+const UNREACHABLE_DAEMON_EXIT_MS = 8000;
+/**
+ * Stop a daemon of this session directory that still runs but can no longer
+ * be reached (its socket was removed, or refuses connections; one that is
+ * only slow to answer is left alone), before a new one starts: two daemons
+ * would launch two Chromes and remove each other's files. It is asked to end
+ * its session (closing its Chrome), and killed with what it launched if it
+ * does not exit in time.
+ */
+async function stopUnreachableDaemon() {
+    const pid = readLiveDaemonPid();
+    if (pid === null || !(await isDaemonSocketGone()))
+        return;
+    log.info(`Stopping daemon ${pid}, which can no longer be reached (its socket is gone)`);
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch (error) {
+        log.debug(`Daemon ${pid} not signalled: ${getErrorMessage(error)}`);
+        return;
+    }
+    const deadline = Date.now() + UNREACHABLE_DAEMON_EXIT_MS;
+    while (isProcessAlive(pid) && Date.now() < deadline)
+        await delay(100);
+    if (!isProcessAlive(pid))
+        return;
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch (error) {
+        log.debug(`Daemon ${pid} not killed: ${getErrorMessage(error)}`);
+    }
+    killSessionChromes();
+}
 /**
  * Check that the session directory can hold the daemon's files before
  * spawning it (otherwise the daemon dies and only its log says why).
  *
- * @throws SessionDirError (103) for a file, (81) for a too-long path like a
- *   named session's, (82) when not writable
+ * @throws SessionDirError (103) for a file or a path that cannot hold a
+ *   directory (a pseudo-filesystem like `/proc`), (81) for a too-long path
+ *   like a named session's, (82) when not writable
  */
 export function assertUsableSessionDir() {
     const dir = getSessionDir();
@@ -72,6 +112,10 @@ export function assertUsableSessionDir() {
     if (Buffer.byteLength(socketPath) > MAX_DAEMON_SOCKET_PATH_BYTES) {
         fail(socketPathTooLongError(socketPath, MAX_DAEMON_SOCKET_PATH_BYTES), EXIT_CODES.INVALID_ARGUMENTS);
     }
+    const problem = directoryProblem(dir);
+    if (problem) {
+        fail(sessionDirNotWritableError(dir, problem.reason), problem.denied ? EXIT_CODES.PERMISSION_DENIED : EXIT_CODES.SESSION_FILE_ERROR);
+    }
     try {
         ensureSessionDir();
         fs.accessSync(dir, fs.constants.W_OK);

package/dist/daemon/session/Session.d.ts

@@ -80,7 +80,11 @@ export declare class Session {
      */
     launch(): Promise<void>;
     /**
-     * Execute a registered command against this session.
+     * Execute a registered command against this session. After a renderer
+     * crash only {@link RUN_ON_CRASHED_PAGE} commands run (`bdg cdp` only for
+     * {@link CRASH_SAFE_CDP} methods); others fail with exit 107 instead of
+     * waiting for a page that cannot answer. Commands that may change the page
+     * drop `dom inspect`'s kept matched rules ({@link withMatchedStylesReset}).
      *
      * @param name - Command name
      * @param params - Command parameters

package/dist/daemon/session/Session.js

@@ -11,13 +11,16 @@ import { connectCDP, navigateToTarget } from './cdpSetup.js';
 import { externalChromePort, findPageTarget, setupChromeConnection, } from './chromeConnection.js';
 import { startTelemetryCollectors } from './collectors.js';
 import { createCommandRegistry } from './commandRegistry.js';
+import { withMatchedStylesReset } from './matchedStylesReset.js';
 import { teardownSession } from './teardown.js';
 import { CommandError } from '../../errors/index.js';
+import { unknownSessionCommandMessage } from '../../errors/messages.js';
 import { applySessionEmulation } from '../../runtime/page/emulation.js';
 import { readPageLoadingState } from '../../runtime/page/loadingState.js';
 import { reapOrphanedChrome, removeSessionFiles } from '../../session/cleanup/staleSession.js';
 import { writeSessionMetadata } from '../../session/metadata.js';
 import { getSessionPort } from '../../session/port.js';
+import { pageCrashedCommandError } from '../../telemetry/pageCrash.js';
 import { createLogger } from '../../ui/logging/index.js';
 import { formatChromeNotice } from '../../ui/messages/chrome.js';
 import { delay } from '../../utils/async.js';
@@ -31,6 +34,26 @@ const log = createLogger('session');
 const CRASH_SETTLE_MS = 500;
 /** Ports tried when automatically chosen ports turn out to be taken */
 const PORT_ATTEMPTS = 3;
+/**
+ * Commands that still work after the page's renderer crashed: they read what
+ * the session collected, load the page again (`page reload`/`navigate`) or
+ * send raw CDP. Every other command needs the page and fails at once.
+ */
+const RUN_ON_CRASHED_PAGE = new Set([
+    'session_peek',
+    'session_details',
+    'session_status',
+    'session_har_data',
+    'session_network_headers',
+    'page_navigate',
+    'cdp_call',
+]);
+/**
+ * CDP methods `bdg cdp` may still send after a renderer crash: loading the
+ * page again, and domains the browser process answers. Others wait for the
+ * renderer, which never answers.
+ */
+const CRASH_SAFE_CDP = /^(Page\.(navigate|reload|getNavigationHistory|navigateToHistoryEntry)|Target\.|Browser\.|Inspector\.|Network\.(?!getResponseBody|getRequestPostData)|Storage\.|SystemInfo\.)/;
 /**
  * Whether a launch failed because another process holds the port.
  *
@@ -127,7 +150,11 @@ export class Session {
         }
     }
     /**
-     * Execute a registered command against this session.
+     * Execute a registered command against this session. After a renderer
+     * crash only {@link RUN_ON_CRASHED_PAGE} commands run (`bdg cdp` only for
+     * {@link CRASH_SAFE_CDP} methods); others fail with exit 107 instead of
+     * waiting for a page that cannot answer. Commands that may change the page
+     * drop `dom inspect`'s kept matched rules ({@link withMatchedStylesReset}).
      *
      * @param name - Command name
      * @param params - Command parameters
@@ -137,7 +164,19 @@ export class Session {
         if (!this.cdp || !this.started || this.stopping) {
             return Promise.reject(new Error('No active session'));
         }
-        return this.registry[name](this.cdp, params);
+        const crashedAt = this.store.pageCrashedAt;
+        const cdpMethod = name === 'cdp_call' ? params.method : undefined;
+        const needsPage = !RUN_ON_CRASHED_PAGE.has(name) ||
+            (cdpMethod !== undefined && !CRASH_SAFE_CDP.test(cdpMethod));
+        if (crashedAt !== undefined && needsPage) {
+            return Promise.reject(pageCrashedCommandError(crashedAt));
+        }
+        if (!Object.hasOwn(this.registry, name)) {
+            return Promise.reject(new CommandError(unknownSessionCommandMessage(name), {}, EXIT_CODES.INVALID_ARGUMENTS));
+        }
+        const handler = this.registry[name];
+        const cdp = this.cdp;
+        return withMatchedStylesReset(cdp, name, () => handler(cdp, params));
     }
     /**
      * Summary of this session for start responses.
@@ -223,7 +262,7 @@ export class Session {
             await this.releaseResources();
             if (!this.started)
                 return;
-            removeSessionFiles();
+            removeSessionFiles(process.pid);
             this.onEnded(reason);
         })();
         return this.stopping;

package/dist/daemon/session/TelemetryStore.d.ts

@@ -1,17 +1,31 @@
 import type { DialogInfo } from '../../ipc/protocol/domTypes.js';
 import type { NavigationEvent } from '../../telemetry/navigation.js';
 import type { PendingRequest } from '../../telemetry/network.js';
+import type { NetworkEvictions } from '../../telemetry/networkRetention.js';
 import type { CDPTarget, ConsoleMessage, NetworkRequest, TelemetryType, WebSocketConnection } from '../../types.js';
 export declare class TelemetryStore {
+    /**
+     * Finished requests, oldest first: the newest are kept, so the session's
+     * `networkEvictions.requestsDropped` oldest ones are gone
+     */
     readonly networkRequests: NetworkRequest[];
+    /** Requests dropped and response bodies evicted at the capture limits */
+    readonly networkEvictions: NetworkEvictions;
     /** Requests still in flight, keyed by CDP requestId */
     readonly pendingNetworkRequests: Map<string, PendingRequest>;
     readonly consoleMessages: ConsoleMessage[];
+    /**
+     * Console messages dropped at the limit, oldest first: the index of
+     * `consoleMessages[i]` in the session is `consoleDropped + i`
+     */
+    consoleDropped: number;
     readonly navigationEvents: NavigationEvent[];
     readonly websocketConnections: WebSocketConnection[];
     /** JavaScript dialogs accepted during the session */
     readonly dialogs: DialogInfo[];
     activeTelemetry: TelemetryType[];
+    /** When the page's renderer crashed (epoch ms); undefined while the page is alive */
+    pageCrashedAt: number | undefined;
     getCurrentNavigationId: (() => number) | null;
     sessionStartTime: number;
     targetInfo: CDPTarget | null;
@@ -21,7 +35,7 @@ export declare class TelemetryStore {
     /**
      * Record an accepted dialog, and show it among the console messages when
      * console telemetry is collected (it is otherwise invisible: bdg accepts it
-     * before anyone could see it).
+     * before anyone could see it), dropping the oldest message at the limit.
      *
      * @param dialog - Dialog type and text
      */

package/dist/daemon/session/TelemetryStore.js

@@ -1,14 +1,28 @@
+import { MAX_CONSOLE_MESSAGES } from '../../constants.js';
 import { dialogConsoleText } from '../../ui/messages/commands.js';
 export class TelemetryStore {
+    /**
+     * Finished requests, oldest first: the newest are kept, so the session's
+     * `networkEvictions.requestsDropped` oldest ones are gone
+     */
     networkRequests = [];
+    /** Requests dropped and response bodies evicted at the capture limits */
+    networkEvictions = { requestsDropped: 0, bodiesEvicted: 0 };
     /** Requests still in flight, keyed by CDP requestId */
     pendingNetworkRequests = new Map();
     consoleMessages = [];
+    /**
+     * Console messages dropped at the limit, oldest first: the index of
+     * `consoleMessages[i]` in the session is `consoleDropped + i`
+     */
+    consoleDropped = 0;
     navigationEvents = [];
     websocketConnections = [];
     /** JavaScript dialogs accepted during the session */
     dialogs = [];
     activeTelemetry = [];
+    /** When the page's renderer crashed (epoch ms); undefined while the page is alive */
+    pageCrashedAt;
     getCurrentNavigationId = null;
     sessionStartTime = Date.now();
     targetInfo = null;
@@ -24,7 +38,7 @@ export class TelemetryStore {
     /**
      * Record an accepted dialog, and show it among the console messages when
      * console telemetry is collected (it is otherwise invisible: bdg accepts it
-     * before anyone could see it).
+     * before anyone could see it), dropping the oldest message at the limit.
      *
      * @param dialog - Dialog type and text
      */
@@ -32,6 +46,10 @@ export class TelemetryStore {
         this.dialogs.push(dialog);
         if (!this.activeTelemetry.includes('console'))
             return;
+        if (this.consoleMessages.length >= MAX_CONSOLE_MESSAGES) {
+            this.consoleMessages.shift();
+            this.consoleDropped++;
+        }
         this.consoleMessages.push({
             type: 'info',
             text: dialogConsoleText(dialog),