chrome-devtools-mcp 1.2.0 → 1.3.0

package/README.md

@@ -514,12 +514,15 @@ If you run into any issues, checkout our [troubleshooting guide](./docs/troubles
   - [`take_snapshot`](docs/tool-reference.md#take_snapshot)
   - [`screencast_start`](docs/tool-reference.md#screencast_start)
   - [`screencast_stop`](docs/tool-reference.md#screencast_stop)
-- **Memory** (6 tools)
+- **Memory** (9 tools)
   - [`take_heapsnapshot`](docs/tool-reference.md#take_heapsnapshot)
   - [`close_heapsnapshot`](docs/tool-reference.md#close_heapsnapshot)
   - [`get_heapsnapshot_class_nodes`](docs/tool-reference.md#get_heapsnapshot_class_nodes)
   - [`get_heapsnapshot_details`](docs/tool-reference.md#get_heapsnapshot_details)
+  - [`get_heapsnapshot_dominators`](docs/tool-reference.md#get_heapsnapshot_dominators)
+  - [`get_heapsnapshot_edges`](docs/tool-reference.md#get_heapsnapshot_edges)
   - [`get_heapsnapshot_retainers`](docs/tool-reference.md#get_heapsnapshot_retainers)
+  - [`get_heapsnapshot_retaining_paths`](docs/tool-reference.md#get_heapsnapshot_retaining_paths)
   - [`get_heapsnapshot_summary`](docs/tool-reference.md#get_heapsnapshot_summary)
 - **Extensions** (5 tools)
   - [`install_extension`](docs/tool-reference.md#install_extension)
@@ -630,7 +633,7 @@ The Chrome DevTools MCP server supports the following configuration option:
   - **Type:** string
 
 - **`--categoryExperimentalWebmcp`/ `--category-experimental-webmcp`**
-  Set to true to enable debugging WebMCP tools. Requires Chrome 149+ with the following flags: `--enable-features=WebMCPTesting,DevToolsWebMCPSupport`
+  Set to true to enable debugging WebMCP tools. Requires Chrome 149+ with the following flags: `--enable-features=WebMCP,DevToolsWebMCPSupport`
   - **Type:** boolean
 
 - **`--chromeArg`/ `--chrome-arg`**
@@ -684,6 +687,23 @@ The Chrome DevTools MCP server supports the following configuration option:
   - **Type:** boolean
   - **Default:** `true`
 
+- **`--screenshotFormat`/ `--screenshot-format`**
+  Override the default output format used by take_screenshot when the caller does not specify one. JPEG and WebP are ~3-5x smaller than PNG, which helps reduce context size in AI conversations. Unset preserves the existing default ("png").
+  - **Type:** string
+  - **Choices:** `jpeg`, `png`, `webp`
+
+- **`--screenshotQuality`/ `--screenshot-quality`**
+  Override the default compression quality (0-100) used by take_screenshot for JPEG and WebP when the caller does not specify one. Lower values mean smaller files. Ignored for PNG. Unset preserves the Puppeteer default.
+  - **Type:** number
+
+- **`--screenshotMaxWidth`/ `--screenshot-max-width`**
+  Maximum width in pixels for screenshots. If the captured image is wider, it is downscaled (preserving aspect ratio) before being returned. Reduces context size in AI conversations. Unset means no resize.
+  - **Type:** number
+
+- **`--screenshotMaxHeight`/ `--screenshot-max-height`**
+  Maximum height in pixels for screenshots. If the captured image is taller, it is downscaled (preserving aspect ratio) before being returned. Can be combined with --screenshot-max-width; the smaller scale factor wins. Unset means no resize.
+  - **Type:** number
+
 - **`--slim`**
   Exposes a "slim" set of 3 tools covering navigation, script execution and screenshots only. Useful for basic browser tasks.
   - **Type:** boolean

package/build/src/HeapSnapshotManager.js

@@ -5,7 +5,6 @@
  */
 import fsSync from 'node:fs';
 import path from 'node:path';
-import { isNodeLike } from './formatters/HeapSnapshotFormatter.js';
 import { DevTools } from './third_party/index.js';
 import { createIdGenerator, stableIdSymbol, } from './utils/id.js';
 export class HeapSnapshotManager {
@@ -67,28 +66,38 @@ export class HeapSnapshotManager {
         const provider = snapshot.createNodesProviderForClass(className, filter);
         return await provider.serializeItemsRange(0, Infinity);
     }
-    async findNodeIndexById(filePath, nodeId) {
+    async getRetainers(filePath, nodeId) {
         const snapshot = await this.getSnapshot(filePath);
-        const aggregates = await this.getAggregates(filePath);
-        const filter = new DevTools.HeapSnapshotModel.HeapSnapshotModel.NodeFilter();
-        for (const classKey of Object.keys(aggregates)) {
-            const provider = snapshot.createNodesProviderForClass(classKey, filter);
-            const range = await provider.serializeItemsRange(0, Infinity);
-            for (const item of range.items) {
-                if (isNodeLike(item) && item.id === nodeId) {
-                    return item.nodeIndex;
-                }
-            }
+        const nodeIndex = await snapshot.nodeIndexForId(nodeId);
+        if (nodeIndex === undefined) {
+            throw new Error(`Node with ID ${nodeId} not found`);
         }
-        return undefined;
+        const provider = snapshot.createRetainingEdgesProvider(nodeIndex);
+        return await provider.serializeItemsRange(0, Infinity);
     }
-    async getRetainers(filePath, nodeId) {
-        const nodeIndex = await this.findNodeIndexById(filePath, nodeId);
+    async getRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings) {
+        const snapshot = await this.getSnapshot(filePath);
+        const nodeIndex = await snapshot.nodeIndexForId(nodeId);
         if (nodeIndex === undefined) {
             throw new Error(`Node with ID ${nodeId} not found`);
         }
+        return await snapshot.getRetainingPaths(nodeIndex, maxDepth, maxNodes, maxSiblings);
+    }
+    async getDominatorsOf(filePath, nodeId) {
         const snapshot = await this.getSnapshot(filePath);
-        const provider = snapshot.createRetainingEdgesProvider(nodeIndex);
+        const nodeIndex = await snapshot.nodeIndexForId(nodeId);
+        if (nodeIndex === undefined) {
+            throw new Error(`Node with ID ${nodeId} not found`);
+        }
+        return await snapshot.getDominatorsOf(nodeIndex);
+    }
+    async getEdges(filePath, nodeId) {
+        const snapshot = await this.getSnapshot(filePath);
+        const nodeIndex = await snapshot.nodeIndexForId(nodeId);
+        if (nodeIndex === undefined) {
+            throw new Error(`Node with ID ${nodeId} not found`);
+        }
+        const provider = snapshot.createEdgesProvider(nodeIndex);
         return await provider.serializeItemsRange(0, Infinity);
     }
     #getCachedSnapshot(filePath) {

package/build/src/McpContext.js

@@ -8,7 +8,7 @@ import fsPromises from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { UniverseManager } from './DevtoolsUtils.js';
+import { overrideDevToolsGlobals, UniverseManager, } from './devtools/DevtoolsUtils.js';
 import { HeapSnapshotManager } from './HeapSnapshotManager.js';
 import { McpPage } from './McpPage.js';
 import { NetworkCollector, ConsoleCollector, } from './PageCollector.js';
@@ -47,6 +47,11 @@ export class McpContext {
     #heapSnapshotManager = new HeapSnapshotManager();
     #roots = undefined;
     constructor(browser, logger, options, locatorClass) {
+        overrideDevToolsGlobals({
+            loadResource: (url) => {
+                return this.loadResource(url);
+            },
+        });
         this.browser = browser;
         this.logger = logger;
         this.#locatorClass = locatorClass;
@@ -659,5 +664,34 @@ export class McpContext {
     hasHeapSnapshots() {
         return this.#heapSnapshotManager.hasSnapshots();
     }
+    async getHeapSnapshotRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings) {
+        return await this.#heapSnapshotManager.getRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings);
+    }
+    async getHeapSnapshotDominators(filePath, nodeId) {
+        return await this.#heapSnapshotManager.getDominatorsOf(filePath, nodeId);
+    }
+    async loadResource(path) {
+        const url = new URL(path);
+        switch (url.protocol) {
+            case 'https:':
+            case 'http:': {
+                // TODO: Verify allow/block list
+                const response = await fetch(url);
+                if (!response.ok) {
+                    throw new Error(`Failed to load resource: ${url}`);
+                }
+                return response.text();
+            }
+            case 'file:': {
+                await this.validatePath(fileURLToPath(url));
+                return await fsPromises.readFile(url, 'utf-8');
+            }
+            default:
+                throw new Error(`Unsupported protocol for: ${url}`);
+        }
+    }
+    async getHeapSnapshotEdges(filePath, nodeId) {
+        return await this.#heapSnapshotManager.getEdges(filePath, nodeId);
+    }
 }
 //# sourceMappingURL=McpContext.js.map

package/build/src/McpResponse.js

@@ -73,6 +73,9 @@ async function getToolGroups(page) {
         return [];
     }
     const toolGroups = await page.pptrPage.evaluate(() => {
+        if (window.__dtmcp) {
+            window.__dtmcp.toolGroups = [];
+        }
         return new Promise(resolve => {
             const event = new CustomEvent('devtoolstooldiscovery');
             const groups = [];
@@ -85,7 +88,8 @@ async function getToolGroups(page) {
                     window.__dtmcp.toolGroups = [];
                 }
                 if (typeof toolGroup.name !== 'string' ||
-                    typeof toolGroup.description !== 'string' ||
+                    (toolGroup.description &&
+                        typeof toolGroup.description !== 'string') ||
                     !Array.isArray(toolGroup.tools)) {
                     console.error('Invalid toolGroup:', toolGroup);
                     return;
@@ -330,6 +334,20 @@ export class McpResponse {
             pagination: options,
         };
     }
+    setHeapSnapshotRetainingPaths(retainingPaths) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            retainingPaths,
+        };
+    }
+    setHeapSnapshotDominators(dominators) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            dominators,
+        };
+    }
     attachImage(value) {
         this.#images.push(value);
     }
@@ -528,7 +546,7 @@ export class McpResponse {
             errorMessage: this.#error?.message,
         }, useToon);
     }
-    format(toolName, context, data, useToon) {
+    async format(toolName, context, data, useToon) {
         const structuredContent = {};
         const response = [];
         if (this.#textResponseLines.length) {
@@ -608,8 +626,12 @@ Call ${handleDialog.name} to handle it before continuing.`);
                     const contextLabel = isolatedContextName
                         ? ` isolatedContext=${isolatedContextName}`
                         : '';
-                    parts.push(`${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
-                    structuredPages.push(createStructuredPage(page, context));
+                    const title = await fetchPageTitle(page);
+                    const pageLabel = title
+                        ? `${truncateTitle(title)} (${page.url()})`
+                        : page.url();
+                    parts.push(`${context.getPageId(page)}: ${pageLabel}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
+                    structuredPages.push(createStructuredPage(page, context, title));
                 }
                 response.push(...parts);
                 structuredContent.pages = structuredPages;
@@ -623,8 +645,12 @@ Call ${handleDialog.name} to handle it before continuing.`);
                         const contextLabel = isolatedContextName
                             ? ` isolatedContext=${isolatedContextName}`
                             : '';
-                        response.push(`${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
-                        structuredExtensionPages.push(createStructuredPage(page, context));
+                        const title = await fetchPageTitle(page);
+                        const pageLabel = title
+                            ? `${truncateTitle(title)} (${page.url()})`
+                            : page.url();
+                        response.push(`${context.getPageId(page)}: ${pageLabel}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
+                        structuredExtensionPages.push(createStructuredPage(page, context, title));
                     }
                     structuredContent.extensionPages = structuredExtensionPages;
                 }
@@ -752,6 +778,36 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 response.push(...paginationData.info);
                 structuredContent.heapSnapshotNodes = paginationData.items;
             }
+            const retainingPaths = this.#heapSnapshotOptions.retainingPaths;
+            if (retainingPaths) {
+                response.push('### Retaining Paths');
+                const { paths, limitsReached } = retainingPaths;
+                if (paths.length === 0) {
+                    response.push('No retaining paths found.');
+                }
+                else {
+                    response.push(HeapSnapshotFormatter.formatRetainingPaths(paths));
+                }
+                const reached = Object.entries(limitsReached)
+                    .filter(([, hit]) => hit)
+                    .map(([limit]) => limit);
+                if (reached.length > 0) {
+                    response.push(`Note: results are truncated, the following limits were reached: ${reached.join(', ')}.`);
+                }
+                structuredContent.heapSnapshotRetainingPaths =
+                    retainingPaths;
+            }
+            const dominators = this.#heapSnapshotOptions.dominators;
+            if (dominators) {
+                response.push('### Dominator Chain');
+                if (dominators.length === 0) {
+                    response.push('No dominators found.');
+                }
+                else {
+                    response.push(HeapSnapshotFormatter.formatDominators(dominators));
+                }
+                structuredContent.heapSnapshotDominators = dominators;
+            }
         }
         if (data.detailedNetworkRequest) {
             response.push(data.detailedNetworkRequest.toStringDetailed());
@@ -905,11 +961,25 @@ Call ${handleDialog.name} to handle it before continuing.`);
         this.#textResponseLines = [];
     }
 }
-function createStructuredPage(page, context) {
+function truncateTitle(title, maxLength = 50) {
+    if (title.length <= maxLength) {
+        return title;
+    }
+    return title.slice(0, maxLength - 3) + '...';
+}
+async function fetchPageTitle(page) {
+    return Promise.race([
+        page.title().catch(() => ''),
+        new Promise(resolve => setTimeout(() => resolve(''), 1000)),
+    ]);
+}
+function createStructuredPage(page, context, rawTitle) {
     const isolatedContextName = context.getIsolatedContextName(page);
+    const title = truncateTitle(rawTitle);
     const entry = {
         id: context.getPageId(page),
         url: page.url(),
+        title,
         selected: context.isPageSelected(page),
     };
     if (isolatedContextName) {

package/build/src/PageCollector.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { FakeIssuesManager } from './DevtoolsUtils.js';
+import { FakeIssuesManager } from './devtools/DevtoolsUtils.js';
 import { logger } from './logger.js';
 import { DevTools } from './third_party/index.js';
 import { createIdGenerator, stableIdSymbol, } from './utils/id.js';

package/build/src/bin/chrome-devtools-cli-options.js

@@ -312,6 +312,54 @@ export const commands = {
             },
         },
     },
+    get_heapsnapshot_dominators: {
+        description: 'Loads a memory heapsnapshot and returns the dominator chain for a specific node ID. This helps to identify which objects are keeping the target node alive. (requires flag: --memoryDebugging=true)',
+        category: 'Memory',
+        args: {
+            filePath: {
+                name: 'filePath',
+                type: 'string',
+                description: 'A path to a .heapsnapshot file to read.',
+                required: true,
+            },
+            nodeId: {
+                name: 'nodeId',
+                type: 'number',
+                description: 'The node ID to get the dominator chain for.',
+                required: true,
+            },
+        },
+    },
+    get_heapsnapshot_edges: {
+        description: 'Loads a memory heapsnapshot and returns outgoing edges (references) for a specific node ID. (requires flag: --memoryDebugging=true)',
+        category: 'Memory',
+        args: {
+            filePath: {
+                name: 'filePath',
+                type: 'string',
+                description: 'A path to a .heapsnapshot file to read.',
+                required: true,
+            },
+            nodeId: {
+                name: 'nodeId',
+                type: 'number',
+                description: 'The node ID to get outgoing edges for.',
+                required: true,
+            },
+            pageIdx: {
+                name: 'pageIdx',
+                type: 'number',
+                description: 'The page index for pagination.',
+                required: false,
+            },
+            pageSize: {
+                name: 'pageSize',
+                type: 'number',
+                description: 'The page size for pagination.',
+                required: false,
+            },
+        },
+    },
     get_heapsnapshot_retainers: {
         description: 'Loads a memory heapsnapshot and returns retainers for a specific node ID. (requires flag: --memoryDebugging=true)',
         category: 'Memory',
@@ -342,6 +390,42 @@ export const commands = {
             },
         },
     },
+    get_heapsnapshot_retaining_paths: {
+        description: 'Loads a memory heapsnapshot and returns retaining paths for a specific node ID. This helps to understand why a node is not being garbage collected. (requires flag: --memoryDebugging=true)',
+        category: 'Memory',
+        args: {
+            filePath: {
+                name: 'filePath',
+                type: 'string',
+                description: 'A path to a .heapsnapshot file to read.',
+                required: true,
+            },
+            nodeId: {
+                name: 'nodeId',
+                type: 'number',
+                description: 'The node ID to get retaining paths for.',
+                required: true,
+            },
+            maxDepth: {
+                name: 'maxDepth',
+                type: 'number',
+                description: 'The maximum depth to search for retaining paths.',
+                required: false,
+            },
+            maxNodes: {
+                name: 'maxNodes',
+                type: 'number',
+                description: 'The maximum number of nodes to return.',
+                required: false,
+            },
+            maxSiblings: {
+                name: 'maxSiblings',
+                type: 'number',
+                description: 'The maximum number of siblings to return.',
+                required: false,
+            },
+        },
+    },
     get_heapsnapshot_summary: {
         description: 'Loads a memory heapsnapshot and returns snapshot summary stats. (requires flag: --memoryDebugging=true)',
         category: 'Memory',

package/build/src/bin/chrome-devtools-mcp-cli-options.js

@@ -185,7 +185,7 @@ export const cliOptions = {
     },
     categoryExperimentalWebmcp: {
         type: 'boolean',
-        describe: 'Set to true to enable debugging WebMCP tools. Requires Chrome 149+ with the following flags: `--enable-features=WebMCPTesting,DevToolsWebMCPSupport`',
+        describe: 'Set to true to enable debugging WebMCP tools. Requires Chrome 149+ with the following flags: `--enable-features=WebMCP,DevToolsWebMCPSupport`',
     },
     chromeArg: {
         type: 'array',
@@ -256,6 +256,50 @@ export const cliOptions = {
         hidden: true,
         describe: 'Include watchdog PID in Clearcut request headers (for testing).',
     },
+    screenshotFormat: {
+        type: 'string',
+        description: 'Override the default output format used by take_screenshot when the caller does not specify one. JPEG and WebP are ~3-5x smaller than PNG, which helps reduce context size in AI conversations. Unset preserves the existing default ("png").',
+        choices: ['jpeg', 'png', 'webp'],
+    },
+    screenshotQuality: {
+        type: 'number',
+        description: 'Override the default compression quality (0-100) used by take_screenshot for JPEG and WebP when the caller does not specify one. Lower values mean smaller files. Ignored for PNG. Unset preserves the Puppeteer default.',
+        coerce: (value) => {
+            if (value === undefined) {
+                return;
+            }
+            if (!Number.isInteger(value) || value < 0 || value > 100) {
+                throw new Error(`Invalid screenshotQuality ${value}. Expected an integer between 0 and 100.`);
+            }
+            return value;
+        },
+    },
+    screenshotMaxWidth: {
+        type: 'number',
+        description: 'Maximum width in pixels for screenshots. If the captured image is wider, it is downscaled (preserving aspect ratio) before being returned. Reduces context size in AI conversations. Unset means no resize.',
+        coerce: (value) => {
+            if (value === undefined) {
+                return;
+            }
+            if (!Number.isInteger(value) || value <= 0) {
+                throw new Error(`Invalid screenshotMaxWidth ${value}. Expected a positive integer.`);
+            }
+            return value;
+        },
+    },
+    screenshotMaxHeight: {
+        type: 'number',
+        description: 'Maximum height in pixels for screenshots. If the captured image is taller, it is downscaled (preserving aspect ratio) before being returned. Can be combined with --screenshot-max-width; the smaller scale factor wins. Unset means no resize.',
+        coerce: (value) => {
+            if (value === undefined) {
+                return;
+            }
+            if (!Number.isInteger(value) || value <= 0) {
+                throw new Error(`Invalid screenshotMaxHeight ${value}. Expected a positive integer.`);
+            }
+            return value;
+        },
+    },
     slim: {
         type: 'boolean',
         describe: 'Exposes a "slim" set of 3 tools covering navigation, script execution and screenshots only. Useful for basic browser tasks.',

package/build/src/{DevToolsConnectionAdapter.js → devtools/DevToolsConnectionAdapter.js}

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { CDPSessionEvent } from './third_party/index.js';
+import { CDPSessionEvent } from '../third_party/index.js';
 /**
  * This class makes a puppeteer connection look like DevTools CDPConnection.
  *

package/build/src/{DevtoolsUtils.js → devtools/DevtoolsUtils.js}

@@ -3,9 +3,10 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { Mutex } from '../Mutex.js';
+import { DevTools } from '../third_party/index.js';
 import { PuppeteerDevToolsConnection } from './DevToolsConnectionAdapter.js';
-import { Mutex } from './Mutex.js';
-import { DevTools } from './third_party/index.js';
+import { McpHostBindingAdapter } from './McpHostBindingAdapter.js';
 /**
  * A mock implementation of an issues manager that only implements the methods
  * that are actually used by the IssuesAggregator
@@ -16,79 +17,82 @@ export class FakeIssuesManager extends DevTools.Common.ObjectWrapper
         return [];
     }
 }
-// DevTools CDP errors can get noisy.
-DevTools.ProtocolClient.InspectorBackend.test.suppressRequestErrors = true;
-// Stub out Network emulation commands on the DevTools Agent prototype globally.
-// This prevents the DevTools Frontend from ever resetting/clearing Puppeteer's
-// active network blocking/throttling rules during target setup or session lifetime.
-const networkAgentPrototype = DevTools.ProtocolClient.InspectorBackend.inspectorBackend.agentPrototypes.get('Network');
-if (networkAgentPrototype) {
-    Object.defineProperty(networkAgentPrototype, 'invoke_emulateNetworkConditionsByRule', {
-        value: () => {
-            return Promise.resolve({
-                ruleIds: [],
-                getError: () => undefined,
-            });
-        },
-        writable: true,
-        configurable: true,
-        enumerable: true,
-    });
-    Object.defineProperty(networkAgentPrototype, 'invoke_overrideNetworkState', {
-        value: () => {
-            return Promise.resolve({
-                getError: () => undefined,
-            });
-        },
-        writable: true,
-        configurable: true,
-        enumerable: true,
-    });
-    Object.defineProperty(networkAgentPrototype, 'invoke_enable', {
-        value: () => {
-            return Promise.resolve({
-                getError: () => undefined,
-            });
-        },
-        writable: true,
-        configurable: true,
-        enumerable: true,
-    });
-    Object.defineProperty(networkAgentPrototype, 'invoke_disable', {
-        value: () => {
-            return Promise.resolve({
-                getError: () => undefined,
-            });
+export function overrideDevToolsGlobals({ loadResource, }) {
+    DevTools.Host.InspectorFrontendHost.installInspectorFrontendHost(new McpHostBindingAdapter(loadResource));
+    // DevTools CDP errors can get noisy.
+    DevTools.ProtocolClient.InspectorBackend.test.suppressRequestErrors = true;
+    // Stub out Network emulation commands on the DevTools Agent prototype globally.
+    // This prevents the DevTools Frontend from ever resetting/clearing Puppeteer's
+    // active network blocking/throttling rules during target setup or session lifetime.
+    const networkAgentPrototype = DevTools.ProtocolClient.InspectorBackend.inspectorBackend.agentPrototypes.get('Network');
+    if (networkAgentPrototype) {
+        Object.defineProperty(networkAgentPrototype, 'invoke_emulateNetworkConditionsByRule', {
+            value: () => {
+                return Promise.resolve({
+                    ruleIds: [],
+                    getError: () => undefined,
+                });
+            },
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+        Object.defineProperty(networkAgentPrototype, 'invoke_overrideNetworkState', {
+            value: () => {
+                return Promise.resolve({
+                    getError: () => undefined,
+                });
+            },
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+        Object.defineProperty(networkAgentPrototype, 'invoke_enable', {
+            value: () => {
+                return Promise.resolve({
+                    getError: () => undefined,
+                });
+            },
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+        Object.defineProperty(networkAgentPrototype, 'invoke_disable', {
+            value: () => {
+                return Promise.resolve({
+                    getError: () => undefined,
+                });
+            },
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+        Object.defineProperty(networkAgentPrototype, 'invoke_setBlockedURLs', {
+            value: () => {
+                return Promise.resolve({
+                    getError: () => undefined,
+                });
+            },
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+    }
+    DevTools.I18n.DevToolsLocale.DevToolsLocale.instance({
+        create: true,
+        data: {
+            navigatorLanguage: 'en-US',
+            settingLanguage: 'en-US',
+            lookupClosestDevToolsLocale: l => l,
         },
-        writable: true,
-        configurable: true,
-        enumerable: true,
     });
-    Object.defineProperty(networkAgentPrototype, 'invoke_setBlockedURLs', {
-        value: () => {
-            return Promise.resolve({
-                getError: () => undefined,
-            });
-        },
-        writable: true,
-        configurable: true,
-        enumerable: true,
+    DevTools.I18n.i18n.registerLocaleDataForTest('en-US', {});
+    DevTools.Formatter.FormatterWorkerPool.FormatterWorkerPool.instance({
+        forceNew: true,
+        entrypointURL: import.meta
+            .resolve('../third_party/devtools-formatter-worker.js'),
     });
 }
-DevTools.I18n.DevToolsLocale.DevToolsLocale.instance({
-    create: true,
-    data: {
-        navigatorLanguage: 'en-US',
-        settingLanguage: 'en-US',
-        lookupClosestDevToolsLocale: l => l,
-    },
-});
-DevTools.I18n.i18n.registerLocaleDataForTest('en-US', {});
-DevTools.Formatter.FormatterWorkerPool.FormatterWorkerPool.instance({
-    forceNew: true,
-    entrypointURL: import.meta
-        .resolve('./third_party/devtools-formatter-worker.js'),
-});
 export class UniverseManager {
     #browser;
     #createUniverseFor;