chrome-devtools-frontend 1.0.1598808 → 1.0.1601661

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -6602,6 +6602,30 @@ export const NativeFunctions = [
     name: "replaceWithHTMLUnsafe",
     signatures: [["html","?options"]]
   },
+  {
+    name: "streamBeforeHTMLUnsafe",
+    signatures: [["?options"]]
+  },
+  {
+    name: "streamBeforeHTML",
+    signatures: [["?options"]]
+  },
+  {
+    name: "streamAfterHTMLUnsafe",
+    signatures: [["?options"]]
+  },
+  {
+    name: "streamAfterHTML",
+    signatures: [["?options"]]
+  },
+  {
+    name: "streamReplaceWithHTMLUnsafe",
+    signatures: [["?options"]]
+  },
+  {
+    name: "streamReplaceWithHTML",
+    signatures: [["?options"]]
+  },
   {
     name: "Comment",
     signatures: [["?data"]]
@@ -6650,6 +6674,10 @@ export const NativeFunctions = [
     name: "streamHTMLUnsafe",
     signatures: [["?options"]]
   },
+  {
+    name: "streamPrependHTMLUnsafe",
+    signatures: [["?options"]]
+  },
   {
     name: "streamAppendHTML",
     signatures: [["?options"]]
@@ -6658,6 +6686,10 @@ export const NativeFunctions = [
     name: "streamHTML",
     signatures: [["?options"]]
   },
+  {
+    name: "streamPrependHTML",
+    signatures: [["?options"]]
+  },
   {
     name: "appendHTML",
     signatures: [["html","?options"]]
@@ -7779,6 +7811,22 @@ export const NativeFunctions = [
     name: "signalCurrentUserDetails",
     signatures: [["options"]]
   },
+  {
+    name: "encapsulateKey",
+    signatures: [["encapsulationAlgorithm","encapsulationKey","sharedKeyAlgorithm","extractable","keyUsages"]]
+  },
+  {
+    name: "encapsulateBits",
+    signatures: [["encapsulationAlgorithm","encapsulationKey"]]
+  },
+  {
+    name: "decapsulateKey",
+    signatures: [["decapsulationAlgorithm","decapsulationKey","ciphertext","sharedKeyAlgorithm","extractable","keyUsages"]]
+  },
+  {
+    name: "decapsulateBits",
+    signatures: [["decapsulationAlgorithm","decapsulationKey","ciphertext"]]
+  },
   {
     name: "registerPaint",
     signatures: [["name","paintCtor"]]
@@ -8067,6 +8115,10 @@ export const NativeFunctions = [
     name: "OverconstrainedError",
     signatures: [["constraint","?message"]]
   },
+  {
+    name: "setConstraints",
+    signatures: [["constraints"]]
+  },
   {
     name: "createContext",
     signatures: [["?options"]]
@@ -8785,6 +8837,14 @@ export const NativeFunctions = [
     name: "SpeechSynthesisUtterance",
     signatures: [["?text"]]
   },
+  {
+    name: "addWords",
+    signatures: [["words"]]
+  },
+  {
+    name: "removeWords",
+    signatures: [["words"]]
+  },
   {
     name: "requestStorageAccessFor",
     signatures: [["requestedOrigin"]]

package/front_end/models/lighthouse/LighthouseReporterTypes.ts

@@ -5,11 +5,14 @@
 import type * as Platform from '../../core/platform/platform.js';
 import type * as Trace from '../../models/trace/trace.js';
 
+import type {CategoryId} from './RunTypes.js';
+
 export class LighthouseReportGenerator {
   generateReportHtml(_lhr: ReportJSON): string {
     return '';
   }
 }
+
 export interface AuditResultJSON {
   rawValue?: number|boolean;
   id: string;
@@ -21,8 +24,16 @@ export interface AuditResultJSON {
   scoreDisplayMode: string;
   error: boolean;
   score: number|null;
+  numericValue?: number;
+  numericUnit?: string;
+  warnings?: string[];
   details?: DetailsJSON;
+  scoringOptions?: {
+    p10: number,
+    median: number,
+  };
 }
+
 export interface AuditJSON {
   id: string;
   score: number|null;
@@ -30,6 +41,7 @@ export interface AuditJSON {
   group?: string;
   result: AuditResultJSON;
 }
+
 export interface CategoryJSON {
   title: string;
   id: string;
@@ -38,37 +50,103 @@ export interface CategoryJSON {
   manualDescription: string;
   auditRefs: AuditJSON[];
 }
+
 export interface GroupJSON {
   title: string;
   description?: string;
 }
+
 export interface ReportJSON {
   lighthouseVersion: string;
   userAgent: string;
   fetchTime: string;
   timing: {total: number};
   requestedUrl?: string;
+  mainDocumentUrl?: string;
   finalDisplayedUrl: string;
   finalUrl?: string;
   runWarnings?: string[];
+  environment?: {
+    networkUserAgent: string,
+    hostUserAgent: string,
+    benchmarkIndex: number,
+    credits?: Record<string, string>,
+  };
   // eslint-disable-next-line @typescript-eslint/naming-convention
   artifacts: {Trace: {traceEvents: unknown[]}};
   audits: Record<string, AuditResultJSON>;
-  categories: Record<string, CategoryJSON>;
+  categories: Record<CategoryId, CategoryJSON>;
   categoryGroups: Record<string, GroupJSON>;
 }
-export interface DetailsJSON {
-  type: string;
-  value?: string|number;
+
+export type DetailsJSON =
+    |TableDetailsJSON|OpportunityDetailsJSON|FilmstripDetailsJSON|ScreenshotDetailsJSON|DebugDataDetailsJSON;
+
+export interface TableDetailsJSON {
+  type: 'table';
+  headings: TableHeadingJSON[];
+  items: Array<Record<string, TableItemValue>>;
   summary?: OpportunitySummary;
-  granularity?: number;
-  displayUnit?: string;
 }
+
+export interface TableHeadingJSON {
+  key: string;
+  valueType: 'url'|'text'|'numeric'|'timespanMs'|'bytes'|'node'|'source-location'|'code';
+  label: string;
+  itemType?: string;
+  subItemsHeading?: {
+    key: string,
+    valueType: string,
+  };
+}
+
+/**
+ * Represents the possible values found in an 'item' object
+ * based on the 'valueType' specified in headings.
+ */
+export type TableItemValue =|string|number|NodeDetailsJSON|SourceLocationDetailsJSON|Platform.DevToolsPath.UrlString;
+
+export interface OpportunityDetailsJSON {
+  type: 'opportunity';
+  headings: TableHeadingJSON[];
+  items: Array<{
+    url: string,
+    wastedBytes?: number,
+    wastedMs?: number,
+    totalBytes?: number, [key: string]: unknown,
+  }>;
+  overallSavingsMs: number;
+  overallSavingsBytes?: number;
+}
+
+export interface FilmstripDetailsJSON {
+  type: 'filmstrip';
+  scale: number;
+  items: Array<{
+    timing: number,
+    timestamp: number,
+    data: string,
+  }>;
+}
+
+export interface ScreenshotDetailsJSON {
+  type: 'screenshot';
+  timing: number;
+  timestamp: number;
+  data: string;
+}
+
+export interface DebugDataDetailsJSON {
+  type: 'debugdata';
+  items: unknown[];
+}
+
 export interface RunnerResultArtifacts {
   // eslint-disable-next-line @typescript-eslint/naming-convention
   Trace: {traceEvents: Trace.Types.Events.Event[]};
   settings: {throttlingMethod: string};
 }
+
 export interface RunnerResult {
   lhr: ReportJSON;
   artifacts: RunnerResultArtifacts;
@@ -77,17 +155,33 @@ export interface RunnerResult {
   fatal: boolean;
   message?: string;
 }
+
 export interface NodeDetailsJSON {
-  type: string;
+  type: 'node';
+  lhId?: string;
   path?: string;
   selector?: string;
+  nodeLabel?: string;
   snippet?: string;
+  boundingRect?: {
+    top: number,
+    bottom: number,
+    left: number,
+    right: number,
+    width: number,
+    height: number,
+  };
+  explanation?: string;
 }
+
 export interface SourceLocationDetailsJSON {
-  sourceUrl?: Platform.DevToolsPath.UrlString;
-  sourceLine?: string;
-  sourceColumn?: string;
+  type: 'source-location';
+  url?: Platform.DevToolsPath.UrlString;
+  urlProvider?: 'network'|'stack';
+  line?: number;
+  column?: number;
 }
+
 export interface OpportunitySummary {
   wastedMs?: number;
   wastedBytes?: number;

package/front_end/models/lighthouse/RunTypes.ts

@@ -0,0 +1,42 @@
+// 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 type * as Common from '../../core/common/common.js';
+import type * as Host from '../../core/host/host.js';
+import type * as Platform from '../../core/platform/platform.js';
+
+export type CategoryId = 'performance'|'accessibility'|'best-practices'|'seo';
+
+export interface Preset {
+  setting: Common.Settings.Setting<boolean>;
+  configID: CategoryId;
+  title: () => Common.UIString.LocalizedString;
+  description: () => Common.UIString.LocalizedString;
+  supportedModes: string[];
+  userMetric: Host.UserMetrics.LighthouseCategoryUsed;
+}
+export interface RuntimeSetting {
+  setting: Common.Settings.Setting<string|boolean>;
+  description: () => Common.UIString.LocalizedString;
+  setFlags: (flags: Flags, value: string|boolean) => void;
+  options?: Array<{
+    label: () => Common.UIString.LocalizedString,
+    value: string,
+    tooltip?: () => Common.UIString.LocalizedString,
+  }>;
+  title?: () => Common.UIString.LocalizedString;
+  learnMore?: Platform.DevToolsPath.UrlString;
+}
+
+export interface Flags {
+  additionalTraceCategories?: string;
+  disableStorageReset?: boolean;
+  throttlingMethod?: string;
+  formFactor?: string|boolean;
+  mode?: string|boolean;
+}
+
+export interface RunOverrides {
+  categoryIds?: CategoryId[];
+  isAIControlled?: boolean;
+}

package/front_end/models/lighthouse/lighthouse.ts

@@ -3,7 +3,9 @@
 // found in the LICENSE file.
 
 import * as ReporterTypes from './LighthouseReporterTypes.js';
+import * as RunTypes from './RunTypes.js';
 
 export {
   ReporterTypes,
+  RunTypes,
 };

package/front_end/models/live-metrics/web-vitals-injected/web-vitals-injected.ts

@@ -17,33 +17,64 @@ declare const window: Window&{
   [Spec.EVENT_BINDING_NAME]: (payload: string) => void,
 };
 
-type ListenerArgs = Parameters<typeof globalThis['addEventListener']>;
-
-const windowListeners: ListenerArgs[] = [];
-const documentListeners: ListenerArgs[] = [];
-const observers: PerformanceObserver[] = [];
+const eventListenerCleanupController = new AbortController();
+
+const patchAddListener = (proto: typeof Window.prototype|typeof Document.prototype): void => {
+  const original = proto.addEventListener;
+
+  proto.addEventListener = function(
+      type: string, listener: EventListenerOrEventListenerObject, options?: boolean|AddEventListenerOptions): void {
+    // Standardize options into an object
+    const navOptions = typeof options === 'boolean' ? {capture: options} : {...options};
+
+    // If we already have a signal, we should respect it,
+    // but also link it to our global cleanup signal.
+    if (navOptions.signal) {
+      navOptions.signal = AbortSignal.any([navOptions.signal, eventListenerCleanupController.signal]);
+    } else {
+      navOptions.signal = eventListenerCleanupController.signal;
+    }
 
-const originalWindowAddListener = Window.prototype.addEventListener;
-Window.prototype.addEventListener = function(...args: ListenerArgs) {
-  windowListeners.push(args);
-  return originalWindowAddListener.call(this, ...args);
+    return original.call(this, type, listener, navOptions);
+  };
 };
 
-const originalDocumentAddListener = Document.prototype.addEventListener;
-Document.prototype.addEventListener = function(...args: ListenerArgs) {
-  documentListeners.push(args);
-  return originalDocumentAddListener.call(this, ...args);
-};
+// Patch the core targets
+patchAddListener(Window.prototype);
+patchAddListener(Document.prototype);
 
-class InternalPerformanceObserver extends PerformanceObserver {
-  constructor(...args: ConstructorParameters<typeof PerformanceObserver>) {
-    super(...args);
-    observers.push(this);
+// Use a class wrapper that auto-registers and auto-unregisters
+const activeObservers = new Set<PerformanceObserver>();
+class TrackedPerformanceObserver extends globalThis.PerformanceObserver {
+  constructor(callback: PerformanceObserverCallback) {
+    super(callback);
+    activeObservers.add(this);
+  }
+
+  // Override disconnect to remove it from our tracking set
+  override disconnect(): void {
+    super.disconnect();
+    activeObservers.delete(this);
   }
 }
-globalThis.PerformanceObserver = InternalPerformanceObserver;
 
-let killed = false;
+const nodeList: Array<WeakRef<Node>> = [];
+const nodeToIdMap = new WeakMap<Node, number>();
+
+function establishNodeIndex(node: Node): number {
+  let index = nodeToIdMap.get(node);
+  if (index !== undefined) {
+    return index;
+  }
+
+  index = nodeList.length;
+  nodeList.push(new WeakRef(node));
+  nodeToIdMap.set(node, index);
+  return index;
+}
+
+// Replace the global constructor
+globalThis.PerformanceObserver = TrackedPerformanceObserver;
 
 /**
  * This is a hack solution to remove any listeners that were added by web-vitals.js
@@ -51,22 +82,23 @@ let killed = false;
  * context should be considered dead and a new one will need to be created for live metrics
  * to be served again.
  */
+let killed = false;
 window[Spec.INTERNAL_KILL_SWITCH] = () => {
   if (killed) {
     return;
   }
 
-  for (const observer of observers) {
+  for (const observer of activeObservers) {
+    // This calls the overridden disconnect above,
+    // cleaning up BOTH the browser resource and our Set.
     observer.disconnect();
   }
+  activeObservers.clear();
 
-  for (const args of windowListeners) {
-    window.removeEventListener(...args);
-  }
+  eventListenerCleanupController.abort();
 
-  for (const args of documentListeners) {
-    document.removeEventListener(...args);
-  }
+  // Explicitly clear the Node List to help GC
+  nodeList.length = 0;
 
   killed = true;
 };
@@ -76,14 +108,6 @@ function sendEventToDevTools(event: Spec.WebVitalsEvent): void {
   window[Spec.EVENT_BINDING_NAME](payload);
 }
 
-const nodeList: Array<WeakRef<Node>> = [];
-
-function establishNodeIndex(node: Node): number {
-  const index = nodeList.length;
-  nodeList.push(new WeakRef(node));
-  return index;
-}
-
 /**
  * The data sent over the event binding needs to be JSON serializable, so we
  * can't send DOM nodes directly. Instead we create an ID for each node (see

package/front_end/models/stack_trace/StackTrace.ts

@@ -34,6 +34,11 @@ export interface Frame {
   readonly column: number;
 
   readonly missingDebugInfo?: MissingDebugInfo;
+  /**
+   * The untranslated function name. For inlined frames this will be the name
+   * of the containing function.
+   */
+  readonly rawName?: string;
 }
 
 export interface DebuggableFrame extends Frame {

package/front_end/models/stack_trace/StackTraceImpl.ts

@@ -84,16 +84,18 @@ export class FrameImpl implements StackTrace.StackTrace.Frame {
   readonly column: number;
 
   readonly missingDebugInfo?: StackTrace.StackTrace.MissingDebugInfo;
+  readonly rawName?: string;
 
   constructor(
       url: string|undefined, uiSourceCode: Workspace.UISourceCode.UISourceCode|undefined, name: string|undefined,
-      line: number, column: number, missingDebugInfo?: StackTrace.StackTrace.MissingDebugInfo) {
+      line: number, column: number, missingDebugInfo?: StackTrace.StackTrace.MissingDebugInfo, rawName?: string) {
     this.url = url;
     this.uiSourceCode = uiSourceCode;
     this.name = name;
     this.line = line;
     this.column = column;
     this.missingDebugInfo = missingDebugInfo;
+    this.rawName = rawName;
   }
 }
 
@@ -166,6 +168,10 @@ export class DebuggableFrameImpl implements StackTrace.StackTrace.DebuggableFram
     return this.#frame.missingDebugInfo;
   }
 
+  get rawName(): string|undefined {
+    return this.#frame.rawName;
+  }
+
   get sdkFrame(): SDK.DebuggerModel.CallFrame {
     return this.#sdkFrame;
   }

package/front_end/models/stack_trace/StackTraceModel.ts

@@ -166,7 +166,8 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
     for (const node of fragment.node.getCallStack()) {
       node.frames = uiFrames[i++].map(
           frame => new FrameImpl(
-              frame.url, frame.uiSourceCode, frame.name, frame.line, frame.column, frame.missingDebugInfo));
+              frame.url, frame.uiSourceCode, frame.name, frame.line, frame.column, frame.missingDebugInfo,
+              node.rawFrame.functionName));
     }
   }
 

package/front_end/models/stack_trace/stack_trace.ts

@@ -2,8 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as ErrorStackParser from './ErrorStackParser.js';
 import * as StackTrace from './StackTrace.js';
 
 export {
+  // TODO(crbug.com/485142682): Move to stack_trace_impl.js once all usage
+  // goes through createStackTraceFromErrorObject.
+  ErrorStackParser,
   StackTrace,
 };

package/front_end/models/trace/ModelImpl.ts

@@ -173,6 +173,10 @@ export class Model extends EventTarget {
     this.#recordingsAvailable.splice(recordingIndex, 1);
   }
 
+  indexForTrace(trace: ParsedTrace): number {
+    return this.#traces.indexOf(trace);
+  }
+
   getRecordingsAvailable(): string[] {
     return this.#recordingsAvailable;
   }

package/front_end/models/trace/helpers/SamplesIntegrator.ts

@@ -477,20 +477,13 @@ export class SamplesIntegrator {
     if (showAllEvents) {
       return;
     }
-    let previousNativeFrameName: string|null = null;
     let j = 0;
     for (let i = 0; i < stack.length; ++i) {
       const frame = stack[i].callFrame;
       const nativeRuntimeFrame = SamplesIntegrator.isNativeRuntimeFrame(frame);
-      if (nativeRuntimeFrame &&
-          !SamplesIntegrator.showNativeName(frame.functionName, engineConfig.includeRuntimeCallStats)) {
+      if (nativeRuntimeFrame) {
         continue;
       }
-      const nativeFrameName = nativeRuntimeFrame ? SamplesIntegrator.nativeGroup(frame.functionName) : null;
-      if (previousNativeFrameName && previousNativeFrameName === nativeFrameName) {
-        continue;
-      }
-      previousNativeFrameName = nativeFrameName;
       stack[j++] = stack[i];
     }
     stack.length = j;

package/front_end/models/trace/types/Configuration.ts

@@ -11,10 +11,6 @@ import type * as File from './File.js';
 import type {Milli} from './Timing.js';
 
 export interface Configuration {
-  /**
-   * Include V8 RCS functions in the JS stacks
-   */
-  includeRuntimeCallStats: boolean;
   /**
    * Show all events: disable the default filtering which hides and excludes some events.
    */
@@ -49,7 +45,6 @@ export interface Configuration {
 }
 
 export const defaults = (): Configuration => ({
-  includeRuntimeCallStats: false,
   showAllEvents: false,
   debugMode: false,
   maxInvalidationEventsPerEvent: 20,

package/front_end/panels/accessibility/AccessibilityNodeView.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /* eslint-disable @devtools/no-imperative-dom-api */
+/* eslint-disable @devtools/no-lit-render-outside-of-view */
 
 import * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
@@ -9,6 +10,7 @@ import * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 import * as uiI18n from '../../ui/i18n/i18n.js';
 import * as UI from '../../ui/legacy/legacy.js';
+import {render} from '../../ui/lit/lit.js';
 import * as VisualLogging from '../../ui/visual_logging/visual_logging.js';
 import * as PanelsCommon from '../common/common.js';
 
@@ -591,9 +593,11 @@ export class AXRelatedNodeElement {
         if (!node) {
           return;
         }
-        valueElement.appendChild(PanelsCommon.DOMLinkifier.Linkifier.instance().linkify(node, {
-          preventKeyboardFocus: true,
-        }));
+        render(
+            PanelsCommon.DOMLinkifier.Linkifier.instance().linkify(node, {
+              preventKeyboardFocus: true,
+            }),
+            valueElement);
       });
     } else if (this.idref) {
       element.classList.add('invalid');