devtools-tracing 1.2.0 → 1.2.2

package/dist/lib/front_end/core/sdk/OverlayPersistentHighlighter.d.ts

@@ -0,0 +1,116 @@
+import * as Protocol from '../../generated/protocol.js';
+import * as Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import type { DOMModel } from './DOMModel.js';
+export declare const enum HighlightType {
+    FLEX = "FLEX",
+    GRID = "GRID",
+    SCROLL_SNAP = "SCROLL_SNAP",
+    CONTAINER_QUERY = "CONTAINER_QUERY",
+    ISOLATED_ELEMENT = "ISOLATED_ELEMENT"
+}
+export interface PersistentHighlightSettingItem {
+    url: Platform.DevToolsPath.UrlString;
+    path: string;
+    type: HighlightType;
+}
+export interface PersistentHighlighterCallbacks {
+    onGridOverlayStateChanged: ({ nodeId, enabled }: {
+        nodeId: Protocol.DOM.NodeId;
+        enabled: boolean;
+    }) => void;
+    onFlexOverlayStateChanged: ({ nodeId, enabled }: {
+        nodeId: Protocol.DOM.NodeId;
+        enabled: boolean;
+    }) => void;
+    onScrollSnapOverlayStateChanged: ({ nodeId, enabled }: {
+        nodeId: Protocol.DOM.NodeId;
+        enabled: boolean;
+    }) => void;
+    onContainerQueryOverlayStateChanged: ({ nodeId, enabled }: {
+        nodeId: Protocol.DOM.NodeId;
+        enabled: boolean;
+    }) => void;
+}
+export declare class OverlayPersistentHighlighter {
+    #private;
+    constructor(model: OverlayModel, settings: Common.Settings.Settings, callbacks: PersistentHighlighterCallbacks);
+    private onSettingChange;
+    private buildGridHighlightConfig;
+    private buildFlexContainerHighlightConfig;
+    private buildScrollSnapContainerHighlightConfig;
+    highlightGridInOverlay(nodeId: Protocol.DOM.NodeId): void;
+    isGridHighlighted(nodeId: Protocol.DOM.NodeId): boolean;
+    colorOfGrid(nodeId: Protocol.DOM.NodeId): Common.Color.Color;
+    setColorOfGrid(nodeId: Protocol.DOM.NodeId, color: Common.Color.Color): void;
+    hideGridInOverlay(nodeId: Protocol.DOM.NodeId): void;
+    highlightScrollSnapInOverlay(nodeId: Protocol.DOM.NodeId): void;
+    isScrollSnapHighlighted(nodeId: Protocol.DOM.NodeId): boolean;
+    hideScrollSnapInOverlay(nodeId: Protocol.DOM.NodeId): void;
+    highlightFlexInOverlay(nodeId: Protocol.DOM.NodeId): void;
+    isFlexHighlighted(nodeId: Protocol.DOM.NodeId): boolean;
+    colorOfFlex(nodeId: Protocol.DOM.NodeId): Common.Color.Color;
+    setColorOfFlex(nodeId: Protocol.DOM.NodeId, color: Common.Color.Color): void;
+    hideFlexInOverlay(nodeId: Protocol.DOM.NodeId): void;
+    highlightContainerQueryInOverlay(nodeId: Protocol.DOM.NodeId): void;
+    hideContainerQueryInOverlay(nodeId: Protocol.DOM.NodeId): void;
+    isContainerQueryHighlighted(nodeId: Protocol.DOM.NodeId): boolean;
+    private buildContainerQueryContainerHighlightConfig;
+    highlightIsolatedElementInOverlay(nodeId: Protocol.DOM.NodeId): void;
+    hideIsolatedElementInOverlay(nodeId: Protocol.DOM.NodeId): void;
+    isIsolatedElementHighlighted(nodeId: Protocol.DOM.NodeId): boolean;
+    private buildIsolationModeHighlightConfig;
+    hideAllInOverlayWithoutSave(): void;
+    refreshHighlights(): void;
+    private updateHighlightsForDeletedNodes;
+    resetOverlay(): void;
+    private updateHighlightsInOverlay;
+    private updateGridHighlightsInOverlay;
+    private updateFlexHighlightsInOverlay;
+    private updateScrollSnapHighlightsInOverlay;
+    updateContainerQueryHighlightsInOverlay(): void;
+    updateIsolatedElementHighlightsInOverlay(): void;
+    restoreHighlightsForDocument(): Promise<void>;
+    private currentUrl;
+    private getPersistentHighlightSettingForOneType;
+    private savePersistentHighlightSetting;
+}
+export interface OverlayAgent {
+    invoke_setShowGridOverlays(param: {
+        gridNodeHighlightConfigs: Array<{
+            nodeId: number;
+            gridHighlightConfig: Protocol.Overlay.GridHighlightConfig;
+        }>;
+    }): void;
+    invoke_setShowFlexOverlays(param: {
+        flexNodeHighlightConfigs: Array<{
+            nodeId: number;
+            flexContainerHighlightConfig: Protocol.Overlay.FlexContainerHighlightConfig;
+        }>;
+    }): void;
+    invoke_setShowScrollSnapOverlays(param: {
+        scrollSnapHighlightConfigs: Array<{
+            nodeId: number;
+        }>;
+    }): void;
+    invoke_setShowContainerQueryOverlays(param: {
+        containerQueryHighlightConfigs: Array<{
+            nodeId: number;
+            containerQueryContainerHighlightConfig: Protocol.Overlay.ContainerQueryContainerHighlightConfig;
+        }>;
+    }): void;
+    invoke_setShowIsolatedElements(param: {
+        isolatedElementHighlightConfigs: Array<{
+            nodeId: number;
+            isolationModeHighlightConfig: Protocol.Overlay.IsolationModeHighlightConfig;
+        }>;
+    }): void;
+}
+export interface Target {
+    overlayAgent(): OverlayAgent;
+}
+export interface OverlayModel {
+    getDOMModel(): DOMModel;
+    target(): Target;
+    setShowViewportSizeOnResize(value: boolean): void;
+}

