browser-debugger-cli 0.11.0 → 0.13.0

package/dist/session/cleanup/staleSession.d.ts

@@ -9,9 +9,13 @@
 /**
  * Remove per-session files (metadata, query cache).
  *
- * Called by the daemon when its session ends, and by `bdg cleanup`.
+ * Called by the daemon when its session ends, and by `bdg cleanup`. A daemon
+ * passes its PID, so it never removes the files of another daemon that
+ * started in the same directory meanwhile.
+ *
+ * @param ownerPid - The daemon whose files these must be; omitted by cleanup
  */
-export declare function removeSessionFiles(): void;
+export declare function removeSessionFiles(ownerPid?: number): void;
 /**
  * Remove daemon and session files if no daemon is listening.
  *
@@ -43,8 +47,21 @@ export declare function isSessionChrome(pid: number, sessionDir: string): boolea
  */
 export declare function killOrphanedChrome(): boolean;
 /**
- * Kill an orphaned Chrome (see {@link killOrphanedChrome}) and wait until it
- * has exited, so its debugging port is free for the next launch.
+ * Kill every Chrome launched for a session directory (its marker flag on the
+ * command line), whatever chrome.pid says: a Chrome whose PID file another
+ * daemon removed, or that a second start left behind, is found too. Only
+ * browser processes are signalled; their helper processes exit with them.
+ *
+ * @param sessionDir - Session directory
+ * @returns PIDs of the processes killed
+ */
+export declare function killSessionChromes(sessionDir?: string): number[];
+/**
+ * Kill the Chromes this session left behind and wait until they have exited,
+ * so their profile and debugging port are free for the next launch. The
+ * Chrome recorded in chrome.pid is killed (see {@link killOrphanedChrome});
+ * without a record (chrome.pid lost with its daemon), every Chrome carrying
+ * the session's marker is, unless another daemon of the session still runs.
  *
  * @returns True if a Chrome process was killed
  */

package/dist/session/cleanup/staleSession.js

@@ -10,13 +10,14 @@ import { chromeSessionMarkerFlag } from '../../connection/launcher/flagsBuilder.
 import { QueryCacheManager } from '../QueryCacheManager.js';
 import { clearChromePid, readChromePid } from '../chrome.js';
 import { probeDaemonSocket } from '../daemonSocket.js';
+import { readSessionMetadata } from '../metadata.js';
 import { getSessionDir, getSessionFilePath, sessionFilePathIn } from '../paths.js';
 import { readPidFromFile } from '../pid.js';
 import { createLogger, logDebugError } from '../../ui/logging/index.js';
 import { delay } from '../../utils/async.js';
 import { safeRemoveFile } from '../../utils/file.js';
 import { DAEMON_SCRIPT_PATH } from '../../utils/packageRoot.js';
-import { getProcessCommand, isProcessAlive, killChromeProcess } from '../../utils/process.js';
+import { getProcessCommand, isProcessAlive, killChromeProcess, listProcesses, } from '../../utils/process.js';
 const log = createLogger('cleanup');
 /**
  * Check whether a process command line contains an exact argument.
@@ -30,12 +31,39 @@ function hasArgument(command, arg) {
         return false;
     return command.includes(`${arg} `) || command.endsWith(arg);
 }
+/**
+ * Check whether a command line contains an exact argument, followed by the
+ * end or by another option: a session directory with a space in it
+ * (`/tmp/a b`) does not match the marker of `/tmp/a`.
+ *
+ * @param command - Full command line
+ * @param arg - Argument to look for
+ * @returns True if `arg` appears as a whole argument
+ */
+function hasWholeArgument(command, arg) {
+    for (let at = command.indexOf(arg); at !== -1; at = command.indexOf(arg, at + 1)) {
+        const before = at === 0 || command[at - 1] === ' ';
+        const rest = command.slice(at + arg.length);
+        if (before && (rest === '' || rest.startsWith(' -')))
+            return true;
+    }
+    return false;
+}
 /**
  * Remove per-session files (metadata, query cache).
  *
- * Called by the daemon when its session ends, and by `bdg cleanup`.
+ * Called by the daemon when its session ends, and by `bdg cleanup`. A daemon
+ * passes its PID, so it never removes the files of another daemon that
+ * started in the same directory meanwhile.
+ *
+ * @param ownerPid - The daemon whose files these must be; omitted by cleanup
  */
