devtools-tracing 1.2.1 → 1.2.2

package/dist/lib/front_end/core/platform/api/HostRuntime.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Provides abstractions for host features that require different implementations depending
+ * on whether DevTools runs in the browser or Node.js
+ */
+export interface HostRuntime {
+    createWorker(url: string): Worker;
+    workerScope: WorkerScope;
+}
+/**
+ * Abstracts away the differences between browser web workers and Node.js worker threads.
+ */
+export interface Worker {
+    postMessage(message: unknown, transfer?: WorkerTransferable[]): void;
+    dispose(): void;
+    terminate(immediately?: boolean): void;
+    set onmessage(listener: (event: WorkerMessageEvent) => void);
+    set onerror(listener: (event: any) => void);
+}
+/**
+ * Currently we ony transfer MessagePorts to workers, but it's possible to add
+ * more things (like ReadableStream) as long as it's present in all runtimes.
+ */
+export type WorkerTransferable = typeof MessagePort.prototype;
+/**
+ * Used by workers to communicate with their parent.
+ */
+export interface WorkerScope {
+    postMessage(message: unknown): void;
+    set onmessage(listener: (event: WorkerMessageEvent) => void);
+}
+export interface WorkerMessageEvent {
+    readonly data: any;
+}

package/dist/lib/front_end/core/platform/api/api.d.ts

@@ -0,0 +1,2 @@
+import * as HostRuntime from './HostRuntime.js';
+export { HostRuntime };

package/dist/lib/front_end/core/platform/platform.d.ts

@@ -0,0 +1,18 @@
+import * as ArrayUtilities from './ArrayUtilities.js';
+import * as Brand from './Brand.js';
+import * as Constructor from './Constructor.js';
+import * as DateUtilities from './DateUtilities.js';
+import * as DevToolsPath from './DevToolsPath.js';
+import * as HostRuntime from './HostRuntime.js';
+import * as KeyboardUtilities from './KeyboardUtilities.js';
+import * as MapUtilities from './MapUtilities.js';
+import * as MimeType from './MimeType.js';
+import * as NumberUtilities from './NumberUtilities.js';
+import * as StringUtilities from './StringUtilities.js';
+import * as Timing from './Timing.js';
+import * as TypedArrayUtilities from './TypedArrayUtilities.js';
+import * as TypeScriptUtilities from './TypescriptUtilities.js';
+import * as UIString from './UIString.js';
+import * as UserVisibleError from './UserVisibleError.js';
+export { assertNever, assertNotNullOrUndefined, assertUnhandled } from './TypescriptUtilities.js';
+export { ArrayUtilities, Brand, Constructor, DateUtilities, DevToolsPath, HostRuntime, KeyboardUtilities, MapUtilities, MimeType, NumberUtilities, StringUtilities, Timing, TypedArrayUtilities, TypeScriptUtilities, UIString, UserVisibleError, };

package/dist/lib/front_end/core/protocol_client/CDPConnection.d.ts