package/dist/lib/front_end/core/sdk/PageLoad.d.ts

@@ -0,0 +1,14 @@
+import type * as Platform from '../platform/platform.js';
+import type { NetworkRequest } from './NetworkRequest.js';
+export declare class PageLoad {
+    id: number;
+    url: Platform.DevToolsPath.UrlString;
+    startTime: number;
+    loadTime: number;
+    contentLoadTime: number;
+    mainRequest: NetworkRequest;
+    constructor(mainRequest: NetworkRequest);
+    static forRequest(request: NetworkRequest): PageLoad | null;
+    bindRequest(request: NetworkRequest): void;
+    private static lastIdentifier;
+}

package/dist/lib/front_end/core/sdk/PageResourceLoader.d.ts

@@ -0,0 +1,111 @@
+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 Platform from '../platform/platform.js';
+import { MultitargetNetworkManager } from './NetworkManager.js';
+import { PrimaryPageChangeType, type ResourceTreeFrame } from './ResourceTreeModel.js';
+import type { Target } from './Target.js';
+import { TargetManager } from './TargetManager.js';
+export interface ExtensionInitiator {
+    target: null;
+    frameId: null;
+    initiatorUrl: Platform.DevToolsPath.UrlString;
+    extensionId: string;
+}
+export type PageResourceLoadInitiator = {
+    target: null;
+    frameId: Protocol.Page.FrameId;
+    initiatorUrl: Platform.DevToolsPath.UrlString | null;
+} | {
+    target: Target;
+    frameId: Protocol.Page.FrameId | null;
+    initiatorUrl: Platform.DevToolsPath.UrlString | null;
+} | ExtensionInitiator;
+export interface PageResource {
+    success: boolean | null;
+    errorMessage?: string;
+    initiator: PageResourceLoadInitiator;
+    url: Platform.DevToolsPath.UrlString;
+    size: number | null;
+    duration: number | null;
+}
+/** Used for revealing a resource. **/
+export declare class ResourceKey {
+    readonly key: string;
+    constructor(key: string);
+}
+export type UserAgentProvider = Pick<MultitargetNetworkManager, 'currentUserAgent'>;
+/**
+ * The PageResourceLoader has two responsibilities: loading resources and tracking statistics scoped to targets
+ * for the DeveloperResourcesPanel. Many places only require the former, so we expose that functionality via small
+ * sub-interface. This makes it easier to test classes that require resource loading.
+ */
+export type ResourceLoader = Pick<PageResourceLoader, 'loadResource'>;
+/**
+ * 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 declare class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements ResourceLoader {
+    #private;
+    constructor(targetManager: TargetManager, settings: Common.Settings.Settings, userAgentProvider: UserAgentProvider, loadOverride: ((arg0: string) => Promise<{
+        success: boolean;
+        content: string | Uint8Array<ArrayBuffer>;
+        errorDescription: Host.ResourceLoader.LoadErrorDescription;
+    }>) | null, maxConcurrentLoads?: number);
+    static instance({ forceNew, targetManager, settings, userAgentProvider, loadOverride, maxConcurrentLoads }?: {
+        forceNew: boolean;
+        loadOverride: (null | ((arg0: string) => Promise<{
+            success: boolean;
+            content: string | Uint8Array<ArrayBuffer>;
+            errorDescription: Host.ResourceLoader.LoadErrorDescription;
+        }>));
+        targetManager?: TargetManager;
+        settings?: Common.Settings.Settings;
+        userAgentProvider?: UserAgentProvider;
+        maxConcurrentLoads?: number;
+    }): PageResourceLoader;
+    static removeInstance(): void;
+    onPrimaryPageChanged(event: Common.EventTarget.EventTargetEvent<{
+        frame: ResourceTreeFrame;
+        type: PrimaryPageChangeType;
+    }>): void;
+    getResourcesLoaded(): Map<string, PageResource>;
+    getScopedResourcesLoaded(): Map<string, PageResource>;
+    /**
+     * Loading is the number of currently loading and queued items. Resources is the total number of resources,
+     * including loading and queued resources, but not including resources that are still loading but scheduled
+     * for cancelation.;
+     */
+    getNumberOfResources(): {
+        loading: number;
+        queued: number;
+        resources: number;
+    };
+    getScopedNumberOfResources(): {
+        loading: number;
+        resources: number;
+    };
+    private acquireLoadSlot;
+    private releaseLoadSlot;
+    static makeExtensionKey(url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator): string;
+    static makeKey(url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator): string;
+    resourceLoadedThroughExtension(pageResource: PageResource): void;
+    loadResource(url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator, isBinary: true): Promise<{
+        content: Uint8Array<ArrayBuffer>;
+    }>;
+    loadResource(url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator, isBinary?: false): Promise<{
+        content: string;
+    }>;
+    private dispatchLoad;
+    private getDeveloperResourceScheme;
+    private loadFromTarget;
+    private loadFromHostBindings;
+    getLoadThroughTargetSetting(): Common.Settings.Setting<boolean>;
+}
+export declare const enum Events {
+    UPDATE = "Update"
+}
+export interface EventTypes {
+    [Events.UPDATE]: void;
+}

