devtools-tracing 1.2.1 → 1.2.2

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

@@ -0,0 +1,199 @@
+import * as Protocol from '../../generated/protocol.js';
+import type { DOMPinnedWebIDLProp, DOMPinnedWebIDLType } from '../common/JavaScriptMetaData.js';
+import type { DebuggerModel, FunctionDetails } from './DebuggerModel.js';
+import type { RuntimeModel } from './RuntimeModel.js';
+/** This cannot be an interface due to "instanceof RemoteObject" checks in the code. **/
+export declare abstract class RemoteObject {
+    static fromLocalObject(value: unknown): RemoteObject;
+    static type(remoteObject: RemoteObject): string;
+    static isNullOrUndefined(remoteObject?: RemoteObject): boolean;
+    static arrayNameFromDescription(description: string): string;
+    static arrayLength(object: RemoteObject | Protocol.Runtime.RemoteObject | Protocol.Runtime.ObjectPreview): number;
+    static arrayBufferByteLength(object: RemoteObject | Protocol.Runtime.RemoteObject | Protocol.Runtime.ObjectPreview): number;
+    static isEmptyArray(object: RemoteObject | Protocol.Runtime.RemoteObject | Protocol.Runtime.ObjectPreview): boolean;
+    static unserializableDescription(object: unknown): string | null;
+    static toCallArgument(object: string | number | bigint | boolean | RemoteObject | Protocol.Runtime.RemoteObject | null | undefined): Protocol.Runtime.CallArgument;
+    static loadFromObjectPerProto(object: RemoteObject, generatePreview: boolean, nonIndexedPropertiesOnly?: boolean): Promise<GetPropertiesResult>;
+    customPreview(): Protocol.Runtime.CustomPreview | null;
+    abstract get objectId(): Protocol.Runtime.RemoteObjectId | undefined;
+    abstract get type(): string;
+    abstract get subtype(): string | undefined;
+    abstract get value(): any;
+    abstract get description(): string | undefined;
+    abstract set description(description: string | undefined);
+    abstract get hasChildren(): boolean;
+    abstract arrayLength(): number;
+    abstract getOwnProperties(generatePreview: boolean, nonIndexedPropertiesOnly?: boolean): Promise<GetPropertiesResult>;
+    abstract getAllProperties(accessorPropertiesOnly: boolean, generatePreview: boolean, nonIndexedPropertiesOnly?: boolean): Promise<GetPropertiesResult>;
+    unserializableValue(): string | undefined;
+    get preview(): Protocol.Runtime.ObjectPreview | undefined;
+    get className(): string | null;
+    callFunction<T, U>(_functionDeclaration: (this: U, ...args: any[]) => T, _args?: Protocol.Runtime.CallArgument[]): Promise<CallFunctionResult>;
+    callFunctionJSON<T, U>(_functionDeclaration: (this: U, ...args: any[]) => T, _args: Protocol.Runtime.CallArgument[] | undefined): Promise<T | null>;
+    arrayBufferByteLength(): number;
+    deleteProperty(_name: Protocol.Runtime.CallArgument): Promise<string | undefined>;
+    setPropertyValue(_name: string | Protocol.Runtime.CallArgument, _value: string): Promise<string | undefined>;
+    release(): void;
+    debuggerModel(): DebuggerModel;
+    runtimeModel(): RuntimeModel;
+    isNode(): boolean;
+    /**
+     * Checks whether this object can be inspected with the Linear memory inspector.
+     * @returns `true` if this object can be inspected with the Linear memory inspector.
+     */
+    isLinearMemoryInspectable(): boolean;
+    webIdl?: RemoteObjectWebIdlTypeMetadata;
+}
+export declare class RemoteObjectImpl extends RemoteObject {
+    #private;
+    constructor(runtimeModel: RuntimeModel, objectId: Protocol.Runtime.RemoteObjectId | undefined, type: string, subtype: string | undefined, value: typeof RemoteObject.prototype.value, unserializableValue?: string, description?: string, preview?: Protocol.Runtime.ObjectPreview, customPreview?: Protocol.Runtime.CustomPreview, className?: string);
+    customPreview(): Protocol.Runtime.CustomPreview | null;
+    get objectId(): Protocol.Runtime.RemoteObjectId | undefined;
+    get type(): string;
+    get subtype(): string | undefined;
+    get value(): typeof RemoteObject.prototype.value;
+    unserializableValue(): string | undefined;
+    get description(): string | undefined;
+    set description(description: string | undefined);
+    get hasChildren(): boolean;
+    get preview(): Protocol.Runtime.ObjectPreview | undefined;
+    get className(): string | null;
+    getOwnProperties(generatePreview: boolean, nonIndexedPropertiesOnly?: boolean): Promise<GetPropertiesResult>;
+    getAllProperties(accessorPropertiesOnly: boolean, generatePreview: boolean, nonIndexedPropertiesOnly?: boolean): Promise<GetPropertiesResult>;
+    createRemoteObject(object: Protocol.Runtime.RemoteObject): Promise<RemoteObject>;
+    doGetProperties(ownProperties: boolean, accessorPropertiesOnly: boolean, nonIndexedPropertiesOnly: boolean, generatePreview: boolean): Promise<GetPropertiesResult>;
+    setPropertyValue(name: string | Protocol.Runtime.CallArgument, value: string): Promise<string | undefined>;
+    doSetObjectPropertyValue(result: Protocol.Runtime.RemoteObject, name: Protocol.Runtime.CallArgument): Promise<string | undefined>;
+    deleteProperty(name: Protocol.Runtime.CallArgument): Promise<string | undefined>;
+    callFunction<T, U>(functionDeclaration: (this: U, ...args: any[]) => T, args?: Protocol.Runtime.CallArgument[]): Promise<CallFunctionResult>;
+    callFunctionJSON<T, U>(functionDeclaration: (this: U, ...args: any[]) => T, args: Protocol.Runtime.CallArgument[] | undefined): Promise<T | null>;
+    release(): void;
+    arrayLength(): number;
+    arrayBufferByteLength(): number;
+    debuggerModel(): DebuggerModel;
+    runtimeModel(): RuntimeModel;
+    isNode(): boolean;
+    isLinearMemoryInspectable(): boolean;
+}
+export declare class ScopeRemoteObject extends RemoteObjectImpl {
+    #private;
+    constructor(runtimeModel: RuntimeModel, objectId: Protocol.Runtime.RemoteObjectId | undefined, scopeRef: ScopeRef, type: string, subtype: string | undefined, value: typeof RemoteObjectImpl.prototype.value, unserializableValue?: string, description?: string, preview?: Protocol.Runtime.ObjectPreview);
+    doGetProperties(ownProperties: boolean, accessorPropertiesOnly: boolean, _generatePreview: boolean): Promise<GetPropertiesResult>;
+    doSetObjectPropertyValue(result: Protocol.Runtime.RemoteObject, argumentName: Protocol.Runtime.CallArgument): Promise<string | undefined>;
+}
+export declare class ScopeRef {
+    readonly number: number;
+    readonly callFrameId: Protocol.Debugger.CallFrameId;
+    constructor(number: number, callFrameId: Protocol.Debugger.CallFrameId);
+}
+export declare class RemoteObjectProperty {
+    name: string;
+    value?: RemoteObject;
+    enumerable: boolean;
+    writable: boolean;
+    isOwn: boolean;
+    wasThrown: boolean;
+    symbol: RemoteObject | undefined;
+    synthetic: boolean;
+    syntheticSetter: ((arg0: string) => Promise<RemoteObject | null>) | undefined;
+    private: boolean;
+    getter: RemoteObject | undefined;
+    setter: RemoteObject | undefined;
+    webIdl?: RemoteObjectWebIdlPropertyMetadata;
+    constructor(name: string, value: RemoteObject | null, enumerable?: boolean, writable?: boolean, isOwn?: boolean, wasThrown?: boolean, symbol?: RemoteObject | null, synthetic?: boolean, syntheticSetter?: ((arg0: string) => Promise<RemoteObject | null>), isPrivate?: boolean);
+    setSyntheticValue(expression: string): Promise<boolean>;
+    isAccessorProperty(): boolean;
+    match({ includeNullOrUndefinedValues, regex }: {
+        includeNullOrUndefinedValues: boolean;
+        regex: RegExp | null;
+    }): boolean;
+    cloneWithNewName(newName: string): RemoteObjectProperty;
+}
+export declare class LocalJSONObject extends RemoteObject {
+    #private;
+    constructor(value: typeof RemoteObject.prototype.value);
+    get objectId(): Protocol.Runtime.RemoteObjectId | undefined;
+    get value(): typeof RemoteObject.prototype.value;
+    unserializableValue(): string | undefined;
+    get description(): string;
+    private formatValue;
+    private concatenate;
+    get type(): string;
+    get subtype(): string | undefined;
+    get hasChildren(): boolean;
+    getOwnProperties(_generatePreview: boolean, nonIndexedPropertiesOnly?: boolean): Promise<GetPropertiesResult>;
+    getAllProperties(accessorPropertiesOnly: boolean, generatePreview: boolean, nonIndexedPropertiesOnly?: boolean): Promise<GetPropertiesResult>;
+    private children;
+    arrayLength(): number;
+    callFunction<T, U>(functionDeclaration: (this: U, ...args: any[]) => T, args?: Protocol.Runtime.CallArgument[]): Promise<CallFunctionResult>;
+    callFunctionJSON<T, U>(functionDeclaration: (this: U, ...args: any[]) => T, args: Protocol.Runtime.CallArgument[] | undefined): Promise<T | null>;
+}
+export declare class RemoteArrayBuffer {
+    #private;
+    constructor(object: RemoteObject);
+    byteLength(): number;
+    bytes(start?: number, end?: number): Promise<number[] | null>;
+    object(): RemoteObject;
+}
+export declare class RemoteArray {
+    #private;
+    constructor(object: RemoteObject);
+    static objectAsArray(object: RemoteObject | null): RemoteArray;
+    static createFromRemoteObjects(objects: RemoteObject[]): Promise<RemoteArray>;
+    at(index: number): Promise<RemoteObject>;
+    length(): number;
+    map<T>(func: (arg0: RemoteObject) => Promise<T>): Promise<T[]>;
+    object(): RemoteObject;
+}
+export declare class RemoteFunction {
+    #private;
+    constructor(object: RemoteObject);
+    static objectAsFunction(object: RemoteObject): RemoteFunction;
+    targetFunction(): Promise<RemoteObject>;
+    targetFunctionDetails(): Promise<FunctionDetails | null>;
+}
+export declare class RemoteError {
+    #private;
+    private constructor();
+    static objectAsError(object: RemoteObject): RemoteError;
+    get errorStack(): string;
+    exceptionDetails(): Promise<Protocol.Runtime.ExceptionDetails | undefined>;
+    cause(): Promise<RemoteObject | undefined>;
+}
+export interface CallFunctionResult {
+    object: RemoteObject | null;
+    wasThrown?: boolean;
+}
+export interface GetPropertiesResult {
+    properties: RemoteObjectProperty[] | null;
+    internalProperties: RemoteObjectProperty[] | null;
+}
+export interface RemoteObjectWebIdlTypeMetadata {
+    info: DOMPinnedWebIDLType;
+    state: Map<string, string>;
+}
+export interface RemoteObjectWebIdlPropertyMetadata {
+    info: DOMPinnedWebIDLProp;
+    applicable?: boolean;
+}
+/**
+ * Pair of a linear memory inspectable {@link RemoteObject} and an optional
+ * expression, which identifies the variable holding the object in the
+ * current scope or the name of the field holding the object.
+ *
+ * This data structure is used to reveal an object in the Linear Memory
+ * Inspector panel.
+ */
+export declare class LinearMemoryInspectable {
+    /** The linear memory inspectable {@link RemoteObject}. */
+    readonly object: RemoteObject;
+    /** The name of the variable or the field holding the `object`. */
+    readonly expression: string | undefined;
+    /**
+     * Wrap `object` and `expression` into a reveable structure.
+     *
+     * @param object A linear memory inspectable {@link RemoteObject}.
+     * @param expression An optional name of the field or variable holding the `object`.
+     */
+    constructor(object: RemoteObject, expression?: string);
+}

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

