chrome-devtools-mcp 0.15.1 → 0.17.0

package/README.md

@@ -15,7 +15,7 @@ Chrome DevTools for reliable automation, in-depth debugging, and performance ana
   DevTools](https://github.com/ChromeDevTools/devtools-frontend) to record
   traces and extract actionable performance insights.
 - **Advanced browser debugging**: Analyze network requests, take screenshots and
-  check the browser console.
+  check browser console messages (with source-mapped stack traces).
 - **Reliable automation**. Uses
   [puppeteer](https://github.com/puppeteer/puppeteer) to automate actions in
   Chrome and automatically wait for action results.
@@ -27,6 +27,12 @@ allowing them to inspect, debug, and modify any data in the browser or DevTools.
 Avoid sharing sensitive or personal information that you don't want to share with
 MCP clients.
 
+Performance tools may send trace URLs to the Google CrUX API to fetch real-user
+experience data. This helps provide a holistic performance picture by
+presenting field data alongside lab data. This data is collected by the [Chrome
+User Experience Report (CrUX)](https://developer.chrome.com/docs/crux). To disable
+this, run with the `--no-performance-crux` flag.
+
 ## **Usage statistics**
 
 Google collects usage statistics (such as tool invocation success rates, latency, and environment information) to improve the reliability and performance of Chrome DevTools MCP.
@@ -466,6 +472,11 @@ The Chrome DevTools MCP server supports the following configuration option:
   - **Type:** boolean
   - **Default:** `true`
 
+- **`--performanceCrux`/ `--performance-crux`**
+  Set to false to disable sending URLs from performance traces to CrUX API to get field performance data.
+  - **Type:** boolean
+  - **Default:** `true`
+
 - **`--usageStatistics`/ `--usage-statistics`**
   Set to false to opt-out of usage statistics collection. Google collects usage data to improve the tool, handled under the Google Privacy Policy (https://policies.google.com/privacy). This is independent from Chrome browser metrics. Disabled if CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS or CI env variables are set.
   - **Type:** boolean
@@ -563,15 +574,12 @@ The following code snippet is an example configuration for gemini-cli:
   "mcpServers": {
     "chrome-devtools": {
       "command": "npx",
-      "args": ["chrome-devtools-mcp@latest", "--autoConnect", "--channel=beta"]
+      "args": ["chrome-devtools-mcp@latest", "--autoConnect"]
     }
   }
 }
 ```
 
-Note: you have to specify `--channel=beta` until Chrome M144 has reached the
-stable channel.
-
 **Step 3:** Test your setup
 
 Make sure your browser is running. Open gemini-cli and run the following prompt:

package/build/src/DevtoolsUtils.js

@@ -169,16 +169,131 @@ const SKIP_ALL_PAUSES = {
         // Do nothing.
     },
 };
+/**
+ * Constructed from Runtime.ExceptionDetails of an uncaught error.
+ *
+ * TODO: Also construct from a RemoteObject of subtype 'error'.
+ *
+ * Consists of the message, a fully resolved stack trace and a fully resolved 'cause' chain.
+ */
+export class SymbolizedError {
+    message;
+    stackTrace;
+    cause;
+    constructor(message, stackTrace, cause) {
+        this.message = message;
+        this.stackTrace = stackTrace;
+        this.cause = cause;
+    }
+    static async fromDetails(opts) {
+        const message = SymbolizedError.#getMessage(opts.details);
+        if (!opts.includeStackAndCause || !opts.devTools) {
+            return new SymbolizedError(message, opts.resolvedStackTraceForTesting, opts.resolvedCauseForTesting);
+        }
+        let stackTrace;
+        if (opts.resolvedStackTraceForTesting) {
+            stackTrace = opts.resolvedStackTraceForTesting;
+        }
+        else if (opts.details.stackTrace) {
+            try {
+                stackTrace = await createStackTrace(opts.devTools, opts.details.stackTrace, opts.targetId);
+            }
+            catch {
+                // ignore
+            }
+        }
+        // TODO: Turn opts.details.exception into a JSHandle and retrieve the 'cause' property.
+        //       If its an Error, recursively create a SymbolizedError.
+        let cause;
+        if (opts.resolvedCauseForTesting) {
+            cause = opts.resolvedCauseForTesting;
+        }
+        else if (opts.details.exception) {
+            try {
+                const causeRemoteObj = await SymbolizedError.#lookupCause(opts.devTools, opts.details.exception, opts.targetId);
+                if (causeRemoteObj) {
+                    cause = await SymbolizedError.fromError({
+                        devTools: opts.devTools,
+                        error: causeRemoteObj,
+                        targetId: opts.targetId,
+                    });
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
+        return new SymbolizedError(message, stackTrace, cause);
+    }
+    static async fromError(opts) {
+        const details = await SymbolizedError.#getExceptionDetails(opts.devTools, opts.error, opts.targetId);
+        if (details) {
+            return SymbolizedError.fromDetails({
+                details,
+                devTools: opts.devTools,
+                targetId: opts.targetId,
+                includeStackAndCause: true,
+            });
+        }
+        return new SymbolizedError(SymbolizedError.#getMessageFromException(opts.error));
+    }
+    static #getMessage(details) {
+        // For Runtime.exceptionThrown with a present exception object, `details.text` will be "Uncaught" and
+        // we have to manually parse out the error text from the exception description.
+        // In the case of Runtime.getExceptionDetails, `details.text` has the Error.message.
+        if (details.text === 'Uncaught' && details.exception) {
+            return ('Uncaught ' +
+                SymbolizedError.#getMessageFromException(details.exception));
+        }
+        return details.text;
+    }
+    static #getMessageFromException(error) {
+        const messageWithRest = error.description?.split('\n    at ', 2) ?? [];
+        return messageWithRest[0] ?? '';
+    }
+    static async #getExceptionDetails(devTools, error, targetId) {
+        if (!devTools || (error.type !== 'object' && error.subtype !== 'error')) {
+            return null;
+        }
+        const targetManager = devTools.universe.context.get(DevTools.TargetManager);
+        const target = targetId
+            ? targetManager.targetById(targetId) || devTools.target
+            : devTools.target;
+        const model = target.model(DevTools.RuntimeModel);
+        return ((await model.getExceptionDetails(error.objectId)) ?? null);
+    }
+    static async #lookupCause(devTools, error, targetId) {
+        if (!devTools || (error.type !== 'object' && error.subtype !== 'error')) {
+            return null;
+        }
+        const targetManager = devTools.universe.context.get(DevTools.TargetManager);
+        const target = targetId
+            ? targetManager.targetById(targetId) || devTools.target
+            : devTools.target;
+        const properties = await target.runtimeAgent().invoke_getProperties({
+            objectId: error.objectId,
+        });
+        if (properties.getError()) {
+            return null;
+        }
+        return properties.result.find(prop => prop.name === 'cause')?.value ?? null;
+    }
+    static createForTesting(message, stackTrace, cause) {
+        return new SymbolizedError(message, stackTrace, cause);
+    }
+}
 export async function createStackTraceForConsoleMessage(devTools, consoleMessage) {
     const message = consoleMessage;
     const rawStackTrace = message._rawStackTrace();
-    if (!rawStackTrace) {
-        return undefined;
+    if (rawStackTrace) {
+        return createStackTrace(devTools, rawStackTrace, message._targetId());
     }
+    return undefined;
+}
+export async function createStackTrace(devTools, rawStackTrace, targetId) {
     const targetManager = devTools.universe.context.get(DevTools.TargetManager);
-    const messageTargetId = message._targetId();
-    const target = messageTargetId
-        ? targetManager.targetById(messageTargetId) || devTools.target
+    const target = targetId
+        ? targetManager.targetById(targetId) || devTools.target
         : devTools.target;
     const model = target.model(DevTools.DebuggerModel);
     // DevTools doesn't wait for source maps to attach before building a stack trace, rather it'll send

package/build/src/McpContext.js

@@ -80,15 +80,8 @@ export class McpContext {
                 console: event => {
                     collect(event);
                 },
-                pageerror: event => {
-                    if (event instanceof Error) {
-                        collect(event);
-                    }
-                    else {
-                        const error = new Error(`${event}`);
-                        error.stack = undefined;
-                        collect(error);
-                    }
+                uncaughtError: event => {
+                    collect(event);
                 },
                 issue: event => {
                     collect(event);
@@ -269,6 +262,9 @@ export class McpContext {
     isRunningPerformanceTrace() {
         return this.#isRunningTrace;
     }
+    isCruxEnabled() {
+        return this.#options.performanceCrux;
+    }
     getDialog() {
         return this.#dialog;
     }

package/build/src/McpResponse.js

@@ -7,6 +7,7 @@ import { ConsoleFormatter } from './formatters/ConsoleFormatter.js';
 import { IssueFormatter } from './formatters/IssueFormatter.js';
 import { NetworkFormatter } from './formatters/NetworkFormatter.js';
 import { SnapshotFormatter } from './formatters/SnapshotFormatter.js';
+import { UncaughtError } from './PageCollector.js';
 import { DevTools } from './third_party/index.js';
 import { handleDialog } from './tools/pages.js';
 import { getInsightOutput, getTraceSummary } from './trace-processing/parse.js';
@@ -173,7 +174,7 @@ export class McpResponse {
         if (this.#attachedConsoleMessageId) {
             const message = context.getConsoleMessageById(this.#attachedConsoleMessageId);
             const consoleMessageStableId = this.#attachedConsoleMessageId;
-            if ('args' in message) {
+            if ('args' in message || message instanceof UncaughtError) {
                 const consoleMessage = message;
                 const devTools = context.getDevToolsUniverse();
                 detailedConsoleMessage = await ConsoleFormatter.from(consoleMessage, {
@@ -193,11 +194,6 @@ export class McpResponse {
                 }
                 detailedConsoleMessage = formatter;
             }
-            else {
-                detailedConsoleMessage = await ConsoleFormatter.from(message, {
-                    id: consoleMessageStableId,
-                });
-            }
         }
         let extensions;
         if (this.#listExtensions) {
@@ -220,7 +216,7 @@ export class McpResponse {
             }
             consoleMessages = (await Promise.all(messages.map(async (item) => {
                 const consoleMessageStableId = context.getConsoleMessageStableId(item);
-                if ('args' in item) {
+                if ('args' in item || item instanceof UncaughtError) {
                     const consoleMessage = item;
                     const devTools = context.getDevToolsUniverse();
                     return await ConsoleFormatter.from(consoleMessage, {
@@ -238,9 +234,7 @@ export class McpResponse {
                     }
                     return formatter;
                 }
-                return await ConsoleFormatter.from(item, {
-                    id: consoleMessageStableId,
-                });
+                return null;
             }))).filter(item => item !== null);
         }
         let networkRequests;

package/build/src/PageCollector.js

@@ -6,6 +6,14 @@
 import { FakeIssuesManager } from './DevtoolsUtils.js';
 import { logger } from './logger.js';
 import { DevTools } from './third_party/index.js';
+export class UncaughtError {
+    details;
+    targetId;
+    constructor(details, targetId) {
+        this.details = details;
+        this.targetId = targetId;
+    }
+}
 function createIdGenerator() {
     let i = 1;
     return () => {
@@ -161,7 +169,7 @@ export class ConsoleCollector extends PageCollector {
     addPage(page) {
         super.addPage(page);
         if (!this.#subscribedPages.has(page)) {
-            const subscriber = new PageIssueSubscriber(page);
+            const subscriber = new PageEventSubscriber(page);
             this.#subscribedPages.set(page, subscriber);
             void subscriber.subscribe();
         }
@@ -172,17 +180,20 @@ export class ConsoleCollector extends PageCollector {
         this.#subscribedPages.delete(page);
     }
 }
-class PageIssueSubscriber {
+class PageEventSubscriber {
     #issueManager = new FakeIssuesManager();
     #issueAggregator = new DevTools.IssueAggregator(this.#issueManager);
     #seenKeys = new Set();
     #seenIssues = new Set();
     #page;
     #session;
+    #targetId;
     constructor(page) {
         this.#page = page;
         // @ts-expect-error use existing CDP client (internal Puppeteer API).
         this.#session = this.#page._client();
+        // @ts-expect-error use internal Puppeteer API to get target ID
+        this.#targetId = this.#session.target()._targetId;
     }
     #resetIssueAggregator() {
         this.#issueManager = new FakeIssuesManager();
@@ -196,6 +207,7 @@ class PageIssueSubscriber {
         this.#resetIssueAggregator();
         this.#page.on('framenavigated', this.#onFrameNavigated);
         this.#session.on('Audits.issueAdded', this.#onIssueAdded);
+        this.#session.on('Runtime.exceptionThrown', this.#onExceptionThrown);
         try {
             await this.#session.send('Audits.enable');
         }
@@ -208,6 +220,7 @@ class PageIssueSubscriber {
         this.#seenIssues.clear();
         this.#page.off('framenavigated', this.#onFrameNavigated);
         this.#session.off('Audits.issueAdded', this.#onIssueAdded);
+        this.#session.off('Runtime.exceptionThrown', this.#onExceptionThrown);
         if (this.#issueAggregator) {
             this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedissue);
         }
@@ -222,6 +235,9 @@ class PageIssueSubscriber {
         this.#seenIssues.add(event.data);
         this.#page.emit('issue', event.data);
     };
+    #onExceptionThrown = (event) => {
+        this.#page.emit('uncaughtError', new UncaughtError(event.exceptionDetails, this.#targetId));
+    };
     // On navigation, we reset issue aggregation.
     #onFrameNavigated = (frame) => {
         // Only split the storage on main frame navigation

package/build/src/cli.js

@@ -188,6 +188,11 @@ export const cliOptions = {
         hidden: true,
         describe: 'Set to false to exclude tools related to extensions.',
     },
+    performanceCrux: {
+        type: 'boolean',
+        default: true,
+        describe: 'Set to false to disable sending URLs from performance traces to CrUX API to get field performance data.',
+    },
     usageStatistics: {
         type: 'boolean',
         default: true,
@@ -277,6 +282,10 @@ export function parseArguments(version, argv = process.argv) {
             '$0 --no-usage-statistics',
             'Do not send usage statistics https://github.com/ChromeDevTools/chrome-devtools-mcp#usage-statistics.',
         ],
+        [
+            '$0 --no-performance-crux',
+            'Disable CrUX (field data) integration in performance tools.',
+        ],
     ]);
     return yargsInstance
         .wrap(Math.min(120, yargsInstance.terminalWidth()))

package/build/src/formatters/ConsoleFormatter.js

@@ -3,85 +3,130 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createStackTraceForConsoleMessage, } from '../DevtoolsUtils.js';
+var _a;
+import { createStackTraceForConsoleMessage, SymbolizedError, } from '../DevtoolsUtils.js';
+import { UncaughtError } from '../PageCollector.js';
+import * as DevTools from '../third_party/index.js';
 export class ConsoleFormatter {
-    #msg;
-    #resolvedArgs = [];
-    #resolvedStackTrace;
+    static #STACK_TRACE_MAX_LINES = 50;
     #id;
-    constructor(msg, options) {
-        this.#msg = msg;
-        this.#id = options?.id;
-        this.#resolvedStackTrace = options?.resolvedStackTraceForTesting;
+    #type;
+    #text;
+    #argCount;
+    #resolvedArgs;
+    #stack;
+    #cause;
+    #isIgnored;
+    constructor(params) {
+        this.#id = params.id;
+        this.#type = params.type;
+        this.#text = params.text;
+        this.#argCount = params.argCount ?? 0;
+        this.#resolvedArgs = params.resolvedArgs ?? [];
+        this.#stack = params.stack;
+        this.#cause = params.cause;
+        this.#isIgnored = params.isIgnored;
     }
     static async from(msg, options) {
-        const formatter = new ConsoleFormatter(msg, options);
-        if (options?.fetchDetailedData) {
-            await formatter.#loadDetailedData(options?.devTools);
+        const ignoreListManager = options?.devTools?.universe.context.get(DevTools.DevTools.IgnoreListManager);
+        const isIgnored = options.isIgnoredForTesting ||
+            (frame => {
+                if (!ignoreListManager) {
+                    return false;
+                }
+                if (frame.uiSourceCode) {
+                    return ignoreListManager.isUserOrSourceMapIgnoreListedUISourceCode(frame.uiSourceCode);
+                }
+                if (frame.url) {
+                    return ignoreListManager.isUserIgnoreListedURL(frame.url);
+                }
+                return false;
+            });
+        if (msg instanceof UncaughtError) {
+            const error = await SymbolizedError.fromDetails({
+                devTools: options?.devTools,
+                details: msg.details,
+                targetId: msg.targetId,
+                includeStackAndCause: options?.fetchDetailedData,
+                resolvedStackTraceForTesting: options?.resolvedStackTraceForTesting,
+                resolvedCauseForTesting: options?.resolvedCauseForTesting,
+            });
+            return new _a({
+                id: options.id,
+                type: 'error',
+                text: error.message,
+                stack: error.stackTrace,
+                cause: error.cause,
+                isIgnored,
+            });
         }
-        return formatter;
-    }
-    async #loadDetailedData(devTools) {
-        if (this.#msg instanceof Error) {
-            return;
+        let resolvedArgs = [];
+        if (options.resolvedArgsForTesting) {
+            resolvedArgs = options.resolvedArgsForTesting;
         }
-        this.#resolvedArgs = await Promise.all(this.#msg.args().map(async (arg, i) => {
-            try {
-                return await arg.jsonValue();
-            }
-            catch {
-                return `<error: Argument ${i} is no longer available>`;
-            }
-        }));
-        if (devTools) {
+        else if (options.fetchDetailedData) {
+            resolvedArgs = await Promise.all(msg.args().map(async (arg, i) => {
+                try {
+                    const remoteObject = arg.remoteObject();
+                    if (remoteObject.type === 'object' &&
+                        remoteObject.subtype === 'error') {
+                        return await SymbolizedError.fromError({
+                            devTools: options.devTools,
+                            error: remoteObject,
+                            // @ts-expect-error Internal ConsoleMessage API
+                            targetId: msg._targetId(),
+                        });
+                    }
+                    return await arg.jsonValue();
+                }
+                catch {
+                    return `<error: Argument ${i} is no longer available>`;
+                }
+            }));
+        }
+        let stack;
+        if (options.resolvedStackTraceForTesting) {
+            stack = options.resolvedStackTraceForTesting;
+        }
+        else if (options.fetchDetailedData && options.devTools) {
             try {
-                this.#resolvedStackTrace = await createStackTraceForConsoleMessage(devTools, this.#msg);
+                stack = await createStackTraceForConsoleMessage(options.devTools, msg);
             }
             catch {
                 // ignore
             }
         }
+        return new _a({
+            id: options.id,
+            type: msg.type(),
+            text: msg.text(),
+            argCount: resolvedArgs.length || msg.args().length,
+            resolvedArgs,
+            stack,
+            isIgnored,
+        });
     }
     // The short format for a console message.
     toString() {
-        const type = this.#getType();
-        const text = this.#getText();
-        const argsCount = this.#msg instanceof Error
-            ? 0
-            : this.#resolvedArgs.length || this.#msg.args().length;
-        const idPart = this.#id !== undefined ? `msgid=${this.#id} ` : '';
-        return `${idPart}[${type}] ${text} (${argsCount} args)`;
+        return `msgid=${this.#id} [${this.#type}] ${this.#text} (${this.#argCount} args)`;
     }
     // The verbose format for a console message, including all details.
     toStringDetailed() {
         const result = [
-            this.#id !== undefined ? `ID: ${this.#id}` : '',
-            `Message: ${this.#getType()}> ${this.#getText()}`,
+            `ID: ${this.#id}`,
+            `Message: ${this.#type}> ${this.#text}`,
             this.#formatArgs(),
-            this.#formatStackTrace(this.#resolvedStackTrace),
+            this.#formatStackTrace(this.#stack, this.#cause, {
+                includeHeading: true,
+            }),
         ].filter(line => !!line);
         return result.join('\n');
     }
-    #getType() {
-        if (this.#msg instanceof Error) {
-            return 'error';
-        }
-        return this.#msg.type();
-    }
-    #getText() {
-        if (this.#msg instanceof Error) {
-            return this.#msg.message;
-        }
-        return this.#msg.text();
-    }
     #getArgs() {