package/dist/lib/front_end/core/sdk/PaintProfiler.d.ts

@@ -0,0 +1,43 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class PaintProfilerModel extends SDKModel<void> {
+    readonly layerTreeAgent: ProtocolProxyApi.LayerTreeApi;
+    constructor(target: Target);
+    loadSnapshotFromFragments(tiles: Protocol.LayerTree.PictureTile[]): Promise<PaintProfilerSnapshot | null>;
+    loadSnapshot(encodedPicture: Protocol.binary): Promise<PaintProfilerSnapshot | null>;
+    makeSnapshot(layerId: Protocol.LayerTree.LayerId): Promise<PaintProfilerSnapshot | null>;
+}
+export declare class PaintProfilerSnapshot {
+    #private;
+    constructor(paintProfilerModel: PaintProfilerModel, snapshotId: Protocol.LayerTree.SnapshotId);
+    release(): void;
+    addReference(): void;
+    replay(scale?: number, fromStep?: number, toStep?: number): Promise<string | null>;
+    profile(clipRect: Protocol.DOM.Rect | null): Promise<Protocol.LayerTree.PaintProfile[]>;
+    commandLog(): Promise<PaintProfilerLogItem[] | null>;
+}
+export declare class PaintProfilerLogItem {
+    method: string;
+    params: RawPaintProfilerLogItemParams | null;
+    commandIndex: number;
+    constructor(rawEntry: RawPaintProfilerLogItem, commandIndex: number);
+}
+export type RawPaintProfilerLogItemParamValue = string | {
+    [key: string]: RawPaintProfilerLogItemParamValue;
+};
+export type RawPaintProfilerLogItemParams = Record<string, RawPaintProfilerLogItemParamValue>;
+export interface SnapshotWithRect {
+    rect: Protocol.DOM.Rect;
+    snapshot: PaintProfilerSnapshot;
+}
+export interface PictureFragment {
+    x: number;
+    y: number;
+    picture: string;
+}
+export interface RawPaintProfilerLogItem {
+    method: string;
+    params: RawPaintProfilerLogItemParams | null;
+}

