chrome-devtools-frontend 1.0.1599001 → 1.0.1601661

package/.agents/skills/verification/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: devtools-verification
-description: Guidelines for verifying changes in DevTools. Covers npm test, autoninja build, linting, and using fast builds.
+description: MANDATORY: Activate this skill ANY TIME you need to build the project, run tests, or verify code health in DevTools. You MUST use this skill before executing commands like npm test, npm run build, autoninja, or linters, as it contains critical, repository-specific instructions on how to correctly format these commands, filter test runs, and interpret failures.
 ---
 
 # Instructions on how to verify your changes

package/front_end/core/common/Settings.ts

@@ -688,7 +688,7 @@ export class VersionController {
   static readonly SYNCED_VERSION_SETTING_NAME = 'syncedInspectorVersion';
   static readonly LOCAL_VERSION_SETTING_NAME = 'localInspectorVersion';
 
-  static readonly CURRENT_VERSION = 41;
+  static readonly CURRENT_VERSION = 42;
 
   readonly #settings: Settings;
   readonly #globalVersionSetting: Setting<number>;
@@ -1480,6 +1480,29 @@ export class VersionController {
     }
   }
 
+  /**
+   * The recording in recorder panel may have unreasonably long titles
+   * or a lot of steps which can cause renderer crashes.
+   * Similar to https://crbug.com/40918380
+   */
+  updateVersionFrom41To42(): void {
+    const recordingsSetting = this.#settings.createSetting<Array<{flow: {steps: unknown[], title: string}}>>(
+        'recorder-recordings-ng',
+        [],
+    );
+    const recordings = recordingsSetting.get();
+    if (recordings.length === 0) {
+      return;
+    }
+
+    for (const recording of recordings) {
+      recording.flow.title = Platform.StringUtilities.trimEndWithMaxLength(recording.flow.title, 300);
+      recording.flow.steps = recording.flow.steps.slice(0, 4096);
+    }
+
+    recordingsSetting.set(recordings);
+  }
+
   /*
    * Any new migration should be added before this comment.
    *

package/front_end/core/dom_extension/DOMExtension.ts

@@ -36,6 +36,7 @@
 
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-nocheck This file is not checked by TypeScript Compiler as it has a lot of legacy code.
+/* eslint-disable @devtools/no-imperative-dom-api */
 
 import * as Platform from '../platform/platform.js';
 

package/front_end/core/host/AidaClient.ts

@@ -67,10 +67,10 @@ interface BaseFunctionParam {
 }
 
 export interface FunctionPrimitiveParams extends BaseFunctionParam {
-  type: ParametersTypes.BOOLEAN|ParametersTypes.INTEGER|ParametersTypes.STRING|ParametersTypes.BOOLEAN;
+  type: ParametersTypes.BOOLEAN|ParametersTypes.INTEGER|ParametersTypes.STRING;
 }
 
