@webref/idl 3.52.2 → 3.53.1

package/css-view-transitions-2.idl

@@ -3,11 +3,9 @@
 // (https://github.com/w3c/webref)
 // Source: CSS View Transitions Module Level 2 (https://drafts.csswg.org/css-view-transitions-2/)
 
-enum ViewTransitionNavigation { "auto", "none" };
-
 [Exposed=Window]
 interface CSSViewTransitionRule : CSSRule {
-  readonly attribute ViewTransitionNavigation navigation;
+  readonly attribute CSSOMString navigation;
   [SameObject] readonly attribute FrozenArray<CSSOMString> types;
 };
 
@@ -22,11 +20,10 @@ partial interface ViewTransition {
 };
 
 dictionary StartViewTransitionOptions {
-  UpdateCallback? update = null;
+  ViewTransitionUpdateCallback? update = null;
   sequence<DOMString>? types = null;
 };
 
 partial interface Document {
-
-  ViewTransition startViewTransition(optional (UpdateCallback or StartViewTransitionOptions) callbackOptions = {});
+  ViewTransition startViewTransition(optional (ViewTransitionUpdateCallback or StartViewTransitionOptions) callbackOptions = {});
 };

package/css-view-transitions.idl

@@ -3,7 +3,7 @@
 // (https://github.com/w3c/webref)
 // Source: CSS View Transitions Module Level 1 (https://drafts.csswg.org/css-view-transitions-1/)
 
-callback UpdateCallback = Promise<any> ();
+callback ViewTransitionUpdateCallback = Promise<any> ();
 
 [Exposed=Window]
 interface ViewTransition {

package/css-viewport.idl

@@ -0,0 +1,13 @@
+// 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 {
+  readonly attribute FrozenArray<DOMRect>? segments;
+};

package/digital-identities.idl

@@ -12,10 +12,10 @@ partial dictionary CredentialRequestOptions {
 };
 
 dictionary DigitalCredentialRequestOptions {
-  sequence<IdentityRequestProvider> providers;
+  sequence<DigitalCredentialsProvider> providers;
 };
 
