chrome-devtools-frontend 1.0.1721762 → 1.0.1726686

package/front_end/panels/timeline/TimelineCommentController.ts

@@ -9,9 +9,34 @@ import type * as PerfUI from '../../ui/legacy/components/perf_ui/perf_ui.js';
 import * as VisualLogging from '../../ui/visual_logging/visual_logging.js';
 
 import * as Overlays from './overlays/overlays.js';
-import type {TimelineFlameChartDataProvider} from './TimelineFlameChartDataProvider.js';
+import {agentContextForEntry} from './TimelineCommentContext.js';
+import {
+  Events as TimelineFlameChartDataProviderEvents,
+  type TimelineFlameChartDataProvider,
+} from './TimelineFlameChartDataProvider.js';
 import type {TimelineFlameChartNetworkDataProvider} from './TimelineFlameChartNetworkDataProvider.js';
 
+/**
+ * Prefix for keys of entries that EventsSerializer cannot key. The full key is
+ * `fc-<chartLocation>-<entryIndex>`.
+ */
+const SYNTHETIC_KEY_PREFIX = 'fc-';
+
+function entryStartTimeMicro(timelineData: PerfUI.FlameChart.FlameChartTimelineData, entryIndex: number): number {
+  return Trace.Helpers.Timing.milliToMicro(Trace.Types.Timing.Milli(timelineData.entryStartTimes[entryIndex]));
+}
+
+/**
+ * Returns the entry's duration, or undefined for instant entries.
+ */
+function entryDurationMicro(timelineData: PerfUI.FlameChart.FlameChartTimelineData, entryIndex: number): number|
+    undefined {
+  const totalTime = timelineData.entryTotalTimes[entryIndex];
+  return !Number.isNaN(totalTime) && totalTime > 0 ?
+      Trace.Helpers.Timing.milliToMicro(Trace.Types.Timing.Milli(totalTime)) :
+      undefined;
+}
+
 /**
  * Supplies the flame charts, data providers, overlays and events serializer
  * that the controller needs to resolve and pin comments.
@@ -44,10 +69,10 @@ interface ResolvedEntry {
  * flame chart canvas:
  * - It registers a CustomAnchorResolver that maps a pointer position on a
  *   flame chart canvas to a timeline anchor.
- * - It keeps one COMMENT_PIN overlay per thread on the current trace. Overlays
- *   positions each COMMENT_PIN element over its entry, and the resolver
- *   returns that element from getAnchorElement() so the shared overlay can
- *   draw the pin on it.
+ * - It keeps one COMMENT_PIN overlay for each thread on the current trace
+ *   whose entry it finds. Overlays positions each COMMENT_PIN element over its
+ *   entry, and the resolver returns that element from getAnchorElement() so
+ *   the shared overlay can draw the pin on it.
  * - It requests repositioning after every Overlays update, because panning or
  *   zooming the flame chart moves the COMMENT_PIN elements without any DOM
  *   scroll or resize.
@@ -68,6 +93,15 @@ export class TimelineCommentController {
     this.#syncCommentOverlays();
   };
 
+  /**
+   * The main flame chart rebuilds its entries when entries are hidden or
+   * shown from the context menu, or the ignore list changes. Threads with a
+   * synthetic key whose entry was missing can then be pinned.
+   */
+  readonly #onMainDataChanged = (): void => {
+    this.#syncCommentOverlays();
+  };
+
   // Overlays updates on every pan and zoom, so the notification is skipped
   // while there are no COMMENT_PIN overlays.
   readonly #onOverlaysUpdated = (): void => {
