chrome-devtools-frontend 1.0.1529904 → 1.0.1531367

package/eslint.config.mjs

@@ -810,7 +810,7 @@ export default defineConfig([
   },
   {
     name: 'Front-end component docs',
-    files: ['front_end/ui/components/docs/**/*.ts'],
+    files: ['front_end/ui/components/docs/**/*.ts', '**/*.docs.ts'],
     rules: {
       // This makes the component doc examples very verbose and doesn't add
       // anything, so we leave return types to the developer within the

package/front_end/core/common/Worker.ts

@@ -5,10 +5,15 @@
 export class WorkerWrapper {
   readonly #workerPromise: Promise<Worker>;
   #disposed?: boolean;
+  #rejectWorkerPromise?: (error: Error) => void;
 
   private constructor(workerLocation: URL) {
-    this.#workerPromise = new Promise(fulfill => {
+    this.#workerPromise = new Promise((fulfill, reject) => {
+      this.#rejectWorkerPromise = reject;
       const worker = new Worker(workerLocation, {type: 'module'});
+      worker.onerror = event => {
+        console.error(`Failed to load worker for ${workerLocation.href}:`, event);
+      };
       worker.onmessage = (event: MessageEvent<unknown>) => {
         console.assert(event.data === 'workerReady');
         worker.onmessage = null;
@@ -34,7 +39,10 @@ export class WorkerWrapper {
     void this.#workerPromise.then(worker => worker.terminate());
   }
 
-  terminate(): void {
+  terminate(immediately = false): void {
+    if (immediately) {
+      this.#rejectWorkerPromise?.(new Error('Worker terminated'));
+    }
     this.dispose();
   }
 

package/front_end/core/host/AidaClient.ts

@@ -279,7 +279,7 @@ export interface DoConversationClientEvent {
 
 export interface UserImpression {
   sample: {
-    sample_id: number,
+    sample_id?: number,
   };
   latency: {
     duration: {
@@ -291,7 +291,7 @@ export interface UserImpression {
 
 export interface UserAcceptance {
   sample: {
-    sample_id: number,
+    sample_id?: number,
   };
 }
 
@@ -366,7 +366,7 @@ export interface CompletionResponse {
 export interface GenerationSample {
   generationString: string;
   score: number;
-  sampleId: number;
+  sampleId?: number;
   attributionMetadata?: AttributionMetadata;
 }
 

package/front_end/core/host/InspectorFrontendHostAPI.ts

@@ -346,8 +346,7 @@ export interface InspectorFrontendHostAPI {
   closeWindow(): void;
 
   /**
-   * Don't use directly - use {@link CopyToClipboard.copyTextToClipboard} instead.
-   * @deprecated Marked to restrict usage.
+   * If you need to alert to the user after copying use {@link UIUtils.copyTextToClipboard}.
    */
   copyText(text: string|null|undefined): void;
 

package/front_end/core/sdk/NetworkManager.ts

@@ -67,6 +67,10 @@ const UIStrings = {
    * @description Text in Network Manager representing the "Fast 4G" throttling preset
    */
   fast4G: 'Fast 4G',
+  /**
+   * @description Text in Network Manager representing the "Blocking" throttling preset
+   */
+  block: 'Block',
   /**
    * @description Text in Network Manager
    * @example {https://example.com} PH1
@@ -459,6 +463,12 @@ export interface EventTypes {
  * @see https://crbug.com/342406608#comment10 for context around the addition of 4G presets in June 2024.
  */
 
+export const BlockingConditions: ThrottlingConditions = {
+  key: PredefinedThrottlingConditionKey.BLOCKING,
+  block: true,
+  title: i18nLazyString(UIStrings.block),
+};
+
 export const NoThrottlingConditions: Conditions = {
   key: PredefinedThrottlingConditionKey.NO_THROTTLING,
   title: i18nLazyString(UIStrings.noThrottling),
@@ -521,7 +531,7 @@ export const Fast4GConditions: Conditions = {
   targetLatency: fast4GTargetLatency,
 };
 
-const MAX_EAGER_POST_REQUEST_BODY_LENGTH = 64 * 1024;  // bytes
+const MAX_EAGER_POST_REQUEST_BODY_LENGTH = 64 * 1024;             // bytes
 const MAX_RESPONSE_BODY_TOTAL_BUFFER_LENGTH = 250 * 1024 * 1024;  // bytes
 
 export class FetchDispatcher implements ProtocolProxyApi.FetchDispatcher {
@@ -1556,11 +1566,12 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
   }
 }
 
-type RequestConditionsSetting = {
+export type RequestConditionsSetting = {
   url: string,
   enabled: boolean,
 }|{
   urlPattern: URLPatternConstructorString,
+  conditions: ThrottlingConditionKey,
   enabled: boolean,
 };
 
@@ -1638,21 +1649,40 @@ export class RequestURLPattern {
 export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<RequestCondition.EventTypes> {
   #pattern: RequestURLPattern|{wildcardURL: string, upgradedPattern?: RequestURLPattern};
   #enabled: boolean;
+  #conditions: ThrottlingConditions;
 
-  constructor(setting: RequestConditionsSetting) {
-    super();
+  static createFromSetting(setting: RequestConditionsSetting): RequestCondition {
     if ('urlPattern' in setting) {
-      this.#pattern = RequestURLPattern.create(setting.urlPattern) ?? {
+      const pattern = RequestURLPattern.create(setting.urlPattern) ?? {
         wildcardURL: setting.urlPattern,
         upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.urlPattern) ?? undefined,
       };
-    } else {
-      this.#pattern = {
-        wildcardURL: setting.url,
-        upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.url) ?? undefined
-      };
+
+      const conditions = getPredefinedOrBlockingCondition(setting.conditions) ??
+          customUserNetworkConditionsSetting().get().find(condition => condition.key === setting.conditions) ??
+          NoThrottlingConditions;
+
+      return new this(pattern, setting.enabled, conditions);
     }
-    this.#enabled = setting.enabled;
+
+    const pattern = {
+      wildcardURL: setting.url,
+      upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.url) ?? undefined
+    };
+    return new this(pattern, setting.enabled, BlockingConditions);
+  }
+
+  static create(pattern: RequestURLPattern, conditions: ThrottlingConditions): RequestCondition {
+    return new this(pattern, /* enabled=*/ true, conditions);
+  }
+
+  private constructor(
+      pattern: RequestURLPattern|{wildcardURL: string, upgradedPattern?: RequestURLPattern}, enabled: boolean,
+      conditions: ThrottlingConditions) {
+    super();
+    this.#pattern = pattern;
+    this.#enabled = enabled;
+    this.#conditions = conditions;
   }
 
   get constructorString(): string|undefined {
@@ -1695,10 +1725,24 @@ export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<Request
     this.dispatchEventToListeners(RequestCondition.Events.REQUEST_CONDITION_CHANGED);
   }
 
+  get conditions(): ThrottlingConditions {
+    return this.#conditions;
+  }
+
+  set conditions(conditions: ThrottlingConditions) {
+    this.#conditions = conditions;
+    this.dispatchEventToListeners(RequestCondition.Events.REQUEST_CONDITION_CHANGED);
+  }
+
   toSetting(): RequestConditionsSetting {
     const enabled = this.enabled;
-    return this.#pattern instanceof RequestURLPattern ? {enabled, urlPattern: this.#pattern.constructorString} :
-                                                        {enabled, url: this.#pattern.wildcardURL};
+    if (this.#pattern instanceof RequestURLPattern) {
+      return {enabled, urlPattern: this.#pattern.constructorString, conditions: this.#conditions.key};
+    }
+    if (this.#conditions !== BlockingConditions && this.#pattern.upgradedPattern) {
+      return {enabled, urlPattern: this.#pattern.upgradedPattern.constructorString, conditions: this.#conditions.key};
+    }
+    return {enabled, url: this.#pattern.wildcardURL};
   }
 
   get originalOrUpgradedURLPattern(): URLPattern|undefined {
@@ -1719,20 +1763,41 @@ export namespace RequestCondition {
 export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<RequestConditions.EventTypes> {
   readonly #setting =
       Common.Settings.Settings.instance().createSetting<RequestConditionsSetting[]>('network-blocked-patterns', []);
-  readonly #conditions: RequestCondition[];
+  readonly #conditionsEnabledSetting =
+      Common.Settings.Settings.instance().moduleSetting<boolean>('request-blocking-enabled');
+  readonly #conditions: RequestCondition[] = [];
 
   constructor() {
     super();
-    this.#conditions = this.#setting.get().map(condition => new RequestCondition(condition));
+    for (const condition of this.#setting.get()) {
+      try {
+        this.#conditions.push(RequestCondition.createFromSetting(condition));
+      } catch (e) {
+        console.error('Error loading throttling settings: ', e);
+      }
+    }
     for (const condition of this.#conditions) {
       condition.addEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
     }
+    this.#conditionsEnabledSetting.addChangeListener(
+        () => this.dispatchEventToListeners(RequestConditions.Events.REQUEST_CONDITIONS_CHANGED));
   }
 
   get count(): number {
     return this.#conditions.length;
   }
 
+  get conditionsEnabled(): boolean {
+    return this.#conditionsEnabledSetting.get();
+  }
+
+  set conditionsEnabled(enabled: boolean) {
+    if (this.#conditionsEnabledSetting.get() === enabled) {
+      return;
+    }
+    this.#conditionsEnabledSetting.set(enabled);
+  }
+
   findCondition(pattern: string): RequestCondition|undefined {
     if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
       return this.#conditions.find(condition => condition.constructorString === pattern);
@@ -1746,6 +1811,9 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
 
   add(...conditions: RequestCondition[]): void {
     this.#conditions.push(...conditions);
+    for (const condition of conditions) {
+      condition.addEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
+    }
     this.#conditionsChanged();
   }
 
@@ -1755,7 +1823,7 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
       return;
     }
     condition.removeEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
-    this.#conditions.splice(index);
+    this.#conditions.splice(index, 1);
     this.#conditionsChanged();
   }
 
@@ -1776,18 +1844,69 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
     return this.#conditions.values();
   }
 
-  applyConditions(...agents: ProtocolProxyApi.NetworkApi[]): boolean {
+  applyConditions(offline: boolean, globalConditions: Conditions|null, ...agents: ProtocolProxyApi.NetworkApi[]):
+      boolean {
+    function isNonBlockingCondition(condition: ThrottlingConditions): condition is Conditions {
+      return !('block' in condition);
+    }
     if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
-      const urlPatterns = this.#conditions.filter(condition => condition.enabled && condition.constructorString)
-                              .map(condition => ({urlPattern: condition.constructorString as string, block: true}));
+      const urlPatterns: Protocol.Network.BlockPattern[] = [];
+      const matchedNetworkConditions: Protocol.Network.NetworkConditions[] = [];
+      if (this.conditionsEnabled) {
+        for (const condition of this.#conditions) {
+          const urlPattern = condition.constructorString;
+          const conditions = condition.conditions;
+          if (!condition.enabled || !urlPattern || conditions === NoThrottlingConditions) {
+            continue;
+          }
+          const block = !isNonBlockingCondition(conditions);
+          urlPatterns.push({urlPattern, block});
+          if (!block) {
+            matchedNetworkConditions.push({
+              urlPattern,
+              latency: conditions.latency,
+              downloadThroughput: conditions.download < 0 ? 0 : conditions.download,
+              uploadThroughput: conditions.upload < 0 ? 0 : conditions.upload,
+              packetLoss: (conditions.packetLoss ?? 0) < 0 ? 0 : conditions.packetLoss,
+              packetQueueLength: conditions.packetQueueLength,
+              packetReordering: conditions.packetReordering,
+              connectionType: NetworkManager.connectionType(conditions),
+            });
+          }
+        }
+
+        if (globalConditions) {
+          matchedNetworkConditions.push({
+            urlPattern: '',
+            latency: globalConditions.latency,
+            downloadThroughput: globalConditions.download < 0 ? 0 : globalConditions.download,
+            uploadThroughput: globalConditions.upload < 0 ? 0 : globalConditions.upload,
+            packetLoss: (globalConditions.packetLoss ?? 0) < 0 ? 0 : globalConditions.packetLoss,
+            packetQueueLength: globalConditions.packetQueueLength,
+            packetReordering: globalConditions.packetReordering,
+            connectionType: NetworkManager.connectionType(globalConditions),
+          });
+        }
+      }
 
       for (const agent of agents) {
         void agent.invoke_setBlockedURLs({urlPatterns});
+        void agent.invoke_emulateNetworkConditionsByRule({offline, matchedNetworkConditions});
+        void agent.invoke_overrideNetworkState({
+          offline,
+          latency: globalConditions?.latency ?? 0,
+          downloadThroughput: !globalConditions || globalConditions.download < 0 ? 0 : globalConditions.download,
+          uploadThroughput: !globalConditions || globalConditions.upload < 0 ? 0 : globalConditions.upload,
+        });
       }
       return urlPatterns.length > 0;
     }
-    const urls = this.#conditions.filter(condition => condition.enabled && condition.wildcardURL)
-                     .map(condition => condition.wildcardURL as string);
+
+    const urls = this.conditionsEnabled ?
+        this.#conditions.filter(condition => condition.enabled && condition.wildcardURL)
+            .map(condition => condition.wildcardURL as string) :
+        [];
+
     for (const agent of agents) {
       void agent.invoke_setBlockedURLs({urls});
     }
@@ -1816,8 +1935,6 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
   readonly inflightMainResourceRequests = new Map<string, NetworkRequest>();
   #networkConditions: Conditions = NoThrottlingConditions;
   #updatingInterceptionPatternsPromise: Promise<void>|null = null;
-  readonly #blockingEnabledSetting =
-      Common.Settings.Settings.instance().moduleSetting<boolean>('request-blocking-enabled');
   readonly #requestConditions = new RequestConditions();
   readonly #urlsForRequestInterceptor:
       Platform.MapUtilities.Multimap<(arg0: InterceptedRequest) => Promise<void>, InterceptionPattern> =
@@ -1834,7 +1951,6 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
       this.updateBlockedPatterns();
       this.dispatchEventToListeners(MultitargetNetworkManager.Events.BLOCKED_PATTERNS_CHANGED);
     };
-    this.#blockingEnabledSetting.addChangeListener(blockedPatternChanged);
     this.#requestConditions.addEventListener(
         RequestConditions.Events.REQUEST_CONDITIONS_CHANGED, blockedPatternChanged);
     this.updateBlockedPatterns();
@@ -1904,7 +2020,8 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
       void networkAgent.invoke_setUserAgentOverride(
           {userAgent: this.currentUserAgent(), userAgentMetadata: this.#userAgentMetadataOverride || undefined});
     }
-    this.#requestConditions.applyConditions(networkAgent);
+    this.#requestConditions.applyConditions(
+        this.isOffline(), this.isThrottling() ? this.#networkConditions : null, networkAgent);
     if (this.isIntercepting()) {
       void fetchAgent.invoke_enable({patterns: this.#urlsForRequestInterceptor.valuesArray()});
     }
@@ -1915,7 +2032,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
     }
     this.#networkAgents.add(networkAgent);
     this.#fetchAgents.add(fetchAgent);
-    if (this.isThrottling()) {
+    if (this.isThrottling() && !Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
       this.updateNetworkConditions(networkAgent);
     }
   }
@@ -1943,8 +2060,13 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
 
   setNetworkConditions(conditions: Conditions): void {
     this.#networkConditions = conditions;
-    for (const agent of this.#networkAgents) {
-      this.updateNetworkConditions(agent);
+    if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+      this.#requestConditions.applyConditions(
+          this.isOffline(), this.isThrottling() ? this.#networkConditions : null, ...this.#networkAgents);
+    } else {
+      for (const agent of this.#networkAgents) {
+        this.updateNetworkConditions(agent);
+      }
     }
     this.dispatchEventToListeners(MultitargetNetworkManager.Events.CONDITIONS_CHANGED);
   }
@@ -2048,12 +2170,16 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
     return this.#requestConditions;
   }
 
-  blockingEnabled(): boolean {
-    return this.#blockingEnabledSetting.get();
+  isBlocking(): boolean {
+    return this.#isBlocking && this.requestConditions.conditionsEnabled;
   }
 
-  isBlocking(): boolean {
-    return this.#isBlocking && this.blockingEnabled();
+  /**
+   * @deprecated Kept for layout tests
+   * TODO(pfaffe) remove
+   */
+  private setBlockingEnabled(enabled: boolean): void {
+    this.requestConditions.conditionsEnabled = enabled;
   }
 
   /**
@@ -2062,18 +2188,12 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
    */
   private setBlockedPatterns(patterns: Array<{url: string, enabled: boolean}>): void {
     this.requestConditions.clear();
-    this.requestConditions.add(...patterns.map(pattern => new RequestCondition(pattern)));
-  }
-
-  setBlockingEnabled(enabled: boolean): void {
-    if (this.#blockingEnabledSetting.get() === enabled) {
-      return;
-    }
-    this.#blockingEnabledSetting.set(enabled);
+    this.requestConditions.add(...patterns.map(pattern => RequestCondition.createFromSetting(pattern)));
   }
 
   private updateBlockedPatterns(): void {
-    this.#isBlocking = this.#requestConditions.applyConditions(...this.#networkAgents);
+    this.#isBlocking = this.#requestConditions.applyConditions(
+        this.isOffline(), this.isThrottling() ? this.#networkConditions : null, ...this.#networkAgents);
   }
 
   isIntercepting(): boolean {
@@ -2466,7 +2586,15 @@ class ExtraInfoBuilder {
 
 SDKModel.register(NetworkManager, {capabilities: Capability.NETWORK, autostart: true});
 
-export function networkConditionsEqual(first: Conditions, second: Conditions): boolean {
+export function networkConditionsEqual(first: ThrottlingConditions, second: ThrottlingConditions): boolean {
+  if ('block' in first || 'block' in second) {
+    if ('block' in first && 'block' in second) {
+      const firstTitle = (typeof first.title === 'function' ? first.title() : first.title);
+      const secondTitle = (typeof second.title === 'function' ? second.title() : second.title);
+      return firstTitle === secondTitle && first.block === second.block;
+    }
+    return false;
+  }
   // Caution: titles might be different function instances, which produce
   // the same value.
   // We prefer to use the i18nTitleKey to prevent against locale changes or
@@ -2493,6 +2621,7 @@ export function networkConditionsEqual(first: Conditions, second: Conditions): b
  * please talk to jacktfranklin@ first.
  */
 export const enum PredefinedThrottlingConditionKey {
+  BLOCKING = 'BLOCKING',
   NO_THROTTLING = 'NO_THROTTLING',
   OFFLINE = 'OFFLINE',
   SPEED_3G = 'SPEED_3G',
@@ -2525,6 +2654,15 @@ export function getPredefinedCondition(key: ThrottlingConditionKey): Conditions|
   return THROTTLING_CONDITIONS_LOOKUP.get(key) ?? null;
 }
 
+export function getPredefinedOrBlockingCondition(key: ThrottlingConditionKey): ThrottlingConditions|null {
+  return key === PredefinedThrottlingConditionKey.BLOCKING ? BlockingConditions : getPredefinedCondition(key);
+}
+
+export type ThrottlingConditions = Conditions|{
+  readonly key: ThrottlingConditionKey,
+  block: true,
+  title: string | (() => string),
+};
 export interface Conditions {
   readonly key: ThrottlingConditionKey;
   download: number;

package/front_end/core/sdk/SourceMap.ts

@@ -12,7 +12,7 @@ import type {CallFrame, ScopeChainEntry} from './DebuggerModel.js';
 import {scopeTreeForScript} from './ScopeTreeCache.js';
 import type {Script} from './Script.js';
 import {buildOriginalScopes, decodePastaRanges, type NamedFunctionRange} from './SourceMapFunctionRanges.js';
-import {SourceMapScopesInfo} from './SourceMapScopesInfo.js';
+import {SourceMapScopesInfo, type TranslatedFrame} from './SourceMapScopesInfo.js';
 
 /**
  * Type of the base source map JSON object, which contains the sources and the mappings at the very least, plus
@@ -789,6 +789,11 @@ export class SourceMap {
     this.#ensureSourceMapProcessed();
     return this.#scopesInfo?.hasInlinedFrames(generatedLine, generatedColumn) ?? false;
   }
+
+  translateCallSite(generatedLine: number, generatedColumn: number): TranslatedFrame[] {
+    this.#ensureSourceMapProcessed();
+    return this.#scopesInfo?.translateCallSite(generatedLine, generatedColumn) ?? [];
+  }
 }
 
 const VLQ_BASE_SHIFT = 5;

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -113,6 +113,10 @@ export class SourceMapScopesInfo {
    */
   isOutlinedFrame(generatedLine: number, generatedColumn: number): boolean {
     const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    return this.#isOutlinedFrame(rangeChain);
+  }
+
+  #isOutlinedFrame(rangeChain: ScopesCodec.GeneratedRange[]): boolean {
     for (let i = rangeChain.length - 1; i >= 0; --i) {
       if (rangeChain[i].isStackFrame) {
         return rangeChain[i].isHidden;
@@ -372,13 +376,7 @@ export class SourceMapScopesInfo {
               .at(-1);
     }
 
-    // Walk the original scope chain outwards until we find a function.
-    for (let originalScope = originalInnerMostScope; originalScope; originalScope = originalScope.parent) {
-      if (originalScope.isStackFrame) {
-        return originalScope.name ?? '';
-      }
-    }
-    return null;
+    return this.#findFunctionNameInOriginalScopeChain(originalInnerMostScope) ?? null;
   }
 
   /**
@@ -404,6 +402,74 @@ export class SourceMapScopesInfo {
 
     return result;
   }
+
+  #findFunctionNameInOriginalScopeChain(innerOriginalScope: ScopesCodec.OriginalScope|undefined): string|null {
+    for (let originalScope = innerOriginalScope; originalScope; originalScope = originalScope.parent) {
+      if (originalScope.isStackFrame) {
+        return originalScope.name ?? '';
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Returns one or more original stack frames for this single "raw frame" or call-site.
+   *
+   * @returns An empty array if no mapping at the call-site was found, or the resulting frames
+   * in top-to-bottom order in case of inlining.
+   * @throws If this range is marked "hidden". Outlining needs to be handled externally as
+   * outlined function segments in stack traces can span across bundles.
+   */
+  translateCallSite(generatedLine: number, generatedColumn: number): TranslatedFrame[] {
+    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    if (this.#isOutlinedFrame(rangeChain)) {
+      throw new Error('SourceMapScopesInfo is unable to translate an outlined function by itself');
+    }
+
+    const mapping = this.#sourceMap.findEntry(generatedLine, generatedColumn);
+    if (mapping?.sourceIndex === undefined) {
+      return [];
+    }
+
+    // The top-most frame is translated the same even if we have inlined functions.
+    const result: TranslatedFrame[] = [{
+      line: mapping.sourceLineNumber,
+      column: mapping.sourceColumnNumber,
+      name: this.findOriginalFunctionName({line: generatedLine, column: generatedColumn}) ?? undefined,
+      url: mapping.sourceURL,
+    }];
+
+    // Walk the range chain inside out until we find a generated function and for each inlined function add a frame.
+    for (let i = rangeChain.length - 1; i >= 0 && !rangeChain[i].isStackFrame; --i) {
+      const range = rangeChain[i];
+      if (!range.callSite) {
+        continue;
+      }
+
+      const originalScopeChain = this.#findOriginalScopeChain(range.callSite);
+      result.push({
+        line: range.callSite.line,
+        column: range.callSite.column,
+        name: this.#findFunctionNameInOriginalScopeChain(originalScopeChain.at(-1)) ?? undefined,
+        url: this.#sourceMap.sourceURLForSourceIndex(range.callSite.sourceIndex),
+      });
+    }
+
+    return result;
+  }
+}
+
+/**
+ * Represents a stack frame in original terms. It closely aligns with StackTrace.StackTrace.Frame,
+ * but since we can't import that type here we mirror it here somewhat.
+ *
+ * Equivalent to Pick<StackTrace.StackTrace.Frame, 'line'|'column'|'name'|'url'>.
+ */
+export interface TranslatedFrame {
+  line: number;
+  column: number;
+  name?: string;
+  url?: Platform.DevToolsPath.UrlString;
 }
 
 /**

package/front_end/entrypoints/main/main-meta.ts

@@ -6,6 +6,7 @@ import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import type * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Workspace from '../../models/workspace/workspace.js';
 import * as Components from '../../ui/legacy/components/utils/utils.js';
@@ -935,6 +936,7 @@ UI.Toolbar.registerToolbarItem({
 });
 
 UI.Toolbar.registerToolbarItem({
+  condition: () => !Root.Runtime.Runtime.isTraceApp(),
   async loadItem() {
     const Main = await loadMainModule();
     return Main.MainImpl.MainMenuItem.instance();

package/front_end/entrypoints/trace_app/trace_app.ts

@@ -18,6 +18,7 @@ import '../../panels/sources/sources-meta.js';
 // sdk/emulation depends on panels/sensors: crbug.com/1376652
 import '../../panels/sensors/sensors-meta.js';
 import '../../panels/timeline/timeline-meta.js';
+import '../../panels/ai_assistance/ai_assistance-meta.js';
 import '../../ui/legacy/components/perf_ui/perf_ui-meta.js';
 import '../../ui/legacy/components/quick_open/quick_open-meta.js';
 import '../../ui/legacy/components/source_frame/source_frame-meta.js';

package/front_end/generated/SupportedCSSProperties.js

@@ -3773,6 +3773,13 @@ export const generatedProperties = [
   ],
   "name": "rule-color"
  },
+ {
+  "longhands": [
+   "row-rule-outset",
+   "column-rule-outset"
+  ],
+  "name": "rule-outset"
+ },
  {
   "longhands": [
    "column-rule-style",

package/front_end/models/ai_assistance/data_formatters/PerformanceTraceFormatterBounds.snapshot.txt

@@ -0,0 +1,4 @@
+Title: PerformanceTraceFormatter serializeBounds works
+Content:
+{min: 1, max: 2}
+=== end content

package/front_end/models/ai_assistance/performance/AICallTree.ts

@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as Root from '../../../core/root/root.js';
 import * as Trace from '../../../models/trace/trace.js';
 import * as SourceMapsResolver from '../../../models/trace_source_maps_resolver/trace_source_maps_resolver.js';
 
@@ -144,7 +143,7 @@ export class AICallTree {
       return null;
     }
 
-    const allEventsEnabled = Root.Runtime.experiments.isEnabled('timeline-show-all-events');
+    const showAllEvents = parsedTrace.data.Meta.config.showAllEvents;
     const {startTime, endTime} = Trace.Helpers.Timing.eventTimingsMilliSeconds(selectedEvent);
     const selectedEventBounds = Trace.Helpers.Timing.traceWindowFromMicroSeconds(
         Trace.Helpers.Timing.milliToMicro(startTime), Trace.Helpers.Timing.milliToMicro(endTime));
@@ -166,7 +165,7 @@ export class AICallTree {
     // If the "Show all events" experiment is on, we don't filter out any
     // events here, otherwise the generated call tree will not match what the
     // user is seeing.
-    if (!allEventsEnabled) {
+    if (!showAllEvents) {
       filters.push(new Trace.Extras.TraceFilter.VisibleEventsFilter(Trace.Styles.visibleTypes()));
     }