@webref/idl 3.51.0 → 3.52.1

package/EXT_disjoint_timer_query.idl

@@ -19,7 +19,7 @@ interface EXT_disjoint_timer_query {
   const GLenum TIMESTAMP_EXT               = 0x8E28;
   const GLenum GPU_DISJOINT_EXT            = 0x8FBB;
 
-  WebGLTimerQueryEXT? createQueryEXT();
+  WebGLTimerQueryEXT createQueryEXT();
   undefined deleteQueryEXT(WebGLTimerQueryEXT? query);
   [WebGLHandlesContextLoss] boolean isQueryEXT(WebGLTimerQueryEXT? query);
   undefined beginQueryEXT(GLenum target, WebGLTimerQueryEXT query);

package/OES_vertex_array_object.idl

@@ -11,7 +11,7 @@ interface WebGLVertexArrayObjectOES : WebGLObject {
 interface OES_vertex_array_object {
     const GLenum VERTEX_ARRAY_BINDING_OES = 0x85B5;
 
-    WebGLVertexArrayObjectOES? createVertexArrayOES();
+    WebGLVertexArrayObjectOES createVertexArrayOES();
     undefined deleteVertexArrayOES(WebGLVertexArrayObjectOES? arrayObject);
     [WebGLHandlesContextLoss] GLboolean isVertexArrayOES(WebGLVertexArrayObjectOES? arrayObject);
     undefined bindVertexArrayOES(WebGLVertexArrayObjectOES? arrayObject);

package/css-anchor-position.idl

@@ -79,6 +79,6 @@ interface CSSPositionTryDescriptors : CSSStyleDeclaration {
   attribute CSSOMString justify-self;
   attribute CSSOMString positionAnchor;
   attribute CSSOMString position-anchor;
-  attribute CSSOMString insetArea;
-  attribute CSSOMString inset-area;
+  attribute CSSOMString positionArea;
+  attribute CSSOMString position-area;
 };

package/css-conditional.idl

@@ -15,10 +15,12 @@ interface CSSConditionRule : CSSGroupingRule {
 [Exposed=Window]
 interface CSSMediaRule : CSSConditionRule {
     [SameObject, PutForwards=mediaText] readonly attribute MediaList media;
+    readonly attribute boolean matches;
 };
 
 [Exposed=Window]
 interface CSSSupportsRule : CSSConditionRule {
+  readonly attribute boolean matches;
 };
 
 partial namespace CSS {

package/css-font-loading.idl

@@ -97,8 +97,6 @@ enum FontFaceSetLoadStatus { "loading", "loaded" };
 
 [Exposed=(Window,Worker)]
 interface FontFaceSet : EventTarget {
-  constructor(sequence<FontFace> initialFaces);
-
   setlike<FontFace>;
   FontFaceSet add(FontFace font);
   boolean delete(FontFace font);

package/css-mixins.idl

@@ -0,0 +1,7 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: CSS Functions and Mixins Module (https://drafts.csswg.org/css-mixins-1/)
+
+[Exposed=Window]
+interface CSSFunctionRule : CSSGroupingRule { };

package/css-view-transitions-2.idl

@@ -3,10 +3,6 @@
 // (https://github.com/w3c/webref)
 // Source: CSS View Transitions Module Level 2 (https://drafts.csswg.org/css-view-transitions-2/)
 
-partial interface CSSRule {
-  const unsigned short VIEW_TRANSITION_RULE = 15;
-};
-
 enum ViewTransitionNavigation { "auto", "none" };
 
 [Exposed=Window]

package/html.idl

@@ -1411,8 +1411,6 @@ interface mixin CanvasDrawPath {
 interface mixin CanvasUserInterface {
   undefined drawFocusIfNeeded(Element element);
   undefined drawFocusIfNeeded(Path2D path, Element element);
-  undefined scrollPathIntoView();
-  undefined scrollPathIntoView(Path2D path);
 };
 
 interface mixin CanvasText {

package/mediasession.idl

@@ -30,7 +30,8 @@ enum MediaSessionAction {
   "hangup",
   "previousslide",
   "nextslide",
-  "enterpictureinpicture"
+  "enterpictureinpicture",
+  "voiceactivity"
 };
 
 callback MediaSessionActionHandler = undefined(MediaSessionActionDetails details);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@webref/idl",
   "description": "Web IDL definitions of the web platform",
-  "version": "3.51.0",
+  "version": "3.52.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/w3c/webref.git"

package/shared-storage.idl

@@ -5,6 +5,8 @@
 
 typedef (USVString or FencedFrameConfig) SharedStorageResponse;
 
+enum SharedStorageDataOrigin { "context-origin", "script-origin" };
+
 [Exposed=(Window)]
 interface SharedStorageWorklet : Worklet {
   Promise<SharedStorageResponse> selectURL(DOMString name,
@@ -52,7 +54,7 @@ interface WindowSharedStorage : SharedStorage {
   Promise<any> run(DOMString name,
                    optional SharedStorageRunOperationMethodOptions options = {});
 
-  Promise<SharedStorageWorklet> createWorklet(USVString moduleURL, optional WorkletOptions options = {});
+  Promise<SharedStorageWorklet> createWorklet(USVString moduleURL, optional SharedStorageWorkletOptions options = {});
 
   readonly attribute SharedStorageWorklet worklet;
 };
@@ -63,6 +65,10 @@ dictionary SharedStorageRunOperationMethodOptions {
   boolean keepAlive = false;
 };
 
+dictionary SharedStorageWorkletOptions : WorkletOptions {
+  SharedStorageDataOrigin dataOrigin = "context-origin";
+};
+
 partial interface Window {
   [SecureContext] readonly attribute WindowSharedStorage? sharedStorage;
 };

package/turtledove.idl

@@ -67,6 +67,10 @@ partial interface Navigator {
   readonly attribute boolean deprecatedRunAdAuctionEnforcesKAnonymity;
 };
 
+dictionary AuctionRealTimeReportingConfig {
+  required DOMString type;
+};
+
 dictionary AuctionAdConfig {
   required USVString seller;
   required USVString decisionLogicURL;
@@ -95,6 +99,8 @@ dictionary AuctionAdConfig {
   sequence<record<DOMString, DOMString>> allSlotsRequestedSizes;
   Promise<undefined> additionalBids;
   DOMString auctionNonce;
+  AuctionRealTimeReportingConfig sellerRealTimeReportingConfig;
+  record<USVString, AuctionRealTimeReportingConfig> perBuyerRealTimeReportingConfig;
   sequence<AuctionAdConfig> componentAuctions = [];
   AbortSignal? signal;
   Promise<boolean> resolveToConfig;
@@ -120,11 +126,22 @@ interface ForDebuggingOnly {
   undefined reportAdAuctionLoss(USVString url);
 };
 
+[Exposed=InterestGroupBiddingAndScoringScriptRunnerGlobalScope]
+interface RealTimeReporting {
+  undefined contributeToHistogram(RealTimeContribution contribution);
+};
+
+dictionary RealTimeContribution {
+  required long bucket;
+  required double priorityWeight;
+  long latencyThreshold;
+};
+
 [Exposed=InterestGroupBiddingAndScoringScriptRunnerGlobalScope,
  Global=InterestGroupBiddingAndScoringScriptRunnerGlobalScope]
 interface InterestGroupBiddingAndScoringScriptRunnerGlobalScope : InterestGroupScriptRunnerGlobalScope {
-
   readonly attribute ForDebuggingOnly forDebuggingOnly;
+  readonly attribute RealTimeReporting realTimeReporting;
 };
 
 [Exposed=InterestGroupBiddingScriptRunnerGlobalScope,
@@ -215,6 +232,7 @@ dictionary BiddingBrowserSignals {
   sequence<PreviousWin> prevWinsMs;
   object wasmHelper;
   unsigned long dataVersion;
+  unsigned long crossOriginDataVersion;
   boolean forDebuggingOnlyInCooldownOrLockout = false;
 };
 
@@ -227,6 +245,7 @@ dictionary ScoringBrowserSignals {
 
   record<DOMString, DOMString> renderSize;
   unsigned long dataVersion;
+  unsigned long crossOriginDataVersion;
   sequence<USVString> adComponents;
   boolean forDebuggingOnlyInCooldownOrLockout = false;
 };

package/webaudio.idl

@@ -82,6 +82,7 @@ interface AudioContext : BaseAudioContext {
     [SecureContext] readonly attribute (DOMString or AudioSinkInfo) sinkId;
     [SecureContext] readonly attribute AudioRenderCapacity renderCapacity;
     attribute EventHandler onsinkchange;
+    attribute EventHandler onerror;
     AudioTimestamp getOutputTimestamp ();
     Promise<undefined> resume ();
     Promise<undefined> suspend ();

package/webauthn.idl

@@ -38,7 +38,7 @@ dictionary AuthenticatorAttestationResponseJSON {
     // algorithm then the public key must be parsed directly from
     // attestationObject or authenticatorData.
     Base64URLString publicKey;
-    required long long publicKeyAlgorithm;
+    required COSEAlgorithmIdentifier publicKeyAlgorithm;
     // This value contains copies of some of the fields above. See
     // section “Easily accessing credential data”.
     required Base64URLString attestationObject;
@@ -272,6 +272,7 @@ enum ClientCapability {
     "hybridTransport",
     "passkeyPlatformAuthenticator",
     "userVerifyingPlatformAuthenticator",
+    "relatedOrigins"
 };
 
 enum PublicKeyCredentialHints {

package/webcodecs.idl

@@ -488,7 +488,7 @@ interface ImageDecoder {
   static Promise<boolean> isTypeSupported(DOMString type);
 };
 
-typedef (BufferSource or ReadableStream) ImageBufferSource;
+typedef (AllowSharedBufferSource or ReadableStream) ImageBufferSource;
 dictionary ImageDecoderInit {
   required DOMString type;
   required ImageBufferSource data;

package/webgl1.idl

@@ -561,12 +561,12 @@ interface mixin WebGLRenderingContextBase
     undefined copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
                                 GLint x, GLint y, GLsizei width, GLsizei height);
 
-    WebGLBuffer? createBuffer();
-    WebGLFramebuffer? createFramebuffer();
-    WebGLProgram? createProgram();
-    WebGLRenderbuffer? createRenderbuffer();
+    WebGLBuffer createBuffer();
+    WebGLFramebuffer createFramebuffer();
+    WebGLProgram createProgram();
+    WebGLRenderbuffer createRenderbuffer();
     WebGLShader? createShader(GLenum type);
-    WebGLTexture? createTexture();
+    WebGLTexture createTexture();
 
     undefined cullFace(GLenum mode);
 

package/webgl2.idl

@@ -423,7 +423,7 @@ interface mixin WebGL2RenderingContextBase
   undefined clearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
 
   /* Query Objects */
-  WebGLQuery? createQuery();
+  WebGLQuery createQuery();
   undefined deleteQuery(WebGLQuery? query);
   [WebGLHandlesContextLoss] GLboolean isQuery(WebGLQuery? query);
   undefined beginQuery(GLenum target, WebGLQuery query);
@@ -432,7 +432,7 @@ interface mixin WebGL2RenderingContextBase
   any getQueryParameter(WebGLQuery query, GLenum pname);
 
   /* Sampler Objects */
-  WebGLSampler? createSampler();
+  WebGLSampler createSampler();
   undefined deleteSampler(WebGLSampler? sampler);
   [WebGLHandlesContextLoss] GLboolean isSampler(WebGLSampler? sampler);
   undefined bindSampler(GLuint unit, WebGLSampler? sampler);
@@ -449,7 +449,7 @@ interface mixin WebGL2RenderingContextBase
   any getSyncParameter(WebGLSync sync, GLenum pname);
 
   /* Transform Feedback */
-  WebGLTransformFeedback? createTransformFeedback();
+  WebGLTransformFeedback createTransformFeedback();
   undefined deleteTransformFeedback(WebGLTransformFeedback? tf);
   [WebGLHandlesContextLoss] GLboolean isTransformFeedback(WebGLTransformFeedback? tf);
   undefined bindTransformFeedback (GLenum target, WebGLTransformFeedback? tf);
@@ -472,7 +472,7 @@ interface mixin WebGL2RenderingContextBase
   undefined uniformBlockBinding(WebGLProgram program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
 
   /* Vertex Array Objects */
-  WebGLVertexArrayObject? createVertexArray();
+  WebGLVertexArrayObject createVertexArray();
   undefined deleteVertexArray(WebGLVertexArrayObject? vertexArray);
   [WebGLHandlesContextLoss] GLboolean isVertexArray(WebGLVertexArrayObject? vertexArray);
   undefined bindVertexArray(WebGLVertexArrayObject? array);

package/webgpu.idl

@@ -109,6 +109,7 @@ enum GPUFeatureName {
     "depth-clip-control",
     "depth32float-stencil8",
     "texture-compression-bc",
+    "texture-compression-bc-sliced-3d",
     "texture-compression-etc2",
     "texture-compression-astc",
     "timestamp-query",

package/webnn.idl

@@ -75,10 +75,11 @@ interface MLOperand {
   sequence<unsigned long> shape();
 };
 
-typedef (bigint or unrestricted double) MLNumber;
+dictionary MLOperatorOptions {
+  USVString label = "";
+};
 
-[SecureContext, Exposed=(Window, DedicatedWorker)]
-interface MLActivation {};
+typedef (bigint or unrestricted double) MLNumber;
 
 typedef record<USVString, MLOperand> MLNamedOperands;
 
@@ -100,18 +101,19 @@ interface MLGraphBuilder {
   Promise<MLGraph> build(MLNamedOperands outputs);
 };
 
-dictionary MLArgMinMaxOptions {
-  sequence<[EnforceRange] unsigned long> axes;
+dictionary MLArgMinMaxOptions : MLOperatorOptions {
   boolean keepDimensions = false;
-  boolean selectLastIndex = false;
+  MLOperandDataType outputDataType = "int32";
 };
 
 partial interface MLGraphBuilder {
-  MLOperand argMin(MLOperand input, optional MLArgMinMaxOptions options = {});
-  MLOperand argMax(MLOperand input, optional MLArgMinMaxOptions options = {});
+  MLOperand argMin(MLOperand input, [EnforceRange] unsigned long axis,
+                   optional MLArgMinMaxOptions options = {});
+  MLOperand argMax(MLOperand input, [EnforceRange] unsigned long axis,
+                   optional MLArgMinMaxOptions options = {});
 };
 
-dictionary MLBatchNormalizationOptions {
+dictionary MLBatchNormalizationOptions : MLOperatorOptions {
   MLOperand scale;
   MLOperand bias;
   [EnforceRange] unsigned long axis = 1;
@@ -124,10 +126,12 @@ partial interface MLGraphBuilder {
 };
 
 partial interface MLGraphBuilder {
-  MLOperand cast(MLOperand input, MLOperandDataType type);
+  MLOperand cast(MLOperand input,
+                 MLOperandDataType type,
+                 optional MLOperatorOptions options = {});
 };
 
-dictionary MLClampOptions {
+dictionary MLClampOptions : MLOperatorOptions {
   MLNumber minValue;
   MLNumber maxValue;
 };
@@ -137,7 +141,9 @@ partial interface MLGraphBuilder {
 };
 
 partial interface MLGraphBuilder {
-  MLOperand concat(sequence<MLOperand> inputs, [EnforceRange] unsigned long axis);
+  MLOperand concat(sequence<MLOperand> inputs,
+                   [EnforceRange] unsigned long axis,
+                   optional MLOperatorOptions options = {});
 };
 
 enum MLConv2dFilterOperandLayout {
@@ -147,7 +153,7 @@ enum MLConv2dFilterOperandLayout {
   "ihwo"
 };
 
-dictionary MLConv2dOptions {
+dictionary MLConv2dOptions : MLOperatorOptions {
   sequence<[EnforceRange] unsigned long> padding;
   sequence<[EnforceRange] unsigned long> strides;
   sequence<[EnforceRange] unsigned long> dilations;
@@ -169,7 +175,7 @@ enum MLConvTranspose2dFilterOperandLayout {
   "ohwi"
 };
 
-dictionary MLConvTranspose2dOptions {
+dictionary MLConvTranspose2dOptions : MLOperatorOptions {
   sequence<[EnforceRange] unsigned long> padding;
   sequence<[EnforceRange] unsigned long> strides;
   sequence<[EnforceRange] unsigned long> dilations;
@@ -187,54 +193,65 @@ partial interface MLGraphBuilder {
 };
 
 partial interface MLGraphBuilder {
-  MLOperand add(MLOperand a, MLOperand b);
-  MLOperand sub(MLOperand a, MLOperand b);
-  MLOperand mul(MLOperand a, MLOperand b);
-  MLOperand div(MLOperand a, MLOperand b);
-  MLOperand max(MLOperand a, MLOperand b);
-  MLOperand min(MLOperand a, MLOperand b);
-  MLOperand pow(MLOperand a, MLOperand b);
-};
-
-partial interface MLGraphBuilder {
-  MLOperand equal(MLOperand a, MLOperand b);
-  MLOperand greater(MLOperand a, MLOperand b);
-  MLOperand greaterOrEqual(MLOperand a, MLOperand b);
-  MLOperand lesser(MLOperand a, MLOperand b);
-  MLOperand lesserOrEqual(MLOperand a, MLOperand b);
-  MLOperand logicalNot(MLOperand a);
-};
-
-partial interface MLGraphBuilder {
-  MLOperand abs(MLOperand input);
-  MLOperand ceil(MLOperand input);
-  MLOperand cos(MLOperand input);
-  MLOperand erf(MLOperand input);
-  MLOperand exp(MLOperand input);
-  MLOperand floor(MLOperand input);
-  MLOperand identity(MLOperand input);
-  MLOperand log(MLOperand input);
-  MLOperand neg(MLOperand input);
-  MLOperand reciprocal(MLOperand input);
-  MLOperand sin(MLOperand input);
-  MLOperand sqrt(MLOperand input);
-  MLOperand tan(MLOperand input);
-};
-
-dictionary MLEluOptions {
+  MLOperand add(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
+  MLOperand sub(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
+  MLOperand mul(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
+  MLOperand div(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
+  MLOperand max(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
+  MLOperand min(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
+  MLOperand pow(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
+};
+
+partial interface MLGraphBuilder {
+  MLOperand equal(MLOperand a,
+                  MLOperand b,
+                  optional MLOperatorOptions options = {});
+  MLOperand greater(MLOperand a,
+                    MLOperand b,
+                    optional MLOperatorOptions options = {});
+  MLOperand greaterOrEqual(MLOperand a,
+                           MLOperand b,
+                           optional MLOperatorOptions options = {});
+  MLOperand lesser(MLOperand a,
+                   MLOperand b,
+                   optional MLOperatorOptions options = {});
+  MLOperand lesserOrEqual(MLOperand a,
+                          MLOperand b,
+                          optional MLOperatorOptions options = {});
+  MLOperand logicalNot(MLOperand a, optional MLOperatorOptions options = {});
+};
+
+partial interface MLGraphBuilder {
+  MLOperand abs(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand ceil(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand cos(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand erf(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand exp(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand floor(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand identity(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand log(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand neg(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand reciprocal(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand sin(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand sqrt(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand tan(MLOperand input, optional MLOperatorOptions options = {});
+};
+
+dictionary MLEluOptions : MLOperatorOptions {
   double alpha = 1;
 };
 
 partial interface MLGraphBuilder {
   MLOperand elu(MLOperand input, optional MLEluOptions options = {});
-  MLActivation elu(optional MLEluOptions options = {});
 };
 
 partial interface MLGraphBuilder {
-  MLOperand expand(MLOperand input, sequence<[EnforceRange] unsigned long> newShape);
+  MLOperand expand(MLOperand input,
+                   sequence<[EnforceRange] unsigned long> newShape,
+                   optional MLOperatorOptions options = {});
 };
 
-dictionary MLGatherOptions {
+dictionary MLGatherOptions : MLOperatorOptions {
   [EnforceRange] unsigned long axis = 0;
 };
 
@@ -245,11 +262,10 @@ partial interface MLGraphBuilder {
 };
 
 partial interface MLGraphBuilder {
-  MLOperand gelu(MLOperand input);
-  MLActivation gelu();
+  MLOperand gelu(MLOperand input, optional MLOperatorOptions options = {});
 };
 
-dictionary MLGemmOptions {
+dictionary MLGemmOptions : MLOperatorOptions {
   MLOperand c;
   double alpha = 1.0;
   double beta = 1.0;
@@ -266,13 +282,19 @@ enum MLGruWeightLayout {
   "rzn"   // reset-update-new gate ordering
 };
 
+enum MLRecurrentNetworkActivation {
+  "relu",
+  "sigmoid",
+  "tanh"
+};
+
 enum MLRecurrentNetworkDirection {
   "forward",
   "backward",
   "both"
 };
 
-dictionary MLGruOptions {
+dictionary MLGruOptions : MLOperatorOptions {
   MLOperand bias;
   MLOperand recurrentBias;
   MLOperand initialHiddenState;
@@ -280,7 +302,7 @@ dictionary MLGruOptions {
   boolean returnSequence = false;
   MLRecurrentNetworkDirection direction = "forward";
   MLGruWeightLayout layout = "zrn";
-  sequence<MLActivation> activations;
+  sequence<MLRecurrentNetworkActivation> activations;
 };
 
 partial interface MLGraphBuilder {
@@ -292,12 +314,12 @@ partial interface MLGraphBuilder {
                           optional MLGruOptions options = {});
 };
 
-dictionary MLGruCellOptions {
+dictionary MLGruCellOptions : MLOperatorOptions {
   MLOperand bias;
   MLOperand recurrentBias;
   boolean resetAfter = true;
   MLGruWeightLayout layout = "zrn";
-  sequence<MLActivation> activations;
+  sequence<MLRecurrentNetworkActivation> activations;
 };
 
 partial interface MLGraphBuilder {
@@ -309,22 +331,20 @@ partial interface MLGraphBuilder {
                     optional MLGruCellOptions options = {});
 };
 
-dictionary MLHardSigmoidOptions {
+dictionary MLHardSigmoidOptions : MLOperatorOptions {
   double alpha = 0.2;
   double beta = 0.5;
 };
 
 partial interface MLGraphBuilder {
   MLOperand hardSigmoid(MLOperand input, optional MLHardSigmoidOptions options = {});
-  MLActivation hardSigmoid(optional MLHardSigmoidOptions options = {});
 };
 
 partial interface MLGraphBuilder {
-  MLOperand hardSwish(MLOperand input);
-  MLActivation hardSwish();
+  MLOperand hardSwish(MLOperand input, optional MLOperatorOptions options = {});
 };
 
-dictionary MLInstanceNormalizationOptions {
+dictionary MLInstanceNormalizationOptions : MLOperatorOptions {
   MLOperand scale;
   MLOperand bias;
   double epsilon = 1e-5;
@@ -336,7 +356,7 @@ partial interface MLGraphBuilder {
                                   optional MLInstanceNormalizationOptions options = {});
 };
 
-dictionary MLLayerNormalizationOptions {
+dictionary MLLayerNormalizationOptions : MLOperatorOptions {
   MLOperand scale;
   MLOperand bias;
   sequence<[EnforceRange] unsigned long> axes;
@@ -348,23 +368,21 @@ partial interface MLGraphBuilder {
                                optional MLLayerNormalizationOptions options = {});
 };
 
-dictionary MLLeakyReluOptions {
+dictionary MLLeakyReluOptions : MLOperatorOptions {
   double alpha = 0.01;
 };
 
 partial interface MLGraphBuilder {
   MLOperand leakyRelu(MLOperand input, optional MLLeakyReluOptions options = {});
-  MLActivation leakyRelu(optional MLLeakyReluOptions options = {});
 };
 
-dictionary MLLinearOptions {
+dictionary MLLinearOptions : MLOperatorOptions {
   double alpha = 1;
   double beta = 0;
 };
 
 partial interface MLGraphBuilder {
   MLOperand linear(MLOperand input, optional MLLinearOptions options = {});
-  MLActivation linear(optional MLLinearOptions options = {});
 };
 
 enum MLLstmWeightLayout {
@@ -372,7 +390,7 @@ enum MLLstmWeightLayout {
   "ifgo"  // input-forget-cell-output gate ordering
 };
 
-dictionary MLLstmOptions {
+dictionary MLLstmOptions : MLOperatorOptions {
   MLOperand bias;
   MLOperand recurrentBias;
   MLOperand peepholeWeight;
@@ -381,7 +399,7 @@ dictionary MLLstmOptions {
   boolean returnSequence = false;
   MLRecurrentNetworkDirection direction = "forward";
   MLLstmWeightLayout layout = "iofg";
-  sequence<MLActivation> activations;
+  sequence<MLRecurrentNetworkActivation> activations;
 };
 
 partial interface MLGraphBuilder {
@@ -393,12 +411,12 @@ partial interface MLGraphBuilder {
                            optional MLLstmOptions options = {});
 };
 
-dictionary MLLstmCellOptions {
+dictionary MLLstmCellOptions : MLOperatorOptions {
   MLOperand bias;
   MLOperand recurrentBias;
   MLOperand peepholeWeight;
   MLLstmWeightLayout layout = "iofg";
-  sequence<MLActivation> activations;
+  sequence<MLRecurrentNetworkActivation> activations;
 };
 
 partial interface MLGraphBuilder {
@@ -412,7 +430,7 @@ partial interface MLGraphBuilder {
 };
 
 partial interface MLGraphBuilder {
-  MLOperand matmul(MLOperand a, MLOperand b);
+  MLOperand matmul(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
 };
 
 enum MLPaddingMode {
@@ -422,7 +440,7 @@ enum MLPaddingMode {
   "symmetric"
 };
 
-dictionary MLPadOptions {
+dictionary MLPadOptions : MLOperatorOptions {
   MLPaddingMode mode = "constant";
   MLNumber value = 0;
 };
@@ -439,7 +457,7 @@ enum MLRoundingType {
   "ceil"
 };
 
-dictionary MLPool2dOptions {
+dictionary MLPool2dOptions : MLOperatorOptions {
   sequence<[EnforceRange] unsigned long> windowDimensions;
   sequence<[EnforceRange] unsigned long> padding;
   sequence<[EnforceRange] unsigned long> strides;
@@ -456,10 +474,12 @@ partial interface MLGraphBuilder {
 };
 
 partial interface MLGraphBuilder {
-  MLOperand prelu(MLOperand input, MLOperand slope);
+  MLOperand prelu(MLOperand input,
+                  MLOperand slope,
+                  optional MLOperatorOptions options = {});
 };
 
-dictionary MLReduceOptions {
+dictionary MLReduceOptions : MLOperatorOptions {
   sequence<[EnforceRange] unsigned long> axes;
   boolean keepDimensions = false;
 };
@@ -478,8 +498,7 @@ partial interface MLGraphBuilder {
 };
 
 partial interface MLGraphBuilder {
-  MLOperand relu(MLOperand input);
-  MLActivation relu();
+  MLOperand relu(MLOperand input, optional MLOperatorOptions options = {});
 };
 
 enum MLInterpolationMode {
@@ -487,7 +506,7 @@ enum MLInterpolationMode {
   "linear"
 };
 
-dictionary MLResample2dOptions {
+dictionary MLResample2dOptions : MLOperatorOptions {
   MLInterpolationMode mode = "nearest-neighbor";
   sequence<float> scales;
   sequence<[EnforceRange] unsigned long> sizes;
@@ -499,35 +518,37 @@ partial interface MLGraphBuilder {
 };
 
 partial interface MLGraphBuilder {
-  MLOperand reshape(MLOperand input, sequence<[EnforceRange] unsigned long> newShape);
+  MLOperand reshape(MLOperand input,
+                    sequence<[EnforceRange] unsigned long> newShape,
+                    optional MLOperatorOptions options = {});
 };
 
 partial interface MLGraphBuilder {
-  MLOperand sigmoid(MLOperand input);
-  MLActivation sigmoid();
+  MLOperand sigmoid(MLOperand input, optional MLOperatorOptions options = {});
 };
 
 partial interface MLGraphBuilder {
   MLOperand slice(MLOperand input,
                   sequence<[EnforceRange] unsigned long> starts,
-                  sequence<[EnforceRange] unsigned long> sizes);
+                  sequence<[EnforceRange] unsigned long> sizes,
+                  optional MLOperatorOptions options = {});
 };
 
 partial interface MLGraphBuilder {
-  MLOperand softmax(MLOperand input, unsigned long axis);
+  MLOperand softmax(MLOperand input,
+                    [EnforceRange] unsigned long axis,
+                    optional MLOperatorOptions options = {});
 };
 
 partial interface MLGraphBuilder {
-  MLOperand softplus(MLOperand input);
-  MLActivation softplus();
+  MLOperand softplus(MLOperand input, optional MLOperatorOptions options = {});
 };
 
 partial interface MLGraphBuilder {
-  MLOperand softsign(MLOperand input);
-  MLActivation softsign();
+  MLOperand softsign(MLOperand input, optional MLOperatorOptions options = {});
 };
 
-dictionary MLSplitOptions {
+dictionary MLSplitOptions : MLOperatorOptions {
   [EnforceRange] unsigned long axis = 0;
 };
 
@@ -539,11 +560,10 @@ partial interface MLGraphBuilder {
 };
 
 partial interface MLGraphBuilder {
-  MLOperand tanh(MLOperand input);
-  MLActivation tanh();
+  MLOperand tanh(MLOperand input, optional MLOperatorOptions options = {});
 };
 
-dictionary MLTransposeOptions {
+dictionary MLTransposeOptions : MLOperatorOptions {
   sequence<[EnforceRange] unsigned long> permutation;
 };
 
@@ -551,7 +571,7 @@ partial interface MLGraphBuilder {
   MLOperand transpose(MLOperand input, optional MLTransposeOptions options = {});
 };
 
-dictionary MLTriangularOptions {
+dictionary MLTriangularOptions : MLOperatorOptions {
   boolean upper = true;
   [EnforceRange] long diagonal = 0;
 };
@@ -561,5 +581,8 @@ partial interface MLGraphBuilder {
 };
 
 partial interface MLGraphBuilder {
-  MLOperand where(MLOperand condition, MLOperand input, MLOperand other);
+  MLOperand where(MLOperand condition,
+                  MLOperand trueValue,
+                  MLOperand falseValue,
+                  optional MLOperatorOptions options = {});
 };

package/webtransport.idl

@@ -84,24 +84,24 @@ dictionary WebTransportSendStreamOptions {
 };
 
 dictionary WebTransportConnectionStats {
-  unsigned long long bytesSent;
-  unsigned long long packetsSent;
-  unsigned long long bytesLost;
-  unsigned long long packetsLost;
-  unsigned long long bytesReceived;
-  unsigned long long packetsReceived;
-  DOMHighResTimeStamp smoothedRtt;
-  DOMHighResTimeStamp rttVariation;
-  DOMHighResTimeStamp minRtt;
-  WebTransportDatagramStats datagrams;
-  unsigned long long? estimatedSendRate;
+  unsigned long long bytesSent = 0;
+  unsigned long long packetsSent = 0;
+  unsigned long long bytesLost = 0;
+  unsigned long long packetsLost = 0;
+  unsigned long long bytesReceived = 0;
+  unsigned long long packetsReceived = 0;
+  required DOMHighResTimeStamp smoothedRtt;
+  required DOMHighResTimeStamp rttVariation;
+  required DOMHighResTimeStamp minRtt;
+  required WebTransportDatagramStats datagrams;
+  required unsigned long long? estimatedSendRate;
 };
 
 dictionary WebTransportDatagramStats {
-  unsigned long long droppedIncoming;
-  unsigned long long expiredIncoming;
-  unsigned long long expiredOutgoing;
-  unsigned long long lostOutgoing;
+  unsigned long long droppedIncoming = 0;
+  unsigned long long expiredIncoming = 0;
+  unsigned long long expiredOutgoing = 0;
+  unsigned long long lostOutgoing = 0;
 };
 
 [Exposed=(Window,Worker), SecureContext, Transferable]
@@ -113,9 +113,9 @@ interface WebTransportSendStream : WritableStream {
 };
 
 dictionary WebTransportSendStreamStats {
-  unsigned long long bytesWritten;
-  unsigned long long bytesSent;
-  unsigned long long bytesAcknowledged;
+  unsigned long long bytesWritten = 0;
+  unsigned long long bytesSent = 0;
+  unsigned long long bytesAcknowledged = 0;
 };
 
 [Exposed=(Window,Worker), SecureContext]
@@ -129,8 +129,8 @@ interface WebTransportReceiveStream : ReadableStream {
 };
 
 dictionary WebTransportReceiveStreamStats {
-  unsigned long long bytesReceived;
-  unsigned long long bytesRead;
+  unsigned long long bytesReceived = 0;
+  unsigned long long bytesRead = 0;
 };
 
 [Exposed=(Window,Worker), SecureContext]

package/css-viewport.idl

@@ -1,13 +0,0 @@
-// GENERATED CONTENT - DO NOT EDIT
-// Content was automatically extracted by Reffy into webref
-// (https://github.com/w3c/webref)
-// Source: CSS Viewport Module Level 1 (https://drafts.csswg.org/css-viewport/)
-
-partial interface Window {
-[SameObject, Replaceable] readonly attribute Viewport? viewport;
-};
-
-[Exposed=Window]
-interface Viewport : EventTarget {
-  readonly attribute double zoom;
-};