chrome-devtools-frontend 1.0.1697998 → 1.0.1699061

package/front_end/core/sdk/DOMModel.ts

@@ -44,6 +44,7 @@ import {ConsoleModel} from './ConsoleModel.js';
 import {CSSModel} from './CSSModel.js';
 import type {FrameManager} from './FrameManager.js';
 import {OverlayModel} from './OverlayModel.js';
+import {focusInPage, scrollIntoViewInPage, toggleClassAndInjectStyleRule} from './PageFunctions.js';
 import {RemoteObject} from './RemoteObject.js';
 import {Events as ResourceTreeModelEvents, type ResourceTreeFrame, ResourceTreeModel} from './ResourceTreeModel.js';
 import {RuntimeModel} from './RuntimeModel.js';
@@ -1127,47 +1128,6 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
                               [{value: pseudoElementName}, {value: !hidden}]);
     object.release();
     this.setMarker('hidden-marker', hidden ? null : true);
-
-    function toggleClassAndInjectStyleRule(this: Element, pseudoElementName: string|null, hidden: boolean): void {
-      const classNamePrefix = '__web-inspector-hide';
-      const classNameSuffix = '-shortcut__';
-      const styleTagId = '__web-inspector-hide-shortcut-style__';
-      const pseudoElementNameEscaped = pseudoElementName ? pseudoElementName.replace(/[\(\)\:]/g, '_') : '';
-      const className = classNamePrefix + pseudoElementNameEscaped + classNameSuffix;
-      this.classList.toggle(className, hidden);
-
-      let localRoot: Element|HTMLHeadElement = this;
-      while (localRoot.parentNode) {
-        localRoot = (localRoot.parentNode as Element);
-      }
-      if (localRoot.nodeType === Node.DOCUMENT_NODE) {
-        localRoot = document.head;
-      }
-
-      let style = localRoot.querySelector('style#' + styleTagId);
-      if (!style) {
-        const selectors = [];
-        selectors.push('.__web-inspector-hide-shortcut__');
-        selectors.push('.__web-inspector-hide-shortcut__ *');
-        const selector = selectors.join(', ');
-        const ruleBody = '    visibility: hidden !important;';
-        const rule = '\n' + selector + '\n{\n' + ruleBody + '\n}\n';
-
-        style = document.createElement('style');
-        style.id = styleTagId;
-        style.textContent = rule;
-
-        localRoot.appendChild(style);
-      }
-
-      // In addition to putting them on the element we want to hide, we will
-      // also add pseudo element classes to the style element to keep track of
-      // which pseudo elements we have style rules for.
-      if (pseudoElementName && !style.classList.contains(className)) {
-        style.classList.add(className);
-        style.textContent = `.${className}${pseudoElementName}, ${style.textContent}`;
-      }
-    }
   }
 
   isToggledToHidden(): boolean {
@@ -1329,8 +1289,8 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
     return node;
   }
 