-dictionary IdentityRequestProvider {
+dictionary DigitalCredentialsProvider {
   required DOMString protocol;
   required object request;
 };
@@ -23,5 +23,5 @@ dictionary IdentityRequestProvider {
 [Exposed=Window, SecureContext]
 interface DigitalCredential : Credential {
   readonly attribute DOMString protocol;
-  readonly attribute any data;
+  readonly attribute object data;
 };

package/document-picture-in-picture.idl

@@ -21,6 +21,7 @@ dictionary DocumentPictureInPictureOptions {
   [EnforceRange] unsigned long long width = 0;
   [EnforceRange] unsigned long long height = 0;
   boolean disallowReturnToOpener = false;
+  boolean preferInitialWindowPlacement = false;
 };
 
 [Exposed=Window, SecureContext]

package/fenced-frame.idl

@@ -10,23 +10,15 @@ interface HTMLFencedFrameElement : HTMLElement {
   [CEReactions] attribute FencedFrameConfig? config;
   [CEReactions] attribute DOMString width;
   [CEReactions] attribute DOMString height;
+  [SameObject, PutForwards=value] readonly attribute DOMTokenList sandbox;
   [CEReactions] attribute DOMString allow;
 };
 
 enum OpaqueProperty {"opaque"};
 
-typedef (unsigned long or OpaqueProperty) FencedFrameConfigSize;
-typedef USVString FencedFrameConfigURL;
-
 [Exposed=Window, Serializable]
 interface FencedFrameConfig {
   constructor(USVString url);
-
-  readonly attribute FencedFrameConfigSize? containerWidth;
-  readonly attribute FencedFrameConfigSize? containerHeight;
-  readonly attribute FencedFrameConfigSize? contentWidth;
-  readonly attribute FencedFrameConfigSize? contentHeight;
-
   undefined setSharedStorageContext(DOMString contextString);
 };
 

package/html.idl

@@ -125,6 +125,7 @@ interface HTMLElement : Element {
   [CEReactions] attribute boolean spellcheck;
   [CEReactions] attribute DOMString writingSuggestions;
   [CEReactions] attribute DOMString autocapitalize;
+  [CEReactions] attribute boolean autocorrect;
 
   [CEReactions] attribute [LegacyNullToEmptyString] DOMString innerText;
   [CEReactions] attribute [LegacyNullToEmptyString] DOMString outerText;

package/ink-enhancement.idl

@@ -16,7 +16,6 @@ dictionary InkPresenterParam {
 [Exposed=Window]
 interface InkPresenter {
     readonly attribute Element? presentationArea;
-    readonly attribute unsigned long expectedImprovement;
 
     undefined updateInkTrailStartPoint(PointerEvent event, InkTrailStyle style);
 };

package/package.json

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

package/shared-storage.idl

@@ -23,7 +23,7 @@ interface SharedStorageWorkletGlobalScope : WorkletGlobalScope {
   undefined register(DOMString name,
                      Function operationCtor);
 
-  readonly attribute WorkletSharedStorage sharedStorage;
+  readonly attribute SharedStorage sharedStorage;
 };
 
 dictionary SharedStorageUrlWithMetadata {
@@ -31,6 +31,10 @@ dictionary SharedStorageUrlWithMetadata {
   object reportingMetadata;
 };
 
+partial interface Window {
+  [SecureContext] readonly attribute SharedStorage? sharedStorage;
+};
+
 [Exposed=(Window,SharedStorageWorklet)]
 interface SharedStorage {
   Promise<any> set(DOMString key,
@@ -40,23 +44,37 @@ interface SharedStorage {
                       DOMString value);
   Promise<any> delete(DOMString key);
   Promise<any> clear();
-};
-
-dictionary SharedStorageSetMethodOptions {
-  boolean ignoreIfPresent = false;
-};
 
-[Exposed=(Window)]
-interface WindowSharedStorage : SharedStorage {
+  [Exposed=Window]
   Promise<SharedStorageResponse> selectURL(DOMString name,
                                sequence<SharedStorageUrlWithMetadata> urls,
                                optional SharedStorageRunOperationMethodOptions options = {});
+
+  [Exposed=Window]
   Promise<any> run(DOMString name,
                    optional SharedStorageRunOperationMethodOptions options = {});
 
+  [Exposed=Window]
   Promise<SharedStorageWorklet> createWorklet(USVString moduleURL, optional SharedStorageWorkletOptions options = {});
 
+  [Exposed=Window]
   readonly attribute SharedStorageWorklet worklet;
+
+  [Exposed=SharedStorageWorklet]
+  Promise<DOMString> get(DOMString key);
+
+  [Exposed=SharedStorageWorklet]
+  Promise<unsigned long> length();
+
+  [Exposed=SharedStorageWorklet]
+  Promise<double> remainingBudget();
+
+  [Exposed=SharedStorageWorklet]
+  async iterable<DOMString, DOMString>;
+};
+
+dictionary SharedStorageSetMethodOptions {
+  boolean ignoreIfPresent = false;
 };
 
 dictionary SharedStorageRunOperationMethodOptions {
@@ -69,19 +87,6 @@ dictionary SharedStorageWorkletOptions : WorkletOptions {
   SharedStorageDataOrigin dataOrigin = "context-origin";
 };
 
-partial interface Window {
-  [SecureContext] readonly attribute WindowSharedStorage? sharedStorage;
-};
-
-[Exposed=(SharedStorageWorklet)]
-interface WorkletSharedStorage : SharedStorage {
-  Promise<DOMString> get(DOMString key);
-  Promise<unsigned long> length();
-  Promise<double> remainingBudget();
-
-  async iterable<DOMString, DOMString>;
-};
-
 interface mixin HTMLSharedStorageWritableElementUtils {
   [CEReactions, SecureContext] attribute boolean sharedStorageWritable;
 };

package/turtledove.idl

@@ -10,11 +10,18 @@ partial interface Navigator {
 
 dictionary AuctionAd {
   required USVString renderURL;
+  USVString sizeGroup;
   any metadata;
 
   USVString buyerReportingId;
   USVString buyerAndSellerReportingId;
   sequence<USVString> allowedReportingOrigins;
+  DOMString adRenderId;
+};
+
+dictionary AuctionAdInterestGroupSize {
+  required USVString width;
+  required USVString height;
 };
 
 dictionary GenerateBidInterestGroup {
@@ -36,6 +43,8 @@ dictionary GenerateBidInterestGroup {
   any userBiddingSignals;
   sequence<AuctionAd> ads;
   sequence<AuctionAd> adComponents;
+  record<DOMString, AuctionAdInterestGroupSize> adSizes;
+  record<DOMString, sequence<DOMString>> sizeGroups;
 };
 
 dictionary AuctionAdInterestGroup : GenerateBidInterestGroup {
@@ -104,6 +113,9 @@ dictionary AuctionAdConfig {
   sequence<AuctionAdConfig> componentAuctions = [];
   AbortSignal? signal;
   Promise<boolean> resolveToConfig;
+
+  Promise<Uint8Array> serverResponse;
+  USVString requestId;
 };
 
 [SecureContext]
@@ -111,6 +123,21 @@ partial interface Navigator {
   boolean canLoadAdAuctionFencedFrame();
 };
 
+[SecureContext]
+partial interface Navigator {
+  Promise<AdAuctionData> getInterestGroupAdAuctionData(AdAuctionDataConfig config);
+};
+
+dictionary AdAuctionDataConfig {
+  required USVString seller;
+  required USVString coordinatorOrigin;
+};
+
+dictionary AdAuctionData {
+  required Uint8Array request;
+  required USVString requestId;
+};
+
 [SecureContext]
 partial interface Navigator {
   Promise<DOMString> createAuctionNonce();
@@ -213,10 +240,8 @@ partial interface HTMLIFrameElement {
   [CEReactions] attribute boolean adAuctionHeaders;
 };
 
-dictionary PreviousWin {
-  required long long timeDelta;
-  required DOMString adJSON;
-};
+typedef (long long or AuctionAd) PreviousWinElement;
+typedef sequence<PreviousWinElement> PreviousWin;
 
 dictionary BiddingBrowserSignals {
   required DOMString topWindowHostname;

package/webauthn.idl

@@ -128,6 +128,30 @@ dictionary PublicKeyCredentialRequestOptionsJSON {
     AuthenticationExtensionsClientInputsJSON                extensions;
 };
 
+partial interface PublicKeyCredential {
+    static Promise<undefined> signalUnknownCredential(UnknownCredentialOptions options);
+    static Promise<undefined> signalAllAcceptedCredentials(AllAcceptedCredentialsOptions options);
+    static Promise<undefined> signalCurrentUserDetails(CurrentUserDetailsOptions options);
+};
+
+dictionary UnknownCredentialOptions {
+    required DOMString                     rpId;
+    required Base64URLString               credentialId;
+};
+
+dictionary AllAcceptedCredentialsOptions {
+    required DOMString                     rpId;
+    required Base64URLString               userId;
+    required sequence<Base64URLString>     allAcceptedCredentialIds;
+};
+
+dictionary CurrentUserDetailsOptions {
+    required DOMString                     rpId;
+    required Base64URLString               userId;
+    required DOMString                     name;
+    required DOMString                     displayName;
+};
+
 [SecureContext, Exposed=Window]
 interface AuthenticatorResponse {
     [SameObject] readonly attribute ArrayBuffer      clientDataJSON;
@@ -272,7 +296,10 @@ enum ClientCapability {
     "hybridTransport",
     "passkeyPlatformAuthenticator",
     "userVerifyingPlatformAuthenticator",
-    "relatedOrigins"
+    "relatedOrigins",
+    "signalAllAcceptedCredentials",
+    "signalCurrentUserDetails",
+    "signalUnknownCredential"
 };
 
 enum PublicKeyCredentialHints {
@@ -303,7 +330,7 @@ partial dictionary AuthenticationExtensionsClientInputs {
 
 dictionary CredentialPropertiesOutput {
     boolean rk;
-    USVString authenticatorDisplayName;
+    DOMString authenticatorDisplayName;
 };
 
 partial dictionary AuthenticationExtensionsClientOutputs {

package/webgpu.idl

@@ -35,7 +35,6 @@ interface GPUSupportedLimits {
     readonly attribute unsigned long long maxBufferSize;
     readonly attribute unsigned long maxVertexAttributes;
     readonly attribute unsigned long maxVertexBufferArrayStride;
-    readonly attribute unsigned long maxInterStageShaderComponents;
     readonly attribute unsigned long maxInterStageShaderVariables;
     readonly attribute unsigned long maxColorAttachments;
     readonly attribute unsigned long maxColorAttachmentBytesPerSample;
@@ -101,7 +100,7 @@ interface GPUAdapter {
 dictionary GPUDeviceDescriptor
          : GPUObjectDescriptorBase {
     sequence<GPUFeatureName> requiredFeatures = [];
-    record<DOMString, GPUSize64> requiredLimits = {};
+    record<DOMString, (GPUSize64 or undefined)> requiredLimits = {};
     GPUQueueDescriptor defaultQueue = {};
 };
 
@@ -256,6 +255,7 @@ dictionary GPUTextureViewDescriptor
          : GPUObjectDescriptorBase {
     GPUTextureFormat format;
     GPUTextureViewDimension dimension;
+    GPUTextureUsageFlags usage = 0;
     GPUTextureAspect aspect = "all";
     GPUIntegerCoordinate baseMipLevel = 0;
     GPUIntegerCoordinate mipLevelCount;
@@ -579,7 +579,6 @@ GPUShaderModule includes GPUObjectBase;
 dictionary GPUShaderModuleDescriptor
          : GPUObjectDescriptorBase {
     required USVString code;
-    object sourceMap;
     sequence<GPUShaderModuleCompilationHint> compilationHints = [];
 };
 

package/webnn.idl

@@ -43,6 +43,30 @@ dictionary MLComputeResult {
 interface MLContext {
   Promise<MLComputeResult> compute(
       MLGraph graph, MLNamedArrayBufferViews inputs, MLNamedArrayBufferViews outputs);
+
+  MLOpSupportLimits opSupportLimits();
+};
+
+dictionary MLOpSupportLimits {
+  MLInputOperandLayout preferredInputLayout;
+  MLSupportLimits input;
+  MLSupportLimits constant;
+  MLSupportLimits output;
+};
+
+dictionary MLSupportLimits {
+  sequence<MLOperandDataType> dataTypes;
+};
+
+dictionary MLBinarySupportLimits {
+  MLSupportLimits a;
+  MLSupportLimits b;
+  MLSupportLimits output;
+};
+
+dictionary MLSingleInputSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits output;
 };
 
 [SecureContext, Exposed=(Window, DedicatedWorker)]
@@ -113,6 +137,11 @@ partial interface MLGraphBuilder {
                    optional MLArgMinMaxOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits argMin;
+  MLSingleInputSupportLimits argMax;
+};
+
 dictionary MLBatchNormalizationOptions : MLOperatorOptions {
   MLOperand scale;
   MLOperand bias;
@@ -125,12 +154,29 @@ partial interface MLGraphBuilder {
                                optional MLBatchNormalizationOptions options = {});
 };
 
+dictionary MLBatchNormalizationSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits mean;
+  MLSupportLimits variance;
+  MLSupportLimits scale;
+  MLSupportLimits bias;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLBatchNormalizationSupportLimits batchNormalization;
+};
+
 partial interface MLGraphBuilder {
   MLOperand cast(MLOperand input,
                  MLOperandDataType type,
                  optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits cast;
+};
+
 dictionary MLClampOptions : MLOperatorOptions {
   MLNumber minValue;
   MLNumber maxValue;
@@ -140,12 +186,25 @@ partial interface MLGraphBuilder {
   MLOperand clamp(MLOperand input, optional MLClampOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits clamp;
+};
+
 partial interface MLGraphBuilder {
   MLOperand concat(sequence<MLOperand> inputs,
                    [EnforceRange] unsigned long axis,
                    optional MLOperatorOptions options = {});
 };
 
+dictionary MLConcatSupportLimits {
+  MLSupportLimits inputs;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLConcatSupportLimits concat;
+};
+
 enum MLConv2dFilterOperandLayout {
   "oihw",
   "hwio",
@@ -169,6 +228,17 @@ partial interface MLGraphBuilder {
                    optional MLConv2dOptions options = {});
 };
 
+dictionary MLConv2dSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits filter;
+  MLSupportLimits bias;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLConv2dSupportLimits conv2d;
+};
+
 enum MLConvTranspose2dFilterOperandLayout {
   "iohw",
   "hwoi",
@@ -192,6 +262,10 @@ partial interface MLGraphBuilder {
                             optional MLConvTranspose2dOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLConv2dSupportLimits convTranspose2d;
+};
+
 partial interface MLGraphBuilder {
   MLOperand add(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
   MLOperand sub(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
@@ -202,6 +276,16 @@ partial interface MLGraphBuilder {
   MLOperand pow(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLBinarySupportLimits add;
+  MLBinarySupportLimits sub;
+  MLBinarySupportLimits mul;
+  MLBinarySupportLimits div;
+  MLBinarySupportLimits max;
+  MLBinarySupportLimits min;
+  MLBinarySupportLimits pow;
+};
+
 partial interface MLGraphBuilder {
   MLOperand equal(MLOperand a,
                   MLOperand b,
@@ -221,6 +305,20 @@ partial interface MLGraphBuilder {
   MLOperand logicalNot(MLOperand a, optional MLOperatorOptions options = {});
 };
 
+dictionary MLLogicalNotSupportLimits {
+  MLSupportLimits a;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLBinarySupportLimits equal;
+  MLBinarySupportLimits greater;
+  MLBinarySupportLimits greaterOrEqual;
+  MLBinarySupportLimits lesser;
+  MLBinarySupportLimits lesserOrEqual;
+  MLLogicalNotSupportLimits logicalNot;
+};
+
 partial interface MLGraphBuilder {
   MLOperand abs(MLOperand input, optional MLOperatorOptions options = {});
   MLOperand ceil(MLOperand input, optional MLOperatorOptions options = {});
@@ -237,6 +335,22 @@ partial interface MLGraphBuilder {
   MLOperand tan(MLOperand input, optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits abs;
+  MLSingleInputSupportLimits ceil;
+  MLSingleInputSupportLimits cos;
+  MLSingleInputSupportLimits erf;
+  MLSingleInputSupportLimits exp;
+  MLSingleInputSupportLimits floor;
+  MLSingleInputSupportLimits identity;
+  MLSingleInputSupportLimits log;
+  MLSingleInputSupportLimits neg;
+  MLSingleInputSupportLimits reciprocal;
+  MLSingleInputSupportLimits sin;
+  MLSingleInputSupportLimits sqrt;
+  MLSingleInputSupportLimits tan;
+};
+
 dictionary MLEluOptions : MLOperatorOptions {
   double alpha = 1;
 };
@@ -245,12 +359,20 @@ partial interface MLGraphBuilder {
   MLOperand elu(MLOperand input, optional MLEluOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits elu;
+};
+
 partial interface MLGraphBuilder {
   MLOperand expand(MLOperand input,
                    sequence<[EnforceRange] unsigned long> newShape,
                    optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits expand;
+};
+
 dictionary MLGatherOptions : MLOperatorOptions {
   [EnforceRange] unsigned long axis = 0;
 };
@@ -261,10 +383,24 @@ partial interface MLGraphBuilder {
                    optional MLGatherOptions options = {});
 };
 
+dictionary MLGatherSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits indices;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLGatherSupportLimits gather;
+};
+
 partial interface MLGraphBuilder {
   MLOperand gelu(MLOperand input, optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits gelu;
+};
+
 dictionary MLGemmOptions : MLOperatorOptions {
   MLOperand c;
   double alpha = 1.0;
@@ -277,6 +413,17 @@ partial interface MLGraphBuilder {
   MLOperand gemm(MLOperand a, MLOperand b, optional MLGemmOptions options = {});
 };
 
+dictionary MLGemmSupportLimits {
+  MLSupportLimits a;
+  MLSupportLimits b;
+  MLSupportLimits c;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLGemmSupportLimits gemm;
+};
+
 enum MLGruWeightLayout {
   "zrn",  // update-reset-new gate ordering
   "rzn"   // reset-update-new gate ordering
@@ -314,6 +461,20 @@ partial interface MLGraphBuilder {
                           optional MLGruOptions options = {});
 };
 
+dictionary MLGruSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits weight;
+  MLSupportLimits recurrentWeight;
+  MLSupportLimits bias;
+  MLSupportLimits recurrentBias;
+  MLSupportLimits initialHiddenState;
+  MLSupportLimits outputs;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLGruSupportLimits gru;
+};
+
 dictionary MLGruCellOptions : MLOperatorOptions {
   MLOperand bias;
   MLOperand recurrentBias;
@@ -331,6 +492,20 @@ partial interface MLGraphBuilder {
                     optional MLGruCellOptions options = {});
 };
 
+dictionary MLGruCellSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits weight;
+  MLSupportLimits recurrentWeight;
+  MLSupportLimits hiddenState;
+  MLSupportLimits bias;
+  MLSupportLimits recurrentBias;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLGruCellSupportLimits gruCell;
+};
+
 dictionary MLHardSigmoidOptions : MLOperatorOptions {
   double alpha = 0.2;
   double beta = 0.5;
@@ -340,10 +515,18 @@ partial interface MLGraphBuilder {
   MLOperand hardSigmoid(MLOperand input, optional MLHardSigmoidOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits hardSigmoid;
+};
+
 partial interface MLGraphBuilder {
   MLOperand hardSwish(MLOperand input, optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits hardSwish;
+};
+
 dictionary MLInstanceNormalizationOptions : MLOperatorOptions {
   MLOperand scale;
   MLOperand bias;
@@ -356,6 +539,17 @@ partial interface MLGraphBuilder {
                                   optional MLInstanceNormalizationOptions options = {});
 };
 
+dictionary MLNormalizationSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits scale;
+  MLSupportLimits bias;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLNormalizationSupportLimits instanceNormalization;
+};
+
 dictionary MLLayerNormalizationOptions : MLOperatorOptions {
   MLOperand scale;
   MLOperand bias;
@@ -368,6 +562,10 @@ partial interface MLGraphBuilder {
                                optional MLLayerNormalizationOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLNormalizationSupportLimits layerNormalization;
+};
+
 dictionary MLLeakyReluOptions : MLOperatorOptions {
   double alpha = 0.01;
 };
@@ -376,6 +574,10 @@ partial interface MLGraphBuilder {
   MLOperand leakyRelu(MLOperand input, optional MLLeakyReluOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits leakyRelu;
+};
+
 dictionary MLLinearOptions : MLOperatorOptions {
   double alpha = 1;
   double beta = 0;
@@ -385,6 +587,10 @@ partial interface MLGraphBuilder {
   MLOperand linear(MLOperand input, optional MLLinearOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits linear;
+};
+
 enum MLLstmWeightLayout {
   "iofg", // input-output-forget-cell gate ordering
   "ifgo"  // input-forget-cell-output gate ordering
@@ -411,6 +617,22 @@ partial interface MLGraphBuilder {
                            optional MLLstmOptions options = {});
 };
 
+dictionary MLLstmSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits weight;
+  MLSupportLimits recurrentWeight;
+  MLSupportLimits bias;
+  MLSupportLimits recurrentBias;
+  MLSupportLimits peepholeWeight;
+  MLSupportLimits initialHiddenState;
+  MLSupportLimits initialCellState;
+  MLSupportLimits outputs;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLLstmSupportLimits lstm;
+};
+
 dictionary MLLstmCellOptions : MLOperatorOptions {
   MLOperand bias;
   MLOperand recurrentBias;
@@ -429,10 +651,30 @@ partial interface MLGraphBuilder {
                                optional MLLstmCellOptions options = {});
 };
 
+dictionary MLLstmCellSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits weight;
+  MLSupportLimits recurrentWeight;
+  MLSupportLimits hiddenState;
+  MLSupportLimits cellState;
+  MLSupportLimits bias;
+  MLSupportLimits recurrentBias;
+  MLSupportLimits peepholeWeight;
+  MLSupportLimits outputs;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLLstmCellSupportLimits lstmCell;
+};
+
 partial interface MLGraphBuilder {
   MLOperand matmul(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLBinarySupportLimits matmul;
+};
+
 enum MLPaddingMode {
   "constant",
   "edge",
@@ -452,6 +694,10 @@ partial interface MLGraphBuilder {
                 optional MLPadOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits pad;
+};
+
 enum MLRoundingType {
   "floor",
   "ceil"
@@ -473,12 +719,28 @@ partial interface MLGraphBuilder {
   MLOperand maxPool2d(MLOperand input, optional MLPool2dOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits averagePool2d;
+  MLSingleInputSupportLimits l2Pool2d;
+  MLSingleInputSupportLimits maxPool2d;
+};
+
 partial interface MLGraphBuilder {
   MLOperand prelu(MLOperand input,
                   MLOperand slope,
                   optional MLOperatorOptions options = {});
 };
 
+dictionary MLPreluSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits slope;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLPreluSupportLimits prelu;
+};
+
 dictionary MLReduceOptions : MLOperatorOptions {
   sequence<[EnforceRange] unsigned long> axes;
   boolean keepDimensions = false;
@@ -497,10 +759,27 @@ partial interface MLGraphBuilder {
   MLOperand reduceSumSquare(MLOperand input, optional MLReduceOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits reduceL1;
+  MLSingleInputSupportLimits reduceL2;
+  MLSingleInputSupportLimits reduceLogSum;
+  MLSingleInputSupportLimits reduceLogSumExp;
+  MLSingleInputSupportLimits reduceMax;
+  MLSingleInputSupportLimits reduceMean;
+  MLSingleInputSupportLimits reduceMin;
+  MLSingleInputSupportLimits reduceProduct;
+  MLSingleInputSupportLimits reduceSum;
+  MLSingleInputSupportLimits reduceSumSquare;
+};
+
 partial interface MLGraphBuilder {
   MLOperand relu(MLOperand input, optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits relu;
+};
+
 enum MLInterpolationMode {
   "nearest-neighbor",
   "linear"
@@ -517,16 +796,28 @@ partial interface MLGraphBuilder {
   MLOperand resample2d(MLOperand input, optional MLResample2dOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits resample2d;
+};
+
 partial interface MLGraphBuilder {
   MLOperand reshape(MLOperand input,
                     sequence<[EnforceRange] unsigned long> newShape,
                     optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits reshape;
+};
+
 partial interface MLGraphBuilder {
   MLOperand sigmoid(MLOperand input, optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits sigmoid;
+};
+
 partial interface MLGraphBuilder {
   MLOperand slice(MLOperand input,
                   sequence<[EnforceRange] unsigned long> starts,
@@ -534,20 +825,36 @@ partial interface MLGraphBuilder {
                   optional MLOperatorOptions options = {});
 };
 
+partial  dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits slice;
+};
+
 partial interface MLGraphBuilder {
   MLOperand softmax(MLOperand input,
                     [EnforceRange] unsigned long axis,
                     optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits softmax;
+};
+
 partial interface MLGraphBuilder {
   MLOperand softplus(MLOperand input, optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits softplus;
+};
+
 partial interface MLGraphBuilder {
   MLOperand softsign(MLOperand input, optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits softsign;
+};
+
 dictionary MLSplitOptions : MLOperatorOptions {
   [EnforceRange] unsigned long axis = 0;
 };
@@ -559,10 +866,23 @@ partial interface MLGraphBuilder {
       optional MLSplitOptions options = {});
 };
 
+dictionary MLSplitSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits outputs;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits split;
+};
+
 partial interface MLGraphBuilder {
   MLOperand tanh(MLOperand input, optional MLOperatorOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits tanh;
+};
+
 dictionary MLTransposeOptions : MLOperatorOptions {
   sequence<[EnforceRange] unsigned long> permutation;
 };
@@ -571,6 +891,10 @@ partial interface MLGraphBuilder {
   MLOperand transpose(MLOperand input, optional MLTransposeOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits transpose;
+};
+
 dictionary MLTriangularOptions : MLOperatorOptions {
   boolean upper = true;
   [EnforceRange] long diagonal = 0;
@@ -580,9 +904,24 @@ partial interface MLGraphBuilder {
   MLOperand triangular(MLOperand input, optional MLTriangularOptions options = {});
 };
 
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits triangular;
+};
+
 partial interface MLGraphBuilder {
   MLOperand where(MLOperand condition,
                   MLOperand trueValue,
                   MLOperand falseValue,
                   optional MLOperatorOptions options = {});
 };
+
+dictionary MLWhereSupportLimits {
+  MLSupportLimits condition;
+  MLSupportLimits trueValue;
+  MLSupportLimits falseValue;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLWhereSupportLimits where;
+};

package/webrtc.idl

@@ -317,6 +317,7 @@ dictionary RTCRtpCodingParameters {
 
 dictionary RTCRtpEncodingParameters : RTCRtpCodingParameters {
   boolean active = true;
+  RTCRtpCodec codec;
   unsigned long maxBitrate;
   double maxFramerate;
   double scaleResolutionDownBy;

package/webxr.idl

@@ -178,7 +178,7 @@ interface XRInputSource {
   [SameObject] readonly attribute XRSpace targetRaySpace;
   [SameObject] readonly attribute XRSpace? gripSpace;
   [SameObject] readonly attribute FrozenArray<DOMString> profiles;
-  [SameObject] readonly attribute boolean skipRendering;
+  readonly attribute boolean skipRendering;
 };
 
 [SecureContext, Exposed=Window]