wgpu 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c118a2950771b2f34f06fcf4642634e57e8b1de07c26681b81aa94d6a1faaf93
-  data.tar.gz: b4f4cc4e97846d21e74144194f97ede7cb2704725cb5887a885345ceedd1c8f1
+  metadata.gz: b1ef9011b4b35861933cac88658c5f5a8c3dba6c3570a22f54109b0bb2b5f0c8
+  data.tar.gz: 33fef1fd859ad532a49e27d154f6e5fc303bf9ac29bd698a955e14a5b18c58ea
 SHA512:
-  metadata.gz: 5fad367a0475a31c846fa57151a01d6fda7aed9a5592f6167237117da8967df7269a7ac0233059a174be0803794dc844ee4660cd1383ce3fa858009620100036
-  data.tar.gz: 967d67b899a1ca01e5e805407677772aeaec152d72ede7b31746a8baef6d5fa04544863f7d8e70a4bb2804506ccf8fdd58036c5d5a99c49cfe338be73d667504
+  metadata.gz: f11393f0e2cb7cfa5b6f4e1eb2062f221654e45622c2e5f6ac45d9ffcd92e2e08dc101f81f73eb576cc21d7c42b832f0d418f3f5ccd3a502a8f66f24271d6117
+  data.tar.gz: a122894e157f437c429675f80819cc69f1198e54f6ba8188e7eaedb5ba32c431738893fd28ff911bd8f6917ef4fdb73eff4bc8541346150431c095494b4a11a2

data/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 1.2.2 - 2026-09-09
+
+### Fixed
+
+- Invalidate mapped buffer views after unmap, destroy, or release, and check
+  accesses against the actual mapped interval, including after remapping.
+- Reject copies of native resource wrappers and validate resource argument
+  types and release state before passing handles to native code.
+- Validate buffer clear ranges and skip zero-length clears that would panic
+  in the pinned native library.
+- Reject empty error-scope pops, serialize nested scopes per device, start
+  asynchronous pops on the calling thread, and clean up scopes when blocks
+  raise without replacing the original exception.
+- Release native handles after failed resource initialization and free native
+  feature arrays after converting them to Ruby values.
+- Validate timeouts before starting native operations and reclaim adapter
+  and device handles when waiting fails.
+- Accept Array texture extents consistently across creation, copies, writes,
+  and readback through shared descriptor normalization.
+- Distinguish raw Wayland surface pointers from existing WGPU surfaces in
+  `CanvasContext`, with explicit `wl_surface:` and `wgpu_surface:` keys.
+
+### Changed
+
+- Allow rubyzip 3.x alongside 2.x.
+
 ## 1.2.1 - 2026-07-24
 
 ### Added

data/docs/async.md

@@ -27,7 +27,9 @@ Thread implementation until those native entry points are implemented.
 Synchronous adapter/device requests, `Buffer#map_sync`,
 `Device#pop_error_scope`, and `Queue#on_submitted_work_done` accept
 `timeout:` in seconds. The default `nil` preserves the prior unbounded wait.
-Expiry raises `WGPU::TimeoutError`.
+Expiry raises `WGPU::TimeoutError`. Timeouts must be finite and non-negative;
+invalid values are rejected before starting the native operation. Adapter and
+device requests also reclaim their handles if waiting fails for another reason.
 
 `Device.request` can time out only when its adapter is associated with an
 `Instance`. When adopting a native adapter, pass `instance:` to

data/docs/errors.md

@@ -8,6 +8,19 @@
 maps WebGPU error types to `ValidationError`, `OutOfMemoryError`,
 `InternalError`, or `DeviceLostError`.
 