@@ -0,0 +1,77 @@
+import type { ProtocolMapping } from '../../generated/protocol-mapping.js';
+export type Command = keyof ProtocolMapping.Commands;
+export type CommandParams<T extends Command> = ProtocolMapping.Commands[T]['paramsType'][0];
+export type CommandResult<T extends Command> = Omit<ProtocolMapping.Commands[T]['returnType'], 'getError'>;
+export type Event = keyof ProtocolMapping.Events;
+export type EventParams<T extends keyof ProtocolMapping.Events> = ProtocolMapping.Events[T][0];
+export interface CDPBaseMessage {
+    sessionId?: string;
+}
+export interface CDPCommandRequest<T extends Command> extends CDPBaseMessage {
+    id: number;
+    method: T;
+    params: CommandParams<T>;
+}
+export interface CDPCommandResponse<T extends Command> extends CDPBaseMessage {
+    id: number;
+    result: CommandResult<T>;
+}
+export interface CDPEvent<T extends Event> extends CDPBaseMessage {
+    method: T;
+    params: EventParams<T>;
+}
+/**
+ * Keep this in sync with https://source.chromium.org/chromium/chromium/src/+/main:third_party/inspector_protocol/crdtp/dispatch.h.
+ */
+export declare enum CDPErrorStatus {
+    PARSE_ERROR = -32700,
+    INVALID_REQUEST = -32600,
+    METHOD_NOT_FOUND = -32601,
+    INVALID_PARAMS = -32602,
+    INTERNAL_ERROR = -32603,
+    SERVER_ERROR = -32000,
+    SESSION_NOT_FOUND = -32001,
+    DEVTOOLS_STUB_ERROR = -32015,
+    DEVTOOLS_REHYDRATION_ERROR = -32016
+}
+export interface CDPError {
+    code: CDPErrorStatus;
+    message: string;
+    data?: string;
+}
+export interface CDPErrorMessage extends CDPBaseMessage {
+    id?: number;
+    error: CDPError;
+}
+export type CDPReceivableMessage = CDPCommandResponse<Command> | CDPEvent<Event> | CDPErrorMessage;
+/**
+ * Allows the sending and receiving of CDP commands and the notification of CDP events to observers.
+ *
+ * An instance of a CDPConnection "owns" the full transport channel and no other CDP traffic must
+ * be proxied over it. This is because each implementation needs to manage "message IDs", which
+ * would conflict with any other shared traffic.
+ */
+export interface CDPConnection {
+    send<T extends Command>(method: T, params: CommandParams<T>, sessionId: string | undefined): Promise<{
+        result: CommandResult<T>;
+    } | {
+        error: CDPError;
+    }>;
+    observe(observer: CDPConnectionObserver): void;
+    unobserve(observer: CDPConnectionObserver): void;
+}
+export interface CDPConnectionObserver {
+    onEvent<T extends Event>(event: CDPEvent<T>): void;
+    onDisconnect(reason: string): void;
+}
+/**
+ * The protocol monitor and test harness require inspection of raw CDP message traffic.
+ */
+export interface DebuggableCDPConnection extends CDPConnection {
+    observeMessages(observer: RawMessageObserver): void;
+    unobserveMessages(observer: RawMessageObserver): void;
+}
+export interface RawMessageObserver {
+    onMessageReceived(message: CDPReceivableMessage): void;
+    onMessageSent(message: CDPCommandRequest<Command>): void;
+}

package/dist/lib/front_end/core/protocol_client/ConnectionTransport.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class ConnectionTransport {
+    onMessage: ((arg0: Object) => void) | null;
+    abstract setOnMessage(onMessage: (arg0: Object | string) => void): void;
+    abstract setOnDisconnect(onDisconnect: (arg0: string) => void): void;
+    abstract sendRawMessage(message: string): void;
+    abstract disconnect(): Promise<void>;
+    static setFactory(factory: () => ConnectionTransport): void;
+    static getFactory(): () => ConnectionTransport;
+}

package/dist/lib/front_end/core/protocol_client/DevToolsCDPConnection.d.ts

@@ -0,0 +1,19 @@
+import { type CDPConnection, type CDPConnectionObserver, type CDPError, type Command, type CommandParams, type CommandResult } from './CDPConnection.js';
+import type { ConnectionTransport } from './ConnectionTransport.js';
+export declare class DevToolsCDPConnection implements CDPConnection {
+    #private;
+    constructor(transport: ConnectionTransport);
+    observe(observer: CDPConnectionObserver): void;
+    unobserve(observer: CDPConnectionObserver): void;
+    send<T extends Command>(method: T, params: CommandParams<T>, sessionId?: string): Promise<{
+        result: CommandResult<T>;
+    } | {
+        error: CDPError;
+    }>;
+    resolvePendingCalls(sessionId: string): void;
+    private sendRawMessageForTesting;
+    private onMessage;
+    private hasOutstandingNonLongPollingRequests;
+    private deprecatedRunAfterPendingDispatches;
+    private executeAfterPendingDispatches;
+}

package/dist/lib/front_end/core/protocol_client/InspectorBackend.d.ts

