chrome-devtools-mcp 0.26.0 → 1.1.0

package/build/src/WaitForHelper.js

@@ -11,12 +11,15 @@ export class WaitForHelper {
     #stableDomFor;
     #expectNavigationIn;
     #navigationTimeout;
+    #dialogOpened = false;
+    #initialUrl;
     constructor(page, cpuTimeoutMultiplier, networkTimeoutMultiplier) {
         this.#stableDomTimeout = 3000 * cpuTimeoutMultiplier;
         this.#stableDomFor = 100 * cpuTimeoutMultiplier;
         this.#expectNavigationIn = 100 * cpuTimeoutMultiplier;
         this.#navigationTimeout = 3000 * networkTimeoutMultiplier;
         this.#page = page;
+        this.#initialUrl = page.url();
     }
     /**
      * A wrapper that executes a action and waits for
@@ -104,10 +107,12 @@ export class WaitForHelper {
         });
     }
     async waitForEventsAfterAction(action, options) {
-        let dialogOpened = false;
+        if (this.#abortController.signal.aborted) {
+            throw new Error("Can't re-use a WaitForHelper");
+        }
         if (options?.handleDialog) {
             const dialogHandler = (dialog) => {
-                dialogOpened = true;
+                this.#dialogOpened = true;
                 if (options.handleDialog === 'dismiss') {
                     void dialog.dismiss();
                 }
@@ -144,8 +149,8 @@ export class WaitForHelper {
         }
         try {
             await navigationFinished;
-            if (dialogOpened) {
-                return;
+            if (this.#dialogOpened) {
+                return this.#getResult();
             }
             // Wait for stable dom after navigation so we execute in
             // the correct context
@@ -157,6 +162,15 @@ export class WaitForHelper {
         finally {
             this.#abortController.abort();
         }
+        return this.#getResult();
+    }
+    #getResult() {
+        const urlAfterAction = this.#page.url();
+        return {
+            ...(urlAfterAction !== this.#initialUrl
+                ? { navigatedToUrl: urlAfterAction }
+                : {}),
+        };
     }
 }
 export function getNetworkMultiplierFromString(condition) {

package/build/src/bin/check-latest-version.js

@@ -3,13 +3,37 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { execSync } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+function getRegistry() {
+    // Use the user's configured npm registry so update checks work behind
+    // corporate proxies and private registries. `npm config get registry`
+    // honors .npmrc files at every scope and respects npm_config_registry,
+    // so it covers direct CLI invocations as well as `npx` / `npm run`.
+    try {
+        const registry = execSync('npm config get registry', {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 5000,
+        })
+            .trim()
+            .replace(/\/$/, '');
+        if (registry && registry !== 'undefined' && /^https?:\/\//.test(registry)) {
+            return registry;
+        }
+    }
+    catch {
+        // npm not on PATH or other errors, fall back to default.
+    }
+    return DEFAULT_REGISTRY;
+}
 const cachePath = process.argv[2];
 if (cachePath) {
     try {
-        const response = await fetch('https://registry.npmjs.org/chrome-devtools-mcp/latest');
+        const response = await fetch(`${getRegistry()}/chrome-devtools-mcp/latest`);
         const data = response.ok ? await response.json() : null;
         if (data &&
             typeof data === 'object' &&

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

@@ -114,7 +114,7 @@ export const commands = {
             geolocation: {
                 name: 'geolocation',
                 type: 'string',
-                description: 'Geolocation (`<latitude>x<longitude>`) to emulate. Latitude between -90 and 90. Longitude between -180 and 180. Omit to clear the geolocation override.',
+                description: 'Geolocation (`<latitude>,<longitude>`) to emulate. Latitude between -90 and 90. Longitude between -180 and 180. Omit to clear the geolocation override.',
                 required: false,
             },
             userAgent: {
@@ -136,6 +136,12 @@ export const commands = {
                 description: "Emulate device viewports '<width>x<height>x<devicePixelRatio>[,mobile][,touch][,landscape]'. 'touch' and 'mobile' to emulate mobile devices. 'landscape' to emulate landscape mode.",
                 required: false,
             },
+            extraHttpHeaders: {
+                name: 'extraHttpHeaders',
+                type: 'string',
+                description: 'Extra HTTP headers as a JSON string object, e.g. {"X-Custom": "value", "Authorization": "Bearer token"}. Headers are included into every HTTP request originating from the page and persist across navigations until cleared. Pass an empty string to clear all extra headers.',
+                required: false,
+            },
         },
     },
     evaluate_script: {
@@ -154,6 +160,12 @@ export const commands = {
                 description: 'An optional list of arguments to pass to the function.',
                 required: false,
             },
+            filePath: {
+                name: 'filePath',
+                type: 'string',
+                description: 'The absolute or relative path to a file to save the script output to. If omitted, the output is returned inline.',
+                required: false,
+            },
             dialogAction: {
                 name: 'dialogAction',
                 type: 'string',
@@ -234,8 +246,8 @@ export const commands = {
             },
         },
     },
-    get_memory_snapshot_details: {
-        description: 'Loads a memory heapsnapshot and returns all available information including statistics, static data, and aggregated node information. Supports pagination for aggregates. (requires flag: --experimentalMemory=true)',
+    get_heapsnapshot_class_nodes: {
+        description: 'Loads a memory heapsnapshot and returns instances of a specific class with their IDs. (requires flag: --experimentalMemory=true)',
         category: 'Memory',
         args: {
             filePath: {
@@ -244,46 +256,52 @@ export const commands = {
                 description: 'A path to a .heapsnapshot file to read.',
                 required: true,
             },
+            id: {
+                name: 'id',
+                type: 'number',
+                description: 'The ID for the class, obtained from details.',
+                required: true,
+            },
             pageIdx: {
                 name: 'pageIdx',
                 type: 'number',
-                description: 'The page index for pagination of aggregates.',
+                description: 'The page index for pagination.',
                 required: false,
             },
             pageSize: {
                 name: 'pageSize',
                 type: 'number',
-                description: 'The page size for pagination of aggregates.',
+                description: 'The page size for pagination.',
                 required: false,
             },
         },
     },
-    get_network_request: {
-        description: 'Gets a network request by an optional reqid, if omitted returns the currently selected request in the DevTools Network panel.',
-        category: 'Network',
+    get_heapsnapshot_details: {
+        description: 'Loads a memory heapsnapshot and returns all available information including statistics, static data, and aggregated node information. Supports pagination for aggregates. (requires flag: --experimentalMemory=true)',
+        category: 'Memory',
         args: {
-            reqid: {
-                name: 'reqid',
-                type: 'number',
-                description: 'The reqid of the network request. If omitted returns the currently selected request in the DevTools Network panel.',
-                required: false,
-            },
-            requestFilePath: {
-                name: 'requestFilePath',
+            filePath: {
+                name: 'filePath',
                 type: 'string',
-                description: 'The absolute or relative path to a .network-request file to save the request body to. If omitted, the body is returned inline.',
+                description: 'A path to a .heapsnapshot file to read.',
+                required: true,
+            },
+            pageIdx: {
+                name: 'pageIdx',
+                type: 'number',
+                description: 'The page index for pagination of aggregates.',
                 required: false,
             },
-            responseFilePath: {
-                name: 'responseFilePath',
-                type: 'string',
-                description: 'The absolute or relative path to a .network-response file to save the response body to. If omitted, the body is returned inline.',
+            pageSize: {
+                name: 'pageSize',
+                type: 'number',
+                description: 'The page size for pagination of aggregates.',
                 required: false,
             },
         },
     },
-    get_nodes_by_class: {
-        description: 'Loads a memory heapsnapshot and returns instances of a specific class with their stable IDs. (requires flag: --experimentalMemory=true)',
+    get_heapsnapshot_retainers: {
+        description: 'Loads a memory heapsnapshot and returns retainers for a specific node ID. (requires flag: --experimentalMemory=true)',
         category: 'Memory',
         args: {
             filePath: {
@@ -292,10 +310,10 @@ export const commands = {
                 description: 'A path to a .heapsnapshot file to read.',
                 required: true,
             },
-            uid: {
-                name: 'uid',
+            nodeId: {
+                name: 'nodeId',
                 type: 'number',
-                description: 'The unique UID for the class, obtained from aggregates listing.',
+                description: 'The node ID to get retainers for.',
                 required: true,
             },
             pageIdx: {
@@ -312,6 +330,42 @@ export const commands = {
             },
         },
     },
+    get_heapsnapshot_summary: {
+        description: 'Loads a memory heapsnapshot and returns snapshot summary stats. (requires flag: --experimentalMemory=true)',
+        category: 'Memory',
+        args: {
+            filePath: {
+                name: 'filePath',
+                type: 'string',
+                description: 'A path to a .heapsnapshot file to read.',
+                required: true,
+            },
+        },
+    },
+    get_network_request: {
+        description: 'Gets a network request by an optional reqid, if omitted returns the currently selected request in the DevTools Network panel.',
+        category: 'Network',
+        args: {
+            reqid: {
+                name: 'reqid',
+                type: 'number',
+                description: 'The reqid of the network request. If omitted returns the currently selected request in the DevTools Network panel.',
+                required: false,
+            },
+            requestFilePath: {
+                name: 'requestFilePath',
+                type: 'string',
+                description: 'The absolute or relative path to a .network-request file to save the request body to. If omitted, the body is returned inline.',
+                required: false,
+            },
+            responseFilePath: {
+                name: 'responseFilePath',
+                type: 'string',
+                description: 'The absolute or relative path to a .network-response file to save the response body to. If omitted, the body is returned inline.',
+                required: false,
+            },
+        },
+    },
     handle_dialog: {
         description: 'If a browser dialog was opened, use this command to handle it',
         category: 'Input automation',
@@ -471,18 +525,6 @@ export const commands = {
         category: 'WebMCP',
         args: {},
     },
-    load_memory_snapshot: {
-        description: 'Loads a memory heapsnapshot and returns snapshot summary stats. (requires flag: --experimentalMemory=true)',
-        category: 'Memory',
-        args: {
-            filePath: {
-                name: 'filePath',
-                type: 'string',
-                description: 'A path to a .heapsnapshot file to read.',
-                required: true,
-            },
-        },
-    },
     navigate_page: {
         description: 'Go to a URL, or back, forward, or reload. Use project URL if not specified otherwise.',
         category: 'Navigation automation',
@@ -696,7 +738,7 @@ export const commands = {
             },
         },
     },
-    take_memory_snapshot: {
+    take_heapsnapshot: {
         description: 'Capture a heap snapshot of the currently selected page. Use to analyze the memory distribution of JavaScript objects and debug memory leaks.',
         category: 'Memory',
         args: {

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

@@ -136,33 +136,27 @@ export const cliOptions = {
     },
     experimentalPageIdRouting: {
         type: 'boolean',
-        describe: 'Whether to expose pageId on page-scoped tools and route requests by page ID.',
-        hidden: true,
+        describe: 'Whether to expose pageId on page-scoped tools and route requests by page ID (useful for concurrent agent sessions).',
     },
     experimentalDevtools: {
         type: 'boolean',
         describe: 'Whether to enable automation over DevTools targets',
-        hidden: true,
     },
     experimentalVision: {
         type: 'boolean',
         describe: 'Whether to enable coordinate-based tools such as click_at(x,y). Usually requires a computer-use model able to produce accurate coordinates by looking at screenshots.',
-        hidden: false,
     },
     experimentalMemory: {
         type: 'boolean',
         describe: 'Whether to enable experimental memory tools.',
-        hidden: true,
     },
     experimentalStructuredContent: {
         type: 'boolean',
         describe: 'Whether to output structured formatted content.',
-        hidden: true,
     },
     experimentalIncludeAllPages: {
         type: 'boolean',
         describe: 'Whether to include all kinds of pages such as webviews or background pages as pages.',
-        hidden: true,
     },
     experimentalNavigationAllowlist: {
         type: 'boolean',
@@ -257,7 +251,7 @@ export const cliOptions = {
     },
     redactNetworkHeaders: {
         type: 'boolean',
-        describe: 'If true, redacts some of the network headers considered senstive before returning to the client.',
+        describe: 'If true, redacts some of the network headers considered sensitive before returning to the client.',
         default: false,
     },
 };

package/build/src/bin/chrome-devtools-mcp-main.js

@@ -5,6 +5,7 @@
  */
 import '../polyfill.js';
 import process from 'node:process';
+import { closeBrowser } from '../browser.js';
 import { createMcpServer, logDisclaimers } from '../index.js';
 import { logger, saveLogsToFile } from '../logger.js';
 import { ClearcutLogger } from '../telemetry/ClearcutLogger.js';
@@ -21,6 +22,43 @@ if (process.env['CHROME_DEVTOOLS_MCP_CRASH_ON_UNCAUGHT'] !== 'true') {
         logger('Unhandled promise rejection', promise, reason);
     });
 }
