devtools-tracing 1.2.1 → 1.2.2

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

@@ -0,0 +1,269 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import * as Protocol from '../../generated/protocol.js';
+import * as Common from '../common/common.js';
+import type * as Platform from '../platform/platform.js';
+import type { PageResourceLoadInitiator } from './PageResourceLoader.js';
+import { type RemoteObject, RemoteObjectProperty } from './RemoteObject.js';
+import { type EvaluationOptions, type EvaluationResult, type ExecutionContext, RuntimeModel } from './RuntimeModel.js';
+import { Script } from './Script.js';
+import { SDKModel } from './SDKModel.js';
+import { SourceMapManager } from './SourceMapManager.js';
+import { type Target } from './Target.js';
+export declare function sortAndMergeRanges(locationRanges: Protocol.Debugger.LocationRange[]): Protocol.Debugger.LocationRange[];
+export declare const enum StepMode {
+    STEP_INTO = "StepInto",
+    STEP_OUT = "StepOut",
+    STEP_OVER = "StepOver"
+}
+export declare const WASM_SYMBOLS_PRIORITY: Protocol.Debugger.DebugSymbolsType[];
+export declare class DebuggerModel extends SDKModel<EventTypes> {
+    #private;
+    readonly agent: ProtocolProxyApi.DebuggerApi;
+    continueToLocationCallback: ((arg0: DebuggerPausedDetails) => boolean) | null;
+    evaluateOnCallFrameCallback: ((arg0: CallFrame, arg1: EvaluationOptions) => Promise<EvaluationResult | null>) | null;
+    constructor(target: Target);
+    static selectSymbolSource(debugSymbols: Protocol.Debugger.DebugSymbols[] | null): Protocol.Debugger.DebugSymbols | null;
+    sourceMapManager(): SourceMapManager<Script>;
+    runtimeModel(): RuntimeModel;
+    debuggerEnabled(): boolean;
+    debuggerId(): string | null;
+    private enableDebugger;
+    syncDebuggerId(): Promise<Protocol.Debugger.EnableResponse>;
+    private onFrameNavigated;
+    private registerDebugger;
+    isReadyToPause(): boolean;
+    static modelForDebuggerId(debuggerId: string): Promise<DebuggerModel | null>;
+    static resyncDebuggerIdForModels(): Promise<void>;
+    private disableDebugger;
+    private skipAllPauses;
+    skipAllPausesUntilReloadOrTimeout(timeout: number): void;
+    private pauseOnExceptionStateChanged;
+    private asyncStackTracesStateChanged;
+    private breakpointsActiveChanged;
+    setComputeAutoStepRangesCallback(callback: ((arg0: StepMode, arg1: CallFrame) => Promise<LocationRange[]>) | null): void;
+    private computeAutoStepSkipList;
+    stepInto(): Promise<void>;
+    stepOver(): Promise<void>;
+    stepOut(): Promise<void>;
+    scheduleStepIntoAsync(): void;
+    resume(): void;
+    pause(): void;
+    setBreakpointByURL(url: Platform.DevToolsPath.UrlString, lineNumber: number, columnNumber?: number, condition?: BackendCondition): Promise<SetBreakpointResult>;
+    setBreakpointInAnonymousScript(scriptHash: string, lineNumber: number, columnNumber?: number, condition?: BackendCondition): Promise<SetBreakpointResult>;
+    removeBreakpoint(breakpointId: Protocol.Debugger.BreakpointId): Promise<void>;
+    getPossibleBreakpoints(startLocation: Location, endLocation: Location | null, restrictToFunction: boolean): Promise<BreakLocation[]>;
+    fetchAsyncStackTrace(stackId: Protocol.Runtime.StackTraceId): Promise<Protocol.Runtime.StackTrace | null>;
+    breakpointResolved(breakpointId: string, location: Protocol.Debugger.Location): void;
+    globalObjectCleared(): void;
+    private reset;
+    scripts(): Script[];
+    scriptForId(scriptId: string): Script | null;
+    /**
+     * Returns all `Script` objects with the same provided `sourceURL`. The
+     * resulting array is sorted by time with the newest `Script` in the front.
+     */
+    scriptsForSourceURL(sourceURL: string): Script[];
+    scriptsForExecutionContext(executionContext: ExecutionContext): Script[];
+    get callFrames(): CallFrame[] | null;
+    debuggerPausedDetails(): DebuggerPausedDetails | null;
+    private setDebuggerPausedDetails;
+    private resetDebuggerPausedDetails;
+    setBeforePausedCallback(callback: ((arg0: DebuggerPausedDetails, autoSteppingContext: Location | null) => Promise<boolean>) | null): void;
+    setEvaluateOnCallFrameCallback(callback: ((arg0: CallFrame, arg1: EvaluationOptions) => Promise<EvaluationResult | null>) | null): void;
+    setSynchronizeBreakpointsCallback(callback: ((script: Script) => Promise<void>) | null): void;
+    pausedScript(callFrames: Protocol.Debugger.CallFrame[], reason: Protocol.Debugger.PausedEventReason, auxData: Object | undefined, breakpointIds: string[], asyncStackTrace?: Protocol.Runtime.StackTrace, asyncStackTraceId?: Protocol.Runtime.StackTraceId): Promise<void>;
+    resumedScript(): void;
+    parsedScriptSource(scriptId: Protocol.Runtime.ScriptId, sourceURL: Platform.DevToolsPath.UrlString, startLine: number, startColumn: number, endLine: number, endColumn: number, executionContextId: number, hash: string, executionContextAuxData: any, isLiveEdit: boolean, sourceMapURL: string | undefined, hasSourceURLComment: boolean, hasSyntaxError: boolean, length: number, isModule: boolean | null, originStackTrace: Protocol.Runtime.StackTrace | null, codeOffset: number | null, scriptLanguage: string | null, debugSymbols: Protocol.Debugger.DebugSymbols[] | null, embedderName: Platform.DevToolsPath.UrlString | null, buildId: string | null): Script;
+    setSourceMapURL(script: Script, newSourceMapURL: Platform.DevToolsPath.UrlString): void;
+    setDebugInfoURL(script: Script, _externalURL: Platform.DevToolsPath.UrlString): Promise<void>;
+    executionContextDestroyed(executionContext: ExecutionContext): void;
+    private registerScript;
+    private unregisterScript;
+    private collectDiscardedScripts;
+    createRawLocation(script: Script, lineNumber: number, columnNumber: number, inlineFrameIndex?: number): Location;
+    createRawLocationByURL(sourceURL: string, lineNumber: number, columnNumber?: number, inlineFrameIndex?: number): Location | null;
+    createRawLocationByScriptId(scriptId: Protocol.Runtime.ScriptId, lineNumber: number, columnNumber?: number, inlineFrameIndex?: number): Location;
+    createRawLocationsByStackTrace(stackTrace: Protocol.Runtime.StackTrace): Location[];
+    isPaused(): boolean;
+    isPausing(): boolean;
+    setSelectedCallFrame(callFrame: CallFrame | null): void;
+    selectedCallFrame(): CallFrame | null;
+    evaluateOnSelectedCallFrame(options: EvaluationOptions): Promise<EvaluationResult>;
+    functionDetailsPromise(remoteObject: RemoteObject): Promise<FunctionDetails | null>;
+    setVariableValue(scopeNumber: number, variableName: string, newValue: Protocol.Runtime.CallArgument, callFrameId: Protocol.Debugger.CallFrameId): Promise<string | undefined>;
+    addBreakpointListener(breakpointId: string, listener: (arg0: Common.EventTarget.EventTargetEvent<Location>) => void, thisObject?: Object): void;
+    removeBreakpointListener(breakpointId: string, listener: (arg0: Common.EventTarget.EventTargetEvent<Location>) => void, thisObject?: Object): void;
+    setBlackboxPatterns(patterns: string[], skipAnonymous: boolean): Promise<boolean>;
+    setBlackboxExecutionContexts(uniqueIds: string[]): Promise<boolean>;
+    dispose(): void;
+    suspendModel(): Promise<void>;
+    resumeModel(): Promise<void>;
+    private static shouldResyncDebuggerId;
+    getEvaluateOnCallFrameCallback(): ((arg0: CallFrame, arg1: EvaluationOptions) => Promise<EvaluationResult | null>) | null;
+    /**
+     * Iterates the async stack trace parents.
+     *
+     * Retrieving cross-target async stack fragments requires CDP interaction, so this is an async generator.
+     *
+     * Important: This iterator will not yield the "synchronous" part of the stack trace, only the async parent chain.
+     */
+    iterateAsyncParents(stackTraceOrPausedDetails: Protocol.Runtime.StackTrace | Pick<DebuggerPausedDetails, 'asyncStackTrace' | 'asyncStackTraceId'>): AsyncGenerator<{
+        stackTrace: Protocol.Runtime.StackTrace;
+        target: Target;
+    }>;
+}
+/**
+ * Keep these in sync with WebCore::V8Debugger
+ */
+export declare enum PauseOnExceptionsState {
+    DontPauseOnExceptions = "none",
+    PauseOnAllExceptions = "all",
+    PauseOnCaughtExceptions = "caught",
+    PauseOnUncaughtExceptions = "uncaught"
+}
+export declare enum Events {
+    DebuggerWasEnabled = "DebuggerWasEnabled",
+    DebuggerWasDisabled = "DebuggerWasDisabled",
+    DebuggerPaused = "DebuggerPaused",
+    DebuggerResumed = "DebuggerResumed",
+    DebugInfoAttached = "DebugInfoAttached",
+    ParsedScriptSource = "ParsedScriptSource",
+    DiscardedAnonymousScriptSource = "DiscardedAnonymousScriptSource",
+    GlobalObjectCleared = "GlobalObjectCleared",
+    CallFrameSelected = "CallFrameSelected",
+    DebuggerIsReadyToPause = "DebuggerIsReadyToPause",
+    ScriptSourceWasEdited = "ScriptSourceWasEdited"
+}
+export interface EventTypes {
+    [Events.DebuggerWasEnabled]: DebuggerModel;
+    [Events.DebuggerWasDisabled]: DebuggerModel;
+    [Events.DebuggerPaused]: DebuggerModel;
+    [Events.DebuggerResumed]: DebuggerModel;
+    [Events.ParsedScriptSource]: Script;
+    [Events.DiscardedAnonymousScriptSource]: Script;
+    [Events.GlobalObjectCleared]: DebuggerModel;
+    [Events.CallFrameSelected]: DebuggerModel;
+    [Events.DebuggerIsReadyToPause]: DebuggerModel;
+    [Events.DebugInfoAttached]: Script;
+    [Events.ScriptSourceWasEdited]: {
+        script: Script;
+        status: Protocol.Debugger.SetScriptSourceResponseStatus;
+    };
+}
+export declare class Location {
+    debuggerModel: DebuggerModel;
+    scriptId: Protocol.Runtime.ScriptId;
+    lineNumber: number;
+    columnNumber: number;
+    inlineFrameIndex: number;
+    constructor(debuggerModel: DebuggerModel, scriptId: Protocol.Runtime.ScriptId, lineNumber: number, columnNumber?: number, inlineFrameIndex?: number);
+    static fromPayload(debuggerModel: DebuggerModel, payload: Protocol.Debugger.Location, inlineFrameIndex?: number): Location;
+    payload(): Protocol.Debugger.Location;
+    script(): Script | null;
+    continueToLocation(pausedCallback?: (() => void)): void;
+    private paused;
+    id(): string;
+}
+export interface LocationRange {
+    start: Location;
+    end: Location;
+}
+export declare class BreakLocation extends Location {
+    type: Protocol.Debugger.BreakLocationType | undefined;
+    constructor(debuggerModel: DebuggerModel, scriptId: Protocol.Runtime.ScriptId, lineNumber: number, columnNumber?: number, type?: Protocol.Debugger.BreakLocationType);
+    static fromPayload(debuggerModel: DebuggerModel, payload: Protocol.Debugger.BreakLocation): BreakLocation;
+}
+export interface MissingDebugFiles {
+    resourceUrl: Platform.DevToolsPath.UrlString;
+    initiator: PageResourceLoadInitiator;
+}
+export declare class CallFrame {
+    #private;
+    debuggerModel: DebuggerModel;
+    readonly script: Script;
+    payload: Protocol.Debugger.CallFrame;
+    readonly inlineFrameIndex: number;
+    readonly functionName: string;
+    readonly exception: RemoteObject | null;
+    readonly canBeRestarted: boolean;
+    constructor(debuggerModel: DebuggerModel, script: Script, payload: Protocol.Debugger.CallFrame, inlineFrameIndex?: number, functionName?: string, exception?: RemoteObject | null);
+    static fromPayloadArray(debuggerModel: DebuggerModel, callFrames: Protocol.Debugger.CallFrame[], exception: RemoteObject | null): CallFrame[];
+    createVirtualCallFrame(inlineFrameIndex: number, name: string): CallFrame;
+    get id(): Protocol.Debugger.CallFrameId;
+    scopeChain(): Scope[];
+    localScope(): Scope | null;
+    thisObject(): RemoteObject | null;
+    returnValue(): RemoteObject | null;
+    setReturnValue(expression: string): Promise<RemoteObject | null>;
+    location(): Location;
+    functionLocation(): Location | null;
+    evaluate(options: EvaluationOptions): Promise<EvaluationResult>;
+    restart(): Promise<void>;
+    getPayload(): Protocol.Debugger.CallFrame;
+}
+export interface ScopeChainEntry {
+    callFrame(): CallFrame;
+    type(): string;
+    typeName(): string;
+    name(): string | undefined;
+    range(): LocationRange | null;
+    object(): RemoteObject;
+    description(): string;
+    icon(): string | undefined;
+    /**
+     * Extra and/or synthetic properties that should be added to the `RemoteObject`
+     * returned by {@link ScopeChainEntry.object}.
+     */
+    extraProperties(): RemoteObjectProperty[];
+}
+export declare class Scope implements ScopeChainEntry {
+    #private;
+    constructor(callFrame: CallFrame, ordinal: number);
+    callFrame(): CallFrame;
+    type(): string;
+    typeName(): string;
+    name(): string | undefined;
+    range(): LocationRange | null;
+    object(): RemoteObject;
+    description(): string;
+    icon(): undefined;
+    extraProperties(): RemoteObjectProperty[];
+}
+export declare class DebuggerPausedDetails {
+    debuggerModel: DebuggerModel;
+    callFrames: CallFrame[];
+    reason: Protocol.Debugger.PausedEventReason;
+    auxData: Record<string, any> | undefined;
+    breakpointIds: string[];
+    asyncStackTrace?: Protocol.Runtime.StackTrace;
+    asyncStackTraceId?: Protocol.Runtime.StackTraceId;
+    constructor(debuggerModel: DebuggerModel, callFrames: Protocol.Debugger.CallFrame[], reason: Protocol.Debugger.PausedEventReason, auxData: Record<string, any> | undefined, breakpointIds: string[], asyncStackTrace?: Protocol.Runtime.StackTrace, asyncStackTraceId?: Protocol.Runtime.StackTraceId);
+    private exception;
+    private cleanRedundantFrames;
+}
+export interface FunctionDetails {
+    location: Location | null;
+    functionName: string;
+}
+export interface SetBreakpointResult {
+    breakpointId: Protocol.Debugger.BreakpointId | null;
+    locations: Location[];
+}
+export interface EventListenerPausedDetailsAuxData {
+    eventName: string;
+    targetName?: string;
+    webglErrorName?: string;
+    directiveText?: string;
+}
+export declare const enum BreakpointType {
+    LOGPOINT = "LOGPOINT",
+    CONDITIONAL_BREAKPOINT = "CONDITIONAL_BREAKPOINT",
+    REGULAR_BREAKPOINT = "REGULAR_BREAKPOINT"
+}
+/**
+ * A breakpoint condition as sent to V8. This helps distinguish
+ * the breakpoint condition as it is entered by the user.
+ */
+export type BackendCondition = Platform.Brand.Brand<string, 'BackendCondition'>;
+export declare const LOGPOINT_SOURCE_URL = "debugger://logpoint";
+export declare const COND_BREAKPOINT_SOURCE_URL = "debugger://breakpoint";

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