package/dist/lib/front_end/core/sdk/PerformanceMetricsModel.d.ts

@@ -0,0 +1,12 @@
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class PerformanceMetricsModel extends SDKModel<void> {
+    #private;
+    constructor(target: Target);
+    enable(): Promise<Object>;
+    disable(): Promise<Object>;
+    requestMetrics(): Promise<{
+        metrics: Map<string, number>;
+        timestamp: number;
+    }>;
+}

package/dist/lib/front_end/core/sdk/PreloadingModel.d.ts

@@ -0,0 +1,146 @@
+import * as Protocol from '../../generated/protocol.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export interface WithId<I, V> {
+    id: I;
+    value: V;
+}
+/**
+ * Holds preloading related information.
+ *
+ * - SpeculationRule rule sets
+ * - Preloading attempts
+ * - Relationship between rule sets and preloading attempts
+ **/
+export declare class PreloadingModel extends SDKModel<EventTypes> {
+    private agent;
+    private loaderIds;
+    private targetJustAttached;
+    private lastPrimaryPageModel;
+    private documents;
+    constructor(target: Target);
+    dispose(): void;
+    reset(): void;
+    private maybeInferLoaderId;
+    private ensureDocumentPreloadingData;
+    private currentLoaderId;
+    private currentDocument;
+    getRuleSetById(id: Protocol.Preload.RuleSetId): Protocol.Preload.RuleSet | null;
+    getAllRuleSets(): Array<WithId<Protocol.Preload.RuleSetId, Protocol.Preload.RuleSet>>;
+    getPreloadCountsByRuleSetId(): Map<Protocol.Preload.RuleSetId | null, Map<PreloadingStatus, number>>;
+    getPreloadingAttemptById(id: PreloadingAttemptId): PreloadingAttempt | null;
+    getRepresentativePreloadingAttempts(ruleSetId: Protocol.Preload.RuleSetId | null): Array<WithId<PreloadingAttemptId, PreloadingAttempt>>;
+    getRepresentativePreloadingAttemptsOfPreviousPage(): Array<WithId<PreloadingAttemptId, PreloadingAttempt>>;
+    private getPipelineById;
+    getPipeline(attempt: PreloadingAttempt): PreloadPipeline;
+    private onPrimaryPageChanged;
+    onRuleSetUpdated(event: Protocol.Preload.RuleSetUpdatedEvent): void;
+    onRuleSetRemoved(event: Protocol.Preload.RuleSetRemovedEvent): void;
+    onPreloadingAttemptSourcesUpdated(event: Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent): void;
+    onPrefetchStatusUpdated(event: Protocol.Preload.PrefetchStatusUpdatedEvent): void;
+    onPrerenderStatusUpdated(event: Protocol.Preload.PrerenderStatusUpdatedEvent): void;
+    onPreloadEnabledStateUpdated(event: Protocol.Preload.PreloadEnabledStateUpdatedEvent): void;
+}
+export declare const enum Events {
+    MODEL_UPDATED = "ModelUpdated",
+    WARNINGS_UPDATED = "WarningsUpdated"
+}
+export interface EventTypes {
+    [Events.MODEL_UPDATED]: void;
+    [Events.WARNINGS_UPDATED]: Protocol.Preload.PreloadEnabledStateUpdatedEvent;
+}
+/**
+ * Protocol.Preload.PreloadingStatus|'NotTriggered'
+ *
+ * A renderer sends SpeculationCandidate to the browser process and the
+ * browser process checks eligibilities, and starts PreloadingAttempt.
+ *
+ * In the frontend, "NotTriggered" is used to denote that a
+ * PreloadingAttempt is waiting for at trigger event (eg:
+ * mousedown/mouseover). All PreloadingAttempts will start off as
+ * "NotTriggered", but "eager" preloading attempts (attempts not
+ * actually waiting for any trigger) will be processed by the browser
+ * immediately, and will not stay in this state for long.
+ *
+ * TODO(https://crbug.com/1384419): Add NotEligible.
+ **/
+export declare const enum PreloadingStatus {
+    NOT_TRIGGERED = "NotTriggered",
+    PENDING = "Pending",
+    RUNNING = "Running",
+    READY = "Ready",
+    SUCCESS = "Success",
+    FAILURE = "Failure",
+    NOT_SUPPORTED = "NotSupported"
+}
+export type PreloadingAttemptId = string;
+export type PreloadingAttempt = PrefetchAttempt | PrerenderAttempt | PrerenderUntilScriptAttempt;
+export interface PrefetchAttempt {
+    action: Protocol.Preload.SpeculationAction.Prefetch;
+    key: Protocol.Preload.PreloadingAttemptKey;
+    pipelineId: Protocol.Preload.PreloadPipelineId | null;
+    status: PreloadingStatus;
+    prefetchStatus: Protocol.Preload.PrefetchStatus | null;
+    requestId: Protocol.Network.RequestId;
+    ruleSetIds: Protocol.Preload.RuleSetId[];
+    nodeIds: Protocol.DOM.BackendNodeId[];
+}
+export interface PrerenderAttempt {
+    action: Protocol.Preload.SpeculationAction.Prerender;
+    key: Protocol.Preload.PreloadingAttemptKey;
+    pipelineId: Protocol.Preload.PreloadPipelineId | null;
+    status: PreloadingStatus;
+    prerenderStatus: Protocol.Preload.PrerenderFinalStatus | null;
+    disallowedMojoInterface: string | null;
+    mismatchedHeaders: Protocol.Preload.PrerenderMismatchedHeaders[] | null;
+    ruleSetIds: Protocol.Preload.RuleSetId[];
+    nodeIds: Protocol.DOM.BackendNodeId[];
+}
+export interface PrerenderUntilScriptAttempt {
+    action: Protocol.Preload.SpeculationAction.PrerenderUntilScript;
+    key: Protocol.Preload.PreloadingAttemptKey;
+    pipelineId: Protocol.Preload.PreloadPipelineId | null;
+    status: PreloadingStatus;
+    prerenderStatus: Protocol.Preload.PrerenderFinalStatus | null;
+    disallowedMojoInterface: string | null;
+    mismatchedHeaders: Protocol.Preload.PrerenderMismatchedHeaders[] | null;
+    ruleSetIds: Protocol.Preload.RuleSetId[];
+    nodeIds: Protocol.DOM.BackendNodeId[];
+}
+export type PreloadingAttemptInternal = PrefetchAttemptInternal | PrerenderAttemptInternal | PrerenderUntilScriptAttemptInternal;
+export interface PrefetchAttemptInternal {
+    action: Protocol.Preload.SpeculationAction.Prefetch;
+    key: Protocol.Preload.PreloadingAttemptKey;
+    pipelineId: Protocol.Preload.PreloadPipelineId | null;
+    status: PreloadingStatus;
+    prefetchStatus: Protocol.Preload.PrefetchStatus | null;
+    requestId: Protocol.Network.RequestId;
+}
+export interface PrerenderAttemptInternal {
+    action: Protocol.Preload.SpeculationAction.Prerender;
+    key: Protocol.Preload.PreloadingAttemptKey;
+    pipelineId: Protocol.Preload.PreloadPipelineId | null;
+    status: PreloadingStatus;
+    prerenderStatus: Protocol.Preload.PrerenderFinalStatus | null;
+    disallowedMojoInterface: string | null;
+    mismatchedHeaders: Protocol.Preload.PrerenderMismatchedHeaders[] | null;
+}
+export interface PrerenderUntilScriptAttemptInternal {
+    action: Protocol.Preload.SpeculationAction.PrerenderUntilScript;
+    key: Protocol.Preload.PreloadingAttemptKey;
+    pipelineId: Protocol.Preload.PreloadPipelineId | null;
+    status: PreloadingStatus;
+    prerenderStatus: Protocol.Preload.PrerenderFinalStatus | null;
+    disallowedMojoInterface: string | null;
+    mismatchedHeaders: Protocol.Preload.PrerenderMismatchedHeaders[] | null;
+}
+export declare class PreloadPipeline {
+    private inner;
+    constructor(inner: Map<Protocol.Preload.SpeculationAction, PreloadingAttempt>);
+    static newFromAttemptsForTesting(attempts: PreloadingAttempt[]): PreloadPipeline;
+    getOriginallyTriggered(): PreloadingAttempt;
+    getPrefetch(): PreloadingAttempt | null;
+    getPrerender(): PreloadingAttempt | null;
+    getPrerenderUntilScript(): PreloadingAttempt | null;
+    getAttempts(): PreloadingAttempt[];
+}

