chrome-devtools-frontend 1.0.1362775 → 1.0.1376716

package/front_end/core/sdk/RehydratingConnection.test.ts

@@ -0,0 +1,190 @@
+// Copyright (c) 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import type * as Protocol from '../../generated/protocol.js';
+
+import * as Rehydrating from './RehydratingConnection.js';
+import type {
+  RehydratingExecutionContext, RehydratingScript, RehydratingTarget, ServerMessage} from './RehydratingObject.js';
+
+const mockTarget1: RehydratingTarget = {
+  targetId: 'ABCDE' as Protocol.Page.FrameId,
+  type: 'page',
+  isolate: '12345',
+  url: 'example.com',
+  pid: 12345,
+};
+
+const mockExecutionContext1: RehydratingExecutionContext = {
+  id: 1 as Protocol.Runtime.ExecutionContextId,
+  origin: 'example.com',
+  v8Context: 'example context 1',
+  auxData: {
+    frameId: 'ABCDE' as Protocol.Page.FrameId,
+    isDefault: true,
+    type: 'type',
+  },
+  isolate: '12345',
+};
+
+const mockExecutionContext2: RehydratingExecutionContext = {
+  id: 2 as Protocol.Runtime.ExecutionContextId,
+  origin: 'example.com',
+  v8Context: 'example context 2',
+  auxData: {
+    frameId: 'ABCDE' as Protocol.Page.FrameId,
+    isDefault: true,
+    type: 'type',
+  },
+  isolate: '12345',
+};
+
+const mockScript1: RehydratingScript = {
+  scriptId: '1' as Protocol.Runtime.ScriptId,
+  isolate: '12345',
+  executionContextId: 1 as Protocol.Runtime.ExecutionContextId,
+  startLine: 0,
+  startColumn: 0,
+  endLine: 1,
+  endColumn: 10,
+  hash: '',
+  isModule: false,
+  url: 'example.com',
+  hasSourceUrl: false,
+  sourceMapUrl: undefined,
+  length: 10,
+  sourceText: 'source text 1',
+  auxData: {
+    frameId: 'ABCDE' as Protocol.Page.FrameId,
+    isDefault: true,
+    type: 'type',
+  },
+};
+
+const mockScript2: RehydratingScript = {
+  scriptId: '2' as Protocol.Runtime.ScriptId,
+  isolate: '12345',
+  executionContextId: 2 as Protocol.Runtime.ExecutionContextId,
+  startLine: 0,
+  startColumn: 0,
+  endLine: 1,
+  endColumn: 10,
+  hash: '',
+  isModule: false,
+  url: 'example.com',
+  hasSourceUrl: false,
+  sourceMapUrl: undefined,
+  length: 10,
+  sourceText: 'source text 2',
+  auxData: {
+    frameId: 'ABCDE' as Protocol.Page.FrameId,
+    isDefault: true,
+    type: 'type',
+  },
+};
+
+describe('RehydratingSession', () => {
+  const sessionId = 1;
+  const messageId = 1;
+  const target = mockTarget1;
+  let mockRehydratingConnection: MockRehydratingConnection;
+  let mockRehydratingSession: Rehydrating.RehydratingSession;
+  const executionContextsForTarget1 = [mockExecutionContext1, mockExecutionContext2];
+  const scriptsForTarget1 = [mockScript1, mockScript2];
+
+  class MockRehydratingConnection implements Rehydrating.RehydratingConnectionInterface {
+    messageQueue: ServerMessage[] = [];
+
+    postToFrontend(arg: ServerMessage): void {
+      this.messageQueue.push(arg);
+    }
+
+    clearMessageQueue(): void {
+      this.messageQueue = [];
+    }
+  }
+
+  class RehydratingSessionForTest extends Rehydrating.RehydratingSession {
+    override sendMessageToFrontend(payload: ServerMessage): void {
+      this.connection?.postToFrontend(payload);
+    }
+  }
+
+  beforeEach(() => {
+    mockRehydratingConnection = new MockRehydratingConnection();
+    mockRehydratingSession = new RehydratingSessionForTest(
+        sessionId, target, executionContextsForTarget1, scriptsForTarget1, mockRehydratingConnection);
+  });
+
+  it('send attach to target on construction', async function() {
+    const attachToTargetMessage = mockRehydratingConnection.messageQueue[0];
+    assert.isNotNull(attachToTargetMessage);
+    assert.strictEqual(attachToTargetMessage.method, 'Target.attachedToTarget');
+    assert.strictEqual(
+        (attachToTargetMessage.params as Protocol.Target.AttachedToTargetEvent).sessionId.toString(),
+        sessionId.toString());
+    assert.strictEqual(
+        (attachToTargetMessage.params as Protocol.Target.AttachedToTargetEvent).targetInfo.targetId.toString(),
+        target.targetId.toString());
+  });
+
+  it('sends script parsed and debugger id while handling debugger enable', async function() {
+    mockRehydratingConnection.clearMessageQueue();
+    mockRehydratingSession.handleFrontendMessageAsFakeCDPAgent({
+      id: messageId,
+      method: 'Debugger.enable',
+      sessionId,
+    });
+    assert.strictEqual(mockRehydratingConnection.messageQueue.length, 3);
+    const scriptParsedMessages = mockRehydratingConnection.messageQueue.slice(0, 2);
+    const resultMessage = mockRehydratingConnection.messageQueue.slice(2);
+    for (const scriptParsedMessage of scriptParsedMessages) {
+      assert.strictEqual(scriptParsedMessage.method, 'Debugger.scriptParsed');
+      assert.strictEqual((scriptParsedMessage.params as RehydratingScript).isolate, target.isolate);
+    }
+    assert.isNotNull(resultMessage[0]);
+    assert.strictEqual(resultMessage[0].id, messageId);
+    assert.isNotNull((resultMessage[0].result as Protocol.Debugger.EnableResponse).debuggerId);
+  });
+
+  it('sends execution context created while handling runtime enable', async function() {
+    mockRehydratingConnection.clearMessageQueue();
+    mockRehydratingSession.handleFrontendMessageAsFakeCDPAgent({
+      id: messageId,
+      method: 'Runtime.enable',
+      sessionId,
+    });
+    assert.strictEqual(mockRehydratingConnection.messageQueue.length, 3);
+    const executionContextCreatedMessages = mockRehydratingConnection.messageQueue.slice(0, 2);
+    const resultMessage = mockRehydratingConnection.messageQueue.slice(2);
+    for (const executionContextCreatedMessage of executionContextCreatedMessages) {
+      assert.strictEqual(executionContextCreatedMessage.method, 'Runtime.executionContextCreated');
+      assert.strictEqual(
+          (executionContextCreatedMessage.params as Protocol.Runtime.ExecutionContextCreatedEvent)
+              .context.auxData.frameId,
+          target.targetId);
+    }
+    assert.isNotNull(resultMessage[0]);
+    assert.strictEqual(resultMessage[0].id, messageId);
+  });
+
+  it('sends script source text while handling get script source', async function() {
+    mockRehydratingConnection.clearMessageQueue();
+    mockRehydratingSession.handleFrontendMessageAsFakeCDPAgent({
+      id: messageId,
+      method: 'Debugger.getScriptSource',
+      sessionId,
+      params: {
+        scriptId: mockScript1.scriptId,
+      },
+    });
+    assert.strictEqual(mockRehydratingConnection.messageQueue.length, 1);
+    const scriptSourceTextMessage = mockRehydratingConnection.messageQueue[0];
+    assert.isNotNull(scriptSourceTextMessage);
+    assert.strictEqual(scriptSourceTextMessage.id, messageId);
+    assert.strictEqual(
+        (scriptSourceTextMessage.result as Protocol.Debugger.GetScriptSourceResponse).scriptSource,
+        mockScript1.sourceText);
+  });
+});

