chrome-devtools-mcp-for-extension 0.19.2 → 0.20.0

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/NetworkRequest.js

@@ -225,8 +225,6 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper {
     #initialPriority = null;
     #currentPriority = null;
     #signedExchangeInfo = null;
-    #webBundleInfo = null;
-    #webBundleInnerRequestInfo = null;
     #resourceType = Common.ResourceType.resourceTypes.Other;
     #contentData = null;
     #streamingContentData = null;
@@ -306,8 +304,8 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper {
     responseReceivedPromiseResolve;
     directSocketInfo;
     #directSocketChunks = [];
-    #isIpProtectionUsed;
     #isAdRelated;
+    #appliedNetworkConditionsId;
     constructor(requestId, backendRequestId, url, documentURL, frameId, loaderId, initiator, hasUserGesture) {
         super();
         this.#requestId = requestId;
@@ -318,7 +316,6 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper {
         this.#loaderId = loaderId;
         this.#initiator = initiator;
         this.#hasUserGesture = hasUserGesture;
-        this.#isIpProtectionUsed = false;
         this.#isAdRelated = false;
     }
     static create(backendRequestId, url, documentURL, frameId, loaderId, initiator, hasUserGesture) {
@@ -376,6 +373,9 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper {
     get loaderId() {
         return this.#loaderId;
     }
+    get appliedNetworkConditionsId() {
+        return this.#appliedNetworkConditionsId;
+    }
     setRemoteAddress(ip, port) {
         this.#remoteAddress = ip + ':' + port;
         this.dispatchEventToListeners(Events.REMOTE_ADDRESS_CHANGED, this);
@@ -1168,18 +1168,6 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper {
     signedExchangeInfo() {
         return this.#signedExchangeInfo;
     }
-    setWebBundleInfo(info) {
-        this.#webBundleInfo = info;
-    }
-    webBundleInfo() {
-        return this.#webBundleInfo;
-    }
-    setWebBundleInnerRequestInfo(info) {
-        this.#webBundleInnerRequestInfo = info;
-    }
-    webBundleInnerRequestInfo() {
-        return this.#webBundleInnerRequestInfo;
-    }
     async populateImageSource(image) {
         const contentData = await this.requestContentData();
         if (TextUtils.ContentData.ContentData.isError(contentData)) {
@@ -1265,12 +1253,16 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper {
         this.#hasExtraRequestInfo = true;
         this.setRequestHeadersText(''); // Mark request headers as non-provisional
         this.#clientSecurityState = extraRequestInfo.clientSecurityState;
+        this.#appliedNetworkConditionsId = extraRequestInfo.appliedNetworkConditionsId;
         if (extraRequestInfo.connectTiming) {
             this.setConnectTimingFromExtraInfo(extraRequestInfo.connectTiming);
         }
         this.#siteHasCookieInOtherPartition = extraRequestInfo.siteHasCookieInOtherPartition ?? false;
         this.#hasThirdPartyCookiePhaseoutIssue = this.#blockedRequestCookies.some(item => item.blockedReasons.includes("ThirdPartyPhaseout" /* Protocol.Network.CookieBlockedReason.ThirdPartyPhaseout */));
     }
+    setAppliedNetworkConditions(appliedNetworkConditionsId) {
+        this.#appliedNetworkConditionsId = appliedNetworkConditionsId;
+    }
     hasExtraRequestInfo() {
         return this.#hasExtraRequestInfo;
     }
@@ -1418,12 +1410,6 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper {
     isSameSite() {
         return this.#isSameSite;
     }
-    setIsIpProtectionUsed(isIpProtectionUsed) {
-        this.#isIpProtectionUsed = isIpProtectionUsed;
-    }
-    isIpProtectionUsed() {
-        return this.#isIpProtectionUsed;
-    }
     setIsAdRelated(isAdRelated) {
         this.#isAdRelated = isAdRelated;
     }

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/PageResourceLoader.js

@@ -4,7 +4,7 @@
 import * as Common from '../common/common.js';
 import * as Host from '../host/host.js';
 import * as i18n from '../i18n/i18n.js';
-import { FrameManager } from './FrameManager.js';
+import * as Root from '../root/root.js';
 import { IOModel } from './IOModel.js';
 import { MultitargetNetworkManager, NetworkManager } from './NetworkManager.js';
 import { Events as ResourceTreeModelEvents, ResourceTreeModel, } from './ResourceTreeModel.js';
@@ -20,44 +20,48 @@ const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 function isExtensionInitiator(initiator) {
     return 'extensionId' in initiator;
 }
-// Used for revealing a resource.
+/** Used for revealing a resource. **/
 export class ResourceKey {
     key;
     constructor(key) {
         this.key = key;
     }
 }
-let pageResourceLoader = null;
 /**
  * The page resource loader is a bottleneck for all DevTools-initiated resource loads. For each such load, it keeps a
  * `PageResource` object around that holds meta information. This can be as the basis for reporting to the user which
  * resources were loaded, and whether there was a load error.
  */
 export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
+    #targetManager;
+    #settings;
+    #userAgentProvider;
     #currentlyLoading = 0;
     #currentlyLoadingPerTarget = new Map();
     #maxConcurrentLoads;
     #pageResources = new Map();
     #queuedLoads = [];
     #loadOverride;
-    constructor(loadOverride, maxConcurrentLoads) {
+    constructor(targetManager, settings, userAgentProvider, loadOverride, maxConcurrentLoads = 500) {
         super();
+        this.#targetManager = targetManager;
+        this.#settings = settings;
+        this.#userAgentProvider = userAgentProvider;
         this.#maxConcurrentLoads = maxConcurrentLoads;
-        TargetManager.instance().addModelListener(ResourceTreeModel, ResourceTreeModelEvents.PrimaryPageChanged, this.onPrimaryPageChanged, this);
+        this.#targetManager.addModelListener(ResourceTreeModel, ResourceTreeModelEvents.PrimaryPageChanged, this.onPrimaryPageChanged, this);
         this.#loadOverride = loadOverride;
     }
-    static instance({ forceNew, loadOverride, maxConcurrentLoads } = {
+    static instance({ forceNew, targetManager, settings, userAgentProvider, loadOverride, maxConcurrentLoads } = {
         forceNew: false,
         loadOverride: null,
-        maxConcurrentLoads: 500,
     }) {
-        if (!pageResourceLoader || forceNew) {
-            pageResourceLoader = new PageResourceLoader(loadOverride, maxConcurrentLoads);
+        if (forceNew) {
+            Root.DevToolsContext.globalInstance().set(PageResourceLoader, new PageResourceLoader(targetManager ?? TargetManager.instance(), settings ?? Common.Settings.Settings.instance(), userAgentProvider ?? MultitargetNetworkManager.instance(), loadOverride, maxConcurrentLoads));
         }
-        return pageResourceLoader;
+        return Root.DevToolsContext.globalInstance().get(PageResourceLoader);
     }
     static removeInstance() {
-        pageResourceLoader = null;
+        Root.DevToolsContext.globalInstance().delete(PageResourceLoader);
     }
     onPrimaryPageChanged(event) {
         const { frame: mainFrame, type } = event.data;
@@ -85,7 +89,7 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
         return this.#pageResources;
     }
     getScopedResourcesLoaded() {
-        return new Map([...this.#pageResources].filter(([_, pageResource]) => TargetManager.instance().isInScope(pageResource.initiator.target) ||
+        return new Map([...this.#pageResources].filter(([_, pageResource]) => this.#targetManager.isInScope(pageResource.initiator.target) ||
             isExtensionInitiator(pageResource.initiator)));
     }
     /**
@@ -97,11 +101,10 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
         return { loading: this.#currentlyLoading, queued: this.#queuedLoads.length, resources: this.#pageResources.size };
     }
     getScopedNumberOfResources() {
-        const targetManager = TargetManager.instance();
         let loadingCount = 0;
         for (const [targetId, count] of this.#currentlyLoadingPerTarget) {
-            const target = targetManager.targetById(targetId);
-            if (targetManager.isInScope(target)) {
+            const target = this.#targetManager.targetById(targetId);
+            if (this.#targetManager.isInScope(target)) {
                 loadingCount += count;
             }
         }
@@ -197,22 +200,15 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
             return await this.#loadOverride(url);
         }
         const parsedURL = new Common.ParsedURL.ParsedURL(url);
-        const eligibleForLoadFromTarget = getLoadThroughTargetSetting().get() && parsedURL && parsedURL.scheme !== 'file' &&
-            parsedURL.scheme !== 'data' && parsedURL.scheme !== 'devtools';
+        const eligibleForLoadFromTarget = this.getLoadThroughTargetSetting().get() && parsedURL &&
+            parsedURL.scheme !== 'file' && parsedURL.scheme !== 'data' && parsedURL.scheme !== 'devtools' &&
+            initiator.target;
         Host.userMetrics.developerResourceScheme(this.getDeveloperResourceScheme(parsedURL));
         if (eligibleForLoadFromTarget) {
             try {
-                if (initiator.target) {
-                    Host.userMetrics.developerResourceLoaded(0 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_TARGET */);
-                    const result = await this.loadFromTarget(initiator.target, initiator.frameId, url, isBinary);
-                    return result;
-                }
-                const frame = FrameManager.instance().getFrame(initiator.frameId);
-                if (frame) {
-                    Host.userMetrics.developerResourceLoaded(1 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_FRAME */);
-                    const result = await this.loadFromTarget(frame.resourceTreeModel().target(), initiator.frameId, url, isBinary);
-                    return result;
-                }
+                Host.userMetrics.developerResourceLoaded(0 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_TARGET */);
+                const result = await this.loadFromTarget(initiator.target, initiator.frameId, url, isBinary);
+                return result;
             }
             catch (e) {
                 if (e instanceof Error) {
@@ -229,12 +225,12 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
             Host.userMetrics.developerResourceLoaded(3 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_FALLBACK */);
         }
         else {
-            const code = getLoadThroughTargetSetting().get() ?
+            const code = this.getLoadThroughTargetSetting().get() ?
                 6 /* Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_PER_PROTOCOL */ :
                 5 /* Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_PER_OVERRIDE */;
             Host.userMetrics.developerResourceLoaded(code);
         }
-        const result = await MultitargetNetworkManager.instance().loadResource(url);
+        const result = await this.loadFromHostBindings(url);
         if (eligibleForLoadFromTarget && !result.success) {
             Host.userMetrics.developerResourceLoaded(7 /* Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_FAILURE */);
         }
@@ -269,7 +265,7 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
     async loadFromTarget(target, frameId, url, isBinary) {
         const networkManager = target.model(NetworkManager);
         const ioModel = target.model(IOModel);
-        const disableCache = Common.Settings.Settings.instance().moduleSetting('cache-disabled').get();
+        const disableCache = this.#settings.moduleSetting('cache-disabled').get();
         const resource = await networkManager.loadNetworkResource(frameId, url, { disableCache, includeCredentials: true });
         try {
             const content = resource.stream ?
@@ -294,7 +290,21 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
             }
         }
     }
-}
-export function getLoadThroughTargetSetting() {
-    return Common.Settings.Settings.instance().createSetting('load-through-target', true);
+    async loadFromHostBindings(url) {
+        const headers = {};
+        const currentUserAgent = this.#userAgentProvider.currentUserAgent();
+        if (currentUserAgent) {
+            headers['User-Agent'] = currentUserAgent;
+        }
+        if (this.#settings.moduleSetting('cache-disabled').get()) {
+            headers['Cache-Control'] = 'no-cache';
+        }
+        const allowRemoteFilePaths = this.#settings.moduleSetting('network.enable-remote-file-loading').get();
+        return await new Promise(resolve => Host.ResourceLoader.load(url, headers, (success, _responseHeaders, content, errorDescription) => {
+            resolve({ success, content, errorDescription });
+        }, allowRemoteFilePaths));
+    }
+    getLoadThroughTargetSetting() {
+        return this.#settings.createSetting('load-through-target', true);
+    }
 }

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/PreloadingModel.js

@@ -6,11 +6,13 @@ import { assertNotNullOrUndefined } from '../platform/platform.js';
 import { Events as ResourceTreeModelEvents, ResourceTreeModel, } from './ResourceTreeModel.js';
 import { SDKModel } from './SDKModel.js';
 import { TargetManager } from './TargetManager.js';
-// Holds preloading related information.
-//
-// - SpeculationRule rule sets
-// - Preloading attempts
-// - Relationship between rule sets and preloading attempts
+/**
+ * Holds preloading related information.
+ *
+ * - SpeculationRule rule sets
+ * - Preloading attempts
+ * - Relationship between rule sets and preloading attempts
+ **/
 export class PreloadingModel extends SDKModel {
     agent;
     loaderIds = [];
@@ -23,7 +25,7 @@ export class PreloadingModel extends SDKModel {
         this.agent = target.preloadAgent();
         void this.agent.invoke_enable();
         const targetInfo = target.targetInfo();
-        if (targetInfo !== undefined && targetInfo.subtype === 'prerender') {
+        if (targetInfo?.subtype === 'prerender') {
             this.lastPrimaryPageModel = TargetManager.instance().primaryPageTarget()?.model(PreloadingModel) || null;
         }
         TargetManager.instance().addModelListener(ResourceTreeModel, ResourceTreeModelEvents.PrimaryPageChanged, this.onPrimaryPageChanged, this);
@@ -226,15 +228,33 @@ export class PreloadingModel extends SDKModel {
     onPrerenderStatusUpdated(event) {
         const loaderId = event.key.loaderId;
         this.ensureDocumentPreloadingData(loaderId);
-        const attempt = {
-            action: "Prerender" /* Protocol.Preload.SpeculationAction.Prerender */,
-            key: event.key,
-            pipelineId: event.pipelineId,
-            status: convertPreloadingStatus(event.status),
-            prerenderStatus: event.prerenderStatus || null,
-            disallowedMojoInterface: event.disallowedMojoInterface || null,
-            mismatchedHeaders: event.mismatchedHeaders || null,
-        };
+        let attempt;
+        switch (event.key.action) {
+            case "Prerender" /* Protocol.Preload.SpeculationAction.Prerender */:
+                attempt = {
+                    action: event.key.action,
+                    key: event.key,
+                    pipelineId: event.pipelineId,
+                    status: convertPreloadingStatus(event.status),
+                    prerenderStatus: event.prerenderStatus || null,
+                    disallowedMojoInterface: event.disallowedMojoInterface || null,
+                    mismatchedHeaders: event.mismatchedHeaders || null,
+                };
+                break;
+            case "PrerenderUntilScript" /* Protocol.Preload.SpeculationAction.PrerenderUntilScript */:
+                attempt = {
+                    action: event.key.action,
+                    key: event.key,
+                    pipelineId: event.pipelineId,
+                    status: convertPreloadingStatus(event.status),
+                    prerenderStatus: event.prerenderStatus || null,
+                    disallowedMojoInterface: event.disallowedMojoInterface || null,
+                    mismatchedHeaders: event.mismatchedHeaders || null,
+                };
+                break;
+            default:
+                throw new Error(`unreachable: event.key.action: ${event.key.action}`);
+        }
         this.documents.get(loaderId)?.preloadingAttempts.upsert(attempt);
         this.dispatchEventToListeners("ModelUpdated" /* Events.MODEL_UPDATED */);
     }
@@ -333,6 +353,9 @@ function makePreloadingAttemptId(key) {
         case "Prerender" /* Protocol.Preload.SpeculationAction.Prerender */:
             action = 'Prerender';
             break;
+        case "PrerenderUntilScript" /* Protocol.Preload.SpeculationAction.PrerenderUntilScript */:
+            action = 'PrerenderUntilScript';
+            break;
     }
     let targetHint;
     switch (key.targetHint) {
@@ -364,7 +387,7 @@ export class PreloadPipeline {
         return new PreloadPipeline(inner);
     }
     getOriginallyTriggered() {
-        const attempt = this.getPrerender() || this.getPrefetch();
+        const attempt = this.getPrerender() || this.getPrerenderUntilScript() || this.getPrefetch();
         assertNotNullOrUndefined(attempt);
         return attempt;
     }
@@ -374,7 +397,10 @@ export class PreloadPipeline {
     getPrerender() {
         return this.inner.get("Prerender" /* Protocol.Preload.SpeculationAction.Prerender */) || null;
     }
-    // Returns attempts in the order: prefetch < prerender.
+    getPrerenderUntilScript() {
+        return this.inner.get("PrerenderUntilScript" /* Protocol.Preload.SpeculationAction.PrerenderUntilScript */) || null;
+    }
+    // Returns attempts in the order: prefetch < prerender_until_script < prerender.
     // Currently unused.
     getAttempts() {
         const ret = [];
@@ -386,6 +412,10 @@ export class PreloadPipeline {
         if (prerender !== null) {
             ret.push(prerender);
         }
+        const prerenderUntilScript = this.getPrerenderUntilScript();
+        if (prerenderUntilScript !== null) {
+            ret.push(prerenderUntilScript);
+        }
         if (ret.length === 0) {
             throw new Error('unreachable');
         }
@@ -412,7 +442,9 @@ class PreloadingAttemptRegistry {
     //
     // In some cases, browsers automatically triggers preloads. For example, Chrome triggers prefetch
     // ahead of prerender to prevent multiple fetches in case that the prerender failed due to, e.g.
-    // use of forbidden mojo APIs. Such prefetch and prerender sit in the same preload pipeline.
+    // use of forbidden mojo APIs. Also, a prerender-until-script attempt triggers prefetch as well,
+    // and can upgrade to prerender. Such prefetch, prerender-until-script, and prerender sit in the
+    // same preload pipeline.
     //
     // We regard them as not representative and only show the representative ones to represent
     // pipelines.
@@ -421,8 +453,10 @@ class PreloadingAttemptRegistry {
             switch (action) {
                 case "Prefetch" /* Protocol.Preload.SpeculationAction.Prefetch */:
                     return 0;
-                case "Prerender" /* Protocol.Preload.SpeculationAction.Prerender */:
+                case "PrerenderUntilScript" /* Protocol.Preload.SpeculationAction.PrerenderUntilScript */:
                     return 1;
+                case "Prerender" /* Protocol.Preload.SpeculationAction.Prerender */:
+                    return 2;
             }
         }
         // Attempt with status `NOT_TRIGGERED` is a representative of a pipeline.
@@ -525,6 +559,17 @@ class PreloadingAttemptRegistry {
                         mismatchedHeaders: null,
                     };
                     break;
+                case "PrerenderUntilScript" /* Protocol.Preload.SpeculationAction.PrerenderUntilScript */:
+                    attempt = {
+                        action: "PrerenderUntilScript" /* Protocol.Preload.SpeculationAction.PrerenderUntilScript */,
+                        key,
+                        pipelineId: null,
+                        status: "NotTriggered" /* PreloadingStatus.NOT_TRIGGERED */,
+                        prerenderStatus: null,
+                        disallowedMojoInterface: null,
+                        mismatchedHeaders: null,
+                    };
+                    break;
             }
             this.map.set(id, attempt);
         }

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/RehydratingConnection.js

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 import * as Common from '../common/common.js';
 import * as i18n from '../i18n/i18n.js';
+import * as Root from '../root/root.js';
 import * as EnhancedTraces from './EnhancedTracesParser.js';
 import { TraceObject } from './TraceObject.js';
 const UIStrings = {
@@ -21,28 +22,52 @@ const UIStrings = {
 };
 const str_ = i18n.i18n.registerUIStrings('core/sdk/RehydratingConnection.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-export class RehydratingConnection {
+export class RehydratingConnectionTransport {
     rehydratingConnectionState = 1 /* RehydratingConnectionState.UNINITIALIZED */;
     onDisconnect = null;
     onMessage = null;
     trace = null;
     sessions = new Map();
     #onConnectionLost;
-    #rehydratingWindow;
+    #rehydratingWindow = window;
     #onReceiveHostWindowPayloadBound = this.onReceiveHostWindowPayload.bind(this);
     constructor(onConnectionLost) {
-        // If we're invoking this class, we're in the rehydrating pop-up window. Rename window for clarity.
         this.#onConnectionLost = onConnectionLost;
-        this.#rehydratingWindow = window;
-        this.#setupMessagePassing();
+        if (!this.#maybeHandleLoadingFromUrl()) {
+            this.#setupMessagePassing();
+        }
+    }
+    /** Returns true if found a trace URL. */
+    #maybeHandleLoadingFromUrl() {
+        let traceUrl = Root.Runtime.Runtime.queryParam('traceURL');
+        if (!traceUrl) {
+            // For compatibility, handle the older loadTimelineFromURL.
+            const timelineUrl = Root.Runtime.Runtime.queryParam('loadTimelineFromURL');
+            if (timelineUrl) {
+                // It was double-URI encoded for some reason.
+                traceUrl = decodeURIComponent(timelineUrl);
+            }
+        }
+        if (traceUrl) {
+            void fetch(traceUrl).then(r => r.arrayBuffer()).then(b => Common.Gzip.arrayBufferToString(b)).then(traceJson => {
+                const trace = new TraceObject(JSON.parse(traceJson));
+                void this.startHydration(trace);
+            });
+            return true;
+        }
+        return false;
     }
     #setupMessagePassing() {
         this.#rehydratingWindow.addEventListener('message', this.#onReceiveHostWindowPayloadBound);
-        if (!this.#rehydratingWindow.opener) {
+        if (this.#rehydratingWindow.opener) {
+            this.#rehydratingWindow.opener.postMessage({ type: 'REHYDRATING_WINDOW_READY' });
+        }
+        else if (this.#rehydratingWindow !== window.top) {
+            this.#rehydratingWindow.parent.postMessage({ type: 'REHYDRATING_IFRAME_READY' }, '*');
+        }
+        else {
             this.#onConnectionLost(i18nString(UIStrings.noHostWindow));
-            return;
         }
-        this.#rehydratingWindow.opener.postMessage({ type: 'REHYDRATING_WINDOW_READY' });
     }
     /**
      * This is a callback for rehydrated session to receive payload from host window. Payload includes but not limited to
@@ -83,6 +108,7 @@ export class RehydratingConnection {
             const target = hydratingDataPerTarget.target;
             const executionContexts = hydratingDataPerTarget.executionContexts;
             const scripts = hydratingDataPerTarget.scripts;
+            const resources = hydratingDataPerTarget.resources;
             this.postToFrontend({
                 method: 'Target.targetCreated',
                 params: {
@@ -97,7 +123,7 @@ export class RehydratingConnection {
                 },
             });
             sessionId += 1;
-            const session = new RehydratingSession(sessionId, target, executionContexts, scripts, this);
+            const session = new RehydratingSession(sessionId, target, executionContexts, scripts, resources, this);
             this.sessions.set(sessionId, session);
             session.declareSessionAttachedToTarget();
         }
@@ -157,14 +183,18 @@ export class RehydratingConnection {
         return Promise.reject();
     }
 }
-// Default rehydrating session with default responses.
+/** Default rehydrating session with default responses. **/
 class RehydratingSessionBase {
     connection = null;
     constructor(connection) {
         this.connection = connection;
     }
     sendMessageToFrontend(payload) {
-        this.connection?.postToFrontend(payload);
+        // The frontend doesn't expect CDP responses within the same synchronous event loop, so it breaks unexpectedly.
+        //  Any async boundary will do, so we use setTimeout.
+        setTimeout(() => {
+            this.connection?.postToFrontend(payload);
+        });
     }
     handleFrontendMessageAsFakeCDPAgent(data) {
         // Send default response in default session.
@@ -179,12 +209,14 @@ export class RehydratingSession extends RehydratingSessionBase {
     target;
     executionContexts = [];
     scripts = [];
-    constructor(sessionId, target, executionContexts, scripts, connection) {
+    resources = [];
+    constructor(sessionId, target, executionContexts, scripts, resources, connection) {
         super(connection);
         this.sessionId = sessionId;
         this.target = target;
         this.executionContexts = executionContexts;
         this.scripts = scripts;
+        this.resources = resources;
     }
     sendMessageToFrontend(payload, attachSessionId = true) {
         // Attach the session's Id to the message.
@@ -201,12 +233,31 @@ export class RehydratingSession extends RehydratingSessionBase {
             case 'Debugger.enable':
                 this.handleDebuggerEnable(data.id);
                 break;
+            case 'CSS.enable':
+                this.sendMessageToFrontend({
+                    id: data.id,
+                    result: {},
+                });
+                break;
             case 'Debugger.getScriptSource':
                 if (data.params) {
                     const params = data.params;
                     this.handleDebuggerGetScriptSource(data.id, params.scriptId);
                 }
                 break;
+            case 'Page.getResourceTree':
+                this.handleGetResourceTree(data.id);
+                break;
+            case 'Page.getResourceContent': {
+                const request = data.params;
+                this.handleGetResourceContent(request.frameId, request.url, data.id);
+                break;
+            }
+            case 'CSS.getStyleSheetText': {
+                const request = data.params;
+                this.handleGetStyleSheetText(request.styleSheetId, data.id);
+                break;
+            }
             default:
                 this.sendMessageToFrontend({
                     id: data.id,
@@ -269,7 +320,20 @@ export class RehydratingSession extends RehydratingSessionBase {
     // script parsed event to communicate the current script state and respond with a mock
     // debugger id.
     handleDebuggerEnable(id) {
+        const htmlResourceUrls = new Set(this.resources.filter(r => r.mimeType === 'text/html').map(r => r.url));
         for (const script of this.scripts) {
+            // Handle inline scripts.
+            if (htmlResourceUrls.has(script.url)) {
+                script.embedderName = script.url;
+                // We don't have the actual embedded offset from this trace event. Non-zero
+                // values are important though: that is what `Script.isInlineScript()`
+                // checks. Otherwise these scripts would try to show individually within the
+                // Sources panel.
+                script.startColumn = 1;
+                script.startLine = 1;
+                script.endColumn = 1;
+                script.endLine = 1;
+            }
             this.sendMessageToFrontend({
                 method: 'Debugger.scriptParsed',
                 params: script,
@@ -283,4 +347,67 @@ export class RehydratingSession extends RehydratingSessionBase {
             },
         });
     }
+    handleGetResourceTree(id) {
+        const resources = this.resources.filter(r => r.mimeType === 'text/html' || r.mimeType === 'text/css');
+        if (!resources.length) {
+            return;
+        }
+        const frameTree = {
+            frame: {
+                id: this.target.targetId,
+                url: this.target.url,
+            },
+            childFrames: [],
+            resources: resources.map(r => ({
+                url: r.url,
+                type: r.mimeType === 'text/html' ? 'Document' : 'Stylesheet',
+                mimeType: r.mimeType,
+                contentSize: r.content.length,
+            })),
+        };
+        this.sendMessageToFrontend({
+            id,
+            result: {
+                frameTree,
+            },
+        });
+        const stylesheets = this.resources.filter(r => r.mimeType === 'text/css');
+        for (const stylesheet of stylesheets) {
+            this.sendMessageToFrontend({
+                method: 'CSS.styleSheetAdded',
+                params: {
+                    header: {
+                        styleSheetId: `sheet.${stylesheet.frame}.${stylesheet.url}`,
+                        frameId: stylesheet.frame,
+                        sourceURL: stylesheet.url,
+                    },
+                },
+            });
+        }
+    }
+    handleGetResourceContent(frame, url, id) {
+        const resource = this.resources.find(r => r.frame === frame && r.url === url);
+        if (!resource) {
+            return;
+        }
+        this.sendMessageToFrontend({
+            id,
+            result: {
+                content: resource.content,
+                base64Encoded: false,
+            },
+        });
+    }
+    handleGetStyleSheetText(stylesheetId, id) {
+        const resource = this.resources.find(r => `sheet.${r.frame}.${r.url}` === stylesheetId);
+        if (!resource) {
+            return;
+        }
+        this.sendMessageToFrontend({
+            id,
+            result: {
+                text: resource.content,
+            },
+        });
+    }
 }

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/RemoteObject.js

@@ -1,7 +1,7 @@
 // Copyright 2009 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
-// This cannot be an interface due to "instanceof RemoteObject" checks in the code.
+/** This cannot be an interface due to "instanceof RemoteObject" checks in the code. **/
 export class RemoteObject {
     static fromLocalObject(value) {
         return new LocalJSONObject(value);
@@ -665,6 +665,9 @@ export class LocalJSONObject extends RemoteObject {
         if (this.#value instanceof Date) {
             return 'date';
         }
+        if (this.#value instanceof Error) {
+            return 'error';
+        }
         return undefined;
     }
     get hasChildren() {
@@ -764,7 +767,7 @@ export class RemoteArray {
         this.#object = object;
     }
     static objectAsArray(object) {
-        if (!object || object.type !== 'object' || (object.subtype !== 'array' && object.subtype !== 'typedarray')) {
+        if (object?.type !== 'object' || (object.subtype !== 'array' && object.subtype !== 'typedarray')) {
             throw new Error('Object is empty or not an array');
         }
         return new RemoteArray(object);