devtools-tracing 1.2.1 → 1.2.2

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

@@ -0,0 +1,173 @@
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import * as ScopesCodec from '../../third_party/source-map-scopes-codec/source-map-scopes-codec.js';
+import * as Platform from '../platform/platform.js';
+import type { CallFrame, ScopeChainEntry } from './DebuggerModel.js';
+import type { Script } from './Script.js';
+import { type NamedFunctionRange } from './SourceMapFunctionRanges.js';
+import { type TranslatedFrame } from './SourceMapScopesInfo.js';
+/**
+ * Type of the base source map JSON object, which contains the sources and the mappings at the very least, plus
+ * some additional fields.
+ *
+ * @see {@link SourceMapV3}
+ * @see {@link https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k Source Map Revision 3 Proposal}
+ */
+export interface SourceMapV3Object {
+    version: number;
+    sources: string[];
+    mappings: string;
+    file?: string;
+    sourceRoot?: string;
+    sourcesContent?: Array<string | null>;
+    names?: string[];
+    ignoreList?: number[];
+    scopes?: string;
+    debugId?: string;
+    x_google_linecount?: number;
+    x_google_ignoreList?: number[];
+    x_com_bloomberg_sourcesFunctionMappings?: string[];
+}
+/**
+ * Type of JSON objects that classify as valid sourcemaps per version 3 of the specification.
+ *
+ * We support both possible formats, the traditional source map object (represented by the {@link SourceMapV3Object} type),
+ * as well as the index map format, which consists of a sequence of sections that each hold source maps objects themselves
+ * or URLs to external source map files.
+ *
+ * @see {@link SourceMapV3Object}
+ * @see {@link https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k Source Map Revision 3 Proposal}
+ */
+export type SourceMapV3 = SourceMapV3Object | {
+    version: number;
+    sections: Array<{
+        offset: {
+            line: number;
+            column: number;
+        };
+        map: SourceMapV3Object;
+    } | {
+        offset: {
+            line: number;
+            column: number;
+        };
+        url: string;
+    }>;
+    file?: string;
+};
+/**
+ * Parses the {@link content} as JSON, ignoring BOM markers in the beginning, and
+ * also handling the CORB bypass prefix correctly.
+ *
+ * @param content the string representation of a sourcemap.
+ * @returns the {@link SourceMapV3} representation of the {@link content}.
+ */
+export declare function parseSourceMap(content: string): SourceMapV3;
+export type DebugId = Platform.Brand.Brand<string, 'DebugId'>;
+export declare class SourceMapEntry {
+    readonly lineNumber: number;
+    readonly columnNumber: number;
+    readonly sourceIndex?: number;
+    readonly sourceURL?: Platform.DevToolsPath.UrlString;
+    readonly sourceLineNumber: number;
+    readonly sourceColumnNumber: number;
+    readonly name?: string;
+    constructor(lineNumber: number, columnNumber: number, sourceIndex?: number, sourceURL?: Platform.DevToolsPath.UrlString, sourceLineNumber?: number, sourceColumnNumber?: number, name?: string);
+    static compare(entry1: SourceMapEntry, entry2: SourceMapEntry): number;
+}
+export declare class SourceMap {
+    #private;
+    static retainRawSourceMaps: boolean;
+    /**
+     * Implements Source Map V3 model. See https://github.com/google/closure-compiler/wiki/Source-Maps
+     * for format description.
+     */
+    constructor(compiledURL: Platform.DevToolsPath.UrlString, sourceMappingURL: Platform.DevToolsPath.UrlString, payload: SourceMapV3, script?: Script);
+    json(): SourceMapV3 | null;
+    augmentWithScopes(scriptUrl: Platform.DevToolsPath.UrlString, ranges: NamedFunctionRange[]): void;
+    compiledURL(): Platform.DevToolsPath.UrlString;
+    url(): Platform.DevToolsPath.UrlString;
+    debugId(): DebugId | null;
+    sourceURLForSourceIndex(index: number): Platform.DevToolsPath.UrlString | undefined;
+    sourceURLs(): Platform.DevToolsPath.UrlString[];
+    embeddedContentByURL(sourceURL: Platform.DevToolsPath.UrlString): string | null;
+    hasScopeInfo(): boolean;
+    waitForScopeInfo(): Promise<void>;
+    findEntry(lineNumber: number, columnNumber: number, inlineFrameIndex?: number): SourceMapEntry | null;
+    /** Returns the entry at the given position but only if an entry exists for that exact position */
+    findEntryExact(lineNumber: number, columnNumber: number): SourceMapEntry | null;
+    findEntryRanges(lineNumber: number, columnNumber: number): {
+        range: TextUtils.TextRange.TextRange;
+        sourceRange: TextUtils.TextRange.TextRange;
+        sourceURL: Platform.DevToolsPath.UrlString;
+    } | null;
+    sourceLineMapping(sourceURL: Platform.DevToolsPath.UrlString, lineNumber: number, columnNumber: number): SourceMapEntry | null;
+    private findReverseIndices;
+    findReverseEntries(sourceURL: Platform.DevToolsPath.UrlString, lineNumber: number, columnNumber: number): SourceMapEntry[];
+    findReverseRanges(sourceURL: Platform.DevToolsPath.UrlString, lineNumber: number, columnNumber: number): TextUtils.TextRange.TextRange[];
+    mappings(): SourceMapEntry[];
+    private reversedMappings;
+    private eachSection;
+    private parseSources;
+    private parseMap;
+    private parseBloombergScopes;
+    private isSeparator;
+    /**
+     * Finds all the reverse mappings that intersect with the given `textRange` within the
+     * source entity identified by the `url`. If the `url` does not have any reverse mappings
+     * within this source map, an empty array is returned.
+     *
+     * @param url the URL of the source entity to query.
+     * @param textRange the range of text within the entity to check, considered `[start,end[`.
+     * @returns the list of ranges in the generated file that map to locations overlapping the
+     *          {@link textRange} in the source file identified by the {@link url}, or `[]`
+     *          if the {@link url} does not identify an entity in this source map.
+     */
+    reverseMapTextRanges(url: Platform.DevToolsPath.UrlString, textRange: TextUtils.TextRange.TextRange): TextUtils.TextRange.TextRange[];
+    mapsOrigin(): boolean;
+    hasIgnoreListHint(sourceURL: Platform.DevToolsPath.UrlString): boolean;
+    /**
+     * Returns a list of ranges in the generated script for original sources that
+     * match a predicate. Each range is a [begin, end) pair, meaning that code at
+     * the beginning location, up to but not including the end location, matches
+     * the predicate.
+     */
+    findRanges(predicate: (sourceURL: Platform.DevToolsPath.UrlString) => boolean, options?: {
+        isStartMatching: boolean;
+    }): TextUtils.TextRange.TextRange[];
+    /**
+     * Determines whether this and the {@link other} `SourceMap` agree on content and ignore-list hint
+     * with respect to the {@link sourceURL}.
+     *
+     * @param sourceURL the URL to test for (might not be provided by either of the sourcemaps).
+     * @param other the other `SourceMap` to check.
+     * @returns `true` if both this and the {@link other} `SourceMap` either both have the ignore-list
+     *          hint for {@link sourceURL} or neither, and if both of them either provide the same
+     *          content for the {@link sourceURL} inline or both provide no `sourcesContent` entry
+     *          for it.
+     */
+    compatibleForURL(sourceURL: Platform.DevToolsPath.UrlString, other: SourceMap): boolean;
+    resolveScopeChain(frame: CallFrame): ScopeChainEntry[] | null;
+    findOriginalFunctionName(position: ScopesCodec.Position): string | null;
+    findOriginalFunctionScope(position: ScopesCodec.Position): {
+        scope: ScopesCodec.OriginalScope;
+        url?: Platform.DevToolsPath.UrlString;
+    } | null;
+    isOutlinedFrame(generatedLine: number, generatedColumn: number): boolean;
+    hasInlinedFrames(generatedLine: number, generatedColumn: number): boolean;
+    translateCallSite(generatedLine: number, generatedColumn: number): TranslatedFrame[];
+}
+export declare class TokenIterator {
+    #private;
+    constructor(string: string);
+    next(): string;
+    /** Returns the unicode value of the next character and advances the iterator  */
+    nextCharCode(): number;
+    peek(): string;
+    hasNext(): boolean;
+    nextVLQ(): number;
+    /**
+     * @returns the next VLQ number without iterating further. Or returns null if
+     * the iterator is at the end or it's not a valid number.
+     */
+    peekVLQ(): null | number;
+}

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