@@ -0,0 +1,221 @@
+import * as InspectorBackendCommands from '../../generated/InspectorBackendCommands.js';
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Platform from '../platform/platform.js';
+import { type CDPConnection, type CDPConnectionObserver, type CDPEvent, type Event } from './CDPConnection.js';
+type MessageParams = Record<string, any>;
+type ProtocolDomainName = ProtocolProxyApi.ProtocolDomainName;
+export interface MessageError {
+    code: number;
+    message: string;
+    data?: string | null;
+}
+export interface Message {
+    sessionId?: string;
+    url?: Platform.DevToolsPath.UrlString;
+    id?: number;
+    error?: MessageError | null;
+    result?: Object | null;
+    method?: QualifiedName;
+    params?: MessageParams | null;
+}
+export interface EventMessage extends Message {
+    method: QualifiedName;
+    params?: MessageParams | null;
+}
+/** A qualified name, e.g. Domain.method */
+export type QualifiedName = string & {
+    qualifiedEventNameTag: string | undefined;
+};
+/** A qualified name, e.g. method */
+export type UnqualifiedName = string & {
+    unqualifiedEventNameTag: string | undefined;
+};
+export declare const splitQualifiedName: (string: QualifiedName) => [string, UnqualifiedName];
+export declare const qualifyName: (domain: string, name: UnqualifiedName) => QualifiedName;
+type EventParameterNames = Map<QualifiedName, string[]>;
+type ReadonlyEventParameterNames = ReadonlyMap<QualifiedName, string[]>;
+type CommandParameter = InspectorBackendCommands.CommandParameter;
+export declare class InspectorBackend implements InspectorBackendCommands.InspectorBackendAPI {
+    #private;
+    readonly agentPrototypes: Map<keyof ProtocolProxyApi.ProtocolApi, AgentPrototype>;
+    readonly typeMap: Map<QualifiedName, InspectorBackendCommands.CommandParameter[]>;
+    readonly enumMap: Map<QualifiedName, Record<string, string>>;
+    constructor();
+    private getOrCreateEventParameterNamesForDomain;
+    getOrCreateEventParameterNamesForDomainForTesting(domain: ProtocolDomainName): EventParameterNames;
+    getEventParameterNames(): ReadonlyMap<ProtocolDomainName, ReadonlyEventParameterNames>;
+    static reportProtocolError(error: string, messageObject: Object): void;
+    static reportProtocolWarning(error: string, messageObject: Object): void;
+    private agentPrototype;
+    registerCommand(method: QualifiedName, parameters: CommandParameter[], replyArgs: string[], description: string): void;
+    registerEnum(type: QualifiedName, values: Record<string, string>): void;
+    registerType(method: QualifiedName, parameters: CommandParameter[]): void;
+    registerEvent(eventName: QualifiedName, params: string[]): void;
+}
+type SendRawMessageCallback = (...args: unknown[]) => void;
+export declare const test: {
+    /**
+     * This will get called for every protocol message.
+     * ProtocolClient.test.dumpProtocol = console.log
+     */
+    dumpProtocol: ((arg0: string) => void) | null;
+    /**
+     * Runs a function when no protocol activity is present.
+     * ProtocolClient.test.deprecatedRunAfterPendingDispatches(() => console.log('done'))
+     */
+    deprecatedRunAfterPendingDispatches: ((arg0: () => void) => void) | null;
+    /**
+     * Sends a raw message over main connection.
+     * ProtocolClient.test.sendRawMessage('Page.enable', {}, console.log)
+     */
+    sendRawMessage: ((method: QualifiedName, args: Object | null, arg2: SendRawMessageCallback) => void) | null;
+    /**
+     * Set to true to not log any errors.
+     */
+    suppressRequestErrors: boolean;
+    /**
+     * Set to get notified about any messages sent over protocol.
+     */
+    onMessageSent: ((message: {
+        domain: string;
+        method: string;
+        params: Object;
+        id: number;
+        sessionId?: string;
+    }) => void) | null;
+    /**
+     * Set to get notified about any messages received over protocol.
+     */
+    onMessageReceived: ((message: Object) => void) | null;
+};
+export declare class SessionRouter implements CDPConnectionObserver {
+    #private;
+    constructor(connection: CDPConnection);
+    registerSession(target: TargetBase, sessionId: string): void;
+    unregisterSession(sessionId: string): void;
+    onDisconnect(reason: string): void;
+    onEvent<T extends Event>(event: CDPEvent<T>): void;
+    get connection(): CDPConnection;
+}
+export declare class TargetBase {
+    #private;
+    readonly sessionId: string;
+    constructor(parentTarget: TargetBase | null, sessionId: string, connection: CDPConnection | null);
+    dispatch(eventMessage: EventMessage): void;
+    dispose(_reason: string): void;
+    isDisposed(): boolean;
+    router(): SessionRouter | null;
+    /**
+     * Make sure that `Domain` is only ever instantiated with one protocol domain
+     * name, because if `Domain` allows multiple domains, the type is unsound.
+     */
+    private getAgent;
+    accessibilityAgent(): ProtocolProxyApi.AccessibilityApi;
+    animationAgent(): ProtocolProxyApi.AnimationApi;
+    auditsAgent(): ProtocolProxyApi.AuditsApi;
+    autofillAgent(): ProtocolProxyApi.AutofillApi;
+    browserAgent(): ProtocolProxyApi.BrowserApi;
+    backgroundServiceAgent(): ProtocolProxyApi.BackgroundServiceApi;
+    cacheStorageAgent(): ProtocolProxyApi.CacheStorageApi;
+    cssAgent(): ProtocolProxyApi.CSSApi;
+    debuggerAgent(): ProtocolProxyApi.DebuggerApi;
+    deviceOrientationAgent(): ProtocolProxyApi.DeviceOrientationApi;
+    domAgent(): ProtocolProxyApi.DOMApi;
+    domdebuggerAgent(): ProtocolProxyApi.DOMDebuggerApi;
+    domsnapshotAgent(): ProtocolProxyApi.DOMSnapshotApi;
+    domstorageAgent(): ProtocolProxyApi.DOMStorageApi;
+    emulationAgent(): ProtocolProxyApi.EmulationApi;
+    eventBreakpointsAgent(): ProtocolProxyApi.EventBreakpointsApi;
+    extensionsAgent(): ProtocolProxyApi.ExtensionsApi;
+    fetchAgent(): ProtocolProxyApi.FetchApi;
+    heapProfilerAgent(): ProtocolProxyApi.HeapProfilerApi;
+    indexedDBAgent(): ProtocolProxyApi.IndexedDBApi;
+    inputAgent(): ProtocolProxyApi.InputApi;
+    ioAgent(): ProtocolProxyApi.IOApi;
+    inspectorAgent(): ProtocolProxyApi.InspectorApi;
+    layerTreeAgent(): ProtocolProxyApi.LayerTreeApi;
+    logAgent(): ProtocolProxyApi.LogApi;
+    mediaAgent(): ProtocolProxyApi.MediaApi;
+    memoryAgent(): ProtocolProxyApi.MemoryApi;
+    networkAgent(): ProtocolProxyApi.NetworkApi;
+    overlayAgent(): ProtocolProxyApi.OverlayApi;
+    pageAgent(): ProtocolProxyApi.PageApi;
+    preloadAgent(): ProtocolProxyApi.PreloadApi;
+    profilerAgent(): ProtocolProxyApi.ProfilerApi;
+    performanceAgent(): ProtocolProxyApi.PerformanceApi;
+    runtimeAgent(): ProtocolProxyApi.RuntimeApi;
+    securityAgent(): ProtocolProxyApi.SecurityApi;
+    serviceWorkerAgent(): ProtocolProxyApi.ServiceWorkerApi;
+    storageAgent(): ProtocolProxyApi.StorageApi;
+    systemInfo(): ProtocolProxyApi.SystemInfoApi;
+    targetAgent(): ProtocolProxyApi.TargetApi;
+    tracingAgent(): ProtocolProxyApi.TracingApi;
+    webAudioAgent(): ProtocolProxyApi.WebAudioApi;
+    webAuthnAgent(): ProtocolProxyApi.WebAuthnApi;
+    webMCPAgent(): ProtocolProxyApi.WebMCPApi;
+    /**
+     * Make sure that `Domain` is only ever instantiated with one protocol domain
+     * name, because if `Domain` allows multiple domains, the type is unsound.
+     */
+    private registerDispatcher;
+    /**
+     * Make sure that `Domain` is only ever instantiated with one protocol domain
+     * name, because if `Domain` allows multiple domains, the type is unsound.
+     */
+    private unregisterDispatcher;
+    registerAccessibilityDispatcher(dispatcher: ProtocolProxyApi.AccessibilityDispatcher): void;
+    registerAutofillDispatcher(dispatcher: ProtocolProxyApi.AutofillDispatcher): void;
+    registerAnimationDispatcher(dispatcher: ProtocolProxyApi.AnimationDispatcher): void;
+    registerAuditsDispatcher(dispatcher: ProtocolProxyApi.AuditsDispatcher): void;
+    registerCSSDispatcher(dispatcher: ProtocolProxyApi.CSSDispatcher): void;
+    registerBackgroundServiceDispatcher(dispatcher: ProtocolProxyApi.BackgroundServiceDispatcher): void;
+    registerDebuggerDispatcher(dispatcher: ProtocolProxyApi.DebuggerDispatcher): void;
+    unregisterDebuggerDispatcher(dispatcher: ProtocolProxyApi.DebuggerDispatcher): void;
+    registerDOMDispatcher(dispatcher: ProtocolProxyApi.DOMDispatcher): void;
+    registerDOMStorageDispatcher(dispatcher: ProtocolProxyApi.DOMStorageDispatcher): void;
+    registerEmulationDispatcher(dispatcher: ProtocolProxyApi.EmulationDispatcher): void;
+    registerFetchDispatcher(dispatcher: ProtocolProxyApi.FetchDispatcher): void;
+    registerHeapProfilerDispatcher(dispatcher: ProtocolProxyApi.HeapProfilerDispatcher): void;
+    registerInspectorDispatcher(dispatcher: ProtocolProxyApi.InspectorDispatcher): void;
+    registerLayerTreeDispatcher(dispatcher: ProtocolProxyApi.LayerTreeDispatcher): void;
+    registerLogDispatcher(dispatcher: ProtocolProxyApi.LogDispatcher): void;
+    registerMediaDispatcher(dispatcher: ProtocolProxyApi.MediaDispatcher): void;
+    registerNetworkDispatcher(dispatcher: ProtocolProxyApi.NetworkDispatcher): void;
+    registerOverlayDispatcher(dispatcher: ProtocolProxyApi.OverlayDispatcher): void;
+    registerPageDispatcher(dispatcher: ProtocolProxyApi.PageDispatcher): void;
+    registerPreloadDispatcher(dispatcher: ProtocolProxyApi.PreloadDispatcher): void;
+    registerProfilerDispatcher(dispatcher: ProtocolProxyApi.ProfilerDispatcher): void;
+    registerRuntimeDispatcher(dispatcher: ProtocolProxyApi.RuntimeDispatcher): void;
+    registerSecurityDispatcher(dispatcher: ProtocolProxyApi.SecurityDispatcher): void;
+    registerServiceWorkerDispatcher(dispatcher: ProtocolProxyApi.ServiceWorkerDispatcher): void;
+    registerStorageDispatcher(dispatcher: ProtocolProxyApi.StorageDispatcher): void;
+    registerTargetDispatcher(dispatcher: ProtocolProxyApi.TargetDispatcher): void;
+    registerTracingDispatcher(dispatcher: ProtocolProxyApi.TracingDispatcher): void;
+    registerWebAudioDispatcher(dispatcher: ProtocolProxyApi.WebAudioDispatcher): void;
+    registerWebAuthnDispatcher(dispatcher: ProtocolProxyApi.WebAuthnDispatcher): void;
+    registerWebMCPDispatcher(dispatcher: ProtocolProxyApi.WebMCPDispatcher): void;
+}
+/**
+ * This is a class that serves as the prototype for a domains #agents (every target
+ * has it's own set of #agents). The InspectorBackend keeps an instance of this class
+ * per domain, and each TargetBase creates its #agents (via Object.create) and installs
+ * this instance as prototype.
+ *
+ * The reasons this is done is so that on the prototypes we can install the implementations
+ * of the invoke_enable, etc. methods that the front-end uses.
+ */
+declare class AgentPrototype {
+    description: string;
+    metadata: Record<string, {
+        parameters: CommandParameter[];
+        description: string;
+        replyArgs: string[];
+    }>;
+    readonly domain: string;
+    target: TargetBase;
+    constructor(domain: string);
+    registerCommand(methodName: UnqualifiedName, parameters: CommandParameter[], replyArgs: string[], description: string): void;
+    private invoke;
+}
+export declare const inspectorBackend: InspectorBackend;
+export {};