@@ -0,0 +1,34 @@
+import type * as Protocol from '../../generated/protocol.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import * as Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import type { NetworkRequest } from './NetworkRequest.js';
+import type { ResourceTreeFrame, ResourceTreeModel } from './ResourceTreeModel.js';
+export declare class Resource implements TextUtils.ContentProvider.ContentProvider {
+    #private;
+    constructor(resourceTreeModel: ResourceTreeModel, request: NetworkRequest | null, url: Platform.DevToolsPath.UrlString, documentURL: Platform.DevToolsPath.UrlString, frameId: Protocol.Page.FrameId | null, loaderId: Protocol.Network.LoaderId | null, type: Common.ResourceType.ResourceType, mimeType: string, lastModified: Date | null, contentSize: number | null);
+    lastModified(): Date | null;
+    contentSize(): number | null;
+    get request(): NetworkRequest | null;
+    get url(): Platform.DevToolsPath.UrlString;
+    set url(x: Platform.DevToolsPath.UrlString);
+    get parsedURL(): Common.ParsedURL.ParsedURL | undefined;
+    get documentURL(): Platform.DevToolsPath.UrlString;
+    get frameId(): Protocol.Page.FrameId | null;
+    get loaderId(): Protocol.Network.LoaderId | null;
+    get displayName(): string;
+    resourceType(): Common.ResourceType.ResourceType;
+    get mimeType(): string;
+    get content(): string | null;
+    get isGenerated(): boolean;
+    set isGenerated(val: boolean);
+    contentURL(): Platform.DevToolsPath.UrlString;
+    contentType(): Common.ResourceType.ResourceType;
+    requestContentData(): Promise<TextUtils.ContentData.ContentDataOrError>;
+    canonicalMimeType(): string;
+    searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): Promise<TextUtils.ContentProvider.SearchMatch[]>;
+    populateImageSource(image: HTMLImageElement): Promise<void>;
+    private innerRequestContent;
+    frame(): ResourceTreeFrame | null;
+    statusCode(): number;
+}

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