package/dist/lib/front_end/core/sdk/RehydratingConnection.d.ts

@@ -0,0 +1,57 @@
+import type * as Platform from '../platform/platform.js';
+import * as ProtocolClient from '../protocol_client/protocol_client.js';
+import type { ProtocolMessage, RehydratingExecutionContext, RehydratingResource, RehydratingScript, RehydratingTarget, ServerMessage } from './RehydratingObject.js';
+import { TraceObject } from './TraceObject.js';
+export interface RehydratingConnectionInterface {
+    postToFrontend: (arg: ServerMessage) => void;
+}
+export declare const enum RehydratingConnectionState {
+    UNINITIALIZED = 1,
+    INITIALIZED = 2,
+    REHYDRATED = 3
+}
+export declare class RehydratingConnectionTransport implements ProtocolClient.ConnectionTransport.ConnectionTransport {
+    #private;
+    rehydratingConnectionState: RehydratingConnectionState;
+    onDisconnect: ((arg0: string) => void) | null;
+    onMessage: ((arg0: Object) => void) | null;
+    trace: TraceObject | null;
+    sessions: Map<number, RehydratingSessionBase>;
+    constructor(onConnectionLost: (message: Platform.UIString.LocalizedString) => void);
+    /**
+     * This is a callback for rehydrated session to receive payload from host window. Payload includes but not limited to
+     * the trace event and all necessary data to power a rehydrated session.
+     */
+    onReceiveHostWindowPayload(event: MessageEvent): void;
+    startHydration(trace: TraceObject): Promise<boolean>;
+    setOnMessage(onMessage: (arg0: Object | string) => void): void;
+    setOnDisconnect(onDisconnect: (arg0: string) => void): void;
+    sendRawMessage(message: string | object): void;
+    postToFrontend(arg: ServerMessage): void;
+    disconnect(): Promise<void>;
+}
+/** Default rehydrating session with default responses. **/
+declare class RehydratingSessionBase {
+    connection: RehydratingConnectionInterface | null;
+    constructor(connection: RehydratingConnectionInterface);
+    sendMessageToFrontend(payload: ServerMessage): void;
+    handleFrontendMessageAsFakeCDPAgent(data: ProtocolMessage): void;
+}
+export declare class RehydratingSession extends RehydratingSessionBase {
+    sessionId: number;
+    target: RehydratingTarget;
+    executionContexts: RehydratingExecutionContext[];
+    scripts: RehydratingScript[];
+    resources: RehydratingResource[];
+    constructor(sessionId: number, target: RehydratingTarget, executionContexts: RehydratingExecutionContext[], scripts: RehydratingScript[], resources: RehydratingResource[], connection: RehydratingConnectionInterface);
+    sendMessageToFrontend(payload: ServerMessage, attachSessionId?: boolean): void;
+    handleFrontendMessageAsFakeCDPAgent(data: ProtocolMessage): void;
+    declareSessionAttachedToTarget(): void;
+    private handleRuntimeEnabled;
+    private handleDebuggerGetScriptSource;
+    private handleDebuggerEnable;
+    private handleGetResourceTree;
+    private handleGetResourceContent;
+    private handleGetStyleSheetText;
+}
+export {};