package/dist/lib/front_end/core/protocol_client/protocol_client.d.ts

@@ -0,0 +1,5 @@
+import * as CDPConnection from './CDPConnection.js';
+import * as ConnectionTransport from './ConnectionTransport.js';
+import * as DevToolsCDPConnection from './DevToolsCDPConnection.js';
+import * as InspectorBackend from './InspectorBackend.js';
+export { CDPConnection, ConnectionTransport, DevToolsCDPConnection, InspectorBackend, };

package/dist/lib/front_end/core/root/DevToolsContext.d.ts

@@ -0,0 +1,34 @@
+export type ConstructorT<T> = new (...args: any[]) => T;
+/**
+ * Container for singletons scoped to a single DevTools universe.
+ *
+ * When wiring up dependencies, strongly prefer to pass all direct dependencies
+ * via constructor, and not just pass a {@link DevToolsContext} around. That would hide
+ * dependencies and we want to be explicit.
+ */
+export interface DevToolsContext {
+    get<T>(ctor: ConstructorT<T>): T;
+}
+/**
+ * The actual implementation. Should only be accessed by test-setup code or the bootstrapper.
+ */
+export declare class WritableDevToolsContext implements DevToolsContext {
+    #private;
+    get<T>(ctor: ConstructorT<T>): T;
+    /** @deprecated Should only be used by existing `instance` accessors. */
+    has<T>(ctor: ConstructorT<T>): boolean;
+    /**
+     * Should only be used by existing `instance` accessors and the bootstrapper.
+     */
+    set<T>(ctor: ConstructorT<T>, instance: T): void;
+    /** @deprecated Should only be used by existing `removeInstance` static methods. */
+    delete<T>(ctor: ConstructorT<T>): void;
+}
+/**
+ * @deprecated Exists to migrate instance() methods.
+ */
+export declare function globalInstance(): WritableDevToolsContext;
+/**
+ * @deprecated Should only be called by test setup and MainImpl
+ */
+export declare function setGlobalInstance(context: WritableDevToolsContext | null): void;