@@ -0,0 +1,92 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import * as Protocol from '../../generated/protocol.js';
+import { OverlayModel } from './OverlayModel.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare const enum DataSaverOverride {
+    UNSET = "unset",
+    ENABLED = "enabled",
+    DISABLED = "disabled"
+}
+export declare class EmulationModel extends SDKModel<EmulationModelEventTypes> implements ProtocolProxyApi.EmulationDispatcher {
+    #private;
+    constructor(target: Target);
+    setTouchEmulationAllowed(touchEmulationAllowed: boolean): void;
+    supportsDeviceEmulation(): boolean;
+    resetPageScaleFactor(): Promise<void>;
+    emulateDevice(metrics: Protocol.Page.SetDeviceMetricsOverrideRequest | null): Promise<void>;
+    overlayModel(): OverlayModel | null;
+    setPressureSourceOverrideEnabled(enabled: boolean): Promise<void>;
+    setPressureStateOverride(pressureState: string): Promise<void>;
+    emulateLocation(location: Location | null): Promise<void>;
+    emulateDeviceOrientation(deviceOrientation: DeviceOrientation | null): Promise<void>;
+    setIdleOverride(emulationParams: {
+        isUserActive: boolean;
+        isScreenUnlocked: boolean;
+    }): Promise<void>;
+    clearIdleOverride(): Promise<void>;
+    private emulateCSSMedia;
+    private emulateAutoDarkMode;
+    private emulateVisionDeficiency;
+    private emulateOSTextScale;
+    private setLocalFontsDisabled;
+    private setDisabledImageTypes;
+    setDataSaverOverride(dataSaverOverride: DataSaverOverride): Promise<void>;
+    setCPUThrottlingRate(rate: number): Promise<void>;
+    setHardwareConcurrency(hardwareConcurrency: number): Promise<void>;
+    emulateTouch(enabled: boolean, mobile: boolean): Promise<void>;
+    overrideEmulateTouch(enabled: boolean): Promise<void>;
+    private updateTouch;
+    private updateCssMedia;
+    virtualTimeBudgetExpired(): void;
+    screenOrientationLockChanged(event: Protocol.Emulation.ScreenOrientationLockChangedEvent): void;
+    isScreenOrientationLocked(): boolean;
+    lockedOrientation(): Protocol.Emulation.ScreenOrientation | null;
+}
+export declare const enum EmulationModelEvents {
+    SCREEN_ORIENTATION_LOCK_CHANGED = "ScreenOrientationLockChanged"
+}
+export interface ScreenOrientationLockChangedEvent {
+    locked: boolean;
+    orientation: Protocol.Emulation.ScreenOrientation | null;
+}
+export interface EmulationModelEventTypes {
+    [EmulationModelEvents.SCREEN_ORIENTATION_LOCK_CHANGED]: ScreenOrientationLockChangedEvent;
+}
+export declare class Location {
+    static readonly DEFAULT_ACCURACY = 150;
+    latitude: number;
+    longitude: number;
+    timezoneId: string;
+    locale: string;
+    accuracy: number;
+    unavailable: boolean;
+    constructor(latitude: number, longitude: number, timezoneId: string, locale: string, accuracy: number, unavailable: boolean);
+    static parseSetting(value: string): Location;
+    static parseUserInput(latitudeString: string, longitudeString: string, timezoneId: string, locale: string, accuracyString: string): Location | null;
+    static latitudeValidator(value: string): boolean;
+    static longitudeValidator(value: string): boolean;
+    static timezoneIdValidator(value: string): boolean;
+    static localeValidator(value: string): boolean;
+    static accuracyValidator(value: string): {
+        valid: boolean;
+        errorMessage?: string;
+    };
+    toSetting(): string;
+}
+export declare class DeviceOrientation {
+    alpha: number;
+    beta: number;
+    gamma: number;
+    constructor(alpha: number, beta: number, gamma: number);
+    static parseSetting(value: string): DeviceOrientation;
+    static parseUserInput(alphaString: string, betaString: string, gammaString: string): DeviceOrientation | null;
+    static angleRangeValidator(value: string, interval: {
+        minimum: number;
+        maximum: number;
+    }): boolean;
+    static alphaAngleValidator(value: string): boolean;
+    static betaAngleValidator(value: string): boolean;
+    static gammaAngleValidator(value: string): boolean;
+    toSetting(): string;
+}

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