@@ -0,0 +1,11 @@
+import type { DebugId, SourceMapV3 } from './SourceMap.js';
+/** A thin wrapper around the Cache API to store source map JSONs keyed on Debug IDs */
+export declare class SourceMapCache {
+    #private;
+    static instance(): SourceMapCache;
+    static createForTest(name: string): SourceMapCache;
+    private constructor();
+    set(debugId: DebugId, sourceMap: SourceMapV3): Promise<void>;
+    get(debugId: DebugId): Promise<SourceMapV3 | null>;
+    disposeForTest(): Promise<void>;
+}

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

@@ -0,0 +1,26 @@
+import type * as ScopesCodec from '../../third_party/source-map-scopes-codec/source-map-scopes-codec.js';
+export interface NamedFunctionRange {
+    start: ScopesCodec.Position;
+    end: ScopesCodec.Position;
+    name: string;
+}
+/**
+ * Turns a list of {@link NamedFunctionRange}s into a single {@link OriginalScope} tree nested
+ * according to the start/end position. Each range is turned into a OriginalScope with the `isStackFrame`
+ * bit set to denote it as a function and a generic "Function" label.
+ *
+ * We nest all these function scopes underneath a single global scope that always starts at (0, 0) and
+ * reaches to the largest end position.
+ *
+ * `ranges` can be unsorted but will be sorted in-place.
+ *
+ * @throws if the ranges are not nested properly. Concretely: start < end for each range, and no
+ * "straddling" (i.e. partially overlapping ranges).
+ */
+export declare function buildOriginalScopes(ranges: NamedFunctionRange[]): ScopesCodec.OriginalScope;
+/**
+ * Implements decoding of the pasta source map specification.
+ *
+ * See https://github.com/bloomberg/pasta-sourcemaps/blob/main/spec.md
+ */
+export declare function decodePastaRanges(encodedRanges: string, names: string[]): NamedFunctionRange[];

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