+`with_error_scope { ... }` always pops its scope, including when the block
+raises; the original block exception is preserved. Popping without a scope
+owned by the current thread raises `WGPU::DeviceError` before calling native
+code.
+
+Scopes are nested and serialized per device from push through native pop.
+Push and pop on the same thread, and finish the scope before waiting for
+another thread's scoped work on that device. In particular, do not wait for
+an asynchronous pipeline creation inside `with_error_scope`.
+`pop_error_scope_async` starts the pop immediately on the calling thread and
+waits for its result in the background, so a later push cannot change which
+scope it pops.
+
 Device-level callbacks can be installed after device creation:
 
 ```ruby

data/docs/getting_started_rendering.md

@@ -57,6 +57,11 @@ their window toolkit to `Surface.from_metal_layer`,
 native window/display/layer alive longer than the surface; wgpu-ruby does not
 take ownership of those platform objects.
 
+For `CanvasContext`, pass an existing surface as `wgpu_surface: surface`.
+Wayland platform descriptors use `platform: :wayland`, `display: wl_display`,
+and `wl_surface: wl_surface_pointer`. The older `surface:` key remains
+supported for existing WGPU surfaces and raw Wayland pointers.
+
 [`examples/09_clear_color.rb`](../examples/09_clear_color.rb) is the smallest
 resizable render loop. The other rendering examples cover vertex/index
 buffers, textures, bind groups, depth testing, and uniform updates.

data/docs/resource_lifetime.md

@@ -33,6 +33,15 @@ bytes = device.create_buffer(
 end
 ```
 
+Native wrappers reject `dup` and `clone` with `TypeError`. Resource arguments
+are checked for the expected wrapper type and release state before their
+handles enter FFI. Failed constructors release any native handle they acquired.
+
+Mapped views retain their buffer, but become invalid after `unmap`, `destroy`,
+or `release`. Reading or writing an invalid view raises `WGPU::BufferError`,
+even after the buffer is mapped again. Accesses must fit within the current
+mapped interval, not just within the buffer's total size.
+
 ## Wrapper matrix
 
 The table covers all 23 native wrapper classes. `BufferMappedRange`,

data/lib/wgpu/commands/command_encoder.rb

@@ -24,7 +24,7 @@ module WGPU
         desc[:label][:length] = 0
       end
 
-      @handle = Native.wgpuDeviceCreateCommandEncoder(device.handle, desc)
+      @handle = Native.wgpuDeviceCreateCommandEncoder(NativeResource.checked_handle(device, expected_class: Device), desc)
       raise CommandError, "Failed to create command encoder" if @handle.null?
     end
 
@@ -86,8 +86,8 @@ module WGPU
       raise CommandError, "Encoder already finished" if @finished
       Native.wgpuCommandEncoderCopyBufferToBuffer(
         @handle,
-        source.handle, source_offset,
-        destination.handle, destination_offset,
+        NativeResource.checked_handle(source, expected_class: Buffer), source_offset,
+        NativeResource.checked_handle(destination, expected_class: Buffer), destination_offset,
         size
       )
     end
@@ -100,19 +100,16 @@ module WGPU
     def copy_buffer_to_texture(source:, destination:, copy_size:)
       raise CommandError, "Encoder already finished" if @finished
 
-      size = Native::Extent3D.new
-      size[:width] = copy_size[:width] || copy_size[0]
-      size[:height] = copy_size[:height] || copy_size[1] || 1
-      size[:depth_or_array_layers] = copy_size[:depth_or_array_layers] || copy_size[2] || 1
+      size = DescriptorHelpers.extent_3d(copy_size)
 
       src = Native::ImageCopyBuffer.new
       src[:layout][:offset] = source[:offset] || 0
       src[:layout][:bytes_per_row] = source[:bytes_per_row]
       src[:layout][:rows_per_image] = source[:rows_per_image] || size[:height]
-      src[:buffer] = source[:buffer].handle
+      src[:buffer] = NativeResource.checked_handle(source[:buffer], expected_class: Buffer)
 
       dst = Native::ImageCopyTexture.new
-      dst[:texture] = destination[:texture].handle
+      dst[:texture] = NativeResource.checked_handle(destination[:texture], expected_class: Texture)
       dst[:mip_level] = destination[:mip_level] || 0
       dst[:origin][:x] = destination.dig(:origin, :x) || 0
       dst[:origin][:y] = destination.dig(:origin, :y) || 0
@@ -134,13 +131,10 @@ module WGPU
     def copy_texture_to_buffer(source:, destination:, copy_size:)
       raise CommandError, "Encoder already finished" if @finished
 
