chrome-devtools-frontend 1.0.1528866 → 1.0.1529904

package/front_end/core/common/Gzip.ts

@@ -49,16 +49,18 @@ export async function compress(str: string): Promise<ArrayBuffer> {
 }
 
 /** Private coder/decoder **/
-function gzipCodec(buffer: Uint8Array<ArrayBufferLike>|ArrayBuffer, codecStream: CompressionStream|DecompressionStream):
-    Promise<ArrayBuffer> {
-  const {readable, writable} = new TransformStream();
+async function gzipCodec(
+    buffer: Uint8Array<ArrayBufferLike>|ArrayBuffer,
+    codecStream: CompressionStream|DecompressionStream): Promise<ArrayBuffer> {
+  const readable = new ReadableStream({
+    start(controller) {
+      controller.enqueue(buffer);
+      controller.close();
+    }
+  });
   const codecReadable = readable.pipeThrough(codecStream);
-
-  const writer = writable.getWriter();
-  void writer.write(buffer);
-  void writer.close();
   // A response is a convenient way to get an ArrayBuffer from a ReadableStream.
-  return new Response(codecReadable).arrayBuffer();
+  return await new Response(codecReadable).arrayBuffer();
 }
 
 export function decompressStream(stream: ReadableStream): ReadableStream {

package/front_end/core/host/UserMetrics.ts

@@ -514,7 +514,8 @@ export enum Action {
   AiCodeCompletionSuggestionAccepted = 187,
   AiCodeCompletionError = 188,
   AttributeLinkClicked = 189,
-  MAX_VALUE = 190,
+  InsightRequestedViaTeaser = 190,
+  MAX_VALUE = 191,
   /* eslint-enable @typescript-eslint/naming-convention */
 }
 

package/front_end/core/root/Runtime.ts

@@ -527,6 +527,14 @@ interface AiPromptApi {
   enabled: boolean;
 }
 
+interface DevToolsIndividualRequestThrottling {
+  enabled: boolean;
+}
+
+export interface DevToolsEnableDurableMessages {
+  enabled: boolean;
+}
+
 /**
  * The host configuration that we expect from the DevTools back-end.
  *
@@ -554,6 +562,7 @@ export type HostConfig = Platform.TypeScriptUtilities.RecursivePartial<{
   devToolsVeLogging: HostConfigVeLogging,
   devToolsWellKnown: HostConfigWellKnown,
   devToolsPrivacyUI: HostConfigPrivacyUI,
+  devToolsIndividualRequestThrottling: DevToolsIndividualRequestThrottling,
   devToolsIpProtectionPanelInDevTools: HostConfigIPProtection,
   /**
    * OffTheRecord here indicates that the user's profile is either incognito,
@@ -574,6 +583,7 @@ export type HostConfig = Platform.TypeScriptUtilities.RecursivePartial<{
   devToolsFlexibleLayout: DevToolsFlexibleLayout,
   devToolsStartingStyleDebugging: DevToolsStartingStyleDebugging,
   devToolsAiPromptApi: AiPromptApi,
+  devToolsEnableDurableMessages: DevToolsEnableDurableMessages,
 }>;
 
 /**

package/front_end/core/sdk/NetworkManager.ts

@@ -165,6 +165,8 @@ export class NetworkManager extends SDKModel<EventTypes> {
 
     void this.#networkAgent.invoke_enable({
       maxPostDataSize: MAX_EAGER_POST_REQUEST_BODY_LENGTH,
+      enableDurableMessages: Root.Runtime.hostConfig.devToolsEnableDurableMessages?.enabled,
+      maxTotalBufferSize: MAX_RESPONSE_BODY_TOTAL_BUFFER_LENGTH,
       reportDirectSocketTraffic: true,
     });
     void this.#networkAgent.invoke_setAttachDebugStack({enabled: true});
@@ -520,6 +522,7 @@ export const Fast4GConditions: Conditions = {
 };
 
 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 {
   readonly #fetchAgent: ProtocolProxyApi.FetchApi;
@@ -1553,10 +1556,13 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
   }
 }
 
-interface RequestConditionsSetting {
-  url: string;
-  enabled: boolean;
-}
+type RequestConditionsSetting = {
+  url: string,
+  enabled: boolean,
+}|{
+  urlPattern: URLPatternConstructorString,
+  enabled: boolean,
+};
 
 declare global {
   // TS typedefs are not up to date
@@ -1621,34 +1627,62 @@ export class RequestURLPattern {
 
     return tryCreate(pattern)  // try as is
         ??
-        // Try upgrade paths for patterns created from the network panel, which either blocks the full url (sans
+        // Try to upgrade patterns created from the network panel, which either blocks the full url (sans
         // protocol) or just the domain name. In both cases the wildcard patterns had implicit wildcards at the end.
-        // The first case is the full url option, which we detect by the presence of '/'. the second case is the
-        // domain name only option.
-        (pattern.includes('/')  // If the pattern includes a '/' we consider this the full-url case
-             ?
-             tryCreate(`*://${pattern}*`)  // Append a wildcard, since the pathname will be parsed from the pattern.
-             :
-             tryCreate(`*://${pattern}`));  // The pathname is empty, which automatically makes it a wildcard.
+        // We explicitly add that here, which will match both domain names without path (implicitly setting pathname
+        // to '*') and urls with path (appending * to the pathname).
+        tryCreate(`*://${pattern}*`);
   }
 }
 
 export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<RequestCondition.EventTypes> {
-  #url: string;
+  #pattern: RequestURLPattern|{wildcardURL: string, upgradedPattern?: RequestURLPattern};
   #enabled: boolean;
 
   constructor(setting: RequestConditionsSetting) {
     super();
-    this.#url = setting.url;
+    if ('urlPattern' in setting) {
+      this.#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
+      };
+    }
     this.#enabled = setting.enabled;
   }
 
-  get url(): string {
-    return this.#url;
+  get constructorString(): string|undefined {
+    return this.#pattern instanceof RequestURLPattern ? this.#pattern.constructorString :
+                                                        this.#pattern.upgradedPattern?.constructorString;
+  }
+
+  get wildcardURL(): string|undefined {
+    return 'wildcardURL' in this.#pattern ? this.#pattern.wildcardURL : undefined;
+  }
+
+  get constructorStringOrWildcardURL(): string {
+    return this.#pattern instanceof RequestURLPattern ?
+        this.#pattern.constructorString :
+        (this.#pattern.upgradedPattern?.constructorString ?? this.#pattern.wildcardURL);
   }
 
-  set url(url: string) {
-    this.#url = url;
+  set pattern(pattern: RequestURLPattern|string) {
+    if (typeof pattern === 'string') {
+      // TODO(pfaffe) Remove once the feature flag is no longer required
+      if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+        throw new Error('Should not use wildcard urls');
+      }
+      this.#pattern = {
+        wildcardURL: pattern,
+        upgradedPattern: RequestURLPattern.upgradeFromWildcard(pattern) ?? undefined
+      };
+    } else {
+      this.#pattern = pattern;
+    }
     this.dispatchEventToListeners(RequestCondition.Events.REQUEST_CONDITION_CHANGED);
   }
 
@@ -1662,8 +1696,13 @@ export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<Request
   }
 
   toSetting(): RequestConditionsSetting {
-    const {url, enabled} = this;
-    return {url, enabled};
+    const enabled = this.enabled;
+    return this.#pattern instanceof RequestURLPattern ? {enabled, urlPattern: this.#pattern.constructorString} :
+                                                        {enabled, url: this.#pattern.wildcardURL};
+  }
+
+  get originalOrUpgradedURLPattern(): URLPattern|undefined {
+    return this.#pattern instanceof RequestURLPattern ? this.#pattern.pattern : this.#pattern.upgradedPattern?.pattern;
   }
 }
 
@@ -1671,6 +1710,7 @@ export namespace RequestCondition {
   export const enum Events {
     REQUEST_CONDITION_CHANGED = 'request-condition-changed',
   }
+
   export interface EventTypes {
     [Events.REQUEST_CONDITION_CHANGED]: void;
   }
@@ -1693,8 +1733,15 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
     return this.#conditions.length;
   }
 
+  findCondition(pattern: string): RequestCondition|undefined {
+    if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+      return this.#conditions.find(condition => condition.constructorString === pattern);
+    }
+    return this.#conditions.find(condition => condition.wildcardURL === pattern);
+  }
+
   has(url: string): boolean {
-    return Boolean(this.#conditions.find(condition => condition.url === url));
+    return Boolean(this.findCondition(url));
   }
 
   add(...conditions: RequestCondition[]): void {
@@ -1729,12 +1776,22 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
     return this.#conditions.values();
   }
 
-  * blockedURLPatterns(): Generator<string> {
-    for (const condition of this.#conditions) {
-      if (condition.enabled) {
-        yield condition.url;
+  applyConditions(...agents: ProtocolProxyApi.NetworkApi[]): boolean {
+    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}));
+
+      for (const agent of agents) {
+        void agent.invoke_setBlockedURLs({urlPatterns});
       }
+      return urlPatterns.length > 0;
+    }
+    const urls = this.#conditions.filter(condition => condition.enabled && condition.wildcardURL)
+                     .map(condition => condition.wildcardURL as string);
+    for (const agent of agents) {
+      void agent.invoke_setBlockedURLs({urls});
     }
+    return urls.length > 0;
   }
 }
 
@@ -1847,10 +1904,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
       void networkAgent.invoke_setUserAgentOverride(
           {userAgent: this.currentUserAgent(), userAgentMetadata: this.#userAgentMetadataOverride || undefined});
     }
-    const blockedURLs = this.#requestConditions.blockedURLPatterns().toArray();
-    if (blockedURLs.length) {
-      void networkAgent.invoke_setBlockedURLs({urls: blockedURLs});
-    }
+    this.#requestConditions.applyConditions(networkAgent);
     if (this.isIntercepting()) {
       void fetchAgent.invoke_enable({patterns: this.#urlsForRequestInterceptor.valuesArray()});
     }
@@ -2006,7 +2060,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
    * @deprecated Kept for layout tests
    * TODO(pfaffe) remove
    */
-  setBlockedPatterns(patterns: Array<{url: string, enabled: boolean}>): void {
+  private setBlockedPatterns(patterns: Array<{url: string, enabled: boolean}>): void {
     this.requestConditions.clear();
     this.requestConditions.add(...patterns.map(pattern => new RequestCondition(pattern)));
   }
@@ -2019,11 +2073,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   private updateBlockedPatterns(): void {
-    const urls = this.#requestConditions.blockedURLPatterns().toArray();
-    this.#isBlocking = urls.length > 0;
-    for (const agent of this.#networkAgents) {
-      void agent.invoke_setBlockedURLs({urls});
-    }
+    this.#isBlocking = this.#requestConditions.applyConditions(...this.#networkAgents);
   }
 
   isIntercepting(): boolean {

package/front_end/core/sdk/SourceMap.ts

@@ -205,6 +205,10 @@ export class SourceMap {
     return this.#debugId ?? null;
   }
 
+  sourceURLForSourceIndex(index: number): Platform.DevToolsPath.UrlString|undefined {
+    return this.#sourceInfos[index]?.sourceURL;
+  }
+
   sourceURLs(): Platform.DevToolsPath.UrlString[] {
     return [...this.#sourceInfoByURL.keys()];
   }
@@ -775,6 +779,16 @@ export class SourceMap {
     this.#ensureSourceMapProcessed();
     return this.#scopesInfo?.findOriginalFunctionName(position) ?? null;
   }
+
+  isOutlinedFrame(generatedLine: number, generatedColumn: number): boolean {
+    this.#ensureSourceMapProcessed();
+    return this.#scopesInfo?.isOutlinedFrame(generatedLine, generatedColumn) ?? false;
+  }
+
+  hasInlinedFrames(generatedLine: number, generatedColumn: number): boolean {
+    this.#ensureSourceMapProcessed();
+    return this.#scopesInfo?.hasInlinedFrames(generatedLine, generatedColumn) ?? false;
+  }
 }
 
 const VLQ_BASE_SHIFT = 5;

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -6,6 +6,7 @@ import * as Protocol from '../../generated/protocol.js';
 import * as Formatter from '../../models/formatter/formatter.js';
 import type * as TextUtils from '../../models/text_utils/text_utils.js';
 import type * as ScopesCodec from '../../third_party/source-map-scopes-codec/source-map-scopes-codec.js';
+import type * as Platform from '../platform/platform.js';
 
 import type {CallFrame, ScopeChainEntry} from './DebuggerModel.js';
 import type {SourceMap} from './SourceMap.js';
@@ -120,6 +121,24 @@ export class SourceMapScopesInfo {
     return false;
   }
 
+  /**
+   * @returns true, iff the range surrounding the provided position contains multiple
+   * inlined original functions.
+   */
+  hasInlinedFrames(generatedLine: number, generatedColumn: number): boolean {
+    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    for (let i = rangeChain.length - 1; i >= 0; --i) {
+      if (rangeChain[i].isStackFrame) {
+        // We stop looking for inlined original functions once we reach the current frame.
+        return false;
+      }
+      if (rangeChain[i].callSite) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Given a generated position, returns the original name of the surrounding function as well as
    * all the original function names that got inlined into the surrounding generated function and their
@@ -142,7 +161,10 @@ export class SourceMapScopesInfo {
 
       if (range.callSite) {
         // Record the name and call-site if the range corresponds to an inlined function.
-        result.inlinedFunctions.push({name: range.originalScope?.name ?? '', callsite: range.callSite});
+        result.inlinedFunctions.push({
+          name: range.originalScope?.name ?? '',
+          callsite: {...range.callSite, sourceURL: this.#sourceMap.sourceURLForSourceIndex(range.callSite.sourceIndex)}
+        });
       }
       if (range.isStackFrame) {
         // We arrived at an actual generated JS function, don't go further.
@@ -394,7 +416,15 @@ export class SourceMapScopesInfo {
  * The inlined functions are sorted from inner to outer (or top to bottom on the stack).
  */
 export interface InlineInfo {
-  inlinedFunctions: Array<{name: string, callsite: ScopesCodec.OriginalPosition}>;
+  inlinedFunctions: Array<{
+    name: string,
+    callsite: {
+      line: number,
+      column: number,
+      sourceIndex: number,
+      sourceURL?: Platform.DevToolsPath.UrlString,
+    },
+  }>;
   originalFunctionName: string;
 }
 

package/front_end/entrypoints/main/MainImpl.ts

@@ -54,7 +54,7 @@ import * as Logs from '../../models/logs/logs.js';
 import * as Persistence from '../../models/persistence/persistence.js';
 import * as ProjectSettings from '../../models/project_settings/project_settings.js';
 import * as Workspace from '../../models/workspace/workspace.js';
-import type * as PanelCommon from '../../panels/common/common.js';
+import * as PanelCommon from '../../panels/common/common.js';
 import * as Snippets from '../../panels/snippets/snippets.js';
 import * as Buttons from '../../ui/components/buttons/buttons.js';
 import * as Snackbar from '../../ui/components/snackbars/snackbars.js';
@@ -120,6 +120,10 @@ const UIStrings = {
    * @description Text describing how to navigate the dock side menu
    */
   dockSideNavigation: 'Use left and right arrow keys to navigate the options',
+  /**
+   * @description Notification shown to the user whenever DevTools receives an external request.
+   */
+  externalRequestReceived: '`DevTools` received an external request',
 } as const;
 const str_ = i18n.i18n.registerUIStrings('entrypoints/main/MainImpl.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
@@ -476,11 +480,13 @@ export class MainImpl {
     isolatedFileSystemManager.addPlatformFileSystem(
         'snippet://' as Platform.DevToolsPath.UrlString, new Snippets.ScriptSnippetFileSystem.SnippetFileSystem());
 
-    Persistence.Persistence.PersistenceImpl.instance({
+    const persistenceImpl = Persistence.Persistence.PersistenceImpl.instance({
       forceNew: true,
       workspace: Workspace.Workspace.WorkspaceImpl.instance(),
       breakpointManager: Breakpoints.BreakpointManager.BreakpointManager.instance(),
     });
+    const linkDecorator = new PanelCommon.PersistenceUtils.LinkDecorator(persistenceImpl);
+    Components.Linkifier.Linkifier.setLinkDecorator(linkDecorator);
     Persistence.NetworkPersistenceManager.NetworkPersistenceManager.instance(
         {forceNew: true, workspace: Workspace.Workspace.WorkspaceImpl.instance()});
 
@@ -541,6 +547,14 @@ export class MainImpl {
       });
     }
 
+    const conversationHandler = AiAssistanceModel.ConversationHandler.ConversationHandler.instance();
+    conversationHandler.addEventListener(
+        AiAssistanceModel.ConversationHandler.ConversationHandlerEvents.EXTERNAL_REQUEST_RECEIVED,
+        () => Snackbar.Snackbar.Snackbar.show({message: i18nString(UIStrings.externalRequestReceived)}));
+    conversationHandler.addEventListener(
+        AiAssistanceModel.ConversationHandler.ConversationHandlerEvents.EXTERNAL_CONVERSATION_STARTED,
+        event => void VisualLogging.logFunctionCall(`start-conversation-${event.data}`, 'external'));
+
     MainImpl.timeEnd('Main._createAppUI');
 
     const appProvider = Common.AppProvider.getRegisteredAppProviders()[0];
@@ -570,7 +584,12 @@ export class MainImpl {
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(
         Host.InspectorFrontendHostAPI.Events.RevealSourceLine, this.#revealSourceLine, this);
 
-    await UI.InspectorView.InspectorView.instance().createToolbars();
+    const inspectorView = UI.InspectorView.InspectorView.instance();
+    Persistence.NetworkPersistenceManager.NetworkPersistenceManager.instance().addEventListener(
+        Persistence.NetworkPersistenceManager.Events.LOCAL_OVERRIDES_REQUESTED, event => {
+          inspectorView.displaySelectOverrideFolderInfobar(event.data);
+        });
+    await inspectorView.createToolbars();
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.loadCompleted();
 
     // Initialize elements for the live announcer functionality for a11y.
@@ -1100,7 +1119,7 @@ export async function handleExternalRequestGenerator(input: ExternalRequestInput
     }
     case 'NETWORK_DEBUGGER': {
       const AiAssistanceModel = await import('../../models/ai_assistance/ai_assistance.js');
-      const conversationHandler = await AiAssistanceModel.ConversationHandler.ConversationHandler.instance();
+      const conversationHandler = AiAssistanceModel.ConversationHandler.ConversationHandler.instance();
       return await conversationHandler.handleExternalRequest({
         conversationType: AiAssistanceModel.AiHistoryStorage.ConversationType.NETWORK,
         prompt: input.args.prompt,

package/front_end/generated/SupportedCSSProperties.js

@@ -3759,6 +3759,13 @@ export const generatedProperties = [
   ],
   "name": "rule"
  },
+ {
+  "longhands": [
+   "row-rule-break",
+   "column-rule-break"
+  ],
+  "name": "rule-break"
+ },
  {
   "longhands": [
    "column-rule-color",
@@ -4375,6 +4382,7 @@ export const generatedProperties = [
    "capitalize",
    "uppercase",
    "lowercase",
+   "full-width",
    "none",
    "math-auto"
   ],
@@ -6803,6 +6811,7 @@ export const generatedPropertyValues = {
    "capitalize",
    "uppercase",
    "lowercase",
+   "full-width",
    "none",
    "math-auto"
   ]

package/front_end/models/ai_assistance/BuiltInAi.ts

@@ -22,7 +22,7 @@ const RESPONSE_SCHEMA = {
   additionalProperties: false,
 };
 
-interface LanguageModel {
+export interface LanguageModel {
   promptStreaming: (arg0: string, opts?: {
     responseConstraint: Object,
     signal?: AbortSignal,

package/front_end/models/ai_assistance/ConversationHandler.ts

@@ -8,8 +8,6 @@ import * as i18n from '../../core/i18n/i18n.js';
 import * 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 Snackbars from '../../ui/components/snackbars/snackbars.js';
-import * as VisualLogging from '../../ui/visual_logging/visual_logging.js';
 import * as NetworkTimeCalculator from '../network_time_calculator/network_time_calculator.js';
 
 import {
@@ -55,13 +53,6 @@ export interface ExternalPerformanceRequestParameters {
   data: ExternalPerformanceAIConversationData;
 }
 
-const UIStrings = {
-  /**
-   * @description Notification shown to the user whenever DevTools receives an external request.
-   */
-  externalRequestReceived: '`DevTools` received an external request',
-} as const;
-
 /*
 * Strings that don't need to be translated at this time.
 */
@@ -72,8 +63,6 @@ const UIStringsNotTranslate = {
   enableInSettings: 'For AI features to be available, you need to enable AI assistance in DevTools settings.',
 } as const;
 
-const str_ = i18n.i18n.registerUIStrings('models/ai_assistance/ConversationHandler.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 const lockedString = i18n.i18n.lockedString;
 
 function isAiAssistanceServerSideLoggingEnabled(): boolean {
@@ -124,13 +113,14 @@ async function inspectNetworkRequestByUrl(selector: string): Promise<SDK.Network
 
 let conversationHandlerInstance: ConversationHandler|undefined;
 
-export class ConversationHandler {
+export class ConversationHandler extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   #aiAssistanceEnabledSetting: Common.Settings.Setting<boolean>|undefined;
   #aidaClient: Host.AidaClient.AidaClient;
   #aidaAvailability?: Host.AidaClient.AidaAccessPreconditions;
 
   private constructor(
       aidaClient: Host.AidaClient.AidaClient, aidaAvailability?: Host.AidaClient.AidaAccessPreconditions) {
+    super();
     this.#aidaClient = aidaClient;
     if (aidaAvailability) {
       this.#aidaAvailability = aidaAvailability;
@@ -186,7 +176,7 @@ export class ConversationHandler {
       ExternalPerformanceRequestParameters,
       ): Promise<AsyncGenerator<ExternalRequestResponse, ExternalRequestResponse>> {
     try {
-      Snackbars.Snackbar.Snackbar.show({message: i18nString(UIStrings.externalRequestReceived)});
+      this.dispatchEventToListeners(ConversationHandlerEvents.EXTERNAL_REQUEST_RECEIVED);
       const disabledReasons = await this.#getDisabledReasons();
       const aiAssistanceSetting = this.#aiAssistanceEnabledSetting?.getIfNotDisabled();
       if (!aiAssistanceSetting) {
@@ -196,7 +186,8 @@ export class ConversationHandler {
         return this.#generateErrorResponse(disabledReasons.join(' '));
       }
 
-      void VisualLogging.logFunctionCall(`start-conversation-${parameters.conversationType}`, 'external');
+      this.dispatchEventToListeners(
+          ConversationHandlerEvents.EXTERNAL_CONVERSATION_STARTED, parameters.conversationType);
       switch (parameters.conversationType) {
         case ConversationType.STYLING: {
           return await this.#handleExternalStylingConversation(parameters.prompt, parameters.selector);
@@ -356,3 +347,13 @@ export class ConversationHandler {
     return agent;
   }
 }
+
+export const enum ConversationHandlerEvents {
+  EXTERNAL_REQUEST_RECEIVED = 'ExternalRequestReceived',
+  EXTERNAL_CONVERSATION_STARTED = 'ExternalConversationStarted',
+}
+
+export interface EventTypes {
+  [ConversationHandlerEvents.EXTERNAL_REQUEST_RECEIVED]: void;
+  [ConversationHandlerEvents.EXTERNAL_CONVERSATION_STARTED]: ConversationType;
+}

package/front_end/models/bindings/CompilerScriptMapping.ts

@@ -5,7 +5,8 @@
 import * as Common from '../../core/common/common.js';
 import * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
-import type * as StackTraceImpl from '../stack_trace/stack_trace_impl.js';
+// eslint-disable-next-line rulesdir/es-modules-import
+import * as StackTraceImpl from '../stack_trace/stack_trace_impl.js';
 import * as TextUtils from '../text_utils/text_utils.js';
 import * as Workspace from '../workspace/workspace.js';
 
@@ -43,12 +44,14 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
   readonly #sourceMapToProject = new Map<SDK.SourceMap.SourceMap, ContentProviderBasedProject>();
   readonly #uiSourceCodeToSourceMaps =
       new Platform.MapUtilities.Multimap<Workspace.UISourceCode.UISourceCode, SDK.SourceMap.SourceMap>();
+  readonly #debuggerModel: SDK.DebuggerModel.DebuggerModel;
 
   constructor(
       debuggerModel: SDK.DebuggerModel.DebuggerModel, workspace: Workspace.Workspace.WorkspaceImpl,
       debuggerWorkspaceBinding: DebuggerWorkspaceBinding) {
     this.#sourceMapManager = debuggerModel.sourceMapManager();
     this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
+    this.#debuggerModel = debuggerModel;
 
     this.#stubProject = new ContentProviderBasedProject(
         workspace, 'jsSourceMaps:stub:' + debuggerModel.target().id(), Workspace.Workspace.projectTypes.Service, '',
@@ -266,9 +269,56 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
   }
 
   translateRawFramesStep(
-      _rawFrames: StackTraceImpl.Trie.RawFrame[],
-      _translatedFrames: Awaited<ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames>>): boolean {
-    // TODO(crbug.com/433162438): Implement source map stack trace translation.
+      rawFrames: StackTraceImpl.Trie.RawFrame[],
+      translatedFrames: Awaited<ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames>>): boolean {
+    const frame = rawFrames[0];
+    if (StackTraceImpl.Trie.isBuiltinFrame(frame)) {
+      return false;
+    }
+
+    const sourceMapWithScopeInfoForFrame =
+        (rawFrame: StackTraceImpl.Trie.RawFrame): {sourceMap: SDK.SourceMap.SourceMap, script: SDK.Script.Script}|
+        null => {
+          const script = this.#debuggerModel.scriptForId(rawFrame.scriptId ?? '');
+          if (!script || this.#stubUISourceCodes.has(script)) {
+            // Use fallback while source map is being loaded.
+            return null;
+          }
+
+          const sourceMap = script.sourceMap();
+          return sourceMap?.hasScopeInfo() ? {sourceMap, script} : null;
+        };
+
+    const sourceMapAndScript = sourceMapWithScopeInfoForFrame(frame);
+    if (!sourceMapAndScript) {
+      return false;
+    }
+    const {sourceMap, script} = sourceMapAndScript;
+    const {lineNumber, columnNumber} = script.relativeLocationToRawLocation(frame);
+
+    if (!sourceMap.hasInlinedFrames(lineNumber, columnNumber) && !sourceMap.isOutlinedFrame(lineNumber, columnNumber)) {
+      // No outlining or inlining: Get the original function name and map the call-site.
+      const mapping = sourceMap.findEntry(lineNumber, columnNumber);
+      if (!mapping?.sourceURL) {
+        return false;
+      }
+
+      const originalName = sourceMap.findOriginalFunctionName({line: lineNumber, column: columnNumber});
+      rawFrames.shift();
+      const project = this.#sourceMapToProject.get(sourceMap);
+      const uiSourceCode = project?.uiSourceCodeForURL(mapping.sourceURL);
+      translatedFrames.push([{
+        line: mapping.sourceLineNumber,
+        column: mapping.sourceColumnNumber,
+        name: originalName ?? undefined,
+        uiSourceCode: uiSourceCode ?? undefined,
+        url: uiSourceCode ? undefined : mapping.sourceURL
+      }]);
+      return true;
+    }
+
+    // TODO(crbug.com/433162438): Expand inlined frames.
+    // TODO(crbug.com/433162438): Consolidate outlined frames.
     return false;
   }
 

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -8439,6 +8439,14 @@ export const NativeFunctions = [
     name: "sendPackets",
     signatures: [["packets"]]
   },
+  {
+    name: "addRemoteCandidate",
+    signatures: [["candidate"]]
+  },
+  {
+    name: "setRemoteDtlsParameters",
+    signatures: [["params"]]
+  },
   {
     name: "revoke",
     signatures: [["permission"]]