devtools-protocol 0.0.1113120 → 0.0.1114386

package/json/browser_protocol.json

@@ -1449,7 +1449,6 @@
                     "type": "string",
                     "enum": [
                         "PermissionPolicyDisabled",
-                        "PermissionPolicyNotDelegated",
                         "UntrustworthyReportingOrigin",
                         "InsecureContext",
                         "InvalidHeader",
@@ -22790,6 +22789,73 @@
                         }
                     ]
                 },
+                {
+                    "id": "SpeculationAction",
+                    "description": "The type of preloading attempted. It corresponds to\nmojom::SpeculationAction (although PrefetchWithSubresources is omitted as it\nisn't being used by clients).",
+                    "type": "string",
+                    "enum": [
+                        "Prefetch",
+                        "Prerender"
+                    ]
+                },
+                {
+                    "id": "SpeculationTargetHint",
+                    "description": "Corresponds to mojom::SpeculationTargetHint.\nSee https://github.com/WICG/nav-speculation/blob/main/triggers.md#window-name-targeting-hints",
+                    "type": "string",
+                    "enum": [
+                        "Blank",
+                        "Self"
+                    ]
+                },
+                {
+                    "id": "PreloadingAttemptKey",
+                    "description": "A key that identifies a preloading attempt.\n\nThe url used is the url specified by the trigger (i.e. the initial URL), and\nnot the final url that is navigated to. For example, prerendering allows\nsame-origin main frame navigations during the attempt, but the attempt is\nstill keyed with the initial URL.",
+                    "type": "object",
+                    "properties": [
+                        {
+                            "name": "loaderId",
+                            "$ref": "Network.LoaderId"
+                        },
+                        {
+                            "name": "action",
+                            "$ref": "SpeculationAction"
+                        },
+                        {
+                            "name": "url",
+                            "type": "string"
+                        },
+                        {
+                            "name": "targetHint",
+                            "optional": true,
+                            "$ref": "SpeculationTargetHint"
+                        }
+                    ]
+                },
+                {
+                    "id": "PreloadingAttemptSource",
+                    "description": "Lists sources for a preloading attempt, specifically the ids of rule sets\nthat had a speculation rule that triggered the attempt, and the\nBackendNodeIds of <a href> or <area href> elements that triggered the\nattempt (in the case of attempts triggered by a document rule). It is\npossible for mulitple rule sets and links to trigger a single attempt.",
+                    "type": "object",
+                    "properties": [
+                        {
+                            "name": "key",
+                            "$ref": "PreloadingAttemptKey"
+                        },
+                        {
+                            "name": "ruleSetIds",
+                            "type": "array",
+                            "items": {
+                                "$ref": "RuleSetId"
+                            }
+                        },
+                        {
+                            "name": "nodeIds",
+                            "type": "array",
+                            "items": {
+                                "$ref": "DOM.BackendNodeId"
+                            }
+                        }
+                    ]
+                },
                 {
                     "id": "PrerenderFinalStatus",
                     "description": "List of FinalStatus reasons for Prerender2.",
@@ -22957,6 +23023,19 @@
                             "$ref": "PreloadingStatus"
                         }
                     ]
+                },
+                {
+                    "name": "preloadingAttemptSourcesUpdated",
+                    "description": "Send a list of sources for all preloading attempts.",
+                    "parameters": [
+                        {
+                            "name": "preloadingAttemptSources",
+                            "type": "array",
+                            "items": {
+                                "$ref": "PreloadingAttemptSource"
+                            }
+                        }
+                    ]
                 }
             ]
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devtools-protocol",
-  "version": "0.0.1113120",
+  "version": "0.0.1114386",
   "description": "The Chrome DevTools Protocol JSON",
   "repository": "https://github.com/ChromeDevTools/devtools-protocol",
   "author": "The Chromium Authors",

package/pdl/browser_protocol.pdl

@@ -702,7 +702,6 @@ experimental domain Audits
   type AttributionReportingIssueType extends string
     enum
       PermissionPolicyDisabled
-      PermissionPolicyNotDelegated
       UntrustworthyReportingOrigin
       InsecureContext
       # TODO(apaseltiner): Rename this to InvalidRegisterSourceHeader
@@ -10742,6 +10741,45 @@ experimental domain Preload
       # - https://github.com/WICG/nav-speculation/blob/main/triggers.md
       string sourceText
 
+  # The type of preloading attempted. It corresponds to
+  # mojom::SpeculationAction (although PrefetchWithSubresources is omitted as it
+  # isn't being used by clients).
+  type SpeculationAction extends string
+    enum
+      Prefetch
+      Prerender
+
+  # Corresponds to mojom::SpeculationTargetHint.
+  # See https://github.com/WICG/nav-speculation/blob/main/triggers.md#window-name-targeting-hints
+  type SpeculationTargetHint extends string
+    enum
+      Blank
+      Self
+
+  # A key that identifies a preloading attempt.
+  #
+  # The url used is the url specified by the trigger (i.e. the initial URL), and
+  # not the final url that is navigated to. For example, prerendering allows
+  # same-origin main frame navigations during the attempt, but the attempt is
+  # still keyed with the initial URL.
+  type PreloadingAttemptKey extends object
+    properties
+      Network.LoaderId loaderId
+      SpeculationAction action
+      string url
+      optional SpeculationTargetHint targetHint
+
+  # Lists sources for a preloading attempt, specifically the ids of rule sets
+  # that had a speculation rule that triggered the attempt, and the
+  # BackendNodeIds of <a href> or <area href> elements that triggered the
+  # attempt (in the case of attempts triggered by a document rule). It is
+  # possible for mulitple rule sets and links to trigger a single attempt.
+  type PreloadingAttemptSource extends object
+    properties
+      PreloadingAttemptKey key
+      array of RuleSetId ruleSetIds
+      array of DOM.BackendNodeId nodeIds
+
   command enable
 
   command disable