-      size = Native::Extent3D.new
-      size[:width] = copy_size[:width] || copy_size[0]
-      size[:height] = copy_size[:height] || copy_size[1] || 1
-      size[:depth_or_array_layers] = copy_size[:depth_or_array_layers] || copy_size[2] || 1
+      size = DescriptorHelpers.extent_3d(copy_size)
 
       src = Native::ImageCopyTexture.new
-      src[:texture] = source[:texture].handle
+      src[:texture] = NativeResource.checked_handle(source[:texture], expected_class: Texture)
       src[:mip_level] = source[:mip_level] || 0
       src[:origin][:x] = source.dig(:origin, :x) || 0
       src[:origin][:y] = source.dig(:origin, :y) || 0
@@ -155,7 +149,7 @@ module WGPU
       dst[:layout][:offset] = destination[:offset] || 0
       dst[:layout][:bytes_per_row] = destination[:bytes_per_row]
       dst[:layout][:rows_per_image] = destination[:rows_per_image] || size[:height]
-      dst[:buffer] = destination[:buffer].handle
+      dst[:buffer] = NativeResource.checked_handle(destination[:buffer], expected_class: Buffer)
 
       Native.wgpuCommandEncoderCopyTextureToBuffer(@handle, src, dst, size)
     end
@@ -169,7 +163,7 @@ module WGPU
       raise CommandError, "Encoder already finished" if @finished
 
       src = Native::ImageCopyTexture.new
-      src[:texture] = source[:texture].handle
+      src[:texture] = NativeResource.checked_handle(source[:texture], expected_class: Texture)
       src[:mip_level] = source[:mip_level] || 0
       src[:origin][:x] = source.dig(:origin, :x) || 0
       src[:origin][:y] = source.dig(:origin, :y) || 0
@@ -181,7 +175,7 @@ module WGPU
       )
 
       dst = Native::ImageCopyTexture.new
-      dst[:texture] = destination[:texture].handle
+      dst[:texture] = NativeResource.checked_handle(destination[:texture], expected_class: Texture)
       dst[:mip_level] = destination[:mip_level] || 0
       dst[:origin][:x] = destination.dig(:origin, :x) || 0
       dst[:origin][:y] = destination.dig(:origin, :y) || 0
@@ -192,10 +186,7 @@ module WGPU
         name: "destination texture aspect"
       )
 
-      size = Native::Extent3D.new
-      size[:width] = copy_size[:width] || copy_size[0]
-      size[:height] = copy_size[:height] || copy_size[1] || 1
-      size[:depth_or_array_layers] = copy_size[:depth_or_array_layers] || copy_size[2] || 1
+      size = DescriptorHelpers.extent_3d(copy_size)
 
       Native.wgpuCommandEncoderCopyTextureToTexture(@handle, src, dst, size)
     end
@@ -206,10 +197,10 @@ module WGPU
       raise CommandError, "Encoder already finished" if @finished
       Native.wgpuCommandEncoderResolveQuerySet(
         @handle,
-        query_set.handle,
+        NativeResource.checked_handle(query_set, expected_class: QuerySet),
         first_query,
         query_count,
-        destination.handle,
+        NativeResource.checked_handle(destination, expected_class: Buffer),
         destination_offset
       )
     end
@@ -221,8 +212,15 @@ module WGPU
     # @return [void]
     def clear_buffer(buffer, offset: 0, size: nil)
       raise CommandError, "Encoder already finished" if @finished
-      size ||= buffer.size - offset
-      Native.wgpuCommandEncoderClearBuffer(@handle, buffer.handle, offset, size)
+      buffer_handle = NativeResource.checked_handle(buffer, expected_class: Buffer)
+      offset = DataTypes.validate_alignment!(offset, 4, name: "clear offset")
+      size = DataTypes.validate_alignment!(size || (buffer.size - offset), 4, name: "clear size")
+      if offset > buffer.size || size > buffer.size - offset
+        raise ArgumentError, "clear range exceeds buffer size"
+      end
+      return if size.zero?
+
+      Native.wgpuCommandEncoderClearBuffer(@handle, buffer_handle, offset, size)
     end
 
     # Writes a GPU timestamp to a query set.
