browser-debugger-cli 0.7.1 → 0.8.0

package/dist/connection/pageReadiness.js

@@ -2,11 +2,11 @@
  * Smart page readiness detection using fixed thresholds
  *
  * This module provides page load detection that works for most page types
- * without configuration. It uses a three-phase approach:
+ * without configuration. It uses a two-phase approach:
  * 1. Load event (baseline readiness)
- * 2. Network stability (200ms idle threshold)
- * 3. DOM stability (300ms idle threshold)
+ * 2. Network (200ms idle) and DOM (300ms without mutations) quiet at once
  */
+import { trackInFlightRequests } from './inFlightRequests.js';
 import { createLogger } from '../ui/logging/index.js';
 import { delay } from '../utils/async.js';
 import { getErrorMessage } from '../utils/errors.js';
@@ -17,15 +17,15 @@ const NETWORK_IDLE_THRESHOLD_MS = 200;
 const DOM_STABLE_THRESHOLD_MS = 300;
 /** Interval for checking deadline expiration in milliseconds */
 const DEADLINE_CHECK_INTERVAL_MS = 100;
-/** Interval for checking network activity in milliseconds */
-const NETWORK_CHECK_INTERVAL_MS = 50;
+/** Interval for checking network and DOM activity in milliseconds */
+const QUIET_CHECK_INTERVAL_MS = 50;
 /**
  * Wait for page to be ready using fixed thresholds
  *
  * Strategy (always applied):
  * 1. Wait for load event (baseline readiness)
- * 2. Wait for network to stabilize (200ms idle threshold)
- * 3. Wait for DOM to stabilize (300ms idle threshold)
+ * 2. Wait for the network (200ms idle) and the DOM (300ms without
+ *    mutations) to be quiet at the same time
  *
  * Uses fixed thresholds that work well for most pages.
  * No framework detection, no configuration needed.
@@ -49,9 +49,8 @@ export async function waitForPageReady(cdp, options = {}) {
     try {
         await waitForLoadEvent(cdp, deadline);
         log.info('Load event fired');
-        const networkIdleMs = await waitForNetworkStable(cdp, deadline);
+        const { networkIdleMs, domIdleMs } = await waitForQuiet(cdp, deadline);
         log.info(`Network stable (${networkIdleMs}ms idle)`);
-        const domIdleMs = await waitForDOMStable(cdp, deadline);
         log.info(`DOM stable (${domIdleMs}ms idle)`);
         log.info('Page ready');
     }
@@ -116,135 +115,79 @@ async function waitForLoadEvent(cdp, deadline) {
     });
 }
 /**
- * Wait for network to stabilize
- *
- * Uses a fixed 200ms idle threshold which works well for most pages:
- * - Fast enough for quick sites (avoids unnecessary waiting)
- * - Patient enough for API-heavy apps (catches late requests)
- * - Simpler and more predictable than adaptive learning
- *
- * Network is considered stable when there are zero active requests
- * for at least 200ms continuously.
- *
- * Why this works:
- * - Catches initial request bursts (CSS, JS, images)
- * - Waits for lazy-loaded resources
- * - Detects API calls triggered by hydration
- * - Framework-agnostic - based on actual network activity
- *
- * @param cdp - CDP connection
- * @param deadline - Timestamp when to timeout
- * @returns Actual idle duration detected
- * @throws Error if deadline exceeded
+ * Page script tracking DOM mutations until {@link REMOVE_MUTATION_OBSERVER_JS}.
+ * Installs only once per document: a page that navigated itself (a redirect
+ * right after load) gets a new observer, its quiet time counted from then.
  */