@@ -10856,6 +10894,11 @@ experimental domain Preload
       string prerenderingUrl
       PreloadingStatus status
 
+  # Send a list of sources for all preloading attempts.
+  event preloadingAttemptSourcesUpdated
+    parameters
+      array of PreloadingAttemptSource preloadingAttemptSources
+
 # This domain allows interacting with the FedCM dialog.
 experimental domain FedCm
   event dialogShown

package/types/protocol-mapping.d.ts

@@ -722,6 +722,10 @@ export namespace ProtocolMapping {
          * Fired when a prerender attempt is updated.
          */
         'Preload.prerenderStatusUpdated': [Protocol.Preload.PrerenderStatusUpdatedEvent];
+        /**
+         * Send a list of sources for all preloading attempts.
+         */
+        'Preload.preloadingAttemptSourcesUpdated': [Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent];
         'FedCm.dialogShown': [];
     }
 

package/types/protocol-proxy-api.d.ts

@@ -3962,6 +3962,11 @@ export namespace ProtocolProxyApi {
          */
         on(event: 'prerenderStatusUpdated', listener: (params: Protocol.Preload.PrerenderStatusUpdatedEvent) => void): void;
 
+        /**
+         * Send a list of sources for all preloading attempts.
+         */
+        on(event: 'preloadingAttemptSourcesUpdated', listener: (params: Protocol.Preload.PreloadingAttemptSourcesUpdatedEvent) => void): void;
+
     }
 
     export interface FedCmApi {

package/types/protocol.d.ts

@@ -3409,7 +3409,7 @@ export namespace Protocol {
             clientSecurityState?: Network.ClientSecurityState;
         }
 
-        export type AttributionReportingIssueType = ('PermissionPolicyDisabled' | 'PermissionPolicyNotDelegated' | 'UntrustworthyReportingOrigin' | 'InsecureContext' | 'InvalidHeader' | 'InvalidRegisterTriggerHeader' | 'InvalidEligibleHeader' | 'TooManyConcurrentRequests' | 'SourceAndTriggerHeaders' | 'SourceIgnored' | 'TriggerIgnored');
+        export type AttributionReportingIssueType = ('PermissionPolicyDisabled' | 'UntrustworthyReportingOrigin' | 'InsecureContext' | 'InvalidHeader' | 'InvalidRegisterTriggerHeader' | 'InvalidEligibleHeader' | 'TooManyConcurrentRequests' | 'SourceAndTriggerHeaders' | 'SourceIgnored' | 'TriggerIgnored');
 
         /**
          * Details for issues around "Attribution Reporting API" usage.
@@ -16884,6 +16884,47 @@ export namespace Protocol {
             sourceText: string;
         }
 
+        /**
+         * The type of preloading attempted. It corresponds to
+         * mojom::SpeculationAction (although PrefetchWithSubresources is omitted as it
+         * isn't being used by clients).
+         */
+        export type SpeculationAction = ('Prefetch' | 'Prerender');
+
+        /**
+         * Corresponds to mojom::SpeculationTargetHint.
+         * See https://github.com/WICG/nav-speculation/blob/main/triggers.md#window-name-targeting-hints
+         */
+        export type SpeculationTargetHint = ('Blank' | 'Self');
+
+        /**
+         * A key that identifies a preloading attempt.
+         * 
+         * The url used is the url specified by the trigger (i.e. the initial URL), and
+         * not the final url that is navigated to. For example, prerendering allows
+         * same-origin main frame navigations during the attempt, but the attempt is
+         * still keyed with the initial URL.
+         */
+        export interface PreloadingAttemptKey {
+            loaderId: Network.LoaderId;
+            action: SpeculationAction;
+            url: string;
+            targetHint?: SpeculationTargetHint;
+        }
+
+        /**
+         * Lists sources for a preloading attempt, specifically the ids of rule sets
+         * that had a speculation rule that triggered the attempt, and the
+         * BackendNodeIds of <a href> or <area href> elements that triggered the
+         * attempt (in the case of attempts triggered by a document rule). It is
+         * possible for mulitple rule sets and links to trigger a single attempt.
+         */
+        export interface PreloadingAttemptSource {
+            key: PreloadingAttemptKey;
+            ruleSetIds: RuleSetId[];
+            nodeIds: DOM.BackendNodeId[];
+        }
+
         /**
          * List of FinalStatus reasons for Prerender2.
          */
@@ -16946,6 +16987,13 @@ export namespace Protocol {
             prerenderingUrl: string;
             status: PreloadingStatus;
         }
+
+        /**
+         * Send a list of sources for all preloading attempts.
+         */
+        export interface PreloadingAttemptSourcesUpdatedEvent {
+            preloadingAttemptSources: PreloadingAttemptSource[];
+        }
     }
 
     /**