@@ -112,13 +146,15 @@ export class TimelineCommentController {
   }
 
   /**
-   * Starts listening for thread and overlay changes, registers the anchor
-   * resolver and shows pins for existing threads.
+   * Starts listening for thread, overlay and flame chart data changes,
+   * registers the anchor resolver and shows pins for existing threads.
    */
   wasShown(): void {
     this.#commentManager.addEventListener(CommentManager.CommentManager.Events.COMMENT_THREADS_CHANGED,
                                           this.#onCommentThreadsChanged);
     this.#delegate.overlays.addEventListener(Overlays.Overlays.OverlaysUpdated.eventName, this.#onOverlaysUpdated);
+    this.#delegate.mainDataProvider.addEventListener(TimelineFlameChartDataProviderEvents.DATA_CHANGED,
+                                                     this.#onMainDataChanged);
     Comments.CommentAnchorResolver.registerCustomAnchorResolver(this.#customAnchorResolver);
     this.#syncCommentOverlays();
     // COMMENT_PIN overlays that survived while the view was hidden need their
@@ -129,14 +165,16 @@ export class TimelineCommentController {
   }
 
   /**
-   * Stops listening for thread and overlay changes and unregisters the anchor
-   * resolver. The final notification removes the shared pins, because the
-   * resolver no longer supplies their anchor elements.
+   * Stops listening for thread, overlay and flame chart data changes and
+   * unregisters the anchor resolver. The final notification removes the shared
+   * pins, because the resolver no longer supplies their anchor elements.
    */
   willHide(): void {
     this.#commentManager.removeEventListener(CommentManager.CommentManager.Events.COMMENT_THREADS_CHANGED,
                                              this.#onCommentThreadsChanged);
     this.#delegate.overlays.removeEventListener(Overlays.Overlays.OverlaysUpdated.eventName, this.#onOverlaysUpdated);
+    this.#delegate.mainDataProvider.removeEventListener(TimelineFlameChartDataProviderEvents.DATA_CHANGED,
+                                                        this.#onMainDataChanged);
     Comments.CommentAnchorResolver.unregisterCustomAnchorResolver(this.#customAnchorResolver);
     Comments.CommentAnchorResolver.notifyCustomAnchorsMoved();
     this.#notifiedWithCommentPins = false;
@@ -176,6 +214,67 @@ export class TimelineCommentController {
     return `trace-${min}-${max}`;
   }
 
+  #dataProviderFor(chartLocation: 'main'|'network'): TimelineFlameChartDataProvider
+      |TimelineFlameChartNetworkDataProvider {
+    return chartLocation === 'network' ? this.#delegate.networkDataProvider : this.#delegate.mainDataProvider;
+  }
+
+  /**
+   * Returns the event for a thread's timeline anchor, or null if the anchor
+   * has a synthetic key and no flame chart entry matches it.
+   */
+  #eventForTimelineAnchor(anchor: CommentManager.CommentManager.TimelineAnchorSignature,
+                          parsedTrace: Trace.TraceModel.ParsedTrace): Trace.Types.Events.Event|null {
+    if (!anchor.traceEventKey.startsWith(SYNTHETIC_KEY_PREFIX)) {
+      // The key was created by EventsSerializer for this trace, because the
+      // thread's traceId matches.
+      return this.#delegate.eventsSerializer.eventForKey(anchor.traceEventKey as Trace.Types.File.SerializableKey,
+                                                         parsedTrace);
+    }
+    const entryIndex = this.#findEntryIndexForSyntheticKey(anchor);
+    if (entryIndex === -1) {
+      return null;
+    }
+    return this.#dataProviderFor(anchor.chartLocation).eventByIndex(entryIndex);
+  }
+
+  /**
+   * Returns the index of the flame chart entry with the anchor's start time,
+   * duration and title, or -1 if there is none. Duration separates nested
+   * entries that share a start time and title, such as recursive calls.
+   *
+   * Entry indexes change when the flame chart rebuilds its entries, for
+   * example after entries are hidden from the context menu. The index encoded
+   * in the synthetic key is therefore checked first and used only if that
+   * entry still matches. Otherwise every entry is scanned, because
+   * `entryStartTimes` concatenates all tracks and is not sorted.
+   */
+  #findEntryIndexForSyntheticKey(anchor: CommentManager.CommentManager.TimelineAnchorSignature): number {
+    const dataProvider = this.#dataProviderFor(anchor.chartLocation);
+    const timelineData = dataProvider.timelineData();
+    const entryCount = timelineData.entryStartTimes.length;
+    const matchesAnchor = (index: number): boolean => {
+      // The anchor's times were computed by entryStartTimeMicro() and
+      // entryDurationMicro() from the same trace, so exact comparisons are
+      // safe.
+      return entryStartTimeMicro(timelineData, index) === anchor.startTimeMicro &&
+          entryDurationMicro(timelineData, index) === anchor.durationMicro &&
+          (dataProvider.entryTitle(index) ?? '') === anchor.entryName;
+    };
+
+    const encodedIndex = Number(anchor.traceEventKey.slice(`${SYNTHETIC_KEY_PREFIX}${anchor.chartLocation}-`.length));
+    if (Number.isInteger(encodedIndex) && encodedIndex >= 0 && encodedIndex < entryCount &&
+        matchesAnchor(encodedIndex)) {
+      return encodedIndex;
+    }
+    for (let index = 0; index < entryCount; index++) {
+      if (matchesAnchor(index)) {
+        return index;
+      }
+    }
+    return -1;
+  }
+
   #syncCommentOverlays(): void {
     const existingOverlays = this.#delegate.overlays.overlaysOfType<Trace.Types.Overlays.CommentPin>('COMMENT_PIN');
     const currentTraceId = this.#traceId();
@@ -202,10 +301,13 @@ export class TimelineCommentController {
       if (existingOverlays.some(overlay => overlay.commentThreadId === thread.id)) {
         continue;
       }
-      // The key was created by EventsSerializer for this trace, because the
-      // thread's traceId matches.
-      const event = this.#delegate.eventsSerializer.eventForKey(
-          thread.anchor.timeline.traceEventKey as Trace.Types.File.SerializableKey, parsedTrace);
+      const event = this.#eventForTimelineAnchor(thread.anchor.timeline, parsedTrace);
+      // The entry of a synthetic key can be missing from the flame chart, for
+      // example after it is hidden from the context menu. The thread then has
+      // no pin until #onMainDataChanged() syncs again and finds the entry.
+      if (!event) {
+        continue;
+      }
       this.#delegate.overlays.add({
         type: 'COMMENT_PIN',
         entry: event,
@@ -223,6 +325,11 @@ export class TimelineCommentController {
 
     if (mutationsMade) {
       void this.#delegate.overlays.update();
+    } else {
+      // Overlays#reset() clears previous overlays before setParsedTrace() runs.
+      // Run #onOverlaysUpdated() so notifyCustomAnchorsMoved() still fires when
+      // the new trace adds no comment pins of its own.
+      this.#onOverlaysUpdated();
     }
   }
 
@@ -304,27 +411,23 @@ export class TimelineCommentController {
     if (!traceId) {
       return null;
     }
-    // Events that EventsSerializer cannot key, such as JS samples, cannot be
-    // found again when the thread is pinned, so they are not commentable.
-    const traceEventKey = this.#delegate.eventsSerializer.keyForEvent(entry.event);
-    if (!traceEventKey) {
-      return null;
-    }
-
-    const {flameChart, dataProvider, chartLocation, canvas, entryIndex, highlightRect} = entry;
+    const {flameChart, dataProvider, chartLocation, canvas, entryIndex, event, highlightRect} = entry;
+    // Events that EventsSerializer cannot key, such as JS samples, get a
+    // synthetic key that encodes the chart and the entry index.
+    // #findEntryIndexForSyntheticKey() uses the stored start time, duration
+    // and title to find the entry again if the index has changed.
+    const traceEventKey =
+        this.#delegate.eventsSerializer.keyForEvent(event) ?? `${SYNTHETIC_KEY_PREFIX}${chartLocation}-${entryIndex}`;
     const timelineData = flameChart.timelineData();
     if (!timelineData) {
       throw new Error('Flame chart resolved an entry index without timeline data.');
     }
-    // Store the raw title, even when it is empty. The UI applies its own
-    // display fallback for untitled entries.
+    // Store the raw title, even when it is empty. #findEntryIndexForSyntheticKey()
+    // compares against it, and the UI applies its own display fallback for
+    // untitled entries.
     const entryName = dataProvider.entryTitle(entryIndex) ?? '';
-    const startTimeMicro =
-        Trace.Helpers.Timing.milliToMicro(Trace.Types.Timing.Milli(timelineData.entryStartTimes[entryIndex]));
-    const totalTime = timelineData.entryTotalTimes[entryIndex];
-    const durationMicro = !Number.isNaN(totalTime) && totalTime > 0 ?
-        Trace.Helpers.Timing.milliToMicro(Trace.Types.Timing.Milli(totalTime)) :
-        undefined;
+    const startTimeMicro = entryStartTimeMicro(timelineData, entryIndex);
+    const durationMicro = entryDurationMicro(timelineData, entryIndex);
 
     return {
       anchor: {
@@ -338,9 +441,44 @@ export class TimelineCommentController {
           durationMicro,
           chartLocation,
         },
+        agentContext: this.#agentContextFor(entry),
       },
       anchorElement: canvas,
       highlightRect,
     };
   }
+
+  /**
+   * Returns the lines that describe the entry to the AI agent, or undefined
+   * if no trace is active.
+   */
+  #agentContextFor(entry: ResolvedEntry): string[]|undefined {
+    if (!this.#parsedTrace) {
+      return undefined;
+    }
+    return agentContextForEntry(entry.event, this.#trackNameFor(entry), this.#parsedTrace);
+  }
+
+  /**
+   * Returns the name of the track that contains the entry. Groups are stored
+   * in level order and nested groups follow their parent, so the entry's
+   * track is the last group that starts at or above the entry's level. The
+   * data provider's groupForEvent() is not used because it only knows tracks
+   * built by track appenders, and not, for example, the Frames track.
+   */
+  #trackNameFor(entry: ResolvedEntry): string|null {
+    const timelineData = entry.flameChart.timelineData();
+    if (!timelineData) {
+      return null;
+    }
+    const level = timelineData.entryLevels[entry.entryIndex];
+    let trackName: string|null = null;
+    for (const group of timelineData.groups) {
+      if (group.startLevel > level) {
+        break;
+      }
+      trackName = group.name;
+    }
+    return trackName;
+  }
 }