-  async callFunction<T, U extends string|number>(fn: (this: HTMLElement, ...args: U[]) => T, args: U[] = []):
-      Promise<{value: T}|null> {
+  async callFunction<T, U extends string|number, This = never>(fn: (this: This, ...args: U[]) => T,
+                                                               args: U[] = []): Promise<{value: T}|null> {
     const object = await this.resolveToObject();
     if (!object) {
       return null;
@@ -1359,16 +1319,10 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
       return;
     }
 
-    const result = await node.callFunction(scrollIntoViewInPage);
-    if (!result) {
-      return;
-    }
-
+    // Highlight synchronously before scrolling to avoid out-of-order highlights
+    // if asynchronous scroll calls resolve late during rapid navigation.
     node.highlightForTwoSeconds();
-
-    function scrollIntoViewInPage(this: Element): void {
-      this.scrollIntoViewIfNeeded(true);
-    }
+    await node.callFunction(scrollIntoViewInPage);
   }
 
   async focus(): Promise<void> {
@@ -1383,10 +1337,6 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
 
     node.highlightForTwoSeconds();
     await this.#domModel.target().pageAgent().invoke_bringToFront();
-
-    function focusInPage(this: HTMLElement): void {
-      this.focus();
-    }
   }
 
   simpleSelector(): string {

package/front_end/core/sdk/DebuggerModel.ts

@@ -23,7 +23,7 @@ import {
   pauseOnExceptionEnabledSettingDescriptor,
   pauseOnUncaughtExceptionSettingDescriptor,
 } from './SDKSettings.js';
-import {SourceMap} from './SourceMap.js';
+import {SourceMap, SourceMapProvenance} from './SourceMap.js';
 import {SourceMapManager} from './SourceMapManager.js';
 import {Capability, type Target} from './Target.js';
 
@@ -189,10 +189,10 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     this.agent = target.debuggerAgent();
     this.#runtimeModel = (target.model(RuntimeModel) as RuntimeModel);
 
-    this.#sourceMapManager =
-        new SourceMapManager(target,
-                             (compiledURL, sourceMappingURL, payload, script) => new SourceMap(
-                                 compiledURL, sourceMappingURL, payload, target.targetManager().getConsole(), script));
+    this.#sourceMapManager = new SourceMapManager(
+        target,
+        (compiledURL, sourceMappingURL, payload, script, provenance) => new SourceMap(
+            compiledURL, sourceMappingURL, payload, target.targetManager().getConsole(), script, provenance));
 
     const settings = this.target().targetManager().settings;
     this.#pauseOnExceptionEnabledSetting = settings.resolve(pauseOnExceptionEnabledSettingDescriptor);
@@ -719,7 +719,7 @@ export class DebuggerModel extends SDKModel<EventTypes> {
 
     if ((!selectedDebugSymbol || selectedDebugSymbol.type === Protocol.Debugger.DebugSymbolsType.SourceMap) &&
         script.sourceMapURL && !hasSyntaxError) {
-      this.#sourceMapManager.attachSourceMap(script, script.sourceURL, script.sourceMapURL);
+      this.#sourceMapManager.attachSourceMap(script, script.sourceURL, script.sourceMapURL, SourceMapProvenance.CDP);
     }
 
     const isDiscardable = hasSyntaxError && script.isAnonymousScript();
@@ -730,11 +730,12 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     return script;
   }
 
-  setSourceMapURL(script: Script, newSourceMapURL: Platform.DevToolsPath.UrlString): void {
+  setSourceMapURL(script: Script, newSourceMapURL: Platform.DevToolsPath.UrlString,
+                  provenance: SourceMapProvenance): void {
     // Detach any previous source map from the `script` first.
     this.#sourceMapManager.detachSourceMap(script);
     script.sourceMapURL = newSourceMapURL;
-    this.#sourceMapManager.attachSourceMap(script, script.sourceURL, script.sourceMapURL);
+    this.#sourceMapManager.attachSourceMap(script, script.sourceURL, script.sourceMapURL, provenance);
   }
 
   async setDebugInfoURL(script: Script, _externalURL: Platform.DevToolsPath.UrlString): Promise<void> {

package/front_end/core/sdk/NetworkManager.ts

@@ -93,14 +93,14 @@ const UIStrings = {
    * @example {GET} PH2
    * @example {https://example.com} PH3
    */
-  sFailedLoadingSS: '{PH1} failed loading: {PH2} "{PH3}".',
+  sFailedLoadingSS: '{PH1} failed loading: {PH2} "{PH3}"',
   /**
    * @description Console message when a request finished loading.
    * @example {XHR} PH1
    * @example {GET} PH2
    * @example {https://example.com} PH3
    */
-  sFinishedLoadingSS: '{PH1} finished loading: {PH2} "{PH3}".',
+  sFinishedLoadingSS: '{PH1} finished loading: {PH2} "{PH3}"',
   /**
    * @description One of direct socket connection statuses.
    */

package/front_end/core/sdk/NetworkRequest.ts

@@ -1566,7 +1566,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     return this.#signedExchangeInfo;
   }
 
-  async populateImageSource(image: HTMLImageElement): Promise<void> {
+  async populateImageSource(image: {src: string}): Promise<void> {
     const contentData = await this.requestContentData();
     if (TextUtils.ContentData.ContentData.isError(contentData)) {
       return;

package/front_end/core/sdk/OverlayModel.ts

@@ -342,13 +342,13 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
       // overlay, so that it is not cleared by the highlight
       return;
     }
-      clearTimeout(this.#hideHighlightTimeout);
-      this.#hideHighlightTimeout = undefined;
+    clearTimeout(this.#hideHighlightTimeout);
+    this.#hideHighlightTimeout = undefined;
 
-      const highlightConfig = this.buildHighlightConfig(mode);
-      if (typeof showInfo !== 'undefined') {
-        highlightConfig.showInfo = showInfo;
-      }
+    const highlightConfig = this.buildHighlightConfig(mode);
+    if (typeof showInfo !== 'undefined') {
+      highlightConfig.showInfo = showInfo;
+    }
     this.#highlighter.highlightInOverlay(data, highlightConfig);
   }
 
@@ -496,12 +496,11 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
   }
 
   private delayedHideHighlight(delay: number): void {
-    if (this.#hideHighlightTimeout === undefined) {
-      this.#hideHighlightTimeout = globalThis.setTimeout(
-          () => this.highlightInOverlay({clear: true}),
-          delay,
-      );
-    }
+    clearTimeout(this.#hideHighlightTimeout);
+    this.#hideHighlightTimeout = globalThis.setTimeout(
+        () => this.highlightInOverlay({clear: true}),
+        delay,
+    );
   }
 
   highlightFrame(frameId: Protocol.Page.FrameId): void {

package/front_end/core/sdk/PageFunctions.ts

@@ -0,0 +1,187 @@
+// Copyright 2026 The Chromium Authors
+// 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';
+
+/**
+ * Functions in this file are serialized via `.toString()` and evaluated in the
+ * inspected page context over CDP (e.g. `Runtime.callFunctionOn`). Because they
+ * execute in the inspected browser environment, they use standard DOM types.
+ */
+
+export function scrollListenerInPage(this: HTMLElement|Document, id: number, reportScrollPositionBindingName: string,
+                                     scrollListenerNameInPage: string): void {
+  if ('scrollingElement' in this && !this.scrollingElement) {
+    return;
+  }
+
+  const scrollingElement = ('scrollingElement' in this ? this.scrollingElement : this) as HTMLElement;
+  // @ts-expect-error We're setting a custom field on `Element` or `Document` for retaining the function on the page.
+  this[scrollListenerNameInPage] = () => {
+    // @ts-expect-error `reportScrollPosition` binding is injected to the page before calling the function.
+    globalThis[reportScrollPositionBindingName](
+        JSON.stringify({scrollTop: scrollingElement.scrollTop, scrollLeft: scrollingElement.scrollLeft, id}));
+  };
+
+  // @ts-expect-error We've already defined the function used below.
+  this.addEventListener('scroll', this[scrollListenerNameInPage], true);
+}
+
+export function removeScrollListenerInPage(this: HTMLElement|Document, scrollListenerNameInPage: string): void {
+  // @ts-expect-error We've already set this custom field while adding scroll listener.
+  this.removeEventListener('scroll', this[scrollListenerNameInPage]);
+  // @ts-expect-error We've already set this custom field while adding scroll listener.
+  delete this[scrollListenerNameInPage];
+}
+
+export function scrollTopInPage(this: Element|Document): number {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return 0;
+    }
+
+    return this.scrollingElement.scrollTop;
+  }
+  return this.scrollTop;
+}
+
+export function scrollLeftInPage(this: Element|Document): number {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return 0;
+    }
+
+    return this.scrollingElement.scrollLeft;
+  }
+  return this.scrollLeft;
+}
+
+export function setScrollTopInPage(this: Element|Document, offsetInPage: number): void {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return;
+    }
+
+    this.scrollingElement.scrollTop = offsetInPage;
+  } else {
+    this.scrollTop = offsetInPage;
+  }
+}
+
+export function setScrollLeftInPage(this: Element|Document, offsetInPage: number): void {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return;
+    }
+
+    this.scrollingElement.scrollLeft = offsetInPage;
+  } else {
+    this.scrollLeft = offsetInPage;
+  }
+}
+
+export function verticalScrollRangeInPage(this: Element|Document): number {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return 0;
+    }
+
+    return this.scrollingElement.scrollHeight - this.scrollingElement.clientHeight;
+  }
+
+  return this.scrollHeight - this.clientHeight;
+}
+
+export function horizontalScrollRangeInPage(this: Element|Document): number {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return 0;
+    }
+
+    return this.scrollingElement.scrollWidth - this.scrollingElement.clientWidth;
+  }
+
+  return this.scrollWidth - this.clientWidth;
+}
+
+export function toggleClassAndInjectStyleRule(this: Element, pseudoElementName: string|null, hidden: boolean): void {
+  const classNamePrefix = '__web-inspector-hide';
+  const classNameSuffix = '-shortcut__';
+  const styleTagId = '__web-inspector-hide-shortcut-style__';
+  const pseudoElementNameEscaped = pseudoElementName ? pseudoElementName.replace(/[\(\)\:]/g, '_') : '';
+  const className = classNamePrefix + pseudoElementNameEscaped + classNameSuffix;
+  this.classList.toggle(className, hidden);
+
+  let localRoot: Element|HTMLHeadElement = this;
+  while (localRoot.parentNode) {
+    localRoot = (localRoot.parentNode as Element);
+  }
+  if (localRoot.nodeType === Node.DOCUMENT_NODE) {
+    localRoot = document.head;
+  }
+
+  let style = localRoot.querySelector('style#' + styleTagId);
+  if (!style) {
+    const selectors = [];
+    selectors.push('.__web-inspector-hide-shortcut__');
+    selectors.push('.__web-inspector-hide-shortcut__ *');
+    const selector = selectors.join(', ');
+    const ruleBody = '    visibility: hidden !important;';
+    const rule = '\n' + selector + '\n{\n' + ruleBody + '\n}\n';
+
+    style = document.createElement('style');
+    style.id = styleTagId;
+    style.textContent = rule;
+
+    localRoot.appendChild(style);
+  }
+
+  // In addition to putting them on the element we want to hide, we will
+  // also add pseudo element classes to the style element to keep track of
+  // which pseudo elements we have style rules for.
+  if (pseudoElementName && !style.classList.contains(className)) {
+    style.classList.add(className);
+    style.textContent = `.${className}${pseudoElementName}, ${style.textContent}`;
+  }
+}
+
+export function scrollIntoViewInPage(this: Element): void {
+  this.scrollIntoViewIfNeeded(true);
+}
+
+export function focusInPage(this: HTMLElement): void {
+  this.focus();
+}
+
+export function toStringForClipboard(this: Object, data: {
+  subtype: string|undefined,
+  indent: string,
+}): string|undefined {
+  const subtype = data.subtype;
+  const indent = data.indent;
+
+  if (subtype === 'node') {
+    return this instanceof Element ? this.outerHTML : undefined;
+  }
+  if (subtype && typeof this === 'undefined') {
+    return String(subtype);
+  }
+  try {
+    return JSON.stringify(this, null, indent);
+  } catch {
+    return String(this);
+  }
+}
+
+export function saveVariable(this: Window, value: Protocol.Runtime.CallArgument): string {
+  const prefix = 'temp';
+  let index = 1;
+  while ((prefix + index) in this) {
+    ++index;
+  }
+  const name = prefix + index;
+  // @ts-expect-error Assignment to global object
+  this[name] = value;
+  return name;
+}

