chrome-devtools-frontend 1.0.1538523 → 1.0.1539972

package/front_end/core/protocol_client/InspectorBackend.ts

@@ -7,14 +7,17 @@ import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import type * as Protocol from '../../generated/protocol.js';
 import type * as Platform from '../platform/platform.js';
 
+import {
+  type CDPConnection,
+  type CDPConnectionObserver,
+  CDPErrorStatus,
+  type CDPEvent,
+  type Command,
+  type CommandParams,
+  type Event
+} from './CDPConnection.js';
 import {ConnectionTransport} from './ConnectionTransport.js';
-import {NodeURL} from './NodeURL.js';
-
-export const DevToolsStubErrorCode = -32015;
-// TODO(dgozman): we are not reporting generic errors in tests, but we should
-// instead report them and just have some expected errors in test expectations.
-const GenericErrorCode = -32000;
-const ConnectionClosedErrorCode = -32001;
+import {DevToolsCDPConnection} from './DevToolsCDPConnection.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type MessageParams = Record<string, any>;
@@ -59,25 +62,9 @@ export const qualifyName = (domain: string, name: UnqualifiedName): QualifiedNam
 type EventParameterNames = Map<QualifiedName, string[]>;
 type ReadonlyEventParameterNames = ReadonlyMap<QualifiedName, string[]>;
 
-interface CommandParameter {
-  name: string;
-  type: string;
-  optional: boolean;
-  description: string;
-}
-
-type Callback = (error: MessageError|null, arg1: Object|null) => void;
-interface ResponseWithError {
-  error: MessageError|null;
-  result: Object|null;
-}
-
-interface CallbackWithDebugInfo {
-  resolve: (response: ResponseWithError) => void;
-  method: string;
-}
+type CommandParameter = InspectorBackendCommands.CommandParameter;
 
