diff --git a/wgpu/src/backend/direct.rs b/wgpu/src/backend/direct.rs
index bd84edefa5..f49c6e39c6 100644
--- a/wgpu/src/backend/direct.rs
+++ b/wgpu/src/backend/direct.rs
@@ -121,10 +121,10 @@ mod pass_impl {
         }
         fn dispatch_indirect(
             &mut self,
-            indirect_buffer: &wgc::id::BufferId,
+            indirect_buffer: &super::Buffer,
             indirect_offset: wgt::BufferAddress,
         ) {
-            wgpu_compute_pass_dispatch_indirect(self, *indirect_buffer, indirect_offset)
+            wgpu_compute_pass_dispatch_indirect(self, indirect_buffer.id, indirect_offset)
         }
     }
 
@@ -150,20 +150,20 @@ mod pass_impl {
         }
         fn set_index_buffer(
             &mut self,
-            buffer: &wgc::id::BufferId,
+            buffer: &super::Buffer,
             offset: wgt::BufferAddress,
             size: Option<wgt::BufferSize>,
         ) {
-            wgpu_render_pass_set_index_buffer(self, *buffer, offset, size)
+            wgpu_render_pass_set_index_buffer(self, buffer.id, offset, size)
         }
         fn set_vertex_buffer(
             &mut self,
             slot: u32,
-            buffer: &wgc::id::BufferId,
+            buffer: &super::Buffer,
             offset: wgt::BufferAddress,
             size: Option<wgt::BufferSize>,
         ) {
-            wgpu_render_pass_set_vertex_buffer(self, slot, *buffer, offset, size)
+            wgpu_render_pass_set_vertex_buffer(self, slot, buffer.id, offset, size)
         }
         fn set_push_constants(&mut self, stages: wgt::ShaderStage, offset: u32, data: &[u32]) {
             unsafe {
@@ -199,69 +199,69 @@ mod pass_impl {
         }
         fn draw_indirect(
             &mut self,
-            indirect_buffer: &wgc::id::BufferId,
+            indirect_buffer: &super::Buffer,
             indirect_offset: wgt::BufferAddress,
         ) {
-            wgpu_render_pass_draw_indirect(self, *indirect_buffer, indirect_offset)
+            wgpu_render_pass_draw_indirect(self, indirect_buffer.id, indirect_offset)
         }
         fn draw_indexed_indirect(
             &mut self,
-            indirect_buffer: &wgc::id::BufferId,
+            indirect_buffer: &super::Buffer,
             indirect_offset: wgt::BufferAddress,
         ) {
-            wgpu_render_pass_draw_indexed_indirect(self, *indirect_buffer, indirect_offset)
+            wgpu_render_pass_draw_indexed_indirect(self, indirect_buffer.id, indirect_offset)
         }
         fn multi_draw_indirect(
             &mut self,
-            indirect_buffer: &wgc::id::BufferId,
+            indirect_buffer: &super::Buffer,
             indirect_offset: wgt::BufferAddress,
             count: u32,
         ) {
-            wgpu_render_pass_multi_draw_indirect(self, *indirect_buffer, indirect_offset, count)
+            wgpu_render_pass_multi_draw_indirect(self, indirect_buffer.id, indirect_offset, count)
         }
         fn multi_draw_indexed_indirect(
             &mut self,
-            indirect_buffer: &wgc::id::BufferId,
+            indirect_buffer: &super::Buffer,
             indirect_offset: wgt::BufferAddress,
             count: u32,
         ) {
             wgpu_render_pass_multi_draw_indexed_indirect(
                 self,
-                *indirect_buffer,
+                indirect_buffer.id,
                 indirect_offset,
                 count,
             )
         }
         fn multi_draw_indirect_count(
             &mut self,
-            indirect_buffer: &wgc::id::BufferId,
+            indirect_buffer: &super::Buffer,
             indirect_offset: wgt::BufferAddress,
-            count_buffer: &wgc::id::BufferId,
+            count_buffer: &super::Buffer,
             count_buffer_offset: wgt::BufferAddress,
             max_count: u32,
         ) {
             wgpu_render_pass_multi_draw_indirect_count(
                 self,
-                *indirect_buffer,
+                indirect_buffer.id,
                 indirect_offset,
-                *count_buffer,
+                count_buffer.id,
                 count_buffer_offset,
                 max_count,
             )
         }
         fn multi_draw_indexed_indirect_count(
             &mut self,
-            indirect_buffer: &wgc::id::BufferId,
+            indirect_buffer: &super::Buffer,
             indirect_offset: wgt::BufferAddress,
-            count_buffer: &wgc::id::BufferId,
+            count_buffer: &super::Buffer,
             count_buffer_offset: wgt::BufferAddress,
             max_count: u32,
         ) {
             wgpu_render_pass_multi_draw_indexed_indirect_count(
                 self,
-                *indirect_buffer,
+                indirect_buffer.id,
                 indirect_offset,
-                *count_buffer,
+                count_buffer.id,
                 count_buffer_offset,
                 max_count,
             )
@@ -346,20 +346,20 @@ mod pass_impl {
         }
         fn set_index_buffer(
             &mut self,
-            buffer: &wgc::id::BufferId,
+            buffer: &super::Buffer,
             offset: wgt::BufferAddress,
             size: Option<wgt::BufferSize>,
         ) {
-            wgpu_render_bundle_set_index_buffer(self, *buffer, offset, size)
+            wgpu_render_bundle_set_index_buffer(self, buffer.id, offset, size)
         }
         fn set_vertex_buffer(
             &mut self,
             slot: u32,
-            buffer: &wgc::id::BufferId,
+            buffer: &super::Buffer,
             offset: wgt::BufferAddress,
             size: Option<wgt::BufferSize>,
         ) {
-            wgpu_render_bundle_set_vertex_buffer(self, slot, *buffer, offset, size)
+            wgpu_render_bundle_set_vertex_buffer(self, slot, buffer.id, offset, size)
         }
 
         fn set_push_constants(&mut self, stages: wgt::ShaderStage, offset: u32, data: &[u32]) {
@@ -396,21 +396,21 @@ mod pass_impl {
         }
         fn draw_indirect(
             &mut self,
-            indirect_buffer: &wgc::id::BufferId,
+            indirect_buffer: &super::Buffer,
             indirect_offset: wgt::BufferAddress,
         ) {
-            wgpu_render_bundle_draw_indirect(self, *indirect_buffer, indirect_offset)
+            wgpu_render_bundle_draw_indirect(self, indirect_buffer.id, indirect_offset)
         }
         fn draw_indexed_indirect(
             &mut self,
-            indirect_buffer: &wgc::id::BufferId,
+            indirect_buffer: &super::Buffer,
             indirect_offset: wgt::BufferAddress,
         ) {
-            wgpu_render_pass_bundle_indexed_indirect(self, *indirect_buffer, indirect_offset)
+            wgpu_render_pass_bundle_indexed_indirect(self, indirect_buffer.id, indirect_offset)
         }
         fn multi_draw_indirect(
             &mut self,
-            _indirect_buffer: &wgc::id::BufferId,
+            _indirect_buffer: &super::Buffer,
             _indirect_offset: wgt::BufferAddress,
             _count: u32,
         ) {
@@ -418,7 +418,7 @@ mod pass_impl {
         }
         fn multi_draw_indexed_indirect(
             &mut self,
-            _indirect_buffer: &wgc::id::BufferId,
+            _indirect_buffer: &super::Buffer,
             _indirect_offset: wgt::BufferAddress,
             _count: u32,
         ) {
@@ -426,9 +426,9 @@ mod pass_impl {
         }
         fn multi_draw_indirect_count(
             &mut self,
-            _indirect_buffer: &wgc::id::BufferId,
+            _indirect_buffer: &super::Buffer,
             _indirect_offset: wgt::BufferAddress,
-            _count_buffer: &wgc::id::BufferId,
+            _count_buffer: &super::Buffer,
             _count_buffer_offset: wgt::BufferAddress,
             _max_count: u32,
         ) {
@@ -436,9 +436,9 @@ mod pass_impl {
         }
         fn multi_draw_indexed_indirect_count(
             &mut self,
-            _indirect_buffer: &wgc::id::BufferId,
+            _indirect_buffer: &super::Buffer,
             _indirect_offset: wgt::BufferAddress,
-            _count_buffer: &wgc::id::BufferId,
+            _count_buffer: &super::Buffer,
             _count_buffer_offset: wgt::BufferAddress,
             _max_count: u32,
         ) {
@@ -449,14 +449,14 @@ mod pass_impl {
 
 fn map_buffer_copy_view(view: crate::BufferCopyView) -> wgc::command::BufferCopyView {
     wgc::command::BufferCopyView {
-        buffer: view.buffer.id,
+        buffer: view.buffer.id.id,
         layout: view.layout,
     }
 }
 
 fn map_texture_copy_view(view: crate::TextureCopyView) -> wgc::command::TextureCopyView {
     wgc::command::TextureCopyView {
-        texture: view.texture.id,
+        texture: view.texture.id.id,
         mip_level: view.mip_level,
         origin: view.origin,
     }
@@ -506,6 +506,23 @@ pub(crate) struct Device {
     id: wgc::id::DeviceId,
     error_sink: ErrorSink,
 }
+#[derive(Debug)]
+pub(crate) struct Buffer {
+    id: wgc::id::BufferId,
+    error_sink: ErrorSink,
+}
+
+#[derive(Debug)]
+pub(crate) struct Texture {
+    id: wgc::id::TextureId,
+    error_sink: ErrorSink,
+}
+
+#[derive(Debug)]
+pub(crate) struct CommandEncoder {
+    id: wgc::id::CommandEncoderId,
+    error_sink: ErrorSink,
+}
 
 impl crate::Context for Context {
     type AdapterId = wgc::id::AdapterId;
@@ -516,12 +533,12 @@ impl crate::Context for Context {
     type BindGroupId = wgc::id::BindGroupId;
     type TextureViewId = wgc::id::TextureViewId;
     type SamplerId = wgc::id::SamplerId;
-    type BufferId = wgc::id::BufferId;
-    type TextureId = wgc::id::TextureId;
+    type BufferId = Buffer;
+    type TextureId = Texture;
     type PipelineLayoutId = wgc::id::PipelineLayoutId;
     type RenderPipelineId = wgc::id::RenderPipelineId;
     type ComputePipelineId = wgc::id::ComputePipelineId;
-    type CommandEncoderId = wgc::id::CommandEncoderId;
+    type CommandEncoderId = CommandEncoder;
     type ComputePassId = wgc::command::ComputePass;
     type RenderPassId = wgc::command::RenderPass;
     type CommandBufferId = wgc::id::CommandBufferId;
@@ -671,7 +688,7 @@ impl crate::Context for Context {
                         offset,
                         size,
                     } => bm::BindingResource::Buffer(bm::BufferBinding {
-                        buffer_id: buffer.id,
+                        buffer_id: buffer.id.id,
                         offset,
                         size,
                     }),
@@ -854,7 +871,7 @@ impl crate::Context for Context {
         desc: &crate::BufferDescriptor<'_>,
     ) -> Self::BufferId {
         let global = &self.0;
-        wgc::gfx_select!(device.id => global.device_create_buffer(
+        let buffer_id = wgc::gfx_select!(device.id => global.device_create_buffer(
             device.id,
             &wgt::BufferDescriptor {
                 label: desc.label.map(Borrowed),
@@ -867,7 +884,11 @@ impl crate::Context for Context {
         .unwrap_error_sink(
             &device.error_sink,
             || wgc::gfx_select!( device.id => global.buffer_error(PhantomData)),
-        )
+        );
+        Buffer {
+            id: buffer_id,
+            error_sink: device.error_sink.clone(),
+        }
     }
 
     fn device_create_texture(
@@ -876,7 +897,7 @@ impl crate::Context for Context {
         desc: &TextureDescriptor,
     ) -> Self::TextureId {
         let global = &self.0;
-        wgc::gfx_select!(device.id => global.device_create_texture(
+        let texture_id = wgc::gfx_select!(device.id => global.device_create_texture(
             device.id,
             &wgt::TextureDescriptor {
                 label: desc.label.map(Borrowed),
@@ -892,7 +913,11 @@ impl crate::Context for Context {
         .unwrap_error_sink(
             &device.error_sink,
             || wgc::gfx_select!( device.id => global.texture_error(PhantomData)),
-        )
+        );
+        Texture {
+            id: texture_id,
+            error_sink: device.error_sink.clone(),
+        }
     }
 
     fn device_create_sampler(
@@ -929,7 +954,7 @@ impl crate::Context for Context {
         desc: &CommandEncoderDescriptor,
     ) -> Self::CommandEncoderId {
         let global = &self.0;
-        wgc::gfx_select!(device.id => global.device_create_command_encoder(
+        let encoder_id = wgc::gfx_select!(device.id => global.device_create_command_encoder(
             device.id,
             &wgt::CommandEncoderDescriptor {
                 label: desc.label.map(Borrowed),
@@ -939,7 +964,11 @@ impl crate::Context for Context {
         .unwrap_error_sink(
             &device.error_sink,
             || wgc::gfx_select!( device.id => global.command_encoder_error(PhantomData)),
-        )
+        );
+        CommandEncoder {
+            id: encoder_id,
+            error_sink: device.error_sink.clone(),
+        }
     }
 
     fn device_create_render_bundle_encoder(
@@ -1028,8 +1057,8 @@ impl crate::Context for Context {
         };
 
         let global = &self.0;
-        wgc::gfx_select!(*buffer => global.buffer_map_async(*buffer, range, operation))
-            .unwrap_pretty();
+        wgc::gfx_select!(buffer.id => global.buffer_map_async(buffer.id, range, operation))
+            .unwrap_error_sink(&buffer.error_sink, || ());
 
         future
     }
@@ -1041,8 +1070,8 @@ impl crate::Context for Context {
     ) -> &[u8] {
         let size = sub_range.end - sub_range.start;
         let global = &self.0;
-        let ptr = wgc::gfx_select!(*buffer => global.buffer_get_mapped_range(
-            *buffer,
+        let ptr = wgc::gfx_select!(buffer.id => global.buffer_get_mapped_range(
+            buffer.id,
             sub_range.start,
             wgt::BufferSize::new(size)
         ))
@@ -1057,8 +1086,8 @@ impl crate::Context for Context {
     ) -> &mut [u8] {
         let size = sub_range.end - sub_range.start;
         let global = &self.0;
-        let ptr = wgc::gfx_select!(*buffer => global.buffer_get_mapped_range(
-            *buffer,
+        let ptr = wgc::gfx_select!(buffer.id => global.buffer_get_mapped_range(
+            buffer.id,
             sub_range.start,
             wgt::BufferSize::new(size)
         ))
@@ -1068,7 +1097,8 @@ impl crate::Context for Context {
 
     fn buffer_unmap(&self, buffer: &Self::BufferId) {
         let global = &self.0;
-        wgc::gfx_select!(*buffer => global.buffer_unmap(*buffer)).unwrap_pretty()
+        wgc::gfx_select!(buffer.id => global.buffer_unmap(buffer.id))
+            .unwrap_error_sink(&buffer.error_sink, || ());
     }
 
     fn swap_chain_get_current_texture_view(
@@ -1116,14 +1146,17 @@ impl crate::Context for Context {
         };
         let global = &self.0;
         wgc::gfx_select!(
-            *texture => global.texture_create_view(*texture, &descriptor, PhantomData)
+            texture.id => global.texture_create_view(texture.id, &descriptor, PhantomData)
+        )
+        .unwrap_error_sink(
+            &texture.error_sink,
+            || wgc::gfx_select!( texture.id =>global.texture_view_error(PhantomData)),
         )
-        .unwrap_pretty()
     }
 
     fn texture_drop(&self, texture: &Self::TextureId) {
         let global = &self.0;
-        wgc::gfx_select!(*texture => global.texture_drop(*texture))
+        wgc::gfx_select!(texture.id => global.texture_drop(texture.id))
     }
     fn texture_view_drop(&self, texture_view: &Self::TextureViewId) {
         let global = &self.0;
@@ -1135,7 +1168,7 @@ impl crate::Context for Context {
     }
     fn buffer_drop(&self, buffer: &Self::BufferId) {
         let global = &self.0;
-        wgc::gfx_select!(*buffer => global.buffer_drop(*buffer, false))
+        wgc::gfx_select!(buffer.id => global.buffer_drop(buffer.id, false))
     }
     fn bind_group_drop(&self, bind_group: &Self::BindGroupId) {
         let global = &self.0;
@@ -1197,15 +1230,15 @@ impl crate::Context for Context {
         copy_size: wgt::BufferAddress,
     ) {
         let global = &self.0;
-        wgc::gfx_select!(*encoder => global.command_encoder_copy_buffer_to_buffer(
-            *encoder,
-            *source,
+        wgc::gfx_select!(encoder.id => global.command_encoder_copy_buffer_to_buffer(
+            encoder.id,
+            source.id,
             source_offset,
-            *destination,
+            destination.id,
             destination_offset,
             copy_size
         ))
-        .unwrap_pretty()
+        .unwrap_error_sink(&encoder.error_sink, || ());
     }
 
     fn command_encoder_copy_buffer_to_texture(
@@ -1216,13 +1249,13 @@ impl crate::Context for Context {
         copy_size: wgt::Extent3d,
     ) {
         let global = &self.0;
-        wgc::gfx_select!(*encoder => global.command_encoder_copy_buffer_to_texture(
-            *encoder,
+        wgc::gfx_select!(encoder.id => global.command_encoder_copy_buffer_to_texture(
+            encoder.id,
             &map_buffer_copy_view(source),
             &map_texture_copy_view(destination),
             &copy_size
         ))
-        .unwrap_pretty()
+        .unwrap_error_sink(&encoder.error_sink, || ())
     }
 
     fn command_encoder_copy_texture_to_buffer(
@@ -1233,13 +1266,13 @@ impl crate::Context for Context {
         copy_size: wgt::Extent3d,
     ) {
         let global = &self.0;
-        wgc::gfx_select!(*encoder => global.command_encoder_copy_texture_to_buffer(
-            *encoder,
+        wgc::gfx_select!(encoder.id => global.command_encoder_copy_texture_to_buffer(
+            encoder.id,
             &map_texture_copy_view(source),
             &map_buffer_copy_view(destination),
             &copy_size
         ))
-        .unwrap_pretty()
+        .unwrap_error_sink(&encoder.error_sink, || ())
     }
 
     fn command_encoder_copy_texture_to_texture(
@@ -1250,20 +1283,20 @@ impl crate::Context for Context {
         copy_size: wgt::Extent3d,
     ) {
         let global = &self.0;
-        wgc::gfx_select!(*encoder => global.command_encoder_copy_texture_to_texture(
-            *encoder,
+        wgc::gfx_select!(encoder.id => global.command_encoder_copy_texture_to_texture(
+            encoder.id,
             &map_texture_copy_view(source),
             &map_texture_copy_view(destination),
             &copy_size
         ))
-        .unwrap_pretty()
+        .unwrap_error_sink(&encoder.error_sink, || ())
     }
 
     fn command_encoder_begin_compute_pass(
         &self,
         encoder: &Self::CommandEncoderId,
     ) -> Self::ComputePassId {
-        wgc::command::ComputePass::new(*encoder)
+        wgc::command::ComputePass::new(encoder.id)
     }
 
     fn command_encoder_end_compute_pass(
@@ -1273,9 +1306,9 @@ impl crate::Context for Context {
     ) {
         let global = &self.0;
         wgc::gfx_select!(
-            *encoder => global.command_encoder_run_compute_pass(*encoder, pass)
+            encoder.id => global.command_encoder_run_compute_pass(encoder.id, pass)
         )
-        .unwrap_pretty()
+        .unwrap_error_sink(&encoder.error_sink, || ())
     }
 
     fn command_encoder_begin_render_pass<'a>(
@@ -1303,7 +1336,7 @@ impl crate::Context for Context {
         });
 
         wgc::command::RenderPass::new(
-            *encoder,
+            encoder.id,
             wgc::command::RenderPassDescriptor {
                 color_attachments: Borrowed(&colors),
                 depth_stencil_attachment: depth_stencil.as_ref(),
@@ -1317,30 +1350,34 @@ impl crate::Context for Context {
         pass: &mut Self::RenderPassId,
     ) {
         let global = &self.0;
-        wgc::gfx_select!(*encoder => global.command_encoder_run_render_pass(*encoder, pass))
-            .unwrap_pretty()
+        wgc::gfx_select!(encoder.id => global.command_encoder_run_render_pass(encoder.id, pass))
+            .unwrap_error_sink(&encoder.error_sink, || ())
     }
 
     fn command_encoder_finish(&self, encoder: &Self::CommandEncoderId) -> Self::CommandBufferId {
         let desc = wgt::CommandBufferDescriptor::default();
         let global = &self.0;
-        wgc::gfx_select!(*encoder => global.command_encoder_finish(*encoder, &desc)).unwrap_pretty()
+        wgc::gfx_select!(encoder.id => global.command_encoder_finish(encoder.id, &desc))
+            .unwrap_error_sink(
+                &encoder.error_sink,
+                || wgc::gfx_select!( encoder.id => global.command_buffer_error(PhantomData)),
+            )
     }
 
     fn command_encoder_insert_debug_marker(&self, encoder: &Self::CommandEncoderId, label: &str) {
         let global = &self.0;
-        wgc::gfx_select!(*encoder => global.command_encoder_insert_debug_marker(*encoder, &label))
-            .unwrap_pretty()
+        wgc::gfx_select!(encoder.id => global.command_encoder_insert_debug_marker(encoder.id, &label))
+        .unwrap_error_sink(&encoder.error_sink, ||())
     }
     fn command_encoder_push_debug_group(&self, encoder: &Self::CommandEncoderId, label: &str) {
         let global = &self.0;
-        wgc::gfx_select!(*encoder => global.command_encoder_push_debug_group(*encoder, &label))
-            .unwrap_pretty()
+        wgc::gfx_select!(encoder.id => global.command_encoder_push_debug_group(encoder.id, &label))
+            .unwrap_error_sink(&encoder.error_sink, || ())
     }
     fn command_encoder_pop_debug_group(&self, encoder: &Self::CommandEncoderId) {
         let global = &self.0;
-        wgc::gfx_select!(*encoder => global.command_encoder_pop_debug_group(*encoder))
-            .unwrap_pretty()
+        wgc::gfx_select!(encoder.id => global.command_encoder_pop_debug_group(encoder.id))
+            .unwrap_error_sink(&encoder.error_sink, || ())
     }
 
     fn render_bundle_encoder_finish(
@@ -1368,7 +1405,7 @@ impl crate::Context for Context {
     ) {
         let global = &self.0;
         wgc::gfx_select!(
-            *queue => global.queue_write_buffer(*queue, *buffer, offset, data)
+            *queue => global.queue_write_buffer(*queue, buffer.id, offset, data)
         )
         .unwrap_pretty()
     }