chrome-devtools-frontend 1.0.1708524 → 1.0.1709383

package/front_end/core/sdk/OverlayModel.ts

@@ -662,6 +662,18 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
           color: Common.Color.PageHighlight.LayoutLine.toProtocolRGBA(),
         },
       };
+
+      highlightConfig.imcbHighlightConfig = {
+        imcbBorderColor: Common.Color.PageHighlight.AnchorIMCB.toProtocolRGBA(),
+        imcbBackgroundColor: Common.Color.PageHighlight.AnchorIMCBBackground.toProtocolRGBA(),
+        insetsBackgroundColor: Common.Color.PageHighlight.AnchorInsetsBackground.toProtocolRGBA(),
+        insetsHatchColor: Common.Color.PageHighlight.AnchorInsetsHatch.toProtocolRGBA(),
+        anchorBorderColor: Common.Color.PageHighlight.AnchorTarget.toProtocolRGBA(),
+        anchorBackgroundColor: Common.Color.PageHighlight.AnchorTargetBackground.toProtocolRGBA(),
+        showPositionAreaGrid: true,
+        positionAreaGridLineColor: Common.Color.PageHighlight.AnchorTarget.toProtocolRGBA(),
+        positionAreaActiveRegionColor: Common.Color.PageHighlight.AnchorTargetBackground.toProtocolRGBA(),
+      };
     }
 
     if (mode.endsWith('gap')) {
@@ -793,6 +805,41 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
       };
     }
 
+    const baseImcbHighlightConfig = {
+      imcbBorderColor: Common.Color.PageHighlight.AnchorIMCB.toProtocolRGBA(),
+      imcbBackgroundColor: Common.Color.PageHighlight.AnchorIMCBBackground.toProtocolRGBA(),
+      anchorBorderColor: Common.Color.PageHighlight.AnchorTarget.toProtocolRGBA(),
+      anchorBackgroundColor: Common.Color.PageHighlight.AnchorTargetBackground.toProtocolRGBA(),
+    };
+
+    if (mode === 'anchor-positioning') {
+      highlightConfig.imcbHighlightConfig = {
+        ...baseImcbHighlightConfig,
+        insetsBackgroundColor: Common.Color.PageHighlight.AnchorInsetsBackground.toProtocolRGBA(),
+        insetsHatchColor: Common.Color.PageHighlight.AnchorInsetsHatch.toProtocolRGBA(),
+        showPositionAreaGrid: true,
+        positionAreaGridLineColor: Common.Color.PageHighlight.AnchorTarget.toProtocolRGBA(),
+        positionAreaActiveRegionColor: Common.Color.PageHighlight.AnchorTargetBackground.toProtocolRGBA(),
+      };
+    }
+
+    if (mode === 'position-area') {
+      highlightConfig.imcbHighlightConfig = {
+        ...baseImcbHighlightConfig,
+        showPositionAreaGrid: true,
+        positionAreaGridLineColor: Common.Color.PageHighlight.AnchorTarget.toProtocolRGBA(),
+        positionAreaActiveRegionColor: Common.Color.PageHighlight.AnchorTargetBackground.toProtocolRGBA(),
+      };
+    }
+
+    if (mode === 'insets') {
+      highlightConfig.imcbHighlightConfig = {
+        ...baseImcbHighlightConfig,
+        insetsBackgroundColor: Common.Color.PageHighlight.AnchorInsetsBackground.toProtocolRGBA(),
+        insetsHatchColor: Common.Color.PageHighlight.AnchorInsetsHatch.toProtocolRGBA(),
+      };
+    }
+
     return highlightConfig;
   }
 

package/front_end/core/sdk/PageResourceLoader.ts

@@ -317,6 +317,29 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
     }
   }
 
