chrome-devtools-frontend 1.0.1657855 → 1.0.1661063

package/front_end/Tests.js

@@ -496,8 +496,8 @@
 
   TestSuite.prototype.testConsoleOnNavigateBack = function() {
     function filteredMessages() {
-      return SDK.ConsoleModel.ConsoleModel.allMessagesUnordered().filter(
-          a => a.source !== Protocol.Log.LogEntrySource.Violation);
+      return SDK.ConsoleModel.ConsoleModel.allMessagesUnordered(SDK.TargetManager.TargetManager.instance())
+          .filter(a => a.source !== Protocol.Log.LogEntrySource.Violation);
     }
 
     if (filteredMessages().length === 1) {
@@ -710,7 +710,7 @@
     SDK.TargetManager.TargetManager.instance().addModelListener(
         SDK.ConsoleModel.ConsoleModel, SDK.ConsoleModel.Events.MessageAdded, onConsoleMessage, this);
 
-    const messages = SDK.ConsoleModel.ConsoleModel.allMessagesUnordered();
+    const messages = SDK.ConsoleModel.ConsoleModel.allMessagesUnordered(SDK.TargetManager.TargetManager.instance());
     if (messages.length) {
       const text = messages[0].messageText;
       this.assertEquals('ready', text);
@@ -976,7 +976,7 @@
   TestSuite.prototype.testWindowInitializedOnNavigateBack = function() {
     const test = this;
     test.takeControl();
-    const messages = SDK.ConsoleModel.ConsoleModel.allMessagesUnordered();
+    const messages = SDK.ConsoleModel.ConsoleModel.allMessagesUnordered(SDK.TargetManager.TargetManager.instance());
     if (messages.length === 1) {
       checkMessages();
     } else {
@@ -985,7 +985,7 @@
     }
 
     function checkMessages() {
-      const messages = SDK.ConsoleModel.ConsoleModel.allMessagesUnordered();
+      const messages = SDK.ConsoleModel.ConsoleModel.allMessagesUnordered(SDK.TargetManager.TargetManager.instance());
       test.assertEquals(1, messages.length);
       test.assertTrue(messages[0].messageText.indexOf('Uncaught') === -1);
       test.releaseControl();
@@ -1062,7 +1062,7 @@
   };
 
   TestSuite.prototype.waitForTestResultsInConsole = function() {
-    const messages = SDK.ConsoleModel.ConsoleModel.allMessagesUnordered();
+    const messages = SDK.ConsoleModel.ConsoleModel.allMessagesUnordered(SDK.TargetManager.TargetManager.instance());
     for (let i = 0; i < messages.length; ++i) {
       const text = messages[i].messageText;
       if (text === 'PASS') {

package/front_end/core/common/Gzip.ts

@@ -38,24 +38,31 @@ export async function fileToString(file: File): Promise<string> {
  * Consider using `arrayBufferToString` instead, which can handle both gzipped and plain text buffers.
  */
 export async function decompress(gzippedBuffer: ArrayBufferLike, charset = 'utf-8'): Promise<string> {
-  const buffer = await gzipCodec(gzippedBuffer, new DecompressionStream('gzip'));
+  const buffer = await decompressToBuffer(gzippedBuffer);
   const str = new TextDecoder(charset).decode(buffer);
   return str;
 }
 
+export async function decompressToBuffer(gzippedBuffer: ArrayBufferLike): Promise<ArrayBuffer> {
+  return await gzipCodec(gzippedBuffer, new DecompressionStream('gzip'));
+}
+
 /**
  * Decompress a deflate-encoded ArrayBuffer to a string.
  * Tries 'deflate' (zlib wrapper) first, then falls back to 'deflate-raw'.
  */
 export async function decompressDeflate(buffer: ArrayBufferLike, charset = 'utf-8'): Promise<string> {
-  let decompressedBuffer: ArrayBuffer;
+  const decompressedBuffer = await decompressDeflateToBuffer(buffer);
+  return new TextDecoder(charset).decode(decompressedBuffer);
+}
+
+export async function decompressDeflateToBuffer(buffer: ArrayBufferLike): Promise<ArrayBuffer> {
   try {
-    decompressedBuffer = await gzipCodec(buffer, new DecompressionStream('deflate'));
+    return await gzipCodec(buffer, new DecompressionStream('deflate'));
   } catch {
     // Try deflate-raw format if zlib-wrapped deflate fails.
-    decompressedBuffer = await gzipCodec(buffer, new DecompressionStream('deflate-raw'));
+    return await gzipCodec(buffer, new DecompressionStream('deflate-raw'));
   }
-  return new TextDecoder(charset).decode(decompressedBuffer);
 }
 export async function compress(str: string): Promise<ArrayBuffer> {
   const encoded = new TextEncoder().encode(str);

package/front_end/core/host/AidaClient.ts

@@ -63,6 +63,7 @@ const AidaLanguageToMarkdown: Record<AidaInferenceLanguage, string> = {
 
 export class AidaAbortError extends Error {}
 export class AidaBlockError extends Error {}
+export class AidaQuotaError extends Error {}
 
 interface AiStream {
   write: (data: string) => Promise<void>;
@@ -185,12 +186,23 @@ export class AidaClient {
           debugLog('doConversation failed with error:', JSON.stringify(err));
           if (err instanceof DispatchHttpRequestClient.DispatchHttpRequestError && err.response) {
             const result = err.response;
+            if (result.statusCode === 429) {
+              stream.fail(new AidaQuotaError('Server responded: quota exceeded'));
+              return;
+            }
             if (result.statusCode === 403) {
               stream.fail(new Error('Server responded: permission denied'));
               return;
             }
             if ('error' in result && result.error) {
-              stream.fail(new Error(`Cannot send request: ${result.error} ${result.detail || ''}`));
+              const errorStr = typeof result.error === 'string' ? result.error : '';
+              const detailStr = typeof result.detail === 'string' ? result.detail : '';
+              if (errorStr.toLowerCase().includes('quota') || detailStr.toLowerCase().includes('quota')) {
+                stream.fail(new AidaQuotaError(
+                    `Cannot send request: ${result.error}${result.detail ? ` ${result.detail}` : ''}`));
+                return;
+              }
+              stream.fail(new Error(`Cannot send request: ${result.error}${result.detail ? ` ${result.detail}` : ''}`));
               return;
             }
             if ('netErrorName' in result && result.netErrorName === 'net::ERR_TIMED_OUT') {
@@ -249,6 +261,9 @@ export class AidaClient {
             thoughtSignature: result.functionCallChunk.functionCall.thoughtSignature,
           });
         } else if ('error' in result) {
+          if (typeof result.error === 'string' && result.error.toLowerCase().includes('quota')) {
+            throw new AidaQuotaError(`Server responded: ${JSON.stringify(result)}`);
+          }
           throw new Error(`Server responded: ${JSON.stringify(result)}`);
         } else {
           throw new Error(`Unknown chunk result ${JSON.stringify(result)}`);
@@ -435,21 +450,32 @@ export function getClientFeatureName(feature: ClientFeature): string {
   return name;
 }
 
-let hostConfigTrackerInstance: HostConfigTracker|undefined;
-
 export class HostConfigTracker extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   #pollTimer?: ReturnType<typeof setTimeout>;
   #aidaAvailability?: AidaAccessPreconditions;
 
-  private constructor() {
-    super();
+  static instance({forceNew}: {
+    forceNew: boolean,
+  } = {forceNew: false}): HostConfigTracker {
+    if (!Root.DevToolsContext.globalInstance().has(HostConfigTracker) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(
+          HostConfigTracker,
+          new HostConfigTracker(),
+      );
+    }
+    return Root.DevToolsContext.globalInstance().get(HostConfigTracker);
+  }
+
+  dispose(): void {
+    clearTimeout(this.#pollTimer);
+    this.listeners = undefined;
   }
 
-  static instance(): HostConfigTracker {
-    if (!hostConfigTrackerInstance) {
-      hostConfigTrackerInstance = new HostConfigTracker();
+  static removeInstance(): void {
+    if (Root.DevToolsContext.globalInstance().has(HostConfigTracker)) {
+      Root.DevToolsContext.globalInstance().get(HostConfigTracker).dispose();
+      Root.DevToolsContext.globalInstance().delete(HostConfigTracker);
     }
-    return hostConfigTrackerInstance;
   }
 
   override addEventListener(eventType: Events, listener: Common.EventTarget.EventListener<EventTypes, Events>):

package/front_end/core/host/GdpClient.ts

@@ -98,21 +98,24 @@ async function makeHttpRequest<R>(request: DispatchHttpRequestRequest): Promise<
 }
 
 const SERVICE_NAME = 'gdpService';
-let gdpClientInstance: GdpClient|null = null;
 export class GdpClient {
   #cachedProfilePromise?: Promise<Profile>;
   #cachedEligibilityPromise?: Promise<CheckElibigilityResponse>;
 
-  private constructor() {
-  }
-
   static instance({forceNew}: {
     forceNew: boolean,
   } = {forceNew: false}): GdpClient {
-    if (!gdpClientInstance || forceNew) {
-      gdpClientInstance = new GdpClient();
+    if (!Root.DevToolsContext.globalInstance().has(GdpClient) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(
+          GdpClient,
+          new GdpClient(),
+      );
     }
-    return gdpClientInstance;
+    return Root.DevToolsContext.globalInstance().get(GdpClient);
+  }
+
+  static removeInstance(): void {
+    Root.DevToolsContext.globalInstance().delete(GdpClient);
   }
 
   /**

package/front_end/core/host/InspectorFrontendHost.ts

@@ -112,6 +112,7 @@ export function isUnderTest(prefs?: Record<string, string>): boolean {
     return prefs['isUnderTest'] === 'true';
   }
   return Common.Settings.Settings.hasInstance() &&
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       Common.Settings.Settings.instance().createSetting('isUnderTest', false).get();
 }
 

package/front_end/core/host/InspectorFrontendHostStub.ts

@@ -168,11 +168,13 @@ export class InspectorFrontendHostStub implements InspectorFrontendHostAPI {
   }
 
   openSearchResultsInNewTab(_query: string): void {
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     Common.Console.Console.instance().error(
         'Search is not enabled in hosted mode. Please inspect using chrome://inspect');
   }
 
   showItemInFolder(_fileSystemPath: Platform.DevToolsPath.RawPathString): void {
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     Common.Console.Console.instance().error(
         'Show item in folder is not enabled in hosted mode. Please inspect using chrome://inspect');
   }

package/front_end/core/platform/StringUtilities.ts

@@ -4,6 +4,8 @@
 
 import type {Brand} from './Brand.js';
 
+let graphemeSegmenter: Intl.Segmenter|null = null;
+
 export const escapeCharacters = (inputString: string, charsToEscape: string): string => {
   let foundChar = false;
   for (let i = 0; i < charsToEscape.length; ++i) {
@@ -48,23 +50,39 @@ const escapedReplacements = new Map([
   ['</script', '\\x3C/script'],
 ]);
 
+export const escapeUnicode = (content: string): string => {
+  return content.replaceAll(/[\p{Format}\p{Surrogate}]/gu, match => {
+    return match.split('').map(char => '\\u' + toHexadecimal(char.charCodeAt(0), 4)).join('');
+  });
+};
+
 export const formatAsJSLiteral = (content: string): string => {
-  const patternsToEscape = /(\\|<(?:!--|\/?script))|(\p{Control})|(\p{Surrogate})/gu;
-  const patternsToEscapePlusSingleQuote = /(\\|'|<(?:!--|\/?script))|(\p{Control})|(\p{Surrogate})/gu;
+  const patternsToEscape = /(\\|<(?:!--|\/?script))|(\p{Control}|\p{Format})|(\p{Surrogate})/giu;
+  const patternsToEscapePlusSingleQuote = /(\\|'|<(?:!--|\/?script))|(\p{Control}|\p{Format})|(\p{Surrogate})/giu;
   const escapePattern = (match: string, pattern: string, controlChar: string, loneSurrogate: string): string => {
     if (controlChar) {
       if (escapedReplacements.has(controlChar)) {
         // @ts-expect-error https://github.com/microsoft/TypeScript/issues/13086
         return escapedReplacements.get(controlChar);
       }
-      const twoDigitHex = toHexadecimal(controlChar.charCodeAt(0), 2);
-      return '\\x' + twoDigitHex;
+      return controlChar.split('')
+          .map(char => {
+            const charCode = char.charCodeAt(0);
+            if (controlChar.length === 1 && charCode <= 0xFF) {
+              return '\\x' + toHexadecimal(charCode, 2);
+            }
+            return '\\u' + toHexadecimal(charCode, 4);
+          })
+          .join('');
     }
     if (loneSurrogate) {
       const fourDigitHex = toHexadecimal(loneSurrogate.charCodeAt(0), 4);
       return '\\u' + fourDigitHex;
     }
     if (pattern) {
+      if (pattern.startsWith('<')) {
+        return '\\x3C' + pattern.slice(1);
+      }
       return escapedReplacements.get(pattern) || '';
     }
     return match;
@@ -447,6 +465,39 @@ export const trimEndWithMaxLength = (str: string, maxLength: number): string =>
   return str.slice(0, lastSegmentIndex) + ellipsis;
 };
 
+/**
+ * Truncates a string to not exceed a maximum number of UTF-16 code units (as measured by JS `string.length`).
+ *
+ * Unlike simple character limiters, this helper is grapheme-aware and uses `Intl.Segmenter` to prevent
+ * slicing inside surrogate pairs (e.g. Plane 1+ characters or emojis like '𠜎' / '🥳') or combining characters
+ * (e.g. 'é' represented in NFD as 'e' + combining acute accent). If the limit falls in the middle of a
+ * grapheme cluster, the function backs off to drop the entire cluster, ensuring the result is always a valid
+ * Unicode string.
+ *
+ * @param str The string to truncate.
+ * @param maxCodeUnits The maximum allowed code unit length (must be >= 0).
+ * @returns The truncated string, guaranteed to be <= maxCodeUnits in length and grapheme-safe.
+ */
+export const truncateToCodeUnitLength = (str: string, maxCodeUnits: number): string => {
+  if (isNaN(maxCodeUnits) || maxCodeUnits <= 0) {
+    return '';
+  }
+  if (str.length <= maxCodeUnits) {
+    return str;
+  }
+  if (!graphemeSegmenter) {
+    graphemeSegmenter = new Intl.Segmenter(undefined, {granularity: 'grapheme'});
+  }
+  let lastSafeIndex = 0;
+  for (const {index, segment} of graphemeSegmenter.segment(str)) {
+    if (index + segment.length > maxCodeUnits) {
+      break;
+    }
+    lastSafeIndex = index + segment.length;
+  }
+  return str.slice(0, lastSafeIndex);
+};
+
 export const escapeForRegExp = (str: string): string => {
   return escapeCharacters(str, SPECIAL_REGEX_CHARACTERS);
 };

package/front_end/core/sdk/AccessibilityModel.snapshot.txt

@@ -0,0 +1,17 @@
+Title: AccessibilityModel axNodeToText correctly formats an accessibility node tree to text
+Content:
+dialog "Confirmation"
+  button "Submit" focusable: true
+=== end content
+
+Title: AccessibilityModel axNodeToText correctly formats when the root node is ignored
+Content:
+Ignored
+  button "Submit" focusable: true
+=== end content
+
+Title: AccessibilityModel axNodeToText correctly formats when a nested node is ignored
+Content:
+dialog "Confirmation"
+  button "Submit" focusable: true
+=== end content

package/front_end/core/sdk/AccessibilityModel.ts

@@ -3,9 +3,10 @@
 // found in the LICENSE file.
 
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
-import type * as Protocol from '../../generated/protocol.js';
+import * as Protocol from '../../generated/protocol.js';
 
-import {DeferredDOMNode, DOMModel, type DOMNode, Events as DOMModelEvents} from './DOMModel.js';
+import {DeferredDOMNode, DOMDocument, DOMModel, type DOMNode, Events as DOMModelEvents} from './DOMModel.js';
+import type {FrameManager} from './FrameManager.js';
 import {SDKModel} from './SDKModel.js';
 import {Capability, type Target} from './Target.js';
 
@@ -23,6 +24,7 @@ export interface CoreOrProtocolAxProperty {
 
 export class AccessibilityNode {
   readonly #accessibilityModel: AccessibilityModel;
+  readonly #frameManager: FrameManager;
   readonly #id: Protocol.Accessibility.AXNodeId;
   readonly #backendDOMNodeId: Protocol.DOM.BackendNodeId|null;
   readonly #deferredDOMNode: DeferredDOMNode|null;
@@ -39,6 +41,7 @@ export class AccessibilityNode {
 
   constructor(accessibilityModel: AccessibilityModel, payload: Protocol.Accessibility.AXNode) {
     this.#accessibilityModel = accessibilityModel;
+    this.#frameManager = accessibilityModel.target().targetManager().getFrameManager();
 
     this.#id = payload.nodeId;
     accessibilityModel.setAXNodeForAXId(this.#id, this);
@@ -190,6 +193,63 @@ export class AccessibilityNode {
   getFrameId(): Protocol.Page.FrameId|null {
     return this.#frameId || this.parentNode()?.getFrameId() || null;
   }
+
+  isLeafNode(): boolean {
+    return this.numChildren() === 0 && this.role()?.value !== 'Iframe';
+  }
+
+  getNodeId(): string {
+    return this.getFrameId() + '#' + this.id();
+  }
+
+  async getChildren(): Promise<AccessibilityNode[]> {
+    if (this.role()?.value === 'Iframe') {
+      const domNode = await this.deferredDOMNode()?.resolvePromise();
+      if (!domNode) {
+        throw new Error('Could not find corresponding DOMNode');
+      }
+      const frameId = domNode.frameOwnerFrameId();
+      if (!frameId) {
+        throw new Error('No owner frameId on iframe node');
+      }
+      const localRoot = await getRootNode(frameId, this.#frameManager);
+      return [localRoot];
+    }
+    return await this.accessibilityModel().requestAXChildren(this.id(), this.getFrameId() || undefined);
+  }
+
+  async axNodeToText(depth = 0): Promise<string> {
+    const indent = '  '.repeat(depth);
+    const role = this.role()?.value || '';
+    const name = this.name()?.value || '';
+    const properties = this.properties() || [];
+    const ignored = this.ignored();
+    let childDepth = depth + 1;
+
+    const lines = [];
+    if (ignored) {
+      if (depth === 0) {
+        lines.push('Ignored\n');
+      } else {
+        childDepth = depth;
+      }
+    } else {
+      let line = `${indent}${role} "${name}"`;
+      for (const prop of properties) {
+        if (prop.value && isPrintableType(prop.value.type)) {
+          line += ` ${prop.name}: ${prop.value.value}`;
+        }
+      }
+      lines.push(line + '\n');
+    }
+
+    const children = await this.getChildren();
+    for (const child of children) {
+      lines.push(await child.axNodeToText(childDepth));
+    }
+
+    return lines.join('');
+  }
 }
 
 export const enum Events {
@@ -363,3 +423,73 @@ export class AccessibilityModel extends SDKModel<EventTypes> implements Protocol
 }
 
 SDKModel.register(AccessibilityModel, {capabilities: Capability.DOM, autostart: false});
+
+function getModel(frameId: Protocol.Page.FrameId, frameManager: FrameManager): AccessibilityModel {
+  const frame = frameManager.getFrame(frameId);
+  const model = frame?.resourceTreeModel().target().model(AccessibilityModel);
+  if (!model) {
+    throw new Error('Could not instantiate model for frameId');
+  }
+  return model;
+}
+
+export async function getRootNode(frameId: Protocol.Page.FrameId,
+                                  frameManager: FrameManager): Promise<AccessibilityNode> {
+  const model = getModel(frameId, frameManager);
+  const root = await model.requestRootNode(frameId);
+  if (!root) {
+    throw new Error('No accessibility root for frame');
+  }
+  return root;
+}
+
+function getFrameIdForNodeOrDocument(node: DOMNode): Protocol.Page.FrameId {
+  let frameId;
+  if (node instanceof DOMDocument) {
+    frameId = node.body?.frameId();
+  } else {
+    frameId = node.frameId();
+  }
+  if (!frameId) {
+    throw new Error('No frameId for DOM node');
+  }
+  return frameId;
+}
+
+export async function getNodeAndAncestorsFromDOMNode(domNode: DOMNode): Promise<AccessibilityNode[]> {
+  const frameManager = domNode.domModel().target().targetManager().getFrameManager();
+  let frameId = getFrameIdForNodeOrDocument(domNode);
+  const model = getModel(frameId, frameManager);
+  const result = await model.requestAndLoadSubTreeToNode(domNode);
+  if (!result) {
+    throw new Error('Could not retrieve accessibility node for inspected DOM node');
+  }
+
+  const outermostFrameId = frameManager.getOutermostFrame()?.id;
+  if (!outermostFrameId) {
+    return result;
+  }
+  while (frameId !== outermostFrameId) {
+    const node = await frameManager.getFrame(frameId)?.getOwnerDOMNodeOrDocument();
+    if (!node) {
+      break;
+    }
+    frameId = getFrameIdForNodeOrDocument(node);
+    const model = getModel(frameId, frameManager);
+    const ancestors = await model.requestAndLoadSubTreeToNode(node);
+    result.push(...ancestors || []);
+  }
+  return result;
+}
+
+export function isPrintableType(valueType: Protocol.Accessibility.AXValueType): boolean {
+  switch (valueType) {
+    case Protocol.Accessibility.AXValueType.Boolean:
+    case Protocol.Accessibility.AXValueType.BooleanOrUndefined:
+    case Protocol.Accessibility.AXValueType.String:
+    case Protocol.Accessibility.AXValueType.Number:
+      return true;
+    default:
+      return false;
+  }
+}

package/front_end/core/sdk/CPUThrottlingManager.ts

@@ -19,7 +19,10 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
     super();
     this.#targetManager = targetManager;
     this.#cpuThrottlingRate = 1;  // No throttling
-    targetManager.observeModels(EmulationModel, this);
+  }
+
+  initialize(): void {
+    this.#targetManager.observeModels(EmulationModel, this);
   }
 
   static instance(opts: {
@@ -29,10 +32,12 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
   } = {forceNew: null}): CPUThrottlingManager {
     const {forceNew} = opts;
     if (!Root.DevToolsContext.globalInstance().has(CPUThrottlingManager) || forceNew) {
-      Root.DevToolsContext.globalInstance().set(
-          CPUThrottlingManager,
-          new CPUThrottlingManager(opts.settings ?? Common.Settings.Settings.instance(),
-                                   opts.targetManager ?? TargetManager.instance()));
+      /* eslint-disable @devtools/no-instance-of-migrated-singletons */
+      const manager = new CPUThrottlingManager(opts.settings ?? Common.Settings.Settings.instance(),
+                                               opts.targetManager ?? TargetManager.instance());
+      /* eslint-enable @devtools/no-instance-of-migrated-singletons */
+      manager.initialize();
+      Root.DevToolsContext.globalInstance().set(CPUThrottlingManager, manager);
     }
 
     return Root.DevToolsContext.globalInstance().get(CPUThrottlingManager);

package/front_end/core/sdk/CompilerSourceMappingContentProvider.ts

@@ -7,7 +7,7 @@ import type * as Common from '../common/common.js';
 import * as i18n from '../i18n/i18n.js';
 import type * as Platform from '../platform/platform.js';
 
-import {PageResourceLoader, type PageResourceLoadInitiator} from './PageResourceLoader.js';
+import type {PageResourceLoader, PageResourceLoadInitiator} from './PageResourceLoader.js';
 
 const UIStrings = {
   /**
@@ -28,10 +28,7 @@ export class CompilerSourceMappingContentProvider implements TextUtils.ContentPr
   readonly #pageResourceLoader: PageResourceLoader;
 
   constructor(sourceURL: Platform.DevToolsPath.UrlString, contentType: Common.ResourceType.ResourceType,
-              initiator: PageResourceLoadInitiator,
-              pageResourceLoader: PageResourceLoader = initiator.target ?
-                  initiator.target.targetManager().context.get(PageResourceLoader) :
-                  PageResourceLoader.instance()) {
+              initiator: PageResourceLoadInitiator, pageResourceLoader: PageResourceLoader) {
     this.#sourceURL = sourceURL;
     this.#contentType = contentType;
     this.#initiator = initiator;

package/front_end/core/sdk/ConsoleModel.ts

@@ -35,7 +35,7 @@ import {
 } from './RuntimeModel.js';
 import {SDKModel} from './SDKModel.js';
 import {Capability, type Target, Type} from './Target.js';
-import {TargetManager} from './TargetManager.js';
+import type {TargetManager} from './TargetManager.js';
 
 export {FrontendMessageType} from './ConsoleModelTypes.js';
 
@@ -357,7 +357,7 @@ export class ConsoleModel extends SDKModel<EventTypes> {
   }
 
   // messages[] are not ordered by timestamp.
-  static allMessagesUnordered(targetManager: TargetManager = TargetManager.instance()): ConsoleMessage[] {
+  static allMessagesUnordered(targetManager: TargetManager): ConsoleMessage[] {
     const messages = [];
     for (const target of targetManager.targets()) {
       const targetMessages = target.model(ConsoleModel)?.messages() || [];
@@ -366,7 +366,7 @@ export class ConsoleModel extends SDKModel<EventTypes> {
     return messages;
   }
 
-  static requestClearMessages(targetManager: TargetManager = TargetManager.instance()): void {
+  static requestClearMessages(targetManager: TargetManager): void {
     for (const logModel of targetManager.models(LogModel)) {
       logModel.requestClear();
     }
@@ -394,7 +394,7 @@ export class ConsoleModel extends SDKModel<EventTypes> {
     return this.#errors;
   }
 
-  static allErrors(targetManager: TargetManager = TargetManager.instance()): number {
+  static allErrors(targetManager: TargetManager): number {
     let errors = 0;
     for (const target of targetManager.targets()) {
       errors += target.model(ConsoleModel)?.errors() || 0;
@@ -406,7 +406,7 @@ export class ConsoleModel extends SDKModel<EventTypes> {
     return this.#warnings;
   }
 
-  static allWarnings(targetManager: TargetManager = TargetManager.instance()): number {
+  static allWarnings(targetManager: TargetManager): number {
     let warnings = 0;
     for (const target of targetManager.targets()) {
       warnings += target.model(ConsoleModel)?.warnings() || 0;

package/front_end/core/sdk/DOMDebuggerModel.ts

@@ -537,6 +537,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   readonly #eventListenerBreakpoints: DOMEventListenerBreakpoint[] = [];
   readonly #targetManager: TargetManager;
 
+  // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
   constructor(targetManager: TargetManager = TargetManager.instance()) {
     this.#targetManager = targetManager;
     this.#xhrBreakpointsSetting = this.#targetManager.settings.createLocalSetting('xhr-breakpoints', []);
@@ -661,7 +662,9 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
     this.createEventListenerBreakpoints(
         Category.XHR, ['readystatechange', 'load', 'loadstart', 'loadend', 'abort', 'error', 'progress', 'timeout'],
         ['xmlhttprequest', 'xmlhttprequestupload']);
+  }
 
+  initialize(): void {
     this.#targetManager.observeModels(DOMDebuggerModel, this);
   }
 
@@ -671,9 +674,12 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   } = {forceNew: null}): DOMDebuggerManager {
     const {forceNew, targetManager} = opts;
     if (!Root.DevToolsContext.globalInstance().has(DOMDebuggerManager) || forceNew) {
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+      const manager = new DOMDebuggerManager(targetManager ?? TargetManager.instance());
+      manager.initialize();
       Root.DevToolsContext.globalInstance().set(
           DOMDebuggerManager,
-          new DOMDebuggerManager(targetManager ?? TargetManager.instance()),
+          manager,
       );
     }