chrome-devtools-mcp 0.10.1 → 0.10.2

package/build/node_modules/chrome-devtools-frontend/front_end/core/i18n/i18nImpl.js

@@ -0,0 +1,135 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as I18n from '../../third_party/i18n/i18n.js';
+import * as Root from '../root/root.js';
+import { DevToolsLocale } from './DevToolsLocale.js';
+import { BUNDLED_LOCALES as BUNDLED_LOCALES_GENERATED, DEFAULT_LOCALE, LOCAL_FETCH_PATTERN, LOCALES, REMOTE_FETCH_PATTERN, } from './locales.js';
+const i18nInstance = new I18n.I18n.I18n(LOCALES, DEFAULT_LOCALE);
+// All the locales that are part of the DevTools bundle and should not be fetched
+// remotely.
+const BUNDLED_LOCALES = new Set([...BUNDLED_LOCALES_GENERATED]);
+/**
+ * Look up the best available locale for the requested language through these fall backs:
+ * - exact match
+ * - progressively shorter prefixes (`de-CH-1996` -> `de-CH` -> `de`)
+ * - the default locale ('en-US') if no match is found
+ *
+ * If `locale` isn't provided, the default is used.
+ */
+export function lookupClosestSupportedDevToolsLocale(locale) {
+    return i18nInstance.lookupClosestSupportedLocale(locale);
+}
+/**
+ * Returns a list of all supported DevTools locales, including pseudo locales.
+ */
+export function getAllSupportedDevToolsLocales() {
+    return [...i18nInstance.supportedLocales];
+}
+/**
+ * Returns the Url from which a locale can be fetched. This depends on the
+ * specific locale, as some are bundled with DevTools while others
+ * have to be fetched remotely.
+ */
+function getLocaleFetchUrl(locale, location) {
+    const remoteBase = Root.Runtime.getRemoteBase(location);
+    if (remoteBase?.version && !BUNDLED_LOCALES.has(locale)) {
+        return REMOTE_FETCH_PATTERN.replace('@HOST@', 'devtools://devtools')
+            .replace('@VERSION@', remoteBase.version)
+            .replace('@LOCALE@', locale);
+    }
+    const path = LOCAL_FETCH_PATTERN.replace('@LOCALE@', locale);
+    return new URL(path, import.meta.url).toString();
+}
+/**
+ * Fetches the locale data of the specified locale.
+ * Callers have to ensure that `locale` is an officially supported locale.
+ * Depending whether a locale is present in `bundledLocales`, the data will be
+ * fetched locally or remotely.
+ */
+export async function fetchAndRegisterLocaleData(locale, location = self.location.toString()) {
+    const localeDataTextPromise = fetch(getLocaleFetchUrl(locale, location)).then(result => result.json());
+    const timeoutPromise = new Promise((_, reject) => window.setTimeout(() => reject(new Error('timed out fetching locale')), 5000));
+    const localeData = await Promise.race([timeoutPromise, localeDataTextPromise]);
+    i18nInstance.registerLocaleData(locale, localeData);
+}
+export function hasLocaleDataForTest(locale) {
+    return i18nInstance.hasLocaleDataForTest(locale);
+}
+export function resetLocaleDataForTest() {
+    i18nInstance.resetLocaleDataForTest();
+}
+export function registerLocaleDataForTest(locale, messages) {
+    i18nInstance.registerLocaleData(locale, messages);
+}
+/**
+ * Returns an anonymous function that wraps a call to retrieve a localized string.
+ * This is introduced so that localized strings can be declared in environments where
+ * the i18n system has not been configured and so, cannot be directly invoked. Instead,
+ * strings are lazily localized when they are used. This is used for instance in the
+ * meta files used to register module extensions.
+ */
+export function getLazilyComputedLocalizedString(registeredStrings, id, values = {}) {
+    return () => getLocalizedString(registeredStrings, id, values);
+}
+/**
+ * Retrieve the localized string.
+ */
+export function getLocalizedString(registeredStrings, id, values = {}) {
+    return registeredStrings.getLocalizedStringSetFor(DevToolsLocale.instance().locale).getLocalizedString(id, values);
+}
+/**
+ * Register a file's UIStrings with i18n, return function to generate the string ids.
+ */
+export function registerUIStrings(path, stringStructure) {
+    return i18nInstance.registerFileStrings(path, stringStructure);
+}
+export function serializeUIString(string, values = {}) {
+    const serializedMessage = { string, values };
+    return JSON.stringify(serializedMessage);
+}
+export function deserializeUIString(serializedMessage) {
+    if (!serializedMessage) {
+        return { string: '', values: {} };
+    }
+    return JSON.parse(serializedMessage);
+}
+/**
+ * Use this function in places where a `LocalizedString` is expected but the
+ * term/phrase you want to use does not require translation.
+ */
+export function lockedString(str) {
+    return str;
+}
+/**
+ * Same as `lockedString` but for places where `i18nLazyString` would be used otherwise.
+ */
+export function lockedLazyString(str) {
+    return () => str;
+}
+/**
+ * Returns a string of the form:
+ *   "German (Austria) - Deutsch (Österreich)"
+ * where the former locale representation is written in the currently enabled DevTools
+ * locale and the latter locale representation is written in the locale of `localeString`.
+ *
+ * Should the two locales match (i.e. have the same language) then the latter locale
+ * representation is written in English.
+ */
+export function getLocalizedLanguageRegion(localeString, devtoolsLocale) {
+    const locale = new Intl.Locale(localeString);
+    const { language, baseName } = locale;
+    const devtoolsLoc = new Intl.Locale(devtoolsLocale.locale);
+    const targetLanguage = language === devtoolsLoc.language ? 'en' : baseName;
+    const languageInCurrentLocale = new Intl.DisplayNames([devtoolsLocale.locale], { type: 'language' }).of(language);
+    const languageInTargetLocale = new Intl.DisplayNames([targetLanguage], { type: 'language' }).of(language);
+    let wrappedRegionInCurrentLocale = '';
+    let wrappedRegionInTargetLocale = '';
+    if (locale.region) {
+        const regionInCurrentLocale = new Intl.DisplayNames([devtoolsLocale.locale], { type: 'region', style: 'short' }).of(locale.region);
+        const regionInTargetLocale = new Intl.DisplayNames([targetLanguage], { type: 'region', style: 'short' }).of(locale.region);
+        wrappedRegionInCurrentLocale = ` (${regionInCurrentLocale})`;
+        wrappedRegionInTargetLocale = ` (${regionInTargetLocale})`;
+    }
+    return `${languageInCurrentLocale}${wrappedRegionInCurrentLocale} - ${languageInTargetLocale}${wrappedRegionInTargetLocale}`;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/{common/QueryParamHandler.js → i18n/i18nTypes.js}

@@ -1,4 +1,4 @@
-// Copyright 2019 The Chromium Authors
+// Copyright 2021 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 export {};

package/build/node_modules/chrome-devtools-frontend/front_end/core/i18n/locales.js

@@ -0,0 +1,14 @@
+
+export const LOCALES = [
+  'en-US',
+];
+
+export const BUNDLED_LOCALES = [
+  'en-US',
+];
+
+export const DEFAULT_LOCALE = 'en-US';
+
+export const REMOTE_FETCH_PATTERN = '@HOST@/remote/serve_file/@VERSION@/core/i18n/locales/@LOCALE@.json';
+
+export const LOCAL_FETCH_PATTERN = './locales/@LOCALE@.json';

package/build/node_modules/chrome-devtools-frontend/front_end/core/i18n/time-utilities.js

@@ -0,0 +1,148 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+/**
+ * @file Uses Intl.NumberFormat.
+ * @see go/cpq:i18n-units-design
+ */
+import * as Platform from '../platform/platform.js';
+import { defineFormatter } from './NumberFormatter.js';
+const narrowMillisecondsInteger = defineFormatter({
+    style: 'unit',
+    unit: 'millisecond',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+});
+const longMilliseconds = defineFormatter({
+    style: 'unit',
+    unit: 'millisecond',
+    unitDisplay: 'long',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+});
+const narrowMicrosecondsInteger = defineFormatter({
+    style: 'unit',
+    unit: 'microsecond',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+});
+const narrowMillisecondsDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'millisecond',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+const narrowSecondsDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'second',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+const shortMinutesDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'minute',
+    unitDisplay: 'short',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 1,
+});
+const shortHoursDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'hour',
+    unitDisplay: 'short',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 1,
+});
+const longDaysDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'day',
+    unitDisplay: 'long',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 1,
+});
+export function formatMicroSecondsTime(time) {
+    return millisToString(Platform.Timing.microSecondsToMilliSeconds(time), true);
+}
+export function formatMicroSecondsAsSeconds(time) {
+    const milliseconds = Platform.Timing.microSecondsToMilliSeconds(time);
+    const seconds = Platform.Timing.milliSecondsToSeconds(milliseconds);
+    return narrowSecondsDecimal.format(seconds);
+}
+export function formatMicroSecondsAsMillisFixed(time) {
+    const milliseconds = Platform.Timing.microSecondsToMilliSeconds(time);
+    return narrowMillisecondsInteger.format(milliseconds);
+}
+export function formatMicroSecondsAsMillisFixedExpanded(time) {
+    const milliseconds = Platform.Timing.microSecondsToMilliSeconds(time);
+    return longMilliseconds.format(milliseconds);
+}
+/**
+ * @param higherResolution if true, the output may show as microsends or as milliseconds with a fractional component
+ */
+export function millisToString(ms, higherResolution) {
+    if (!isFinite(ms)) {
+        return '-';
+    }
+    if (higherResolution && ms < 0.1) {
+        return narrowMicrosecondsInteger.format(ms * 1000);
+    }
+    if (higherResolution && ms < 1000) {
+        return narrowMillisecondsDecimal.format(ms);
+    }
+    if (ms < 1000) {
+        return narrowMillisecondsInteger.format(ms);
+    }
+    const seconds = ms / 1000;
+    if (seconds < 60) {
+        return narrowSecondsDecimal.format(seconds);
+    }
+    const minutes = seconds / 60;
+    if (minutes < 60) {
+        return shortMinutesDecimal.format(minutes);
+    }
+    const hours = minutes / 60;
+    if (hours < 24) {
+        return shortHoursDecimal.format(hours);
+    }
+    const days = hours / 24;
+    return longDaysDecimal.format(days);
+}
+const preciseMillisToStringFormattersCache = new Map();
+export function preciseMillisToString(ms, precision = 0, separator) {
+    let formatter = preciseMillisToStringFormattersCache.get(precision);
+    if (!formatter) {
+        formatter = defineFormatter({
+            style: 'unit',
+            unit: 'millisecond',
+            unitDisplay: 'narrow',
+            minimumFractionDigits: precision,
+            maximumFractionDigits: precision,
+        });
+        preciseMillisToStringFormattersCache.set(precision, formatter);
+    }
+    return formatter.format(ms, separator);
+}
+const preciseSecondsToStringFormattersCache = new Map();
+export function preciseSecondsToString(ms, precision = 0) {
+    let formatter = preciseSecondsToStringFormattersCache.get(precision);
+    if (!formatter) {
+        formatter = defineFormatter({
+            style: 'unit',
+            unit: 'second',
+            unitDisplay: 'narrow',
+            minimumFractionDigits: precision,
+            maximumFractionDigits: precision,
+        });
+        preciseSecondsToStringFormattersCache.set(precision, formatter);
+    }
+    return formatter.format(ms);
+}
+export function secondsToString(seconds, higherResolution) {
+    if (!isFinite(seconds)) {
+        return '-';
+    }
+    return millisToString(seconds * 1000, higherResolution);
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/DevToolsCDPConnection.js

@@ -0,0 +1,138 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { CDPErrorStatus } from './CDPConnection.js';
+import { InspectorBackend, test } from './InspectorBackend.js';
+const LongPollingMethods = new Set(['CSS.takeComputedStyleUpdates']);
+export class DevToolsCDPConnection {
+    #transport;
+    #lastMessageId = 1;
+    #pendingResponsesCount = 0;
+    #pendingLongPollingMessageIds = new Set();
+    #pendingScripts = [];
+    #callbacks = new Map();
+    #observers = new Set();
+    constructor(transport) {
+        this.#transport = transport;
+        test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
+        test.sendRawMessage = this.sendRawMessageForTesting.bind(this);
+        this.#transport.setOnMessage(this.onMessage.bind(this));
+        this.#transport.setOnDisconnect(reason => {
+            this.#observers.forEach(observer => observer.onDisconnect(reason));
+        });
+    }
+    observe(observer) {
+        this.#observers.add(observer);
+    }
+    unobserve(observer) {
+        this.#observers.delete(observer);
+    }
+    send(method, params, sessionId) {
+        const messageId = ++this.#lastMessageId;
+        const messageObject = {
+            id: messageId,
+            method,
+        };
+        if (params) {
+            messageObject.params = params;
+        }
+        if (sessionId) {
+            messageObject.sessionId = sessionId;
+        }
+        if (test.dumpProtocol) {
+            test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
+        }
+        if (test.onMessageSent) {
+            const domain = method.split('.')[0];
+            const paramsObject = JSON.parse(JSON.stringify(params || {}));
+            test.onMessageSent({ domain, method, params: paramsObject, id: messageId, sessionId });
+        }
+        ++this.#pendingResponsesCount;
+        if (LongPollingMethods.has(method)) {
+            this.#pendingLongPollingMessageIds.add(messageId);
+        }
+        return new Promise(resolve => {
+            this.#callbacks.set(messageId, { resolve, method, sessionId });
+            this.#transport.sendRawMessage(JSON.stringify(messageObject));
+        });
+    }
+    resolvePendingCalls(sessionId) {
+        for (const { resolve, method, sessionId: callbackSessionId } of this.#callbacks.values()) {
+            if (sessionId !== callbackSessionId) {
+                continue;
+            }
+            resolve({
+                error: {
+                    message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
+                    code: CDPErrorStatus.SESSION_NOT_FOUND,
+                }
+            });
+        }
+    }
+    sendRawMessageForTesting(method, params, callback, sessionId = '') {
+        void this.send(method, params, sessionId).then(response => {
+            if ('error' in response && response.error) {
+                callback?.(response.error, null);
+            }
+            else if ('result' in response) {
+                callback?.(null, response.result);
+            }
+        });
+    }
+    onMessage(message) {
+        if (test.dumpProtocol) {
+            test.dumpProtocol('backend: ' + ((typeof message === 'string') ? message : JSON.stringify(message)));
+        }
+        if (test.onMessageReceived) {
+            const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
+            test.onMessageReceived(messageObjectCopy);
+        }
+        const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message);
+        if ('id' in messageObject && messageObject.id !== undefined) { // just a response for some request
+            const callback = this.#callbacks.get(messageObject.id);
+            this.#callbacks.delete(messageObject.id);
+            if (!callback) {
+                // Ignore messages with unknown IDs, we might see puppeteer proxied messages here.
+                return;
+            }
+            callback.resolve(messageObject);
+            --this.#pendingResponsesCount;
+            this.#pendingLongPollingMessageIds.delete(messageObject.id);
+            if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
+                this.deprecatedRunAfterPendingDispatches();
+            }
+        }
+        else if ('method' in messageObject) {
+            this.#observers.forEach(observer => observer.onEvent(messageObject));
+        }
+        else {
+            InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
+        }
+    }
+    hasOutstandingNonLongPollingRequests() {
+        return this.#pendingResponsesCount - this.#pendingLongPollingMessageIds.size > 0;
+    }
+    deprecatedRunAfterPendingDispatches(script) {
+        if (script) {
+            this.#pendingScripts.push(script);
+        }
+        // Execute all promises.
+        setTimeout(() => {
+            if (!this.hasOutstandingNonLongPollingRequests()) {
+                this.executeAfterPendingDispatches();
+            }
+            else {
+                this.deprecatedRunAfterPendingDispatches();
+            }
+        }, 0);
+    }
+    executeAfterPendingDispatches() {
+        if (!this.hasOutstandingNonLongPollingRequests()) {
+            const scripts = this.#pendingScripts;
+            this.#pendingScripts = [];
+            for (let id = 0; id < scripts.length; ++id) {
+                scripts[id]();
+            }
+        }
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/InspectorBackend.js

@@ -4,7 +4,7 @@
 import * as InspectorBackendCommands from '../../generated/InspectorBackendCommands.js';
 import { CDPErrorStatus } from './CDPConnection.js';
 import { ConnectionTransport } from './ConnectionTransport.js';
-import { NodeURL } from './NodeURL.js';
+import { DevToolsCDPConnection } from './DevToolsCDPConnection.js';
 export const splitQualifiedName = (string) => {
     const [domain, eventName] = string.split('.');
     return [domain, eventName];
@@ -105,34 +105,12 @@ export const test = {
      */
     onMessageReceived: null,
 };
-const LongPollingMethods = new Set(['CSS.takeComputedStyleUpdates']);
 export class SessionRouter {
     #connection;
-    #lastMessageId = 1;
-    #pendingResponsesCount = 0;
-    #pendingLongPollingMessageIds = new Set();
     #sessions = new Map();
-    #pendingScripts = [];
-    #callbacks = new Map();
-    #observers = new Set();
     constructor(connection) {
         this.#connection = connection;
-        test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
-        test.sendRawMessage = this.sendRawMessageForTesting.bind(this);
-        this.#connection.setOnMessage(this.onMessage.bind(this));
-        this.#connection.setOnDisconnect(reason => {
-            const session = this.#sessions.get('');
-            if (session) {
-                session.target.dispose(reason);
-            }
-            this.#observers.forEach(observer => observer.onDisconnect(reason));
-        });
-    }
-    observe(observer) {
-        this.#observers.add(observer);
-    }
-    unobserve(observer) {
-        this.#observers.delete(observer);
+        this.#connection.observe(this);
     }
     registerSession(target, sessionId) {
         this.#sessions.set(sessionId, { target });
@@ -142,136 +120,32 @@ export class SessionRouter {
         if (!session) {
             return;
         }
-        for (const { resolve, method, sessionId: callbackSessionId } of this.#callbacks.values()) {
-            if (sessionId !== callbackSessionId) {
-                continue;
-            }
-            resolve({
-                error: {
-                    message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
-                    code: CDPErrorStatus.SESSION_NOT_FOUND,
-                }
-            });
+        if (this.#connection instanceof DevToolsCDPConnection) {
+            this.#connection.resolvePendingCalls(sessionId);
         }
         this.#sessions.delete(sessionId);
     }
-    nextMessageId() {
-        return this.#lastMessageId++;
-    }
-    connection() {
-        return this.#connection;
-    }
-    send(method, params, sessionId) {
-        const messageId = this.nextMessageId();
-        const messageObject = {
-            id: messageId,
-            method,
-        };
-        if (params) {
-            messageObject.params = params;
-        }
-        if (sessionId) {
-            messageObject.sessionId = sessionId;
+    onDisconnect(reason) {
+        const session = this.#sessions.get('');
+        if (session) {
+            session.target.dispose(reason);
         }
-        if (test.dumpProtocol) {
-            test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
-        }
-        if (test.onMessageSent) {
-            const domain = method.split('.')[0];
-            const paramsObject = JSON.parse(JSON.stringify(params || {}));
-            test.onMessageSent({ domain, method, params: paramsObject, id: messageId, sessionId });
-        }
-        ++this.#pendingResponsesCount;
-        if (LongPollingMethods.has(method)) {
-            this.#pendingLongPollingMessageIds.add(messageId);
-        }
-        return new Promise(resolve => {
-            this.#callbacks.set(messageId, { resolve, method, sessionId });
-            this.#connection.sendRawMessage(JSON.stringify(messageObject));
-        });
-    }
-    sendRawMessageForTesting(method, params, callback, sessionId = '') {
-        void this.send(method, params, sessionId).then(response => {
-            if ('error' in response && response.error) {
-                callback?.(response.error, null);
-            }
-            else if ('result' in response) {
-                callback?.(null, response.result);
-            }
-        });
     }
-    onMessage(message) {
-        if (test.dumpProtocol) {
-            test.dumpProtocol('backend: ' + ((typeof message === 'string') ? message : JSON.stringify(message)));
-        }
-        if (test.onMessageReceived) {
-            const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
-            test.onMessageReceived(messageObjectCopy);
-        }
-        const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message);
-        const sessionId = messageObject.sessionId || '';
+    onEvent(event) {
+        const sessionId = event.sessionId || '';
         const session = this.#sessions.get(sessionId);
-        if (session?.target.getNeedsNodeJSPatching()) {
-            NodeURL.patch(messageObject);
-        }
-        if ('id' in messageObject && messageObject.id !== undefined) { // just a response for some request
-            const callback = this.#callbacks.get(messageObject.id);
-            this.#callbacks.delete(messageObject.id);
-            if (!callback) {
-                // Ignore messages with unknown IDs, we might see puppeteer proxied messages here.
-                return;
-            }
-            callback.resolve(messageObject);
-            --this.#pendingResponsesCount;
-            this.#pendingLongPollingMessageIds.delete(messageObject.id);
-            if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
-                this.deprecatedRunAfterPendingDispatches();
-            }
-        }
-        else if ('method' in messageObject) {
-            // This cast is justified as we just checked for the presence of messageObject.method.
-            session?.target.dispatch(messageObject);
-            this.#observers.forEach(observer => observer.onEvent(messageObject));
-        }
-        else {
-            InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
-        }
+        session?.target.dispatch(event);
     }
-    hasOutstandingNonLongPollingRequests() {
-        return this.#pendingResponsesCount - this.#pendingLongPollingMessageIds.size > 0;
-    }
-    deprecatedRunAfterPendingDispatches(script) {
-        if (script) {
-            this.#pendingScripts.push(script);
-        }
-        // Execute all promises.
-        window.setTimeout(() => {
-            if (!this.hasOutstandingNonLongPollingRequests()) {
-                this.executeAfterPendingDispatches();
-            }
-            else {
-                this.deprecatedRunAfterPendingDispatches();
-            }
-        }, 0);
-    }
-    executeAfterPendingDispatches() {
-        if (!this.hasOutstandingNonLongPollingRequests()) {
-            const scripts = this.#pendingScripts;
-            this.#pendingScripts = [];
-            for (let id = 0; id < scripts.length; ++id) {
-                scripts[id]();
-            }
-        }
+    get connection() {
+        return this.#connection;
     }
 }
 export class TargetBase {
-    needsNodeJSPatching;
     sessionId;
     #router;
     #agents = new Map();
     #dispatchers = new Map();
-    constructor(needsNodeJSPatching, parentTarget, sessionId, connection) {
-        this.needsNodeJSPatching = needsNodeJSPatching;
+    constructor(parentTarget, sessionId, connection) {
         this.sessionId = sessionId;
         if (parentTarget && !sessionId) {
             throw new Error('Specifying a parent target requires a session ID');
@@ -284,7 +158,7 @@ export class TargetBase {
             router = new SessionRouter(connection);
         }
         else {
-            router = new SessionRouter(ConnectionTransport.getFactory()());
+            router = new SessionRouter(new DevToolsCDPConnection(ConnectionTransport.getFactory()()));
         }
         this.#router = router;
         router.registerSession(this, this.sessionId);
@@ -316,9 +190,6 @@ export class TargetBase {
     isDisposed() {
         return !this.#router;
     }
-    markAsNodeJSForTest() {
-        this.needsNodeJSPatching = true;
-    }
     router() {
         return this.#router;
     }
@@ -570,9 +441,6 @@ export class TargetBase {
     registerWebAuthnDispatcher(dispatcher) {
         this.registerDispatcher('WebAuthn', dispatcher);
     }
-    getNeedsNodeJSPatching() {
-        return this.needsNodeJSPatching;
-    }
 }
 /** These are not logged as console.error */
 const IGNORED_ERRORS = new Set([
@@ -608,11 +476,12 @@ class AgentPrototype {
         this['invoke_' + methodName] = invoke;
     }
     invoke(method, request) {
-        const router = this.target.router();
-        if (!router) {
+        const connection = this.target.router()?.connection;
+        if (!connection) {
             return Promise.resolve({ result: null, getError: () => `Connection is closed, can\'t dispatch pending call to ${method}` });
         }
-        return router.send(method, request, this.target.sessionId).then(response => {
+        return connection.send(method, request, this.target.sessionId)
+            .then(response => {
             if ('error' in response && response.error) {
                 if (!test.suppressRequestErrors && !IGNORED_ERRORS.has(response.error.code)) {
                     console.error('Request ' + method + ' failed. ' + JSON.stringify(response.error));