chrome-devtools-frontend 1.0.1545096 → 1.0.1547571

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -26,35 +26,114 @@ export class SourceMapScopesInfo {
   }
 
   /**
-   * If the source map does not contain any scopes information, this factory function attempts to create bare bones scope information
+   * If the source map does not contain any scopes information, this factory function attempts to create scope information
    * via the script's AST combined with the mappings.
    *
    * We create the generated ranges from the scope tree and for each range we create an original scope that matches the bounds 1:1.
-   * We don't map the bounds via mappings as mappings are often iffy and it's not strictly required to translate stack traces where we
-   * map call-sites separately.
    */
   static createFromAst(
       sourceMap: SourceMap, scopeTree: Formatter.FormatterWorkerPool.ScopeTreeNode,
       text: TextUtils.Text.Text): SourceMapScopesInfo {
-    const {scope, range} = convertScope(scopeTree, undefined, undefined);
-    return new SourceMapScopesInfo(sourceMap, {scopes: [scope], ranges: [range]});
+    const numSourceUrls = sourceMap.sourceURLs().length;
+    const scopeBySourceUrl: ScopesCodec.OriginalScope[] = [];
+    for (let i = 0; i < numSourceUrls; i++) {
+      const scope: ScopesCodec.OriginalScope = {
+        start: {line: 0, column: 0},
+        end: {line: Number.POSITIVE_INFINITY, column: Number.POSITIVE_INFINITY},
+        isStackFrame: false,
+        variables: [],
+        children: [],
+      };
+      scopeBySourceUrl.push(scope);
+    }
+
+    // Convert the entire scopeTree. Returns a root range that encompasses everything,
+    // and inserts scopes by sourceIndex into the above scopeBySourceUrl.
+    const {range} = convertScope(scopeTree, undefined);
+    return new SourceMapScopesInfo(sourceMap, {scopes: scopeBySourceUrl, ranges: [range]});
+
+    /**
+     * Recursively finds the correct place in the tree to insert the new scope.
+     * Maintains the invariant that children are sorted and contained by their parent.
+     */
+    function insertInScope(parent: ScopesCodec.OriginalScope, newScope: ScopesCodec.OriginalScope): void {
+      // Check if the newScope fits strictly inside any of the existing children.
+      for (const child of parent.children) {
+        if (contains(child, newScope)) {
+          insertInScope(child, newScope);
+          return;
+        }
+      }
+
+      // When here, newScope belongs directly in parent.
+      // However, newScope might encompass some of parent's existing children (due
+      // to compiler transform quirks or arbitrary insertion order). We must move
+      // those children inside newScope.
+      const childrenToKeep: ScopesCodec.OriginalScope[] = [];
+      for (const child of parent.children) {
+        if (contains(newScope, child)) {
+          // child is actually inside newScope, so re-parent it.
+          newScope.children.push(child);
+          child.parent = newScope;
+        } else {
+          childrenToKeep.push(child);
+        }
+      }
+
+      // Find the correct index in the remaining children to insert newScope.
+      // We look for the first child that starts after the new scope.
+      const insertIndex = childrenToKeep.findIndex(child => compareScopes(newScope, child) < 0);
+      if (insertIndex === -1) {
+        // If no child starts after, it goes at the end.
+        childrenToKeep.push(newScope);
+      } else {
+        childrenToKeep.splice(insertIndex, 0, newScope);
+      }
+
+      // Update parent's children to only be the ones that don't belong to newScope.
+      parent.children = childrenToKeep;
+      newScope.parent = parent;
+    }
+
+    function contains(outer: ScopesCodec.OriginalScope, inner: ScopesCodec.OriginalScope): boolean {
+      return comparePositions(outer.start, inner.start) <= 0 && comparePositions(outer.end, inner.end) >= 0;
+    }
+
+    function compareScopes(a: ScopesCodec.OriginalScope, b: ScopesCodec.OriginalScope): number {
+      return comparePositions(a.start, b.start);
+    }
+
+    function comparePositions(a: ScopesCodec.Position, b: ScopesCodec.Position): number {
+      if (a.line !== b.line) {
+        return a.line - b.line;
+      }
+      return a.column - b.column;
+    }
 
     function convertScope(
-        node: Formatter.FormatterWorkerPool.ScopeTreeNode, parentScope: ScopesCodec.OriginalScope|undefined,
-        parentRange: ScopesCodec.GeneratedRange|
-        undefined): {scope: ScopesCodec.OriginalScope, range: ScopesCodec.GeneratedRange} {
+        node: Formatter.FormatterWorkerPool.ScopeTreeNode,
+        parentRange: ScopesCodec.GeneratedRange|undefined): {range: ScopesCodec.GeneratedRange} {
       const start = positionFromOffset(node.start);
       const end = positionFromOffset(node.end);
+      const startEntry = sourceMap.findEntry(start.line, start.column);
+      const endEntry = sourceMap.findEntry(end.line, end.column);
+      const sourceIndex = startEntry?.sourceIndex;
+      const canMapOriginalPosition = startEntry && endEntry && sourceIndex !== undefined &&
+          startEntry.sourceIndex === endEntry.sourceIndex && startEntry.sourceIndex !== undefined && sourceIndex >= 0 &&
+          sourceIndex < numSourceUrls;
       const isStackFrame = node.kind === Formatter.FormatterWorkerPool.ScopeKind.FUNCTION;
 
-      const scope: ScopesCodec.OriginalScope = {
-        start,
-        end,
-        name: sourceMap.findEntry(start.line, start.column, 0)?.name,
-        isStackFrame,
-        variables: [],
-        children: [],
-      };
+      let scope: ScopesCodec.OriginalScope|undefined;
+      if (canMapOriginalPosition) {
+        scope = {
+          start: {line: startEntry.sourceLineNumber, column: startEntry.sourceColumnNumber},
+          end: {line: endEntry.sourceLineNumber, column: endEntry.sourceColumnNumber},
+          name: startEntry.name,
+          isStackFrame,
+          variables: [],
+          children: [],
+        };
+      }
 
       const range: ScopesCodec.GeneratedRange = {
         start,
@@ -67,11 +146,14 @@ export class SourceMapScopesInfo {
       };
 
       parentRange?.children.push(range);
-      parentScope?.children.push(scope);
+      if (canMapOriginalPosition && scope) {
+        const rootScope = scopeBySourceUrl[sourceIndex];
+        insertInScope(rootScope, scope);
+      }
 
-      node.children.forEach(child => convertScope(child, scope, range));
+      node.children.forEach(child => convertScope(child, range));
 
-      return {scope, range};
+      return {range};
     }
 
     function positionFromOffset(offset: number): ScopesCodec.Position {
@@ -347,7 +429,16 @@ export class SourceMapScopesInfo {
   /**
    * Returns the authored function name of the function containing the provided generated position.
    */
-  findOriginalFunctionName({line, column}: ScopesCodec.Position): string|null {
+  findOriginalFunctionName(position: ScopesCodec.Position): string|null {
+    const originalInnerMostScope = this.findOriginalFunctionScope(position)?.scope ?? undefined;
+    return this.#findFunctionNameInOriginalScopeChain(originalInnerMostScope);
+  }
+
+  /**
+   * Returns the authored function scope of the function containing the provided generated position.
+   */
+  findOriginalFunctionScope({line, column}: ScopesCodec.Position):
+      {scope: ScopesCodec.OriginalScope, url?: Platform.DevToolsPath.UrlString}|null {
     // There are 2 approaches:
     //   1) Find the inner-most generated range containing the provided generated position
     //      and use it's OriginalScope (then walk it outwards until we hit a function).
@@ -376,7 +467,24 @@ export class SourceMapScopesInfo {
               .at(-1);
     }
 
-    return this.#findFunctionNameInOriginalScopeChain(originalInnerMostScope) ?? null;
+    if (!originalInnerMostScope) {
+      return null;
+    }
+
+    const functionScope = this.#findFunctionScopeInOriginalScopeChain(originalInnerMostScope);
+    if (!functionScope) {
+      return null;
+    }
+
+    // Find the root scope for some given original source, to get the source url.
+    let rootScope: ScopesCodec.OriginalScope = functionScope;
+    while (rootScope.parent) {
+      rootScope = rootScope.parent;
+    }
+    const sourceIndex = this.#originalScopes.indexOf(rootScope);
+    const url = sourceIndex !== -1 ? this.#sourceMap.sourceURLForSourceIndex(sourceIndex) : undefined;
+
+    return functionScope ? {scope: functionScope, url} : null;
   }
 
   /**
@@ -403,15 +511,25 @@ export class SourceMapScopesInfo {
     return result;
   }
 
-  #findFunctionNameInOriginalScopeChain(innerOriginalScope: ScopesCodec.OriginalScope|undefined): string|null {
+  #findFunctionScopeInOriginalScopeChain(innerOriginalScope: ScopesCodec.OriginalScope|undefined):
+      ScopesCodec.OriginalScope|null {
     for (let originalScope = innerOriginalScope; originalScope; originalScope = originalScope.parent) {
       if (originalScope.isStackFrame) {
-        return originalScope.name ?? '';
+        return originalScope;
       }
     }
     return null;
   }
 
+  #findFunctionNameInOriginalScopeChain(innerOriginalScope: ScopesCodec.OriginalScope|undefined): string|null {
+    const functionScope = this.#findFunctionScopeInOriginalScopeChain(innerOriginalScope);
+    if (!functionScope) {
+      return null;
+    }
+
+    return functionScope.name ?? '';
+  }
+
   /**
    * Returns one or more original stack frames for this single "raw frame" or call-site.
    *

package/front_end/core/sdk/Target.ts

@@ -7,7 +7,7 @@ import * as Common from '../common/common.js';
 import * as Platform from '../platform/platform.js';
 import * as ProtocolClient from '../protocol_client/protocol_client.js';
 
-import {SDKModel} from './SDKModel.js';
+import {SDKModel, type SDKModelConstructor} from './SDKModel.js';
 import type {TargetManager} from './TargetManager.js';
 
 export class Target extends ProtocolClient.InspectorBackend.TargetBase {
@@ -111,20 +111,11 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
     this.#targetInfo = targetInfo;
   }
 
-  createModels(required: Set<new(arg1: Target) => SDKModel>): void {
+  /** Creates the models in the order in which they are provided */
+  createModels(models: SDKModelConstructor[]): void {
     this.#creatingModels = true;
-    const registeredModels = Array.from(SDKModel.registeredModels.entries());
-    // Create early models.
-    for (const [modelClass, info] of registeredModels) {
-      if (info.early) {
-        this.model(modelClass);
-      }
-    }
-    // Create autostart and required models.
-    for (const [modelClass, info] of registeredModels) {
-      if (info.autostart || required.has(modelClass)) {
-        this.model(modelClass);
-      }
+    for (const model of models) {
+      this.model(model);
     }
     this.#creatingModels = false;
   }

package/front_end/core/sdk/TargetManager.ts

@@ -10,7 +10,7 @@ import {assertNotNullOrUndefined} from '../platform/platform.js';
 import type * as ProtocolClient from '../protocol_client/protocol_client.js';
 import * as Root from '../root/root.js';
 
-import {SDKModel, type SDKModelConstructor} from './SDKModel.js';
+import {type RegistrationInfo, SDKModel, type SDKModelConstructor} from './SDKModel.js';
 import {Target, Type as TargetType} from './Target.js';
 
 export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
@@ -31,8 +31,12 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   #scopeTarget: Target|null;
   #defaultScopeSet: boolean;
   readonly #scopeChangeListeners: Set<() => void>;
+  readonly #overrideAutoStartModels?: Set<SDKModelConstructor>;
 
-  constructor() {
+  /**
+   * @param overrideAutoStartModels If provided, then the `autostart` flag on {@link RegistrationInfo} will be ignored.
+   */
+  constructor(overrideAutoStartModels?: Set<SDKModelConstructor>) {
     super();
     this.#targets = new Set();
     this.#observers = new Set();
@@ -44,6 +48,7 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     this.#scopedObservers = new WeakSet();
     this.#defaultScopeSet = false;
     this.#scopeChangeListeners = new Set();
+    this.#overrideAutoStartModels = overrideAutoStartModels;
   }
 
   static instance({forceNew}: {
@@ -205,6 +210,23 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     this.#scopedObservers.delete(targetObserver);
   }
 
+  /** @returns The set of models we create unconditionally for new targets in the order in which they should be created */
+  #autoStartModels(): SDKModelConstructor[] {
+    const earlyModels = new Set<SDKModelConstructor>();
+    const models = new Set<SDKModelConstructor>();
+    const shouldAutostart = (model: SDKModelConstructor, info: RegistrationInfo): boolean =>
+        this.#overrideAutoStartModels ? this.#overrideAutoStartModels.has(model) : info.autostart;
+
+    for (const [model, info] of SDKModel.registeredModels) {
+      if (info.early) {
+        earlyModels.add(model);
+      } else if (shouldAutostart(model, info) || this.#modelObservers.has(model)) {
+        models.add(model);
+      }
+    }
+    return [...earlyModels, ...models];
+  }
+
   createTarget(
       id: Protocol.Target.TargetID|'main', name: string, type: TargetType, parentTarget: Target|null,
       sessionId?: string, waitForDebuggerInPage?: boolean, connection?: ProtocolClient.CDPConnection.CDPConnection,
@@ -214,7 +236,7 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     if (waitForDebuggerInPage) {
       void target.pageAgent().invoke_waitForDebugger();
     }
-    target.createModels(new Set(this.#modelObservers.keysArray()));
+    target.createModels(this.#autoStartModels());
     this.#targets.add(target);
 
     const inScope = this.isInScope(target);
@@ -316,7 +338,7 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
       this.#browserTarget = new Target(
           this, /* #id*/ 'main', /* #name*/ 'browser', TargetType.BROWSER, /* #parentTarget*/ null,
           /* #sessionId */ '', /* suspended*/ false, /* #connection*/ null, /* targetInfo*/ undefined);
-      this.#browserTarget.createModels(new Set(this.#modelObservers.keysArray()));
+      this.#browserTarget.createModels(this.#autoStartModels());
     }
     const targetId =
         await Host.InspectorFrontendHost.InspectorFrontendHostInstance.initialTargetId() as Protocol.Target.TargetID;

package/front_end/core/sdk/sdk-meta.ts

@@ -363,6 +363,30 @@ const UIStrings = {
    */
   networkCacheExplanation:
       'Disabling the network cache will simulate a network experience similar to a first time visitor.',
+  /**
+   * @description Setting under the Sources category to toggle usage of JavaScript source maps.
+   */
+  javaScriptSourceMaps: 'JavaScript source maps',
+  /**
+   * @description Title of a setting under the Sources category that can be invoked through the Command Menu
+   */
+  enableJavaScriptSourceMaps: 'Enable JavaScript source maps',
+  /**
+   * @description Title of a setting under the Sources category that can be invoked through the Command Menu
+   */
+  disableJavaScriptSourceMaps: 'Disable JavaScript source maps',
+  /**
+   * @description Title of a setting under the Sources category
+   */
+  cssSourceMaps: 'CSS source maps',
+  /**
+   * @description Title of a setting under the Sources category that can be invoked through the Command Menu
+   */
+  enableCssSourceMaps: 'Enable CSS source maps',
+  /**
+   * @description Title of a setting under the Sources category that can be invoked through the Command Menu
+   */
+  disableCssSourceMaps: 'Disable CSS source maps',
 } as const;
 const str_ = i18n.i18n.registerUIStrings('core/sdk/sdk-meta.ts', UIStrings);
 const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
@@ -1132,3 +1156,41 @@ Common.Settings.registerSettingExtension({
     tooltip: i18nLazyString(UIStrings.remoteFileLoadingInfo),
   }
 });
+
+Common.Settings.registerSettingExtension({
+  category: Common.Settings.SettingCategory.SOURCES,
+  storageType: Common.Settings.SettingStorageType.SYNCED,
+  title: i18nLazyString(UIStrings.javaScriptSourceMaps),
+  settingName: 'js-source-maps-enabled',
+  settingType: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: true,
+  options: [
+    {
+      value: true,
+      title: i18nLazyString(UIStrings.enableJavaScriptSourceMaps),
+    },
+    {
+      value: false,
+      title: i18nLazyString(UIStrings.disableJavaScriptSourceMaps),
+    },
+  ],
+});
+
+Common.Settings.registerSettingExtension({
+  category: Common.Settings.SettingCategory.SOURCES,
+  storageType: Common.Settings.SettingStorageType.SYNCED,
+  title: i18nLazyString(UIStrings.cssSourceMaps),
+  settingName: 'css-source-maps-enabled',
+  settingType: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: true,
+  options: [
+    {
+      value: true,
+      title: i18nLazyString(UIStrings.enableCssSourceMaps),
+    },
+    {
+      value: false,
+      title: i18nLazyString(UIStrings.disableCssSourceMaps),
+    },
+  ],
+});

package/front_end/devtools_compatibility.js

@@ -450,7 +450,6 @@
     TimelineNavigationSettingState: 'DevTools.TimelineNavigationSettingState',
     SyncSetting: 'DevTools.SyncSetting',
     SwatchActivated: 'DevTools.SwatchActivated',
-    AnimationPlaybackRateChanged: 'DevTools.AnimationPlaybackRateChanged',
     BuiltInAiAvailability: 'DevTools.BuiltInAiAvailability'
     // LINT.ThenChange(/front_end/core/host/InspectorFrontendHostAPI.ts:EnumeratedHistogram)
   };

package/front_end/entrypoints/formatter_worker/HTMLFormatter.ts

@@ -260,8 +260,8 @@ export class HTMLModel {
       this.#updateDOM(token);
 
       const element = this.#stack[this.#stack.length - 1];
-      if (element && (element.name === 'script' || element.name === 'style') && element.openTag &&
-          element.openTag.endOffset === lastOffset) {
+      if (element && (element.name === 'script' || element.name === 'style') &&
+          element.openTag?.endOffset === lastOffset) {
         return AbortTokenization;
       }
 

package/front_end/entrypoints/formatter_worker/JavaScriptFormatter.ts

@@ -174,7 +174,7 @@ export class JavaScriptFormatter {
         return 'sts';
       }
     } else if (nodeType === 'ObjectPattern') {
-      if (node.parent && node.parent.type === 'VariableDeclarator' && AT.punctuator(token, '{')) {
+      if (node.parent?.type === 'VariableDeclarator' && AT.punctuator(token, '{')) {
         return 'st';
       }
       if (AT.punctuator(token, ',')) {
@@ -203,7 +203,7 @@ export class JavaScriptFormatter {
       }
     } else if (nodeType === 'WithStatement') {
       if (AT.punctuator(token, ')')) {
-        return node.body && node.body.type === 'BlockStatement' ? 'ts' : 'tn>';
+        return node.body?.type === 'BlockStatement' ? 'ts' : 'tn>';
       }
     } else if (nodeType === 'SwitchStatement') {
       if (AT.punctuator(token, '{')) {
@@ -269,11 +269,11 @@ export class JavaScriptFormatter {
       }
     } else if (nodeType === 'IfStatement') {
       if (AT.punctuator(token, ')')) {
-        return node.consequent && node.consequent.type === 'BlockStatement' ? 'ts' : 'tn>';
+        return node.consequent?.type === 'BlockStatement' ? 'ts' : 'tn>';
       }
 
       if (AT.keyword(token, 'else')) {
-        const preFormat = node.consequent && node.consequent.type === 'BlockStatement' ? 'st' : 'n<t';
+        const preFormat = node.consequent?.type === 'BlockStatement' ? 'st' : 'n<t';
         let postFormat = 'n>';
         if (node.alternate && (node.alternate.type === 'BlockStatement' || node.alternate.type === 'IfStatement')) {
           postFormat = 's';
@@ -285,7 +285,7 @@ export class JavaScriptFormatter {
         return 'ts';
       }
     } else if (nodeType === 'SequenceExpression' && AT.punctuator(token, ',')) {
-      return node.parent && node.parent.type === 'SwitchCase' ? 'ts' : 'tn';
+      return node.parent?.type === 'SwitchCase' ? 'ts' : 'tn';
     } else if (nodeType === 'ForStatement' || nodeType === 'ForOfStatement' || nodeType === 'ForInStatement') {
       if (AT.punctuator(token, ';')) {
         return 'ts';
@@ -295,14 +295,14 @@ export class JavaScriptFormatter {
       }
 
       if (AT.punctuator(token, ')')) {
-        return node.body && node.body.type === 'BlockStatement' ? 'ts' : 'tn>';
+        return node.body?.type === 'BlockStatement' ? 'ts' : 'tn>';
       }
     } else if (nodeType === 'WhileStatement') {
       if (AT.punctuator(token, ')')) {
-        return node.body && node.body.type === 'BlockStatement' ? 'ts' : 'tn>';
+        return node.body?.type === 'BlockStatement' ? 'ts' : 'tn>';
       }
     } else if (nodeType === 'DoWhileStatement') {
-      const blockBody = node.body && node.body.type === 'BlockStatement';
+      const blockBody = node.body?.type === 'BlockStatement';
       if (AT.keyword(token, 'do')) {
         return blockBody ? 'ts' : 'tn>';
       }
@@ -369,34 +369,31 @@ export class JavaScriptFormatter {
         return 'n<';
       }
     } else if (nodeType === 'BlockStatement') {
-      if (node.parent && node.parent.type === 'IfStatement') {
+      if (node.parent?.type === 'IfStatement') {
         const parentNode = (node.parent as Acorn.ESTree.IfStatement);
         if (parentNode.alternate && parentNode.consequent === node) {
           return '';
         }
       }
-      if (node.parent && node.parent.type === 'FunctionExpression' && node.parent.parent &&
-          node.parent.parent.type === 'Property') {
+      if (node.parent?.type === 'FunctionExpression' && node.parent.parent?.type === 'Property') {
         return '';
       }
-      if (node.parent && node.parent.type === 'FunctionExpression' && node.parent.parent &&
-          node.parent.parent.type === 'VariableDeclarator') {
+      if (node.parent?.type === 'FunctionExpression' && node.parent.parent?.type === 'VariableDeclarator') {
         return '';
       }
-      if (node.parent && node.parent.type === 'FunctionExpression' && node.parent.parent &&
-          node.parent.parent.type === 'CallExpression') {
+      if (node.parent?.type === 'FunctionExpression' && node.parent.parent?.type === 'CallExpression') {
         return '';
       }
-      if (node.parent && node.parent.type === 'DoWhileStatement') {
+      if (node.parent?.type === 'DoWhileStatement') {
         return '';
       }
-      if (node.parent && node.parent.type === 'TryStatement') {
+      if (node.parent?.type === 'TryStatement') {
         const parentNode = (node.parent as Acorn.ESTree.TryStatement);
         if (parentNode.block === node) {
           return 's';
         }
       }
-      if (node.parent && node.parent.type === 'CatchClause') {
+      if (node.parent?.type === 'CatchClause') {
         const parentNode = (node.parent as Acorn.ESTree.CatchClause);
         // @ts-expect-error We are doing a subtype check, without properly checking whether
         // it exists. We can't fix that, unless we use proper typechecking

package/front_end/entrypoints/formatter_worker/formatter_worker-entrypoint.ts

@@ -7,7 +7,7 @@ import * as Platform from '../../core/platform/platform.js';
 import * as FormatterWorker from './formatter_worker.js';
 import {FormatterActions} from './FormatterActions.js';
 
-self.onmessage = function(event: MessageEvent): void {
+Platform.HostRuntime.HOST_RUNTIME.workerScope.onmessage = function(event): void {
   const method: FormatterActions = event.data.method;
   const params: {
     indentString: string,
@@ -22,17 +22,20 @@ self.onmessage = function(event: MessageEvent): void {
 
   switch (method) {
     case FormatterActions.FORMAT:
-      self.postMessage(FormatterWorker.FormatterWorker.format(params.mimeType, params.content, params.indentString));
+      Platform.HostRuntime.HOST_RUNTIME.workerScope.postMessage(
+          FormatterWorker.FormatterWorker.format(params.mimeType, params.content, params.indentString));
       break;
     case FormatterActions.PARSE_CSS:
       FormatterWorker.CSSRuleParser.parseCSS(params.content, self.postMessage);
       break;
     case FormatterActions.JAVASCRIPT_SUBSTITUTE: {
-      self.postMessage(FormatterWorker.Substitute.substituteExpression(params.content, params.mapping));
+      Platform.HostRuntime.HOST_RUNTIME.workerScope.postMessage(
+          FormatterWorker.Substitute.substituteExpression(params.content, params.mapping));
       break;
     }
     case FormatterActions.JAVASCRIPT_SCOPE_TREE: {
-      self.postMessage(FormatterWorker.ScopeParser.parseScopes(params.content, params.sourceType)?.export());
+      Platform.HostRuntime.HOST_RUNTIME.workerScope.postMessage(
+          FormatterWorker.ScopeParser.parseScopes(params.content, params.sourceType)?.export());
       break;
     }
     default:
@@ -40,4 +43,4 @@ self.onmessage = function(event: MessageEvent): void {
   }
 };
 
-self.postMessage('workerReady');
+Platform.HostRuntime.HOST_RUNTIME.workerScope.postMessage('workerReady');

package/front_end/entrypoints/main/ExecutionContextSelector.ts

@@ -45,7 +45,7 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
 
   modelRemoved(runtimeModel: SDK.RuntimeModel.RuntimeModel): void {
     const currentExecutionContext = this.#context.flavor(SDK.RuntimeModel.ExecutionContext);
-    if (currentExecutionContext && currentExecutionContext.runtimeModel === runtimeModel) {
+    if (currentExecutionContext?.runtimeModel === runtimeModel) {
       this.#currentExecutionContextGone();
     }
 

package/front_end/entrypoints/main/MainImpl.ts

@@ -183,7 +183,7 @@ export class MainImpl {
     Host.userMetrics.syncSetting(Common.Settings.Settings.instance().moduleSetting<boolean>('sync-preferences').get());
     const veLogging = config.devToolsVeLogging;
 
-    // Used by e2e_non_hosted to put VE Logs into "test mode".
+    // Used by e2e to put VE Logs into "test mode".
     const veLogsTestMode = Common.Settings.Settings.instance().createSetting('veLogsTestMode', false).get();
 
     if (veLogging?.enabled) {
@@ -504,7 +504,7 @@ export class MainImpl {
     LiveMetrics.LiveMetrics.instance();
     CrUXManager.CrUXManager.instance();
 
-    void AiAssistanceModel.BuiltInAi.BuiltInAi.instance();
+    AiAssistanceModel.BuiltInAi.BuiltInAi.instance();
 
     new PauseListener();
 
@@ -717,7 +717,7 @@ export class MainImpl {
     // @ts-expect-error Used in ElementsTreeOutline
     eventCopy['original'] = event;
     const document = event.target && (event.target as HTMLElement).ownerDocument;
-    const target = document ? Platform.DOMUtilities.deepActiveElement(document) : null;
+    const target = document ? UI.DOMUtilities.deepActiveElement(document) : null;
     if (target) {
       target.dispatchEvent(eventCopy);
     }
@@ -778,7 +778,7 @@ export class ZoomActionDelegate implements UI.ActionRegistration.ActionDelegate
 export class SearchActionDelegate implements UI.ActionRegistration.ActionDelegate {
   handleAction(_context: UI.Context.Context, actionId: string): boolean {
     let searchableView = UI.SearchableView.SearchableView.fromElement(
-        Platform.DOMUtilities.deepActiveElement(document),
+        UI.DOMUtilities.deepActiveElement(document),
     );
     if (!searchableView) {
       const currentPanel = (UI.InspectorView.InspectorView.instance().currentPanelDeprecated() as UI.Panel.Panel);

package/front_end/foundation/Universe.ts

@@ -9,8 +9,8 @@ import * as Bindings from '../models/bindings/bindings.js';
 import * as Workspace from '../models/workspace/workspace.js';
 
 export interface CreationOptions {
-  // Settings things
   settingsCreationOptions: Common.Settings.SettingsCreationOptions;
+  overrideAutoStartModels?: Set<SDK.SDKModel.SDKModelConstructor>;
 }
 
 export class Universe {
@@ -24,7 +24,7 @@ export class Universe {
       ...options.settingsCreationOptions,
     });
 
-    const targetManager = new SDK.TargetManager.TargetManager();
+    const targetManager = new SDK.TargetManager.TargetManager(options.overrideAutoStartModels);
     this.context.set(SDK.TargetManager.TargetManager, targetManager);
 
     const workspace = new Workspace.Workspace.WorkspaceImpl();