browser-debugger-cli 0.8.0 → 0.10.0

package/dist/telemetry/a11y.d.ts

@@ -24,10 +24,22 @@ export declare function buildTreeFromRawNodes(rawNodes: Protocol.Accessibility.A
  * @throws Error if CDP Accessibility domain fails
  */
 export declare function collectA11yTree(): Promise<A11yTree>;
+/**
+ * The tree with the values of secret fields masked ({@link MASKED_VALUE},
+ * whatever their length), and the names and values of the nodes inside them
+ * left out (the text Chrome lists under a text field is its value).
+ *
+ * @param tree - Accessibility tree
+ * @param secretIds - Node ids of secret fields
+ * @returns The same tree (nodes replaced in place)
+ */
+export declare function maskSecretValues(tree: A11yTree, secretIds: ReadonlySet<string>): A11yTree;
 /**
  * Queries accessibility tree by pattern (role, name, description).
  *
  * Performs case-insensitive matching with AND logic for multiple fields.
+ * An element reported more than once (by the page's tree and its frame's)
+ * is listed once.
  *
  * @param tree - Accessibility tree to search
  * @param pattern - Query pattern with optional role, name, description
@@ -50,18 +62,21 @@ export declare function queryA11yTree(tree: A11yTree, pattern: A11yQueryPattern)
  * Parses query pattern string into A11yQueryPattern object.
  *
  * Fields are `key:value` or `key=value`, separated by spaces or commas.
- * Values may contain spaces (quote them if they contain `key:`-like text).
- * Keys: role, name, description (desc). Case-insensitive.
+ * Keys: role, name, description (desc). Case-insensitive. A role ends at the
+ * next `key:`; a name or description runs to the next role/name/description
+ * field with a value, or to the end, so it may contain spaces and colons
+ * (`name=E-mail address:`). Quote a value to end it explicitly.
  *
  * @param patternString - Query pattern string
  * @returns Parsed query pattern
- * @throws CommandError (81) for unknown keys
+ * @throws CommandError (81) for unknown keys, also a misspelled one inside a name
  *
  * @example
  * ```typescript
  * parseQueryPattern('role:button name:Submit')     // { role: 'button', name: 'Submit' }
  * parseQueryPattern('role=link,name=Google Chrome') // { role: 'link', name: 'Google Chrome' }
  * parseQueryPattern('name:"Sign in" role:button')  // { name: 'Sign in', role: 'button' }
+ * parseQueryPattern('name=E-mail address:')        // { name: 'E-mail address:' }
  * ```
  */
 export declare function parseQueryPattern(patternString: string): A11yQueryPattern;

package/dist/telemetry/a11y.js

@@ -1,7 +1,11 @@
 import { CommandError } from '../errors/index.js';
 import { unknownQueryFieldError } from '../errors/messages.js';
 import { 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';
 import { EXIT_CODES } from '../utils/exitCodes.js';
+import { levenshteinDistance } from '../utils/levenshtein.js';
 /**
  * Builds accessibility tree from raw CDP nodes.
  *
@@ -78,12 +82,87 @@ export async function collectA11yTree() {
         if (!result?.nodes) {
             throw new CommandError('Failed to get accessibility tree', { suggestion: 'CDP returned no nodes. The page may not be fully loaded.' }, EXIT_CODES.SOFTWARE_ERROR);
         }
-        return buildTreeFromRawNodes([...result.nodes, ...(await collectFrameNodes(result.nodes))]);
+        const tree = buildTreeFromRawNodes([
+            ...result.nodes,
+            ...(await collectFrameNodes(result.nodes)),
+        ]);
+        return maskSecretValues(tree, await sensitiveNodeIds(tree));
     }
     finally {
         await callCDP('Accessibility.disable', {});
     }
 }
+/** Concurrent page checks for {@link sensitiveNodeIds} */
+const SENSITIVE_CHECK_CONCURRENCY = 10;
+/**
+ * The accessibility nodes whose value is a secret: nodes with a value whose
+ * element is a sensitive field ({@link SENSITIVE_FIELD_JS}: passwords, card
+ * fields, one-time codes). Only nodes with a value are checked, one page
+ * call each (a page has few).
+ *
+ * @param tree - Accessibility tree
+ * @returns Node ids of secret fields
+ */
+async function sensitiveNodeIds(tree) {
+    const candidates = [...tree.nodes.values()].filter((node) => node.value !== undefined && node.backendDOMNodeId !== undefined);
+    const limiter = new ConcurrencyLimiter(SENSITIVE_CHECK_CONCURRENCY);
+    const checked = await Promise.all(candidates.map((node) => limiter.run(async () => (await isSensitiveField(node.backendDOMNodeId ?? 0)) ? node.nodeId : null)));
+    return new Set(checked.filter((id) => id !== null));
+}
+/**
+ * Whether an element is a sensitive field. An element that cannot be read
+ * counts as one, so a value is never shown by mistake.
+ *
+ * @param backendNodeId - The element
+ * @returns True for secret fields (and unreadable elements)
+ */
+async function isSensitiveField(backendNodeId) {
+    const objectGroup = 'bdg-a11y-secret';
+    const resolved = await callCDP('DOM.resolveNode', { backendNodeId, objectGroup });
+    const objectId = resolved.data?.result?.object
+        ?.objectId;
+    if (!objectId)
+        return true;
+    try {
+        const response = await callCDP('Runtime.callFunctionOn', {
+            objectId,
+            functionDeclaration: `function () { return this.nodeType !== 1 || (${SENSITIVE_FIELD_JS})(this); }`,
+            returnByValue: true,
+        });
+        const value = response.data?.result?.result
+            ?.value;
+        return value !== false;
+    }
+    finally {
+        await callCDP('Runtime.releaseObjectGroup', { objectGroup });
+    }
+}
+/**
+ * The tree with the values of secret fields masked ({@link MASKED_VALUE},
+ * whatever their length), and the names and values of the nodes inside them
+ * left out (the text Chrome lists under a text field is its value).
+ *
+ * @param tree - Accessibility tree
+ * @param secretIds - Node ids of secret fields
+ * @returns The same tree (nodes replaced in place)
+ */
+export function maskSecretValues(tree, secretIds) {
+    const hide = (nodeId, inside) => {
+        const node = tree.nodes.get(nodeId);
+        if (!node)
+            return;
+        const { name: _name, value: _value, ...rest } = node;
+        const masked = inside
+            ? rest
+            : { ...node, ...(node.value !== undefined && { value: MASKED_VALUE }) };
+        tree.nodes.set(nodeId, masked);
+        if (tree.root.nodeId === nodeId)
+            tree.root = masked;
+        node.childIds?.forEach((childId) => hide(childId, true));
+    };
+    secretIds.forEach((nodeId) => hide(nodeId, false));
+    return tree;
+}
 /**
  * Accessibility nodes of the page's iframes, attached under their `Iframe`
  * node (the page's own tree stops there). Frames in another process
@@ -98,22 +177,13 @@ async function collectFrameNodes(pageNodes) {
     const tree = (await callCDP('Page.getFrameTree', {})).data?.result;
     const known = [...pageNodes];
     const collected = [];
-    for (const [index, frameId] of childFrames(tree?.frameTree).entries()) {
+    for (const [index, frameId] of childFrameIds(tree?.frameTree).entries()) {
         const nodes = await frameNodes(frameId, `f${index}:`, known);
         known.push(...nodes);
         collected.push(...nodes);
     }
     return collected;
 }
-/**
- * Ids of all frames below a frame tree's root.
- *
- * @param tree - Frame tree
- * @returns Frame ids, depth-first
- */
-function childFrames(tree) {
-    return (tree?.childFrames ?? []).flatMap((child) => [child.frame.id, ...childFrames(child)]);
-}
 /**
  * One frame's nodes, with ids prefixed, its root attached to the node of its
  * `<iframe>` element.
@@ -234,6 +304,8 @@ const TEXT_ROLES = new Set(['statictext', 'inlinetextbox']);
  * Queries accessibility tree by pattern (role, name, description).
  *
  * Performs case-insensitive matching with AND logic for multiple fields.
+ * An element reported more than once (by the page's tree and its frame's)
+ * is listed once.
  *
  * @param tree - Accessibility tree to search
  * @param pattern - Query pattern with optional role, name, description
@@ -253,13 +325,19 @@ const TEXT_ROLES = new Set(['statictext', 'inlinetextbox']);
  */
 export function queryA11yTree(tree, pattern) {
     const matches = [];
+    const seenElements = new Set();
     const wantsText = pattern.role !== undefined && TEXT_ROLES.has(pattern.role.toLowerCase());
     for (const node of tree.nodes.values()) {
         if (!wantsText && TEXT_ROLES.has(node.role.toLowerCase()))
             continue;
-        if (matchesPattern(node, pattern)) {
-            matches.push(node);
+        if (!matchesPattern(node, pattern))
+            continue;
+        if (node.backendDOMNodeId !== undefined) {
+            if (seenElements.has(node.backendDOMNodeId))
+                continue;
+            seenElements.add(node.backendDOMNodeId);
         }
+        matches.push(node);
     }
     return {
         nodes: matches,
@@ -317,47 +395,110 @@ const QUERY_FIELDS = {
     description: 'description',
     desc: 'description',
 };
+/** The next `key:`/`key=` anywhere (fields may follow other text). */
+const QUERY_KEY = /([a-z]+)\s*[:=]/i;
+/** A quoted value (it may contain anything but its own quote). */
+const QUOTED_QUERY_VALUE = /^\s*("[^"]*"|'[^']*')/;
+/** Where a role value ends: at the next `key:` after a space or comma. */
+const NEXT_QUERY_FIELD = /[\s,]+[a-z]+\s*[:=]/i;
 /**
- * One `key:value` (or `key=value`) field: the value is quoted, or runs until
- * the next `key:`/`key=` after a space or comma.
+ * Where a name or description ends: only at a known field that has a value,
+ * so names keep their spaces and colons (`name=E-mail address:`).
  */
-const QUERY_FIELD = /([a-z]+)\s*[:=](?:\s*("[^"]*"|'[^']*')|((?:(?![\s,]+[a-z]+\s*[:=]).)*))/gis;
+const NEXT_KNOWN_QUERY_FIELD = /[\s,]+(?:role|name|description|desc)\s*[:=](?=\s*[^\s,])/i;
+/**
+ * Read one field value.
+ *
+ * @param text - Text after `key:`
+ * @param field - Field the value is for
+ * @returns The value, where it ends in `text`, and whether it was quoted
+ */
+function readQueryValue(text, field) {
+    const quoted = QUOTED_QUERY_VALUE.exec(text);
+    if (quoted?.[1])
+        return { value: quoted[1].slice(1, -1), end: quoted[0].length, quoted: true };
+    const next = (field === 'role' ? NEXT_QUERY_FIELD : NEXT_KNOWN_QUERY_FIELD).exec(text);
+    const end = next ? next.index : text.length;
+    const value = text
+        .slice(0, end)
+        .trim()
+        .replace(/,+$/, '')
+        .replace(/^(["'])(.*)\1$/s, '$2');
+    return { value, end, quoted: false };
+}
 /**
  * Parses query pattern string into A11yQueryPattern object.
  *
  * Fields are `key:value` or `key=value`, separated by spaces or commas.
- * Values may contain spaces (quote them if they contain `key:`-like text).
- * Keys: role, name, description (desc). Case-insensitive.
+ * Keys: role, name, description (desc). Case-insensitive. A role ends at the
+ * next `key:`; a name or description runs to the next role/name/description
+ * field with a value, or to the end, so it may contain spaces and colons
+ * (`name=E-mail address:`). Quote a value to end it explicitly.
  *
  * @param patternString - Query pattern string
  * @returns Parsed query pattern
- * @throws CommandError (81) for unknown keys
+ * @throws CommandError (81) for unknown keys, also a misspelled one inside a name
  *
  * @example
  * ```typescript
  * parseQueryPattern('role:button name:Submit')     // { role: 'button', name: 'Submit' }
  * parseQueryPattern('role=link,name=Google Chrome') // { role: 'link', name: 'Google Chrome' }
  * parseQueryPattern('name:"Sign in" role:button')  // { name: 'Sign in', role: 'button' }
+ * parseQueryPattern('name=E-mail address:')        // { name: 'E-mail address:' }
  * ```
  */
 export function parseQueryPattern(patternString) {
     const pattern = {};
-    for (const [, rawKey = '', quoted, plain = ''] of patternString.matchAll(QUERY_FIELD)) {
-        const rawValue = quoted ?? plain;
+    let rest = patternString;
+    for (let key = QUERY_KEY.exec(rest); key; key = QUERY_KEY.exec(rest)) {
+        const rawKey = key[1] ?? '';
         const field = QUERY_FIELDS[rawKey.toLowerCase()];
-        if (!field) {
-            const err = unknownQueryFieldError(rawKey);
-            throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
-        }
-        const value = rawValue
-            .trim()
-            .replace(/,+$/, '')
-            .replace(/^(["'])(.*)\1$/s, '$2');
+        if (!field)
+            throwUnknownField(rawKey);
+        const valueText = rest.slice(key.index + key[0].length);
+        const { value, end, quoted } = readQueryValue(valueText, field);
+        if (!quoted && field !== 'role')
+            checkMisspelledField(value, field);
         if (value)
             pattern[field] = value;
+        rest = valueText.slice(end);
     }
     return pattern;
 }
+/**
+ * Throw the exit-81 error for an unknown query field.
+ *
+ * @param field - The unrecognized key
+ * @param similar - A known field it looks like a typo of
+ * @param value - The name or description that absorbed it
+ * @throws CommandError (81)
+ */
+function throwUnknownField(field, similar, value) {
+    const err = unknownQueryFieldError(field, similar, value);
+    throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
+}
+/** A `word:`/`word=` inside a name or description. */
+const ABSORBED_KEY = /[\s,]([a-z]+)\s*[:=]/gi;
+/**
+ * Reject a name or description that swallowed a misspelled field
+ * (`name:Save rol:button`): a `word:` within edit distance 1 of role, name or
+ * desc (2 of description). Wider distances would catch common label words
+ * (`Date:`, `Note:`, `Code:`).
+ *
+ * @param value - Unquoted name or description
+ * @param field - Field it is the value of
+ * @throws CommandError (81) with a "did you mean" suggestion
+ */
+function checkMisspelledField(value, field) {
+    for (const [, word = ''] of value.matchAll(ABSORBED_KEY)) {
+        const lower = word.toLowerCase();
+        if (QUERY_FIELDS[lower])
+            continue;
+        const similar = Object.keys(QUERY_FIELDS).find((name) => levenshteinDistance(lower, name) <= (name.length > 4 ? 2 : 1));
+        if (similar)
+            throwUnknownField(word, similar, `${field}=${value}`);
+    }
+}
 /**
  * Resolve accessibility properties for a DOM node via IPC.
  *

package/dist/telemetry/console.d.ts

@@ -2,6 +2,7 @@
  * Console message collection via CDP Runtime and Log domains.
  *
  * Captures console.log, console.error, etc. and JavaScript exceptions
+ * (unhandled rejections removed again when a handler is attached later)
  * with automatic nested object expansion, browser messages (failed loads,
  * CORS, security, deprecations), and the same from cross-origin iframes and
  * workers.

package/dist/telemetry/console.js

@@ -2,6 +2,7 @@
  * Console message collection via CDP Runtime and Log domains.
  *
  * Captures console.log, console.error, etc. and JavaScript exceptions
+ * (unhandled rejections removed again when a handler is attached later)
  * with automatic nested object expansion, browser messages (failed loads,
  * CORS, security, deprecations), and the same from cross-origin iframes and
  * workers.
@@ -76,14 +77,17 @@ function createMessage(type, text, timestamp, args, context) {
 /**
  * Insert a message in timestamp order.
  * Messages are kept sorted by timestamp to handle async expansion delays.
+ *
+ * @returns False when the message limit is reached (the message is dropped)
  */
 function insertMessageByTimestamp(messages, message) {
     if (messages.length >= MAX_CONSOLE_MESSAGES) {
         log.debug(`Warning: Console message limit reached (${MAX_CONSOLE_MESSAGES})`);
-        return;
+        return false;
     }
     const insertIndex = findInsertIndex(messages, message.timestamp);
     messages.splice(insertIndex, 0, message);
+    return true;
 }
 /**
  * Find the correct insertion index to maintain timestamp order.
@@ -171,15 +175,93 @@ export function formatExceptionText(details) {
 }
 /**
  * Handle an exception thrown event.
+ *
+ * @returns The message added, undefined when filtered out or over the limit
  */
 function handleExceptionThrown(messages, params, context, includeAll) {
     const exception = params.exceptionDetails;
     const text = formatExceptionText(exception);
     if (shouldExcludeConsoleMessage(text, 'error', includeAll)) {
-        return;
+        return undefined;
     }
     const message = createMessage('error', text, params.timestamp, undefined, context);
-    insertMessageByTimestamp(messages, message);
+    return insertMessageByTimestamp(messages, message) ? message : undefined;
+}
+/** CDP's text of an unhandled promise rejection (the only kind Chrome revokes) */
+const UNHANDLED_REJECTION_TEXT = 'Uncaught (in promise)';
+/**
+ * Unhandled promise rejections that may still be revoked: Chrome reports a
+ * rejection without a handler at the end of the task, and revokes the
+ * report (`Runtime.exceptionRevoked`) when a handler is attached later, as
+ * DevTools does by removing the message. `bdg dom eval` attaches its
+ * handler only after the evaluation returns, so this is what keeps
+ * `bdg dom eval 'Promise.reject(…)'` out of the console; a rejection
+ * nothing ever handles stays.
+ */
+class RevocableRejections {
+    /** Messages of rejections, by session and exception id, oldest first */
+    pending = new Map();
+    /**
+     * Remember a reported exception if it is an unhandled rejection. Past
+     * {@link MAX_CONSOLE_MESSAGES} rejections, the oldest is forgotten.
+     *
+     * @param details - Exception details
+     * @param message - Its console message
+     * @param sessionId - Session it was reported on (undefined: the page)
+     */
+    track(details, message, sessionId) {
+        if (!details.text.startsWith(UNHANDLED_REJECTION_TEXT))
+            return;
+        this.pending.set(this.key(details.exceptionId, sessionId), message);
+        if (this.pending.size <= MAX_CONSOLE_MESSAGES)
+            return;
+        const [oldest] = this.pending.keys();
+        if (oldest !== undefined)
+            this.pending.delete(oldest);
+    }
+    /**
+     * Remove the message of a revoked rejection.
+     *
+     * @param messages - Console messages (updated)
+     * @param exceptionId - Revoked exception
+     * @param sessionId - Session it was revoked on (undefined: the page)
+     */
+    revoke(messages, exceptionId, sessionId) {
+        const key = this.key(exceptionId, sessionId);
+        const message = this.pending.get(key);
+        this.pending.delete(key);
+        const index = message ? messages.indexOf(message) : -1;
+        if (index !== -1)
+            messages.splice(index, 1);
+    }
+    /**
+     * Forget the rejections of a session whose documents are gone (it
+     * detached, or its contexts were cleared by a navigation): they can no
+     * longer be revoked.
+     *
+     * @param sessionId - Session (undefined: the page)
+     */
+    forgetSession(sessionId) {
+        const prefix = this.key('', sessionId);
+        for (const key of this.pending.keys()) {
+            if (key.startsWith(prefix))
+                this.pending.delete(key);
+        }
+    }
+    /** Forget every rejection (the collection stopped). */
+    clear() {
+        this.pending.clear();
+    }
+    /**
+     * Map key of an exception: ids are counted per session.
+     *
+     * @param exceptionId - Exception id ('' for the session's prefix)
+     * @param sessionId - Session
+     * @returns Key
+     */
+    key(exceptionId, sessionId) {
+        return `${sessionId ?? ''}:${exceptionId}`;
+    }
 }
 /**
  * Handle a browser log entry (failed resource loads, CORS, security,
@@ -255,12 +337,24 @@ export async function startConsoleCollection(cdp, messages, includeAll = false,
         };
         handleConsoleAPICall(senderFor(cdp, sessionId), messages, params, context, includeAll);
     });
-    registry.registerTyped(typed, 'Runtime.exceptionThrown', (params) => {
+    const rejections = new RevocableRejections();
+    registry.registerTyped(typed, 'Runtime.exceptionThrown', (params, sessionId) => {
         const context = {
             navigationId: getCurrentNavigationId?.(),
             stackTrace: convertStackTrace(params.exceptionDetails.stackTrace),
         };
-        handleExceptionThrown(messages, params, context, includeAll);
+        const message = handleExceptionThrown(messages, params, context, includeAll);
+        if (message)
+            rejections.track(params.exceptionDetails, message, sessionId);
+    });
+    registry.registerTyped(typed, 'Runtime.exceptionRevoked', ({ exceptionId }, sessionId) => {
+        rejections.revoke(messages, exceptionId, sessionId);
+    });
+    registry.registerTyped(typed, 'Runtime.executionContextsCleared', (_params, sessionId) => {
+        rejections.forgetSession(sessionId);
+    });
+    registry.registerTyped(typed, 'Target.detachedFromTarget', ({ sessionId }) => {
+        rejections.forgetSession(sessionId);
     });
     registry.registerTyped(typed, 'Log.entryAdded', ({ entry }) => {
         handleLogEntry(messages, entry, getCurrentNavigationId?.(), includeAll);
@@ -275,6 +369,7 @@ export async function startConsoleCollection(cdp, messages, includeAll = false,
     const detachChildren = await startOptionalSources(cdp, typed);
     return async () => {
         registry.cleanup();
+        rejections.clear();
         await detachChildren();
     };
 }

package/dist/telemetry/network.js

@@ -110,7 +110,7 @@ export function skippedBodyReason(body) {
  * @param resourceType - Resource type reported with the response
  */
 function applyResponse(request, response, resourceType) {
-    const { status, mimeType, headers, timing, remoteIPAddress, connectionId } = response;
+    const { status, mimeType, headers, timing, remoteIPAddress, remotePort, connectionId } = response;
     request.status = status;
     if (response.statusText)
         request.statusText = response.statusText;
@@ -138,6 +138,8 @@ function applyResponse(request, response, resourceType) {
     }
     if (remoteIPAddress)
         request.serverIPAddress = remoteIPAddress;
+    if (remotePort)
+        request.serverPort = remotePort;
     if (connectionId !== undefined)
         request.connection = String(connectionId);
 }

package/dist/telemetry/requestKinds.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Which requests an action is about (pages, API calls, sockets) and which
+ * are static assets loaded along the way (stylesheets, scripts, fonts,
+ * images), by CDP resource type.
+ */
+/** Fields a request needs to be classified */
+interface ClassifiedRequest {
+    method?: string | undefined;
+    resourceType?: string | undefined;
+    status?: number | undefined;
+    failed?: true | undefined;
+}
+/**
+ * Whether a request is worth its own line after an action: one of the
+ * {@link ACTIVITY_RESOURCE_TYPES}, one of unknown type, any request that is
+ * not a GET (a `sendBeacon` POST typed `Other`), or an asset that failed (an
+ * HTTP error or no response).
+ *
+ * @param request - Request with its method and CDP resource type
+ * @returns False for assets fetched with GET that loaded normally
+ */
+export declare function isNotableRequest(request: ClassifiedRequest): boolean;
+/**
+ * Short names of the asset types among requests, e.g. `["css", "js", "images"]`
+ * (types without a short name are lowercased, after the known ones).
+ *
+ * @param requests - Asset requests
+ * @returns Distinct names, known types first
+ */
+export declare function assetTypeNames(requests: ClassifiedRequest[]): string[];
+export {};
+//# sourceMappingURL=requestKinds.d.ts.map

package/dist/telemetry/requestKinds.js

@@ -0,0 +1,61 @@
+/**
+ * Which requests an action is about (pages, API calls, sockets) and which
+ * are static assets loaded along the way (stylesheets, scripts, fonts,
+ * images), by CDP resource type.
+ */
+/**
+ * Resource types listed one by one after an action: pages, API calls,
+ * sockets, and the requests a page sends about itself (pings, beacons,
+ * preflights, CSP reports)
+ */
+const ACTIVITY_RESOURCE_TYPES = new Set([
+    'Document',
+    'XHR',
+    'Fetch',
+    'WebSocket',
+    'EventSource',
+    'Ping',
+    'Preflight',
+    'CSPViolationReport',
+]);
+/** Short names of asset types, in the order summaries list them */
+const ASSET_TYPE_NAMES = [
+    ['Stylesheet', 'css'],
+    ['Script', 'js'],
+    ['Font', 'fonts'],
+    ['Image', 'images'],
+    ['Media', 'media'],
+];
+/**
+ * Whether a request is worth its own line after an action: one of the
+ * {@link ACTIVITY_RESOURCE_TYPES}, one of unknown type, any request that is
+ * not a GET (a `sendBeacon` POST typed `Other`), or an asset that failed (an
+ * HTTP error or no response).
+ *
+ * @param request - Request with its method and CDP resource type
+ * @returns False for assets fetched with GET that loaded normally
+ */
+export function isNotableRequest(request) {
+    if (request.resourceType === undefined || ACTIVITY_RESOURCE_TYPES.has(request.resourceType)) {
+        return true;
+    }
+    if (request.method !== undefined && request.method.toUpperCase() !== 'GET')
+        return true;
+    return request.failed === true || (request.status ?? 0) >= 400;
+}
+/**
+ * Short names of the asset types among requests, e.g. `["css", "js", "images"]`
+ * (types without a short name are lowercased, after the known ones).
+ *
+ * @param requests - Asset requests
+ * @returns Distinct names, known types first
+ */
+export function assetTypeNames(requests) {
+    const types = new Set(requests.map((request) => request.resourceType ?? 'Other'));
+    const known = ASSET_TYPE_NAMES.filter(([type]) => types.has(type)).map(([, name]) => name);
+    const others = [...types]
+        .filter((type) => !ASSET_TYPE_NAMES.some(([known]) => known === type))
+        .map((type) => type.toLowerCase());
+    return [...known, ...others];
+}
+//# sourceMappingURL=requestKinds.js.map

package/dist/telemetry/requestState.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Lifecycle state of captured network requests.
+ *
+ * A request is pending until it completes or fails. Status 0 means it failed
+ * without any response (DNS, refused, aborted, blocked); a request that got a
+ * response keeps its HTTP status even if loading failed afterwards.
+ */
+import type { NetworkRequest } from '../types.js';
+/** Lifecycle state of a captured request. */
+export type RequestState = 'pending' | 'failed' | 'complete';
+/**
+ * Classify a request.
+ *
+ * @param request - Captured request
+ * @returns Its lifecycle state
+ */
+export declare function getRequestState(request: Pick<NetworkRequest, 'status'>): RequestState;
+/**
+ * Why a request failed, leaving out Chrome stopping an unneeded body after a
+ * complete response (204/304 report `net::ERR_ABORTED` that way).
+ *
+ * @param request - Captured request
+ * @returns Reason, or undefined when there is none worth showing
+ */
+export declare function failureReason(request: Pick<NetworkRequest, 'status' | 'errorText'>): string | undefined;
+/**
+ * Error Chrome reports when it stops reading a response body nobody needs
+ * (the response itself arrived; not a failure of the request).
+ */
+export declare const BODY_ABORTED = "net::ERR_ABORTED";
+//# sourceMappingURL=requestState.d.ts.map