react-native-wgpu 0.2.0 → 0.2.2

package/cpp/webgpu/webgpu_cpp.h

@@ -191,6 +191,18 @@ enum class CompilationMessageType : uint32_t {
 static_assert(sizeof(CompilationMessageType) == sizeof(WGPUCompilationMessageType), "sizeof mismatch for CompilationMessageType");
 static_assert(alignof(CompilationMessageType) == alignof(WGPUCompilationMessageType), "alignof mismatch for CompilationMessageType");
 
+enum class ComponentSwizzle : uint32_t {
+    Undefined = WGPUComponentSwizzle_Undefined,
+    Zero = WGPUComponentSwizzle_Zero,
+    One = WGPUComponentSwizzle_One,
+    R = WGPUComponentSwizzle_R,
+    G = WGPUComponentSwizzle_G,
+    B = WGPUComponentSwizzle_B,
+    A = WGPUComponentSwizzle_A,
+};
+static_assert(sizeof(ComponentSwizzle) == sizeof(WGPUComponentSwizzle), "sizeof mismatch for ComponentSwizzle");
+static_assert(alignof(ComponentSwizzle) == alignof(WGPUComponentSwizzle), "alignof mismatch for ComponentSwizzle");
+
 enum class CompositeAlphaMode : uint32_t {
     Auto = WGPUCompositeAlphaMode_Auto,
     Opaque = WGPUCompositeAlphaMode_Opaque,
@@ -228,6 +240,13 @@ enum class DeviceLostReason : uint32_t {
 static_assert(sizeof(DeviceLostReason) == sizeof(WGPUDeviceLostReason), "sizeof mismatch for DeviceLostReason");
 static_assert(alignof(DeviceLostReason) == alignof(WGPUDeviceLostReason), "alignof mismatch for DeviceLostReason");
 
+enum class DynamicBindingKind : uint32_t {
+    Undefined = WGPUDynamicBindingKind_Undefined,
+    SampledTexture = WGPUDynamicBindingKind_SampledTexture,
+};
+static_assert(sizeof(DynamicBindingKind) == sizeof(WGPUDynamicBindingKind), "sizeof mismatch for DynamicBindingKind");
+static_assert(alignof(DynamicBindingKind) == alignof(WGPUDynamicBindingKind), "alignof mismatch for DynamicBindingKind");
+
 enum class ErrorFilter : uint32_t {
     Validation = WGPUErrorFilter_Validation,
     OutOfMemory = WGPUErrorFilter_OutOfMemory,
@@ -264,14 +283,15 @@ static_assert(sizeof(FeatureLevel) == sizeof(WGPUFeatureLevel), "sizeof mismatch
 static_assert(alignof(FeatureLevel) == alignof(WGPUFeatureLevel), "alignof mismatch for FeatureLevel");
 
 enum class FeatureName : uint32_t {
+    CoreFeaturesAndLimits = WGPUFeatureName_CoreFeaturesAndLimits,
     DepthClipControl = WGPUFeatureName_DepthClipControl,
     Depth32FloatStencil8 = WGPUFeatureName_Depth32FloatStencil8,
-    TimestampQuery = WGPUFeatureName_TimestampQuery,
     TextureCompressionBC = WGPUFeatureName_TextureCompressionBC,
     TextureCompressionBCSliced3D = WGPUFeatureName_TextureCompressionBCSliced3D,
     TextureCompressionETC2 = WGPUFeatureName_TextureCompressionETC2,
     TextureCompressionASTC = WGPUFeatureName_TextureCompressionASTC,
     TextureCompressionASTCSliced3D = WGPUFeatureName_TextureCompressionASTCSliced3D,
+    TimestampQuery = WGPUFeatureName_TimestampQuery,
     IndirectFirstInstance = WGPUFeatureName_IndirectFirstInstance,
     ShaderF16 = WGPUFeatureName_ShaderF16,
     RG11B10UfloatRenderable = WGPUFeatureName_RG11B10UfloatRenderable,
@@ -281,7 +301,9 @@ enum class FeatureName : uint32_t {
     ClipDistances = WGPUFeatureName_ClipDistances,
     DualSourceBlending = WGPUFeatureName_DualSourceBlending,
     Subgroups = WGPUFeatureName_Subgroups,
-    CoreFeaturesAndLimits = WGPUFeatureName_CoreFeaturesAndLimits,
+    TextureFormatsTier1 = WGPUFeatureName_TextureFormatsTier1,
+    TextureFormatsTier2 = WGPUFeatureName_TextureFormatsTier2,
+    PrimitiveIndex = WGPUFeatureName_PrimitiveIndex,
     DawnInternalUsages = WGPUFeatureName_DawnInternalUsages,
     DawnMultiPlanarFormats = WGPUFeatureName_DawnMultiPlanarFormats,
     DawnNative = WGPUFeatureName_DawnNative,
@@ -339,6 +361,8 @@ enum class FeatureName : uint32_t {
     ChromiumExperimentalSubgroupMatrix = WGPUFeatureName_ChromiumExperimentalSubgroupMatrix,
     SharedFenceEGLSync = WGPUFeatureName_SharedFenceEGLSync,
     DawnDeviceAllocatorControl = WGPUFeatureName_DawnDeviceAllocatorControl,
+    TextureComponentSwizzle = WGPUFeatureName_TextureComponentSwizzle,
+    ChromiumExperimentalBindless = WGPUFeatureName_ChromiumExperimentalBindless,
 };
 static_assert(sizeof(FeatureName) == sizeof(WGPUFeatureName), "sizeof mismatch for FeatureName");
 static_assert(alignof(FeatureName) == alignof(WGPUFeatureName), "alignof mismatch for FeatureName");
@@ -367,6 +391,14 @@ enum class IndexFormat : uint32_t {
 static_assert(sizeof(IndexFormat) == sizeof(WGPUIndexFormat), "sizeof mismatch for IndexFormat");
 static_assert(alignof(IndexFormat) == alignof(WGPUIndexFormat), "alignof mismatch for IndexFormat");
 
+enum class InstanceFeatureName : uint32_t {
+    TimedWaitAny = WGPUInstanceFeatureName_TimedWaitAny,
+    ShaderSourceSPIRV = WGPUInstanceFeatureName_ShaderSourceSPIRV,
+    MultipleDevicesPerAdapter = WGPUInstanceFeatureName_MultipleDevicesPerAdapter,
+};
+static_assert(sizeof(InstanceFeatureName) == sizeof(WGPUInstanceFeatureName), "sizeof mismatch for InstanceFeatureName");
+static_assert(alignof(InstanceFeatureName) == alignof(WGPUInstanceFeatureName), "alignof mismatch for InstanceFeatureName");
+
 enum class LoadOp : uint32_t {
     Undefined = WGPULoadOp_Undefined,
     Load = WGPULoadOp_Load,
@@ -550,7 +582,7 @@ enum class SType : uint32_t {
     SurfaceSourceXCBWindow = WGPUSType_SurfaceSourceXCBWindow,
     SurfaceColorManagement = WGPUSType_SurfaceColorManagement,
     RequestAdapterWebXROptions = WGPUSType_RequestAdapterWebXROptions,
-    AdapterPropertiesSubgroups = WGPUSType_AdapterPropertiesSubgroups,
+    CompatibilityModeLimits = WGPUSType_CompatibilityModeLimits,
     TextureBindingViewDimensionDescriptor = WGPUSType_TextureBindingViewDimensionDescriptor,
     EmscriptenSurfaceSourceCanvasHTMLSelector = WGPUSType_EmscriptenSurfaceSourceCanvasHTMLSelector,
     SurfaceDescriptorFromWindowsCoreWindow = WGPUSType_SurfaceDescriptorFromWindowsCoreWindow,
@@ -622,6 +654,15 @@ enum class SType : uint32_t {
     DawnHostMappedPointerLimits = WGPUSType_DawnHostMappedPointerLimits,
     RenderPassDescriptorResolveRect = WGPUSType_RenderPassDescriptorResolveRect,
     RequestAdapterWebGPUBackendOptions = WGPUSType_RequestAdapterWebGPUBackendOptions,
+    DawnFakeDeviceInitializeErrorForTesting = WGPUSType_DawnFakeDeviceInitializeErrorForTesting,
+    TextureComponentSwizzleDescriptor = WGPUSType_TextureComponentSwizzleDescriptor,
+    SharedTextureMemoryD3D11BeginState = WGPUSType_SharedTextureMemoryD3D11BeginState,
+    DawnConsumeAdapterDescriptor = WGPUSType_DawnConsumeAdapterDescriptor,
+    BindGroupLayoutDynamicBindingArray = WGPUSType_BindGroupLayoutDynamicBindingArray,
+    DynamicBindingArrayLimits = WGPUSType_DynamicBindingArrayLimits,
+    BindGroupDynamicBindingArray = WGPUSType_BindGroupDynamicBindingArray,
+    TexelBufferBindingEntry = WGPUSType_TexelBufferBindingEntry,
+    TexelBufferBindingLayout = WGPUSType_TexelBufferBindingLayout,
 };
 static_assert(sizeof(SType) == sizeof(WGPUSType), "sizeof mismatch for SType");
 static_assert(alignof(SType) == alignof(WGPUSType), "alignof mismatch for SType");
@@ -631,6 +672,8 @@ enum class SubgroupMatrixComponentType : uint32_t {
     F16 = WGPUSubgroupMatrixComponentType_F16,
     U32 = WGPUSubgroupMatrixComponentType_U32,
     I32 = WGPUSubgroupMatrixComponentType_I32,
+    U8 = WGPUSubgroupMatrixComponentType_U8,
+    I8 = WGPUSubgroupMatrixComponentType_I8,
 };
 static_assert(sizeof(SubgroupMatrixComponentType) == sizeof(WGPUSubgroupMatrixComponentType), "sizeof mismatch for SubgroupMatrixComponentType");
 static_assert(alignof(SubgroupMatrixComponentType) == alignof(WGPUSubgroupMatrixComponentType), "alignof mismatch for SubgroupMatrixComponentType");
@@ -646,6 +689,14 @@ enum class SurfaceGetCurrentTextureStatus : uint32_t {
 static_assert(sizeof(SurfaceGetCurrentTextureStatus) == sizeof(WGPUSurfaceGetCurrentTextureStatus), "sizeof mismatch for SurfaceGetCurrentTextureStatus");
 static_assert(alignof(SurfaceGetCurrentTextureStatus) == alignof(WGPUSurfaceGetCurrentTextureStatus), "alignof mismatch for SurfaceGetCurrentTextureStatus");
 
+enum class TexelBufferAccess : uint32_t {
+    Undefined = WGPUTexelBufferAccess_Undefined,
+    ReadOnly = WGPUTexelBufferAccess_ReadOnly,
+    ReadWrite = WGPUTexelBufferAccess_ReadWrite,
+};
+static_assert(sizeof(TexelBufferAccess) == sizeof(WGPUTexelBufferAccess), "sizeof mismatch for TexelBufferAccess");
+static_assert(alignof(TexelBufferAccess) == alignof(WGPUTexelBufferAccess), "alignof mismatch for TexelBufferAccess");
+
 enum class TextureAspect : uint32_t {
     Undefined = WGPUTextureAspect_Undefined,
     All = WGPUTextureAspect_All,
@@ -673,6 +724,8 @@ enum class TextureFormat : uint32_t {
     R8Snorm = WGPUTextureFormat_R8Snorm,
     R8Uint = WGPUTextureFormat_R8Uint,
     R8Sint = WGPUTextureFormat_R8Sint,
+    R16Unorm = WGPUTextureFormat_R16Unorm,
+    R16Snorm = WGPUTextureFormat_R16Snorm,
     R16Uint = WGPUTextureFormat_R16Uint,
     R16Sint = WGPUTextureFormat_R16Sint,
     R16Float = WGPUTextureFormat_R16Float,
@@ -683,6 +736,8 @@ enum class TextureFormat : uint32_t {
     R32Float = WGPUTextureFormat_R32Float,
     R32Uint = WGPUTextureFormat_R32Uint,
     R32Sint = WGPUTextureFormat_R32Sint,
+    RG16Unorm = WGPUTextureFormat_RG16Unorm,
+    RG16Snorm = WGPUTextureFormat_RG16Snorm,
     RG16Uint = WGPUTextureFormat_RG16Uint,
     RG16Sint = WGPUTextureFormat_RG16Sint,
     RG16Float = WGPUTextureFormat_RG16Float,
@@ -700,6 +755,8 @@ enum class TextureFormat : uint32_t {
     RG32Float = WGPUTextureFormat_RG32Float,
     RG32Uint = WGPUTextureFormat_RG32Uint,
     RG32Sint = WGPUTextureFormat_RG32Sint,
+    RGBA16Unorm = WGPUTextureFormat_RGBA16Unorm,
+    RGBA16Snorm = WGPUTextureFormat_RGBA16Snorm,
     RGBA16Uint = WGPUTextureFormat_RGBA16Uint,
     RGBA16Sint = WGPUTextureFormat_RGBA16Sint,
     RGBA16Float = WGPUTextureFormat_RGBA16Float,
@@ -764,12 +821,6 @@ enum class TextureFormat : uint32_t {
     ASTC12x10UnormSrgb = WGPUTextureFormat_ASTC12x10UnormSrgb,
     ASTC12x12Unorm = WGPUTextureFormat_ASTC12x12Unorm,
     ASTC12x12UnormSrgb = WGPUTextureFormat_ASTC12x12UnormSrgb,
-    R16Unorm = WGPUTextureFormat_R16Unorm,
-    RG16Unorm = WGPUTextureFormat_RG16Unorm,
-    RGBA16Unorm = WGPUTextureFormat_RGBA16Unorm,
-    R16Snorm = WGPUTextureFormat_R16Snorm,
-    RG16Snorm = WGPUTextureFormat_RG16Snorm,
-    RGBA16Snorm = WGPUTextureFormat_RGBA16Snorm,
     R8BG8Biplanar420Unorm = WGPUTextureFormat_R8BG8Biplanar420Unorm,
     R10X6BG10X6Biplanar420Unorm = WGPUTextureFormat_R10X6BG10X6Biplanar420Unorm,
     R8BG8A8Triplanar420Unorm = WGPUTextureFormat_R8BG8A8Triplanar420Unorm,
@@ -881,6 +932,8 @@ enum class WGSLLanguageFeatureName : uint32_t {
     UnrestrictedPointerParameters = WGPUWGSLLanguageFeatureName_UnrestrictedPointerParameters,
     PointerCompositeAccess = WGPUWGSLLanguageFeatureName_PointerCompositeAccess,
     SizedBindingArray = WGPUWGSLLanguageFeatureName_SizedBindingArray,
+    TexelBuffers = WGPUWGSLLanguageFeatureName_TexelBuffers,
+    ChromiumPrint = WGPUWGSLLanguageFeatureName_ChromiumPrint,
     ChromiumTestingUnimplemented = WGPUWGSLLanguageFeatureName_ChromiumTestingUnimplemented,
     ChromiumTestingUnsafeExperimental = WGPUWGSLLanguageFeatureName_ChromiumTestingUnsafeExperimental,
     ChromiumTestingExperimental = WGPUWGSLLanguageFeatureName_ChromiumTestingExperimental,
@@ -903,6 +956,7 @@ enum class BufferUsage : uint64_t {
     Storage = WGPUBufferUsage_Storage,
     Indirect = WGPUBufferUsage_Indirect,
     QueryResolve = WGPUBufferUsage_QueryResolve,
+    TexelBuffer = WGPUBufferUsage_TexelBuffer,
 };
 static_assert(sizeof(BufferUsage) == sizeof(WGPUBufferUsage), "sizeof mismatch for BufferUsage");
 static_assert(alignof(BufferUsage) == alignof(WGPUBufferUsage), "alignof mismatch for BufferUsage");
@@ -1135,11 +1189,6 @@ class ObjectBase {
     CType mHandle = nullptr;
 };
 
-
-
-
-
-
 class Adapter;
 class BindGroup;
 class BindGroupLayout;
@@ -1164,29 +1213,33 @@ class SharedBufferMemory;
 class SharedFence;
 class SharedTextureMemory;
 class Surface;
+class TexelBufferView;
 class Texture;
 class TextureView;
 
 struct StringView;
 struct AdapterPropertiesD3D;
-struct AdapterPropertiesSubgroups;
 struct AdapterPropertiesVk;
+struct BindGroupDynamicBindingArray;
 struct BlendComponent;
 struct BufferBindingLayout;
 struct BufferHostMappedPointer;
 struct Color;
 struct ColorTargetStateExpandResolveTextureDawn;
 struct CommandBufferDescriptor;
+struct CompatibilityModeLimits;
 struct ConstantEntry;
 struct CopyTextureForBrowserOptions;
 struct DawnAdapterPropertiesPowerPreference;
 struct DawnBufferDescriptorErrorInfoFromWireClient;
 struct DawnCacheDeviceDescriptor;
 struct DawnCompilationMessageUtf16;
+struct DawnConsumeAdapterDescriptor;
 struct DawnDeviceAllocatorControl;
 struct DawnDrmFormatProperties;
 struct DawnEncoderInternalUsageDescriptor;
 struct DawnFakeBufferOOMForTesting;
+struct DawnFakeDeviceInitializeErrorForTesting;
 struct DawnHostMappedPointerLimits;
 struct DawnInjectedInvalidSType;
 struct DawnRenderPassColorAttachmentRenderToSingleSampled;
@@ -1196,13 +1249,15 @@ struct DawnTextureInternalUsageDescriptor;
 struct DawnTogglesDescriptor;
 struct DawnWGSLBlocklist;
 struct DawnWireWGSLControl;
+struct DynamicBindingArrayLayout;
+struct DynamicBindingArrayLimits;
 struct EmscriptenSurfaceSourceCanvasHTMLSelector;
 struct Extent2D;
 struct Extent3D;
 struct ExternalTextureBindingEntry;
 struct ExternalTextureBindingLayout;
 struct Future;
-struct InstanceCapabilities;
+struct InstanceLimits;
 struct INTERNAL_HAVE_EMDAWNWEBGPU_HEADER;
 struct MemoryHeapInfo;
 struct MultisampleState;
@@ -1242,6 +1297,7 @@ struct SharedFenceVkSemaphoreOpaqueFDExportInfo;
 struct SharedFenceVkSemaphoreZirconHandleDescriptor;
 struct SharedFenceVkSemaphoreZirconHandleExportInfo;
 struct SharedTextureMemoryAHardwareBufferDescriptor;
+struct SharedTextureMemoryD3D11BeginState;
 struct SharedTextureMemoryD3DSwapchainBeginState;
 struct SharedTextureMemoryDmaBufPlane;
 struct SharedTextureMemoryDXGISharedHandleDescriptor;
@@ -1257,6 +1313,7 @@ struct StencilFaceState;
 struct StorageTextureBindingLayout;
 struct SubgroupMatrixConfig;
 struct SupportedFeatures;
+struct SupportedInstanceFeatures;
 struct SupportedWGSLLanguageFeatures;
 struct SurfaceCapabilities;
 struct SurfaceColorManagement;
@@ -1271,15 +1328,20 @@ struct SurfaceSourceWindowsHWND;
 struct SurfaceSourceXCBWindow;
 struct SurfaceSourceXlibWindow;
 struct SurfaceTexture;
+struct TexelBufferBindingEntry;
+struct TexelBufferBindingLayout;
+struct TexelBufferViewDescriptor;
 struct TexelCopyBufferLayout;
 struct TextureBindingLayout;
 struct TextureBindingViewDimensionDescriptor;
+struct TextureComponentSwizzle;
 struct VertexAttribute;
 struct YCbCrVkDescriptor;
 struct AdapterPropertiesMemoryHeaps;
 struct AdapterPropertiesSubgroupMatrixConfigs;
 struct AHardwareBufferProperties;
 struct BindGroupEntry;
+struct BindGroupLayoutDynamicBindingArray;
 struct BindGroupLayoutEntry;
 struct BlendState;
 struct BufferDescriptor;
@@ -1309,8 +1371,8 @@ struct SharedTextureMemoryEndAccessState;
 struct SurfaceDescriptor;
 struct TexelCopyBufferInfo;
 struct TexelCopyTextureInfo;
+struct TextureComponentSwizzleDescriptor;
 struct TextureDescriptor;
-struct TextureViewDescriptor;
 struct VertexBufferLayout;
 struct AdapterInfo;
 struct BindGroupDescriptor;
@@ -1324,6 +1386,7 @@ struct PipelineLayoutDescriptor;
 struct RenderPassPixelLocalStorage;
 struct SharedTextureMemoryDescriptor;
 struct SharedTextureMemoryProperties;
+struct TextureViewDescriptor;
 struct VertexState;
 struct FragmentState;
 struct RenderPassDescriptor;
@@ -1466,23 +1529,23 @@ struct CallbackTypeBase<std::tuple<Args...>, T> {
 
 
 template <typename... T>
-using BufferMapCallback = typename detail::CallbackTypeBase<std::tuple<MapAsyncStatus , StringView >, T...>::Callback;
+using BufferMapCallback = typename detail::CallbackTypeBase<std::tuple<MapAsyncStatus, StringView>, T...>::Callback;
 template <typename... T>
-using CompilationInfoCallback = typename detail::CallbackTypeBase<std::tuple<CompilationInfoRequestStatus , CompilationInfo const * >, T...>::Callback;
+using CompilationInfoCallback = typename detail::CallbackTypeBase<std::tuple<CompilationInfoRequestStatus, CompilationInfo const *>, T...>::Callback;
 template <typename... T>
-using CreateComputePipelineAsyncCallback = typename detail::CallbackTypeBase<std::tuple<CreatePipelineAsyncStatus , ComputePipeline , StringView >, T...>::Callback;
+using CreateComputePipelineAsyncCallback = typename detail::CallbackTypeBase<std::tuple<CreatePipelineAsyncStatus, ComputePipeline, StringView>, T...>::Callback;
 template <typename... T>
-using CreateRenderPipelineAsyncCallback = typename detail::CallbackTypeBase<std::tuple<CreatePipelineAsyncStatus , RenderPipeline , StringView >, T...>::Callback;
+using CreateRenderPipelineAsyncCallback = typename detail::CallbackTypeBase<std::tuple<CreatePipelineAsyncStatus, RenderPipeline, StringView>, T...>::Callback;
 template <typename... T>
-using LoggingCallback = typename detail::CallbackTypeBase<std::tuple<LoggingType , StringView >, T...>::Callback;
+using LoggingCallback = typename detail::CallbackTypeBase<std::tuple<LoggingType, StringView>, T...>::Callback;
 template <typename... T>
-using PopErrorScopeCallback = typename detail::CallbackTypeBase<std::tuple<PopErrorScopeStatus , ErrorType , StringView >, T...>::Callback;
+using PopErrorScopeCallback = typename detail::CallbackTypeBase<std::tuple<PopErrorScopeStatus, ErrorType, StringView>, T...>::Callback;
 template <typename... T>
-using QueueWorkDoneCallback = typename detail::CallbackTypeBase<std::tuple<QueueWorkDoneStatus >, T...>::Callback;
+using QueueWorkDoneCallback = typename detail::CallbackTypeBase<std::tuple<QueueWorkDoneStatus, StringView>, T...>::Callback;
 template <typename... T>
-using RequestAdapterCallback = typename detail::CallbackTypeBase<std::tuple<RequestAdapterStatus , Adapter , StringView >, T...>::Callback;
+using RequestAdapterCallback = typename detail::CallbackTypeBase<std::tuple<RequestAdapterStatus, Adapter, StringView>, T...>::Callback;
 template <typename... T>
-using RequestDeviceCallback = typename detail::CallbackTypeBase<std::tuple<RequestDeviceStatus , Device , StringView >, T...>::Callback;
+using RequestDeviceCallback = typename detail::CallbackTypeBase<std::tuple<RequestDeviceStatus, Device, StringView>, T...>::Callback;
 template <typename... T>
 using DeviceLostCallback = typename detail::CallbackTypeBase<std::tuple<const Device&, DeviceLostReason, StringView>, T...>::Callback;
 template <typename... T>
@@ -1507,12 +1570,12 @@ class Adapter : public ObjectBase<Adapter, WGPUAdapter> {
               typename Cb = RequestDeviceCallback<T>,
               typename CbChar = void (RequestDeviceStatus status, Device device, const char* message, T userdata),
               typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
-    Future RequestDevice(DeviceDescriptor const * options, CallbackMode callbackMode,F callback, T userdata) const;
+    Future RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode,F callback, T userdata) const;
     template <typename L,
               typename Cb = RequestDeviceCallback<>,
               typename CbChar = std::function<void(RequestDeviceStatus status, Device device, const char* message)>,
               typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
-    Future RequestDevice(DeviceDescriptor const * options, CallbackMode callbackMode,L callback) const;
+    Future RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode,L callback) const;
 
 
   private:
@@ -1526,6 +1589,7 @@ class BindGroup : public ObjectBase<BindGroup, WGPUBindGroup> {
     using ObjectBase::ObjectBase;
     using ObjectBase::operator=;
 
+    inline void Destroy() const;
     inline void SetLabel(StringView label) const;
 
 
@@ -1554,6 +1618,7 @@ class Buffer : public ObjectBase<Buffer, WGPUBuffer> {
     using ObjectBase::ObjectBase;
     using ObjectBase::operator=;
 
+    inline TexelBufferView CreateTexelView(TexelBufferViewDescriptor const * descriptor) const;
     inline void Destroy() const;
     inline void const * GetConstMappedRange(size_t offset = 0, size_t size = kWholeMapSize) const;
     inline void * GetMappedRange(size_t offset = 0, size_t size = kWholeMapSize) const;
@@ -1775,7 +1840,7 @@ class Instance : public ObjectBase<Instance, WGPUInstance> {
     using ObjectBase::operator=;
 
     inline Surface CreateSurface(SurfaceDescriptor const * descriptor) const;
-    inline ConvertibleStatus GetWGSLLanguageFeatures(SupportedWGSLLanguageFeatures * features) const;
+    inline void GetWGSLLanguageFeatures(SupportedWGSLLanguageFeatures * features) const;
     inline Bool HasWGSLLanguageFeature(WGSLLanguageFeatureName feature) const;
     inline void ProcessEvents() const;
     template <typename F, typename T,
@@ -1838,12 +1903,12 @@ class Queue : public ObjectBase<Queue, WGPUQueue> {
     inline void CopyTextureForBrowser(TexelCopyTextureInfo const * source, TexelCopyTextureInfo const * destination, Extent3D const * copySize, CopyTextureForBrowserOptions const * options) const;
     template <typename F, typename T,
               typename Cb = QueueWorkDoneCallback<T>,
-              typename CbChar = void (QueueWorkDoneStatus status, T userdata),
+              typename CbChar = void (QueueWorkDoneStatus status, const char* message, T userdata),
               typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
     Future OnSubmittedWorkDone(CallbackMode callbackMode,F callback, T userdata) const;
     template <typename L,
               typename Cb = QueueWorkDoneCallback<>,
-              typename CbChar = std::function<void(QueueWorkDoneStatus status)>,
+              typename CbChar = std::function<void(QueueWorkDoneStatus status, const char* message)>,
               typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
     Future OnSubmittedWorkDone(CallbackMode callbackMode,L callback) const;
     inline void SetLabel(StringView label) const;
@@ -2050,7 +2115,7 @@ class Surface : public ObjectBase<Surface, WGPUSurface> {
     inline void Configure(SurfaceConfiguration const * config) const;
     inline ConvertibleStatus GetCapabilities(Adapter const& adapter, SurfaceCapabilities * capabilities) const;
     inline void GetCurrentTexture(SurfaceTexture * surfaceTexture) const;
-    inline void Present() const;
+    inline ConvertibleStatus Present() const;
     inline void SetLabel(StringView label) const;
     inline void Unconfigure() const;
 
@@ -2061,6 +2126,20 @@ class Surface : public ObjectBase<Surface, WGPUSurface> {
     static inline void WGPURelease(WGPUSurface handle);
 };
 
+class TexelBufferView : public ObjectBase<TexelBufferView, WGPUTexelBufferView> {
+  public:
+    using ObjectBase::ObjectBase;
+    using ObjectBase::operator=;
+
+    inline void SetLabel(StringView label) const;
+
+
+  private:
+    friend ObjectBase<TexelBufferView, WGPUTexelBufferView>;
+    static inline void WGPUAddRef(WGPUTexelBufferView handle);
+    static inline void WGPURelease(WGPUTexelBufferView handle);
+};
+
 class Texture : public ObjectBase<Texture, WGPUTexture> {
   public:
     using ObjectBase::ObjectBase;
@@ -2077,7 +2156,9 @@ class Texture : public ObjectBase<Texture, WGPUTexture> {
     inline uint32_t GetSampleCount() const;
     inline TextureUsage GetUsage() const;
     inline uint32_t GetWidth() const;
+    inline void Pin(TextureUsage usage) const;
     inline void SetLabel(StringView label) const;
+    inline void Unpin() const;
 
 
   private:
@@ -2120,23 +2201,10 @@ struct AdapterPropertiesD3D : ChainedStructOut {
     inline AdapterPropertiesD3D(Init&& init);
     inline operator const WGPUAdapterPropertiesD3D&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t shaderModel;
 };
 
-// Can be chained in AdapterInfo
-struct AdapterPropertiesSubgroups : ChainedStructOut {
-    inline AdapterPropertiesSubgroups();
-
-    struct Init;
-    inline AdapterPropertiesSubgroups(Init&& init);
-    inline operator const WGPUAdapterPropertiesSubgroups&() const noexcept;
-
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
-    alignas(kFirstMemberAlignment) uint32_t subgroupMinSize = kLimitU32Undefined;
-    uint32_t subgroupMaxSize = kLimitU32Undefined;
-};
-
 // Can be chained in AdapterInfo
 struct AdapterPropertiesVk : ChainedStructOut {
     inline AdapterPropertiesVk();
@@ -2145,10 +2213,22 @@ struct AdapterPropertiesVk : ChainedStructOut {
     inline AdapterPropertiesVk(Init&& init);
     inline operator const WGPUAdapterPropertiesVk&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t driverVersion;
 };
 
+// Can be chained in BindGroupDescriptor
+struct BindGroupDynamicBindingArray : ChainedStruct {
+    inline BindGroupDynamicBindingArray();
+
+    struct Init;
+    inline BindGroupDynamicBindingArray(Init&& init);
+    inline operator const WGPUBindGroupDynamicBindingArray&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
+    alignas(kFirstMemberAlignment) uint32_t dynamicArraySize = 0;
+};
+
 struct BlendComponent {
     inline operator const WGPUBlendComponent&() const noexcept;
 
@@ -2174,7 +2254,7 @@ struct BufferHostMappedPointer : ChainedStruct {
     inline BufferHostMappedPointer(Init&& init);
     inline operator const WGPUBufferHostMappedPointer&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * pointer;
     Callback disposeCallback;
     void * userdata;
@@ -2197,7 +2277,7 @@ struct ColorTargetStateExpandResolveTextureDawn : ChainedStruct {
     inline ColorTargetStateExpandResolveTextureDawn(Init&& init);
     inline operator const WGPUColorTargetStateExpandResolveTextureDawn&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool enabled = false;
 };
 
@@ -2208,6 +2288,21 @@ struct CommandBufferDescriptor {
     StringView label = {};
 };
 
+// Can be chained in Limits
+struct CompatibilityModeLimits : ChainedStructOut {
+    inline CompatibilityModeLimits();
+
+    struct Init;
+    inline CompatibilityModeLimits(Init&& init);
+    inline operator const WGPUCompatibilityModeLimits&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
+    alignas(kFirstMemberAlignment) uint32_t maxStorageBuffersInVertexStage = kLimitU32Undefined;
+    uint32_t maxStorageTexturesInVertexStage = kLimitU32Undefined;
+    uint32_t maxStorageBuffersInFragmentStage = kLimitU32Undefined;
+    uint32_t maxStorageTexturesInFragmentStage = kLimitU32Undefined;
+};
+
 struct ConstantEntry {
     inline operator const WGPUConstantEntry&() const noexcept;
 
@@ -2238,7 +2333,7 @@ struct DawnAdapterPropertiesPowerPreference : ChainedStructOut {
     inline DawnAdapterPropertiesPowerPreference(Init&& init);
     inline operator const WGPUDawnAdapterPropertiesPowerPreference&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(PowerPreference ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(PowerPreference));
     alignas(kFirstMemberAlignment) PowerPreference powerPreference = PowerPreference::Undefined;
 };
 
@@ -2250,7 +2345,7 @@ struct DawnBufferDescriptorErrorInfoFromWireClient : ChainedStruct {
     inline DawnBufferDescriptorErrorInfoFromWireClient(Init&& init);
     inline operator const WGPUDawnBufferDescriptorErrorInfoFromWireClient&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool outOfMemory = false;
 };
 
@@ -2262,7 +2357,7 @@ struct DawnCacheDeviceDescriptor : ChainedStruct {
     inline DawnCacheDeviceDescriptor(Init&& init);
     inline operator const WGPUDawnCacheDeviceDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(StringView ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(StringView));
     alignas(kFirstMemberAlignment) StringView isolationKey = {};
     DawnLoadCacheDataFunction loadDataFunction = nullptr;
     DawnStoreCacheDataFunction storeDataFunction = nullptr;
@@ -2277,12 +2372,24 @@ struct DawnCompilationMessageUtf16 : ChainedStruct {
     inline DawnCompilationMessageUtf16(Init&& init);
     inline operator const WGPUDawnCompilationMessageUtf16&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t));
     alignas(kFirstMemberAlignment) uint64_t linePos;
     uint64_t offset;
     uint64_t length;
 };
 
+// Can be chained in DeviceDescriptor
+struct DawnConsumeAdapterDescriptor : ChainedStruct {
+    inline DawnConsumeAdapterDescriptor();
+
+    struct Init;
+    inline DawnConsumeAdapterDescriptor(Init&& init);
+    inline operator const WGPUDawnConsumeAdapterDescriptor&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
+    alignas(kFirstMemberAlignment) Bool consumeAdapter = false;
+};
+
 // Can be chained in DeviceDescriptor
 struct DawnDeviceAllocatorControl : ChainedStruct {
     inline DawnDeviceAllocatorControl();
@@ -2291,7 +2398,7 @@ struct DawnDeviceAllocatorControl : ChainedStruct {
     inline DawnDeviceAllocatorControl(Init&& init);
     inline operator const WGPUDawnDeviceAllocatorControl&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
     alignas(kFirstMemberAlignment) size_t allocatorHeapBlockSize = 0;
 };
 
@@ -2310,7 +2417,7 @@ struct DawnEncoderInternalUsageDescriptor : ChainedStruct {
     inline DawnEncoderInternalUsageDescriptor(Init&& init);
     inline operator const WGPUDawnEncoderInternalUsageDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool useInternalUsages = false;
 };
 
@@ -2322,12 +2429,22 @@ struct DawnFakeBufferOOMForTesting : ChainedStruct {
     inline DawnFakeBufferOOMForTesting(Init&& init);
     inline operator const WGPUDawnFakeBufferOOMForTesting&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool fakeOOMAtWireClientMap;
     Bool fakeOOMAtNativeMap;
     Bool fakeOOMAtDevice;
 };
 
+// Can be chained in DeviceDescriptor
+struct DawnFakeDeviceInitializeErrorForTesting : ChainedStruct {
+    inline DawnFakeDeviceInitializeErrorForTesting();
+
+    struct Init;
+    inline DawnFakeDeviceInitializeErrorForTesting(Init&& init);
+    inline operator const WGPUDawnFakeDeviceInitializeErrorForTesting&() const noexcept;
+
+};
+
 // Can be chained in Limits
 struct DawnHostMappedPointerLimits : ChainedStructOut {
     inline DawnHostMappedPointerLimits();
@@ -2336,7 +2453,7 @@ struct DawnHostMappedPointerLimits : ChainedStructOut {
     inline DawnHostMappedPointerLimits(Init&& init);
     inline operator const WGPUDawnHostMappedPointerLimits&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t hostMappedPointerAlignment = kLimitU32Undefined;
 };
 
@@ -2347,7 +2464,7 @@ struct DawnInjectedInvalidSType : ChainedStruct {
     inline DawnInjectedInvalidSType(Init&& init);
     inline operator const WGPUDawnInjectedInvalidSType&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(SType ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(SType));
     alignas(kFirstMemberAlignment) SType invalidSType = {};
 };
 
@@ -2359,7 +2476,7 @@ struct DawnRenderPassColorAttachmentRenderToSingleSampled : ChainedStruct {
     inline DawnRenderPassColorAttachmentRenderToSingleSampled(Init&& init);
     inline operator const WGPUDawnRenderPassColorAttachmentRenderToSingleSampled&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t implicitSampleCount = 1;
 };
 
@@ -2371,7 +2488,7 @@ struct DawnShaderModuleSPIRVOptionsDescriptor : ChainedStruct {
     inline DawnShaderModuleSPIRVOptionsDescriptor(Init&& init);
     inline operator const WGPUDawnShaderModuleSPIRVOptionsDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool allowNonUniformDerivatives = false;
 };
 
@@ -2383,7 +2500,7 @@ struct DawnTexelCopyBufferRowAlignmentLimits : ChainedStructOut {
     inline DawnTexelCopyBufferRowAlignmentLimits(Init&& init);
     inline operator const WGPUDawnTexelCopyBufferRowAlignmentLimits&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t minTexelCopyBufferRowAlignment = kLimitU32Undefined;
 };
 
@@ -2395,7 +2512,7 @@ struct DawnTextureInternalUsageDescriptor : ChainedStruct {
     inline DawnTextureInternalUsageDescriptor(Init&& init);
     inline operator const WGPUDawnTextureInternalUsageDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TextureUsage ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TextureUsage));
     alignas(kFirstMemberAlignment) TextureUsage internalUsage = TextureUsage::None;
 };
 
@@ -2409,7 +2526,7 @@ struct DawnTogglesDescriptor : ChainedStruct {
     inline DawnTogglesDescriptor(Init&& init);
     inline operator const WGPUDawnTogglesDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
     alignas(kFirstMemberAlignment) size_t enabledToggleCount = 0;
     const char* const * enabledToggles = nullptr;
     size_t disabledToggleCount = 0;
@@ -2424,7 +2541,7 @@ struct DawnWGSLBlocklist : ChainedStruct {
     inline DawnWGSLBlocklist(Init&& init);
     inline operator const WGPUDawnWGSLBlocklist&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
     alignas(kFirstMemberAlignment) size_t blocklistedFeatureCount = 0;
     const char* const * blocklistedFeatures = nullptr;
 };
@@ -2437,12 +2554,32 @@ struct DawnWireWGSLControl : ChainedStruct {
     inline DawnWireWGSLControl(Init&& init);
     inline operator const WGPUDawnWireWGSLControl&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool enableExperimental = false;
     Bool enableUnsafe = false;
     Bool enableTesting = false;
 };
 
+struct DynamicBindingArrayLayout {
+    inline operator const WGPUDynamicBindingArrayLayout&() const noexcept;
+
+    ChainedStruct const * nextInChain = nullptr;
+    uint32_t start = 0;
+    DynamicBindingKind kind = DynamicBindingKind::Undefined;
+};
+
+// Can be chained in Limits
+struct DynamicBindingArrayLimits : ChainedStructOut {
+    inline DynamicBindingArrayLimits();
+
+    struct Init;
+    inline DynamicBindingArrayLimits(Init&& init);
+    inline operator const WGPUDynamicBindingArrayLimits&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
+    alignas(kFirstMemberAlignment) uint32_t maxDynamicBindingArraySize = kLimitU32Undefined;
+};
+
 // Can be chained in SurfaceDescriptor
 struct EmscriptenSurfaceSourceCanvasHTMLSelector : ChainedStruct {
     inline EmscriptenSurfaceSourceCanvasHTMLSelector();
@@ -2451,7 +2588,7 @@ struct EmscriptenSurfaceSourceCanvasHTMLSelector : ChainedStruct {
     inline EmscriptenSurfaceSourceCanvasHTMLSelector(Init&& init);
     inline operator const WGPUEmscriptenSurfaceSourceCanvasHTMLSelector&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(StringView ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(StringView));
     alignas(kFirstMemberAlignment) StringView selector = {};
 };
 
@@ -2478,7 +2615,7 @@ struct ExternalTextureBindingEntry : ChainedStruct {
     inline ExternalTextureBindingEntry(Init&& init);
     inline operator const WGPUExternalTextureBindingEntry&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(ExternalTexture ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(ExternalTexture));
     alignas(kFirstMemberAlignment) ExternalTexture externalTexture = nullptr;
 };
 
@@ -2498,11 +2635,10 @@ struct Future {
     uint64_t id;
 };
 
-struct InstanceCapabilities {
-    inline operator const WGPUInstanceCapabilities&() const noexcept;
+struct InstanceLimits {
+    inline operator const WGPUInstanceLimits&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
-    Bool timedWaitAnyEnable = false;
     size_t timedWaitAnyMaxCount = 0;
 };
 
@@ -2630,7 +2766,7 @@ struct RenderPassDescriptorExpandResolveRect : ChainedStruct {
     inline RenderPassDescriptorExpandResolveRect(Init&& init);
     inline operator const WGPURenderPassDescriptorExpandResolveRect&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t x;
     uint32_t y;
     uint32_t width;
@@ -2645,7 +2781,7 @@ struct RenderPassDescriptorResolveRect : ChainedStruct {
     inline RenderPassDescriptorResolveRect(Init&& init);
     inline operator const WGPURenderPassDescriptorResolveRect&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t colorOffsetX;
     uint32_t colorOffsetY;
     uint32_t resolveOffsetX;
@@ -2662,7 +2798,7 @@ struct RenderPassMaxDrawCount : ChainedStruct {
     inline RenderPassMaxDrawCount(Init&& init);
     inline operator const WGPURenderPassMaxDrawCount&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t));
     alignas(kFirstMemberAlignment) uint64_t maxDrawCount = 50000000;
 };
 
@@ -2684,7 +2820,7 @@ struct RequestAdapterWebXROptions : ChainedStruct {
     inline RequestAdapterWebXROptions(Init&& init);
     inline operator const WGPURequestAdapterWebXROptions&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool xrCompatible;
 };
 
@@ -2703,7 +2839,7 @@ struct ShaderModuleCompilationOptions : ChainedStruct {
     inline ShaderModuleCompilationOptions(Init&& init);
     inline operator const WGPUShaderModuleCompilationOptions&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool strictMath;
 };
 
@@ -2715,7 +2851,7 @@ struct ShaderSourceSPIRV : ChainedStruct {
     inline ShaderSourceSPIRV(Init&& init);
     inline operator const WGPUShaderSourceSPIRV&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t codeSize;
     uint32_t const * code = nullptr;
 };
@@ -2728,7 +2864,7 @@ struct ShaderSourceWGSL : ChainedStruct {
     inline ShaderSourceWGSL(Init&& init);
     inline operator const WGPUShaderSourceWGSL&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(StringView ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(StringView));
     alignas(kFirstMemberAlignment) StringView code = {};
 };
 
@@ -2785,7 +2921,7 @@ struct SharedFenceDXGISharedHandleDescriptor : ChainedStruct {
     inline SharedFenceDXGISharedHandleDescriptor(Init&& init);
     inline operator const WGPUSharedFenceDXGISharedHandleDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * handle;
 };
 
@@ -2797,7 +2933,7 @@ struct SharedFenceDXGISharedHandleExportInfo : ChainedStructOut {
     inline SharedFenceDXGISharedHandleExportInfo(Init&& init);
     inline operator const WGPUSharedFenceDXGISharedHandleExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * handle;
 };
 
@@ -2809,7 +2945,7 @@ struct SharedFenceEGLSyncDescriptor : ChainedStruct {
     inline SharedFenceEGLSyncDescriptor(Init&& init);
     inline operator const WGPUSharedFenceEGLSyncDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * sync;
 };
 
@@ -2821,7 +2957,7 @@ struct SharedFenceEGLSyncExportInfo : ChainedStructOut {
     inline SharedFenceEGLSyncExportInfo(Init&& init);
     inline operator const WGPUSharedFenceEGLSyncExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * sync;
 };
 
@@ -2833,7 +2969,7 @@ struct SharedFenceMTLSharedEventDescriptor : ChainedStruct {
     inline SharedFenceMTLSharedEventDescriptor(Init&& init);
     inline operator const WGPUSharedFenceMTLSharedEventDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * sharedEvent;
 };
 
@@ -2845,7 +2981,7 @@ struct SharedFenceMTLSharedEventExportInfo : ChainedStructOut {
     inline SharedFenceMTLSharedEventExportInfo(Init&& init);
     inline operator const WGPUSharedFenceMTLSharedEventExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * sharedEvent;
 };
 
@@ -2857,7 +2993,7 @@ struct SharedFenceSyncFDDescriptor : ChainedStruct {
     inline SharedFenceSyncFDDescriptor(Init&& init);
     inline operator const WGPUSharedFenceSyncFDDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int));
     alignas(kFirstMemberAlignment) int handle;
 };
 
@@ -2869,7 +3005,7 @@ struct SharedFenceSyncFDExportInfo : ChainedStructOut {
     inline SharedFenceSyncFDExportInfo(Init&& init);
     inline operator const WGPUSharedFenceSyncFDExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int));
     alignas(kFirstMemberAlignment) int handle;
 };
 
@@ -2881,7 +3017,7 @@ struct SharedFenceVkSemaphoreOpaqueFDDescriptor : ChainedStruct {
     inline SharedFenceVkSemaphoreOpaqueFDDescriptor(Init&& init);
     inline operator const WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int));
     alignas(kFirstMemberAlignment) int handle;
 };
 
@@ -2893,7 +3029,7 @@ struct SharedFenceVkSemaphoreOpaqueFDExportInfo : ChainedStructOut {
     inline SharedFenceVkSemaphoreOpaqueFDExportInfo(Init&& init);
     inline operator const WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int));
     alignas(kFirstMemberAlignment) int handle;
 };
 
@@ -2905,7 +3041,7 @@ struct SharedFenceVkSemaphoreZirconHandleDescriptor : ChainedStruct {
     inline SharedFenceVkSemaphoreZirconHandleDescriptor(Init&& init);
     inline operator const WGPUSharedFenceVkSemaphoreZirconHandleDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t handle;
 };
 
@@ -2917,7 +3053,7 @@ struct SharedFenceVkSemaphoreZirconHandleExportInfo : ChainedStructOut {
     inline SharedFenceVkSemaphoreZirconHandleExportInfo(Init&& init);
     inline operator const WGPUSharedFenceVkSemaphoreZirconHandleExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t handle;
 };
 
@@ -2929,11 +3065,23 @@ struct SharedTextureMemoryAHardwareBufferDescriptor : ChainedStruct {
     inline SharedTextureMemoryAHardwareBufferDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryAHardwareBufferDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * handle;
     Bool useExternalFormat;
 };
 
+// Can be chained in SharedTextureMemoryBeginAccessDescriptor
+struct SharedTextureMemoryD3D11BeginState : ChainedStruct {
+    inline SharedTextureMemoryD3D11BeginState();
+
+    struct Init;
+    inline SharedTextureMemoryD3D11BeginState(Init&& init);
+    inline operator const WGPUSharedTextureMemoryD3D11BeginState&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
+    alignas(kFirstMemberAlignment) Bool requiresEndAccessFence = true;
+};
+
 // Can be chained in SharedTextureMemoryBeginAccessDescriptor
 struct SharedTextureMemoryD3DSwapchainBeginState : ChainedStruct {
     inline SharedTextureMemoryD3DSwapchainBeginState();
@@ -2942,7 +3090,7 @@ struct SharedTextureMemoryD3DSwapchainBeginState : ChainedStruct {
     inline SharedTextureMemoryD3DSwapchainBeginState(Init&& init);
     inline operator const WGPUSharedTextureMemoryD3DSwapchainBeginState&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool isSwapchain = false;
 };
 
@@ -2962,7 +3110,7 @@ struct SharedTextureMemoryDXGISharedHandleDescriptor : ChainedStruct {
     inline SharedTextureMemoryDXGISharedHandleDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryDXGISharedHandleDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * handle;
     Bool useKeyedMutex;
 };
@@ -2975,7 +3123,7 @@ struct SharedTextureMemoryEGLImageDescriptor : ChainedStruct {
     inline SharedTextureMemoryEGLImageDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryEGLImageDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * image;
 };
 
@@ -2987,7 +3135,7 @@ struct SharedTextureMemoryIOSurfaceDescriptor : ChainedStruct {
     inline SharedTextureMemoryIOSurfaceDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryIOSurfaceDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * ioSurface;
     Bool allowStorageBinding = true;
 };
@@ -3000,7 +3148,7 @@ struct SharedTextureMemoryOpaqueFDDescriptor : ChainedStruct {
     inline SharedTextureMemoryOpaqueFDDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryOpaqueFDDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void const * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void const *));
     alignas(kFirstMemberAlignment) void const * vkImageCreateInfo;
     int memoryFD;
     uint32_t memoryTypeIndex;
@@ -3016,7 +3164,7 @@ struct SharedTextureMemoryVkDedicatedAllocationDescriptor : ChainedStruct {
     inline SharedTextureMemoryVkDedicatedAllocationDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool dedicatedAllocation;
 };
 
@@ -3028,7 +3176,7 @@ struct SharedTextureMemoryVkImageLayoutBeginState : ChainedStruct {
     inline SharedTextureMemoryVkImageLayoutBeginState(Init&& init);
     inline operator const WGPUSharedTextureMemoryVkImageLayoutBeginState&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int32_t));
     alignas(kFirstMemberAlignment) int32_t oldLayout;
     int32_t newLayout;
 };
@@ -3041,7 +3189,7 @@ struct SharedTextureMemoryVkImageLayoutEndState : ChainedStructOut {
     inline SharedTextureMemoryVkImageLayoutEndState(Init&& init);
     inline operator const WGPUSharedTextureMemoryVkImageLayoutEndState&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int32_t));
     alignas(kFirstMemberAlignment) int32_t oldLayout;
     int32_t newLayout;
 };
@@ -3054,7 +3202,7 @@ struct SharedTextureMemoryZirconHandleDescriptor : ChainedStruct {
     inline SharedTextureMemoryZirconHandleDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryZirconHandleDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t memoryFD;
     uint64_t allocationSize;
 };
@@ -3067,7 +3215,7 @@ struct StaticSamplerBindingLayout : ChainedStruct {
     inline StaticSamplerBindingLayout(Init&& init);
     inline operator const WGPUStaticSamplerBindingLayout&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Sampler ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Sampler));
     alignas(kFirstMemberAlignment) Sampler sampler = nullptr;
     uint32_t sampledTextureBinding = kLimitU32Undefined;
 };
@@ -3117,6 +3265,23 @@ struct SupportedFeatures {
     static inline void Reset(SupportedFeatures& value);
 };
 
+struct SupportedInstanceFeatures {
+    inline SupportedInstanceFeatures();
+    inline ~SupportedInstanceFeatures();
+    SupportedInstanceFeatures(const SupportedInstanceFeatures&) = delete;
+    SupportedInstanceFeatures& operator=(const SupportedInstanceFeatures&) = delete;
+    inline SupportedInstanceFeatures(SupportedInstanceFeatures&&);
+    inline SupportedInstanceFeatures& operator=(SupportedInstanceFeatures&&);
+    inline operator const WGPUSupportedInstanceFeatures&() const noexcept;
+
+    size_t const featureCount = {};
+    InstanceFeatureName const * const features = nullptr;
+
+  private:
+    inline void FreeMembers();
+    static inline void Reset(SupportedInstanceFeatures& value);
+};
+
 struct SupportedWGSLLanguageFeatures {
     inline SupportedWGSLLanguageFeatures();
     inline ~SupportedWGSLLanguageFeatures();
@@ -3165,7 +3330,7 @@ struct SurfaceColorManagement : ChainedStruct {
     inline SurfaceColorManagement(Init&& init);
     inline operator const WGPUSurfaceColorManagement&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(PredefinedColorSpace ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(PredefinedColorSpace));
     alignas(kFirstMemberAlignment) PredefinedColorSpace colorSpace = {};
     ToneMappingMode toneMappingMode = {};
 };
@@ -3193,7 +3358,7 @@ struct SurfaceDescriptorFromWindowsCoreWindow : ChainedStruct {
     inline SurfaceDescriptorFromWindowsCoreWindow(Init&& init);
     inline operator const WGPUSurfaceDescriptorFromWindowsCoreWindow&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * coreWindow = nullptr;
 };
 
@@ -3205,7 +3370,7 @@ struct SurfaceDescriptorFromWindowsUWPSwapChainPanel : ChainedStruct {
     inline SurfaceDescriptorFromWindowsUWPSwapChainPanel(Init&& init);
     inline operator const WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * swapChainPanel = nullptr;
 };
 
@@ -3217,7 +3382,7 @@ struct SurfaceDescriptorFromWindowsWinUISwapChainPanel : ChainedStruct {
     inline SurfaceDescriptorFromWindowsWinUISwapChainPanel(Init&& init);
     inline operator const WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * swapChainPanel = nullptr;
 };
 
@@ -3229,7 +3394,7 @@ struct SurfaceSourceAndroidNativeWindow : ChainedStruct {
     inline SurfaceSourceAndroidNativeWindow(Init&& init);
     inline operator const WGPUSurfaceSourceAndroidNativeWindow&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * window;
 };
 
@@ -3241,7 +3406,7 @@ struct SurfaceSourceMetalLayer : ChainedStruct {
     inline SurfaceSourceMetalLayer(Init&& init);
     inline operator const WGPUSurfaceSourceMetalLayer&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * layer = nullptr;
 };
 
@@ -3253,7 +3418,7 @@ struct SurfaceSourceWaylandSurface : ChainedStruct {
     inline SurfaceSourceWaylandSurface(Init&& init);
     inline operator const WGPUSurfaceSourceWaylandSurface&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * display = nullptr;
     void * surface = nullptr;
 };
@@ -3266,7 +3431,7 @@ struct SurfaceSourceWindowsHWND : ChainedStruct {
     inline SurfaceSourceWindowsHWND(Init&& init);
     inline operator const WGPUSurfaceSourceWindowsHWND&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * hinstance = nullptr;
     void * hwnd = nullptr;
 };
@@ -3279,7 +3444,7 @@ struct SurfaceSourceXCBWindow : ChainedStruct {
     inline SurfaceSourceXCBWindow(Init&& init);
     inline operator const WGPUSurfaceSourceXCBWindow&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * connection = nullptr;
     uint32_t window;
 };
@@ -3292,7 +3457,7 @@ struct SurfaceSourceXlibWindow : ChainedStruct {
     inline SurfaceSourceXlibWindow(Init&& init);
     inline operator const WGPUSurfaceSourceXlibWindow&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void * ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * display = nullptr;
     uint64_t window;
 };
@@ -3305,6 +3470,41 @@ struct SurfaceTexture {
     SurfaceGetCurrentTextureStatus status = {};
 };
 
+// Can be chained in BindGroupEntry
+struct TexelBufferBindingEntry : ChainedStruct {
+    inline TexelBufferBindingEntry();
+
+    struct Init;
+    inline TexelBufferBindingEntry(Init&& init);
+    inline operator const WGPUTexelBufferBindingEntry&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TexelBufferView));
+    alignas(kFirstMemberAlignment) TexelBufferView texelBufferView = nullptr;
+};
+
+// Can be chained in BindGroupLayoutEntry
+struct TexelBufferBindingLayout : ChainedStruct {
+    inline TexelBufferBindingLayout();
+
+    struct Init;
+    inline TexelBufferBindingLayout(Init&& init);
+    inline operator const WGPUTexelBufferBindingLayout&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TexelBufferAccess));
+    alignas(kFirstMemberAlignment) TexelBufferAccess access = TexelBufferAccess::Undefined;
+    TextureFormat format = TextureFormat::Undefined;
+};
+
+struct TexelBufferViewDescriptor {
+    inline operator const WGPUTexelBufferViewDescriptor&() const noexcept;
+
+    ChainedStruct const * nextInChain = nullptr;
+    StringView label = {};
+    TextureFormat format = TextureFormat::Undefined;
+    uint64_t offset = 0;
+    uint64_t size = kWholeSize;
+};
+
 struct TexelCopyBufferLayout {
     inline operator const WGPUTexelCopyBufferLayout&() const noexcept;
 
@@ -3330,10 +3530,19 @@ struct TextureBindingViewDimensionDescriptor : ChainedStruct {
     inline TextureBindingViewDimensionDescriptor(Init&& init);
     inline operator const WGPUTextureBindingViewDimensionDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TextureViewDimension ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TextureViewDimension));
     alignas(kFirstMemberAlignment) TextureViewDimension textureBindingViewDimension = TextureViewDimension::Undefined;
 };
 
+struct TextureComponentSwizzle {
+    inline operator const WGPUTextureComponentSwizzle&() const noexcept;
+
+    ComponentSwizzle r = ComponentSwizzle::Undefined;
+    ComponentSwizzle g = ComponentSwizzle::Undefined;
+    ComponentSwizzle b = ComponentSwizzle::Undefined;
+    ComponentSwizzle a = ComponentSwizzle::Undefined;
+};
+
 struct VertexAttribute {
     inline operator const WGPUVertexAttribute&() const noexcept;
 
@@ -3352,7 +3561,7 @@ struct YCbCrVkDescriptor : ChainedStruct {
     inline YCbCrVkDescriptor(Init&& init);
     inline operator const WGPUYCbCrVkDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t vkFormat = 0;
     uint32_t vkYCbCrModel = 0;
     uint32_t vkYCbCrRange = 0;
@@ -3380,7 +3589,7 @@ struct AdapterPropertiesMemoryHeaps : ChainedStructOut {
     inline AdapterPropertiesMemoryHeaps& operator=(AdapterPropertiesMemoryHeaps&&);
     inline operator const WGPUAdapterPropertiesMemoryHeaps&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
     alignas(kFirstMemberAlignment) size_t const heapCount = {};
     MemoryHeapInfo const * const heapInfo = nullptr;
 
@@ -3402,7 +3611,7 @@ struct AdapterPropertiesSubgroupMatrixConfigs : ChainedStructOut {
     inline AdapterPropertiesSubgroupMatrixConfigs& operator=(AdapterPropertiesSubgroupMatrixConfigs&&);
     inline operator const WGPUAdapterPropertiesSubgroupMatrixConfigs&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
     alignas(kFirstMemberAlignment) size_t const configCount = {};
     SubgroupMatrixConfig const * const configs = nullptr;
 
@@ -3429,6 +3638,18 @@ struct BindGroupEntry {
     TextureView textureView = nullptr;
 };
 
+// Can be chained in BindGroupLayoutDescriptor
+struct BindGroupLayoutDynamicBindingArray : ChainedStruct {
+    inline BindGroupLayoutDynamicBindingArray();
+
+    struct Init;
+    inline BindGroupLayoutDynamicBindingArray(Init&& init);
+    inline operator const WGPUBindGroupLayoutDynamicBindingArray&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(DynamicBindingArrayLayout));
+    alignas(kFirstMemberAlignment) DynamicBindingArrayLayout dynamicArray = {};
+};
+
 struct BindGroupLayoutEntry {
     inline operator const WGPUBindGroupLayoutEntry&() const noexcept;
 
@@ -3509,7 +3730,7 @@ struct DawnDrmFormatCapabilities : ChainedStructOut {
     inline DawnDrmFormatCapabilities& operator=(DawnDrmFormatCapabilities&&);
     inline operator const WGPUDawnDrmFormatCapabilities&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
     alignas(kFirstMemberAlignment) size_t const propertiesCount = {};
     DawnDrmFormatProperties const * const properties = nullptr;
 
@@ -3530,8 +3751,8 @@ struct DepthStencilState {
     uint32_t stencilReadMask = 0xFFFFFFFF;
     uint32_t stencilWriteMask = 0xFFFFFFFF;
     int32_t depthBias = 0;
-    float depthBiasSlopeScale = 0.0f;
-    float depthBiasClamp = 0.0f;
+    float depthBiasSlopeScale = 0.f;
+    float depthBiasClamp = 0.f;
 };
 
 struct ExternalTextureDescriptor {
@@ -3573,7 +3794,9 @@ struct InstanceDescriptor {
     inline operator const WGPUInstanceDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
-    InstanceCapabilities capabilities = {};
+    size_t requiredFeatureCount = 0;
+    InstanceFeatureName const * requiredFeatures = nullptr;
+    InstanceLimits const * requiredLimits = nullptr;
 };
 
 struct Limits {
@@ -3612,10 +3835,6 @@ struct Limits {
     uint32_t maxComputeWorkgroupSizeZ = kLimitU32Undefined;
     uint32_t maxComputeWorkgroupsPerDimension = kLimitU32Undefined;
     uint32_t maxImmediateSize = kLimitU32Undefined;
-    uint32_t maxStorageBuffersInVertexStage = kLimitU32Undefined;
-    uint32_t maxStorageTexturesInVertexStage = kLimitU32Undefined;
-    uint32_t maxStorageBuffersInFragmentStage = kLimitU32Undefined;
-    uint32_t maxStorageTexturesInFragmentStage = kLimitU32Undefined;
 };
 
 // Can be chained in PipelineLayoutDescriptor
@@ -3626,7 +3845,7 @@ struct PipelineLayoutPixelLocalStorage : ChainedStruct {
     inline PipelineLayoutPixelLocalStorage(Init&& init);
     inline operator const WGPUPipelineLayoutPixelLocalStorage&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t));
     alignas(kFirstMemberAlignment) uint64_t totalPixelLocalStorageSize;
     size_t storageAttachmentCount = 0;
     PipelineLayoutStorageAttachment const * storageAttachments = nullptr;
@@ -3677,8 +3896,8 @@ struct SamplerDescriptor {
     FilterMode magFilter = FilterMode::Undefined;
     FilterMode minFilter = FilterMode::Undefined;
     MipmapFilterMode mipmapFilter = MipmapFilterMode::Undefined;
-    float lodMinClamp = 0.0f;
-    float lodMaxClamp = 32.0f;
+    float lodMinClamp = 0.f;
+    float lodMaxClamp = 32.f;
     CompareFunction compare = CompareFunction::Undefined;
     uint16_t maxAnisotropy = 1;
 };
@@ -3712,7 +3931,7 @@ struct SharedTextureMemoryAHardwareBufferProperties : ChainedStructOut {
     inline SharedTextureMemoryAHardwareBufferProperties(Init&& init);
     inline operator const WGPUSharedTextureMemoryAHardwareBufferProperties&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(YCbCrVkDescriptor ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(YCbCrVkDescriptor));
     alignas(kFirstMemberAlignment) YCbCrVkDescriptor yCbCrInfo = {};
 };
 
@@ -3735,7 +3954,7 @@ struct SharedTextureMemoryDmaBufDescriptor : ChainedStruct {
     inline SharedTextureMemoryDmaBufDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryDmaBufDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Extent3D ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Extent3D));
     alignas(kFirstMemberAlignment) Extent3D size = {};
     uint32_t drmFormat;
     uint64_t drmModifier;
@@ -3786,6 +4005,18 @@ struct TexelCopyTextureInfo {
     TextureAspect aspect = TextureAspect::Undefined;
 };
 
+// Can be chained in TextureViewDescriptor
+struct TextureComponentSwizzleDescriptor : ChainedStruct {
+    inline TextureComponentSwizzleDescriptor();
+
+    struct Init;
+    inline TextureComponentSwizzleDescriptor(Init&& init);
+    inline operator const WGPUTextureComponentSwizzleDescriptor&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TextureComponentSwizzle));
+    alignas(kFirstMemberAlignment) TextureComponentSwizzle swizzle = {};
+};
+
 struct TextureDescriptor {
     inline operator const WGPUTextureDescriptor&() const noexcept;
 
@@ -3801,21 +4032,6 @@ struct TextureDescriptor {
     TextureFormat const * viewFormats = nullptr;
 };
 
-struct TextureViewDescriptor {
-    inline operator const WGPUTextureViewDescriptor&() const noexcept;
-
-    ChainedStruct const * nextInChain = nullptr;
-    StringView label = {};
-    TextureFormat format = TextureFormat::Undefined;
-    TextureViewDimension dimension = TextureViewDimension::Undefined;
-    uint32_t baseMipLevel = 0;
-    uint32_t mipLevelCount = kMipLevelCountUndefined;
-    uint32_t baseArrayLayer = 0;
-    uint32_t arrayLayerCount = kArrayLayerCountUndefined;
-    TextureAspect aspect = TextureAspect::Undefined;
-    TextureUsage usage = TextureUsage::None;
-};
-
 struct VertexBufferLayout {
     inline operator const WGPUVertexBufferLayout&() const noexcept;
 
@@ -3858,7 +4074,7 @@ struct BindGroupDescriptor {
     ChainedStruct const * nextInChain = nullptr;
     StringView label = {};
     BindGroupLayout layout = nullptr;
-    size_t entryCount;
+    size_t entryCount = 0;
     BindGroupEntry const * entries = nullptr;
 };
 
@@ -3867,7 +4083,7 @@ struct BindGroupLayoutDescriptor {
 
     ChainedStruct const * nextInChain = nullptr;
     StringView label = {};
-    size_t entryCount;
+    size_t entryCount = 0;
     BindGroupLayoutEntry const * entries = nullptr;
 };
 
@@ -3921,7 +4137,7 @@ struct RenderPassPixelLocalStorage : ChainedStruct {
     inline RenderPassPixelLocalStorage(Init&& init);
     inline operator const WGPURenderPassPixelLocalStorage&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t ));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t));
     alignas(kFirstMemberAlignment) uint64_t totalPixelLocalStorageSize;
     size_t storageAttachmentCount = 0;
     RenderPassStorageAttachment const * storageAttachments = nullptr;
@@ -3943,6 +4159,21 @@ struct SharedTextureMemoryProperties {
     TextureFormat format = TextureFormat::Undefined;
 };
 
+struct TextureViewDescriptor {
+    inline operator const WGPUTextureViewDescriptor&() const noexcept;
+
+    ChainedStruct const * nextInChain = nullptr;
+    StringView label = {};
+    TextureFormat format = TextureFormat::Undefined;
+    TextureViewDimension dimension = TextureViewDimension::Undefined;
+    uint32_t baseMipLevel = 0;
+    uint32_t mipLevelCount = kMipLevelCountUndefined;
+    uint32_t baseArrayLayer = 0;
+    uint32_t arrayLayerCount = kArrayLayerCountUndefined;
+    TextureAspect aspect = TextureAspect::Undefined;
+    TextureUsage usage = TextureUsage::None;
+};
+
 struct VertexState {
     inline operator const WGPUVertexState&() const noexcept;
 
@@ -4064,30 +4295,6 @@ static_assert(alignof(AdapterPropertiesD3D) == alignof(WGPUAdapterPropertiesD3D)
 static_assert(offsetof(AdapterPropertiesD3D, shaderModel) == offsetof(WGPUAdapterPropertiesD3D, shaderModel),
         "offsetof mismatch for AdapterPropertiesD3D::shaderModel");
 
-// AdapterPropertiesSubgroups implementation
-AdapterPropertiesSubgroups::AdapterPropertiesSubgroups()
-  : ChainedStructOut { nullptr, SType::AdapterPropertiesSubgroups } {}
-struct AdapterPropertiesSubgroups::Init {
-    ChainedStructOut *  nextInChain;
-    uint32_t subgroupMinSize = kLimitU32Undefined;
-    uint32_t subgroupMaxSize = kLimitU32Undefined;
-};
-AdapterPropertiesSubgroups::AdapterPropertiesSubgroups(AdapterPropertiesSubgroups::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::AdapterPropertiesSubgroups }, 
-    subgroupMinSize(std::move(init.subgroupMinSize)), 
-    subgroupMaxSize(std::move(init.subgroupMaxSize)){}
-
-AdapterPropertiesSubgroups::operator const WGPUAdapterPropertiesSubgroups&() const noexcept {
-    return *reinterpret_cast<const WGPUAdapterPropertiesSubgroups*>(this);
-}
-
-static_assert(sizeof(AdapterPropertiesSubgroups) == sizeof(WGPUAdapterPropertiesSubgroups), "sizeof mismatch for AdapterPropertiesSubgroups");
-static_assert(alignof(AdapterPropertiesSubgroups) == alignof(WGPUAdapterPropertiesSubgroups), "alignof mismatch for AdapterPropertiesSubgroups");
-static_assert(offsetof(AdapterPropertiesSubgroups, subgroupMinSize) == offsetof(WGPUAdapterPropertiesSubgroups, subgroupMinSize),
-        "offsetof mismatch for AdapterPropertiesSubgroups::subgroupMinSize");
-static_assert(offsetof(AdapterPropertiesSubgroups, subgroupMaxSize) == offsetof(WGPUAdapterPropertiesSubgroups, subgroupMaxSize),
-        "offsetof mismatch for AdapterPropertiesSubgroups::subgroupMaxSize");
-
 // AdapterPropertiesVk implementation
 AdapterPropertiesVk::AdapterPropertiesVk()
   : ChainedStructOut { nullptr, SType::AdapterPropertiesVk } {}
@@ -4108,6 +4315,26 @@ static_assert(alignof(AdapterPropertiesVk) == alignof(WGPUAdapterPropertiesVk),
 static_assert(offsetof(AdapterPropertiesVk, driverVersion) == offsetof(WGPUAdapterPropertiesVk, driverVersion),
         "offsetof mismatch for AdapterPropertiesVk::driverVersion");
 
+// BindGroupDynamicBindingArray implementation
+BindGroupDynamicBindingArray::BindGroupDynamicBindingArray()
+  : ChainedStruct { nullptr, SType::BindGroupDynamicBindingArray } {}
+struct BindGroupDynamicBindingArray::Init {
+    ChainedStruct * const nextInChain;
+    uint32_t dynamicArraySize = 0;
+};
+BindGroupDynamicBindingArray::BindGroupDynamicBindingArray(BindGroupDynamicBindingArray::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::BindGroupDynamicBindingArray }, 
+    dynamicArraySize(std::move(init.dynamicArraySize)){}
+
+BindGroupDynamicBindingArray::operator const WGPUBindGroupDynamicBindingArray&() const noexcept {
+    return *reinterpret_cast<const WGPUBindGroupDynamicBindingArray*>(this);
+}
+
+static_assert(sizeof(BindGroupDynamicBindingArray) == sizeof(WGPUBindGroupDynamicBindingArray), "sizeof mismatch for BindGroupDynamicBindingArray");
+static_assert(alignof(BindGroupDynamicBindingArray) == alignof(WGPUBindGroupDynamicBindingArray), "alignof mismatch for BindGroupDynamicBindingArray");
+static_assert(offsetof(BindGroupDynamicBindingArray, dynamicArraySize) == offsetof(WGPUBindGroupDynamicBindingArray, dynamicArraySize),
+        "offsetof mismatch for BindGroupDynamicBindingArray::dynamicArraySize");
+
 // BlendComponent implementation
 
 BlendComponent::operator const WGPUBlendComponent&() const noexcept {
@@ -4218,6 +4445,38 @@ static_assert(offsetof(CommandBufferDescriptor, nextInChain) == offsetof(WGPUCom
 static_assert(offsetof(CommandBufferDescriptor, label) == offsetof(WGPUCommandBufferDescriptor, label),
         "offsetof mismatch for CommandBufferDescriptor::label");
 
+// CompatibilityModeLimits implementation
+CompatibilityModeLimits::CompatibilityModeLimits()
+  : ChainedStructOut { nullptr, SType::CompatibilityModeLimits } {}
+struct CompatibilityModeLimits::Init {
+    ChainedStructOut *  nextInChain;
+    uint32_t maxStorageBuffersInVertexStage = kLimitU32Undefined;
+    uint32_t maxStorageTexturesInVertexStage = kLimitU32Undefined;
+    uint32_t maxStorageBuffersInFragmentStage = kLimitU32Undefined;
+    uint32_t maxStorageTexturesInFragmentStage = kLimitU32Undefined;
+};
+CompatibilityModeLimits::CompatibilityModeLimits(CompatibilityModeLimits::Init&& init)
+  : ChainedStructOut { init.nextInChain, SType::CompatibilityModeLimits }, 
+    maxStorageBuffersInVertexStage(std::move(init.maxStorageBuffersInVertexStage)), 
+    maxStorageTexturesInVertexStage(std::move(init.maxStorageTexturesInVertexStage)), 
+    maxStorageBuffersInFragmentStage(std::move(init.maxStorageBuffersInFragmentStage)), 
+    maxStorageTexturesInFragmentStage(std::move(init.maxStorageTexturesInFragmentStage)){}
+
+CompatibilityModeLimits::operator const WGPUCompatibilityModeLimits&() const noexcept {
+    return *reinterpret_cast<const WGPUCompatibilityModeLimits*>(this);
+}
+
+static_assert(sizeof(CompatibilityModeLimits) == sizeof(WGPUCompatibilityModeLimits), "sizeof mismatch for CompatibilityModeLimits");
+static_assert(alignof(CompatibilityModeLimits) == alignof(WGPUCompatibilityModeLimits), "alignof mismatch for CompatibilityModeLimits");
+static_assert(offsetof(CompatibilityModeLimits, maxStorageBuffersInVertexStage) == offsetof(WGPUCompatibilityModeLimits, maxStorageBuffersInVertexStage),
+        "offsetof mismatch for CompatibilityModeLimits::maxStorageBuffersInVertexStage");
+static_assert(offsetof(CompatibilityModeLimits, maxStorageTexturesInVertexStage) == offsetof(WGPUCompatibilityModeLimits, maxStorageTexturesInVertexStage),
+        "offsetof mismatch for CompatibilityModeLimits::maxStorageTexturesInVertexStage");
+static_assert(offsetof(CompatibilityModeLimits, maxStorageBuffersInFragmentStage) == offsetof(WGPUCompatibilityModeLimits, maxStorageBuffersInFragmentStage),
+        "offsetof mismatch for CompatibilityModeLimits::maxStorageBuffersInFragmentStage");
+static_assert(offsetof(CompatibilityModeLimits, maxStorageTexturesInFragmentStage) == offsetof(WGPUCompatibilityModeLimits, maxStorageTexturesInFragmentStage),
+        "offsetof mismatch for CompatibilityModeLimits::maxStorageTexturesInFragmentStage");
+
 // ConstantEntry implementation
 
 ConstantEntry::operator const WGPUConstantEntry&() const noexcept {
@@ -4360,6 +4619,26 @@ static_assert(offsetof(DawnCompilationMessageUtf16, offset) == offsetof(WGPUDawn
 static_assert(offsetof(DawnCompilationMessageUtf16, length) == offsetof(WGPUDawnCompilationMessageUtf16, length),
         "offsetof mismatch for DawnCompilationMessageUtf16::length");
 
+// DawnConsumeAdapterDescriptor implementation
+DawnConsumeAdapterDescriptor::DawnConsumeAdapterDescriptor()
+  : ChainedStruct { nullptr, SType::DawnConsumeAdapterDescriptor } {}
+struct DawnConsumeAdapterDescriptor::Init {
+    ChainedStruct * const nextInChain;
+    Bool consumeAdapter = false;
+};
+DawnConsumeAdapterDescriptor::DawnConsumeAdapterDescriptor(DawnConsumeAdapterDescriptor::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::DawnConsumeAdapterDescriptor }, 
+    consumeAdapter(std::move(init.consumeAdapter)){}
+
+DawnConsumeAdapterDescriptor::operator const WGPUDawnConsumeAdapterDescriptor&() const noexcept {
+    return *reinterpret_cast<const WGPUDawnConsumeAdapterDescriptor*>(this);
+}
+
+static_assert(sizeof(DawnConsumeAdapterDescriptor) == sizeof(WGPUDawnConsumeAdapterDescriptor), "sizeof mismatch for DawnConsumeAdapterDescriptor");
+static_assert(alignof(DawnConsumeAdapterDescriptor) == alignof(WGPUDawnConsumeAdapterDescriptor), "alignof mismatch for DawnConsumeAdapterDescriptor");
+static_assert(offsetof(DawnConsumeAdapterDescriptor, consumeAdapter) == offsetof(WGPUDawnConsumeAdapterDescriptor, consumeAdapter),
+        "offsetof mismatch for DawnConsumeAdapterDescriptor::consumeAdapter");
+
 // DawnDeviceAllocatorControl implementation
 DawnDeviceAllocatorControl::DawnDeviceAllocatorControl()
   : ChainedStruct { nullptr, SType::DawnDeviceAllocatorControl } {}
@@ -4441,6 +4720,22 @@ static_assert(offsetof(DawnFakeBufferOOMForTesting, fakeOOMAtNativeMap) == offse
 static_assert(offsetof(DawnFakeBufferOOMForTesting, fakeOOMAtDevice) == offsetof(WGPUDawnFakeBufferOOMForTesting, fakeOOMAtDevice),
         "offsetof mismatch for DawnFakeBufferOOMForTesting::fakeOOMAtDevice");
 
+// DawnFakeDeviceInitializeErrorForTesting implementation
+DawnFakeDeviceInitializeErrorForTesting::DawnFakeDeviceInitializeErrorForTesting()
+  : ChainedStruct { nullptr, SType::DawnFakeDeviceInitializeErrorForTesting } {}
+struct DawnFakeDeviceInitializeErrorForTesting::Init {
+    ChainedStruct * const nextInChain;
+};
+DawnFakeDeviceInitializeErrorForTesting::DawnFakeDeviceInitializeErrorForTesting(DawnFakeDeviceInitializeErrorForTesting::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::DawnFakeDeviceInitializeErrorForTesting }{}
+
+DawnFakeDeviceInitializeErrorForTesting::operator const WGPUDawnFakeDeviceInitializeErrorForTesting&() const noexcept {
+    return *reinterpret_cast<const WGPUDawnFakeDeviceInitializeErrorForTesting*>(this);
+}
+
+static_assert(sizeof(DawnFakeDeviceInitializeErrorForTesting) == sizeof(WGPUDawnFakeDeviceInitializeErrorForTesting), "sizeof mismatch for DawnFakeDeviceInitializeErrorForTesting");
+static_assert(alignof(DawnFakeDeviceInitializeErrorForTesting) == alignof(WGPUDawnFakeDeviceInitializeErrorForTesting), "alignof mismatch for DawnFakeDeviceInitializeErrorForTesting");
+
 // DawnHostMappedPointerLimits implementation
 DawnHostMappedPointerLimits::DawnHostMappedPointerLimits()
   : ChainedStructOut { nullptr, SType::DawnHostMappedPointerLimits } {}
@@ -4645,6 +4940,41 @@ static_assert(offsetof(DawnWireWGSLControl, enableUnsafe) == offsetof(WGPUDawnWi
 static_assert(offsetof(DawnWireWGSLControl, enableTesting) == offsetof(WGPUDawnWireWGSLControl, enableTesting),
         "offsetof mismatch for DawnWireWGSLControl::enableTesting");
 
+// DynamicBindingArrayLayout implementation
+
+DynamicBindingArrayLayout::operator const WGPUDynamicBindingArrayLayout&() const noexcept {
+    return *reinterpret_cast<const WGPUDynamicBindingArrayLayout*>(this);
+}
+
+static_assert(sizeof(DynamicBindingArrayLayout) == sizeof(WGPUDynamicBindingArrayLayout), "sizeof mismatch for DynamicBindingArrayLayout");
+static_assert(alignof(DynamicBindingArrayLayout) == alignof(WGPUDynamicBindingArrayLayout), "alignof mismatch for DynamicBindingArrayLayout");
+static_assert(offsetof(DynamicBindingArrayLayout, nextInChain) == offsetof(WGPUDynamicBindingArrayLayout, nextInChain),
+        "offsetof mismatch for DynamicBindingArrayLayout::nextInChain");
+static_assert(offsetof(DynamicBindingArrayLayout, start) == offsetof(WGPUDynamicBindingArrayLayout, start),
+        "offsetof mismatch for DynamicBindingArrayLayout::start");
+static_assert(offsetof(DynamicBindingArrayLayout, kind) == offsetof(WGPUDynamicBindingArrayLayout, kind),
+        "offsetof mismatch for DynamicBindingArrayLayout::kind");
+
+// DynamicBindingArrayLimits implementation
+DynamicBindingArrayLimits::DynamicBindingArrayLimits()
+  : ChainedStructOut { nullptr, SType::DynamicBindingArrayLimits } {}
+struct DynamicBindingArrayLimits::Init {
+    ChainedStructOut *  nextInChain;
+    uint32_t maxDynamicBindingArraySize = kLimitU32Undefined;
+};
+DynamicBindingArrayLimits::DynamicBindingArrayLimits(DynamicBindingArrayLimits::Init&& init)
+  : ChainedStructOut { init.nextInChain, SType::DynamicBindingArrayLimits }, 
+    maxDynamicBindingArraySize(std::move(init.maxDynamicBindingArraySize)){}
+
+DynamicBindingArrayLimits::operator const WGPUDynamicBindingArrayLimits&() const noexcept {
+    return *reinterpret_cast<const WGPUDynamicBindingArrayLimits*>(this);
+}
+
+static_assert(sizeof(DynamicBindingArrayLimits) == sizeof(WGPUDynamicBindingArrayLimits), "sizeof mismatch for DynamicBindingArrayLimits");
+static_assert(alignof(DynamicBindingArrayLimits) == alignof(WGPUDynamicBindingArrayLimits), "alignof mismatch for DynamicBindingArrayLimits");
+static_assert(offsetof(DynamicBindingArrayLimits, maxDynamicBindingArraySize) == offsetof(WGPUDynamicBindingArrayLimits, maxDynamicBindingArraySize),
+        "offsetof mismatch for DynamicBindingArrayLimits::maxDynamicBindingArraySize");
+
 // EmscriptenSurfaceSourceCanvasHTMLSelector implementation
 EmscriptenSurfaceSourceCanvasHTMLSelector::EmscriptenSurfaceSourceCanvasHTMLSelector()
   : ChainedStruct { nullptr, SType::EmscriptenSurfaceSourceCanvasHTMLSelector } {}
@@ -4740,20 +5070,18 @@ static_assert(alignof(Future) == alignof(WGPUFuture), "alignof mismatch for Futu
 static_assert(offsetof(Future, id) == offsetof(WGPUFuture, id),
         "offsetof mismatch for Future::id");
 
-// InstanceCapabilities implementation
+// InstanceLimits implementation
 
-InstanceCapabilities::operator const WGPUInstanceCapabilities&() const noexcept {
-    return *reinterpret_cast<const WGPUInstanceCapabilities*>(this);
+InstanceLimits::operator const WGPUInstanceLimits&() const noexcept {
+    return *reinterpret_cast<const WGPUInstanceLimits*>(this);
 }
 
-static_assert(sizeof(InstanceCapabilities) == sizeof(WGPUInstanceCapabilities), "sizeof mismatch for InstanceCapabilities");
-static_assert(alignof(InstanceCapabilities) == alignof(WGPUInstanceCapabilities), "alignof mismatch for InstanceCapabilities");
-static_assert(offsetof(InstanceCapabilities, nextInChain) == offsetof(WGPUInstanceCapabilities, nextInChain),
-        "offsetof mismatch for InstanceCapabilities::nextInChain");
-static_assert(offsetof(InstanceCapabilities, timedWaitAnyEnable) == offsetof(WGPUInstanceCapabilities, timedWaitAnyEnable),
-        "offsetof mismatch for InstanceCapabilities::timedWaitAnyEnable");
-static_assert(offsetof(InstanceCapabilities, timedWaitAnyMaxCount) == offsetof(WGPUInstanceCapabilities, timedWaitAnyMaxCount),
-        "offsetof mismatch for InstanceCapabilities::timedWaitAnyMaxCount");
+static_assert(sizeof(InstanceLimits) == sizeof(WGPUInstanceLimits), "sizeof mismatch for InstanceLimits");
+static_assert(alignof(InstanceLimits) == alignof(WGPUInstanceLimits), "alignof mismatch for InstanceLimits");
+static_assert(offsetof(InstanceLimits, nextInChain) == offsetof(WGPUInstanceLimits, nextInChain),
+        "offsetof mismatch for InstanceLimits::nextInChain");
+static_assert(offsetof(InstanceLimits, timedWaitAnyMaxCount) == offsetof(WGPUInstanceLimits, timedWaitAnyMaxCount),
+        "offsetof mismatch for InstanceLimits::timedWaitAnyMaxCount");
 
 // INTERNAL_HAVE_EMDAWNWEBGPU_HEADER implementation
 
@@ -5550,6 +5878,26 @@ static_assert(offsetof(SharedTextureMemoryAHardwareBufferDescriptor, handle) ==
 static_assert(offsetof(SharedTextureMemoryAHardwareBufferDescriptor, useExternalFormat) == offsetof(WGPUSharedTextureMemoryAHardwareBufferDescriptor, useExternalFormat),
         "offsetof mismatch for SharedTextureMemoryAHardwareBufferDescriptor::useExternalFormat");
 
+// SharedTextureMemoryD3D11BeginState implementation
+SharedTextureMemoryD3D11BeginState::SharedTextureMemoryD3D11BeginState()
+  : ChainedStruct { nullptr, SType::SharedTextureMemoryD3D11BeginState } {}
+struct SharedTextureMemoryD3D11BeginState::Init {
+    ChainedStruct * const nextInChain;
+    Bool requiresEndAccessFence = true;
+};
+SharedTextureMemoryD3D11BeginState::SharedTextureMemoryD3D11BeginState(SharedTextureMemoryD3D11BeginState::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryD3D11BeginState }, 
+    requiresEndAccessFence(std::move(init.requiresEndAccessFence)){}
+
+SharedTextureMemoryD3D11BeginState::operator const WGPUSharedTextureMemoryD3D11BeginState&() const noexcept {
+    return *reinterpret_cast<const WGPUSharedTextureMemoryD3D11BeginState*>(this);
+}
+
+static_assert(sizeof(SharedTextureMemoryD3D11BeginState) == sizeof(WGPUSharedTextureMemoryD3D11BeginState), "sizeof mismatch for SharedTextureMemoryD3D11BeginState");
+static_assert(alignof(SharedTextureMemoryD3D11BeginState) == alignof(WGPUSharedTextureMemoryD3D11BeginState), "alignof mismatch for SharedTextureMemoryD3D11BeginState");
+static_assert(offsetof(SharedTextureMemoryD3D11BeginState, requiresEndAccessFence) == offsetof(WGPUSharedTextureMemoryD3D11BeginState, requiresEndAccessFence),
+        "offsetof mismatch for SharedTextureMemoryD3D11BeginState::requiresEndAccessFence");
+
 // SharedTextureMemoryD3DSwapchainBeginState implementation
 SharedTextureMemoryD3DSwapchainBeginState::SharedTextureMemoryD3DSwapchainBeginState()
   : ChainedStruct { nullptr, SType::SharedTextureMemoryD3DSwapchainBeginState } {}
@@ -5906,6 +6254,54 @@ static_assert(offsetof(SupportedFeatures, featureCount) == offsetof(WGPUSupporte
 static_assert(offsetof(SupportedFeatures, features) == offsetof(WGPUSupportedFeatures, features),
         "offsetof mismatch for SupportedFeatures::features");
 
+// SupportedInstanceFeatures implementation
+SupportedInstanceFeatures::SupportedInstanceFeatures() = default;
+SupportedInstanceFeatures::~SupportedInstanceFeatures() {
+    FreeMembers();
+}
+
+SupportedInstanceFeatures::SupportedInstanceFeatures(SupportedInstanceFeatures&& rhs)
+    : featureCount(rhs.featureCount),
+            features(rhs.features){
+    Reset(rhs);
+}
+
+SupportedInstanceFeatures& SupportedInstanceFeatures::operator=(SupportedInstanceFeatures&& rhs) {
+    if (&rhs == this) {
+        return *this;
+    }
+    FreeMembers();
+    detail::AsNonConstReference(this->featureCount) = std::move(rhs.featureCount);
+    detail::AsNonConstReference(this->features) = std::move(rhs.features);
+    Reset(rhs);
+    return *this;
+}
+
+void SupportedInstanceFeatures::FreeMembers() {
+    bool needsFreeing = false;    if (this->features != nullptr) { needsFreeing = true; }if (needsFreeing) {
+        wgpuSupportedInstanceFeaturesFreeMembers(
+            *reinterpret_cast<WGPUSupportedInstanceFeatures*>(this));
+    }
+}
+
+// static
+void SupportedInstanceFeatures::Reset(SupportedInstanceFeatures& value) {
+    SupportedInstanceFeatures defaultValue{};
+    detail::AsNonConstReference(value.featureCount) = defaultValue.featureCount;
+    detail::AsNonConstReference(value.features) = defaultValue.features;
+}
+
+SupportedInstanceFeatures::operator const WGPUSupportedInstanceFeatures&() const noexcept {
+    return *reinterpret_cast<const WGPUSupportedInstanceFeatures*>(this);
+}
+
+static_assert(sizeof(SupportedInstanceFeatures) == sizeof(WGPUSupportedInstanceFeatures), "sizeof mismatch for SupportedInstanceFeatures");
+static_assert(alignof(SupportedInstanceFeatures) == alignof(WGPUSupportedInstanceFeatures), "alignof mismatch for SupportedInstanceFeatures");
+static_assert(offsetof(SupportedInstanceFeatures, featureCount) == offsetof(WGPUSupportedInstanceFeatures, featureCount),
+        "offsetof mismatch for SupportedInstanceFeatures::featureCount");
+static_assert(offsetof(SupportedInstanceFeatures, features) == offsetof(WGPUSupportedInstanceFeatures, features),
+        "offsetof mismatch for SupportedInstanceFeatures::features");
+
 // SupportedWGSLLanguageFeatures implementation
 SupportedWGSLLanguageFeatures::SupportedWGSLLanguageFeatures() = default;
 SupportedWGSLLanguageFeatures::~SupportedWGSLLanguageFeatures() {
@@ -6293,6 +6689,69 @@ static_assert(offsetof(SurfaceTexture, texture) == offsetof(WGPUSurfaceTexture,
 static_assert(offsetof(SurfaceTexture, status) == offsetof(WGPUSurfaceTexture, status),
         "offsetof mismatch for SurfaceTexture::status");
 
+// TexelBufferBindingEntry implementation
+TexelBufferBindingEntry::TexelBufferBindingEntry()
+  : ChainedStruct { nullptr, SType::TexelBufferBindingEntry } {}
+struct TexelBufferBindingEntry::Init {
+    ChainedStruct * const nextInChain;
+    TexelBufferView texelBufferView = nullptr;
+};
+TexelBufferBindingEntry::TexelBufferBindingEntry(TexelBufferBindingEntry::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::TexelBufferBindingEntry }, 
+    texelBufferView(std::move(init.texelBufferView)){}
+
+TexelBufferBindingEntry::operator const WGPUTexelBufferBindingEntry&() const noexcept {
+    return *reinterpret_cast<const WGPUTexelBufferBindingEntry*>(this);
+}
+
+static_assert(sizeof(TexelBufferBindingEntry) == sizeof(WGPUTexelBufferBindingEntry), "sizeof mismatch for TexelBufferBindingEntry");
+static_assert(alignof(TexelBufferBindingEntry) == alignof(WGPUTexelBufferBindingEntry), "alignof mismatch for TexelBufferBindingEntry");
+static_assert(offsetof(TexelBufferBindingEntry, texelBufferView) == offsetof(WGPUTexelBufferBindingEntry, texelBufferView),
+        "offsetof mismatch for TexelBufferBindingEntry::texelBufferView");
+
+// TexelBufferBindingLayout implementation
+TexelBufferBindingLayout::TexelBufferBindingLayout()
+  : ChainedStruct { nullptr, SType::TexelBufferBindingLayout } {}
+struct TexelBufferBindingLayout::Init {
+    ChainedStruct * const nextInChain;
+    TexelBufferAccess access = TexelBufferAccess::Undefined;
+    TextureFormat format = TextureFormat::Undefined;
+};
+TexelBufferBindingLayout::TexelBufferBindingLayout(TexelBufferBindingLayout::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::TexelBufferBindingLayout }, 
+    access(std::move(init.access)), 
+    format(std::move(init.format)){}
+
+TexelBufferBindingLayout::operator const WGPUTexelBufferBindingLayout&() const noexcept {
+    return *reinterpret_cast<const WGPUTexelBufferBindingLayout*>(this);
+}
+
+static_assert(sizeof(TexelBufferBindingLayout) == sizeof(WGPUTexelBufferBindingLayout), "sizeof mismatch for TexelBufferBindingLayout");
+static_assert(alignof(TexelBufferBindingLayout) == alignof(WGPUTexelBufferBindingLayout), "alignof mismatch for TexelBufferBindingLayout");
+static_assert(offsetof(TexelBufferBindingLayout, access) == offsetof(WGPUTexelBufferBindingLayout, access),
+        "offsetof mismatch for TexelBufferBindingLayout::access");
+static_assert(offsetof(TexelBufferBindingLayout, format) == offsetof(WGPUTexelBufferBindingLayout, format),
+        "offsetof mismatch for TexelBufferBindingLayout::format");
+
+// TexelBufferViewDescriptor implementation
+
+TexelBufferViewDescriptor::operator const WGPUTexelBufferViewDescriptor&() const noexcept {
+    return *reinterpret_cast<const WGPUTexelBufferViewDescriptor*>(this);
+}
+
+static_assert(sizeof(TexelBufferViewDescriptor) == sizeof(WGPUTexelBufferViewDescriptor), "sizeof mismatch for TexelBufferViewDescriptor");
+static_assert(alignof(TexelBufferViewDescriptor) == alignof(WGPUTexelBufferViewDescriptor), "alignof mismatch for TexelBufferViewDescriptor");
+static_assert(offsetof(TexelBufferViewDescriptor, nextInChain) == offsetof(WGPUTexelBufferViewDescriptor, nextInChain),
+        "offsetof mismatch for TexelBufferViewDescriptor::nextInChain");
+static_assert(offsetof(TexelBufferViewDescriptor, label) == offsetof(WGPUTexelBufferViewDescriptor, label),
+        "offsetof mismatch for TexelBufferViewDescriptor::label");
+static_assert(offsetof(TexelBufferViewDescriptor, format) == offsetof(WGPUTexelBufferViewDescriptor, format),
+        "offsetof mismatch for TexelBufferViewDescriptor::format");
+static_assert(offsetof(TexelBufferViewDescriptor, offset) == offsetof(WGPUTexelBufferViewDescriptor, offset),
+        "offsetof mismatch for TexelBufferViewDescriptor::offset");
+static_assert(offsetof(TexelBufferViewDescriptor, size) == offsetof(WGPUTexelBufferViewDescriptor, size),
+        "offsetof mismatch for TexelBufferViewDescriptor::size");
+
 // TexelCopyBufferLayout implementation
 
 TexelCopyBufferLayout::operator const WGPUTexelCopyBufferLayout&() const noexcept {
@@ -6345,6 +6804,23 @@ static_assert(alignof(TextureBindingViewDimensionDescriptor) == alignof(WGPUText
 static_assert(offsetof(TextureBindingViewDimensionDescriptor, textureBindingViewDimension) == offsetof(WGPUTextureBindingViewDimensionDescriptor, textureBindingViewDimension),
         "offsetof mismatch for TextureBindingViewDimensionDescriptor::textureBindingViewDimension");
 
+// TextureComponentSwizzle implementation
+
+TextureComponentSwizzle::operator const WGPUTextureComponentSwizzle&() const noexcept {
+    return *reinterpret_cast<const WGPUTextureComponentSwizzle*>(this);
+}
+
+static_assert(sizeof(TextureComponentSwizzle) == sizeof(WGPUTextureComponentSwizzle), "sizeof mismatch for TextureComponentSwizzle");
+static_assert(alignof(TextureComponentSwizzle) == alignof(WGPUTextureComponentSwizzle), "alignof mismatch for TextureComponentSwizzle");
+static_assert(offsetof(TextureComponentSwizzle, r) == offsetof(WGPUTextureComponentSwizzle, r),
+        "offsetof mismatch for TextureComponentSwizzle::r");
+static_assert(offsetof(TextureComponentSwizzle, g) == offsetof(WGPUTextureComponentSwizzle, g),
+        "offsetof mismatch for TextureComponentSwizzle::g");
+static_assert(offsetof(TextureComponentSwizzle, b) == offsetof(WGPUTextureComponentSwizzle, b),
+        "offsetof mismatch for TextureComponentSwizzle::b");
+static_assert(offsetof(TextureComponentSwizzle, a) == offsetof(WGPUTextureComponentSwizzle, a),
+        "offsetof mismatch for TextureComponentSwizzle::a");
+
 // VertexAttribute implementation
 
 VertexAttribute::operator const WGPUVertexAttribute&() const noexcept {
@@ -6576,6 +7052,26 @@ static_assert(offsetof(BindGroupEntry, sampler) == offsetof(WGPUBindGroupEntry,
 static_assert(offsetof(BindGroupEntry, textureView) == offsetof(WGPUBindGroupEntry, textureView),
         "offsetof mismatch for BindGroupEntry::textureView");
 
+// BindGroupLayoutDynamicBindingArray implementation
+BindGroupLayoutDynamicBindingArray::BindGroupLayoutDynamicBindingArray()
+  : ChainedStruct { nullptr, SType::BindGroupLayoutDynamicBindingArray } {}
+struct BindGroupLayoutDynamicBindingArray::Init {
+    ChainedStruct * const nextInChain;
+    DynamicBindingArrayLayout dynamicArray = {};
+};
+BindGroupLayoutDynamicBindingArray::BindGroupLayoutDynamicBindingArray(BindGroupLayoutDynamicBindingArray::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::BindGroupLayoutDynamicBindingArray }, 
+    dynamicArray(std::move(init.dynamicArray)){}
+
+BindGroupLayoutDynamicBindingArray::operator const WGPUBindGroupLayoutDynamicBindingArray&() const noexcept {
+    return *reinterpret_cast<const WGPUBindGroupLayoutDynamicBindingArray*>(this);
+}
+
+static_assert(sizeof(BindGroupLayoutDynamicBindingArray) == sizeof(WGPUBindGroupLayoutDynamicBindingArray), "sizeof mismatch for BindGroupLayoutDynamicBindingArray");
+static_assert(alignof(BindGroupLayoutDynamicBindingArray) == alignof(WGPUBindGroupLayoutDynamicBindingArray), "alignof mismatch for BindGroupLayoutDynamicBindingArray");
+static_assert(offsetof(BindGroupLayoutDynamicBindingArray, dynamicArray) == offsetof(WGPUBindGroupLayoutDynamicBindingArray, dynamicArray),
+        "offsetof mismatch for BindGroupLayoutDynamicBindingArray::dynamicArray");
+
 // BindGroupLayoutEntry implementation
 
 BindGroupLayoutEntry::operator const WGPUBindGroupLayoutEntry&() const noexcept {
@@ -6869,8 +7365,12 @@ static_assert(sizeof(InstanceDescriptor) == sizeof(WGPUInstanceDescriptor), "siz
 static_assert(alignof(InstanceDescriptor) == alignof(WGPUInstanceDescriptor), "alignof mismatch for InstanceDescriptor");
 static_assert(offsetof(InstanceDescriptor, nextInChain) == offsetof(WGPUInstanceDescriptor, nextInChain),
         "offsetof mismatch for InstanceDescriptor::nextInChain");
-static_assert(offsetof(InstanceDescriptor, capabilities) == offsetof(WGPUInstanceDescriptor, capabilities),
-        "offsetof mismatch for InstanceDescriptor::capabilities");
+static_assert(offsetof(InstanceDescriptor, requiredFeatureCount) == offsetof(WGPUInstanceDescriptor, requiredFeatureCount),
+        "offsetof mismatch for InstanceDescriptor::requiredFeatureCount");
+static_assert(offsetof(InstanceDescriptor, requiredFeatures) == offsetof(WGPUInstanceDescriptor, requiredFeatures),
+        "offsetof mismatch for InstanceDescriptor::requiredFeatures");
+static_assert(offsetof(InstanceDescriptor, requiredLimits) == offsetof(WGPUInstanceDescriptor, requiredLimits),
+        "offsetof mismatch for InstanceDescriptor::requiredLimits");
 
 // Limits implementation
 
@@ -6946,14 +7446,6 @@ static_assert(offsetof(Limits, maxComputeWorkgroupsPerDimension) == offsetof(WGP
         "offsetof mismatch for Limits::maxComputeWorkgroupsPerDimension");
 static_assert(offsetof(Limits, maxImmediateSize) == offsetof(WGPULimits, maxImmediateSize),
         "offsetof mismatch for Limits::maxImmediateSize");
-static_assert(offsetof(Limits, maxStorageBuffersInVertexStage) == offsetof(WGPULimits, maxStorageBuffersInVertexStage),
-        "offsetof mismatch for Limits::maxStorageBuffersInVertexStage");
-static_assert(offsetof(Limits, maxStorageTexturesInVertexStage) == offsetof(WGPULimits, maxStorageTexturesInVertexStage),
-        "offsetof mismatch for Limits::maxStorageTexturesInVertexStage");
-static_assert(offsetof(Limits, maxStorageBuffersInFragmentStage) == offsetof(WGPULimits, maxStorageBuffersInFragmentStage),
-        "offsetof mismatch for Limits::maxStorageBuffersInFragmentStage");
-static_assert(offsetof(Limits, maxStorageTexturesInFragmentStage) == offsetof(WGPULimits, maxStorageTexturesInFragmentStage),
-        "offsetof mismatch for Limits::maxStorageTexturesInFragmentStage");
 
 // PipelineLayoutPixelLocalStorage implementation
 PipelineLayoutPixelLocalStorage::PipelineLayoutPixelLocalStorage()
@@ -7300,6 +7792,26 @@ static_assert(offsetof(TexelCopyTextureInfo, origin) == offsetof(WGPUTexelCopyTe
 static_assert(offsetof(TexelCopyTextureInfo, aspect) == offsetof(WGPUTexelCopyTextureInfo, aspect),
         "offsetof mismatch for TexelCopyTextureInfo::aspect");
 
+// TextureComponentSwizzleDescriptor implementation
+TextureComponentSwizzleDescriptor::TextureComponentSwizzleDescriptor()
+  : ChainedStruct { nullptr, SType::TextureComponentSwizzleDescriptor } {}
+struct TextureComponentSwizzleDescriptor::Init {
+    ChainedStruct * const nextInChain;
+    TextureComponentSwizzle swizzle = {};
+};
+TextureComponentSwizzleDescriptor::TextureComponentSwizzleDescriptor(TextureComponentSwizzleDescriptor::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::TextureComponentSwizzleDescriptor }, 
+    swizzle(std::move(init.swizzle)){}
+
+TextureComponentSwizzleDescriptor::operator const WGPUTextureComponentSwizzleDescriptor&() const noexcept {
+    return *reinterpret_cast<const WGPUTextureComponentSwizzleDescriptor*>(this);
+}
+
+static_assert(sizeof(TextureComponentSwizzleDescriptor) == sizeof(WGPUTextureComponentSwizzleDescriptor), "sizeof mismatch for TextureComponentSwizzleDescriptor");
+static_assert(alignof(TextureComponentSwizzleDescriptor) == alignof(WGPUTextureComponentSwizzleDescriptor), "alignof mismatch for TextureComponentSwizzleDescriptor");
+static_assert(offsetof(TextureComponentSwizzleDescriptor, swizzle) == offsetof(WGPUTextureComponentSwizzleDescriptor, swizzle),
+        "offsetof mismatch for TextureComponentSwizzleDescriptor::swizzle");
+
 // TextureDescriptor implementation
 
 TextureDescriptor::operator const WGPUTextureDescriptor&() const noexcept {
@@ -7329,35 +7841,6 @@ static_assert(offsetof(TextureDescriptor, viewFormatCount) == offsetof(WGPUTextu
 static_assert(offsetof(TextureDescriptor, viewFormats) == offsetof(WGPUTextureDescriptor, viewFormats),
         "offsetof mismatch for TextureDescriptor::viewFormats");
 
-// TextureViewDescriptor implementation
-
-TextureViewDescriptor::operator const WGPUTextureViewDescriptor&() const noexcept {
-    return *reinterpret_cast<const WGPUTextureViewDescriptor*>(this);
-}
-
-static_assert(sizeof(TextureViewDescriptor) == sizeof(WGPUTextureViewDescriptor), "sizeof mismatch for TextureViewDescriptor");
-static_assert(alignof(TextureViewDescriptor) == alignof(WGPUTextureViewDescriptor), "alignof mismatch for TextureViewDescriptor");
-static_assert(offsetof(TextureViewDescriptor, nextInChain) == offsetof(WGPUTextureViewDescriptor, nextInChain),
-        "offsetof mismatch for TextureViewDescriptor::nextInChain");
-static_assert(offsetof(TextureViewDescriptor, label) == offsetof(WGPUTextureViewDescriptor, label),
-        "offsetof mismatch for TextureViewDescriptor::label");
-static_assert(offsetof(TextureViewDescriptor, format) == offsetof(WGPUTextureViewDescriptor, format),
-        "offsetof mismatch for TextureViewDescriptor::format");
-static_assert(offsetof(TextureViewDescriptor, dimension) == offsetof(WGPUTextureViewDescriptor, dimension),
-        "offsetof mismatch for TextureViewDescriptor::dimension");
-static_assert(offsetof(TextureViewDescriptor, baseMipLevel) == offsetof(WGPUTextureViewDescriptor, baseMipLevel),
-        "offsetof mismatch for TextureViewDescriptor::baseMipLevel");
-static_assert(offsetof(TextureViewDescriptor, mipLevelCount) == offsetof(WGPUTextureViewDescriptor, mipLevelCount),
-        "offsetof mismatch for TextureViewDescriptor::mipLevelCount");
-static_assert(offsetof(TextureViewDescriptor, baseArrayLayer) == offsetof(WGPUTextureViewDescriptor, baseArrayLayer),
-        "offsetof mismatch for TextureViewDescriptor::baseArrayLayer");
-static_assert(offsetof(TextureViewDescriptor, arrayLayerCount) == offsetof(WGPUTextureViewDescriptor, arrayLayerCount),
-        "offsetof mismatch for TextureViewDescriptor::arrayLayerCount");
-static_assert(offsetof(TextureViewDescriptor, aspect) == offsetof(WGPUTextureViewDescriptor, aspect),
-        "offsetof mismatch for TextureViewDescriptor::aspect");
-static_assert(offsetof(TextureViewDescriptor, usage) == offsetof(WGPUTextureViewDescriptor, usage),
-        "offsetof mismatch for TextureViewDescriptor::usage");
-
 // VertexBufferLayout implementation
 
 VertexBufferLayout::operator const WGPUVertexBufferLayout&() const noexcept {
@@ -7640,6 +8123,35 @@ static_assert(offsetof(SharedTextureMemoryProperties, size) == offsetof(WGPUShar
 static_assert(offsetof(SharedTextureMemoryProperties, format) == offsetof(WGPUSharedTextureMemoryProperties, format),
         "offsetof mismatch for SharedTextureMemoryProperties::format");
 
+// TextureViewDescriptor implementation
+
+TextureViewDescriptor::operator const WGPUTextureViewDescriptor&() const noexcept {
+    return *reinterpret_cast<const WGPUTextureViewDescriptor*>(this);
+}
+
+static_assert(sizeof(TextureViewDescriptor) == sizeof(WGPUTextureViewDescriptor), "sizeof mismatch for TextureViewDescriptor");
+static_assert(alignof(TextureViewDescriptor) == alignof(WGPUTextureViewDescriptor), "alignof mismatch for TextureViewDescriptor");
+static_assert(offsetof(TextureViewDescriptor, nextInChain) == offsetof(WGPUTextureViewDescriptor, nextInChain),
+        "offsetof mismatch for TextureViewDescriptor::nextInChain");
+static_assert(offsetof(TextureViewDescriptor, label) == offsetof(WGPUTextureViewDescriptor, label),
+        "offsetof mismatch for TextureViewDescriptor::label");
+static_assert(offsetof(TextureViewDescriptor, format) == offsetof(WGPUTextureViewDescriptor, format),
+        "offsetof mismatch for TextureViewDescriptor::format");
+static_assert(offsetof(TextureViewDescriptor, dimension) == offsetof(WGPUTextureViewDescriptor, dimension),
+        "offsetof mismatch for TextureViewDescriptor::dimension");
+static_assert(offsetof(TextureViewDescriptor, baseMipLevel) == offsetof(WGPUTextureViewDescriptor, baseMipLevel),
+        "offsetof mismatch for TextureViewDescriptor::baseMipLevel");
+static_assert(offsetof(TextureViewDescriptor, mipLevelCount) == offsetof(WGPUTextureViewDescriptor, mipLevelCount),
+        "offsetof mismatch for TextureViewDescriptor::mipLevelCount");
+static_assert(offsetof(TextureViewDescriptor, baseArrayLayer) == offsetof(WGPUTextureViewDescriptor, baseArrayLayer),
+        "offsetof mismatch for TextureViewDescriptor::baseArrayLayer");
+static_assert(offsetof(TextureViewDescriptor, arrayLayerCount) == offsetof(WGPUTextureViewDescriptor, arrayLayerCount),
+        "offsetof mismatch for TextureViewDescriptor::arrayLayerCount");
+static_assert(offsetof(TextureViewDescriptor, aspect) == offsetof(WGPUTextureViewDescriptor, aspect),
+        "offsetof mismatch for TextureViewDescriptor::aspect");
+static_assert(offsetof(TextureViewDescriptor, usage) == offsetof(WGPUTextureViewDescriptor, usage),
+        "offsetof mismatch for TextureViewDescriptor::usage");
+
 // VertexState implementation
 
 VertexState::operator const WGPUVertexState&() const noexcept {
@@ -7864,20 +8376,20 @@ void DeviceDescriptor::SetUncapturedErrorCallback(L callback) {
 // Adapter implementation
 
 Device Adapter::CreateDevice(DeviceDescriptor const * descriptor) const {
-    auto result = wgpuAdapterCreateDevice(Get(), reinterpret_cast<WGPUDeviceDescriptor const * >(descriptor));
+    auto result = wgpuAdapterCreateDevice(Get(), reinterpret_cast<WGPUDeviceDescriptor const *>(descriptor));
     return Device::Acquire(result);
 }
 void Adapter::GetFeatures(SupportedFeatures * features) const {
     *features = SupportedFeatures();
-    wgpuAdapterGetFeatures(Get(), reinterpret_cast<WGPUSupportedFeatures * >(features));
+    wgpuAdapterGetFeatures(Get(), reinterpret_cast<WGPUSupportedFeatures *>(features));
 }
 ConvertibleStatus Adapter::GetFormatCapabilities(TextureFormat format, DawnFormatCapabilities * capabilities) const {
-    auto result = wgpuAdapterGetFormatCapabilities(Get(), static_cast<WGPUTextureFormat>(format), reinterpret_cast<WGPUDawnFormatCapabilities * >(capabilities));
+    auto result = wgpuAdapterGetFormatCapabilities(Get(), static_cast<WGPUTextureFormat>(format), reinterpret_cast<WGPUDawnFormatCapabilities *>(capabilities));
     return static_cast<Status>(result);
 }
 ConvertibleStatus Adapter::GetInfo(AdapterInfo * info) const {
     *info = AdapterInfo();
-    auto result = wgpuAdapterGetInfo(Get(), reinterpret_cast<WGPUAdapterInfo * >(info));
+    auto result = wgpuAdapterGetInfo(Get(), reinterpret_cast<WGPUAdapterInfo *>(info));
     return static_cast<Status>(result);
 }
 Instance Adapter::GetInstance() const {
@@ -7885,7 +8397,7 @@ Instance Adapter::GetInstance() const {
     return Instance::Acquire(result);
 }
 ConvertibleStatus Adapter::GetLimits(Limits * limits) const {
-    auto result = wgpuAdapterGetLimits(Get(), reinterpret_cast<WGPULimits * >(limits));
+    auto result = wgpuAdapterGetLimits(Get(), reinterpret_cast<WGPULimits *>(limits));
     return static_cast<Status>(result);
 }
 Bool Adapter::HasFeature(FeatureName feature) const {
@@ -7896,7 +8408,7 @@ template <typename F, typename T,
           typename Cb,
           typename CbChar,
           typename>
-Future Adapter::RequestDevice(DeviceDescriptor const * options, CallbackMode callbackMode,F callback, T userdata) const {
+Future Adapter::RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode,F callback, T userdata) const {
     WGPURequestDeviceCallbackInfo callbackInfo = {};
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
     if constexpr (std::is_convertible_v<F, Cb*>) {
@@ -7915,7 +8427,7 @@ Future Adapter::RequestDevice(DeviceDescriptor const * options, CallbackMode cal
     }
     callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
     callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
-    auto result = wgpuAdapterRequestDevice(Get(), reinterpret_cast<WGPUDeviceDescriptor const * >(options), callbackInfo);
+    auto result = wgpuAdapterRequestDevice(Get(), reinterpret_cast<WGPUDeviceDescriptor const *>(descriptor), callbackInfo);
     return Future {
         result.id
     };
@@ -7924,7 +8436,7 @@ template <typename L,
           typename Cb,
           typename CbChar,
           typename>
-Future Adapter::RequestDevice(DeviceDescriptor const * options, CallbackMode callbackMode,L callback) const {
+Future Adapter::RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode,L callback) const {
     using F = RequestDeviceCallback<void>;
 
     WGPURequestDeviceCallbackInfo callbackInfo = {};
@@ -7948,7 +8460,7 @@ Future Adapter::RequestDevice(DeviceDescriptor const * options, CallbackMode cal
         callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
         callbackInfo.userdata2 = nullptr;
     }
-    auto result = wgpuAdapterRequestDevice(Get(), reinterpret_cast<WGPUDeviceDescriptor const * >(options), callbackInfo);
+    auto result = wgpuAdapterRequestDevice(Get(), reinterpret_cast<WGPUDeviceDescriptor const *>(descriptor), callbackInfo);
     return Future {
             result.id
         };
@@ -7970,6 +8482,9 @@ static_assert(alignof(Adapter) == alignof(WGPUAdapter), "alignof mismatch for Ad
 
 // BindGroup implementation
 
+void BindGroup::Destroy() const {
+    wgpuBindGroupDestroy(Get());
+}
 void BindGroup::SetLabel(StringView label) const {
     wgpuBindGroupSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
 }
@@ -8010,6 +8525,10 @@ static_assert(alignof(BindGroupLayout) == alignof(WGPUBindGroupLayout), "alignof
 
 // Buffer implementation
 
+TexelBufferView Buffer::CreateTexelView(TexelBufferViewDescriptor const * descriptor) const {
+    auto result = wgpuBufferCreateTexelView(Get(), reinterpret_cast<WGPUTexelBufferViewDescriptor const *>(descriptor));
+    return TexelBufferView::Acquire(result);
+}
 void Buffer::Destroy() const {
     wgpuBufferDestroy(Get());
 }
@@ -8095,7 +8614,7 @@ Future Buffer::MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode c
         };
 }
 ConvertibleStatus Buffer::ReadMappedRange(size_t offset, void * data, size_t size) const {
-    auto result = wgpuBufferReadMappedRange(Get(), offset, reinterpret_cast<void * >(data), size);
+    auto result = wgpuBufferReadMappedRange(Get(), offset, reinterpret_cast<void *>(data), size);
     return static_cast<Status>(result);
 }
 void Buffer::SetLabel(StringView label) const {
@@ -8105,7 +8624,7 @@ void Buffer::Unmap() const {
     wgpuBufferUnmap(Get());
 }
 ConvertibleStatus Buffer::WriteMappedRange(size_t offset, void const * data, size_t size) const {
-    auto result = wgpuBufferWriteMappedRange(Get(), offset, reinterpret_cast<void const * >(data), size);
+    auto result = wgpuBufferWriteMappedRange(Get(), offset, reinterpret_cast<void const *>(data), size);
     return static_cast<Status>(result);
 }
 
@@ -8146,11 +8665,11 @@ static_assert(alignof(CommandBuffer) == alignof(WGPUCommandBuffer), "alignof mis
 // CommandEncoder implementation
 
 ComputePassEncoder CommandEncoder::BeginComputePass(ComputePassDescriptor const * descriptor) const {
-    auto result = wgpuCommandEncoderBeginComputePass(Get(), reinterpret_cast<WGPUComputePassDescriptor const * >(descriptor));
+    auto result = wgpuCommandEncoderBeginComputePass(Get(), reinterpret_cast<WGPUComputePassDescriptor const *>(descriptor));
     return ComputePassEncoder::Acquire(result);
 }
 RenderPassEncoder CommandEncoder::BeginRenderPass(RenderPassDescriptor const * descriptor) const {
-    auto result = wgpuCommandEncoderBeginRenderPass(Get(), reinterpret_cast<WGPURenderPassDescriptor const * >(descriptor));
+    auto result = wgpuCommandEncoderBeginRenderPass(Get(), reinterpret_cast<WGPURenderPassDescriptor const *>(descriptor));
     return RenderPassEncoder::Acquire(result);
 }
 void CommandEncoder::ClearBuffer(Buffer const& buffer, uint64_t offset, uint64_t size) const {
@@ -8160,16 +8679,16 @@ void CommandEncoder::CopyBufferToBuffer(Buffer const& source, uint64_t sourceOff
     wgpuCommandEncoderCopyBufferToBuffer(Get(), source.Get(), sourceOffset, destination.Get(), destinationOffset, size);
 }
 void CommandEncoder::CopyBufferToTexture(TexelCopyBufferInfo const * source, TexelCopyTextureInfo const * destination, Extent3D const * copySize) const {
-    wgpuCommandEncoderCopyBufferToTexture(Get(), reinterpret_cast<WGPUTexelCopyBufferInfo const * >(source), reinterpret_cast<WGPUTexelCopyTextureInfo const * >(destination), reinterpret_cast<WGPUExtent3D const * >(copySize));
+    wgpuCommandEncoderCopyBufferToTexture(Get(), reinterpret_cast<WGPUTexelCopyBufferInfo const *>(source), reinterpret_cast<WGPUTexelCopyTextureInfo const *>(destination), reinterpret_cast<WGPUExtent3D const *>(copySize));
 }
 void CommandEncoder::CopyTextureToBuffer(TexelCopyTextureInfo const * source, TexelCopyBufferInfo const * destination, Extent3D const * copySize) const {
-    wgpuCommandEncoderCopyTextureToBuffer(Get(), reinterpret_cast<WGPUTexelCopyTextureInfo const * >(source), reinterpret_cast<WGPUTexelCopyBufferInfo const * >(destination), reinterpret_cast<WGPUExtent3D const * >(copySize));
+    wgpuCommandEncoderCopyTextureToBuffer(Get(), reinterpret_cast<WGPUTexelCopyTextureInfo const *>(source), reinterpret_cast<WGPUTexelCopyBufferInfo const *>(destination), reinterpret_cast<WGPUExtent3D const *>(copySize));
 }
 void CommandEncoder::CopyTextureToTexture(TexelCopyTextureInfo const * source, TexelCopyTextureInfo const * destination, Extent3D const * copySize) const {
-    wgpuCommandEncoderCopyTextureToTexture(Get(), reinterpret_cast<WGPUTexelCopyTextureInfo const * >(source), reinterpret_cast<WGPUTexelCopyTextureInfo const * >(destination), reinterpret_cast<WGPUExtent3D const * >(copySize));
+    wgpuCommandEncoderCopyTextureToTexture(Get(), reinterpret_cast<WGPUTexelCopyTextureInfo const *>(source), reinterpret_cast<WGPUTexelCopyTextureInfo const *>(destination), reinterpret_cast<WGPUExtent3D const *>(copySize));
 }
 CommandBuffer CommandEncoder::Finish(CommandBufferDescriptor const * descriptor) const {
-    auto result = wgpuCommandEncoderFinish(Get(), reinterpret_cast<WGPUCommandBufferDescriptor const * >(descriptor));
+    auto result = wgpuCommandEncoderFinish(Get(), reinterpret_cast<WGPUCommandBufferDescriptor const *>(descriptor));
     return CommandBuffer::Acquire(result);
 }
 void CommandEncoder::InjectValidationError(StringView message) const {
@@ -8191,7 +8710,7 @@ void CommandEncoder::SetLabel(StringView label) const {
     wgpuCommandEncoderSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
 }
 void CommandEncoder::WriteBuffer(Buffer const& buffer, uint64_t bufferOffset, uint8_t const * data, uint64_t size) const {
-    wgpuCommandEncoderWriteBuffer(Get(), buffer.Get(), bufferOffset, reinterpret_cast<uint8_t const * >(data), size);
+    wgpuCommandEncoderWriteBuffer(Get(), buffer.Get(), bufferOffset, reinterpret_cast<uint8_t const *>(data), size);
 }
 void CommandEncoder::WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const {
     wgpuCommandEncoderWriteTimestamp(Get(), querySet.Get(), queryIndex);
@@ -8232,10 +8751,10 @@ void ComputePassEncoder::PushDebugGroup(StringView groupLabel) const {
     wgpuComputePassEncoderPushDebugGroup(Get(), *reinterpret_cast<WGPUStringView const*>(&groupLabel));
 }
 void ComputePassEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const {
-    wgpuComputePassEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const * >(dynamicOffsets));
+    wgpuComputePassEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const *>(dynamicOffsets));
 }
 void ComputePassEncoder::SetImmediateData(uint32_t offset, void const * data, size_t size) const {
-    wgpuComputePassEncoderSetImmediateData(Get(), offset, reinterpret_cast<void const * >(data), size);
+    wgpuComputePassEncoderSetImmediateData(Get(), offset, reinterpret_cast<void const *>(data), size);
 }
 void ComputePassEncoder::SetLabel(StringView label) const {
     wgpuComputePassEncoderSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
@@ -8288,23 +8807,23 @@ static_assert(alignof(ComputePipeline) == alignof(WGPUComputePipeline), "alignof
 // Device implementation
 
 BindGroup Device::CreateBindGroup(BindGroupDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateBindGroup(Get(), reinterpret_cast<WGPUBindGroupDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateBindGroup(Get(), reinterpret_cast<WGPUBindGroupDescriptor const *>(descriptor));
     return BindGroup::Acquire(result);
 }
 BindGroupLayout Device::CreateBindGroupLayout(BindGroupLayoutDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateBindGroupLayout(Get(), reinterpret_cast<WGPUBindGroupLayoutDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateBindGroupLayout(Get(), reinterpret_cast<WGPUBindGroupLayoutDescriptor const *>(descriptor));
     return BindGroupLayout::Acquire(result);
 }
 Buffer Device::CreateBuffer(BufferDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateBuffer(Get(), reinterpret_cast<WGPUBufferDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateBuffer(Get(), reinterpret_cast<WGPUBufferDescriptor const *>(descriptor));
     return Buffer::Acquire(result);
 }
 CommandEncoder Device::CreateCommandEncoder(CommandEncoderDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateCommandEncoder(Get(), reinterpret_cast<WGPUCommandEncoderDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateCommandEncoder(Get(), reinterpret_cast<WGPUCommandEncoderDescriptor const *>(descriptor));
     return CommandEncoder::Acquire(result);
 }
 ComputePipeline Device::CreateComputePipeline(ComputePipelineDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateComputePipeline(Get(), reinterpret_cast<WGPUComputePipelineDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateComputePipeline(Get(), reinterpret_cast<WGPUComputePipelineDescriptor const *>(descriptor));
     return ComputePipeline::Acquire(result);
 }
 template <typename F, typename T,
@@ -8330,7 +8849,7 @@ Future Device::CreateComputePipelineAsync(ComputePipelineDescriptor const * desc
     }
     callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
     callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
-    auto result = wgpuDeviceCreateComputePipelineAsync(Get(), reinterpret_cast<WGPUComputePipelineDescriptor const * >(descriptor), callbackInfo);
+    auto result = wgpuDeviceCreateComputePipelineAsync(Get(), reinterpret_cast<WGPUComputePipelineDescriptor const *>(descriptor), callbackInfo);
     return Future {
         result.id
     };
@@ -8363,13 +8882,13 @@ Future Device::CreateComputePipelineAsync(ComputePipelineDescriptor const * desc
         callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
         callbackInfo.userdata2 = nullptr;
     }
-    auto result = wgpuDeviceCreateComputePipelineAsync(Get(), reinterpret_cast<WGPUComputePipelineDescriptor const * >(descriptor), callbackInfo);
+    auto result = wgpuDeviceCreateComputePipelineAsync(Get(), reinterpret_cast<WGPUComputePipelineDescriptor const *>(descriptor), callbackInfo);
     return Future {
             result.id
         };
 }
 Buffer Device::CreateErrorBuffer(BufferDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateErrorBuffer(Get(), reinterpret_cast<WGPUBufferDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateErrorBuffer(Get(), reinterpret_cast<WGPUBufferDescriptor const *>(descriptor));
     return Buffer::Acquire(result);
 }
 ExternalTexture Device::CreateErrorExternalTexture() const {
@@ -8377,31 +8896,31 @@ ExternalTexture Device::CreateErrorExternalTexture() const {
     return ExternalTexture::Acquire(result);
 }
 ShaderModule Device::CreateErrorShaderModule(ShaderModuleDescriptor const * descriptor, StringView errorMessage) const {
-    auto result = wgpuDeviceCreateErrorShaderModule(Get(), reinterpret_cast<WGPUShaderModuleDescriptor const * >(descriptor), *reinterpret_cast<WGPUStringView const*>(&errorMessage));
+    auto result = wgpuDeviceCreateErrorShaderModule(Get(), reinterpret_cast<WGPUShaderModuleDescriptor const *>(descriptor), *reinterpret_cast<WGPUStringView const*>(&errorMessage));
     return ShaderModule::Acquire(result);
 }
 Texture Device::CreateErrorTexture(TextureDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateErrorTexture(Get(), reinterpret_cast<WGPUTextureDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateErrorTexture(Get(), reinterpret_cast<WGPUTextureDescriptor const *>(descriptor));
     return Texture::Acquire(result);
 }
 ExternalTexture Device::CreateExternalTexture(ExternalTextureDescriptor const * externalTextureDescriptor) const {
-    auto result = wgpuDeviceCreateExternalTexture(Get(), reinterpret_cast<WGPUExternalTextureDescriptor const * >(externalTextureDescriptor));
+    auto result = wgpuDeviceCreateExternalTexture(Get(), reinterpret_cast<WGPUExternalTextureDescriptor const *>(externalTextureDescriptor));
     return ExternalTexture::Acquire(result);
 }
 PipelineLayout Device::CreatePipelineLayout(PipelineLayoutDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreatePipelineLayout(Get(), reinterpret_cast<WGPUPipelineLayoutDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreatePipelineLayout(Get(), reinterpret_cast<WGPUPipelineLayoutDescriptor const *>(descriptor));
     return PipelineLayout::Acquire(result);
 }
 QuerySet Device::CreateQuerySet(QuerySetDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateQuerySet(Get(), reinterpret_cast<WGPUQuerySetDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateQuerySet(Get(), reinterpret_cast<WGPUQuerySetDescriptor const *>(descriptor));
     return QuerySet::Acquire(result);
 }
 RenderBundleEncoder Device::CreateRenderBundleEncoder(RenderBundleEncoderDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateRenderBundleEncoder(Get(), reinterpret_cast<WGPURenderBundleEncoderDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateRenderBundleEncoder(Get(), reinterpret_cast<WGPURenderBundleEncoderDescriptor const *>(descriptor));
     return RenderBundleEncoder::Acquire(result);
 }
 RenderPipeline Device::CreateRenderPipeline(RenderPipelineDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateRenderPipeline(Get(), reinterpret_cast<WGPURenderPipelineDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateRenderPipeline(Get(), reinterpret_cast<WGPURenderPipelineDescriptor const *>(descriptor));
     return RenderPipeline::Acquire(result);
 }
 template <typename F, typename T,
@@ -8427,7 +8946,7 @@ Future Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descri
     }
     callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
     callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
-    auto result = wgpuDeviceCreateRenderPipelineAsync(Get(), reinterpret_cast<WGPURenderPipelineDescriptor const * >(descriptor), callbackInfo);
+    auto result = wgpuDeviceCreateRenderPipelineAsync(Get(), reinterpret_cast<WGPURenderPipelineDescriptor const *>(descriptor), callbackInfo);
     return Future {
         result.id
     };
@@ -8460,21 +8979,21 @@ Future Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descri
         callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
         callbackInfo.userdata2 = nullptr;
     }
-    auto result = wgpuDeviceCreateRenderPipelineAsync(Get(), reinterpret_cast<WGPURenderPipelineDescriptor const * >(descriptor), callbackInfo);
+    auto result = wgpuDeviceCreateRenderPipelineAsync(Get(), reinterpret_cast<WGPURenderPipelineDescriptor const *>(descriptor), callbackInfo);
     return Future {
             result.id
         };
 }
 Sampler Device::CreateSampler(SamplerDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateSampler(Get(), reinterpret_cast<WGPUSamplerDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateSampler(Get(), reinterpret_cast<WGPUSamplerDescriptor const *>(descriptor));
     return Sampler::Acquire(result);
 }
 ShaderModule Device::CreateShaderModule(ShaderModuleDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateShaderModule(Get(), reinterpret_cast<WGPUShaderModuleDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateShaderModule(Get(), reinterpret_cast<WGPUShaderModuleDescriptor const *>(descriptor));
     return ShaderModule::Acquire(result);
 }
 Texture Device::CreateTexture(TextureDescriptor const * descriptor) const {
-    auto result = wgpuDeviceCreateTexture(Get(), reinterpret_cast<WGPUTextureDescriptor const * >(descriptor));
+    auto result = wgpuDeviceCreateTexture(Get(), reinterpret_cast<WGPUTextureDescriptor const *>(descriptor));
     return Texture::Acquire(result);
 }
 void Device::Destroy() const {
@@ -8489,19 +9008,19 @@ Adapter Device::GetAdapter() const {
 }
 ConvertibleStatus Device::GetAdapterInfo(AdapterInfo * adapterInfo) const {
     *adapterInfo = AdapterInfo();
-    auto result = wgpuDeviceGetAdapterInfo(Get(), reinterpret_cast<WGPUAdapterInfo * >(adapterInfo));
+    auto result = wgpuDeviceGetAdapterInfo(Get(), reinterpret_cast<WGPUAdapterInfo *>(adapterInfo));
     return static_cast<Status>(result);
 }
 ConvertibleStatus Device::GetAHardwareBufferProperties(void * handle, AHardwareBufferProperties * properties) const {
-    auto result = wgpuDeviceGetAHardwareBufferProperties(Get(), handle, reinterpret_cast<WGPUAHardwareBufferProperties * >(properties));
+    auto result = wgpuDeviceGetAHardwareBufferProperties(Get(), handle, reinterpret_cast<WGPUAHardwareBufferProperties *>(properties));
     return static_cast<Status>(result);
 }
 void Device::GetFeatures(SupportedFeatures * features) const {
     *features = SupportedFeatures();
-    wgpuDeviceGetFeatures(Get(), reinterpret_cast<WGPUSupportedFeatures * >(features));
+    wgpuDeviceGetFeatures(Get(), reinterpret_cast<WGPUSupportedFeatures *>(features));
 }
 ConvertibleStatus Device::GetLimits(Limits * limits) const {
-    auto result = wgpuDeviceGetLimits(Get(), reinterpret_cast<WGPULimits * >(limits));
+    auto result = wgpuDeviceGetLimits(Get(), reinterpret_cast<WGPULimits *>(limits));
     return static_cast<Status>(result);
 }
 Future Device::GetLostFuture() const {
@@ -8519,15 +9038,15 @@ Bool Device::HasFeature(FeatureName feature) const {
     return result;
 }
 SharedBufferMemory Device::ImportSharedBufferMemory(SharedBufferMemoryDescriptor const * descriptor) const {
-    auto result = wgpuDeviceImportSharedBufferMemory(Get(), reinterpret_cast<WGPUSharedBufferMemoryDescriptor const * >(descriptor));
+    auto result = wgpuDeviceImportSharedBufferMemory(Get(), reinterpret_cast<WGPUSharedBufferMemoryDescriptor const *>(descriptor));
     return SharedBufferMemory::Acquire(result);
 }
 SharedFence Device::ImportSharedFence(SharedFenceDescriptor const * descriptor) const {
-    auto result = wgpuDeviceImportSharedFence(Get(), reinterpret_cast<WGPUSharedFenceDescriptor const * >(descriptor));
+    auto result = wgpuDeviceImportSharedFence(Get(), reinterpret_cast<WGPUSharedFenceDescriptor const *>(descriptor));
     return SharedFence::Acquire(result);
 }
 SharedTextureMemory Device::ImportSharedTextureMemory(SharedTextureMemoryDescriptor const * descriptor) const {
-    auto result = wgpuDeviceImportSharedTextureMemory(Get(), reinterpret_cast<WGPUSharedTextureMemoryDescriptor const * >(descriptor));
+    auto result = wgpuDeviceImportSharedTextureMemory(Get(), reinterpret_cast<WGPUSharedTextureMemoryDescriptor const *>(descriptor));
     return SharedTextureMemory::Acquire(result);
 }
 void Device::InjectError(ErrorType type, StringView message) const {
@@ -8657,7 +9176,7 @@ void Device::Tick() const {
     wgpuDeviceTick(Get());
 }
 void Device::ValidateTextureDescriptor(TextureDescriptor const * descriptor) const {
-    wgpuDeviceValidateTextureDescriptor(Get(), reinterpret_cast<WGPUTextureDescriptor const * >(descriptor));
+    wgpuDeviceValidateTextureDescriptor(Get(), reinterpret_cast<WGPUTextureDescriptor const *>(descriptor));
 }
 
 
@@ -8706,13 +9225,12 @@ static_assert(alignof(ExternalTexture) == alignof(WGPUExternalTexture), "alignof
 // Instance implementation
 
 Surface Instance::CreateSurface(SurfaceDescriptor const * descriptor) const {
-    auto result = wgpuInstanceCreateSurface(Get(), reinterpret_cast<WGPUSurfaceDescriptor const * >(descriptor));
+    auto result = wgpuInstanceCreateSurface(Get(), reinterpret_cast<WGPUSurfaceDescriptor const *>(descriptor));
     return Surface::Acquire(result);
 }
-ConvertibleStatus Instance::GetWGSLLanguageFeatures(SupportedWGSLLanguageFeatures * features) const {
+void Instance::GetWGSLLanguageFeatures(SupportedWGSLLanguageFeatures * features) const {
     *features = SupportedWGSLLanguageFeatures();
-    auto result = wgpuInstanceGetWGSLLanguageFeatures(Get(), reinterpret_cast<WGPUSupportedWGSLLanguageFeatures * >(features));
-    return static_cast<Status>(result);
+    wgpuInstanceGetWGSLLanguageFeatures(Get(), reinterpret_cast<WGPUSupportedWGSLLanguageFeatures *>(features));
 }
 Bool Instance::HasWGSLLanguageFeature(WGSLLanguageFeatureName feature) const {
     auto result = wgpuInstanceHasWGSLLanguageFeature(Get(), static_cast<WGPUWGSLLanguageFeatureName>(feature));
@@ -8744,7 +9262,7 @@ Future Instance::RequestAdapter(RequestAdapterOptions const * options, CallbackM
     }
     callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
     callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
-    auto result = wgpuInstanceRequestAdapter(Get(), reinterpret_cast<WGPURequestAdapterOptions const * >(options), callbackInfo);
+    auto result = wgpuInstanceRequestAdapter(Get(), reinterpret_cast<WGPURequestAdapterOptions const *>(options), callbackInfo);
     return Future {
         result.id
     };
@@ -8777,13 +9295,13 @@ Future Instance::RequestAdapter(RequestAdapterOptions const * options, CallbackM
         callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
         callbackInfo.userdata2 = nullptr;
     }
-    auto result = wgpuInstanceRequestAdapter(Get(), reinterpret_cast<WGPURequestAdapterOptions const * >(options), callbackInfo);
+    auto result = wgpuInstanceRequestAdapter(Get(), reinterpret_cast<WGPURequestAdapterOptions const *>(options), callbackInfo);
     return Future {
             result.id
         };
 }
 WaitStatus Instance::WaitAny(size_t futureCount, FutureWaitInfo * futures, uint64_t timeoutNS) const {
-    auto result = wgpuInstanceWaitAny(Get(), futureCount, reinterpret_cast<WGPUFutureWaitInfo * >(futures), timeoutNS);
+    auto result = wgpuInstanceWaitAny(Get(), futureCount, reinterpret_cast<WGPUFutureWaitInfo *>(futures), timeoutNS);
     return static_cast<WaitStatus>(result);
 }
 
@@ -8859,10 +9377,10 @@ static_assert(alignof(QuerySet) == alignof(WGPUQuerySet), "alignof mismatch for
 // Queue implementation
 
 void Queue::CopyExternalTextureForBrowser(ImageCopyExternalTexture const * source, TexelCopyTextureInfo const * destination, Extent3D const * copySize, CopyTextureForBrowserOptions const * options) const {
-    wgpuQueueCopyExternalTextureForBrowser(Get(), reinterpret_cast<WGPUImageCopyExternalTexture const * >(source), reinterpret_cast<WGPUTexelCopyTextureInfo const * >(destination), reinterpret_cast<WGPUExtent3D const * >(copySize), reinterpret_cast<WGPUCopyTextureForBrowserOptions const * >(options));
+    wgpuQueueCopyExternalTextureForBrowser(Get(), reinterpret_cast<WGPUImageCopyExternalTexture const *>(source), reinterpret_cast<WGPUTexelCopyTextureInfo const *>(destination), reinterpret_cast<WGPUExtent3D const *>(copySize), reinterpret_cast<WGPUCopyTextureForBrowserOptions const *>(options));
 }
 void Queue::CopyTextureForBrowser(TexelCopyTextureInfo const * source, TexelCopyTextureInfo const * destination, Extent3D const * copySize, CopyTextureForBrowserOptions const * options) const {
-    wgpuQueueCopyTextureForBrowser(Get(), reinterpret_cast<WGPUTexelCopyTextureInfo const * >(source), reinterpret_cast<WGPUTexelCopyTextureInfo const * >(destination), reinterpret_cast<WGPUExtent3D const * >(copySize), reinterpret_cast<WGPUCopyTextureForBrowserOptions const * >(options));
+    wgpuQueueCopyTextureForBrowser(Get(), reinterpret_cast<WGPUTexelCopyTextureInfo const *>(source), reinterpret_cast<WGPUTexelCopyTextureInfo const *>(destination), reinterpret_cast<WGPUExtent3D const *>(copySize), reinterpret_cast<WGPUCopyTextureForBrowserOptions const *>(options));
 }
 template <typename F, typename T,
           typename Cb,
@@ -8872,14 +9390,17 @@ Future Queue::OnSubmittedWorkDone(CallbackMode callbackMode,F callback, T userda
     WGPUQueueWorkDoneCallbackInfo callbackInfo = {};
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
     if constexpr (std::is_convertible_v<F, Cb*>) {
-        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, void* callback_param, void* userdata_param) {
+        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, WGPUStringView message, void* callback_param, void* userdata_param) {
             auto cb = reinterpret_cast<Cb*>(callback_param);
-            (*cb)(static_cast<QueueWorkDoneStatus>(status), static_cast<T>(userdata_param));
+            (*cb)(static_cast<QueueWorkDoneStatus>(status), StringView {
+    message.data,
+    message.length
+}, static_cast<T>(userdata_param));
         };
     } else {
-        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, void* callback_param, void* userdata_param) {
+        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, WGPUStringView message, void* callback_param, void* userdata_param) {
             auto cb = reinterpret_cast<CbChar*>(callback_param);
-            (*cb)(static_cast<QueueWorkDoneStatus>(status), static_cast<T>(userdata_param));
+            (*cb)(static_cast<QueueWorkDoneStatus>(status), {detail::StringViewAdapter(message)}, static_cast<T>(userdata_param));
         };
     }
     callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
@@ -8899,17 +9420,20 @@ Future Queue::OnSubmittedWorkDone(CallbackMode callbackMode,L callback) const {
     WGPUQueueWorkDoneCallbackInfo callbackInfo = {};
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
     if constexpr (std::is_convertible_v<L, F*>) {
-        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, void* callback_param, void*) {
+        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, WGPUStringView message, void* callback_param, void*) {
             auto cb = reinterpret_cast<F*>(callback_param);
-            (*cb)(static_cast<QueueWorkDoneStatus>(status));
+            (*cb)(static_cast<QueueWorkDoneStatus>(status), StringView {
+    message.data,
+    message.length
+});
         };
         callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
         callbackInfo.userdata2 = nullptr;
     } else {
         auto* lambda = new L(std::move(callback));
-        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, void* callback_param, void*) {
+        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, WGPUStringView message, void* callback_param, void*) {
             std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            (*the_lambda)(static_cast<QueueWorkDoneStatus>(status));
+            (*the_lambda)(static_cast<QueueWorkDoneStatus>(status), {detail::StringViewAdapter(message)});
         };
         callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
         callbackInfo.userdata2 = nullptr;
@@ -8923,13 +9447,13 @@ void Queue::SetLabel(StringView label) const {
     wgpuQueueSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
 }
 void Queue::Submit(size_t commandCount, CommandBuffer const * commands) const {
-    wgpuQueueSubmit(Get(), commandCount, reinterpret_cast<WGPUCommandBuffer const * >(commands));
+    wgpuQueueSubmit(Get(), commandCount, reinterpret_cast<WGPUCommandBuffer const *>(commands));
 }
 void Queue::WriteBuffer(Buffer const& buffer, uint64_t bufferOffset, void const * data, size_t size) const {
-    wgpuQueueWriteBuffer(Get(), buffer.Get(), bufferOffset, reinterpret_cast<void const * >(data), size);
+    wgpuQueueWriteBuffer(Get(), buffer.Get(), bufferOffset, reinterpret_cast<void const *>(data), size);
 }
 void Queue::WriteTexture(TexelCopyTextureInfo const * destination, void const * data, size_t dataSize, TexelCopyBufferLayout const * dataLayout, Extent3D const * writeSize) const {
-    wgpuQueueWriteTexture(Get(), reinterpret_cast<WGPUTexelCopyTextureInfo const * >(destination), reinterpret_cast<void const * >(data), dataSize, reinterpret_cast<WGPUTexelCopyBufferLayout const * >(dataLayout), reinterpret_cast<WGPUExtent3D const * >(writeSize));
+    wgpuQueueWriteTexture(Get(), reinterpret_cast<WGPUTexelCopyTextureInfo const *>(destination), reinterpret_cast<void const *>(data), dataSize, reinterpret_cast<WGPUTexelCopyBufferLayout const *>(dataLayout), reinterpret_cast<WGPUExtent3D const *>(writeSize));
 }
 
 
@@ -8981,7 +9505,7 @@ void RenderBundleEncoder::DrawIndirect(Buffer const& indirectBuffer, uint64_t in
     wgpuRenderBundleEncoderDrawIndirect(Get(), indirectBuffer.Get(), indirectOffset);
 }
 RenderBundle RenderBundleEncoder::Finish(RenderBundleDescriptor const * descriptor) const {
-    auto result = wgpuRenderBundleEncoderFinish(Get(), reinterpret_cast<WGPURenderBundleDescriptor const * >(descriptor));
+    auto result = wgpuRenderBundleEncoderFinish(Get(), reinterpret_cast<WGPURenderBundleDescriptor const *>(descriptor));
     return RenderBundle::Acquire(result);
 }
 void RenderBundleEncoder::InsertDebugMarker(StringView markerLabel) const {
@@ -8994,10 +9518,10 @@ void RenderBundleEncoder::PushDebugGroup(StringView groupLabel) const {
     wgpuRenderBundleEncoderPushDebugGroup(Get(), *reinterpret_cast<WGPUStringView const*>(&groupLabel));
 }
 void RenderBundleEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const {
-    wgpuRenderBundleEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const * >(dynamicOffsets));
+    wgpuRenderBundleEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const *>(dynamicOffsets));
 }
 void RenderBundleEncoder::SetImmediateData(uint32_t offset, void const * data, size_t size) const {
-    wgpuRenderBundleEncoderSetImmediateData(Get(), offset, reinterpret_cast<void const * >(data), size);
+    wgpuRenderBundleEncoderSetImmediateData(Get(), offset, reinterpret_cast<void const *>(data), size);
 }
 void RenderBundleEncoder::SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset, uint64_t size) const {
     wgpuRenderBundleEncoderSetIndexBuffer(Get(), buffer.Get(), static_cast<WGPUIndexFormat>(format), offset, size);
@@ -9050,7 +9574,7 @@ void RenderPassEncoder::EndOcclusionQuery() const {
     wgpuRenderPassEncoderEndOcclusionQuery(Get());
 }
 void RenderPassEncoder::ExecuteBundles(size_t bundleCount, RenderBundle const * bundles) const {
-    wgpuRenderPassEncoderExecuteBundles(Get(), bundleCount, reinterpret_cast<WGPURenderBundle const * >(bundles));
+    wgpuRenderPassEncoderExecuteBundles(Get(), bundleCount, reinterpret_cast<WGPURenderBundle const *>(bundles));
 }
 void RenderPassEncoder::InsertDebugMarker(StringView markerLabel) const {
     wgpuRenderPassEncoderInsertDebugMarker(Get(), *reinterpret_cast<WGPUStringView const*>(&markerLabel));
@@ -9071,13 +9595,13 @@ void RenderPassEncoder::PushDebugGroup(StringView groupLabel) const {
     wgpuRenderPassEncoderPushDebugGroup(Get(), *reinterpret_cast<WGPUStringView const*>(&groupLabel));
 }
 void RenderPassEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const {
-    wgpuRenderPassEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const * >(dynamicOffsets));
+    wgpuRenderPassEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const *>(dynamicOffsets));
 }
 void RenderPassEncoder::SetBlendConstant(Color const * color) const {
-    wgpuRenderPassEncoderSetBlendConstant(Get(), reinterpret_cast<WGPUColor const * >(color));
+    wgpuRenderPassEncoderSetBlendConstant(Get(), reinterpret_cast<WGPUColor const *>(color));
 }
 void RenderPassEncoder::SetImmediateData(uint32_t offset, void const * data, size_t size) const {
-    wgpuRenderPassEncoderSetImmediateData(Get(), offset, reinterpret_cast<void const * >(data), size);
+    wgpuRenderPassEncoderSetImmediateData(Get(), offset, reinterpret_cast<void const *>(data), size);
 }
 void RenderPassEncoder::SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset, uint64_t size) const {
     wgpuRenderPassEncoderSetIndexBuffer(Get(), buffer.Get(), static_cast<WGPUIndexFormat>(format), offset, size);
@@ -9240,20 +9764,20 @@ static_assert(alignof(ShaderModule) == alignof(WGPUShaderModule), "alignof misma
 // SharedBufferMemory implementation
 
 ConvertibleStatus SharedBufferMemory::BeginAccess(Buffer const& buffer, SharedBufferMemoryBeginAccessDescriptor const * descriptor) const {
-    auto result = wgpuSharedBufferMemoryBeginAccess(Get(), buffer.Get(), reinterpret_cast<WGPUSharedBufferMemoryBeginAccessDescriptor const * >(descriptor));
+    auto result = wgpuSharedBufferMemoryBeginAccess(Get(), buffer.Get(), reinterpret_cast<WGPUSharedBufferMemoryBeginAccessDescriptor const *>(descriptor));
     return static_cast<Status>(result);
 }
 Buffer SharedBufferMemory::CreateBuffer(BufferDescriptor const * descriptor) const {
-    auto result = wgpuSharedBufferMemoryCreateBuffer(Get(), reinterpret_cast<WGPUBufferDescriptor const * >(descriptor));
+    auto result = wgpuSharedBufferMemoryCreateBuffer(Get(), reinterpret_cast<WGPUBufferDescriptor const *>(descriptor));
     return Buffer::Acquire(result);
 }
 ConvertibleStatus SharedBufferMemory::EndAccess(Buffer const& buffer, SharedBufferMemoryEndAccessState * descriptor) const {
     *descriptor = SharedBufferMemoryEndAccessState();
-    auto result = wgpuSharedBufferMemoryEndAccess(Get(), buffer.Get(), reinterpret_cast<WGPUSharedBufferMemoryEndAccessState * >(descriptor));
+    auto result = wgpuSharedBufferMemoryEndAccess(Get(), buffer.Get(), reinterpret_cast<WGPUSharedBufferMemoryEndAccessState *>(descriptor));
     return static_cast<Status>(result);
 }
 ConvertibleStatus SharedBufferMemory::GetProperties(SharedBufferMemoryProperties * properties) const {
-    auto result = wgpuSharedBufferMemoryGetProperties(Get(), reinterpret_cast<WGPUSharedBufferMemoryProperties * >(properties));
+    auto result = wgpuSharedBufferMemoryGetProperties(Get(), reinterpret_cast<WGPUSharedBufferMemoryProperties *>(properties));
     return static_cast<Status>(result);
 }
 Bool SharedBufferMemory::IsDeviceLost() const {
@@ -9281,7 +9805,7 @@ static_assert(alignof(SharedBufferMemory) == alignof(WGPUSharedBufferMemory), "a
 // SharedFence implementation
 
 void SharedFence::ExportInfo(SharedFenceExportInfo * info) const {
-    wgpuSharedFenceExportInfo(Get(), reinterpret_cast<WGPUSharedFenceExportInfo * >(info));
+    wgpuSharedFenceExportInfo(Get(), reinterpret_cast<WGPUSharedFenceExportInfo *>(info));
 }
 
 
@@ -9301,20 +9825,20 @@ static_assert(alignof(SharedFence) == alignof(WGPUSharedFence), "alignof mismatc
 // SharedTextureMemory implementation
 
 ConvertibleStatus SharedTextureMemory::BeginAccess(Texture const& texture, SharedTextureMemoryBeginAccessDescriptor const * descriptor) const {
-    auto result = wgpuSharedTextureMemoryBeginAccess(Get(), texture.Get(), reinterpret_cast<WGPUSharedTextureMemoryBeginAccessDescriptor const * >(descriptor));
+    auto result = wgpuSharedTextureMemoryBeginAccess(Get(), texture.Get(), reinterpret_cast<WGPUSharedTextureMemoryBeginAccessDescriptor const *>(descriptor));
     return static_cast<Status>(result);
 }
 Texture SharedTextureMemory::CreateTexture(TextureDescriptor const * descriptor) const {
-    auto result = wgpuSharedTextureMemoryCreateTexture(Get(), reinterpret_cast<WGPUTextureDescriptor const * >(descriptor));
+    auto result = wgpuSharedTextureMemoryCreateTexture(Get(), reinterpret_cast<WGPUTextureDescriptor const *>(descriptor));
     return Texture::Acquire(result);
 }
 ConvertibleStatus SharedTextureMemory::EndAccess(Texture const& texture, SharedTextureMemoryEndAccessState * descriptor) const {
     *descriptor = SharedTextureMemoryEndAccessState();
-    auto result = wgpuSharedTextureMemoryEndAccess(Get(), texture.Get(), reinterpret_cast<WGPUSharedTextureMemoryEndAccessState * >(descriptor));
+    auto result = wgpuSharedTextureMemoryEndAccess(Get(), texture.Get(), reinterpret_cast<WGPUSharedTextureMemoryEndAccessState *>(descriptor));
     return static_cast<Status>(result);
 }
 ConvertibleStatus SharedTextureMemory::GetProperties(SharedTextureMemoryProperties * properties) const {
-    auto result = wgpuSharedTextureMemoryGetProperties(Get(), reinterpret_cast<WGPUSharedTextureMemoryProperties * >(properties));
+    auto result = wgpuSharedTextureMemoryGetProperties(Get(), reinterpret_cast<WGPUSharedTextureMemoryProperties *>(properties));
     return static_cast<Status>(result);
 }
 Bool SharedTextureMemory::IsDeviceLost() const {
@@ -9342,18 +9866,19 @@ static_assert(alignof(SharedTextureMemory) == alignof(WGPUSharedTextureMemory),
 // Surface implementation
 
 void Surface::Configure(SurfaceConfiguration const * config) const {
-    wgpuSurfaceConfigure(Get(), reinterpret_cast<WGPUSurfaceConfiguration const * >(config));
+    wgpuSurfaceConfigure(Get(), reinterpret_cast<WGPUSurfaceConfiguration const *>(config));
 }
 ConvertibleStatus Surface::GetCapabilities(Adapter const& adapter, SurfaceCapabilities * capabilities) const {
     *capabilities = SurfaceCapabilities();
-    auto result = wgpuSurfaceGetCapabilities(Get(), adapter.Get(), reinterpret_cast<WGPUSurfaceCapabilities * >(capabilities));
+    auto result = wgpuSurfaceGetCapabilities(Get(), adapter.Get(), reinterpret_cast<WGPUSurfaceCapabilities *>(capabilities));
     return static_cast<Status>(result);
 }
 void Surface::GetCurrentTexture(SurfaceTexture * surfaceTexture) const {
-    wgpuSurfaceGetCurrentTexture(Get(), reinterpret_cast<WGPUSurfaceTexture * >(surfaceTexture));
+    wgpuSurfaceGetCurrentTexture(Get(), reinterpret_cast<WGPUSurfaceTexture *>(surfaceTexture));
 }
-void Surface::Present() const {
-    wgpuSurfacePresent(Get());
+ConvertibleStatus Surface::Present() const {
+    auto result = wgpuSurfacePresent(Get());
+    return static_cast<Status>(result);
 }
 void Surface::SetLabel(StringView label) const {
     wgpuSurfaceSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
@@ -9376,14 +9901,34 @@ void Surface::WGPURelease(WGPUSurface handle) {
 static_assert(sizeof(Surface) == sizeof(WGPUSurface), "sizeof mismatch for Surface");
 static_assert(alignof(Surface) == alignof(WGPUSurface), "alignof mismatch for Surface");
 
+// TexelBufferView implementation
+
+void TexelBufferView::SetLabel(StringView label) const {
+    wgpuTexelBufferViewSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
+}
+
+
+void TexelBufferView::WGPUAddRef(WGPUTexelBufferView handle) {
+    if (handle != nullptr) {
+        wgpuTexelBufferViewAddRef(handle);
+    }
+}
+void TexelBufferView::WGPURelease(WGPUTexelBufferView handle) {
+    if (handle != nullptr) {
+        wgpuTexelBufferViewRelease(handle);
+    }
+}
+static_assert(sizeof(TexelBufferView) == sizeof(WGPUTexelBufferView), "sizeof mismatch for TexelBufferView");
+static_assert(alignof(TexelBufferView) == alignof(WGPUTexelBufferView), "alignof mismatch for TexelBufferView");
+
 // Texture implementation
 
 TextureView Texture::CreateErrorView(TextureViewDescriptor const * descriptor) const {
-    auto result = wgpuTextureCreateErrorView(Get(), reinterpret_cast<WGPUTextureViewDescriptor const * >(descriptor));
+    auto result = wgpuTextureCreateErrorView(Get(), reinterpret_cast<WGPUTextureViewDescriptor const *>(descriptor));
     return TextureView::Acquire(result);
 }
 TextureView Texture::CreateView(TextureViewDescriptor const * descriptor) const {
-    auto result = wgpuTextureCreateView(Get(), reinterpret_cast<WGPUTextureViewDescriptor const * >(descriptor));
+    auto result = wgpuTextureCreateView(Get(), reinterpret_cast<WGPUTextureViewDescriptor const *>(descriptor));
     return TextureView::Acquire(result);
 }
 void Texture::Destroy() const {
@@ -9421,9 +9966,15 @@ uint32_t Texture::GetWidth() const {
     auto result = wgpuTextureGetWidth(Get());
     return result;
 }
+void Texture::Pin(TextureUsage usage) const {
+    wgpuTexturePin(Get(), static_cast<WGPUTextureUsage>(usage));
+}
 void Texture::SetLabel(StringView label) const {
     wgpuTextureSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
 }
+void Texture::Unpin() const {
+    wgpuTextureUnpin(Get());
+}
 
 
 void Texture::WGPUAddRef(WGPUTexture handle) {
@@ -9491,13 +10042,20 @@ using SurfaceDescriptorFromXlibWindow = SurfaceSourceXlibWindow;
 
 // Free Functions
 static inline Instance CreateInstance(InstanceDescriptor const * descriptor = nullptr) {
-    auto result = wgpuCreateInstance(reinterpret_cast<WGPUInstanceDescriptor const * >(descriptor));
+    auto result = wgpuCreateInstance(reinterpret_cast<WGPUInstanceDescriptor const *>(descriptor));
     return Instance::Acquire(result);
 }
-static inline Status GetInstanceCapabilities(InstanceCapabilities * capabilities) {
-    auto result = wgpuGetInstanceCapabilities(reinterpret_cast<WGPUInstanceCapabilities * >(capabilities));
+static inline void GetInstanceFeatures(SupportedInstanceFeatures * features) {
+    wgpuGetInstanceFeatures(reinterpret_cast<WGPUSupportedInstanceFeatures *>(features));
+}
+static inline Status GetInstanceLimits(InstanceLimits * limits) {
+    auto result = wgpuGetInstanceLimits(reinterpret_cast<WGPUInstanceLimits *>(limits));
     return static_cast<Status>(result);
 }
+static inline Bool HasInstanceFeature(InstanceFeatureName feature) {
+    auto result = wgpuHasInstanceFeature(static_cast<WGPUInstanceFeatureName>(feature));
+    return result;
+}
 static inline Proc GetProcAddress(StringView procName) {
     auto result = wgpuGetProcAddress(*reinterpret_cast<WGPUStringView const*>(&procName));
     return reinterpret_cast<Proc>(result);