browser-debugger-cli 0.7.1 → 0.8.0

package/dist/telemetry/console.js

@@ -1,17 +1,27 @@
 /**
- * Console message collection via CDP Runtime domain.
+ * Console message collection via CDP Runtime and Log domains.
  *
  * Captures console.log, console.error, etc. and JavaScript exceptions
- * with automatic nested object expansion.
+ * with automatic nested object expansion, browser messages (failed loads,
+ * CORS, security, deprecations), and the same from cross-origin iframes and
+ * workers.
  */
 import { CDPHandlerRegistry } from '../connection/handlers.js';
 import { TypedCDPConnection } from '../connection/typed-cdp.js';
 import { MAX_CONSOLE_MESSAGES } from '../constants.js';
+import { attachChildTargets } from './attachedTargets.js';
 import { createLogger } from '../ui/logging/index.js';
 import { shouldExcludeConsoleMessage } from './filters.js';
-import { expandConsoleArgs } from './objectExpander.js';
-import { formatConsoleArgs } from './remoteObject.js';
+import { expandConsoleArgs, senderFor } from './objectExpander.js';
+import { formatConsoleArgs, usesFormatSpecifiers } from './remoteObject.js';
 import { needsAsyncExpansion } from './remoteObjectUtils.js';
+/** Console message type of each browser log level */
+const LOG_LEVEL_TYPES = {
+    verbose: 'debug',
+    info: 'info',
+    warning: 'warning',
+    error: 'error',
+};
 const log = createLogger('console');
 /**
  * Convert a CDP call frame to a StackFrame.
@@ -60,6 +70,7 @@ function createMessage(type, text, timestamp, args, context) {
         ...(args && { args }),
         ...(context.navigationId !== undefined && { navigationId: context.navigationId }),
         ...(context.stackTrace && { stackTrace: context.stackTrace }),
+        ...(context.source && { source: context.source }),
     };
 }
 /**
@@ -101,7 +112,7 @@ function handleConsoleAPICall(cdp, messages, params, context, includeAll) {
     if (shouldExcludeConsoleMessage(basicText, params.type, includeAll)) {
         return;
     }
-    if (hasArgsNeedingExpansion(params.args)) {
+    if (hasArgsNeedingExpansion(params.args) && !usesFormatSpecifiers(params.args)) {
         handleExpandableMessage(cdp, messages, params, context, basicText);
     }
     else {
@@ -124,12 +135,46 @@ function handleExpandableMessage(cdp, messages, params, context, fallbackText) {
         insertMessageByTimestamp(messages, message);
     });
 }
+/**
+ * Remove V8 stack frame lines from an error description.
+ *
+ * @param description - Error description: message lines followed by stack frame lines
+ * @returns The message lines only
+ */
+function stripStackFrames(description) {
+    const lines = description.split('\n');
+    const firstFrame = lines.findIndex((line) => /^\s+at\s/.test(line));
+    return (firstFrame === -1 ? lines : lines.slice(0, firstFrame)).join('\n').trim();
+}
+/**
+ * Build the message text for an uncaught exception, as DevTools shows it.
+ *
+ * CDP's `text` is usually just "Uncaught" or "Uncaught (in promise)"; the
+ * actual error lives in `exception.description` (Errors) or `exception.value`
+ * (thrown primitives). The description's stack frames (`    at ...` lines)
+ * are dropped, since the stack is kept separately on the message; multi-line
+ * error messages are kept whole.
+ *
+ * @param details - CDP exception details
+ * @returns e.g. "Uncaught TypeError: x is not a function"
+ */
+export function formatExceptionText(details) {
+    const exception = details.exception;
+    const raw = exception?.description ?? (exception?.value !== undefined ? String(exception.value) : '');
+    const detail = stripStackFrames(raw);
+    const prefix = details.text;
+    if (!detail)
+        return prefix || 'Unknown error';
+    if (!prefix || detail.startsWith(prefix))
+        return detail;
+    return `${prefix} ${detail}`;
+}
 /**
  * Handle an exception thrown event.
  */
 function handleExceptionThrown(messages, params, context, includeAll) {
     const exception = params.exceptionDetails;
-    const text = exception.text ?? exception.exception?.description ?? 'Unknown error';
+    const text = formatExceptionText(exception);
     if (shouldExcludeConsoleMessage(text, 'error', includeAll)) {
         return;
     }
@@ -137,7 +182,62 @@ function handleExceptionThrown(messages, params, context, includeAll) {
     insertMessageByTimestamp(messages, message);
 }
 /**
- * Start collecting console messages and exceptions via CDP Runtime domain.
+ * Handle a browser log entry (failed resource loads, CORS, security,
+ * deprecations). Entries without a stack point at their resource URL.
+ *
+ * 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) {
+    const type = LOG_LEVEL_TYPES[entry.level];
+    if (entry.source === 'worker' || shouldExcludeConsoleMessage(entry.text, type, includeAll)) {
+        return;
+    }
+    const location = entry.url
+        ? [
+            entry.lineNumber === undefined
+                ? { url: entry.url, lineNumber: -1, columnNumber: -1 }
+                : { url: entry.url, lineNumber: entry.lineNumber, columnNumber: 0 },
+        ]
+        : undefined;
+    const context = {
+        navigationId,
+        stackTrace: convertStackTrace(entry.stackTrace) ?? location,
+        source: entry.source,
+    };
+    insertMessageByTimestamp(messages, createMessage(type, entry.text, entry.timestamp, undefined, context));
+}
+/**
+ * Enable console and log events on an attached target's session.
+ *
+ * @param typed - Typed CDP connection
+ * @param sessionId - Session of the attached target
+ */
+async function enableConsoleEvents(typed, sessionId) {
+    await typed.send('Runtime.enable', {}, sessionId);
+    await typed.send('Log.enable', {}, sessionId);
+}
+/**
+ * Enable browser log entries and attach to iframes and workers. Both only add
+ * messages, so a failure is logged and the session keeps the page's console.
+ *
+ * @param cdp - CDP connection
+ * @param typed - Typed CDP connection
+ * @returns Cleanup that stops attaching to new targets
+ */
+async function startOptionalSources(cdp, typed) {
+    try {
+        await typed.send('Log.enable', {});
+        return await attachChildTargets(cdp, (sessionId) => enableConsoleEvents(typed, sessionId));
+    }
+    catch (error) {
+        log.debug(`Browser messages or iframe/worker consoles unavailable: ${String(error)}`);
+        return () => undefined;
+    }
+}
+/**
+ * Start collecting console messages, exceptions and browser log entries from
+ * the page and its cross-origin iframes and workers.
  *
  * @param cdp - CDP connection instance
  * @param messages - Array to populate with console messages
@@ -148,13 +248,12 @@ function handleExceptionThrown(messages, params, context, includeAll) {
 export async function startConsoleCollection(cdp, messages, includeAll = false, getCurrentNavigationId) {
     const registry = new CDPHandlerRegistry();
     const typed = new TypedCDPConnection(cdp);
-    await cdp.send('Runtime.enable');
-    registry.registerTyped(typed, 'Runtime.consoleAPICalled', (params) => {
+    registry.registerTyped(typed, 'Runtime.consoleAPICalled', (params, sessionId) => {
         const context = {
             navigationId: getCurrentNavigationId?.(),
             stackTrace: convertStackTrace(params.stackTrace),
         };
-        handleConsoleAPICall(cdp, messages, params, context, includeAll);
+        handleConsoleAPICall(senderFor(cdp, sessionId), messages, params, context, includeAll);
     });
     registry.registerTyped(typed, 'Runtime.exceptionThrown', (params) => {
         const context = {
@@ -163,8 +262,20 @@ export async function startConsoleCollection(cdp, messages, includeAll = false,
         };
         handleExceptionThrown(messages, params, context, includeAll);
     });
-    return () => {
+    registry.registerTyped(typed, 'Log.entryAdded', ({ entry }) => {
+        handleLogEntry(messages, entry, getCurrentNavigationId?.(), includeAll);
+    });
+    try {
+        await typed.send('Runtime.enable', {});
+    }
+    catch (error) {
+        registry.cleanup();
+        throw error;
+    }
+    const detachChildren = await startOptionalSources(cdp, typed);
+    return async () => {
         registry.cleanup();
+        await detachChildren();
     };
 }
 //# sourceMappingURL=console.js.map

package/dist/telemetry/dialogs.d.ts

@@ -1,5 +1,6 @@
 import type { CDPConnection } from '../connection/cdp.js';
-import type { CleanupFunction } from '../types';
+import type { DialogInfo } from '../ipc/protocol/domTypes.js';
+import type { CleanupFunction } from '../types.js';
 /**
  * Start auto-dismissing JavaScript dialogs to prevent collection blocking.
  *
@@ -8,6 +9,7 @@ import type { CleanupFunction } from '../types';
  * further telemetry collection.
  *
  * @param cdp - CDP connection instance
+ * @param onDialog - Called for each accepted dialog
  * @returns Cleanup function to remove event handlers
  *
  * @remarks
@@ -23,5 +25,5 @@ import type { CleanupFunction } from '../types';
  * cleanup(); // Stop handling dialogs
  * ```
  */
-export declare function startDialogHandling(cdp: CDPConnection): Promise<CleanupFunction>;
+export declare function startDialogHandling(cdp: CDPConnection, onDialog?: (dialog: DialogInfo) => void): Promise<CleanupFunction>;
 //# sourceMappingURL=dialogs.d.ts.map

package/dist/telemetry/dialogs.js

@@ -10,6 +10,7 @@ const log = createLogger('dialogs');
  * further telemetry collection.
  *
  * @param cdp - CDP connection instance
+ * @param onDialog - Called for each accepted dialog
  * @returns Cleanup function to remove event handlers
  *
  * @remarks
@@ -25,12 +26,13 @@ const log = createLogger('dialogs');
  * cleanup(); // Stop handling dialogs
  * ```
  */
-export async function startDialogHandling(cdp) {
+export async function startDialogHandling(cdp, onDialog) {
     const registry = new CDPHandlerRegistry();
     const typed = new TypedCDPConnection(cdp);
     await cdp.send('Page.enable');
     registry.registerTyped(typed, 'Page.javascriptDialogOpening', (params) => {
         log.debug(`Auto-dismissing ${params.type} dialog: "${params.message}" from ${params.url}`);
+        onDialog?.({ type: params.type, message: params.message });
         void cdp
             .send('Page.handleJavaScriptDialog', {
             accept: true,

package/dist/telemetry/dom.d.ts

@@ -1,5 +1,5 @@
 import type { CDPConnection } from '../connection/cdp.js';
-import type { DOMData, CleanupFunction } from '../types';
+import type { CleanupFunction } from '../types.js';
 /**
  * Prepare CDP domains for DOM collection.
  *
@@ -9,14 +9,4 @@ import type { DOMData, CleanupFunction } from '../types';
  * @returns Cleanup function that disables Runtime domain
  */
 export declare function prepareDOMCollection(cdp: CDPConnection): Promise<CleanupFunction>;
-/**
- * Capture a complete DOM snapshot of the current page.
- *
- * Called during session shutdown to get the final state of the page.
- * Parallelizes independent CDP calls for better performance.
- *
- * @param cdp - CDP connection instance
- * @returns DOM data including URL, title, full HTML, and A11y tree
- */
-export declare function collectDOM(cdp: CDPConnection): Promise<DOMData>;
 //# sourceMappingURL=dom.d.ts.map

package/dist/telemetry/dom.js

@@ -1,9 +1,6 @@
 import { createLogger } from '../ui/logging/index.js';
 import { getErrorMessage } from '../utils/errors.js';
-import { buildTreeFromRawNodes } from './a11y.js';
-import { withTimeout } from './utils.js';
 const log = createLogger('dom');
-const CDP_TIMEOUT = 5000;
 /**
  * Prepare CDP domains for DOM collection.
  *
@@ -27,103 +24,4 @@ export async function prepareDOMCollection(cdp) {
         }
     };
 }
-/**
- * Get the root node of the DOM tree.
- */
-async function getDocumentRoot(cdp) {
-    const response = await withTimeout(cdp.send('DOM.getDocument', { depth: -1 }), CDP_TIMEOUT, 'DOM.getDocument');
-    return response.root;
-}
-/**
- * Get the outer HTML of a node.
- */
-async function getOuterHTML(cdp, nodeId) {
-    const response = await withTimeout(cdp.send('DOM.getOuterHTML', { nodeId }), CDP_TIMEOUT, 'DOM.getOuterHTML');
-    return response.outerHTML;
-}
-/**
- * Get the main frame information.
- */
-async function getMainFrame(cdp) {
-    const response = await withTimeout(cdp.send('Page.getFrameTree'), CDP_TIMEOUT, 'Page.getFrameTree');
-    return response.frameTree.frame;
-}
-/**
- * Get the document title using Runtime.evaluate.
- */
-async function getDocumentTitle(cdp) {
-    try {
-        const result = await withTimeout(cdp.send('Runtime.evaluate', {
-            expression: 'document.title',
-            returnByValue: true,
-        }), CDP_TIMEOUT, 'Runtime.evaluate');
-        if (result.result.value !== undefined && typeof result.result.value === 'string') {
-            return result.result.value;
-        }
-    }
-    catch (error) {
-        log.debug(`Failed to get document title: ${getErrorMessage(error)}`);
-    }
-    return 'Untitled';
-}
-/**
- * Capture accessibility tree from the current page.
- *
- * @param cdp - CDP connection instance
- * @returns A11y tree with nodes serialized as plain object, or undefined on error
- */
-async function collectA11yTree(cdp) {
-    try {
-        await cdp.send('Accessibility.enable');
-        const response = (await withTimeout(cdp.send('Accessibility.getFullAXTree', {}), CDP_TIMEOUT, 'Accessibility.getFullAXTree'));
-        if (!response.nodes) {
-            return undefined;
-        }
-        const tree = buildTreeFromRawNodes(response.nodes);
-        await cdp.send('Accessibility.disable').catch(() => {
-            /* Ignore errors */
-        });
-        return {
-            root: tree.root,
-            nodes: Object.fromEntries(tree.nodes),
-            count: tree.count,
-        };
-    }
-    catch (error) {
-        log.debug(`A11y tree capture failed: ${getErrorMessage(error)}`);
-        return undefined;
-    }
-}
-/**
- * Capture a complete DOM snapshot of the current page.
- *
- * Called during session shutdown to get the final state of the page.
- * Parallelizes independent CDP calls for better performance.
- *
- * @param cdp - CDP connection instance
- * @returns DOM data including URL, title, full HTML, and A11y tree
- */
-export async function collectDOM(cdp) {
-    try {
-        // Run independent CDP calls in parallel for better performance
-        const [root, frame, title, a11yTree] = await Promise.all([
-            getDocumentRoot(cdp),
-            getMainFrame(cdp),
-            getDocumentTitle(cdp),
-            collectA11yTree(cdp),
-        ]);
-        // getOuterHTML depends on root.nodeId, so it must be sequential
-        const outerHTML = await getOuterHTML(cdp, root.nodeId);
-        return {
-            url: frame.url,
-            title,
-            outerHTML,
-            ...(a11yTree && { a11yTree }),
-        };
-    }
-    catch (error) {
-        log.info(`DOM capture failed: ${getErrorMessage(error)}`);
-        throw error;
-    }
-}
 //# sourceMappingURL=dom.js.map

package/dist/telemetry/filterDsl.d.ts

@@ -6,7 +6,7 @@
  * header inspection, and various state filters.
  */
 import type { NetworkRequest } from '../types.js';
-export type FilterType = 'domain' | 'status-code' | 'method' | 'mime-type' | 'resource-type' | 'larger-than' | 'has-response-header' | 'is' | 'scheme';
+export type FilterType = 'domain' | 'status-code' | 'method' | 'mime-type' | 'resource-type' | 'larger-than' | 'duration' | 'has-response-header' | 'is' | 'scheme';
 export type ComparisonOperator = '=' | '>=' | '<=' | '>' | '<';
 export interface ParsedFilter {
     type: FilterType;
@@ -22,6 +22,14 @@ export type FilterValidationResult = {
     error: string;
     suggestion?: string;
 };
+/**
+ * Parse a duration into milliseconds.
+ *
+ * @param value - e.g. "500", "500ms", "1.5s"
+ * @returns Milliseconds
+ * @throws Error for another format
+ */
+export declare function parseDuration(value: string): number;
 /**
  * Parse a size string with units into bytes.
  */

package/dist/telemetry/filterDsl.js

@@ -5,8 +5,10 @@
  * Supports domain matching, status codes, HTTP methods, MIME types, size thresholds,
  * header inspection, and various state filters.
  */
-import { matchesWildcard } from '../telemetry/filters.js';
+import { RESOURCE_TYPE_ABBREVIATIONS, resourceTypeFromName } from '../constants.js';
+import { matchesWildcard } from './filters.js';
 import { createLogger } from '../ui/logging/index.js';
+import { findSimilar } from '../utils/suggestions.js';
 import { extractHostname } from '../utils/url.js';
 const log = createLogger('network');
 const SIZE_UNITS = {
@@ -22,11 +24,29 @@ const VALID_FILTER_TYPES = [
     'mime-type',
     'resource-type',
     'larger-than',
+    'duration',
     'has-response-header',
     'is',
     'scheme',
 ];
-const VALID_IS_VALUES = ['from-cache', 'running'];
+/** CDP resource types (the keys of the TYP abbreviations) */
+const RESOURCE_TYPES = Object.keys(RESOURCE_TYPE_ABBREVIATIONS);
+const DURATION_PATTERN = /^(\d+(?:\.\d+)?)\s*(ms|s)?$/i;
+/**
+ * Parse a duration into milliseconds.
+ *
+ * @param value - e.g. "500", "500ms", "1.5s"
+ * @returns Milliseconds
+ * @throws Error for another format
+ */
+export function parseDuration(value) {
+    const match = DURATION_PATTERN.exec(value);
+    if (!match)
+        throw new Error(`Invalid duration: "${value}". Use format like "500ms" or "1.5s"`);
+    const amount = parseFloat(match[1] ?? '0');
+    return match[2]?.toLowerCase() === 's' ? amount * 1000 : amount;
+}
+const VALID_IS_VALUES = ['from-cache', 'running', 'failed'];
 const SIZE_PATTERN = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i;
 const QUOTED_TOKEN_PATTERN = /(?:[^\s"]+|"[^"]*")+/g;
 /**
@@ -51,8 +71,64 @@ function extractOperator(value) {
         return ['>', value.slice(1)];
     if (value.startsWith('<'))
         return ['<', value.slice(1)];
+    if (value.startsWith('='))
+        return ['=', value.slice(1)];
     return ['=', value];
 }
+/** Filter types whose value may start with a comparison operator */
+const COMPARABLE_TYPES = new Set(['status-code', 'larger-than', 'duration']);
+/**
+ * Check a filter value of a type with a fixed vocabulary or format.
+ *
+ * @param type - Filter type
+ * @param value - Value (after any operator)
+ * @returns An error, or null if the value is valid
+ */
+function validateFilterValue(type, value) {
+    switch (type) {
+        case 'is':
+            return validateIsValue(value);
+        case 'larger-than':
+            return validateSizeValue(value);
+        case 'status-code':
+            return validateStatusCode(value);
+        case 'duration':
+            return validateDuration(value);
+        case 'resource-type':
+            return validateResourceTypes(value);
+        default:
+            return null;
+    }
+}
+/**
+ * Check a duration value.
+ *
+ * @param value - Duration text
+ * @returns An error, or null if valid
+ */
+function validateDuration(value) {
+    return DURATION_PATTERN.test(value)
+        ? null
+        : createError(`Invalid duration: "${value}"`, 'Use format like "500ms", "1.5s" or "1000"');
+}
+/**
+ * Check that every comma-separated resource type exists.
+ *
+ * @param value - e.g. "XHR,Fetch"
+ * @returns An error with a did-you-mean, or null if all are known
+ */
+function validateResourceTypes(value) {
+    const unknown = value
+        .split(',')
+        .map((type) => type.trim())
+        .find((type) => resourceTypeFromName(type) === undefined);
+    if (unknown === undefined)
+        return null;
+    const similar = findSimilar(unknown, RESOURCE_TYPES);
+    return createError(`Unknown resource type: "${unknown}"`, similar.length > 0
+        ? `Did you mean: ${similar[0]}?`
+        : `Valid types: ${RESOURCE_TYPES.join(', ')}`);
+}
 function findSimilarTypes(input) {
     const lowerInput = input.toLowerCase();
     return VALID_FILTER_TYPES.filter((type) => {
@@ -119,27 +195,13 @@ function parseFilterToken(token) {
     const typeError = validateFilterType(type);
     if (typeError)
         return typeError;
-    let operator = '=';
-    let value = rawValue;
-    if (type === 'status-code' || type === 'larger-than') {
-        [operator, value] = extractOperator(rawValue);
-    }
-    if (type === 'is') {
-        const isError = validateIsValue(value);
-        if (isError)
-            return isError;
-        value = value.toLowerCase();
-    }
-    if (type === 'larger-than') {
-        const sizeError = validateSizeValue(value);
-        if (sizeError)
-            return sizeError;
-    }
-    if (type === 'status-code') {
-        const statusError = validateStatusCode(value);
-        if (statusError)
-            return statusError;
-    }
+    const [operator, operand] = COMPARABLE_TYPES.has(type)
+        ? extractOperator(rawValue)
+        : ['=', rawValue];
+    const valueError = validateFilterValue(type, operand);
+    if (valueError)
+        return valueError;
+    const value = type === 'is' ? operand.toLowerCase() : operand;
     return { type: type, value, negated, operator };
 }
 function tokenize(input) {
@@ -220,7 +282,7 @@ function matchesFilter(request, filter) {
         case 'domain':
             return matchesWildcard(extractHostname(request.url), filter.value);
         case 'status-code':
-            if (request.status === undefined)
+            if (!request.status)
                 return false;
             return compareNumeric(request.status, parseInt(filter.value, 10), filter.operator);
         case 'method':
@@ -229,14 +291,14 @@ function matchesFilter(request, filter) {
             if (!request.mimeType)
                 return false;
             const normalizedMime = normalizeMimeType(request.mimeType);
-            const filterValue = filter.value.toLowerCase();
+            const filterValue = filter.value.toLowerCase().replace(/\*$/, '');
             return normalizedMime === filterValue || normalizedMime.startsWith(filterValue);
         }
         case 'resource-type': {
             if (!request.resourceType)
                 return false;
-            const types = filter.value.split(',').map((t) => t.trim().toLowerCase());
-            return types.includes(request.resourceType.toLowerCase());
+            const types = filter.value.split(',').map((t) => resourceTypeFromName(t));
+            return types.includes(request.resourceType);
         }
         case 'larger-than': {
             const size = request.encodedDataLength ?? 0;
@@ -244,6 +306,9 @@ function matchesFilter(request, filter) {
             const effectiveOperator = filter.operator === '=' ? '>' : filter.operator;
             return compareNumeric(size, threshold, effectiveOperator);
         }
+        case 'duration':
+            return (request.duration !== undefined &&
+                compareNumeric(request.duration, parseDuration(filter.value), filter.operator === '=' ? '>=' : filter.operator));
         case 'has-response-header': {
             if (!request.responseHeaders)
                 return false;
@@ -251,10 +316,13 @@ function matchesFilter(request, filter) {
             return Object.keys(request.responseHeaders).some((h) => h.toLowerCase() === headerName);
         }
         case 'is':
-            if (filter.value === 'from-cache')
-                return matchesCacheHeaders(request.responseHeaders);
+            if (filter.value === 'from-cache') {
+                return request.fromCache === true || matchesCacheHeaders(request.responseHeaders);
+            }
             if (filter.value === 'running')
                 return request.status === undefined;
+            if (filter.value === 'failed')
+                return request.status === 0;
             return false;
         case 'scheme':
             return extractScheme(request.url).toLowerCase() === filter.value.toLowerCase();
@@ -277,15 +345,17 @@ export function applyFilters(requests, filters) {
 export function getFilterHelpText() {
     return `
 Filter syntax:
-  status-code:>=400       HTTP status codes (supports =, >=, <=, >, <)
+  status-code:>=400       HTTP status codes (supports =, >=, <=, >, <; status-code:=500 or :500)
   domain:api.*            Domain with wildcards
   method:POST             HTTP method
   mime-type:application/json
   resource-type:XHR,Fetch CDP resource types (comma-separated)
   larger-than:100KB       Size threshold (B, KB, MB, GB)
+  duration:>1s            Request time (ms or s; supports =, >=, <=, >, <; a bare value means at least)
   has-response-header:set-cookie
-  is:from-cache           Cached responses
+  is:from-cache           Served from browser cache (or a CDN cache hit)
   is:running              In-progress requests
+  is:failed               Requests that got no response (DNS, refused, aborted, blocked)
   scheme:https            URL scheme
 
 Negation (use ! to avoid CLI conflicts with -):

package/dist/telemetry/filterPresets.js

@@ -3,7 +3,7 @@
  *
  * Provides convenient shortcuts for frequently used filter combinations.
  */
-import { CommandError } from '../ui/errors/index.js';
+import { CommandError } from '../errors/index.js';
 import { EXIT_CODES } from '../utils/exitCodes.js';
 import { getSuggestion } from '../utils/suggestions.js';
 /**
@@ -12,7 +12,7 @@ import { getSuggestion } from '../utils/suggestions.js';
 export const FILTER_PRESETS = {
     errors: {
         name: 'errors',
-        description: 'Failed requests (4xx and 5xx status codes)',
+        description: 'HTTP error responses (4xx and 5xx status codes)',
         filter: 'status-code:>=400',
     },
     api: {
@@ -45,11 +45,21 @@ export const FILTER_PRESETS = {
         description: 'JavaScript files',
         filter: 'resource-type:Script',
     },
+    failed: {
+        name: 'failed',
+        description: 'Requests that got no response (DNS, refused, aborted, blocked)',
+        filter: 'is:failed',
+    },
     pending: {
         name: 'pending',
         description: 'In-progress requests (no response yet)',
         filter: 'is:running',
     },
+    slow: {
+        name: 'slow',
+        description: 'Requests that took at least 1 second',
+        filter: 'duration:>=1s',
+    },
 };
 /**
  * Resolve a preset name to its filter string.

package/dist/telemetry/filters.d.ts

@@ -16,7 +16,7 @@ export interface BodyFetchDecision {
  * Domains to exclude by default (common tracking/analytics)
  * These generate high volume but are rarely useful for debugging
  */
-export declare const DEFAULT_EXCLUDED_DOMAINS: readonly ["analytics.google.com", "googletagmanager.com", "googleadservices.com", "doubleclick.net", "google-analytics.com", "clarity.ms", "bat.bing.com", "facebook.com", "connect.facebook.net", "tiktok.com", "linkedin.com", "twitter.com", "snapchat.com", "mixpanel.com", "segment.com", "segment.io", "amplitude.com", "heap.io", "fullstory.com", "hotjar.com", "logrocket.com", "smartlook.com", "exactag.com", "criteo.com", "adroll.com", "outbrain.com", "taboola.com", "confirmit.com", "newrelic.com", "datadoghq.com", "sentry.io"];
+export declare const DEFAULT_EXCLUDED_DOMAINS: readonly ["analytics.google.com", "googletagmanager.com", "googleadservices.com", "doubleclick.net", "google-analytics.com", "clarity.ms", "bat.bing.com", "facebook.com", "connect.facebook.net", "tiktok.com", "linkedin.com", "twitter.com", "snapchat.com", "mixpanel.com", "segment.com", "segment.io", "amplitude.com", "heap.io", "fullstory.com", "hotjar.com", "logrocket.com", "smartlook.com", "exactag.com", "criteo.com", "adroll.com", "outbrain.com", "taboola.com", "confirmit.com", "newrelic.com", "datadoghq.com", "sentry.io", "googlesyndication.com", "googletagservices.com", "adservice.google.com", "amazon-adsystem.com", "adnxs.com", "rubiconproject.com", "pubmatic.com", "casalemedia.com", "indexww.com", "openx.net", "3lift.com", "teads.tv", "bidswitch.net", "sharethrough.com", "adsafeprotected.com", "moatads.com", "doubleverify.com", "scorecardresearch.com", "imrworldwide.com", "chartbeat.com", "chartbeat.net", "permutive.com", "permutive.app", "optimizely.com", "quantserve.com", "quantcount.com", "krxd.net", "demdex.net", "omtrdc.net", "everesttech.net", "xiti.com", "ati-host.net"];
 /**
  * Console message types to exclude by default (Redux/React DevTools noise)
  */