+  #resolveFrameTarget(initiator: PageResourceLoadInitiator): {
+    frameTarget: Target|null,
+    frameId: Protocol.Page.FrameId|null,
+  } {
+    let frameTarget: Target|null = initiator.target;
+    let parentFrameId: Protocol.Page.FrameId|null = null;
+    while (frameTarget && !frameTarget.model(ResourceTreeModel)) {
+      parentFrameId = parentFrameId ?? frameTarget.targetInfo()?.parentFrameId ?? null;
+      frameTarget = frameTarget.parentTarget();
+    }
+    const frameId = initiator.frameId ?? parentFrameId ?? frameTarget?.model(ResourceTreeModel)?.mainFrame?.id ?? null;
+    return {frameTarget, frameId};
+  }
+
+  #isSameOriginWithPrimaryPage(frameTarget: Target|null, frameId: Protocol.Page.FrameId|null): boolean {
+    const primaryFrame = this.#targetManager.primaryPageTarget()?.model(ResourceTreeModel)?.mainFrame;
+    const initiatorFrame = frameId ? frameTarget?.model(ResourceTreeModel)?.frameForId(frameId) : null;
+    if (!primaryFrame || !initiatorFrame) {
+      return false;
+    }
+    return initiatorFrame.securityOrigin().isSameOriginWith(primaryFrame.securityOrigin());
+  }
+
   private async dispatchLoad(
       url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator, isBinary: boolean): Promise<{
     success: boolean,
@@ -343,11 +366,7 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
       // directive is present. A null/error response keeps the guard armed so that a
       // detached-frame or protocol-error path cannot fall through to loadFromHostBindings.
       let mustEnforceCSP = isHttp;
-      let frameTarget: Target|null = initiator.target;
-      while (frameTarget && !frameTarget.model(ResourceTreeModel)) {
-        frameTarget = frameTarget.parentTarget();
-      }
-      const frameId = initiator.frameId ?? frameTarget?.model(ResourceTreeModel)?.mainFrame?.id ?? null;
+      const {frameTarget, frameId} = this.#resolveFrameTarget(initiator);
       if (isHttp && frameTarget) {
         const networkManager = frameTarget.model(NetworkManager);
         if (networkManager) {
@@ -366,7 +385,8 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
       } catch (e) {
         if (e instanceof Error) {
           Host.userMetrics.developerResourceLoaded(Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_FAILURE);
-          if (mustEnforceCSP || e.message.includes('CSP violation')) {
+          if (mustEnforceCSP || !this.#isSameOriginWithPrimaryPage(frameTarget, frameId) ||
+              e.message.includes('CSP violation')) {
             return {
               success: false,
               content: '',

package/front_end/core/sdk/SourceMap.ts

@@ -12,7 +12,12 @@ import {scopeTreeForScript} from './ScopeTreeCache.js';
 import type {Script} from './Script.js';
 import {buildOriginalScopes, decodePastaRanges, type NamedFunctionRange} from './SourceMapFunctionRanges.js';
 import {decodeRangeMappings} from './SourceMapRangeMappings.js';
-import {type RawFrameTranslation, scriptRelativePosition, SourceMapScopesInfo} from './SourceMapScopesInfo.js';
+import {
+  type PositionRange,
+  type RawFrameTranslation,
+  scriptRelativePosition,
+  SourceMapScopesInfo,
+} from './SourceMapScopesInfo.js';
 
 /**
  * Type of the base source map JSON object, which contains the sources and the mappings at the very least, plus
@@ -250,6 +255,16 @@ export class SourceMap {
     return this.#scopesInfo !== null && !this.#scopesInfo.isEmpty();
   }
 
+  /**
+   * True iff the scopes come from the source map itself (encoded `scopes`), not from the AST fallback or from an
+   * extension.
+   */
+  hasEncodedScopeInfo(): boolean {
+    this.#ensureSourceMapProcessed();
+    return this.#scopesInfo !== null && this.#scopesFallbackPromise === undefined &&
+        this.#scopesInfo.hasGeneratedRanges();
+  }
+
   waitForScopeInfo(): Promise<void> {
     this.#ensureSourceMapProcessed();
     return this.#scopesFallbackPromise ?? Promise.resolve();
@@ -872,6 +887,28 @@ export class SourceMap {
     this.#ensureSourceMapProcessed();
     return this.#scopesInfo?.translateRawFrame(generatedLine, generatedColumn) ?? null;
   }
+
+  /** See {@link SourceMapScopesInfo.inlinedFunctionRange}. `null` without encoded scopes. */
+  inlinedFunctionRange(generatedLine: number, generatedColumn: number): PositionRange|null {
+    return this.hasEncodedScopeInfo() ? this.#scopesInfo?.inlinedFunctionRange(generatedLine, generatedColumn) ?? null :
+                                        null;
+  }
+
+  /** See {@link SourceMapScopesInfo.inlinedCalleeRanges}. Empty without encoded scopes. */
+  inlinedCalleeRanges(generatedLine: number, generatedColumn: number): PositionRange[] {
+    return this.hasEncodedScopeInfo() ? this.#scopesInfo?.inlinedCalleeRanges(generatedLine, generatedColumn) ?? [] :
+                                        [];
+  }
+
+  /** See {@link SourceMapScopesInfo.hasOutlinedFunctions}. False without encoded scopes. */
+  hasOutlinedFunctions(): boolean {
+    return this.hasEncodedScopeInfo() && (this.#scopesInfo?.hasOutlinedFunctions() ?? false);
+  }
+
+  /** See {@link SourceMapScopesInfo.artificialFunctionRanges}. Empty without encoded scopes. */
+  artificialFunctionRanges(): PositionRange[] {
+    return this.hasEncodedScopeInfo() ? this.#scopesInfo?.artificialFunctionRanges() ?? [] : [];
+  }
 }
 
 /** @returns a copy of the {@link entry} that is marked as a range mapping. */

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -215,6 +215,10 @@ export class SourceMapScopesInfo {
     return noScopes && !this.#generatedRanges.length;
   }
 
+  hasGeneratedRanges(): boolean {
+    return this.#generatedRanges.length > 0;
+  }
+
   addOriginalScopesAtIndex(sourceIdx: number, scopes: ScopesCodec.OriginalScope[]): void {
     if (!this.#originalScopes[sourceIdx]?.length) {
       this.#originalScopes[sourceIdx] = scopes;
@@ -561,6 +565,91 @@ export class SourceMapScopesInfo {
 
     return result;
   }
+
+  /**
+   * @returns the body of the innermost inlined function at the position (the innermost range with a `callSite`
+   *          within the generated function), or null if the position is not inside an inlined function.
+   *
+   * The innermost inlined function is the logical frame the position belongs to, i.e. the analogue of the top frame
+   * of a real call stack. Stepping over its body therefore goes up exactly one logical frame: into the caller, which
+   * may itself be inlined. An outer range would leave several logical frames at once.
+   */
+  inlinedFunctionRange(generatedLine: number, generatedColumn: number): PositionRange|null {
+    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    for (let i = rangeChain.length - 1; i >= 0 && !rangeChain[i].isStackFrame; --i) {
+      if (rangeChain[i].callSite) {
+        return {start: rangeChain[i].start, end: rangeChain[i].end};
+      }
+    }
+    return null;
+  }
+
+  /**
+   * @returns the bodies of all functions that were inlined directly into the logical function at the position
+   *          (the innermost inlined function, or else the generated function). Doesn't descend into inlined
+   *          functions or nested generated functions.
+   */
+  inlinedCalleeRanges(generatedLine: number, generatedColumn: number): PositionRange[] {
+    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    let body: ScopesCodec.GeneratedRange|undefined;
+    for (let i = rangeChain.length - 1; i >= 0 && !body; --i) {
+      if (rangeChain[i].callSite || rangeChain[i].isStackFrame) {
+        body = rangeChain[i];
+      }
+    }
+    const result: PositionRange[] = [];
+    (function walk(range: ScopesCodec.GeneratedRange) {
+      for (const child of range.children) {
+        if (child.isStackFrame) {
+          continue;
+        }
+        if (child.callSite) {
+          result.push({start: child.start, end: child.end});
+        } else {
+          walk(child);
+        }
+      }
+    })(body ?? {children: this.#generatedRanges} as ScopesCodec.GeneratedRange);
+    return result;
+  }
+
+  /**
+   * @returns true, iff any generated function is outlined, i.e. marked as "hidden" but with a definition (see
+   *          {@link GeneratedFrameKind.OUTLINED}). Hidden functions without a definition are compiler helpers.
+   */
+  hasOutlinedFunctions(): boolean {
+    const hasOutlined = (ranges: ScopesCodec.GeneratedRange[]): boolean =>
+        ranges.some(range => (range.isStackFrame && range.isHidden && range.originalScope !== undefined) ||
+                        hasOutlined(range.children));
+    return hasOutlined(this.#generatedRanges);
+  }
+
+  /**
+   * @returns the "artificial" generated functions (in the DWARF sense): functions that contain no authored code at all
+   *          (no original scope anywhere in their subtree), e.g. compiler helpers. Sorted by start position,
+   *          non-overlapping.
+   */
+  artificialFunctionRanges(): PositionRange[] {
+    const hasOriginalScope = (range: ScopesCodec.GeneratedRange): boolean =>
+        range.originalScope !== undefined || range.children.some(hasOriginalScope);
+    const result: PositionRange[] = [];
+    (function walk(ranges: ScopesCodec.GeneratedRange[]) {
+      for (const range of ranges) {
+        if (range.isStackFrame && !hasOriginalScope(range)) {
+          result.push({start: range.start, end: range.end});
+        } else {
+          walk(range.children);
+        }
+      }
+    })(this.#generatedRanges);
+    return result;
+  }
+}
+
+/** A range of generated positions, relative to the start of the script. `end` is exclusive. */
+export interface PositionRange {
+  readonly start: ScopesCodec.Position;
+  readonly end: ScopesCodec.Position;
 }
 
 /**

package/front_end/core/text_utils/TextUtils.ts

@@ -9,7 +9,7 @@ import {SearchMatch} from './ContentProvider.js';
 import type {Text} from './Text.js';
 
 const KEY_VALUE_FILTER_REGEXP = /(?:^|\s)(\-)?([\w\-]+):([^\s]+)/;
-const REGEXP_FILTER_REGEXP = /(?:^|\s)(\-)?\/([^\/\\]+(\\.[^\/]*)*)\//;
+const REGEXP_FILTER_REGEXP = /(?:^|\s)(\-)?\/((?:[^\/\\]|\\.)+)\//;
 const TEXT_FILTER_REGEXP = /(?:^|\s)(\-)?([^\s]+)/;
 const SPACE_CHAR_REGEXP = /\s/;
 

package/front_end/entrypoints/devtools_app/devtools_app.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.
 import '../shell/shell.js';
+import '../../panels/comments/comments-meta.js';
 import '../../panels/css_overview/css_overview-meta.js';
 import '../../panels/elements/elements-meta.js';
 import '../../panels/browser_debugger/browser_debugger-meta.js';

package/front_end/entrypoints/main/MainImpl.ts

@@ -223,8 +223,6 @@ export class MainImpl {
       this.#universe.settings.resolve(SDK.SDKSettings.cacheDisabledSettingDescriptor).setRequiresUserAction(true);
     }
 
-    Root.Runtime.experiments.removeAllExperimentsFromLocalStorage();
-
     await this.requestAndRegisterLocaleData();
 
     Host.userMetrics.syncSetting(
@@ -352,23 +350,10 @@ export class MainImpl {
     return {syncedStorage, globalStorage, localStorage};
   }
 
-  // TODO(crbug.com/464173054) remove after M156
-  #migrateValueFromLegacyExperiment(legacyExperimentName: Root.ExperimentNames.ExperimentName,
-                                    experiment: Root.Runtime.Experiment): void {
-    const value = Root.Runtime.experiments.getValueFromStorage(legacyExperimentName);
-    if (value !== undefined && experiment.aboutFlag) {
-      // Set the experiment to the same value as the legacy experiment.
-      experiment.setEnabled(value);
-      // Set the chrome flag to the same value as the legacy experiment.
-      Host.InspectorFrontendHost.InspectorFrontendHostInstance.setChromeFlag(experiment.aboutFlag, value);
-      // The legacy experiment will be cleaned up by `removeAllExperimentsFromLocalStorage`.
-    }
-  }
-
   #initializeExperiments(): void {
     const enableProtocolMonitor = (Root.Runtime.hostConfig.devToolsProtocolMonitor?.enabled ?? false) ||
         Boolean(Root.Runtime.Runtime.queryParam('isChromeForTesting'));
-    const protocolMonitorExperiment = Root.Runtime.experiments.register({
+    Root.Runtime.experiments.register({
       name: Root.ExperimentNames.ExperimentName.PROTOCOL_MONITOR,
       title: 'Protocol Monitor',
       aboutFlag: 'devtools-protocol-monitor',
@@ -377,19 +362,15 @@ export class MainImpl {
       docLink: 'https://developer.chrome.com/blog/new-in-devtools-92/#protocol-monitor' as
           Platform.DevToolsPath.UrlString,
     });
-    this.#migrateValueFromLegacyExperiment(Root.ExperimentNames.ExperimentName.PROTOCOL_MONITOR,
-                                           protocolMonitorExperiment);
 
     // Debugging
-    const instrumentationBreakpointsExperiment = Root.Runtime.experiments.register({
+    Root.Runtime.experiments.register({
       name: Root.ExperimentNames.ExperimentName.INSTRUMENTATION_BREAKPOINTS,
       title: 'Instrumentation breakpoints',
       aboutFlag: 'devtools-instrumentation-breakpoints',
       isEnabled: Root.Runtime.hostConfig.devToolsInstrumentationBreakpoints?.enabled ?? false,
       requiresChromeRestart: false,
     });
-    this.#migrateValueFromLegacyExperiment(Root.ExperimentNames.ExperimentName.INSTRUMENTATION_BREAKPOINTS,
-                                           instrumentationBreakpointsExperiment);
 
     Root.Runtime.experiments.register({
       name: Root.ExperimentNames.ExperimentName.DURABLE_MESSAGES,

package/front_end/generated/InspectorBackendCommands.ts

@@ -1520,6 +1520,7 @@ inspectorBackend.registerType("WebMCP.RemovedTool", [{"name": "name", "type": "s
 
 // Debugger.
 inspectorBackend.registerEnum("Debugger.ScopeType", {Global: "global", Local: "local", With: "with", Closure: "closure", Catch: "catch", Block: "block", Script: "script", Eval: "eval", Module: "module", WasmExpressionStack: "wasm-expression-stack"});
+inspectorBackend.registerEnum("Debugger.ScopeEmptyReason", {NoVariables: "no-variables", AllUnavailable: "all-unavailable"});
 inspectorBackend.registerEnum("Debugger.BreakLocationType", {DebuggerStatement: "debuggerStatement", Call: "call", Return: "return"});
 inspectorBackend.registerEnum("Debugger.ScriptLanguage", {JavaScript: "JavaScript", WebAssembly: "WebAssembly"});
 inspectorBackend.registerEnum("Debugger.DebugSymbolsType", {SourceMap: "SourceMap", EmbeddedDWARF: "EmbeddedDWARF", ExternalDWARF: "ExternalDWARF"});
@@ -1570,7 +1571,7 @@ inspectorBackend.registerType("Debugger.Location", [{"name": "scriptId", "type":
 inspectorBackend.registerType("Debugger.ScriptPosition", [{"name": "lineNumber", "type": "number", "optional": false, "description": "", "typeRef": null}, {"name": "columnNumber", "type": "number", "optional": false, "description": "", "typeRef": null}]);
 inspectorBackend.registerType("Debugger.LocationRange", [{"name": "scriptId", "type": "string", "optional": false, "description": "", "typeRef": "Runtime.ScriptId"}, {"name": "start", "type": "object", "optional": false, "description": "", "typeRef": "Debugger.ScriptPosition"}, {"name": "end", "type": "object", "optional": false, "description": "", "typeRef": "Debugger.ScriptPosition"}]);
 inspectorBackend.registerType("Debugger.CallFrame", [{"name": "callFrameId", "type": "string", "optional": false, "description": "Call frame identifier. This identifier is only valid while the virtual machine is paused.", "typeRef": "Debugger.CallFrameId"}, {"name": "functionName", "type": "string", "optional": false, "description": "Name of the JavaScript function called on this call frame.", "typeRef": null}, {"name": "functionLocation", "type": "object", "optional": true, "description": "Location in the source code.", "typeRef": "Debugger.Location"}, {"name": "location", "type": "object", "optional": false, "description": "Location in the source code.", "typeRef": "Debugger.Location"}, {"name": "url", "type": "string", "optional": false, "description": "JavaScript script name or url. Deprecated in favor of using the `location.scriptId` to resolve the URL via a previously sent `Debugger.scriptParsed` event.", "typeRef": null}, {"name": "scopeChain", "type": "array", "optional": false, "description": "Scope chain for this call frame.", "typeRef": "Debugger.Scope"}, {"name": "this", "type": "object", "optional": false, "description": "`this` object for this call frame.", "typeRef": "Runtime.RemoteObject"}, {"name": "returnValue", "type": "object", "optional": true, "description": "The value being returned, if the function is at return point.", "typeRef": "Runtime.RemoteObject"}, {"name": "canBeRestarted", "type": "boolean", "optional": true, "description": "Valid only while the VM is paused and indicates whether this frame can be restarted or not. Note that a `true` value here does not guarantee that Debugger#restartFrame with this CallFrameId will be successful, but it is very likely.", "typeRef": null}]);
-inspectorBackend.registerType("Debugger.Scope", [{"name": "type", "type": "string", "optional": false, "description": "Scope type.", "typeRef": null}, {"name": "object", "type": "object", "optional": false, "description": "Object representing the scope. For `global` and `with` scopes it represents the actual object; for the rest of the scopes, it is artificial transient object enumerating scope variables as its properties.", "typeRef": "Runtime.RemoteObject"}, {"name": "name", "type": "string", "optional": true, "description": "", "typeRef": null}, {"name": "startLocation", "type": "object", "optional": true, "description": "Location in the source code where scope starts", "typeRef": "Debugger.Location"}, {"name": "endLocation", "type": "object", "optional": true, "description": "Location in the source code where scope ends", "typeRef": "Debugger.Location"}, {"name": "empty", "type": "boolean", "optional": true, "description": "True if the scope does not declare any variables. Only present if true. Empty scopes are retained in the scope chain because they can be targeted via `evaluateOnCallFrame` (using `scopeNumber`) or matched against scopes in source maps.", "typeRef": null}]);
+inspectorBackend.registerType("Debugger.Scope", [{"name": "type", "type": "string", "optional": false, "description": "Scope type.", "typeRef": null}, {"name": "object", "type": "object", "optional": false, "description": "Object representing the scope. For `global` and `with` scopes it represents the actual object; for the rest of the scopes, it is artificial transient object enumerating scope variables as its properties.", "typeRef": "Runtime.RemoteObject"}, {"name": "name", "type": "string", "optional": true, "description": "", "typeRef": null}, {"name": "startLocation", "type": "object", "optional": true, "description": "Location in the source code where scope starts", "typeRef": "Debugger.Location"}, {"name": "endLocation", "type": "object", "optional": true, "description": "Location in the source code where scope ends", "typeRef": "Debugger.Location"}, {"name": "emptyReason", "type": "string", "optional": true, "description": "Present if the scope has no variable values to show. Absent means that the scope declares at least one variable with an available value. Empty scopes are retained in the scope chain because they can be targeted via `evaluateOnCallFrame` (using `scopeNumber`) or matched against scopes in source maps.", "typeRef": null}]);
 inspectorBackend.registerType("Debugger.SearchMatch", [{"name": "lineNumber", "type": "number", "optional": false, "description": "Line number in resource content.", "typeRef": null}, {"name": "lineContent", "type": "string", "optional": false, "description": "Line with match content.", "typeRef": null}]);
 inspectorBackend.registerType("Debugger.BreakLocation", [{"name": "scriptId", "type": "string", "optional": false, "description": "Script identifier as reported in the `Debugger.scriptParsed`.", "typeRef": "Runtime.ScriptId"}, {"name": "lineNumber", "type": "number", "optional": false, "description": "Line number in the script (0-based).", "typeRef": null}, {"name": "columnNumber", "type": "number", "optional": true, "description": "Column number in the script (0-based).", "typeRef": null}, {"name": "type", "type": "string", "optional": true, "description": "", "typeRef": null}]);
 inspectorBackend.registerType("Debugger.WasmDisassemblyChunk", [{"name": "lines", "type": "array", "optional": false, "description": "The next chunk of disassembled lines.", "typeRef": "string"}, {"name": "bytecodeOffsets", "type": "array", "optional": false, "description": "The bytecode offsets describing the start of each line.", "typeRef": "integer"}]);

package/front_end/generated/SupportedCSSProperties.ts

@@ -4313,7 +4313,7 @@ export const generatedProperties: CSSProperty[] = [
    "overlay"
   ],
   "name": "overscroll-container-type",
-  "runtime_flag": "OverscrollGestures",
+  "runtime_flag": "OverscrollAreas",
   "runtime_flag_status": "experimental"
  },
  {

package/front_end/generated/protocol.ts

@@ -20731,6 +20731,11 @@ export namespace Debugger {
     WasmExpressionStack = 'wasm-expression-stack',
   }
 
+  export const enum ScopeEmptyReason {
+    NoVariables = 'no-variables',
+    AllUnavailable = 'all-unavailable',
+  }
+
   /**
    * Scope description.
    */
@@ -20755,13 +20760,13 @@ export namespace Debugger {
      */
     endLocation?: Location;
     /**
-     * True if the scope does not declare any variables.
-     * Only present if true.
+     * Present if the scope has no variable values to show. Absent means that
+     * the scope declares at least one variable with an available value.
      * Empty scopes are retained in the scope chain because
      * they can be targeted via `evaluateOnCallFrame` (using `scopeNumber`) or
      * matched against scopes in source maps.
      */
-    empty?: boolean;
+    emptyReason?: ScopeEmptyReason;
   }
 
   /**

package/front_end/models/ai_assistance/AiAgent2.ts

@@ -13,13 +13,15 @@ import {
   type ContextResponse,
   type ConversationContext,
   type MultimodalInputType,
+  type ParsedResponse,
   type RequestOptions,
   ResponseType,
+  sanitizeSuggestions,
 } from './agents/AiAgent.js';
 import {type ExecuteJsAgentOptions, executeJsCode} from './agents/ExecuteJavascript.js';
 import {ChangeManager} from './ChangeManager.js';
-import {AccessibilityContext} from './contexts/AccessibilityContext.js';
 import {DOMNodeContext} from './contexts/DOMNodeContext.js';
+import {LighthouseContext} from './contexts/LighthouseContext.js';
 import {PerformanceTraceContext} from './contexts/PerformanceTraceContext.js';
 import {debugLog} from './debug.js';
 import {ExtensionScope} from './ExtensionScope.js';
@@ -85,6 +87,110 @@ export interface AiAgent2Options extends ExecuteJsAgentOptions {
   performanceRecordAndReload?: () => Promise<Trace.TraceModel.ParsedTrace>;
 }
 
+/**
+ * Matches the follow-up suggestions directive in plain uppercase, at the start
+ * of the line or after whitespace: `SUGGESTIONS: ["a"]`, `Done. SUGGESTIONS: ["a"]`.
+ * It is case-sensitive, so `Suggestions:` and `DEFAULT_SUGGESTIONS:` do not match.
+ * - Group 1: the text before the directive.
+ */
+const PLAIN_SUGGESTIONS_REGEX = /^(.*?)(?:^|\s)SUGGESTIONS:/;
+
+/**
+ * Matches any spelling of the follow-up suggestions directive that is followed
+ * by an array ending the line, for example `**Suggestions**: ["a"]`,
+ * `- suggestions: ["a"]` or `` `SUGGESTIONS`: ["a"] ``. The keyword is
+ * case-insensitive, must be at the start of the line or after whitespace, and
+ * can have up to three markdown characters (`*`, `_` or `` ` ``) on each side
+ * of it and of the colon. Only markdown characters or whitespace can follow the
+ * closing `]`, so `A few suggestions: [see docs](url)` does not match.
+ * - Group 1: the text before the directive. It is greedy, so the last keyword
+ *   on the line is used: `**Suggestions**: [1] Fix. SUGGESTIONS: ["a"]` keeps
+ *   `**Suggestions**: [1] Fix.` as answer text.
+ * - Group 2: the array, from the first `[` after the keyword to the last `]`.
+ */
+const FORMATTED_SUGGESTIONS_REGEX = /^(.*)(?:^|\s)[*_`]{0,3}suggestions[*_`]{0,3}:[*_`]{0,3}\s*`?(\[.*\])[*_`\s]*$/i;
+
+/**
+ * Matches the start of any spelling of the follow-up suggestions directive
+ * while it is streaming: the keyword in any case, at the start of the line or
+ * after whitespace, with optional markdown characters, followed by `:`. Nothing
+ * after the colon is checked, because the array may still be arriving.
+ * - Group 1: the text before the directive.
+ */
+const STREAMING_SUGGESTIONS_REGEX = /^(.*?)(?:^|\s)[*_`]{0,3}suggestions[*_`]{0,3}:/i;
+
+/**
+ * Matches a markdown list or heading marker on its own, such as `-`, `1.` or
+ * `###`. The marker is dropped when the directive was the only thing after it.
+ */
+const LIST_OR_HEADING_MARKER_REGEX = /^(?:[-*+]|\d+\.|#{1,6})$/;
+
+/**
+ * Returns the answer text with the directive removed from the last line.
+ * `textBeforeDirective` is what the last line contained before the directive.
+ */
+function removeDirectiveFromLastLine(lines: string[], textBeforeDirective: string): string {
+  const keptText = textBeforeDirective.trimEnd();
+  const lastLine = LIST_OR_HEADING_MARKER_REGEX.test(keptText.trim()) ? '' : keptText;
+  return [...lines.slice(0, -1), lastLine].join('\n').trimEnd();
+}
+
+/**
+ * Parses the JSON array of a suggestions directive. Returns `null` if `array`
+ * is not valid JSON, and `{suggestions: undefined}` if it is valid but holds no
+ * usable suggestions.
+ */
+function parseSuggestionsArray(array: string): {suggestions: [string, ...string[]]|undefined}|null {
+  try {
+    return {suggestions: sanitizeSuggestions(array)};
+  } catch {
+    // Invalid JSON: the caller decides whether the line is still a directive.
+    return null;
+  }
+}
+
+/**
+ * Parses a completed response. Only the last line can be the follow-up
+ * suggestions directive; every other line is always kept as answer text.
+ * 1. If any spelling of the directive is followed by a valid JSON array that
+ *    ends the line, it is removed and the array becomes the suggestions.
+ * 2. Otherwise, if the line contains `SUGGESTIONS:` in plain uppercase, it is
+ *    removed from the keyword onward even though the array is missing or not
+ *    valid JSON, and no suggestions are returned.
+ * 3. Otherwise, the line is kept unchanged.
+ * Text before the directive on the same line is kept.
+ */
+function parseCompletedSuggestions(text: string): ParsedResponse {
+  const lines = text.split('\n');
+  const lastLine = lines[lines.length - 1];
+
+  const formatted = lastLine.match(FORMATTED_SUGGESTIONS_REGEX);
+  const parsedArray = formatted ? parseSuggestionsArray(formatted[2]) : null;
+  if (formatted && parsedArray) {
+    const answer = removeDirectiveFromLastLine(lines, formatted[1]);
+    return parsedArray.suggestions ? {answer, suggestions: parsedArray.suggestions} : {answer};
+  }
+
+  const plain = lastLine.match(PLAIN_SUGGESTIONS_REGEX);
+  if (plain) {
+    return {answer: removeDirectiveFromLastLine(lines, plain[1])};
+  }
+
+  return {answer: text};
+}
+
+/**
+ * Hides a follow-up suggestions directive that is still streaming on the last
+ * line, from the keyword onward, without looking at its array. Hiding text by
+ * mistake is temporary: the completed response is parsed again by
+ * `parseCompletedSuggestions()`.
+ */
+function hideStreamingSuggestions(text: string): string {
+  const lines = text.split('\n');
+  const match = lines[lines.length - 1].match(STREAMING_SUGGESTIONS_REGEX);
+  return match ? removeDirectiveFromLastLine(lines, match[1]) : text;
+}
+
 export class AiAgent2 extends AiAgent<unknown> {
   // TODO: The static preamble is a placeholder and will eventually live server-side.
   readonly preamble: string = preamble;
@@ -236,6 +342,22 @@ Do NOT call \`learnSkills\` for skills that are already loaded.
 User query: ${enhancedQuery}`;
   }
 
+  /**
+   * Parses a completed response. Only the last line can be the follow-up
+   * suggestions directive. See `parseCompletedSuggestions()`.
+   */
+  override parseTextResponse(response: string): ParsedResponse {
+    return parseCompletedSuggestions(response.trim());
+  }
+
+  /**
+   * Parses a response that is still streaming, hiding a suggestions directive
+   * on the last line. See `hideStreamingSuggestions()`.
+   */
+  protected override parsePartialTextResponse(response: string): ParsedResponse {
+    return {answer: hideStreamingSuggestions(response.trim())};
+  }
+
   override async *
       handleContextDetails(selected: ConversationContext<unknown>|null): AsyncGenerator<ContextResponse, void, void> {
     if (selected) {
@@ -311,6 +433,8 @@ User query: ${enhancedQuery}`;
       description: tool.description,
       parameters: tool.parameters,
       displayInfoFromArgs: tool.displayInfoFromArgs,
+      permissionPrompt: tool.permissionPrompt,
+      permissionTitle: tool.permissionTitle,
       handler: (args, options) => {
         const context: AllToolsCapabilities = {
           changeManager: this.#changes,
@@ -319,7 +443,7 @@ User query: ${enhancedQuery}`;
           getExecutionContextNode: () => this.#getExecutionContextNode(),
           getTarget: () => this.#getTarget(),
           getOriginLock: () => this.#originLock(),
-          getLighthouseReport: () => (this.context instanceof AccessibilityContext ? this.context.getItem() : null),
+          getLighthouseReport: () => (this.context instanceof LighthouseContext ? this.context.getItem() : null),
           runLighthouse: async overrides => await (this.#lighthouseRecording?.(overrides) ?? null),
           getPerformanceTraceContext: () => (this.context instanceof PerformanceTraceContext ? this.context : null),
           performanceRecordAndReload: this.#performanceRecordAndReload,

package/front_end/models/ai_assistance/AiConversation.ts

@@ -33,9 +33,9 @@ import {AiAgent2} from './AiAgent2.js';
 import {AiHistoryStorage, ConversationType, type SerializedConversation} from './AiHistoryStorage.js';
 import {isContextSelectionEnabled} from './AiUtils.js';
 import type {ChangeManager} from './ChangeManager.js';
-import {AccessibilityContext} from './contexts/AccessibilityContext.js';
 import {DOMNodeContext} from './contexts/DOMNodeContext.js';
 import {FileContext} from './contexts/FileContext.js';
+import {LighthouseContext} from './contexts/LighthouseContext.js';
 import {PerformanceTraceContext} from './contexts/PerformanceTraceContext.js';
 import {RequestContext} from './contexts/RequestContext.js';
 import {StorageContext} from './contexts/StorageContext.js';
@@ -207,7 +207,7 @@ export class AiConversation {
         this.#updateAgent(ConversationType.NETWORK);
       } else if (updateContext instanceof PerformanceTraceContext) {
         this.#updateAgent(ConversationType.PERFORMANCE);
-      } else if (updateContext instanceof AccessibilityContext) {
+      } else if (updateContext instanceof LighthouseContext) {
         this.#updateAgent(ConversationType.ACCESSIBILITY);
       } else if (updateContext instanceof StorageContext) {
         this.#updateAgent(ConversationType.STORAGE);

package/front_end/models/ai_assistance/AiUtils.ts

@@ -122,6 +122,10 @@ export function isGeminiBranding(): boolean {
   return !!Root.Runtime.hostConfig.devToolsGeminiRebranding?.enabled;
 }
 
+export function isNaturalLanguageInterfaceEnabled(): boolean {
+  return Boolean(Root.Runtime.hostConfig.devToolsAiNaturalLanguageInterface?.enabled);
+}
+
 /**
  * Returns true if context selection / dynamic context switching is enabled.
  *