@@ -0,0 +1,105 @@
+import type * as Protocol from '../../generated/protocol.js';
+import type { HydratingDataPerTarget } from './RehydratingObject.js';
+import type { TraceObject } from './TraceObject.js';
+interface EventBase {
+    cat: string;
+    pid: number;
+    args: {
+        data: object;
+    };
+    name: string;
+}
+/**
+ * While called 'TargetRundown', this event is emitted for each script that is compiled or evaluated.
+ * Within EnhancedTraceParser, this event is used to construct targets and execution contexts (and to associate scripts to frames).
+ *
+ * See `inspector_target_rundown_event::Data` https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/inspector/inspector_trace_events.cc;l=1189-1232;drc=48d6f7175422b2c969c14258f9f8d5b196c28d18
+ */
+export interface RundownScriptCompiled extends EventBase {
+    cat: 'disabled-by-default-devtools.target-rundown';
+    name: 'ScriptCompiled' | 'ModuleEvaluated';
+    args: {
+        data: {
+            frame: Protocol.Page.FrameId;
+            frameType: 'page' | 'iframe';
+            url: string;
+            /**
+             * Older traces were a number, but this is an unsigned 64 bit value, so that was a bug.
+             * New traces use string instead. See https://crbug.com/447654178.
+             */
+            isolate: string | number;
+            /** 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;
+            origin: string;
+            scriptId: number;
+            /** script->World().isMainWorld() */
+            isDefault?: boolean;
+            contextType?: 'default' | 'isolated' | 'worker';
+        };
+    };
+}
+/**
+ * When profiling starts, all currently loaded scripts are emitted via this event.
+ *
+ * See `Script::TraceScriptRundown()` https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/script.cc;l=184-220;drc=328f6c467b940f322544567740c9c871064d045c
+ */
+export interface RundownScript extends EventBase {
+    cat: 'disabled-by-default-devtools.v8-source-rundown';
+    name: 'ScriptCatchup';
+    args: {
+        data: {
+            /**
+             * Older traces were a number, but this is an unsigned 64 bit value, so that was a bug.
+             * New traces use string instead. See https://crbug.com/447654178.
+             */
+            isolate: string | number;
+            executionContextId: Protocol.Runtime.ExecutionContextId;
+            scriptId: number;
+            isModule: boolean;
+            /** aka HasSourceURLComment */
+            hasSourceUrl: boolean;
+            url?: string;
+            hash?: string;
+            /** value of the sourceURL comment. */
+            sourceUrl?: string;
+            sourceMapUrl?: string;
+            /** If true, the source map url was a data URL, so the `sourceMapUrl` was removed. */
+            sourceMapUrlElided?: boolean;
+            startLine?: number;
+            startColumn?: number;
+            endLine?: number;
+            endColumn?: number;
+        };
+    };
+}
+export interface RundownScriptSource extends EventBase {
+    cat: 'disabled-by-default-devtools.v8-source-rundown-sources';
+    name: 'ScriptCatchup' | 'LargeScriptCatchup' | 'TooLargeScriptCatchup';
+    args: {
+        data: {
+            isolate: number;
+            scriptId: number;
+            length?: number;
+            sourceText?: string;
+        };
+    };
+}
+export declare class EnhancedTracesParser {
+    #private;
+    static readonly enhancedTraceVersion: number;
+    constructor(trace: TraceObject);
+    parseEnhancedTrace(): void;
+    data(): HydratingDataPerTarget[];
+    private resolveSourceMap;
+    private getSourceMapFromMetadata;
+    private getScriptIsolateId;
+    private getExecutionContextIsolateId;
+    private isTraceEvent;
+    private isRundownScriptCompiled;
+    private isRundownScript;
+    private isRundownScriptSource;
+    private isTracingStartedInBrowser;
+    private isFunctionCallEvent;
+    private groupContextsAndScriptsUnderTarget;
+}
+export {};

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

