@mcp-b/chrome-devtools-mcp 2.1.0 → 2.2.0

package/build/src/formatters/snapshotFormatter.js

@@ -3,71 +3,132 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export function formatSnapshotNode(root, snapshot, depth = 0) {
-    const chunks = [];
-    if (depth === 0) {
+export class SnapshotFormatter {
+    #snapshot;
+    constructor(snapshot) {
+        this.#snapshot = snapshot;
+    }
+    toString() {
+        const chunks = [];
+        const root = this.#snapshot.root;
         // Top-level content of the snapshot.
-        if (snapshot?.verbose &&
-            snapshot?.hasSelectedElement &&
-            !snapshot.selectedElementUid) {
+        if (this.#snapshot.verbose &&
+            this.#snapshot.hasSelectedElement &&
+            !this.#snapshot.selectedElementUid) {
             chunks.push(`Note: there is a selected element in the DevTools Elements panel but it is not included into the current a11y tree snapshot.
 Get a verbose snapshot to include all elements if you are interested in the selected element.\n\n`);
         }
+        chunks.push(this.#formatNode(root, 0));
+        return chunks.join('');
     }
-    const attributes = getAttributes(root);
-    const line = ' '.repeat(depth * 2) +
-        attributes.join(' ') +
-        (root.id === snapshot?.selectedElementUid
-            ? ' [selected in the DevTools Elements panel]'
-            : '') +
-        '\n';
-    chunks.push(line);
-    for (const child of root.children) {
-        chunks.push(formatSnapshotNode(child, snapshot, depth + 1));
+    toJSON() {
+        return this.#nodeToJSON(this.#snapshot.root);
     }
-    return chunks.join('');
-}
-function getAttributes(serializedAXNodeRoot) {
-    const attributes = [`uid=${serializedAXNodeRoot.id}`];
-    if (serializedAXNodeRoot.role) {
-        // To match representation in DevTools.
-        attributes.push(serializedAXNodeRoot.role === 'none'
-            ? 'ignored'
-            : serializedAXNodeRoot.role);
+    #formatNode(node, depth = 0) {
+        const chunks = [];
+        const attributes = this.#getAttributes(node);
+        const line = ' '.repeat(depth * 2) +
+            attributes.join(' ') +
+            (node.id === this.#snapshot.selectedElementUid
+                ? ' [selected in the DevTools Elements panel]'
+                : '') +
+            '\n';
+        chunks.push(line);
+        for (const child of node.children) {
+            chunks.push(this.#formatNode(child, depth + 1));
+        }
+        return chunks.join('');
     }
-    if (serializedAXNodeRoot.name) {
-        attributes.push(`"${serializedAXNodeRoot.name}"`);
+    #nodeToJSON(node) {
+        const rawAttrs = this.#getAttributesMap(node);
+        const children = node.children.map(child => this.#nodeToJSON(child));
+        const result = structuredClone(rawAttrs);
+        if (children.length > 0) {
+            result.children = children;
+        }
+        return result;
     }
-    const excluded = new Set([
-        'id',
-        'role',
-        'name',
-        'elementHandle',
-        'children',
-        'backendNodeId',
-    ]);
-    const booleanPropertyMap = {
-        disabled: 'disableable',
-        expanded: 'expandable',
-        focused: 'focusable',
-        selected: 'selectable',
-    };
-    for (const attr of Object.keys(serializedAXNodeRoot).sort()) {
-        if (excluded.has(attr)) {
-            continue;
+    #getAttributes(serializedAXNodeRoot) {
+        const attributes = [`uid=${serializedAXNodeRoot.id}`];
+        if (serializedAXNodeRoot.role) {
+            attributes.push(serializedAXNodeRoot.role === 'none'
+                ? 'ignored'
+                : serializedAXNodeRoot.role);
         }
-        const value = serializedAXNodeRoot[attr];
-        if (typeof value === 'boolean') {
-            if (booleanPropertyMap[attr]) {
-                attributes.push(booleanPropertyMap[attr]);
+        if (serializedAXNodeRoot.name) {
+            attributes.push(`"${serializedAXNodeRoot.name}"`);
+        }
+        const simpleAttrs = this.#getAttributesMap(serializedAXNodeRoot, 
+        /* excludeSpecial */ true);
+        for (const attr of Object.keys(serializedAXNodeRoot).sort()) {
+            if (excludedAttributes.has(attr)) {
+                continue;
+            }
+            const mapped = booleanPropertyMap[attr];
+            if (mapped && simpleAttrs[mapped]) {
+                attributes.push(mapped);
             }
-            if (value) {
+            const val = simpleAttrs[attr];
+            if (val === true) {
                 attributes.push(attr);
             }
+            else if (typeof val === 'string' || typeof val === 'number') {
+                attributes.push(`${attr}="${val}"`);
+            }
         }
-        else if (typeof value === 'string' || typeof value === 'number') {
-            attributes.push(`${attr}="${value}"`);
+        return attributes;
+    }
+    #getAttributesMap(node, excludeSpecial = false) {
+        const result = {};
+        if (!excludeSpecial) {
+            result.id = node.id;
+            if (node.role) {
+                result.role = node.role;
+            }
+            if (node.name) {
+                result.name = node.name;
+            }
+        }
+        // Re-implementing the exact logic from original function for #getAttributes to be safe:
+        return {
+            ...result,
+            ...this.#extractedAttributes(node),
+        };
+    }
+    #extractedAttributes(node) {
+        const result = {};
+        for (const attr of Object.keys(node).sort()) {
+            if (excludedAttributes.has(attr)) {
+                continue;
+            }
+            const value = node[attr];
+            if (typeof value === 'boolean') {
+                if (booleanPropertyMap[attr]) {
+                    result[booleanPropertyMap[attr]] = true;
+                }
+                if (value) {
+                    result[attr] = true;
+                }
+            }
+            else if (typeof value === 'string' || typeof value === 'number') {
+                result[attr] = value;
+            }
         }
+        return result;
     }
-    return attributes;
 }
+const booleanPropertyMap = {
+    disabled: 'disableable',
+    expanded: 'expandable',
+    focused: 'focusable',
+    selected: 'selectable',
+};
+const excludedAttributes = new Set([
+    'id',
+    'role',
+    'name',
+    'elementHandle',
+    'children',
+    'backendNodeId',
+    'loaderId',
+]);

package/build/src/index.js

@@ -1,21 +1,212 @@
-#!/usr/bin/env node
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { version } from 'node:process';
-const [major, minor] = version.substring(1).split('.').map(Number);
-if (major === 20 && minor < 19) {
-    console.error(`ERROR: \`chrome-devtools-mcp\` does not support Node ${process.version}. Please upgrade to Node 20.19.0 LTS or a newer LTS.`);
-    process.exit(1);
+import { ensureBrowserConnected, ensureBrowserLaunched } from './browser.js';
+import { loadIssueDescriptions } from './issue-descriptions.js';
+import { logger } from './logger.js';
+import { McpContext } from './McpContext.js';
+import { McpResponse } from './McpResponse.js';
+import { Mutex } from './Mutex.js';
+import { SlimMcpResponse } from './SlimMcpResponse.js';
+import { ClearcutLogger } from './telemetry/ClearcutLogger.js';
+import { bucketizeLatency } from './telemetry/metricUtils.js';
+import { McpServer, SetLevelRequestSchema, } from './third_party/index.js';
+import { ToolCategory } from './tools/categories.js';
+import { pageIdSchema } from './tools/ToolDefinition.js';
+import { createTools } from './tools/tools.js';
+import { VERSION } from './version.js';
+export async function createMcpServer(serverArgs, options) {
+    let clearcutLogger;
+    if (serverArgs.usageStatistics) {
+        clearcutLogger = new ClearcutLogger({
+            logFile: serverArgs.logFile,
+            appVersion: VERSION,
+            clearcutEndpoint: serverArgs.clearcutEndpoint,
+            clearcutForceFlushIntervalMs: serverArgs.clearcutForceFlushIntervalMs,
+            clearcutIncludePidHeader: serverArgs.clearcutIncludePidHeader,
+        });
+    }
+    const server = new McpServer({
+        name: 'chrome_devtools',
+        title: 'Chrome DevTools MCP server',
+        version: VERSION,
+    }, { capabilities: { logging: {} } });
+    server.server.setRequestHandler(SetLevelRequestSchema, () => {
+        return {};
+    });
+    let context;
+    async function getContext() {
+        const chromeArgs = (serverArgs.chromeArg ?? []).map(String);
+        const ignoreDefaultChromeArgs = (serverArgs.ignoreDefaultChromeArg ?? []).map(String);
+        if (serverArgs.proxyServer) {
+            chromeArgs.push(`--proxy-server=${serverArgs.proxyServer}`);
+        }
+        const devtools = serverArgs.experimentalDevtools ?? false;
+        const browser = serverArgs.browserUrl || serverArgs.wsEndpoint || serverArgs.autoConnect
+            ? await ensureBrowserConnected({
+                browserURL: serverArgs.browserUrl,
+                wsEndpoint: serverArgs.wsEndpoint,
+                wsHeaders: serverArgs.wsHeaders,
+                // Important: only pass channel, if autoConnect is true.
+                channel: serverArgs.autoConnect
+                    ? serverArgs.channel
+                    : undefined,
+                userDataDir: serverArgs.userDataDir,
+                devtools,
+            })
+            : await ensureBrowserLaunched({
+                headless: serverArgs.headless,
+                executablePath: serverArgs.executablePath,
+                channel: serverArgs.channel,
+                isolated: serverArgs.isolated ?? false,
+                userDataDir: serverArgs.userDataDir,
+                logFile: options.logFile,
+                viewport: serverArgs.viewport,
+                chromeArgs,
+                ignoreDefaultChromeArgs,
+                acceptInsecureCerts: serverArgs.acceptInsecureCerts,
+                devtools,
+                enableExtensions: serverArgs.categoryExtensions,
+                viaCli: serverArgs.viaCli,
+            });
+        if (context?.browser !== browser) {
+            context = await McpContext.from(browser, logger, {
+                experimentalDevToolsDebugging: devtools,
+                experimentalIncludeAllPages: serverArgs.experimentalIncludeAllPages,
+                performanceCrux: serverArgs.performanceCrux,
+            });
+        }
+        return context;
+    }
+    const toolMutex = new Mutex();
+    function registerTool(tool) {
+        if (tool.annotations.category === ToolCategory.EMULATION &&
+            serverArgs.categoryEmulation === false) {
+            return;
+        }
+        if (tool.annotations.category === ToolCategory.PERFORMANCE &&
+            serverArgs.categoryPerformance === false) {
+            return;
+        }
+        if (tool.annotations.category === ToolCategory.NETWORK &&
+            serverArgs.categoryNetwork === false) {
+            return;
+        }
+        if (tool.annotations.category === ToolCategory.EXTENSIONS &&
+            serverArgs.categoryExtensions === false) {
+            return;
+        }
+        if (tool.annotations.conditions?.includes('computerVision') &&
+            !serverArgs.experimentalVision) {
+            return;
+        }
+        if (tool.annotations.conditions?.includes('experimentalInteropTools') &&
+            !serverArgs.experimentalInteropTools) {
+            return;
+        }
+        if (tool.annotations.conditions?.includes('screencast') &&
+            !serverArgs.experimentalScreencast) {
+            return;
+        }
+        const schema = 'pageScoped' in tool &&
+            tool.pageScoped &&
+            serverArgs.experimentalPageIdRouting &&
+            !serverArgs.slim
+            ? { ...tool.schema, ...pageIdSchema }
+            : tool.schema;
+        server.registerTool(tool.name, {
+            description: tool.description,
+            inputSchema: schema,
+            annotations: tool.annotations,
+        }, async (params) => {
+            const guard = await toolMutex.acquire();
+            const startTime = Date.now();
+            let success = false;
+            try {
+                logger(`${tool.name} request: ${JSON.stringify(params, null, '  ')}`);
+                const context = await getContext();
+                logger(`${tool.name} context: resolved`);
+                await context.detectOpenDevToolsWindows();
+                const response = serverArgs.slim
+                    ? new SlimMcpResponse(serverArgs)
+                    : new McpResponse(serverArgs);
+                if ('pageScoped' in tool && tool.pageScoped) {
+                    const page = serverArgs.experimentalPageIdRouting &&
+                        params.pageId &&
+                        !serverArgs.slim
+                        ? context.getPageById(params.pageId)
+                        : context.getSelectedMcpPage();
+                    response.setPage(page);
+                    await tool.handler({
+                        params,
+                        page,
+                    }, response, context);
+                }
+                else {
+                    await tool.handler(
+                    // @ts-expect-error types do not match.
+                    {
+                        params,
+                    }, response, context);
+                }
+                const { content, structuredContent } = await response.handle(tool.name, context);
+                const result = {
+                    content,
+                };
+                if (response.isError) {
+                    result.isError = true;
+                }
+                success = true;
+                if (serverArgs.experimentalStructuredContent) {
+                    result.structuredContent = structuredContent;
+                }
+                return result;
+            }
+            catch (err) {
+                logger(`${tool.name} error:`, err, err?.stack);
+                let errorText = err && 'message' in err ? err.message : String(err);
+                if ('cause' in err && err.cause) {
+                    errorText += `\nCause: ${err.cause.message}`;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: errorText,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            finally {
+                void clearcutLogger?.logToolInvocation({
+                    toolName: tool.name,
+                    success,
+                    latencyMs: bucketizeLatency(Date.now() - startTime),
+                });
+                guard.dispose();
+            }
+        });
+    }
+    const tools = createTools(serverArgs);
+    for (const tool of tools) {
+        registerTool(tool);
+    }
+    await loadIssueDescriptions();
+    return { server, clearcutLogger };
 }
-if (major === 22 && minor < 12) {
-    console.error(`ERROR: \`chrome-devtools-mcp\` does not support Node ${process.version}. Please upgrade to Node 22.12.0 LTS or a newer LTS.`);
-    process.exit(1);
-}
-if (major < 20) {
-    console.error(`ERROR: \`chrome-devtools-mcp\` does not support Node ${process.version}. Please upgrade to Node 20.19.0 LTS or a newer LTS.`);
-    process.exit(1);
-}
-await import('./main.js');
+export const logDisclaimers = (args) => {
+    console.error(`chrome-devtools-mcp exposes content of the browser instance to the MCP clients allowing them to inspect,
+debug, and modify any data in the browser or DevTools.
+Avoid sharing sensitive or personal information that you do not want to share with MCP clients.`);
+    if (!args.slim && args.performanceCrux) {
+        console.error(`Performance tools may send trace URLs to the Google CrUX API to fetch real-user experience data. To disable, run with --no-performance-crux.`);
+    }
+    if (!args.slim && args.usageStatistics) {
+        console.error(`
+Google collects usage statistics to improve Chrome DevTools MCP. To opt-out, run with --no-usage-statistics.
+For more details, visit: https://github.com/ChromeDevTools/chrome-devtools-mcp#usage-statistics`);
+    }
+};

package/build/src/issue-descriptions.js

@@ -5,7 +5,7 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-const DESCRIPTIONS_PATH = path.join(import.meta.dirname, '../vendor/chrome-devtools-frontend/front_end/models/issues_manager/descriptions');
+const DESCRIPTIONS_PATH = path.join(import.meta.dirname, 'third_party/issue-descriptions');
 let issueDescriptions = {};
 /**
  * Reads all issue descriptions from the filesystem into memory.

package/build/src/logger.js

@@ -24,4 +24,13 @@ export function saveLogsToFile(fileName) {
     });
     return logFile;
 }
+export function flushLogs(logFile, timeoutMs = 2000) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(reject, timeoutMs);
+        logFile.end(() => {
+            clearTimeout(timeout);
+            resolve();
+        });
+    });
+}
 export const logger = debug(mcpDebugNamespace);

package/build/src/telemetry/{clearcut-logger.js → ClearcutLogger.js}

@@ -7,7 +7,7 @@ import process from 'node:process';
 import { logger } from '../logger.js';
 import { FilePersistence } from './persistence.js';
 import { WatchdogMessageType, OsType } from './types.js';
-import { WatchdogClient } from './watchdog-client.js';
+import { WatchdogClient } from './WatchdogClient.js';
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 function detectOsType() {
     switch (process.platform) {

package/build/src/telemetry/watchdog/{clearcut-sender.js → ClearcutSender.js}

@@ -125,6 +125,7 @@ export class ClearcutSender {
         });
     }
     #scheduleFlush(delayMs) {
+        logger(`Scheduling flush in ${delayMs}`);
         if (this.#flushTimer) {
             clearTimeout(this.#flushTimer);
         }
@@ -135,6 +136,7 @@ export class ClearcutSender {
         }, delayMs);
     }
     async #sendBatch(events) {
+        logger(`Sending batch of ${events.length}`);
         const requestBody = {
             log_source: LOG_SOURCE,
             request_time_ms: Date.now().toString(),

package/build/src/telemetry/watchdog/main.js

@@ -8,7 +8,7 @@ import readline from 'node:readline';
 import { parseArgs } from 'node:util';
 import { logger, flushLogs, saveLogsToFile } from '../../logger.js';
 import { WatchdogMessageType } from '../types.js';
-import { ClearcutSender } from './clearcut-sender.js';
+import { ClearcutSender } from './ClearcutSender.js';
 function parseWatchdogArgs() {
     const { values } = parseArgs({
         options: {

package/build/src/third_party/devtools-formatter-worker.js

@@ -4,4 +4,4 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 // eslint-disable-next-line no-restricted-imports
-import '../../vendor/chrome-devtools-frontend/front_end/entrypoints/formatter_worker/formatter_worker-entrypoint.js';
+import '../../node_modules/chrome-devtools-frontend/front_end/entrypoints/formatter_worker/formatter_worker-entrypoint.js';

package/build/src/third_party/index.js

@@ -4,13 +4,23 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import 'core-js/modules/es.promise.with-resolvers.js';
+import 'core-js/modules/es.set.union.v2.js';
 import 'core-js/proposals/iterator-helpers.js';
 export { default as yargs } from 'yargs';
 export { hideBin } from 'yargs/helpers';
 export { default as debug } from 'debug';
 export { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-export { SetLevelRequestSchema, ToolListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
+export { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+export { Client } from '@modelcontextprotocol/sdk/client/index.js';
+export { SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 export { z as zod } from 'zod';
-export { Locator, PredefinedNetworkConditions, CDPSessionEvent, } from 'puppeteer-core';
+export { Locator, PredefinedNetworkConditions, KnownDevices, CDPSessionEvent, } from 'puppeteer-core';
 export { default as puppeteer } from 'puppeteer-core';
+export { PipeTransport } from 'puppeteer-core/internal/node/PipeTransport.js';
+export { resolveDefaultUserDataDir, detectBrowserPlatform, Browser as BrowserEnum, } from '@puppeteer/browsers';
+import { snapshot as snapshotImpl, navigation as navigationImpl, generateReport as generateReportImpl, } from './lighthouse-devtools-mcp-bundle.js';
+export const snapshot = snapshotImpl;
+export const navigation = navigationImpl;
+export const generateReport = generateReportImpl;
+export * as DevTools from '../../node_modules/chrome-devtools-frontend/mcp/mcp.js';

package/build/src/third_party/issue-descriptions/connectionAllowlistInvalidAllowlistItemType.md

@@ -0,0 +1,12 @@
+# An item in the `Connection-Allowlist` header is invalid.
+
+Each item in the `Connection-Allowlist`'s header's [Inner List](sfInnerList)
+must be a [String](sfString) representing a [URL Pattern](urlPatternSpec), or
+the [Token](sfToken) `response-origin`.
+
+For example, the following header allows connections to (only)
+`https://example.com/` and the origin from which the response was delivered:
+
+```
+Connection-Allowlist: ("https://example.com" response-origin)
+```

package/build/src/third_party/issue-descriptions/connectionAllowlistInvalidHeader.md

@@ -0,0 +1,12 @@
+# The `Connection-Allowlist` header is not formatted as a Structured Field List.
+
+Responses' `Connection-Allowlist` header should be formatted as a [List](sfList)
+containing a single [Inner List](sfInnerList) that declares the allowed set of
+[URL Patterns](urlPatternSpec) for a given context.
+
+For example, the following header allows connections to (only)
+`https://example.com/`:
+
+```
+Connection-Allowlist: ("https://example.com")
+```

package/build/src/third_party/issue-descriptions/connectionAllowlistInvalidUrlPattern.md

@@ -0,0 +1,8 @@
+# An item in the `Connection-Allowlist` header is not a valid URL pattern.
+
+Each item in the `Connection-Allowlist` header must be a valid
+[URL Pattern](urlPatternSpec) that can be used to match against the request's
+origin.
+
+Note that our current implementation does not allow regular expressions to be
+used as part of the pattern.

package/build/src/third_party/issue-descriptions/connectionAllowlistItemNotInnerList.md

@@ -0,0 +1,12 @@
+# An item in the `Connection-Allowlist` header is not an Inner List.
+
+Responses' `Connection-Allowlist` header should be formatted as a [List](sfList)
+containing a single [Inner List](sfInnerList) that declares the allowed set of
+[URL Patterns](urlPatternSpec) for a given context.
+
+For example, the following header allows connections to (only)
+`https://example.com/`:
+
+```
+Connection-Allowlist: ("https://example.com")
+```

package/build/src/third_party/issue-descriptions/connectionAllowlistMoreThanOneList.md

@@ -0,0 +1,7 @@
+# `Connection-Allowlist` has multiple items.
+
+Responses' `Connection-Allowlist` header should be formatted as a [List](sfList)
+containing a single [Inner List](sfInnerList) that declares the allowed set of
+[URL Patterns](urlPatternSpec) for a given context. This response was a
+[List](sfList) containing more than one item: all but the first have been
+ignored.

package/build/src/third_party/issue-descriptions/connectionAllowlistReportingEndpointNotToken.md

@@ -0,0 +1,10 @@
+# The `report-to` parameter in the `Connection-Allowlist` header is not a token.
+
+If provided, the `report-to` parameter must be a [Token](sfToken)
+naming a reporting endpoint.
+
+For example:
+
+```
+Connection-Allowlist: ("https://example.com");report-to=endpoint
+```

package/build/{vendor/chrome-devtools-frontend/front_end/models/issues_manager/descriptions → src/third_party/issue-descriptions}/corsLocalNetworkAccessPermissionDenied.md

@@ -1,4 +1,4 @@
-# Ensure that local network requests are compatible with upcoming restrictions
+# Ensure that local network requests are compatible with restrictions
 
 A site requested a resource from a network that it could only access because of
 its users' privileged network position.
@@ -6,7 +6,7 @@ its users' privileged network position.
 These requests expose devices and servers to the internet, increasing the risk
 of a cross-site request forgery (CSRF) attack and/or information leakage.
 
-To mitigate these risks, Chrome will begin requiring the user grant explicit
+To mitigate these risks, Chrome is requiring the user grant explicit
 permission before a site can make local network requests. Local network requests
 are those that go to either private IP addresses, .local domains, or loopback
 addresses. Additionally, Chrome will block local network requests (both

package/build/src/third_party/issue-descriptions/selectivePermissionsIntervention.md

@@ -0,0 +1,7 @@
+# Selective Permissions Intervention
+
+The Selective Permissions Intervention blocks calls to privacy-sensitive APIs when they are called from ad scripts in order to align the permission grant with the user's intent. The particular API that was blocked, the call-stack that triggered the intervention, and why the script that called the API is considered ad-related is shown below.
+
+Note that Chrome considers any script with a URL that matches a rule in the [filterlist](ChromeFilterlistRepository) as ad script, and the matching rule is shown in the Ad Ancestry section. In addition, any script loaded while an ad script is in the JavaScript stack will also be considered an ad script by Chrome and is also shown in Ad Ancestry.
+
+If you believe this intervention  was in error (e.g., this call would occur even when loading the page with an ad blocker enabled), then please [file a bug](SelectivePermissionsInterventionIssue).