package/front_end/core/sdk/Resource.ts

@@ -199,7 +199,7 @@ export class Resource implements TextUtils.ContentProvider.ContentProvider {
     return TextUtils.TextUtils.performSearchInSearchMatches(result.result || [], query, caseSensitive, isRegex);
   }
 
-  async populateImageSource(image: HTMLImageElement): Promise<void> {
+  async populateImageSource(image: {src: string}): Promise<void> {
     const contentData = await this.requestContentData();
     if (TextUtils.ContentData.ContentData.isError(contentData)) {
       return;

package/front_end/core/sdk/RuntimeModel.ts

@@ -10,6 +10,7 @@ import type * as Platform from '../platform/platform.js';
 
 import {DebuggerModel, type FunctionDetails} from './DebuggerModel.js';
 import {HeapProfilerModel} from './HeapProfilerModel.js';
+import {toStringForClipboard} from './PageFunctions.js';
 import {
   RemoteFunction,
   RemoteObject,
@@ -313,26 +314,6 @@ export class RuntimeModel extends SDKModel<EventTypes> {
                           }])
         .then(Host.InspectorFrontendHost.InspectorFrontendHostInstance.copyText.bind(
             Host.InspectorFrontendHost.InspectorFrontendHostInstance));
-
-    function toStringForClipboard(this: Object, data: {
-      subtype: string,
-      indent: string,
-    }): string|undefined {
-      const subtype = data.subtype;
-      const indent = data.indent;
-
-      if (subtype === 'node') {
-        return this instanceof Element ? this.outerHTML : undefined;
-      }
-      if (subtype && typeof this === 'undefined') {
-        return String(subtype);
-      }
-      try {
-        return JSON.stringify(this, null, indent);
-      } catch {
-        return String(this);
-      }
-    }
   }
 
   private async queryObjectsRequested(object: RemoteObject, executionContextId?: number): Promise<void> {

package/front_end/core/sdk/Script.ts

@@ -43,6 +43,7 @@ import type {FrameAssociated} from './FrameAssociated.js';
 import type {PageResourceLoadInitiator} from './PageResourceLoader.js';
 import {ResourceTreeModel} from './ResourceTreeModel.js';
 import type {ExecutionContext} from './RuntimeModel.js';
+import {SecurityOrigin} from './SecurityOrigin.js';
 import type {DebugId, SourceMap} from './SourceMap.js';
 import type {Target} from './Target.js';
 
@@ -88,6 +89,7 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
   readonly #language: string|null;
   #contentPromise: Promise<TextUtils.ContentData.ContentDataOrError>|null;
   readonly #embedderName: Platform.DevToolsPath.UrlString|null;
+  readonly #securityOrigin: SecurityOrigin;
   readonly isModule: boolean|null;
   readonly buildId: string|null;
   constructor(debuggerModel: DebuggerModel, scriptId: Protocol.Runtime.ScriptId,
@@ -119,12 +121,31 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
     this.#language = scriptLanguage;
     this.#contentPromise = null;
     this.#embedderName = embedderName;
+    this.#securityOrigin = SecurityOrigin.create(this.#embedderName ?? '');
   }
 
   embedderName(): Platform.DevToolsPath.UrlString|null {
     return this.#embedderName;
   }
 
+  /**
+   * Returns the security origin of the script derived exclusively from its
+   * embedder/network URL (`#embedderName`), or a unique opaque origin if the
+   * script has no valid network provenance (e.g. `eval()` or buffer-based Wasm).
+   *
+   * Security note: Do NOT fall back to `this.sourceURL` or
+   * `this.target().inspectedSecurityOrigin()`:
+   * - `sourceURL` is overwritten by `//# sourceURL=` comments, allowing a script
+   *   to spoof an arbitrary origin.
+   * - Third-party scripts (`<script src="https://attacker.example/...">`) run in
+   *   the same target/frame as the main page; falling back to the target's
+   *   origin would allow them to launder their origin by dynamically evaluating
+   *   code via `eval()` or `WebAssembly.instantiate(buffer)`.
+   */
+  securityOrigin(): SecurityOrigin {
+    return this.#securityOrigin;
+  }
+
   target(): Target {
     return this.debuggerModel.target();
   }

package/front_end/core/sdk/SourceMap.ts

@@ -130,6 +130,12 @@ interface SourceInfo {
   reverseMappings: number[]|null;
 }
 
+export const enum SourceMapProvenance {
+  CDP = 'cdp',
+  EXTENSION = 'extension',
+  USER = 'user',
+}
+
 export class SourceMap {
   static retainRawSourceMaps = false;
 
@@ -149,13 +155,15 @@ export class SourceMap {
 
   #scopesFallbackPromise?: Promise<void>;
   readonly #console: Common.Console.Console;
+  readonly #provenance: SourceMapProvenance;
 
   /**
    * Implements Source Map V3 model. See https://github.com/google/closure-compiler/wiki/Source-Maps
    * for format description.
    */
   constructor(compiledURL: Platform.DevToolsPath.UrlString, sourceMappingURL: Platform.DevToolsPath.UrlString,
-              payload: SourceMapV3, console: Common.Console.Console, script?: Script) {
+              payload: SourceMapV3, console: Common.Console.Console, script?: Script,
+              provenance: SourceMapProvenance = SourceMapProvenance.CDP) {
     this.#json = payload;
     this.#script = script;
     this.#compiledURL = compiledURL;
@@ -163,6 +171,7 @@ export class SourceMap {
     this.#baseURL = (Common.ParsedURL.schemeIs(sourceMappingURL, 'data:')) ? compiledURL : sourceMappingURL;
     this.#debugId = 'debugId' in payload ? (payload.debugId as DebugId | undefined) : undefined;
     this.#console = console;
+    this.#provenance = provenance;
 
     if ('sections' in this.#json) {
       if (this.#json.sections.find(section => 'url' in section)) {
@@ -172,6 +181,10 @@ export class SourceMap {
     this.eachSection(this.parseSources.bind(this));
   }
 
+  provenance(): SourceMapProvenance {
+    return this.#provenance;
+  }
+
   json(): SourceMapV3|null {
     return this.#json;
   }
@@ -823,7 +836,7 @@ export class SourceMap {
 
   resolveScopeChain(frame: CallFrame): ScopeChainEntry[]|null {
     this.#ensureSourceMapProcessed();
-    if (this.#scopesInfo === null) {
+    if (this.#provenance === SourceMapProvenance.USER || !this.#scopesInfo?.hasVariablesAndBindings()) {
       return null;
     }
 

package/front_end/core/sdk/SourceMapCache.ts

@@ -2,15 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as Platform from '../platform/platform.js';
+import * as Platform from '../platform/platform.js';
 
 import type {DebugId, SourceMapV3} from './SourceMap.js';
 
 /** A thin wrapper around the Cache API to store source map JSONs keyed on Debug IDs */
 export class SourceMapCache {
   static create(): SourceMapCache {
-    if (typeof window === 'undefined') {
-      // TODO(crbug.com/451502260): Move this behind a `HostRuntime` interface.
+    if (!Platform.HostRuntime.HOST_RUNTIME.getCacheStorage()) {
       return IN_MEMORY_INSTANCE as unknown as
           SourceMapCache;  // TS doesn't like that our in-memory class doesn't have the same private fields.
     }
@@ -22,7 +21,7 @@ export class SourceMapCache {
   }
 
   readonly #name: string;
-  #cachePromise?: Promise<Cache>;
+  #cachePromise?: Promise<Platform.HostRuntime.CacheEntry>;
 
   private constructor(name: string) {
     this.#name = name;
@@ -30,21 +29,25 @@ export class SourceMapCache {
 
   async set(debugId: DebugId, securityOrigin: Platform.DevToolsPath.UrlString, sourceMap: SourceMapV3): Promise<void> {
     const cache = await this.#cache();
-    await cache.put(SourceMapCache.#urlForDebugId(debugId, securityOrigin), new Response(JSON.stringify(sourceMap)));
+    await cache?.put(SourceMapCache.#urlForDebugId(debugId, securityOrigin), new Response(JSON.stringify(sourceMap)));
   }
 
   async get(debugId: DebugId, securityOrigin: Platform.DevToolsPath.UrlString): Promise<SourceMapV3|null> {
     const cache = await this.#cache();
-    const response = await cache.match(SourceMapCache.#urlForDebugId(debugId, securityOrigin));
-    return await response?.json() ?? null;
+    const response = await cache?.match(SourceMapCache.#urlForDebugId(debugId, securityOrigin));
+    return (await response?.json() as SourceMapV3 | undefined) ?? null;
   }
 
-  async #cache(): Promise<Cache> {
+  async #cache(): Promise<Platform.HostRuntime.CacheEntry|undefined> {
     if (this.#cachePromise) {
       return await this.#cachePromise;
     }
 
-    this.#cachePromise = window.caches.open(this.#name);
+    const cacheStorage = Platform.HostRuntime.HOST_RUNTIME.getCacheStorage();
+    if (!cacheStorage) {
+      return undefined;
+    }
+    this.#cachePromise = cacheStorage.open(this.#name);
     return await this.#cachePromise;
   }
 
@@ -54,7 +57,7 @@ export class SourceMapCache {
   }
 
   async disposeForTest(): Promise<void> {
-    await window.caches.delete(this.#name);
+    await Platform.HostRuntime.HOST_RUNTIME.getCacheStorage()?.delete(this.#name);
   }
 }