chrome-devtools-frontend 1.0.1530564 → 1.0.1532228

package/AUTHORS

@@ -65,6 +65,7 @@ Marijn Haverbeke <marijnh@gmail.com>
 Max 😎 Coplan <mchcopl@gmail.com>
 Michael Brüning <michael.bruning@qt.io>
 Michael Rienstra <mrienstra@gmail.com>
+Mostafa Aboalkasim <mostafa.aboalkasim.offical@gmail.com>
 Muhammad Mahad <mahadtxt@gmail.com>
 Naoto Ono <onoto1998@gmail.com>
 Paras Awasthi <awasthiparas6@gmail.com>
@@ -93,6 +94,7 @@ Tony Kostowny <tonykostowny@gmail.com>
 Toshiaki Tanaka <zokutyou2@gmail.com>
 Tushar Singh <tusharvickey1999@gmail.com>
 Varun Varada <varuncvarada@gmail.com>
+Vishwa Kalubowila <vishwa.kalubowila@codimite.com>
 Vitali Zaidman <vzaidman@gmail.com>
 Will Hernandez <w.hernandez.code@gmail.com>
 Yeol Park <peary2@gmail.com>

package/front_end/core/protocol_client/InspectorBackend.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as InspectorBackendCommands from '../../generated/InspectorBackendCommands.js';
 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';