@@ -231,7 +229,7 @@ module WGPU
     # @return [void]
     def write_timestamp(query_set, query_index)
       raise CommandError, "Encoder already finished" if @finished
-      Native.wgpuCommandEncoderWriteTimestamp(@handle, query_set.handle, query_index)
+      Native.wgpuCommandEncoderWriteTimestamp(@handle, NativeResource.checked_handle(query_set, expected_class: QuerySet), query_index)
     end
 
     # Starts a labeled group in GPU debugging tools.

data/lib/wgpu/commands/compute_pass.rb

@@ -25,7 +25,7 @@ module WGPU
       @timestamp_writes = nil
       if timestamp_writes
         @timestamp_writes = Native::ComputePassTimestampWrites.new
-        @timestamp_writes[:query_set] = timestamp_writes.fetch(:query_set).handle
+        @timestamp_writes[:query_set] = NativeResource.checked_handle(timestamp_writes.fetch(:query_set), expected_class: QuerySet)
         @timestamp_writes[:beginning_of_pass_write_index] = timestamp_writes[:beginning_of_pass_write_index] || 0xFFFFFFFF
         @timestamp_writes[:end_of_pass_write_index] = timestamp_writes[:end_of_pass_write_index] || 0xFFFFFFFF
         desc[:timestamp_writes] = @timestamp_writes.to_ptr
@@ -33,7 +33,7 @@ module WGPU
         desc[:timestamp_writes] = nil
       end
 
-      @handle = Native.wgpuCommandEncoderBeginComputePass(encoder.handle, desc)
+      @handle = Native.wgpuCommandEncoderBeginComputePass(NativeResource.checked_handle(encoder, expected_class: CommandEncoder), desc)
       raise CommandError, "Failed to begin compute pass" if @handle.null?
     end
 
@@ -41,7 +41,7 @@ module WGPU
     # @param pipeline [ComputePipeline] pipeline to bind
     # @return [void]
     def set_pipeline(pipeline)
-      Native.wgpuComputePassEncoderSetPipeline(@handle, pipeline.handle)
+      Native.wgpuComputePassEncoderSetPipeline(@handle, NativeResource.checked_handle(pipeline, expected_class: ComputePipeline))
     end
 
     # Binds a resource group for subsequent dispatches.
@@ -51,11 +51,11 @@ module WGPU
     # @return [void]
     def set_bind_group(index, bind_group, dynamic_offsets: [])
       if dynamic_offsets.empty?
-        Native.wgpuComputePassEncoderSetBindGroup(@handle, index, bind_group.handle, 0, nil)
+        Native.wgpuComputePassEncoderSetBindGroup(@handle, index, NativeResource.checked_handle(bind_group, expected_class: BindGroup), 0, nil)
       else
         offsets_ptr = FFI::MemoryPointer.new(:uint32, dynamic_offsets.size)
         offsets_ptr.write_array_of_uint32(dynamic_offsets)
-        Native.wgpuComputePassEncoderSetBindGroup(@handle, index, bind_group.handle, dynamic_offsets.size, offsets_ptr)
+        Native.wgpuComputePassEncoderSetBindGroup(@handle, index, NativeResource.checked_handle(bind_group, expected_class: BindGroup), dynamic_offsets.size, offsets_ptr)
       end
     end
 
@@ -73,7 +73,7 @@ module WGPU
     # @param offset [Integer] byte offset of the arguments
     # @return [void]
     def dispatch_workgroups_indirect(buffer, offset: 0)
-      Native.wgpuComputePassEncoderDispatchWorkgroupsIndirect(@handle, buffer.handle, offset)
+      Native.wgpuComputePassEncoderDispatchWorkgroupsIndirect(@handle, NativeResource.checked_handle(buffer, expected_class: Buffer), offset)
     end
 
     # Starts a labeled group in GPU debugging tools.

data/lib/wgpu/commands/render_bundle_encoder.rb