-export function removeSessionFiles() {
+export function removeSessionFiles(ownerPid) {
+    if (ownerPid !== undefined) {
+        const owner = readSessionMetadata()?.bdgPid;
+        if (owner !== undefined && owner !== ownerPid)
+            return;
+    }
     safeRemoveFile(getSessionFilePath('METADATA'), 'metadata file', log);
     void QueryCacheManager.getInstance()
         .clear()
@@ -103,22 +131,64 @@ export function killOrphanedChrome() {
     clearChromePid();
     return true;
 }
+/**
+ * Kill every Chrome launched for a session directory (its marker flag on the
+ * command line), whatever chrome.pid says: a Chrome whose PID file another
+ * daemon removed, or that a second start left behind, is found too. Only
+ * browser processes are signalled; their helper processes exit with them.
+ *
+ * @param sessionDir - Session directory
+ * @returns PIDs of the processes killed
+ */
+export function killSessionChromes(sessionDir = getSessionDir()) {
+    const marker = chromeSessionMarkerFlag(sessionDir);
+    const killed = [];
+    for (const { pid, command } of listProcesses()) {
+        if (pid === process.pid || !hasWholeArgument(command, marker) || / --type=/.test(command)) {
+            continue;
+        }
+        try {
+            killChromeProcess(pid, 'SIGKILL');
+            killed.push(pid);
+            log.info(`Killed Chrome of this session (PID ${pid})`);
+        }
+        catch (error) {
+            logDebugError(log, `kill Chrome ${pid}`, error);
+        }
+    }
+    if (killed.length > 0)
+        clearChromePid();
+    return killed;
+}
 /** How long to wait for a killed orphaned Chrome to exit (and free its port) */
 const ORPHAN_EXIT_WAIT_MS = 5000;
 /**
- * Kill an orphaned Chrome (see {@link killOrphanedChrome}) and wait until it
- * has exited, so its debugging port is free for the next launch.
+ * Kill the Chromes this session left behind and wait until they have exited,
+ * so their profile and debugging port are free for the next launch. The
+ * Chrome recorded in chrome.pid is killed (see {@link killOrphanedChrome});
+ * without a record (chrome.pid lost with its daemon), every Chrome carrying
+ * the session's marker is, unless another daemon of the session still runs.
  *
  * @returns True if a Chrome process was killed
  */
 export async function reapOrphanedChrome() {
     const chromePid = findOrphanedChrome();
-    if (!killOrphanedChrome() || chromePid === null)
-        return false;
+    const killed = chromePid !== null ? (killOrphanedChrome() ? [chromePid] : []) : killUnrecordedChromes();
     const deadline = Date.now() + ORPHAN_EXIT_WAIT_MS;
-    while (isProcessAlive(chromePid) && Date.now() < deadline)
+    while (killed.some(isProcessAlive) && Date.now() < deadline)
         await delay(50);
-    return true;
+    return killed.length > 0;
+}
+/**
+ * Kill the session's Chromes found by their marker (see
+ * {@link killSessionChromes}), unless a daemon of the session other than
+ * this process still runs: they could be its Chrome.
+ *
+ * @returns PIDs of the processes killed
+ */
+function killUnrecordedChromes() {
+    const daemonPid = readLiveDaemonPid();
+    return daemonPid === null || daemonPid === process.pid ? killSessionChromes() : [];
 }
 /**
  * Read the PID of a live bdg daemon from daemon.pid.

package/dist/session/cleanup/userCommands.d.ts

@@ -27,7 +27,10 @@ export interface SessionCleanupResult {
  *
  * With `force`, a live daemon is killed first (after verifying its command
  * line). Then stale daemon files are removed and an orphaned bdg Chrome, if
- * any, is killed.
+ * any, is killed, and, once no daemon of the session runs, every other
+ * Chrome launched for this session directory (one chrome.pid lost track of).
+ * The record of a session that ended without `bdg stop` is removed too, and
+ * counts as cleaned session files.
  *
  * @param options - Cleanup options
  * @returns What was cleaned, plus warnings

package/dist/session/cleanup/userCommands.js

@@ -2,7 +2,7 @@
  * Cleanup behind the user-facing `bdg cleanup` command.
  */
 import * as fs from 'fs';
-import { killOrphanedChrome, readLiveDaemonPid, removeStaleDaemonFiles, } from './staleSession.js';
+import { killOrphanedChrome, killSessionChromes, readLiveDaemonPid, removeStaleDaemonFiles, } from './staleSession.js';
 import { isDaemonAlive } from '../daemonSocket.js';
 import { clearLastSessionEnd } from '../lastSession.js';
 import { SESSION_STATE_FILES, getSessionFilePath } from '../paths.js';
@@ -15,7 +15,10 @@ const DAEMON_EXIT_WAIT_MS = 2000;
  *
  * With `force`, a live daemon is killed first (after verifying its command
  * line). Then stale daemon files are removed and an orphaned bdg Chrome, if
- * any, is killed.
+ * any, is killed, and, once no daemon of the session runs, every other
+ * Chrome launched for this session directory (one chrome.pid lost track of).
+ * The record of a session that ended without `bdg stop` is removed too, and
+ * counts as cleaned session files.
  *
  * @param options - Cleanup options
  * @returns What was cleaned, plus warnings
@@ -25,13 +28,15 @@ export async function performSessionCleanup(options) {
     const filesBefore = countSessionFiles();
     const daemonKilled = options.force ? await killLiveDaemon(warnings) : false;
     const session = await removeStaleDaemonFiles();
-    const chrome = killOrphanedChrome();
+    const orphan = killOrphanedChrome();
+    const unrecorded = readLiveDaemonPid() === null ? killSessionChromes() : [];
+    const chrome = orphan || unrecorded.length > 0;
     const output = options.removeOutput ? removeOutputFile(warnings) : false;
     const filesRemoved = countSessionFiles() < filesBefore;
-    clearLastSessionEnd();
+    const endedRecordRemoved = clearLastSessionEnd();
     return {
         cleaned: {
-            session: session || daemonKilled || filesRemoved,
+            session: session || daemonKilled || filesRemoved || endedRecordRemoved,
             chrome,
             daemons: daemonKilled,
             output,

package/dist/session/daemonSocket.d.ts

@@ -22,4 +22,14 @@ export declare function probeDaemonSocket(socketPath?: string, timeoutMs?: numbe
  * @returns True if the daemon socket accepts a connection
  */
 export declare function isDaemonAlive(): Promise<boolean>;
+/**
+ * Whether the daemon socket certainly cannot be reached: there is no socket
+ * file, or connecting is refused. A daemon that is only slow to accept (busy,
+ * a timeout) does not count, so it is never taken for a dead one.
+ *
+ * @param socketPath - Socket path (defaults to the session's daemon socket)
+ * @param timeoutMs - Connection timeout
+ * @returns True when the socket is missing or refuses connections
+ */
+export declare function isDaemonSocketGone(socketPath?: string, timeoutMs?: number): Promise<boolean>;
 //# sourceMappingURL=daemonSocket.d.ts.map

package/dist/session/daemonSocket.js

@@ -37,4 +37,26 @@ export function probeDaemonSocket(socketPath = getSessionFilePath('DAEMON_SOCKET
 export async function isDaemonAlive() {
     return (await probeDaemonSocket()) === 'alive';
 }
+/**
+ * Whether the daemon socket certainly cannot be reached: there is no socket
+ * file, or connecting is refused. A daemon that is only slow to accept (busy,
+ * a timeout) does not count, so it is never taken for a dead one.
+ *
+ * @param socketPath - Socket path (defaults to the session's daemon socket)
+ * @param timeoutMs - Connection timeout
+ * @returns True when the socket is missing or refuses connections
+ */
+export function isDaemonSocketGone(socketPath = getSessionFilePath('DAEMON_SOCKET'), timeoutMs = PROBE_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection(socketPath);
+        const finish = (gone) => {
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(gone);
+        };
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        socket.once('connect', () => finish(false));
+        socket.once('error', (error) => finish(error.code === 'ENOENT' || error.code === 'ECONNREFUSED'));
+    });
+}
 //# sourceMappingURL=daemonSocket.js.map

package/dist/session/lastSession.d.ts

@@ -18,12 +18,15 @@ export interface LastSessionEnd {
 export declare function writeLastSessionEnd(reason: UnexpectedEndReason): void;
 /**
  * Forget the last session's end (a new session is starting, or `cleanup` ran).
+ *
+ * @returns True if there was a record to remove
  */
-export declare function clearLastSessionEnd(): void;
+export declare function clearLastSessionEnd(): boolean;
 /**
- * How the last session ended, if it ended unexpectedly.
+ * How the last session of a directory ended, if it ended unexpectedly.
  *
+ * @param dir - Session directory (default: the selected session's)
  * @returns The record, or null
  */
-export declare function readLastSessionEnd(): LastSessionEnd | null;
+export declare function readLastSessionEnd(dir?: string): LastSessionEnd | null;
 //# sourceMappingURL=lastSession.d.ts.map

package/dist/session/lastSession.js

@@ -3,7 +3,7 @@
  * `bdg status` can explain why there is no session any more.
  */
 import * as fs from 'fs';
-import { getSessionFilePath } from './paths.js';
+import { getSessionDir, getSessionFilePath, sessionFilePathIn } from './paths.js';
 import { createLogger } from '../ui/logging/index.js';
 import { AtomicFileWriter } from '../utils/atomicFile.js';
 import { getErrorMessage } from '../utils/errors.js';
@@ -23,18 +23,24 @@ export function writeLastSessionEnd(reason) {
 }
 /**
  * Forget the last session's end (a new session is starting, or `cleanup` ran).
+ *
+ * @returns True if there was a record to remove
  */
 export function clearLastSessionEnd() {
-    fs.rmSync(getSessionFilePath('LAST_SESSION'), { force: true });
+    const file = getSessionFilePath('LAST_SESSION');
+    const existed = fs.existsSync(file);
+    fs.rmSync(file, { force: true });
+    return existed;
 }
 /**
- * How the last session ended, if it ended unexpectedly.
+ * How the last session of a directory ended, if it ended unexpectedly.
  *
+ * @param dir - Session directory (default: the selected session's)
  * @returns The record, or null
  */
-export function readLastSessionEnd() {
+export function readLastSessionEnd(dir = getSessionDir()) {
     try {
-        const data = JSON.parse(fs.readFileSync(getSessionFilePath('LAST_SESSION'), 'utf8'));
+        const data = JSON.parse(fs.readFileSync(sessionFilePathIn(dir, 'LAST_SESSION'), 'utf8'));
         return typeof data.endedAt === 'number' ? data : null;
     }
     catch (error) {

package/dist/session/paths.d.ts

@@ -124,8 +124,10 @@ export declare function getDaemonSocketPath(): string;
  * Ensure the session directory exists.
  *
  * Creates ~/.bdg/ if it doesn't exist. Safe to call multiple times (idempotent).
+ * A path that cannot hold a directory is refused before `mkdir`, which
+ * would spin on a pseudo-filesystem ({@link makeDirectory}).
  *
- * @throws Error if directory creation fails due to permissions
+ * @throws Error if the directory cannot be created
  */
 export declare function ensureSessionDir(): void;
 export {};

package/dist/session/paths.js

@@ -9,6 +9,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { createLogger, logDebugError } from '../ui/logging/index.js';
+import { makeDirectory } from '../utils/directories.js';
 const log = createLogger('session');
 /**
  * Session file paths relative to ~/.bdg/
@@ -166,13 +167,12 @@ export function getDaemonSocketPath() {
  * Ensure the session directory exists.
  *
  * Creates ~/.bdg/ if it doesn't exist. Safe to call multiple times (idempotent).
+ * A path that cannot hold a directory is refused before `mkdir`, which
+ * would spin on a pseudo-filesystem ({@link makeDirectory}).
  *
- * @throws Error if directory creation fails due to permissions
+ * @throws Error if the directory cannot be created
  */
 export function ensureSessionDir() {
-    const dir = getSessionDir();
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
+    makeDirectory(getSessionDir());
 }
 //# sourceMappingURL=paths.js.map

package/dist/session/portClaims.js

@@ -20,6 +20,7 @@ import * as path from 'path';
 import { getSessionBaseDir, getSessionDir, listSessionDirs, sessionFilePathIn, } from './paths.js';
 import { createLogger, logDebugError } from '../ui/logging/index.js';
 import { delay } from '../utils/async.js';
+import { makeDirectory } from '../utils/directories.js';
 const log = createLogger('session');
 /** Lock file guarding port selection, in the port registry (or base session) directory */
 const PORT_LOCK_FILE = 'port.lock';
@@ -93,8 +94,8 @@ function trustedRegistryDir(create) {
     const dir = getPortRegistryDir();
     try {
         if (create) {
-            fs.mkdirSync(path.dirname(dir), { recursive: true });
-            fs.mkdirSync(path.join(dir, CLAIMS_DIR), { recursive: true, mode: 0o700 });
+            makeDirectory(path.dirname(dir));
+            makeDirectory(path.join(dir, CLAIMS_DIR), 0o700);
         }
         if (!fs.existsSync(dir))
             return null;
@@ -266,7 +267,7 @@ function releaseLock(lockPath, token) {
 export async function withPortLock(select) {
     const registryDir = trustedRegistryDir(true);
     const lockDir = registryDir ?? getSessionBaseDir();
-    fs.mkdirSync(lockDir, { recursive: true });
+    makeDirectory(lockDir);
     const lockPath = path.join(lockDir, PORT_LOCK_FILE);
     const token = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const locked = await acquireLock(lockPath, token);

package/dist/session/sessionList.d.ts

@@ -4,13 +4,15 @@
  */
 import type { StatusResponseData } from '../ipc/session/queries.js';
 import { type SocketProbeResult } from './daemonSocket.js';
+import { type UnexpectedEndReason } from './lastSession.js';
 import { type SessionDirEntry } from './paths.js';
 /**
  * State of a session: its daemon runs (`active`, `starting`, `ending`,
- * `unresponsive`), or died and left its Chrome running (`crashed`) or only
- * files (`stale`).
+ * `unresponsive`), died and left its Chrome running (`crashed`) or only
+ * files (`stale`), or exited after the session ended without `bdg stop`
+ * (`ended`: Chrome crashed or was closed, the page was closed, `--timeout`).
  */
-export type RunningSessionState = 'active' | 'starting' | 'ending' | 'unresponsive' | 'crashed' | 'stale';
+export type RunningSessionState = 'active' | 'starting' | 'ending' | 'unresponsive' | 'crashed' | 'stale' | 'ended';
 /**
  * One session in the list.
  */
@@ -27,6 +29,10 @@ export interface RunningSessionInfo {
     chromePid?: number;
     /** Command that cleans up a crashed or stale session */
     cleanup?: string;
+    /** Why an `ended` session ended */
+    endReason?: UnexpectedEndReason;
+    /** When an `ended` session ended (epoch ms) */
+    endedAt?: number;
 }
 /**
  * Summarize a daemon's status response.
@@ -38,8 +44,10 @@ export interface RunningSessionInfo {
 export declare function toRunningSession(name: string | null, data: StatusResponseData): RunningSessionInfo;
 /**
  * A session whose daemon is gone: `crashed` while the Chrome bdg launched for
- * it still runs, `stale` when only its files are left. Nothing is changed on
- * disk; `cleanup` names the command that removes them.
+ * it still runs, `stale` when only its files are left, `ended` when it left
+ * only the record of an end without `bdg stop` ({@link describeEnded}).
+ * Nothing is changed on disk; `cleanup` names the command that removes
+ * leftover files.
  *
  * @param entry - Session directory
  * @param probe - Result of probing its daemon socket

package/dist/session/sessionList.js

@@ -6,6 +6,7 @@ import * as fs from 'fs';
 import { getStatus } from '../ipc/client.js';
 import { isSessionChrome, readLiveDaemonPid } from './cleanup/staleSession.js';
 import { probeDaemonSocket } from './daemonSocket.js';
+import { readLastSessionEnd } from './lastSession.js';
 import { SESSION_STATE_FILES, getNamedSessionDir, listSessionDirs, sessionFilePathIn, } from './paths.js';
 import { readPidFromFile } from './pid.js';
 import { readPortFile } from './portClaims.js';
@@ -58,9 +59,10 @@ async function describeSession(entry) {
     return { name, state: 'unresponsive' };
 }
 /**
- * A session whose daemon socket does not answer: `starting` while its daemon
- * (from daemon.pid, verified by command line) runs but has not bound the
- * socket yet, otherwise see {@link describeLeftovers}.
+ * A session whose daemon socket does not answer: `ending` while its daemon
+ * (from daemon.pid, verified by command line) still runs, since a daemon
+ * writes daemon.pid only after it opened its socket and removes the socket
+ * first when it shuts down; otherwise see {@link describeLeftovers}.
  *
  * @param entry - Session directory
  * @param probe - Result of probing its daemon socket
@@ -69,13 +71,15 @@ async function describeSession(entry) {
 function describeWithoutSocket(entry, probe) {
     const daemonPid = readLiveDaemonPid(entry.dir);
     if (daemonPid !== null)
-        return { name: entry.name, state: 'starting', daemonPid };
+        return { name: entry.name, state: 'ending', daemonPid };
     return describeLeftovers(entry, probe);
 }
 /**
  * A session whose daemon is gone: `crashed` while the Chrome bdg launched for
- * it still runs, `stale` when only its files are left. Nothing is changed on
- * disk; `cleanup` names the command that removes them.
+ * it still runs, `stale` when only its files are left, `ended` when it left
+ * only the record of an end without `bdg stop` ({@link describeEnded}).
+ * Nothing is changed on disk; `cleanup` names the command that removes
+ * leftover files.
  *
  * @param entry - Session directory
  * @param probe - Result of probing its daemon socket
@@ -87,7 +91,7 @@ export function describeLeftovers({ name, dir }, probe) {
     const leftover = probe === 'stale' ||
         SESSION_STATE_FILES.some((type) => fs.existsSync(sessionFilePathIn(dir, type)));
     if (!orphan && !leftover)
-        return null;
+        return describeEnded({ name, dir });
     const port = leftoverPort(dir);
     return {
         name,
@@ -97,6 +101,26 @@ export function describeLeftovers({ name, dir }, probe) {
         cleanup: sessionCommand('bdg cleanup', name),
     };
 }
+/**
+ * A session that ended without `bdg stop` and whose daemon exited cleanly:
+ * `ended`, with why and when, until the session starts again or
+ * `bdg cleanup` clears the record.
+ *
+ * @param entry - Session directory
+ * @returns Session info, or null when the directory holds no such record
+ */
+function describeEnded({ name, dir }) {
+    const end = readLastSessionEnd(dir);
+    if (end === null)
+        return null;
+    return {
+        name,
+        state: 'ended',
+        endReason: end.reason,
+        endedAt: end.endedAt,
+        cleanup: sessionCommand('bdg cleanup', name),
+    };
+}
 /**
  * The port a dead session used: from its metadata, else its `port.txt`.
  *

package/dist/telemetry/a11y.js

@@ -1,6 +1,6 @@
 import { CommandError } from '../errors/index.js';
 import { unknownQueryFieldError } from '../errors/messages.js';
-import { callCDP } from '../ipc/client.js';
+import { callBdgScript, callCDP } from '../ipc/client.js';
 import { MASKED_VALUE, SENSITIVE_FIELD_JS } from '../runtime/dom/elementInfo.js';
 import { childFrameIds } from '../runtime/dom/frameLayout.js';
 import { ConcurrencyLimiter } from '../utils/concurrency.js';
@@ -118,7 +118,7 @@ async function sensitiveNodeIds(tree) {
  */
 async function isSensitiveField(backendNodeId) {
     const objectGroup = 'bdg-a11y-secret';
-    const resolved = await callCDP('DOM.resolveNode', { backendNodeId, objectGroup });
+    const resolved = await callBdgScript('DOM.resolveNode', { backendNodeId, objectGroup });
     const objectId = resolved.data?.result?.object
         ?.objectId;
     if (!objectId)

package/dist/telemetry/console.d.ts

@@ -31,7 +31,8 @@ export declare function formatExceptionText(details: Protocol.Runtime.ExceptionD
  * @param messages - Array to populate with console messages
  * @param includeAll - If true, disable default pattern filtering
  * @param getCurrentNavigationId - Function to get current navigation ID
+ * @param onDropped - Called for each message dropped at the limit (the oldest go first)
  * @returns Cleanup function to remove event handlers
  */
-export declare function startConsoleCollection(cdp: CDPConnection, messages: ConsoleMessage[], includeAll?: boolean, getCurrentNavigationId?: () => number): Promise<CleanupFunction>;
+export declare function startConsoleCollection(cdp: CDPConnection, messages: ConsoleMessage[], includeAll?: boolean, getCurrentNavigationId?: () => number, onDropped?: () => void): Promise<CleanupFunction>;
 //# sourceMappingURL=console.d.ts.map