package/dist/lib/front_end/core/root/ExperimentNames.d.ts

@@ -0,0 +1,19 @@
+export declare enum ExperimentName {
+    ALL = "*",
+    CAPTURE_NODE_CREATION_STACKS = "capture-node-creation-stacks",
+    LIVE_HEAP_PROFILE = "live-heap-profile",
+    PROTOCOL_MONITOR = "protocol-monitor",
+    SAMPLING_HEAP_PROFILER_TIMELINE = "sampling-heap-profiler-timeline",
+    SHOW_OPTION_TO_EXPOSE_INTERNALS_IN_HEAP_SNAPSHOT = "show-option-to-expose-internals-in-heap-snapshot",
+    TIMELINE_INVALIDATION_TRACKING = "timeline-invalidation-tracking",
+    TIMELINE_SHOW_ALL_EVENTS = "timeline-show-all-events",
+    APCA = "apca",
+    FONT_EDITOR = "font-editor",
+    FULL_ACCESSIBILITY_TREE = "full-accessibility-tree",
+    EXPERIMENTAL_COOKIE_FEATURES = "experimental-cookie-features",
+    INSTRUMENTATION_BREAKPOINTS = "instrumentation-breakpoints",
+    USE_SOURCE_MAP_SCOPES = "use-source-map-scopes",
+    TIMELINE_DEBUG_MODE = "timeline-debug-mode",
+    DURABLE_MESSAGES = "durable-messages",
+    JPEG_XL = "jpeg-xl"
+}