@@ -0,0 +1,249 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import * as Protocol from '../../generated/protocol.js';
+import * as Platform from '../platform/platform.js';
+import { type DeferredDOMNode, DOMModel, type DOMNode } from './DOMModel.js';
+import type { NetworkRequest } from './NetworkRequest.js';
+import { Resource } from './Resource.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class ResourceTreeModel extends SDKModel<EventTypes> {
+    #private;
+    readonly agent: ProtocolProxyApi.PageApi;
+    readonly storageAgent: ProtocolProxyApi.StorageApi;
+    readonly framesInternal: Map<string, ResourceTreeFrame>;
+    isInterstitialShowing: boolean;
+    mainFrame: ResourceTreeFrame | null;
+    constructor(target: Target);
+    static frameForRequest(request: NetworkRequest): ResourceTreeFrame | null;
+    static frames(): ResourceTreeFrame[];
+    static resourceForURL(url: Platform.DevToolsPath.UrlString): Resource | null;
+    static reloadAllPages(bypassCache?: boolean, scriptToEvaluateOnLoad?: string): void;
+    storageKeyForFrame(frameId: Protocol.Page.FrameId): Promise<string | null>;
+    domModel(): DOMModel;
+    private processCachedResources;
+    cachedResourcesLoaded(): boolean;
+    private addFrame;
+    frameAttached(frameId: Protocol.Page.FrameId, parentFrameId: Protocol.Page.FrameId | null, stackTrace?: Protocol.Runtime.StackTrace): ResourceTreeFrame | null;
+    frameNavigated(framePayload: Protocol.Page.Frame, type: Protocol.Page.NavigationType | undefined): void;
+    primaryPageChanged(frame: ResourceTreeFrame, type: PrimaryPageChangeType): void;
+    documentOpened(framePayload: Protocol.Page.Frame): void;
+    frameDetached(frameId: Protocol.Page.FrameId, isSwap: boolean): void;
+    private onRequestFinished;
+    private onRequestUpdateDropped;
+    frameForId(frameId: Protocol.Page.FrameId): ResourceTreeFrame | null;
+    forAllResources(callback: (arg0: Resource) => boolean): boolean;
+    frames(): ResourceTreeFrame[];
+    private addFramesRecursively;
+    private createResourceFromFramePayload;
+    suspendReload(): void;
+    resumeReload(): void;
+    reloadPage(ignoreCache?: boolean, scriptToEvaluateOnLoad?: string): void;
+    navigate(url: Platform.DevToolsPath.UrlString): Promise<Protocol.Page.NavigateResponse>;
+    navigationHistory(): Promise<{
+        currentIndex: number;
+        entries: Protocol.Page.NavigationEntry[];
+    } | null>;
+    navigateToHistoryEntry(entry: Protocol.Page.NavigationEntry): void;
+    setLifecycleEventsEnabled(enabled: boolean): Promise<Protocol.ProtocolResponseWithError>;
+    fetchAppManifest(): Promise<{
+        url: Platform.DevToolsPath.UrlString;
+        data: string | null;
+        errors: Protocol.Page.AppManifestError[];
+    }>;
+    getInstallabilityErrors(): Promise<Protocol.Page.InstallabilityError[]>;
+    getAppId(): Promise<Protocol.Page.GetAppIdResponse>;
+    private executionContextComparator;
+    private getSecurityOriginData;
+    private getStorageKeyData;
+    private updateSecurityOrigins;
+    private updateStorageKeys;
+    getMainStorageKey(): Promise<string | null>;
+    getMainSecurityOrigin(): string | null;
+    onBackForwardCacheNotUsed(event: Protocol.Page.BackForwardCacheNotUsedEvent): void;
+    processPendingEvents(frame: ResourceTreeFrame): void;
+}
+export declare enum Events {
+    FrameAdded = "FrameAdded",
+    FrameNavigated = "FrameNavigated",
+    FrameDetached = "FrameDetached",
+    FrameResized = "FrameResized",
+    FrameWillNavigate = "FrameWillNavigate",
+    DocumentOpened = "DocumentOpened",
+    PrimaryPageChanged = "PrimaryPageChanged",
+    ResourceAdded = "ResourceAdded",
+    WillLoadCachedResources = "WillLoadCachedResources",
+    CachedResourcesLoaded = "CachedResourcesLoaded",
+    DOMContentLoaded = "DOMContentLoaded",
+    LifecycleEvent = "LifecycleEvent",
+    Load = "Load",
+    PageReloadRequested = "PageReloadRequested",
+    WillReloadPage = "WillReloadPage",
+    InterstitialShown = "InterstitialShown",
+    InterstitialHidden = "InterstitialHidden",
+    BackForwardCacheDetailsUpdated = "BackForwardCacheDetailsUpdated",
+    JavaScriptDialogOpening = "JavaScriptDialogOpening"
+}
+export interface EventTypes {
+    [Events.FrameAdded]: ResourceTreeFrame;
+    [Events.FrameNavigated]: ResourceTreeFrame;
+    [Events.FrameDetached]: {
+        frame: ResourceTreeFrame;
+        isSwap: boolean;
+    };
+    [Events.FrameResized]: void;
+    [Events.FrameWillNavigate]: ResourceTreeFrame;
+    [Events.DocumentOpened]: ResourceTreeFrame;
+    [Events.PrimaryPageChanged]: {
+        frame: ResourceTreeFrame;
+        type: PrimaryPageChangeType;
+    };
+    [Events.ResourceAdded]: Resource;
+    [Events.WillLoadCachedResources]: void;
+    [Events.CachedResourcesLoaded]: ResourceTreeModel;
+    [Events.DOMContentLoaded]: number;
+    [Events.LifecycleEvent]: {
+        frameId: Protocol.Page.FrameId;
+        name: string;
+    };
+    [Events.Load]: {
+        resourceTreeModel: ResourceTreeModel;
+        loadTime: number;
+    };
+    [Events.PageReloadRequested]: ResourceTreeModel;
+    [Events.WillReloadPage]: void;
+    [Events.InterstitialShown]: void;
+    [Events.InterstitialHidden]: void;
+    [Events.BackForwardCacheDetailsUpdated]: ResourceTreeFrame;
+    [Events.JavaScriptDialogOpening]: Protocol.Page.JavascriptDialogOpeningEvent;
+}
+export declare class ResourceTreeFrame {
+    #private;
+    crossTargetParentFrameId: string | null;
+    resourcesMap: Map<Platform.DevToolsPath.UrlString, Resource>;
+    backForwardCacheDetails: {
+        explanations: Protocol.Page.BackForwardCacheNotRestoredExplanation[];
+        restoredFromCache?: boolean;
+        explanationsTree?: Protocol.Page.BackForwardCacheNotRestoredExplanationTree;
+    };
+    constructor(model: ResourceTreeModel, parentFrame: ResourceTreeFrame | null, frameId: Protocol.Page.FrameId, payload: Protocol.Page.Frame | null, creationStackTrace: Protocol.Runtime.StackTrace | null);
+    isSecureContext(): boolean;
+    getSecureContextType(): Protocol.Page.SecureContextType | null;
+    isCrossOriginIsolated(): boolean;
+    getCrossOriginIsolatedContextType(): Protocol.Page.CrossOriginIsolatedContextType | null;
+    getGatedAPIFeatures(): Protocol.Page.GatedAPIFeatures[] | null;
+    getCreationStackTraceData(): {
+        creationStackTrace: Protocol.Runtime.StackTrace | null;
+        creationStackTraceTarget: Target;
+    };
+    navigate(framePayload: Protocol.Page.Frame): void;
+    resourceTreeModel(): ResourceTreeModel;
+    get id(): Protocol.Page.FrameId;
+    get name(): string;
+    get url(): Platform.DevToolsPath.UrlString;
+    domainAndRegistry(): string;
+    getAdScriptAncestry(frameId: Protocol.Page.FrameId): Promise<Protocol.Network.AdAncestry | null>;
+    get securityOrigin(): string | null;
+    get securityOriginDetails(): Protocol.Page.SecurityOriginDetails | null;
+    getStorageKey(forceFetch: boolean): Promise<string | null>;
+    unreachableUrl(): Platform.DevToolsPath.UrlString;
+    get loaderId(): Protocol.Network.LoaderId;
+    adFrameType(): Protocol.Page.AdFrameType;
+    adFrameStatus(): Protocol.Page.AdFrameStatus | undefined;
+    get childFrames(): ResourceTreeFrame[];
+    /**
+     * Returns the parent frame if both #frames are part of the same process/target.
+     */
+    sameTargetParentFrame(): ResourceTreeFrame | null;
+    /**
+     * Returns the parent frame if both #frames are part of different processes/targets (child is an OOPIF).
+     */
+    crossTargetParentFrame(): ResourceTreeFrame | null;
+    /**
+     * Returns the parent frame. There is only 1 parent and it's either in the
+     * same target or it's cross-target.
+     */
+    parentFrame(): ResourceTreeFrame | null;
+    /**
+     * Returns true if this is the main frame of its target. A main frame is the root of the frame tree i.e. a frame without
+     * a parent, but the whole frame tree could be embedded in another frame tree (e.g. OOPIFs, fenced frames, portals).
+     * https://chromium.googlesource.com/chromium/src/+/HEAD/docs/frame_trees.md
+     */
+    isMainFrame(): boolean;
+    /**
+     * Returns true if this is a main frame which is not embedded in another frame tree. With MPArch features such as
+     * back/forward cache or prerender there can be multiple outermost frames.
+     * https://chromium.googlesource.com/chromium/src/+/HEAD/docs/frame_trees.md
+     */
+    isOutermostFrame(): boolean;
+    /**
+     * Returns true if this is the primary frame of the browser tab. There can only be one primary frame for each
+     * browser tab. It is the outermost frame being actively displayed in the browser tab.
+     * https://chromium.googlesource.com/chromium/src/+/HEAD/docs/frame_trees.md
+     */
+    isPrimaryFrame(): boolean;
+    removeChildFrame(frame: ResourceTreeFrame, isSwap: boolean): void;
+    private removeChildFrames;
+    remove(isSwap: boolean): void;
+    addResource(resource: Resource): void;
+    addRequest(request: NetworkRequest): void;
+    resources(): Resource[];
+    resourceForURL(url: Platform.DevToolsPath.UrlString): Resource | null;
+    callForFrameResources(callback: (arg0: Resource) => boolean): boolean;
+    displayName(): string;
+    getOwnerDeferredDOMNode(): Promise<DeferredDOMNode | null>;
+    getOwnerDOMNodeOrDocument(): Promise<DOMNode | null>;
+    highlight(): Promise<void>;
+    getPermissionsPolicyState(): Promise<Protocol.Page.PermissionsPolicyFeatureState[] | null>;
+    getOriginTrials(): Promise<Protocol.Page.OriginTrial[]>;
+    setCreationStackTrace(creationStackTraceData: {
+        creationStackTrace: Protocol.Runtime.StackTrace | null;
+        creationStackTraceTarget: Target;
+    }): void;
+    setBackForwardCacheDetails(event: Protocol.Page.BackForwardCacheNotUsedEvent): void;
+    getResourcesMap(): Map<string, Resource>;
+}
+export declare class PageDispatcher implements ProtocolProxyApi.PageDispatcher {
+    #private;
+    constructor(resourceTreeModel: ResourceTreeModel);
+    backForwardCacheNotUsed(params: Protocol.Page.BackForwardCacheNotUsedEvent): void;
+    domContentEventFired({ timestamp }: Protocol.Page.DomContentEventFiredEvent): void;
+    loadEventFired({ timestamp }: Protocol.Page.LoadEventFiredEvent): void;
+    lifecycleEvent({ frameId, name }: Protocol.Page.LifecycleEventEvent): void;
+    frameAttached({ frameId, parentFrameId, stack }: Protocol.Page.FrameAttachedEvent): void;
+    frameNavigated({ frame, type }: Protocol.Page.FrameNavigatedEvent): void;
+    documentOpened({ frame }: Protocol.Page.DocumentOpenedEvent): void;
+    frameDetached({ frameId, reason }: Protocol.Page.FrameDetachedEvent): void;
+    frameSubtreeWillBeDetached(_params: Protocol.Page.FrameSubtreeWillBeDetachedEvent): void;
+    frameStartedLoading({}: Protocol.Page.FrameStartedLoadingEvent): void;
+    frameStoppedLoading({}: Protocol.Page.FrameStoppedLoadingEvent): void;
+    frameRequestedNavigation({}: Protocol.Page.FrameRequestedNavigationEvent): void;
+    frameScheduledNavigation({}: Protocol.Page.FrameScheduledNavigationEvent): void;
+    frameClearedScheduledNavigation({}: Protocol.Page.FrameClearedScheduledNavigationEvent): void;
+    frameStartedNavigating({}: Protocol.Page.FrameStartedNavigatingEvent): void;
+    navigatedWithinDocument({}: Protocol.Page.NavigatedWithinDocumentEvent): void;
+    frameResized(): void;
+    javascriptDialogOpening(event: Protocol.Page.JavascriptDialogOpeningEvent): void;
+    javascriptDialogClosed({}: Protocol.Page.JavascriptDialogClosedEvent): void;
+    screencastFrame({}: Protocol.Page.ScreencastFrameEvent): void;
+    screencastVisibilityChanged({}: Protocol.Page.ScreencastVisibilityChangedEvent): void;
+    interstitialShown(): void;
+    interstitialHidden(): void;
+    windowOpen({}: Protocol.Page.WindowOpenEvent): void;
+    compilationCacheProduced({}: Protocol.Page.CompilationCacheProducedEvent): void;
+    fileChooserOpened({}: Protocol.Page.FileChooserOpenedEvent): void;
+    downloadWillBegin({}: Protocol.Page.DownloadWillBeginEvent): void;
+    downloadProgress(): void;
+}
+export interface SecurityOriginData {
+    securityOrigins: Set<string>;
+    mainSecurityOrigin: string | null;
+    unreachableMainSecurityOrigin: string | null;
+}
+export interface StorageKeyData {
+    storageKeys: Set<string>;
+    mainStorageKey: string | null;
+}
+export declare const enum PrimaryPageChangeType {
+    NAVIGATION = "Navigation",
+    ACTIVATION = "Activation"
+}

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

