chrome-devtools-frontend 1.0.1665921 → 1.0.1667564

package/front_end/core/host/AidaClient.ts

@@ -61,10 +61,33 @@ const AidaLanguageToMarkdown: Record<AidaInferenceLanguage, string> = {
   [AidaInferenceLanguage.UNKNOWN]: 'unknown',
 };
 
-export class AidaAbortError extends Error {}
-export class AidaBlockError extends Error {}
-export class AidaQuotaError extends Error {}
-export class AidaPayloadTooLargeError extends Error {}
+export abstract class AidaClientError extends Error {
+  override name = 'AidaClientError';
+}
+export class AidaUnknownError extends AidaClientError {
+  override name = 'AidaUnknownError';
+}
+export class AidaAbortError extends AidaClientError {
+  override name = 'AidaAbortError';
+}
+export class AidaBlockError extends AidaClientError {
+  override name = 'AidaBlockError';
+}
+export class AidaQuotaError extends AidaClientError {
+  override name = 'AidaQuotaError';
+}
+export class AidaPayloadTooLargeError extends AidaClientError {
+  override name = 'AidaPayloadTooLargeError';
+}
+export class AidaPermissionDeniedError extends AidaClientError {
+  override name = 'AidaPermissionDeniedError';
+}
+export class AidaTimeoutError extends AidaClientError {
+  override name = 'AidaTimeoutError';
+}
+export class AidaInvalidJsonResponseError extends AidaClientError {
+  override name = 'AidaInvalidJsonResponseError';
+}
 
 interface AiStream {
   write: (data: string) => Promise<void>;
@@ -185,40 +208,7 @@ export class AidaClient {
         },
         err => {
           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) {
-              if (isQuotaError(result.error, result.detail)) {
-                stream.fail(new AidaQuotaError(
-                    `Cannot send request: ${result.error}${result.detail ? ` ${result.detail}` : ''}`));
-                return;
-              }
-              if (isPayloadTooLargeError(result.error, result.detail)) {
-                stream.fail(new AidaPayloadTooLargeError(
-                    `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') {
-              stream.fail(new Error('doAidaConversation timed out'));
-              return;
-            }
-            if (result.statusCode !== 200) {
-              stream.fail(new Error(`Request failed: ${JSON.stringify(result)}`));
-              return;
-            }
-          }
-          stream.fail(err);
+          stream.fail(mapError(err));
         });
     await (yield* this.#handleResponseStream(stream));
   }
@@ -265,13 +255,7 @@ export class AidaClient {
             thoughtSignature: result.functionCallChunk.functionCall.thoughtSignature,
           });
         } else if ('error' in result) {
-          if (isQuotaError(result.error)) {
-            throw new AidaQuotaError(`Server responded: ${JSON.stringify(result)}`);
-          }
-          if (isPayloadTooLargeError(result.error)) {
-            throw new AidaPayloadTooLargeError(`Server responded: ${JSON.stringify(result)}`);
-          }
-          throw new Error(`Server responded: ${JSON.stringify(result)}`);
+          throw mapError(result.error);
         } else {
           throw new Error(`Unknown chunk result ${JSON.stringify(result)}`);
         }
@@ -364,14 +348,18 @@ export class AidaClient {
     }
 
     if (this.#gcaClient.enabled()) {
-      return await this.#gcaClient.completeCode(request);
+      try {
+        return await this.#gcaClient.completeCode(request);
+      } catch (err) {
+        throw mapError(err);
+      }
     }
     const {promise, resolve} = Promise.withResolvers<AidaCodeCompleteResult>();
     InspectorFrontendHostInstance.aidaCodeComplete(JSON.stringify(request), resolve);
     const completeCodeResult = await promise;
 
     if (completeCodeResult.error) {
-      throw new Error(`Cannot send request: ${completeCodeResult.error} ${completeCodeResult.detail || ''}`);
+      throw mapError(completeCodeResult.error, completeCodeResult.detail);
     }
     const response = completeCodeResult.response;
     if (!response?.length) {
@@ -420,18 +408,25 @@ export class AidaClient {
 
     if (this.#gcaClient.enabled()) {
       // Inline and remove the else clause after migration
-      return await this.#gcaClient.generateCode(request, options);
-    }
-    const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateCodeResponse>(
-        {
-          service: SERVICE_NAME,
-          path: '/v1/aida:generateCode',
-          method: 'POST',
-          body: JSON.stringify(request),
-        },
-        options);
+      try {
+        return await this.#gcaClient.generateCode(request, options);
+      } catch (err) {
+        throw mapError(err);
+      }
+    }
+    try {
+      const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateCodeResponse>({
+        service: SERVICE_NAME,
+        path: '/v1/aida:generateCode',
+        method: 'POST',
+        body: JSON.stringify(request),
+      },
+                                                                                             options);
 
-    return response;
+      return response;
+    } catch (err) {
+      throw mapError(err);
+    }
   }
 }
 
@@ -461,6 +456,10 @@ export class HostConfigTracker extends Common.ObjectWrapper.ObjectWrapper<EventT
   #pollTimer?: ReturnType<typeof setTimeout>;
   #aidaAvailability?: AidaAccessPreconditions;
 
+  get aidaAvailability(): AidaAccessPreconditions|undefined {
+    return this.#aidaAvailability;
+  }
+
   static instance({forceNew}: {
     forceNew: boolean,
   } = {forceNew: false}): HostConfigTracker {
@@ -512,9 +511,7 @@ export class HostConfigTracker extends Common.ObjectWrapper.ObjectWrapper<EventT
       const config =
           await new Promise<Root.Runtime.HostConfig>(resolve => InspectorFrontendHostInstance.getHostConfig(resolve));
       Object.assign(Root.Runtime.hostConfig, config);
-      // TODO(crbug.com/442545623): Send `currentAidaAvailability` to the listeners as part of the event so that
-      // `await AidaClient.checkAccessPreconditions()` does not need to be called again in the event handlers.
-      this.dispatchEventToListeners(Events.AIDA_AVAILABILITY_CHANGED);
+      this.dispatchEventToListeners(Events.AIDA_AVAILABILITY_CHANGED, currentAidaAvailability);
     }
   }
 }
@@ -524,13 +521,67 @@ export const enum Events {
 }
 
 export interface EventTypes {
-  [Events.AIDA_AVAILABILITY_CHANGED]: void;
+  [Events.AIDA_AVAILABILITY_CHANGED]: AidaAccessPreconditions;
 }
 
-function isQuotaError(...inputs: Array<string|undefined>): boolean {
+export function isQuotaError(...inputs: Array<string|undefined>): boolean {
   return inputs.some(input => input?.toLowerCase().includes('quota'));
 }
 
-function isPayloadTooLargeError(...inputs: Array<string|undefined>): boolean {
+export function isPayloadTooLargeError(...inputs: Array<string|undefined>): boolean {
   return inputs.some(input => input?.toLowerCase().includes('payload size exceeds the limit'));
 }
+
+/**
+ * Maps AIDA-specific errors, DispatchHttpRequestErrors, strings, and generic
+ * Errors to dedicated AidaClientError subclasses.
+ */
+export function mapError(err: unknown, detail?: string): AidaClientError {
+  if (err instanceof AidaClientError) {
+    return err;
+  }
+
+  if (err instanceof DispatchHttpRequestClient.DispatchHttpRequestError) {
+    if (err.type === DispatchHttpRequestClient.ErrorType.ABORT) {
+      return new AidaAbortError();
+    }
+    const response = err.response;
+    if (response) {
+      if (response.statusCode === 429) {
+        return new AidaQuotaError('Server responded: quota exceeded');
+      }
+      if (response.statusCode === 403) {
+        return new AidaPermissionDeniedError('Server responded: permission denied');
+      }
+      if ('netErrorName' in response && response.netErrorName === 'net::ERR_TIMED_OUT') {
+        return new AidaTimeoutError('AIDA request timed out');
+      }
+      if ('error' in response && response.error) {
+        return mapError(response.error, response.detail);
+      }
+      // The dispatcher throws HTTP_RESPONSE_UNAVAILABLE with status code 200
+      // when it successfully receives the HTTP response but fails to parse its JSON body.
+      if (response.statusCode === 200 && err.type === DispatchHttpRequestClient.ErrorType.HTTP_RESPONSE_UNAVAILABLE) {
+        return new AidaInvalidJsonResponseError('Server responded with invalid JSON', {cause: err});
+      }
+      if (response.statusCode !== 200) {
+        return new AidaUnknownError(`Request failed: ${JSON.stringify(response)}`);
+      }
+    }
+  }
+
+  if (typeof err === 'string') {
+    if (isQuotaError(err, detail)) {
+      return new AidaQuotaError(`Cannot send request: ${err}${detail ? ` ${detail}` : ''}`);
+    }
+    if (isPayloadTooLargeError(err, detail)) {
+      return new AidaPayloadTooLargeError(`Cannot send request: ${err}${detail ? ` ${detail}` : ''}`);
+    }
+    return new AidaUnknownError(`Cannot send request: ${err}${detail ? ` ${detail}` : ''}`);
+  }
+
+  if (err instanceof Error) {
+    return new AidaUnknownError(err.message, {cause: err});
+  }
+  return new AidaUnknownError(String(err));
+}

package/front_end/core/host/GcaClient.ts

@@ -91,8 +91,8 @@ export class GcaClient {
     return result ? gcaResponseToAidaGenerateCodeResponse(result) : null;
   }
 
-  async #requestContent(request: GenerateContentRequest, options?: {signal?: AbortSignal}):
-      Promise<GenerateContentResponse|null> {
+  async #requestContent(request: GenerateContentRequest,
+                        options?: {signal?: AbortSignal}): Promise<GenerateContentResponse> {
     try {
       const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateContentResponse>(
           {
@@ -106,7 +106,7 @@ export class GcaClient {
       return response;
     } catch (err) {
       debugLog('GCA request failed:', JSON.stringify(request), err);
-      return null;
+      throw err;
     }
   }
 }

package/front_end/core/host/InspectorFrontendHostAPI.ts

@@ -556,5 +556,6 @@ export const enum EnumeratedHistogram {
   LighthouseCategoryUsed = 'DevTools.LighthouseCategoryUsed',
   SwatchActivated = 'DevTools.SwatchActivated',
   BuiltInAiAvailability = 'DevTools.BuiltInAiAvailability',
+  ResendRequest = 'DevTools.ResendRequest',
   // LINT.ThenChange(/front_end/devtools_compatibility.js:EnumeratedHistogram)
 }

package/front_end/core/host/InspectorFrontendHostStub.ts

@@ -118,15 +118,15 @@ export class InspectorFrontendHostStub implements InspectorFrontendHostAPI {
   }
 
   setIsDocked(_isDocked: boolean, callback: () => void): void {
-    window.setTimeout(callback, 0);
+    globalThis.setTimeout(callback, 0);
   }
 
   showSurvey(_trigger: string, callback: (arg0: ShowSurveyResult) => void): void {
-    window.setTimeout(() => callback({surveyShown: false}), 0);
+    globalThis.setTimeout(() => callback({surveyShown: false}), 0);
   }
 
   canShowSurvey(_trigger: string, callback: (arg0: CanShowSurveyResult) => void): void {
-    window.setTimeout(() => callback({canShowSurvey: false}), 0);
+    globalThis.setTimeout(() => callback({canShowSurvey: false}), 0);
   }
 
   /**

package/front_end/core/host/UserMetrics.ts

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as Common from '../common/common.js';
+
 import {InspectorFrontendHostInstance} from './InspectorFrontendHost.js';
 import {EnumeratedHistogram} from './InspectorFrontendHostAPI.js';
 
@@ -29,6 +31,11 @@ export class UserMetrics {
     InspectorFrontendHostInstance.recordEnumeratedHistogram(EnumeratedHistogram.ActionTaken, action, Action.MAX_VALUE);
   }
 
+  resendRequest(resourceType: ResendRequestType): void {
+    InspectorFrontendHostInstance.recordEnumeratedHistogram(EnumeratedHistogram.ResendRequest, resourceType,
+                                                            ResendRequestType.MAX_VALUE);
+  }
+
   keybindSetSettingChanged(keybindSet: string): void {
     const value = KeybindSetSettings[keybindSet as keyof typeof KeybindSetSettings] || 0;
     InspectorFrontendHostInstance.recordEnumeratedHistogram(
@@ -253,7 +260,6 @@ export class UserMetrics {
     InspectorFrontendHostInstance.recordPerformanceHistogram(
         'DevTools.Insights.ShortTeaserGenerationTime', timeInMilliseconds);
   }
-
 }
 
 /**
@@ -813,18 +819,7 @@ export enum IssueCreated {
   'CookieIssue::ExcludeSameSiteNoneInsecure::SetCookie' = 15,
   'CookieIssue::WarnSameSiteNoneInsecure::ReadCookie' = 16,
   'CookieIssue::WarnSameSiteNoneInsecure::SetCookie' = 17,
-  'CookieIssue::WarnSameSiteStrictLaxDowngradeStrict::Secure' = 18,
-  'CookieIssue::WarnSameSiteStrictLaxDowngradeStrict::Insecure' = 19,
-  'CookieIssue::WarnCrossDowngrade::ReadCookie::Secure' = 20,
-  'CookieIssue::WarnCrossDowngrade::ReadCookie::Insecure' = 21,
-  'CookieIssue::WarnCrossDowngrade::SetCookie::Secure' = 22,
-  'CookieIssue::WarnCrossDowngrade::SetCookie::Insecure' = 23,
-  'CookieIssue::ExcludeNavigationContextDowngrade::Secure' = 24,
-  'CookieIssue::ExcludeNavigationContextDowngrade::Insecure' = 25,
-  'CookieIssue::ExcludeContextDowngrade::ReadCookie::Secure' = 26,
-  'CookieIssue::ExcludeContextDowngrade::ReadCookie::Insecure' = 27,
-  'CookieIssue::ExcludeContextDowngrade::SetCookie::Secure' = 28,
-  'CookieIssue::ExcludeContextDowngrade::SetCookie::Insecure' = 29,
+
   'CookieIssue::ExcludeSameSiteUnspecifiedTreatedAsLax::ReadCookie' = 30,
   'CookieIssue::ExcludeSameSiteUnspecifiedTreatedAsLax::SetCookie' = 31,
   'CookieIssue::WarnSameSiteUnspecifiedLaxAllowUnsafe::ReadCookie' = 32,
@@ -1193,3 +1188,45 @@ export const enum BuiltInAiAvailability {
   DISABLED_NO_GPU = 9,
   MAX_VALUE = 10,
 }
+
+export const enum ResendRequestType {
+  XHR = 0,
+  FETCH = 1,
+  SCRIPT = 2,
+  STYLESHEET = 3,
+  IMAGE = 4,
+  MEDIA = 5,
+  FONT = 6,
+  WASM = 7,
+  MANIFEST = 8,
+  TEXT_TRACK = 9,
+  SOURCE_MAP_SCRIPT = 10,
+  SOURCE_MAP_STYLE_SHEET = 11,
+  DOCUMENT = 12,
+  PREFETCH = 13,
+  PING = 14,
+  OTHER = 15,
+  MAX_VALUE = 16,
+}
+
+const resendRequestTypeMap = new Map<Common.ResourceType.ResourceType, ResendRequestType>([
+  [Common.ResourceType.resourceTypes.XHR, ResendRequestType.XHR],
+  [Common.ResourceType.resourceTypes.Fetch, ResendRequestType.FETCH],
+  [Common.ResourceType.resourceTypes.Script, ResendRequestType.SCRIPT],
+  [Common.ResourceType.resourceTypes.Stylesheet, ResendRequestType.STYLESHEET],
+  [Common.ResourceType.resourceTypes.Image, ResendRequestType.IMAGE],
+  [Common.ResourceType.resourceTypes.Media, ResendRequestType.MEDIA],
+  [Common.ResourceType.resourceTypes.Font, ResendRequestType.FONT],
+  [Common.ResourceType.resourceTypes.Wasm, ResendRequestType.WASM],
+  [Common.ResourceType.resourceTypes.Manifest, ResendRequestType.MANIFEST],
+  [Common.ResourceType.resourceTypes.TextTrack, ResendRequestType.TEXT_TRACK],
+  [Common.ResourceType.resourceTypes.SourceMapScript, ResendRequestType.SOURCE_MAP_SCRIPT],
+  [Common.ResourceType.resourceTypes.SourceMapStyleSheet, ResendRequestType.SOURCE_MAP_STYLE_SHEET],
+  [Common.ResourceType.resourceTypes.Document, ResendRequestType.DOCUMENT],
+  [Common.ResourceType.resourceTypes.Prefetch, ResendRequestType.PREFETCH],
+  [Common.ResourceType.resourceTypes.Ping, ResendRequestType.PING],
+]);
+
+export function resendRequestType(resourceType: Common.ResourceType.ResourceType): ResendRequestType {
+  return resendRequestTypeMap.get(resourceType) ?? ResendRequestType.OTHER;
+}

package/front_end/core/sdk/CSSMatchedStyles.ts

@@ -52,7 +52,7 @@ import {
   CSSStyleRule,
 } from './CSSRule.js';
 import {CSSStyleDeclaration, Type} from './CSSStyleDeclaration.js';
-import type {DOMNode} from './DOMModel.js';
+import {type DOMNode, NodeType} from './DOMModel.js';
 
 function containsStyle(styles: CSSStyleDeclaration[]|Set<CSSStyleDeclaration>, query: CSSStyleDeclaration): boolean {
   if (!query.styleSheetId || !query.range) {
@@ -456,7 +456,7 @@ export class CSSMatchedStyles {
     }
 
     // Inline style takes precedence over regular and inherited rules.
-    if (inlinePayload && this.#node.nodeType() === Node.ELEMENT_NODE) {
+    if (inlinePayload && this.#node.nodeType() === NodeType.ELEMENT_NODE) {
       const style = new CSSStyleDeclaration(this.#cssModel, null, inlinePayload, Type.Inline);
       this.#nodeForStyle.set(style, this.#node);
       nodeStyles.push(style);
@@ -905,9 +905,6 @@ export class CSSMatchedStyles {
 
     const matchCascade = (cascade: DOMInheritanceCascade): CSSStyleRule|null => {
       for (const style of cascade.styles()) {
-        if (this.isInherited(style)) {
-          continue;
-        }
         const parentRule = style.parentRule;
         if (!(parentRule instanceof CSSStyleRule)) {
           continue;

package/front_end/core/sdk/CSSPropertyParserMatchers.ts

@@ -243,6 +243,18 @@ function getCssEvaluationElement(): HTMLElement {
   return cssEvaluationElement;
 }
 
+/**
+ * If a test calls localEvalCSS, an element is created on demand for this
+ * purpose. This element is not removed from the DOM and will leak between tests
+ * if not removed.
+ */
+export function removeCSSEvaluationElement(): void {
+  if (cssEvaluationElement) {
+    document.body.removeChild(cssEvaluationElement);
+    cssEvaluationElement = null;
+  }
+}
+
 /**
  * These functions use an element in the frontend to evaluate CSS. The advantage
  * of this is that it is synchronous and doesn't require a CDP method. The

package/front_end/core/sdk/Connections.ts

@@ -189,7 +189,7 @@ export class StubTransport implements ProtocolClient.ConnectionTransport.Connect
   }
 
   sendRawMessage(message: string): void {
-    window.setTimeout(this.respondWithError.bind(this, message), 0);
+    globalThis.setTimeout(this.respondWithError.bind(this, message), 0);
   }
 
   private respondWithError(message: string): void {

package/front_end/core/sdk/DOMModel.test.api.ts

@@ -0,0 +1,104 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import {assert} from 'chai';
+
+import type * as Common from '../common/common.js';
+
+// eslint-disable-next-line @devtools/es-modules-import
+import * as SDK from './sdk.js';
+
+function findNode(node: SDK.DOMModel.DOMNode, predicate: (node: SDK.DOMModel.DOMNode) => boolean): SDK.DOMModel.DOMNode|
+    null {
+  if (predicate(node)) {
+    return node;
+  }
+  const children = node.children();
+  if (children) {
+    for (const child of children) {
+      const result = findNode(child, predicate);
+      if (result) {
+        return result;
+      }
+    }
+  }
+  return null;
+}
+
+describe('DOMModel API Test', () => {
+  it('generates attribute updated event only when attribute is actually changed', async ({inspectedPage, universe}) => {
+    const primaryTarget = universe.targetManager.primaryPageTarget();
+    assert.isNotNull(primaryTarget);
+
+    const domModel = primaryTarget.model(SDK.DOMModel.DOMModel);
+    assert.isNotNull(domModel);
+
+    await inspectedPage.goToHtml(`
+      <div id="container">
+          <div id="node-set-new-value" style="color:red"></div>
+          <div id="node-set-same-value" style="color:red"></div>
+      </div>
+    `);
+
+    const documentNode = await domModel.requestDocument();
+    assert.isNotNull(documentNode);
+
+    // Retrieve the subtree to populate the DOMModel cache.
+    await documentNode.getSubtree(5, true);
+
+    const container = findNode(documentNode, n => n.getAttribute('id') === 'container');
+    assert.isNotNull(container);
+
+    const nodeSetNewValue = findNode(documentNode, n => n.getAttribute('id') === 'node-set-new-value');
+    assert.isNotNull(nodeSetNewValue);
+
+    const nodeSetSameValue = findNode(documentNode, n => n.getAttribute('id') === 'node-set-same-value');
+    assert.isNotNull(nodeSetSameValue);
+
+    if (!nodeSetNewValue || !nodeSetSameValue) {
+      assert.fail('Could not find test nodes');
+    }
+
+    // Verifies that setting a new style attribute value triggers the AttrModified event.
+    let attrModifiedPromise = domModel.once(SDK.DOMModel.Events.AttrModified);
+
+    await inspectedPage.evaluate(() => {
+      (document.getElementById('node-set-new-value') as HTMLElement).style.setProperty('color', 'blue');
+    });
+
+    let eventData = await attrModifiedPromise;
+    assert.strictEqual(eventData.node, nodeSetNewValue);
+    assert.strictEqual(eventData.name, 'style');
+    assert.strictEqual(nodeSetNewValue.getAttribute('style'), 'color: blue;');
+
+    // Verifies that setting the style attribute to the same value does not trigger the AttrModified event.
+    let attrModifiedFired = false;
+    const listener =
+        (event: Common.EventTarget
+             .EventTargetEvent<SDK.DOMModel.EventTypes[SDK.DOMModel.Events.AttrModified], SDK.DOMModel.EventTypes>):
+            void => {
+              if (event.data.node === nodeSetSameValue) {
+                attrModifiedFired = true;
+              }
+            };
+    domModel.addEventListener(SDK.DOMModel.Events.AttrModified, listener);
+
+    await inspectedPage.evaluate(() => {
+      (document.getElementById('node-set-same-value') as HTMLElement).style.setProperty('color', 'red');
+    });
+
+    // Flushes pending events by triggering a style change on the new value node.
+    attrModifiedPromise = domModel.once(SDK.DOMModel.Events.AttrModified);
+
+    await inspectedPage.evaluate(() => {
+      (document.getElementById('node-set-new-value') as HTMLElement).style.setProperty('color', 'green');
+    });
+
+    eventData = await attrModifiedPromise;
+    assert.strictEqual(eventData.node, nodeSetNewValue);
+    assert.isFalse(attrModifiedFired, 'AttrModified should not have fired for same value');
+
+    domModel.removeEventListener(SDK.DOMModel.Events.AttrModified, listener);
+  });
+});

package/front_end/core/sdk/DOMModel.ts

@@ -50,6 +50,18 @@ import {SDKModel} from './SDKModel.js';
 import {Capability, type Target} from './Target.js';
 import type {TargetManager} from './TargetManager.js';
 
+export const enum NodeType {
+  ELEMENT_NODE = 1,
+  ATTRIBUTE_NODE = 2,
+  TEXT_NODE = 3,
+  CDATA_SECTION_NODE = 4,
+  PROCESSING_INSTRUCTION_NODE = 7,
+  COMMENT_NODE = 8,
+  DOCUMENT_NODE = 9,
+  DOCUMENT_TYPE_NODE = 10,
+  DOCUMENT_FRAGMENT_NODE = 11,
+}
+
 /** Keep this list in sync with https://w3c.github.io/aria/#state_prop_def **/
 export const ARIA_ATTRIBUTES = new Set<string>([
   'role',
@@ -297,7 +309,7 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
       this.#adProvenance = payload.adProvenance;
     }
 
-    if (this.#nodeType === Node.ELEMENT_NODE) {
+    if (this.#nodeType === NodeType.ELEMENT_NODE) {
       // HTML and BODY from internal iframes should not overwrite top-level ones.
       if (this.ownerDocument && !this.ownerDocument.documentElement && this.#nodeName === 'HTML') {
         this.ownerDocument.documentElement = this;
@@ -305,11 +317,11 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
       if (this.ownerDocument && !this.ownerDocument.body && this.#nodeName === 'BODY') {
         this.ownerDocument.body = this;
       }
-    } else if (this.#nodeType === Node.DOCUMENT_TYPE_NODE) {
+    } else if (this.#nodeType === NodeType.DOCUMENT_TYPE_NODE) {
       this.publicId = payload.publicId;
       this.systemId = payload.systemId;
       this.internalSubset = payload.internalSubset;
-    } else if (this.#nodeType === Node.ATTRIBUTE_NODE) {
+    } else if (this.#nodeType === NodeType.ATTRIBUTE_NODE) {
       this.name = payload.name;
       this.value = payload.value;
     }
@@ -354,7 +366,7 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
   }
 
   isRootNode(): boolean {
-    if (this.nodeType() === Node.ELEMENT_NODE && this.nodeName() === 'HTML') {
+    if (this.nodeType() === NodeType.ELEMENT_NODE && this.nodeName() === 'HTML') {
       return true;
     }
     return false;
@@ -762,7 +774,7 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
       if (node.isShadowRoot()) {
         return node.shadowRootType() === DOMNode.ShadowRootTypes.UserAgent ? 'u' : 'a';
       }
-      if (node.nodeType() === Node.DOCUMENT_NODE) {
+      if (node.nodeType() === NodeType.DOCUMENT_NODE) {
         return 'd';
       }
       return null;
@@ -1018,7 +1030,7 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
   }
 
   isCustomElement(): boolean {
-    if (this.nodeType() !== Node.ELEMENT_NODE || this.isXMLNode()) {
+    if (this.nodeType() !== NodeType.ELEMENT_NODE || this.isXMLNode()) {
       return false;
     }
     const localName = this.localName() || this.nodeName().toLowerCase();
@@ -1158,11 +1170,11 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
 
   enclosingElementOrSelf(): DOMNode|null {
     let node: DOMNode|null = this;
-    if (node && node.nodeType() === Node.TEXT_NODE && node.parentNode) {
+    if (node && node.nodeType() === NodeType.TEXT_NODE && node.parentNode) {
       node = node.parentNode;
     }
 
-    if (node && node.nodeType() !== Node.ELEMENT_NODE) {
+    if (node && node.nodeType() !== NodeType.ELEMENT_NODE) {
       node = null;
     }
     return node;
@@ -1223,7 +1235,7 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
 
   simpleSelector(): string {
     const lowerCaseName = this.localName() || this.nodeName().toLowerCase();
-    if (this.nodeType() !== Node.ELEMENT_NODE) {
+    if (this.nodeType() !== NodeType.ELEMENT_NODE) {
       return lowerCaseName;
     }
     const type = this.getAttribute('type');
@@ -1474,7 +1486,7 @@ export class DOMModel extends SDKModel<EventTypes> {
   #lastMutationId!: number;
   #pendingDocumentRequestPromise: Promise<DOMDocument|null>|null = null;
   #frameOwnerNode?: DOMNode|null;
-  #loadNodeAttributesTimeout?: number;
+  #loadNodeAttributesTimeout?: ReturnType<typeof setTimeout>;
   #searchId?: string;
   #topLayerThrottler = new Common.Throttler.Throttler(100);
   #topLayerNodes: DOMNode[] = [];
@@ -1663,7 +1675,7 @@ export class DOMModel extends SDKModel<EventTypes> {
   inlineStyleInvalidated(nodeIds: Protocol.DOM.NodeId[]): void {
     nodeIds.forEach(nodeId => this.#attributeLoadNodeIds.add(nodeId));
     if (!this.#loadNodeAttributesTimeout) {
-      this.#loadNodeAttributesTimeout = window.setTimeout(this.loadNodeAttributes.bind(this), 20);
+      this.#loadNodeAttributesTimeout = globalThis.setTimeout(this.loadNodeAttributes.bind(this), 20);
     }
   }