chrome-devtools-frontend 1.0.1543472 → 1.0.1545096

package/AUTHORS

@@ -18,6 +18,7 @@ Alex Ho <wjhe1016@gmail.com>
 Alexander Stammbach <alexander@stammbach.io>
 Alexey Rodionov <fluorescent.hallucinogen@gmail.com>
 Ameen Basha <ameenbasha111@gmail.com>
+Ankit Kumar Sahu <sahuankit.murhu@gmail.com>
 Ankit Mishra <ankit.mishra131990@gmail.com>
 Anna Agoha <annaagoha@gmail.com>
 Anthony Xie <anthonyxie64@gmail.com>

package/config/typescript/tsconfig.eslint.json

@@ -17,6 +17,7 @@
   },
   "include": [
     "../../front_end/**/*.ts",
+    "../../mcp/**/*.ts",
     "../../inspector_overlay/**/*.ts",
     "../../scripts/**/*.ts",
     "../../test/**/*.ts",

package/front_end/core/common/ParsedURL.ts

@@ -38,7 +38,7 @@ export function normalizePath(path: string): string {
   return normalizedPath;
 }
 
-export function schemeIs(url: Platform.DevToolsPath.UrlString, scheme: string): boolean {
+export function schemeIs(url: Platform.DevToolsPath.UrlString|URL, scheme: string): boolean {
   try {
     return (new URL(url)).protocol === scheme;
   } catch {

package/front_end/core/common/common.ts

@@ -15,7 +15,6 @@ import * as EventTarget from './EventTarget.js';
 import * as Gzip from './Gzip.js';
 import * as JavaScriptMetaData from './JavaScriptMetaData.js';
 import * as Lazy from './Lazy.js';
-import * as Linkifier from './Linkifier.js';
 import * as MapWithDefault from './MapWithDefault.js';
 import * as Mutex from './Mutex.js';
 import * as ObjectWrapper from './Object.js';
@@ -56,7 +55,6 @@ export {
   Gzip,
   JavaScriptMetaData,
   Lazy,
-  Linkifier,
   MapWithDefault,
   Mutex,
   ObjectWrapper,

package/front_end/core/host/AidaClient.ts

@@ -707,13 +707,16 @@ export class AidaClient {
     return {generatedSamples, metadata};
   }
 
-  async generateCode(request: GenerateCodeRequest): Promise<GenerateCodeResponse|null> {
-    const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateCodeResponse>({
-      service: SERVICE_NAME,
-      path: '/v1/aida:generateCode',
-      method: 'POST',
-      body: JSON.stringify(request),
-    });
+  async generateCode(request: GenerateCodeRequest, options?: {signal?: AbortSignal}):
+      Promise<GenerateCodeResponse|null> {
+    const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateCodeResponse>(
+        {
+          service: SERVICE_NAME,
+          path: '/v1/aida:generateCode',
+          method: 'POST',
+          body: JSON.stringify(request),
+        },
+        options);
 
     return response;
   }

package/front_end/core/host/DispatchHttpRequestClient.ts

@@ -8,6 +8,7 @@ import type {DispatchHttpRequestRequest, DispatchHttpRequestResult} from './Insp
 export enum ErrorType {
   HTTP_RESPONSE_UNAVAILABLE = 'HTTP_RESPONSE_UNAVAILABLE',
   NOT_FOUND = 'NOT_FOUND',
+  ABORT = 'ABORT',
 }
 
 export class DispatchHttpRequestError extends Error {
@@ -16,9 +17,23 @@ export class DispatchHttpRequestError extends Error {
   }
 }
 
-export async function makeHttpRequest<R>(request: DispatchHttpRequestRequest): Promise<R> {
-  const response = await new Promise<DispatchHttpRequestResult>(resolve => {
-    InspectorFrontendHostInstance.dispatchHttpRequest(request, resolve);
+export async function makeHttpRequest<R>(
+    request: DispatchHttpRequestRequest, options?: {signal?: AbortSignal}): Promise<R> {
+  const signal = options?.signal;
+  if (signal?.aborted) {
+    throw new DispatchHttpRequestError(ErrorType.ABORT);
+  }
+
+  const response = await new Promise<DispatchHttpRequestResult>((resolve, reject) => {
+    const onAbort = (): void => {
+      reject(new DispatchHttpRequestError(ErrorType.ABORT));
+    };
+
+    signal?.addEventListener('abort', onAbort, {once: true});
+    InspectorFrontendHostInstance.dispatchHttpRequest(request, result => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve(result);
+    });
   });
 
   debugLog({request, response});

package/front_end/core/protocol_client/CDPConnection.ts

@@ -5,10 +5,10 @@
 import type {ProtocolMapping} from '../../generated/protocol-mapping.js';
 
 export type Command = keyof ProtocolMapping.Commands;
-export type CommandParams<T extends keyof ProtocolMapping.Commands> = ProtocolMapping.Commands[T]['paramsType'][0];
-export type CommandResult<T extends keyof ProtocolMapping.Commands> = ProtocolMapping.Commands[T]['returnType'];
+export type CommandParams<T extends Command> = ProtocolMapping.Commands[T]['paramsType'][0];
+export type CommandResult<T extends Command> = Omit<ProtocolMapping.Commands[T]['returnType'], 'getError'>;
 export type Event = keyof ProtocolMapping.Events;
-export type EventParams<T extends keyof ProtocolMapping.Events> = ProtocolMapping.Events[T];
+export type EventParams<T extends keyof ProtocolMapping.Events> = ProtocolMapping.Events[T][0];
 
 export interface CDPBaseMessage {
   sessionId?: string;

package/front_end/core/protocol_client/DevToolsCDPConnection.ts

@@ -17,7 +17,8 @@ import type {ConnectionTransport} from './ConnectionTransport.js';
 import {InspectorBackend, type MessageError, type QualifiedName, test} from './InspectorBackend.js';
 
 interface CallbackWithDebugInfo {
-  resolve: (response: Awaited<ReturnType<CDPConnection['send']>>) => void;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolve: (response: {result: CommandResult<any>}|{error: CDPError}) => void;
   method: string;
   sessionId: string|undefined;
 }

package/front_end/core/root/Runtime.ts

@@ -70,21 +70,22 @@ export class Runtime {
     runtimeInstance = undefined;
   }
 
-  static queryParamsObject: URLSearchParams;
+  static #queryParamsObject: URLSearchParams;
 
-  static getSearchParams(): URLSearchParams {
-    if (!Runtime.queryParamsObject) {
-      Runtime.queryParamsObject = new URLSearchParams(location.search);
+  static #getSearchParams(): URLSearchParams|null {
+    // TODO(crbug.com/451502260): Find a more explicit way to support running in Node.js
+    if (!Runtime.#queryParamsObject && 'location' in globalThis) {
+      Runtime.#queryParamsObject = new URLSearchParams(location.search);
     }
-    return Runtime.queryParamsObject;
+    return Runtime.#queryParamsObject;
   }
 
   static queryParam(name: string): string|null {
-    return Runtime.getSearchParams().get(name);
+    return Runtime.#getSearchParams()?.get(name) ?? null;
   }
 
   static setQueryParamForTesting(name: string, value: string): void {
-    Runtime.getSearchParams().set(name, value);
+    Runtime.#getSearchParams()?.set(name, value);
   }
 
   static isNode(): boolean {

package/front_end/core/sdk/CPUThrottlingManager.ts

@@ -184,10 +184,6 @@ export interface EventTypes {
   [Events.HARDWARE_CONCURRENCY_CHANGED]: number;
 }
 
-export function throttlingManager(): CPUThrottlingManager {
-  return CPUThrottlingManager.instance();
-}
-
 export enum CPUThrottlingRates {
   NO_THROTTLING = 1,
   MID_TIER_MOBILE = 4,

package/front_end/core/sdk/CSSMatchedStyles.ts

@@ -41,7 +41,7 @@ import {
   VariableMatcher
 } from './CSSPropertyParserMatchers.js';
 import {
-  CSSFontPaletteValuesRule,
+  CSSAtRule,
   CSSFunctionRule,
   CSSKeyframeRule,
   CSSKeyframesRule,
@@ -210,7 +210,7 @@ export interface CSSMatchedStylesPayload {
   positionTryRules: Protocol.CSS.CSSPositionTryRule[];
   propertyRules: Protocol.CSS.CSSPropertyRule[];
   cssPropertyRegistrations: Protocol.CSS.CSSPropertyRegistration[];
-  fontPaletteValuesRule: Protocol.CSS.CSSFontPaletteValuesRule|undefined;
+  atRules: Protocol.CSS.CSSAtRule[];
   animationStylesPayload: Protocol.CSS.CSSAnimationStyle[];
   transitionsStylePayload: Protocol.CSS.CSSStyle|null;
   inheritedAnimatedPayload: Protocol.CSS.InheritedAnimatedStyleEntry[];
@@ -305,8 +305,8 @@ export class CSSMatchedStyles {
   #pseudoDOMCascades?: Map<Protocol.DOM.PseudoType, DOMInheritanceCascade>;
   #customHighlightPseudoDOMCascades?: Map<string, DOMInheritanceCascade>;
   #functionRules: CSSFunctionRule[];
+  #atRules: CSSAtRule[];
   #functionRuleMap = new Map<string, CSSFunctionRule>();
-  readonly #fontPaletteValuesRule: CSSFontPaletteValuesRule|undefined;
   #environmentVariables: Record<string, string> = {};
 
   static async create(payload: CSSMatchedStylesPayload): Promise<CSSMatchedStyles> {
@@ -323,9 +323,9 @@ export class CSSMatchedStyles {
     positionTryRules,
     propertyRules,
     cssPropertyRegistrations,
-    fontPaletteValuesRule,
     activePositionFallbackIndex,
     functionRules,
+    atRules,
   }: CSSMatchedStylesPayload) {
     this.#cssModel = cssModel;
     this.#node = node;
@@ -338,11 +338,9 @@ export class CSSMatchedStyles {
     }
     this.#positionTryRules = positionTryRules.map(rule => new CSSPositionTryRule(cssModel, rule));
     this.#parentLayoutNodeId = parentLayoutNodeId;
-    this.#fontPaletteValuesRule =
-        fontPaletteValuesRule ? new CSSFontPaletteValuesRule(cssModel, fontPaletteValuesRule) : undefined;
-
     this.#activePositionFallbackIndex = activePositionFallbackIndex;
     this.#functionRules = functionRules.map(rule => new CSSFunctionRule(cssModel, rule));
+    this.#atRules = atRules.map(rule => new CSSAtRule(cssModel, rule));
   }
 
   private async init({
@@ -799,8 +797,8 @@ export class CSSMatchedStyles {
     return this.#functionRules;
   }
 
-  fontPaletteValuesRule(): CSSFontPaletteValuesRule|undefined {
-    return this.#fontPaletteValuesRule;
+  atRules(): CSSAtRule[] {
+    return this.#atRules;
   }
 
   keyframes(): CSSKeyframesRule[] {

package/front_end/core/sdk/CSSMetadata.ts

@@ -455,11 +455,8 @@ const cornerShapeValuePresetMap = new Map([
 ]);
 
 const valuePresets = new Map([
-  ['filter', filterValuePresetMap],
-  ['backdrop-filter', filterValuePresetMap],
-  ['background', imageValuePresetMap],
-  ['background-image', imageValuePresetMap],
-  ['-webkit-mask-image', imageValuePresetMap],
+  ['filter', filterValuePresetMap], ['backdrop-filter', filterValuePresetMap], ['background', imageValuePresetMap],
+  ['background-image', imageValuePresetMap], ['-webkit-mask-image', imageValuePresetMap],
   [
     'transform',
     new Map([
@@ -486,6 +483,17 @@ const valuePresets = new Map([
     ]),
   ],
   ['corner-shape', cornerShapeValuePresetMap],
+  [
+    'font-variant-alternates',
+    new Map([
+      ['stylistic', 'stylistic(||)'],
+      ['styleset', 'styleset(||)'],
+      ['character-variant', 'character-variant(||)'],
+      ['swash', 'swash(||)'],
+      ['ornaments', 'ornaments(||)'],
+      ['annotation', 'annotation(||)'],
+    ]),
+  ]
 ]);
 
 const distanceProperties = new Set<string>([
@@ -766,6 +774,10 @@ const extraPropertyValues = new Map<string, Set<string>>([
       'ruby',
     ]),
   ],
+  [
+    'font-variant-alternates',
+    new Set(['historical-forms', 'stylistic', 'styleset', 'character-variant', 'swash', 'ornaments', 'annotation'])
+  ],
   ['vertical-align', new Set(['top', 'bottom', '-webkit-baseline-middle'])],
   ['page-break-after', new Set(['left', 'right', 'always', 'avoid'])],
   ['text-emphasis-style', textEmphasisStyle],

package/front_end/core/sdk/CSSModel.ts

@@ -358,7 +358,7 @@ export class CSSModel extends SDKModel<EventTypes> {
       propertyRules: matchedStylesResponse.cssPropertyRules ?? [],
       functionRules: matchedStylesResponse.cssFunctionRules ?? [],
       cssPropertyRegistrations: matchedStylesResponse.cssPropertyRegistrations ?? [],
-      fontPaletteValuesRule: matchedStylesResponse.cssFontPaletteValuesRule,
+      atRules: matchedStylesResponse.cssAtRules ?? [],
       activePositionFallbackIndex: matchedStylesResponse.activePositionFallbackIndex ?? -1,
       animationStylesPayload: animatedStylesResponse?.animationStyles || [],
       inheritedAnimatedPayload: animatedStylesResponse?.inherited || [],

package/front_end/core/sdk/CSSRule.ts

@@ -268,20 +268,32 @@ export class CSSPropertyRule extends CSSRule {
   }
 }
 
-export class CSSFontPaletteValuesRule extends CSSRule {
-  readonly #paletteName: CSSValue;
-  constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSFontPaletteValuesRule) {
+export class CSSAtRule extends CSSRule {
+  readonly #name: CSSValue|null;
+  readonly #type: string;
+  readonly #subsection: string|null;
+  constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSAtRule) {
     super(cssModel, {
       origin: payload.origin,
       style: payload.style,
       header: styleSheetHeaderForRule(cssModel, payload),
       originTreeScopeNodeId: undefined
     });
-    this.#paletteName = new CSSValue(payload.fontPaletteName);
+    this.#name = payload.name ? new CSSValue(payload.name) : null;
+    this.#type = payload.type;
+    this.#subsection = payload.subsection ?? null;
   }
 
-  name(): CSSValue {
-    return this.#paletteName;
+  name(): CSSValue|null {
+    return this.#name;
+  }
+
+  type(): string {
+    return this.#type;
+  }
+
+  subsection(): string|null {
+    return this.#subsection;
   }
 }
 

package/front_end/core/sdk/ChildTargetManager.ts

@@ -13,7 +13,7 @@ import {SDKModel} from './SDKModel.js';
 import {SecurityOriginManager} from './SecurityOriginManager.js';
 import {StorageKeyManager} from './StorageKeyManager.js';
 import {Capability, type Target, Type} from './Target.js';
-import {Events as TargetManagerEvents, TargetManager} from './TargetManager.js';
+import {Events as TargetManagerEvents, type TargetManager} from './TargetManager.js';
 
 const UIStrings = {
   /**
@@ -126,7 +126,7 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   }
 
   private fireAvailableTargetsChanged(): void {
-    TargetManager.instance().dispatchEventToListeners(
+    this.#targetManager.dispatchEventToListeners(
         TargetManagerEvents.AVAILABLE_TARGETS_CHANGED, [...this.#targetInfos.values()]);
   }
 

package/front_end/core/sdk/NetworkManager.ts

@@ -383,14 +383,6 @@ export class NetworkManager extends SDKModel<EventTypes> {
     return result.status;
   }
 
-  async getIpProtectionProxyStatus(): Promise<Protocol.Network.IpProxyStatus|null> {
-    const result = await this.#networkAgent.invoke_getIPProtectionProxyStatus();
-    if (result.getError()) {
-      return null;
-    }
-    return result.status;
-  }
-
   async enableReportingApi(enable = true): Promise<Promise<Protocol.ProtocolResponseWithError>> {
     return await this.#networkAgent.invoke_enableReportingApi({enable});
   }
@@ -1043,6 +1035,12 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
       appliedNetworkConditionsId,
     };
     this.getExtraInfoBuilder(requestId).addRequestExtraInfo(extraRequestInfo);
+
+    const networkRequest = this.#requestsById.get(requestId);
+    if (appliedNetworkConditionsId && networkRequest) {
+      networkRequest.setAppliedNetworkConditions(appliedNetworkConditionsId);
+      this.updateNetworkRequest(networkRequest);
+    }
   }
 
   responseReceivedEarlyHints({

package/front_end/core/sdk/NetworkRequest.ts

@@ -1629,6 +1629,10 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     );
   }
 
+  setAppliedNetworkConditions(appliedNetworkConditionsId: string): void {
+    this.#appliedNetworkConditionsId = appliedNetworkConditionsId;
+  }
+
   hasExtraRequestInfo(): boolean {
     return this.#hasExtraRequestInfo;
   }

package/front_end/core/sdk/SDKModel.ts

@@ -12,7 +12,9 @@ export interface RegistrationInfo {
   early?: boolean;
 }
 
-const registeredModels = new Map<new (arg1: Target) => SDKModel, RegistrationInfo>();
+export type SDKModelConstructor<T extends SDKModel = SDKModel> = new (target: Target) => T;
+
+const registeredModels = new Map<SDKModelConstructor, RegistrationInfo>();
 
 // TODO(crbug.com/1228674) Remove defaults for generic type parameters once
 //                         all event emitters and sinks have been migrated.
@@ -52,7 +54,7 @@ export class SDKModel<Events = any> extends Common.ObjectWrapper.ObjectWrapper<E
   dispose(): void {
   }
 
-  static register(modelClass: new(arg1: Target) => SDKModel, registrationInfo: RegistrationInfo): void {
+  static register(modelClass: SDKModelConstructor, registrationInfo: RegistrationInfo): void {
     if (registrationInfo.early && !registrationInfo.autostart) {
       throw new Error(`Error registering model ${modelClass.name}: early models must be autostarted.`);
     }

package/front_end/core/sdk/TargetManager.ts

@@ -10,22 +10,20 @@ import {assertNotNullOrUndefined} from '../platform/platform.js';
 import type * as ProtocolClient from '../protocol_client/protocol_client.js';
 import * as Root from '../root/root.js';
 
-import {SDKModel} from './SDKModel.js';
+import {SDKModel, type SDKModelConstructor} from './SDKModel.js';
 import {Target, Type as TargetType} from './Target.js';
 
-type ModelClass<T = SDKModel> = new (arg1: Target) => T;
-
 export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   #targets: Set<Target>;
   readonly #observers: Set<Observer>;
   /* eslint-disable @typescript-eslint/no-explicit-any */
   #modelListeners: Platform.MapUtilities.Multimap<string|symbol|number, {
-    modelClass: ModelClass,
+    modelClass: SDKModelConstructor,
     thisObject: Object|undefined,
     listener: Common.EventTarget.EventListener<any, any>,
     wrappedListener: Common.EventTarget.EventListener<any, any>,
   }>;
-  readonly #modelObservers: Platform.MapUtilities.Multimap<ModelClass, SDKModelObserver<any>>;
+  readonly #modelObservers: Platform.MapUtilities.Multimap<SDKModelConstructor, SDKModelObserver<any>>;
   #scopedObservers: WeakSet<Observer|SDKModelObserver<any>>;
   /* eslint-enable @typescript-eslint/no-explicit-any */
   #isSuspended: boolean;
@@ -99,7 +97,7 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     return this.#isSuspended;
   }
 
-  models<T extends SDKModel>(modelClass: ModelClass<T>, opts?: {scoped: boolean}): T[] {
+  models<T extends SDKModel>(modelClass: SDKModelConstructor<T>, opts?: {scoped: boolean}): T[] {
     const result = [];
     for (const target of this.#targets) {
       if (opts?.scoped && !this.isInScope(target)) {
@@ -119,8 +117,9 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     return mainTarget ? mainTarget.inspectedURL() : '';
   }
 
-  observeModels<T extends SDKModel>(modelClass: ModelClass<T>, observer: SDKModelObserver<T>, opts?: {scoped: boolean}):
-      void {
+  observeModels<T extends SDKModel>(modelClass: SDKModelConstructor<T>, observer: SDKModelObserver<T>, opts?: {
+    scoped: boolean,
+  }): void {
     const models = this.models(modelClass, opts);
     this.#modelObservers.set(modelClass, observer);
     if (opts?.scoped) {
@@ -131,12 +130,12 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     }
   }
 
-  unobserveModels<T extends SDKModel>(modelClass: ModelClass<T>, observer: SDKModelObserver<T>): void {
+  unobserveModels<T extends SDKModel>(modelClass: SDKModelConstructor<T>, observer: SDKModelObserver<T>): void {
     this.#modelObservers.delete(modelClass, observer);
     this.#scopedObservers.delete(observer);
   }
 
-  modelAdded(modelClass: ModelClass, model: SDKModel, inScope: boolean): void {
+  modelAdded(modelClass: SDKModelConstructor, model: SDKModel, inScope: boolean): void {
     for (const observer of this.#modelObservers.get(modelClass).values()) {
       if (!this.#scopedObservers.has(observer) || inScope) {
         observer.modelAdded(model);
@@ -144,7 +143,7 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     }
   }
 
-  private modelRemoved(modelClass: ModelClass, model: SDKModel, inScope: boolean): void {
+  private modelRemoved(modelClass: SDKModelConstructor, model: SDKModel, inScope: boolean): void {
     for (const observer of this.#modelObservers.get(modelClass).values()) {
       if (!this.#scopedObservers.has(observer) || inScope) {
         observer.modelRemoved(model);
@@ -153,8 +152,8 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   }
 
   addModelListener<Events, T extends keyof Events>(
-      modelClass: ModelClass<SDKModel<Events>>, eventType: T, listener: Common.EventTarget.EventListener<Events, T>,
-      thisObject?: Object, opts?: {scoped: boolean}): void {
+      modelClass: SDKModelConstructor<SDKModel<Events>>, eventType: T,
+      listener: Common.EventTarget.EventListener<Events, T>, thisObject?: Object, opts?: {scoped: boolean}): void {
     const wrappedListener = (event: Common.EventTarget.EventTargetEvent<Events[T], Events>): void => {
       if (!opts?.scoped || this.isInScope(event)) {
         listener.call(thisObject, event);
@@ -167,8 +166,8 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   }
 
   removeModelListener<Events, T extends keyof Events>(
-      modelClass: ModelClass<SDKModel<Events>>, eventType: T, listener: Common.EventTarget.EventListener<Events, T>,
-      thisObject?: Object): void {
+      modelClass: SDKModelConstructor<SDKModel<Events>>, eventType: T,
+      listener: Common.EventTarget.EventListener<Events, T>, thisObject?: Object): void {
     if (!this.#modelListeners.has(eventType)) {
       return;
     }

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotLoader.ts

@@ -46,6 +46,8 @@ export class HeapSnapshotLoader {
   }
 
   async buildSnapshot(secondWorker: MessagePort): Promise<JSHeapSnapshot> {
+    await this.parsingComplete;
+
     this.#snapshot = this.#snapshot || {};
 
     this.#progress.updateStatus('Processing snapshot…');

package/front_end/entrypoints/main/MainImpl.ts

@@ -448,23 +448,7 @@ export class MainImpl {
     Workspace.FileManager.FileManager.instance({forceNew: true});
 
     Bindings.NetworkProject.NetworkProjectManager.instance();
-    const resourceMapping = new Bindings.ResourceMapping.ResourceMapping(
-        targetManager,
-        Workspace.Workspace.WorkspaceImpl.instance(),
-    );
     new Bindings.PresentationConsoleMessageHelper.PresentationConsoleMessageManager();
-    Bindings.CSSWorkspaceBinding.CSSWorkspaceBinding.instance({
-      forceNew: true,
-      resourceMapping,
-      targetManager,
-    });
-    Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance({
-      forceNew: true,
-      resourceMapping,
-      targetManager,
-      ignoreListManager: Workspace.IgnoreListManager.IgnoreListManager.instance(),
-      workspace: Workspace.Workspace.WorkspaceImpl.instance(),
-    });
     targetManager.setScopeTarget(targetManager.primaryPageTarget());
     UI.Context.Context.instance().addFlavorChangeListener(SDK.Target.Target, ({data}) => {
       const outermostTarget = data?.outermostTarget();

package/front_end/foundation/Universe.ts

@@ -5,6 +5,7 @@
 import * as Common from '../core/common/common.js';
 import * as Root from '../core/root/root.js';
 import * as SDK from '../core/sdk/sdk.js';
+import * as Bindings from '../models/bindings/bindings.js';
 import * as Workspace from '../models/workspace/workspace.js';
 
 export interface CreationOptions {
@@ -25,9 +26,19 @@ export class Universe {
 
     const targetManager = new SDK.TargetManager.TargetManager();
     this.context.set(SDK.TargetManager.TargetManager, targetManager);
-    this.context.set(Workspace.Workspace.WorkspaceImpl, new Workspace.Workspace.WorkspaceImpl());
+
+    const workspace = new Workspace.Workspace.WorkspaceImpl();
+    this.context.set(Workspace.Workspace.WorkspaceImpl, workspace);
 
     const ignoreListManager = new Workspace.IgnoreListManager.IgnoreListManager(settings, targetManager);
     this.context.set(Workspace.IgnoreListManager.IgnoreListManager, ignoreListManager);
+
+    const resourceMapping = new Bindings.ResourceMapping.ResourceMapping(targetManager, workspace);
+    const cssWorkspaceBinding = new Bindings.CSSWorkspaceBinding.CSSWorkspaceBinding(resourceMapping, targetManager);
+    this.context.set(Bindings.CSSWorkspaceBinding.CSSWorkspaceBinding, cssWorkspaceBinding);
+
+    const debuggerWorkspaceBinding = new Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding(
+        resourceMapping, targetManager, ignoreListManager, workspace);
+    this.context.set(Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding, debuggerWorkspaceBinding);
   }
 }

package/front_end/generated/Deprecation.ts

@@ -54,6 +54,10 @@ export const UIStrings = {
    * @description Warning displayed to developers when a data: URL is assigned to SVGUseElement to let them know that the support is deprecated.
    */
   DataUrlInSvgUse: "Support for data: URLs in SVGUseElement is deprecated and it will be removed in the future.",
+  /**
+   * @description A deprecation warning shown in the DevTools Issues tab. It's shown when one of the Protected Audience APIs like `navigator.joinAdInterestGroup`, `navigator.getInterestGroupAdAuctionData` or `navigator.runAdAuction` are called.
+   */
+  Fledge: "The Protected Audience API is deprecated and will be removed in a future release.",
   /**
    * @description Warning displayed to developers when the Geolocation API is used from an insecure origin (one that isn't localhost or doesn't use HTTPS) to notify them that this use is no longer supported.
    */