@@ -47,7 +47,7 @@ module WGPU
       desc[:depth_read_only] = depth_read_only ? 1 : 0
       desc[:stencil_read_only] = stencil_read_only ? 1 : 0
 
-      @handle = Native.wgpuDeviceCreateRenderBundleEncoder(device.handle, desc)
+      @handle = Native.wgpuDeviceCreateRenderBundleEncoder(NativeResource.checked_handle(device, expected_class: Device), desc)
       raise RenderBundleError, "Failed to create render bundle encoder" if @handle.null?
     end
 
@@ -58,7 +58,7 @@ module WGPU
     def set_pipeline(pipeline)
       raise RenderBundleError, "Encoder already finished" if @finished
 
-      Native.wgpuRenderBundleEncoderSetPipeline(@handle, pipeline.handle)
+      Native.wgpuRenderBundleEncoderSetPipeline(@handle, NativeResource.checked_handle(pipeline, expected_class: RenderPipeline))
     end
 
     # Binds a resource group for subsequent bundle draws.
@@ -72,9 +72,9 @@ module WGPU
       if dynamic_offsets && !dynamic_offsets.empty?
         offsets_ptr = FFI::MemoryPointer.new(:uint32, dynamic_offsets.size)
         offsets_ptr.write_array_of_uint32(dynamic_offsets)
-        Native.wgpuRenderBundleEncoderSetBindGroup(@handle, index, bind_group.handle, dynamic_offsets.size, offsets_ptr)
+        Native.wgpuRenderBundleEncoderSetBindGroup(@handle, index, NativeResource.checked_handle(bind_group, expected_class: BindGroup), dynamic_offsets.size, offsets_ptr)
       else
-        Native.wgpuRenderBundleEncoderSetBindGroup(@handle, index, bind_group.handle, 0, nil)
+        Native.wgpuRenderBundleEncoderSetBindGroup(@handle, index, NativeResource.checked_handle(bind_group, expected_class: BindGroup), 0, nil)
       end
     end
 
@@ -86,7 +86,7 @@ module WGPU
       raise RenderBundleError, "Encoder already finished" if @finished
 
       size ||= buffer.size - offset
-      Native.wgpuRenderBundleEncoderSetVertexBuffer(@handle, slot, buffer.handle, offset, size)
+      Native.wgpuRenderBundleEncoderSetVertexBuffer(@handle, slot, NativeResource.checked_handle(buffer, expected_class: Buffer), offset, size)
     end
 
     # Binds an index buffer for indexed bundle draws.
@@ -98,7 +98,7 @@ module WGPU
 
       size ||= buffer.size - offset
       format_value = Native::EnumHelper.coerce(Native::IndexFormat, format, name: "index format")
-      Native.wgpuRenderBundleEncoderSetIndexBuffer(@handle, buffer.handle, format_value, offset, size)
+      Native.wgpuRenderBundleEncoderSetIndexBuffer(@handle, NativeResource.checked_handle(buffer, expected_class: Buffer), format_value, offset, size)
     end
 
     # Records a non-indexed draw in the bundle.
@@ -124,7 +124,7 @@ module WGPU
     def draw_indirect(buffer, offset: 0)
       raise RenderBundleError, "Encoder already finished" if @finished
 
-      Native.wgpuRenderBundleEncoderDrawIndirect(@handle, buffer.handle, offset)
+      Native.wgpuRenderBundleEncoderDrawIndirect(@handle, NativeResource.checked_handle(buffer, expected_class: Buffer), offset)
     end
 
     # Records an indexed draw using buffer arguments.
@@ -134,7 +134,7 @@ module WGPU
     def draw_indexed_indirect(buffer, offset: 0)
       raise RenderBundleError, "Encoder already finished" if @finished
 
-      Native.wgpuRenderBundleEncoderDrawIndexedIndirect(@handle, buffer.handle, offset)
+      Native.wgpuRenderBundleEncoderDrawIndexedIndirect(@handle, NativeResource.checked_handle(buffer, expected_class: Buffer), offset)
     end
 
     # Starts a labeled group in GPU debugging tools.

data/lib/wgpu/commands/render_pass.rb