-async function waitForNetworkStable(cdp, deadline) {
-    await cdp.send('Network.enable');
-    let activeRequests = 0;
-    let lastActivity = Date.now();
-    const requestHandler = () => {
-        activeRequests++;
-        lastActivity = Date.now();
-    };
-    const finishHandler = () => {
-        activeRequests--;
-        if (activeRequests === 0) {
-            lastActivity = Date.now();
-        }
-    };
-    const cleanupRequest = cdp.on('Network.requestWillBeSent', requestHandler);
-    const cleanupFinished = cdp.on('Network.loadingFinished', finishHandler);
-    const cleanupFailed = cdp.on('Network.loadingFailed', finishHandler);
-    try {
-        while (Date.now() < deadline) {
-            if (activeRequests === 0) {
-                const idleTime = Date.now() - lastActivity;
-                if (idleTime >= NETWORK_IDLE_THRESHOLD_MS) {
-                    return idleTime; // Success!
-                }
-            }
-            await delay(NETWORK_CHECK_INTERVAL_MS);
-        }
-        throw new Error('Network stability timeout');
-    }
-    finally {
-        cleanupRequest();
-        cleanupFinished();
-        cleanupFailed();
-    }
-}
+const INSTALL_MUTATION_OBSERVER_JS = `
+  if (!window.__bdg_observer) {
+    window.__bdg_lastMutation = Date.now();
+    window.__bdg_observer = new MutationObserver(() => {
+      window.__bdg_lastMutation = Date.now();
+    });
+    window.__bdg_observer.observe(document.body ?? document.documentElement, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      characterData: true
+    });
+  }
+`;
+const REMOVE_MUTATION_OBSERVER_JS = `
+  window.__bdg_observer?.disconnect();
+  delete window.__bdg_observer;
+  delete window.__bdg_lastMutation;
+`;
 /**
- * Wait for DOM to stabilize
+ * Wait until the network and the DOM are both quiet: no request in flight
+ * for 200 ms and no DOM mutation for 300 ms (hydration, client rendering,
+ * lazy-loaded resources and API calls all show up in one or the other).
  *
- * Uses a MutationObserver to detect when the DOM stops changing.
- * DOM is considered stable when there are no mutations for 300ms continuously.
- *
- * HOW IT WORKS:
- * 1. Inject MutationObserver into page to track all DOM changes
- * 2. Monitor childList, attributes, subtree, and characterData changes
- * 3. Wait for 300ms of continuous no-change activity
- * 4. Clean up observer when complete
- *
- * Why this works:
- * - SSR hydration causes DOM mutations (React, Vue, Svelte)
- * - Client-side rendering creates DOM elements
- * - When mutations stop, framework initialization is complete
- * - 300ms is long enough to catch batched updates, short enough to be responsive
- *
- * Framework-agnostic - detects actual mutations regardless of framework.
+ * Both are watched at once, so a page that is already quiet is ready after
+ * 300 ms, not after 200 ms and then another 300 ms.
  *
  * @param cdp - CDP connection
  * @param deadline - Timestamp when to timeout
- * @returns Actual stable duration detected
+ * @returns How long each has been quiet
  * @throws Error if deadline exceeded
  */
