@webref/idl 3.9.0 → 3.11.1

package/FedCM.idl

@@ -0,0 +1,40 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Federated Credential Management API (https://fedidcg.github.io/FedCM/)
+
+[Exposed=Window, SecureContext]
+dictionary FederatedAccountLoginRequest {
+  AbortSignal signal;
+  USVString nonce;
+};
+
+[Exposed=Window, SecureContext]
+partial interface FederatedCredential {
+  Promise<FederatedTokens> login(optional FederatedAccountLoginRequest request = {});
+};
+
+[Exposed=Window, SecureContext]
+dictionary FederatedTokens {
+  USVString idToken;
+};
+
+[Exposed=Window, SecureContext]
+partial interface FederatedCredential {
+  Promise<undefined> revoke(USVString hint);
+};
+
+[Exposed=Window, SecureContext]
+partial interface FederatedCredential {
+  Promise<undefined> logout();
+};
+
+dictionary FederatedCredentialLogoutRpsRequest {
+  required USVString url;
+  required USVString accountId;
+};
+
+[Exposed=Window, SecureContext]
+partial interface FederatedCredential {
+  static Promise<undefined> logoutRPs(sequence<FederatedCredentialLogoutRpsRequest> logoutRequests);
+};

package/{mediacapture-handle-identity.idl → capture-handle-identity.idl}

@@ -22,16 +22,6 @@ partial interface MediaStreamTrack {
   CaptureHandle? getCaptureHandle();
 };
 
-[Exposed=Window]
-interface CaptureHandleChangeEvent : Event {
-  constructor(optional CaptureHandleChangeEventInit init = {});
-  [SameObject] CaptureHandle captureHandle();
-};
-
-dictionary CaptureHandleChangeEventInit : EventInit {
-  CaptureHandle captureHandle;
-};
-
 partial interface MediaStreamTrack {
   attribute EventHandler oncapturehandlechange;
 };

package/conversion-measurement-api.idl

@@ -4,28 +4,9 @@
 // Source: Attribution Reporting (https://wicg.github.io/conversion-measurement-api/)
 
 partial interface HTMLAnchorElement {
-    [CEReactions] attribute USVString attributionDestination;
-    [CEReactions] attribute DOMString attributionSourceEventId;
-    [CEReactions] attribute USVString attributionReportTo;
-    [CEReactions] attribute long long attributionExpiry;
-    [CEReactions] attribute long long attributionSourcePriority;
-    [CEReactions] attribute boolean registerAttributionSource;
+    [CEReactions] attribute USVString attributionSrc;
 };
 
-dictionary AttributionSourceParams {
-  required USVString attributionDestination;
-  required DOMString attributionSourceEventId;
-  USVString attributionReportTo;
-  long long attributionExpiry;
-  long long attributionSourcePriority;
-};
-
-[Exposed=Window, SecureContext]
-interface AttributionReporting {
-  Promise<undefined> registerAttributionSource(AttributionSourceParams params);
-};
-
-[SecureContext]
-partial interface Window {
-  readonly attribute AttributionReporting attributionReporting;
+partial interface HTMLImageElement {
+    [CEReactions] attribute USVString attributionSrc;
 };

package/cssom-view.idl

@@ -101,7 +101,6 @@ dictionary ScrollIntoViewOptions : ScrollOptions {
 };
 
 dictionary IsVisibleOptions {
-    boolean checkAriaHidden = false;
     boolean checkInert = false;
     boolean checkOpacity = false;
     boolean checkVisibilityCSS = false;

package/fetch.idl

@@ -83,6 +83,7 @@ enum RequestRedirect { "follow", "error", "manual" };
 
   [NewObject] static Response error();
   [NewObject] static Response redirect(USVString url, optional unsigned short status = 302);
+  [NewObject] static Response json(any data, optional ResponseInit init = {});
 
   readonly attribute ResponseType type;
 

package/html.idl

@@ -192,7 +192,7 @@ interface HTMLLinkElement : HTMLElement {
   [CEReactions] attribute USVString href;
   [CEReactions] attribute DOMString? crossOrigin;
   [CEReactions] attribute DOMString rel;
-  [CEReactions] attribute DOMString as; // (default "")
+  [CEReactions] attribute DOMString as;
   [SameObject, PutForwards=value] readonly attribute DOMTokenList relList;
   [CEReactions] attribute DOMString media;
   [CEReactions] attribute DOMString integrity;

package/media-source.idl

@@ -25,14 +25,18 @@ interface MediaSource : EventTarget {
                     attribute EventHandler        onsourceended;
                     attribute EventHandler        onsourceclose;
     static readonly attribute boolean canConstructInDedicatedWorker;
-    SourceBuffer   addSourceBuffer (DOMString type);
-    undefined           removeSourceBuffer (SourceBuffer sourceBuffer);
-    undefined           endOfStream (optional EndOfStreamError error);
-    undefined           setLiveSeekableRange (double start, double end);
-    undefined           clearLiveSeekableRange ();
-    static boolean isTypeSupported (DOMString type);
+    SourceBuffer      addSourceBuffer (DOMString type);
+    undefined         removeSourceBuffer (SourceBuffer sourceBuffer);
+    undefined         endOfStream (optional EndOfStreamError error);
+    undefined         setLiveSeekableRange (double start, double end);
+    undefined         clearLiveSeekableRange ();
+    MediaSourceHandle getHandle ();
+    static boolean    isTypeSupported (DOMString type);
 };
 
+[Exposed=(Window,DedicatedWorker)]
+interface MediaSourceHandle {};
+
 enum AppendMode {
     "segments",
     "sequence"

package/mediacapture-viewport.idl

@@ -0,0 +1,9 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Viewport Capture (https://w3c.github.io/mediacapture-viewport/)
+
+partial interface MediaDevices {
+  Promise<MediaStream> getViewportMedia(
+      optional DisplayMediaStreamConstraints constraints = {});
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@webref/idl",
   "description": "Web IDL definitions of the web platform",
-  "version": "3.9.0",
+  "version": "3.11.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/w3c/webref.git"
@@ -12,6 +12,6 @@
   "license": "MIT",
   "main": "index.js",
   "peerDependencies": {
-    "webidl2": "^24.2.1"
+    "webidl2": "^24.2.2"
   }
 }

package/screen-capture.idl

@@ -12,10 +12,16 @@ enum SelfCapturePreferenceEnum {
   "exclude"
 };
 
+enum SystemAudioPreferenceEnum {
+  "include",
+  "exclude"
+};
+
 dictionary DisplayMediaStreamConstraints {
   (boolean or MediaTrackConstraints) video = true;
   (boolean or MediaTrackConstraints) audio = false;
   SelfCapturePreferenceEnum selfBrowserSurface;
+  SystemAudioPreferenceEnum systemAudio;
 };
 
 partial dictionary MediaTrackSupportedConstraints {

package/touch-events.idl

@@ -68,6 +68,7 @@ interface TouchEvent : UIEvent {
     readonly        attribute boolean   metaKey;
     readonly        attribute boolean   ctrlKey;
     readonly        attribute boolean   shiftKey;
+    getter boolean getModifierState (DOMString keyArg);
 };
 
 partial interface mixin GlobalEventHandlers {

package/webaudio.idl

@@ -92,7 +92,7 @@ dictionary AudioTimestamp {
 };
 
 [Exposed=Window]
-interface AudioRenderCapacity {
+interface AudioRenderCapacity : EventTarget {
   undefined start(optional AudioRenderCapacityOptions options = {});
     undefined stop();
     attribute EventHandler onupdate;
@@ -103,15 +103,21 @@ dictionary AudioRenderCapacityOptions {
 };
 
 [Exposed=Window]
-interface AudioRenderCapacityEvent {
-  constructor (DOMString type, double timestamp, double averageLoad,
-              double peakLoad, double underrunRatio);
+interface AudioRenderCapacityEvent : Event {
+  constructor (DOMString type, optional AudioRenderCapacityEventInit eventInitDict = {});
     readonly attribute double timestamp;
     readonly attribute double averageLoad;
     readonly attribute double peakLoad;
     readonly attribute double underrunRatio;
 };
 
+dictionary AudioRenderCapacityEventInit : EventInit {
+  double timestamp = 0;
+  double averageLoad = 0;
+  double peakLoad = 0;
+  double underrunRatio = 0;
+};
+
 [Exposed=Window]
 interface OfflineAudioContext : BaseAudioContext {
   constructor(OfflineAudioContextOptions contextOptions);

package/webgl1.idl

@@ -516,6 +516,8 @@ interface mixin WebGLRenderingContextBase
     readonly attribute (HTMLCanvasElement or OffscreenCanvas) canvas;
     readonly attribute GLsizei drawingBufferWidth;
     readonly attribute GLsizei drawingBufferHeight;
+    attribute PredefinedColorSpace drawingBufferColorSpace;
+    attribute PredefinedColorSpace unpackColorSpace;
 
     [WebGLHandlesContextLoss] WebGLContextAttributes? getContextAttributes();
     [WebGLHandlesContextLoss] boolean isContextLost();

package/webgpu.idl

@@ -46,6 +46,14 @@ interface GPUSupportedFeatures {
     readonly setlike<DOMString>;
 };
 
+[Exposed=(Window, DedicatedWorker), SecureContext]
+interface GPUAdapterInfo {
+  readonly attribute DOMString vendor;
+  readonly attribute DOMString architecture;
+  readonly attribute DOMString device;
+  readonly attribute DOMString description;
+};
+
 enum GPUPredefinedColorSpace {
     "srgb",
 };
@@ -59,6 +67,7 @@ WorkerNavigator includes NavigatorGPU;
 [Exposed=(Window, DedicatedWorker), SecureContext]
 interface GPU {
     Promise<GPUAdapter?> requestAdapter(optional GPURequestAdapterOptions options = {});
+    GPUTextureFormat getPreferredCanvasFormat();
 };
 
 dictionary GPURequestAdapterOptions {
@@ -73,12 +82,12 @@ enum GPUPowerPreference {
 
 [Exposed=(Window, DedicatedWorker), SecureContext]
 interface GPUAdapter {
-    readonly attribute DOMString name;
     [SameObject] readonly attribute GPUSupportedFeatures features;
     [SameObject] readonly attribute GPUSupportedLimits limits;
     readonly attribute boolean isFallbackAdapter;
 
     Promise<GPUDevice> requestDevice(optional GPUDeviceDescriptor descriptor = {});
+    Promise<GPUAdapterInfo> requestAdapterInfo(optional sequence<DOMString> unmaskHints = []);
 };
 
 dictionary GPUDeviceDescriptor : GPUObjectDescriptorBase {
@@ -97,6 +106,7 @@ enum GPUFeatureName {
     "timestamp-query",
     "indirect-first-instance",
     "shader-f16",
+    "bgra8unorm-storage",
 };
 
 [Exposed=(Window, DedicatedWorker), SecureContext]
@@ -420,14 +430,6 @@ dictionary GPUBindGroupLayoutDescriptor : GPUObjectDescriptorBase {
     required sequence<GPUBindGroupLayoutEntry> entries;
 };
 
-typedef [EnforceRange] unsigned long GPUShaderStageFlags;
-[Exposed=(Window, DedicatedWorker)]
-namespace GPUShaderStage {
-    const GPUFlagsConstant VERTEX   = 0x1;
-    const GPUFlagsConstant FRAGMENT = 0x2;
-    const GPUFlagsConstant COMPUTE  = 0x4;
-};
-
 dictionary GPUBindGroupLayoutEntry {
     required GPUIndex32 binding;
     required GPUShaderStageFlags visibility;
@@ -439,6 +441,14 @@ dictionary GPUBindGroupLayoutEntry {
     GPUExternalTextureBindingLayout externalTexture;
 };
 
+typedef [EnforceRange] unsigned long GPUShaderStageFlags;
+[Exposed=(Window, DedicatedWorker)]
+namespace GPUShaderStage {
+    const GPUFlagsConstant VERTEX   = 0x1;
+    const GPUFlagsConstant FRAGMENT = 0x2;
+    const GPUFlagsConstant COMPUTE  = 0x4;
+};
+
 enum GPUBufferBindingType {
     "uniform",
     "storage",
@@ -526,16 +536,16 @@ interface GPUShaderModule {
 };
 GPUShaderModule includes GPUObjectBase;
 
-dictionary GPUShaderModuleCompilationHint {
-    required GPUPipelineLayout layout;
-};
-
 dictionary GPUShaderModuleDescriptor : GPUObjectDescriptorBase {
     required USVString code;
     object sourceMap;
     record<USVString, GPUShaderModuleCompilationHint> hints;
 };
 
+dictionary GPUShaderModuleCompilationHint {
+    (GPUPipelineLayout or GPUAutoLayoutMode) layout;
+};
+
 enum GPUCompilationMessageType {
     "error",
     "warning",
@@ -557,12 +567,16 @@ interface GPUCompilationInfo {
     readonly attribute FrozenArray<GPUCompilationMessage> messages;
 };
 
+enum GPUAutoLayoutMode {
+    "auto",
+};
+
 dictionary GPUPipelineDescriptorBase : GPUObjectDescriptorBase {
-    GPUPipelineLayout layout;
+    required (GPUPipelineLayout or GPUAutoLayoutMode) layout;
 };
 
 interface mixin GPUPipelineBase {
-    GPUBindGroupLayout getBindGroupLayout(unsigned long index);
+    [NewObject] GPUBindGroupLayout getBindGroupLayout(unsigned long index);
 };
 
 dictionary GPUProgrammableStage {
@@ -597,14 +611,6 @@ dictionary GPURenderPipelineDescriptor : GPUPipelineDescriptorBase {
     GPUFragmentState fragment;
 };
 
-enum GPUPrimitiveTopology {
-    "point-list",
-    "line-list",
-    "line-strip",
-    "triangle-list",
-    "triangle-strip",
-};
-
 dictionary GPUPrimitiveState {
     GPUPrimitiveTopology topology = "triangle-list";
     GPUIndexFormat stripIndexFormat;
@@ -615,6 +621,14 @@ dictionary GPUPrimitiveState {
     boolean unclippedDepth = false;
 };
 
+enum GPUPrimitiveTopology {
+    "point-list",
+    "line-list",
+    "line-strip",
+    "triangle-list",
+    "triangle-strip",
+};
+
 enum GPUFrontFace {
     "ccw",
     "cw",
@@ -1093,7 +1107,6 @@ interface GPUCanvasContext {
     undefined configure(GPUCanvasConfiguration configuration);
     undefined unconfigure();
 
-    GPUTextureFormat getPreferredFormat(GPUAdapter adapter);
     GPUTexture getCurrentTexture();
 };
 
@@ -1109,7 +1122,6 @@ dictionary GPUCanvasConfiguration {
     sequence<GPUTextureFormat> viewFormats = [];
     GPUPredefinedColorSpace colorSpace = "srgb";
     GPUCanvasCompositingAlphaMode compositingAlphaMode = "opaque";
-    GPUExtent3D size;
 };
 
 enum GPUDeviceLostReason {
@@ -1132,17 +1144,19 @@ enum GPUErrorFilter {
 };
 
 [Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUOutOfMemoryError {
-    constructor();
+interface GPUError {
+    readonly attribute DOMString message;
 };
 
 [Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUValidationError {
+interface GPUOutOfMemoryError : GPUError {
     constructor(DOMString message);
-    readonly attribute DOMString message;
 };
 
-typedef (GPUOutOfMemoryError or GPUValidationError) GPUError;
+[Exposed=(Window, DedicatedWorker), SecureContext]
+interface GPUValidationError : GPUError {
+    constructor(DOMString message);
+};
 
 partial interface GPUDevice {
     undefined pushErrorScope(GPUErrorFilter filter);

package/webnn.idl

@@ -9,10 +9,9 @@ interface mixin NavigatorML {
 Navigator includes NavigatorML;
 WorkerNavigator includes NavigatorML;
 
-enum MLDevicePreference {
-  "default",
-  "gpu",
-  "cpu"
+enum MLDeviceType {
+  "cpu",
+  "gpu"
 };
 
 enum MLPowerPreference {
@@ -22,20 +21,43 @@ enum MLPowerPreference {
 };
 
 dictionary MLContextOptions {
-  MLDevicePreference devicePreference = "default";
+  MLDeviceType deviceType = "cpu";
   MLPowerPreference powerPreference = "default";
 };
 
 [SecureContext, Exposed=(Window, DedicatedWorker)]
 interface ML {
   MLContext createContext(optional MLContextOptions options = {});
-  MLContext createContext(WebGLRenderingContext glContext);
   MLContext createContext(GPUDevice gpuDevice);
+  MLContext createContext(WebGLRenderingContext glContext);
+};
+
+dictionary MLArrayInput {
+  required ArrayBufferView resource;
+  required sequence<long> dimensions;
 };
 
+typedef record<DOMString, (ArrayBufferView or MLArrayInput)> MLNamedArrayInputs;
+typedef record<DOMString, ArrayBufferView> MLNamedArrayOutputs;
+
 [SecureContext, Exposed=(Window, DedicatedWorker)]
 interface MLContext {};
 
+partial interface MLContext {
+  [Exposed=(DedicatedWorker)]
+  undefined compute(MLGraph graph, MLNamedArrayInputs inputs, MLNamedArrayOutputs outputs);
+};
+
+partial interface MLContext {
+  Promise<undefined> computeAsync(MLGraph graph, MLNamedArrayInputs inputs,
+
+                    MLNamedArrayOutputs outputs);
+};
+
+partial interface MLContext {
+  MLCommandEncoder createCommandEncoder();
+};
+
 enum MLInputOperandLayout {
   "nchw",
   "nhwc"
@@ -89,8 +111,12 @@ interface MLGraphBuilder {
   // Create a single-value operand from the specified number of the specified type.
   MLOperand constant(double value, optional MLOperandType type = "float32");
 
-  // Compile the graph up to the specified output operands
+  // Compile the graph up to the specified output operands synchronously.
+  [Exposed=(DedicatedWorker)]
   MLGraph build(MLNamedOperands outputs);
+
+  // Compile the graph up to the specified output operands asynchronously.
+  Promise<MLGraph> buildAsync(MLNamedOperands outputs);
 };
 
 dictionary MLBatchNormalizationOptions {
@@ -454,17 +480,30 @@ partial interface MLGraphBuilder {
   MLOperand transpose(MLOperand input, optional MLTransposeOptions options = {});
 };
 
-typedef (MLBufferView or WebGLTexture or GPUTexture) MLResource;
+[SecureContext, Exposed=(Window, DedicatedWorker)]
+interface MLGraph {};
+
+typedef (GPUBuffer or GPUTexture) MLGPUResource;
 
-dictionary MLInput {
-  required MLResource resource;
+dictionary MLGPUInput {
+  required MLGPUResource resource;
   required sequence<long> dimensions;
 };
 
-typedef record<DOMString, (MLResource or MLInput)> MLNamedInputs;
-typedef record<DOMString, MLResource> MLNamedOutputs;
+typedef record<DOMString, (MLGPUResource or MLGPUInput)> MLNamedGPUInputs;
+typedef record<DOMString, MLGPUResource> MLNamedGPUOutputs;
 
 [SecureContext, Exposed=(Window, DedicatedWorker)]
-interface MLGraph {
-  undefined compute(MLNamedInputs inputs, MLNamedOutputs outputs);
+interface MLCommandEncoder {};
+
+partial interface MLCommandEncoder {
+  undefined initializeGraph(MLGraph graph);
+};
+
+partial interface MLCommandEncoder {
+  undefined dispatch(MLGraph graph, MLNamedGPUInputs inputs, MLNamedGPUOutputs outputs);
+};
+
+partial interface MLCommandEncoder {
+  GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {});
 };

package/webrtc-encoded-transform.idl

@@ -120,7 +120,7 @@ interface RTCRtpScriptTransformer {
     readonly attribute ReadableStream readable;
     readonly attribute WritableStream writable;
     readonly attribute any options;
-    Promise<undefined> generateKeyFrame(optional sequence <DOMString> rids);
+    Promise<unsigned long long> generateKeyFrame(optional DOMString rid);
     Promise<undefined> sendKeyFrameRequest();
 };