@@ -34,10 +34,10 @@ module WGPU
         desc[:depth_stencil_attachment] = nil
       end
 
-      desc[:occlusion_query_set] = occlusion_query_set&.handle
+      desc[:occlusion_query_set] = (occlusion_query_set && NativeResource.checked_handle(occlusion_query_set, expected_class: QuerySet))
       if timestamp_writes
         ts = Native::RenderPassTimestampWrites.new
-        ts[:query_set] = timestamp_writes.fetch(:query_set).handle
+        ts[:query_set] = NativeResource.checked_handle(timestamp_writes.fetch(:query_set), expected_class: QuerySet)
         ts[:beginning_of_pass_write_index] = timestamp_writes[:beginning_of_pass_write_index] || 0xFFFFFFFF
         ts[:end_of_pass_write_index] = timestamp_writes[:end_of_pass_write_index] || 0xFFFFFFFF
         @pointers << ts
@@ -46,7 +46,7 @@ module WGPU
         desc[:timestamp_writes] = nil
       end
 
-      @handle = Native.wgpuCommandEncoderBeginRenderPass(encoder.handle, desc)
+      @handle = Native.wgpuCommandEncoderBeginRenderPass(NativeResource.checked_handle(encoder, expected_class: CommandEncoder), desc)
       raise CommandError, "Failed to begin render pass" if @handle.null?
     end
 
@@ -54,7 +54,7 @@ module WGPU
     # @param pipeline [RenderPipeline] pipeline to bind
     # @return [void]
     def set_pipeline(pipeline)
-      Native.wgpuRenderPassEncoderSetPipeline(@handle, pipeline.handle)
+      Native.wgpuRenderPassEncoderSetPipeline(@handle, NativeResource.checked_handle(pipeline, expected_class: RenderPipeline))
     end
 
     # Binds a resource group for subsequent draws.
@@ -64,11 +64,11 @@ module WGPU
     # @return [void]
     def set_bind_group(index, bind_group, dynamic_offsets: [])
       if dynamic_offsets.empty?
-        Native.wgpuRenderPassEncoderSetBindGroup(@handle, index, bind_group.handle, 0, nil)
+        Native.wgpuRenderPassEncoderSetBindGroup(@handle, index, NativeResource.checked_handle(bind_group, expected_class: BindGroup), 0, nil)
       else
         offsets_ptr = FFI::MemoryPointer.new(:uint32, dynamic_offsets.size)
         offsets_ptr.write_array_of_uint32(dynamic_offsets)
-        Native.wgpuRenderPassEncoderSetBindGroup(@handle, index, bind_group.handle, dynamic_offsets.size, offsets_ptr)
+        Native.wgpuRenderPassEncoderSetBindGroup(@handle, index, NativeResource.checked_handle(bind_group, expected_class: BindGroup), dynamic_offsets.size, offsets_ptr)
       end
     end
 
@@ -80,7 +80,7 @@ module WGPU
     # @return [void]
     def set_vertex_buffer(slot, buffer, offset: 0, size: nil)
       size ||= buffer.size - offset
-      Native.wgpuRenderPassEncoderSetVertexBuffer(@handle, slot, buffer.handle, offset, size)
+      Native.wgpuRenderPassEncoderSetVertexBuffer(@handle, slot, NativeResource.checked_handle(buffer, expected_class: Buffer), offset, size)
     end
 
     # Binds an index buffer for indexed draws.
@@ -92,7 +92,7 @@ module WGPU
     def set_index_buffer(buffer, format, offset: 0, size: nil)
       size ||= buffer.size - offset
       format_value = Native::EnumHelper.coerce(Native::IndexFormat, format, name: "index format")
-      Native.wgpuRenderPassEncoderSetIndexBuffer(@handle, buffer.handle, format_value, offset, size)
+      Native.wgpuRenderPassEncoderSetIndexBuffer(@handle, NativeResource.checked_handle(buffer, expected_class: Buffer), format_value, offset, size)
     end
 
     # Records a non-indexed draw.
@@ -161,7 +161,7 @@ module WGPU
     # @param offset [Integer] byte offset of the arguments
     # @return [void]
     def draw_indirect(buffer, offset: 0)