-export class InspectorBackend {
+export class InspectorBackend implements InspectorBackendCommands.InspectorBackendAPI {
   readonly agentPrototypes = new Map<ProtocolDomainName, AgentPrototype>();
   #eventParameterNamesForDomain = new Map<ProtocolDomainName, EventParameterNames>();
   readonly typeMap = new Map<QualifiedName, CommandParameter[]>();
@@ -195,49 +182,19 @@ export const test = {
   onMessageReceived: null as ((message: Object) => void) | null,
 };
 
-const LongPollingMethods = new Set<string>(['CSS.takeComputedStyleUpdates']);
-
-export class SessionRouter {
-  readonly #connection: ConnectionTransport;
-  #lastMessageId = 1;
-  #pendingResponsesCount = 0;
-  readonly #pendingLongPollingMessageIds = new Set<number>();
+export class SessionRouter implements CDPConnectionObserver {
+  readonly #connection: CDPConnection;
   readonly #sessions = new Map<string, {
     target: TargetBase,
-    callbacks: Map<number, CallbackWithDebugInfo>,
-    proxyConnection: ConnectionTransport|undefined|null,
   }>();
-  #pendingScripts: Array<() => void> = [];
 
-  constructor(connection: ConnectionTransport) {
+  constructor(connection: CDPConnection) {
     this.#connection = connection;
+    this.#connection.observe(this);
+  }
 
-    test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
-    test.sendRawMessage = this.sendRawMessageForTesting.bind(this);
-
-    this.#connection.setOnMessage(this.onMessage.bind(this));
-
-    this.#connection.setOnDisconnect(reason => {
-      const session = this.#sessions.get('');
-      if (session) {
-        session.target.dispose(reason);
-      }
-    });
-  }
-
-  registerSession(target: TargetBase, sessionId: string, proxyConnection?: ConnectionTransport|null): void {
-    // Only the Audits panel uses proxy connections. If it is ever possible to have multiple active at the
-    // same time, it should be tested thoroughly.
-    if (proxyConnection) {
-      for (const session of this.#sessions.values()) {
-        if (session.proxyConnection) {
-          console.error('Multiple simultaneous proxy connections are currently unsupported');
-          break;
-        }
-      }
-    }
-
-    this.#sessions.set(sessionId, {target, callbacks: new Map(), proxyConnection});
+  registerSession(target: TargetBase, sessionId: string): void {
+    this.#sessions.set(sessionId, {target});
   }
 
   unregisterSession(sessionId: string): void {
@@ -245,178 +202,27 @@ export class SessionRouter {
     if (!session) {
       return;
     }
-    for (const {resolve, method} of session.callbacks.values()) {
-      resolve({
-        result: null,
-        error: {
-          message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
-          code: ConnectionClosedErrorCode,
-          data: null,
-        }
-      });
+    if (this.#connection instanceof DevToolsCDPConnection) {
+      this.#connection.resolvePendingCalls(sessionId);
     }
     this.#sessions.delete(sessionId);
   }
 
-  private nextMessageId(): number {
-    return this.#lastMessageId++;
-  }
-
-  connection(): ConnectionTransport {
-    return this.#connection;
-  }
-
-  sendMessage(sessionId: string, domain: string, method: QualifiedName, params: Object|null):
-      Promise<ResponseWithError> {
-    const messageId = this.nextMessageId();
-    const messageObject: Message = {
-      id: messageId,
-      method,
-    };
-
-    if (params) {
-      messageObject.params = params;
+  onDisconnect(reason: string): void {
+    const session = this.#sessions.get('');
+    if (session) {
+      session.target.dispose(reason);
     }
-    if (sessionId) {
-      messageObject.sessionId = sessionId;
-    }
-
-    if (test.dumpProtocol) {
-      test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
-    }
-
-    if (test.onMessageSent) {
-      const paramsObject = JSON.parse(JSON.stringify(params || {}));
-      test.onMessageSent({domain, method, params: (paramsObject as Object), id: messageId, sessionId});
-    }
-
-    ++this.#pendingResponsesCount;
-    if (LongPollingMethods.has(method)) {
-      this.#pendingLongPollingMessageIds.add(messageId);
-    }
-
-    const session = this.#sessions.get(sessionId);
-    if (!session) {
-      return Promise.resolve({error: null, result: null});
-    }
-
-    return new Promise(resolve => {
-      session.callbacks.set(messageId, {resolve, method});
-      this.#connection.sendRawMessage(JSON.stringify(messageObject));
-    });
-  }
-
-  private sendRawMessageForTesting(method: QualifiedName, params: Object|null, callback: Callback|null, sessionId = ''):
-      void {
-    const domain = method.split('.')[0];
-    void this.sendMessage(sessionId, domain, method, params).then(({error, result}) => callback?.(error, result));
   }
 
-  private onMessage(message: string|Object): void {
-    if (test.dumpProtocol) {
-      test.dumpProtocol('backend: ' + ((typeof message === 'string') ? message : JSON.stringify(message)));
-    }
-
-    if (test.onMessageReceived) {
-      const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
-      test.onMessageReceived(messageObjectCopy);
-    }
-
-    const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message) as Message;
-
-    // Send all messages to proxy connections.
-    let suppressUnknownMessageErrors = false;
-    for (const session of this.#sessions.values()) {
-      if (!session.proxyConnection) {
-        continue;
-      }
-
-      if (!session.proxyConnection.onMessage) {
-        InspectorBackend.reportProtocolError(
-            'Protocol Error: the session has a proxyConnection with no _onMessage', messageObject);
-        continue;
-      }
-
-      session.proxyConnection.onMessage(messageObject);
-      suppressUnknownMessageErrors = true;
-    }
-
-    const sessionId = messageObject.sessionId || '';
+  onEvent<T extends Event>(event: CDPEvent<T>): void {
+    const sessionId = event.sessionId || '';
     const session = this.#sessions.get(sessionId);
-    if (!session) {
-      // In the DevTools MCP case, we may share the transport with puppeteer so we silently
-      // ignore unknown sessions.
-      return;
-    }
-
-    // If this message is directly for the target controlled by the proxy connection, don't handle it.
-    if (session.proxyConnection) {
-      return;
-    }
-
-    if (session.target.getNeedsNodeJSPatching()) {
-      NodeURL.patch(messageObject);
-    }
-
-    if (messageObject.id !== undefined) {  // just a response for some request
-      const callback = session.callbacks.get(messageObject.id);
-      session.callbacks.delete(messageObject.id);
-      if (!callback) {
-        if (messageObject.error?.code === ConnectionClosedErrorCode) {
-          // Ignore the errors that are sent as responses after the session closes.
-          return;
-        }
-        if (!suppressUnknownMessageErrors) {
-          InspectorBackend.reportProtocolError('Protocol Error: the message with wrong id', messageObject);
-        }
-        return;
-      }
-
-      callback.resolve({error: messageObject.error || null, result: messageObject.result || null});
-      --this.#pendingResponsesCount;
-      this.#pendingLongPollingMessageIds.delete(messageObject.id);
-
-      if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
-        this.deprecatedRunAfterPendingDispatches();
-      }
-    } else {
-      if (messageObject.method === undefined) {
-        InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
-        return;
-      }
-      // This cast is justified as we just checked for the presence of messageObject.method.
-      const eventMessage = messageObject as EventMessage;
-      session.target.dispatch(eventMessage);
-    }
-  }
-
-  private hasOutstandingNonLongPollingRequests(): boolean {
-    return this.#pendingResponsesCount - this.#pendingLongPollingMessageIds.size > 0;
-  }
-
-  private deprecatedRunAfterPendingDispatches(script?: (() => void)): void {
-    if (script) {
-      this.#pendingScripts.push(script);
-    }
-
-    // Execute all promises.
-    window.setTimeout(() => {
-      if (!this.hasOutstandingNonLongPollingRequests()) {
-        this.executeAfterPendingDispatches();
-      } else {
-        this.deprecatedRunAfterPendingDispatches();
-      }
-    }, 0);
+    session?.target.dispatch(event as unknown as EventMessage);
   }
 
-  private executeAfterPendingDispatches(): void {
-    if (!this.hasOutstandingNonLongPollingRequests()) {
-      const scripts = this.#pendingScripts;
-      this.#pendingScripts = [];
-      for (let id = 0; id < scripts.length; ++id) {
-        scripts[id]();
-      }
-    }
+  get connection(): CDPConnection {
+    return this.#connection;
   }
 }
 
@@ -439,16 +245,12 @@ interface DispatcherMap extends Map<ProtocolDomainName, ProtocolProxyApi.Protoco
 }
 
 export class TargetBase {
-  needsNodeJSPatching: boolean;
   readonly sessionId: string;
   #router: SessionRouter|null;
   #agents: AgentsMap = new Map();
   #dispatchers: DispatcherMap = new Map();
 
-  constructor(
-      needsNodeJSPatching: boolean, parentTarget: TargetBase|null, sessionId: string,
-      connection: ConnectionTransport|null) {
-    this.needsNodeJSPatching = needsNodeJSPatching;
+  constructor(parentTarget: TargetBase|null, sessionId: string, connection: CDPConnection|null) {
     this.sessionId = sessionId;
 
     if (parentTarget && !sessionId) {
@@ -461,7 +263,7 @@ export class TargetBase {
     } else if (connection) {
       router = new SessionRouter(connection);
     } else {
-      router = new SessionRouter(ConnectionTransport.getFactory()());
+      router = new SessionRouter(new DevToolsCDPConnection(ConnectionTransport.getFactory()()));
     }
 
     this.#router = router;
@@ -503,10 +305,6 @@ export class TargetBase {
     return !this.#router;
   }
 
-  markAsNodeJSForTest(): void {
-    this.needsNodeJSPatching = true;
-  }
-
   router(): SessionRouter|null {
     return this.#router;
   }
@@ -836,12 +634,15 @@ export class TargetBase {
   registerWebAuthnDispatcher(dispatcher: ProtocolProxyApi.WebAuthnDispatcher): void {
     this.registerDispatcher('WebAuthn', dispatcher);
   }
-
-  getNeedsNodeJSPatching(): boolean {
-    return this.needsNodeJSPatching;
-  }
 }
 
+/** These are not logged as console.error */
+const IGNORED_ERRORS = new Set<CDPErrorStatus>([
+  CDPErrorStatus.DEVTOOLS_STUB_ERROR,
+  CDPErrorStatus.SERVER_ERROR,
+  CDPErrorStatus.SESSION_NOT_FOUND,
+]);
+
 /**
  * This is a class that serves as the prototype for a domains #agents (every target
  * has it's own set of #agents). The InspectorBackend keeps an instance of this class
@@ -875,21 +676,26 @@ class AgentPrototype {
   }
 
   private invoke(method: QualifiedName, request: Object|null): Promise<Protocol.ProtocolResponseWithError> {
-    const router = this.target.router();
-    if (!router) {
+    const connection = this.target.router()?.connection;
+    if (!connection) {
       return Promise.resolve(
           {result: null, getError: () => `Connection is closed, can\'t dispatch pending call to ${method}`});
     }
 
-    return router.sendMessage(this.target.sessionId, this.domain, method, request).then(({error, result}) => {
-      if (error && !test.suppressRequestErrors && error.code !== DevToolsStubErrorCode &&
-          error.code !== GenericErrorCode && error.code !== ConnectionClosedErrorCode) {
-        console.error('Request ' + method + ' failed. ' + JSON.stringify(error));
-      }
-
-      const errorMessage = error?.message;
-      return {...result, getError: () => errorMessage};
-    });
+    return connection.send(method as Command, request as CommandParams<Command>, this.target.sessionId)
+        .then(response => {
+          if ('error' in response && response.error) {
+            if (!test.suppressRequestErrors && !IGNORED_ERRORS.has(response.error.code)) {
+              console.error('Request ' + method + ' failed. ' + JSON.stringify(response.error));
+            }
+            return {getError: () => response.error.message};
+          }
+
+          if ('result' in response) {
+            return {...response.result, getError: () => undefined};
+          }
+          return {getError: () => undefined};
+        });
   }
 }
 

package/front_end/core/protocol_client/protocol_client.ts

@@ -4,12 +4,12 @@
 
 import * as CDPConnection from './CDPConnection.js';
 import * as ConnectionTransport from './ConnectionTransport.js';
+import * as DevToolsCDPConnection from './DevToolsCDPConnection.js';
 import * as InspectorBackend from './InspectorBackend.js';
-import * as NodeURL from './NodeURL.js';
 
 export {
   CDPConnection,
   ConnectionTransport,
+  DevToolsCDPConnection,
   InspectorBackend,
-  NodeURL,
 };

package/front_end/core/sdk/ChildTargetManager.ts

@@ -7,9 +7,7 @@ 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 Host from '../host/host.js';
-import type * as ProtocolClient from '../protocol_client/protocol_client.js';
 
-import {ParallelConnection} from './Connections.js';
 import {PrimaryPageChangeType, ResourceTreeModel} from './ResourceTreeModel.js';
 import {SDKModel} from './SDKModel.js';
 import {SecurityOriginManager} from './SecurityOriginManager.js';
@@ -36,7 +34,6 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   readonly #targetInfos = new Map<Protocol.Target.TargetID, Protocol.Target.TargetInfo>();
   readonly #childTargetsBySessionId = new Map<Protocol.Target.SessionID, Target>();
   readonly #childTargetsById = new Map<Protocol.Target.TargetID|'main', Target>();
-  readonly #parallelConnections = new Map<string, ProtocolClient.ConnectionTransport.ConnectionTransport>();
   #parentTargetId: Protocol.Target.TargetID|null = null;
 
   constructor(parentTarget: Target) {
@@ -244,15 +241,11 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   }
 
   detachedFromTarget({sessionId}: Protocol.Target.DetachedFromTargetEvent): void {
-    if (this.#parallelConnections.has(sessionId)) {
-      this.#parallelConnections.delete(sessionId);
-    } else {
-      const target = this.#childTargetsBySessionId.get(sessionId);
-      if (target) {
-        target.dispose('target terminated');
-        this.#childTargetsBySessionId.delete(sessionId);
-        this.#childTargetsById.delete(target.id());
-      }
+    const target = this.#childTargetsBySessionId.get(sessionId);
+    if (target) {
+      target.dispose('target terminated');
+      this.#childTargetsBySessionId.delete(sessionId);
+      this.#childTargetsById.delete(target.id());
     }
   }
 
@@ -260,35 +253,6 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
     // We use flatten protocol.
   }
 
-  async createParallelConnection(onMessage: (arg0: Object|string) => void):
-      Promise<{connection: ProtocolClient.ConnectionTransport.ConnectionTransport, sessionId: string}> {
-    // The main Target id is actually just `main`, instead of the real targetId.
-    // Get the real id (requires an async operation) so that it can be used synchronously later.
-    const targetId = await this.getParentTargetId();
-    const {connection, sessionId} =
-        await this.createParallelConnectionAndSessionForTarget(this.#parentTarget, targetId);
-    connection.setOnMessage(onMessage);
-    this.#parallelConnections.set(sessionId, connection);
-    return {connection, sessionId};
-  }
-
-  private async createParallelConnectionAndSessionForTarget(target: Target, targetId: Protocol.Target.TargetID):
-      Promise<{
-        connection: ProtocolClient.ConnectionTransport.ConnectionTransport,
-        sessionId: string,
-      }> {
-    const targetAgent = target.targetAgent();
-    const targetRouter = (target.router() as ProtocolClient.InspectorBackend.SessionRouter);
-    const sessionId = (await targetAgent.invoke_attachToTarget({targetId, flatten: true})).sessionId;
-    const connection = new ParallelConnection(targetRouter.connection(), sessionId);
-    targetRouter.registerSession(target, sessionId, connection);
-    connection.setOnDisconnect(() => {
-      targetRouter.unregisterSession(sessionId);
-      void targetAgent.invoke_detachFromTarget({sessionId});
-    });
-    return {connection, sessionId};
-  }
-
   targetInfos(): Protocol.Target.TargetInfo[] {
     return Array.from(this.#targetInfos.values());
   }

package/front_end/core/sdk/Connections.ts

@@ -9,7 +9,7 @@ import type * as Platform from '../platform/platform.js';
 import * as ProtocolClient from '../protocol_client/protocol_client.js';
 import * as Root from '../root/root.js';
 
-import {RehydratingConnection} from './RehydratingConnection.js';
+import {RehydratingConnectionTransport} from './RehydratingConnection.js';
 
 const UIStrings = {
   /**
@@ -81,7 +81,7 @@ export class MainConnection implements ProtocolClient.ConnectionTransport.Connec
   }
 }
 
-export class WebSocketConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
+export class WebSocketTransport implements ProtocolClient.ConnectionTransport.ConnectionTransport {
   #socket: WebSocket|null;
   onMessage: ((arg0: Object|string) => void)|null = null;
   #onDisconnect: ((arg0: string) => void)|null = null;
@@ -176,7 +176,7 @@ export class WebSocketConnection implements ProtocolClient.ConnectionTransport.C
   }
 }
 
-export class StubConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
+export class StubTransport implements ProtocolClient.ConnectionTransport.ConnectionTransport {
   onMessage: ((arg0: Object|string) => void)|null = null;
   #onDisconnect: ((arg0: string) => void)|null = null;
 
@@ -196,7 +196,7 @@ export class StubConnection implements ProtocolClient.ConnectionTransport.Connec
     const messageObject = JSON.parse(message);
     const error = {
       message: 'This is a stub connection, can\'t dispatch message.',
-      code: ProtocolClient.InspectorBackend.DevToolsStubErrorCode,
+      code: ProtocolClient.CDPConnection.CDPErrorStatus.DEVTOOLS_STUB_ERROR,
       data: messageObject,
     };
     if (this.onMessage) {
@@ -213,80 +213,31 @@ export class StubConnection implements ProtocolClient.ConnectionTransport.Connec
   }
 }
 
-export interface ParallelConnectionInterface extends ProtocolClient.ConnectionTransport.ConnectionTransport {
-  getSessionId: () => string;
-  getOnDisconnect: () => ((arg0: string) => void) | null;
-}
-
-export class ParallelConnection implements ParallelConnectionInterface {
-  readonly #connection: ProtocolClient.ConnectionTransport.ConnectionTransport;
-  #sessionId: string;
-  onMessage: ((arg0: Object) => void)|null = null;
-  #onDisconnect: ((arg0: string) => void)|null = null;
-  constructor(connection: ProtocolClient.ConnectionTransport.ConnectionTransport, sessionId: string) {
-    this.#connection = connection;
-    this.#sessionId = sessionId;
-  }
-
-  setOnMessage(onMessage: (arg0: Object) => void): void {
-    this.onMessage = onMessage;
-  }
-
-  setOnDisconnect(onDisconnect: (arg0: string) => void): void {
-    this.#onDisconnect = onDisconnect;
-  }
-
-  getOnDisconnect(): ((arg0: string) => void)|null {
-    return this.#onDisconnect;
-  }
-
-  sendRawMessage(message: string): void {
-    const messageObject = JSON.parse(message);
-    // If the message isn't for a specific session, it must be for the root session.
-    if (!messageObject.sessionId) {
-      messageObject.sessionId = this.#sessionId;
-    }
-    this.#connection.sendRawMessage(JSON.stringify(messageObject));
-  }
-
-  getSessionId(): string {
-    return this.#sessionId;
-  }
-
-  async disconnect(): Promise<void> {
-    if (this.#onDisconnect) {
-      this.#onDisconnect.call(null, 'force disconnect');
-    }
-    this.#onDisconnect = null;
-    this.onMessage = null;
-  }
-}
-
 export async function initMainConnection(
     createRootTarget: () => Promise<void>,
     onConnectionLost: (message: Platform.UIString.LocalizedString) => void): Promise<void> {
-  ProtocolClient.ConnectionTransport.ConnectionTransport.setFactory(createMainConnection.bind(null, onConnectionLost));
+  ProtocolClient.ConnectionTransport.ConnectionTransport.setFactory(createMainTransport.bind(null, onConnectionLost));
   await createRootTarget();
   Host.InspectorFrontendHost.InspectorFrontendHostInstance.connectionReady();
 }
 
-function createMainConnection(onConnectionLost: (message: Platform.UIString.LocalizedString) => void):
+function createMainTransport(onConnectionLost: (message: Platform.UIString.LocalizedString) => void):
     ProtocolClient.ConnectionTransport.ConnectionTransport {
   if (Root.Runtime.Runtime.isTraceApp()) {
-    return new RehydratingConnection(onConnectionLost);
+    return new RehydratingConnectionTransport(onConnectionLost);
   }
 
   const wsParam = Root.Runtime.Runtime.queryParam('ws');
   const wssParam = Root.Runtime.Runtime.queryParam('wss');
   if (wsParam || wssParam) {
     const ws = (wsParam ? `ws://${wsParam}` : `wss://${wssParam}`) as Platform.DevToolsPath.UrlString;
-    return new WebSocketConnection(ws, onConnectionLost);
+    return new WebSocketTransport(ws, onConnectionLost);
   }
 
   const notEmbeddedOrWs = Host.InspectorFrontendHost.InspectorFrontendHostInstance.isHostedMode();
   if (notEmbeddedOrWs) {
     // eg., hosted mode (e.g. `http://localhost:9222/devtools/inspector.html`) without a WebSocket URL,
-    return new StubConnection();
+    return new StubTransport();
   }
 
   return new MainConnection();

package/front_end/core/sdk/DOMModel.ts

@@ -632,6 +632,7 @@ export class DOMNode {
   }
 
   async getSubtree(depth: number, pierce: boolean): Promise<DOMNode[]|null> {
+    console.assert(depth > 0, 'Do not fetch an infinite subtree to avoid crashing the renderer for large documents');
     const response = await this.#agent.invoke_requestChildNodes({nodeId: this.id, depth, pierce});
     return response.getError() ? null : this.childrenInternal;
   }

package/front_end/core/sdk/DebuggerModel.ts

@@ -5,9 +5,8 @@
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
 import * as Common from '../common/common.js';
-import * as Host from '../host/host.js';
 import * as i18n from '../i18n/i18n.js';
-import * as Platform from '../platform/platform.js';
+import type * as Platform from '../platform/platform.js';
 import * as Root from '../root/root.js';
 
 import type {PageResourceLoadInitiator} from './PageResourceLoader.js';
@@ -18,7 +17,7 @@ import {Script} from './Script.js';
 import {SDKModel} from './SDKModel.js';
 import {SourceMap} from './SourceMap.js';
 import {SourceMapManager} from './SourceMapManager.js';
-import {Capability, type Target, Type} from './Target.js';
+import {Capability, type Target} from './Target.js';
 
 const UIStrings = {
   /**
@@ -456,17 +455,6 @@ export class DebuggerModel extends SDKModel<EventTypes> {
   async setBreakpointByURL(
       url: Platform.DevToolsPath.UrlString, lineNumber: number, columnNumber?: number,
       condition?: BackendCondition): Promise<SetBreakpointResult> {
-    // Convert file url to node-js path.
-    let urlRegex;
-    if (this.target().type() === Type.NODE && Common.ParsedURL.schemeIs(url, 'file:')) {
-      const platformPath = Common.ParsedURL.ParsedURL.urlToRawPathString(url, Host.Platform.isWin());
-      urlRegex =
-          `${Platform.StringUtilities.escapeForRegExp(platformPath)}|${Platform.StringUtilities.escapeForRegExp(url)}`;
-      if (Host.Platform.isWin() && platformPath.match(/^.:\\/)) {
-        // Match upper or lower case drive letter
-        urlRegex = `[${platformPath[0].toUpperCase()}${platformPath[0].toLowerCase()}]` + urlRegex.substr(1);
-      }
-    }
     // Adjust column if needed.
     let minColumnNumber = 0;
     const scripts = this.#scriptsBySourceURL.get(url) || [];
@@ -479,8 +467,7 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     columnNumber = Math.max(columnNumber || 0, minColumnNumber);
     const response = await this.agent.invoke_setBreakpointByUrl({
       lineNumber,
-      url: urlRegex ? undefined : url,
-      urlRegex,
+      url,
       columnNumber,
       condition,
     });

package/front_end/core/sdk/RehydratingConnection.ts

@@ -63,7 +63,7 @@ export const enum RehydratingConnectionState {
   REHYDRATED = 3,
 }
 
-export class RehydratingConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
+export class RehydratingConnectionTransport implements ProtocolClient.ConnectionTransport.ConnectionTransport {
   rehydratingConnectionState: RehydratingConnectionState = RehydratingConnectionState.UNINITIALIZED;
   onDisconnect: ((arg0: string) => void)|null = null;
   onMessage: ((arg0: Object) => void)|null = null;

package/front_end/core/sdk/RemoteObject.ts

@@ -841,6 +841,10 @@ export class LocalJSONObject extends RemoteObject {
       return 'date';
     }
 
+    if (this.#value instanceof Error) {
+      return 'error';
+    }
+
     return undefined;
   }