-        if (this.#msg instanceof Error) {
-            return [];
-        }
         if (this.#resolvedArgs.length > 0) {
             const args = [...this.#resolvedArgs];
             // If there is no text, the first argument serves as text (see formatMessage).
-            if (!this.#msg.text()) {
+            if (!this.#text) {
                 args.shift();
             }
             return args;
@@ -89,6 +134,16 @@ export class ConsoleFormatter {
         return [];
     }
     #formatArg(arg) {
+        if (arg instanceof SymbolizedError) {
+            return [
+                arg.message,
+                this.#formatStackTrace(arg.stackTrace, arg.cause, {
+                    includeHeading: false,
+                }),
+            ]
+                .filter(line => !!line)
+                .join('\n');
+        }
         return typeof arg === 'object' ? JSON.stringify(arg) : String(arg);
     }
     #formatArgs() {
@@ -102,52 +157,84 @@ export class ConsoleFormatter {
         }
         return result.join('\n');
     }
-    #formatStackTrace(stackTrace) {
+    #formatStackTrace(stackTrace, cause, opts) {
         if (!stackTrace) {
             return '';
         }
+        const lines = this.#formatStackTraceInner(stackTrace, cause);
+        const includedLines = lines.slice(0, _a.#STACK_TRACE_MAX_LINES);
+        const reminderCount = lines.length - includedLines.length;
+        return [
+            opts.includeHeading ? '### Stack trace' : '',
+            ...includedLines,
+            reminderCount > 0 ? `... and ${reminderCount} more frames` : '',
+            'Note: line and column numbers use 1-based indexing',
+        ]
+            .filter(line => !!line)
+            .join('\n');
+    }
+    #formatStackTraceInner(stackTrace, cause) {
+        if (!stackTrace) {
+            return [];
+        }
         return [
-            '### Stack trace',
-            this.#formatFragment(stackTrace.syncFragment),
-            ...stackTrace.asyncFragments.map(this.#formatAsyncFragment.bind(this)),
-        ].join('\n');
+            ...this.#formatFragment(stackTrace.syncFragment),
+            ...stackTrace.asyncFragments
+                .map(this.#formatAsyncFragment.bind(this))
+                .flat(),
+            ...this.#formatCause(cause),
+        ];
     }
     #formatFragment(fragment) {