@@ -0,0 +1,158 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import type * as Platform from '../platform/platform.js';
+import { DebuggerModel } from './DebuggerModel.js';
+import { HeapProfilerModel } from './HeapProfilerModel.js';
+import { RemoteObject, RemoteObjectProperty, type ScopeRef } from './RemoteObject.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class RuntimeModel extends SDKModel<EventTypes> {
+    #private;
+    readonly agent: ProtocolProxyApi.RuntimeApi;
+    constructor(target: Target);
+    static isSideEffectFailure(response: Protocol.Runtime.EvaluateResponse | EvaluationResult): boolean;
+    debuggerModel(): DebuggerModel;
+    heapProfilerModel(): HeapProfilerModel;
+    executionContexts(): ExecutionContext[];
+    setExecutionContextComparator(comparator: (arg0: ExecutionContext, arg1: ExecutionContext) => number): void;
+    /**
+     * comparator
+     */
+    executionContextComparator(): (arg0: ExecutionContext, arg1: ExecutionContext) => number;
+    defaultExecutionContext(): ExecutionContext | null;
+    executionContext(id: number): ExecutionContext | null;
+    executionContextCreated(context: Protocol.Runtime.ExecutionContextDescription): void;
+    executionContextDestroyed(executionContextId: number): void;
+    fireExecutionContextOrderChanged(): void;
+    executionContextsCleared(): void;
+    createRemoteObject(payload: Protocol.Runtime.RemoteObject): RemoteObject;
+    createScopeRemoteObject(payload: Protocol.Runtime.RemoteObject, scopeRef: ScopeRef): RemoteObject;
+    createRemoteObjectFromPrimitiveValue(value: string | number | bigint | boolean | undefined): RemoteObject;
+    createRemotePropertyFromPrimitiveValue(name: string, value: string | number | boolean): RemoteObjectProperty;
+    discardConsoleEntries(): void;
+    releaseObjectGroup(objectGroup: string): void;
+    releaseEvaluationResult(result: EvaluationResult): void;
+    runIfWaitingForDebugger(): void;
+    private customFormattersStateChanged;
+    compileScript(expression: string, sourceURL: string, persistScript: boolean, executionContextId: Protocol.Runtime.ExecutionContextId): Promise<CompileScriptResult | null>;
+    runScript(scriptId: Protocol.Runtime.ScriptId, executionContextId: Protocol.Runtime.ExecutionContextId, objectGroup?: string, silent?: boolean, includeCommandLineAPI?: boolean, returnByValue?: boolean, generatePreview?: boolean, awaitPromise?: boolean): Promise<EvaluationResult>;
+    queryObjects(prototype: RemoteObject): Promise<QueryObjectResult>;
+    isolateId(): Promise<string>;
+    heapUsage(): Promise<{
+        usedSize: number;
+        totalSize: number;
+        embedderHeapUsedSize?: number;
+        backingStorageSize?: number;
+    } | null>;
+    inspectRequested(payload: Protocol.Runtime.RemoteObject, hints: unknown, executionContextId?: number): void;
+    addBinding(event: Protocol.Runtime.AddBindingRequest): Promise<Protocol.ProtocolResponseWithError>;
+    removeBinding(request: Protocol.Runtime.RemoveBindingRequest): Promise<Protocol.ProtocolResponseWithError>;
+    bindingCalled(event: Protocol.Runtime.BindingCalledEvent): void;
+    private copyRequested;
+    private queryObjectsRequested;
+    static simpleTextFromException(exceptionDetails: Protocol.Runtime.ExceptionDetails): string;
+    exceptionThrown(timestamp: number, exceptionDetails: Protocol.Runtime.ExceptionDetails): void;
+    exceptionRevoked(exceptionId: number): void;
+    consoleAPICalled(type: Protocol.Runtime.ConsoleAPICalledEventType, args: Protocol.Runtime.RemoteObject[], executionContextId: number, timestamp: number, stackTrace?: Protocol.Runtime.StackTrace, context?: string): void;
+    executionContextIdForScriptId(scriptId: string): number;
+    executionContextForStackTrace(stackTrace: Protocol.Runtime.StackTrace): number;
+    terminateExecution(): Promise<Protocol.ProtocolResponseWithError>;
+    getExceptionDetails(errorObjectId: Protocol.Runtime.RemoteObjectId): Promise<Protocol.Runtime.ExceptionDetails | undefined>;
+}
+export declare enum Events {
+    BindingCalled = "BindingCalled",
+    ExecutionContextCreated = "ExecutionContextCreated",
+    ExecutionContextDestroyed = "ExecutionContextDestroyed",
+    ExecutionContextChanged = "ExecutionContextChanged",
+    ExecutionContextOrderChanged = "ExecutionContextOrderChanged",
+    ExceptionThrown = "ExceptionThrown",
+    ExceptionRevoked = "ExceptionRevoked",
+    ConsoleAPICalled = "ConsoleAPICalled",
+    QueryObjectRequested = "QueryObjectRequested"
+}
+export interface ConsoleAPICall {
+    type: Protocol.Runtime.ConsoleAPICalledEventType;
+    args: Protocol.Runtime.RemoteObject[];
+    executionContextId: number;
+    timestamp: number;
+    stackTrace?: Protocol.Runtime.StackTrace;
+    context?: string;
+}
+export interface ExceptionWithTimestamp {
+    timestamp: number;
+    details: Protocol.Runtime.ExceptionDetails;
+}
+export interface QueryObjectRequestedEvent {
+    objects: RemoteObject;
+    executionContextId?: number;
+}
+export interface EventTypes {
+    [Events.BindingCalled]: Protocol.Runtime.BindingCalledEvent;
+    [Events.ExecutionContextCreated]: ExecutionContext;
+    [Events.ExecutionContextDestroyed]: ExecutionContext;
+    [Events.ExecutionContextChanged]: ExecutionContext;
+    [Events.ExecutionContextOrderChanged]: RuntimeModel;
+    [Events.ExceptionThrown]: ExceptionWithTimestamp;
+    [Events.ExceptionRevoked]: number;
+    [Events.ConsoleAPICalled]: ConsoleAPICall;
+    [Events.QueryObjectRequested]: QueryObjectRequestedEvent;
+}
+export declare class ExecutionContext {
+    #private;
+    id: Protocol.Runtime.ExecutionContextId;
+    uniqueId: string;
+    name: string;
+    origin: Platform.DevToolsPath.UrlString;
+    isDefault: boolean;
+    runtimeModel: RuntimeModel;
+    debuggerModel: DebuggerModel;
+    frameId: Protocol.Page.FrameId | undefined;
+    constructor(runtimeModel: RuntimeModel, id: Protocol.Runtime.ExecutionContextId, uniqueId: string, name: string, origin: Platform.DevToolsPath.UrlString, isDefault: boolean, frameId?: Protocol.Page.FrameId);
+    target(): Target;
+    static comparator(a: ExecutionContext, b: ExecutionContext): number;
+    evaluate(options: EvaluationOptions, userGesture: boolean, awaitPromise: boolean): Promise<EvaluationResult>;
+    globalObject(objectGroup: string, generatePreview: boolean): Promise<EvaluationResult>;
+    callFunctionOn(options: CallFunctionOptions): Promise<EvaluationResult>;
+    private evaluateGlobal;
+    globalLexicalScopeNames(): Promise<string[] | null>;
+    label(): string | null;
+    setLabel(label: string): void;
+}
+export type EvaluationResult = {
+    object: RemoteObject;
+    exceptionDetails?: Protocol.Runtime.ExceptionDetails;
+} | {
+    error: string;
+};
+export interface CompileScriptResult {
+    scriptId?: string;
+    exceptionDetails?: Protocol.Runtime.ExceptionDetails;
+}
+export interface EvaluationOptions {
+    expression: string;
+    objectGroup?: string;
+    includeCommandLineAPI?: boolean;
+    silent?: boolean;
+    returnByValue?: boolean;
+    generatePreview?: boolean;
+    throwOnSideEffect?: boolean;
+    timeout?: number;
+    disableBreaks?: boolean;
+    replMode?: boolean;
+    allowUnsafeEvalBlockedByCSP?: boolean;
+    contextId?: number;
+}
+export interface CallFunctionOptions {
+    functionDeclaration: string;
+    returnByValue?: boolean;
+    throwOnSideEffect?: boolean;
+    allowUnsafeEvalBlockedByCSP?: boolean;
+    arguments: Protocol.Runtime.CallArgument[];
+    userGesture: boolean;
+    awaitPromise: boolean;
+}
+export type QueryObjectResult = {
+    objects: RemoteObject;
+} | {
+    error: string;
+};

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