@@ -0,0 +1,63 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import { CategorizedBreakpoint } from './CategorizedBreakpoint.js';
+import type { EventListenerPausedDetailsAuxData } from './DebuggerModel.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+import { type SDKModelObserver } from './TargetManager.js';
+export declare const enum InstrumentationNames {
+    BEFORE_BIDDER_WORKLET_BIDDING_START = "beforeBidderWorkletBiddingStart",
+    BEFORE_BIDDER_WORKLET_REPORTING_START = "beforeBidderWorkletReportingStart",
+    BEFORE_SELLER_WORKLET_SCORING_START = "beforeSellerWorkletScoringStart",
+    BEFORE_SELLER_WORKLET_REPORTING_START = "beforeSellerWorkletReportingStart",
+    SET_TIMEOUT = "setTimeout",
+    CLEAR_TIMEOUT = "clearTimeout",
+    SET_TIMEOUT_CALLBACK = "setTimeout.callback",
+    SET_INTERVAL = "setInterval",
+    CLEAR_INTERVAL = "clearInterval",
+    SET_INTERVAL_CALLBACK = "setInterval.callback",
+    SCRIPT_FIRST_STATEMENT = "scriptFirstStatement",
+    SCRIPT_BLOCKED_BY_CSP = "scriptBlockedByCSP",
+    SHARED_STORAGE_WORKLET_SCRIPT_FIRST_STATEMENT = "sharedStorageWorkletScriptFirstStatement",
+    REQUEST_ANIMATION_FRAME = "requestAnimationFrame",
+    CANCEL_ANIMATION_FRAME = "cancelAnimationFrame",
+    REQUEST_ANIMATION_FRAME_CALLBACK = "requestAnimationFrame.callback",
+    WEBGL_ERROR_FIRED = "webglErrorFired",
+    WEBGL_WARNING_FIRED = "webglWarningFired",
+    ELEMENT_SET_INNER_HTML = "Element.setInnerHTML",
+    CANVAS_CONTEXT_CREATED = "canvasContextCreated",
+    GEOLOCATION_GET_CURRENT_POSITION = "Geolocation.getCurrentPosition",
+    GEOLOCATION_WATCH_POSITION = "Geolocation.watchPosition",
+    NOTIFICATION_REQUEST_PERMISSION = "Notification.requestPermission",
+    DOM_WINDOW_CLOSE = "DOMWindow.close",
+    DOCUMENT_WRITE = "Document.write",
+    AUDIO_CONTEXT_CREATED = "audioContextCreated",
+    AUDIO_CONTEXT_CLOSED = "audioContextClosed",
+    AUDIO_CONTEXT_RESUMED = "audioContextResumed",
+    AUDIO_CONTEXT_SUSPENDED = "audioContextSuspended"
+}
+export declare class EventBreakpointsModel extends SDKModel<void> {
+    readonly agent: ProtocolProxyApi.EventBreakpointsApi;
+    constructor(target: Target);
+}
+/**
+ * This implementation (as opposed to similar class in DOMDebuggerModel) is for
+ * instrumentation breakpoints in targets that run JS but do not have a DOM.
+ **/
+declare class EventListenerBreakpoint extends CategorizedBreakpoint {
+    setEnabled(enabled: boolean): void;
+    updateOnModel(model: EventBreakpointsModel): void;
+    static readonly instrumentationPrefix = "instrumentation:";
+}
+export declare class EventBreakpointsManager implements SDKModelObserver<EventBreakpointsModel> {
+    #private;
+    constructor();
+    static instance(opts?: {
+        forceNew: boolean | null;
+    }): EventBreakpointsManager;
+    private createInstrumentationBreakpoints;
+    eventListenerBreakpoints(): EventListenerBreakpoint[];
+    resolveEventListenerBreakpoint({ eventName }: EventListenerPausedDetailsAuxData): EventListenerBreakpoint | null;
+    modelAdded(eventBreakpointModel: EventBreakpointsModel): void;
+    modelRemoved(_eventBreakpointModel: EventBreakpointsModel): void;
+}
+export {};

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

