chrome-devtools-frontend 1.0.1684555 → 1.0.1690116

package/front_end/core/sdk/CSSPropertyParserMatchers.ts

@@ -21,6 +21,7 @@ import {
   type Match,
   matchDeclaration,
   matcherBase,
+  type MatcherClass,
   type SyntaxTree,
   tokenizeDeclaration,
 } from './CSSPropertyParser.js';
@@ -56,12 +57,13 @@ export class BaseVariableMatch implements Match {
   }
 }
 
+const BaseVariableMatcherBase: MatcherClass<BaseVariableMatch> = matcherBase(BaseVariableMatch);
 // This matcher provides matching for var() functions and basic computedText support. Computed text is resolved by a
 // callback. This matcher is intended to be used directly only in environments where CSSMatchedStyles is not available.
 // A more ergonomic version of this matcher exists in VariableMatcher, which uses CSSMatchedStyles to correctly resolve
 // variable references automatically.
 // clang-format off
-export class BaseVariableMatcher extends matcherBase(BaseVariableMatch) {
+export class BaseVariableMatcher extends BaseVariableMatcherBase {
   // clang-format on
   readonly #computedTextCallback: (match: BaseVariableMatch, matching: BottomUpTreeMatching) => string | null;
   constructor(computedTextCallback: (match: BaseVariableMatch, matching: BottomUpTreeMatching) => string | null) {
@@ -114,8 +116,9 @@ export class VariableMatch extends BaseVariableMatch {
   }
 }
 
+const VariableMatcherBase: MatcherClass<VariableMatch> = matcherBase(VariableMatch);
 // clang-format off
-export class VariableMatcher extends matcherBase(VariableMatch) {
+export class VariableMatcher extends VariableMatcherBase {
   // clang-format on
   constructor(readonly matchedStyles: CSSMatchedStyles, readonly style: CSSStyleDeclaration) {
     super();
@@ -144,8 +147,9 @@ export class VariableNameMatch implements Match {
   }
 }
 
+const VariableNameMatcherBase: MatcherClass<VariableNameMatch> = matcherBase(VariableNameMatch);
 // clang-format off
-export class VariableNameMatcher extends matcherBase(VariableNameMatch) {
+export class VariableNameMatcher extends VariableNameMatcherBase {
   // clang-format on
   constructor(readonly matchedStyles: CSSMatchedStyles, readonly style: CSSStyleDeclaration) {
     super();
@@ -270,10 +274,11 @@ export function defaultValueForCSSType(type: string|null): string|null {
 
 export const RAW_STRING_TYPE = 'raw-string';
 
+const AttributeMatcherBase: MatcherClass<AttributeMatch> = matcherBase(AttributeMatch);
 // This matcher provides matching for attr() functions and basic computedText support. Computed text is resolved by a
 // callback.
 // clang-format off
-export class AttributeMatcher extends matcherBase(AttributeMatch) {
+export class AttributeMatcher extends AttributeMatcherBase {
   // clang-format on
   constructor(
       private readonly matchedStyles: CSSMatchedStyles,
@@ -347,8 +352,9 @@ export class BinOpMatch implements Match {
   }
 }
 
+const BinOpMatcherBase: MatcherClass<BinOpMatch> = matcherBase(BinOpMatch);
 // clang-format off
-export class BinOpMatcher extends matcherBase(BinOpMatch) {
+export class BinOpMatcher extends BinOpMatcherBase {
   // clang-format on
   override accepts(): boolean {
     return true;
@@ -372,8 +378,9 @@ export class TextMatch implements Match {
   }
 }
 
+const TextMatcherBase: MatcherClass<TextMatch> = matcherBase(TextMatch);
 // clang-format off
-export class TextMatcher extends matcherBase(TextMatch) {
+export class TextMatcher extends TextMatcherBase {
   // clang-format on
   override accepts(): boolean {
     return true;
@@ -399,8 +406,9 @@ export class AngleMatch implements Match {
   }
 }
 
+const AngleMatcherBase: MatcherClass<AngleMatch> = matcherBase(AngleMatch);
 // clang-format off
-export class AngleMatcher extends matcherBase(AngleMatch) {
+export class AngleMatcher extends AngleMatcherBase {
   // clang-format on
   override accepts(propertyName: string): boolean {
     return cssMetadata().isAngleAwareProperty(propertyName);
@@ -435,8 +443,9 @@ export class ColorMixMatch implements Match {
   }
 }
 
+const ColorMixMatcherBase: MatcherClass<ColorMixMatch> = matcherBase(ColorMixMatch);
 // clang-format off
-export class ColorMixMatcher extends matcherBase(ColorMixMatch) {
+export class ColorMixMatcher extends ColorMixMatcherBase {
   // clang-format on
   override accepts(propertyName: string): boolean {
     return cssMetadata().isColorAwareProperty(propertyName);
@@ -497,8 +506,9 @@ export class ContrastColorMatch implements Match {
   }
 }
 
+const ContrastColorMatcherBase: MatcherClass<ContrastColorMatch> = matcherBase(ContrastColorMatch);
 // clang-format off
-export class ContrastColorMatcher extends matcherBase(ContrastColorMatch) {
+export class ContrastColorMatcher extends ContrastColorMatcherBase {
   // clang-format on
   override accepts(propertyName: string): boolean {
     return cssMetadata().isColorAwareProperty(propertyName);
@@ -527,8 +537,9 @@ export class URLMatch implements Match {
   }
 }
 
+const URLMatcherBase: MatcherClass<URLMatch> = matcherBase(URLMatch);
 // clang-format off
-export class URLMatcher extends matcherBase(URLMatch) {
+export class URLMatcher extends URLMatcherBase {
   // clang-format on
   override matches(node: CodeMirror.SyntaxNode, matching: BottomUpTreeMatching): URLMatch|null {
     if (node.name !== 'CallLiteral') {
@@ -557,8 +568,9 @@ export class LinearGradientMatch implements Match {
   }
 }
 
+const LinearGradientMatcherBase: MatcherClass<LinearGradientMatch> = matcherBase(LinearGradientMatch);
 // clang-format off
-export class LinearGradientMatcher extends matcherBase(LinearGradientMatch) {
+export class LinearGradientMatcher extends LinearGradientMatcherBase {
   // clang-format on
   override matches(node: CodeMirror.SyntaxNode, matching: BottomUpTreeMatching): Match|null {
     const text = matching.ast.text(node);
@@ -579,15 +591,16 @@ interface RelativeColor {
 
 export class ColorMatch implements Match {
   computedText: (() => string | null)|undefined;
-  constructor(
-      readonly text: string, readonly node: CodeMirror.SyntaxNode,
-      private readonly currentColorCallback?: () => string | null, readonly relativeColor?: RelativeColor) {
+  constructor(readonly text: string, readonly node: CodeMirror.SyntaxNode,
+              private readonly currentColorCallback?: () => string | null,
+              readonly relativeColor?: RelativeColor|undefined) {
     this.computedText = currentColorCallback;
   }
 }
 
+const ColorMatcherBase: MatcherClass<ColorMatch> = matcherBase(ColorMatch);
 // clang-format off
-export class ColorMatcher extends matcherBase(ColorMatch) {
+export class ColorMatcher extends ColorMatcherBase {
   constructor(private readonly currentColorCallback?: () => string|null) {
       super();
   }
@@ -724,8 +737,9 @@ export class RelativeColorChannelMatch implements Match {
   }
 }
 
+const RelativeColorChannelMatcherBase: MatcherClass<RelativeColorChannelMatch> = matcherBase(RelativeColorChannelMatch);
 // clang-format off
-export class RelativeColorChannelMatcher extends matcherBase(RelativeColorChannelMatch) {
+export class RelativeColorChannelMatcher extends RelativeColorChannelMatcherBase {
   // clang-format on
   override accepts(propertyName: string): boolean {
     return cssMetadata().isColorAwareProperty(propertyName);
@@ -747,8 +761,9 @@ export class LightDarkColorMatch implements Match {
   }
 }
 
+const LightDarkColorMatcherBase: MatcherClass<LightDarkColorMatch> = matcherBase(LightDarkColorMatch);
 // clang-format off
-export class LightDarkColorMatcher extends matcherBase(LightDarkColorMatch) {
+export class LightDarkColorMatcher extends LightDarkColorMatcherBase {
   // clang-format on
   constructor(readonly style: CSSStyleDeclaration) {
     super();
@@ -776,8 +791,9 @@ export class AutoBaseMatch implements Match {
   }
 }
 
+const AutoBaseMatcherBase: MatcherClass<AutoBaseMatch> = matcherBase(AutoBaseMatch);
 // clang-format off
-export class AutoBaseMatcher extends matcherBase(AutoBaseMatch) {
+export class AutoBaseMatcher extends AutoBaseMatcherBase {
   // clang-format on
   override matches(node: CodeMirror.SyntaxNode, matching: BottomUpTreeMatching): AutoBaseMatch|null {
     if (node.name !== 'CallExpression' || matching.ast.text(node.getChild('Callee')) !== '-internal-auto-base') {
@@ -817,8 +833,9 @@ export class LinkableNameMatch implements Match {
   }
 }
 
+const LinkableNameMatcherBase: MatcherClass<LinkableNameMatch> = matcherBase(LinkableNameMatch);
 // clang-format off
-export class LinkableNameMatcher extends matcherBase(LinkableNameMatch) {
+export class LinkableNameMatcher extends LinkableNameMatcherBase {
   // clang-format on
   private static isLinkableNameProperty(propertyName: string): propertyName is LinkableNameProperties {
     const names: string[] = [
@@ -833,29 +850,30 @@ export class LinkableNameMatcher extends matcherBase(LinkableNameMatch) {
     return names.includes(propertyName);
   }
 
-  static readonly identifierAnimationLonghandMap = new Map<string, AnimationLonghandPart>(
-      Object.entries({
-        normal: AnimationLonghandPart.DIRECTION,
-        alternate: AnimationLonghandPart.DIRECTION,
-        reverse: AnimationLonghandPart.DIRECTION,
-        'alternate-reverse': AnimationLonghandPart.DIRECTION,
-        none: AnimationLonghandPart.FILL_MODE,
-        forwards: AnimationLonghandPart.FILL_MODE,
-        backwards: AnimationLonghandPart.FILL_MODE,
-        both: AnimationLonghandPart.FILL_MODE,
-        running: AnimationLonghandPart.PLAY_STATE,
-        paused: AnimationLonghandPart.PLAY_STATE,
-        infinite: AnimationLonghandPart.ITERATION_COUNT,
-        linear: AnimationLonghandPart.EASING_FUNCTION,
-        ease: AnimationLonghandPart.EASING_FUNCTION,
-        'ease-in': AnimationLonghandPart.EASING_FUNCTION,
-        'ease-out': AnimationLonghandPart.EASING_FUNCTION,
-        'ease-in-out': AnimationLonghandPart.EASING_FUNCTION,
-        steps: AnimationLonghandPart.EASING_FUNCTION,
-        'step-start': AnimationLonghandPart.EASING_FUNCTION,
-        'step-end': AnimationLonghandPart.EASING_FUNCTION,
-      }),
-  );
+  static readonly identifierAnimationLonghandMap: Map<string, AnimationLonghandPart> =
+      new Map<string, AnimationLonghandPart>(
+          Object.entries({
+            normal: AnimationLonghandPart.DIRECTION,
+            alternate: AnimationLonghandPart.DIRECTION,
+            reverse: AnimationLonghandPart.DIRECTION,
+            'alternate-reverse': AnimationLonghandPart.DIRECTION,
+            none: AnimationLonghandPart.FILL_MODE,
+            forwards: AnimationLonghandPart.FILL_MODE,
+            backwards: AnimationLonghandPart.FILL_MODE,
+            both: AnimationLonghandPart.FILL_MODE,
+            running: AnimationLonghandPart.PLAY_STATE,
+            paused: AnimationLonghandPart.PLAY_STATE,
+            infinite: AnimationLonghandPart.ITERATION_COUNT,
+            linear: AnimationLonghandPart.EASING_FUNCTION,
+            ease: AnimationLonghandPart.EASING_FUNCTION,
+            'ease-in': AnimationLonghandPart.EASING_FUNCTION,
+            'ease-out': AnimationLonghandPart.EASING_FUNCTION,
+            'ease-in-out': AnimationLonghandPart.EASING_FUNCTION,
+            steps: AnimationLonghandPart.EASING_FUNCTION,
+            'step-start': AnimationLonghandPart.EASING_FUNCTION,
+            'step-end': AnimationLonghandPart.EASING_FUNCTION,
+          }),
+      );
 
   private matchAnimationNameInShorthand(node: CodeMirror.SyntaxNode, matching: BottomUpTreeMatching): LinkableNameMatch|
       null {
@@ -949,8 +967,9 @@ export class BezierMatch implements Match {
   }
 }
 
+const BezierMatcherBase: MatcherClass<BezierMatch> = matcherBase(BezierMatch);
 // clang-format off
-export class BezierMatcher extends matcherBase(BezierMatch) {
+export class BezierMatcher extends BezierMatcherBase {
   // clang-format on
   override accepts(propertyName: string): boolean {
     return cssMetadata().isBezierAwareProperty(propertyName);
@@ -975,8 +994,9 @@ export class StringMatch implements Match {
   }
 }
 
+const StringMatcherBase: MatcherClass<StringMatch> = matcherBase(StringMatch);
 // clang-format off
-export class StringMatcher extends matcherBase(StringMatch) {
+export class StringMatcher extends StringMatcherBase {
   // clang-format on
   override matches(node: CodeMirror.SyntaxNode, matching: BottomUpTreeMatching): Match|null {
     return node.name === 'StringLiteral' ? new StringMatch(matching.ast.text(node), node) : null;
@@ -992,8 +1012,9 @@ export class ShadowMatch implements Match {
   }
 }
 
+const ShadowMatcherBase: MatcherClass<ShadowMatch> = matcherBase(ShadowMatch);
 // clang-format off
-export class ShadowMatcher extends matcherBase(ShadowMatch) {
+export class ShadowMatcher extends ShadowMatcherBase {
   // clang-format on
   override accepts(propertyName: string): boolean {
     return cssMetadata().isShadowProperty(propertyName);
@@ -1017,10 +1038,11 @@ export class LengthMatch implements Match {
   }
 }
 
+const LengthMatcherBase: MatcherClass<LengthMatch> = matcherBase(LengthMatch);
 // clang-format off
-export class LengthMatcher extends matcherBase(LengthMatch) {
+export class LengthMatcher extends LengthMatcherBase {
   // clang-format on
-  static readonly LENGTH_UNITS = new Set([
+  static readonly LENGTH_UNITS: Set<string> = new Set([
     'em',    'ex',    'ch',  'cap', 'ic',    'lh',    'rem',   'rex',   'rch',  'rlh',  'ric', 'rcap', 'pt',    'pc',
     'in',    'cm',    'mm',  'Q',   'vw',    'vh',    'vi',    'vb',    'vmin', 'vmax', 'dvw', 'dvh',  'dvi',   'dvb',
     'dvmin', 'dvmax', 'svw', 'svh', 'svi',   'svb',   'svmin', 'svmax', 'lvw',  'lvh',  'lvi', 'lvb',  'lvmin', 'lvmax',
@@ -1079,8 +1101,9 @@ export class MathFunctionMatch extends BaseFunctionMatch<MathFunction> {
   }
 }
 
+const MathFunctionMatcherBase: MatcherClass<MathFunctionMatch> = matcherBase(MathFunctionMatch);
 // clang-format off
-export class MathFunctionMatcher extends matcherBase(MathFunctionMatch) {
+export class MathFunctionMatcher extends MathFunctionMatcherBase {
   // clang-format on
   private static getFunctionType(callee: string|null): MathFunction|null {
     const maybeFunc = callee as MathFunction | null;
@@ -1125,8 +1148,9 @@ export class MathFunctionMatcher extends matcherBase(MathFunctionMatch) {
 
 export class CustomFunctionMatch extends BaseFunctionMatch<string> {}
 
+const CustomFunctionMatcherBase: MatcherClass<CustomFunctionMatch> = matcherBase(CustomFunctionMatch);
 // clang-format off
-export class CustomFunctionMatcher extends matcherBase(CustomFunctionMatch) {
+export class CustomFunctionMatcher extends CustomFunctionMatcherBase {
   // clang-format on
 
   override matches(node: CodeMirror.SyntaxNode, matching: BottomUpTreeMatching): CustomFunctionMatch|null {
@@ -1157,12 +1181,13 @@ export class FlexGridGridLanesMatch implements Match {
   }
 }
 
+const FlexGridGridLanesMatcherBase: MatcherClass<FlexGridGridLanesMatch> = matcherBase(FlexGridGridLanesMatch);
 // clang-format off
-export class FlexGridGridLanesMatcher extends matcherBase(FlexGridGridLanesMatch) {
+export class FlexGridGridLanesMatcher extends FlexGridGridLanesMatcherBase {
   // clang-format on
-  static readonly FLEX = ['flex', 'inline-flex', 'block flex', 'inline flex'];
-  static readonly GRID = ['grid', 'inline-grid', 'block grid', 'inline grid'];
-  static readonly GRID_LANES = ['grid-lanes', 'inline-grid-lanes', 'block grid-lanes', 'inline grid-lanes'];
+  static readonly FLEX: string[] = ['flex', 'inline-flex', 'block flex', 'inline flex'];
+  static readonly GRID: string[] = ['grid', 'inline-grid', 'block grid', 'inline grid'];
+  static readonly GRID_LANES: string[] = ['grid-lanes', 'inline-grid-lanes', 'block grid-lanes', 'inline grid-lanes'];
   override accepts(propertyName: string): boolean {
     return propertyName === 'display';
   }
@@ -1197,8 +1222,9 @@ export class GridTemplateMatch implements Match {
   }
 }
 
+const GridTemplateMatcherBase: MatcherClass<GridTemplateMatch> = matcherBase(GridTemplateMatch);
 // clang-format off
-export class GridTemplateMatcher extends matcherBase(GridTemplateMatch) {
+export class GridTemplateMatcher extends GridTemplateMatcherBase {
   // clang-format on
   override accepts(propertyName: string): boolean {
     return cssMetadata().isGridAreaDefiningProperty(propertyName);
@@ -1293,8 +1319,9 @@ export class AnchorFunctionMatch implements Match {
   }
 }
 
+const AnchorFunctionMatcherBase: MatcherClass<AnchorFunctionMatch> = matcherBase(AnchorFunctionMatch);
 // clang-format off
-export class AnchorFunctionMatcher extends matcherBase(AnchorFunctionMatch) {
+export class AnchorFunctionMatcher extends AnchorFunctionMatcherBase {
   // clang-format on
   anchorFunction(node: CodeMirror.SyntaxNode, matching: BottomUpTreeMatching): string|null {
     if (node.name !== 'CallExpression') {
@@ -1343,8 +1370,9 @@ export class PositionAnchorMatch implements Match {
   }
 }
 
+const PositionAnchorMatcherBase: MatcherClass<PositionAnchorMatch> = matcherBase(PositionAnchorMatch);
 // clang-format off
-export class PositionAnchorMatcher extends matcherBase(PositionAnchorMatch) {
+export class PositionAnchorMatcher extends PositionAnchorMatcherBase {
   // clang-format on
   override accepts(propertyName: string): boolean {
     return propertyName === 'position-anchor';
@@ -1373,8 +1401,9 @@ export class CSSWideKeywordMatch implements Match {
   }
 }
 
+const CSSWideKeywordMatcherBase: MatcherClass<CSSWideKeywordMatch> = matcherBase(CSSWideKeywordMatch);
 // clang-format off
-export class CSSWideKeywordMatcher extends matcherBase(CSSWideKeywordMatch) {
+export class CSSWideKeywordMatcher extends CSSWideKeywordMatcherBase {
   // clang-format on
   constructor(readonly property: CSSProperty, readonly matchedStyles: CSSMatchedStyles) {
     super();
@@ -1407,8 +1436,9 @@ export class PositionTryMatch implements Match {
   }
 }
 
+const PositionTryMatcherBase: MatcherClass<PositionTryMatch> = matcherBase(PositionTryMatch);
 // clang-format off
-export class PositionTryMatcher extends matcherBase(PositionTryMatch) {
+export class PositionTryMatcher extends PositionTryMatcherBase {
   // clang-format on
   override accepts(propertyName: string): boolean {
     return propertyName === LinkableNameProperties.POSITION_TRY ||
@@ -1452,8 +1482,9 @@ export class EnvFunctionMatch implements Match {
   }
 }
 
+const EnvFunctionMatcherBase: MatcherClass<EnvFunctionMatch> = matcherBase(EnvFunctionMatch);
 // clang-format off
-export class EnvFunctionMatcher extends matcherBase(EnvFunctionMatch) {
+export class EnvFunctionMatcher extends EnvFunctionMatcherBase {
   // clang-format on
   constructor(readonly matchedStyles: CSSMatchedStyles) {
     super();

package/front_end/core/sdk/ConsoleModel.ts

@@ -797,7 +797,7 @@ export type MessageSource = Protocol.Log.LogEntrySource|Common.Console.FrontendM
 export type MessageLevel = Protocol.Log.LogEntryLevel;
 export type MessageType = Protocol.Runtime.ConsoleAPICalledEventType|FrontendMessageType;
 
-export const MessageSourceDisplayName = new Map<MessageSource, string>(([
+export const MessageSourceDisplayName: Map<MessageSource, string> = new Map<MessageSource, string>(([
   [Protocol.Log.LogEntrySource.XML, 'xml'],
   [Protocol.Log.LogEntrySource.Javascript, 'javascript'],
   [Protocol.Log.LogEntrySource.Network, 'network'],

package/front_end/core/sdk/DOMModel.ts

@@ -48,6 +48,7 @@ import {RemoteObject} from './RemoteObject.js';
 import {Events as ResourceTreeModelEvents, type ResourceTreeFrame, ResourceTreeModel} from './ResourceTreeModel.js';
 import {RuntimeModel} from './RuntimeModel.js';
 import {SDKModel} from './SDKModel.js';
+import {SecurityOrigin} from './SecurityOrigin.js';
 import {Capability, type Target} from './Target.js';
 import type {TargetManager} from './TargetManager.js';
 
@@ -64,7 +65,7 @@ export const enum NodeType {
 }
 
 /** Keep this list in sync with https://w3c.github.io/aria/#state_prop_def **/
-export const ARIA_ATTRIBUTES = new Set<string>([
+export const ARIA_ATTRIBUTES: Set<string> = new Set<string>([
   'role',
   'aria-activedescendant',
   'aria-atomic',
@@ -387,6 +388,14 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
     return this.#topLayerIndex;
   }
 
+  /**
+   * Returns the security origin of the document owning this node, or `null` if
+   * this node is not attached to a document.
+   */
+  securityOrigin(): SecurityOrigin|null {
+    return this.ownerDocument?.securityOrigin() ?? null;
+  }
+
   adProvenance(): Protocol.Network.AdProvenance|undefined {
     if (this.#adProvenance !== undefined) {
       return this.#adProvenance;
@@ -1424,6 +1433,8 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
       nodeName: this.nodeName(),
       localName: this.localName(),
       nodeValue: this.nodeValueInternal,
+      documentURL: this.documentURL,
+      baseURL: this.baseURL,
     } as Protocol.DOM.Node) :
                                                      new DOMNodeSnapshot(this.domModel());
     snapshot.id = this.id;
@@ -1445,11 +1456,6 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
     snapshot.#isInShadowTree = this.#isInShadowTree;
     snapshot.childNodeCountInternal = this.childNodeCountInternal;
 
-    if (snapshot instanceof DOMDocument && this instanceof DOMDocument) {
-      snapshot.documentURL = this.documentURL;
-      snapshot.baseURL = this.baseURL;
-    }
-
     if (!this.childrenInternal && this.childNodeCountInternal > 0) {
       await this.getSubtree(1, false);
     }
@@ -1600,15 +1606,45 @@ export class DOMNodeShortcut {
 export class DOMDocument extends DOMNode {
   body: DOMNode|null;
   documentElement: DOMNode|null;
-  documentURL: Platform.DevToolsPath.UrlString;
-  baseURL: Platform.DevToolsPath.UrlString;
+  #documentURL: Platform.DevToolsPath.UrlString;
+  #baseURL: Platform.DevToolsPath.UrlString;
+  #securityOrigin: SecurityOrigin;
+
   constructor(domModel: DOMModel, payload: Protocol.DOM.Node) {
     super(domModel);
     this.body = null;
     this.documentElement = null;
     this.init(this, false, payload);
-    this.documentURL = (payload.documentURL || '') as Platform.DevToolsPath.UrlString;
-    this.baseURL = (payload.baseURL || '') as Platform.DevToolsPath.UrlString;
+    this.#documentURL = (payload.documentURL || '') as Platform.DevToolsPath.UrlString;
+    this.#baseURL = (payload.baseURL || '') as Platform.DevToolsPath.UrlString;
+    this.#securityOrigin = SecurityOrigin.create(this.#documentURL);
+  }
+
+  get documentURL(): Platform.DevToolsPath.UrlString {
+    return this.#documentURL;
+  }
+
+  get baseURL(): Platform.DevToolsPath.UrlString {
+    return this.#baseURL;
+  }
+
+  /**
+   * Returns the security origin of this document.
+   *
+   * The security origin is derived from the document URL and is recomputed
+   * when the document navigates to a new URL via `setDocumentURL`.
+   */
+  override securityOrigin(): SecurityOrigin {
+    return this.#securityOrigin;
+  }
+
+  /**
+   * Updates the document and base URLs, and recomputes the document's security origin.
+   */
+  setDocumentURL(url: Platform.DevToolsPath.UrlString): void {
+    this.#documentURL = url;
+    this.#baseURL = url;
+    this.#securityOrigin = SecurityOrigin.create(url);
   }
 }
 
@@ -1623,8 +1659,8 @@ export class AdoptedStyleSheet {
 
 export class DOMModel extends SDKModel<EventTypes> {
   agent: ProtocolProxyApi.DOMApi;
-  idToDOMNode = new Map<Protocol.DOM.NodeId, DOMNode>();
-  frameIdToOwnerNode = new Map<Protocol.Page.FrameId, DOMNode>();
+  idToDOMNode: Map<Protocol.DOM.NodeId, DOMNode> = new Map<Protocol.DOM.NodeId, DOMNode>();
+  frameIdToOwnerNode: Map<Protocol.Page.FrameId, DOMNode> = new Map<Protocol.Page.FrameId, DOMNode>();
   #document: DOMDocument|null = null;
   readonly #attributeLoadNodeIds = new Set<Protocol.DOM.NodeId>();
   readonly runtimeModelInternal: RuntimeModel;
@@ -1694,8 +1730,7 @@ export class DOMModel extends SDKModel<EventTypes> {
     if (node) {
       const contentDocument = node.contentDocument();
       if (contentDocument && contentDocument.documentURL !== frame.url) {
-        contentDocument.documentURL = frame.url;
-        contentDocument.baseURL = frame.url;
+        contentDocument.setDocumentURL(frame.url);
         this.dispatchEventToListeners(Events.DocumentURLChanged, contentDocument);
       }
     }

package/front_end/core/sdk/DebuggerModel.ts

@@ -134,7 +134,7 @@ export const enum StepMode {
   STEP_OVER = 'StepOver',
 }
 
-export const WASM_SYMBOLS_PRIORITY = [
+export const WASM_SYMBOLS_PRIORITY: Protocol.Debugger.DebugSymbolsType[] = [
   Protocol.Debugger.DebugSymbolsType.ExternalDWARF,
   Protocol.Debugger.DebugSymbolsType.EmbeddedDWARF,
   Protocol.Debugger.DebugSymbolsType.SourceMap,

package/front_end/core/sdk/EmulationModel.ts

@@ -4,6 +4,7 @@
 
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
+import type * as Common from '../common/common.js';
 
 import {CSSModel} from './CSSModel.js';
 import type {MultitargetNetworkManager} from './NetworkManager.js';
@@ -12,6 +13,7 @@ import {SDKModel} from './SDKModel.js';
 import {
   avifFormatDisabledSettingDescriptor,
   cpuPressureSettingDescriptor,
+  dataSaverSettingDescriptor,
   emulateAutoDarkModeSettingDescriptor,
   emulatedCSSMediaFeatureColorGamutSettingDescriptor,
   emulatedCSSMediaFeatureForcedColorsSettingDescriptor,
@@ -56,6 +58,8 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
   };
   #screenOrientationLocked: boolean;
   #lockedOrientation: Protocol.Emulation.ScreenOrientation|null;
+  readonly #dataSaverSetting: Common.Settings.Setting<DataSaverOverride>;
+  readonly #dataSaverChangeListener: () => void;
 
   constructor(target: Target) {
     super(target);
@@ -239,6 +243,15 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       updateDisabledImageFormats();
     }
 
+    this.#dataSaverSetting = settings.resolve(dataSaverSettingDescriptor);
+    this.#dataSaverChangeListener = () => {
+      void this.setDataSaverOverride(this.#dataSaverSetting.get());
+    };
+    this.#dataSaverSetting.addChangeListener(this.#dataSaverChangeListener, this);
+    if (this.#dataSaverSetting.get() !== DataSaverOverride.UNSET) {
+      void this.setDataSaverOverride(this.#dataSaverSetting.get());
+    }
+
     this.#cpuPressureEnabled = false;
     this.#touchEmulationAllowed = true;
     this.#touchEnabled = false;
@@ -251,6 +264,11 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
     target.registerEmulationDispatcher(this);
   }
 
+  override dispose(): void {
+    super.dispose();
+    this.#dataSaverSetting.removeChangeListener(this.#dataSaverChangeListener, this);
+  }
+
   setTouchEmulationAllowed(touchEmulationAllowed: boolean): void {
     this.#touchEmulationAllowed = touchEmulationAllowed;
   }
@@ -426,6 +444,11 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
     await this.#emulationAgent.invoke_setHardwareConcurrencyOverride({hardwareConcurrency});
   }
 
+  async setCPUPerformanceOverride(performanceTier?: Protocol.Emulation.SetCPUPerformanceOverrideRequestPerformanceTier):
+      Promise<void> {
+    await this.#emulationAgent.invoke_setCPUPerformanceOverride({performanceTier});
+  }
+
   async emulateTouch(enabled: boolean, mobile: boolean): Promise<void> {
     this.#touchEnabled = enabled && this.#touchEmulationAllowed;
     this.#touchMobile = mobile && this.#touchEmulationAllowed;

package/front_end/core/sdk/LayerTreeBase.ts

@@ -86,7 +86,7 @@ export class StickyPositionConstraint {
 export class LayerTreeBase {
   readonly #target: Target|null;
   #domModel: DOMModel|null;
-  layersById = new Map<string|number, Layer>();
+  layersById: Map<string|number, Layer> = new Map<string|number, Layer>();
   #root: Layer|null = null;
   #contentRoot: Layer|null = null;
   readonly #backendNodeIdToNode = new Map<Protocol.DOM.BackendNodeId, DOMNode|null>();

package/front_end/core/sdk/NetworkManager.ts

@@ -2202,7 +2202,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
   #userAgentMetadataOverride: Protocol.Emulation.UserAgentMetadata|null = null;
   readonly #networkAgents = new Set<ProtocolProxyApi.NetworkApi>();
   readonly #fetchAgents = new Set<ProtocolProxyApi.FetchApi>();
-  readonly inflightMainResourceRequests = new Map<string, NetworkRequest>();
+  readonly inflightMainResourceRequests: Map<string, NetworkRequest> = new Map<string, NetworkRequest>();
   #networkConditions: Conditions = NoThrottlingConditions;
   #updatingInterceptionPatternsPromise: Promise<void>|null = null;
   readonly #requestConditions: RequestConditions;

package/front_end/core/sdk/README.md

@@ -0,0 +1,40 @@
+# Core SDK
+
+The **Core SDK** (`front_end/core/sdk/`) is DevTools' foundational data access layer wrapping the [Chrome DevTools Protocol (CDP)](https://chromedevtools.github.io/devtools-protocol/). It creates typed data access objects and models for CDP structures, abstracting away low-level JSON-RPC commands and events into developer-friendly APIs.
+
+---
+
+## Architectural Principles
+
+### 1. Single CDP Domain Responsibility
+Each SDK model and data object encapsulates data and operations from a **single CDP domain** (e.g., `DOM`, `CSS`, `Network`, `Debugger`, `Audits`).
+
+### 2. Cross-Domain Separation (What to Avoid)
+Data from multiple CDP domains must be joined **outside** of `core/sdk`, typically in `front_end/models/` (such as `models/bindings/`, `models/issues_manager/`, or `models/trace/`).
+
+#### ❌ Anti-pattern: Cross-domain getters on SDK objects
+Do **not** add methods or getters to an SDK data object that fetch or resolve data from another CDP domain.
+
+```ts
+// ❌ BAD: DOMNode (DOM domain) must not reference Network or Audits domains directly.
+class DOMNode {
+  // Violates single-domain boundary:
+  getNetworkRequest(): SDK.NetworkRequest.NetworkRequest|null {
+    // ...
+  }
+
+  // Violates single-domain boundary:
+  getIssues(): IssuesModel.Issue[] {
+    // ...
+  }
+}
+```
+
+#### ✅ Best Practice: Aggregate in `models/`
+Keep `DOMNode` strictly focused on the DOM domain, and correlate cross-domain data in a higher-level model or service:
+
+```ts
+// ✅ GOOD: A higher-level model in models/ joins DOM and Audits/Network data.
+// In front_end/models/issues_manager/ or similar:
+const issues = issuesManager.issuesForNode(domNode);
+```