@@ -0,0 +1,44 @@
+import * as Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import type { FrameAssociated } from './FrameAssociated.js';
+import { type PageResourceLoadInitiator, type ResourceLoader } from './PageResourceLoader.js';
+import { SourceMap, type SourceMapV3 } from './SourceMap.js';
+import { type Target } from './Target.js';
+export type SourceMapFactory<T> = (compiledURL: Platform.DevToolsPath.UrlString, sourceMappingURL: Platform.DevToolsPath.UrlString, payload: SourceMapV3, client: T) => SourceMap;
+export declare class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWrapper.ObjectWrapper<EventTypes<T>> {
+    #private;
+    constructor(target: Target, factory?: SourceMapFactory<T>);
+    setEnabled(isEnabled: boolean): void;
+    private static getBaseUrl;
+    static resolveRelativeSourceURL(target: Target | null, url: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.UrlString;
+    sourceMapForClient(client: T): SourceMap | undefined;
+    sourceMapForClientPromise(client: T): Promise<SourceMap | undefined>;
+    clientForSourceMap(sourceMap: SourceMap): T | undefined;
+    attachSourceMap(client: T, relativeSourceURL: Platform.DevToolsPath.UrlString, relativeSourceMapURL: string | undefined): void;
+    cancelAttachSourceMap(client: T): void;
+    detachSourceMap(client: T): void;
+    waitForSourceMapsProcessedForTest(): Promise<unknown>;
+}
+export declare function tryLoadSourceMap(resourceLoader: ResourceLoader, url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator): Promise<SourceMapV3 | null>;
+export declare enum Events {
+    SourceMapWillAttach = "SourceMapWillAttach",
+    SourceMapFailedToAttach = "SourceMapFailedToAttach",
+    SourceMapAttached = "SourceMapAttached",
+    SourceMapDetached = "SourceMapDetached"
+}
+export interface EventTypes<T extends FrameAssociated> {
+    [Events.SourceMapWillAttach]: {
+        client: T;
+    };
+    [Events.SourceMapFailedToAttach]: {
+        client: T;
+    };
+    [Events.SourceMapAttached]: {
+        client: T;
+        sourceMap: SourceMap;
+    };
+    [Events.SourceMapDetached]: {
+        client: T;
+        sourceMap: SourceMap;
+    };
+}

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

@@ -0,0 +1,20 @@
+import type * as ScopesCodec from '../../third_party/source-map-scopes-codec/source-map-scopes-codec.js';
+import type { CallFrame, LocationRange, ScopeChainEntry } from './DebuggerModel.js';
+import { type RemoteObject, RemoteObjectProperty } from './RemoteObject.js';
+export declare class SourceMapScopeChainEntry implements ScopeChainEntry {
+    #private;
+    /**
+     * @param isInnerMostFunction If `scope` is the innermost 'function' scope. Only used for labeling as we name the
+     * scope of the paused function 'Local', while other outer 'function' scopes are named 'Closure'.
+     */
+    constructor(callFrame: CallFrame, scope: ScopesCodec.OriginalScope, range: ScopesCodec.GeneratedRange | undefined, isInnerMostFunction: boolean, returnValue: RemoteObject | undefined);
+    extraProperties(): RemoteObjectProperty[];
+    callFrame(): CallFrame;
+    type(): string;
+    typeName(): string;
+    name(): string | undefined;
+    range(): LocationRange | null;
+    object(): RemoteObject;
+    description(): string;
+    icon(): string | undefined;
+}

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

@@ -0,0 +1,123 @@
+import * as Formatter from '../../models/formatter/formatter.js';
+import type * as TextUtils from '../../models/text_utils/text_utils.js';
+import type * as ScopesCodec from '../../third_party/source-map-scopes-codec/source-map-scopes-codec.js';
+import type * as Platform from '../platform/platform.js';
+import type { CallFrame, ScopeChainEntry } from './DebuggerModel.js';
+import type { SourceMap } from './SourceMap.js';
+export declare class SourceMapScopesInfo {
+    #private;
+    constructor(sourceMap: SourceMap, scopeInfo: ScopesCodec.ScopeInfo);
+    /**
+     * If the source map does not contain any scopes information, this factory function attempts to create scope information
+     * via the script's AST combined with the mappings.
+     *
+     * We create the generated ranges from the scope tree and for each range we create an original scope that matches the bounds 1:1.
+     */
+    static createFromAst(sourceMap: SourceMap, scopeTree: Formatter.FormatterWorkerPool.ScopeTreeNode, text: TextUtils.Text.Text): SourceMapScopesInfo;
+    addOriginalScopes(scopes: Array<ScopesCodec.OriginalScope | null>): void;
+    addGeneratedRanges(ranges: ScopesCodec.GeneratedRange[]): void;
+    hasOriginalScopes(sourceIdx: number): boolean;
+    isEmpty(): boolean;
+    addOriginalScopesAtIndex(sourceIdx: number, scope: ScopesCodec.OriginalScope): void;
+    /**
+     * @returns true, iff the function surrounding the provided position is marked as "hidden".
+     */
+    isOutlinedFrame(generatedLine: number, generatedColumn: number): boolean;
+    /**
+     * @returns true, iff the range surrounding the provided position contains multiple
+     * inlined original functions.
+     */
+    hasInlinedFrames(generatedLine: number, generatedColumn: number): boolean;
+    /**
+     * Given a generated position, returns the original name of the surrounding function as well as
+     * all the original function names that got inlined into the surrounding generated function and their
+     * respective callsites in the original code (ordered from inner to outer).
+     *
+     * @returns a list with inlined functions. Every entry in the list has a callsite in the orignal code,
+     * except the last function (since the last function didn't get inlined).
+     */
+    findInlinedFunctions(generatedLine: number, generatedColumn: number): InlineInfo;
+    /**
+     * @returns true if we have enough info (i.e. variable and binding expressions) to build
+     * a scope view.
+     */
+    hasVariablesAndBindings(): boolean;
+    /**
+     * Constructs a scope chain based on the CallFrame's paused position.
+     *
+     * The algorithm to obtain the original scope chain is straight-forward:
+     *
+     *   1) Find the inner-most generated range that contains the CallFrame's
+     *      paused position.
+     *
+     *   2) Does the found range have an associated original scope?
+     *
+     *      2a) If no, return null. This is a "hidden" range and technically
+     *          we shouldn't be pausing here in the first place. This code doesn't
+     *          correspond to anything in the authored code.
+     *
+     *      2b) If yes, the associated original scope is the inner-most
+     *          original scope in the resulting scope chain.
+     *
+     *   3) Walk the parent chain of the found original scope outwards. This is
+     *      our scope view. For each original scope we also try to find a
+     *      corresponding generated range that contains the CallFrame's
+     *      paused position. We need the generated range to resolve variable
+     *      values.
+     */
+    resolveMappedScopeChain(callFrame: CallFrame): ScopeChainEntry[] | null;
+    /**
+     * Returns the authored function name of the function containing the provided generated position.
+     */
+    findOriginalFunctionName(position: ScopesCodec.Position): string | null;
+    /**
+     * Returns the authored function scope of the function containing the provided generated position.
+     */
+    findOriginalFunctionScope({ line, column }: ScopesCodec.Position): {
+        scope: ScopesCodec.OriginalScope;
+        url?: Platform.DevToolsPath.UrlString;
+    } | null;
+    /**
+     * Returns one or more original stack frames for this single "raw frame" or call-site.
+     *
+     * @returns An empty array if no mapping at the call-site was found, or the resulting frames
+     * in top-to-bottom order in case of inlining.
+     * @throws If this range is marked "hidden". Outlining needs to be handled externally as
+     * outlined function segments in stack traces can span across bundles.
+     */
+    translateCallSite(generatedLine: number, generatedColumn: number): TranslatedFrame[];
+}
+/**
+ * Represents a stack frame in original terms. It closely aligns with StackTrace.StackTrace.Frame,
+ * but since we can't import that type here we mirror it here somewhat.
+ *
+ * Equivalent to Pick<StackTrace.StackTrace.Frame, 'line'|'column'|'name'|'url'>.
+ */
+export interface TranslatedFrame {
+    line: number;
+    column: number;
+    name?: string;
+    url?: Platform.DevToolsPath.UrlString;
+}
+/**
+ * Represents the inlining information for a given generated position.
+ *
+ * It contains a list of all the inlined original functions at the generated position
+ * as well as the original function name of the generated position's surrounding
+ * function.
+ *
+ * The inlined functions are sorted from inner to outer (or top to bottom on the stack).
+ */
+export interface InlineInfo {
+    inlinedFunctions: Array<{
+        name: string;
+        callsite: {
+            line: number;
+            column: number;
+            sourceIndex: number;
+            sourceURL?: Platform.DevToolsPath.UrlString;
+        };
+    }>;
+    originalFunctionName: string;
+}
+export declare function contains(range: Pick<ScopesCodec.GeneratedRange, 'start' | 'end'>, line: number, column: number): boolean;

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

@@ -0,0 +1,56 @@
+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 StorageBucketsModel extends SDKModel<EventTypes> implements ProtocolProxyApi.StorageDispatcher {
+    private enabled;
+    readonly storageAgent: ProtocolProxyApi.StorageApi;
+    private readonly storageKeyManager;
+    private bucketsById;
+    private trackedStorageKeys;
+    constructor(target: Target);
+    getBuckets(): Set<Protocol.Storage.StorageBucketInfo>;
+    getBucketsForStorageKey(storageKey: string): Set<Protocol.Storage.StorageBucketInfo>;
+    getDefaultBucketForStorageKey(storageKey: string): Protocol.Storage.StorageBucketInfo | null;
+    getBucketById(bucketId: string): Protocol.Storage.StorageBucketInfo | null;
+    getBucketByName(storageKey: string, bucketName?: string): Protocol.Storage.StorageBucketInfo | null;
+    deleteBucket(bucket: Protocol.Storage.StorageBucket): void;
+    enable(): void;
+    private storageKeyAdded;
+    private storageKeyRemoved;
+    private addStorageKey;
+    private removeStorageKey;
+    private bucketAdded;
+    private bucketRemoved;
+    private bucketChanged;
+    private bucketInfosAreEqual;
+    storageBucketCreatedOrUpdated({ bucketInfo }: Protocol.Storage.StorageBucketCreatedOrUpdatedEvent): void;
+    storageBucketDeleted({ bucketId }: Protocol.Storage.StorageBucketDeletedEvent): void;
+    attributionReportingTriggerRegistered(_event: Protocol.Storage.AttributionReportingTriggerRegisteredEvent): void;
+    interestGroupAccessed(_event: Protocol.Storage.InterestGroupAccessedEvent): void;
+    interestGroupAuctionEventOccurred(_event: Protocol.Storage.InterestGroupAuctionEventOccurredEvent): void;
+    interestGroupAuctionNetworkRequestCreated(_event: Protocol.Storage.InterestGroupAuctionNetworkRequestCreatedEvent): void;
+    indexedDBListUpdated(_event: Protocol.Storage.IndexedDBListUpdatedEvent): void;
+    indexedDBContentUpdated(_event: Protocol.Storage.IndexedDBContentUpdatedEvent): void;
+    cacheStorageListUpdated(_event: Protocol.Storage.CacheStorageListUpdatedEvent): void;
+    cacheStorageContentUpdated(_event: Protocol.Storage.CacheStorageContentUpdatedEvent): void;
+    sharedStorageAccessed(_event: Protocol.Storage.SharedStorageAccessedEvent): void;
+    sharedStorageWorkletOperationExecutionFinished(_event: Protocol.Storage.SharedStorageWorkletOperationExecutionFinishedEvent): void;
+    attributionReportingSourceRegistered(_event: Protocol.Storage.AttributionReportingSourceRegisteredEvent): void;
+    attributionReportingReportSent(_event: Protocol.Storage.AttributionReportingReportSentEvent): void;
+    attributionReportingVerboseDebugReportSent(_event: Protocol.Storage.AttributionReportingVerboseDebugReportSentEvent): void;
+}
+export declare const enum Events {
+    BUCKET_ADDED = "BucketAdded",
+    BUCKET_REMOVED = "BucketRemoved",
+    BUCKET_CHANGED = "BucketChanged"
+}
+export interface BucketEvent {
+    model: StorageBucketsModel;
+    bucketInfo: Protocol.Storage.StorageBucketInfo;
+}
+export interface EventTypes {
+    [Events.BUCKET_ADDED]: BucketEvent;
+    [Events.BUCKET_REMOVED]: BucketEvent;
+    [Events.BUCKET_CHANGED]: BucketEvent;
+}

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

@@ -0,0 +1,38 @@
+import type * as Platform from '../platform/platform.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class StorageKeyManager extends SDKModel<EventTypes> {
+    #private;
+    constructor(target: Target);
+    updateStorageKeys(storageKeys: Set<string>): void;
+    storageKeys(): string[];
+    mainStorageKey(): string;
+    setMainStorageKey(storageKey: string): void;
+}
+export declare function parseStorageKey(storageKeyString: string): StorageKey;
+export declare const enum StorageKeyComponent {
+    TOP_LEVEL_SITE = "0",
+    NONCE_HIGH = "1",
+    NONCE_LOW = "2",
+    ANCESTOR_CHAIN_BIT = "3",
+    TOP_LEVEL_SITE_OPAQUE_NONCE_HIGH = "4",
+    TOP_LEVEL_SITE_OPAQUE_NONCE_LOW = "5",
+    TOP_LEVEL_SITE_OPAQUE_NONCE_PRECURSOR = "6"
+}
+export interface StorageKey {
+    origin: Platform.DevToolsPath.UrlString;
+    components: Map<StorageKeyComponent, string>;
+}
+export declare const enum Events {
+    STORAGE_KEY_ADDED = "StorageKeyAdded",
+    STORAGE_KEY_REMOVED = "StorageKeyRemoved",
+    MAIN_STORAGE_KEY_CHANGED = "MainStorageKeyChanged"
+}
+export interface MainStorageKeyChangedEvent {
+    mainStorageKey: string;
+}
+export interface EventTypes {
+    [Events.STORAGE_KEY_ADDED]: string;
+    [Events.STORAGE_KEY_REMOVED]: string;
+    [Events.MAIN_STORAGE_KEY_CHANGED]: MainStorageKeyChangedEvent;
+}

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