-      Native.wgpuRenderPassEncoderDrawIndirect(@handle, buffer.handle, offset)
+      Native.wgpuRenderPassEncoderDrawIndirect(@handle, NativeResource.checked_handle(buffer, expected_class: Buffer), offset)
     end
 
     # Draws using indexed arguments stored in a buffer.
@@ -170,7 +170,7 @@ module WGPU
     # @param offset [Integer] byte offset of the arguments
     # @return [void]
     def draw_indexed_indirect(buffer, offset: 0)
-      Native.wgpuRenderPassEncoderDrawIndexedIndirect(@handle, buffer.handle, offset)
+      Native.wgpuRenderPassEncoderDrawIndexedIndirect(@handle, NativeResource.checked_handle(buffer, expected_class: Buffer), offset)
     end
 
     # Executes pre-recorded render bundles.
@@ -178,7 +178,7 @@ module WGPU
     # @param bundles [Array<RenderBundle>] bundles to execute in order
     # @return [void]
     def execute_bundles(bundles)
-      bundle_handles = bundles.map(&:handle)
+      bundle_handles = bundles.map { |bundle| NativeResource.checked_handle(bundle, expected_class: RenderBundle) }
       bundles_ptr = FFI::MemoryPointer.new(:pointer, bundle_handles.size)
       bundles_ptr.write_array_of_pointer(bundle_handles)
       Native.wgpuRenderPassEncoderExecuteBundles(@handle, bundle_handles.size, bundles_ptr)
@@ -283,9 +283,9 @@ module WGPU
       attachments.each_with_index do |att, i|
         ca = Native::RenderPassColorAttachment.new(ptr + (i * Native::RenderPassColorAttachment.size))
         ca[:next_in_chain] = nil
-        ca[:view] = att[:view].handle
+        ca[:view] = NativeResource.checked_handle(att[:view], expected_class: TextureView)
         ca[:depth_slice] = att[:depth_slice] || 0xFFFFFFFF
-        ca[:resolve_target] = att[:resolve_target]&.handle
+        ca[:resolve_target] = (att[:resolve_target] && NativeResource.checked_handle(att[:resolve_target], expected_class: TextureView))
         ca[:load_op] = Native::EnumHelper.coerce(Native::LoadOp, att[:load_op] || :clear, name: "load op")
         ca[:store_op] = Native::EnumHelper.coerce(Native::StoreOp, att[:store_op] || :store, name: "store op")
 
@@ -303,7 +303,7 @@ module WGPU
       ds = Native::RenderPassDepthStencilAttachment.new
       @pointers << ds
 
