--- a/testing/web-platform/tests/css/css-images/idlharness.html
+++ b/testing/web-platform/tests/css/css-images/idlharness.html
@@ -4,15 +4,15 @@
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/WebIDLParser.js"></script>
 <script src="/resources/idlharness.js"></script>
 <script>
   'use strict';
 
   idl_test(
-    ['css-images'],
+    ['css-images-4'],
     ['cssom'],
     idl_array => {
       // No objects,
     }
   );
 </script>

--- a/testing/web-platform/tests/css/css-typed-om/idlharness.html
+++ b/testing/web-platform/tests/css/css-typed-om/idlharness.html
@@ -14,17 +14,17 @@
   }
 </style>
 
 <script>
 'use strict';
 
 idl_test(
   ['css-typed-om'],
-  ['cssom', 'SVG', 'geometry', 'html', 'dom'],
+  ['cssom', 'SVG', 'geometry', 'html', 'dom', 'mathml-core'],
   idl_array => {
     try {
       self.styleMap = document.styleSheets[0].rules[0].styleMap;
     } catch (e) {}
 
     try {
       self.unitValue = CSSStyleValue.parse('height', '10px');
     } catch (e) {}

--- a/testing/web-platform/tests/css/cssom/idlharness.html
+++ b/testing/web-platform/tests/css/cssom/idlharness.html
@@ -30,17 +30,17 @@ Use a non-empty style attribute to get a
 
 <script>
 'use strict';
 
 const waitForLoad = new Promise(r => { addEventListener('load', r); });
 
 idl_test(
   ['cssom'],
-  ['SVG', 'uievents', 'html', 'dom'],
+  ['SVG', 'uievents', 'html', 'dom', 'mathml-core'],
   async idlArray => {
     idlArray.add_objects({
       Document: ['document', 'new Document()'],
       StyleSheetList: ['document.styleSheets'],
       CSSStyleSheet: ['sheet'],
       MediaList: ['sheet.media'],
       CSSRuleList: ['sheet.cssRules'],
       CSSImportRule: ['sheet.cssRules[0]'],

--- a/testing/web-platform/tests/gamepad/idlharness.https.window.js
+++ b/testing/web-platform/tests/gamepad/idlharness.https.window.js
@@ -3,16 +3,16 @@
 // META: timeout=long
 
 // https://w3c.github.io/gamepad/
 
 'use strict';
 
 idl_test(
   ['gamepad'],
-  ['dom', 'html'],
+  ['html', 'dom'],
   idl_array => {
     idl_array.add_objects({
       GamepadEvent: ['new GamepadEvent("gamepad")'],
       Navigator: ['navigator']
     });
   }
 );

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/ANGLE_instanced_arrays.idl
@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL ANGLE_instanced_arrays Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/ANGLE_instanced_arrays/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface ANGLE_instanced_arrays {
+    const GLenum VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE = 0x88FE;
+    undefined drawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+    undefined drawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, GLintptr offset, GLsizei primcount);
+    undefined vertexAttribDivisorANGLE(GLuint index, GLuint divisor);
+};

--- a/testing/web-platform/tests/interfaces/DOM-Parsing.idl
+++ b/testing/web-platform/tests/interfaces/DOM-Parsing.idl
@@ -13,14 +13,14 @@ interface mixin InnerHTML {
   [CEReactions] attribute [LegacyNullToEmptyString] DOMString innerHTML;
 };
 
 Element includes InnerHTML;
 ShadowRoot includes InnerHTML;
 
 partial interface Element {
   [CEReactions] attribute [LegacyNullToEmptyString] DOMString outerHTML;
-  [CEReactions] void insertAdjacentHTML(DOMString position, DOMString text);
+  [CEReactions] undefined insertAdjacentHTML(DOMString position, DOMString text);
 };
 
 partial interface Range {
   [CEReactions, NewObject] DocumentFragment createContextualFragment(DOMString fragment);
 };

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_blend_minmax.idl
@@ -0,0 +1,10 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_blend_minmax Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_blend_minmax/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_blend_minmax {
+  const GLenum MIN_EXT = 0x8007;
+  const GLenum MAX_EXT = 0x8008;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_clip_cull_distance.idl
@@ -0,0 +1,20 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_clip_cull_distance Extension Draft Specification (https://www.khronos.org/registry/webgl/extensions/EXT_clip_cull_distance/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_clip_cull_distance {
+  const GLenum MAX_CLIP_DISTANCES_EXT                       = 0x0D32;
+  const GLenum MAX_CULL_DISTANCES_EXT                       = 0x82F9;
+  const GLenum MAX_COMBINED_CLIP_AND_CULL_DISTANCES_EXT     = 0x82FA;
+
+  const GLenum CLIP_DISTANCE0_EXT                           = 0x3000;
+  const GLenum CLIP_DISTANCE1_EXT                           = 0x3001;
+  const GLenum CLIP_DISTANCE2_EXT                           = 0x3002;
+  const GLenum CLIP_DISTANCE3_EXT                           = 0x3003;
+  const GLenum CLIP_DISTANCE4_EXT                           = 0x3004;
+  const GLenum CLIP_DISTANCE5_EXT                           = 0x3005;
+  const GLenum CLIP_DISTANCE6_EXT                           = 0x3006;
+  const GLenum CLIP_DISTANCE7_EXT                           = 0x3007;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_color_buffer_float.idl
@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_color_buffer_float Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_color_buffer_float/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_color_buffer_float {
+}; // interface EXT_color_buffer_float

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_color_buffer_half_float.idl
@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_color_buffer_half_float Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_color_buffer_half_float/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_color_buffer_half_float {
+  const GLenum RGBA16F_EXT = 0x881A;
+  const GLenum RGB16F_EXT = 0x881B;
+  const GLenum FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT = 0x8211;
+  const GLenum UNSIGNED_NORMALIZED_EXT = 0x8C17;
+}; // interface EXT_color_buffer_half_float

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_disjoint_timer_query.idl
@@ -0,0 +1,30 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_disjoint_timer_query Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_disjoint_timer_query/)
+
+typedef unsigned long long GLuint64EXT;
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WebGLTimerQueryEXT : WebGLObject {
+};
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_disjoint_timer_query {
+  const GLenum QUERY_COUNTER_BITS_EXT      = 0x8864;
+  const GLenum CURRENT_QUERY_EXT           = 0x8865;
+  const GLenum QUERY_RESULT_EXT            = 0x8866;
+  const GLenum QUERY_RESULT_AVAILABLE_EXT  = 0x8867;
+  const GLenum TIME_ELAPSED_EXT            = 0x88BF;
+  const GLenum TIMESTAMP_EXT               = 0x8E28;
+  const GLenum GPU_DISJOINT_EXT            = 0x8FBB;
+
+  WebGLTimerQueryEXT? createQueryEXT();
+  undefined deleteQueryEXT(WebGLTimerQueryEXT? query);
+  [WebGLHandlesContextLoss] boolean isQueryEXT(WebGLTimerQueryEXT? query);
+  undefined beginQueryEXT(GLenum target, WebGLTimerQueryEXT query);
+  undefined endQueryEXT(GLenum target);
+  undefined queryCounterEXT(WebGLTimerQueryEXT query, GLenum target);
+  any getQueryEXT(GLenum target, GLenum pname);
+  any getQueryObjectEXT(WebGLTimerQueryEXT query, GLenum pname);
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_disjoint_timer_query_webgl2.idl
@@ -0,0 +1,14 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_disjoint_timer_query_webgl2 Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_disjoint_timer_query_webgl2/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_disjoint_timer_query_webgl2 {
+  const GLenum QUERY_COUNTER_BITS_EXT      = 0x8864;
+  const GLenum TIME_ELAPSED_EXT            = 0x88BF;
+  const GLenum TIMESTAMP_EXT               = 0x8E28;
+  const GLenum GPU_DISJOINT_EXT            = 0x8FBB;
+
+  undefined queryCounterEXT(WebGLQuery query, GLenum target);
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_float_blend.idl
@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_float_blend Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_float_blend/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_float_blend {
+}; // interface EXT_float_blend

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_frag_depth.idl
@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_frag_depth Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_frag_depth/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_frag_depth {
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_sRGB.idl
@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_sRGB Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_sRGB/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_sRGB {
+  const GLenum SRGB_EXT                                     = 0x8C40;
+  const GLenum SRGB_ALPHA_EXT                               = 0x8C42;
+  const GLenum SRGB8_ALPHA8_EXT                             = 0x8C43;
+  const GLenum FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT    = 0x8210;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_shader_texture_lod.idl
@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_shader_texture_lod Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_shader_texture_lod/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_shader_texture_lod {
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_texture_compression_bptc.idl
@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_texture_compression_bptc Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_texture_compression_bptc/)
+
+[Exposed=Window, LegacyNoInterfaceObject]
+interface EXT_texture_compression_bptc {
+    const GLenum COMPRESSED_RGBA_BPTC_UNORM_EXT = 0x8E8C;
+    const GLenum COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT = 0x8E8D;
+    const GLenum COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT = 0x8E8E;
+    const GLenum COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT = 0x8E8F;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_texture_compression_rgtc.idl
@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_texture_compression_rgtc Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_texture_compression_rgtc/)
+
+[Exposed=Window, LegacyNoInterfaceObject]
+interface EXT_texture_compression_rgtc {
+    const GLenum COMPRESSED_RED_RGTC1_EXT = 0x8DBB;
+    const GLenum COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC;
+    const GLenum COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD;
+    const GLenum COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_texture_filter_anisotropic.idl
@@ -0,0 +1,10 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_texture_filter_anisotropic Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_texture_filter_anisotropic/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface EXT_texture_filter_anisotropic {
+  const GLenum TEXTURE_MAX_ANISOTROPY_EXT       = 0x84FE;
+  const GLenum MAX_TEXTURE_MAX_ANISOTROPY_EXT   = 0x84FF;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/EXT_texture_norm16.idl
@@ -0,0 +1,16 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL EXT_texture_norm16 Extension Specification (https://www.khronos.org/registry/webgl/extensions/EXT_texture_norm16/)
+
+[Exposed=Window, LegacyNoInterfaceObject]
+interface EXT_texture_norm16 {
+  const GLenum R16_EXT = 0x822A;
+  const GLenum RG16_EXT = 0x822C;
+  const GLenum RGB16_EXT = 0x8054;
+  const GLenum RGBA16_EXT = 0x805B;
+  const GLenum R16_SNORM_EXT = 0x8F98;
+  const GLenum RG16_SNORM_EXT = 0x8F99;
+  const GLenum RGB16_SNORM_EXT = 0x8F9A;
+  const GLenum RGBA16_SNORM_EXT = 0x8F9B;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/KHR_parallel_shader_compile.idl
@@ -0,0 +1,9 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL KHR_parallel_shader_compile Extension Specification (https://www.khronos.org/registry/webgl/extensions/KHR_parallel_shader_compile/)
+
+[Exposed=Window, LegacyNoInterfaceObject]
+interface KHR_parallel_shader_compile {
+  const GLenum COMPLETION_STATUS_KHR                = 0x91B1;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/OES_draw_buffers_indexed.idl
@@ -0,0 +1,26 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL OES_draw_buffers_indexed Extension Draft Specification (https://www.khronos.org/registry/webgl/extensions/OES_draw_buffers_indexed/)
+
+[Exposed=Window, LegacyNoInterfaceObject]
+interface OES_draw_buffers_indexed {
+  undefined enableiOES(GLenum target, GLuint index);
+
+  undefined disableiOES(GLenum target, GLuint index);
+
+  undefined blendEquationiOES(GLuint buf, GLenum mode);
+
+  undefined blendEquationSeparateiOES(GLuint buf,
+                                 GLenum modeRGB, GLenum modeAlpha);
+
+  undefined blendFunciOES(GLuint buf,
+                     GLenum src, GLenum dst);
+
+  undefined blendFuncSeparateiOES(GLuint buf,
+                             GLenum srcRGB, GLenum dstRGB,
+                             GLenum srcAlpha, GLenum dstAlpha);
+
+  undefined colorMaskiOES(GLuint buf,
+                     GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/OES_element_index_uint.idl
@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL OES_element_index_uint Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/OES_element_index_uint/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface OES_element_index_uint {
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/OES_fbo_render_mipmap.idl
@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL OES_fbo_render_mipmap Extension Specification (https://www.khronos.org/registry/webgl/extensions/OES_fbo_render_mipmap/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface OES_fbo_render_mipmap {
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/OES_standard_derivatives.idl
@@ -0,0 +1,9 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL OES_standard_derivatives Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/OES_standard_derivatives/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface OES_standard_derivatives {
+    const GLenum FRAGMENT_SHADER_DERIVATIVE_HINT_OES = 0x8B8B;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/OES_texture_float.idl
@@ -0,0 +1,7 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL OES_texture_float Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/OES_texture_float/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface OES_texture_float { };

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/OES_texture_float_linear.idl
@@ -0,0 +1,7 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL OES_texture_float_linear Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/OES_texture_float_linear/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface OES_texture_float_linear { };

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/OES_texture_half_float.idl
@@ -0,0 +1,9 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL OES_texture_half_float Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/OES_texture_half_float/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface OES_texture_half_float {
+  const GLenum HALF_FLOAT_OES = 0x8D61;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/OES_texture_half_float_linear.idl
@@ -0,0 +1,7 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL OES_texture_half_float_linear Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/OES_texture_half_float_linear/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface OES_texture_half_float_linear { };

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/OES_vertex_array_object.idl
@@ -0,0 +1,18 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL OES_vertex_array_object Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WebGLVertexArrayObjectOES : WebGLObject {
+};
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface OES_vertex_array_object {
+    const GLenum VERTEX_ARRAY_BINDING_OES = 0x85B5;
+
+    WebGLVertexArrayObjectOES? createVertexArrayOES();
+    undefined deleteVertexArrayOES(WebGLVertexArrayObjectOES? arrayObject);
+    [WebGLHandlesContextLoss] GLboolean isVertexArrayOES(WebGLVertexArrayObjectOES? arrayObject);
+    undefined bindVertexArrayOES(WebGLVertexArrayObjectOES? arrayObject);
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/OVR_multiview2.idl
@@ -0,0 +1,14 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL OVR_multiview2 Extension Specification (https://www.khronos.org/registry/webgl/extensions/OVR_multiview2/)
+
+[Exposed=Window, LegacyNoInterfaceObject]
+interface OVR_multiview2 {
+    const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR = 0x9630;
+    const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR = 0x9632;
+    const GLenum MAX_VIEWS_OVR = 0x9631;
+    const GLenum FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR = 0x9633;
+
+    undefined framebufferTextureMultiviewOVR(GLenum target, GLenum attachment, WebGLTexture? texture, GLint level, GLint baseViewIndex, GLsizei numViews);
+};

--- a/testing/web-platform/tests/interfaces/SVG.idl
+++ b/testing/web-platform/tests/interfaces/SVG.idl
@@ -19,16 +19,17 @@ SVGElement includes HTMLOrSVGElement;
 
 dictionary SVGBoundingBoxOptions {
   boolean fill = true;
   boolean stroke = false;
   boolean markers = false;
   boolean clipped = false;
 };
 
+[Exposed=Window]
 interface SVGGraphicsElement : SVGElement {
   [SameObject] readonly attribute SVGAnimatedTransformList transform;
 
   DOMRect getBBox(optional SVGBoundingBoxOptions options = {});
   DOMMatrix? getCTM();
   DOMMatrix? getScreenCTM();
 };
 
@@ -65,18 +66,18 @@ interface SVGLength {
   const unsigned short SVG_LENGTHTYPE_PT = 9;
   const unsigned short SVG_LENGTHTYPE_PC = 10;
 
   readonly attribute unsigned short unitType;
            attribute float value;
            attribute float valueInSpecifiedUnits;
            attribute DOMString valueAsString;
 
-  void newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits);
-  void convertToSpecifiedUnits(unsigned short unitType);
+  undefined newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits);
+  undefined convertToSpecifiedUnits(unsigned short unitType);
 };
 
 [Exposed=Window]
 interface SVGAngle {
 
   // Angle Unit Types
   const unsigned short SVG_ANGLETYPE_UNKNOWN = 0;
   const unsigned short SVG_ANGLETYPE_UNSPECIFIED = 1;
@@ -84,66 +85,66 @@ interface SVGAngle {
   const unsigned short SVG_ANGLETYPE_RAD = 3;
   const unsigned short SVG_ANGLETYPE_GRAD = 4;
 
   readonly attribute unsigned short unitType;
            attribute float value;
            attribute float valueInSpecifiedUnits;
            attribute DOMString valueAsString;
 
-  void newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits);
-  void convertToSpecifiedUnits(unsigned short unitType);
+  undefined newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits);
+  undefined convertToSpecifiedUnits(unsigned short unitType);
 };
 
 [Exposed=Window]
 interface SVGNumberList {
 
   readonly attribute unsigned long length;
   readonly attribute unsigned long numberOfItems;
 
-  void clear();
+  undefined clear();
   SVGNumber initialize(SVGNumber newItem);
   getter SVGNumber getItem(unsigned long index);
   SVGNumber insertItemBefore(SVGNumber newItem, unsigned long index);
   SVGNumber replaceItem(SVGNumber newItem, unsigned long index);
   SVGNumber removeItem(unsigned long index);
   SVGNumber appendItem(SVGNumber newItem);
-  setter void (unsigned long index, SVGNumber newItem);
+  setter undefined (unsigned long index, SVGNumber newItem);
 };
 
 [Exposed=Window]
 interface SVGLengthList {
 
   readonly attribute unsigned long length;
   readonly attribute unsigned long numberOfItems;
 
-  void clear();
+  undefined clear();
   SVGLength initialize(SVGLength newItem);
   getter SVGLength getItem(unsigned long index);
   SVGLength insertItemBefore(SVGLength newItem, unsigned long index);
   SVGLength replaceItem(SVGLength newItem, unsigned long index);
   SVGLength removeItem(unsigned long index);
   SVGLength appendItem(SVGLength newItem);
-  setter void (unsigned long index, SVGLength newItem);
+  setter undefined (unsigned long index, SVGLength newItem);
 };
 
 [Exposed=Window]
 interface SVGStringList {
 
   readonly attribute unsigned long length;
   readonly attribute unsigned long numberOfItems;
 
-  void clear();
+  undefined clear();
   DOMString initialize(DOMString newItem);
   getter DOMString getItem(unsigned long index);
   DOMString insertItemBefore(DOMString newItem, unsigned long index);
   DOMString replaceItem(DOMString newItem, unsigned long index);
   DOMString removeItem(unsigned long index);
   DOMString appendItem(DOMString newItem);
-  setter void (unsigned long index, DOMString newItem);
+  setter undefined (unsigned long index, DOMString newItem);
 };
 
 [Exposed=Window]
 interface SVGAnimatedBoolean {
            attribute boolean baseVal;
   readonly attribute boolean animVal;
 };
 
@@ -238,35 +239,35 @@ interface SVGSVGElement : SVGGraphicsEle
   attribute float currentScale;
   [SameObject] readonly attribute DOMPointReadOnly currentTranslate;
 
   NodeList getIntersectionList(DOMRectReadOnly rect, SVGElement? referenceElement);
   NodeList getEnclosureList(DOMRectReadOnly rect, SVGElement? referenceElement);
   boolean checkIntersection(SVGElement element, DOMRectReadOnly rect);
   boolean checkEnclosure(SVGElement element, DOMRectReadOnly rect);
 
-  void deselectAll();
+  undefined deselectAll();
 
   SVGNumber createSVGNumber();
   SVGLength createSVGLength();
   SVGAngle createSVGAngle();
   DOMPoint createSVGPoint();
   DOMMatrix createSVGMatrix();
   DOMRect createSVGRect();
   SVGTransform createSVGTransform();
   SVGTransform createSVGTransformFromMatrix(optional DOMMatrix2DInit matrix);
 
   Element getElementById(DOMString elementId);
 
   // Deprecated methods that have no effect when called,
   // but which are kept for compatibility reasons.
   unsigned long suspendRedraw(unsigned long maxWaitMilliseconds);
-  void unsuspendRedraw(unsigned long suspendHandleID);
-  void unsuspendRedrawAll();
-  void forceRedraw();
+  undefined unsuspendRedraw(unsigned long suspendHandleID);
+  undefined unsuspendRedrawAll();
+  undefined forceRedraw();
 };
 
 SVGSVGElement includes SVGFitToViewBox;
 SVGSVGElement includes WindowEventHandlers;
 
 [Exposed=Window]
 interface SVGGElement : SVGGraphicsElement {
 };
@@ -348,38 +349,38 @@ interface SVGTransform {
   const unsigned short SVG_TRANSFORM_ROTATE = 4;
   const unsigned short SVG_TRANSFORM_SKEWX = 5;
   const unsigned short SVG_TRANSFORM_SKEWY = 6;
 
   readonly attribute unsigned short type;
   [SameObject] readonly attribute DOMMatrix matrix;
   readonly attribute float angle;
 
-  void setMatrix(optional DOMMatrix2DInit matrix);
-  void setTranslate(float tx, float ty);
-  void setScale(float sx, float sy);
-  void setRotate(float angle, float cx, float cy);
-  void setSkewX(float angle);
-  void setSkewY(float angle);
+  undefined setMatrix(optional DOMMatrix2DInit matrix);
+  undefined setTranslate(float tx, float ty);
+  undefined setScale(float sx, float sy);
+  undefined setRotate(float angle, float cx, float cy);
+  undefined setSkewX(float angle);
+  undefined setSkewY(float angle);
 };
 
 [Exposed=Window]
 interface SVGTransformList {
 
   readonly attribute unsigned long length;
   readonly attribute unsigned long numberOfItems;
 
-  void clear();
+  undefined clear();
   SVGTransform initialize(SVGTransform newItem);
   getter SVGTransform getItem(unsigned long index);
   SVGTransform insertItemBefore(SVGTransform newItem, unsigned long index);
   SVGTransform replaceItem(SVGTransform newItem, unsigned long index);
   SVGTransform removeItem(unsigned long index);
   SVGTransform appendItem(SVGTransform newItem);
-  setter void (unsigned long index, SVGTransform newItem);
+  setter undefined (unsigned long index, SVGTransform newItem);
 
   // Additional methods not common to other list interfaces.
   SVGTransform createSVGTransformFromMatrix(optional DOMMatrix2DInit matrix);
   SVGTransform? consolidate();
 };
 
 [Exposed=Window]
 interface SVGAnimatedTransformList {
@@ -461,24 +462,24 @@ interface mixin SVGAnimatedPoints {
 };
 
 [Exposed=Window]
 interface SVGPointList {
 
   readonly attribute unsigned long length;
   readonly attribute unsigned long numberOfItems;
 
-  void clear();
+  undefined clear();
   DOMPoint initialize(DOMPoint newItem);
   getter DOMPoint getItem(unsigned long index);
   DOMPoint insertItemBefore(DOMPoint newItem, unsigned long index);
   DOMPoint replaceItem(DOMPoint newItem, unsigned long index);
   DOMPoint removeItem(unsigned long index);
   DOMPoint appendItem(DOMPoint newItem);
-  setter void (unsigned long index, DOMPoint newItem);
+  setter undefined (unsigned long index, DOMPoint newItem);
 };
 
 [Exposed=Window]
 interface SVGPolylineElement : SVGGeometryElement {
 };
 
 SVGPolylineElement includes SVGAnimatedPoints;
 
@@ -502,17 +503,17 @@ interface SVGTextContentElement : SVGGra
   long getNumberOfChars();
   float getComputedTextLength();
   float getSubStringLength(unsigned long charnum, unsigned long nchars);
   DOMPoint getStartPositionOfChar(unsigned long charnum);
   DOMPoint getEndPositionOfChar(unsigned long charnum);
   DOMRect getExtentOfChar(unsigned long charnum);
   float getRotationOfChar(unsigned long charnum);
   long getCharNumAtPosition(optional DOMPointInit point = {});
-  void selectSubString(unsigned long charnum, unsigned long nchars);
+  undefined selectSubString(unsigned long charnum, unsigned long nchars);
 };
 
 [Exposed=Window]
 interface SVGTextPositioningElement : SVGTextContentElement {
   [SameObject] readonly attribute SVGAnimatedLengthList x;
   [SameObject] readonly attribute SVGAnimatedLengthList y;
   [SameObject] readonly attribute SVGAnimatedLengthList dx;
   [SameObject] readonly attribute SVGAnimatedLengthList dy;
@@ -584,18 +585,18 @@ interface SVGMarkerElement : SVGElement 
   [SameObject] readonly attribute SVGAnimatedLength refY;
   [SameObject] readonly attribute SVGAnimatedEnumeration markerUnits;
   [SameObject] readonly attribute SVGAnimatedLength markerWidth;
   [SameObject] readonly attribute SVGAnimatedLength markerHeight;
   [SameObject] readonly attribute SVGAnimatedEnumeration orientType;
   [SameObject] readonly attribute SVGAnimatedAngle orientAngle;
   attribute DOMString orient;
 
-  void setOrientToAuto();
-  void setOrientToAngle(SVGAngle angle);
+  undefined setOrientToAuto();
+  undefined setOrientToAngle(SVGAngle angle);
 };
 
 SVGMarkerElement includes SVGFitToViewBox;
 
 [Exposed=Window]
 interface SVGGradientElement : SVGElement {
 
   // Spread Method Types
@@ -667,14 +668,27 @@ interface SVGAElement : SVGGraphicsEleme
   attribute DOMString type;
 
   attribute DOMString text;
 
   attribute DOMString referrerPolicy;
 };
 
 SVGAElement includes SVGURIReference;
-SVGAElement includes HTMLHyperlinkElementUtils;
+
+// Inline HTMLHyperlinkElementUtils except href, which conflicts.
+partial interface SVGAElement {
+  readonly attribute USVString origin;
+  [CEReactions] attribute USVString protocol;
+  [CEReactions] attribute USVString username;
+  [CEReactions] attribute USVString password;
+  [CEReactions] attribute USVString host;
+  [CEReactions] attribute USVString hostname;
+  [CEReactions] attribute USVString port;
+  [CEReactions] attribute USVString pathname;
+  [CEReactions] attribute USVString search;
+  [CEReactions] attribute USVString hash;
+};
 
 [Exposed=Window]
 interface SVGViewElement : SVGElement {};
 
 SVGViewElement includes SVGFitToViewBox;

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_blend_equation_advanced_coherent.idl
@@ -0,0 +1,23 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_blend_equation_advanced_coherent Extension Draft Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_blend_equation_advanced_coherent/)
+
+[Exposed=Window, LegacyNoInterfaceObject]
+interface WEBGL_blend_equation_advanced_coherent  {
+  const GLenum MULTIPLY       = 0x9294;
+  const GLenum SCREEN         = 0x9295;
+  const GLenum OVERLAY        = 0x9296;
+  const GLenum DARKEN         = 0x9297;
+  const GLenum LIGHTEN        = 0x9298;
+  const GLenum COLORDODGE     = 0x9299;
+  const GLenum COLORBURN      = 0x929A;
+  const GLenum HARDLIGHT      = 0x929B;
+  const GLenum SOFTLIGHT      = 0x929C;
+  const GLenum DIFFERENCE     = 0x929E;
+  const GLenum EXCLUSION      = 0x92A0;
+  const GLenum HSL_HUE        = 0x92AD;
+  const GLenum HSL_SATURATION = 0x92AE;
+  const GLenum HSL_COLOR      = 0x92AF;
+  const GLenum HSL_LUMINOSITY = 0x92B0;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_color_buffer_float.idl
@@ -0,0 +1,11 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_color_buffer_float Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_color_buffer_float/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_color_buffer_float {
+  const GLenum RGBA32F_EXT = 0x8814;
+  const GLenum FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT = 0x8211;
+  const GLenum UNSIGNED_NORMALIZED_EXT = 0x8C17;
+}; // interface WEBGL_color_buffer_float

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_compressed_texture_astc.idl
@@ -0,0 +1,41 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_compressed_texture_astc Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_compressed_texture_astc {
+    /* Compressed Texture Format */
+    const GLenum COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0;
+    const GLenum COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93B1;
+    const GLenum COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93B2;
+    const GLenum COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93B3;
+    const GLenum COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93B4;
+    const GLenum COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93B5;
+    const GLenum COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93B6;
+    const GLenum COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93B7;
+    const GLenum COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93B8;
+    const GLenum COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93B9;
+    const GLenum COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93BA;
+    const GLenum COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93BB;
+    const GLenum COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93BC;
+    const GLenum COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93BD;
+
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93D0;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93D1;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93D2;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93D3;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93D4;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93D5;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93D6;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93D7;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93D8;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93D9;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93DA;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93DB;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93DC;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93DD;
+
+    // Profile query support.
+    sequence<DOMString> getSupportedProfiles();
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_compressed_texture_etc.idl
@@ -0,0 +1,19 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_compressed_texture_etc Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_etc/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_compressed_texture_etc {
+    /* Compressed Texture Formats */
+    const GLenum COMPRESSED_R11_EAC                        = 0x9270;
+    const GLenum COMPRESSED_SIGNED_R11_EAC                 = 0x9271;
+    const GLenum COMPRESSED_RG11_EAC                       = 0x9272;
+    const GLenum COMPRESSED_SIGNED_RG11_EAC                = 0x9273;
+    const GLenum COMPRESSED_RGB8_ETC2                      = 0x9274;
+    const GLenum COMPRESSED_SRGB8_ETC2                     = 0x9275;
+    const GLenum COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2  = 0x9276;
+    const GLenum COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277;
+    const GLenum COMPRESSED_RGBA8_ETC2_EAC                 = 0x9278;
+    const GLenum COMPRESSED_SRGB8_ALPHA8_ETC2_EAC          = 0x9279;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_compressed_texture_etc1.idl
@@ -0,0 +1,10 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_compressed_texture_etc1 Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_etc1/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_compressed_texture_etc1 {
+    /* Compressed Texture Format */
+    const GLenum COMPRESSED_RGB_ETC1_WEBGL = 0x8D64;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_compressed_texture_pvrtc.idl
@@ -0,0 +1,13 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_compressed_texture_pvrtc Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_pvrtc/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_compressed_texture_pvrtc {
+    /* Compressed Texture Formats */
+    const GLenum COMPRESSED_RGB_PVRTC_4BPPV1_IMG      = 0x8C00;
+    const GLenum COMPRESSED_RGB_PVRTC_2BPPV1_IMG      = 0x8C01;
+    const GLenum COMPRESSED_RGBA_PVRTC_4BPPV1_IMG     = 0x8C02;
+    const GLenum COMPRESSED_RGBA_PVRTC_2BPPV1_IMG     = 0x8C03;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_compressed_texture_s3tc.idl
@@ -0,0 +1,13 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_compressed_texture_s3tc Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_s3tc/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_compressed_texture_s3tc {
+    /* Compressed Texture Formats */
+    const GLenum COMPRESSED_RGB_S3TC_DXT1_EXT        = 0x83F0;
+    const GLenum COMPRESSED_RGBA_S3TC_DXT1_EXT       = 0x83F1;
+    const GLenum COMPRESSED_RGBA_S3TC_DXT3_EXT       = 0x83F2;
+    const GLenum COMPRESSED_RGBA_S3TC_DXT5_EXT       = 0x83F3;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_compressed_texture_s3tc_srgb.idl
@@ -0,0 +1,13 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_compressed_texture_s3tc_srgb Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_s3tc_srgb/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_compressed_texture_s3tc_srgb {
+    /* Compressed Texture Formats */
+    const GLenum COMPRESSED_SRGB_S3TC_DXT1_EXT        = 0x8C4C;
+    const GLenum COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT  = 0x8C4D;
+    const GLenum COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT  = 0x8C4E;
+    const GLenum COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT  = 0x8C4F;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_debug_renderer_info.idl
@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_debug_renderer_info Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_debug_renderer_info {
+
+      const GLenum UNMASKED_VENDOR_WEBGL            = 0x9245;
+      const GLenum UNMASKED_RENDERER_WEBGL          = 0x9246;
+
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_debug_shaders.idl
@@ -0,0 +1,11 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_debug_shaders Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_shaders/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_debug_shaders {
+
+      DOMString getTranslatedShaderSource(WebGLShader shader);
+
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_depth_texture.idl
@@ -0,0 +1,9 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_depth_texture Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_depth_texture {
+  const GLenum UNSIGNED_INT_24_8_WEBGL = 0x84FA;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_draw_buffers.idl
@@ -0,0 +1,46 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_draw_buffers Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_draw_buffers/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_draw_buffers {
+    const GLenum COLOR_ATTACHMENT0_WEBGL     = 0x8CE0;
+    const GLenum COLOR_ATTACHMENT1_WEBGL     = 0x8CE1;
+    const GLenum COLOR_ATTACHMENT2_WEBGL     = 0x8CE2;
+    const GLenum COLOR_ATTACHMENT3_WEBGL     = 0x8CE3;
+    const GLenum COLOR_ATTACHMENT4_WEBGL     = 0x8CE4;
+    const GLenum COLOR_ATTACHMENT5_WEBGL     = 0x8CE5;
+    const GLenum COLOR_ATTACHMENT6_WEBGL     = 0x8CE6;
+    const GLenum COLOR_ATTACHMENT7_WEBGL     = 0x8CE7;
+    const GLenum COLOR_ATTACHMENT8_WEBGL     = 0x8CE8;
+    const GLenum COLOR_ATTACHMENT9_WEBGL     = 0x8CE9;
+    const GLenum COLOR_ATTACHMENT10_WEBGL    = 0x8CEA;
+    const GLenum COLOR_ATTACHMENT11_WEBGL    = 0x8CEB;
+    const GLenum COLOR_ATTACHMENT12_WEBGL    = 0x8CEC;
+    const GLenum COLOR_ATTACHMENT13_WEBGL    = 0x8CED;
+    const GLenum COLOR_ATTACHMENT14_WEBGL    = 0x8CEE;
+    const GLenum COLOR_ATTACHMENT15_WEBGL    = 0x8CEF;
+
+    const GLenum DRAW_BUFFER0_WEBGL          = 0x8825;
+    const GLenum DRAW_BUFFER1_WEBGL          = 0x8826;
+    const GLenum DRAW_BUFFER2_WEBGL          = 0x8827;
+    const GLenum DRAW_BUFFER3_WEBGL          = 0x8828;
+    const GLenum DRAW_BUFFER4_WEBGL          = 0x8829;
+    const GLenum DRAW_BUFFER5_WEBGL          = 0x882A;
+    const GLenum DRAW_BUFFER6_WEBGL          = 0x882B;
+    const GLenum DRAW_BUFFER7_WEBGL          = 0x882C;
+    const GLenum DRAW_BUFFER8_WEBGL          = 0x882D;
+    const GLenum DRAW_BUFFER9_WEBGL          = 0x882E;
+    const GLenum DRAW_BUFFER10_WEBGL         = 0x882F;
+    const GLenum DRAW_BUFFER11_WEBGL         = 0x8830;
+    const GLenum DRAW_BUFFER12_WEBGL         = 0x8831;
+    const GLenum DRAW_BUFFER13_WEBGL         = 0x8832;
+    const GLenum DRAW_BUFFER14_WEBGL         = 0x8833;
+    const GLenum DRAW_BUFFER15_WEBGL         = 0x8834;
+
+    const GLenum MAX_COLOR_ATTACHMENTS_WEBGL = 0x8CDF;
+    const GLenum MAX_DRAW_BUFFERS_WEBGL      = 0x8824;
+
+    undefined drawBuffersWEBGL(sequence<GLenum> buffers);
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_draw_instanced_base_vertex_base_instance.idl
@@ -0,0 +1,14 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_draw_instanced_base_vertex_base_instance Extension Draft Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_draw_instanced_base_vertex_base_instance/)
+
+[Exposed=Window, LegacyNoInterfaceObject]
+interface WEBGL_draw_instanced_base_vertex_base_instance {
+  undefined drawArraysInstancedBaseInstanceWEBGL(
+      GLenum mode, GLint first, GLsizei count,
+      GLsizei instanceCount, GLuint baseInstance);
+  undefined drawElementsInstancedBaseVertexBaseInstanceWEBGL(
+      GLenum mode, GLsizei count, GLenum type, GLintptr offset,
+      GLsizei instanceCount, GLint baseVertex, GLuint baseInstance);
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_lose_context.idl
@@ -0,0 +1,10 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_lose_context Khronos Ratified Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_lose_context/)
+
+[Exposed=(Window,Worker), LegacyNoInterfaceObject]
+interface WEBGL_lose_context {
+      undefined loseContext();
+      undefined restoreContext();
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_multi_draw.idl
@@ -0,0 +1,32 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_multi_draw Extension Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_multi_draw/)
+
+[Exposed=Window, LegacyNoInterfaceObject]
+interface WEBGL_multi_draw {
+  undefined multiDrawArraysWEBGL(
+      GLenum mode,
+      (Int32Array or sequence<GLint>) firstsList, GLuint firstsOffset,
+      (Int32Array or sequence<GLsizei>) countsList, GLuint countsOffset,
+      GLsizei drawcount);
+  undefined multiDrawElementsWEBGL(
+      GLenum mode,
+      (Int32Array or sequence<GLint>) countsList, GLuint countsOffset,
+      GLenum type,
+      (Int32Array or sequence<GLsizei>) offsetsList, GLuint offsetsOffset,
+      GLsizei drawcount);
+  undefined multiDrawArraysInstancedWEBGL(
+      GLenum mode,
+      (Int32Array or sequence<GLint>) firstsList, GLuint firstsOffset,
+      (Int32Array or sequence<GLsizei>) countsList, GLuint countsOffset,
+      (Int32Array or sequence<GLsizei>) instanceCountsList, GLuint instanceCountsOffset,
+      GLsizei drawcount);
+  undefined multiDrawElementsInstancedWEBGL(
+      GLenum mode,
+      (Int32Array or sequence<GLint>) countsList, GLuint countsOffset,
+      GLenum type,
+      (Int32Array or sequence<GLsizei>) offsetsList, GLuint offsetsOffset,
+      (Int32Array or sequence<GLsizei>) instanceCountsList, GLuint instanceCountsOffset,
+      GLsizei drawcount);
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/WEBGL_multi_draw_instanced_base_vertex_base_instance.idl
@@ -0,0 +1,26 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGL WEBGL_multi_draw_instanced_base_vertex_base_instance Extension Draft Specification (https://www.khronos.org/registry/webgl/extensions/WEBGL_multi_draw_instanced_base_vertex_base_instance/)
+
+[Exposed=Window, LegacyNoInterfaceObject]
+interface WEBGL_multi_draw_instanced_base_vertex_base_instance {
+  undefined multiDrawArraysInstancedBaseInstanceWEBGL(
+      GLenum mode,
+      (Int32Array or sequence<GLint>) firstsList, GLuint firstsOffset,
+      (Int32Array or sequence<GLsizei>) countsList, GLuint countsOffset,
+      (Int32Array or sequence<GLsizei>) instanceCountsList, GLuint instanceCountsOffset,
+      (Uint32Array or sequence<GLuint>) baseInstancesList, GLuint baseInstancesOffset,
+      GLsizei drawCount
+  );
+  undefined multiDrawElementsInstancedBaseVertexBaseInstanceWEBGL(
+      GLenum mode,
+      (Int32Array or sequence<GLsizei>) countsList, GLuint countsOffset,
+      GLenum type,
+      (Int32Array or sequence<GLsizei>) offsetsList, GLuint offsetsOffset,
+      (Int32Array or sequence<GLsizei>) instanceCountsList, GLuint instanceCountsOffset,
+      (Int32Array or sequence<GLint>) baseVerticesList, GLuint baseVerticesOffset,
+      (Uint32Array or sequence<GLuint>) baseInstancesList, GLuint baseInstancesOffset,
+      GLsizei drawCount
+  );
+};

--- a/testing/web-platform/tests/interfaces/anchors.idl
+++ b/testing/web-platform/tests/interfaces/anchors.idl
@@ -2,26 +2,27 @@
 // Content was automatically extracted by Reffy into webref
 // (https://github.com/w3c/webref)
 // Source: WebXR Anchors Module (https://immersive-web.github.io/anchors/)
 
 [SecureContext, Exposed=Window]
 interface XRAnchor {
   readonly attribute XRSpace anchorSpace;
 
-  void delete();
+  undefined delete();
 };
 
 partial interface XRFrame {
   Promise<XRAnchor> createAnchor(XRRigidTransform pose, XRSpace space);
 };
 
 partial interface XRHitTestResult {
   Promise<XRAnchor> createAnchor();
 };
 
+[Exposed=Window]
 interface XRAnchorSet {
   readonly setlike<XRAnchor>;
 };
 
 partial interface XRFrame {
   [SameObject] readonly attribute XRAnchorSet trackedAnchors;
 };

--- a/testing/web-platform/tests/interfaces/background-fetch.idl
+++ b/testing/web-platform/tests/interfaces/background-fetch.idl
@@ -80,10 +80,10 @@ interface BackgroundFetchEvent : Extenda
 
 dictionary BackgroundFetchEventInit : ExtendableEventInit {
   required BackgroundFetchRegistration registration;
 };
 
 [Exposed=ServiceWorker]
 interface BackgroundFetchUpdateUIEvent : BackgroundFetchEvent {
   constructor(DOMString type, BackgroundFetchEventInit init);
-  Promise<void> updateUI(optional BackgroundFetchUIOptions options = {});
+  Promise<undefined> updateUI(optional BackgroundFetchUIOptions options = {});
 };

--- a/testing/web-platform/tests/interfaces/construct-stylesheets.idl
+++ b/testing/web-platform/tests/interfaces/construct-stylesheets.idl
@@ -1,17 +1,17 @@
 // GENERATED CONTENT - DO NOT EDIT
 // Content was automatically extracted by Reffy into webref
 // (https://github.com/w3c/webref)
 // Source: Constructable Stylesheet Objects (https://wicg.github.io/construct-stylesheets/)
 
 partial interface CSSStyleSheet {
   constructor(optional CSSStyleSheetInit options = {});
   Promise<CSSStyleSheet> replace(USVString text);
-  void replaceSync(USVString text);
+  undefined replaceSync(USVString text);
 };
 
 dictionary CSSStyleSheetInit {
   (MediaList or DOMString) media = "";
   DOMString title = "";
   boolean alternate = false;
   boolean disabled = false;
 };

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/contact-api.idl
@@ -0,0 +1,32 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Contact Picker API (https://wicg.github.io/contact-api/spec/)
+
+[Exposed=Window]
+partial interface Navigator {
+  [SecureContext, SameObject] readonly attribute ContactsManager contacts;
+};
+
+enum ContactProperty { "address", "email", "icon", "name", "tel" };
+
+[Exposed=Window]
+interface ContactAddress : PaymentAddress {};
+
+dictionary ContactInfo {
+    sequence<ContactAddress> address;
+    sequence<DOMString> email;
+    sequence<Blob> icon;
+    sequence<DOMString> name;
+    sequence<DOMString> tel;
+};
+
+dictionary ContactsSelectOptions {
+    boolean multiple = false;
+};
+
+[Exposed=(Window,SecureContext)]
+interface ContactsManager {
+    Promise<sequence<ContactProperty>> getProperties();
+    Promise<sequence<ContactInfo>> select(sequence<ContactProperty> properties, optional ContactsSelectOptions options = {});
+};

--- a/testing/web-platform/tests/interfaces/content-index.idl
+++ b/testing/web-platform/tests/interfaces/content-index.idl
@@ -25,18 +25,18 @@ dictionary ContentDescription {
   required DOMString description;
   ContentCategory category = "";
   sequence<ImageResource> icons = [];
   required USVString url;
 };
 
 [Exposed=(Window,Worker)]
 interface ContentIndex {
-  Promise<void> add(ContentDescription description);
-  Promise<void> delete(DOMString id);
+  Promise<undefined> add(ContentDescription description);
+  Promise<undefined> delete(DOMString id);
   Promise<sequence<ContentDescription>> getAll();
 };
 
 dictionary ContentIndexEventInit : ExtendableEventInit {
   required DOMString id;
 };
 
 [Exposed=ServiceWorker]

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/crash-reporting.idl
@@ -0,0 +1,10 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Crash Reporting (https://wicg.github.io/crash-reporting/)
+
+[Exposed=(Window,Worker)]
+interface CrashReportBody : ReportBody {
+  [Default] object toJSON();
+  readonly attribute DOMString? reason;
+};

--- a/testing/web-platform/tests/interfaces/credential-management.idl
+++ b/testing/web-platform/tests/interfaces/credential-management.idl
@@ -19,17 +19,17 @@ partial interface Navigator {
   [SecureContext, SameObject] readonly attribute CredentialsContainer credentials;
 };
 
 [Exposed=Window, SecureContext]
 interface CredentialsContainer {
   Promise<Credential?> get(optional CredentialRequestOptions options = {});
   Promise<Credential> store(Credential credential);
   Promise<Credential?> create(optional CredentialCreationOptions options = {});
-  Promise<void> preventSilentAccess();
+  Promise<undefined> preventSilentAccess();
 };
 
 dictionary CredentialData {
   required USVString id;
 };
 
 dictionary CredentialRequestOptions {
   CredentialMediationRequirement mediation = "optional";

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/css-animations-2.idl
@@ -0,0 +1,9 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: CSS Animations Level 2 (https://drafts.csswg.org/css-animations-2/)
+
+[Exposed=Window]
+interface CSSAnimation : Animation {
+  readonly attribute CSSOMString animationName;
+};

--- a/testing/web-platform/tests/interfaces/css-font-loading.idl
+++ b/testing/web-platform/tests/interfaces/css-font-loading.idl
@@ -51,18 +51,16 @@ dictionary FontFaceSetLoadEventInit : Ev
 [Exposed=(Window,Worker)]
 interface FontFaceSetLoadEvent : Event {
   constructor(CSSOMString type, optional FontFaceSetLoadEventInit eventInitDict = {});
   [SameObject] readonly attribute FrozenArray<FontFace> fontfaces;
 };
 
 enum FontFaceSetLoadStatus { "loading", "loaded" };
 
-callback ForEachCallback = undefined (FontFace font, long index, FontFaceSet self);
-
 [Exposed=(Window,Worker)]
 interface FontFaceSet : EventTarget {
   constructor(sequence<FontFace> initialFaces);
 
   // FontFaceSet is Set-like!
   setlike<FontFace>;
   FontFaceSet add(FontFace font);
   boolean delete(FontFace font);

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/css-highlight-api.idl
@@ -0,0 +1,20 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: CSS Custom Highlight API Module Level 1 (https://drafts.csswg.org/css-highlight-api-1/)
+
+[Exposed=Window]
+interface Highlight {
+  constructor(AbstractRange... initialRanges);
+  setlike<AbstractRange>;
+  attribute long priority;
+};
+
+partial namespace CSS {
+  readonly attribute HighlightRegistry highlights;
+};
+
+[Exposed=Window]
+interface HighlightRegistry {
+  maplike<DOMString, Highlight>;
+};

rename from testing/web-platform/tests/interfaces/css-images.idl
rename to testing/web-platform/tests/interfaces/css-images-4.idl

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/css-layout-api.idl
@@ -0,0 +1,147 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: CSS Layout API Level 1 (https://drafts.css-houdini.org/css-layout-api-1/)
+
+partial namespace CSS {
+    [SameObject] readonly attribute Worklet layoutWorklet;
+};
+
+[Global=(Worklet,LayoutWorklet),Exposed=LayoutWorklet]
+interface LayoutWorkletGlobalScope : WorkletGlobalScope {
+    undefined registerLayout(DOMString name, VoidFunction layoutCtor);
+};
+
+[Exposed=LayoutWorklet]
+dictionary LayoutOptions {
+  ChildDisplayType childDisplay = "block";
+  LayoutSizingMode sizing = "block-like";
+};
+
+[Exposed=LayoutWorklet]
+enum ChildDisplayType {
+    "block", // default - "blockifies" the child boxes.
+    "normal",
+};
+
+[Exposed=LayoutWorklet]
+enum LayoutSizingMode {
+    "block-like", // default - Sizing behaves like block containers.
+    "manual", // Sizing is specified by the web developer.
+};
+
+[Exposed=LayoutWorklet]
+interface LayoutChild {
+    readonly attribute StylePropertyMapReadOnly styleMap;
+
+    Promise<IntrinsicSizes> intrinsicSizes();
+    Promise<LayoutFragment> layoutNextFragment(LayoutConstraintsOptions constraints, ChildBreakToken breakToken);
+};
+
+[Exposed=LayoutWorklet]
+interface LayoutFragment {
+    readonly attribute double inlineSize;
+    readonly attribute double blockSize;
+
+    attribute double inlineOffset;
+    attribute double blockOffset;
+
+    readonly attribute any data;
+
+    readonly attribute ChildBreakToken? breakToken;
+};
+
+[Exposed=LayoutWorklet]
+interface IntrinsicSizes {
+  readonly attribute double minContentSize;
+  readonly attribute double maxContentSize;
+};
+
+[Exposed=LayoutWorklet]
+interface LayoutConstraints {
+    readonly attribute double availableInlineSize;
+    readonly attribute double availableBlockSize;
+
+    readonly attribute double? fixedInlineSize;
+    readonly attribute double? fixedBlockSize;
+
+    readonly attribute double percentageInlineSize;
+    readonly attribute double percentageBlockSize;
+
+    readonly attribute double? blockFragmentationOffset;
+    readonly attribute BlockFragmentationType blockFragmentationType;
+
+    readonly attribute any data;
+};
+
+enum BlockFragmentationType { "none", "page", "column", "region" };
+
+dictionary LayoutConstraintsOptions {
+    double availableInlineSize;
+    double availableBlockSize;
+
+    double fixedInlineSize;
+    double fixedBlockSize;
+
+    double percentageInlineSize;
+    double percentageBlockSize;
+
+    double blockFragmentationOffset;
+    BlockFragmentationType blockFragmentationType = "none";
+
+    any data;
+};
+
+[Exposed=LayoutWorklet]
+interface ChildBreakToken {
+    readonly attribute BreakType breakType;
+    readonly attribute LayoutChild child;
+};
+
+[Exposed=LayoutWorklet]
+interface BreakToken {
+    readonly attribute FrozenArray<ChildBreakToken> childBreakTokens;
+    readonly attribute any data;
+};
+
+dictionary BreakTokenOptions {
+    sequence<ChildBreakToken> childBreakTokens;
+    any data = null;
+};
+
+enum BreakType { "none", "line", "column", "page", "region" };
+
+[Exposed=LayoutWorklet]
+interface LayoutEdges {
+  readonly attribute double inlineStart;
+  readonly attribute double inlineEnd;
+
+  readonly attribute double blockStart;
+  readonly attribute double blockEnd;
+
+  // Convenience attributes for the sum in one direction.
+  readonly attribute double inline;
+  readonly attribute double block;
+};
+
+// This is the final return value from the author defined layout() method.
+dictionary FragmentResultOptions {
+    double inlineSize = 0;
+    double blockSize = 0;
+    double autoBlockSize = 0;
+    sequence<LayoutFragment> childFragments = [];
+    any data = null;
+    BreakTokenOptions breakToken = null;
+};
+
+[Exposed=LayoutWorklet]
+interface FragmentResult {
+    constructor(optional FragmentResultOptions options = {});
+    readonly attribute double inlineSize;
+    readonly attribute double blockSize;
+};
+
+dictionary IntrinsicSizesResultOptions {
+    double maxContentSize;
+    double minContentSize;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/css-nav.idl
@@ -0,0 +1,48 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: CSS Spatial Navigation Level 1 (https://drafts.csswg.org/css-nav-1/)
+
+enum SpatialNavigationDirection {
+    "up",
+    "down",
+    "left",
+    "right",
+};
+
+partial interface Window {
+    undefined navigate(SpatialNavigationDirection dir);
+};
+
+enum FocusableAreaSearchMode {
+    "visible",
+    "all"
+};
+
+dictionary FocusableAreasOption {
+    FocusableAreaSearchMode mode;
+};
+
+dictionary SpatialNavigationSearchOptions {
+    sequence<Node>? candidates;
+    Node? container;
+};
+
+partial interface Element {
+    Node getSpatialNavigationContainer();
+    sequence<Node> focusableAreas(optional FocusableAreasOption option = {});
+    Node? spatialNavigationSearch(SpatialNavigationDirection dir, optional SpatialNavigationSearchOptions options = {});
+};
+
+[Exposed=Window]
+interface NavigationEvent : UIEvent {
+    constructor(DOMString type,
+                optional NavigationEventInit eventInitDict = {});
+    readonly attribute SpatialNavigationDirection dir;
+    readonly attribute EventTarget? relatedTarget;
+};
+
+dictionary NavigationEventInit : UIEventInit {
+    SpatialNavigationDirection dir;
+    EventTarget? relatedTarget = null;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/css-nesting.idl
@@ -0,0 +1,19 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: CSS Nesting Module (https://drafts.csswg.org/css-nesting-1/)
+
+partial interface CSSStyleRule {
+  [SameObject] readonly attribute CSSRuleList cssRules;
+  unsigned long insertRule(CSSOMString rule, optional unsigned long index = 0);
+  undefined deleteRule(unsigned long index);
+};
+
+[Exposed=Window]
+interface CSSNestingRule : CSSRule {
+  attribute CSSOMString selectorText;
+  [SameObject, PutForwards=cssText] readonly attribute CSSStyleDeclaration style;
+  [SameObject] readonly attribute CSSRuleList cssRules;
+  unsigned long insertRule(CSSOMString rule, optional unsigned long index = 0);
+  undefined deleteRule(unsigned long index);
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/css-regions.idl
@@ -0,0 +1,29 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: CSS Regions Module Level 1 (https://drafts.csswg.org/css-regions/)
+
+partial interface Document {
+  readonly attribute NamedFlowMap namedFlows;
+};
+
+[Exposed=Window] interface NamedFlowMap {
+  maplike<CSSOMString, NamedFlow>;
+};
+
+[Exposed=Window]
+interface NamedFlow : EventTarget {
+  readonly attribute CSSOMString name;
+  readonly attribute boolean overset;
+  sequence<Region> getRegions();
+  readonly attribute short firstEmptyRegionIndex;
+  sequence<Node> getContent();
+  sequence<Region> getRegionsByContent(Node node);
+};
+
+interface mixin Region {
+  readonly attribute CSSOMString regionOverset;
+  sequence<Range>? getRegionFlowRanges();
+};
+
+Element includes Region;

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/css-transitions-2.idl
@@ -0,0 +1,9 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: CSS Transitions Level 2 (https://drafts.csswg.org/css-transitions-2/)
+
+[Exposed=Window]
+interface CSSTransition : Animation {
+  readonly attribute CSSOMString transitionProperty;
+};

--- a/testing/web-platform/tests/interfaces/css-typed-om.idl
+++ b/testing/web-platform/tests/interfaces/css-typed-om.idl
@@ -311,8 +311,80 @@ interface CSSMatrixComponent : CSSTransf
 
 dictionary CSSMatrixComponentOptions {
     boolean is2D;
 };
 
 [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
 interface CSSImageValue : CSSStyleValue {
 };
+
+[Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
+interface CSSColorValue : CSSStyleValue {
+    CSSRGB toRGB();
+    CSSHSL toHSL();
+    CSSHWB toHWB();
+    CSSGray toGray();
+    CSSLCH toLCH();
+    CSSLab toLab();
+    CSSColor toColor(CSSKeywordish colorspace);
+
+    [Exposed=Window] static CSSColorValue parse(USVString cssText);
+};
+
+[Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
+interface CSSRGB : CSSColorValue {
+    constructor(CSSNumberish r, CSSNumberish g, CSSNumberish b, optional CSSNumberish alpha = 1);
+    attribute CSSNumberish r;
+    attribute CSSNumberish g;
+    attribute CSSNumberish b;
+    attribute CSSNumberish alpha;
+};
+
+[Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
+interface CSSHSL : CSSColorValue {
+    constructor(CSSNumericValue h, CSSNumberish s, CSSNumberish l, optional CSSNumberish alpha = 1);
+    attribute CSSNumericValue h;
+    attribute CSSNumberish s;
+    attribute CSSNumberish l;
+    attribute CSSNumberish alpha;
+};
+
+[Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
+interface CSSHWB : CSSColorValue {
+    constructor(CSSNumericValue h, CSSNumberish w, CSSNumberish b, optional CSSNumberish alpha = 1);
+    attribute CSSNumericValue h;
+    attribute CSSNumberish w;
+    attribute CSSNumberish b;
+    attribute CSSNumberish alpha;
+};
+
+[Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
+interface CSSGray : CSSColorValue {
+    constructor(CSSNumberish gray, optional CSSNumberish alpha = 1);
+    attribute CSSNumberish gray;
+    attribute CSSNumberish alpha;
+};
+
+[Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
+interface CSSLCH : CSSColorValue {
+    constructor(CSSNumberish l, CSSNumberish c, CSSNumericValue h, optional CSSNumberish alpha = 1);
+    attribute CSSNumberish l;
+    attribute CSSNumberish c;
+    attribute CSSNumericValue h;
+    attribute CSSNumberish alpha;
+};
+
+[Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
+interface CSSLab : CSSColorValue {
+    constructor(CSSNumberish l, CSSNumberish a, CSSNumberish b, optional CSSNumberish alpha = 1);
+    attribute CSSNumberish l;
+    attribute CSSNumberish a;
+    attribute CSSNumberish b;
+    attribute CSSNumberish alpha;
+};
+
+[Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
+interface CSSColor : CSSColorValue {
+    constructor(sequence<(DOMString or CSSNumberish)> variant);
+    /* CSSColor(["foo", 0, 1, .5], ["bar", "yellow"], 1, fallbackColor) */
+    /* or just make the alpha and fallback successive optional args? */
+};

--- a/testing/web-platform/tests/interfaces/cssom-view.idl
+++ b/testing/web-platform/tests/interfaces/cssom-view.idl
@@ -134,35 +134,24 @@ partial interface HTMLImageElement {
 };
 
 partial interface Range {
   DOMRectList getClientRects();
   [NewObject] DOMRect getBoundingClientRect();
 };
 
 partial interface MouseEvent {
-  readonly attribute double screenX;
-  readonly attribute double screenY;
   readonly attribute double pageX;
   readonly attribute double pageY;
-  readonly attribute double clientX;
-  readonly attribute double clientY;
   readonly attribute double x;
   readonly attribute double y;
   readonly attribute double offsetX;
   readonly attribute double offsetY;
 };
 
-partial dictionary MouseEventInit {
-  double screenX = 0.0;
-  double screenY = 0.0;
-  double clientX = 0.0;
-  double clientY = 0.0;
-};
-
 enum CSSBoxType { "margin", "border", "padding", "content" };
 dictionary BoxQuadOptions {
   CSSBoxType box = "border";
   GeometryNode relativeTo; // XXX default document (i.e. viewport)
 };
 
 dictionary ConvertCoordinateOptions {
   CSSBoxType fromBox = "border";

--- a/testing/web-platform/tests/interfaces/cssom.idl
+++ b/testing/web-platform/tests/interfaces/cssom.idl
@@ -139,16 +139,18 @@ interface CSSStyleDeclaration {
 interface mixin ElementCSSInlineStyle {
   [SameObject, PutForwards=cssText] readonly attribute CSSStyleDeclaration style;
 };
 
 HTMLElement includes ElementCSSInlineStyle;
 
 SVGElement includes ElementCSSInlineStyle;
 
+MathMLElement includes ElementCSSInlineStyle;
+
 partial interface Window {
   [NewObject] CSSStyleDeclaration getComputedStyle(Element elt, optional CSSOMString? pseudoElt);
 };
 
 [Exposed=Window]
 namespace CSS {
   CSSOMString escape(CSSOMString ident);
 };

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/datacue.idl
@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: DataCue API (https://wicg.github.io/datacue/)
+
+[Exposed=Window]
+interface DataCue : TextTrackCue {
+  constructor(double startTime, unrestricted double endTime,
+              any value, optional DOMString type);
+  attribute any value;
+  readonly attribute DOMString type;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/depth-sensing.idl
@@ -0,0 +1,57 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebXR Depth Sensing Module (https://immersive-web.github.io/depth-sensing/)
+
+enum XRDepthUsage {
+  "cpu-optimized",
+  "gpu-optimized",
+};
+
+enum XRDepthDataFormat {
+  "luminance-alpha",
+  "float32"
+};
+
+dictionary XRDepthStateInit {
+  required sequence<XRDepthUsage> usagePreference;
+  required sequence<XRDepthDataFormat> dataFormatPreference;
+};
+
+partial dictionary XRSessionInit {
+  XRDepthStateInit depthSensing;
+};
+
+partial interface XRSession {
+  readonly attribute XRDepthUsage depthUsage;
+  readonly attribute XRDepthDataFormat depthDataFormat;
+};
+
+[SecureContext, Exposed=Window]
+interface XRDepthInformation {
+  readonly attribute unsigned long width;
+  readonly attribute unsigned long height;
+
+  [SameObject] readonly attribute XRRigidTransform normDepthBufferFromNormView;
+  readonly attribute float rawValueToMeters;
+};
+
+[Exposed=Window]
+interface XRCPUDepthInformation : XRDepthInformation {
+  [SameObject] readonly attribute ArrayBuffer data;
+
+  float getDepthInMeters(float x, float y);
+};
+
+partial interface XRFrame {
+  XRCPUDepthInformation? getDepthInformation(XRView view);
+};
+
+[Exposed=Window]
+interface XRWebGLDepthInformation : XRDepthInformation {
+  [SameObject] readonly attribute WebGLTexture texture;
+};
+
+partial interface XRWebGLBinding {
+  XRWebGLDepthInformation? getDepthInformation(XRView view);
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/device-posture.idl
@@ -0,0 +1,24 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Device Posture API (https://w3c.github.io/device-posture/)
+
+[SecureContext]
+partial interface Screen {
+  [SameObject] readonly attribute DevicePosture posture;
+};
+
+[SecureContext, Exposed=(Window)]
+interface DevicePosture : EventTarget {
+  readonly attribute DevicePostureType type;
+  attribute EventHandler onchange;
+};
+
+enum DevicePostureType {
+  "no-fold",
+  "laptop",
+  "flat",
+  "tent",
+  "tablet",
+  "book"
+};

--- a/testing/web-platform/tests/interfaces/dom.idl
+++ b/testing/web-platform/tests/interfaces/dom.idl
@@ -88,16 +88,18 @@ interface AbortController {
 
   [SameObject] readonly attribute AbortSignal signal;
 
   undefined abort();
 };
 
 [Exposed=(Window,Worker)]
 interface AbortSignal : EventTarget {
+  [NewObject] static AbortSignal abort();
+
   readonly attribute boolean aborted;
 
   attribute EventHandler onabort;
 };
 interface mixin NonElementParentNode {
   Element? getElementById(DOMString elementId);
 };
 Document includes NonElementParentNode;

--- a/testing/web-platform/tests/interfaces/encrypted-media.idl
+++ b/testing/web-platform/tests/interfaces/encrypted-media.idl
@@ -33,18 +33,17 @@ dictionary MediaKeySystemMediaCapability
 [Exposed=Window, SecureContext] interface MediaKeySystemAccess {
     readonly        attribute DOMString keySystem;
     MediaKeySystemConfiguration getConfiguration ();
     Promise<MediaKeys>          createMediaKeys ();
 };
 
 enum MediaKeySessionType {
     "temporary",
-    "persistent-license",
-    "persistent-usage-record"
+    "persistent-license"
 };
 
 [Exposed=Window, SecureContext] interface MediaKeys {
     MediaKeySession  createSession (optional MediaKeySessionType sessionType = "temporary");
     Promise<boolean> setServerCertificate (BufferSource serverCertificate);
 };
 
 [Exposed=Window, SecureContext] interface MediaKeySession : EventTarget {

--- a/testing/web-platform/tests/interfaces/filter-effects.idl
+++ b/testing/web-platform/tests/interfaces/filter-effects.idl
@@ -1,13 +1,14 @@
 // GENERATED CONTENT - DO NOT EDIT
 // Content was automatically extracted by Reffy into webref
 // (https://github.com/w3c/webref)
 // Source: Filter Effects Module Level 1 (https://drafts.fxtf.org/filter-effects-1/)
 
+[Exposed=Window]
 interface SVGFilterElement : SVGElement {
   readonly attribute SVGAnimatedEnumeration filterUnits;
   readonly attribute SVGAnimatedEnumeration primitiveUnits;
   readonly attribute SVGAnimatedLength x;
   readonly attribute SVGAnimatedLength y;
   readonly attribute SVGAnimatedLength width;
   readonly attribute SVGAnimatedLength height;
 };
@@ -17,16 +18,17 @@ SVGFilterElement includes SVGURIReferenc
 interface mixin SVGFilterPrimitiveStandardAttributes {
   readonly attribute SVGAnimatedLength x;
   readonly attribute SVGAnimatedLength y;
   readonly attribute SVGAnimatedLength width;
   readonly attribute SVGAnimatedLength height;
   readonly attribute SVGAnimatedString result;
 };
 
+[Exposed=Window]
 interface SVGFEBlendElement : SVGElement {
 
   // Blend Mode Types
   const unsigned short SVG_FEBLEND_MODE_UNKNOWN = 0;
   const unsigned short SVG_FEBLEND_MODE_NORMAL = 1;
   const unsigned short SVG_FEBLEND_MODE_MULTIPLY = 2;
   const unsigned short SVG_FEBLEND_MODE_SCREEN = 3;
   const unsigned short SVG_FEBLEND_MODE_DARKEN = 4;
@@ -45,38 +47,41 @@ interface SVGFEBlendElement : SVGElement
 
   readonly attribute SVGAnimatedString in1;
   readonly attribute SVGAnimatedString in2;
   readonly attribute SVGAnimatedEnumeration mode;
 };
 
 SVGFEBlendElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEColorMatrixElement : SVGElement {
 
   // Color Matrix Types
   const unsigned short SVG_FECOLORMATRIX_TYPE_UNKNOWN = 0;
   const unsigned short SVG_FECOLORMATRIX_TYPE_MATRIX = 1;
   const unsigned short SVG_FECOLORMATRIX_TYPE_SATURATE = 2;
   const unsigned short SVG_FECOLORMATRIX_TYPE_HUEROTATE = 3;
   const unsigned short SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA = 4;
 
   readonly attribute SVGAnimatedString in1;
   readonly attribute SVGAnimatedEnumeration type;
   readonly attribute SVGAnimatedNumberList values;
 };
 
 SVGFEColorMatrixElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEComponentTransferElement : SVGElement {
   readonly attribute SVGAnimatedString in1;
 };
 
 SVGFEComponentTransferElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGComponentTransferFunctionElement : SVGElement {
 
   // Component Transfer Types
   const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN = 0;
   const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY = 1;
   const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_TABLE = 2;
   const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE = 3;
   const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_LINEAR = 4;
@@ -86,28 +91,33 @@ interface SVGComponentTransferFunctionEl
   readonly attribute SVGAnimatedNumberList tableValues;
   readonly attribute SVGAnimatedNumber slope;
   readonly attribute SVGAnimatedNumber intercept;
   readonly attribute SVGAnimatedNumber amplitude;
   readonly attribute SVGAnimatedNumber exponent;
   readonly attribute SVGAnimatedNumber offset;
 };
 
+[Exposed=Window]
 interface SVGFEFuncRElement : SVGComponentTransferFunctionElement {
 };
 
+[Exposed=Window]
 interface SVGFEFuncGElement : SVGComponentTransferFunctionElement {
 };
 
+[Exposed=Window]
 interface SVGFEFuncBElement : SVGComponentTransferFunctionElement {
 };
 
+[Exposed=Window]
 interface SVGFEFuncAElement : SVGComponentTransferFunctionElement {
 };
 
+[Exposed=Window]
 interface SVGFECompositeElement : SVGElement {
 
   // Composite Operators
   const unsigned short SVG_FECOMPOSITE_OPERATOR_UNKNOWN = 0;
   const unsigned short SVG_FECOMPOSITE_OPERATOR_OVER = 1;
   const unsigned short SVG_FECOMPOSITE_OPERATOR_IN = 2;
   const unsigned short SVG_FECOMPOSITE_OPERATOR_OUT = 3;
   const unsigned short SVG_FECOMPOSITE_OPERATOR_ATOP = 4;
@@ -120,16 +130,17 @@ interface SVGFECompositeElement : SVGEle
   readonly attribute SVGAnimatedNumber k1;
   readonly attribute SVGAnimatedNumber k2;
   readonly attribute SVGAnimatedNumber k3;
   readonly attribute SVGAnimatedNumber k4;
 };
 
 SVGFECompositeElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEConvolveMatrixElement : SVGElement {
 
   // Edge Mode Values
   const unsigned short SVG_EDGEMODE_UNKNOWN = 0;
   const unsigned short SVG_EDGEMODE_DUPLICATE = 1;
   const unsigned short SVG_EDGEMODE_WRAP = 2;
   const unsigned short SVG_EDGEMODE_NONE = 3;
 
@@ -144,48 +155,53 @@ interface SVGFEConvolveMatrixElement : S
   readonly attribute SVGAnimatedEnumeration edgeMode;
   readonly attribute SVGAnimatedNumber kernelUnitLengthX;
   readonly attribute SVGAnimatedNumber kernelUnitLengthY;
   readonly attribute SVGAnimatedBoolean preserveAlpha;
 };
 
 SVGFEConvolveMatrixElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEDiffuseLightingElement : SVGElement {
   readonly attribute SVGAnimatedString in1;
   readonly attribute SVGAnimatedNumber surfaceScale;
   readonly attribute SVGAnimatedNumber diffuseConstant;
   readonly attribute SVGAnimatedNumber kernelUnitLengthX;
   readonly attribute SVGAnimatedNumber kernelUnitLengthY;
 };
 
 SVGFEDiffuseLightingElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEDistantLightElement : SVGElement {
   readonly attribute SVGAnimatedNumber azimuth;
   readonly attribute SVGAnimatedNumber elevation;
 };
 
+[Exposed=Window]
 interface SVGFEPointLightElement : SVGElement {
   readonly attribute SVGAnimatedNumber x;
   readonly attribute SVGAnimatedNumber y;
   readonly attribute SVGAnimatedNumber z;
 };
 
+[Exposed=Window]
 interface SVGFESpotLightElement : SVGElement {
   readonly attribute SVGAnimatedNumber x;
   readonly attribute SVGAnimatedNumber y;
   readonly attribute SVGAnimatedNumber z;
   readonly attribute SVGAnimatedNumber pointsAtX;
   readonly attribute SVGAnimatedNumber pointsAtY;
   readonly attribute SVGAnimatedNumber pointsAtZ;
   readonly attribute SVGAnimatedNumber specularExponent;
   readonly attribute SVGAnimatedNumber limitingConeAngle;
 };
 
+[Exposed=Window]
 interface SVGFEDisplacementMapElement : SVGElement {
 
   // Channel Selectors
   const unsigned short SVG_CHANNEL_UNKNOWN = 0;
   const unsigned short SVG_CHANNEL_R = 1;
   const unsigned short SVG_CHANNEL_G = 2;
   const unsigned short SVG_CHANNEL_B = 3;
   const unsigned short SVG_CHANNEL_A = 4;
@@ -194,108 +210,119 @@ interface SVGFEDisplacementMapElement : 
   readonly attribute SVGAnimatedString in2;
   readonly attribute SVGAnimatedNumber scale;
   readonly attribute SVGAnimatedEnumeration xChannelSelector;
   readonly attribute SVGAnimatedEnumeration yChannelSelector;
 };
 
 SVGFEDisplacementMapElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEDropShadowElement : SVGElement {
   readonly attribute SVGAnimatedString in1;
   readonly attribute SVGAnimatedNumber dx;
   readonly attribute SVGAnimatedNumber dy;
   readonly attribute SVGAnimatedNumber stdDeviationX;
   readonly attribute SVGAnimatedNumber stdDeviationY;
 
-  void setStdDeviation(float stdDeviationX, float stdDeviationY);
+  undefined setStdDeviation(float stdDeviationX, float stdDeviationY);
 };
 
 SVGFEDropShadowElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEFloodElement : SVGElement {
 };
 
 SVGFEFloodElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEGaussianBlurElement : SVGElement {
 
   // Edge Mode Values
   const unsigned short SVG_EDGEMODE_UNKNOWN = 0;
   const unsigned short SVG_EDGEMODE_DUPLICATE = 1;
   const unsigned short SVG_EDGEMODE_WRAP = 2;
   const unsigned short SVG_EDGEMODE_NONE = 3;
 
   readonly attribute SVGAnimatedString in1;
   readonly attribute SVGAnimatedNumber stdDeviationX;
   readonly attribute SVGAnimatedNumber stdDeviationY;
   readonly attribute SVGAnimatedEnumeration edgeMode;
 
-  void setStdDeviation(float stdDeviationX, float stdDeviationY);
+  undefined setStdDeviation(float stdDeviationX, float stdDeviationY);
 };
 
 SVGFEGaussianBlurElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEImageElement : SVGElement {
   readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio;
   readonly attribute SVGAnimatedString crossOrigin;
 };
 
 SVGFEImageElement includes SVGFilterPrimitiveStandardAttributes;
 SVGFEImageElement includes SVGURIReference;
 
+[Exposed=Window]
 interface SVGFEMergeElement : SVGElement {
 };
 
 SVGFEMergeElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEMergeNodeElement : SVGElement {
   readonly attribute SVGAnimatedString in1;
 };
 
+[Exposed=Window]
 interface SVGFEMorphologyElement : SVGElement {
 
   // Morphology Operators
   const unsigned short SVG_MORPHOLOGY_OPERATOR_UNKNOWN = 0;
   const unsigned short SVG_MORPHOLOGY_OPERATOR_ERODE = 1;
   const unsigned short SVG_MORPHOLOGY_OPERATOR_DILATE = 2;
 
   readonly attribute SVGAnimatedString in1;
   readonly attribute SVGAnimatedEnumeration operator;
   readonly attribute SVGAnimatedNumber radiusX;
   readonly attribute SVGAnimatedNumber radiusY;
 };
 
 SVGFEMorphologyElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFEOffsetElement : SVGElement {
   readonly attribute SVGAnimatedString in1;
   readonly attribute SVGAnimatedNumber dx;
   readonly attribute SVGAnimatedNumber dy;
 };
 
 SVGFEOffsetElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFESpecularLightingElement : SVGElement {
   readonly attribute SVGAnimatedString in1;
   readonly attribute SVGAnimatedNumber surfaceScale;
   readonly attribute SVGAnimatedNumber specularConstant;
   readonly attribute SVGAnimatedNumber specularExponent;
   readonly attribute SVGAnimatedNumber kernelUnitLengthX;
   readonly attribute SVGAnimatedNumber kernelUnitLengthY;
 };
 
 SVGFESpecularLightingElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFETileElement : SVGElement {
   readonly attribute SVGAnimatedString in1;
 };
 
 SVGFETileElement includes SVGFilterPrimitiveStandardAttributes;
 
+[Exposed=Window]
 interface SVGFETurbulenceElement : SVGElement {
 
   // Turbulence Types
   const unsigned short SVG_TURBULENCE_TYPE_UNKNOWN = 0;
   const unsigned short SVG_TURBULENCE_TYPE_FRACTALNOISE = 1;
   const unsigned short SVG_TURBULENCE_TYPE_TURBULENCE = 2;
 
   // Stitch Options

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/floc.idl
@@ -0,0 +1,13 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Federated Learning of Cohorts (https://wicg.github.io/floc/)
+
+dictionary InterestCohort {
+  DOMString id;
+  DOMString version;
+};
+
+partial interface Document {
+    Promise<InterestCohort> interestCohort();
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/font-metrics-api.idl
@@ -0,0 +1,42 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Font Metrics API Level 1 (https://drafts.css-houdini.org/font-metrics-api-1/)
+
+partial interface Document {
+    FontMetrics measureElement(Element element);
+    FontMetrics measureText(DOMString text, StylePropertyMapReadOnly styleMap);
+};
+
+[Exposed=Window]
+interface FontMetrics {
+  readonly attribute double width;
+  readonly attribute FrozenArray<double> advances;
+
+  readonly attribute double boundingBoxLeft;
+  readonly attribute double boundingBoxRight;
+
+  readonly attribute double height;
+  readonly attribute double emHeightAscent;
+  readonly attribute double emHeightDescent;
+  readonly attribute double boundingBoxAscent;
+  readonly attribute double boundingBoxDescent;
+  readonly attribute double fontBoundingBoxAscent;
+  readonly attribute double fontBoundingBoxDescent;
+
+  readonly attribute Baseline dominantBaseline;
+  readonly attribute FrozenArray<Baseline> baselines;
+  readonly attribute FrozenArray<Font> fonts;
+};
+
+[Exposed=Window]
+interface Baseline {
+  readonly attribute DOMString name;
+  readonly attribute double value;
+};
+
+[Exposed=Window]
+interface Font {
+  readonly attribute DOMString name;
+  readonly attribute unsigned long glyphsRendered;
+};

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/frame-timing.idl
@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Frame Timing (https://wicg.github.io/frame-timing/)
+
+[Exposed=Window]
+interface PerformanceFrameTiming : PerformanceEntry {
+};

--- a/testing/web-platform/tests/interfaces/gamepad.idl
+++ b/testing/web-platform/tests/interfaces/gamepad.idl
@@ -19,16 +19,17 @@ interface GamepadButton {
   readonly attribute boolean pressed;
   readonly attribute boolean touched;
   readonly attribute double value;
 };
 
 enum GamepadMappingType {
   "",
   "standard",
+  "xr-standard",
 };
 
 [Exposed=Window]
 partial interface Navigator {
   sequence<Gamepad?> getGamepads();
 };
 
 [Exposed=Window, SecureContext]
@@ -36,8 +37,13 @@ partial interface Navigator {
 interface GamepadEvent: Event {
   constructor(DOMString type, GamepadEventInit eventInitDict);
   [SameObject] readonly attribute Gamepad gamepad;
 };
 
 dictionary GamepadEventInit : EventInit {
   required Gamepad gamepad;
 };
+
+partial interface mixin WindowEventHandlers {
+  attribute EventHandler ongamepadconnected;
+  attribute EventHandler ongamepaddisconnected;
+};

--- a/testing/web-platform/tests/interfaces/geolocation-API.idl
+++ b/testing/web-platform/tests/interfaces/geolocation-API.idl
@@ -1,52 +1,60 @@
 // GENERATED CONTENT - DO NOT EDIT
 // Content was automatically extracted by Reffy into webref
 // (https://github.com/w3c/webref)
-// Source: Geolocation API Specification (https://w3c.github.io/geolocation-api/)
+// Source: Geolocation API (https://w3c.github.io/geolocation-api/)
 
 partial interface Navigator {
   [SameObject] readonly attribute Geolocation geolocation;
 };
 
 [Exposed=Window]
 interface Geolocation {
-  undefined getCurrentPosition(PositionCallback successCallback,
-                          optional PositionErrorCallback errorCallback,
-                          optional PositionOptions options = {});
+  undefined getCurrentPosition (
+    PositionCallback successCallback,
+    optional PositionErrorCallback? errorCallback = null,
+    optional PositionOptions options = {}
+  );
 
-  long watchPosition(PositionCallback successCallback,
-                      optional PositionErrorCallback errorCallback,
-                      optional PositionOptions options = {});
+  long watchPosition (
+    PositionCallback successCallback,
+    optional PositionErrorCallback? errorCallback = null,
+    optional PositionOptions options = {}
+  );
 
-  undefined clearWatch(long watchId);
+  undefined clearWatch (long watchId);
 };
 
-callback PositionCallback = undefined (GeolocationPosition position);
+callback PositionCallback = undefined (
+  GeolocationPosition position
+);
 
-callback PositionErrorCallback = undefined (GeolocationPositionError positionError);
+callback PositionErrorCallback = undefined (
+  GeolocationPositionError positionError
+);
 
 dictionary PositionOptions {
   boolean enableHighAccuracy = false;
   [Clamp] unsigned long timeout = 0xFFFFFFFF;
   [Clamp] unsigned long maximumAge = 0;
 };
 
 [Exposed=Window, SecureContext]
 interface GeolocationPosition {
   readonly attribute GeolocationCoordinates coords;
   readonly attribute DOMTimeStamp timestamp;
 };
 
 [Exposed=Window, SecureContext]
 interface GeolocationCoordinates {
+  readonly attribute double accuracy;
   readonly attribute double latitude;
   readonly attribute double longitude;
   readonly attribute double? altitude;
-  readonly attribute double accuracy;
   readonly attribute double? altitudeAccuracy;
   readonly attribute double? heading;
   readonly attribute double? speed;
 };
 
 [Exposed=Window]
 interface GeolocationPositionError {
   const unsigned short PERMISSION_DENIED = 1;

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/tests/interfaces/gpuweb.idl
@@ -0,0 +1,1074 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebGPU (https://gpuweb.github.io/gpuweb/)
+
+interface mixin GPUObjectBase {
+    attribute USVString? label;
+};
+
+dictionary GPUObjectDescriptorBase {
+    USVString label;
+};
+
+[Exposed=Window]
+interface GPUAdapterLimits {
+    readonly attribute unsigned long maxTextureDimension1D;
+    readonly attribute unsigned long maxTextureDimension2D;
+    readonly attribute unsigned long maxTextureDimension3D;
+    readonly attribute unsigned long maxTextureArrayLayers;
+    readonly attribute unsigned long maxBindGroups;
+    readonly attribute unsigned long maxDynamicUniformBuffersPerPipelineLayout;
+    readonly attribute unsigned long maxDynamicStorageBuffersPerPipelineLayout;
+    readonly attribute unsigned long maxSampledTexturesPerShaderStage;
+    readonly attribute unsigned long maxSamplersPerShaderStage;
+    readonly attribute unsigned long maxStorageBuffersPerShaderStage;
+    readonly attribute unsigned long maxStorageTexturesPerShaderStage;
+    readonly attribute unsigned long maxUniformBuffersPerShaderStage;
+    readonly attribute unsigned long maxUniformBufferBindingSize;
+    readonly attribute unsigned long maxStorageBufferBindingSize;
+    readonly attribute unsigned long maxVertexBuffers;
+    readonly attribute unsigned long maxVertexAttributes;
+    readonly attribute unsigned long maxVertexBufferArrayStride;
+};
+
+[Exposed=Window]
+interface GPUSupportedFeatures {
+    readonly setlike<GPUFeatureName>;
+};
+
+interface mixin NavigatorGPU {
+    [SameObject] readonly attribute GPU gpu;
+};
+Navigator includes NavigatorGPU;
+WorkerNavigator includes NavigatorGPU;
+
+[Exposed=(Window, DedicatedWorker)]
+interface GPU {
+    Promise<GPUAdapter?> requestAdapter(optional GPURequestAdapterOptions options = {});
+};
+
+dictionary GPURequestAdapterOptions {
+    GPUPowerPreference powerPreference;
+};
+
+enum GPUPowerPreference {
+    "low-power",
+    "high-performance"
+};
+
+[Exposed=Window]
+interface GPUAdapter {
+    readonly attribute DOMString name;
+    [SameObject] readonly attribute GPUSupportedFeatures features;
+    [SameObject] readonly attribute GPUAdapterLimits limits;
+
+    Promise<GPUDevice> requestDevice(optional GPUDeviceDescriptor descriptor = {});
+};
+
+dictionary GPUDeviceDescriptor : GPUObjectDescriptorBase {
+    sequence<GPUFeatureName> nonGuaranteedFeatures = [];
+    record<DOMString, GPUSize32> nonGuaranteedLimits = {};
+};
+
+enum GPUFeatureName {
+    "depth-clamping",
+    "depth24unorm-stencil8",
+    "depth32float-stencil8",
+    "pipeline-statistics-query",
+    "texture-compression-bc",
+    "timestamp-query",
+};
+
+[Exposed=(Window, DedicatedWorker), Serializable]
+interface GPUDevice : EventTarget {
+    [SameObject] readonly attribute GPUSupportedFeatures features;
+    readonly attribute object limits;
+
+    [SameObject] readonly attribute GPUQueue queue;
+
+    undefined destroy();
+
+    GPUBuffer createBuffer(GPUBufferDescriptor descriptor);
+    GPUTexture createTexture(GPUTextureDescriptor descriptor);
+    GPUSampler createSampler(optional GPUSamplerDescriptor descriptor = {});
+
+    GPUBindGroupLayout createBindGroupLayout(GPUBindGroupLayoutDescriptor descriptor);
+    GPUPipelineLayout createPipelineLayout(GPUPipelineLayoutDescriptor descriptor);
+    GPUBindGroup createBindGroup(GPUBindGroupDescriptor descriptor);
+
+    GPUShaderModule createShaderModule(GPUShaderModuleDescriptor descriptor);
+    GPUComputePipeline createComputePipeline(GPUComputePipelineDescriptor descriptor);
+    GPURenderPipeline createRenderPipeline(GPURenderPipelineDescriptor descriptor);
+    Promise<GPUComputePipeline> createComputePipelineAsync(GPUComputePipelineDescriptor descriptor);
+    Promise<GPURenderPipeline> createRenderPipelineAsync(GPURenderPipelineDescriptor descriptor);
+
+    GPUCommandEncoder createCommandEncoder(optional GPUCommandEncoderDescriptor descriptor = {});
+    GPURenderBundleEncoder createRenderBundleEncoder(GPURenderBundleEncoderDescriptor descriptor);
+
+    GPUQuerySet createQuerySet(GPUQuerySetDescriptor descriptor);
+};
+GPUDevice includes GPUObjectBase;
+
+[Exposed=Window, Serializable]
+interface GPUBuffer {
+    Promise<undefined> mapAsync(GPUMapModeFlags mode, optional GPUSize64 offset = 0, optional GPUSize64 size);
+    ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size);
+    undefined unmap();
+
+    undefined destroy();
+};
+GPUBuffer includes GPUObjectBase;
+
+dictionary GPUBufferDescriptor : GPUObjectDescriptorBase {
+    required GPUSize64 size;
+    required GPUBufferUsageFlags usage;
+    boolean mappedAtCreation = false;
+};
+
+typedef [EnforceRange] unsigned long GPUBufferUsageFlags;
+[Exposed=Window]
+interface GPUBufferUsage {
+    const GPUFlagsConstant MAP_READ      = 0x0001;
+    const GPUFlagsConstant MAP_WRITE     = 0x0002;
+    const GPUFlagsConstant COPY_SRC      = 0x0004;
+    const GPUFlagsConstant COPY_DST      = 0x0008;
+    const GPUFlagsConstant INDEX         = 0x0010;
+    const GPUFlagsConstant VERTEX        = 0x0020;
+    const GPUFlagsConstant UNIFORM       = 0x0040;
+    const GPUFlagsConstant STORAGE       = 0x0080;
+    const GPUFlagsConstant INDIRECT      = 0x0100;
+    const GPUFlagsConstant QUERY_RESOLVE = 0x0200;
+};
+
+typedef [EnforceRange] unsigned long GPUMapModeFlags;
+[Exposed=Window]
+interface GPUMapMode {
+    const GPUFlagsConstant READ  = 0x0001;
+    const GPUFlagsConstant WRITE = 0x0002;
+};
+
+[Exposed=Window, Serializable]
+interface GPUTexture {
+    GPUTextureView createView(optional GPUTextureViewDescriptor descriptor = {});
+
+    undefined destroy();
+};
+GPUTexture includes GPUObjectBase;
+
+dictionary GPUTextureDescriptor : GPUObjectDescriptorBase {
+    required GPUExtent3D size;
+    GPUIntegerCoordinate mipLevelCount = 1;
+    GPUSize32 sampleCount = 1;
+    GPUTextureDimension dimension = "2d";
+    required GPUTextureFormat format;
+    required GPUTextureUsageFlags usage;
+};
+
+enum GPUTextureDimension {
+    "1d",
+    "2d",
+    "3d",
+};
+
+typedef [EnforceRange] unsigned long GPUTextureUsageFlags;
+[Exposed=Window]
+interface GPUTextureUsage {
+    const GPUFlagsConstant COPY_SRC          = 0x01;
+    const GPUFlagsConstant COPY_DST          = 0x02;
+    const GPUFlagsConstant SAMPLED           = 0x04;
+    const GPUFlagsConstant STORAGE           = 0x08;
+    const GPUFlagsConstant RENDER_ATTACHMENT = 0x10;
+};
+
+[Exposed=Window]
+interface GPUTextureView {
+};
+GPUTextureView includes GPUObjectBase;
+
+dictionary GPUTextureViewDescriptor : GPUObjectDescriptorBase {
+    GPUTextureFormat format;
+    GPUTextureViewDimension dimension;
+    GPUTextureAspect aspect = "all";
+    GPUIntegerCoordinate baseMipLevel = 0;
+    GPUIntegerCoordinate mipLevelCount;
+    GPUIntegerCoordinate baseArrayLayer = 0;
+    GPUIntegerCoordinate arrayLayerCount;
+};
+
+enum GPUTextureViewDimension {
+    "1d",
+    "2d",
+    "2d-array",
+    "cube",
+    "cube-array",
+    "3d"
+};
+
+enum GPUTextureAspect {
+    "all",
+    "stencil-only",
+    "depth-only"
+};
+
+enum GPUTextureFormat {
+    // 8-bit formats
+    "r8unorm",
+    "r8snorm",
+    "r8uint",
+    "r8sint",
+
+    // 16-bit formats
+    "r16uint",
+    "r16sint",
+    "r16float",
+    "rg8unorm",
+    "rg8snorm",
+    "rg8uint",
+    "rg8sint",
+
+    // 32-bit formats
+    "r32uint",
+    "r32sint",
+    "r32float",
+    "rg16uint",
+    "rg16sint",
+    "rg16float",
+    "rgba8unorm",
+    "rgba8unorm-srgb",
+    "rgba8snorm",
+    "rgba8uint",
+    "rgba8sint",
+    "bgra8unorm",
+    "bgra8unorm-srgb",
+    // Packed 32-bit formats
+    "rgb9e5ufloat",
+    "rgb10a2unorm",
+    "rg11b10ufloat",
+
+    // 64-bit formats
+    "rg32uint",
+    "rg32sint",
+    "rg32float",
+    "rgba16uint",
+    "rgba16sint",
+    "rgba16float",
+
+    // 128-bit formats
+    "rgba32uint",
+    "rgba32sint",
+    "rgba32float",
+
+    // Depth and stencil formats
+    "stencil8",
+    "depth16unorm",
+    "depth24plus",
+    "depth24plus-stencil8",
+    "depth32float",
+
+    // BC compressed formats usable if "texture-compression-bc" is both
+    // supported by the device/user agent and enabled in requestDevice.
+    "bc1-rgba-unorm",
+    "bc1-rgba-unorm-srgb",
+    "bc2-rgba-unorm",
+    "bc2-rgba-unorm-srgb",
+    "bc3-rgba-unorm",
+    "bc3-rgba-unorm-srgb",
+    "bc4-r-unorm",
+    "bc4-r-snorm",
+    "bc5-rg-unorm",
+    "bc5-rg-snorm",
+    "bc6h-rgb-ufloat",
+    "bc6h-rgb-float",
+    "bc7-rgba-unorm",
+    "bc7-rgba-unorm-srgb",
+
+    // "depth24unorm-stencil8" feature
+    "depth24unorm-stencil8",
+
+    // "depth32float-stencil8" feature
+    "depth32float-stencil8",
+};
+
+[Exposed=Window]
+interface GPUSampler {
+};
+GPUSampler includes GPUObjectBase;
+
+dictionary GPUSamplerDescriptor : GPUObjectDescriptorBase {
+    GPUAddressMode addressModeU = "clamp-to-edge";
+    GPUAddressMode addressModeV = "clamp-to-edge";
+    GPUAddressMode addressModeW = "clamp-to-edge";
+    GPUFilterMode magFilter = "nearest";
+    GPUFilterMode minFilter = "nearest";
+    GPUFilterMode mipmapFilter = "nearest";
+    float lodMinClamp = 0;
+    float lodMaxClamp = 0xffffffff; // TODO: What should this be? Was Number.MAX_VALUE.
+    GPUCompareFunction compare;
+    [Clamp] unsigned short maxAnisotropy = 1;
+};
+
+enum GPUAddressMode {
+    "clamp-to-edge",
+    "repeat",
+    "mirror-repeat"
+};
+
+enum GPUFilterMode {
+    "nearest",
+    "linear"
+};
+
+enum GPUCompareFunction {
+    "never",
+    "less",
+    "equal",
+    "less-equal",
+    "greater",
+    "not-equal",
+    "greater-equal",
+    "always"
+};
+
+[Exposed=Window, Serializable]
+interface GPUBindGroupLayout {
+};
+GPUBindGroupLayout includes GPUObjectBase;
+
+dictionary GPUBindGroupLayoutDescriptor : GPUObjectDescriptorBase {
+    required sequence<GPUBindGroupLayoutEntry> entries;
+};
+
+typedef [EnforceRange] unsigned long GPUShaderStageFlags;
+[Exposed=Window]
+interface GPUShaderStage {
+    const GPUFlagsConstant VERTEX   = 0x1;
+    const GPUFlagsConstant FRAGMENT = 0x2;
+    const GPUFlagsConstant COMPUTE  = 0x4;
+};
+
+dictionary GPUBindGroupLayoutEntry {
+    required GPUIndex32 binding;
+    required GPUShaderStageFlags visibility;
+
+    GPUBufferBindingLayout buffer;
+    GPUSamplerBindingLayout sampler;
+    GPUTextureBindingLayout texture;
+    GPUStorageTextureBindingLayout storageTexture;
+};
+
+enum GPUBufferBindingType {
+    "uniform",
+    "storage",
+    "read-only-storage",
+};
+
+dictionary GPUBufferBindingLayout {
+    GPUBufferBindingType type = "uniform";
+    boolean hasDynamicOffset = false;
+    GPUSize64 minBindingSize = 0;
+};
+
+enum GPUSamplerBindingType {
+    "filtering",
+    "non-filtering",
+    "comparison",
+};
+
+dictionary GPUSamplerBindingLayout {
+    GPUSamplerBindingType type = "filtering";
+};
+
+enum GPUTextureSampleType {
+  "float",
+  "unfilterable-float",
+  "depth",
+  "sint",
+  "uint",
+};
+
+dictionary GPUTextureBindingLayout {
+    GPUTextureSampleType sampleType = "float";
+    GPUTextureViewDimension viewDimension = "2d";
+    boolean multisampled = false;
+};
+
+enum GPUStorageTextureAccess {
+    "read-only",
+    "write-only",
+};
+
+dictionary GPUStorageTextureBindingLayout {
+    required GPUStorageTextureAccess access;
+    required GPUTextureFormat format;
+    GPUTextureViewDimension viewDimension = "2d";
+};
+
+[Exposed=Window]
+interface GPUBindGroup {
+};
+GPUBindGroup includes GPUObjectBase;
+
+dictionary GPUBindGroupDescriptor : GPUObjectDescriptorBase {
+    required GPUBindGroupLayout layout;
+    required sequence<GPUBindGroupEntry> entries;
+};
+
+typedef (GPUSampler or GPUTextureView or GPUBufferBinding) GPUBindingResource;
+
+dictionary GPUBindGroupEntry {
+    required GPUIndex32 binding;
+    required GPUBindingResource resource;
+};
+
+dictionary GPUBufferBinding {
+    required GPUBuffer buffer;
+    GPUSize64 offset = 0;
+    GPUSize64 size;
+};
+
+[Exposed=Window, Serializable]
+interface GPUPipelineLayout {
+};
+GPUPipelineLayout includes GPUObjectBase;
+
+dictionary GPUPipelineLayoutDescriptor : GPUObjectDescriptorBase {
+    required sequence<GPUBindGroupLayout> bindGroupLayouts;
+};
+
+enum GPUCompilationMessageType {
+    "error",
+    "warning",
+    "info"
+};
+
+[Exposed=Window, Serializable]
+interface GPUCompilationMessage {
+    readonly attribute DOMString message;
+    readonly attribute GPUCompilationMessageType type;
+    readonly attribute unsigned long long lineNum;
+    readonly attribute unsigned long long linePos;
+};
+
+[Exposed=Window, Serializable]
+interface GPUCompilationInfo {
+    readonly attribute FrozenArray<GPUCompilationMessage> messages;
+};
+
+[Exposed=Window, Serializable]
+interface GPUShaderModule {
+    Promise<GPUCompilationInfo> compilationInfo();
+};
+GPUShaderModule includes GPUObjectBase;
+
+dictionary GPUShaderModuleDescriptor : GPUObjectDescriptorBase {
+    required USVString code;
+    object sourceMap;
+};
+
+dictionary GPUPipelineDescriptorBase : GPUObjectDescriptorBase {
+    GPUPipelineLayout layout;
+};
+
+interface mixin GPUPipelineBase {
+    GPUBindGroupLayout getBindGroupLayout(unsigned long index);
+};
+
+dictionary GPUProgrammableStage {
+    required GPUShaderModule module;
+    required USVString entryPoint;
+};
+
+[Exposed=Window, Serializable]
+interface GPUComputePipeline {
+};
+GPUComputePipeline includes GPUObjectBase;
+GPUComputePipeline includes GPUPipelineBase;
+
+dictionary GPUComputePipelineDescriptor : GPUPipelineDescriptorBase {
+    required GPUProgrammableStage compute;
+};
+
+[Exposed=Window, Serializable]
+interface GPURenderPipeline {
+};
+GPURenderPipeline includes GPUObjectBase;
+GPURenderPipeline includes GPUPipelineBase;
+
+dictionary GPURenderPipelineDescriptor : GPUPipelineDescriptorBase {
+    required GPUVertexState vertex;
+    GPUPrimitiveState primitive = {};
+    GPUDepthStencilState depthStencil;
+    GPUMultisampleState multisample = {};
+    GPUFragmentState fragment;
+};
+
+enum GPUPrimitiveTopology {
+    "point-list",
+    "line-list",
+    "line-strip",
+    "triangle-list",
+    "triangle-strip"
+};
+
+dictionary GPUPrimitiveState {
+    GPUPrimitiveTopology topology = "triangle-list";
+    GPUIndexFormat stripIndexFormat;
+    GPUFrontFace frontFace = "ccw";
+    GPUCullMode cullMode = "none";
+
+    // Enable depth clamping (requires "depth-clamping" feature)
+    boolean clampDepth = false;
+};
+
+enum GPUFrontFace {
+    "ccw",
+    "cw"
+};
+
+enum GPUCullMode {
+    "none",
+    "front",
+    "back"
+};
+
+dictionary GPUMultisampleState {
+    GPUSize32 count = 1;
+    GPUSampleMask mask = 0xFFFFFFFF;
+    boolean alphaToCoverageEnabled = false;
+};
+
+dictionary GPUFragmentState: GPUProgrammableStage {
+    required sequence<GPUColorTargetState> targets;
+};
+
+dictionary GPUColorTargetState {
+    required GPUTextureFormat format;
+
+    GPUBlendState blend;
+    GPUColorWriteFlags writeMask = 0xF;  // GPUColorWrite.ALL
+};
+
+dictionary GPUBlendState {
+    required GPUBlendComponent color;
+    required GPUBlendComponent alpha;
+};
+
+typedef [EnforceRange] unsigned long GPUColorWriteFlags;
+[Exposed=Window]
+interface GPUColorWrite {
+    const GPUFlagsConstant RED   = 0x1;
+    const GPUFlagsConstant GREEN = 0x2;
+    const GPUFlagsConstant BLUE  = 0x4;
+    const GPUFlagsConstant ALPHA = 0x8;
+    const GPUFlagsConstant ALL   = 0xF;
+};
+
+dictionary GPUBlendComponent {
+    GPUBlendFactor srcFactor = "one";
+    GPUBlendFactor dstFactor = "zero";
+    GPUBlendOperation operation = "add";
+};
+
+enum GPUBlendFactor {
+    "zero",
+    "one",
+    "src",
+    "one-minus-src",
+    "src-alpha",
+    "one-minus-src-alpha",
+    "dst",
+    "one-minus-dst",
+    "dst-alpha",
+    "one-minus-dst-alpha",
+    "src-alpha-saturated",
+    "constant",
+    "one-minus-constant"
+};
+
+enum GPUBlendOperation {
+    "add",
+    "subtract",
+    "reverse-subtract",
+    "min",
+    "max"
+};
+
+dictionary GPUDepthStencilState {
+    required GPUTextureFormat format;
+
+    boolean depthWriteEnabled = false;
+    GPUCompareFunction depthCompare = "always";
+
+    GPUStencilFaceState stencilFront = {};
+    GPUStencilFaceState stencilBack = {};
+
+    GPUStencilValue stencilReadMask = 0xFFFFFFFF;
+    GPUStencilValue stencilWriteMask = 0xFFFFFFFF;
+
+    GPUDepthBias depthBias = 0;
+    float depthBiasSlopeScale = 0;
+    float depthBiasClamp = 0;
+};
+
+dictionary GPUStencilFaceState {
+    GPUCompareFunction compare = "always";
+    GPUStencilOperation failOp = "keep";
+    GPUStencilOperation depthFailOp = "keep";
+    GPUStencilOperation passOp = "keep";
+};
+
+enum GPUStencilOperation {
+    "keep",
+    "zero",
+    "replace",
+    "invert",
+    "increment-clamp",
+    "decrement-clamp",
+    "increment-wrap",
+    "decrement-wrap"
+};
+
+enum GPUIndexFormat {
+    "uint16",
+    "uint32"
+};
+
+enum GPUVertexFormat {
+    "uint8x2",
+    "uint8x4",
+    "sint8x2",
+    "sint8x4",
+    "unorm8x2",
+    "unorm8x4",
+    "snorm8x2",
+    "snorm8x4",
+    "uint16x2",
+    "uint16x4",
+    "sint16x2",
+    "sint16x4",
+    "unorm16x2",
+    "unorm16x4",
+    "snorm16x2",
+    "snorm16x4",
+    "float16x2",
+    "float16x4",
+    "float32",
+    "float32x2",
+    "float32x3",
+    "float32x4",
+    "uint32",
+    "uint32x2",
+    "uint32x3",
+    "uint32x4",
+    "sint32",
+    "sint32x2",
+    "sint32x3",
+    "sint32x4",
+};
+
+enum GPUInputStepMode {
+    "vertex",
+    "instance"
+};
+
+dictionary GPUVertexState: GPUProgrammableStage {
+    sequence<GPUVertexBufferLayout?> buffers = [];
+};
+
+dictionary GPUVertexBufferLayout {
+    required GPUSize64 arrayStride;
+    GPUInputStepMode stepMode = "vertex";
+    required sequence<GPUVertexAttribute> attributes;
+};
+
+dictionary GPUVertexAttribute {
+    required GPUVertexFormat format;
+    required GPUSize64 offset;
+
+    required GPUIndex32 shaderLocation;
+};
+
+[Exposed=Window]
+interface GPUCommandBuffer {
+    readonly attribute Promise<double> executionTime;
+};
+GPUCommandBuffer includes GPUObjectBase;
+
+dictionary GPUCommandBufferDescriptor : GPUObjectDescriptorBase {
+};
+
+[Exposed=Window]
+interface GPUCommandEncoder {
+    GPURenderPassEncoder beginRenderPass(GPURenderPassDescriptor descriptor);
+    GPUComputePassEncoder beginComputePass(optional GPUComputePassDescriptor descriptor = {});
+
+    undefined copyBufferToBuffer(
+        GPUBuffer source,
+        GPUSize64 sourceOffset,
+        GPUBuffer destination,
+        GPUSize64 destinationOffset,
+        GPUSize64 size);
+
+    undefined copyBufferToTexture(
+        GPUImageCopyBuffer source,
+        GPUImageCopyTexture destination,
+        GPUExtent3D copySize);
+
+    undefined copyTextureToBuffer(
+        GPUImageCopyTexture source,
+        GPUImageCopyBuffer destination,
+        GPUExtent3D copySize);
+
+    undefined copyTextureToTexture(
+        GPUImageCopyTexture source,
+        GPUImageCopyTexture destination,
+        GPUExtent3D copySize);
+
+    undefined pushDebugGroup(USVString groupLabel);
+    undefined popDebugGroup();
+    undefined insertDebugMarker(USVString markerLabel);
+
+    undefined writeTimestamp(GPUQuerySet querySet, GPUSize32 queryIndex);
+
+    undefined resolveQuerySet(
+        GPUQuerySet querySet,
+        GPUSize32 firstQuery,
+        GPUSize32 queryCount,
+        GPUBuffer destination,
+        GPUSize64 destinationOffset);
+
+    GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {});
+};
+GPUCommandEncoder includes GPUObjectBase;
+
+dictionary GPUCommandEncoderDescriptor : GPUObjectDescriptorBase {
+    boolean measureExecutionTime = false;
+
+    // TODO: reusability flag?
+};
+
+dictionary GPUImageDataLayout {
+    GPUSize64 offset = 0;
+    GPUSize32 bytesPerRow;
+    GPUSize32 rowsPerImage;
+};
+
+dictionary GPUImageCopyBuffer : GPUImageDataLayout {
+    required GPUBuffer buffer;
+};
+
+dictionary GPUImageCopyTexture {
+    required GPUTexture texture;
+    GPUIntegerCoordinate mipLevel = 0;
+    GPUOrigin3D origin = {};
+    GPUTextureAspect aspect = "all";
+};
+
+dictionary GPUImageCopyImageBitmap {
+    required ImageBitmap imageBitmap;
+    GPUOrigin2D origin = {};
+};
+
+interface mixin GPUProgrammablePassEncoder {
+    undefined setBindGroup(GPUIndex32 index, GPUBindGroup bindGroup,
+                      optional sequence<GPUBufferDynamicOffset> dynamicOffsets = []);
+
+    undefined setBindGroup(GPUIndex32 index, GPUBindGroup bindGroup,
+                      Uint32Array dynamicOffsetsData,
+                      GPUSize64 dynamicOffsetsDataStart,
+                      GPUSize32 dynamicOffsetsDataLength);
+
+    undefined pushDebugGroup(USVString groupLabel);
+    undefined popDebugGroup();
+    undefined insertDebugMarker(USVString markerLabel);
+};
+
+[Exposed=Window]
+interface GPUComputePassEncoder {
+    undefined setPipeline(GPUComputePipeline pipeline);
+    undefined dispatch(GPUSize32 x, optional GPUSize32 y = 1, optional GPUSize32 z = 1);
+    undefined dispatchIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
+
+    undefined beginPipelineStatisticsQuery(GPUQuerySet querySet, GPUSize32 queryIndex);
+    undefined endPipelineStatisticsQuery();
+
+    undefined writeTimestamp(GPUQuerySet querySet, GPUSize32 queryIndex);
+
+    undefined endPass();
+};
+GPUComputePassEncoder includes GPUObjectBase;
+GPUComputePassEncoder includes GPUProgrammablePassEncoder;
+
+dictionary GPUComputePassDescriptor : GPUObjectDescriptorBase {
+};
+
+interface mixin GPURenderEncoderBase {
+    undefined setPipeline(GPURenderPipeline pipeline);
+
+    undefined setIndexBuffer(GPUBuffer buffer, GPUIndexFormat indexFormat, optional GPUSize64 offset = 0, optional GPUSize64 size = 0);
+    undefined setVertexBuffer(GPUIndex32 slot, GPUBuffer buffer, optional GPUSize64 offset = 0, optional GPUSize64 size = 0);
+
+    undefined draw(GPUSize32 vertexCount, optional GPUSize32 instanceCount = 1,
+              optional GPUSize32 firstVertex = 0, optional GPUSize32 firstInstance = 0);
+    undefined drawIndexed(GPUSize32 indexCount, optional GPUSize32 instanceCount = 1,
+                     optional GPUSize32 firstIndex = 0,
+                     optional GPUSignedOffset32 baseVertex = 0,
+                     optional GPUSize32 firstInstance = 0);
+
+    undefined drawIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
+    undefined drawIndexedIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
+};
+
+[Exposed=Window]
+interface GPURenderPassEncoder {
+    undefined setViewport(float x, float y,
+                     float width, float height,
+                     float minDepth, float maxDepth);
+
+    undefined setScissorRect(GPUIntegerCoordinate x, GPUIntegerCoordinate y,
+                        GPUIntegerCoordinate width, GPUIntegerCoordinate height);
+
+    undefined setBlendConstant(GPUColor color);
+    undefined setStencilReference(GPUStencilValue reference);
+
+    undefined beginOcclusionQuery(GPUSize32 queryIndex);
+    undefined endOcclusionQuery();
+
+    undefined beginPipelineStatisticsQuery(GPUQuerySet querySet, GPUSize32 queryIndex);
+    undefined endPipelineStatisticsQuery();
+
+    undefined writeTimestamp(GPUQuerySet querySet, GPUSize32 queryIndex);
+
+    undefined executeBundles(sequence<GPURenderBundle> bundles);
+    undefined endPass();
+};
+GPURenderPassEncoder includes GPUObjectBase;
+GPURenderPassEncoder includes GPUProgrammablePassEncoder;
+GPURenderPassEncoder includes GPURenderEncoderBase;
+
+dictionary GPURenderPassDescriptor : GPUObjectDescriptorBase {
+    required sequence<GPURenderPassColorAttachment> colorAttachments;
+    GPURenderPassDepthStencilAttachment depthStencilAttachment;
+    GPUQuerySet occlusionQuerySet;
+};
+
+dictionary GPURenderPassColorAttachment {
+    required GPUTextureView view;
+    GPUTextureView resolveTarget;
+
+    required (GPULoadOp or GPUColor) loadValue;
+    required GPUStoreOp storeOp;
+};
+
+dictionary GPURenderPassDepthStencilAttachment {
+    required GPUTextureView view;
+
+    required (GPULoadOp or float) depthLoadValue;
+    required GPUStoreOp depthStoreOp;
+    boolean depthReadOnly = false;
+
+    required (GPULoadOp or GPUStencilValue) stencilLoadValue;
+    required GPUStoreOp stencilStoreOp;
+    boolean stencilReadOnly = false;
+};
+
+enum GPULoadOp {
+    "load"
+};
+
+enum GPUStoreOp {
+    "store",
+    "clear"
+};
+
+[Exposed=Window]
+interface GPURenderBundle {
+};
+GPURenderBundle includes GPUObjectBase;
+
+dictionary GPURenderBundleDescriptor : GPUObjectDescriptorBase {
+};
+
+[Exposed=Window]
+interface GPURenderBundleEncoder {
+    GPURenderBundle finish(optional GPURenderBundleDescriptor descriptor = {});
+};
+GPURenderBundleEncoder includes GPUObjectBase;
+GPURenderBundleEncoder includes GPUProgrammablePassEncoder;
+GPURenderBundleEncoder includes GPURenderEncoderBase;
+
+dictionary GPURenderBundleEncoderDescriptor : GPUObjectDescriptorBase {
+    required sequence<GPUTextureFormat> colorFormats;
+    GPUTextureFormat depthStencilFormat;
+    GPUSize32 sampleCount = 1;
+};
+
+[Exposed=Window]
+interface GPUQueue {
+    undefined submit(sequence<GPUCommandBuffer> commandBuffers);
+
+    Promise<undefined> onSubmittedWorkDone();
+
+    undefined writeBuffer(
+        GPUBuffer buffer,
+        GPUSize64 bufferOffset,
+        [AllowShared] BufferSource data,
+        optional GPUSize64 dataOffset = 0,
+        optional GPUSize64 size);
+
+    undefined writeTexture(
+      GPUImageCopyTexture destination,
+      [AllowShared] BufferSource data,
+      GPUImageDataLayout dataLayout,
+      GPUExtent3D size);
+
+    undefined copyImageBitmapToTexture(
+        GPUImageCopyImageBitmap source,
+        GPUImageCopyTexture destination,
+        GPUExtent3D copySize);
+};
+GPUQueue includes GPUObjectBase;
+
+[Exposed=Window]
+interface GPUQuerySet {
+    undefined destroy();
+};
+GPUQuerySet includes GPUObjectBase;
+
+dictionary GPUQuerySetDescriptor : GPUObjectDescriptorBase {
+    required GPUQueryType type;
+    required GPUSize32 count;
+    sequence<GPUPipelineStatisticName> pipelineStatistics = [];
+};
+
+enum GPUQueryType {
+    "occlusion",
+    "pipeline-statistics",
+    "timestamp"
+};
+
+enum GPUPipelineStatisticName {
+    "vertex-shader-invocations",
+    "clipper-invocations",
+    "clipper-primitives-out",
+    "fragment-shader-invocations",
+    "compute-shader-invocations"
+};
+
+[Exposed=Window]
+interface GPUCanvasContext {
+    GPUSwapChain configureSwapChain(GPUSwapChainDescriptor descriptor);
+
+    GPUTextureFormat getSwapChainPreferredFormat(GPUAdapter adapter);
+};
+
+dictionary GPUSwapChainDescriptor : GPUObjectDescriptorBase {
+    required GPUDevice device;
+    required GPUTextureFormat format;
+    GPUTextureUsageFlags usage = 0x10;  // GPUTextureUsage.RENDER_ATTACHMENT
+};
+
+[Exposed=Window]
+interface GPUSwapChain {
+    GPUTexture getCurrentTexture();
+};
+GPUSwapChain includes GPUObjectBase;
+
+enum GPUDeviceLostReason {
+    "destroyed",
+};
+
+[Exposed=Window]
+interface GPUDeviceLostInfo {
+    readonly attribute (GPUDeviceLostReason or undefined) reason;
+    readonly attribute DOMString message;
+};
+
+partial interface GPUDevice {
+    readonly attribute Promise<GPUDeviceLostInfo> lost;
+};
+
+enum GPUErrorFilter {
+    "out-of-memory",
+    "validation"
+};
+
+[Exposed=Window]
+interface GPUOutOfMemoryError {
+    constructor();
+};
+
+[Exposed=Window]
+interface GPUValidationError {
+    constructor(DOMString message);
+    readonly attribute DOMString message;
+};
+
+typedef (GPUOutOfMemoryError or GPUValidationError) GPUError;
+
+partial interface GPUDevice {
+    undefined pushErrorScope(GPUErrorFilter filter);
+    Promise<GPUError?> popErrorScope();
+};
+
+[
+    Exposed=(Window, DedicatedWorker)
+]
+interface GPUUncapturedErrorEvent : Event {
+    constructor(
+        DOMString type,
+        GPUUncapturedErrorEventInit gpuUncapturedErrorEventInitDict
+    );
+    [SameObject] readonly attribute GPUError error;
+};
+
+dictionary GPUUncapturedErrorEventInit : EventInit {
+    required GPUError error;
+};
+
+partial interface GPUDevice {
+    [Exposed=(Window, DedicatedWorker)]
+    attribute EventHandler onuncapturederror;
+};
+
+typedef [EnforceRange] unsigned long GPUBufferDynamicOffset;
+typedef [EnforceRange] unsigned long GPUStencilValue;
+typedef [EnforceRange] unsigned long GPUSampleMask;
+typedef [EnforceRange] long GPUDepthBias;
+
+typedef [EnforceRange] unsigned long long GPUSize64;
+typedef [EnforceRange] unsigned long GPUIntegerCoordinate;
+typedef [EnforceRange] unsigned long GPUIndex32;
+typedef [EnforceRange] unsigned long GPUSize32;
+typedef [EnforceRange] long GPUSignedOffset32;
+
+typedef unsigned long GPUFlagsConstant;
+
+dictionary GPUColorDict {
+    required double r;
+    required double g;
+    required double b;
+    required double a;
+};
+typedef (sequence<double> or GPUColorDict) GPUColor;
+
+dictionary GPUOrigin2DDict {
+    GPUIntegerCoordinate x = 0;
+    GPUIntegerCoordinate y = 0;
+};
+typedef (sequence<GPUIntegerCoordinate> or GPUOrigin2DDict) GPUOrigin2D;
+
+dictionary GPUOrigin3DDict {
+    GPUIntegerCoordinate x = 0;
+    GPUIntegerCoordinate y = 0;
+    GPUIntegerCoordinate z = 0;
+};
+typedef (sequence<GPUIntegerCoordinate> or GPUOrigin3DDict) GPUOrigin3D;
+
+dictionary GPUExtent3DDict {
+    required GPUIntegerCoordinate width;
+    GPUIntegerCoordinate height = 1;
+    GPUIntegerCoordinate depthOrArrayLayers = 1;
+};
+typedef (sequence<GPUIntegerCoordinate> or GPUExtent3DDict) GPUExtent3D;