package/front_end/panels/timeline/TimelinePanel.ts

@@ -962,6 +962,10 @@ export class TimelinePanel extends TimelinePanelBase implements Client, Timeline
         // We also hide the sidebar - else if the user is viewing a trace and
         // then load/record another, the sidebar remains visible.
         this.#hideSidebar();
+        // Hide the SearchableView so Ctrl/Cmd-F cannot search a hidden trace
+        // and flame chart overlays (such as comment pins rendered on
+        // document.body) do not remain visible above the StatusDialog.
+        this.#searchableView.hideWidget();
         return;
       }
       default:

package/front_end/panels/timeline/components/IgnoreListSetting.ts

@@ -89,7 +89,7 @@ export const DEFAULT_VIEW: View = (input, output, target) => {
     // clang-format off
     return html`
       <div class='regex-row'>
-        <devtools-checkbox title=${helpText} aria-label=${helpText} ?checked=${!regex.disabled}
+        <devtools-checkbox title=${helpText} aria-label=${helpText} .checked=${!regex.disabled}
           @change=${(event: Event) => onExistingRegexEnableToggle(regex, (event.currentTarget as UI.UIUtils.CheckboxLabel).checked)}
           .jslogContext=${'timeline.ignore-list-pattern'}>${regex.pattern}</devtools-checkbox>
         <devtools-button

package/front_end/panels/timeline/timeline.ts

@@ -23,6 +23,7 @@ import * as StatusDialog from './StatusDialog.js';
 import * as TargetForEvent from './TargetForEvent.js';
 import * as ThirdPartyTreeView from './ThirdPartyTreeView.js';
 import * as ThreadAppender from './ThreadAppender.js';
+import * as TimelineCommentContext from './TimelineCommentContext.js';
 import * as TimelineCommentController from './TimelineCommentController.js';
 import * as TimelineController from './TimelineController.js';
 import * as TimelineDetailsView from './TimelineDetailsView.js';
@@ -69,6 +70,7 @@ export {
   TargetForEvent,
   ThirdPartyTreeView,
   ThreadAppender,
+  TimelineCommentContext,
   TimelineCommentController,
   TimelineController,
   TimelineDetailsView,

package/front_end/panels/timeline/utils/Treemap.ts

@@ -197,12 +197,20 @@ export function createTreemapData(
     duplication: Trace.Extras.ScriptDuplication.ScriptDuplication): TreemapData {
   const nodes: TreemapNode[] = [];
   const htmlNodesByFrameId = new Map<string, TreemapNode>();
+  const seenRequests = new Set<Trace.Types.Events.SyntheticNetworkRequest>();
 
   for (const script of scripts.scripts) {
     if (!script.url) {
       continue;
     }
 
+    if (!script.inline && script.request) {
+      if (seenRequests.has(script.request)) {
+        continue;
+      }
+      seenRequests.add(script.request);
+    }
+
     const name = script.url;
     const sizes = Trace.Handlers.ModelHandlers.Scripts.getScriptGeneratedSizes(script);
 

package/front_end/panels/webauthn/WebauthnPane.ts

@@ -753,20 +753,22 @@ export class WebauthnPaneImpl extends UI.Panel.Panel implements
         Host.userMetrics.actionTaken(Host.UserMetrics.Action.VirtualAuthenticatorEnvironmentEnabled);
         this.#hasBeenEnabled = true;
       }
-      if (this.#model) {
-        await this.#model.setVirtualAuthEnvEnabled(enable);
+      try {
+        if (this.#model) {
+          await this.#model.setVirtualAuthEnvEnabled(enable);
+        }
+
+        if (enable) {
+          await this.#loadInitialAuthenticators();
+        } else {
+          this.#removeAuthenticatorSections();
+        }
+        this.#enabled = enable;
+      } finally {
+        this.#isEnabling = undefined;
+        this.requestUpdate();
+        resolve();
       }
-
-      if (enable) {
-        await this.#loadInitialAuthenticators();
-      } else {
-        this.#removeAuthenticatorSections();
-      }
-
-      this.#isEnabling = undefined;
-      this.#enabled = enable;
-      this.requestUpdate();
-      resolve();
     });
   }
 

package/front_end/third_party/chromium/README.chromium

@@ -1,7 +1,7 @@
 Name: Dependencies sourced from the upstream `chromium` repository
 URL: Internal
 Version: N/A
-Revision: fae02652a5804f15d9defae53943428ceffa617d
+Revision: d4d613355ad137685e4f35deed6a3697cd9d5202
 Update Mechanism: Manual (https://crbug.com/428069060)
 License: BSD-3-Clause
 License File: LICENSE

package/front_end/third_party/puppeteer/README.chromium

@@ -1,10 +1,10 @@
 Name: Puppeteer Core
 Short Name: Puppeteer Core
 URL: https://github.com/puppeteer/puppeteer/tree/main/packages/puppeteer-core
-Version: 25.14.0
+Version: 25.16.0
 License: Apache-2.0
 License File: LICENSE
-Revision: d1b9a2162a0113356db5093f055b4a2e1979c6a8
+Revision: a207faf527ce4305b33a6c0f9706b090c21c115e
 Security Critical: no
 Shipped: yes
 Update Mechanism: Autoroll

package/front_end/third_party/puppeteer/package/lib/es5-iife/puppeteer-core-browser.d.ts

@@ -439,6 +439,24 @@ export declare abstract class Browser extends EventEmitter<BrowserEvents> {
    * {@link Browser.defaultBrowserContext | default browser context}).
    */
   abstract target(): Target;
+  /**
+   * Sets the network conditions (blocklist or allowlist) and re-applies the
+   * conditions to all targets.
+   * To clear all network conditions, omit the argument or pass `null`.
+   *
+   * @param conditions - The network conditions to apply.
+   *
+   * @remarks
+   * Currently only supported for Chrome and the CDP protocol.
+   *
+   * Targets that are already on a blocked URL when `restrictNetwork` is called
+   * will remain attached and stay on the blocked page. This is a behavior difference
+   * compared to launching the browser with network restrictions, where such targets
+   * are detached immediately upon initial attach.
+   *
+   * @experimental
+   */
+  restrictNetwork(conditions?: NetworkRestrictions | null): Promise<void>;
   /**
    * Waits until a {@link Target | target} matching the given `predicate`
    * appears and returns it.
@@ -4056,9 +4074,28 @@ export declare abstract class HTTPRequest {
    * Fetches the POST data for the request from the browser.
    */
   abstract fetchPostData(): Promise<string | undefined>;
+  /**
+   * Fetches the POST data for the request from the browser as a `Uint8Array`.
+   *
+   * @remarks
+   * If the request has no POST data or fetching the POST data from the browser
+   * fails, this method resolves to `undefined`.
+   *
+   * @returns A promise that resolves to the raw POST data bytes, or
+   * `undefined` when the request has no POST data or fetching it fails.
+   */
+  abstract content(): Promise<Uint8Array | undefined>;
   /**
    * An object with HTTP headers associated with the request. All
    * header names are lower-case.
+   *
+   * @remarks
+   *
+   * Under CDP, `page.on('request')` fires before the browser's network stack
+   * attaches all headers (such as `accept`, `accept-encoding`, `cookie`,
+   * `host`, and `sec-fetch-*`). The full set of headers is populated
+   * asynchronously and is available by the time `page.on('response')` or
+   * `page.on('requestfinished')` fires.
    */
   abstract headers(): Record<string, string>;
   /**
@@ -4068,7 +4105,7 @@ export declare abstract class HTTPRequest {
    *
    * Headers are copied to the new Request instance. The request URL and
    * method are preserved. The body is built from
-   * {@link HTTPRequest.fetchPostData} when the request has post data,
+   * {@link HTTPRequest.content} when the request has post data,
    * otherwise the Request is created without a body. For `GET` and
    * `HEAD` requests the body is always omitted, as required by the
    * Fetch API.
@@ -5503,6 +5540,8 @@ export declare abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    * method is chosen based on the type. `contenteditable`, select, textarea and
    * input elements are supported. For checkboxes, radio buttons and switches
    * specify a boolean value.
+   * Read-only elements and values the element does not accept are rejected without
+   * modifying the element.
    */
   fill<ElementType extends Element>(
     this: Locator<ElementType>,
@@ -5992,6 +6031,25 @@ export declare interface NetworkConditions {
   latency?: number;
 }
 
+/**
+ * @experimental
+ * @public
+ */
+export declare interface NetworkRestrictions {
+  /**
+   * A list of {@link https://urlpattern.spec.whatwg.org/ | URLPattern} strings to block.
+   * Mutually exclusive with {@link NetworkRestrictions.allowlist}.
+   * Passing `[]` or omitting this option means no restriction.
+   */
+  blocklist?: string[];
+  /**
+   * A list of {@link https://urlpattern.spec.whatwg.org/ | URLPattern} strings to allow.
+   * Mutually exclusive with {@link NetworkRestrictions.blocklist}.
+   * Passing `[]` or omitting this option means no restriction.
+   */
+  allowlist?: string[];
+}
+
 /**
  * @public
  */
@@ -6129,13 +6187,17 @@ export declare abstract class Page extends EventEmitter<PageEvents> {
    * Consider using {@link BrowserContext.overridePermissions} to grant
    * permissions for the page to read its geolocation.
    *
+   * Pass `null` to remove the geolocation override.
+   *
    * @example
    *
    * ```ts
    * await page.setGeolocation({latitude: 59.95, longitude: 30.31667});
+   * // Later, go back to the browser's real geolocation:
+   * await page.setGeolocation(null);
    * ```
    */
-  abstract setGeolocation(options: GeolocationOptions): Promise<void>;
+  abstract setGeolocation(options: GeolocationOptions | null): Promise<void>;
   /**
    * A target this page was created from.
    *
@@ -7983,6 +8045,17 @@ export declare abstract class Page extends EventEmitter<PageEvents> {
    * @experimental
    */
   abstract windowId(): Promise<WindowId>;
+  /**
+   * Returns information about the browser tab of this page. The result is a
+   * snapshot and is not updated when the tab changes.
+   *
+   * @returns `null` if the page is not in a tab strip, for example, in
+   * `chrome-headless-shell`. Chrome before M150 does not report tab
+   * information, so the method also returns `null` there.
+   *
+   * @experimental
+   */
+  abstract tabInfo(): Promise<TabInfo | null>;
   [disposeSymbol](): void;
   [asyncDisposeSymbol](): Promise<void>;
   /**
@@ -8624,6 +8697,7 @@ declare namespace Puppeteer_2 {
     LaunchPWAOptions,
     GetPWAStateOptions,
     PWAState,
+    NetworkRestrictions,
     BrowserContextEvents,
     CDPEvents,
     CDPSessionEvents,
@@ -8679,6 +8753,7 @@ declare namespace Puppeteer_2 {
     NewDocumentScriptEvaluation,
     ReloadOptions,
     HeapSnapshotOptions,
+    TabInfo,
     WritableDestination,
     WebWorkerEvents,
     VisibilityOption,
@@ -9625,7 +9700,8 @@ export declare interface SerializedAXNode {
    * Get an ElementHandle for this AXNode if available.
    *
    * If the underlying DOM element has been disposed, the method might return an
-   * error.
+   * error. If the frame has navigated to a new document since the snapshot,
+   * the method returns `null`.
    */
   elementHandle(): Promise<ElementHandle | null>;
 }
@@ -9700,6 +9776,31 @@ export declare type SupportedWebDriverCapability = Exclude<
   'unhandledPromptBehavior' | 'acceptInsecureCerts'
 >;
 
+/**
+ * Information about the browser tab of a page. See {@link Page.tabInfo}.
+ *
+ * @public
+ * @experimental
+ */
+export declare interface TabInfo {
+  /**
+   * Zero-based index of the tab in its window's tab strip.
+   */
+  index: number;
+  /**
+   * Whether the tab is the active tab in its window.
+   */
+  active: boolean;
+  /**
+   * Whether the tab is pinned.
+   */
+  pinned: boolean;
+  /**
+   * ID of the tab group the tab belongs to, if any.
+   */
+  groupId?: string;
+}
+
 /**
  * Target represents a
  * {@link https://chromedevtools.github.io/devtools-protocol/tot/Target/ | CDP target}.
@@ -10481,6 +10582,15 @@ export declare interface WsOptions {
    * @defaultValue `256 * 1024 * 1024`
    */
   maxPayload?: number;
+  /**
+   * Time in milliseconds to wait for the WebSocket opening handshake before
+   * failing. Without it, connecting to a host that accepts the TCP connection
+   * but never answers the upgrade request waits until the operating system
+   * gives up. Node.js only.
+   *
+   * @defaultValue no timeout
+   */
+  handshakeTimeout?: number;
 }
 
 export {};