@@ -0,0 +1,6 @@
+import type { PageResourceLoadInitiator } from './PageResourceLoader.js';
+import type { DebugId } from './SourceMap.js';
+export interface FrameAssociated {
+    createPageResourceLoadInitiator(): PageResourceLoadInitiator;
+    debugId(): DebugId | null;
+}

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

@@ -0,0 +1,68 @@
+import type * as Protocol from '../../generated/protocol.js';
+import * as Common from '../common/common.js';
+import type { Resource } from './Resource.js';
+import { type ResourceTreeFrame, ResourceTreeModel } from './ResourceTreeModel.js';
+import type { Target } from './Target.js';
+import { type SDKModelObserver, TargetManager } from './TargetManager.js';
+/**
+ * The FrameManager is a central storage for all #frames. It collects #frames from all
+ * ResourceTreeModel-instances (one per target), so that #frames can be found by id
+ * without needing to know their target.
+ */
+export declare class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements SDKModelObserver<ResourceTreeModel> {
+    #private;
+    constructor(targetManager: TargetManager);
+    static instance({ forceNew }?: {
+        forceNew: boolean;
+    }): FrameManager;
+    static removeInstance(): void;
+    modelAdded(resourceTreeModel: ResourceTreeModel): void;
+    modelRemoved(resourceTreeModel: ResourceTreeModel): void;
+    private frameAdded;
+    private frameDetached;
+    private frameNavigated;
+    private resourceAdded;
+    private decreaseOrRemoveFrame;
+    /**
+     * Looks for the outermost frame in `#frames` and sets `#outermostFrame` accordingly.
+     *
+     * Important: This method needs to be called everytime `#frames` is updated.
+     */
+    private resetOutermostFrame;
+    /**
+     * Returns the ResourceTreeFrame with a given frameId.
+     * When a frame is being detached a new ResourceTreeFrame but with the same
+     * frameId is created. Consequently getFrame() will return a different
+     * ResourceTreeFrame after detachment. Callers of getFrame() should therefore
+     * immediately use the function return value and not store it for later use.
+     */
+    getFrame(frameId: Protocol.Page.FrameId): ResourceTreeFrame | null;
+    getAllFrames(): ResourceTreeFrame[];
+    getOutermostFrame(): ResourceTreeFrame | null;
+    getOrWaitForFrame(frameId: Protocol.Page.FrameId, notInTarget?: Target): Promise<ResourceTreeFrame>;
+    private resolveAwaitedFrame;
+}
+export declare const enum Events {
+    FRAME_ADDED_TO_TARGET = "FrameAddedToTarget",
+    FRAME_NAVIGATED = "FrameNavigated",
+    FRAME_REMOVED = "FrameRemoved",
+    RESOURCE_ADDED = "ResourceAdded",
+    OUTERMOST_FRAME_NAVIGATED = "OutermostFrameNavigated"
+}
+export interface EventTypes {
+    [Events.FRAME_ADDED_TO_TARGET]: {
+        frame: ResourceTreeFrame;
+    };
+    [Events.FRAME_NAVIGATED]: {
+        frame: ResourceTreeFrame;
+    };
+    [Events.FRAME_REMOVED]: {
+        frameId: Protocol.Page.FrameId;
+    };
+    [Events.RESOURCE_ADDED]: {
+        resource: Resource;
+    };
+    [Events.OUTERMOST_FRAME_NAVIGATED]: {
+        frame: ResourceTreeFrame;
+    };
+}