-      ds[:view] = att[:view].handle
+      ds[:view] = NativeResource.checked_handle(att[:view], expected_class: TextureView)
       ds[:depth_load_op] = Native::EnumHelper.coerce(
         Native::LoadOp,
         att[:depth_load_op] || :clear,

data/lib/wgpu/core/adapter.rb

@@ -28,6 +28,7 @@ module WGPU
     # @raise [TimeoutError] if the request exceeds +timeout+
     def self.request(instance, power_preference: :high_performance, backend: nil, feature_level: :core,
                      force_fallback_adapter: false, compatible_surface: nil, timeout: nil)
+      timeout = AsyncWaiter.normalize_timeout(timeout)
       adapter_ptr = FFI::MemoryPointer.new(:pointer)
       status_holder = {
         done: false,
@@ -80,7 +81,7 @@ module WGPU
         backend || :undefined,
         name: "backend type"
       )
-      options[:compatible_surface] = compatible_surface&.handle
+      options[:compatible_surface] = (compatible_surface && NativeResource.checked_handle(compatible_surface, expected_class: Surface))
 
       callback_info = Native::RequestAdapterCallbackInfo.new
       callback_info[:next_in_chain] = nil
@@ -92,7 +93,7 @@ module WGPU
       callback_token = CallbackKeepalive.retain(instance, callback)
       future =
         begin
-          Native.wgpuInstanceRequestAdapter(instance.handle, options, callback_info)
+          Native.wgpuInstanceRequestAdapter(NativeResource.checked_handle(instance, expected_class: Instance), options, callback_info)
         rescue StandardError
           CallbackKeepalive.release(instance, callback_token)
           raise
@@ -100,7 +101,7 @@ module WGPU
 
       begin
         AsyncWaiter.wait(status_holder: status_holder, instance: instance, future: future, timeout: timeout)
-      rescue TimeoutError
+      rescue StandardError
         abandoned_adapter = status_holder[:mutex].synchronize do
           status_holder[:abandoned] = true
           next unless status_holder[:done] && !status_holder[:cleanup_claimed]
@@ -212,6 +213,8 @@ module WGPU
         end
       end
       result
+    ensure
+      Native.wgpuSupportedFeaturesFreeMembers(supported) if supported
     end
 
     # Reports whether the adapter supports a feature.

data/lib/wgpu/core/async_waiter.rb

@@ -45,8 +45,7 @@ module WGPU
     # @return [void]
     # @raise [TimeoutError] if completion exceeds the timeout
     def wait(status_holder:, instance: nil, device: nil, future: nil, timeout: nil)
-      timeout = Float(timeout) if timeout
-      raise ArgumentError, "timeout must be non-negative" if timeout&.negative?
+      timeout = normalize_timeout(timeout)
 
       deadline = monotonic_time + timeout if timeout
       wait_info = build_wait_info(future) if instance && Native.future_api?
@@ -60,12 +59,24 @@ module WGPU
         elsif instance
           instance.process_events
         elsif device && Native.device_poll_available?
-          Native.wgpuDevicePoll(device.handle, 0, nil)
+          Native.wgpuDevicePoll(NativeResource.checked_handle(device, expected_class: Device), 0, nil)
         end
         sleep(poll_interval) unless status_holder[:done] || waited
       end
     end
 
+    # Validates a timeout before any native operation is started.
+    def normalize_timeout(timeout)
+      return nil if timeout.nil?
+
+      value = Float(timeout)
+      raise ArgumentError, "timeout must be finite and non-negative" unless value.finite? && value >= 0
+
+      value
+    rescue TypeError
+      raise ArgumentError, "timeout must be a number"
+    end
+
     def callback_mode_value(name)
       Native::CallbackMode[name] || CALLBACK_MODE_FALLBACK.fetch(name)
     end
@@ -87,7 +98,7 @@ module WGPU
     private_class_method :build_wait_info
 
     def wait_with_wait_any(instance, wait_info)
-      status = Native.wgpuInstanceWaitAny(instance.handle, 1, wait_info.to_ptr, 0)
+      status = Native.wgpuInstanceWaitAny(NativeResource.checked_handle(instance, expected_class: Instance), 1, wait_info.to_ptr, 0)
       return false if [:success, :timed_out].include?(status)
 
       raise Error, "wgpuInstanceWaitAny failed: #{status.inspect}"

data/lib/wgpu/core/canvas_context.rb

@@ -10,7 +10,10 @@ module WGPU
     def initialize(instance, present_info = {})
       @instance = instance
       @present_info = present_info || {}
-      @surface = @present_info[:surface]
+      @surface = @present_info[:wgpu_surface]
+      if @present_info[:surface].is_a?(Surface) || ![:wayland, :linux_wayland].include?(@present_info[:platform]&.to_sym)
+        @surface ||= @present_info[:surface]
+      end
       @physical_size = [0, 0]
       @config = nil
     end
@@ -125,7 +128,7 @@ module WGPU
                  when :x11, :linux_x11
                    Surface.from_xlib_window(@instance, @present_info.fetch(:display), @present_info.fetch(:window))
                  when :wayland, :linux_wayland
-                   Surface.from_wayland_surface(@instance, @present_info.fetch(:display), @present_info.fetch(:surface))
+                   Surface.from_wayland_surface(@instance, @present_info.fetch(:display), @present_info.fetch(:wl_surface) { @present_info.fetch(:surface) })
                  else
                    raise SurfaceError, "Cannot build surface from present_info: #{@present_info.inspect}"
                  end