-async function waitForDOMStable(cdp, deadline) {
-    await cdp.send('Runtime.evaluate', {
-        expression: `
-      window.__bdg_mutations = 0;
-      window.__bdg_lastMutation = Date.now();
-
-      const observer = new MutationObserver(() => {
-        window.__bdg_mutations++;
-        window.__bdg_lastMutation = Date.now();
-      });
-
-      observer.observe(document.body, {
-        childList: true,
-        subtree: true,
-        attributes: true,
-        characterData: true
-      });
-
-      window.__bdg_observer = observer;
-    `,
-    });
+async function waitForQuiet(cdp, deadline) {
+    await cdp.send('Network.enable');
+    const requests = trackInFlightRequests(cdp);
     try {
+        await cdp.send('Runtime.evaluate', { expression: INSTALL_MUTATION_OBSERVER_JS });
         while (Date.now() < deadline) {
-            const checkResult = (await cdp.send('Runtime.evaluate', {
-                expression: 'Date.now() - window.__bdg_lastMutation',
-                returnByValue: true,
-            }));
-            const timeSinceLastMutation = checkResult.result.value ?? 0;
-            if (timeSinceLastMutation >= DOM_STABLE_THRESHOLD_MS) {
-                return timeSinceLastMutation; // Success!
+            const networkIdleMs = requests.count === 0 ? Date.now() - requests.lastActivity : 0;
+            if (networkIdleMs >= NETWORK_IDLE_THRESHOLD_MS) {
+                const domIdleMs = await msSinceLastMutation(cdp);
+                if (domIdleMs >= DOM_STABLE_THRESHOLD_MS)
+                    return { networkIdleMs, domIdleMs };
             }
-            await delay(DEADLINE_CHECK_INTERVAL_MS);
+            await delay(QUIET_CHECK_INTERVAL_MS);
         }
-        throw new Error('DOM stability timeout');
+        throw new Error('Page stability timeout');
     }
     finally {
+        requests.dispose();
         await cdp
-            .send('Runtime.evaluate', {
-            expression: `
-        window.__bdg_observer?.disconnect();
-        delete window.__bdg_observer;
-        delete window.__bdg_mutations;
-        delete window.__bdg_lastMutation;
-      `,
-        })
+            .send('Runtime.evaluate', { expression: REMOVE_MUTATION_OBSERVER_JS })
             .catch((error) => {
             log.debug(`Failed to clean up DOM observer: ${getErrorMessage(error)}`);
         });
     }
 }
+/**
+ * Time since the page's DOM last changed.
+ *
+ * @param cdp - CDP connection
+ * @returns Milliseconds since the last mutation (0 when unknown)
+ */
+async function msSinceLastMutation(cdp) {
+    const check = (await cdp.send('Runtime.evaluate', {
+        expression: `${INSTALL_MUTATION_OBSERVER_JS}; Date.now() - window.__bdg_lastMutation`,
+        returnByValue: true,
+    }));
+    const value = check.result.value;
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
 //# sourceMappingURL=pageReadiness.js.map

package/dist/connection/portReservation.d.ts

@@ -11,6 +11,16 @@ export interface PortReservation {
     /** Release the port reservation */
     release: () => void;
 }
+/**
+ * Whether something already accepts connections on 127.0.0.1:port. A
+ * listener on all interfaces (`0.0.0.0`/`::`) does not stop bdg from binding
+ * 127.0.0.1 on macOS, but Chrome would then fail to listen, so it is checked
+ * by connecting.
+ *
+ * @param port - Port to check
+ * @returns True if a connection was accepted
+ */
+export declare function isPortAnswering(port: number): Promise<boolean>;
 /**
  * Atomically reserve a port to prevent race conditions during Chrome launch.
  *

package/dist/connection/portReservation.js

@@ -5,8 +5,41 @@
  * Chrome launch when multiple processes might try to bind to the same port.
  */
 import * as net from 'net';
-import { portInUseError } from '../ui/messages/chrome.js';
 import { ChromeLaunchError } from './errors.js';
+/** How long a connection attempt may take when checking a port */
+const CONNECT_CHECK_MS = 500;
+/**
+ * Whether something already accepts connections on 127.0.0.1:port. A
+ * listener on all interfaces (`0.0.0.0`/`::`) does not stop bdg from binding
+ * 127.0.0.1 on macOS, but Chrome would then fail to listen, so it is checked
+ * by connecting.
+ *
+ * @param port - Port to check
+ * @returns True if a connection was accepted
+ */
+export function isPortAnswering(port) {
+    return new Promise((resolve) => {
+        const socket = net.connect({ port, host: '127.0.0.1' });
+        const finish = (answering) => {
+            socket.destroy();
+            resolve(answering);
+        };
+        socket.setTimeout(CONNECT_CHECK_MS, () => finish(false));
+        socket.once('connect', () => finish(true));
+        socket.once('error', () => finish(false));
+    });
+}
+/**
+ * The error for a port another process uses.
+ *
+ * @param port - Port
+ * @returns Launch error with the PORT_IN_USE issue
+ */
+function portInUseError(port) {
+    return new ChromeLaunchError(`Port ${port} is already in use`, {
+        issue: { code: 'PORT_IN_USE', context: { port } },
+    });
+}
 /**
  * Atomically reserve a port to prevent race conditions during Chrome launch.
  *
@@ -33,11 +66,13 @@ import { ChromeLaunchError } from './errors.js';
  * ```
  */
 export async function reservePort(port) {
+    if (await isPortAnswering(port))
+        throw portInUseError(port);
     return new Promise((resolve, reject) => {
         const server = net.createServer();
         server.once('error', (err) => {
             if (err.code === 'EADDRINUSE') {
-                reject(new ChromeLaunchError(portInUseError(port)));
+                reject(portInUseError(port));
             }
             else {
                 reject(err);

package/dist/connection/startupExit.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Notice when Chrome exits while bdg waits for its debugging port.
+ *
+ * chrome-launcher only polls the port (about 25 s) and then reports a refused
+ * connection, which reads like a port conflict. Chrome that exits right away
+ * (an unknown flag taken as a URL, a profile already open in another Chrome)
+ * says why on stderr: that is reported instead, as soon as it exits.
+ */
+import type { ChildProcess } from 'child_process';
+/** Chrome's log files in the profile directory, and their size before the launch */
+export interface StartupLogs {
+    files: Array<{
+        file: string;
+        offset: number;
+    }>;
+}
+/**
+ * Remember where Chrome's logs end before the launch, so only this launch's
+ * output is reported.
+ *
+ * @param userDataDir - Chrome profile directory
+ * @returns Log positions
+ */
+export declare function markStartupLogs(userDataDir: string): StartupLogs;
+/**
+ * Reject when the launched Chrome exits before it is ready.
+ *
+ * @param getProcess - Returns the spawned process once chrome-launcher has it
+ * @param logs - Log positions from before the launch
+ * @param userDataDir - Chrome profile directory (named in the error)
+ * @returns A promise that only rejects, and a function to stop watching
+ */
+export declare function watchStartupExit(getProcess: () => ChildProcess | undefined, logs: StartupLogs, userDataDir: string): {
+    exited: Promise<never>;
+    stop: () => void;
+};
+//# sourceMappingURL=startupExit.d.ts.map

package/dist/connection/startupExit.js

@@ -0,0 +1,107 @@
+/**
+ * Notice when Chrome exits while bdg waits for its debugging port.
+ *
+ * chrome-launcher only polls the port (about 25 s) and then reports a refused
+ * connection, which reads like a port conflict. Chrome that exits right away
+ * (an unknown flag taken as a URL, a profile already open in another Chrome)
+ * says why on stderr: that is reported instead, as soon as it exits.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { ChromeLaunchError } from './errors.js';
+/** How often to look for the spawned Chrome process */
+const PROCESS_POLL_MS = 100;
+/** Lines of Chrome's output kept for the error */
+const OUTPUT_LINES = 5;
+/** Chrome's output when another Chrome already has the profile open */
+const PROFILE_IN_USE_PATTERN = /existing browser session|profile appears to be in use|ProcessSingleton/i;
+/**
+ * Remember where Chrome's logs end before the launch, so only this launch's
+ * output is reported.
+ *
+ * @param userDataDir - Chrome profile directory
+ * @returns Log positions
+ */
+export function markStartupLogs(userDataDir) {
+    return {
+        files: ['chrome-err.log', 'chrome-out.log'].map((name) => {
+            const file = path.join(userDataDir, name);
+            return { file, offset: fs.existsSync(file) ? fs.statSync(file).size : 0 };
+        }),
+    };
+}
+/**
+ * Chrome's output since {@link markStartupLogs}, last lines first trimmed.
+ *
+ * @param logs - Log positions
+ * @returns Up to {@link OUTPUT_LINES} non-empty lines
+ */
+function readStartupOutput(logs) {
+    const lines = logs.files.flatMap(({ file, offset }) => {
+        if (!fs.existsSync(file))
+            return [];
+        return fs.readFileSync(file, 'utf8').slice(offset).split('\n');
+    });
+    return lines
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(-OUTPUT_LINES);
+}
+/**
+ * Reject when the launched Chrome exits before it is ready.
+ *
+ * @param getProcess - Returns the spawned process once chrome-launcher has it
+ * @param logs - Log positions from before the launch
+ * @param userDataDir - Chrome profile directory (named in the error)
+ * @returns A promise that only rejects, and a function to stop watching
+ */
+export function watchStartupExit(getProcess, logs, userDataDir) {
+    let timer;
+    let stopped = false;
+    const exited = new Promise((_resolve, reject) => {
+        const attach = () => {
+            if (stopped)
+                return;
+            const child = getProcess();
+            if (!child) {
+                timer = setTimeout(attach, PROCESS_POLL_MS);
+                return;
+            }
+            const report = (code) => {
+                if (!stopped)
+                    reject(startupExitError(code, readStartupOutput(logs), userDataDir));
+            };
+            if (child.exitCode !== null || child.signalCode !== null)
+                report(child.exitCode);
+            else
+                child.once('exit', report);
+        };
+        attach();
+    });
+    exited.catch(() => undefined);
+    return {
+        exited,
+        stop: () => {
+            stopped = true;
+            clearTimeout(timer);
+        },
+    };
+}
+/**
+ * The error for a Chrome that exited during startup.
+ *
+ * @param exitCode - Chrome's exit code
+ * @param output - Chrome's last output lines
+ * @param userDataDir - Chrome profile directory
+ * @returns Launch error with a structured issue
+ */
+function startupExitError(exitCode, output, userDataDir) {
+    const profileInUse = output.some((line) => PROFILE_IN_USE_PATTERN.test(line));
+    return new ChromeLaunchError(`Chrome exited during startup (exit code ${exitCode ?? 'none'})`, {
+        issue: {
+            code: 'CHROME_EXITED_DURING_STARTUP',
+            context: { exitCode, output, userDataDir, profileInUse },
+        },
+    });
+}
+//# sourceMappingURL=startupExit.js.map

package/dist/connection/typed-cdp.d.ts

@@ -12,8 +12,8 @@
  */
 import type { CDPConnection } from './cdp.js';
 import type { EventCleanup } from './events.js';
-import type Protocol from 'devtools-protocol/types/protocol';
-import type ProtocolMapping from 'devtools-protocol/types/protocol-mapping';
+import type { ProtocolMapping } from 'devtools-protocol/types/protocol-mapping.js';
+import type { Protocol } from 'devtools-protocol/types/protocol.js';
 /**
  * Extract parameter type from a CDP command.
  *
@@ -62,6 +62,7 @@ export declare class TypedCDPConnection {
      *
      * @param method - CDP method name (autocomplete available for 300+ methods)
      * @param params - Command parameters (type-checked)
+     * @param sessionId - Session of an attached target (iframe, worker); the page when omitted
      * @returns Promise resolving to command response (type-safe)
      *
      * @example
@@ -79,12 +80,13 @@ export declare class TypedCDPConnection {
      * const doc = await typed.send('DOM.getDocument', {});
      * ```
      */
-    send<T extends keyof ProtocolMapping.Commands>(method: T, params: CommandParams<T>): Promise<CommandReturn<T>>;
+    send<T extends keyof ProtocolMapping.Commands>(method: T, params: CommandParams<T>, sessionId?: string): Promise<CommandReturn<T>>;
     /**
      * Register a type-safe event handler.
      *
      * @param event - CDP event name (autocomplete available)
-     * @param handler - Event handler with type-safe parameters
+     * @param handler - Event handler with type-safe parameters, and the session of
+     *   the attached target that sent the event (undefined for the page itself)
      * @returns Handler ID for later removal
      *
      * @example
@@ -105,7 +107,7 @@ export declare class TypedCDPConnection {
      * });
      * ```
      */
-    on<T extends keyof ProtocolMapping.Events>(event: T, handler: (params: EventParams<T>) => void): EventCleanup;
+    on<T extends keyof ProtocolMapping.Events>(event: T, handler: (params: EventParams<T>, sessionId?: string) => void): EventCleanup;
     /**
      * Remove an event handler by ID.
      *
@@ -133,7 +135,7 @@ export declare class TypedCDPConnection {
  *
  * @example
  * ```typescript
- * import { Protocol } from '../connection/typed-cdp.js';
+ * import { Protocol } from './typed-cdp.js';
  *
  * type Cookie = Protocol.Network.Cookie;
  * type Headers = Protocol.Network.Headers;

package/dist/connection/typed-cdp.js

@@ -42,6 +42,7 @@ export class TypedCDPConnection {
      *
      * @param method - CDP method name (autocomplete available for 300+ methods)
      * @param params - Command parameters (type-checked)
+     * @param sessionId - Session of an attached target (iframe, worker); the page when omitted
      * @returns Promise resolving to command response (type-safe)
      *
      * @example
@@ -59,15 +60,16 @@ export class TypedCDPConnection {
      * const doc = await typed.send('DOM.getDocument', {});
      * ```
      */
-    async send(method, params) {
-        const result = await this.cdp.send(method, params);
+    async send(method, params, sessionId) {
+        const result = await this.cdp.send(method, params, sessionId);
         return result;
     }
     /**
      * Register a type-safe event handler.
      *
      * @param event - CDP event name (autocomplete available)
-     * @param handler - Event handler with type-safe parameters
+     * @param handler - Event handler with type-safe parameters, and the session of
+     *   the attached target that sent the event (undefined for the page itself)
      * @returns Handler ID for later removal
      *
      * @example

package/dist/connection/types.d.ts

@@ -23,6 +23,7 @@ export interface CDPMessage {
     error?: {
         code?: number;
         message: string;
+        data?: string;
     };
     /** Session ID for commands sent to specific targets */
     sessionId?: string;
@@ -58,6 +59,8 @@ export interface ConnectionOptions {
     onReconnect?: (() => Promise<void>) | undefined;
     /** Async hook invoked when WebSocket closes unexpectedly */
     onDisconnect?: ((code: number, reason: string) => void | Promise<void>) | undefined;
+    /** Stops connection attempts (e.g. the session was stopped while starting) */
+    signal?: AbortSignal | undefined;
 }
 /**
  * Options for CDPConnection.create() factory method.

package/dist/constants.d.ts

@@ -8,11 +8,6 @@
  * Default Chrome debugging port
  */
 export declare const DEFAULT_CDP_PORT = 9222;
-/**
- * Default Chrome debugging port (string version for CLI argument parsing)
- * Derived from DEFAULT_CDP_PORT to maintain single source of truth
- */
-export declare const DEFAULT_DEBUG_PORT: string;
 /**
  * Default Chrome launcher log level for quiet operation
  */
@@ -104,16 +99,6 @@ export declare const CHROME_NETWORK_BUFFER_PER_RESOURCE: number;
  * Limits size of POST body data included in requestWillBeSent notification
  */
 export declare const CHROME_POST_DATA_LIMIT: number;
-/**
- * Stale network request timeout (60 seconds)
- * Network requests incomplete after this duration are cleaned up
- */
-export declare const STALE_REQUEST_TIMEOUT = 60000;
-/**
- * Stale request cleanup interval (30 seconds)
- * How often to check for and remove stale network requests
- */
-export declare const STALE_REQUEST_CLEANUP_INTERVAL = 30000;
 /**
  * Default page readiness timeout (2 seconds)
  * Maximum time to wait for page to be ready before proceeding
@@ -121,13 +106,10 @@ export declare const STALE_REQUEST_CLEANUP_INTERVAL = 30000;
  */
 export declare const DEFAULT_PAGE_READINESS_TIMEOUT_MS = 2000;
 /**
- * Maximum JSONL buffer size in bytes (50MB)
- * Prevents OOM attacks from malicious/buggy processes sending data without newlines
- * If buffer exceeds this size, connection is terminated with protocol error
- *
- * Set to 50MB to accommodate large screenshots (base64-encoded full-page captures
- * of content-heavy pages like Amazon can exceed 10MB).
- * Matches CHROME_NETWORK_BUFFER_TOTAL for consistency.
+ * Maximum size of one JSONL message from the daemon (256 MB, below V8's
+ * maximum string length so joining a message cannot fail).
+ * Guards against a process sending data without newlines; large enough for
+ * HAR exports of long sessions with response bodies (`--all`).
  */
 export declare const MAX_JSONL_BUFFER_SIZE: number;
 /**
@@ -141,6 +123,15 @@ export declare const MAX_JSONL_BUFFER_SIZE: number;
  * @see docs/IMPROVEMENTS_ANALYSIS.md - Issue #3: Smart Page Readiness Detection
  */
 export declare function getIPCRequestTimeout(): number;
+/**
+ * Timeout for small requests the daemon answers from memory (status, peek,
+ * details, headers): a daemon that does not answer these within seconds is
+ * not responding, so commands do not wait the full IPC timeout. HAR data is
+ * excluded: a large session's requests and bodies take longer to transfer.
+ *
+ * @returns Timeout in milliseconds (10 s, or the IPC timeout if shorter)
+ */
+export declare function getQuickIPCRequestTimeout(): number;
 /**
  * Description for port option in CLI commands
  */
@@ -150,6 +141,14 @@ export declare const PORT_OPTION_DESCRIPTION = "Chrome debugging port";
  * Used for token-efficient display in preview/peek output.
  */
 export declare const RESOURCE_TYPE_ABBREVIATIONS: Record<string, string>;
+/**
+ * The CDP resource type a user means: its name or its abbreviation from
+ * `network list` (`WS`, `DOC`, `FET`), in any case.
+ *
+ * @param name - Type as typed
+ * @returns CDP resource type, or undefined if unknown
+ */
+export declare function resourceTypeFromName(name: string): string | undefined;
 /**
  * Rules for inferring resource types from MIME patterns.
  * Ordered by precedence (first match wins).