@@ -0,0 +1,71 @@
+import type * as Protocol from '../../generated/protocol.js';
+import * as Platform from '../platform/platform.js';
+import * as ProtocolClient from '../protocol_client/protocol_client.js';
+import { SDKModel, type SDKModelConstructor } from './SDKModel.js';
+import type { TargetManager } from './TargetManager.js';
+export declare class Target extends ProtocolClient.InspectorBackend.TargetBase {
+    #private;
+    constructor(targetManager: TargetManager, id: Protocol.Target.TargetID | 'main', name: string, type: Type, parentTarget: Target | null, sessionId: string, suspended: boolean, connection: ProtocolClient.CDPConnection.CDPConnection | null, targetInfo?: Protocol.Target.TargetInfo);
+    /** Creates the models in the order in which they are provided */
+    createModels(models: SDKModelConstructor[]): void;
+    id(): Protocol.Target.TargetID | 'main';
+    name(): string;
+    setName(name: string): void;
+    type(): Type;
+    markAsNodeJSForTest(): void;
+    targetManager(): TargetManager;
+    hasAllCapabilities(capabilitiesMask: number): boolean;
+    decorateLabel(label: string): string;
+    parentTarget(): Target | null;
+    outermostTarget(): Target | null;
+    dispose(reason: string): void;
+    model<T extends SDKModel>(modelClass: new (arg1: Target) => T): T | null;
+    models(): Map<new (arg1: Target) => SDKModel, SDKModel>;
+    inspectedURL(): Platform.DevToolsPath.UrlString;
+    setInspectedURL(inspectedURL: Platform.DevToolsPath.UrlString): void;
+    hasCrashed(): boolean;
+    setHasCrashed(isCrashed: boolean): void;
+    suspend(reason?: string): Promise<void>;
+    resume(): Promise<void>;
+    suspended(): boolean;
+    updateTargetInfo(targetInfo: Protocol.Target.TargetInfo): void;
+    targetInfo(): Protocol.Target.TargetInfo | undefined;
+}
+export declare enum Type {
+    FRAME = "frame",
+    ServiceWorker = "service-worker",
+    Worker = "worker",
+    SHARED_WORKER = "shared-worker",
+    SHARED_STORAGE_WORKLET = "shared-storage-worklet",
+    NODE = "node",
+    BROWSER = "browser",
+    AUCTION_WORKLET = "auction-worklet",
+    WORKLET = "worklet",
+    TAB = "tab",
+    NODE_WORKER = "node-worker"
+}
+export declare const enum Capability {
+    BROWSER = 1,
+    DOM = 2,
+    JS = 4,
+    LOG = 8,
+    NETWORK = 16,
+    TARGET = 32,
+    SCREEN_CAPTURE = 64,
+    TRACING = 128,
+    EMULATION = 256,
+    SECURITY = 512,
+    INPUT = 1024,
+    INSPECTOR = 2048,
+    DEVICE_EMULATION = 4096,
+    STORAGE = 8192,
+    SERVICE_WORKER = 16384,
+    AUDITS = 32768,
+    WEB_AUTHN = 65536,
+    IO = 131072,
+    MEDIA = 262144,
+    EVENT_BREAKPOINTS = 524288,
+    DOM_STORAGE = 1048576,
+    WEB_MCP = 2097152,
+    NONE = 0
+}

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