package/dist/lib/front_end/core/sdk/RehydratingObject.d.ts

@@ -0,0 +1,59 @@
+import type * as Protocol from '../../generated/protocol.js';
+/** This object is emitted to ScriptParsed and also used in the RehydratingConnection **/
+export interface RehydratingScript extends Protocol.Debugger.ScriptParsedEvent {
+    sourceText?: string;
+    executionContextAuxData?: RehydratingExecutionContextAuxData;
+    isolate: string;
+    /** The manually provided string via the `//# sourceURL` directive. Meanwhile the `url` is the script's `src`  */
+    sourceURL?: string;
+    pid: number;
+}
+export interface RehydratingResource {
+    url: string;
+    content: string;
+    frame: string;
+    mimeType: string;
+}
+export interface RehydratingExecutionContextAuxData {
+    frameId?: Protocol.Page.FrameId;
+    isDefault?: boolean;
+    type?: string;
+}
+export interface RehydratingExecutionContext extends Protocol.Runtime.ExecutionContextDescription {
+    /** AKA V8ContextToken. https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/inspector/inspector_trace_events.cc;l=1229;drc=3c88f61e18b043e70c225d8d57c77832a85e7f58 */
+    v8Context?: string;
+    auxData?: RehydratingExecutionContextAuxData;
+    isolate: string;
+}
+export interface RehydratingTarget {
+    targetId: Protocol.Target.TargetID;
+    type: string;
+    url: string;
+    pid?: number;
+    isolate?: string;
+}
+export interface HydratingDataPerTarget {
+    target: RehydratingTarget;
+    executionContexts: RehydratingExecutionContext[];
+    scripts: RehydratingScript[];
+    resources: RehydratingResource[];
+}
+export interface ProtocolMessage {
+    id: number;
+    method: string;
+    sessionId?: number;
+    params?: object;
+}
+export interface ProtocolEvent {
+    method: string;
+    params: object;
+}
+export interface ProtocolResponse {
+    id: number;
+}
+export type ServerMessage = (ProtocolEvent | ProtocolMessage | ProtocolResponse) & Record<string, unknown>;
+export interface Session {
+    target: RehydratingTarget;
+    executionContexts: RehydratingExecutionContext[];
+    scripts: RehydratingScript[];
+}