chrome-devtools-frontend 1.0.942529 → 1.0.943986

package/front_end/core/protocol_client/InspectorBackend.ts

@@ -764,6 +764,10 @@ export class TargetBase {
     manager.removeDomainDispatcher(dispatcher);
   }
 
+  registerAccessibilityDispatcher(dispatcher: ProtocolProxyApi.AccessibilityDispatcher): void {
+    this.registerDispatcher('Accessibility', dispatcher);
+  }
+
   registerAnimationDispatcher(dispatcher: ProtocolProxyApi.AnimationDispatcher): void {
     this.registerDispatcher('Animation', dispatcher);
   }

package/front_end/core/sdk/AccessibilityModel.ts

@@ -6,7 +6,6 @@ import type * as Protocol from '../../generated/protocol.js';
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 
 import type {DOMNode} from './DOMModel.js';
-import {DOMModel} from './DOMModel.js';
 import {DeferredDOMNode} from './DOMModel.js';
 import type {Target} from './Target.js';
 import {Capability} from './Target.js';
@@ -39,8 +38,9 @@ export class AccessibilityNode {
   readonly #descriptionInternal: Protocol.Accessibility.AXValue|null;
   readonly #valueInternal: Protocol.Accessibility.AXValue|null;
   readonly #propertiesInternal: Protocol.Accessibility.AXProperty[]|null;
-  #childIds: string[]|null;
-  #parentNodeInternal: AccessibilityNode|null;
+  readonly #parentId: Protocol.Accessibility.AXNodeId|null;
+  readonly #frameId: Protocol.Page.FrameId|null;
+  readonly #childIds: Protocol.Accessibility.AXNodeId[]|null;
 
   constructor(accessibilityModel: AccessibilityModel, payload: Protocol.Accessibility.AXNode) {
     this.#accessibilityModelInternal = accessibilityModel;
@@ -67,7 +67,13 @@ export class AccessibilityNode {
     this.#valueInternal = payload.value || null;
     this.#propertiesInternal = payload.properties || null;
     this.#childIds = payload.childIds || null;
-    this.#parentNodeInternal = null;
+    this.#parentId = payload.parentId || null;
+    if (payload.frameId && !payload.parentId) {
+      this.#frameId = payload.frameId;
+      accessibilityModel.setRootAXNodeForFrameId(payload.frameId, this);
+    } else {
+      this.#frameId = null;
+    }
   }
 
   id(): Protocol.Accessibility.AXNodeId {
@@ -123,11 +129,10 @@ export class AccessibilityNode {
   }
 
   parentNode(): AccessibilityNode|null {
-    return this.#parentNodeInternal;
-  }
-
-  setParentNode(parentNode: AccessibilityNode|null): void {
-    this.#parentNodeInternal = parentNode;
+    if (this.#parentId) {
+      return this.#accessibilityModelInternal.axNodeForId(this.#parentId);
+    }
+    return null;
   }
 
   isDOMNode(): boolean {
@@ -178,38 +183,57 @@ export class AccessibilityNode {
     if (!this.#childIds || !this.#childIds.length) {
       return false;
     }
-
     return this.#childIds.every(id => this.#accessibilityModelInternal.axNodeForId(id) === null);
   }
 
+  hasUnloadedChildren(): boolean {
+    if (!this.#childIds || !this.#childIds.length) {
+      return false;
+    }
+    return this.#childIds.some(id => this.#accessibilityModelInternal.axNodeForId(id) === null);
+  }
   // Only the root node gets a frameId, so nodes have to walk up the tree to find their frameId.
   getFrameId(): Protocol.Page.FrameId|null {
-    const domNode = this.accessibilityModel().domNodeforAXNode(this);
-    if (!domNode) {
-      return null;
-    }
-    return domNode.frameId();
+    return this.#frameId || this.parentNode()?.getFrameId() || null;
   }
 }
 
-export class AccessibilityModel extends SDKModel<void> {
+// TODO(crbug.com/1167717): Make this a const enum again
+// eslint-disable-next-line rulesdir/const_enum
+export enum Events {
+  TreeUpdated = 'TreeUpdated',
+}
+
+export type EventTypes = {
+  [Events.TreeUpdated]: {root?: AccessibilityNode},
+};
+
+export class AccessibilityModel extends SDKModel<EventTypes> implements ProtocolProxyApi.AccessibilityDispatcher {
   agent: ProtocolProxyApi.AccessibilityApi;
   #axIdToAXNode: Map<string, AccessibilityNode>;
-  readonly #backendDOMNodeIdToAXNode: Map<Protocol.DOM.BackendNodeId, AccessibilityNode>;
-  readonly #backendDOMNodeIdToDOMNode: Map<Protocol.DOM.BackendNodeId, DOMNode|null>;
+  #backendDOMNodeIdToAXNode: Map<Protocol.DOM.BackendNodeId, AccessibilityNode>;
+  #frameIdToAXNode: Map<Protocol.Page.FrameId, AccessibilityNode>;
+  #pendingChildRequests: Map<string, Promise<Protocol.Accessibility.GetChildAXNodesResponse>>;
+  #root: AccessibilityNode|null;
 
   constructor(target: Target) {
     super(target);
+    target.registerAccessibilityDispatcher(this);
     this.agent = target.accessibilityAgent();
     this.resumeModel();
 
     this.#axIdToAXNode = new Map();
     this.#backendDOMNodeIdToAXNode = new Map();
-    this.#backendDOMNodeIdToDOMNode = new Map();
+    this.#frameIdToAXNode = new Map();
+    this.#pendingChildRequests = new Map();
+    this.#root = null;
   }
 
   clear(): void {
+    this.#root = null;
     this.#axIdToAXNode.clear();
+    this.#backendDOMNodeIdToAXNode.clear();
+    this.#frameIdToAXNode.clear();
   }
 
   async resumeModel(): Promise<void> {
@@ -225,60 +249,64 @@ export class AccessibilityModel extends SDKModel<void> {
     if (!nodes) {
       return;
     }
-
+    const axNodes = [];
     for (const payload of nodes) {
-      new AccessibilityNode(this, payload);
+      axNodes.push(new AccessibilityNode(this, payload));
     }
+  }
 
-    for (const axNode of this.#axIdToAXNode.values()) {
-      for (const axChild of axNode.children()) {
-        axChild.setParentNode(axNode);
-      }
-    }
+  loadComplete({root}: Protocol.Accessibility.LoadCompleteEvent): void {
+    this.clear();
+    this.#root = new AccessibilityNode(this, root);
+    this.dispatchEventToListeners(Events.TreeUpdated, {root: this.#root});
   }
 
-  private async pushNodesToFrontend(backendIds: Set<Protocol.DOM.BackendNodeId>): Promise<void> {
-    const domModel = this.target().model(DOMModel);
-    if (!domModel) {
-      return;
-    }
-    const newNodesToTrack = await domModel.pushNodesByBackendIdsToFrontend(backendIds);
-    newNodesToTrack?.forEach((value, key) => this.#backendDOMNodeIdToDOMNode.set(key, value));
+  nodesUpdated({nodes}: Protocol.Accessibility.NodesUpdatedEvent): void {
+    this.createNodesFromPayload(nodes);
+    this.dispatchEventToListeners(Events.TreeUpdated, {});
+    return;
   }
 
   private createNodesFromPayload(payloadNodes: Protocol.Accessibility.AXNode[]): AccessibilityNode[] {
-    const backendIds: Set<Protocol.DOM.BackendNodeId> = new Set();
     const accessibilityNodes = payloadNodes.map(node => {
       const sdkNode = new AccessibilityNode(this, node);
-      const backendId = sdkNode.backendDOMNodeId();
-      if (backendId) {
-        backendIds.add(backendId);
-      }
       return sdkNode;
     });
-    this.pushNodesToFrontend(backendIds);
 
-    for (const sdkNode of accessibilityNodes) {
-      for (const sdkChild of sdkNode.children()) {
-        sdkChild.setParentNode(sdkNode);
-      }
-    }
     return accessibilityNodes;
   }
 
-  async requestRootNode(depth: number = 2, frameId?: Protocol.Page.FrameId): Promise<AccessibilityNode|undefined> {
-    const {nodes} = await this.agent.invoke_getFullAXTree({depth, frameId});
-    if (!nodes) {
+  async requestRootNode(frameId?: Protocol.Page.FrameId): Promise<AccessibilityNode|undefined> {
+    if (frameId && this.#frameIdToAXNode.has(frameId)) {
+      return this.#frameIdToAXNode.get(frameId);
+    }
+    if (!frameId && this.#root) {
+      return this.#root;
+    }
+    const {node} = await this.agent.invoke_getRootAXNode({frameId});
+    if (!node) {
       return;
     }
-    const axNodes = this.createNodesFromPayload(nodes);
-    const root = axNodes[0];
-    return root;
+    return this.createNodesFromPayload([node])[0];
   }
 
   async requestAXChildren(nodeId: Protocol.Accessibility.AXNodeId, frameId?: Protocol.Page.FrameId):
       Promise<AccessibilityNode[]> {
-    const {nodes} = await this.agent.invoke_getChildAXNodes({id: nodeId, frameId});
+    const parent = this.#axIdToAXNode.get(nodeId);
+    if (parent && !parent.hasUnloadedChildren()) {
+      return parent.children();
+    }
+
+    let nodes;
+    const request = this.#pendingChildRequests.get(nodeId);
+    if (request) {
+      nodes = (await request).nodes;
+    } else {
+      const req = this.agent.invoke_getChildAXNodes({id: nodeId, frameId});
+      this.#pendingChildRequests.set(nodeId, req);
+      nodes = (await req).nodes;
+      this.#pendingChildRequests.delete(nodeId);
+    }
     if (!nodes) {
       return [];
     }
@@ -286,36 +314,37 @@ export class AccessibilityModel extends SDKModel<void> {
     return axNodes;
   }
 
-  async requestAndLoadSubTreeToNode(node: DOMNode): Promise<AccessibilityNode|null> {
+  async requestAndLoadSubTreeToNode(node: DOMNode): Promise<AccessibilityNode[]|null> {
     // Node may have already been loaded, so don't bother requesting it again.
-    const loadedAXNode = this.axNodeForDOMNode(node);
-    if (loadedAXNode) {
-      return loadedAXNode;
+    const result = [];
+    let ancestor = this.axNodeForDOMNode(node);
+    while (ancestor) {
+      result.push(ancestor);
+      const parent = ancestor.parentNode();
+      if (!parent) {
+        return result;
+      }
+      ancestor = parent;
     }
-
-    const {nodes} = await this.agent.invoke_getPartialAXTree({nodeId: node.id, fetchRelatives: true});
+    const {nodes} = await this.agent.invoke_getAXNodeAndAncestors({backendNodeId: node.backendNodeId()});
     if (!nodes) {
       return null;
     }
     const ancestors = this.createNodesFromPayload(nodes);
-    // Request top level children nodes.
-    for (const node of ancestors) {
-      await this.requestAXChildren(node.id());
-    }
 
-    return this.axNodeForDOMNode(node);
+    return ancestors;
   }
 
-  async updateSubtreeAndAncestors(backendNodeId: Protocol.DOM.BackendNodeId): Promise<void> {
-    const {nodes} = await this.agent.invoke_getPartialAXTree({backendNodeId, fetchRelatives: true});
-    if (!nodes) {
-      return;
-    }
-    this.createNodesFromPayload(nodes);
+  axNodeForId(axId: Protocol.Accessibility.AXNodeId): AccessibilityNode|null {
+    return this.#axIdToAXNode.get(axId) || null;
   }
 
-  axNodeForId(axId: string): AccessibilityNode|null {
-    return this.#axIdToAXNode.get(axId) || null;
+  setRootAXNodeForFrameId(frameId: Protocol.Page.FrameId, axNode: AccessibilityNode): void {
+    this.#frameIdToAXNode.set(frameId, axNode);
+  }
+
+  axNodeForFrameId(frameId: Protocol.Page.FrameId): AccessibilityNode|null {
+    return this.#frameIdToAXNode.get(frameId) ?? null;
   }
 
   setAXNodeForAXId(axId: string, axNode: AccessibilityNode): void {
@@ -329,14 +358,6 @@ export class AccessibilityModel extends SDKModel<void> {
     return this.#backendDOMNodeIdToAXNode.get(domNode.backendNodeId()) ?? null;
   }
 
-  domNodeforAXNode(axNode: AccessibilityNode): DOMNode|null {
-    const backendDOMNodeId = axNode.backendDOMNodeId();
-    if (!backendDOMNodeId) {
-      return null;
-    }
-    return this.#backendDOMNodeIdToDOMNode.get(backendDOMNodeId) ?? null;
-  }
-
   setAXNodeForBackendDOMNodeId(backendDOMNodeId: Protocol.DOM.BackendNodeId, axNode: AccessibilityNode): void {
     this.#backendDOMNodeIdToAXNode.set(backendDOMNodeId, axNode);
   }

package/front_end/core/sdk/CPUProfilerModel.ts

@@ -29,7 +29,6 @@
  */
 
 import * as i18n from '../i18n/i18n.js';
-import * as Root from '../root/root.js';
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import type * as Protocol from '../../generated/protocol.js';
 
@@ -57,6 +56,7 @@ export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolPr
   #preciseCoverageDeltaUpdateCallback:
       ((arg0: number, arg1: string, arg2: Array<Protocol.Profiler.ScriptCoverage>) => void)|null;
   readonly #debuggerModelInternal: DebuggerModel;
+  readonly registeredConsoleProfileMessages: ProfileFinishedData[] = [];
 
   constructor(target: Target) {
     super(target);
@@ -92,14 +92,12 @@ export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolPr
       title = this.#anonymousConsoleProfileIdToTitle.get(id);
       this.#anonymousConsoleProfileIdToTitle.delete(id);
     }
-    // Make sure ProfilesPanel is initialized and CPUProfileType is created.
-    Root.Runtime.Runtime.instance().loadModulePromise('profiler').then(() => {
-      const eventData: ProfileFinishedData = {
-        ...this.createEventDataFrom(id, location, title),
-        cpuProfile: profile,
-      };
-      this.dispatchEventToListeners(Events.ConsoleProfileFinished, eventData);
-    });
+    const eventData: ProfileFinishedData = {
+      ...this.createEventDataFrom(id, location, title),
+      cpuProfile: profile,
+    };
+    this.registeredConsoleProfileMessages.push(eventData);
+    this.dispatchEventToListeners(Events.ConsoleProfileFinished, eventData);
   }
 
   private createEventDataFrom(id: string, scriptLocation: Protocol.Debugger.Location, title?: string): EventData {

package/front_end/core/sdk/ConsoleModel.ts

@@ -491,6 +491,30 @@ function areAffectedResourcesEquivalent(a?: AffectedResources, b?: AffectedResou
   return a?.requestId === b?.requestId;
 }
 
+function areStackTracesEquivalent(
+    stackTrace1?: Protocol.Runtime.StackTrace, stackTrace2?: Protocol.Runtime.StackTrace): boolean {
+  if (!stackTrace1 !== !stackTrace2) {
+    return false;
+  }
+  if (!stackTrace1 || !stackTrace2) {
+    return true;
+  }
+  const callFrames1 = stackTrace1.callFrames;
+  const callFrames2 = stackTrace2.callFrames;
+  if (callFrames1.length !== callFrames2.length) {
+    return false;
+  }
+  for (let i = 0, n = callFrames1.length; i < n; ++i) {
+    if (callFrames1[i].scriptId !== callFrames2[i].scriptId ||
+        callFrames1[i].functionName !== callFrames2[i].functionName ||
+        callFrames1[i].lineNumber !== callFrames2[i].lineNumber ||
+        callFrames1[i].columnNumber !== callFrames2[i].columnNumber) {
+      return false;
+    }
+  }
+  return areStackTracesEquivalent(stackTrace1.parent, stackTrace2.parent);
+}
+
 export interface ConsoleMessageDetails {
   type?: MessageType;
   url?: string;
@@ -659,10 +683,6 @@ export class ConsoleMessage {
       return false;
     }
 
-    if (!this.isEqualStackTraces(this.stackTrace, msg.stackTrace)) {
-      return false;
-    }
-
     if (this.parameters) {
       if (!msg.parameters || this.parameters.length !== msg.parameters.length) {
         return false;
@@ -687,38 +707,12 @@ export class ConsoleMessage {
       }
     }
 
-    const watchExpressionRegex = /^watch-expression-\d+.devtools$/;
-    const bothAreWatchExpressions =
-        watchExpressionRegex.test(this.url || '') && watchExpressionRegex.test(msg.url || '');
-
     return (this.runtimeModel() === msg.runtimeModel()) && (this.source === msg.source) && (this.type === msg.type) &&
         (this.level === msg.level) && (this.line === msg.line) && (this.url === msg.url) &&
-        (bothAreWatchExpressions || this.scriptId === msg.scriptId) && (this.messageText === msg.messageText) &&
+        (this.scriptId === msg.scriptId) && (this.messageText === msg.messageText) &&
         (this.#executionContextId === msg.#executionContextId) &&
-        areAffectedResourcesEquivalent(this.#affectedResources, msg.#affectedResources);
-  }
-
-  private isEqualStackTraces(
-      stackTrace1: Protocol.Runtime.StackTrace|undefined, stackTrace2: Protocol.Runtime.StackTrace|undefined): boolean {
-    if (!stackTrace1 !== !stackTrace2) {
-      return false;
-    }
-    if (!stackTrace1 || !stackTrace2) {
-      return true;
-    }
-    const callFrames1 = stackTrace1.callFrames;
-    const callFrames2 = stackTrace2.callFrames;
-    if (callFrames1.length !== callFrames2.length) {
-      return false;
-    }
-    for (let i = 0, n = callFrames1.length; i < n; ++i) {
-      if (callFrames1[i].url !== callFrames2[i].url || callFrames1[i].functionName !== callFrames2[i].functionName ||
-          callFrames1[i].lineNumber !== callFrames2[i].lineNumber ||
-          callFrames1[i].columnNumber !== callFrames2[i].columnNumber) {
-        return false;
-      }
-    }
-    return this.isEqualStackTraces(stackTrace1.parent, stackTrace2.parent);
+        areAffectedResourcesEquivalent(this.#affectedResources, msg.#affectedResources) &&
+        areStackTracesEquivalent(this.stackTrace, msg.stackTrace);
   }
 }
 

package/front_end/core/sdk/NetworkManager.ts

@@ -1044,6 +1044,9 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
     this.#manager.dispatchEventToListeners(Events.ReportingApiReportUpdated, data.report);
   }
 
+  reportingApiEndpointsChangedForOrigin(_data: Protocol.Network.ReportingApiEndpointsChangedForOriginEvent): void {
+  }
+
   /**
    * @deprecated
    * This method is only kept for usage in a web test.

package/front_end/core/sdk/Script.ts

@@ -313,10 +313,6 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
     return !this.sourceURL;
   }
 
-  isInlineScriptWithSourceURL(): boolean {
-    return Boolean(this.hasSourceURL) && this.isInlineScript();
-  }
-
   async setBlackboxedRanges(positions: Protocol.Debugger.ScriptPosition[]): Promise<boolean> {
     const response = await this.debuggerModel.target().debuggerAgent().invoke_setBlackboxedRanges(
         {scriptId: this.scriptId, positions});

package/front_end/core/sdk/ServiceWorkerCacheModel.ts

@@ -25,13 +25,17 @@ const str_ = i18n.i18n.registerUIStrings('core/sdk/ServiceWorkerCacheModel.ts',
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class ServiceWorkerCacheModel extends SDKModel<EventTypes> implements ProtocolProxyApi.StorageDispatcher {
-  readonly #cachesInternal: Map<string, Cache>;
   readonly cacheAgent: ProtocolProxyApi.CacheStorageApi;
   readonly #storageAgent: ProtocolProxyApi.StorageApi;
   readonly #securityOriginManager: SecurityOriginManager;
-  readonly #originsUpdated: Set<string>;
-  readonly #throttler: Common.Throttler.Throttler;
-  #enabled: boolean;
+
+  readonly #cachesInternal = new Map<string, Cache>();
+  readonly #originsUpdated = new Set<string>();
+  readonly #throttler = new Common.Throttler.Throttler(2000);
+  #enabled = false;
+
+  // Used by tests to remove the Throttler timeout.
+  #scheduleAsSoonAsPossible = false;
 
   /**
    * Invariant: This #model can only be constructed on a ServiceWorker target.
@@ -40,16 +44,9 @@ export class ServiceWorkerCacheModel extends SDKModel<EventTypes> implements Pro
     super(target);
     target.registerStorageDispatcher(this);
 
-    this.#cachesInternal = new Map();
-
     this.cacheAgent = target.cacheStorageAgent();
     this.#storageAgent = target.storageAgent();
     this.#securityOriginManager = (target.model(SecurityOriginManager) as SecurityOriginManager);
-
-    this.#originsUpdated = new Set();
-    this.#throttler = new Common.Throttler.Throttler(2000);
-
-    this.#enabled = false;
   }
 
   enable(): void {
@@ -240,7 +237,7 @@ export class ServiceWorkerCacheModel extends SDKModel<EventTypes> implements Pro
       const promises = Array.from(this.#originsUpdated, origin => this.loadCacheNames(origin));
       this.#originsUpdated.clear();
       return Promise.all(promises);
-    });
+    }, this.#scheduleAsSoonAsPossible);
   }
 
   cacheStorageContentUpdated({origin, cacheName}: Protocol.Storage.CacheStorageContentUpdatedEvent): void {
@@ -252,6 +249,10 @@ export class ServiceWorkerCacheModel extends SDKModel<EventTypes> implements Pro
 
   indexedDBContentUpdated(_event: Protocol.Storage.IndexedDBContentUpdatedEvent): void {
   }
+
+  setThrottlerSchedulesAsSoonAsPossibleForTest(): void {
+    this.#scheduleAsSoonAsPossible = true;
+  }
 }
 
 // TODO(crbug.com/1167717): Make this a const enum again

package/front_end/entrypoints/device_mode_emulation_frame/device_mode_emulation_frame.ts

@@ -5,7 +5,7 @@
 import '../../core/dom_extension/dom_extension.js';
 import '../../Images/Images.js';
 
-import * as Platform from '../../core/platform/platform.js';  // eslint-disable-line rulesdir/es_modules_import
+import * as Platform from '../../core/platform/platform.js';
 
 Platform.runOnWindowLoad(() => {
   if (!window.opener) {

package/front_end/entrypoints/devtools_app/devtools_app.js

@@ -3,6 +3,6 @@
 // found in the LICENSE file.
 import '../shell/shell.js';
 import './devtools_app-meta-files.js';
-import * as Startup from '../startup/startup.js';  // eslint-disable-line rulesdir/es_modules_import
+import * as Startup from '../startup/startup.js';
 
 Startup.RuntimeInstantiator.startApplication('devtools_app');

package/front_end/entrypoints/devtools_app/devtools_app.json

@@ -1,9 +1,6 @@
 {
   "modules" : [
-    { "name": "panels/lighthouse" },
-    { "name": "emulated_devices" },
-    { "name": "panels/layers" },
-    { "name": "panels/timeline" }
+    { "name": "panels/lighthouse" }
   ],
   "extends": "shell"
 }

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

@@ -8,7 +8,7 @@ import '../../third_party/codemirror/package/mode/xml/xml.js';
 import '../../third_party/codemirror/package/mode/javascript/javascript.js';
 
 import * as Platform from '../../core/platform/platform.js';
-import * as FormatterWorker from './formatter_worker.js';  // eslint-disable-line rulesdir/es_modules_import
+import * as FormatterWorker from './formatter_worker.js';
 
 import {FormatterActions} from './FormatterActions.js';
 

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

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as HeapSnapshotWorker from './heap_snapshot_worker.js';  // eslint-disable-line rulesdir/es_modules_import
+import * as HeapSnapshotWorker from './heap_snapshot_worker.js';
 
 // We need to force the worker context
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/front_end/entrypoints/inspector/inspector.js

@@ -3,6 +3,6 @@
 // found in the LICENSE file.
 import '../devtools_app/devtools_app.js';
 import '../../panels/screencast/screencast-meta.js';
-import * as Startup from '../startup/startup.js';  // eslint-disable-line rulesdir/es_modules_import
+import * as Startup from '../startup/startup.js';
 
 Startup.RuntimeInstantiator.startApplication('inspector');

package/front_end/entrypoints/inspector/inspector.json

@@ -1,6 +1,4 @@
 {
-  "modules" : [
-    { "name": "panels/screencast", "type": "autostart" }
-  ],
+  "modules" : [],
   "extends": "devtools_app"
 }

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

@@ -6,6 +6,8 @@ import * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import * as UI from '../../ui/legacy/legacy.js';
 
+import type * as InspectorMain from './inspector_main.js';
+
 const UIStrings = {
   /**
   * @description Title of the Rendering tool. The rendering tool is a collection of settings that
@@ -101,9 +103,6 @@ const UIStrings = {
 const str_ = i18n.i18n.registerUIStrings('entrypoints/inspector_main/inspector_main-meta.ts', UIStrings);
 const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
 
-// eslint-disable-next-line rulesdir/es_modules_import
-import type * as InspectorMain from './inspector_main.js';
-
 let loadedInspectorMainModule: (typeof InspectorMain|undefined);
 
 async function loadInspectorMainModule(): Promise<typeof InspectorMain> {

package/front_end/entrypoints/js_app/js_app.js

@@ -4,6 +4,6 @@
 import '../shell/shell.js';
 import '../../panels/js_profiler/js_profiler-meta.js';
 import './JsMain.js';
-import * as Startup from '../startup/startup.js';  // eslint-disable-line rulesdir/es_modules_import
+import * as Startup from '../startup/startup.js';
 
 Startup.RuntimeInstantiator.startApplication('js_app');

package/front_end/entrypoints/js_app/js_app.json

@@ -1,6 +1,4 @@
 {
-  "modules" : [
-    { "name": "panels/js_profiler" }
-  ],
+  "modules" : [],
   "extends": "shell"
 }

package/front_end/entrypoints/main/MainImpl.ts

@@ -299,8 +299,8 @@ export class MainImpl {
         'keyboardShortcutEditor', 'Enable keyboard shortcut editor', true,
         'https://developer.chrome.com/blog/new-in-devtools-88/#keyboard-shortcuts');
 
-    // Back-Forward Cache
-    Root.Runtime.experiments.register('bfcacheDebugging', 'Enable Back-Forward Cache debugging support');
+    // Back/forward cache
+    Root.Runtime.experiments.register('bfcacheDebugging', 'Enable back/forward cache debugging support');
 
     // Timeline
     Root.Runtime.experiments.register('timelineEventInitiators', 'Timeline: event initiators');

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

@@ -8,10 +8,9 @@ import * as SDK from '../../core/sdk/sdk.js';
 import * as Workspace from '../../models/workspace/workspace.js';
 import * as Components from '../../ui/legacy/components/utils/utils.js';
 import * as UI from '../../ui/legacy/legacy.js';
+import type * as InspectorMain from '../inspector_main/inspector_main.js';
 
-// eslint-disable-next-line rulesdir/es_modules_import
 import type * as Main from './main.js';
-import type * as InspectorMain from '../inspector_main/inspector_main.js';
 
 import * as i18n from '../../core/i18n/i18n.js';
 const UIStrings = {

package/front_end/entrypoints/ndb_app/ndb_app.js

@@ -2,6 +2,6 @@
 // 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 * as Startup from '../startup/startup.js';  // eslint-disable-line rulesdir/es_modules_import
+import * as Startup from '../startup/startup.js';
 
 Startup.RuntimeInstantiator.startApplication('ndb_app');

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

@@ -4,8 +4,6 @@
 
 import * as i18n from '../../core/i18n/i18n.js';
 import * as UI from '../../ui/legacy/legacy.js';
-
-// eslint-disable-next-line rulesdir/es_modules_import
 import type * as Sources from '../../panels/sources/sources.js';
 
 const UIStrings = {