@@ -0,0 +1,84 @@
+import type * as Protocol from '../../generated/protocol.js';
+import * as Common from '../common/common.js';
+import type * as ProtocolClient from '../protocol_client/protocol_client.js';
+import * as Root from '../root/root.js';
+import { SDKModel, type SDKModelConstructor } from './SDKModel.js';
+import { Target, Type as TargetType } from './Target.js';
+export declare class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+    #private;
+    /**
+     * @deprecated
+     *
+     * Intended for {@link SDKModel} classes to be able to retrieve scoped singletons like
+     * the "PageResourceLoader" or the "FrameManager".
+     *
+     * This is only an intermediate step to migrate towards our "layering vision" where
+     * SDKModels don't require things from the next layer.
+     */
+    readonly context: Root.DevToolsContext.DevToolsContext;
+    get settings(): Common.Settings.Settings;
+    /**
+     * @param overrideAutoStartModels If provided, then the `autostart` flag on {@link RegistrationInfo} will be ignored.
+     */
+    constructor(context: Root.DevToolsContext.DevToolsContext, overrideAutoStartModels?: Set<SDKModelConstructor>);
+    static instance({ forceNew }?: {
+        forceNew: boolean;
+    }): TargetManager;
+    static removeInstance(): void;
+    onInspectedURLChange(target: Target): void;
+    onNameChange(target: Target): void;
+    suspendAllTargets(reason?: string): Promise<void>;
+    resumeAllTargets(): Promise<void>;
+    allTargetsSuspended(): boolean;
+    models<T extends SDKModel>(modelClass: SDKModelConstructor<T>, opts?: {
+        scoped: boolean;
+    }): T[];
+    inspectedURL(): string;
+    observeModels<T extends SDKModel>(modelClass: SDKModelConstructor<T>, observer: SDKModelObserver<T>, opts?: {
+        scoped: boolean;
+    }): void;
+    unobserveModels<T extends SDKModel>(modelClass: SDKModelConstructor<T>, observer: SDKModelObserver<T>): void;
+    modelAdded(modelClass: SDKModelConstructor, model: SDKModel, inScope: boolean): void;
+    private modelRemoved;
+    addModelListener<Events, T extends keyof Events>(modelClass: SDKModelConstructor<SDKModel<Events>>, eventType: T, listener: Common.EventTarget.EventListener<Events, T>, thisObject?: Object, opts?: {
+        scoped: boolean;
+    }): void;
+    removeModelListener<Events, T extends keyof Events>(modelClass: SDKModelConstructor<SDKModel<Events>>, eventType: T, listener: Common.EventTarget.EventListener<Events, T>, thisObject?: Object): void;
+    observeTargets(targetObserver: Observer, opts?: {
+        scoped: boolean;
+    }): void;
+    unobserveTargets(targetObserver: Observer): void;
+    createTarget(id: Protocol.Target.TargetID | 'main', name: string, type: TargetType, parentTarget: Target | null, sessionId?: string, waitForDebuggerInPage?: boolean, connection?: ProtocolClient.CDPConnection.CDPConnection, targetInfo?: Protocol.Target.TargetInfo): Target;
+    removeTarget(target: Target): void;
+    targets(): Target[];
+    targetById(id: string): Target | null;
+    rootTarget(): Target | null;
+    primaryPageTarget(): Target | null;
+    browserTarget(): Target | null;
+    maybeAttachInitialTarget(): Promise<boolean>;
+    clearAllTargetsForTest(): void;
+    isInScope(arg: SDKModel | Target | Common.EventTarget.EventTargetEvent<any, any> | null): boolean;
+    setScopeTarget(scopeTarget: Target | null): void;
+    addScopeChangeListener(listener: () => void): void;
+    scopeTarget(): Target | null;
+}
+export declare const enum Events {
+    AVAILABLE_TARGETS_CHANGED = "AvailableTargetsChanged",
+    INSPECTED_URL_CHANGED = "InspectedURLChanged",
+    NAME_CHANGED = "NameChanged",
+    SUSPEND_STATE_CHANGED = "SuspendStateChanged"
+}
+export interface EventTypes {
+    [Events.AVAILABLE_TARGETS_CHANGED]: Protocol.Target.TargetInfo[];
+    [Events.INSPECTED_URL_CHANGED]: Target;
+    [Events.NAME_CHANGED]: Target;
+    [Events.SUSPEND_STATE_CHANGED]: void;
+}
+export declare class Observer {
+    targetAdded(_target: Target): void;
+    targetRemoved(_target: Target): void;
+}
+export declare class SDKModelObserver<T> {
+    modelAdded(_model: T): void;
+    modelRemoved(_model: T): void;
+}