@@ -0,0 +1,30 @@
+import * as Common from '../common/common.js';
+import type { Target } from './Target.js';
+export interface RegistrationInfo {
+    capabilities: number;
+    autostart: boolean;
+    early?: boolean;
+}
+export type SDKModelConstructor<T extends SDKModel = SDKModel> = new (target: Target) => T;
+declare const registeredModels: Map<SDKModelConstructor<SDKModel<any>>, RegistrationInfo>;
+export declare class SDKModel<Events = any> extends Common.ObjectWrapper.ObjectWrapper<Events> {
+    #private;
+    constructor(target: Target);
+    target(): Target;
+    /**
+     * Override this method to perform tasks that are required to suspend the
+     * model and that still need other models in an unsuspended state.
+     */
+    preSuspendModel(_reason?: string): Promise<void>;
+    suspendModel(_reason?: string): Promise<void>;
+    resumeModel(): Promise<void>;
+    /**
+     * Override this method to perform tasks that are required to after resuming
+     * the model and that require all models already in an unsuspended state.
+     */
+    postResumeModel(): Promise<void>;
+    dispose(): void;
+    static register(modelClass: SDKModelConstructor, registrationInfo: RegistrationInfo): void;
+    static get registeredModels(): typeof registeredModels;
+}
+export {};