+// Shutdown on stdin EOF (stdio MCP convention — the client closes the
+// transport to signal exit) and on standard termination signals. Without
+// this, an active Chrome subprocess keeps the Node event loop ref'd after
+// stdin closes and the server hangs until something else kills it.
+let shuttingDown = false;
+async function shutdown(reason) {
+    if (shuttingDown) {
+        return;
+    }
+    shuttingDown = true;
+    logger(`Shutting down (${reason})`);
+    // Backstop in case browser teardown hangs (e.g. unresponsive Chrome,
+    // slow beforeunload handlers, many tabs). Exits 0 because we still
+    // honored the shutdown request; the log line preserves observability.
+    // Unref'd so it doesn't keep the loop alive on the clean path.
+    setTimeout(() => {
+        logger('Shutdown timeout exceeded, forcing exit');
+        process.exit(0);
+    }, 10000).unref();
+    await closeBrowser();
+    process.exit(0);
+}
+process.stdin.on('end', () => {
+    void shutdown('stdin end');
+});
+process.stdin.on('close', () => {
+    void shutdown('stdin close');
+});
+process.on('SIGTERM', () => {
+    void shutdown('SIGTERM');
+});
+process.on('SIGINT', () => {
+    void shutdown('SIGINT');
+});
+process.on('SIGHUP', () => {
+    void shutdown('SIGHUP');
+});
 logger(`Starting Chrome DevTools MCP Server v${VERSION}`);
 const { server } = await createMcpServer(args, {
     logFile,

package/build/src/browser.js

@@ -10,6 +10,7 @@ import path from 'node:path';
 import { logger } from './logger.js';
 import { puppeteer } from './third_party/index.js';
 let browser;
+let browserMode;
 function makeTargetFilter(enableExtensions = false) {
     const ignoredPrefixes = new Set(['chrome://', 'chrome-untrusted://']);
     if (!enableExtensions) {
@@ -95,7 +96,12 @@ export async function ensureBrowserConnected(options) {
     }
     logger('Connecting Puppeteer to ', JSON.stringify(connectOptions));
     try {
-        browser = await puppeteer.connect(connectOptions);
+        // Assign mode before browser so a concurrent closeBrowser() never sees
+        // `browser` set with `browserMode` still undefined (would fall through
+        // to the disconnect() path and orphan a launched Chrome).
+        const connected = await puppeteer.connect(connectOptions);
+        browserMode = 'connected';
+        browser = connected;
     }
     catch (err) {
         throw new Error(`Could not connect to Chrome. ${autoConnect ? `Check if Chrome is running and remote debugging is enabled by going to chrome://inspect/#remote-debugging.` : `Check if Chrome is running.`}`, {
@@ -198,7 +204,35 @@ export async function ensureBrowserLaunched(options) {
     if (browser?.connected) {
         return browser;
     }
-    browser = await launch(options);
+    // Assign mode before browser; see the connect path above for rationale.
+    const launched = await launch(options);
+    browserMode = 'launched';
+    browser = launched;
     return browser;
 }
+/**
+ * Shutdown hook for the active browser. Closes a launched browser (so the
+ * Chrome subprocess is reaped) or disconnects from an attached browser (so
+ * the user's Chrome instance stays alive). No-op if no browser is active or
+ * the connection has already been dropped. Called from the server entrypoint
+ * on stdin EOF / SIGTERM / SIGINT.
+ */
+export async function closeBrowser() {
+    const b = browser;
+    const mode = browserMode;
+    browser = undefined;
+    browserMode = undefined;
+    if (!b || !b.connected) {
+        return;
+    }
+    if (mode === 'launched') {
+        await b.close().catch(err => {
+            logger('Failed to close browser', err);
+        });
+        return;
+    }
+    await b.disconnect().catch(err => {
+        logger('Failed to disconnect from browser', err);
+    });
+}
 //# sourceMappingURL=browser.js.map

package/build/src/daemon/client.js

@@ -115,13 +115,8 @@ export async function handleResponse(response, format) {
     if (response.isError) {
         return JSON.stringify(response.content);
     }
-    if (format === 'json') {
-        if (response.structuredContent) {
-            return JSON.stringify(response.structuredContent);
-        }
-        // Fall-through to text for backward compatibility.
-    }
     const chunks = [];
+    const images = [];
     for (const content of response.content) {
         if (content.type === 'text') {
             chunks.push(content.text);
@@ -143,12 +138,23 @@ export async function handleResponse(response, format) {
             const name = crypto.randomUUID();
             const filepath = await getTempFilePath(`${name}${extension}`);
             fs.writeFileSync(filepath, data);
+            images.push({ filePath: filepath, mimeType });
             chunks.push(`Saved to ${filepath}.`);
         }
         else {
             throw new Error('Not supported response content type');
         }
     }
+    if (format === 'json') {
+        if (response.structuredContent) {
+            const structuredContent = {
+                ...response.structuredContent,
+                ...(images.length ? { images } : {}),
+            };
+            return JSON.stringify(structuredContent);
+        }
+        // Fall-through to text for backward compatibility.
+    }
     return format === 'md' ? chunks.join(' ') : JSON.stringify(chunks);
 }
 //# sourceMappingURL=client.js.map

package/build/src/daemon/daemon.js

@@ -4,8 +4,9 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import fs from 'node:fs';
+import fs, { constants, openSync, writeSync, closeSync } from 'node:fs';
 import { createServer } from 'node:net';
+import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
 import { logger } from '../logger.js';
@@ -19,10 +20,66 @@ if (isDaemonRunning(sessionId)) {
     process.exit(1);
 }
 const pidFilePath = getPidFilePath(sessionId);
-fs.mkdirSync(path.dirname(pidFilePath), {
-    recursive: true,
-});
-fs.writeFileSync(pidFilePath, process.pid.toString());
+const pidDir = path.dirname(pidFilePath);
+const currentUserUid = os.userInfo().uid;
+try {
+    fs.mkdirSync(pidDir, { recursive: true });
+    if (os.platform() !== 'win32') {
+        // POSIX specific checks
+        try {
+            const stats = fs.statSync(pidDir);
+            // 1. Check Ownership: Ensure the directory is owned by the current user.
+            if (stats.uid !== currentUserUid) {
+                console.error(`[MCP Daemon] Critical error: PID directory ${pidDir} is not owned by the current user (Expected: ${currentUserUid}, Found: ${stats.uid}). Possible tampering.`);
+                process.exit(1);
+            }
+            // 2. Check Permissions: Ensure the directory is not group or world-writable.
+            // Mode is a number, e.g., 0o700. We check if bits for group/world write are set.
+            const mode = stats.mode;
+            if (mode & constants.S_IWGRP || mode & constants.S_IWOTH) {
+                console.error(`[MCP Daemon] Critical error: PID directory ${pidDir} has insecure permissions (Mode: ${mode.toString(8)}). It should not be writable by group or others.`);
+                process.exit(1);
+            }
+        }
+        catch (statErr) {
+            console.error(`[MCP Daemon] Critical error stating PID directory ${pidDir}:`, statErr);
+            process.exit(1);
+        }
+    }
+}
+catch (err) {
+    console.error(`[MCP Daemon] Critical error creating/validating PID directory: ${pidDir}`, err);
+    process.exit(1);
+}
+let fd = -1;
+try {
+    // Open the file with flags to:
+    // - O_WRONLY: Write-only
+    // - O_CREAT: Create if it doesn't exist
+    // - O_TRUNC: Truncate to zero length if it exists
+    // - O_NOFOLLOW: DO NOT follow symlinks.
+    // - 0o600: Permissions: read/write for owner, no permissions for others.
+    fd = openSync(pidFilePath, constants.O_WRONLY |
+        constants.O_CREAT |
+        constants.O_TRUNC |
+        constants.O_NOFOLLOW, 0o600);
+    writeSync(fd, process.pid.toString());
+}
+catch (err) {
+    console.error(`[MCP Daemon] Critical error writing PID file: ${pidFilePath}`, err);
+    // If openSync fails due to O_NOFOLLOW on a symlink, the error will be caught here.
+    process.exit(1);
+}
+finally {
+    if (fd !== -1) {
+        try {
+            closeSync(fd);
+        }
+        catch (err) {
+            console.error(`[MCP Daemon] Error closing PID file: ${pidFilePath}`, err);
+        }
+    }
+}
 logger(`Writing ${process.pid.toString()} to ${pidFilePath}`);
 const socketPath = getSocketPath(sessionId);
 const startDate = new Date();

package/build/src/formatters/HeapSnapshotFormatter.js

@@ -3,10 +3,22 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { DevTools } from '../third_party/index.js';
 import { stableIdSymbol } from '../utils/id.js';
 export function isNodeLike(item) {
     return (typeof item === 'object' && item !== null && 'id' in item && 'name' in item);
 }
+export function isEdgeLike(item) {
+    return (typeof item === 'object' &&
+        item !== null &&
+        'name' in item &&
+        'node' in item &&
+        'type' in item &&
+        typeof item.node === 'object' &&
+        item.node !== null &&
+        'id' in item.node &&
+        'name' in item.node);
+}
 export class HeapSnapshotFormatter {
     #aggregates;
     constructor(aggregates) {
@@ -14,12 +26,21 @@ export class HeapSnapshotFormatter {
     }
     static formatNodes(items) {
         const lines = [];
-        if (items.length > 0 && isNodeLike(items[0])) {
-            lines.push('id,name,type,distance,selfSize,retainedSize');
+        if (items.length > 0) {
+            const firstItem = items[0];
+            if (isNodeLike(firstItem)) {
+                lines.push('nodeId,nodeName,type,distance,selfSize,retainedSize');
+            }
+            else if (isEdgeLike(firstItem)) {
+                lines.push('name,type,nodeId,nodeName');
+            }
         }
         for (const item of items) {
             if (isNodeLike(item)) {
-                lines.push(`${item.id},"${item.name}",${item.type},${item.distance},${item.selfSize},${item.retainedSize}`);
+                lines.push(`${item.id},${item.name},${item.type},${item.distance},${DevTools.I18n.ByteUtilities.formatBytesToKb(item.selfSize)},${DevTools.I18n.ByteUtilities.formatBytesToKb(item.retainedSize)}`);
+            }
+            else if (isEdgeLike(item)) {
+                lines.push(`${item.name},${item.type},${item.node.id},${item.node.name}`);
             }
         }
         return lines.join('\n');
@@ -30,21 +51,21 @@ export class HeapSnapshotFormatter {
     toString() {
         const sorted = this.#getSortedAggregates();
         const lines = [];
-        lines.push('uid,className,count,selfSize,maxRetainedSize');
+        lines.push('id,name,count,selfSize,maxRetainedSize');
         for (const info of sorted) {
-            const uid = info[stableIdSymbol] ?? '';
-            lines.push(`${uid},"${info.name}",${info.count},${info.self},${info.maxRet}`);
+            const id = info[stableIdSymbol] ?? '';
+            lines.push(`${id},${info.name},${info.count},${DevTools.I18n.ByteUtilities.formatBytesToKb(info.self)},${DevTools.I18n.ByteUtilities.formatBytesToKb(info.maxRet)}`);
         }
         return lines.join('\n');
     }
     toJSON() {
         const sorted = this.#getSortedAggregates();
         return sorted.map(info => ({
-            uid: info[stableIdSymbol],
+            id: info[stableIdSymbol],
             className: info.name,
             count: info.count,
-            selfSize: info.self,
-            retainedSize: info.maxRet,
+            selfSize: DevTools.I18n.ByteUtilities.formatBytesToKb(info.self),
+            retainedSize: DevTools.I18n.ByteUtilities.formatBytesToKb(info.maxRet),
         }));
     }
     static sort(aggregates) {