browser-debugger-cli 0.12.0 → 0.13.0

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

package/dist/telemetry/console.js

@@ -75,15 +75,23 @@ function createMessage(type, text, timestamp, args, context) {
     };
 }
 /**
- * Insert a message in timestamp order.
- * Messages are kept sorted by timestamp to handle async expansion delays.
+ * Insert a message in timestamp order (async expansion can deliver a message
+ * late). At {@link MAX_CONSOLE_MESSAGES} the oldest message is dropped to
+ * make room, so the newest are kept; a late message older than all kept ones
+ * is dropped itself.
  *
- * @returns False when the message limit is reached (the message is dropped)
+ * @param messages - Messages, oldest first (updated)
+ * @param message - Message to add
+ * @param onDropped - Called for each message dropped
+ * @returns False when the message itself was dropped
  */
-function insertMessageByTimestamp(messages, message) {
+function insertMessageByTimestamp(messages, message, onDropped) {
     if (messages.length >= MAX_CONSOLE_MESSAGES) {
-        log.debug(`Warning: Console message limit reached (${MAX_CONSOLE_MESSAGES})`);
-        return false;
+        const oldest = messages[0];
+        onDropped();
+        if (oldest && message.timestamp < oldest.timestamp)
+            return false;
+        messages.shift();
     }
     const insertIndex = findInsertIndex(messages, message.timestamp);
     messages.splice(insertIndex, 0, message);
@@ -111,32 +119,31 @@ function findInsertIndex(messages, timestamp) {
 /**
  * Handle a console API call event with object expansion.
  */
-function handleConsoleAPICall(cdp, messages, params, context, includeAll) {
+function handleConsoleAPICall(cdp, insert, params, context, includeAll) {
     const basicText = formatConsoleArgs(params.args);
     if (shouldExcludeConsoleMessage(basicText, params.type, includeAll)) {
         return;
     }
     if (hasArgsNeedingExpansion(params.args) && !usesFormatSpecifiers(params.args)) {
-        handleExpandableMessage(cdp, messages, params, context, basicText);
+        handleExpandableMessage(cdp, insert, params, context, basicText);
     }
     else {
-        const message = createMessage(params.type, basicText, params.timestamp, params.args, context);
-        insertMessageByTimestamp(messages, message);
+        insert(createMessage(params.type, basicText, params.timestamp, params.args, context));
     }
 }
 /**
  * Handle a message with expandable objects.
  */
-function handleExpandableMessage(cdp, messages, params, context, fallbackText) {
+function handleExpandableMessage(cdp, insert, params, context, fallbackText) {
     void expandConsoleArgs(cdp, params.args)
         .then((expandedText) => {
         const message = createMessage(params.type, expandedText, params.timestamp, params.args, context);
-        insertMessageByTimestamp(messages, message);
+        insert(message);
     })
         .catch((error) => {
         log.debug(`Object expansion failed, using basic text: ${String(error)}`);
         const message = createMessage(params.type, fallbackText, params.timestamp, params.args, context);
-        insertMessageByTimestamp(messages, message);
+        insert(message);
     });
 }
 /**
@@ -178,14 +185,14 @@ export function formatExceptionText(details) {
  *
  * @returns The message added, undefined when filtered out or over the limit
  */
-function handleExceptionThrown(messages, params, context, includeAll) {
+function handleExceptionThrown(insert, params, context, includeAll) {
     const exception = params.exceptionDetails;
     const text = formatExceptionText(exception);
     if (shouldExcludeConsoleMessage(text, 'error', includeAll)) {
         return undefined;
     }
     const message = createMessage('error', text, params.timestamp, undefined, context);
-    return insertMessageByTimestamp(messages, message) ? message : undefined;
+    return insert(message) ? message : undefined;
 }
 /** CDP's text of an unhandled promise rejection (the only kind Chrome revokes) */
 const UNHANDLED_REJECTION_TEXT = 'Uncaught (in promise)';
@@ -270,7 +277,7 @@ class RevocableRejections {
  * Worker entries are skipped: workers are attached directly, so their console
  * calls already arrive (with arguments) from the worker's own session.
  */
-function handleLogEntry(messages, entry, navigationId, includeAll) {
+function handleLogEntry(insert, entry, navigationId, includeAll) {
     const type = LOG_LEVEL_TYPES[entry.level];
     if (entry.source === 'worker' || shouldExcludeConsoleMessage(entry.text, type, includeAll)) {
         return;
@@ -287,7 +294,7 @@ function handleLogEntry(messages, entry, navigationId, includeAll) {
         stackTrace: convertStackTrace(entry.stackTrace) ?? location,
         source: entry.source,
     };
-    insertMessageByTimestamp(messages, createMessage(type, entry.text, entry.timestamp, undefined, context));
+    insert(createMessage(type, entry.text, entry.timestamp, undefined, context));
 }
 /**
  * Enable console and log events on an attached target's session.
@@ -325,17 +332,19 @@ async function startOptionalSources(cdp, typed) {
  * @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 async function startConsoleCollection(cdp, messages, includeAll = false, getCurrentNavigationId) {
+export async function startConsoleCollection(cdp, messages, includeAll = false, getCurrentNavigationId, onDropped = () => undefined) {
     const registry = new CDPHandlerRegistry();
     const typed = new TypedCDPConnection(cdp);
+    const insert = (message) => insertMessageByTimestamp(messages, message, onDropped);
     registry.registerTyped(typed, 'Runtime.consoleAPICalled', (params, sessionId) => {
         const context = {
             navigationId: getCurrentNavigationId?.(),
             stackTrace: convertStackTrace(params.stackTrace),
         };
-        handleConsoleAPICall(senderFor(cdp, sessionId), messages, params, context, includeAll);
+        handleConsoleAPICall(senderFor(cdp, sessionId), insert, params, context, includeAll);
     });
     const rejections = new RevocableRejections();
     registry.registerTyped(typed, 'Runtime.exceptionThrown', (params, sessionId) => {
@@ -343,7 +352,7 @@ export async function startConsoleCollection(cdp, messages, includeAll = false,
             navigationId: getCurrentNavigationId?.(),
             stackTrace: convertStackTrace(params.exceptionDetails.stackTrace),
         };
-        const message = handleExceptionThrown(messages, params, context, includeAll);
+        const message = handleExceptionThrown(insert, params, context, includeAll);
         if (message)
             rejections.track(params.exceptionDetails, message, sessionId);
     });
@@ -357,7 +366,7 @@ export async function startConsoleCollection(cdp, messages, includeAll = false,
         rejections.forgetSession(sessionId);
     });
     registry.registerTyped(typed, 'Log.entryAdded', ({ entry }) => {
-        handleLogEntry(messages, entry, getCurrentNavigationId?.(), includeAll);
+        handleLogEntry(insert, entry, getCurrentNavigationId?.(), includeAll);
     });
     try {
         await typed.send('Runtime.enable', {});

package/dist/telemetry/pageCrash.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Renderer crash tracking: Chrome reports a crashed page with
+ * `Inspector.targetCrashed` and keeps the connection open, so without this a
+ * session looks active while every page command waits for a timeout. A
+ * reload (or any main-frame navigation) brings the page back.
+ */
+import type { CDPConnection } from '../connection/cdp.js';
+import { CommandError } from '../errors/index.js';
+import type { CleanupFunction } from '../types.js';
+/**
+ * Start tracking renderer crashes of the page.
+ *
+ * @param cdp - CDP connection to the page
+ * @param onChange - Called with the crash time when the page crashes, and
+ *   with undefined when it is loaded again
+ * @returns Cleanup that stops tracking
+ */
+export declare function startCrashTracking(cdp: CDPConnection, onChange: (crashedAt: number | undefined) => void): Promise<CleanupFunction>;
+/**
+ * Error for a page command after the page's renderer crashed (exit 107).
+ *
+ * @param crashedAt - When it crashed (epoch ms)
+ * @returns Error with the way back
+ */
+export declare function pageCrashedCommandError(crashedAt: number): CommandError;
+//# sourceMappingURL=pageCrash.d.ts.map

package/dist/telemetry/pageCrash.js

@@ -0,0 +1,53 @@
+/**
+ * Renderer crash tracking: Chrome reports a crashed page with
+ * `Inspector.targetCrashed` and keeps the connection open, so without this a
+ * session looks active while every page command waits for a timeout. A
+ * reload (or any main-frame navigation) brings the page back.
+ */
+import { CDPHandlerRegistry } from '../connection/handlers.js';
+import { TypedCDPConnection } from '../connection/typed-cdp.js';
+import { CommandError } from '../errors/index.js';
+import { pageCrashedError } from '../errors/messages.js';
+import { createLogger } from '../ui/logging/index.js';
+import { getErrorMessage } from '../utils/errors.js';
+import { EXIT_CODES } from '../utils/exitCodes.js';
+const log = createLogger('page-crash');
+/**
+ * Start tracking renderer crashes of the page.
+ *
+ * @param cdp - CDP connection to the page
+ * @param onChange - Called with the crash time when the page crashes, and
+ *   with undefined when it is loaded again
+ * @returns Cleanup that stops tracking
+ */
+export async function startCrashTracking(cdp, onChange) {
+    const registry = new CDPHandlerRegistry();
+    const typed = new TypedCDPConnection(cdp);
+    registry.registerTyped(typed, 'Inspector.targetCrashed', () => {
+        log.info('The page crashed (renderer gone)');
+        onChange(Date.now());
+    });
+    registry.registerTyped(typed, 'Inspector.targetReloadedAfterCrash', () => onChange(undefined));
+    registry.registerTyped(typed, 'Page.frameNavigated', ({ frame }) => {
+        if (frame.parentId === undefined)
+            onChange(undefined);
+    });
+    try {
+        await cdp.send('Inspector.enable');
+    }
+    catch (error) {
+        log.debug(`Crash reports unavailable: ${getErrorMessage(error)}`);
+    }
+    return () => registry.cleanup();
+}
+/**
+ * Error for a page command after the page's renderer crashed (exit 107).
+ *
+ * @param crashedAt - When it crashed (epoch ms)
+ * @returns Error with the way back
+ */
+export function pageCrashedCommandError(crashedAt) {
+    const err = pageCrashedError(crashedAt);
+    return new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.PAGE_CRASHED);
+}
+//# sourceMappingURL=pageCrash.js.map

package/dist/types.d.ts

@@ -226,10 +226,14 @@ export interface BdgOutput {
     };
     /** Navigation id of the page currently loaded (live previews) */
     currentNavigationId?: number;
+    /** When the page's renderer crashed (epoch ms), while it is not loaded again */
+    pageCrashedAt?: number;
     /** Counts of all captured items matching the request (e.g. `peek --type`), when `data` holds only the most recent ones */
     totals?: {
         network: number;
         console: number;
+        /** Console messages dropped at the limit, oldest first (indices start after them) */
+        consoleDropped?: number;
     };
     error?: string;
     partial?: boolean;
@@ -327,6 +331,8 @@ export interface DomContext {
     children?: string[];
     /** Number of child elements, for an element without text */
     childCount?: number;
+    /** The children listed are those of its shadow root (a web component) */
+    shadowChildren?: boolean;
     /** Attributes that identify it by its type (see {@link KeyAttributes}) */
     attributes?: KeyAttributes;
     /** A field holding a secret (password, card, one-time code): its value is shown masked */
@@ -438,6 +444,14 @@ export interface DomQueryResult {
         /** Unique selector for this node (set by form discovery) */
         selector?: string;
     }>;
+    /** Matches not listed (`--limit`); `count` is all of them */
+    omitted?: number;
+    /** Matches usable by index (described and cached), when fewer than `count` */
+    indexed?: number;
+    /** First matches whose viewport position was checked (`inViewport`), when more are listed */
+    viewportChecked?: number;
+    /** Identity of the page document the matches belong to (cached results only) */
+    document?: string;
 }
 /**
  * Result of a DOM get operation.
@@ -679,5 +693,7 @@ export interface InstalledSkill {
     target: SkillTarget;
     path: string;
     status: 'installed' | 'updated' | 'unchanged';
+    /** Where the replaced copy was kept (`updated` only) */
+    backup?: string;
 }
 //# sourceMappingURL=types.d.ts.map