chrome-devtools-frontend 1.0.1706026 → 1.0.1708524

package/front_end/models/ai_assistance/tools/RunLighthouse.ts

@@ -4,7 +4,7 @@
 
 import * as Host from '../../../core/host/host.js';
 import type * as LHModel from '../../lighthouse/lighthouse.js';
-import {LighthouseFormatter} from '../data_formatters/LighthouseFormatter.js';
+import {type LighthouseCategoryArg, LighthouseFormatter} from '../data_formatters/LighthouseFormatter.js';
 
 import {
   type BaseToolCapability,
@@ -17,7 +17,7 @@ import {
 
 export interface RunLighthouseArgs extends ToolArgs {
   explanation: string;
-  categoryId: LHModel.RunTypes.CategoryId;
+  categoryId: LighthouseCategoryArg;
   mode?: LHModel.RunTypes.RunMode;
 }
 
@@ -39,7 +39,9 @@ export class RunLighthouseTool implements
       },
       categoryId: {
         type: Host.AidaClient.ParametersTypes.STRING,
-        description: 'Lighthouse category. E.g. "accessibility", "performance".',
+        // The experimental 'agentic-browsing' category is intentionally omitted from the prompt description so the agent does not invoke it unprompted. It is also excluded when 'all' is provided.
+        description:
+            'Lighthouse category. Use "all" to run all categories, or specify a category: "accessibility", "performance", "best-practices", "seo".',
         nullable: false,
       },
       mode: {
@@ -64,16 +66,17 @@ export class RunLighthouseTool implements
       Promise<DataHandlerResult<{audits: string}>> {
     const mode = params.mode ?? 'snapshot';
     try {
+      // Passing undefined for categoryIds instructs the Lighthouse runner to audit all categories supported by the mode when isAIControlled is true.
       const report = await context.runLighthouse({
         mode,
-        categoryIds: [params.categoryId],
+        categoryIds: params.categoryId === 'all' ? undefined : [params.categoryId],
         isAIControlled: true,
       });
       if (!report) {
         return {error: 'Error: Failed to record new audits.'};
       }
 
-      const audits = new LighthouseFormatter().audits(report, params.categoryId);
+      const audits = new LighthouseFormatter().formatReport(report, params.categoryId);
       const isSnapshot = mode === 'snapshot';
       return {
         result: {audits},

package/front_end/models/bindings/CompilerScriptMapping.ts

@@ -75,6 +75,11 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
       ranges: SDK.SourceMapFunctionRanges.NamedFunctionRange[]): void {
     for (const sourceMap of this.#uiSourceCodeToSourceMaps.get(uiSourceCode)) {
       sourceMap.augmentWithScopes(uiSourceCode.url(), ranges);
+      // The scopes information changed, so stack traces of the script need to be re-translated.
+      const script = this.#sourceMapManager.clientForSourceMap(sourceMap);
+      if (script) {
+        void this.#debuggerWorkspaceBinding.updateLocations(script);
+      }
     }
   }
 
@@ -96,6 +101,11 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
     }
   }
 
+  /** @returns whether `uiSourceCode` is a placeholder for a script whose source map is still loading. */
+  isStubUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
+    return uiSourceCode.project() === this.#stubProject;
+  }
+
   getLocationRangesForSameSourceLocation(rawLocation: SDK.DebuggerModel.Location): SDK.DebuggerModel.LocationRange[] {
     const debuggerModel = rawLocation.debuggerModel;
     const script = rawLocation.script();
@@ -322,60 +332,92 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
     return new Workspace.UISourceCode.UIFunctionBounds(uiSourceCode, range, name);
   }
 
-  async translateRawFramesStep(
-      rawFrames: StackTraceImpl.Trie.RawFrame[],
-      translatedFrames: Awaited<ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames>>): Promise<boolean> {
-    const frame = rawFrames[0];
-    if (StackTraceImpl.Trie.isBuiltinFrame(frame)) {
-      return false;
+  /**
+   * Translates a raw frame using the "scopes" information of its script's source map. Frames of compiler helpers
+   * are dropped (see {@link SDK.SourceMapScopesInfo.GeneratedFrameKind}).
+   *
+   * Outlined frames are merged at read time by the stack_trace model (see `consolidate`). The function keys
+   * tell it which authored function the top and bottom frames of a translation belong to. A frame at an
+   * unmapped position still gets its keys from the generated ranges; it shows the generated location, named
+   * after the authored function.
+   *
+   * @returns null if the raw frame can't be translated via "scopes" information, e.g. because the script doesn't
+   * have a source map (with scopes information), the source map is still loading, or neither mappings nor
+   * generated ranges know the position. It's then left to the default mapping.
+   */
+  async translateRawFrame(rawFrame: StackTraceImpl.Trie.RawFrame):
+      Promise<StackTraceImpl.StackTraceModel.TranslatedRawFrame|null> {
+    const translation = await this.#scopesTranslation(rawFrame);
+    if (!translation) {
+      return null;
+    }
+    if (translation.kind === SDK.SourceMapScopesInfo.GeneratedFrameKind.HIDDEN) {
+      // Compiler helpers don't represent any authored code.
+      return {kind: StackTraceImpl.Trie.FrameKind.HIDDEN, frames: []};
+    }
+    const {frames} = translation;
+    if (!frames.length) {
+      return null;
     }
+    return {
+      kind: translation.kind === SDK.SourceMapScopesInfo.GeneratedFrameKind.OUTLINED ?
+          StackTraceImpl.Trie.FrameKind.OUTLINED :
+          StackTraceImpl.Trie.FrameKind.VISIBLE,
+      frames: await this.#toUIFrames(translation, rawFrame),
+      functionKeys: {top: functionKey(frames[0]), bottom: functionKey(frames[frames.length - 1])},
+    };
+  }
 
-    const sourceMapWithScopeInfoForFrame = async(rawFrame: StackTraceImpl.Trie.RawFrame):
-        Promise<{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;
-          }
+  /** The raw translation of `rawFrame` by the "scopes" information of its script's source map, if any. */
+  async #scopesTranslation(rawFrame: StackTraceImpl.Trie.RawFrame): Promise<ScopesTranslation|null> {
+    if (StackTraceImpl.Trie.isBuiltinFrame(rawFrame)) {
+      return null;
+    }
 
-          const sourceMap = script.sourceMap();
-          await sourceMap?.waitForScopeInfo();
-          return sourceMap?.hasScopeInfo() ? {sourceMap, 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 sourceMapAndScript = await sourceMapWithScopeInfoForFrame(frame);
-    if (!sourceMapAndScript) {
-      return false;
+    const sourceMap = script.sourceMap();
+    await sourceMap?.waitForScopeInfo();
+    if (!sourceMap?.hasScopeInfo()) {
+      return null;
     }
-    const {sourceMap, script} = sourceMapAndScript;
-    const {lineNumber, columnNumber} = script.rawLocationToRelativeLocation(frame);
 
-    if (!sourceMap.isOutlinedFrame(lineNumber, columnNumber)) {
-      const frames = sourceMap.translateCallSite(lineNumber, columnNumber);
-      if (!frames.length) {
-        return false;
-      }
+    const {lineNumber, columnNumber} = script.rawLocationToRelativeLocation(rawFrame);
+    const translation = sourceMap.translateRawFrame(lineNumber, columnNumber);
+    return translation ? {...translation, sourceMap, script} : null;
+  }
 
-      rawFrames.shift();
-      const result: typeof translatedFrames[0] = [];
-      translatedFrames.push(result);
-
-      const project = this.#sourceMapToProject.get(sourceMap);
-      for (const frame of frames) {
-        // Switch out url for UISourceCode where we have it.
-        const uiSourceCode = frame.url ? project?.uiSourceCodeForURL(frame.url) : undefined;
-        result.push({
-          ...frame,
-          url: uiSourceCode ? undefined : frame.url,
-          uiSourceCode: uiSourceCode ?? undefined,
-        });
+  /**
+   * Switch out url for UISourceCode where we have it. A top frame without position (unmapped generated position)
+   * gets the generated location of `rawFrame`.
+   */
+  async #toUIFrames({sourceMap, script, frames}: ScopesTranslation, rawFrame: StackTraceImpl.Trie.RawFrame):
+      Promise<StackTraceImpl.StackTraceModel.TranslatedUIFrame[]> {
+    const project = this.#sourceMapToProject.get(sourceMap);
+    return await Promise.all(frames.map(async ({line, column, name, url}) => {
+      if (line === undefined || column === undefined) {
+        return {...await this.#generatedUIFrame(script, rawFrame), name};
       }
+      const uiSourceCode = url ? project?.uiSourceCodeForURL(url) : undefined;
+      return {line, column, name, url: uiSourceCode ? undefined : url, uiSourceCode: uiSourceCode ?? undefined};
+    }));
+  }
 
-      return true;
-    }
-
-    // TODO(crbug.com/433162438): Consolidate outlined frames.
-    return false;
+  /** The location of `rawFrame` in terms of the generated `script`, as the non-compiler mappings would show it. */
+  async #generatedUIFrame(script: SDK.Script.Script, rawFrame: StackTraceImpl.Trie.RawFrame):
+      Promise<StackTraceImpl.StackTraceModel.TranslatedUIFrame> {
+    const rawLocation = this.#debuggerModel.createRawLocation(script, rawFrame.lineNumber, rawFrame.columnNumber);
+    // Goes through the DebuggerWorkspaceBinding so that e.g. inline scripts resolve to their document.
+    const uiLocation = await this.#debuggerWorkspaceBinding.rawLocationToUILocation(rawLocation);
+    if (uiLocation) {
+      const {uiSourceCode, lineNumber: line, columnNumber} = uiLocation;
+      return {uiSourceCode, line, column: columnNumber ?? -1};
+    }
+    return {url: rawFrame.url, line: rawFrame.lineNumber, column: rawFrame.columnNumber};
   }
 
   /**
@@ -594,3 +636,18 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
     this.#stubProject.dispose();
   }
 }
+
+type ScopesTranslation = SDK.SourceMapScopesInfo.RawFrameTranslation&{
+  sourceMap: SDK.SourceMap.SourceMap,
+  script: SDK.Script.Script,
+};
+
+/**
+ * Identifies the authored function of a translated frame. The frames can originate from different source maps
+ * (bundles), so we can't compare original scopes directly. The start position tells apart anonymous and
+ * same-named functions in one file. All top-level code of a file shares a key.
+ */
+function functionKey(frame: SDK.SourceMapScopesInfo.TranslatedFrame): string {
+  const start = frame.functionStart ? `${frame.functionStart.line}:${frame.functionStart.column}` : '';
+  return `${frame.url ?? ''}\n${frame.name ?? ''}\n${start}`;
+}

package/front_end/models/bindings/DebuggerLanguagePlugins.ts

@@ -12,7 +12,7 @@ import * as TextUtils from '../../core/text_utils/text_utils.js';
 import * as Protocol from '../../generated/protocol.js';
 import * as StackTrace from '../stack_trace/stack_trace.js';
 // eslint-disable-next-line @devtools/es-modules-import
-import type * as StackTraceImpl from '../stack_trace/stack_trace_impl.js';
+import * as StackTraceImpl from '../stack_trace/stack_trace_impl.js';
 import * as Workspace from '../workspace/workspace.js';
 
 import {ContentProviderBasedProject} from './ContentProviderBasedProject.js';
@@ -166,7 +166,8 @@ class SourceScopeRemoteObject extends SDK.RemoteObject.RemoteObjectImpl {
     }
 
     const properties = [];
-    const namespaces: Record<string, SDK.RemoteObject.RemoteObject> = {};
+    const namespaces: Record<string, SDK.RemoteObject.RemoteObject> =
+        Object.create(null) as Record<string, SDK.RemoteObject.RemoteObject>;
 
     function makeProperty(name: string, obj: SDK.RemoteObject.RemoteObject): SDK.RemoteObject.RemoteObjectProperty {
       return new SDK.RemoteObject.RemoteObjectProperty(
@@ -190,7 +191,7 @@ class SourceScopeRemoteObject extends SDK.RemoteObject.RemoteObjectImpl {
           const nestedName = variable.nestedName[index];
           let child: NamespaceObject|SDK.RemoteObject.RemoteObject = parent[nestedName];
           if (!child) {
-            child = new NamespaceObject({});
+            child = new NamespaceObject(Object.create(null));
             parent[nestedName] = child;
           }
           parent = child.value;
@@ -561,6 +562,9 @@ export class DebuggerLanguagePluginManager implements
       // new instance of the #plugin added before we remove
       // the previous instance.
       this.parsedScriptSource({data: script});
+      if (!this.hasPluginForScript(script)) {
+        void this.#debuggerWorkspaceBinding.updateLocations(script);
+      }
     }
   }
 
@@ -731,25 +735,24 @@ export class DebuggerLanguagePluginManager implements
     return ranges;
   }
 
-  async translateRawFramesStep(
-      rawFrames: StackTraceImpl.Trie.RawFrame[],
-      translatedFrames: Awaited<ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames>>,
-      target: SDK.Target.Target): Promise<boolean> {
-    const frame = rawFrames[0];
+  /**
+   * Translates a raw frame via the language plugin responsible for its script.
+   *
+   * @returns null if no plugin is responsible for the frame. Otherwise the frame is translated, either
+   * successfully, or identity mapped with the "missing debug info details" attached.
+   */
+  async translateRawFrame(frame: StackTraceImpl.Trie.RawFrame,
+                          target: SDK.Target.Target): Promise<StackTraceImpl.StackTraceModel.TranslatedRawFrame|null> {
     const script = target.model(SDK.DebuggerModel.DebuggerModel)?.scriptForId(frame.scriptId ?? '');
     if (!script) {
-      return false;
+      return null;
     }
 
     const functionInfo = await this.getFunctionInfo(script, frame);
     if (!functionInfo) {
-      return false;
+      return null;
     }
 
-    // The plugin is responsible for translating this frame. The only question is whether it was successful,
-    // or if we identity map the raw frame and attach the "missing debug info details".
-    rawFrames.shift();
-
     if ('frames' in functionInfo && functionInfo.frames.length) {
       const framePromises = functionInfo.frames.map(async ({name}, index) => {
         const rawLocation = new SDK.DebuggerModel.Location(
@@ -758,8 +761,7 @@ export class DebuggerLanguagePluginManager implements
         return translatedFromUILocation(uiLocation, name, frame);
       });
 
-      translatedFrames.push(await Promise.all(framePromises));
-      return true;
+      return {kind: StackTraceImpl.Trie.FrameKind.VISIBLE, frames: await Promise.all(framePromises), unmapped: false};
     }
 
     // Translate the location only. We go through via "DebuggerWorkspaceBinding". It'll still try the plugin
@@ -768,28 +770,18 @@ export class DebuggerLanguagePluginManager implements
         new SDK.DebuggerModel.Location(script.debuggerModel, script.scriptId, frame.lineNumber, frame.columnNumber));
     const mappedFrame = translatedFromUILocation(uiLocation, frame.functionName, frame);
 
-    if ('missingSymbolFiles' in functionInfo && functionInfo.missingSymbolFiles.length) {
-      translatedFrames.push([{
-        ...mappedFrame,
-        missingDebugInfo: {
+    const missingDebugInfo: StackTrace.StackTrace.MissingDebugInfo =
+        'missingSymbolFiles' in functionInfo && functionInfo.missingSymbolFiles.length ?
+        {
           type: StackTrace.StackTrace.MissingDebugInfoType.PARTIAL_INFO,
           missingDebugFiles: functionInfo.missingSymbolFiles,
-        },
-      }]);
-    } else {
-      translatedFrames.push([{
-        ...mappedFrame,
-        missingDebugInfo: {
-          type: StackTrace.StackTrace.MissingDebugInfoType.NO_INFO,
-        },
-      }]);
-    }
-
-    return true;
+        } :
+        {type: StackTrace.StackTrace.MissingDebugInfoType.NO_INFO};
+    return {kind: StackTraceImpl.Trie.FrameKind.VISIBLE, frames: [{...mappedFrame, missingDebugInfo}], unmapped: true};
 
     function translatedFromUILocation(
         uiLocation: Workspace.UISourceCode.UILocation|null, name: string|undefined,
-        fallback: StackTraceImpl.Trie.RawFrame): (typeof translatedFrames)[number][number] {
+        fallback: StackTraceImpl.Trie.RawFrame): StackTraceImpl.StackTraceModel.TranslatedUIFrame {
       if (uiLocation) {
         return {
           uiSourceCode: uiLocation.uiSourceCode,

package/front_end/models/bindings/DebuggerWorkspaceBinding.ts

@@ -517,32 +517,29 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
 
   async #translateRawFrames(frames: readonly StackTraceImpl.Trie.RawFrame[], target: SDK.Target.Target):
       ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames> {
-    const rawFrames = frames.slice(0);
-    const translatedFrames: Awaited<ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames>> = [];
-    while (rawFrames.length) {
-      await this.#translateRawFramesStep(rawFrames, translatedFrames, target);
-    }
-    return translatedFrames;
+    return await Promise.all(frames.map(frame => this.#translateRawFrame(frame, target)));
   }
 
-  async #translateRawFramesStep(
-      rawFrames: StackTraceImpl.Trie.RawFrame[],
-      translatedFrames: Awaited<ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames>>,
-      target: SDK.Target.Target): Promise<void> {
-    if (await this.pluginManager.translateRawFramesStep(rawFrames, translatedFrames, target)) {
-      return;
+  /** Translates a single raw frame: language plugins first, then the script mappings of the frame's debugger model. */
+  async #translateRawFrame(frame: StackTraceImpl.Trie.RawFrame,
+                           target: SDK.Target.Target): Promise<StackTraceImpl.StackTraceModel.TranslatedRawFrame> {
+    const pluginTranslation = await this.pluginManager.translateRawFrame(frame, target);
+    if (pluginTranslation) {
+      return pluginTranslation;
     }
 
     const modelData =
         this.#debuggerModelToData.get(target.model(SDK.DebuggerModel.DebuggerModel) as SDK.DebuggerModel.DebuggerModel);
     if (modelData) {
-      await modelData.translateRawFramesStep(rawFrames, translatedFrames);
-      return;
+      return await modelData.translateRawFrame(frame);
     }
 
-    const frame = rawFrames.shift() as StackTraceImpl.Trie.RawFrame;
     const {url, lineNumber, columnNumber, functionName} = frame;
-    translatedFrames.push([{url, line: lineNumber, column: columnNumber, name: functionName}]);
+    return {
+      kind: StackTraceImpl.Trie.FrameKind.VISIBLE,
+      frames: [{url, line: lineNumber, column: columnNumber, name: functionName}],
+      unmapped: true,
+    };
   }
 }
 
@@ -592,8 +589,12 @@ class ModelData {
   }
 
   rawLocationToUILocation(rawLocation: SDK.DebuggerModel.Location): Workspace.UISourceCode.UILocation|null {
-    let uiLocation = this.compilerMapping.rawLocationToUILocation(rawLocation);
-    uiLocation = uiLocation || this.#resourceScriptMapping.rawLocationToUILocation(rawLocation);
+    return this.compilerMapping.rawLocationToUILocation(rawLocation) ||
+        this.#nonCompilerRawLocationToUILocation(rawLocation);
+  }
+
+  #nonCompilerRawLocationToUILocation(rawLocation: SDK.DebuggerModel.Location): Workspace.UISourceCode.UILocation|null {
+    let uiLocation = this.#resourceScriptMapping.rawLocationToUILocation(rawLocation);
     uiLocation = uiLocation || this.#resourceMapping.jsLocationToUILocation(rawLocation);
     uiLocation = uiLocation || this.#defaultMapping.rawLocationToUILocation(rawLocation);
     return uiLocation;
@@ -646,37 +647,30 @@ class ModelData {
     return scope;
   }
 
-  async translateRawFramesStep(
-      rawFrames: StackTraceImpl.Trie.RawFrame[],
-      translatedFrames: Awaited<ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames>>): Promise<void> {
-    if (!await this.compilerMapping.translateRawFramesStep(rawFrames, translatedFrames)) {
-      this.#defaultTranslateRawFramesStep(rawFrames, translatedFrames);
-    }
+  async translateRawFrame(frame: StackTraceImpl.Trie.RawFrame):
+      Promise<StackTraceImpl.StackTraceModel.TranslatedRawFrame> {
+    return await this.compilerMapping.translateRawFrame(frame) ?? this.#defaultTranslateRawFrame(frame);
   }
 
-  /** The default implementation translates one frame at a time and only translates the location, but not the function name. */
-  #defaultTranslateRawFramesStep(
-      rawFrames: StackTraceImpl.Trie.RawFrame[],
-      translatedFrames: Awaited<ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames>>): void {
-    const frame = rawFrames.shift() as StackTraceImpl.Trie.RawFrame;
+  /** The default translation only translates the location, but not the function name. */
+  #defaultTranslateRawFrame(frame: StackTraceImpl.Trie.RawFrame): StackTraceImpl.StackTraceModel.TranslatedRawFrame {
     const {scriptId, url, lineNumber, columnNumber, functionName} = frame;
     const rawLocation = scriptId ? this.#debuggerModel.createRawLocationByScriptId(scriptId, lineNumber, columnNumber) :
         url                      ? this.#debuggerModel.createRawLocationByURL(url, lineNumber, columnNumber) :
                                    null;
-    if (rawLocation) {
-      const uiLocation = this.rawLocationToUILocation(rawLocation);
-      if (uiLocation) {
-        translatedFrames.push([{
+    const mapped = rawLocation && this.compilerMapping.rawLocationToUILocation(rawLocation);
+    // A stub UISourceCode shows the generated script while its source map is loading.
+    const unmapped = !mapped || this.compilerMapping.isStubUISourceCode(mapped.uiSourceCode);
+    const uiLocation = mapped || (rawLocation && this.#nonCompilerRawLocationToUILocation(rawLocation));
+    const translatedFrame: StackTraceImpl.StackTraceModel.TranslatedUIFrame = uiLocation ?
+        {
           uiSourceCode: uiLocation.uiSourceCode,
           name: functionName,
           line: uiLocation.lineNumber,
           column: uiLocation.columnNumber ?? -1,
-        }]);
-        return;
-      }
-    }
-
-    translatedFrames.push([{url, line: lineNumber, column: columnNumber, name: functionName}]);
+        } :
+        {url, line: lineNumber, column: columnNumber, name: functionName};
+    return {kind: StackTraceImpl.Trie.FrameKind.VISIBLE, frames: [translatedFrame], unmapped};
   }
 
   getMappedLines(uiSourceCode: Workspace.UISourceCode.UISourceCode): Set<number>|null {

package/front_end/models/bindings/StylesSourceMapping.ts

@@ -176,6 +176,9 @@ export class StyleFile implements TextUtils.ContentProvider.ContentProvider {
     this.uiSourceCode = this.#project.createUISourceCode(url, header.contentType());
     uiSourceCodeToStyleMap.set(this.uiSourceCode, this);
     NetworkProject.setInitialFrameAttribution(this.uiSourceCode, header.frameId);
+    if (header.hasSourceURL) {
+      NetworkProject.setSourceURLSynthesized(this.uiSourceCode);
+    }
     this.#project.addUISourceCodeWithProvider(this.uiSourceCode, this, metadata, 'text/css');
 
     this.#eventListeners = [

package/front_end/models/extensions/ExtensionEndpoint.ts

@@ -14,6 +14,13 @@ interface EventMessage {
   event: string;
 }
 
+interface Message {
+  data: Response|EventMessage;
+}
+type ResultValidator<T> = (result: unknown) => result is T;
+
+const isUndefined = (result: unknown): result is undefined => result === undefined;
+
 export class ExtensionEndpoint {
   private readonly port: Platform.HostRuntime.WorkerMessagePort;
   private nextRequestId = 0;
@@ -24,16 +31,30 @@ export class ExtensionEndpoint {
 
   constructor(port: Platform.HostRuntime.WorkerMessagePort) {
     this.port = port;
-    this.port.addEventListener('message', (event: unknown) => this.onResponse(event as MessageEvent));
+    this.port.addEventListener('message', (event: unknown) => this.onResponse(event as Message));
     (this.port as {start?: () => void}).start?.();
     (this.port as {unref?: () => void}).unref?.();
     this.pendingRequests = new Map();
   }
 
-  sendRequest<ReturnType>(method: string, parameters: unknown): Promise<ReturnType> {
-    return new Promise((resolve, reject) => {
+  sendRequest(method: string, parameters: unknown): Promise<void>;
+  sendRequest<ReturnType>(method: string, parameters: unknown,
+                          validate: ResultValidator<ReturnType>): Promise<ReturnType>;
+  sendRequest<ReturnType>(method: string, parameters: unknown,
+                          validate: ResultValidator<ReturnType>|
+                          ResultValidator<undefined> = isUndefined): Promise<ReturnType|void> {
+    return new Promise<ReturnType|void>((resolve, reject) => {
       const requestId = this.nextRequestId++;
-      this.pendingRequests.set(requestId, {resolve: resolve as (arg: unknown) => void, reject});
+      this.pendingRequests.set(requestId, {
+        resolve: (result: unknown) => {
+          if (!validate(result)) {
+            reject(new Error(`Extension returned malformed ${method} result`));
+            return;
+          }
+          resolve(result);
+        },
+        reject,
+      });
       this.port.postMessage({requestId, method, parameters});
     });
   }
@@ -46,8 +67,8 @@ export class ExtensionEndpoint {
     this.port.close();
   }
 
-  private onResponse(event: MessageEvent): void {
-    const data = event.data as Response | EventMessage;
+  private onResponse(event: Message): void {
+    const data = event.data;
     if ('event' in data) {
       this.handleEvent(data);
       return;