@@ -78,6 +79,15 @@ export class InspectorBackend {
   readonly typeMap = new Map<QualifiedName, CommandParameter[]>();
   readonly enumMap = new Map<QualifiedName, Record<string, string>>();
 
+  constructor() {
+    // Create the global here because registering commands will involve putting
+    // items onto the global.
+    // @ts-expect-error Global namespace instantiation
+    globalThis.Protocol ||= {};
+
+    InspectorBackendCommands.registerCommands(this);
+  }
+
   private getOrCreateEventParameterNamesForDomain(domain: ProtocolDomainName): EventParameterNames {
     let map = this.#eventParameterNamesForDomain.get(domain);
     if (!map) {
@@ -367,9 +377,8 @@ export class SessionRouter {
     const sessionId = messageObject.sessionId || '';
     const session = this.#sessions.get(sessionId);
     if (!session) {
-      if (!suppressUnknownMessageErrors) {
-        InspectorBackend.reportProtocolError('Protocol Error: the message with wrong session id', messageObject);
-      }
+      // In the DevTools MCP case, we may share the transport with puppeteer so we silently
+      // ignore unknown sessions.
       return;
     }
 
@@ -492,12 +501,12 @@ export class TargetBase {
     this.needsNodeJSPatching = needsNodeJSPatching;
     this.sessionId = sessionId;
 
-    if ((!parentTarget && connection) || (!parentTarget && sessionId) || (connection && sessionId)) {
-      throw new Error('Either connection or sessionId (but not both) must be supplied for a child target');
+    if (parentTarget && !sessionId) {
+      throw new Error('Specifying a parent target requires a session ID');
     }
 
     let router: SessionRouter;
-    if (sessionId && parentTarget && parentTarget.#router) {
+    if (parentTarget && parentTarget.#router) {
       router = parentTarget.#router;
     } else if (connection) {
       router = new SessionRouter(connection);

package/front_end/core/protocol_client/protocol_client.ts

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as InspectorBackendCommands from '../../generated/InspectorBackendCommands.js';
-
 import * as InspectorBackend from './InspectorBackend.js';
 import * as NodeURL from './NodeURL.js';
 
@@ -11,11 +9,3 @@ export {
   InspectorBackend,
   NodeURL,
 };
-
-// Create the global here because registering commands will involve putting
-// items onto the global.
-// @ts-expect-error Global namespace instantiation
-globalThis.Protocol = globalThis.Protocol || {};
-
-// FIXME: This instance of InspectorBackend should not be a side effect of importing this module.
-InspectorBackendCommands.registerCommands(InspectorBackend.inspectorBackend);

package/front_end/core/sdk/NetworkManager.ts

@@ -531,7 +531,7 @@ export const Fast4GConditions: Conditions = {
   targetLatency: fast4GTargetLatency,
 };
 
-const MAX_EAGER_POST_REQUEST_BODY_LENGTH = 64 * 1024;  // bytes
+const MAX_EAGER_POST_REQUEST_BODY_LENGTH = 64 * 1024;             // bytes
 const MAX_RESPONSE_BODY_TOTAL_BUFFER_LENGTH = 250 * 1024 * 1024;  // bytes
 
 export class FetchDispatcher implements ProtocolProxyApi.FetchDispatcher {
@@ -1566,11 +1566,12 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
   }
 }
 
-type RequestConditionsSetting = {
+export type RequestConditionsSetting = {
   url: string,
   enabled: boolean,
 }|{
   urlPattern: URLPatternConstructorString,
+  conditions: ThrottlingConditionKey,
   enabled: boolean,
 };
 
@@ -1648,21 +1649,40 @@ export class RequestURLPattern {
 export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<RequestCondition.EventTypes> {
   #pattern: RequestURLPattern|{wildcardURL: string, upgradedPattern?: RequestURLPattern};
   #enabled: boolean;
+  #conditions: ThrottlingConditions;
 
-  constructor(setting: RequestConditionsSetting) {
-    super();
+  static createFromSetting(setting: RequestConditionsSetting): RequestCondition {
     if ('urlPattern' in setting) {
-      this.#pattern = RequestURLPattern.create(setting.urlPattern) ?? {
+      const pattern = RequestURLPattern.create(setting.urlPattern) ?? {
         wildcardURL: setting.urlPattern,
         upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.urlPattern) ?? undefined,
       };
-    } else {
-      this.#pattern = {
-        wildcardURL: setting.url,
-        upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.url) ?? undefined
-      };
+
+      const conditions = getPredefinedOrBlockingCondition(setting.conditions) ??
+          customUserNetworkConditionsSetting().get().find(condition => condition.key === setting.conditions) ??
+          NoThrottlingConditions;
+
+      return new this(pattern, setting.enabled, conditions);
     }
-    this.#enabled = setting.enabled;
+
+    const pattern = {
+      wildcardURL: setting.url,
+      upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.url) ?? undefined
+    };
+    return new this(pattern, setting.enabled, BlockingConditions);
+  }
+
+  static create(pattern: RequestURLPattern, conditions: ThrottlingConditions): RequestCondition {
+    return new this(pattern, /* enabled=*/ true, conditions);
+  }
+
+  private constructor(
+      pattern: RequestURLPattern|{wildcardURL: string, upgradedPattern?: RequestURLPattern}, enabled: boolean,
+      conditions: ThrottlingConditions) {
+    super();
+    this.#pattern = pattern;
+    this.#enabled = enabled;
+    this.#conditions = conditions;
   }
 
   get constructorString(): string|undefined {
@@ -1705,10 +1725,24 @@ export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<Request
     this.dispatchEventToListeners(RequestCondition.Events.REQUEST_CONDITION_CHANGED);
   }
 
+  get conditions(): ThrottlingConditions {
+    return this.#conditions;
+  }
+
+  set conditions(conditions: ThrottlingConditions) {
+    this.#conditions = conditions;
+    this.dispatchEventToListeners(RequestCondition.Events.REQUEST_CONDITION_CHANGED);
+  }
+
   toSetting(): RequestConditionsSetting {
     const enabled = this.enabled;
-    return this.#pattern instanceof RequestURLPattern ? {enabled, urlPattern: this.#pattern.constructorString} :
-                                                        {enabled, url: this.#pattern.wildcardURL};
+    if (this.#pattern instanceof RequestURLPattern) {
+      return {enabled, urlPattern: this.#pattern.constructorString, conditions: this.#conditions.key};
+    }
+    if (this.#conditions !== BlockingConditions && this.#pattern.upgradedPattern) {
+      return {enabled, urlPattern: this.#pattern.upgradedPattern.constructorString, conditions: this.#conditions.key};
+    }
+    return {enabled, url: this.#pattern.wildcardURL};
   }
 
   get originalOrUpgradedURLPattern(): URLPattern|undefined {
@@ -1729,20 +1763,41 @@ export namespace RequestCondition {
 export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<RequestConditions.EventTypes> {
   readonly #setting =
       Common.Settings.Settings.instance().createSetting<RequestConditionsSetting[]>('network-blocked-patterns', []);
-  readonly #conditions: RequestCondition[];
+  readonly #conditionsEnabledSetting =
+      Common.Settings.Settings.instance().moduleSetting<boolean>('request-blocking-enabled');
+  readonly #conditions: RequestCondition[] = [];
 
   constructor() {
     super();
-    this.#conditions = this.#setting.get().map(condition => new RequestCondition(condition));
+    for (const condition of this.#setting.get()) {
+      try {
+        this.#conditions.push(RequestCondition.createFromSetting(condition));
+      } catch (e) {
+        console.error('Error loading throttling settings: ', e);
+      }
+    }
     for (const condition of this.#conditions) {
       condition.addEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
     }
+    this.#conditionsEnabledSetting.addChangeListener(
+        () => this.dispatchEventToListeners(RequestConditions.Events.REQUEST_CONDITIONS_CHANGED));
   }
 
   get count(): number {
     return this.#conditions.length;
   }
 
+  get conditionsEnabled(): boolean {
+    return this.#conditionsEnabledSetting.get();
+  }
+
+  set conditionsEnabled(enabled: boolean) {
+    if (this.#conditionsEnabledSetting.get() === enabled) {
+      return;
+    }
+    this.#conditionsEnabledSetting.set(enabled);
+  }
+
   findCondition(pattern: string): RequestCondition|undefined {
     if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
       return this.#conditions.find(condition => condition.constructorString === pattern);
@@ -1756,6 +1811,9 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
 
   add(...conditions: RequestCondition[]): void {
     this.#conditions.push(...conditions);
+    for (const condition of conditions) {
+      condition.addEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
+    }
     this.#conditionsChanged();
   }
 
@@ -1765,7 +1823,7 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
       return;
     }
     condition.removeEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
-    this.#conditions.splice(index);
+    this.#conditions.splice(index, 1);
     this.#conditionsChanged();
   }
 
@@ -1786,18 +1844,69 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
     return this.#conditions.values();
   }
 
-  applyConditions(...agents: ProtocolProxyApi.NetworkApi[]): boolean {
+  applyConditions(offline: boolean, globalConditions: Conditions|null, ...agents: ProtocolProxyApi.NetworkApi[]):
+      boolean {
+    function isNonBlockingCondition(condition: ThrottlingConditions): condition is Conditions {
+      return !('block' in condition);
+    }
     if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
-      const urlPatterns = this.#conditions.filter(condition => condition.enabled && condition.constructorString)
-                              .map(condition => ({urlPattern: condition.constructorString as string, block: true}));
+      const urlPatterns: Protocol.Network.BlockPattern[] = [];
+      const matchedNetworkConditions: Protocol.Network.NetworkConditions[] = [];
+      if (this.conditionsEnabled) {
+        for (const condition of this.#conditions) {
+          const urlPattern = condition.constructorString;
+          const conditions = condition.conditions;
+          if (!condition.enabled || !urlPattern || conditions === NoThrottlingConditions) {
+            continue;
+          }
+          const block = !isNonBlockingCondition(conditions);
+          urlPatterns.push({urlPattern, block});
+          if (!block) {
+            matchedNetworkConditions.push({
+              urlPattern,
+              latency: conditions.latency,
+              downloadThroughput: conditions.download < 0 ? 0 : conditions.download,
+              uploadThroughput: conditions.upload < 0 ? 0 : conditions.upload,
+              packetLoss: (conditions.packetLoss ?? 0) < 0 ? 0 : conditions.packetLoss,
+              packetQueueLength: conditions.packetQueueLength,
+              packetReordering: conditions.packetReordering,
+              connectionType: NetworkManager.connectionType(conditions),
+            });
+          }
+        }
+
+        if (globalConditions) {
+          matchedNetworkConditions.push({
+            urlPattern: '',
+            latency: globalConditions.latency,
+            downloadThroughput: globalConditions.download < 0 ? 0 : globalConditions.download,
+            uploadThroughput: globalConditions.upload < 0 ? 0 : globalConditions.upload,
+            packetLoss: (globalConditions.packetLoss ?? 0) < 0 ? 0 : globalConditions.packetLoss,
+            packetQueueLength: globalConditions.packetQueueLength,
+            packetReordering: globalConditions.packetReordering,
+            connectionType: NetworkManager.connectionType(globalConditions),
+          });
+        }
+      }
 
       for (const agent of agents) {
         void agent.invoke_setBlockedURLs({urlPatterns});
+        void agent.invoke_emulateNetworkConditionsByRule({offline, matchedNetworkConditions});
+        void agent.invoke_overrideNetworkState({
+          offline,
+          latency: globalConditions?.latency ?? 0,
+          downloadThroughput: !globalConditions || globalConditions.download < 0 ? 0 : globalConditions.download,
+          uploadThroughput: !globalConditions || globalConditions.upload < 0 ? 0 : globalConditions.upload,
+        });
       }
       return urlPatterns.length > 0;
     }
-    const urls = this.#conditions.filter(condition => condition.enabled && condition.wildcardURL)
-                     .map(condition => condition.wildcardURL as string);
+
+    const urls = this.conditionsEnabled ?
+        this.#conditions.filter(condition => condition.enabled && condition.wildcardURL)
+            .map(condition => condition.wildcardURL as string) :
+        [];
+
     for (const agent of agents) {
       void agent.invoke_setBlockedURLs({urls});
     }
@@ -1826,8 +1935,6 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
   readonly inflightMainResourceRequests = new Map<string, NetworkRequest>();
   #networkConditions: Conditions = NoThrottlingConditions;
   #updatingInterceptionPatternsPromise: Promise<void>|null = null;
-  readonly #blockingEnabledSetting =
-      Common.Settings.Settings.instance().moduleSetting<boolean>('request-blocking-enabled');
   readonly #requestConditions = new RequestConditions();
   readonly #urlsForRequestInterceptor:
       Platform.MapUtilities.Multimap<(arg0: InterceptedRequest) => Promise<void>, InterceptionPattern> =
@@ -1844,7 +1951,6 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
       this.updateBlockedPatterns();
       this.dispatchEventToListeners(MultitargetNetworkManager.Events.BLOCKED_PATTERNS_CHANGED);
     };
-    this.#blockingEnabledSetting.addChangeListener(blockedPatternChanged);
     this.#requestConditions.addEventListener(
         RequestConditions.Events.REQUEST_CONDITIONS_CHANGED, blockedPatternChanged);
     this.updateBlockedPatterns();
@@ -1914,7 +2020,8 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
       void networkAgent.invoke_setUserAgentOverride(
           {userAgent: this.currentUserAgent(), userAgentMetadata: this.#userAgentMetadataOverride || undefined});
     }
-    this.#requestConditions.applyConditions(networkAgent);
+    this.#requestConditions.applyConditions(
+        this.isOffline(), this.isThrottling() ? this.#networkConditions : null, networkAgent);
     if (this.isIntercepting()) {
       void fetchAgent.invoke_enable({patterns: this.#urlsForRequestInterceptor.valuesArray()});
     }
@@ -1925,7 +2032,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
     }
     this.#networkAgents.add(networkAgent);
     this.#fetchAgents.add(fetchAgent);
-    if (this.isThrottling()) {
+    if (this.isThrottling() && !Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
       this.updateNetworkConditions(networkAgent);
     }
   }
@@ -1953,8 +2060,13 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
 
   setNetworkConditions(conditions: Conditions): void {
     this.#networkConditions = conditions;
-    for (const agent of this.#networkAgents) {
-      this.updateNetworkConditions(agent);
+    if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+      this.#requestConditions.applyConditions(
+          this.isOffline(), this.isThrottling() ? this.#networkConditions : null, ...this.#networkAgents);
+    } else {
+      for (const agent of this.#networkAgents) {
+        this.updateNetworkConditions(agent);
+      }
     }
     this.dispatchEventToListeners(MultitargetNetworkManager.Events.CONDITIONS_CHANGED);
   }
@@ -2058,12 +2170,16 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
     return this.#requestConditions;
   }
 
-  blockingEnabled(): boolean {
-    return this.#blockingEnabledSetting.get();
+  isBlocking(): boolean {
+    return this.#isBlocking && this.requestConditions.conditionsEnabled;
   }
 
-  isBlocking(): boolean {
-    return this.#isBlocking && this.blockingEnabled();
+  /**
+   * @deprecated Kept for layout tests
+   * TODO(pfaffe) remove
+   */
+  private setBlockingEnabled(enabled: boolean): void {
+    this.requestConditions.conditionsEnabled = enabled;
   }
 
   /**
@@ -2072,18 +2188,12 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
    */
   private setBlockedPatterns(patterns: Array<{url: string, enabled: boolean}>): void {
     this.requestConditions.clear();
-    this.requestConditions.add(...patterns.map(pattern => new RequestCondition(pattern)));
-  }
-
-  setBlockingEnabled(enabled: boolean): void {
-    if (this.#blockingEnabledSetting.get() === enabled) {
-      return;
-    }
-    this.#blockingEnabledSetting.set(enabled);
+    this.requestConditions.add(...patterns.map(pattern => RequestCondition.createFromSetting(pattern)));
   }
 
   private updateBlockedPatterns(): void {
-    this.#isBlocking = this.#requestConditions.applyConditions(...this.#networkAgents);
+    this.#isBlocking = this.#requestConditions.applyConditions(
+        this.isOffline(), this.isThrottling() ? this.#networkConditions : null, ...this.#networkAgents);
   }
 
   isIntercepting(): boolean {
@@ -2544,6 +2654,10 @@ export function getPredefinedCondition(key: ThrottlingConditionKey): Conditions|
   return THROTTLING_CONDITIONS_LOOKUP.get(key) ?? null;
 }
 
+export function getPredefinedOrBlockingCondition(key: ThrottlingConditionKey): ThrottlingConditions|null {
+  return key === PredefinedThrottlingConditionKey.BLOCKING ? BlockingConditions : getPredefinedCondition(key);
+}
+
 export type ThrottlingConditions = Conditions|{
   readonly key: ThrottlingConditionKey,
   block: true,

package/front_end/core/sdk/SourceMap.ts

@@ -12,7 +12,7 @@ import type {CallFrame, ScopeChainEntry} from './DebuggerModel.js';
 import {scopeTreeForScript} from './ScopeTreeCache.js';
 import type {Script} from './Script.js';
 import {buildOriginalScopes, decodePastaRanges, type NamedFunctionRange} from './SourceMapFunctionRanges.js';
-import {SourceMapScopesInfo} from './SourceMapScopesInfo.js';
+import {SourceMapScopesInfo, type TranslatedFrame} from './SourceMapScopesInfo.js';
 
 /**
  * Type of the base source map JSON object, which contains the sources and the mappings at the very least, plus
@@ -789,6 +789,11 @@ export class SourceMap {
     this.#ensureSourceMapProcessed();
     return this.#scopesInfo?.hasInlinedFrames(generatedLine, generatedColumn) ?? false;
   }
+
+  translateCallSite(generatedLine: number, generatedColumn: number): TranslatedFrame[] {
+    this.#ensureSourceMapProcessed();
+    return this.#scopesInfo?.translateCallSite(generatedLine, generatedColumn) ?? [];
+  }
 }
 
 const VLQ_BASE_SHIFT = 5;

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -113,6 +113,10 @@ export class SourceMapScopesInfo {
    */
   isOutlinedFrame(generatedLine: number, generatedColumn: number): boolean {
     const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    return this.#isOutlinedFrame(rangeChain);
+  }
+
+  #isOutlinedFrame(rangeChain: ScopesCodec.GeneratedRange[]): boolean {
     for (let i = rangeChain.length - 1; i >= 0; --i) {
       if (rangeChain[i].isStackFrame) {
         return rangeChain[i].isHidden;
@@ -372,13 +376,7 @@ export class SourceMapScopesInfo {
               .at(-1);
     }
 
-    // Walk the original scope chain outwards until we find a function.
-    for (let originalScope = originalInnerMostScope; originalScope; originalScope = originalScope.parent) {
-      if (originalScope.isStackFrame) {
-        return originalScope.name ?? '';
-      }
-    }
-    return null;
+    return this.#findFunctionNameInOriginalScopeChain(originalInnerMostScope) ?? null;
   }
 
   /**
@@ -404,6 +402,74 @@ export class SourceMapScopesInfo {
 
     return result;
   }
+
+  #findFunctionNameInOriginalScopeChain(innerOriginalScope: ScopesCodec.OriginalScope|undefined): string|null {
+    for (let originalScope = innerOriginalScope; originalScope; originalScope = originalScope.parent) {
+      if (originalScope.isStackFrame) {
+        return originalScope.name ?? '';
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Returns one or more original stack frames for this single "raw frame" or call-site.
+   *
+   * @returns An empty array if no mapping at the call-site was found, or the resulting frames
+   * in top-to-bottom order in case of inlining.
+   * @throws If this range is marked "hidden". Outlining needs to be handled externally as
+   * outlined function segments in stack traces can span across bundles.
+   */
+  translateCallSite(generatedLine: number, generatedColumn: number): TranslatedFrame[] {
+    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    if (this.#isOutlinedFrame(rangeChain)) {
+      throw new Error('SourceMapScopesInfo is unable to translate an outlined function by itself');
+    }
+
+    const mapping = this.#sourceMap.findEntry(generatedLine, generatedColumn);
+    if (mapping?.sourceIndex === undefined) {
+      return [];
+    }
+
+    // The top-most frame is translated the same even if we have inlined functions.
+    const result: TranslatedFrame[] = [{
+      line: mapping.sourceLineNumber,
+      column: mapping.sourceColumnNumber,
+      name: this.findOriginalFunctionName({line: generatedLine, column: generatedColumn}) ?? undefined,
+      url: mapping.sourceURL,
+    }];
+
+    // Walk the range chain inside out until we find a generated function and for each inlined function add a frame.
+    for (let i = rangeChain.length - 1; i >= 0 && !rangeChain[i].isStackFrame; --i) {
+      const range = rangeChain[i];
+      if (!range.callSite) {
+        continue;
+      }
+
+      const originalScopeChain = this.#findOriginalScopeChain(range.callSite);
+      result.push({
+        line: range.callSite.line,
+        column: range.callSite.column,
+        name: this.#findFunctionNameInOriginalScopeChain(originalScopeChain.at(-1)) ?? undefined,
+        url: this.#sourceMap.sourceURLForSourceIndex(range.callSite.sourceIndex),
+      });
+    }
+
+    return result;
+  }
+}
+
+/**
+ * Represents a stack frame in original terms. It closely aligns with StackTrace.StackTrace.Frame,
+ * but since we can't import that type here we mirror it here somewhat.
+ *
+ * Equivalent to Pick<StackTrace.StackTrace.Frame, 'line'|'column'|'name'|'url'>.
+ */
+export interface TranslatedFrame {
+  line: number;
+  column: number;
+  name?: string;
+  url?: Platform.DevToolsPath.UrlString;
 }
 
 /**