-interface FunctionArrayParam extends BaseFunctionParam {
+export interface FunctionArrayParam extends BaseFunctionParam {
   type: ParametersTypes.ARRAY;
   items: FunctionPrimitiveParams;
 }
@@ -301,6 +301,9 @@ export enum UseCase {
 
   // Code generation use case is expected to generate code from scratch
   CODE_GENERATION = 1,
+
+  // Code transformation or code editing use case.
+  CODE_TRANSFORMATION = 2,
 }
 
 /* eslint-disable @typescript-eslint/naming-convention */

package/front_end/core/host/AidaGcaTranslation.ts

@@ -0,0 +1,377 @@
+// 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 * as AIDA from './AidaClient.js';
+import * as GCA from './GcaTypes.js';
+
+type AidaRequest = AIDA.DoConversationRequest|AIDA.CompletionRequest|AIDA.GenerateCodeRequest;
+
+function createBaseGcaRequest(request: AidaRequest, contents: GCA.Content[]): GCA.GenerateContentRequest {
+  const gcaRequest: GCA.GenerateContentRequest = {contents};
+  mapCommonAidaRequestFields(request, gcaRequest);
+  buildLabels(request, gcaRequest);
+
+  if ('preamble' in request && request.preamble) {
+    gcaRequest.system_instruction = {
+      role: 'user',
+      parts: [{text: request.preamble}],
+    };
+  }
+
+  return gcaRequest;
+}
+
+export function aidaDoConversationRequestToGcaRequest(request: AIDA.DoConversationRequest): GCA.GenerateContentRequest {
+  const contents: GCA.Content[] = [];
+
+  if (request.historical_contexts) {
+    contents.push(...request.historical_contexts.map(convertAidaContentToGcaContent));
+  }
+  contents.push(convertAidaContentToGcaContent(request.current_message));
+
+  const gcaRequest = createBaseGcaRequest(request, contents);
+
+  if (request.function_declarations) {
+    gcaRequest.tools = [{
+      function_declarations: request.function_declarations.map(fd => ({
+                                                                 name: fd.name,
+                                                                 description: fd.description,
+                                                                 parameters: convertAidaParamToGcaSchema(fd.parameters),
+                                                               })),
+    }];
+  }
+
+  return gcaRequest;
+}
+
+function mapCommonAidaRequestFields(aidaRequest: AidaRequest, gcaRequest: GCA.GenerateContentRequest): void {
+  if (aidaRequest.options?.model_id) {
+    gcaRequest.model = aidaRequest.options.model_id;
+  }
+  if (aidaRequest.metadata.string_session_id) {
+    gcaRequest.session_id = aidaRequest.metadata.string_session_id;
+  }
+  if (aidaRequest.options?.temperature !== undefined) {
+    gcaRequest.generation_config = {
+      ...gcaRequest.generation_config,
+      temperature: aidaRequest.options.temperature,
+    };
+  }
+}
+
+export function gcaResponseToAidaDoConversationResponse(response: GCA.GenerateContentResponse):
+    AIDA.DoConversationResponse {
+  const candidate = response.candidates[0];
+  const functionCalls: AIDA.AidaFunctionCallResponse[] = [];
+
+  if (candidate?.content?.parts) {
+    for (const part of candidate.content.parts) {
+      if (part.function_call) {
+        functionCalls.push({
+          name: part.function_call.name,
+          args: part.function_call.args || {},
+        });
+      }
+    }
+  }
+
+  return {
+    explanation: extractTextFromGcaParts(candidate?.content?.parts),
+    metadata: {
+      rpcGlobalId: response.response_id,
+    },
+    functionCalls: functionCalls.length > 0 ?
+        (functionCalls as [AIDA.AidaFunctionCallResponse, ...AIDA.AidaFunctionCallResponse[]]) :
+        undefined,
+    completed: true,
+  };
+}
+
+function extractTextFromGcaParts(parts: GCA.Part[]|undefined): string {
+  if (!parts) {
+    return '';
+  }
+  return parts.map(p => p.text || '').join('');
+}
+
+export function aidaEventToGcaTelemetryRequest(clientEvent: AIDA.AidaRegisterClientEvent): GCA.SendTelemetryRequest {
+  const feedbackMetrics: GCA.FeedbackMetric[] = [];
+  const responseId = String(clientEvent.corresponding_aida_rpc_global_id);
+  const eventTime = new Date().toISOString();
+
+  if (clientEvent.do_conversation_client_event) {
+    const feedback = clientEvent.do_conversation_client_event.user_feedback;
+    if (feedback.sentiment) {
+      let interaction: GCA.InteractionType = GCA.InteractionType.INTERACTION_TYPE_UNSPECIFIED;
+      if (feedback.sentiment === AIDA.Rating.POSITIVE) {
+        interaction = GCA.InteractionType.THUMBS_UP;
+      } else if (feedback.sentiment === AIDA.Rating.NEGATIVE) {
+        interaction = GCA.InteractionType.THUMBS_DOWN;
+      }
+      feedbackMetrics.push({
+        event_time: eventTime,
+        response_id: responseId,
+        suggestion_interaction: {interaction},
+      });
+    }
+  }
+
+  feedbackMetrics.push(
+      ...convertCodeTelemetry(clientEvent.complete_code_client_event, GCA.Method.COMPLETE_CODE, responseId, eventTime));
+  feedbackMetrics.push(
+      ...convertCodeTelemetry(clientEvent.generate_code_client_event, GCA.Method.GENERATE_CODE, responseId, eventTime));
+
+  return {feedback_metrics: feedbackMetrics};
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+function convertCodeTelemetry(
+    event: {user_acceptance?: AIDA.UserAcceptance, user_impression?: AIDA.UserImpression}|undefined, method: GCA.Method,
+    responseId: string, eventTime: string): GCA.FeedbackMetric[] {
+  if (!event) {
+    return [];
+  }
+  if ('user_impression' in event && event.user_impression) {
+    const impression = event.user_impression;
+    return [{
+      event_time: eventTime,
+      response_id: responseId,
+      suggestion_offered: {
+        method,
+        status: GCA.SuggestionStatus.NO_ERROR,
+        response_latency: `${impression.latency.duration.seconds + impression.latency.duration.nanos / 1e9}s`,
+      },
+    }];
+  }
+  if ('user_acceptance' in event && event.user_acceptance) {
+    const acceptance = event.user_acceptance;
+    return [{
+      event_time: eventTime,
+      response_id: responseId,
+      suggestion_interaction: {
+        interaction: GCA.InteractionType.ACCEPT,
+        candidate_index: acceptance.sample.sample_id,
+      },
+    }];
+  }
+  return [];
+}
+/* eslint-enable @typescript-eslint/naming-convention */
+
+export function aidaCompletionRequestToGcaRequest(request: AIDA.CompletionRequest): GCA.GenerateContentRequest {
+  const contents: GCA.Content[] = [
+    {
+      role: 'user',
+      parts: [{text: request.prefix + (request.suffix || '')}],
+    },
+  ];
+
+  const gcaRequest = createBaseGcaRequest(request, contents);
+
+  if (request.options?.stop_sequences) {
+    gcaRequest.generation_config = {
+      ...gcaRequest.generation_config,
+      stop_sequences: request.options.stop_sequences,
+    };
+  }
+
+  if (request.additional_files) {
+    gcaRequest.aicode = {
+      experience: 'completion',
+      files: request.additional_files.map(f => ({
+                                            file_uri: f.path,
+                                            inclusion_reason: [AidaReasonToGcaInclusionReason[f.included_reason]],
+                                          })),
+    };
+  }
+
+  return gcaRequest;
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+function buildLabels(request: AidaRequest, gcaRequest: GCA.GenerateContentRequest): void {
+  const labels: Record<string, string> = {};
+  if (request.client) {
+    labels['client'] = request.client;
+  }
+  if ('functionality_type' in request && request.functionality_type !== undefined) {
+    labels['functionality_type'] = AIDA.FunctionalityType[request.functionality_type];
+  }
+  if ('client_feature' in request && request.client_feature !== undefined) {
+    labels['client_feature'] = AIDA.ClientFeature[request.client_feature];
+  }
+  if ('last_user_action' in request && request.last_user_action !== undefined) {
+    labels['last_user_action'] = AIDA.EditType[request.last_user_action];
+  }
+  if ('use_case' in request && request.use_case !== undefined) {
+    labels['use_case'] = AIDA.UseCase[request.use_case];
+  }
+  const options = request.options as {
+    inference_language?: string,
+    expect_code_output?: boolean,
+  } | undefined;
+  if (options?.inference_language) {
+    labels['inference_language'] = options.inference_language;
+  }
+  if (options?.expect_code_output !== undefined) {
+    labels['expect_code_output'] = String(options.expect_code_output);
+  }
+
+  if (Object.keys(labels).length > 0) {
+    gcaRequest.labels = labels;
+  }
+}
+/* eslint-enable @typescript-eslint/naming-convention */
+
+const AidaReasonToGcaInclusionReason: Record<AIDA.Reason, GCA.InclusionReason> = {
+  [AIDA.Reason.UNKNOWN]: GCA.InclusionReason.INCLUSION_REASON_UNSPECIFIED,
+  [AIDA.Reason.CURRENTLY_OPEN]: GCA.InclusionReason.OPEN,
+  // Intentional mapping due to type mismatch
+  // TODO(liviurau): find a way to validate this mapping
+  [AIDA.Reason.RECENTLY_OPENED]: GCA.InclusionReason.RECENTLY_CLOSED,
+  [AIDA.Reason.RECENTLY_EDITED]: GCA.InclusionReason.RECENTLY_EDITED,
+  [AIDA.Reason.COLOCATED]: GCA.InclusionReason.COLOCATED,
+  [AIDA.Reason.RELATED_FILE]: GCA.InclusionReason.RELATED,
+};
+
+export function gcaResponseToAidaCompletionResponse(response: GCA.GenerateContentResponse): AIDA.CompletionResponse {
+  const {samples, metadata} = gcaResponseToAidaSamplesAndMetadata(response);
+  return {
+    generatedSamples: samples,
+    metadata,
+  };
+}
+
+function gcaResponseToAidaSamplesAndMetadata(response: GCA.GenerateContentResponse): {
+  samples: AIDA.GenerationSample[],
+  metadata: AIDA.ResponseMetadata,
+} {
+  return {
+    samples: response.candidates.map(gcaCandidateToAidaGenerationSample),
+    metadata: {
+      rpcGlobalId: response.response_id,
+    },
+  };
+}
+
+export function aidaGenerateCodeRequestToGcaRequest(request: AIDA.GenerateCodeRequest): GCA.GenerateContentRequest {
+  const gcaRequest = createBaseGcaRequest(request, [convertAidaContentToGcaContent(request.current_message)]);
+
+  if (request.context_files) {
+    gcaRequest.aicode = {
+      experience: 'generate_code',
+      files: request.context_files.map(f => ({
+                                         file_uri: f.path,
+                                         programming_language: f.programming_language,
+                                       })),
+    };
+  }
+
+  return gcaRequest;
+}
+
+export function gcaResponseToAidaGenerateCodeResponse(response: GCA.GenerateContentResponse):
+    AIDA.GenerateCodeResponse {
+  return gcaResponseToAidaSamplesAndMetadata(response);
+}
+
+function gcaCandidateToAidaGenerationSample(candidate: GCA.Candidate): AIDA.GenerationSample {
+  const generationSample: AIDA.GenerationSample = {
+    generationString: extractTextFromGcaParts(candidate.content?.parts),
+    score: 0,
+    sampleId: candidate.index,
+  };
+  if (candidate.citation_metadata) {
+    generationSample.attributionMetadata = {
+      attributionAction: AIDA.RecitationAction.CITE,
+      citations: candidate.citation_metadata.citations.map(c => ({
+                                                             startIndex: c.start_index,
+                                                             endIndex: c.end_index,
+                                                             uri: c.uri,
+                                                           })),
+    };
+  }
+  return generationSample;
+}
+
+function convertAidaContentToGcaContent(content: AIDA.Content): GCA.Content {
+  // TODO(liviurau): decide how to map AIDA.Role.SYSTEM
+  // currently it will default to 'user'
+  let role: GCA.Role = 'user';
+
+  if (content.role === AIDA.Role.MODEL) {
+    role = 'model';
+  }
+  return {
+    role,
+    parts: content.parts.map(convertAidaPartToGcaPart),
+  };
+}
+
+function convertAidaPartToGcaPart(part: AIDA.Part): GCA.Part {
+  if ('text' in part) {
+    return {text: part.text};
+  }
+  if ('functionCall' in part) {
+    return {
+      function_call: {
+        name: part.functionCall.name,
+        args: part.functionCall.args,
+      },
+    };
+  }
+  if ('functionResponse' in part) {
+    const fResponse: Record<string, unknown> = {};
+    if ('result' in part.functionResponse.response) {
+      fResponse.output = part.functionResponse.response['result'];
+    } else if ('output' in part.functionResponse.response) {
+      fResponse.output = part.functionResponse.response['output'];
+    } else if (!('error' in part.functionResponse.response)) {
+      fResponse.output = part.functionResponse.response;
+    }
+    if ('error' in part.functionResponse.response) {
+      fResponse.error = part.functionResponse.response['error'];
+    }
+    return {
+      function_response: {
+        name: part.functionResponse.name,
+        response: fResponse,
+      },
+    };
+  }
+  if ('inlineData' in part) {
+    return {
+      inline_data: {
+        mime_type: part.inlineData.mimeType,
+        data: part.inlineData.data,
+      },
+    };
+  }
+  return {};
+}
+
+type FunctionParam<T extends string|number|symbol = string> =
+    AIDA.FunctionObjectParam<T>|AIDA.FunctionArrayParam|AIDA.FunctionPrimitiveParams;
+
+function convertAidaParamToGcaSchema<T extends string|number|symbol = string>(param: FunctionParam<T>): GCA.Schema {
+  const schema: GCA.Schema = {
+    type: param.type as unknown as GCA.Type,
+    description: param.description,
+  };
+  if (param.nullable) {
+    schema.nullable = param.nullable;
+  }
+
+  if (param.type === AIDA.ParametersTypes.ARRAY && param.items) {
+    schema.items = convertAidaParamToGcaSchema(param.items);
+  } else if (param.type === AIDA.ParametersTypes.OBJECT && param.properties) {
+    schema.properties = {};
+    for (const [key, value] of Object.entries(param.properties)) {
+      schema.properties[key] = convertAidaParamToGcaSchema(value as FunctionParam);
+    }
+    schema.required = param.required.map(r => r.toString());
+  }
+
+  return schema;
+}

package/front_end/core/host/GcaTypes.ts

@@ -203,9 +203,11 @@ export interface FileEdit {
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 
+export type Role = 'user'|'model';
+
 export interface Content {
   parts?: Part[];
-  role: string;
+  role: Role;
 }
 
 /* eslint-disable @typescript-eslint/naming-convention */

package/front_end/core/host/UserMetrics.ts

@@ -823,8 +823,6 @@ export enum DevtoolsExperiments {
   'full-accessibility-tree' = 42,
   'experimental-cookie-features' = 45,
   'instrumentation-breakpoints' = 61,
-  'authored-deployed-grouping' = 63,
-  'just-my-code' = 65,
   'use-source-map-scopes' = 76,
   'timeline-debug-mode' = 93,
   'durable-messages' = 110,

package/front_end/core/host/host.ts

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import * as AidaClient from './AidaClient.js';
+import * as AidaGcaTranslation from './AidaGcaTranslation.js';
 import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
 import * as GcaTypes from './GcaTypes.js';
 import * as GdpClient from './GdpClient.js';
@@ -14,6 +15,7 @@ import * as UserMetrics from './UserMetrics.js';
 
 export {
   AidaClient,
+  AidaGcaTranslation,
   DispatchHttpRequestClient,
   GcaTypes,
   GdpClient,

package/front_end/core/root/ExperimentNames.ts

@@ -16,8 +16,6 @@ export enum ExperimentName {
   FULL_ACCESSIBILITY_TREE = 'full-accessibility-tree',
   EXPERIMENTAL_COOKIE_FEATURES = 'experimental-cookie-features',
   INSTRUMENTATION_BREAKPOINTS = 'instrumentation-breakpoints',
-  AUTHORED_DEPLOYED_GROUPING = 'authored-deployed-grouping',
-  JUST_MY_CODE = 'just-my-code',
   USE_SOURCE_MAP_SCOPES = 'use-source-map-scopes',
   TIMELINE_DEBUG_MODE = 'timeline-debug-mode',
   DURABLE_MESSAGES = 'durable-messages',

package/front_end/core/sdk/CPUThrottlingManager.ts

@@ -39,24 +39,27 @@ let throttlingManagerInstance: CPUThrottlingManager|undefined;
 
 export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDKModelObserver<EmulationModel> {
+  readonly #targetManager: TargetManager;
   #cpuThrottlingOption: CPUThrottlingOption;
   #calibratedThrottlingSetting: Common.Settings.Setting<CalibratedCPUThrottling>;
   #hardwareConcurrency?: number;
   #pendingMainTargetPromise?: (r: number) => void;
 
-  private constructor() {
+  private constructor(settings: Common.Settings.Settings, targetManager: TargetManager) {
     super();
+    this.#targetManager = targetManager;
     this.#cpuThrottlingOption = NoThrottlingOption;
-    this.#calibratedThrottlingSetting = Common.Settings.Settings.instance().createSetting<CalibratedCPUThrottling>(
+    this.#calibratedThrottlingSetting = settings.createSetting<CalibratedCPUThrottling>(
         'calibrated-cpu-throttling', {}, Common.Settings.SettingStorageType.GLOBAL);
     this.#calibratedThrottlingSetting.addChangeListener(this.#onCalibratedSettingChanged, this);
-    TargetManager.instance().observeModels(EmulationModel, this);
+    targetManager.observeModels(EmulationModel, this);
   }
 
   static instance(opts: {forceNew: boolean|null} = {forceNew: null}): CPUThrottlingManager {
     const {forceNew} = opts;
     if (!throttlingManagerInstance || forceNew) {
-      throttlingManagerInstance = new CPUThrottlingManager();
+      throttlingManagerInstance =
+          new CPUThrottlingManager(Common.Settings.Settings.instance(), TargetManager.instance());
     }
 
     return throttlingManagerInstance;
@@ -88,7 +91,7 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
       return;
     }
 
-    for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+    for (const emulationModel of this.#targetManager.models(EmulationModel)) {
       void emulationModel.setCPUThrottlingRate(rate);
     }
     this.dispatchEventToListeners(Events.RATE_CHANGED, rate);
@@ -100,7 +103,7 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
     }
 
     this.#cpuThrottlingOption = option;
-    for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+    for (const emulationModel of this.#targetManager.models(EmulationModel)) {
       void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingOption.rate());
     }
     this.dispatchEventToListeners(Events.RATE_CHANGED, this.#cpuThrottlingOption.rate());
@@ -108,7 +111,7 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
 
   setHardwareConcurrency(concurrency: number): void {
     this.#hardwareConcurrency = concurrency;
-    for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+    for (const emulationModel of this.#targetManager.models(EmulationModel)) {
       void emulationModel.setHardwareConcurrency(concurrency);
     }
     this.dispatchEventToListeners(Events.HARDWARE_CONCURRENCY_CHANGED, this.#hardwareConcurrency);
@@ -119,14 +122,14 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
     // target may error. So if we get any errors here at all, assume that we do
     // not have a target.
     try {
-      return TargetManager.instance().primaryPageTarget() !== null;
+      return this.#targetManager.primaryPageTarget() !== null;
     } catch {
       return false;
     }
   }
 
   async getHardwareConcurrency(): Promise<number> {
-    const target = TargetManager.instance().primaryPageTarget();
+    const target = this.#targetManager.primaryPageTarget();
     const existingCallback = this.#pendingMainTargetPromise;
 
     // If the main target hasn't attached yet, block callers until it appears.

package/front_end/core/sdk/ResourceTreeModel.ts

@@ -754,7 +754,7 @@ export class ResourceTreeFrame {
     return this.#domainAndRegistry;
   }
 
-  async getAdScriptAncestry(frameId: Protocol.Page.FrameId): Promise<Protocol.Page.AdScriptAncestry|null> {
+  async getAdScriptAncestry(frameId: Protocol.Page.FrameId): Promise<Protocol.Network.AdAncestry|null> {
     const res = await this.#model.agent.invoke_getAdScriptAncestry({frameId});
     return res.adScriptAncestry || null;
   }

package/front_end/core/sdk/SourceMap.ts

@@ -175,9 +175,11 @@ export class SourceMap {
     // Ensure scriptUrl is associated with sourceMap sources
     const sourceIdx = this.#sourceIndex(scriptUrl);
     if (sourceIdx >= 0) {
-      if (!this.#scopesInfo) {
-        // First time seeing this sourcemap, create an new empty scopesInfo object
+      if (!this.#scopesInfo || this.#scopesFallbackPromise !== undefined) {
+        // First time seeing this sourcemap, create an new empty scopesInfo object.
+        // Also reset the fallback scope info since the extension will provide it.
         this.#scopesInfo = new SourceMapScopesInfo(this, {scopes: [], ranges: []});
+        this.#scopesFallbackPromise = undefined;
       }
       if (!this.#scopesInfo.hasOriginalScopes(sourceIdx)) {
         const originalScopes = buildOriginalScopes(ranges);

package/front_end/entrypoints/main/MainImpl.ts

@@ -401,16 +401,6 @@ export class MainImpl {
     Root.Runtime.experiments.register(
         Root.ExperimentNames.ExperimentName.EXPERIMENTAL_COOKIE_FEATURES, 'Experimental cookie features');
 
-    // Change grouping of sources panel to use Authored/Deployed trees
-    Root.Runtime.experiments.register(
-        Root.ExperimentNames.ExperimentName.AUTHORED_DEPLOYED_GROUPING,
-        'Group sources into authored and deployed trees', 'https://goo.gle/authored-deployed',
-        'https://goo.gle/authored-deployed-feedback');
-
-    // Hide third party code (as determined by ignore lists or source maps)
-    Root.Runtime.experiments.register(
-        Root.ExperimentNames.ExperimentName.JUST_MY_CODE, 'Hide ignore-listed code in Sources tree view');
-
     Root.Runtime.experiments.registerHostExperiment({
       name: Root.ExperimentNames.ExperimentName.DURABLE_MESSAGES,
       title: 'Durable Messages',
@@ -514,6 +504,7 @@ export class MainImpl {
       workspace: Workspace.Workspace.WorkspaceImpl.instance(),
       targetManager,
       debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance(),
+      settings: Common.Settings.Settings.instance(),
     });
     // @ts-expect-error e2e test global
     self.Extensions.extensionServer = PanelCommon.ExtensionServer.ExtensionServer.instance({forceNew: true});

package/front_end/generated/Deprecation.ts

@@ -54,6 +54,14 @@ 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 Warning displayed to developers when document.createEvent() is called with 'KeyboardEvents', which is a non-standard event interface that will be removed.
+   */
+  DocumentCreateEventKeyboardEvents: "document.createEvent('KeyboardEvents') is deprecated and will be removed. Use `new KeyboardEvent()` instead.",
+  /**
+   * @description Warning displayed to developers when document.createEvent() is called with 'TransitionEvent', which is a non-standard event interface that will be removed.
+   */
+  DocumentCreateEventTransitionEvent: "document.createEvent('TransitionEvent') is deprecated and will be removed. Use `new TransitionEvent()` instead.",
   /**
    * @description Translation is not needed, this will never be exposed in production code.
    */
@@ -313,6 +321,14 @@ export const DEPRECATIONS_METADATA: Partial<Record<string, DeprecationDescriptor
     "chromeStatusFeature": 5128825141198848,
     "milestone": 119
   },
+  "DocumentCreateEventKeyboardEvents": {
+    "chromeStatusFeature": 5095987863486464,
+    "milestone": 151
+  },
+  "DocumentCreateEventTransitionEvent": {
+    "chromeStatusFeature": 5095987863486464,
+    "milestone": 151
+  },
   "IdentityInCanMakePaymentEvent": {
     "chromeStatusFeature": 5190978431352832
   },