package/front_end/core/sdk/RehydratingConnection.ts

@@ -0,0 +1,310 @@
+// Copyright (c) 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/**
+ * This file is the implementation of a protocol `Connection` object
+ *  which is central to the rehydrated devtools feature. The premise of
+ * this feature is that the enhanced traces will contain enough
+ * information to power this class with all metadata needed. This class
+ * then interacts with rehydrated devtools in a way that produces the
+ * equivalent result as live debugging session.
+ *
+ * It's much more of a state machine than the other Connection
+ * implementations, which simply interact with a network protocol in
+ * one way or another.
+ *
+ * Note on the methodology to derive runtime/debugger domain behavior below:
+ * We can use protocol monitor in the devtools to look at how dt-fe
+ * communicates with the backend, and it's also how majority of the behavior
+ * in the rehydrated sesion was derived at the first place. In the event of
+ * adding more support and capability to rehydrated session, developers will
+ * want to look at protocol monitor to imitate the behavior in a real session
+ *
+ */
+
+import type * as Protocol from '../../generated/protocol.js';
+import * as i18n from '../i18n/i18n.js';
+import type * as ProtocolClient from '../protocol_client/protocol_client.js';
+
+import * as EnhancedTraces from './EnhancedTracesParser.js';
+import type {
+  ProtocolMessage, RehydratingExecutionContext, RehydratingScript, RehydratingTarget, ServerMessage} from
+  './RehydratingObject.js';
+
+const UIStrings = {
+  /**
+   * @description Text that appears when no source text is available for the given script
+   */
+  noSourceText: 'No source text available',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/RehydratingConnection.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+
+export interface RehydratingConnectionInterface {
+  postToFrontend: (arg: ServerMessage) => void;
+}
+
+export const enum RehydratingConnectionState {
+  UNINITIALIZED = 1,
+  INITIALIZED = 2,
+  REHYDRATED = 3,
+}
+
+export class RehydratingConnection implements ProtocolClient.InspectorBackend.Connection {
+  rehydratingConnectionState: RehydratingConnectionState = RehydratingConnectionState.UNINITIALIZED;
+  onDisconnect: ((arg0: string) => void)|null = null;
+  onMessage: ((arg0: Object) => void)|null = null;
+  traceEvents: unknown[] = [];
+  sessions: Map<number, RehydratingSessionBase> = new Map();
+  private static rehydratingConnectionInstance: RehydratingConnection|null = null;
+
+  private constructor() {
+  }
+
+  static instance(): RehydratingConnection {
+    if (!this.rehydratingConnectionInstance) {
+      this.rehydratingConnectionInstance = new RehydratingConnection();
+    }
+    return this.rehydratingConnectionInstance;
+  }
+
+  async startHydration(logPayload: string): Promise<boolean> {
+    // OnMessage should've been set before hydration, and the connection should
+    // be initialized and not hydrated already.
+    if (!this.onMessage || this.rehydratingConnectionState !== RehydratingConnectionState.INITIALIZED) {
+      return false;
+    }
+
+    const payload = JSON.parse(logPayload);
+    if (!('traceEvents' in payload)) {
+      console.error('RehydratingConnection failed to initialize due to missing trace events in payload');
+      return false;
+    }
+
+    this.traceEvents = payload.traceEvents;
+    const enhancedTracesParser = new EnhancedTraces.EnhancedTracesParser(this.traceEvents);
+    const dataPerTarget = enhancedTracesParser.data();
+
+    let sessionId = 0;
+    // Set up default rehydrating session.
+    this.sessions.set(sessionId, new RehydratingSessionBase(this));
+    for (const [target, [executionContexts, scripts]] of dataPerTarget.entries()) {
+      this.postToFrontend({
+        method: 'Target.targetCreated',
+        params: {
+          targetInfo: {
+            targetId: target.targetId,
+            type: target.type,
+            title: target.url,
+            url: target.url,
+            attached: false,
+            canAccessOpener: false,
+          },
+        },
+      });
+
+      // Create new session associated to the target created and send
+      // Target.attachedToTarget to frontend.
+      sessionId += 1;
+      this.sessions.set(sessionId, new RehydratingSession(sessionId, target, executionContexts, scripts, this));
+    }
+    this.rehydratingConnectionState = RehydratingConnectionState.REHYDRATED;
+    return true;
+  }
+
+  setOnMessage(onMessage: (arg0: (Object|string)) => void): void {
+    this.onMessage = onMessage;
+    this.rehydratingConnectionState = RehydratingConnectionState.INITIALIZED;
+  }
+
+  setOnDisconnect(onDisconnect: (arg0: string) => void): void {
+    this.onDisconnect = onDisconnect;
+  }
+
+  // The function "sendRawMessage" is typically devtools front-end
+  // sending message to the backend via CDP. In this case, given that Rehydrating
+  // connection is an emulation of devtool back-end, sendRawMessage here
+  // is in fact rehydrating connection directly handling and acting on the
+  // receieved message.
+  sendRawMessage(message: string|object): void {
+    if (typeof message === 'string') {
+      message = JSON.parse(message);
+    }
+    const data = message as ProtocolMessage;
+    if (typeof data.sessionId !== 'undefined') {
+      const session = this.sessions.get(data.sessionId);
+      if (session) {
+        session.handleFrontendMessageAsFakeCDPAgent(data);
+      } else {
+        console.error('Invalid SessionId: ' + data.sessionId);
+      }
+    } else {
+      this.sessions.get(0)?.handleFrontendMessageAsFakeCDPAgent(data);
+    }
+  }
+
+  // Posting rehydrating connection's message/response
+  // to devtools frontend through debugger protocol.
+  postToFrontend(arg: ServerMessage): void {
+    if (this.onMessage) {
+      this.onMessage(arg);
+    } else {
+      // onMessage should be set before the connection is rehydrated
+      console.error('onMessage was not initialized');
+    }
+  }
+
+  disconnect(): Promise<void> {
+    return Promise.reject();
+  }
+}
+
+// Default rehydrating session with default responses.
+class RehydratingSessionBase {
+  connection: RehydratingConnectionInterface|null = null;
+
+  constructor(connection: RehydratingConnectionInterface) {
+    this.connection = connection;
+  }
+
+  sendMessageToFrontend(payload: ServerMessage): void {
+    requestAnimationFrame(() => {
+      if (this.connection) {
+        this.connection.postToFrontend(payload);
+      }
+    });
+  }
+
+  handleFrontendMessageAsFakeCDPAgent(data: ProtocolMessage): void {
+    // Send default response in default session.
+    this.sendMessageToFrontend({
+      id: data.id,
+      result: {},
+    });
+  }
+}
+
+export class RehydratingSession extends RehydratingSessionBase {
+  sessionId: number;
+  target: RehydratingTarget;
+  executionContexts: RehydratingExecutionContext[] = [];
+  scripts: RehydratingScript[] = [];
+
+  constructor(
+      sessionId: number, target: RehydratingTarget, executionContexts: RehydratingExecutionContext[],
+      scripts: RehydratingScript[], connection: RehydratingConnectionInterface) {
+    super(connection);
+    this.sessionId = sessionId;
+    this.target = target;
+    this.executionContexts = executionContexts;
+    this.scripts = scripts;
+    this.sessionAttachToTarget();
+  }
+
+  override sendMessageToFrontend(payload: ServerMessage, attachSessionId: boolean = true): void {
+    // Attach the session's Id to the message.
+    if (this.sessionId !== 0 && attachSessionId) {
+      payload.sessionId = this.sessionId;
+    }
+    super.sendMessageToFrontend(payload);
+  }
+
+  override handleFrontendMessageAsFakeCDPAgent(data: ProtocolMessage): void {
+    switch (data.method) {
+      case 'Runtime.enable':
+        this.handleRuntimeEnabled(data.id);
+        break;
+      case 'Debugger.enable':
+        this.handleDebuggerEnable(data.id);
+        break;
+      case 'Debugger.getScriptSource':
+        if (data.params) {
+          const params = data.params as Protocol.Debugger.GetScriptSourceRequest;
+          this.handleDebuggerGetScriptSource(data.id, params.scriptId);
+        }
+        break;
+      default:
+        this.sendMessageToFrontend({
+          id: data.id,
+          result: {},
+        });
+        break;
+    }
+  }
+
+  private sessionAttachToTarget(): void {
+    this.sendMessageToFrontend(
+        {
+          method: 'Target.attachedToTarget',
+          params: {
+            sessionId: this.sessionId,
+            waitingForDebugger: false,
+            targetInfo: {
+              targetId: this.target.targetId,
+              type: this.target.type,
+              title: this.target.url,
+              url: this.target.url,
+              attached: true,
+              canAccessOpener: false,
+            },
+          },
+        },
+        /* attachSessionId */ false);
+  }
+
+  // Runtime.Enable indicates that Runtime domain is flushing the event to communicate
+  // the current state with the backend. In rehydrating connection, we made up the artificial
+  // execution context to support the rehydrated session.
+  private handleRuntimeEnabled(id: number): void {
+    for (const executionContext of this.executionContexts) {
+      executionContext.name = executionContext.origin;
+      this.sendMessageToFrontend({
+        method: 'Runtime.executionContextCreated',
+        params: {
+          context: executionContext,
+        },
+      });
+    }
+
+    this.sendMessageToFrontend({
+      id,
+      result: {},
+    });
+  }
+
+  private handleDebuggerGetScriptSource(id: number, scriptId: Protocol.Runtime.ScriptId): void {
+    const script = this.scripts.find(script => script.scriptId === scriptId);
+    if (!script) {
+      console.error('No script for id: ' + scriptId);
+      return;
+    }
+    this.sendMessageToFrontend({
+      id,
+      result: {
+        scriptSource: typeof script.sourceText === 'undefined' ? i18nString(UIStrings.noSourceText) : script.sourceText,
+      },
+    });
+  }
+
+  // Debugger.Enable indicates that Debugger domain is flushing the event to communicate
+  // the current state with the backend. In rehydrating connection, we made up the artificial
+  // script parsed event to communicate the current script state and respond with a mock
+  // debugger id.
+  private handleDebuggerEnable(id: number): void {
+    for (const script of this.scripts) {
+      this.sendMessageToFrontend({
+        method: 'Debugger.scriptParsed',
+        params: script,
+      });
+    }
+
+    const mockDebuggerId = '7777777777777777777.8888888888888888888';
+    this.sendMessageToFrontend({
+      id,
+      result: {
+        debuggerId: mockDebuggerId,
+      },
+    });
+  }
+}

package/front_end/core/sdk/RehydratingObject.ts

@@ -45,6 +45,30 @@ export interface RehydratingTarget {
   isolate?: string;
 }
 
-export interface EnhancedTracesData {
-  data: Map<RehydratingTarget, [RehydratingExecutionContext[], RehydratingScript[]]>;
+export type HydratingDataPerTarget = Map<RehydratingTarget, [RehydratingExecutionContext[], RehydratingScript[]]>;
+
+export interface ProtocolMessage {
+  id: number;
+  method: string;
+  sessionId?: number;
+  params?: object;
+}
+
+export interface ProtocolEvent {
+  method: string;
+  params: object;
+}
+
+export interface ProtocolResponse {
+  id: number;
+}
+
+export type ServerMessage = (ProtocolEvent|ProtocolMessage|ProtocolResponse)&{
+  [others: string]: unknown,
+};
+
+export interface Session {
+  target: RehydratingTarget;
+  executionContexts: RehydratingExecutionContext[];
+  scripts: RehydratingScript[];
 }

package/front_end/core/sdk/RemoteObject.ts

@@ -34,10 +34,10 @@
 
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
-import {type DOMPinnedWebIDLProp, type DOMPinnedWebIDLType} from '../common/JavaScriptMetaData.js';
+import type {DOMPinnedWebIDLProp, DOMPinnedWebIDLType} from '../common/JavaScriptMetaData.js';
 
-import {type DebuggerModel, type FunctionDetails} from './DebuggerModel.js';
-import {type RuntimeModel} from './RuntimeModel.js';
+import type {DebuggerModel, FunctionDetails} from './DebuggerModel.js';
+import type {RuntimeModel} from './RuntimeModel.js';
 
 // This cannot be an interface due to "instanceof RemoteObject" checks in the code.
 export class RemoteObject {

package/front_end/core/sdk/Resource.ts

@@ -35,8 +35,8 @@ import * as TextUtils from '../../models/text_utils/text_utils.js';
 import * as Common from '../common/common.js';
 import * as Platform from '../platform/platform.js';
 
-import {type NetworkRequest} from './NetworkRequest.js';
-import {type ResourceTreeFrame, type ResourceTreeModel} from './ResourceTreeModel.js';
+import type {NetworkRequest} from './NetworkRequest.js';
+import type {ResourceTreeFrame, ResourceTreeModel} from './ResourceTreeModel.js';
 
 export class Resource implements TextUtils.ContentProvider.ContentProvider {
   readonly #resourceTreeModel: ResourceTreeModel;

package/front_end/core/sdk/ResourceTreeModel.ts

@@ -41,7 +41,7 @@ import * as Platform from '../platform/platform.js';
 import {type DeferredDOMNode, DOMModel, type DOMNode} from './DOMModel.js';
 import {FrameManager} from './FrameManager.js';
 import {Events as NetworkManagerEvents, NetworkManager, type RequestUpdateDroppedEventData} from './NetworkManager.js';
-import {type NetworkRequest} from './NetworkRequest.js';
+import type {NetworkRequest} from './NetworkRequest.js';
 import {Resource} from './Resource.js';
 import {ExecutionContext, RuntimeModel} from './RuntimeModel.js';
 import {SDKModel} from './SDKModel.js';

package/front_end/core/sdk/RuntimeModel.ts

@@ -634,6 +634,26 @@ export class ExecutionContext {
     return this.evaluateGlobal((evaluationOptions as EvaluationOptions), false, false);
   }
 
+  async callFunctionOn(options: CallFunctionOptions): Promise<EvaluationResult> {
+    const response = await this.runtimeModel.agent.invoke_callFunctionOn({
+      functionDeclaration: options.functionDeclaration,
+      returnByValue: options.returnByValue,
+      userGesture: options.userGesture,
+      awaitPromise: options.awaitPromise,
+      throwOnSideEffect: options.throwOnSideEffect,
+      arguments: options.arguments,
+      // Old back-ends don't know about uniqueContextId (and also don't generate
+      // one), so fall back to contextId in that case (https://crbug.com/1192621).
+      ...(this.uniqueId ? {uniqueContextId: this.uniqueId} : {contextId: this.id}),
+    });
+
+    const error = response.getError();
+    if (error) {
+      return {error};
+    }
+    return {object: this.runtimeModel.createRemoteObject(response.result), exceptionDetails: response.exceptionDetails};
+  }
+
   private async evaluateGlobal(options: EvaluationOptions, userGesture: boolean, awaitPromise: boolean):
       Promise<EvaluationResult> {
     if (!options.expression) {
@@ -725,6 +745,17 @@ export interface EvaluationOptions {
   contextId?: number;
 }
 
+export interface CallFunctionOptions {
+  functionDeclaration: string;
+  includeCommandLineAPI?: boolean;
+  returnByValue?: boolean;
+  throwOnSideEffect?: boolean;
+  allowUnsafeEvalBlockedByCSP?: boolean;
+  arguments: Array<Protocol.Runtime.CallArgument>;
+  userGesture: boolean;
+  awaitPromise: boolean;
+}
+
 export type QueryObjectResult = {
   objects: RemoteObject,
 }|{error: string};

package/front_end/core/sdk/SDKModel.ts

@@ -4,7 +4,7 @@
 
 import * as Common from '../common/common.js';
 
-import {type Target} from './Target.js';
+import type {Target} from './Target.js';
 
 export interface RegistrationInfo {
   capabilities: number;

package/front_end/core/sdk/Script.ts

@@ -40,12 +40,12 @@ import {
   Location,
   LOGPOINT_SOURCE_URL,
 } from './DebuggerModel.js';
-import {type FrameAssociated} from './FrameAssociated.js';
-import {type PageResourceLoadInitiator} from './PageResourceLoader.js';
+import type {FrameAssociated} from './FrameAssociated.js';
+import type {PageResourceLoadInitiator} from './PageResourceLoader.js';
 import {ResourceTreeModel} from './ResourceTreeModel.js';
-import {type ExecutionContext} from './RuntimeModel.js';
-import {type SourceMap} from './SourceMap.js';
-import {type Target} from './Target.js';
+import type {ExecutionContext} from './RuntimeModel.js';
+import type {SourceMap} from './SourceMap.js';
+import type {Target} from './Target.js';
 
 const UIStrings = {
   /**
@@ -498,7 +498,7 @@ function frameIdForScript(script: Script): Protocol.Page.FrameId|null {
 
 export const sourceURLRegex = /^[\x20\t]*\/\/[@#] sourceURL=\s*(\S*?)\s*$/;
 
-async function disassembleWasm(content: string): Promise<TextUtils.WasmDisassembly.WasmDisassembly> {
+export async function disassembleWasm(content: string): Promise<TextUtils.WasmDisassembly.WasmDisassembly> {
   const worker = Common.Worker.WorkerWrapper.fromURL(
       new URL('../../entrypoints/wasmparser_worker/wasmparser_worker-entrypoint.js', import.meta.url));
   const promise = new Promise<TextUtils.WasmDisassembly.WasmDisassembly>((resolve, reject) => {

package/front_end/core/sdk/ServiceWorkerCacheModel.ts

@@ -2,18 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
 import * as Common from '../common/common.js';
 import * as i18n from '../i18n/i18n.js';
 import type * as Platform from '../platform/platform.js';
-import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
-import type * as Protocol from '../../generated/protocol.js';
 
-import {type NameValue} from './NetworkRequest.js';
-
-import {Capability, type Target} from './Target.js';
+import type {NameValue} from './NetworkRequest.js';
 import {SDKModel} from './SDKModel.js';
-
-import {Events as StorageBucketsModelEvents, StorageBucketsModel, type BucketEvent} from './StorageBucketsModel.js';
+import {type BucketEvent, Events as StorageBucketsModelEvents, StorageBucketsModel} from './StorageBucketsModel.js';
+import {Capability, type Target} from './Target.js';
 
 const UIStrings = {
   /**

package/front_end/core/sdk/SourceMap.ts

@@ -37,7 +37,7 @@ import * as Common from '../common/common.js';
 import * as Platform from '../platform/platform.js';
 import * as Root from '../root/root.js';
 
-import {type CallFrame, type ScopeChainEntry} from './DebuggerModel.js';
+import type {CallFrame, ScopeChainEntry} from './DebuggerModel.js';
 import {SourceMapScopesInfo} from './SourceMapScopesInfo.js';
 
 /**