-        return fragment.frames.map(this.#formatFrame.bind(this)).join('\n');
+        const frames = fragment.frames.filter(frame => !this.#isIgnored(frame));
+        return frames.map(this.#formatFrame.bind(this));
     }
     #formatAsyncFragment(fragment) {
+        const formattedFrames = this.#formatFragment(fragment);
+        if (formattedFrames.length === 0) {
+            return [];
+        }
         const separatorLineLength = 40;
         const prefix = `--- ${fragment.description || 'async'} `;
         const separator = prefix + '-'.repeat(separatorLineLength - prefix.length);
-        return separator + '\n' + this.#formatFragment(fragment);
+        return [separator, ...formattedFrames];
     }
     #formatFrame(frame) {
         let result = `at ${frame.name ?? '<anonymous>'}`;
         if (frame.uiSourceCode) {
-            result += ` (${frame.uiSourceCode.displayName()}:${frame.line}:${frame.column})`;
+            const location = frame.uiSourceCode.uiLocation(frame.line, frame.column);
+            result += ` (${location.linkText(/* skipTrim */ false, /* showColumnNumber */ true)})`;
         }
         else if (frame.url) {
             result += ` (${frame.url}:${frame.line}:${frame.column})`;
         }
         return result;
     }
+    #formatCause(cause) {
+        if (!cause) {
+            return [];
+        }
+        return [
+            `Caused by: ${cause.message}`,
+            ...this.#formatStackTraceInner(cause.stackTrace, cause.cause),
+        ];
+    }
     toJSON() {
         return {
-            type: this.#getType(),
-            text: this.#getText(),
-            argsCount: this.#msg instanceof Error
-                ? 0
-                : this.#resolvedArgs.length || this.#msg.args().length,
+            type: this.#type,
+            text: this.#text,
+            argsCount: this.#argCount,
             id: this.#id,
         };
     }
     toJSONDetailed() {
         return {
             id: this.#id,
-            type: this.#getType(),
-            text: this.#getText(),
+            type: this.#type,
+            text: this.#text,
             args: this.#getArgs().map(arg => typeof arg === 'object' ? arg : String(arg)),
-            stackTrace: this.#resolvedStackTrace,
+            stackTrace: this.#stack,
         };
     }
 }
+_a = ConsoleFormatter;